Interop with FastAPI

[strangemonad]

Thanks for this awesome project!

I know the main goal is actually to provide a stand-alone alternative but I'm curious if there's a way (or plans) to support interoperability with the FastAPI dependency system.

The main use case I can think of is the following:

• In a larger code base, I want to be able to create some libraries that can be re-used in different contexts. E.g. a db package with connection pool setup dependencies. Sometimes that might be included in a fastapi app, other times a fast-stream app, other times a cli tool. I would like to be able to share the dependency configuration.
• This is similar in spirit to how the guice or dagger dependency frameworks on the jvm allow you to create DI modules that can be composed and included (e.g. in a Spring boot or Jetty server).

[Lancetnik]

Thanks for your feedback and ideas! I really appreciate that!
For now FastDepends provides you with just a regular FastAPI Depends and serialization feauture, so I didn't plan a FastAPI compatibility due it already has it's own functional.

Also, FastDepends is not a really Dependency Injection library, it just a DI-like tool. But I had a lot of feedback and ideas about making FastDepends truly Dependency Injection system, so I have a big plan on it!

For now, I want to finish with FastStream reworking and improvements, then I am planning to refactor FastDepends as well to make it compatible-with-everything tool. But, it is not nearest future plans, sorry.

[strangemonad]

@Lancetnik I think that order or priorities makes sense

[Poogles]

Is there any movement on this? Do you have a roadmap of what you might want to do so others can take bites of it?

[Lancetnik]

I'm still not sure what this request is about

[mads-bisgaard]

I use FastAPI a lot and I have also been wishing for interoperability between FastDepends and FastAPI. I imagine this working by having a special decorator, say inject_fastapi, and a function, say Provide, such that I could write my FastAPI endpoints as follows

from fastapi import FastAPI, Request
from fast_depends import inject_fastapi, Provide

app = FastAPI


async def get_bar(request: Request):
    # extract bar from request
    return bar

@app.post("/v1/foo")
@inject_fastapi
async def foo_handler(
    request: Request,
    bar: Annotated[Bar, Provide[get_bar]]
):

The key points would be that

• inject_fastapi would ensure that FastAPI doesn't detect bar as a Body, Header or Query parameter
• Together inject_fastapi and Provide would ensure that bar is provided to functions which are deeper inside the service layer of the app, within the context of the request.

With this in place, my service could be exposed in two different APIs, implemented using FastAPI and FastStream but share a single dependency injection tool so I could inject dependencies deeper into the service layer.