IIT M DIPLOMA AN EXAM QDD3 24 Mar 2024 - 24 Mar 2024

Consider the following code.

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

@app.route('/home')
def home1():
    return "This is homepage 1"

@app.route('/home/')
def home2():
    return "This is homepage 2"

@app.errorhandler(404)
def page_not_found(e):
    return 'page not found'

app.run(debug=True)
```

If the flask application is running on http://127.0.0.1:5000, what will browser render for URL http://127.0.0.1:5000/home/

Consider the following Flask code snippet.

```python
from flask import Flask, request

app = Flask(__name__)

@app.route('/greet/<name>')
def greet(name):
    if name:
        return f'<h1>Hi, Mr/Ms/ {name} welcome to flask</h1>'
    else:
        return f'<h1>Hi, Mr/Ms/ <Unknown> welcome to flask</h1>'

app.run(debug=True)
```

If the application is running on a local server for the URL: https://127.0.0.1:5000, what will the browser render for the URL, http://127.0.0.1:5000/greet/?

Consider the below Flask code snippet:

```python
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/courses')
def get_courses():
    courses = [{'id': 'CS1001', 'name': 'CT'}, {'id': 'CS1002',
               'name': 'PDSA'}]

    return jsonify(courses)
```

If the application is running locally, what will be the **status** code and **mimetype** of the response for the URL, `http://127.0.0.1:5000/api/courses`?

Consider the following Python code snippet.

```python
from string import Template

text = "The $color car is parked in front of the $building."

template = Template(text)

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

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

Software packages A and B of complexity O(nlogn) and O(n^2), respectively, spend exactly T_A(n) = C_A nlog_10(n) and T_B(n) = C_B n^2 milliseconds to process n data items.

During a test, the average time of processing n = 10^7 data items with the package A and B is 420 milliseconds and 350 milliseconds, respectively. The time taken (in milliseconds) by software package A and B to process 10^8 data items, respectively will be?

Consider the "loans" table below, and it's model class "Loans" associated with the table "loans" in the SQLite db.

| ID | application_date | approved_status | Remarks |
|---|---|---|---|
| 1 | 27/01/2023 | Yes | All docs verified |
| 2 | 29/03/2023 | No | The mortgage doc is missing |
| 3 | 13/04/2023 | No | The payslip doc is not enclosed |
| 4 | 03/08/2023 | No | TDS doc is not enclosed |
| 6 | 10/12/2023 | Yes | All docs verified |
| 7 | 17/12/2023 | Yes | All docs verified |

What is the correct output of the `flask_sqlalchemy` commands below?

```python
loans=Loans.query.filter_by(approved_status= "No").all()
for l in loans:
    print(l.ID, ",", l.approved_status, ",", l.remarks)
```

Consider the following Python code snippet.

```python
def modify(func):
    def wrapper(name):
        print("Before function execution")
        result = func(name)
        print("After function execution")
        return result
    return wrapper

@modify
def greet(name):
    return f"Hello, {name}!"

print(greet("Ram"))
```

What will be the output of the code on the terminal?

Consider the following Python code snippet.

```python
import logging
import sys

logging.basicConfig(level=logging.INFO,
                    format='%(levelname)s - %(message)s')

num1, num2 = int(sys.argv[1]), int(sys.argv[2])

logging.info("This operation checks factors")

if num1 % num2 == 0:
    logging.debug(f"{num2} is a factor of {num1}")
else:
    logging.warning(f"{num2} is not the factor of {num1}")
```

What will be the output of the above code on the terminal for the command:
`python log.py 25 5`

Consider the following flask application.
app.py

```python
from flask import Flask, abort, request

app = Flask(__name__)

@app.route('/validate/<int:number>')
def validate_number(number):
    if number % 2 == 0 and number % 3 == 1:
        abort(400, "Bad Request: Invalid number provided")
    return f'<h1>Valid Number: {number}</h1>'

app.run(debug=True)
```

Which of the following statements is/are true if the application is running locally on
http://127.0.0.1:5000 ?

Consider the following flask application.
app.py

```python
from flask import Flask, abort, request

app = Flask(__name__)

@app.route('/process')
def process():
    username = request.args.get('uname', 'MAD-I')
    if username.isnumeric():
        abort(400, "Bad Request: Numeric username provided")
    return f'<h1>Valid Username: {username}</h1>'

app.run(debug=True)
```

Which of the following statements is/are true if the application is running locally on
http://127.0.0.1:5000 ?

Consider the following flask application.
app.py

```python
from flask import Flask, abort, request

app = Flask(__name__)
data = {'MAD-I':'CS2003', 'MAD-II':'CS2004', 'Java':'CS2005'}

@app.route('/course/<course_name>')
def course(course_name):
    course_id = request.args.get('id')
    if course_name in data and course_id == data[course_name]:
        return f'<h1>The Course ID for {course_name} is: {course_id}</h1>'
    else:
        abort(400, "Bad Request: Invalid data")

app.run(debug=True)
```

Which of the following statements is/are true if the application is running locally on
http://127.0.0.1:5000 ?

Consider the below schema:

| Field           | Description                                                               |
| :-------------- | :------------------------------------------------------------------------ |
| emp_id          | Integer and primary key                                                   |
| employee_name   | String with maximum 255 length, mandatory field and can be duplicated     |
| basic_salary    | Real number is an optional field that can be duplicated                   |

Which of the below is the correct syntax to create a data model using
`flask_sqlalchemy`?

Consider the following HTML document and select the correct option(s).

```html
<!DOCTYPE html>
<html>
<head>
    <title>Form Validation</title>
    <script>
        function validateForm() {
            var username = document.forms["myForm"]["username"].value;
            var password = document.forms["myForm"]["password"].value;
            if (username == "") {
                alert("Username must be filled out");
                return false;
            }
            if (password.length < 8) {
                alert("Password must be at least 8 characters long");
                return false;
            }
        }
    </script>
</head>
<body>
    <form name="myForm" onsubmit="validateForm()">
        <label for="username">Username:</label>
        <input type="text" name="username">
        <label for="password">Password:</label>
        <input type="password" name="password" required>
        <input type="submit" value="Submit">
    </form>
</body>
</html>
```

Consider the following api resources created using flask_restful. Assume that the app is connected to the database and is running on one terminal. Select the correct option(s).

```python
class TestApi(Resource):
    def get(self, admin):
        # retrieves admin data from database and returns it.
        return {
            "name": "mad1_admin",
            "role": "admin",
        }

    def post(self):
        # fetches user data from request body and stores in the
        # database.
        return {
            "message": "user added successfully"
        }, 201

api.add_resource(TestApi, "/api/<string:admin>", "/<admin>",
                 "/user_data", "/")

app.run()
```