IIT M FOUNDATION DIPLOMA ENDTERM QPD2 07 Aug 2022 IBA NS - 07 Aug 2022

THIS IS QUESTION PAPER FOR THE SUBJECT "DIPLOMA LEVEL: MODERN APPLICATION DEVELOPMENT 1"

ARE YOU SURE YOU HAVE TO WRITE EXAM FOR THIS SUBJECT?
CROSS CHECK YOUR HALL TICKET TO CONFIRM THE SUBJECTS TO BE WRITTEN.

(IF IT IS NOT THE CORRECT SUBJECT, PLS CHECK THE SECTION AT THE TOP FOR THE SUBJECTS REGISTERED BY YOU)

```
https://www.mywebsite.com/home?user=Mad1&key=madcs2003
```

Python file: app.py

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

my_list = ['Web development', 'onlinedegree', 'cs2003',
           'MAD-I', 'Data_science']

@app.route('/')
def render():
    return render_template('index.html', my_list = my_list)

app.run(debug = True)
```
Template file:

```html
<!DOCTYPE html>
<head>
    <style>
        body{width: 200px;
            border: 2px solid black}
        #one{color:red;}
        #two{color:blue;}
    </style>
</head>
<body>
    {% for item in my_list %}
        {% set Length = item|length %}
        {% if Length%2 == 0 %}
            <h3 id = "one">{{ item }}</h3>
        {% else %}
            <h3 id = "two">{{ item }}</h3>
        {% endif %}
    {% endfor %}
</body>
```

If the above flask app is running locally on http://127.0.0.1:5000/, what will be rendered by the browser for the base URL?

Python file: app.py
```python
from flask import Flask, jsonify, request

app = Flask(__name__)

my_shops= [
    {
        'name of the shop' : 'Grocery',
        'items' : [
            {
                'item1' : 'Toothpaste',
                'item2' : 'Snacks',
                'item3' : 'Biscuits',
                'item4' : 'Soaps'
            }
        ]
    }
]

@app.route('/')
def show_shop():
    return jsonify({"shops" : my_shops})

#===========================
#        CODE HERE
#===========================

if __name__ == '__main__':
    app.run()
```

| id | firstname | lastname | email | age | occupation |
|---|---|---|---|---|---|
| 1 | Rahul | Mishra | rahul@gmail.com | 23 | Engineer |
| 2 | Ishan | Vadhera | vadhera@gmail.com | 35 | Lawyer |
| 3 | Abhilasha | Verma | vermaa@gmail.com | 25 | Teacher |

Assuming that flask_sqlalchemy is to be used in the 'main.py' file, which of the following statements is/are true?

Python file: app.py
```python
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/home')
def HomePage():
    return "Welcome, folks! This is the Home Page!"

@app.route('/about')
def AboutPage():
    users = [
        {"user":"Shobhit","gender" : "Male", "age" : 23, "score": 90},
        {"user":"Deepak", "gender" : "Male", "age" : 17, "score": 88},
        {"user":"Nikita", "gender" : "Female", "age" : 20, "score": 87}
    ]
    return render_template('home.html', condition=True, users=users)

if __name__ == "__main__":
    app.run(debug=True)
```

Templates file: home.html
```html
<!DOCTYPE html>
<html>
<body>
<p><a href="{{ url_for('HomePage') }}">Go back to home page?</a></p>
<h2>About page</h2>
{% if condition %}
    <h3>You are landed on about page.</h3>
    {% for user in users %}
    <ul>
        <li>Username : {{user.user}}, Age : {{user.age}}, Gender : {{user.gender}}, Score : {{user.score}}</li>
    </ul>
    {% endfor %}
{% else %}
    <h3> Please Go back.</h3>
{% endif %}
</body>
</html>
```

```html
<!DOCTYPE html>
<html>
<body>
    <h1 id="id1">Welcome to IITM</h1>
    <h3 class="class1">Welcome to the world's first online degree program.</h3>
    <a href="">Go back to main link</a>
    <p class="class1">Lorem ipsum dolor sit amet consectetur adipisicing elit. Earum, rerum?</p>
    <p class="class1">Have you enrolled in BSc in Data science and Programming?</p>
    <p id="id2">Go to the IITM online degree website and enroll now!</p>
</body>
</html>
```

```html
<!DOCTYPE html>
<html>
<head>
    <style type="text/css">
        *{
            margin: 0px;
            width: 253px;
        }
        div{
            margin: 10px;
            padding: 20px;
            border-style: dotted;
            border-width: 10px;
            font-size: 30px;
            color: blue;
            background-color: pink;
            border-color: red;
        }
    </style>
    <title>End Sem</title>
</head>
<body>
    <div>This is my content</div>
    <div>Another content</div>
