feat: add iterable providers

[fadedDexofan]

Added support for Iterable providers. This makes it possible to register multiple implementations for a single type and query them all at once.

Behaves like .NET DI equivalent
https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection#service-registration-methods

class ILogger(Protocol):
    def log(self, msg: str) -> None: ...

class ConsoleLogger(ILogger):
    ...

class FileLogger(ILogger):
    ...

class Service:
    def __init__(
        self,
        all_loggers: Sequence[ILogger],
        actual_logger: ILogger,
    ) -> None:
        self.all_loggers = all_loggers
        self.actual_logger = actual_logger

container = Container()
container.register(Scoped(ConsoleLogger, type_=ILogger))
container.register(Scoped(FileLogger, type_=ILogger))
container.register(Scoped(Service))

async with container.context() as ctx:
    service = await ctx.resolve(Service)
    assert isinstance(service.all_loggers[0], ConsoleLogger)
    assert isinstance(service.all_loggers[1], FileLogger)
    assert isinstance(service.actual_logger, FileLogger)

[fadedDexofan]

cc @nrbnlulu
With new generic types support:

class MiddlewareBase(abc.ABC, Generic[ReqT, ResT]):
    @abc.abstractmethod
    async def __call__(
        self,
        request: ReqT,
        handle: Callable[[ReqT], Awaitable[ResT]],
    ) -> ResT:
        pass

class FirstMiddleware(MiddlewareBase[ReqT, ResT]):
    async def __call__(
        self,
        request: ReqT,
        handle: Callable[[ReqT], Awaitable[ResT]],
    ) -> ResT:
        return await handle(request)

class SecondMiddleware(MiddlewareBase[ReqT, ResT]):
    async def __call__(
        self,
        request: ReqT,
        handle: Callable[[ReqT], Awaitable[ResT]],
    ) -> ResT:
        return await handle(request)

class ThirdMiddleware(MiddlewareBase[ReqT, ResT]):
    async def __call__(
        self,
        request: ReqT,
        handle: Callable[[ReqT], Awaitable[ResT]],
    ) -> ResT:
        return await handle(request)

container = Container()
container.register(
    Transient(FirstMiddleware, MiddlewareBase[str, str]),
    Transient(SecondMiddleware, MiddlewareBase[int, int]),
    Transient(ThirdMiddleware, MiddlewareBase[int, int]),
)

async with container.context() as ctx:
    instances = await ctx.resolve_iterable(MiddlewareBase[int, int])  # type: ignore[type-abstract]
    assert len(instances) == 2  # noqa: PLR2004
    assert isinstance(instances[0], SecondMiddleware)
    assert isinstance(instances[1], ThirdMiddleware)

[nrbnlulu]

does it means you can register the same provider twice?

[fadedDexofan]

does it means you can register the same provider twice?

Yes, but only with different implementations. Also there is validator for different provider lifetimes for same type. Just like in .NET DI