Before_request as middleware alternative in Flask - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to register a function that runs before each request in Flask.

Flask

from flask import Flask
app = Flask(__name__)

@app.[1]
def before():
    print("This runs before each request")

Drag options to blanks, or click blank then click option'

Aroute

Bteardown_request

Cafter_request

Dbefore_request

Attempts:

3 left

💡 Hint

Common Mistakes

Using @app.route instead of @app.before_request

Using @app.after_request which runs after the request

Using @app.teardown_request which runs after response

The @app.before_request decorator registers a function to run before each request in Flask.

2fill in blank

medium

Complete the code to access the current request path inside a before_request function.

Flask

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

@app.before_request
def check_path():
    path = request.[1]
    print(f"Request path is: {path}")

Drag options to blanks, or click blank then click option'

Aurl

Bmethod

Cpath

Dheaders

Attempts:

3 left

💡 Hint

Common Mistakes

Using request.url which includes full URL

Using request.method which is HTTP method

Using request.headers which is request headers

The request.path attribute gives the path of the current request URL.

3fill in blank

hard

Fix the error in the before_request function to correctly abort requests to '/forbidden'.

Flask

from flask import Flask, request, abort
app = Flask(__name__)

@app.before_request
def block_forbidden():
    if request.path == '/forbidden':
        [1](403)

Drag options to blanks, or click blank then click option'

Aabort()

Babort

Creturn abort

Dreturn abort()

Attempts:

3 left

💡 Hint

Common Mistakes

Returning abort instead of calling it

Calling abort with extra parentheses in the blank

Not calling abort at all

Calling abort(403) raises an HTTP 403 error immediately. You do not return it.

4fill in blank

hard

Fill both blanks to create a before_request function that sets a global variable and logs the request method.

Flask

from flask import Flask, request, g
app = Flask(__name__)

@app.before_request
def setup():
    g.user = 'guest'
    print(f"Method: {request.[1]")
    g.[2] = 123

Drag options to blanks, or click blank then click option'

Amethod

Bpath

Cuser

Did

Attempts:

3 left

💡 Hint

Common Mistakes

Using request.path instead of request.method

Using g.user again instead of a new variable

Confusing variable names in g

request.method gives the HTTP method. g.id sets a global variable named 'id'.

5fill in blank

hard

Fill all three blanks to create a before_request function that checks a header and aborts if missing.

Flask

from flask import Flask, request, abort
app = Flask(__name__)

@app.before_request
def check_header():
    token = request.headers.get('[1]')
    if not token:
        [2](401)
    print(f"Token: {token}")
    request.[3] = token

Drag options to blanks, or click blank then click option'

AAuthorization

Babort

Ctoken

Dheaders

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong header name

Not calling abort correctly

Assigning token to request.headers instead of request.token

The header name is 'Authorization'. abort(401) stops unauthorized requests. request.token stores the token.

Practice

1. What is the main purpose of the before_request function in Flask?

easy

A. To send the final response to the client

B. To handle errors after a request has been processed

C. To define routes and their handlers

D. To run code before every request to perform tasks like login checks or logging

Solution

1. Step 1: Understand the role of before_request

   The before_request function runs before each request to the Flask app, allowing pre-processing like login checks or logging.

2. Step 2: Compare with other Flask functions

   Functions like error handlers run after requests, and route handlers define endpoints, so they differ from before_request.

3. Final Answer:

   To run code before every request to perform tasks like login checks or logging -> Option D

4. Quick Check:

   before_request runs before requests = D [OK]

Hint: before_request runs code before requests start [OK]

Common Mistakes:

• Confusing before_request with error handlers
• Thinking before_request sends responses directly
• Mixing route definition with before_request

2. Which of the following is the correct way to register a before_request function in Flask?

easy

A. @app.before_request\ndef my_function(): pass

B. app.before_request(my_function())

C. app.before_request = my_function()

D. app.before_request = my_function

Solution

