Quart Documentation

Quart is an asynchronous (asyncio) Python web microframework designed for high-performance web applications. It is an asyncio reimplementation of the Flask API, meaning developers familiar with Flask can easily transition to Quart.

Key capabilities include:

• Writing JSON APIs (RESTful).
• Rendering and serving HTML.
• Serving WebSockets (e.g., for chat servers).
• Streaming responses (e.g., for video).
• Supporting both asynchronous (asyncio) and synchronous libraries/code.

Quart has a variety of community-maintained extensions for common tasks such as authentication, database management, API documentation, and more. Notable extensions include:

• Authentication & Security: Quart-Auth (cookie sessions), Quart-Login (Flask-Login port), Quart-Keycloak (OIDC), Quart-WTF (WTForms & CSRF), Quart-Enciphers (encrypted cookies), and Quart-Rate-Limiter.
• Databases & Caching: Quart-DB (PostgreSQL), Quart-Mongo / Quart-Motor (MongoDB), Quart-SqlAlchemy (SQLAlchemy wrapper), and Quart-Redis.
• API & Validation: Quart-OpenApi, Quart-Rapidoc (OpenAPI docs), Quart-Schema (validation), and Webargs-Quart (parsing).
• Utilities: Quart-Babel (i18n), Quart-compress / Quart-compress2 (gzip), Quart-CORS (CORS support), Quart-minify (HTML/JS/CSS minification), and Quart-Uploads (file uploads).

Quart uses two primary contexts to resolve global proxies like current_app and request: the Application Context and the Request Context.

• Application Context: Provides access to information not specific to a single request, such as the application instance itself, the g global object, and an app-bound url_adapter. It is implicitly created and destroyed by the request context.
• Request Context: Provides access to request-specific information, including the request object, a request-bound url_adapter, and the session. It is created and destroyed per request by Quart.handle_request.

Best Practice: Because these contexts are accessed via global proxies, it is recommended to use them only within routes to isolate their scope and avoid issues with global variable arguments.

Quart's background task API follows the pattern used by Sanic and Starlette, where you provide a callable and its arguments.

Key behaviors include:

• Graceful Shutdown: Quart ensures that background tasks are completed during the application shutdown process (provided the server does not time out and cancel them first).
• Error Isolation: Errors raised within a background task are logged but do not crash the application. The task is treated similarly to request or websocket handling errors, allowing the rest of the app to continue running.

Quart is an async Python web application framework. You can use it to render HTML templates, write RESTful JSON APIs, serve WebSockets, and stream request/response data.

To run a Quart application, use the quart run command.

from quart import Quart, render_template, websocket

app = Quart(__name__)

@app.route("/")
async def hello():
    return await render_template("index.html")

@app.route("/api")
async def json():
    return {"hello": "world"}

@app.websocket("/ws")
async def ws():
    while True:
        await websocket.send("hello")
        await websocket.send_json({"hello": "world"})

To run the application:

$ quart run

Initialize a Quart app in your package's __init__.py. You can define a run() function to start the server.

To make the app easily runnable via Poetry, add a script entry to your pyproject.toml:

[tool.poetry.scripts]
start = "video:run"

Then start the application using: poetry run start.

from quart import Quart

app = Quart(__name__)

def run() -> None:
    app.run()

By default, Quart session cookies are not permanent and are deleted when the browser session ends. To make cookies permanent, you must set session.permanent = True when the session is modified.

To make all sessions permanent by default for your application, use a @app.before_request handler.

@app.before_request
def make_session_permanent():
    session.permanent = True

Quart applies default timeouts to protect against DoS attacks, which can prematurely close long-running or indefinite streams. To allow a specific stream to run indefinitely, use make_response to create the response object and set its timeout attribute to None.

from quart import make_response

@app.route('/sse')
async def stream_time():
    ...
    response = await make_response(async_generator())
    response.timeout = None  # No timeout for this route
    return response

Replace imports from the flask package with imports from the quart package. Most imported objects retain their original names.

Flask Example:

from flask import Flask, g, request
from flask.helpers import make_response

Quart Equivalent:

from quart import Quart, g, request
from quart.helpers import make_response