IIT M FOUNDATION DIPLOMA FN EXAM - 22 Dec 2024

Consider the following models Library and Book corresponding to tables library and book in SQLite database.

```python
class Library(db.Model):
    id = db.Column(db.Integer(), primary_key = True)
    name = db.Column(db.String(), unique = True)

class Book(db.Model):
    id = db.Column(db.Integer(), primary_key = True)
    name = db.Column(db.String(), unique = True)
    library = db.Column(db.Integer(), unique = True, db.ForeignKey("section.id"))
```

Based on the model schemas, what relationship do the classes Library and Book share?

Consider the following python code snippet "app.py", the HTML files, "base.html" and "home.html" residing in "templates" folder.

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

@app.route('/')
def home():
    return render_template('home.html')

app.run(debug=True)
```

home.html
```html
{% extends "base.html" %}
{% block content %}
<h3>This is from home.html</h3>
{% endblock %}
```

base.html
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
</head>
<body>
    <h3 style="color: blue;"> This is from base.html </h3>
    {% block content %}
    {% endblock %}
</body>
</html>
```

What will be the rendered output for base URL if flask app is running locally on
http://localhost:5000

Consider the following Python code snippet.

```python
from string import Template

sentence = Template("A $var1 fox $var2 over the $var3 dog")

output = sentence.safe_substitute(word_dict)

print(output)
```

Which of the following options correctly represent(s) the dictionary `word_dict`, such that the code does not throw any error when run in the terminal?

| Column A | Column B |
|---|---|
| 1. Desktop | A. Data center storage |
| 2. Mobile | B. Keyboard |
| 3. Web-based | C. Single function |
| 4. Embedded | D. tilt |

Consider the following view function.

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

@app.route('/employee', methods=['GET', 'POST'])
def show_info():
    info = request.args
    details = {
        'Department': info['dept'],
        'ID': info['id'],
        'Role': info['role']
    }
    return details

app.run()
```

If this flask app is running locally on http://127.0.0.1:5000, which of the following URLs will be handled by the controller correctly?

A certain internet connection is established such that its bandwidth reduces to half of its current value every hour. A user connects to this connection at 01:00 pm with the network speed of 4 Mbps, how much data (in GBs) will be consumed by the user by 04:00 p.m in the evening? [round off upto 2 decimal places](Assume that the user is using the entire bandwidth)

Consider the following function to be tested and test functions given in the Python code snippet below.

file.py

```python
def sample_function(x):
    var = []
    for i in range(x):
        var.append((i)**3)
    return var

def test_func1():
    assert 125 in sample_function(6)

def test_func2():
    assert 64 in sample_function(8)

def sample_test3():
    assert 125 in sample_function(5)
```

What will be the summary of the output for the command
`pytest file.py` on the terminal?

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        function makeBold(){
            //MISSING JS CODE
        }
    </script>
</head>
<body>
    Enter your name : <input type="text" id="txt1" name="txt1">
    <br>
    <input type="button" onclick="makeBold();" value="Click Me">
</body>
</html>
```
Replace the **MISSING JS CODE** part with the correct JS code that will change the text box content to bold?

| | |
| :--- | :--- |
| A. DOM Event | 1. The structure that represents the HTML document and allows interaction with it. |
| B. Attributes | 2. A method or action triggered by user interactions like clicks, typing, etc. |
| C. Document | 3. The individual elements or parts of a page, such as elements, attributes, or text. |
| D. Node | 4. The properties that define the characteristics of an HTML element, like `id`, `class`, etc. |
| E. DOM (Document Object Model) | 5. A programming interface for web documents that provides structured access to the document's elements. |

Consider the following Table products in SQLite database created using model class Product and the python file main.py given below.

products:

| id | pro_name  | section    |
|:---|:----------|:-----------|
| 1  | Palm Oil  | food       |
| 2  | Butter    | food       |
| 3  | Pencil    | art        |
| 4  | Face wash | cosmetics  |
| 5  | Olive     | vegetables |

main.py

```python
from jinja2 import Template
templates = """
    {% if result %}
    <ol>
        {% for product in products %}
        <li>{{product.pro_name}}</li>
        <li>{{product.section}}</li>
        {% endfor %}
    </ol>
    {% endif %}
"""

products = Product.query.filter_by(section = 'food').all()

Templates = Template(templates)
result = Templates.render(products = products)
print(result)
```

What will be the output on the terminal?

Consider the following Python code snippet.

```python
from math import factorial

def prettify(func):
    def wrapper(num):
        try:
            return func(num)
        except:
            return "Please check your number!"
    return wrapper

@prettify
def fact(num):
    return factorial(num)

out = fact(5)
print(out)
```

What will the output if the above Python code is run on the terminal?

Consider the following Python code snippet.
file.py

