Dependencies in lifespan

[notpushkin]

Here's a hacky way to use dependencies in a lifespan function:

from contextlib import AsyncExitStack, asynccontextmanager
from fastapi import FastAPI, Request
from fastapi.dependencies.utils import get_dependant, solve_dependencies

def solve_lifespan(lifespan):
    @asynccontextmanager
    async def _solve_lifespan(app: FastAPI):
        # A fake request for solve_dependencies
        request = Request(scope={
            "type": "http",
            "http_version": "1.1",
            "method": "GET",
            "scheme": "http",
            "path": "/",
            "raw_path": b"/",
            "query_string": b"",
            "root_path": "",
            "headers": (
                (b"X-Request-Scope", b"lifespan"),
            ),
            "client": ("localhost", 80),
            "server": ("localhost", 80),
            "state": app.state,
        })
        dependant = get_dependant(path="/", call=lifespan)
        
        async with AsyncExitStack() as async_exit_stack:
            solved_deps, *_ = await solve_dependencies(
                request=request,
                dependant=dependant,
                async_exit_stack=async_exit_stack,
            )
        
            ctxmgr = asynccontextmanager(lifespan)
            async with ctxmgr(app, **solved_deps) as value:
                yield value

    return _solve_lifespan

async def get_database_url():
    """
    Example dependency. In a real app this could e.g. connect to a DB.
    """

    yield "postgres://"

@solve_lifespan
async def lifespan(database_url: Annotated[str, Depends(get_database_url)]):
    """
    Example lifespan using the dependency.
    In a real app this could do something like ``SQLModel.metadata.create_all()``.
    """
    print("database_url:", database_url)

    yield


app = FastAPI(lifespan=lifespan)

This could be done in a more appropriate way by introducing a new request type with scope["type"] == "lifespan" and skipping params which don't make sense in the lifecycle method (i.e. don't try to parse fields from path, etc.) Not sure if it's worth the effort but I think it will fit FastAPI's API design better than just exposing Starlette's lifecycle implementation!

[carlosdavila91]

It looks like the database_url type in the lifespan method should be Annotated[str, Depends(get_database_url)], is it?

[notpushkin]

Yeah, sorry, mixed up when simplifying the example. I'll update the code, thanks!

[Tishka17]

I do not think we should implement this straightforward without conceptions of lifetime Scopes. Created objects are now cached within span of single event. But, there were no nested spans. All requests are processed during single life span, I believe that they should share cache. At the same time we do not have to create a dependency per-message in websocket - we have a single object per whole connection. So, from my point of view - there should be some objects that are created once per app, others - once per websocket, rest - once per message/request. Thay can depende on each other. I have this implemented in dishka but the idea can be adopted.

The other point here is that lifespan is actually the whole application lifetime. What is injected here will be finalized only on termination. Opposite to this were on_srtartup (and on_shutdown) event, where you could release dependency in the end of startup process, not the end of application. I'd love to have both techniques available together.