python-injection 0.25.2__tar.gz → 0.25.4__tar.gz

{python_injection-0.25.2 → python_injection-0.25.4}/PKG-INFO

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

{python_injection-0.25.2 → python_injection-0.25.4}/injection/__init__.pyi

@@ -151,13 +151,13 @@ class Module:
     @property
     def is_locked(self) -> bool: ...
     @overload
-    def inject[**P, T](
+    def inject[T](
         self,
-        wrapped: Callable[P, T],
+        wrapped: T,
         /,
         *,
         threadsafe: bool | None = ...,
-    ) -> Callable[P, T]:
+    ) -> T:
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
@@ -166,14 +166,6 @@ 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,
@@ -181,57 +173,24 @@ class Module:
         /,
         *,
         threadsafe: bool | None = ...,
-    ) -> _Decorator[Callable[..., Any] | type]: ...
+    ) -> _Decorator: ...  # type: ignore[type-arg]
     @overload
-    def injectable[**P, T](
+    def injectable[T](
         self,
-        wrapped: Callable[P, T],
+        wrapped: T,
         /,
         *,
-        cls: _InjectableFactory[T] = ...,
+        cls: _InjectableFactory[Any] = ...,
         inject: bool = ...,
-        on: _TypeInfo[T] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Callable[P, T]:
+    ) -> 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,
@@ -240,55 +199,25 @@ class Module:
         *,
         cls: _InjectableFactory[Any] = ...,
         inject: bool = ...,
-        on: tuple[()] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> _Decorator[Callable[..., Any] | type]: ...
+    ) -> _Decorator: ...  # type: ignore[type-arg]
     @overload
-    def singleton[**P, T](
+    def singleton[T](
         self,
-        wrapped: Callable[P, T],
+        wrapped: T,
         /,
         *,
         inject: bool = ...,
-        on: _TypeInfo[T] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Callable[P, T]:
+    ) -> 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,
@@ -296,25 +225,18 @@ class Module:
         /,
         *,
         inject: bool = ...,
-        on: tuple[()] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> _Decorator[Callable[..., Any] | type]: ...
-    @overload
-    def scoped[T](
+    ) -> _Decorator: ...  # type: ignore[type-arg]
+    def scoped(
         self,
         scope_name: str,
         /,
         *,
         inject: bool = ...,
-        on: _TypeInfo[T],
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> _Decorator[
-        Callable[..., T]
-        | Callable[..., Awaitable[T]]
-        | Callable[..., AsyncIterator[T]]
-        | Callable[..., Iterator[T]]
-        | type[T]
-    ]:
+    ) -> _Decorator:  # type: ignore[type-arg]
         """
         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
@@ -322,17 +244,7 @@ class Module:
         """
 
     @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]:
+    def should_be_injectable[T](self, wrapped: T, /) -> 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
@@ -344,62 +256,35 @@ class Module:
         self,
         wrapped: None = ...,
         /,
-    ) -> _Decorator[type]: ...
+    ) -> _Decorator: ...  # type: ignore[type-arg]
     @overload
-    def constant[**P, T](
+    def constant[T](
         self,
-        wrapped: Callable[P, T],
+        wrapped: T,
         /,
         *,
-        on: _TypeInfo[T] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> Callable[P, T]:
+    ) -> 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[()] = ...,
+        on: _TypeInfo[Any] = ...,
         mode: Mode | ModeStr = ...,
-    ) -> _Decorator[Callable[..., Any] | type]: ...
+    ) -> _Decorator: ...  # type: ignore[type-arg]
     def set_constant[T](
         self,
         instance: T,
-        on: _TypeInfo[T] = ...,
+        on: _TypeInfo[Any] = ...,
         *,
         alias: bool = ...,
         mode: Mode | ModeStr = ...,

{python_injection-0.25.2 → python_injection-0.25.4}/injection/_core/asfunction.py

@@ -1,12 +1,17 @@
 from collections.abc import Callable
 from functools import wraps
 from inspect import iscoroutinefunction
-from typing import Any
+from typing import Any, Protocol
 
 from injection._core.common.asynchronous import Caller
 from injection._core.module import Module, mod
 
-type AsFunctionWrappedType[**P, T] = type[Callable[P, T]]
+
+class _AsFunctionCallable[**P, T](Protocol):
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T: ...
+
+
+type AsFunctionWrappedType[**P, T] = type[_AsFunctionCallable[P, T]]
 
 
 def asfunction[**P, T](

{python_injection-0.25.2 → python_injection-0.25.4}/injection/_core/injectables.py

@@ -209,10 +209,6 @@ class ScopedSlotInjectable[T](Injectable[T]):
     scope_name: str
     key: SlotKey[T] = field(default_factory=SlotKey)
 
-    @property
-    def is_locked(self) -> bool:
-        return in_scope_cache(self.key, self.scope_name)
-
     async def aget_instance(self) -> T:
         return self.get_instance()
 
@@ -227,9 +223,6 @@ class ScopedSlotInjectable[T](Injectable[T]):
                 f"The slot for `{self.cls}` isn't set in the current `{scope_name}` scope."
             ) from exc
 
-    def unlock(self) -> None:
-        remove_scoped_values(self.key, self.scope_name)
-
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class ShouldBeInjectable[T](Injectable[T]):

{python_injection-0.25.2 → python_injection-0.25.4}/pyproject.toml

@@ -11,6 +11,7 @@ bench = [
 dev = [
     "hatch",
     "mypy",
+    "pyright",
     "ruff",
 ]
 doc = [
@@ -30,7 +31,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.25.2"
+version = "0.25.4"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]
@@ -76,7 +77,7 @@ exclude_lines = [
 ]
 
 [tool.coverage.run]
-omit = ["bench.py"]
+omit = ["bench.py", "typing_checks/*"]
 
 [tool.hatch.build]
 skip-excluded-dirs = true
@@ -108,6 +109,9 @@ init_forbid_extra = true
 init_typed = true
 warn_required_dynamic_aliases = true
 
+[tool.pyright]
+include = ["typing_checks/"]
+
 [tool.pytest]
 python_files = ["test_*.py"]
 addopts = ["--tb", "short", "--cov", "./", "--cov-report", "term-missing:skip-covered"]