python-injection 0.19.2__py3-none-any.whl → 0.19.4__py3-none-any.whl

injection/__init__.pyi

@@ -11,9 +11,10 @@ from ._core.common.type import InputType as _InputType
 from ._core.common.type import TypeInfo as _TypeInfo
 from ._core.module import InjectableFactory as _InjectableFactory
 from ._core.module import ModeStr, PriorityStr
-from ._core.module import Recipe as _Recipe
 from ._core.scope import ScopeKindStr
 
+type _Decorator[T] = Callable[[T], T]
+
 __MODULE: Final[Module] = ...
 
 afind_instance = __MODULE.afind_instance
@@ -120,13 +121,14 @@ class Module:
     def __contains__(self, cls: _InputType[Any], /) -> bool: ...
     @property
     def is_locked(self) -> bool: ...
+    @overload
     def inject[**P, T](
         self,
-        wrapped: Callable[P, T] = ...,
+        wrapped: Callable[P, T],
         /,
         *,
         threadsafe: bool | None = ...,
-    ) -> Any:
+    ) -> Callable[P, T]:
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
@@ -134,39 +136,127 @@ class Module:
 
         With `threadsafe=True`, the injection logic is wrapped in a `threading.RLock`.
         """
-
+    @overload
+    def inject[T](
+        self,
+        wrapped: type[T],
+        /,
+        *,
+        threadsafe: bool | None = ...,
+    ) -> type[T]: ...
+    @overload
+    def inject[**P, T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        threadsafe: bool | None = ...,
+    ) -> _Decorator[Callable[P, T]] | _Decorator[type[T]]: ...
+    @overload
     def injectable[**P, T](
         self,
-        wrapped: _Recipe[P, T] = ...,
+        wrapped: Callable[P, T],
         /,
         *,
         cls: _InjectableFactory[T] = ...,
         inject: bool = ...,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Any:
+    ) -> Callable[P, T]:
         """
         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.
         """
 
+    @overload
+    def injectable[**P, T](  # type: ignore[overload-overlap]
+        self,
+        wrapped: Callable[P, Awaitable[T]],
+        /,
+        *,
+        cls: _InjectableFactory[T] = ...,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> Callable[P, Awaitable[T]]: ...
+    @overload
+    def injectable[T](
+        self,
+        wrapped: type[T],
+        /,
+        *,
+        cls: _InjectableFactory[T] = ...,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> type[T]: ...
+    @overload
+    def injectable[**P, T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        cls: _InjectableFactory[T] = ...,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> (
+        _Decorator[Callable[P, T]]
+        | _Decorator[Callable[P, Awaitable[T]]]
+        | _Decorator[type[T]]
+    ): ...
+    @overload
     def singleton[**P, T](
         self,
-        wrapped: _Recipe[P, T] = ...,
+        wrapped: Callable[P, T],
         /,
         *,
         inject: bool = ...,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Any:
+    ) -> Callable[P, T]:
         """
         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 scoped[T](
+    @overload
+    def singleton[**P, T](  # type: ignore[overload-overlap]
+        self,
+        wrapped: Callable[P, Awaitable[T]],
+        /,
+        *,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> Callable[P, Awaitable[T]]: ...
+    @overload
+    def singleton[T](
+        self,
+        wrapped: type[T],
+        /,
+        *,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> type[T]: ...
+    @overload
+    def singleton[**P, T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        inject: bool = ...,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> (
+        _Decorator[Callable[P, T]]
+        | _Decorator[Callable[P, Awaitable[T]]]
+        | _Decorator[type[T]]
+    ): ...
+    def scoped[**P, T](
         self,
         scope_name: str,
         /,
@@ -174,34 +264,79 @@ class Module:
         inject: bool = ...,
         on: _TypeInfo[T] = (),
         mode: Mode | ModeStr = ...,
-    ) -> Any:
+    ) -> (
+        _Decorator[Callable[P, T]]
+        | _Decorator[Callable[P, Awaitable[T]]]
+        | _Decorator[Callable[P, AsyncIterator[T]]]
+        | _Decorator[Callable[P, Iterator[T]]]
+        | _Decorator[type[T]]
+    ):
         """
         Decorator applicable to a class or function or generator function. It is used
         to indicate how the scoped instance will be constructed. At injection time, the
         injected instance is retrieved from the scope.
         """
 
-    def should_be_injectable[T](self, wrapped: type[T] = ..., /) -> Any:
+    @overload
+    def should_be_injectable[T](self, wrapped: type[T], /) -> type[T]:
         """
         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.
         """
 
+    @overload
+    def should_be_injectable[T](
+        self,
+        wrapped: None = ...,
+        /,
+    ) -> _Decorator[type[T]]: ...
+    @overload
     def constant[**P, T](
         self,
-        wrapped: _Recipe[P, T] = ...,
+        wrapped: Callable[P, T],
         /,
         *,
         on: _TypeInfo[T] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Any:
+    ) -> Callable[P, T]:
         """
         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
         be the same. Unlike `@singleton`, dependencies will not be resolved.
         """
 
+    @overload
+    def constant[**P, T](  # type: ignore[overload-overlap]
+        self,
+        wrapped: Callable[P, Awaitable[T]],
+        /,
+        *,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> Callable[P, Awaitable[T]]: ...
+    @overload
+    def constant[T](
+        self,
+        wrapped: type[T],
+        /,
+        *,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> type[T]: ...
+    @overload
+    def constant[**P, T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        on: _TypeInfo[T] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> (
+        _Decorator[Callable[P, T]]
+        | _Decorator[Callable[P, Awaitable[T]]]
+        | _Decorator[type[T]]
+    ): ...
     def set_constant[T](
         self,
         instance: T,

injection/_core/common/lazy.py

@@ -1,41 +1,50 @@
-from collections.abc import Callable, Iterator
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
 from functools import partial
 
-from injection._core.common.invertible import Invertible, SimpleInvertible
+from injection._core.common.invertible import Invertible
 
 
-def lazy[T](factory: Callable[..., T]) -> Invertible[T]:
+def lazy[T](factory: Callable[..., T]) -> Callable[[], T]:
     def cache() -> Iterator[T]:
-        nonlocal factory
         value = factory()
-        del factory
+        while True:
+            yield value
+
+    return partial(next, cache())
 
+
+def alazy[T](factory: Callable[..., Awaitable[T]]) -> Callable[[], Awaitable[T]]:
+    async def cache() -> AsyncIterator[T]:
+        value = await factory()
         while True:
             yield value
 
-    getter = partial(next, cache())
-    return SimpleInvertible(getter)
+    return partial(_anext, cache())
 
 
 class Lazy[T](Invertible[T]):
-    __slots__ = ("__invertible", "__is_set")
+    __slots__ = ("__get", "__is_set")
 
-    __invertible: Invertible[T]
+    __get: Callable[[], T]
     __is_set: bool
 
     def __init__(self, factory: Callable[..., T]) -> None:
         @lazy
-        def invertible() -> T:
+        def get() -> T:
             value = factory()
             self.__is_set = True
             return value
 
-        self.__invertible = invertible
+        self.__get = get
         self.__is_set = False
 
     def __invert__(self) -> T:
-        return ~self.__invertible
+        return self.__get()
 
     @property
     def is_set(self) -> bool:
         return self.__is_set
+
+
+async def _anext[T](async_iterator: AsyncIterator[T]) -> T:
+    return await anext(async_iterator)

injection/_core/common/type.py

@@ -7,6 +7,7 @@ from collections.abc import (
     Generator,
     Iterable,
     Iterator,
+    Sequence,
 )
 from inspect import isfunction
 from types import GenericAlias, UnionType
@@ -26,7 +27,7 @@ type TypeInfo[T] = (
     InputType[T]
     | Callable[..., T]
     | Callable[..., Awaitable[T]]
-    | Iterable[TypeInfo[T]]
+    | Sequence[TypeInfo[T]]
 )
 
 
@@ -89,8 +90,16 @@ def standardize_types(
         else:
             yield tp
 
-            if with_origin and origin is not None:
-                yield origin
+            if with_origin:
+                if origin is not None:
+                    yield origin
+
+                for alias in (tp, origin):
+                    if isinstance(alias, TypeAliasType):
+                        yield from standardize_types(
+                            alias.__value__,
+                            with_origin=with_origin,
+                        )
 
             continue
 

injection/_core/module.py

@@ -50,7 +50,7 @@ from injection._core.common.asynchronous import (
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.key import new_short_key
-from injection._core.common.lazy import Lazy, lazy
+from injection._core.common.lazy import Lazy, alazy, lazy
 from injection._core.common.threading import get_lock
 from injection._core.common.type import (
     InputType,
@@ -347,8 +347,8 @@ class Locator(Broker):
     @staticmethod
     def __standardize_inputs[T](
         classes: Iterable[InputType[T]],
-    ) -> Iterable[InputType[T]]:
-        return tuple(standardize_types(*classes, with_origin=True))
+    ) -> Iterator[InputType[T]]:
+        return standardize_types(*classes, with_origin=True)
 
     @staticmethod
     def __update_preprocessing[T](updater: Updater[T]) -> Updater[T]:
@@ -512,9 +512,9 @@ class Module(Broker, EventListener):
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
         def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
-            lazy_instance = lazy(wp)
+            recipe: Recipe[[], T] = alazy(wp) if iscoroutinefunction(wp) else lazy(wp)  # type: ignore[arg-type]
             self.injectable(
-                lambda: ~lazy_instance,
+                recipe,
                 ignore_type_hint=True,
                 inject=False,
                 on=(wp, on),

injection/entrypoint.py

@@ -22,9 +22,20 @@ type EntrypointSetupMethod[**P, **EPP, T1, T2] = Callable[
 ]
 
 
-def autocall[**P, T](wrapped: Callable[P, T] | None = None, /) -> Any:
-    def decorator(wp: Callable[P, T]) -> Callable[P, T]:
-        wp()  # type: ignore[call-arg]
+@overload
+def autocall[T: Callable[..., Any]](wrapped: T, /) -> T: ...
+
+
+@overload
+def autocall[T: Callable[..., Any]](wrapped: None = ..., /) -> Callable[[T], T]: ...
+
+
+def autocall[T: Callable[..., Any]](
+    wrapped: T | None = None,
+    /,
+) -> T | Callable[[T], T]:
+    def decorator(wp: T) -> T:
+        wp()
         return wp
 
     return decorator(wrapped) if wrapped else decorator

{python_injection-0.19.2.dist-info → python_injection-0.19.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.19.2
+Version: 0.19.4
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.19.2.dist-info → python_injection-0.19.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 injection/__init__.py,sha256=iJm0BbyGZw-Qr5e8d2C3n8-7FiVD-sy4LU_i_n3AgHY,1318
-injection/__init__.pyi,sha256=2ndBULZyjN0SnyRml2gba9OOsTY0BhR3STEyvv1aZOA,11566
-injection/entrypoint.py,sha256=NIILL_w3z2JKyn7S9XXwE0JtH2icuDWnAVpUY1fAMf8,4805
+injection/__init__.pyi,sha256=VCuJkbE1S2XppeTkwiDAbOsVBmlmCpFFXe5ztTUb_-Q,14942
+injection/entrypoint.py,sha256=1JtooUCE9nIvHGAps5ypRb9ZEbgLdLwydkGF-kXMXDY,4953
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
 injection/loaders.py,sha256=gKlJfe9nXCuB8r6j0RF9_2FHC6YplM8GQYsgRqyxYw8,7257
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -8,7 +8,7 @@ injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/asfunction.py,sha256=fTgAAWsDWUz89kYsoSVDXdqYKIuh6HtUW5MohGp3ov4,1767
 injection/_core/descriptors.py,sha256=1OX6JnM8Ux14vW1JSW3FzPgKc2VMTKqJUYBGT3Ypafg,800
 injection/_core/injectables.py,sha256=fxhiGv7qTCbUunhhd6a3ahosFmgznUFsEvqlwxi4gS4,6098
-injection/_core/module.py,sha256=T9zvSOjMaPZiC_DCV7BIKOqCrmAHcYcleqgNro0MBgU,32624
+injection/_core/module.py,sha256=IrNpWIO75kO3REQX6RdQdtZDjc-S17B8Y2KdM_NGacA,32684
 injection/_core/scope.py,sha256=r094k1Vjvwm0hTf7AQGYrxxvqQgb7_CDVUKaHQ8wyeM,8772
 injection/_core/slots.py,sha256=g9TG6CbqRzCsjg01iPyfRtTTUCJnnJOwcj9mJabH0dc,37
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,15 +16,15 @@ injection/_core/common/asynchronous.py,sha256=nKY2_PAMFF2haC75Fwp8O9Zd-SDuenE6n3
 injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
 injection/_core/common/invertible.py,sha256=gA_vw5nBjgp_w9MrDK5jMO8lhuOQWON8BbPpKzEuIY0,502
 injection/_core/common/key.py,sha256=ghkZD-Y8Moz6SEPNgMh3xgsZUjDVq-XYAmXaCu5VuCA,80
-injection/_core/common/lazy.py,sha256=L7C2dB5UBI--W5Kkvntp_jypYhudY3SHqs8rM6jxxsk,965
+injection/_core/common/lazy.py,sha256=hZvz9LhlYxVkD_D8VBAvQmy7YuVaaw075jq0XM0w9_Y,1193
 injection/_core/common/threading.py,sha256=kwRXNa9ocndIqeZA9kMHjEa8SBpHFcJARj1bgrWCpxE,225
-injection/_core/common/type.py,sha256=SCDtmBv9qFvEf5o5tTgCuwMDfuo1fgjSW0bUqA8ACis,2251
+injection/_core/common/type.py,sha256=mmDMaR68pQpwGnOLLkOmy9slCvgjLVYuEhoYVyANRlk,2564
 injection/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/ext/fastapi.py,sha256=fiy3-mZIIwGcql3Y5ekFX8_7hALzqXP5u40qbtNE73o,1441
 injection/ext/fastapi.pyi,sha256=HLs7mfruIEFRrN_Xf8oCvSa4qwHWfwm6HHU_KMedXkE,185
 injection/testing/__init__.py,sha256=bJ7WXBXrw4rHc91AFVFnOwFLWOlpvX9Oh2SnRQ_NESo,919
 injection/testing/__init__.pyi,sha256=raGsGlxwbz3jkzJwA_5oCIE1emWINjT2UuwzbnqRb-0,577
-python_injection-0.19.2.dist-info/METADATA,sha256=92VOjBIEVr3f-V35vtchT60StdudDnupyvXgAx1qkxE,4301
-python_injection-0.19.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.19.2.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
-python_injection-0.19.2.dist-info/RECORD,,
+python_injection-0.19.4.dist-info/METADATA,sha256=xtDdgHy2s2fYA8jwKObxTd--xD2gC6yPVkDNKSwgr8c,4301
+python_injection-0.19.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.19.4.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
+python_injection-0.19.4.dist-info/RECORD,,