IIT M DIPLOMA FN1 EXAM ETD1 11 Dec 2022 - 11 Dec 2022

| URL Component | Name          |
| :------------ | :------------ |
| 1. http       | A. Domain Name |
| 2. appdev1.com | B. Query String |
| 3. /sep-22    | C. Protocol   |
| 4. ?week=2    | D. Fragment   |
| 5. #MVC       | E. Path       |

```python
class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key = True)
    name = db.Column(db.String(30))
    def __init__(self, id, name):
        self.id = id
        self.name = name
@login_manager.user_loader
def firstuser(id):
    return User.query.get(int(id))
@app.route('/')


def index():
    u1 = User.query.filter_by(id = 112).first()
    login_user(u1)
    return current_user.name + ' logged in'
@app.route('/logout')
@login_required
def logout():
    logout_user()
    return 'logged out'
@app.route('/home')
@login_required
def home():
    return "current user is " + current_user.name

def init_db():
    db.create_all()
    new_user = User(112, 'Rose')
    new_user2 = User(113, 'lily')
    db.session.add(new_user)
    db.session.add(new_user2)
    db.session.commit()
if __name__ == '__main__':
    init_db()
    app.run(debug = True)
```
If the above program is running in the URL “http://127.0.0.1:8000” then what will be the output for the given URLs in sequence.

* http://127.0.0.1:8000
* http://127.0.0.1:8000/home
* http://127.0.0.1:8000/logout

```html
<h1> Hello {{user_name}}! </h1>
```
Which of the following code snippets will utilize the template to display **Hello Ram** when **http://localhost:5000/user/Ram** is visited on the browser?

```python
from flask_restful import Api
api = Api(app)
class Hello(Resource):
    def post(self):
        return {'User':'Abhishek'}
api.add_resource(Hello, '/hello')
```

Folder: My_app

My_app
|__home.html
|__index.html
|__main.html

File: home.html

```html
<h1>Hello from Home!</h1>
```

File: index.html

```html
<h1>Hello from Index!</h1>
```

File: main.html

```html
<h1>Hello from Main!</h1>
```

What will be rendered by the browser for the URL: http://localhost:8000 assuming that 8000 is the port of connection?

| | |
|---|---|
| A. API | 1. Servers do not assume anything about the client's state; they only serve responses. |
| B. MVC | 2. An action is assigned to each uniform resource locator. |
| C. Routing | 3. A standard way defined between two applications for them to communicate. |
| D. Stateless | 4. A design pattern that emphasizes the separation of concerns. |

```html
<!DOCTYPE html>
<html>
<body>

<h2>Creating a JSON String</h2>

<p id="demo"></p>

<script>
  const txt = '{"name":"Balu", "age":30, "city":"New Delhi"}'
  const obj = JSON.parse(txt);
  document.getElementById("demo").innerHTML = "Hi\n" + obj.name + ",\t" + obj.city + "," + obj.age*3;
</script>

</body>
</html>
```

```python
def dec(x):
    return x-1

def test_answer():
    assert dec(3) == 3
```

```html
<a href = {{ url_for('user')}}>Click here</a>
```

| Column Name | Datatype | Constraints |
|---|---|---|
| RollNo | Integer | Primary Key |
| Name | String | Not Null |
| AadhaarNo | Integer | Not Null, UNIQUE |
| Department | String | Not Null |

In most cases, the query executed in the student table looks like the one below.

```sql
SELECT RollNo, Name, AadhaarNo FROM student WHERE Department = 'Biology';
```

For the above student table, which of the following columns would be the most appropriate for the indexing?

```python
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(100), unique=True, index=True)
    name = db.Column(db.String(100))
    password = db.Column(db.String(100))
```
Which of the following methods from the Flask-sqlalchemy package will behave the same as SQL query `select * from User where name='Ram'`?

Filename: module_0.py

```python
import sys

arguments = sys.argv

courses = {'MAD-1': '1002', 'MAD 2': '2003', 'BDM': '205', 'SysCom': '304'}

def operate():
    arg_1 = arguments[1]
    arg_2 = courses[arg_1]
    return f"The function output is: {len(arg_1 + arg_2)}"

print(operate())
```

The above file will yield the output as "The function output is: 9", for which of the following command line inputs?

Consider two software packages A and B spend exactly $T_A(N) = 2N^2 + 9$ and $T_B(N) = N^3$ milliseconds to process N data items. Analyze the software packages and select the correct statement(s).

```python
from flask import Flask, abort, redirect, url_for, render_template
app = Flask(__name__)

data_science = ['ML-techniques', 'ML-foundations', 'ML-practices']
programming = ['Java', 'MAD-I', 'System-Commands', 'PDSA']

@app.route('/courses/<course>')
def find_course(course):
    if course in data_science:
        return f"<h2>Data Science course found, {course}!</h2>"
    elif course in programming:
        return f"<h2>Programming course found, {course}!</h2>"
    else:
        abort(401)

@app.errorhandler(401)
def page_not_found(error):
    return "<h2>No course found!</h2>"

app.run()
```
If the above application is running locally on URL: http://127.0.0.1:5000, select the correct statement(s).

user1:

| userid | name  | password |
| :----- | :---- | :------- |
| U1     | Mack  | UabZa    |
| U2     | Jack  | ZeFad    |
| U3     | Shaun | UsTZb    |

logstable:

| logid | userid | name      |
| :---- | :----- | :-------- |
| 1     | U1     | Playing   |
| 2     | U2     | Studying  |
| 3     | U3     | Swimming  |
| 4     | U1     | Running   |
| 5     | U3     | Studying  |
| 6     | U2     | Dancing   |

Which of the following query/queries will return the log ID and log name, which are created by user 'Shaun'?

```python
data = {'a': 'programming', 'b': 'mathematics', 'c': 'statistics',
'd': 'machine learning'}
```

```python
data = {'b': 'mathematics', 'c': 'statistics', 'd': 'programming'}
```

If an object "p1" that represents an
existing record in the table "producer"
is defined as
```
p1 = Producer.query.get(2),
```
The correct way to create a new record in
the "movies" table that is produced by the
producer represented by object 'p1' using
terminal is.

```
curl http://127.0.0.1:5000/api/v1 -X GET -d "{\"employee_id\": \"2003\", \"employee_name\": \"Suresh\"}" -H "Content-Type: application/json"
```
retrieves the employee_id only with status 200 OK, what will come in place of GET-FUNCTION in the code?

```
curl http://127.0.0.1:5000/api/v1/5001 -X POST
retrieves the employee_id only with status 200 OK, what will come in place of
POST-FUNCTION in the code?
```

```
curl http://127.0.0.1:5000/api/v1 -X PUT -d "{\"employee_id\": \"2003\", \"employee_name\": \"Suresh\"}" -H "Content-Type: application/json"
```