MAD1 week 4 - real exam questions

```python
class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.Integer, primary_key=True)
    mail_id = db.Column(db.String, unique=True)
    password = db.Column(db.String, nullable=False)
```
```python
>>> u1=User(mail_id='abc@gmail.com',password='12345')
>>> u2=User(mail_id='pxyz@gmail.com',password='abcd1234')
>>> u3=User(mail_id='lmn@gmail.com',password='54321')
>>> u4=User(mail_id='opqrst@gmail.com',password='xyz123')
>>> db.session.add_all([u1,u2,u3,u4])
>>> db.session.commit()
>>> result=User.query.filter(User.mail_id.like('p%')).all()
>>> print(len(result))
```

Table name: orders

| id | cust_id | status | amount |
|---|---|---|---|
| 1 | C101 | PAID | 500 |
| 2 | C102 | PENDING | 1200 |
| 3 | C101 | PAID | 800 |
| 4 | C103 | CANCELLED | 400 |
| 5 | C102 | PAID | 1200 |

Choose the correct SQLAlchemy statements that is similar to the SQL query:

```sql
SELECT * FROM orders where status='PAID' and amount>500;
```

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

class Enrollment(db.Model):
    id = db.Column(db.Integer(), primary_key = True)
    student_id = db.Column(db.String(), nullable = False)
    course_id = db.Column(db.Integer(), db.ForeignKey("course.id"))
```

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

@app.route('/course/<path:subject>')
def course(subject):
    if "Python" in subject:
        return "Welcome to Python course!"
    else:
        abort(404)

@app.route('/learn/<path:subject>')
def learn(subject):
    if "Python" in subject:
        return redirect(url_for('course', subject=subject))
    else:
        abort(404)

@app.errorhandler(404)
def not_found(error):
    return "<h2>Course not available!</h2>"

app.run(debug=True)
```

CourseRegistrations
| ID | student_id | course_id | date_of_registration |
|---|---|---|---|
| 1 | S101 | CS101 | 17-10-2024 |
| 2 | S103 | CS101 | 10-10-2024 |
| 3 | S101 | CS201 | 16-10-2024 |
| 4 | S102 | CS101 | 17-10-2024 |
| 5 | S104 | CS201 | 06-10-2024 |
```
course_id="CS101"
```

```python
class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.Integer, primary_key=True)
    mail_id = db.Column(db.String, unique=True)
    password = db.Column(db.String, nullable=False)
```

What is the output after the following Python code is executed ? (Assume all entries are successfully committed to the database)

```python
>>> u1=User(mail_id='abc@gmail.com',password='12345')
>>> u2=User(mail_id='pxyz@gmail.com',password='abcd1234')
>>> u3=User(mail_id='lmn@gmail.com',password='54321')
>>> u4=User(mail_id='pqrst@gmail.com',password='xyz123')
>>> db.session.add_all([u1,u2,u3,u4])
>>> db.session.commit()
>>> result=User.query.filter(User.mail_id.like('p%')).all()
>>> print(len(result))
```

File name: app.py
```python
class User(db.Model):
    __tablename__ = "user"
    id = db.Column(db.Integer, primary_key=True)
    full_name = db.Column(db.String, unique=True)

class UserPosts(db.Model):
    __tablename__ = "user_posts"
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String, unique=True, nullable=False)
    description = db.Column(db.String, nullable=True)
    user_id = db.Column(db.Integer, db.ForeignKey("user.id"))

class UserApi(Resource):
    def post(self):
        user_data = request.json
        ==Missing code 1==
        db.session.add(user)
        db.session.commit()
        return {"msg": "User added!"}, 201

class UserPostsApi(Resource):
    def post(self):
        post_data = request.json
        ==Missing code 2==
        db.session.add(user_post)
        db.session.commit()
        return {"msg": "Post added!"}, 201
```
Which of the following is the most suitable ==Missing code 1== and ==Missing code 2==? So that the Flask application does not return any run-time error?

