掌握 Flask 应用程序上下文和请求上下文管理，构建全球化应用

            from flask import Flask, current_app

app = Flask(__name__)
app.config['MY_SETTING'] = 'Global Value'

# Outside a request, you need to push the context to use current_app
with app.app_context():
    print(current_app.config['MY_SETTING']) # Output: Global Value

# Example in a CLI command (using Flask-CLI)
@app.cli.command('show-setting')
def show_setting_command():
    with app.app_context():
        print(f"My setting is: {current_app.config['MY_SETTING']}")

            

              
                Copy
              
            
          

            
from flask import Flask, request, g, session, current_app

app = Flask(__name__)
app.secret_key = 'your secret key'

@app.route('/')
def index():
    # Accessing request data
    user_agent = request.headers.get('User-Agent')
    user_ip = request.remote_addr

    # Accessing application data via current_app
    app_name = current_app.name

    # Storing data in g for this request
    g.request_id = 'some-unique-id-123'

    # Setting session data (requires secret_key)
    session['username'] = 'global_user_example'

    return f"Hello! Your IP is {user_ip}, User Agent: {user_agent}. App: {app_name}. Request ID: {g.request_id}. Session user: {session.get('username')}"

@app.route('/profile')
def profile():
    # Accessing g data set in another view during the same request cycle
    # Note: This is only if the /profile route was accessed via a redirect or internal
    #       forward from the '/' route within the same request. In practice, it's better
    #       to pass data explicitly or use session.
    request_id_from_g = getattr(g, 'request_id', 'Not set')
    return f"Profile page. Request ID (from g): {request_id_from_g}"

            

              
                Copy
              
            
          

            
from flask import Flask, request, current_app

app = Flask(__name__)
app.config['MY_SETTING'] = 'Global Value'

# Simulate a request context
with app.test_request_context('/test', method='GET', headers={'User-Agent': 'TestClient'}):
    print(request.method) # Output: GET
    print(request.headers.get('User-Agent')) # Output: TestClient
    print(current_app.name) # Output: __main__ (or your app's name)

    # You can even use g within this simulated context
    g.test_data = 'Some test info'
    print(g.test_data) # Output: Some test info

            

              
                Copy
              
            
          

            
from flask import Flask, request, g, current_app
from flask_babel import Babel, get_locale

app = Flask(__name__)
app.config['BABEL_DEFAULT_LOCALE'] = 'en'
app.config['BABEL_DEFAULT_TIMEZONE'] = 'UTC'

babel = Babel(app)

# Application context is implicitly pushed by Flask-Babel during initialization
# and will be available during requests.

@babel.localeselector
def get_locale():
    # Try to get language from URL first (e.g., /en/about)
    if 'lang' in request.view_args:
        g.current_lang = request.view_args['lang']
        return request.view_args['lang']

    # Try to get language from user's browser headers
    user_lang = request.accept_languages.best_match(app.config['LANGUAGES'])
    if user_lang:
        g.current_lang = user_lang
        return user_lang

    # Fallback to application default
    g.current_lang = app.config['BABEL_DEFAULT_LOCALE']
    return app.config['BABEL_DEFAULT_LOCALE']

@app.route('//hello')
def hello_lang(lang):
    # current_app.config['BABEL_DEFAULT_LOCALE'] is accessible
    # g.current_lang was set by get_locale()
    return f"Hello in {g.current_lang}!"

@app.route('/hello')
def hello_default():
    # get_locale() will be called automatically
    return f"Hello in {get_locale()}!"

            

              
                Copy
              
            
          

            
from flask import Flask, request, g, current_app
from datetime import datetime
import pytz # A robust timezone library

app = Flask(__name__)
app.config['SERVER_TIMEZONE'] = 'UTC'

# Function to get user's timezone (simulated)
def get_user_timezone(user_id):
    # In a real app, this would query a database or session
    timezones = {'user1': 'America/New_York', 'user2': 'Asia/Tokyo'}
    return timezones.get(user_id, app.config['SERVER_TIMEZONE'])

@app.before_request
def set_timezone():
    # Simulate a logged-in user
    user_id = 'user1'
    g.user_timezone_str = get_user_timezone(user_id)
    g.user_timezone = pytz.timezone(g.user_timezone_str)

@app.route('/time')
def show_time():
    now_utc = datetime.now(pytz.utc)
    # Format time for the current user's timezone
    now_user_tz = now_utc.astimezone(g.user_timezone)
    formatted_time = now_user_tz.strftime('%Y-%m-%d %H:%M:%S %Z%z')

    # Accessing application's base timezone
    server_tz_str = current_app.config['SERVER_TIMEZONE']

    return f"Current time in your timezone ({g.user_timezone_str}): {formatted_time}
\n              Server is set to: {server_tz_str}"

            

              
                Copy
              
            
          

            
from flask import Flask, g, request, current_app
import sqlite3

app = Flask(__name__)
app.config['DATABASE_URI_GLOBAL'] = 'global_data.db'
app.config['DATABASE_URI_USERS'] = 'user_specific_data.db'

def get_db(db_uri):
    db = getattr(g, '_database', None)
    if db is None:
        db = g._database = sqlite3.connect(db_uri)
        # Optional: Configure how rows are returned (e.g., as dictionaries)
        db.row_factory = sqlite3.Row
    return db

@app.before_request
def setup_db_connection():
    # Determine which database to use based on request, e.g., user's region
    user_region = request.args.get('region', 'global') # 'global' or 'user'

    if user_region == 'user':
        # In a real app, user_id would come from session/auth
        g.db_uri = current_app.config['DATABASE_URI_USERS']
    else:
        g.db_uri = current_app.config['DATABASE_URI_GLOBAL']

    g.db = get_db(g.db_uri)

@app.teardown_request
def close_db_connection(exception):
    db = getattr(g, '_database', None)
    if db is not None:
        db.close()

@app.route('/data')
def get_data():
    cursor = g.db.execute('SELECT * FROM items')
    items = cursor.fetchall()
    return f"Data from {g.db_uri}: {items}"

# Example usage: /data?region=global or /data?region=user

            

              
                Copy
              
            
          

            
from flask import Flask, session, current_app

app = Flask(__name__)
app.secret_key = 'testing_key'

@app.route('/login')
def login():
    session['user'] = 'test_user'
    return 'Logged in'

@app.route('/user')
def get_user():
    return session.get('user', 'No user')

# Test using the test client
client = app.test_client()

response = client.get('/login')
assert response.status_code == 200

# Session data is now set within the test client's context
response = client.get('/user')
assert response.get_data(as_text=True) == 'test_user'

# current_app is also available
with app.test_client() as c:
    with c.application.app_context(): # Explicitly push app context if needed
        print(current_app.name)

            

              
                Copy
              
            
          

            
from your_flask_app import create_app # Assuming you have a factory pattern
from flask import current_app

@celery.task
def process_background_data(data):
    app = create_app() # Get your Flask app instance
    with app.app_context():
        # Now you can safely use current_app
        config_value = current_app.config['SOME_BACKGROUND_SETTING']
        # ... perform operations using config_value ...
        print(f"Processing with config: {config_value}")
    return "Task completed"

            

              
                Copy