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

```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*2;
</script>

</body>
</html>
```

File name: test1.py

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

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

| URL Component           | Name          |
| :---------------------- | :------------ |
| 1. https                | A. Domain Name |
| 2. onlinedegree.com     | B. Query String |
| 3. /academics           | C. Protocol   |
| 4. ?course=appdev1      | D. Fragment   |
| 5. #week2               | 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)
```

```html
<h1> Hello {{user_name}}! </h1>
```

```python
from flask_restful import Api
api = Api(app)
Class Hello(Resource):
    def get(self):
        return {'User':'Abhishek'}
```

Folder: My_app
My_app
  |_ home.html
  |_ first.html
  |_ main.html

File: home.html

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

File: first.html

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

File: main.html

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

What will be rendered by the browser for the URL: http://localhost:8000/first.html 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. |

```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'`?

| Column Name | Datatype | Constraints |
|---|---|---|
| RollNo | Integer | Primary Key |
| Name | String | Not Null |
| Section | Integer | Not Null |
| 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 Section = 'B';
```

Consider the following Python code snippet:

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', 'PDSA']
programming = ['Java', 'MAD-I', 'System-Commands', 'ML-practices']

@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()
```

user1:

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

logstable:

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

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

```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.

If the curl request shown below.

```
curl http://127.0.0.1:5000/api/v1/5001 -X GET
```

retrieves the employee_id only with status 200 OK, what will come in place of GET-FUNCTION in the code?

If the curl request shown below.

```
curl http://127.0.0.1:5000/api/v1 -X POST -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
POST-FUNCTION in the code?

What will be the response from the server for the request:

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