Is That-Depends could be used in a Library?

Hey mates, On the main page it's said that this lib is good to switch from dependency-injector so I'm hyped already. But can this library help with wiring FastAPI routers which are defined in a library and should be used eventually in a customer application code?

To elaborate a bit more about my particular example (which fails with other DI libraries):

I want to make a library with some REST API routers for FastAPI application and with some DI bindings to pre-configured so my routers will receive my services:

Here is the LoggignContainer where I have logging-related dependencies:

class LoggingContainer(containers.DeclarativeContainer):

    logger = providers.Singleton(MyLogger)

And here is a main BaseContainer where I aggregated all smaller containers from my library, it then can be used in the client code to register (for me) and access (for client) my services if needed:

class BaseContainer(containers.DeclarativeContainer):

    app = providers.Container(AppContainer)

    logging = providers.Container(LoggingContainer)

    web_api = providers.Container(WebApiContainer, app=app, logging=logging)

Here is my library router which should automate some work, very simple one and which uses services registred in IoC Contaier from my lib, specifically my logger:

router = APIRouter()

tag = "Ping"

@router.get("/ping", tags=[tag], status_code=status.HTTP_200_OK)

@inject

async def ping_async(logger: Logger = Depends(Provide[LoggingContainer.logger])):

    logger.trace("Ping")

    return

In a client code some steps should be done, firstly a client Container to be defined, it has it's own application-related dependencies + inherits from my BaseContainer:

class AppContainer(BaseContainer):

    hello_world_service = providers.Factory(HelloWorldService) <- some application related registration

Now client code need to register the library router (typical registration via FastAPI methods) + wire the router :

if __name__ == "__main__":

    container = Container()

    ... here happens FastAPI code and registration of router there ....

    container.wire(modules=[ping_router])

    container.wire(modules=[__name__])

    configure_services()

    run_app()

My expectations are Logger from my library will be injected in my router but the results is: "AttributeError: 'Provide' object has no attribute logger"

I tried many combinations and changed code many ways but unless I directly use AppContainer in my library code (what is impossible to expect beyond local examples and testing since I can not know what is App level container in advance) wiring doesn't work

So now I started to check you examples and in the FastAPI example I see such lines of code:

@ROUTER.get("/decks/")
async def list_decks(
    decks_repo: DecksRepository = fastapi.Depends(ioc.IOCContainer.decks_repo),
) -> schemas.Decks:
    objects = await decks_repo.all()
    return typing.cast(schemas.Decks, {"items": objects})

Where ioc.IOCContainer.decks_repo is a reference to the container in the application code and I decided to ask in advance.

Is it possible in your lib to:

Define a library Container that will be used or inherited by the Client specific container
Wire client and library modules with Client Container
And happily use dependencies from library container in library code not knowing about client-level Container in advance?

Thank you 🙂

modern-python / that-depends

Is That-Depends could be used in a Library? #50