Dynamic dependencies

[Tishka17]

Create something depending on, at least, request data

[Tishka17]

Need to add a way to understand what dependencies can be accessed during dynamic selection

[Skorpyon]

import abc
import asyncio
from dishka import Provider, provide, Scope, make_async_container


class DepMeta(abc.ABCMeta):
    registered_deps: list[type] = []

    def __new__(mcs, *args, **kwargs) -> type:
        dep_class = super().__new__(mcs, *args, **kwargs)
        DepMeta.registered_deps.append(dep_class)
        return dep_class


class AbstractDep(metaclass=DepMeta):
    def __init__(self):
        self.dep_id = id(self)

    def __str__(self) -> str:
        return f'{self.__class__.__name__}({self.dep_id})'


class Dependency1(AbstractDep):
    ...


class Dependency2(AbstractDep):
    ...


class Dependency3(AbstractDep):
    ...


class MyProvider(Provider):
    def __init__(self, scope=None):
        super().__init__(scope)

        for dep in DepMeta.registered_deps:
            setattr(self, str(dep.__name__), provide(dep, scope=Scope.REQUEST))

        self._init_dependency_sources()


async def main():
    async with make_async_container(MyProvider()) as app_container:
        async with app_container() as container:
            print(await container.get(Dependency1))
            print(await container.get(Dependency2))
            print(await container.get(Dependency3))

        async with app_container() as container:
            print(await container.get(Dependency1))
            print(await container.get(Dependency2))
            print(await container.get(Dependency3))


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

Right now the only way is do some like that. It may be very useful for automated dependencies registration, such Repositories, Services that collected in AbstractRegistryMetadata etc.

[Tishka17]

@Skorpyon I guess this will help: #61
It is not released but I hope to do it pretty soon

[Tishka17]

Version 0.4.0 released

[Skorpyon]

Absolutely amazing.

[Tishka17]

As an Idea for dynamic dependencies: dynamic alias

@alias(provides=MyProto)
def foo(self, request: Request) -> Type[TypeA] | Type[TypeB]:
   if ...:
      return TypeA
   else:
      return TypeB

It will work the same as:

@provide
def foo(self, request: Request, container: Container) -> MyProto:
   if ...:
      return container.get(TypeA)
   else:
      return container.get(TypeB)

We can use return type annotations for graph validation

[Tishka17]

Another idea:

@provide
def xxx(self, a: Deferred[XxxA], b: Deferred[XxxB], r: Request) -> XxxProto:
    if r.something:
       return a.ensure()
    else:
       return b.ensure()