python-injection 0.19.3__tar.gz → 0.19.5__tar.gz

{python_injection-0.19.3 → python_injection-0.19.5}/PKG-INFO

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

{python_injection-0.19.3 → python_injection-0.19.5}/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,74 +136,236 @@ 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(
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        threadsafe: bool | None = ...,
+    ) -> _Decorator[Callable[..., Any] | type]: ...
+    @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[T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        cls: _InjectableFactory[T] = ...,
+        inject: bool = ...,
+        on: _TypeInfo[T],
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., T] | Callable[..., Awaitable[T]] | type[T]]: ...
+    @overload
+    def injectable(
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        cls: _InjectableFactory[Any] = ...,
+        inject: bool = ...,
+        on: tuple[()] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., Any] | type]: ...
+    @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.
         """
 
+    @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[T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        inject: bool = ...,
+        on: _TypeInfo[T],
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., T] | Callable[..., Awaitable[T]] | type[T]]: ...
+    @overload
+    def singleton(
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        inject: bool = ...,
+        on: tuple[()] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., Any] | type]: ...
+    @overload
     def scoped[T](
         self,
         scope_name: str,
         /,
         *,
         inject: bool = ...,
-        on: _TypeInfo[T] = (),
+        on: _TypeInfo[T],
         mode: Mode | ModeStr = ...,
-    ) -> Any:
+    ) -> _Decorator[
+        Callable[..., T]
+        | Callable[..., Awaitable[T]]
+        | Callable[..., AsyncIterator[T]]
+        | Callable[..., Iterator[T]]
+        | 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 scoped(
+        self,
+        scope_name: str,
+        /,
+        *,
+        inject: bool = ...,
+        on: tuple[()] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., Any] | type]: ...
+    @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(
+        self,
+        wrapped: None = ...,
+        /,
+    ) -> _Decorator[type]: ...
+    @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[T](
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        on: _TypeInfo[T],
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., T] | Callable[..., Awaitable[T]] | type[T]]: ...
+    @overload
+    def constant(
+        self,
+        wrapped: None = ...,
+        /,
+        *,
+        on: tuple[()] = ...,
+        mode: Mode | ModeStr = ...,
+    ) -> _Decorator[Callable[..., Any] | type]: ...
     def set_constant[T](
         self,
         instance: T,

python_injection-0.19.5/injection/_core/common/lazy.py

@@ -0,0 +1,50 @@
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from functools import partial
+
+from injection._core.common.invertible import Invertible
+
+
+def lazy[T](factory: Callable[..., T]) -> Callable[[], T]:
+    def cache() -> Iterator[T]:
+        value = 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
+
+    return partial(_anext, cache())
+
+
+class Lazy[T](Invertible[T]):
+    __slots__ = ("__get", "__is_set")
+
+    __get: Callable[[], T]
+    __is_set: bool
+
+    def __init__(self, factory: Callable[..., T]) -> None:
+        @lazy
+        def get() -> T:
+            value = factory()
+            self.__is_set = True
+            return value
+
+        self.__get = get
+        self.__is_set = False
+
+    def __invert__(self) -> T:
+        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)

{python_injection-0.19.3 → python_injection-0.19.5}/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]]
 )
 
 

{python_injection-0.19.3 → python_injection-0.19.5}/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,
@@ -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),

{python_injection-0.19.3 → python_injection-0.19.5}/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.3 → python_injection-0.19.5}/pyproject.toml

@@ -30,7 +30,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.19.3"
+version = "0.19.5"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]

python_injection-0.19.3/injection/_core/common/lazy.py

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