Flask Context System

Flask Context System: The Magic Behind Every Request 🎭

The Story of Two Worlds

Imagine a busy restaurant kitchen. The chef needs to know two things at any moment:

1. Which restaurant am I in? (The building, menu, equipment) → Application Context
2. Which order am I cooking right now? (The specific customer’s request) → Request Context

Flask works the same way! Let’s explore this magical system.

🏠 Application Context: The Restaurant Building

The Application Context is like the restaurant itself—it exists whether customers are there or not.

What lives here?

• Your app’s configuration
• Database connections
• Registered blueprints

Simple Example:

from flask import Flask, current_app

app = Flask(__name__)
app.config['SECRET'] = 'my-secret-key'

with app.app_context():
    # Now we're "inside" the restaurant
    print(current_app.config['SECRET'])
    # Output: my-secret-key

Think of it: You walk into the restaurant building. Now you can see the kitchen, menu, and equipment!

📬 Request Context: The Customer’s Order

When someone visits your website, Flask creates a Request Context—like a waiter bringing a specific order ticket.

What lives here?

• URL the user visited
• Form data they submitted
• Cookies they sent

Simple Example:

from flask import Flask, request

app = Flask(__name__)

@app.route('/hello')
def hello():
    # Inside a request context
    name = request.args.get('name', 'Friend')
    return f'Hello, {name}!'

Real Life: When you visit /hello?name=Sam, Flask creates a request context holding that information!

🎒 The g Object: Your Request Backpack

The g object is like a backpack you carry during one trip through the restaurant. Put stuff in, use it later, empty it when you leave.

Key Facts:

• Lives only during ONE request
• Perfect for storing database connections
• Resets between requests

Simple Example:

from flask import Flask, g

app = Flask(__name__)

def get_user():
    if 'user' not in g:
        g.user = load_user_from_db()
    return g.user

@app.route('/profile')
def profile():
    user = get_user()  # Stored in backpack!
    return f'Welcome, {user.name}'

Think of it: You grab your backpack at the door, fill it with what you need, use it throughout your visit, then leave it at the exit.

🔮 current_app Proxy: The Magic Mirror

current_app is like a magic mirror that always shows you the current restaurant, no matter where you are in the code.

Why do we need it?

from flask import current_app

def send_email():
    # We don't have direct access to 'app'
    # But current_app knows which app we're in!
    api_key = current_app.config['EMAIL_API_KEY']
    # Send email using api_key

The Magic:

from flask import Flask, current_app

app1 = Flask('app1')
app1.config['NAME'] = 'Restaurant A'

app2 = Flask('app2')
app2.config['NAME'] = 'Restaurant B'

with app1.app_context():
    print(current_app.config['NAME'])
    # Output: Restaurant A

with app2.app_context():
    print(current_app.config['NAME'])
    # Output: Restaurant B

Real Life: It’s like asking “What restaurant am I in?” and always getting the right answer!

🔄 Request Lifecycle: The Customer’s Journey

Every request follows a journey, like a customer visiting your restaurant:

graph TD
    A["Customer Arrives"] --> B["before_request"]
    B --> C["Your View Function"]
    C --> D["after_request"]
    D --> E["Customer Leaves"]
    E --> F["teardown_request"]

    style A fill:#e8f5e9
    style B fill:#fff3e0
    style C fill:#e3f2fd
    style D fill:#fff3e0
    style F fill:#fce4ec

The Journey:

1. Customer arrives → Request context created
2. before_request → Check reservation, validate identity
3. View function → Cook and serve the meal
4. after_request → Hand them the bill
5. teardown_request → Clean the table (always happens!)

🚦 before_request: The Security Guard

before_request runs BEFORE every request reaches your view. Perfect for:

• Checking if user is logged in
• Loading user data
• Validating tokens

Simple Example:

from flask import Flask, g, request, redirect

app = Flask(__name__)

@app.before_request
def check_login():
    # Runs before EVERY request
    if request.endpoint != 'login':
        if not is_logged_in():
            return redirect('/login')
    g.user = get_current_user()

@app.route('/dashboard')
def dashboard():
    # g.user is already loaded!
    return f'Hello, {g.user.name}'

Think of it: The bouncer at the door checking your ID before you enter!

🎁 after_request: The Gift Wrapper

after_request runs AFTER your view, but BEFORE sending the response. Perfect for:

• Adding headers
• Logging
• Modifying the response

Simple Example:

from flask import Flask

app = Flask(__name__)

@app.after_request
def add_security_headers(response):
    # Add headers to EVERY response
    response.headers['X-Frame-Options'] = 'DENY'
    response.headers['X-Content-Type'] = 'nosniff'
    return response  # Must return response!

@app.route('/')
def home():
    return 'Hello World'
    # Headers automatically added!

Think of it: Wrapping every gift before it leaves the store, adding a ribbon and card!

🧹 teardown_request: The Cleanup Crew

teardown_request runs at the VERY END, even if errors happened! Perfect for:

• Closing database connections
• Cleaning up resources
• Logging errors

Simple Example:

from flask import Flask, g

app = Flask(__name__)

@app.teardown_request
def cleanup(exception):
    # This ALWAYS runs, even if there's an error!
    db = g.pop('db', None)
    if db is not None:
        db.close()
        print('Database connection closed')

@app.route('/data')
def get_data():
    g.db = connect_to_database()
    # Even if this crashes, cleanup runs!
    return query_data(g.db)

Think of it: The cleaning crew that comes in EVERY night, no matter what happened during the day!

🎯 Putting It All Together

Here’s a complete example showing everything working together:

from flask import Flask, g, request, current_app

app = Flask(__name__)
app.config['DB_NAME'] = 'myapp.db'

@app.before_request
def setup():
    # 1. First, prepare resources
    g.db = connect(current_app.config['DB_NAME'])
    g.start_time = time.time()

@app.route('/users')
def users():
    # 2. Use the resources
    return g.db.query('SELECT * FROM users')

@app.after_request
def log_request(response):
    # 3. Log how long it took
    duration = time.time() - g.start_time
    print(f'Request took {duration}s')
    return response

@app.teardown_request
def cleanup(exception):
    # 4. Always clean up!
    db = g.pop('db', None)
    if db:
        db.close()

🌟 Quick Summary

🎉 You Did It!

Now you understand Flask’s context system! Remember:

• Application context = Which app am I in?
• Request context = What does this user want?
• g = My temporary backpack
• current_app = Show me the current app
• Lifecycle = before → view → after → teardown

You’re ready to build Flask apps that handle requests like a pro! 🚀