IIT M FOUNDATION FN EXAM QDF1 13 Apr - 13 Apr 2025

In a Flask application, we have a base template (`base.html`) that includes a `{% block content %}` section. A child template (`home.html`) extends this base template and uses `{{ super() }}` inside `{% block content %}`.

What will be the effect of using `{{ super() }}` inside the block in the child template?

Consider the following Python code snippet.

```python
from jinja2 import Template

newlist = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']

this_template = """
{% for item in data %}
    {% if item|length<6 %}
        {{ item }}
    {% endif %}
{% endfor %}
"""

out = Template(this_template)

print(out.render(data=newlist))
```

What will be the output on the terminal?

Consider the following git branches for a remote repository.

```
feature1
* feature2
main
```

Choose the correct git command sequence to merge *feature1* and *feature2* into the *main* branch.

Match the Column-A with the Column-B.

| | Column-A | | Column-B |
|---|---|---|---|
| 1 | GET | a | Defines the view/layout of the web app |
| 2 | SQLAlchemy | b | Defines the model/table of the web app |
| 3 | Template | c | Method of HTTP request |
| 4 | SQLite | d | Object Relational Mapping |

Consider the following example:

```html
<form>
    <label for="search-input">Search for a word:</label>
    <input
        type="text"
        id="search-input"
        placeholder="Type a word to search"
        aria-describedby="search-help"
        required
    />
    <small id="search-help">Enter a word to find relevant results.</small>
    <button type="submit">Start Search</button>
</form>
```

Which of the following accessibility principles is followed in this example?

A Flask application and its absolute path is given below.

C:\home\mad_1>

**app.py**

```python
from flask import Flask, url_for
import sys

def create_path():
    if len(sys.argv) < 2:
        return '/static'
    else:
        return f'/{sys.argv[1]}'

app = Flask(__name__, static_url_path = create_path())

@app.route('/home')
def display():
    return f"<h3>static url path: {app.static_url_path}</h3>\
           <h3>static folder: {app.static_folder}</h3>"

app.run(debug = True)
```

If the application is run locally on http://127.0.0.1:5000 using the command python app.py stable, what will be rendered by the browser for URL http://127.0.0.1:5000/home?

Consider the following HTML code below.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <style>
        body{text-align: center;}
        p{font-size: 30px;color: black;}
        .blue{color: red;}
        .red{color: green !important;}
        .green{color: blue;}
        #myId{color: grey;}
    </style>
</head>
<body>
    <div>
        <p class="blue">Text1</p>
        <p class="red" id="myId">Text2</p>
        <p class="green" id="myId">Text3</p>
        <p class="green">Text4</p>
    </div>
</body>
</html>
```

How will the browser render the above HTML file?
Match the rendered color for the text.

| 1. Text1 | a. green |
|---|---|
| 2. Text2 | b. blue |
| 3. Text3 | c. red |
| 4. Text4 | d. grey |

Let L = { 'a', 'b', 'c', 'd', 'A', 'B', 'C', 'D', '^', '*', '#', '!', '$' } be a complete character set (i.e., only these characters can be used to represent text in the document). If a document that uses fixed encoding with optimal number of bits for all characters is created using the character set L and has a disk size of 3 Kilobytes, the number of characters in the documents would be _____. [Take 1 Byte = 8 bits, 1 KB = 1000 Bytes, 1 MB = 1000 Kilobytes and so on.]

A mobile server and a client initially 1000 km apart are moving towards each other
in a straight line with the speeds of 180 kmph and 70 kmph respectively. The network
bandwidth is set constant to 3 Mbps. Determine how much data (in Gigabytes) is used
by the client before the client and the server collide. [speed of light in vacuum: 3 x 10⁸
m/sec, 1 MB = 1000 KB and so on.]

Consider the following flask app. Given that **test_request_context()** allows text
to be printed on the terminal, which of the following statements is correct?

```python
from flask import Flask, url_for

app = Flask(__name__)

@app.route('/hello')
def hello():
    return 'Hello World!'

@app.route('/user/<username>')
def user(username):
    return f'Welcome {username}!'

with app.test_request_context():
    #== print statement ==#
```

Consider the following Python code snippet.

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

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

class MyApi(Resource):
    def get(self):
        return {"message":"Hello user!"}

    def put(self):
        return {"message":"Hello World!"}

api.add_resource(MyApi, '/api/get', '/api/put', '/api/post')

app.run()
```

If this application is running locally on http://127.0.0.1:5000, which of the following curl commands will throw an error?

