2023 Dec24: IIT M FN EXAM FDD1 - 24 Dec 2023

Consider the given URL below.

```
https://seek.onlinedegree.iitm.ac.in/courses/ns_23t3_cs2003?type=lesson&tab
=courses
```

Select the appropriate option that correctly identifies different components of a given URL.

Consider two python files, one.py and two.py with following code snippets.
File1: one.py

```python
import sys
import two
print(f'{sys.argv[0]} {sys.argv[1]}')
```

File2: two.py

```python
import sys
print(f'{sys.argv[3]} {sys.argv[2]}')
```

What is the output of the following command "python one.py two.py one.py two.py "?

```html
<!DOCTYPE html>
<html>
<head>
    <title>Document</title>
    <style>
        div{
            border: 1px solid black;
            color:pink;
            display: inline-block;
        }
        span{
            border: 1px solid pink;
        }
    </style>
</head>
<body>
    <div>Div 1</div>
    <div>Div 2</div>
    <span>Span 1</span>
    <span>Span 2</span>
</body>
</html>
```

Consider the below flask application.

```python
from flask_sqlalchemy import SQLAlchemy
from flask import Flask

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///testdb.sqlite3'
db = SQLAlchemy(app)
app.app_context().push()

class Material(db.Model):
    m_id = db.Column('m_id', db.Integer, primary_key = True)
    name = db.Column('name', db.String(100), unique = True)

db.create_all()
material1 = Material(name = 'Steel')
db.session.add(material1)
material2 = Material(name = 'Iron')
material3 = Material(name = 'Aluminium')
db.session.add(material2)
db.session.commit()
db.session.add(material3)

all_material = Material.query.all()
print([(x.m_id, x.name) for x in all_material])
```
If you run the flask application using a terminal. What will be the output in the terminal?

Consider a function func, and a set of test cases given below.

Filename: test_file.py

```python
import pytest
def func(x,y):
    out = x**2+y**2
    return out

class Test_class0():
    def test_case1(self):
        assert func(1,2) == 5

    def case_test2(self):
        assert func(2,3) == 10

    def test_case3(self):
        assert func(4,2) == 21

class Test_class1():
    def test_case1(self):
        assert func(5,2) == 27

    def case_test2(self):
        assert func(4,3) == 25
```
What will be the output on the terminal for the command below?
pytest test_file.py -k Test_class

Consider the following box model of an element `<div>` with Id = "box".

Diagram: Box Model
- Outermost layer (light orange, dashed border): Margin. Values: Top 5, Right 10, Bottom 5, Left 10.
- Second layer (yellow, solid border): Border. Values: Top 3, Right 3, Bottom 3, Left 3.
- Third layer (green, dashed border): Padding. Values: Top 8, Right 4, Bottom 8, Left 4.
- Innermost layer (blue, solid border): Content. Values: 200x20.

Which of the following CSS styling would correctly create the box model of the element given above?

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

test_file.py
```python
import pytest

def square(x):
    sum = 0
    for counter in range(x):
        sum += x
    return sum

@pytest.mark.marker1
def testcase_1():
    assert square(12) == 144

@pytest.mark.marker2
def testcase_2():
    assert square(9) == 9

@pytest.mark.marker3
def testcase_3():
    assert square(3) == 27
```

On running this file on the terminal using pytest, the summary of the output is:
`========== 1 passed, 2 deselected, 3 warnings in 0.02s ==========`

What command will result into the outcome given above?

The hexadecimal equivalent of the IPv4 address 172.16.254.10 would be
___________

Consider the following models Creator and Song corresponding to tables
creator and song in SQLite database.

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

class Song(db.Model):
    id = db.Column(db.Integer(), primary_key = True)
    s_title = db.Column(db.String(), unique = True)
    singer = db.Column(db.Integer(), db.ForeignKey("singer.id"))
```

Based on the model schemas, what relationship do the table creator and song
share?

Consider the following one-line python code snippet.
Filename: application.py

```python
print(__name__)
```

If we run the above file in a terminal using "python application.py", what will be the output?

A flask application shown below is running locally on http://127.0.0.1:5000.

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

app = Flask(__name__)
app.config['SECRET_KEY'] = "yekterces"

@app.route('/login')
def log_in():
    user = request.args['user']
    role = request.args['role'] if 'role' in request.args else \
           'general'
    session['user'], session['role'] = user, role
    return "Logged in successfully!"

@app.route('/home')
def land():
    if 'user' in session:
        if session['role'] == 'admin':
            return f"Welcome {session['user']}"
        return abort(401)
    return abort(404)

@app.route('/logout')
def log_out():
    session.pop('user', None)
    session.pop('role', None)
    return "Logged out sucessfully!"

app.run(debug=True)
```

If the application is running locally on http://127.0.0.1:5000. What will be the correct sequence of response status codes if the client visits the URLs one by one in the sequence given below?

1. http://127.0.0.1:5000/home
2. http://127.0.0.1:5000/login/admin
3. http://127.0.0.1:5000/login?user=admin
4. http://127.0.0.1:5000/home
5. http://127.0.0.1:5000/logout

Consider the following Python code snippet.

Filename: arg.py
```python
from jinja2 import Template
import sys
input_list = sys.argv
num1, num2, input_list[3] = int(input_list[1]), int(input_list[2]), \
                            int(input_list[3])

if input_list[3]== 1:
    num3= (num1*num2)
elif input_list[3]== 2:
    num3= (num1+num2)
elif input_list[3]== 3:
    num3= (num1-num2)
else:
    num3= (num1%num2)
template = """
<!DOCTYPE html>
<html>
<div>
    Number 1: {{num1}},
    Number 2: {{num2}},
    Output : {{num3}}
</div>
</html>
"""

t = Template(template)
print(t.render(num1=num1, num2=num2, num3=num3))
```
Map the commands in column A with the correct rendered output in the browser in column B.

