python-injection 0.8.5__tar.gz → 0.9.0__tar.gz

{python_injection-0.8.5 → python_injection-0.9.0}/PKG-INFO

@@ -1,16 +1,14 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.5
+Version: 0.9.0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
 Keywords: dependencies,inject,injection
 Author: remimd
-Requires-Python: >=3.10,<4
+Requires-Python: >=3.12,<4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Project-URL: Repository, https://github.com/100nm/python-injection
 Description-Content-Type: text/markdown

{python_injection-0.8.5 → python_injection-0.9.0}/injection/__init__.pyi

@@ -1,23 +1,23 @@
 from abc import abstractmethod
-from collections.abc import Callable, Iterable
+from collections.abc import Callable
 from contextlib import ContextDecorator
-from enum import Enum
+from enum import StrEnum
 from types import UnionType
 from typing import (
     Any,
     ContextManager,
     Final,
-    Literal,
     Protocol,
-    TypeVar,
+    Self,
     final,
     runtime_checkable,
 )
 
 from .common.invertible import Invertible
-
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
+from .common.tools.type import TypeInfo
+from .core import InjectableFactory
+from .core import ModeStr as InjectableModeStr
+from .core import PriorityStr as ModulePriorityStr
 
 default_module: Final[Module] = ...
 
@@ -41,6 +41,8 @@ class Module:
 
     def __init__(self, name: str = ...): ...
     def __contains__(self, cls: type | UnionType, /) -> bool: ...
+    @property
+    def is_locked(self) -> bool: ...
     def inject(self, wrapped: Callable[..., Any] = ..., /):
         """
         Decorator applicable to a class or function. Inject function dependencies using
@@ -48,15 +50,15 @@ class Module:
         will be those of the `__init__` method.
         """
 