```python
>>> u1 = User(uname = "Jane", pwd = "1234")
>>> p1 = Profile(name = "Analyst", email = "zoozle.com", user_id = u1.id)
>>> db.session.add_all([u1,p1])
>>> db.session.commit()
>>> user1 = User.query.filter_by(uname="Jane").first()
>>> user1.profile
```

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

@app.route('/calculate')
def calculate():
    a = request.args.get('a')
    b = request.args.get('b', 2)
    c = request.args.get('c', "5")

    try:
        a = int(a)
        b = int(b)
        c = int(c)
    except:
        return "Invalid Input"

    if a + b == c:
        return f"Sum: {a+b}"
    elif a * c == b:
        return f"Product: {a*b}"
    else:
        return f"No match: {a+b+c}"

app.run(debug=True)
```
| URL | Output |
|---|---|
| 1. http://127.0.0.1:5000/calculate?a=3 | a. Sum: 6 |
| 2. http://127.0.0.1:5000/calculate?a=3&d=5 | b. Invalid Input |
| 3. http://127.0.0.1:5000/calculate?a=1&b=5 | c. Sum: 5 |
| 4. http://127.0.0.1:5000/calculate?a=1&b=5&c=6 | d. Product: 5 |

```sql
CREATE TABLE employee (
    emp_id INTEGER NOT NULL,
    emp_code VARCHAR() NOT NULL,
    name VARCHAR(),
    salary INTEGER NOT NULL,
    join_date DATE NOT NULL,
    PRIMARY KEY (emp_id),
    UNIQUE (emp_code),
    UNIQUE (name)
)
```

Match the type of update with the correct analogy/description:

| Update Type             | Analogy/Description                                                      |
| :---------------------- | :----------------------------------------------------------------------- |
| 1. Synchronous Updates  | A. Runs tasks one after another, without parallel execution              |
| 2. Asynchronous Updates | B. Freezes the UI until the operation is complete                        |
| 3. Blocking Execution   | C. Ordering food at a restaurant and waiting in line until it is ready   |
| 4. Non-blocking Execution | D. Ordering food, receiving a buzzer, and waiting at a table until it rings |
|                         | E. Allows other tasks to continue while waiting for a response           |

You want to change the text of a `<p>` element with `id="msg"` to "Welcome to JavaScript!" when a button is clicked. Which code snippet correctly does this?

```html
<p id="msg">Old Message</p>
<button id="btn">Change</button>
<script>
    // Code goes here
</script>
```

Table: products

| pid | name  | price |
| :-- | :---- | :---- |
| 101 | Pen   | 10    |
| 102 | Bag   | 450   |
| 103 | Watch | 800   |
| 104 | Shoes | 1300  |

Which query lists all products sorted from expensive to cheap?

Consider test file with markers:

```python
@pytest.mark.slow
def test_database():
    pass

@pytest.mark.unit
def test_calculation():
    pass

@pytest.mark.slow
@pytest.mark.unit
def test_complex():
    pass
```

Running `pytest -m "unit and not slow"` will execute which tests?

Consider the following statements and select the correct option.

Statement 1: The `<span>` elements will start on new lines, while the `<div>` elements will appear inline with surrounding content.

Statement 2: The `<p>` and `<div>` elements will each start on new lines and take up the full width of their container, while `<span>`, `<strong>`, and `<em>` will flow inline with surrounding content.

Consider the following code:

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

app = Flask(__name__)

@app.route('/', methods=['GET', 'POST'])
def home():
    if request.method == 'POST':
        name = request.form['name']
        template = "Hello, {{ name }}!"
        return render_template_string(template, name=name)
    return '''
        <form method="POST">
            Enter Your Name: <input type="text" name="name">
            <button>Submit</button>
        </form>
    '''

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

You are building a Flask web application that takes user input from an HTML form and displays it using Jinja2 templates. Suppose the user runs this app locally and submits the name **Alice** in the form.

Which of the following represents the correct sequence of concepts that occur when the user submits the form with the name **Alice** ?

You executed the following:

```python
student = Student.query.filter_by(id=2).first()
student.name = "Riya"
db.session.add(student)
print(student.name)
```

What will this print?

Suppose you have these models in your Flask-SQLAlchemy app:

```python
class Author(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    books = db.relationship('Book', backref='author', cascade="all, delete")

class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(80))
    author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