</body>
</html>
```

Consider the following table "workers" created in SQLite database corresponding to model class "Workers" using flask_sqlalchemy.

| Id | Name | Designation | Gender | Salary |
|---|---|---|---|---|
| Filter | Filter | Filter | Filter | Filter |
| 1 | Padma Raja | Supervisor | Female | 2000 |
| 2 | Sameer Gandhi | Labour | Male | 1200 |
| 3 | Latika Murthy | Labour | Female | 800 |
| 4 | Nitya Grover | Supervisor | Female | 2000 |
| 5 | Amit Saxena | Supervisor | Male | 2000 |

The correct way to increase the salary of all the female workers by 500 Rupees using the Python console is:

```python
from jinja2 import Template

styles=[
    '.text{color: purple}\n #heading{color:red}\n #subhead{color:blue}',
    '.text{color: purple}\n #subhead{color:green}\n #main{color:blue}',
    '.text{color: purple}\n #main{color:red}\n #heading{color:blue}'
]

template = """
<!DOCTYPE html>
<style>
    div{border: 2px solid black;
        width: 300px;
        background-color: rgb(247, 247, 230)}
    {{styles[0]}}
</style>
<body>
    <div>
        <h2 style="color:brown;" class="text" id="heading">
Programming Degree</h2>
        <h3 class="text" id="subhead">Modern Application 1</h3>
        <p class="text" id="main">This is a course on Application
Development</p>
    </div>
</body>
"""

test_render = Template(template)
output = test_render.render(styles = styles)
print(output)
```

What will be the output of the following python code if method
test_request_context() allows flask app to print statements on the terminal?

```python
from flask import Flask, url_for

app = Flask(__name__)

@app.route('/')
def home():
    return 'base url'

@app.route('/subscribe')
def subscribe():
    return 'Please subscribe to this page.'

@app.route('/new_course/<coursename>')
def course(coursename):
    return f'The course {coursename} gives basics of web development.'

with app.test_request_context():
    print(url_for('home'))
    print(url_for('subscribe'))
    print(url_for('subscribe', username = 'user_one'))
    print(url_for('course', coursename = 'MAD_I'))
```

Python file: test_app.py
```python
import pytest

@pytest.fixture
def items():
    return "Books"

@pytest.fixture
def order():
    return "Pens"

@pytest.fixture
def order_items(order, items):
    return [order, items]

@pytest.fixture
def expected_list():
    return ["Books", "Pencils", "Pens"]

def test_1(order_items, expected_list):
    order_items.append("Pencils")
    assert order_items == expected_list

def test_2(order_items):
    order_items.append("Pencils")
    assert order_items == ["Pens", "Books", "Pencils"]
```

Python file: app.py

```python
from flask import Flask, request
from flask_restful import Api, Resource, reqparse

app = Flask(__name__)
api = Api(app)

class Add(Resource):
    def post(self):
        data_args = reqparse.RequestParser()
        data_args.add_argument('Name', help='Name is required',
                               required=True)
        data_args.add_argument('Age', help='Age is required',
                               required=True)
        args = data_args.parse_args()
        return { "Your Name": args['Name'], "Your Age" : args['Age']}

api.add_resource(Add, '/add')

if __name__ == '__main__':
    app.run(debug=True)
```

If this flask application is running on http://127.0.0.1:5000, which of the following is the correct output when a POST request is sent to URL "http://127.0.0.1:5000/add"?

```python
import pytest

@pytest.fixture
def first_entry():
    return "Apple"

@pytest.fixture
def order(first_entry):
    return [first_entry]

def test_string(order):
    order.append("Kiwi")
    assert order == ["Banana", "Apple"]

def test_int(order):
    order.append("Banana")
    assert order == ["Banana", "Apple", "Kiwi"]
```

```python
from flask import Flask, abort
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

item_list=[{"item1": "Cloths"},
           {"item2": "Shoes"},
           {"item3": "Sunglasses"}]

class ItemList(Resource):
    def get(self, item_no, item_name):
        this_item = {'item'+item_no : item_name}
        if this_item in item_list:
            return item_list, 200
        else:
            abort('400')

    def post(self, item_no, item_name):
        my_item = {'item'+item_no : item_name}
        item_list.append(my_item)
        return my_item, 201

api.add_resource(ItemList, '/items/<item_no>/<item_name>')
app.run(debug=True)
```
If the above flask application is running locally on "http://127.0.0.1:5000", what will be the output of a GET request sent to the URL: 'http://127.0.0.1:5000/items/4/watch' just after a POST request that is sent on the same URL?

```python
from flask import Flask, render_template

app=Flask(__name__)

