| | .. currentmodule:: flask |
| |
|
| | The Application Context |
| | ======================= |
| |
|
| | The application context keeps track of the application-level data during |
| | a request, CLI command, or other activity. Rather than passing the |
| | application around to each function, the :data:`current_app` and |
| | :data:`g` proxies are accessed instead. |
| |
|
| | This is similar to :doc:`/reqcontext`, which keeps track of |
| | request-level data during a request. A corresponding application context |
| | is pushed when a request context is pushed. |
| |
|
| | Purpose of the Context |
| | ---------------------- |
| |
|
| | The :class:`Flask` application object has attributes, such as |
| | :attr:`~Flask.config`, that are useful to access within views and |
| | :doc:`CLI commands </cli>`. However, importing the ``app`` instance |
| | within the modules in your project is prone to circular import issues. |
| | When using the :doc:`app factory pattern </patterns/appfactories>` or |
| | writing reusable :doc:`blueprints </blueprints>` or |
| | :doc:`extensions </extensions>` there won't be an ``app`` instance to |
| | import at all. |
| |
|
| | Flask solves this issue with the *application context*. Rather than |
| | referring to an ``app`` directly, you use the :data:`current_app` |
| | proxy, which points to the application handling the current activity. |
| |
|
| | Flask automatically *pushes* an application context when handling a |
| | request. View functions, error handlers, and other functions that run |
| | during a request will have access to :data:`current_app`. |
| |
|
| | Flask will also automatically push an app context when running CLI |
| | commands registered with :attr:`Flask.cli` using ``@app.cli.command()``. |
| |
|
| |
|
| | Lifetime of the Context |
| | ----------------------- |
| |
|
| | The application context is created and destroyed as necessary. When a |
| | Flask application begins handling a request, it pushes an application |
| | context and a :doc:`request context </reqcontext>`. When the request |
| | ends it pops the request context then the application context. |
| | Typically, an application context will have the same lifetime as a |
| | request. |
| |
|
| | See :doc:`/reqcontext` for more information about how the contexts work |
| | and the full life cycle of a request. |
| |
|
| |
|
| | Manually Push a Context |
| | ----------------------- |
| |
|
| | If you try to access :data:`current_app`, or anything that uses it, |
| | outside an application context, you'll get this error message: |
| |
|
| | .. code-block:: pytb |
| |
|
| | RuntimeError: Working outside of application context. |
| |
|
| | This typically means that you attempted to use functionality that |
| | needed to interface with the current application object in some way. |
| | To solve this, set up an application context with app.app_context(). |
| |
|
| | If you see that error while configuring your application, such as when |
| | initializing an extension, you can push a context manually since you |
| | have direct access to the ``app``. Use :meth:`~Flask.app_context` in a |
| | ``with`` block, and everything that runs in the block will have access |
| | to :data:`current_app`. :: |
| |
|
| | def create_app(): |
| | app = Flask(__name__) |
| |
|
| | with app.app_context(): |
| | init_db() |
| |
|
| | return app |
| |
|
| | If you see that error somewhere else in your code not related to |
| | configuring the application, it most likely indicates that you should |
| | move that code into a view function or CLI command. |
| |
|
| |
|
| | Storing Data |
| | ------------ |
| |
|
| | The application context is a good place to store common data during a |
| | request or CLI command. Flask provides the :data:`g object <g>` for this |
| | purpose. It is a simple namespace object that has the same lifetime as |
| | an application context. |
| |
|
| | .. note:: |
| | The ``g`` name stands for "global", but that is referring to the |
| | data being global *within a context*. The data on ``g`` is lost |
| | after the context ends, and it is not an appropriate place to store |
| | data between requests. Use the :data:`session` or a database to |
| | store data across requests. |
| |
|
| | A common use for :data:`g` is to manage resources during a request. |
| |
|
| | 1. ``get_X()`` creates resource ``X`` if it does not exist, caching it |
| | as ``g.X``. |
| | 2. ``teardown_X()`` closes or otherwise deallocates the resource if it |
| | exists. It is registered as a :meth:`~Flask.teardown_appcontext` |
| | handler. |
| |
|
| | For example, you can manage a database connection using this pattern:: |
| | |
| | from flask import g |
| |
|
| | def get_db(): |
| | if 'db' not in g: |
| | g.db = connect_to_database() |
| |
|
| | return g.db |
| |
|
| | @app.teardown_appcontext |
| | def teardown_db(exception): |
| | db = g.pop('db', None) |
| |
|
| | if db is not None: |
| | db.close() |
| |
|
| | During a request, every call to ``get_db()`` will return the same |
| | connection, and it will be closed automatically at the end of the |
| | request. |
| |
|
| | You can use :class:`~werkzeug.local.LocalProxy` to make a new context |
| | local from ``get_db()``:: |
| | |
| | from werkzeug.local import LocalProxy |
| | db = LocalProxy(get_db) |
| |
|
| | Accessing ``db`` will call ``get_db`` internally, in the same way that |
| | :data:`current_app` works. |
| |
|
| | ---- |
| | |
| | If you're writing an extension, :data:`g` should be reserved for user |
| | code. You may store internal data on the context itself, but be sure to |
| | use a sufficiently unique name. The current context is accessed with |
| | :data:`_app_ctx_stack.top <_app_ctx_stack>`. For more information see |
| | :doc:`/extensiondev`. |
| | |
| | |
| | Events and Signals |
| | ------------------ |
| |
|
| | The application will call functions registered with |
| | :meth:`~Flask.teardown_appcontext` when the application context is |
| | popped. |
| |
|
| | If :data:`~signals.signals_available` is true, the following signals are |
| | sent: :data:`appcontext_pushed`, :data:`appcontext_tearing_down`, and |
| | :data:`appcontext_popped`. |
| |
|