-    def injectable(
+    def injectable[T](
         self,
-        wrapped: Callable[..., Any] = ...,
+        wrapped: Callable[..., T] = ...,
         /,
         *,
-        cls: type[Injectable] = ...,
+        cls: InjectableFactory[T] = ...,
         inject: bool = ...,
-        on: type | Iterable[type] | UnionType = ...,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
+        on: TypeInfo[T] = ...,
+        mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -64,14 +66,14 @@ class Module:
         injected each time.
         """
 
-    def singleton(
+    def singleton[T](
         self,
-        wrapped: Callable[..., Any] = ...,
+        wrapped: Callable[..., T] = ...,
         /,
         *,
         inject: bool = ...,
-        on: type | Iterable[type] | UnionType = ...,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
+        on: TypeInfo[T] = ...,
+        mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -86,37 +88,37 @@ class Module:
         registered.
         """
 
-    def set_constant(
+    def set_constant[T](
         self,
-        instance: _T,
-        on: type | Iterable[type] | UnionType = ...,
+        instance: T,
+        on: TypeInfo[T] = ...,
         *,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
-    ) -> _T:
+        mode: InjectableMode | InjectableModeStr = ...,
+    ) -> T:
         """
         Function for registering a specific instance to be injected. This is useful for
         registering global variables. The difference with the singleton decorator is
         that no dependencies are resolved, so the module doesn't need to be locked.
         """
 
-    def resolve(self, cls: type[_T]) -> _T:
+    def resolve[T](self, cls: type[T]) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
         """
 
-    def get_instance(self, cls: type[_T]) -> _T | None:
+    def get_instance[T](self, cls: type[T]) -> T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
         """
 
-    def get_lazy_instance(
+    def get_lazy_instance[T](
         self,
-        cls: type[_T],
+        cls: type[T],
         *,
         cache: bool = ...,
-    ) -> Invertible[_T | None]:
+    ) -> Invertible[T | None]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Invertible` object. To access the instance
@@ -126,19 +128,24 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
+    def init_modules(self, *modules: Module) -> Self:
+        """
+        Function to clean modules in use and to use those passed as parameters.
+        """
+
     def use(
         self,
         module: Module,
         *,
-        priority: ModulePriority | Literal["low", "high"] = ...,
-    ):
+        priority: ModulePriority | ModulePriorityStr = ...,
+    ) -> Self:
         """
         Function for using another module. Using another module replaces the module's
         dependencies with those of the module used. If the dependency is not found, it
         will be searched for in the module's dependency container.
         """
 
-    def stop_using(self, module: Module):
+    def stop_using(self, module: Module) -> Self:
         """
         Function to remove a module in use.
         """
@@ -147,7 +154,7 @@ class Module:
         self,
         module: Module,
         *,
-        priority: ModulePriority | Literal["low", "high"] = ...,
+        priority: ModulePriority | ModulePriorityStr = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
@@ -156,8 +163,8 @@ class Module:
     def change_priority(
         self,
         module: Module,
-        priority: ModulePriority | Literal["low", "high"],
-    ):
+        priority: ModulePriority | ModulePriorityStr,
+    ) -> Self:
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -166,27 +173,26 @@ class Module:
         * **HIGH**: The module concerned becomes the most important of the modules used.
         """
 
-    def unlock(self):
+    def unlock(self) -> Self:
         """
         Function to unlock the module by deleting cached instances of singletons.
         """
 
 @final
-class ModulePriority(str, Enum):
+class ModulePriority(StrEnum):
     LOW = ...
     HIGH = ...
 
 @runtime_checkable
-class Injectable(Protocol[_T_co]):
-    def __init__(self, factory: Callable[[], _T_co] = ..., /): ...
+class Injectable[T](Protocol):
     @property
     def is_locked(self) -> bool: ...
     def unlock(self): ...
     @abstractmethod
-    def get_instance(self) -> _T_co: ...
+    def get_instance(self) -> T: ...
 
 @final
-class InjectableMode(str, Enum):
+class InjectableMode(StrEnum):
     FALLBACK = ...
     NORMAL = ...
     OVERRIDE = ...

{python_injection-0.8.5 → python_injection-0.9.0}/injection/common/event.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
-from typing import ContextManager
+from typing import ContextManager, Self
 from weakref import WeakSet
 
 __all__ = ("Event", "EventChannel", "EventListener")
@@ -36,11 +36,11 @@ class EventChannel:
 
             yield
 
-    def add_listener(self, listener: EventListener):
+    def add_listener(self, listener: EventListener) -> Self:
         self.__listeners.add(listener)
         return self
 
-    def remove_listener(self, listener: EventListener):
+    def remove_listener(self, listener: EventListener) -> Self:
         with suppress(KeyError):
             self.__listeners.remove(listener)
 

{python_injection-0.8.5 → python_injection-0.9.0}/injection/common/invertible.py

@@ -1,23 +1,21 @@
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Protocol, TypeVar, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 __all__ = ("Invertible", "SimpleInvertible")
 
-_T_co = TypeVar("_T_co", covariant=True)
-
 
 @runtime_checkable
-class Invertible(Protocol[_T_co]):
+class Invertible[T](Protocol):
     @abstractmethod
-    def __invert__(self) -> _T_co:
+    def __invert__(self) -> T:
         raise NotImplementedError
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class SimpleInvertible(Invertible[_T_co]):
-    callable: Callable[[], _T_co]
+class SimpleInvertible[T](Invertible[T]):
+    callable: Callable[[], T]
 
-    def __invert__(self) -> _T_co:
+    def __invert__(self) -> T:
         return self.callable()

{python_injection-0.8.5 → python_injection-0.9.0}/injection/common/lazy.py

@@ -1,31 +1,26 @@
 from collections.abc import Callable, Iterator, Mapping
 from types import MappingProxyType
-from typing import TypeVar
 
 from injection.common.invertible import Invertible
 
 __all__ = ("Lazy", "LazyMapping")
 
-_T = TypeVar("_T")
-_K = TypeVar("_K")
-_V = TypeVar("_V")
 
-
-class Lazy(Invertible[_T]):
+class Lazy[T](Invertible[T]):
     __slots__ = ("__cache", "__is_set")
 
-    def __init__(self, factory: Callable[[], _T]):
+    def __init__(self, factory: Callable[[], T]):
         self.__setup_cache(factory)
 
-    def __invert__(self) -> _T:
+    def __invert__(self) -> T:
         return next(self.__cache)
 
     @property
     def is_set(self) -> bool:
         return self.__is_set
 
-    def __setup_cache(self, factory: Callable[[], _T]):
-        def cache_generator() -> Iterator[_T]:
+    def __setup_cache(self, factory: Callable[[], T]):
+        def cache_generator() -> Iterator[T]:
             nonlocal factory
             cached = factory()
             self.__is_set = True
@@ -38,16 +33,16 @@ class Lazy(Invertible[_T]):
         self.__is_set = False
 
 
-class LazyMapping(Mapping[_K, _V]):
+class LazyMapping[K, V](Mapping[K, V]):
     __slots__ = ("__lazy",)
 
-    def __init__(self, iterator: Iterator[tuple[_K, _V]]):
+    def __init__(self, iterator: Iterator[tuple[K, V]]):
         self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
 
-    def __getitem__(self, key: _K, /) -> _V:
+    def __getitem__(self, key: K, /) -> V:
         return (~self.__lazy)[key]
 
-    def __iter__(self) -> Iterator[_K]:
+    def __iter__(self) -> Iterator[K]:
         yield from ~self.__lazy
 
     def __len__(self) -> int:

{python_injection-0.8.5 → python_injection-0.9.0}/injection/common/tools/threading.py

@@ -3,10 +3,8 @@ from threading import RLock
 
 __all__ = ("synchronized",)
 
-__lock = RLock()
-
 
 @contextmanager
 def synchronized():
-    with __lock:
+    with RLock():
         yield

python_injection-0.9.0/injection/common/tools/type.py

@@ -0,0 +1,73 @@
+from collections.abc import Callable, Iterable, Iterator
+from inspect import get_annotations, isfunction
+from types import UnionType
+from typing import (
+    Annotated,
+    Any,
+    NamedTuple,
+    Self,
+    Union,
+    get_args,
+    get_origin,
+)
+
+__all__ = ("TypeInfo", "TypeReport", "analyze_types", "get_return_types")
+
+type TypeInfo[T] = type[T] | Callable[..., T] | Iterable[TypeInfo[T]] | UnionType
+
+
+class TypeReport[T](NamedTuple):
+    origin: type[T]
+    args: tuple[Any, ...]
+
+    @property
+    def cls(self) -> type[T]:
+        if self.args:
+            return self.origin[*self.args]
+
+        return self.origin
+
+    @property
+    def no_args(self) -> Self:
+        if self.args:
+            return type(self)(self.origin, ())
+
+        return self
+
+
+def analyze_types(*types: type | Any) -> Iterator[TypeReport[Any]]:
+    for tp in types:
+        if tp is None:
+            continue
+
+        origin = get_origin(tp)
+
+        if origin is Union or isinstance(tp, UnionType):
+            inner_types = get_args(tp)
+
+        elif origin is Annotated:
+            inner_types = get_args(tp)[:1]
+
+        else:
+            yield TypeReport(origin or tp, get_args(tp))
+            continue
+
+        yield from analyze_types(*inner_types)
+
+
+def get_return_types(*args: TypeInfo[Any]) -> Iterator[type | UnionType]:
+    for arg in args:
+        if isinstance(arg, Iterable) and not isinstance(
+            get_origin(arg) or arg,
+            type | str,
+        ):
+            inner_args = arg
+
+        elif isfunction(arg):
+            inner_args = (get_annotations(arg, eval_str=True).get("return"),)
+
+        else:
+            yield arg
+            continue
+
+        yield from get_return_types(*inner_args)

{python_injection-0.8.5 → python_injection-0.9.0}/injection/core/module.py

@@ -14,7 +14,7 @@ from collections.abc import (
 )
 from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import StrEnum
 from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
 from queue import Queue
@@ -27,7 +27,7 @@ from typing import (
     NamedTuple,
     NoReturn,
     Protocol,
-    TypeVar,
+    Self,
     runtime_checkable,
 )
 
@@ -35,7 +35,12 @@ from injection.common.event import Event, EventChannel, EventListener
 from injection.common.invertible import Invertible, SimpleInvertible
 from injection.common.lazy import Lazy, LazyMapping
 from injection.common.tools.threading import synchronized
-from injection.common.tools.type import find_types, format_type, get_origins
+from injection.common.tools.type import (
+    TypeInfo,
+    TypeReport,
+    analyze_types,
+    get_return_types,
+)
 from injection.exceptions import (
     InjectionError,
     ModuleError,
@@ -44,13 +49,18 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Mode", "Module", "Priority")
+__all__ = (
+    "Injectable",
+    "InjectableFactory",
+    "Mode",
+    "ModeStr",
+    "Module",
+    "Priority",
+    "PriorityStr",
+)
 
 _logger = logging.getLogger(__name__)
 
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
-
 """
 Events
 """
@@ -63,12 +73,12 @@ class ContainerEvent(Event, ABC):
 
 @dataclass(frozen=True, slots=True)
 class ContainerDependenciesUpdated(ContainerEvent):
-    classes: Collection[type]
+    reports: Collection[TypeReport]
     mode: Mode
 
     def __str__(self) -> str:
-        length = len(self.classes)
-        formatted_classes = ", ".join(f"`{format_type(cls)}`" for cls in self.classes)
+        length = len(self.reports)
+        formatted_classes = ", ".join(f"`{report.cls}`" for report in self.reports)
         return (
             f"{length} container dependenc{'ies' if length > 1 else 'y'} have been "
             f"updated{f': {formatted_classes}' if formatted_classes else ''}."
@@ -134,12 +144,9 @@ Injectables
 
 
 @runtime_checkable
-class Injectable(Protocol[_T_co]):
+class Injectable[T](Protocol):
     __slots__ = ()
 
-    def __init__(self, __factory: Callable[[], _T_co] = None, /):
-        pass
-
     @property
     def is_locked(self) -> bool:
         return False
@@ -148,23 +155,23 @@ class Injectable(Protocol[_T_co]):
         return
 
     @abstractmethod
-    def get_instance(self) -> _T_co:
+    def get_instance(self) -> T:
         raise NotImplementedError
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class BaseInjectable(Injectable[_T], ABC):
-    factory: Callable[[], _T]
+class BaseInjectable[T](Injectable[T], ABC):
+    factory: Callable[[], T]
 
 
-class NewInjectable(BaseInjectable[_T]):
+class NewInjectable[T](BaseInjectable[T]):
     __slots__ = ()
 
-    def get_instance(self) -> _T:
+    def get_instance(self) -> T:
         return self.factory()
 
 
-class SingletonInjectable(BaseInjectable[_T]):
+class SingletonInjectable[T](BaseInjectable[T]):
     __slots__ = ("__dict__",)
 
     __INSTANCE_KEY: ClassVar[str] = "$instance"
@@ -180,7 +187,7 @@ class SingletonInjectable(BaseInjectable[_T]):
     def unlock(self):
         self.cache.clear()
 
-    def get_instance(self) -> _T:
+    def get_instance(self) -> T:
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
@@ -192,11 +199,11 @@ class SingletonInjectable(BaseInjectable[_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(Injectable[_T]):
-    cls: type[_T]
+class ShouldBeInjectable[T](Injectable[T]):
+    cls: type[T]
 
     def get_instance(self) -> NoReturn:
-        raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
+        raise InjectionError(f"`{self.cls}` should be an injectable.")
 
 
 """
@@ -209,7 +216,7 @@ class Broker(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+    def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
         raise NotImplementedError
 
     @abstractmethod
@@ -222,7 +229,7 @@ class Broker(Protocol):
         raise NotImplementedError
 
     @abstractmethod
-    def unlock(self):
+    def unlock(self) -> Self:
         raise NotImplementedError
 
 
@@ -231,7 +238,7 @@ Container
 """
 
 
-class Mode(str, Enum):
+class Mode(StrEnum):
     FALLBACK = "fallback"
     NORMAL = "normal"
     OVERRIDE = "override"
@@ -241,36 +248,37 @@ class Mode(str, Enum):
         return tuple(type(self)).index(self)
 
     @classmethod
-    def get_default(cls):
+    def get_default(cls) -> Mode:
         return cls.NORMAL
 
 
-ModeStr = Literal["fallback", "normal", "override"]
+type ModeStr = Literal["fallback", "normal", "override"]
 
 
-class Record(NamedTuple):
-    injectable: Injectable
+class Record[T](NamedTuple):
+    injectable: Injectable[T]
     mode: Mode
 
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Container(Broker):
-    __records: dict[type, Record] = field(default_factory=dict, init=False)
+    __records: dict[TypeReport, Record] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
-        for cls in get_origins(cls):
-            try:
-                injectable, _ = self.__records[cls]
-            except KeyError:
-                continue
+    def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
+        for report in analyze_types(cls):
+            for scoped_report in dict.fromkeys((report, report.no_args)):
+                try:
+                    injectable, _ = self.__records[scoped_report]
+                except KeyError:
+                    continue
 
-            return injectable
+                return injectable
 
         raise NoInjectable(cls)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
-        return any(cls in self.__records for cls in get_origins(cls))
+        return any(report in self.__records for report in analyze_types(cls))
 
     @property
     def is_locked(self) -> bool:
@@ -281,16 +289,16 @@ class Container(Broker):
         return frozenset(injectable for injectable, _ in self.__records.values())
 
     @synchronized()
-    def update(
+    def update[T](
         self,
-        classes: Iterable[type | UnionType],
-        injectable: Injectable,
+        classes: Iterable[type[T] | UnionType],
+        injectable: Injectable[T],
         mode: Mode | ModeStr,
-    ):
+    ) -> Self:
         mode = Mode(mode)
         records = {
-            cls: Record(injectable, mode)
-            for cls in self.__classes_to_update(classes, mode)
+            report: Record(injectable, mode)
+            for report in self.__prepare_reports_for_updating(classes, mode)
         }
 
         if records:
@@ -302,43 +310,43 @@ class Container(Broker):
         return self
 
     @synchronized()
-    def unlock(self):
+    def unlock(self) -> Self:
         for injectable in self.__injectables:
             injectable.unlock()
 
         return self
 
-    def add_listener(self, listener: EventListener):
+    def add_listener(self, listener: EventListener) -> Self:
         self.__channel.add_listener(listener)
         return self
 
-    def notify(self, event: Event):
+    def notify(self, event: Event) -> ContextManager:
         return self.__channel.dispatch(event)
 
-    def __classes_to_update(
+    def __prepare_reports_for_updating(
         self,
         classes: Iterable[type | UnionType],
         mode: Mode,
-    ) -> Iterator[type]:
+    ) -> Iterator[TypeReport]:
         rank = mode.rank
 
-        for cls in frozenset(get_origins(*classes)):
+        for report in frozenset(analyze_types(*classes)):
             try:
-                _, current_mode = self.__records[cls]
+                _, current_mode = self.__records[report]
 
             except KeyError:
                 pass
 
             else:
-                if mode == current_mode:
+                if mode == current_mode and mode != Mode.OVERRIDE:
                     raise RuntimeError(
-                        f"An injectable already exists for the class `{format_type(cls)}`."
+                        f"An injectable already exists for the class `{report.cls}`."
                     )
 
                 elif rank < current_mode.rank:
                     continue
 
-            yield cls
+            yield report
 
 
 """
@@ -346,16 +354,18 @@ Module
 """
 
 
-class Priority(str, Enum):
+class Priority(StrEnum):
     LOW = "low"
     HIGH = "high"
 
     @classmethod
-    def get_default(cls):
+    def get_default(cls) -> Priority:
         return cls.LOW
 
 
-PriorityStr = Literal["low", "high"]
+type PriorityStr = Literal["low", "high"]
+
+type InjectableFactory[T] = Callable[[Callable[..., T]], Injectable[T]]
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -371,14 +381,14 @@ class Module(EventListener, Broker):
     def __post_init__(self):
         self.__container.add_listener(self)
 
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+    def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
         for broker in self.__brokers:
             with suppress(KeyError):
                 return broker[cls]
 
         raise NoInjectable(cls)
 
-    def __setitem__(self, cls: type | UnionType, injectable: Injectable, /):
+    def __setitem__[T](self, cls: type[T] | UnionType, injectable: Injectable[T], /):
         self.update((cls,), injectable)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
@@ -396,20 +406,20 @@ class Module(EventListener, Broker):
         yield from tuple(self.__modules)
         yield self.__container
 
-    def injectable(
+    def injectable[T](
         self,
-        wrapped: Callable[..., Any] = None,
+        wrapped: Callable[..., T] = None,
         /,
         *,
-        cls: type[Injectable] = NewInjectable,
+        cls: InjectableFactory[T] = NewInjectable,
         inject: bool = True,
-        on: type | Iterable[type] | UnionType = (),
+        on: TypeInfo[T] = (),
         mode: Mode | ModeStr = Mode.get_default(),
     ):
         def decorator(wp):
             factory = self.inject(wp, return_factory=True) if inject else wp
             injectable = cls(factory)
-            classes = find_types(wp, on)
+            classes = get_return_types(wp, on)
             self.update(classes, injectable, mode)
             return wp
 
@@ -428,18 +438,18 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def set_constant(
+    def set_constant[T](
         self,
-        instance: _T,
-        on: type | Iterable[type] | UnionType = (),
+        instance: T,
+        on: TypeInfo[T] = (),
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-    ) -> _T:
+    ) -> T:
         cls = type(instance)
         self.injectable(
             lambda: instance,
             inject=False,
-            on=(cls, on),  # type: ignore
+            on=(cls, on),
             mode=mode,
         )
         return instance
@@ -467,22 +477,22 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def resolve(self, cls: type[_T]) -> _T:
+    def resolve[T](self, cls: type[T]) -> T:
         injectable = self[cls]
         return injectable.get_instance()
 
-    def get_instance(self, cls: type[_T]) -> _T | None:
+    def get_instance[T](self, cls: type[T]) -> T | None:
         try:
             return self.resolve(cls)
         except KeyError:
             return None
 
-    def get_lazy_instance(
+    def get_lazy_instance[T](
         self,
-        cls: type[_T],
+        cls: type[T],
         *,
         cache: bool = False,
-    ) -> Invertible[_T | None]:
+    ) -> Invertible[T | None]:
         if cache:
             return Lazy(lambda: self.get_instance(cls))
 
@@ -490,21 +500,30 @@ class Module(EventListener, Broker):
         function.set_owner(cls)
         return SimpleInvertible(function)
 
-    def update(
+    def update[T](
         self,
-        classes: Iterable[type | UnionType],
-        injectable: Injectable,
+        classes: Iterable[type[T] | UnionType],
+        injectable: Injectable[T],
         mode: Mode | ModeStr = Mode.get_default(),
-    ):
+    ) -> Self:
         self.__container.update(classes, injectable, mode)
         return self
 
+    def init_modules(self, *modules: Module) -> Self:
+        for module in tuple(self.__modules):
+            self.stop_using(module)
+
+        for module in modules:
+            self.use(module)
+
+        return self
+
     def use(
         self,
         module: Module,
         *,
         priority: Priority | PriorityStr = Priority.get_default(),
-    ):
+    ) -> Self:
         if module is self:
             raise ModuleError("Module can't be used by itself.")
 
@@ -521,7 +540,7 @@ class Module(EventListener, Broker):
 
         return self
 
-    def stop_using(self, module: Module):
+    def stop_using(self, module: Module) -> Self:
         event = ModuleRemoved(self, module)
 
         with suppress(KeyError):
@@ -542,7 +561,7 @@ class Module(EventListener, Broker):
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: Priority | PriorityStr):
+    def change_priority(self, module: Module, priority: Priority | PriorityStr) -> Self:
         priority = Priority(priority)
         event = ModulePriorityUpdated(self, module, priority)
 
@@ -552,17 +571,17 @@ class Module(EventListener, Broker):
         return self
 
     @synchronized()
-    def unlock(self):
+    def unlock(self) -> Self:
         for broker in self.__brokers:
             broker.unlock()
 
         return self
 
-    def add_listener(self, listener: EventListener):
+    def add_listener(self, listener: EventListener) -> Self:
         self.__channel.add_listener(listener)
         return self
 
-    def remove_listener(self, listener: EventListener):
+    def remove_listener(self, listener: EventListener) -> Self:
         self.__channel.remove_listener(listener)
         return self
 
@@ -621,15 +640,15 @@ class Dependencies:
         return OrderedDict(self)
 
     @classmethod
-    def from_mapping(cls, mapping: Mapping[str, Injectable]):
+    def from_mapping(cls, mapping: Mapping[str, Injectable]) -> Self:
         return cls(mapping=mapping)
 
     @classmethod
-    def empty(cls):
+    def empty(cls) -> Self:
         return cls.from_mapping({})
 
     @classmethod
-    def resolve(cls, signature: Signature, module: Module, owner: type = None):
+    def resolve(cls, signature: Signature, module: Module, owner: type = None) -> Self:
         dependencies = LazyMapping(cls.__resolver(signature, module, owner))
         return cls.from_mapping(dependencies)
 
@@ -705,7 +724,7 @@ class InjectedFunction(EventListener):
         arguments = self.bind(args, kwargs)
         return self.wrapped(*arguments.args, **arguments.kwargs)
 
-    def __get__(self, instance: object = None, owner: type = None):
+    def __get__(self, instance: object = None, owner: type = None) -> Self | MethodType:
         if instance is None:
             return self
 
@@ -739,7 +758,7 @@ class InjectedFunction(EventListener):
         )
         return Arguments(bound.args, bound.kwargs)
 
-    def set_owner(self, owner: type):
+    def set_owner(self, owner: type) -> Self:
         if self.__dependencies.are_resolved:
             raise TypeError(
                 "Function owner must be assigned before dependencies are resolved."
@@ -752,7 +771,7 @@ class InjectedFunction(EventListener):
         return self
 
     @synchronized()
-    def update(self, module: Module):
+    def update(self, module: Module) -> Self:
         self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
         return self
 
@@ -764,7 +783,7 @@ class InjectedFunction(EventListener):
         return decorator(wrapped) if wrapped else decorator
 
     @singledispatchmethod
-    def on_event(self, event: Event, /) -> ContextManager | None:  # type: ignore
+    def on_event(self, event: Event, /) -> None:  # type: ignore
         return None
 
     @on_event.register
@@ -773,7 +792,7 @@ class InjectedFunction(EventListener):
         yield
         self.update(event.on_module)
 
-    def __set_signature(self):
+    def __set_signature(self) -> Self:
         self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self
 

{python_injection-0.8.5 → python_injection-0.9.0}/injection/exceptions.py

@@ -1,7 +1,5 @@
 from typing import Any
 
-from injection.common.tools.type import format_type
-
 __all__ = (
     "InjectionError",
     "NoInjectable",
@@ -15,15 +13,15 @@ class InjectionError(Exception):
     pass
 
 
-class NoInjectable(KeyError, InjectionError):
+class NoInjectable[T](KeyError, InjectionError):
     __slots__ = ("__class",)
 
-    def __init__(self, cls: type | Any):
-        super().__init__(f"No injectable for `{format_type(cls)}`.")
+    def __init__(self, cls: type[T] | Any):
+        super().__init__(f"No injectable for `{cls}`.")
         self.__class = cls
 
     @property
-    def cls(self) -> type:
+    def cls(self) -> type[T]:
         return self.__class
 
 

{python_injection-0.8.5 → python_injection-0.9.0}/injection/integrations/blacksheep.py

@@ -1,4 +1,4 @@
-from typing import Any, TypeVar
+from typing import Any
 
 from rodi import ContainerProtocol
 
@@ -6,8 +6,6 @@ from injection import Module, default_module
 
 __all__ = ("InjectionServices",)
 
-_T = TypeVar("_T")
-
 
 class InjectionServices(ContainerProtocol):
     """
@@ -26,5 +24,5 @@ class InjectionServices(ContainerProtocol):
         self.__module.injectable(obj_type)
         return self
 
-    def resolve(self, obj_type: type[_T] | Any, *args, **kwargs) -> _T:
+    def resolve[T](self, obj_type: type[T] | Any, *args, **kwargs) -> T:
         return self.__module.resolve(obj_type)

{python_injection-0.8.5 → python_injection-0.9.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.5"
+version = "0.9.0"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -10,7 +10,7 @@ readme = "documentation/basic-usage.md"
 repository = "https://github.com/100nm/python-injection"
 
 [tool.poetry.dependencies]
-python = ">=3.10, <4"
+python = ">=3.12, <4"
 
 [tool.poetry.group.dev.dependencies]
 argon2-cffi = "*"
@@ -32,6 +32,7 @@ exclude_lines = [
 
 [tool.mypy]
 check_untyped_defs = true
+enable_incomplete_feature = ["NewGenericSyntax"]
 exclude = [
     "documentation/example/",
     "tests/",

python_injection-0.8.5/injection/common/tools/type.py

@@ -1,48 +0,0 @@
-from collections.abc import Iterable, Iterator
-from inspect import get_annotations, isfunction
-from types import NoneType, UnionType
-from typing import Annotated, Any, Union, get_args, get_origin
-
-__all__ = ("find_types", "format_type", "get_origins")
-
-
-def format_type(cls: type | Any) -> str:
-    try:
-        return f"{cls.__module__}.{cls.__qualname__}"
-    except AttributeError:
-        return str(cls)
-
-
-def get_origins(*types: type | Any) -> Iterator[type | Any]:
-    for tp in types:
-        origin = get_origin(tp) or tp
-
-        if origin in (None, NoneType):
-            continue
-
-        elif origin in (Union, UnionType):
-            args = get_args(tp)
-
-        elif origin is Annotated is not tp:
-            args = get_args(tp)[:1]
-
-        else:
-            yield origin
-            continue
-
-        yield from get_origins(*args)
-
-
-def find_types(*args: Any) -> Iterator[type | UnionType]:
-    for argument in args:
-        if isinstance(argument, Iterable) and not isinstance(argument, type | str):
-            arguments = argument
-
-        elif isfunction(argument):
-            arguments = (get_annotations(argument, eval_str=True).get("return"),)
-
-        else:
-            yield argument
-            continue
-
-        yield from find_types(*arguments)