@app.route('/')
def home():
    my_items = ['Cake', 'Apple', 'Ice Cream', 'DarkChocolate',
                'Donut', 'Grape']
    l1 = []
    for i in range(len(my_items)):
        if i>2:
            l1.append(my_items[i])

    return render_template('index.html', list=l1)

app.run(debug=True)
```
Template File - index.html
```html
{% macro display(list) %}
    {% for item in list %}
        <p>{{ item }}</p>
    {% endfor %}
{% endmacro %}
<html>
<body>
    {{ display(list) }}
</body>
</html>
```

File 1: main.py
```python
import sys
from new import fun
a = sys.argv[1]
b = sys.argv[2]
c = sys.argv[3]
result = fun(a, b, c)
print(result + " is greater")
```

File 2: new.py
```python
def fun(num1,num2,num3):
    if (num1 > num2) and (num1 > num3):
        return num1
    elif (num2 > num1) and (num2 > num3):
        return num2
    else:
        return num3
```
suppose the main.py file is executed in the terminal. What will be the output?
python main.py
python main.py 8 10 5

```python
from flask import Flask, abort, redirect, url_for, render_template

app = Flask(__name__)

weekday_users = ['user_1', 'user_3', 'user_4', 'user_6', 'user_7']
weekend_users = ['user_2', 'user_5']

@app.route('/weekday/<username>')
def user_weekday(username):
    if username in weekday_users:
        return redirect(url_for('login', username = username))
    else:
        abort(401)

@app.route('/weekend/<username>')
def user_weekend(username):
    if username in weekend_users:
        return redirect(url_for('login', username = username))
    else:
        abort(401)

@app.route('/login/<username>')
def login(username):
    return f"<h2>Correct User Found! {username}</h2>"

@app.errorhandler(401)
def page_not_found(error):
    return "<h2>You are not authorized for this day.</h2>", 401

app.run()
```

If the above flask app is running locally on "http://127.0.0.1:5000", Which of the following statements is/are correct?

```python
from flask import Flask, request
from flask_restful import Api, Resource, reqparse

app = Flask(__name__)

api = Api(app)

Mytasks = {
    1: {"mytask": "Studying"},
    2: {"mytask": "Exercise"},
    3: {"mytask": "Eating"},
    4: {"mytask": "Sleeping"}
}

class Display(Resource):
    def get(self):
        return Mytasks

class DisplayAll(Resource):
    def get(self, MytaskList_id):
        return Mytasks[MytaskList_id]

    def post(self, MytaskList_id):
        data_args = reqparse.RequestParser()
        data_args.add_argument("mytask",help='This is required field', required =True)
        args = data_args.parse_args()
        Mytasks[MytaskList_id] = {"mytask" : args["mytask"]}
        return Mytasks[MytaskList_id]
api.add_resource(Display, '/mytask')
api.add_resource(DisplayAll, '/task/<int:MytaskList_id>')

if __name__ == '__main__':
    app.run(debug=True)
```
If the above flask application is running locally on "http://127.0.0.1:5000", which of the following statements is/are true?

This is a 2D line graph with a light grey background.

The y-axis is labeled "Throughput -->" and "MBytes/sec". It has tick marks and labels at 0, 25, 50, 75, 100, 125, and 150.
The x-axis is labeled "Speed -->" and "RPM". It has tick marks and labels at 0, 3600, and 7200.

A solid black line starts at (0,0) and goes up to (3600, 100).
From (3600, 100), the line continues as a solid black line up to (7200, 150).
Beyond (7200, 150), the line continues as a dashed black line, indicating it extends further.

Dashed black lines are drawn from the point (3600, 100) to the x-axis at 3600 and to the y-axis at 100.
Dashed black lines are drawn from the point (7200, 150) to the x-axis at 7200 and to the y-axis at 150.

Flask app: app.py

```python
from flask import Flask, render_template, request
app = Flask(__name__)
users = {
    '3':{'name': 'Ram', 'Designation': 'Teacher'},
    '2':{'name': 'Dilip', 'Designation': 'student'},
    '5':{'name': 'Sonu', 'Designation': 'computer operator'},
    '1':{'name': 'Guru', 'Designation': 'clerk'}
}

@app.route('/')
def country():
    id = request.args.get('id')
    authenticated_users_id = [3, 2, 5]
    user = users.get(id)
    name = user.get('name') if user is not None else None
    Designation = user.get('Designation') if user is not None else None

    user = {'is_authenticated': False, 'name': name, 'Designation': Designation}
    if int(id) in authenticated_users_id:
        user['is_authenticated'] = True
        return render_template('index.html', data = user)
    if int(id) not in authenticated_users_id:
        user['is_authenticated'] = False
        return render_template('index.html', data = user)

