DI LSP #144

Activity

1. xelandernt

   added

   questionFurther information is requestedFurther information is requested

   on Jan 14, 2025
2. xelandernt commented on Jan 15, 2025

   

   xelandernt

   on Jan 15, 2025

   Collaborator

   More actions

   Hi @felippemr, thank you for sharing this!

   Currently, that_depends supports injection primarily through an IOC container.
   This means that in my average case, my code looks something like this:

   # mymodule.py
   @inject
   async def create_item(session: AsyncSession = Provide[Container.session]):
       ...

   Thus, I specify explicitly the provider that then injects the dependency.

   # container.py
   class Container(BaseContainer):
       config = providers.Singleton(Config)
       session = providers.ContextResource(create_async_session, config=config)

   And finally, the functions/classes that actually generate the dependencies:

   # deps.py
   from pydantic_settings import BaseSettings
   class Config(BaseSettings):
        host: str
        port: str
   
   async def create_async_session(config: Config):
       # creates an async sqlalchemy session 
       ....

   You can also see a pretty good example for this in the fastapi template.

   Thus, in my average case, getting to the implementation is just 2 "go to implementation" (for example Ctrl + B in Pycharm) away (without having multiple options to select from).

   Now that_depends technically supports resolution by name using Container.resolve() in which case your tool would be more useful.

   In general, in the current state of the project, I am not sure if a tool like you suggests would be too useful, but I can see it being more relevant as the project grows. Currently, the resolution framework of that_depends is just pretty simple and thus easy to follow.

   This is my personal opinion, it is likely someone else has a different one.

   👍React with 👍1Reacted by Felippe da Motta Raposo
3. xelandernt

   converted this issue into a discussion #145 on Jan 15, 2025