modern-di-flask 4.2.2

modern-di integration for Flask.

Full guide: Flask integration docs

Usage example: examples/

Installation

uv add modern-di-flask      # or: pip install modern-di-flask

Usage

Flask has no dependency-injection system of its own, so modern-di-flask pairs an @inject decorator with inert FromDI markers (there is no Depends). setup_di installs a before_request/teardown_appcontext pair that builds a per-request Scope.REQUEST child container and closes it once the request finishes. The child is also built on first use, so request hooks registered before setup_di can use it, and it is closed after every teardown_appcontext handler. Resolution is sync, also for async def views, and the child container is closed with close_sync().

import typing

from flask import Flask
from modern_di import Container, Group, Scope, providers
from modern_di_flask import FromDI, inject, setup_di


class Settings:
    def __init__(self) -> None:
        self.greeting = "hello"


class Dependencies(Group):
    settings = providers.Factory(scope=Scope.APP, creator=Settings)


app = Flask(__name__)


@app.route("/hello/<name>")
@inject
def hello(name: str, settings: typing.Annotated[Settings, FromDI(Dependencies.settings)]) -> str:
    return f"{settings.greeting}, {name}"


container = Container(groups=[Dependencies])
setup_di(app, container)
container.validate()  # optional fail-fast; must come after setup_di registers its providers

Pass auto_inject=True to setup_di to wire every registered view (app and blueprint routes alike) without a per-view @inject. It walks app.view_functions when setup_di runs, so call setup_di after all routes are registered. flask.Request is resolvable within DI via the pre-built flask_request_provider context provider.

A streamed response (a generator body, with or without stream_with_context) keeps the child container open until the response is closed, which a WSGI server does after sending the body. A stream_with_context generator can resolve from it, and dependencies resolved in the view stay usable while the body streams. A direct_passthrough response, such as one from send_file, is not closed through Flask, so its child container closes at teardown as usual.

async def views work with @inject and with auto_inject=True. Flask runs them through asgiref, so install Flask's async extra (pip install "flask[async]"). The markers are resolved from the request's child container before the view is awaited. Teardown is sync: the child container is closed with close_sync(), so a Scope.REQUEST provider with an async finalizer is not supported and fails when the request ends. The same applies to the root container at shutdown: if an APP-scoped provider has an async finalizer, close the root with asyncio.run(fetch_di_container(app).close_async()) instead of close_sync().

A container is open from construction. To fail fast at boot, call .validate() after setup_di, which registers flask_request_provider. Flask has no shutdown hook, so call fetch_di_container(app).close_sync() at process shutdown.

API

📦 PyPI

📝 License

Part of modern-python

Built on modern-di, a dependency-injection framework with an IoC container and scopes.

Browse the full list of templates and libraries in modern-python; the org profile has the categorized index.