IIT M DIPLOMA AN EXAM QDD4 03 Aug - 03 Aug 2025

Consider the following table "ExamScores" in the SQLite database.

| id | score |
|----|-------|
| 1  | 57    |
| 2  | 98    |
| 3  | 83    |

Which of the following Python statements will print the maximum score value?

Consider the following Flask and HTML implementations.

Flask file: main.py

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

@app.route("/text/size/<int:size>/<color>")
def set_size(size, color):
    style = {"font-size": str(size) + "px", "color": color}
    return render_template("index.html", css_style=style)

app.run(debug=True)
```

HTML file: index.html

```html
<!DOCTYPE html>
<html>
    <div style="color: {{css_style['color']}};
    font-size:{{css_style['font-size']}};">
        IITM BS Degree Program
    </div>
</html>
```

Assume that the Flask code is running on the server http://127.0.0.1:5000 without any errors.
Choose the correct URL to render the output below.

IITM BS Degree Program

Consider the following Python code.
File name: main.py

```python
def calculate(funx):
    def wrapper(a, b):
        x = funx(a, b)
        return x**2
    return wrapper

@calculate
def foo(x, y):
    return x - y

# main code
print(foo(5, 2))
```

What is the correct output of the given code?

Consider the following Python code snippet.

```python
from string import Template

msg = "The $lang programming language is $desc and $useful for web
development."

template = Template(msg)

print(=== OUTPUT ===)
```

Which of the following statements, when substituted in place of `=== OUTPUT ===`, will throw a KeyError?

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. What will be the output for the URL: "http://127.0.0.1:5000/signin?uid=professor&pwd=54321" ?

Consider the following HTML code.
Filename: main.html

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Greetings</title>
</head>
<body>

    <button onclick="alert('Hello, welcome')">Greet1!</button><br>
    <button onclick="console.log('Hello, welcome')">Greet2!</button><br>
    <button onclick="document.write('Hello, welcome')">Greet3!</button><br>
    <button onclick="console.error('Hello, welcome')">Greet4!</button>

</body>
</html>
```
Rendered HTML output below:

[Greet1!] (button)
[Greet2!] (button)
[Greet3!] (button)
[Greet4!] (button)

Which of the above “Greet” buttons will print greetings on the dialogue box?

Consider the following flask application.

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

users = ["admin", "user_1", "user_2", "user_3"]

@app.route('/home/<string:username>', methods = ['POST'])
def home(username):
    if username in users:
        return f"<h1>Hello {username}, Welcome!</h1>"
    else:
        abort(407)

@app.errorhandler(404)
def user_error_1(error):
    return "<h1>The user you are looking for is invalid.</h1>"

@app.errorhandler(405)
def user_error_2(error):
    return "<h1>Please check the web request.</h1>"

@app.errorhandler(407)
def user_error_4(error):
    return "<h1>Proxy authentication required.</h1>"

app.run()
```

If the application is running locally on `http://127.0.0.1:5000`. What will be rendered on the browser for the URL `http://127.0.0.1:5000/home/user_4` ?

Consider the Flask Restful API code given below:
File name: app.py

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

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

class APICalculator(Resource):
    def post(self):
        d = request.json
        a = int(d["val1"])
        b = int(d["val2"])
        oper = d["operator"]
        if oper == "+":
            return {"Sum": (a + b)}, 200
        elif oper == "-":
            return {"Difference": (a - b)}, 200
        elif oper == "*":
            return {"Product": (a * b)}, 200
        else:
            return {"Error": "Invalid option"}, 401

api.add_resource(APICalculator, "/")

app.run(debug=True)
```

Assume that the Flask server is running on http://127.0.0.1:5000. Which of the following is the correct curl command(s) that will return calculated values?
**Note: Assume data sent is valid for cmd, and powershell**

Consider a document of 2000 characters written using only the characters from the character set L1 = {'x', 'y', 'z', 'w', 'v', 'u', 't', 's'}. If the character set L1 is to be upgraded by adding all the characters from the set L2 = {'1', '2', '3', '4', '5'}, by how many bits will the size of the original document increase?(assume an optimal number of bits are used for representing each character).

You need to obtain a list of (id, days_to_fix)
where days_to_fix is the number of days
between broken_at and fixed_at. Using
Flask-SQLAlchemy, which of the following
approaches will work?

You want to retrieve all repairs that took more
than 7 days to fix. Using Flask-SQLAlchemy,
which of the following approaches will
correctly yield a list of (id, days_to_fix)
only for those records where days_to_fix > 7?