| Column A | Column B |
|---|---|
| a) python arg.py 1 2 1 | 1) Number 1: 1, Number 2: 2, Output : 3 |
| b) python arg.py 1 2 2 | 2) Number 1: 3, Number 2: 2, Output : 1 |
| c) python arg.py 3 2 4 | 3) Number 1: 1, Number 2: 2, Output : 2 |
| d) python arg.py 3 2 3 | 4) Number 1: 3, Number 2: 2, Output : 1 |

Given a Python code snippet, code.py is run on the terminal with an appropriate temp.html document.

code.py
```python
from jinja2 import Template
Products = [
    {'product_id':'101', 'prod_name':'Legion', 'producer':'Lenovo'},
    {'product_id':'102', 'prod_name':'S21pro', 'producer':'Samsung'},
    {'product_id':'103', 'prod_name':'TabA7', 'producer':'Samsung'},
    {'product_id':'104', 'prod_name':'Ideapad', 'producer':'Lenovo'},
]

file = open ('temp.html','r')
temp = file.read()
file.close()
made_temp = Template(temp)
print(made_temp.render(Products=Products))
```

What should be the content of temp.html file if the browser renders the output of the above code, as shown below;
Lenovo

| Product ID | Name    |
|:-----------|:--------|
| 101        | Legion  |
| 104        | Ideapad |

Samsung

| Product ID | Name   |
|:-----------|:-------|
| 102        | S21pro |
| 103        | TabA7  |

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

```python
# test_file.py
powers = []

for i in range(1,5):
    def powers_of_x(x):
        return x**i
    powers.append(powers_of_x)

powers_of_4 = [x(4) for x in powers]

def testcase_1():
    assert 12 in powers_of_4

def testcase_2():
    assert 64 in powers_of_4

def testcase_3():
    assert 256 in powers_of_4
```

For the command `pytest test_file.py`, what will be the output on the terminal?

Consider the following HTML document rendered using a browser.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Document</title>
    <style>
        input:valid {
            background: green;
        }
        input:invalid {
            background: red;
        }
    </style>
</head>
<body>
    <form>
        <label for="uname">Enter a valid e-mail:</label>
        <input type="text" name="uname" minlength="5"
               maxlength="8" value="a">
    </form>
</body>
</html>
```

If a user starts typing "madcourse" letter by letter, how will the background colour of the `<input>` tag change?

An HTML code is given below, which of the following CSS code will render the output as shown below.

HTML Code:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Document</title>
    <link href="style.css" rel="stylesheet">
    <style>
        body{background-color: gray; text-align: center;}
        h2{color: purple !important ;}
    </style>
</head>
<body style="background-color:lavender;" >
    <h2 style="color: blue;">CSS Selectors</h2>
    <p class="one">ID</p>
    <p class="two">Class</p>
    <p class="three" id="id">Element</p>
</body>
</html>
```

Rendered Output:

UI screenshot: A light blue rectangular box with rounded corners.
Inside the box, the text "CSS Selectors" is displayed in purple, centered.
Below it, the text "ID" is displayed in blue, centered.
Below it, the text "Class" is displayed in blue, centered.
Below it, the text "Element" is displayed in red, centered.

Consider the following flask application.

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

@app.route('/home/<path:url_path>')
def course(url_path):
    return 'The path is: ' + url_path

@app.route('/home/details/<student_id>/<course_id>')
def home(student_id, course_id):
    return f'The student-id and course-id are {student_id} and {course_id} respectively.'

@app.route('/home/student/<student_id>/<course_id>')
def details(student_id, course_id):
    details = {'course_id': course_id, 'student_id': student_id}
    return details

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 python code snippet and choose the correct option.

```python
def modify(func):
    def wrapper(x):
        list = func(x, [])
        return list
    return wrapper

@modify
def expandList(x, list = []):
    list.append(x)
    return list

print(expandList(5))
print(expandList(6))
```

Consider the following flask application.

```python
from flask import Flask, abort
app = Flask(__name__)
modules = ['python', 'react', 'node']

@app.route('/home/modules/')
def all_modules():
    return f"<h3>List of modules: {modules}</h3>"

@app.route('/get/<string:module_1>')
def get_module(module_1):
    if module_1 in modules:
        return f"<h3>One module found: {module_1}.</h3>"
    else:
        abort(400)

@app.errorhandler(400)
def module_error(error):
    return "<h3>Cannot find module</h3>"

@app.errorhandler(404)
def module_error(error):
    return "<h3>Incorrect Path</h3>"

app.run(debug=True)
```

If the application is running locally on http://127.0.0.1:5000, select the correct statement(s).

Consider the following flask view function definition given below.

```python
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        return render_template("login.html")
    if request.method == 'POST':
        #=== POST Logic ===
        return render_template("profile.html")
```

Which of the following view function definitions would work the same as that of one given above?

If the curl request shown below.

```
curl http://127.0.0.1:5000/api/v1 -X GET -d "{\"movie\": \"X-men\", \"genre\": \"Action\"}" -H "Content-Type: application/json"
```

retrieves the movie only with status 200 OK,
what will come in place of GET-FUNCTION
in the code?

If the curl request shown below

```
curl http://127.0.0.1:5000/api/v1/fiction -X POST
```

retrieves the genre only with status 200 OK,
what will come in place of POST-FUNCTION
in the code?

What will be the response from the server for the request:
```
curl http://127.0.0.1:5000/api/v1 -X PUT -d "{\"movie\" : \"X-men\", \"genre\": \"Action\"}" -H "Content-Type: application/json"
```