app.run(debug = True)
```

HTML File: index.html
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
    {% if data.name == None %}
        User not found
    {% elif data.is_authenticated == True %}
        Hello {{data.name}} you can enter into this site:
        {{data.Designation}}
    {% else %}
        Hello {{data.name}} you have no access to this site:
        {{data.Designation}}
    {% endif %}
</body>
</html>
```

```python
from jinja2 import Template

temp = """{% set numbers = studs | map(attribute = "mark") | list %}
{{numbers | min}}{{numbers | max}}"""

studs = [
{"stud_name":"Reeta","mark":"92"},
{"stud_name":"Veena","mark":"88"},
{"stud_name":"Meena","mark":"62"},
{"stud_name":"uma","mark":"98"}
]

t1 = """{% for i in studs -%}
{{i}}
{%- endfor%}"""

output = Template(temp)
out = Template(t1)

print(output.render(studs = studs))
print(out.render(studs = studs))
```

Here is the transcription of the image:

| ID | Name | Age | Mark | course |
|---|---|---|---|---|
| Filter | Filter | Filter | Filter | Filter |
| 1 | Vishnu | 20 | 98 | M1 |
| 2 | Kumar | 18 | 90 | M2 |
| 3 | Leela | 20 | 90 | M1 |
| 4 | Naren | 18 | 98 | M2 |
| 5 | Vishal | 19 | 95 | M1 |
| 6 | Pranav | 20 | 95 | M2 |
| 7 | Vinu | 19 | 90 | M1 |
| 8 | Viki | 18 | 95 | M2 |

What will be the output of the following SQL queries given below?

```sql
CREATE UNIQUE INDEX IF NOT EXISTS index_name
ON newtable (Name ASC, Mark ASC) WHERE Age>18;
SELECT ID, Name, Age, Mark, course FROM newtable WHERE Age>18;
```

```python
@app.route("/search", methods = ["GET"])
def search():
    q = request.args.get('q')
    query = "%"+q+"%"
    results = Details.query.filter(Details.Content.like(query)).all()
    Return render_template("result.html", q=q, Details = results)
```
File : result.html
```html
{% for item in results %}
    {{item["Title"]}}
{% endfor %}
```
SQLite table: details

| ID | Title         | Content                                     |
|----|---------------|---------------------------------------------|
| 1  | Introduction  | Java is a powerful general-purpose ...      |
| 2  | learn python  | Python is a powerful general-purpose ...    |
| 3  | Basics        | Java works on different platforms (Windo    |
| 4  | Code          | Python is currently the most widely used    |

If the flask application is running locally on URL: http://127.0.0.1:5000, what will be rendered by the web browser for URL http://127.0.0.1:5000/search?q=Java?

HTML file: index.html

```html
<!DOCTYPE html>
<html lang="en">
<head>
</head>
<body>
<h1>
    <h1>CSS Selectors</h1>
</h1>
<div>
    <h2 id="header-id1" class="header-class">Hi, Folks!</h2>
    <p id="paragraph-id1" class="paragraph-class">Welcome to IITM.</p>
    <a href="https://iitm.ac.in">
        IIT Bsc Degree Website</a>
    <p class="class1 class2">We are launching World's first online
        degree course.</p>
</div>
<div>
    <h2 id="header-id2">Have you enrolled to the program?</h2>
    <p id="paragraph-id2">If not, enroll now!</p>
    <a href="https://mywebsite.com
        ">Link to Enroll</a>
    <p class="class2 class3">Happy Learning!</p>
</div>
</body>
</html>
```

CSS Selectors

Hi, Folks!

Welcome to IITM.

IIT Bsc Degree Website

We are launching World's first online degree course.

Have you enrolled to the program?

If not, enroll now!

Link to Enroll

Happy Learning!

If an object "s1" that represents an
existing record in the table "state" is
defined as
```python
s1 = State.query.get(1),
```
The correct way(s) to add a city with
the name "Chennai" that belongs to
s1 using the Python console is.

```python
s1 = State.query.filter_by(state_name = "Maharashtra").first()

and

c1 = City.query.filter_by(city_name = "Mumbai").first()
```

If the flask application is running locally on URL "http://127.0.0.1:5000/myinfo",
what will be the output of the following curl request?

```
curl "http://127.0.0.1:5000/myinfo" -X POST -d "{\"first_name\":
\"Shrivatsa\",\"last_name\":\"Tandon\",\"role\":\"Analyst\",\"salary
\": 50000}" -H "Content-Type: application/json"
```

If the flask application is running locally on URL "http://127.0.0.1:5000/myinfo",
what will be the output of the following Python code snippet?

```python
import requests

data = {"first_name":"Rajnish",
        "last_name":"Dey",
        "role":"Manager",
        "salary":"10 thousand"}

response = requests.put('http://127.0.0.1:5000/myinfo', data = data)
print(response.json())
```