1. Step 1: Recall Flask decorator syntax

   Flask uses decorators like @app.before_request above a function to register it as a before_request handler.

2. Step 2: Analyze each option

   @app.before_request\ndef my_function(): pass uses the correct decorator syntax. app.before_request(my_function()) calls the function instead of decorating. Options C and D assign incorrectly.

3. Final Answer:

   @app.before_request\ndef my_function(): pass -> Option A

4. Quick Check:

   Use @app.before_request decorator = A [OK]

Hint: Use @app.before_request decorator above the function [OK]

Common Mistakes:

• Calling the function instead of decorating
• Assigning function instead of decorating
• Missing the @ symbol for decorator

3. Given this Flask code, what will be the output when accessing /?

from flask import Flask, request, abort
app = Flask(__name__)

@app.before_request
def check_auth():
    if request.args.get('token') != 'secret':
        abort(401)

@app.route('/')
def home():
    return 'Welcome!'

# Assume app runs normally

medium

A. Displays 'Welcome!' if URL has ?token=secret, else 401 Unauthorized error

B. Always displays 'Welcome!' regardless of token

C. Always returns 401 Unauthorized error

D. Raises a syntax error due to missing return in before_request

Solution

1. Step 1: Understand the before_request check

   The check_auth function runs before every request and aborts with 401 if the 'token' query parameter is not 'secret'.

2. Step 2: Analyze the route behavior

   If the token is correct, the request proceeds to home() which returns 'Welcome!'. Otherwise, the request is stopped early with 401.

3. Final Answer:

   Displays 'Welcome!' if URL has ?token=secret, else 401 Unauthorized error -> Option A

4. Quick Check:

   before_request aborts if token wrong = C [OK]

Hint: before_request can block requests early with abort() [OK]

Common Mistakes:

• Thinking before_request must return a value
• Assuming route runs even if abort called
• Confusing query parameters with headers

4. Identify the error in this Flask code using before_request:

from flask import Flask
app = Flask(__name__)

@app.before_request
def setup():
    print('Setup done')

@app.route('/')
def index():
    return 'Hello'

medium

A. Missing parentheses in @app.before_request decorator

B. No return statement in before_request function causes error

C. No error; code works correctly

D. Route function must be named before_request

Solution

1. Step 1: Check before_request function requirements

   The before_request function can run code and does not need to return anything unless it wants to stop the request.

2. Step 2: Verify decorator and route correctness

   The decorator syntax is correct, and the route function is properly defined with a return statement.

3. Final Answer:

   No error; code works correctly -> Option C

4. Quick Check:

   before_request can have no return = B [OK]

Hint: before_request functions don't need to return unless blocking [OK]

Common Mistakes:

• Expecting before_request to always return a response
• Confusing decorator syntax with function call
• Thinking route function must be named before_request

5. You want to use before_request to check if a user is logged in by verifying a session key. If not logged in, redirect to /login. Which code snippet correctly implements this?

hard

A. from flask import redirect, session

def check_login():
if 'user' not in session:
return redirect('/login')
app.before_request(check_login())

B. from flask import redirect, session

@app.before_request
def check_login():
if 'user' not in session:
return redirect('/login')

C. from flask import redirect, session

@app.before_request
def check_login():
if session['user'] is None:
return redirect('/login')

D. from flask import redirect

@app.before_request
def check_login():
if session.get('user') == False:
return redirect('/login')

Solution

1. Step 1: Check session key existence safely

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') uses 'user' not in session which safely checks if the user is logged in.

2. Step 2: Confirm correct decorator and redirect usage

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') uses the @app.before_request decorator and returns a redirect response correctly to stop further processing.

3. Final Answer:

   from flask import redirect, session @app.before_request def check_login(): if 'user' not in session: return redirect('/login') -> Option B

4. Quick Check:

   Use @app.before_request and check 'user' in session = A [OK]

Hint: Use @app.before_request and check session key presence [OK]

Common Mistakes:

• Calling the function instead of decorating
• Checking session key with wrong condition
• Not returning redirect to stop request