python-injection 0.21.0__tar.gz → 0.21.2__tar.gz

{python_injection-0.21.0 → python_injection-0.21.2}/PKG-INFO

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

{python_injection-0.21.0 → python_injection-0.21.2}/injection/_core/common/type.py

@@ -9,7 +9,7 @@ from collections.abc import (
     Iterable,
     Iterator,
 )
-from inspect import isfunction
+from inspect import isclass, isfunction
 from types import GenericAlias, UnionType
 from typing import (
     Annotated,
@@ -33,7 +33,7 @@ type TypeInfo[T] = (
 
 def get_return_types(*args: TypeInfo[Any]) -> Iterator[InputType[Any]]:
     for arg in args:
-        if isinstance(arg, Collection):
+        if isinstance(arg, Collection) and not isclass(arg):
             inner_args = arg
 
         elif isfunction(arg) and (return_type := get_return_hint(arg)):

{python_injection-0.21.0 → python_injection-0.21.2}/injection/_core/module.py

@@ -29,6 +29,7 @@ from inspect import signature as inspect_signature
 from logging import Logger, getLogger
 from types import MethodType
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncContextManager,
     ClassVar,
@@ -577,21 +578,23 @@ class Module(Broker, EventListener):
 
         return decorator(wrapped) if wrapped else decorator
 
-    @overload
-    def make_injected_function[**P, T](
-        self,
-        wrapped: Callable[P, T],
-        /,
-        threadsafe: bool | None = ...,
-    ) -> SyncInjectedFunction[P, T]: ...
+    if TYPE_CHECKING:  # pragma: no cover
 
-    @overload
-    def make_injected_function[**P, T](
-        self,
-        wrapped: Callable[P, Awaitable[T]],
-        /,
-        threadsafe: bool | None = ...,
-    ) -> AsyncInjectedFunction[P, T]: ...
+        @overload
+        def make_injected_function[**P, T](
+            self,
+            wrapped: Callable[P, T],
+            /,
+            threadsafe: bool | None = ...,
+        ) -> SyncInjectedFunction[P, T]: ...
+
+        @overload
+        def make_injected_function[**P, T](
+            self,
+            wrapped: Callable[P, Awaitable[T]],
+            /,
+            threadsafe: bool | None = ...,
+        ) -> AsyncInjectedFunction[P, T]: ...
 
     def make_injected_function[**P, T](
         self,
@@ -643,23 +646,25 @@ class Module(Broker, EventListener):
             injectable = self[cls]
             return injectable.get_instance()
 
-    @overload
-    async def aget_instance[T, Default](
-        self,
-        cls: InputType[T],
-        default: Default,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> T | Default: ...
-
-    @overload
-    async def aget_instance[T](
-        self,
-        cls: InputType[T],
-        default: T = ...,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> T: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        async def aget_instance[T, Default](
+            self,
+            cls: InputType[T],
+            default: Default,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> T | Default: ...
+
+        @overload
+        async def aget_instance[T](
+            self,
+            cls: InputType[T],
+            default: T = ...,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> T: ...
 
     async def aget_instance[T, Default](
         self,
@@ -673,23 +678,25 @@ class Module(Broker, EventListener):
         except (KeyError, SkipInjectable):
             return default
 
-    @overload
-    def get_instance[T, Default](
-        self,
-        cls: InputType[T],
-        default: Default,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> T | Default: ...
-
-    @overload
-    def get_instance[T](
-        self,
-        cls: InputType[T],
-        default: T = ...,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> T: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def get_instance[T, Default](
+            self,
+            cls: InputType[T],
+            default: Default,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> T | Default: ...
+
+        @overload
+        def get_instance[T](
+            self,
+            cls: InputType[T],
+            default: T = ...,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> T: ...
 
     def get_instance[T, Default](
         self,
@@ -703,23 +710,25 @@ class Module(Broker, EventListener):
         except (KeyError, SkipInjectable):
             return default
 
-    @overload
-    def aget_lazy_instance[T, Default](
-        self,
-        cls: InputType[T],
-        default: Default,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> Awaitable[T | Default]: ...
-
-    @overload
-    def aget_lazy_instance[T](
-        self,
-        cls: InputType[T],
-        default: T = ...,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> Awaitable[T]: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def aget_lazy_instance[T, Default](
+            self,
+            cls: InputType[T],
+            default: Default,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> Awaitable[T | Default]: ...
+
+        @overload
+        def aget_lazy_instance[T](
+            self,
+            cls: InputType[T],
+            default: T = ...,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> Awaitable[T]: ...
 
     def aget_lazy_instance[T, Default](
         self,
@@ -735,23 +744,25 @@ class Module(Broker, EventListener):
         metadata = function.__inject_metadata__.set_owner(cls)
         return SimpleAwaitable(metadata.acall)
 
-    @overload
-    def get_lazy_instance[T, Default](
-        self,
-        cls: InputType[T],
-        default: Default,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> Invertible[T | Default]: ...
-
-    @overload
-    def get_lazy_instance[T](
-        self,
-        cls: InputType[T],
-        default: T = ...,
-        *,
-        threadsafe: bool | None = ...,
-    ) -> Invertible[T]: ...
+    if TYPE_CHECKING:  # pragma: no cover
+
+        @overload
+        def get_lazy_instance[T, Default](
+            self,
+            cls: InputType[T],
+            default: Default,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> Invertible[T | Default]: ...
+
+        @overload
+        def get_lazy_instance[T](
+            self,
+            cls: InputType[T],
+            default: T = ...,
+            *,
+            threadsafe: bool | None = ...,
+        ) -> Invertible[T]: ...
 
     def get_lazy_instance[T, Default](
         self,

{python_injection-0.21.0 → python_injection-0.21.2}/injection/_core/scope.py

@@ -10,6 +10,7 @@ from dataclasses import dataclass, field
 from enum import StrEnum
 from types import EllipsisType, TracebackType
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncContextManager,
     ContextManager,
@@ -158,12 +159,13 @@ def get_active_scopes(name: str) -> tuple[Scope, ...]:
     return tuple(itertools.chain.from_iterable(active_scopes))
 
 
-@overload
-def get_scope(name: str, default: EllipsisType = ...) -> Scope: ...
+if TYPE_CHECKING:  # pragma: no cover
 
+    @overload
+    def get_scope(name: str, default: EllipsisType = ...) -> Scope: ...
 
-@overload
-def get_scope[T](name: str, default: T) -> Scope | T: ...
+    @overload
+    def get_scope[T](name: str, default: T) -> Scope | T: ...
 
 
 def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:

{python_injection-0.21.0 → python_injection-0.21.2}/injection/entrypoint.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from functools import wraps
 from types import MethodType
 from types import ModuleType as PythonModule
-from typing import Any, Concatenate, Self, final, overload
+from typing import TYPE_CHECKING, Any, Concatenate, Self, final, overload
 
 from injection import Module
 from injection.loaders import ProfileLoader, PythonModuleLoader
@@ -21,13 +21,13 @@ type EntrypointSetupMethod[**P, **EPP, T1, T2] = Callable[
     Entrypoint[EPP, T2],
 ]
 
+if TYPE_CHECKING:  # pragma: no cover
 
-@overload
-def autocall[T: Callable[..., Any]](wrapped: T, /) -> T: ...
+    @overload
+    def autocall[T: Callable[..., Any]](wrapped: T, /) -> T: ...
 
-
-@overload
-def autocall[T: Callable[..., Any]](wrapped: None = ..., /) -> Callable[[T], T]: ...
+    @overload
+    def autocall[T: Callable[..., Any]](wrapped: None = ..., /) -> Callable[[T], T]: ...
 
 
 def autocall[T: Callable[..., Any]](
@@ -44,26 +44,26 @@ def autocall[T: Callable[..., Any]](
 # SMP = Setup Method Parameters
 # EPP = EntryPoint Parameters
 
+if TYPE_CHECKING:  # pragma: no cover
 
-@overload
-def entrypointmaker[**SMP, **EPP, T1, T2](
-    wrapped: EntrypointSetupMethod[SMP, EPP, T1, T2],
-    /,
-    *,
-    profile_loader: ProfileLoader = ...,
-) -> EntrypointDecorator[EPP, T1, T2]: ...
-
+    @overload
+    def entrypointmaker[**SMP, **EPP, T1, T2](
+        wrapped: EntrypointSetupMethod[SMP, EPP, T1, T2],
+        /,
+        *,
+        profile_loader: ProfileLoader = ...,
+    ) -> EntrypointDecorator[EPP, T1, T2]: ...
 
-@overload
-def entrypointmaker[**SMP, **EPP, T1, T2](
-    wrapped: None = ...,
-    /,
-    *,
-    profile_loader: ProfileLoader = ...,
-) -> Callable[
-    [EntrypointSetupMethod[SMP, EPP, T1, T2]],
-    EntrypointDecorator[EPP, T1, T2],
-]: ...
+    @overload
+    def entrypointmaker[**SMP, **EPP, T1, T2](
+        wrapped: None = ...,
+        /,
+        *,
+        profile_loader: ProfileLoader = ...,
+    ) -> Callable[
+        [EntrypointSetupMethod[SMP, EPP, T1, T2]],
+        EntrypointDecorator[EPP, T1, T2],
+    ]: ...
 
 
 def entrypointmaker[**SMP, **EPP, T1, T2](

{python_injection-0.21.0 → python_injection-0.21.2}/pyproject.toml

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