```

If you delete an Author instance from the database, what happens to their related Book instances?

Consider the table and match each type of software testing with its correct focus area.

| Test Type | Focus Area |
|---|---|
| 1. Unit Testing | a. Simulated end-user browser-based interaction |
| 2. Integration Testing | b. Whole app in full environment including server |
| 3. System Testing | c. Real-world verification by actual users before release |
| 4. System Testing Automation | d. Multiple components/modules working together |
| 5. User Acceptance Testing | e. Smallest logical units (functions/methods) |

If the application is running locally
on http://127.0.0.1:5000, which
of the following statements are TRUE?

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?

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?

What will be the output of the following HTML code?

```html
<!DOCTYPE html>
<html>
<head>
    <title>Test List</title>
</head>
<body>
    <dl>
        <dt>Flask</dt>
        <dd>A Python web framework.</dd>
        <dt>SQLAlchemy</dt>
        <dd>A database toolkit for Python.</dd>
    </dl>
</body>
</html>
```

Consider the following Python code snippet:
main.py

```python
import sys
def process(v):
    # Missing code 1
    v = sys.argv
    # Missing code 2
    print(output)
```

We are executing above main.py in command line with command `python main.py 1 2 3 4 5`.
Which of the following codes when replaced at #Missing code 1 and #Missing code 2 will render the output below:
**1,2,3,4,5**

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 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 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.

Consider the following models Department and Student corresponding to tables
department and student in SQLite database.

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

class Student(db.Model):
    id = db.Column(db.Integer(), primary_key = True)
    name = db.Column(db.String(), unique = True)
    department = db.Column(db.Integer(), db.ForeignKey("faculty.id"))
```

Based on the model schemas, what relationship do the classes Department and
Student share?

```sql
CREATE TABLE "student" (
    "s_id"          INTEGER,
    "roll_number"   TEXT NOT NULL UNIQUE,
    "first_name"    TEXT NOT NULL,
    "last_name" TEXT NOT NULL,
    PRIMARY KEY("s_id" AUTOINCREMENT)
);
```

What will be the output of the flask_sqlalchemy command given below?

```python
>>> s1 = Student(roll_number = "M01", first_name = "John", last_name = "Dewis")
>>> db.session.add(s1)
>>> s2 = Student(roll_number = "M02", first_name = "John", last_name = "Nector")
>>> db.session.add(s2)
>>> s3 = Student(roll_number = "M03", first_name = "Nick", last_name = "Dewis")
>>> db.session.add(s3)
>>> db.session.commit()
>>> user1= Student.query.filter_by(first_name="John").first()
>>> user1.first_name= "Nick"
>>> db.session.commit()
>>> s1 = Student.query.all()
>>> for student in s1:
        print(student.first_name)
        print(student.last_name)
```

Consider the following Python code.

```python
from string import Template

output = "List of courses in IITM BS Diploma : $c1, $c2, $c3, $c4, $c5"
my_template = Template(output)
==Missing code here===
```

Which of the following statement(s) should replace ==Missing code here=== so that it prints the output without any KeyError exception?

IIT Madras runs a **BS Degree Program in Data Science & AI**, which has thousands of students enrolled across multiple levels (Foundational, Diploma, and Degree). The institution needs a database system to manage:

* Student enrollments, tracking performance across multiple subjects and semesters.
* Faculty assignments to courses, ensuring each instructor handles only specific subjects.
* Course prerequisites (e.g., a student must complete Mad1 before Mad2).
* Secure storage of student grades and transcripts, ensuring only authorized access.
* Handling transactions such as course enrollments, fee payments, and refunds.

