Circular Imports

[JCHacking]

Good morning, I had a question about my application design and the use of that_depends.

If I have the following files (Simplify example):

# main.py
import asyncio

from container import Container
from customer_container import CustomerContainer


async def main() -> None:
    try:
        CustomerContainer.connect_containers(Container)

        await Container.init_resources()
        await CustomerContainer.init_resources()

        # START
    finally:
        await CustomerContainer.tear_down()
        await Container.tear_down()


if __name__ == "__main__":
    asyncio.run(main())

# container.py
from that_depends import container, providers


class Container(container.BaseContainer):
    settings = providers.Singleton(...)

    engine = providers.Resource(..., settings=settings.cast)
    session = providers.ContextResource(..., engine=engine.cast)

    rest_app = providers.Singleton(..., settings=settings.cast)
    rest_server = providers.Singleton(..., app=rest_app.cast)

# customer_container.py
from that_depends import container, providers

from container import Container


class CustomerContainer(container.BaseContainer):
    repository = providers.Factory(..., session=Container.session)

    get_customers = providers.Factory(..., repository=repository.cast)

A circular import is generated, because when importing CustomerContainer, it needs to import Container, and Container needs to import CustomerContainer.

The idea I had was to have one container per feature, and then the generic container with the engine, session, settings, etc. and before starting the server initialize all of them.
As I see in the documentation it is mentioned that starting CustomerContainer will start Container, but for multiples will it work? This would generate several singletons in each container?
Wouldn't it be better to approach a container inside a container as a dependency-injector with providers.Container?

Am I doing something wrong? How can I avoid this Circular import problem?
Thanks!!!

[lesnik512]

Hi, @JCHacking )

1. You can call init_resources and tear_down on base container and it will call it automatically for connected containers
2. I don't see why Container needs to import CustomerContainer
3. If you have generic container and several containers which connect this generic container, you need to call init and tear_down on each container except the generic one.
4. Singletons and resources of generic container will be shared between all containers

P.S. I'm personally using one container for all application and this works well and its easy to manage. We have big containers with 50+ dependencies

[JCHacking]

Hi @lesnik512

Thank you for your response!!
I think I have explained myself badly

The structure of my code is this:

context
    customer 
        application
        domain
        infrastructure
        __init__.py
        container.py
rest
   v1
      customer
         __init__.py
        router.py
      __init__.py
      main.py
   __init__.py
   main.py
__init__.py
main.py
container.py

And this is the high-level flow of my code:

• And this is the high-level flow of my code:
• This run() function is used to run the different services such as the rest server api, grpc server, etc.
• To get them, I get them from container.py, since the container is in charge of creating the objects with the necessary dependencies.
• This container, when creating the fastapi app, imports it from rest/init.py, which in turn gets it from rest/main.py.
• That app includes the different versions of my api, obtained from rest/v1/init.py that are imported from rest/v1/main.py.
• That app includes the routers from rest/v1/customer/init.py which is imported from rest/v1/customer/main.py.
• This router imports with FastAPI and depends on context dependency containers as needed by the use cases. These are exposed in context/customer/init.py
• This router imports with FastAPI and depends on context dependency containers as needed by the use cases. These are obtained from context/customer/init.py which exposes CustomerContainer.py

As for run() I need to import both Container and CustomerContainer, that's when I get that circular import.
Because:

• run() import Container
• Container import rest app
• rest app eventually imports CustomerContainer
• CustomerContainer needs Container to reference the SQLAlchemy engine.
• Container needs to import rest app
• rest app needs CustomerContainer
• ...

It is probably a problem of my structure, or how I manage the creation of the rest server or rest app.

I have tested and got it working if I exclude the responsibility of creating rest_app and rest_server from container.py.