```python
from string import Template as makeTemplate
from jinja2 import Template
import sys

var = sys.argv[2]

data = {"name": "Alice", "activity": "data analysis",
        "tool": "Python", "goal": "insights"}

temp = "{{name}} performs $activity using $tool to gain {{goal}}."

if var == "python":
    temp = makeTemplate(temp)
    out = temp.substitute(data)
    output = Template(out)
    output = output.render(data)
    print(output)
else:
    temp = Template(temp)
    output = temp.render(data)
    print(output)
```

What will be printed on the terminal for the command `python file.py ml python`?

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
    <style>
        p {
            background-color: yellow;
            color: red;
            display: inline-block;
        }
        #id {
            border: 2px solid purple;
            color:blue ;
        }
        .class1 {
            background-color: aqua;
            color: red;
        }
        .class2{
            background-color: lightgreen;
            color: darkgreen;
        }
    </style>
</head>
<body>
    <p class="class1" id="id">Code 1</p>
    <p class="class1 class2" >Code 2</p>
    <p class="class1">Code 3</p>
    <p >Code 4</p>
</body>
</html>
```

Refer to the project with three files: `conftest1.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.

* `conftest1.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:

**conftest1.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**?

Consider the following Python code snippet that returns the potential energy stored in an object of a certain mass at a certain height. (PE = mgh, where "g" is acceleration due to gravity).

```python
from jinja2 import Template

x = Template(template)
```

What should be the value of template if;
`print(x.render(mass = "5", height = "22"))` returns 1100 and
`print(x.render())` returns 3000

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

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

@app.route('/products')
def products():
    return 'Product List'

@app.route('/product/<int:product_id>/<string:name>')
def product_detail(product_id, name):
    return f'Product ID: {product_id}, Name: {name}'

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

```python
from flask import Flask
import logging
app = Flask(__name__)

logging.basicConfig(filename='logger.log', level=logging.INFO,
                    format=f'%(asctime)s : %(message)s')

@app.route('/home')
def home():
    app.logger.debug('This is a debug log')
    app.logger.warning('This is a warning log')
    return f"Application Dashboard"

if __name__ == "__main__":
    app.run()
```
Suppose the given flask application is running locally on http://127.0.0.1:5000, which of the following statements is/are true if you hit the URL http://127.0.0.1:5000/home ?

```python
app = Flask(__name__)

users = {
    1 : {"Name": "Mukesh", "role": "Admin", "access": True},
    2 : {"Name": "Gautam", "role": "User", "access": True},
    3 : {"Name": "Narendra", "role": "Admin", "access": True},
    4 : {"Name": "Amit", "role": "User", "access": False}
}

@app.route('/login')
def auth():
    cred = request.args
    if users[int(cred["id"])].get("access"):
        id = int(cred["id"])
        user = users[id]
        return "Welcome, "+ user.get("Name")+", you have "+user.get("role") \
            + " access"
    else:
        abort(403)

@app.errorhandler(403)
def no_access(error):
    return "You are an unauthorized user!"

app.run(debug = True)
```

File name: main.py
```python
import sys

def func1(x):
    return x > 0

def func2(x):
    return x % 2 == 0

def test_fun3(x):
    assert func1(x) == True, str(x) + " is not even/odd"
    assert func2(x) == True, str(x) + " is even number"
    assert x % 2 != 0, str(x) + " is odd number"

x = int(sys.argv[1])
test_fun3(x)
```

Which of the following is the correct combinations of “command line argument” and “assertion error”?

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>IITM</title>
</head>
<body>
    <h2>Welcome to IITM </h2>
    <h3>Online Degree</h3>
    Courses offered
    <ol>
        <li>Foundation</li>
        <ul>
            <li>CT</li>
            <li>Python</li>
            <li>Maths-I</li>
        </ul>
        <li>Diploma</li>
        <ul>
            <li>PDSA</li>
            <li>MAD-I</li>
            <li>MAD-II</li>
        </ul>
    </ol>
</body>
</html>
```

Consider a comma-separated values (CSV) file with all characters set ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b"]. You need to store a file consisting of 2000 characters mentioned only in the above list without spaces. How many minimum number of bytes are required to store this CSV file efficiently?

You are connected to a server that can process 1500 requests per second. Each request is a constant size of 100KB. You are connected to the above server through a network line with a speed of 2Gbps. What is the maximum number of requests per second that the server can handle(in KBps)? (Consider that 1000Bytes=1KB, 1000KB = 1MB)?

Which of the following urls will display [Joker]
on the browser?

What will be displayed on the browser for the url:
http://127.0.0.1:5000?genre=action ?

What will be the output of the below terminal request?
```
curl http://127.0.0.1:5000/api/get_account/fd101 -X GET
```

Which of the following command will
update balance of account no. **ca101**?

Assume you have the following Item
API endpoint as shown in the code. If
a client sends a POST request with an
existing item name but missing the
price field in the JSON payload,
what will happen, and why?

What will be the status code of the response
for the request:

```
curl http://127.0.0.1:5000/item/candle?price=120 -X POST
```