python-injection 0.11.0__tar.gz → 0.12.0__tar.gz

{python_injection-0.11.0 → python_injection-0.12.0}/PKG-INFO

@@ -1,26 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-injection
-Version: 0.11.0
+Version: 0.12.0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
 Keywords: dependencies,dependency,inject,injection
 Author: remimd
-Requires-Python: >=3.12,<4
+Requires-Python: >=3.12, <4
 Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Natural Language :: English
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
 Classifier: Typing :: Typed
 Project-URL: Repository, https://github.com/100nm/python-injection
 Description-Content-Type: text/markdown

{python_injection-0.11.0 → python_injection-0.12.0}/injection/__init__.py

@@ -1,5 +1,6 @@
 from ._core.descriptors import LazyInstance
-from ._core.module import Injectable, Mode, Module, Priority
+from ._core.injectables import Injectable
+from ._core.module import Mode, Module, Priority, mod
 
 __all__ = (
     "Injectable",
@@ -7,6 +8,9 @@ __all__ = (
     "Mode",
     "Module",
     "Priority",
+    "afind_instance",
+    "aget_instance",
+    "aget_lazy_instance",
     "constant",
     "find_instance",
     "get_instance",
@@ -19,14 +23,9 @@ __all__ = (
     "singleton",
 )
 
-
-def mod(name: str | None = None, /) -> Module:
-    if name is None:
-        return Module.default()
-
-    return Module.from_name(name)
-
-
+afind_instance = mod().afind_instance
+aget_instance = mod().aget_instance
+aget_lazy_instance = mod().aget_lazy_instance
 constant = mod().constant
 find_instance = mod().find_instance
 get_instance = mod().get_instance

{python_injection-0.11.0 → python_injection-0.12.0}/injection/__init__.pyi

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from contextlib import ContextDecorator
 from enum import Enum
 from logging import Logger
@@ -21,6 +21,9 @@ from ._core.module import ModeStr, PriorityStr
 
 _: Module = ...
 
+afind_instance = _.afind_instance
+aget_instance = _.aget_instance
+aget_lazy_instance = _.aget_lazy_instance
 constant = _.constant
 find_instance = _.find_instance
 get_instance = _.get_instance
@@ -53,59 +56,59 @@ class Module:
     def __contains__(self, cls: _InputType[Any], /) -> bool: ...
     @property
     def is_locked(self) -> bool: ...
-    def inject[**P, T](self, wrapped: Callable[P, T] = ..., /):  # type: ignore[no-untyped-def]
+    def inject[**P, T](self, wrapped: Callable[P, T] = ..., /) -> Any:
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
         will be those of the `__init__` method.
         """
 
-    def injectable[**P, T](  # type: ignore[no-untyped-def]
+    def injectable[**P, T](
         self,
-        wrapped: Callable[P, T] = ...,
+        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] = ...,
         /,
         *,
         cls: _InjectableFactory[T] = ...,
         inject: bool = ...,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ):
+    ) -> Any:
         """
         Decorator applicable to a class or function. It is used to indicate how the
         injectable will be constructed. At injection time, a new instance will be
         injected each time.
         """
 
-    def singleton[**P, T](  # type: ignore[no-untyped-def]
+    def singleton[**P, T](
         self,
-        wrapped: Callable[P, T] = ...,
+        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] = ...,
         /,
         *,
         inject: bool = ...,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ):
+    ) -> Any:
         """
         Decorator applicable to a class or function. It is used to indicate how the
         singleton will be constructed. At injection time, the injected instance will
         always be the same.
         """
 
-    def should_be_injectable[T](self, wrapped: type[T] = ..., /):  # type: ignore[no-untyped-def]
+    def should_be_injectable[T](self, wrapped: type[T] = ..., /) -> Any:
         """
         Decorator applicable to a class. It is used to specify whether an injectable
         should be registered. Raise an exception at injection time if the class isn't
         registered.
         """
 
-    def constant[T](  # type: ignore[no-untyped-def]
+    def constant[T](
         self,
         wrapped: type[T] = ...,
         /,
         *,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ):
+    ) -> Any:
         """
         Decorator applicable to a class or function. It is used to indicate how the
         constant is constructed. At injection time, the injected instance will always
@@ -131,12 +134,25 @@ class Module:
         wrapped: Callable[P, T],
         /,
     ) -> Callable[P, T]: ...
+    async def afind_instance[T](self, cls: _InputType[T]) -> T: ...
     def find_instance[T](self, cls: _InputType[T]) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
         """
 
+    @overload
+    async def aget_instance[T, Default](
+        self,
+        cls: _InputType[T],
+        default: Default,
+    ) -> T | Default: ...
+    @overload
+    async def aget_instance[T](
+        self,
+        cls: _InputType[T],
+        default: None = ...,
+    ) -> T | None: ...
     @overload
     def get_instance[T, Default](
         self,
@@ -149,12 +165,28 @@ class Module:
         """
 
     @overload
-    def get_instance[T, _](
+    def get_instance[T](
         self,
         cls: _InputType[T],
         default: None = ...,
     ) -> T | None: ...
     @overload
+    def aget_lazy_instance[T, Default](
+        self,
+        cls: _InputType[T],
+        default: Default,
+        *,
+        cache: bool = ...,
+    ) -> Awaitable[T | Default]: ...
+    @overload
+    def aget_lazy_instance[T](
+        self,
+        cls: _InputType[T],
+        default: None = ...,
+        *,
+        cache: bool = ...,
+    ) -> Awaitable[T | None]: ...
+    @overload
     def get_lazy_instance[T, Default](
         self,
         cls: _InputType[T],
@@ -172,7 +204,7 @@ class Module:
         """
 
     @overload
-    def get_lazy_instance[T, _](
+    def get_lazy_instance[T](
         self,
         cls: _InputType[T],
         default: None = ...,
@@ -229,6 +261,7 @@ class Module:
         Function to unlock the module by deleting cached instances of singletons.
         """
 
+    async def all_ready(self) -> None: ...
     def add_logger(self, logger: Logger) -> Self: ...
     @classmethod
     def from_name(cls, name: str) -> Module:
@@ -253,6 +286,8 @@ class Injectable[T](Protocol):
     def is_locked(self) -> bool: ...
     def unlock(self) -> None: ...
     @abstractmethod
+    async def aget_instance(self) -> T: ...
+    @abstractmethod
     def get_instance(self) -> T: ...
 
 @final

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/__init__.py

@@ -49,5 +49,5 @@ def standardize_input_classes[T](
 @Locator.static_hooks.on_update
 def standardize_classes[T](*_: Any, **__: Any) -> HookGenerator[Updater[T]]:
     updater = yield
-    updater.classes = set(standardize_types(*updater.classes))
+    updater.classes = frozenset(standardize_types(*updater.classes))
     return updater

python_injection-0.12.0/injection/_core/common/asynchronous.py

@@ -0,0 +1,54 @@
+from abc import abstractmethod
+from collections.abc import Awaitable, Callable, Generator
+from dataclasses import dataclass
+from typing import Any, NoReturn, Protocol, override, runtime_checkable
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class SimpleAwaitable[T](Awaitable[T]):
+    callable: Callable[..., Awaitable[T]]
+
+    @override
+    def __await__(self) -> Generator[Any, Any, T]:
+        return self.callable().__await__()
+
+
+@runtime_checkable
+class Caller[**P, T](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class AsyncCaller[**P, T](Caller[P, T]):
+    callable: Callable[P, Awaitable[T]]
+
+    @override
+    async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return await self.callable(*args, **kwargs)
+
+    @override
+    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> NoReturn:
+        raise RuntimeError(
+            "Synchronous call isn't supported for an asynchronous Callable."
+        )
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class SyncCaller[**P, T](Caller[P, T]):
+    callable: Callable[P, T]
+
+    @override
+    async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self.callable(*args, **kwargs)
+
+    @override
+    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self.callable(*args, **kwargs)

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/common/invertible.py

@@ -13,8 +13,8 @@ class Invertible[T](Protocol):
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class SimpleInvertible[T](Invertible[T]):
-    getter: Callable[..., T]
+    callable: Callable[..., T]
 
     @override
     def __invert__(self) -> T:
-        return self.getter()
+        return self.callable()

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/common/type.py

@@ -1,5 +1,5 @@
-from collections.abc import Awaitable, Callable, Iterable, Iterator
-from inspect import iscoroutinefunction, isfunction
+from collections.abc import Callable, Iterable, Iterator
+from inspect import isfunction
 from types import GenericAlias, UnionType
 from typing import (
     Annotated,
@@ -24,9 +24,6 @@ def get_return_types(*args: TypeInfo[Any]) -> Iterator[InputType[Any]]:
             inner_args = arg
 
         elif isfunction(arg) and (return_type := get_type_hints(arg).get("return")):
-            if iscoroutinefunction(arg):
-                return_type = Awaitable[return_type]  # type: ignore[valid-type]
-
             inner_args = (return_type,)
 
         else:

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/descriptors.py

@@ -2,7 +2,7 @@ from typing import Self
 
 from injection._core.common.invertible import Invertible
 from injection._core.common.type import InputType
-from injection._core.module import Module
+from injection._core.module import Module, mod
 
 
 class LazyInstance[T]:
@@ -11,8 +11,8 @@ class LazyInstance[T]:
     __value: Invertible[T]
 
     def __init__(self, cls: InputType[T], module: Module | None = None) -> None:
-        module = module or Module.default()
-        self.__value = module.get_lazy_instance(cls, default=NotImplemented)  # type: ignore[assignment]
+        module = module or mod()
+        self.__value = module.get_lazy_instance(cls, default=NotImplemented)
 
     def __get__(
         self,

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/hook.py

@@ -2,12 +2,13 @@ import itertools
 from collections.abc import Callable, Generator, Iterator
 from dataclasses import dataclass, field
 from inspect import isclass, isgeneratorfunction
-from typing import Any, Self
+from typing import Any, Self, TypeGuard
 
 from injection.exceptions import HookError
 
 type HookGenerator[T] = Generator[None, T, T]
-type HookFunction[**P, T] = Callable[P, T | HookGenerator[T]]
+type HookGeneratorFunction[**P, T] = Callable[P, HookGenerator[T]]
+type HookFunction[**P, T] = Callable[P, T] | HookGeneratorFunction[P, T]
 
 
 @dataclass(eq=False, frozen=True, slots=True)
@@ -18,12 +19,12 @@ class Hook[**P, T]:
         repr=False,
     )
 
-    def __call__(  # type: ignore[no-untyped-def]
+    def __call__(
         self,
         wrapped: HookFunction[P, T] | type[HookFunction[P, T]] | None = None,
         /,
-    ):
-        def decorator(wp):  # type: ignore[no-untyped-def]
+    ) -> Any:
+        def decorator(wp: Any) -> Any:
             self.add(wp() if isclass(wp) else wp)
             return wp
 
@@ -48,11 +49,11 @@ class Hook[**P, T]:
         handler: Callable[P, T],
         function: HookFunction[P, T],
     ) -> Callable[P, T]:
-        if not cls.__is_generator_function(function):
+        if not cls.__is_hook_generator_function(function):
             return function  # type: ignore[return-value]
 
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            hook: HookGenerator[T] = function(*args, **kwargs)  # type: ignore[assignment]
+            hook: HookGenerator[T] = function(*args, **kwargs)
 
             try:
                 next(hook)
@@ -88,9 +89,11 @@ class Hook[**P, T]:
         return handler
 
     @staticmethod
-    def __is_generator_function(obj: Any) -> bool:
-        for o in obj, getattr(obj, "__call__", None):
-            if isgeneratorfunction(o):
+    def __is_hook_generator_function[**_P, _T](
+        function: HookFunction[_P, _T],
+    ) -> TypeGuard[HookGeneratorFunction[_P, _T]]:
+        for fn in function, getattr(function, "__call__", None):
+            if isgeneratorfunction(fn):
                 return True
 
         return False

python_injection-0.12.0/injection/_core/injectables.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from collections.abc import MutableMapping
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import Any, ClassVar, NoReturn, Protocol, override, runtime_checkable
+
+from injection._core.common.asynchronous import Caller
+from injection._core.common.threading import synchronized
+from injection.exceptions import InjectionError
+
+
+@runtime_checkable
+class Injectable[T](Protocol):
+    __slots__ = ()
+
+    @property
+    def is_locked(self) -> bool:
+        return False
+
+    def unlock(self) -> None:
+        return
+
+    @abstractmethod
+    async def aget_instance(self) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_instance(self) -> T:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class BaseInjectable[T](Injectable[T], ABC):
+    factory: Caller[..., T]
+
+
+class SimpleInjectable[T](BaseInjectable[T]):
+    __slots__ = ()
+
+    @override
+    async def aget_instance(self) -> T:
+        return await self.factory.acall()
+
+    @override
+    def get_instance(self) -> T:
+        return self.factory.call()
+
+
+class SingletonInjectable[T](BaseInjectable[T]):
+    __slots__ = ("__dict__",)
+
+    __key: ClassVar[str] = "$instance"
+
+    @property
+    def cache(self) -> MutableMapping[str, Any]:
+        return self.__dict__
+
+    @property
+    @override
+    def is_locked(self) -> bool:
+        return self.__key in self.cache
+
+    @override
+    def unlock(self) -> None:
+        self.cache.clear()
+
+    @override
+    async def aget_instance(self) -> T:
+        with suppress(KeyError):
+            return self.__check_instance()
+
+        with synchronized():
+            instance = await self.factory.acall()
+            self.__set_instance(instance)
+
+        return instance
+
+    @override
+    def get_instance(self) -> T:
+        with suppress(KeyError):
+            return self.__check_instance()
+
+        with synchronized():
+            instance = self.factory.call()
+            self.__set_instance(instance)
+
+        return instance
+
+    def __check_instance(self) -> T:
+        return self.cache[self.__key]
+
+    def __set_instance(self, value: T) -> None:
+        self.cache[self.__key] = value
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class ShouldBeInjectable[T](Injectable[T]):
+    cls: type[T]
+
+    @override
+    async def aget_instance(self) -> T:
+        return self.get_instance()
+
+    @override
+    def get_instance(self) -> NoReturn:
+        raise InjectionError(f"`{self.cls}` should be an injectable.")

{python_injection-0.11.0 → python_injection-0.12.0}/injection/_core/module.py

@@ -1,21 +1,23 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 from abc import ABC, abstractmethod
 from collections import OrderedDict
 from collections.abc import (
+    AsyncIterator,
+    Awaitable,
     Callable,
     Collection,
     Iterable,
     Iterator,
     Mapping,
-    MutableMapping,
 )
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import StrEnum
 from functools import partialmethod, singledispatchmethod, update_wrapper
-from inspect import Signature, isclass
+from inspect import Signature, isclass, iscoroutinefunction
 from logging import Logger, getLogger
 from queue import Empty, Queue
 from types import MethodType
@@ -25,22 +27,34 @@ from typing import (
     ContextManager,
     Literal,
     NamedTuple,
-    NoReturn,
     Protocol,
     Self,
+    TypeGuard,
+    overload,
     override,
     runtime_checkable,
 )
 from uuid import uuid4
 
+from injection._core.common.asynchronous import (
+    AsyncCaller,
+    Caller,
+    SimpleAwaitable,
+    SyncCaller,
+)
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.lazy import Lazy, LazyMapping
 from injection._core.common.threading import synchronized
 from injection._core.common.type import InputType, TypeInfo, get_return_types
 from injection._core.hook import Hook, apply_hooks
+from injection._core.injectables import (
+    Injectable,
+    ShouldBeInjectable,
+    SimpleInjectable,
+    SingletonInjectable,
+)
 from injection.exceptions import (
-    InjectionError,
     ModuleError,
     ModuleLockError,
     ModuleNotUsedError,
@@ -129,86 +143,6 @@ class ModulePriorityUpdated(ModuleEvent):
         )
 
 
-"""
-Injectables
-"""
-
-
-@runtime_checkable
-class Injectable[T](Protocol):
-    __slots__ = ()
-
-    @property
-    def is_locked(self) -> bool:
-        return False
-
-    def unlock(self) -> None:
-        return
-
-    @abstractmethod
-    def get_instance(self) -> T:
-        raise NotImplementedError
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class BaseInjectable[T](Injectable[T], ABC):
-    factory: Callable[..., T]
-
-
-class SimpleInjectable[T](BaseInjectable[T]):
-    __slots__ = ()
-
-    @override
-    def get_instance(self) -> T:
-        return self.factory()
-
-
-class SingletonInjectable[T](BaseInjectable[T]):
-    __slots__ = ("__dict__",)
-
-    __key: ClassVar[str] = "$instance"
-
-    @property
-    def cache(self) -> MutableMapping[str, Any]:
-        return self.__dict__
-
-    @property
-    @override
-    def is_locked(self) -> bool:
-        return self.__key in self.cache
-
-    @override
-    def unlock(self) -> None:
-        self.cache.clear()
-
-    @override
-    def get_instance(self) -> T:
-        with suppress(KeyError):
-            return self.cache[self.__key]
-
-        with synchronized():
-            instance = self.factory()
-            self.cache[self.__key] = instance
-
-        return instance
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable[T](Injectable[T]):
-    cls: type[T]
-
-    @override
-    def get_instance(self) -> NoReturn:
-        raise InjectionError(f"`{self.cls}` should be an injectable.")
-
-    @classmethod
-    def from_callable(cls, callable: Callable[..., T]) -> Self:
-        if not isclass(callable):
-            raise TypeError(f"`{callable}` should be a class.")
-
-        return cls(callable)
-
-
 """
 Broker
 """
@@ -235,6 +169,10 @@ class Broker(Protocol):
     def unlock(self) -> Self:
         raise NotImplementedError
 
+    @abstractmethod
+    async def all_ready(self) -> None:
+        raise NotImplementedError
+
 
 """
 Locator
@@ -257,7 +195,7 @@ class Mode(StrEnum):
 
 type ModeStr = Literal["fallback", "normal", "override"]
 
-type InjectableFactory[T] = Callable[[Callable[..., T]], Injectable[T]]
+type InjectableFactory[T] = Callable[[Caller[..., T]], Injectable[T]]
 
 
 class Record[T](NamedTuple):
@@ -267,7 +205,7 @@ class Record[T](NamedTuple):
 
 @dataclass(repr=False, eq=False, kw_only=True, slots=True)
 class Updater[T]:
-    factory: Callable[..., T]
+    factory: Caller[..., T]
     classes: Iterable[InputType[T]]
     injectable_factory: InjectableFactory[T]
     mode: Mode
@@ -354,6 +292,11 @@ class Locator(Broker):
 
         return self
 
+    @override
+    async def all_ready(self) -> None:
+        for injectable in self.__injectables:
+            await injectable.aget_instance()
+
     def add_listener(self, listener: EventListener) -> Self:
         self.__channel.add_listener(listener)
         return self
@@ -466,18 +409,20 @@ class Module(Broker, EventListener):
         yield from tuple(self.__modules)
         yield self.__locator
 
-    def injectable[**P, T](  # type: ignore[no-untyped-def]
+    def injectable[**P, T](
         self,
-        wrapped: Callable[P, T] | None = None,
+        wrapped: Callable[P, T] | Callable[P, Awaitable[T]] | None = None,
         /,
         *,
         cls: InjectableFactory[T] = SimpleInjectable,
         inject: bool = True,
         on: TypeInfo[T] = (),
         mode: Mode | ModeStr = Mode.get_default(),
-    ):
-        def decorator(wp):  # type: ignore[no-untyped-def]
-            factory = self.make_injected_function(wp) if inject else wp
+    ) -> Any:
+        def decorator(
+            wp: Callable[P, T] | Callable[P, Awaitable[T]],
+        ) -> Callable[P, T] | Callable[P, Awaitable[T]]:
+            factory = _get_caller(self.make_injected_function(wp) if inject else wp)
             classes = get_return_types(wp, on)
             updater = Updater(
                 factory=factory,
@@ -492,12 +437,12 @@ class Module(Broker, EventListener):
 
     singleton = partialmethod(injectable, cls=SingletonInjectable)
 
-    def should_be_injectable[T](self, wrapped: type[T] | None = None, /):  # type: ignore[no-untyped-def]
-        def decorator(wp):  # type: ignore[no-untyped-def]
+    def should_be_injectable[T](self, wrapped: type[T] | None = None, /) -> Any:
+        def decorator(wp: type[T]) -> type[T]:
             updater = Updater(
-                factory=wp,
+                factory=SyncCaller(wp),
                 classes=(wp,),
-                injectable_factory=ShouldBeInjectable.from_callable,
+                injectable_factory=lambda _: ShouldBeInjectable(wp),
                 mode=Mode.FALLBACK,
             )
             self.update(updater)
@@ -505,15 +450,15 @@ class Module(Broker, EventListener):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def constant[T](  # type: ignore[no-untyped-def]
+    def constant[T](
         self,
         wrapped: type[T] | None = None,
         /,
         *,
         on: TypeInfo[T] = (),
         mode: Mode | ModeStr = Mode.get_default(),
-    ):
-        def decorator(wp):  # type: ignore[no-untyped-def]
+    ) -> Any:
+        def decorator(wp: type[T]) -> type[T]:
             lazy_instance = Lazy(wp)
             self.injectable(
                 lambda: ~lazy_instance,
@@ -545,8 +490,8 @@ class Module(Broker, EventListener):
         )
         return self
 
-    def inject[**P, T](self, wrapped: Callable[P, T] | None = None, /):  # type: ignore[no-untyped-def]
-        def decorator(wp):  # type: ignore[no-untyped-def]
+    def inject[**P, T](self, wrapped: Callable[P, T] | None = None, /) -> Any:
+        def decorator(wp: Callable[P, T]) -> Callable[P, T]:
             if isclass(wp):
                 wp.__init__ = self.inject(wp.__init__)
                 return wp
@@ -555,47 +500,135 @@ class Module(Broker, EventListener):
 
         return decorator(wrapped) if wrapped else decorator
 
+    @overload
     def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, T],
         /,
-    ) -> InjectedFunction[P, T]:
-        injected = Injected(wrapped)
+    ) -> SyncInjectedFunction[P, T]: ...
+
+    @overload
+    def make_injected_function[**P, T](
+        self,
+        wrapped: Callable[P, Awaitable[T]],
+        /,
+    ) -> AsyncInjectedFunction[P, T]: ...
+
+    def make_injected_function(self, wrapped, /):  # type: ignore[no-untyped-def]
+        metadata = InjectMetadata(wrapped)
 
-        @injected.on_setup
+        @metadata.on_setup
         def listen() -> None:
-            injected.update(self)
-            self.add_listener(injected)
+            metadata.update(self)
+            self.add_listener(metadata)
+
+        if iscoroutinefunction(wrapped):
+            return AsyncInjectedFunction(metadata)
 
-        return InjectedFunction(injected)
+        return SyncInjectedFunction(metadata)
+
+    async def afind_instance[T](self, cls: InputType[T]) -> T:
+        injectable = self[cls]
+        return await injectable.aget_instance()
 
     def find_instance[T](self, cls: InputType[T]) -> T:
         injectable = self[cls]
         return injectable.get_instance()
 
+    @overload
+    async def aget_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default,
+    ) -> T | Default: ...
+
+    @overload
+    async def aget_instance[T](
+        self,
+        cls: InputType[T],
+        default: None = ...,
+    ) -> T | None: ...
+
+    async def aget_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
+        try:
+            return await self.afind_instance(cls)
+        except KeyError:
+            return default
+
+    @overload
     def get_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
-    ) -> T | Default | None:
+        default: Default,
+    ) -> T | Default: ...
+
+    @overload
+    def get_instance[T](
+        self,
+        cls: InputType[T],
+        default: None = ...,
+    ) -> T | None: ...
+
+    def get_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
         try:
             return self.find_instance(cls)
         except KeyError:
             return default
 
+    @overload
+    def aget_lazy_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default,
+        *,
+        cache: bool = ...,
+    ) -> Awaitable[T | Default]: ...
+
+    @overload
+    def aget_lazy_instance[T](
+        self,
+        cls: InputType[T],
+        default: None = ...,
+        *,
+        cache: bool = ...,
+    ) -> Awaitable[T | None]: ...
+
+    def aget_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
+        if cache:
+            coroutine = self.aget_instance(cls, default)
+            return asyncio.ensure_future(coroutine)
+
+        function = self.make_injected_function(lambda instance=default: instance)
+        metadata = function.__inject_metadata__
+        metadata.set_owner(cls)
+        return SimpleAwaitable(metadata.acall)
+
+    @overload
     def get_lazy_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
+        default: Default,
         *,
-        cache: bool = False,
-    ) -> Invertible[T | Default | None]:
+        cache: bool = ...,
+    ) -> Invertible[T | Default]: ...
+
+    @overload
+    def get_lazy_instance[T](
+        self,
+        cls: InputType[T],
+        default: None = ...,
+        *,
+        cache: bool = ...,
+    ) -> Invertible[T | None]: ...
+
+    def get_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
         if cache:
             return Lazy(lambda: self.get_instance(cls, default))
 
-        function = self.inject(lambda instance=default: instance)
-        function.__injected__.set_owner(cls)
-        return SimpleInvertible(function)
+        function = self.make_injected_function(lambda instance=default: instance)
+        metadata = function.__inject_metadata__
+        metadata.set_owner(cls)
+        return SimpleInvertible(metadata.call)
 
     def update[T](self, updater: Updater[T]) -> Self:
         self.__locator.update(updater)
@@ -670,6 +703,11 @@ class Module(Broker, EventListener):
 
         return self
 
+    @override
+    async def all_ready(self) -> None:
+        for broker in self.__brokers:
+            await broker.all_ready()
+
     def add_logger(self, logger: Logger) -> Self:
         self.__loggers.append(logger)
         return self
@@ -730,6 +768,13 @@ class Module(Broker, EventListener):
         return cls.from_name("__default__")
 
 
+def mod(name: str | None = None, /) -> Module:
+    if name is None:
+        return Module.default()
+
+    return Module.from_name(name)
+
+
 """
 InjectedFunction
 """
@@ -744,7 +789,13 @@ class Dependencies:
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
         for name, injectable in self.mapping.items():
-            yield name, injectable.get_instance()
+            instance = injectable.get_instance()
+            yield name, instance
+
+    async def __aiter__(self) -> AsyncIterator[tuple[str, Any]]:
+        for name, injectable in self.mapping.items():
+            instance = await injectable.aget_instance()
+            yield name, instance
 
     @property
     def are_resolved(self) -> bool:
@@ -753,9 +804,11 @@ class Dependencies:
 
         return bool(self)
 
-    @property
-    def arguments(self) -> OrderedDict[str, Any]:
-        return OrderedDict(self)
+    async def aget_arguments(self) -> dict[str, Any]:
+        return {key: value async for key, value in self}
+
+    def get_arguments(self) -> dict[str, Any]:
+        return dict(self)
 
     @classmethod
     def from_mapping(cls, mapping: Mapping[str, Injectable[Any]]) -> Self:
@@ -810,7 +863,7 @@ class Arguments(NamedTuple):
     kwargs: Mapping[str, Any]
 
 
-class Injected[**P, T](EventListener):
+class InjectMetadata[**P, T](Caller[P, T], EventListener):
     __slots__ = (
         "__dependencies",
         "__owner",
@@ -831,11 +884,6 @@ class Injected[**P, T](EventListener):
         self.__setup_queue = Queue()
         self.__wrapped = wrapped
 
-    def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        self.__setup()
-        arguments = self.bind(args, kwargs)
-        return self.wrapped(*arguments.args, **arguments.kwargs)
-
     @property
     def signature(self) -> Signature:
         with suppress(AttributeError):
@@ -851,22 +899,33 @@ class Injected[**P, T](EventListener):
     def wrapped(self) -> Callable[P, T]:
         return self.__wrapped
 
+    async def abind(
+        self,
+        args: Iterable[Any] = (),
+        kwargs: Mapping[str, Any] | None = None,
+    ) -> Arguments:
+        additional_arguments = await self.__dependencies.aget_arguments()
+        return self.__bind(args, kwargs, additional_arguments)
+
     def bind(
         self,
         args: Iterable[Any] = (),
         kwargs: Mapping[str, Any] | None = None,
     ) -> Arguments:
-        if kwargs is None:
-            kwargs = {}
+        additional_arguments = self.__dependencies.get_arguments()
+        return self.__bind(args, kwargs, additional_arguments)
 
-        if not self.__dependencies:
-            return Arguments(args, kwargs)
+    @override
+    async def acall(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        self.__setup()
+        arguments = await self.abind(args, kwargs)
+        return self.wrapped(*arguments.args, **arguments.kwargs)
 
-        bound = self.signature.bind_partial(*args, **kwargs)
-        bound.arguments = (
-            bound.arguments | self.__dependencies.arguments | bound.arguments
-        )
-        return Arguments(bound.args, bound.kwargs)
+    @override
+    def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        self.__setup()
+        arguments = self.bind(args, kwargs)
+        return self.wrapped(*arguments.args, **arguments.kwargs)
 
     def set_owner(self, owner: type) -> Self:
         if self.__dependencies.are_resolved:
@@ -885,8 +944,8 @@ class Injected[**P, T](EventListener):
         self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
         return self
 
-    def on_setup[**_P, _T](self, wrapped: Callable[_P, _T] | None = None, /):  # type: ignore[no-untyped-def]
-        def decorator(wp):  # type: ignore[no-untyped-def]
+    def on_setup[**_P, _T](self, wrapped: Callable[_P, _T] | None = None, /) -> Any:
+        def decorator(wp: Callable[_P, _T]) -> Callable[_P, _T]:
             queue = self.__setup_queue
 
             if queue is None:
@@ -908,6 +967,22 @@ class Injected[**P, T](EventListener):
         yield
         self.update(event.module)
 
+    def __bind(
+        self,
+        args: Iterable[Any],
+        kwargs: Mapping[str, Any] | None,
+        additional_arguments: dict[str, Any] | None,
+    ) -> Arguments:
+        if kwargs is None:
+            kwargs = {}
+
+        if not additional_arguments:
+            return Arguments(args, kwargs)
+
+        bound = self.signature.bind_partial(*args, **kwargs)
+        bound.arguments = bound.arguments | additional_arguments | bound.arguments
+        return Arguments(bound.args, bound.kwargs)
+
     def __close_setup_queue(self) -> None:
         self.__setup_queue = None
 
@@ -930,25 +1005,26 @@ class Injected[**P, T](EventListener):
         self.__close_setup_queue()
 
 
-class InjectedFunction[**P, T]:
-    __slots__ = ("__dict__", "__injected__")
+class InjectedFunction[**P, T](ABC):
+    __slots__ = ("__dict__", "__inject_metadata__")
 
-    __injected__: Injected[P, T]
+    __inject_metadata__: InjectMetadata[P, T]
 
-    def __init__(self, injected: Injected[P, T]) -> None:
-        update_wrapper(self, injected.wrapped)
-        self.__injected__ = injected
+    def __init__(self, metadata: InjectMetadata[P, T]) -> None:
+        update_wrapper(self, metadata.wrapped)
+        self.__inject_metadata__ = metadata
 
     @override
     def __repr__(self) -> str:  # pragma: no cover
-        return repr(self.__injected__.wrapped)
+        return repr(self.__inject_metadata__.wrapped)
 
     @override
     def __str__(self) -> str:  # pragma: no cover
-        return str(self.__injected__.wrapped)
+        return str(self.__inject_metadata__.wrapped)
 
+    @abstractmethod
     def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        return self.__injected__(*args, **kwargs)
+        raise NotImplementedError
 
     def __get__(
         self,
@@ -961,4 +1037,43 @@ class InjectedFunction[**P, T]:
         return MethodType(self, instance)
 
     def __set_name__(self, owner: type, name: str) -> None:
-        self.__injected__.set_owner(owner)
+        self.__inject_metadata__.set_owner(owner)
+
+
+class AsyncInjectedFunction[**P, T](InjectedFunction[P, Awaitable[T]]):
+    __slots__ = ()
+
+    @override
+    async def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return await (await self.__inject_metadata__.acall(*args, **kwargs))
+
+
+class SyncInjectedFunction[**P, T](InjectedFunction[P, T]):
+    __slots__ = ()
+
+    @override
+    def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return self.__inject_metadata__.call(*args, **kwargs)
+
+
+def _is_coroutine_function[**P, T](
+    function: Callable[P, T] | Callable[P, Awaitable[T]],
+) -> TypeGuard[Callable[P, Awaitable[T]]]:
+    if iscoroutinefunction(function):
+        return True
+
+    elif isclass(function):
+        return False
+
+    call = getattr(function, "__call__", None)
+    return iscoroutinefunction(call)
+
+
+def _get_caller[**P, T](function: Callable[P, T]) -> Caller[P, T]:
+    if _is_coroutine_function(function):
+        return AsyncCaller(function)
+
+    elif isinstance(function, InjectedFunction):
+        return function.__inject_metadata__
+
+    return SyncCaller(function)

{python_injection-0.11.0 → python_injection-0.12.0}/injection/integrations/fastapi.py

@@ -1,4 +1,4 @@
-from collections.abc import Callable
+from collections.abc import Awaitable
 from types import GenericAlias
 from typing import Any, TypeAliasType
 
@@ -28,18 +28,29 @@ def Inject[T](  # noqa: N802
 
 
 class InjectionDependency[T]:
-    __slots__ = ("__call__", "__class", "__module")
+    __slots__ = ("__class", "__lazy_instance", "__module")
 
-    __call__: Callable[[], T]
     __class: type[T] | TypeAliasType | GenericAlias
+    __lazy_instance: Awaitable[T]
     __module: Module
 
-    def __init__(self, cls: type[T] | TypeAliasType | GenericAlias, module: Module):
-        lazy_instance = module.get_lazy_instance(cls, default=NotImplemented)
-        self.__call__ = lambda: self.__ensure(~lazy_instance)
+    def __init__(
+        self,
+        cls: type[T] | TypeAliasType | GenericAlias,
+        module: Module,
+    ) -> None:
         self.__class = cls
+        self.__lazy_instance = module.aget_lazy_instance(cls, default=NotImplemented)
         self.__module = module
 
+    async def __call__(self) -> T:
+        instance = await self.__lazy_instance
+
+        if instance is NotImplemented:
+            raise InjectionError(f"`{self.__class}` is an unknown dependency.")
+
+        return instance
+
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, type(self)):
             return self.__key == other.__key
@@ -52,9 +63,3 @@ class InjectionDependency[T]:
     @property
     def __key(self) -> tuple[type[T] | TypeAliasType | GenericAlias, Module]:
         return self.__class, self.__module
-
-    def __ensure(self, instance: T) -> T:
-        if instance is NotImplemented:
-            raise InjectionError(f"`{self.__class}` is an unknown dependency.")
-
-        return instance

{python_injection-0.11.0 → python_injection-0.12.0}/injection/testing/__init__.pyi

@@ -8,7 +8,7 @@ test_constant = _.constant
 test_injectable = _.injectable
 test_singleton = _.singleton
 
-def load_test_profile(*other_profile_names: str) -> ContextManager[None]:
+def load_test_profile(*names: str) -> ContextManager[None]:
     """
     Context manager or decorator for temporary use test module.
     """

{python_injection-0.11.0 → python_injection-0.12.0}/pyproject.toml

@@ -1,11 +1,11 @@
-[tool.poetry]
+[project]
 name = "python-injection"
-version = "0.11.0"
+version = "0.12.0"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
-authors = ["remimd"]
 readme = "README.md"
-repository = "https://github.com/100nm/python-injection"
+requires-python = ">=3.12, <4"
+authors = [{ name = "remimd" }]
 keywords = ["dependencies", "dependency", "inject", "injection"]
 classifiers = [
     "Development Status :: 4 - Beta",
@@ -21,17 +21,19 @@ classifiers = [
     "Natural Language :: English",
     "Typing :: Typed",
 ]
-packages = [{ include = "injection" }]
+dependencies = []
 
-[tool.poetry.dependencies]
-python = ">=3.12, <4"
+[project.urls]
+repository = "https://github.com/100nm/python-injection"
+
+[tool.poetry]
+packages = [{ include = "injection" }]
 
 [tool.poetry.group.dev.dependencies]
 mypy = "*"
 ruff = "*"
 
 [tool.poetry.group.test.dependencies]
-blacksheep = { version = "*", optional = true }
 fastapi = "*"
 httpx = "*"
 pydantic = "*"
@@ -70,7 +72,6 @@ exclude = [
     "tests/",
     "bench.py",
     "conftest.py",
-    "injection/integrations/blacksheep.py",
 ]
 follow_imports = "silent"
 no_implicit_reexport = true
@@ -85,7 +86,7 @@ warn_required_dynamic_aliases = true
 
 [tool.pytest.ini_options]
 python_files = "test_*.py"
-addopts = "--tb short --cov ./ --cov-report term-missing:skip-covered --ignore tests/integrations/test_blacksheep.py"
+addopts = "--tb short --cov ./ --cov-report term-missing:skip-covered"
 asyncio_default_fixture_loop_scope = "session"
 asyncio_mode = "auto"
 testpaths = "**/tests/"

python_injection-0.11.0/injection/integrations/blacksheep.py

@@ -1,34 +0,0 @@
-from typing import Any, override
-
-from injection import Module, mod
-from injection.integrations import _is_installed
-
-__all__ = ("InjectionServices",)
-
-if _is_installed("blacksheep", __name__):
-    from rodi import ContainerProtocol
-
-
-class InjectionServices(ContainerProtocol):
-    """
-    BlackSheep dependency injection container implemented with `python-injection`.
-    """
-
-    __slots__ = ("__module",)
-
-    __module: Module
-
-    def __init__(self, module: Module | None = None) -> None:
-        self.__module = module or mod()
-
-    @override
-    def __contains__(self, item: Any) -> bool:
-        return item in self.__module
-
-    @override
-    def register(self, obj_type: type | Any, *args: Any, **kwargs: Any) -> None:
-        self.__module.injectable(obj_type)
-
-    @override
-    def resolve[T](self, obj_type: type[T] | Any, *args: Any, **kwargs: Any) -> T:
-        return self.__module.find_instance(obj_type)