1. `curl http://127.0.0.1:5000/api/get -X get`
2. `curl http://127.0.0.1:5000/api/put -X put`
3. `curl http://127.0.0.1:5000/api/post -X post`
4. `curl http://127.0.0.1:5000/api/get -X put`
5. `curl http://127.0.0.1:5000/api/put -X get`
6. `curl http://127.0.0.1:5000/api/post -X get`

Consider the following HTML code.

**File name: login.html**
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Login Page</title>
</head>
<body>
    <form action="/">
        <label for="uname">Username</label><br>
        <input type="text" name="uname" id="uname"><br>
        <label for="pwd">Password</label><br>
        <input type="password" name="pwd" id="pwd"><br>
        <input type="submit" value="Login">
    </form>
</body>
</html>
```

When the user clicks on the "Login" button the form data will be sent to the server using which HTTP method?

Consider the code below in a file called test_students.py.

test_students.py
```python
import pytest

@pytest.fixture
def students():
    return {"names": ["ravi", "raj"], "ages": [12, 9]}

@pytest.mark.check
def test_name(students):
    assert "ravi" in students['names']

@pytest.mark.check
def test_age(students):
    assert students['ages'][0] > 9

def test_check(students):
    assert "raj" not in students['names']
```

What will be the output on the terminal on running the command "pytest -m check"? (assume that the tests ran in 0.03s and that the markers have been registered)

Consider the following Python code.

File name: main.py

```python
def funA(func):
    def inner_wrapper():
        print("Wrapper function of funA")
        res1 = func()
        res2 = func()
        return res1, res2

    return inner_wrapper

@funA
def funB():
    return "I am from funB"

print(funB())
```

What will be the output, when running the above code using the command "python main.py"?

Consider the following Python code

File name: main_test.py

```python
import pytest

class TestGroup:

    def do_something(self, x, y):
        return x % y

    def test_one(self):
        assert self.do_something(10, 5) == 0, " Is 5 factor of 10? "

    def test_two(self):
        assert self.do_something(32, 5) == 0, " Is 5 factor of 32 "
```

What will be the output of running the above python script using command line
“pytest -v main_test.py”?

Consider the following Jinja2 templating code:

```python
from jinja2 import Template

template_str = """
{% set gifts = [
    {'name': 'Teddy Bear', 'price': 250, 'rating': 4.2},
    {'name': 'Coffee Mug', 'price': 150, 'rating': 4.5},
    {'name': 'Keychain', 'price': 100, 'rating': 3.9},
    {'name': 'Notebook', 'price': 180, 'rating': 4.7},
    {'name': 'Wall Clock', 'price': 300, 'rating': 4.0}
] %}

<ul>
{% for gift in gifts if gift.price < 200 and gift.rating > 4 %}
    <li>{{ gift.name }} - {{ gift.price }} - {{ gift.rating }}</li>
{% endfor %}
</ul>
"""

template = Template(template_str)
rendered_str = template.render()
print(rendered_str)
```

Will the above Jinja templating code return the correct output? If yes, what will be the result?

You are given a project with three files: `conftest.py`, `test_multiples_of_3_and_6.py`, and `test_multiples_of_13.py`. The purpose of the tests is to verify if numbers generated by each function are divisible by 39. However, there is a setup issue in this project.

* `conftest.py` contains a fixture that provides test data.
* `test_multiples_of_3_and_6.py` has two functions: one checks divisibility by 3, and the other by 6.
* `test_multiples_of_13.py` contains a function to check divisibility by 13.

Here is the content of each file:

`conftest.py`
```python
import pytest

@pytest.fixture
def divisible_by_39():
    return 39 # Fixture providing the number to be tested
```

`test_multiples_of_3_and_6.py`
```python
import pytest

def test_divisible_by_3(divisible_by_39):
    assert divisible_by_39 % 3 == 0 # Checks if divisible by 3

def test_divisible_by_6(divisible_by_39):
    assert divisible_by_39 % 6 == 0 # Checks if divisible by 6
```

`test_multiples_of_13.py`
```python
import pytest

def test_divisible_by_13(divisible_by_39):
    assert divisible_by_39 % 13 == 0 # Checks if divisible by 13