Considering the above requirements, which type of database system is **most appropriate**?

Consider the following Flask Restful API code:

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

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

class my_resource1(Resource):
    def get(self):
        return {"output": "Default computed value : 0"}, 200

class my_resource2(Resource):
    def get(self, x, y):
        c = x**y
        return f"output": "Computed x^y = " + str(c)}, 200

api.add_resource(my_resource1, "/")
api.add_resource(my_resource2, "/<int:x>/<int:y>")

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

Assume that the above code is running on "http://127.0.0.1:5000".

| request URL | rendered output |
|---|---|
| 1) http://127.0.0.1:5000/ | i) {"output": "Computed x^y =36"} |
| 2) http://127.0.0.1:5000/x=6/y=2 | ii) {"output": "Default computed value : 0"} |
| 3) http://127.0.0.1:5000/6/2 | iii) Not Found |
| 4) http://127.0.0.1:5000/6 | iv) {"output": "Default computed value : 6"} |
| 5) http://127.0.0.1:5000/2 | v) {"output": "Default computed value : 2"} |

Based on the above table, choose the correct matching?

Consider the table "students" given below. The model class "Student" corresponds to the table "students" in the SQLite database.

Table: students

| ID | First_name | Last_name | Email             |
|----|------------|-----------|-------------------|
| 1  | Arjun      | Kumar     | arjun@example.com |
| 2  | Karthik    | Kumar     | karthik@example.com |
| 3  | Pranav     | Kumar     | pranav@example.com |
| 4  | Surya      |           | surya@example.com |
| 5  | Harish     | Vignesh   | harisj@example.com |
| 6  | Karthik    | Ramesh    | ramesh@example.com |
| 7  | Karthik    | Kumar     | kumar@example.com |

What will be the output of the following Flask-SQLAlchemy commands?

```python
student1 = Student.query.filter_by(First_name="Karthik").first()
student1.First_name = "Vikram"
db.session.commit()
students_list = Student.query.all()
for student in students_list:
    print(student.First_name, student.Last_name)
```

Consider the following Salesman table/model and answer the following question.
Table/model name: Salesman

| sid | name    | sales_amount |
| :-- | :------ | :----------- |
| 101 | Ram     | 7800         |
| 102 | Rahim   | 4560         |
| 103 | Krishna | 8900         |
| 104 | David   | 12300        |
| 105 | Kittu   | 16700        |

Which of the following Flask SQLAlchemy code will retrieve Salesman data, where **sales_amount** is between 5000 and 10000(both inclusive)?

Consider the following two tables in an SQLite database:
Table: Gifts

| GiftID | GiftName | Price |
|---|---|---|
| 1 | Teddy Bear | 250 |
| 2 | Coffee Mug | 150 |
| 3 | Keychain | 100 |
| 4 | Notebook | 180 |
| 5 | Wall Clock | 300 |

Table: Reviews

| ReviewID | GiftID | Rating |
|---|---|---|
| 1 | 1 | 4.2 |
| 2 | 2 | 4.5 |
| 3 | 3 | 3.9 |
| 4 | 4 | 4.7 |
| 5 | 5 | 4.0 |

Which of the following SQL queries correctly retrieves a list of **unique gift names** with a **price less than 200 rupees** and a **rating above 4**? (Note: Displaying the rating in the result is optional, but duplicate gift names should not appear.)

Consider the following code:

```python
import pyhtml as html

table = {'table': [[1,2,3],[4,5,6]]}

def f_table(ctx):
    template_str = html.html(
        html.head(
            html.title('Title')
        ),
        html.body(
            html.table(
                (html.tr(
                    [html.td(cell) for cell in row]
                ) for row in ctx['table'])
            )
        )
    )
    return (template_str)

template = f_table(table)
print(template.render())
```

What will the output of the above PyHTML code be?

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 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?

```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)
```