```

When you run `pytest -k divisible`, which of the following is **true**?

A client machine and a server machine located 120 kilometers apart start moving towards each other along a straight line at 400 kmph and 800 kmph respectively. At the same time, the client starts sending requests to the server and the server sends back the response to the client. This client-server network continues to send requests and receive responses (with a new request being sent only after the response is received by the client for the previous one) until both the server and the client collide with each other. Calculate the total distance travelled (in kms) by the request data and the response data together before the two machines collide with each other?(assume the speed of request and response to be 3 x 10⁸ m/s )

Consider the following flask code.

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

@app.route('/admin')
def hello_admin():
    return 'Hello Admin'

@app.route('/guest/<guest>')
def hello_guest(guest):
    return f'Hello {guest}'

@app.route('/user/<name>')
def hello_user(name):
    if name == 'admin':
        return redirect(url_for('hello_admin'))
    else:
        return redirect(url_for('hello_guest', guest=name))

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

Match the commands in Column A with their correct rendered output in Column B

| Column A | Column B |
|---|---|
| 1. http://127.0.0.1:5000/user/admin | a. Hello mad1 |
| 2. http://127.0.0.1:5000/admin | b. Hello Admin |
| 3. http://127.0.0.1:5000/guest/mad1 | c. /admin |
| 4. http://127.0.0.1:5000/user/mad1 | d. /guest/mad1 |

Consider a flask app "app.py" and a template file "doc.html" given below:

Python file: app.py

```python
from flask import Flask, render_template

app = Flask(__name__)

itemlist = [
    {'value': '0', 'content': 'zero'},
    {'value': '1', 'content': 'one'},
    {'value': '2', 'content': 'two'},
    {'value': '3', 'content': 'three'},
]

@app.route('/')
def func():
    return render_template('doc.html', itemlist = itemlist)

app.run()
```

Template file: doc.html

```html
<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"></head>
<body>
    {% macro render_field(value='field value', content='content value') %}
        <option value="{{value}}">{{content}}</option>
    {% endmacro %}

    {% for item in itemlist %}
        {{ render_field(item.content) }}
    {% endfor %}
</body>
</html>
```

If the application is running locally on http://127.0.0.1:5000. What will be the raw HTML body of the file rendered by the flask app for base url?

Consider the following route in the flask for a signup page and select the correct option:

```python
@app.route('/signup', methods=['GET', 'POST'])
def signup():
    if request.method == 'GET':
        return """<form action='/signup' method='POST'>
            <label for='username'>Username</label>
            <input type='text' name='username' required>
            <label for='password'>Password</label>
            <input type='text' name='password' required minlength="8">
            <input type='submit' value='Submit'>
        </form>
        """
    if request.method == 'POST':
        if request.form.get('username') is None:
            return redirect(url_for(signup))
        if request.form.get('password') is None:
            return redirect(url_for(signup))
        if len(request.form.get('password')) < 8:
            return redirect(url_for(signup))
        return f"<h1>Welcome, {request.form.get('username')}!</h1>"
```

Consider the following HTML code.

File name: home.html

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Home page</title>
    <script>
        //Missing JS code
    </script>
</head>
<body>
    <form>
        Your name : <input type="text" id="txt1" value="Welcome to IITM Online BS Degree" size="35">
        <br>
        <input type="button" onclick="doSomething()" value="Click me!">
    </form>
</body>
</html>
```

If the user clicks on the “Click me!” button, then which of the following JS codes should be added in the `<script>` tag that will bold the content of `<input>` tag as given in the image below?

Your name : **Welcome to IITM Online BS Degree**
Click me!

The following Flask-RESTful API code snippet is intended to create a RESTful API for managing student registrations in an IITM BS degree program. However, there is an error in the code that prevents it from functioning correctly.

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

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

students = []

class Student(Resource):
    def get(self, student_id):
        for student in students:
            if student["id"] == student_id:
                return jsonify(student)
        return jsonify({"message": "Student not found"}), 404

    def post(self):
        data = request.get_json()
        new_student = {
            "id": data["id"],
            "name": data["name"]
        }
        students.append(new_student)
        return jsonify({"message": "Student added successfully"})

api.add_resource(Student, "/student/<int:student_id>")

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

**Error:**
When trying to use the **POST** method to add a student, it throws a **TypeError** stating that the route does not match the method. Identify the correct option to fix the error in the code.

Consider the following Flask app code.

```python
from flask import Flask, request
valid_users = [
    {"uid": "student", "pwd": "12345"},
    {"uid": "professor", "pwd": "54321"},
    {"uid": "hod", "pwd": "abcde"},
]

app = Flask(__name__)

@app.route("/signin")
def login():
    args = request.args
    for vu in valid_users:
        if vu["uid"] == args["uid"] and vu["pwd"] == args["pwd"]:
            return "You are authorized!!"
    else:
        return "You are unauthorized!!"

app.run(debug=True)
```

Assume the above flask app runs on "http://127.0.0.1:5000/" and is accessed through the web browser. Select the URL(s) that render **Not Found** error.

What will be the output when the
following URL is accessed?

http://127.0.0.1:5000/score/students

What will happen if we access the
following URL?

http://127.0.0.1:5000/score/instructors/Dr.Prashant