python-injection 0.8.2__tar.gz → 0.8.4__tar.gz

{python_injection-0.8.2 → python_injection-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.2
+Version: 0.8.4
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -136,7 +136,7 @@ class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
-If a class is registered in a package and you want to override it, there is the `mode` parameter:
+If a class is registered in a package, and you want to override it, there is the `mode` parameter:
 
 ```python
 @injectable

{python_injection-0.8.2 → python_injection-0.8.4}/documentation/basic-usage.md

@@ -119,7 +119,7 @@ class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
-If a class is registered in a package and you want to override it, there is the `mode` parameter:
+If a class is registered in a package, and you want to override it, there is the `mode` parameter:
 
 ```python
 @injectable

{python_injection-0.8.2 → python_injection-0.8.4}/injection/__init__.py

@@ -1,8 +1,12 @@
 from .core import Injectable, Module
+from .core import Mode as InjectableMode
+from .core import Priority as ModulePriority
 
 __all__ = (
     "Injectable",
+    "InjectableMode",
     "Module",
+    "ModulePriority",
     "default_module",
     "get_instance",
     "get_lazy_instance",

{python_injection-0.8.2 → python_injection-0.8.4}/injection/__init__.pyi

@@ -1,6 +1,7 @@
 from abc import abstractmethod
 from collections.abc import Callable, Iterable
 from contextlib import ContextDecorator
+from enum import Enum
 from types import UnionType
 from typing import (
     Any,
@@ -15,7 +16,8 @@ from typing import (
 
 from .common.invertible import Invertible
 
-_T = TypeVar("_T")
+_In_T = TypeVar("_In_T", covariant=False)
+_Co_T = TypeVar("_Co_T", covariant=True)
 
 default_module: Final[Module] = ...
 
@@ -54,7 +56,7 @@ class Module:
         cls: type[Injectable] = ...,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        mode: Literal["fallback", "normal", "override"] = ...,
+        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -69,7 +71,7 @@ class Module:
         *,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        mode: Literal["fallback", "normal", "override"] = ...,
+        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -86,30 +88,35 @@ class Module:
 
     def set_constant(
         self,
-        instance: _T,
+        instance: _In_T,
         on: type | Iterable[type] | UnionType = ...,
         *,
-        mode: Literal["fallback", "normal", "override"] = ...,
-    ) -> _T:
+        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
+    ) -> _In_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 get_instance(self, cls: type[_T], *, none: bool = ...) -> _T | None:
+    def resolve(self, cls: type[_In_T]) -> _In_T:
         """
         Function used to retrieve an instance associated with the type passed in
-        parameter or return `None` but if `none` parameter is `False` an exception
-        will be raised.
+        parameter or an exception will be raised.
+        """
+
+    def get_instance(self, cls: type[_In_T]) -> _In_T | None:
+        """
+        Function used to retrieve an instance associated with the type passed in
+        parameter or return `None`.
         """
 
     def get_lazy_instance(
         self,
-        cls: type[_T],
+        cls: type[_In_T],
         *,
         cache: bool = ...,
-    ) -> Invertible[_T | None]:
+    ) -> Invertible[_In_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
@@ -119,7 +126,12 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
-    def use(self, module: Module, *, priority: Literal["low", "high"] = ...):
+    def use(
+        self,
+        module: Module,
+        *,
+        priority: ModulePriority | Literal["low", "high"] = ...,
+    ):
         """
         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
@@ -135,13 +147,17 @@ class Module:
         self,
         module: Module,
         *,
-        priority: Literal["low", "high"] = ...,
+        priority: ModulePriority | Literal["low", "high"] = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
         """
 
-    def change_priority(self, module: Module, priority: Literal["low", "high"]):
+    def change_priority(
+        self,
+        module: Module,
+        priority: ModulePriority | Literal["low", "high"],
+    ):
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -155,11 +171,22 @@ class Module:
         Function to unlock the module by deleting cached instances of singletons.
         """
 
+@final
+class ModulePriority(str, Enum):
+    LOW = ...
+    HIGH = ...
+
 @runtime_checkable
-class Injectable(Protocol[_T]):
-    def __init__(self, factory: Callable[[], _T] = ..., /): ...
+class Injectable(Protocol[_Co_T]):
+    def __init__(self, factory: Callable[[], _Co_T] = ..., /): ...
     @property
     def is_locked(self) -> bool: ...
     def unlock(self): ...
     @abstractmethod
-    def get_instance(self) -> _T: ...
+    def get_instance(self) -> _Co_T: ...
+
+@final
+class InjectableMode(str, Enum):
+    FALLBACK = ...
+    NORMAL = ...
+    OVERRIDE = ...

{python_injection-0.8.2 → python_injection-0.8.4}/injection/common/event.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from contextlib import ContextDecorator, ExitStack, contextmanager, suppress
+from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
 from typing import ContextManager
 from weakref import WeakSet
@@ -24,7 +24,7 @@ class EventChannel:
     __listeners: WeakSet[EventListener] = field(default_factory=WeakSet, init=False)
 
     @contextmanager
-    def dispatch(self, event: Event) -> ContextManager | ContextDecorator:
+    def dispatch(self, event: Event):
         with ExitStack() as stack:
             for listener in tuple(self.__listeners):
                 context_manager = listener.on_event(event)

{python_injection-0.8.2 → python_injection-0.8.4}/injection/common/invertible.py

@@ -5,7 +5,7 @@ from typing import Protocol, TypeVar, runtime_checkable
 
 __all__ = ("Invertible", "SimpleInvertible")
 
-_T = TypeVar("_T")
+_T = TypeVar("_T", covariant=True)
 
 
 @runtime_checkable

python_injection-0.8.4/injection/common/tools/threading.py

@@ -0,0 +1,12 @@
+from contextlib import contextmanager
+from threading import RLock
+
+__all__ = ("synchronized",)
+
+__lock = RLock()
+
+
+@contextmanager
+def synchronized():
+    with __lock:
+        yield

{python_injection-0.8.2 → python_injection-0.8.4}/injection/common/tools/type.py

@@ -24,7 +24,7 @@ def get_origins(*types: type | Any) -> Iterator[type | Any]:
             args = get_args(tp)
 
         elif origin is Annotated is not tp:
-            args = (tp.__origin__,)
+            args = get_args(tp)[:1]
 
         else:
             yield origin

{python_injection-0.8.2 → python_injection-0.8.4}/injection/core/module.py

@@ -12,8 +12,9 @@ from collections.abc import (
     Mapping,
     MutableMapping,
 )
-from contextlib import ContextDecorator, contextmanager, suppress
+from contextlib import contextmanager, suppress
 from dataclasses import dataclass, field
+from enum import Enum
 from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
 from types import MethodType, UnionType
@@ -26,8 +27,6 @@ from typing import (
     NoReturn,
     Protocol,
     TypeVar,
-    cast,
-    get_args,
     runtime_checkable,
 )
 
@@ -45,21 +44,12 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Module")
+__all__ = ("Injectable", "Mode", "Module", "Priority")
 
 _logger = logging.getLogger(__name__)
 
-_T = TypeVar("_T")
-_Types = Iterable[type] | UnionType
-
-
-"""
-Literal types
-"""
-
-
-_Mode = Literal["fallback", "normal", "override"]
-_Priority = Literal["low", "high"]
+_In_T = TypeVar("_In_T", covariant=False)
+_Co_T = TypeVar("_Co_T", covariant=True)
 
 
 """
@@ -75,7 +65,7 @@ class ContainerEvent(Event, ABC):
 @dataclass(frozen=True, slots=True)
 class ContainerDependenciesUpdated(ContainerEvent):
     classes: Collection[type]
-    mode: _Mode
+    mode: Mode
 
     def __str__(self) -> str:
         length = len(self.classes)
@@ -113,6 +103,7 @@ class ModuleEventProxy(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModuleAdded(ModuleEvent):
     module_added: Module
+    priority: Priority
 
     def __str__(self) -> str:
         return f"`{self.on_module}` now uses `{self.module_added}`."
@@ -129,7 +120,7 @@ class ModuleRemoved(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModulePriorityUpdated(ModuleEvent):
     module_updated: Module
-    priority: _Priority
+    priority: Priority
 
     def __str__(self) -> str:
         return (
@@ -144,10 +135,10 @@ Injectables
 
 
 @runtime_checkable
-class Injectable(Protocol[_T]):
+class Injectable(Protocol[_Co_T]):
     __slots__ = ()
 
-    def __init__(self, __factory: Callable[[], _T] = None, /):
+    def __init__(self, __factory: Callable[[], _Co_T] = None, /):
         pass
 
     @property
@@ -155,26 +146,26 @@ class Injectable(Protocol[_T]):
         return False
 
     def unlock(self):
-        pass
+        return
 
     @abstractmethod
-    def get_instance(self) -> _T:
+    def get_instance(self) -> _Co_T:
         raise NotImplementedError
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class BaseInjectable(Injectable[_T], ABC):
-    factory: Callable[[], _T]
+class BaseInjectable(Injectable[_In_T], ABC):
+    factory: Callable[[], _In_T]
 
 
-class NewInjectable(BaseInjectable[_T]):
+class NewInjectable(BaseInjectable[_In_T]):
     __slots__ = ()
 
-    def get_instance(self) -> _T:
+    def get_instance(self) -> _In_T:
         return self.factory()
 
 
-class SingletonInjectable(BaseInjectable[_T]):
+class SingletonInjectable(BaseInjectable[_In_T]):
     __slots__ = ("__dict__",)
 
     __INSTANCE_KEY: ClassVar[str] = "$instance"
@@ -190,7 +181,7 @@ class SingletonInjectable(BaseInjectable[_T]):
     def unlock(self):
         self.cache.clear()
 
-    def get_instance(self) -> _T:
+    def get_instance(self) -> _In_T:
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
@@ -202,8 +193,8 @@ class SingletonInjectable(BaseInjectable[_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(Injectable[_T]):
-    cls: type[_T]
+class ShouldBeInjectable(Injectable[_In_T]):
+    cls: type[_In_T]
 
     def get_instance(self) -> NoReturn:
         raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
@@ -219,7 +210,7 @@ class Broker(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
         raise NotImplementedError
 
     @abstractmethod
@@ -241,20 +232,37 @@ Container
 """
 
 
+class Mode(str, Enum):
+    FALLBACK = "fallback"
+    NORMAL = "normal"
+    OVERRIDE = "override"
+
+    @property
+    def rank(self) -> int:
+        return tuple(type(self)).index(self)
+
+    @classmethod
+    def get_default(cls):
+        return cls.NORMAL
+
+
+ModeStr = Literal["fallback", "normal", "override"]
+
+
 class Record(NamedTuple):
     injectable: Injectable
-    mode: _Mode
+    mode: Mode
 
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Container(Broker):
-    __data: dict[type, Record] = field(default_factory=dict, init=False)
+    __records: dict[type, Record] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
         for cls in get_origins(cls):
             try:
-                injectable, _ = self.__data[cls]
+                injectable, _ = self.__records[cls]
             except KeyError:
                 continue
 
@@ -263,7 +271,7 @@ class Container(Broker):
         raise NoInjectable(cls)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
-        return any(cls in self.__data for cls in get_origins(cls))
+        return any(cls in self.__records for cls in get_origins(cls))
 
     @property
     def is_locked(self) -> bool:
@@ -271,10 +279,16 @@ class Container(Broker):
 
     @property
     def __injectables(self) -> frozenset[Injectable]:
-        return frozenset(injectable for injectable, _ in self.__data.values())
+        return frozenset(injectable for injectable, _ in self.__records.values())
 
     @synchronized()
-    def update(self, classes: Iterable[type], injectable: Injectable, mode: _Mode):
+    def update(
+        self,
+        classes: Iterable[type | UnionType],
+        injectable: Injectable,
+        mode: Mode | ModeStr,
+    ):
+        mode = Mode(mode)
         records = {
             cls: Record(injectable, mode)
             for cls in self.__filter_classes(classes, mode)
@@ -284,7 +298,7 @@ class Container(Broker):
             event = ContainerDependenciesUpdated(self, records.keys(), mode)
 
             with self.notify(event):
-                self.__data.update(records)
+                self.__records.update(records)
 
         return self
 
@@ -299,16 +313,19 @@ class Container(Broker):
         self.__channel.add_listener(listener)
         return self
 
-    def notify(self, event: Event) -> ContextManager | ContextDecorator:
+    def notify(self, event: Event):
         return self.__channel.dispatch(event)
 
-    def __filter_classes(self, classes: Iterable[type], mode: _Mode) -> Iterator[type]:
-        modes = get_args(_Mode)
-        rank = modes.index(mode)
+    def __filter_classes(
+        self,
+        classes: Iterable[type | UnionType],
+        mode: Mode,
+    ) -> Iterator[type]:
+        rank = mode.rank
 
         for cls in frozenset(get_origins(*classes)):
             try:
-                _, current_mode = self.__data[cls]
+                _, current_mode = self.__records[cls]
 
             except KeyError:
                 pass
@@ -319,7 +336,7 @@ class Container(Broker):
                         f"An injectable already exists for the class `{format_type(cls)}`."
                     )
 
-                elif rank < modes.index(current_mode):
+                elif rank < current_mode.rank:
                     continue
 
             yield cls
@@ -330,9 +347,21 @@ Module
 """
 
 
+class Priority(str, Enum):
+    LOW = "low"
+    HIGH = "high"
+
+    @classmethod
+    def get_default(cls):
+        return cls.LOW
+
+
+PriorityStr = Literal["low", "high"]
+
+
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class Module(EventListener, Broker):
-    name: str = field(default=None)
+    name: str | None = field(default=None)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
     __container: Container = field(default_factory=Container, init=False)
     __modules: OrderedDict[Module, None] = field(
@@ -343,7 +372,7 @@ class Module(EventListener, Broker):
     def __post_init__(self):
         self.__container.add_listener(self)
 
-    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
         for broker in self.__brokers:
             with suppress(KeyError):
                 return broker[cls]
@@ -375,8 +404,8 @@ class Module(EventListener, Broker):
         *,
         cls: type[Injectable] = NewInjectable,
         inject: bool = True,
-        on: type | _Types = None,
-        mode: _Mode = "normal",
+        on: type | Iterable[type] | UnionType = (),
+        mode: Mode | ModeStr = Mode.get_default(),
     ):
         def decorator(wp):
             factory = self.inject(wp, return_factory=True) if inject else wp
@@ -394,7 +423,7 @@ class Module(EventListener, Broker):
             self.update(
                 (wp,),
                 ShouldBeInjectable(wp),
-                mode="fallback",
+                mode=Mode.FALLBACK,
             )
             return wp
 
@@ -402,16 +431,16 @@ class Module(EventListener, Broker):
 
     def set_constant(
         self,
-        instance: _T,
-        on: type | _Types = None,
+        instance: _In_T,
+        on: type | Iterable[type] | UnionType = (),
         *,
-        mode: _Mode = "normal",
-    ) -> _T:
+        mode: Mode | ModeStr = Mode.get_default(),
+    ) -> _In_T:
         cls = type(instance)
         self.injectable(
             lambda: instance,
             inject=False,
-            on=(cls, on),
+            on=(cls, on),  # type: ignore
             mode=mode,
         )
         return instance
@@ -439,24 +468,22 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def get_instance(self, cls: type[_T], *, none: bool = True) -> _T | None:
-        try:
-            injectable = self[cls]
-        except KeyError as exc:
-            if none:
-                return None
-
-            raise exc
+    def resolve(self, cls: type[_In_T]) -> _In_T:
+        injectable = self[cls]
+        return injectable.get_instance()
 
-        instance = injectable.get_instance()
-        return cast(cls, instance)
+    def get_instance(self, cls: type[_In_T]) -> _In_T | None:
+        try:
+            return self.resolve(cls)
+        except KeyError:
+            return None
 
     def get_lazy_instance(
         self,
-        cls: type[_T],
+        cls: type[_In_T],
         *,
         cache: bool = False,
-    ) -> Invertible[_T | None]:
+    ) -> Invertible[_In_T | None]:
         if cache:
             return Lazy(lambda: self.get_instance(cls))
 
@@ -466,21 +493,27 @@ class Module(EventListener, Broker):
 
     def update(
         self,
-        classes: Iterable[type],
+        classes: Iterable[type | UnionType],
         injectable: Injectable,
-        mode: _Mode = "normal",
+        mode: Mode | ModeStr = Mode.get_default(),
     ):
         self.__container.update(classes, injectable, mode)
         return self
 
-    def use(self, module: Module, *, priority: _Priority = "low"):
+    def use(
+        self,
+        module: Module,
+        *,
+        priority: Priority | PriorityStr = Priority.get_default(),
+    ):
         if module is self:
             raise ModuleError("Module can't be used by itself.")
 
         if module in self.__modules:
             raise ModuleError(f"`{self}` already uses `{module}`.")
 
-        event = ModuleAdded(self, module)
+        priority = Priority(priority)
+        event = ModuleAdded(self, module, priority)
 
         with self.notify(event):
             self.__modules[module] = None
@@ -504,13 +537,14 @@ class Module(EventListener, Broker):
         self,
         module: Module,
         *,
-        priority: _Priority = "low",
-    ) -> ContextManager | ContextDecorator:
+        priority: Priority | PriorityStr = Priority.get_default(),
+    ):
         self.use(module, priority=priority)
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: _Priority):
+    def change_priority(self, module: Module, priority: Priority | PriorityStr):
+        priority = Priority(priority)
         event = ModulePriorityUpdated(self, module, priority)
 
         with self.notify(event):
@@ -538,7 +572,7 @@ class Module(EventListener, Broker):
         return self.notify(self_event)
 
     @contextmanager
-    def notify(self, event: Event) -> ContextManager | ContextDecorator:
+    def notify(self, event: Event):
         self.__check_locking()
 
         with self.__channel.dispatch(event):
@@ -549,8 +583,8 @@ class Module(EventListener, Broker):
         if self.is_locked:
             raise ModuleLockError(f"`{self}` is locked.")
 
-    def __move_module(self, module: Module, priority: _Priority):
-        last = priority != "high"
+    def __move_module(self, module: Module, priority: Priority):
+        last = priority != Priority.HIGH
 
         try:
             self.__modules.move_to_end(module, last=last)
@@ -609,7 +643,7 @@ class Dependencies:
     ) -> Iterator[tuple[str, Injectable]]:
         for name, annotation in cls.__get_annotations(signature, owner):
             try:
-                injectable = module[annotation]
+                injectable: Injectable = module[annotation]
             except KeyError:
                 continue
 
@@ -646,32 +680,25 @@ class InjectedFunction(EventListener):
     )
 
     def __init__(self, wrapped: Callable[..., Any], /):
-        try:
-            variables = vars(wrapped)
-        except TypeError:
-            pass
-        else:
-            self.__update_vars(variables)
-            del variables
-
+        self.__update_vars_from(wrapped)
         update_wrapper(self, wrapped, updated=())
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
         self.on_setup(self.__set_signature)
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         return repr(self.wrapped)
 
-    def __str__(self) -> str:
+    def __str__(self) -> str:  # pragma: no cover
         return str(self.wrapped)
 
     def __call__(self, /, *args, **kwargs) -> Any:
         for function in self.__setup_queue:
             function()
 
-        args, kwargs = self.bind(args, kwargs)
-        return self.wrapped(*args, **kwargs)
+        arguments = self.bind(args, kwargs)
+        return self.wrapped(*arguments.args, **arguments.kwargs)
 
     def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
@@ -688,7 +715,7 @@ class InjectedFunction(EventListener):
 
     @property
     def wrapped(self) -> Callable[..., Any]:
-        return self.__wrapped__
+        return self.__wrapped__  # type: ignore
 
     def bind(
         self,
@@ -716,7 +743,7 @@ class InjectedFunction(EventListener):
         if self.__owner:
             raise TypeError("Function owner is already defined.")
 
-        self.__owner = owner
+        self.__owner = owner  # type: ignore
         return self
 
     @synchronized()
@@ -732,12 +759,12 @@ class InjectedFunction(EventListener):
         return decorator(wrapped) if wrapped else decorator
 
     @singledispatchmethod
-    def on_event(self, event: Event, /):
-        pass
+    def on_event(self, event: Event, /) -> ContextManager | None:  # type: ignore
+        return None
 
     @on_event.register
     @contextmanager
-    def _(self, event: ModuleEvent, /) -> ContextManager:
+    def _(self, event: ModuleEvent, /):
         yield
         self.update(event.on_module)
 
@@ -745,14 +772,21 @@ class InjectedFunction(EventListener):
         self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self
 
-    def __update_vars(self, variables: Mapping[str, Any], /):
+    def __update_vars_from(self, obj: Any):
+        try:
+            variables = vars(obj)
+        except TypeError:
+            pass
+        else:
+            self.__update_vars(variables)
+
+    def __update_vars(self, variables: Mapping[str, Any]):
         def is_dunder(var: str) -> bool:
             return var.startswith("__") and var.endswith("__")
 
         restricted_vars = frozenset(var for var in dir(self) if not is_dunder(var))
-        variables = (
+        vars(self).update(
             (var, value)
             for var, value in variables.items()
             if var not in restricted_vars
         )
-        vars(self).update(variables)

{python_injection-0.8.2 → python_injection-0.8.4}/injection/exceptions.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from injection.common.tools.type import format_type
 
 __all__ = (
@@ -16,7 +18,7 @@ class InjectionError(Exception):
 class NoInjectable(KeyError, InjectionError):
     __slots__ = ("__class",)
 
-    def __init__(self, cls: type):
+    def __init__(self, cls: type | Any):
         super().__init__(f"No injectable for `{format_type(cls)}`.")
         self.__class = cls
 

python_injection-0.8.4/injection/integrations/blacksheep.py

@@ -0,0 +1,30 @@
+from typing import Any, TypeVar
+
+from rodi import ContainerProtocol
+
+from injection import Module, default_module
+
+__all__ = ("InjectionServices",)
+
+_T = TypeVar("_T")
+
+
+class InjectionServices(ContainerProtocol):
+    """
+    BlackSheep dependency injection container implemented with `python-injection`.
+    """
+
+    __slots__ = ("__module",)
+
+    def __init__(self, module: Module = default_module):
+        self.__module = module
+
+    def __contains__(self, item: Any) -> bool:
+        return item in self.__module
+
+    def register(self, obj_type: type | Any, *args, **kwargs):
+        self.__module.injectable(obj_type)
+        return self
+
+    def resolve(self, obj_type: type[_T] | Any, *args, **kwargs) -> _T:
+        return self.__module.resolve(obj_type)

{python_injection-0.8.2 → python_injection-0.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.2"
+version = "0.8.4"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -16,6 +16,7 @@ python = ">=3.10, <4"
 argon2-cffi = "*"
 blacksheep = "*"
 faker = "*"
+mypy = "*"
 pydantic = "*"
 pytest = "*"
 pytest-asyncio = "*"
@@ -29,6 +30,14 @@ exclude_lines = [
     "raise NotImplementedError",
 ]
 
+[tool.mypy]
+check_untyped_defs = true
+exclude = [
+    "documentation/example/",
+    "tests/",
+]
+implicit_optional = true
+
 [tool.pytest.ini_options]
 python_files = "test_*.py"
 addopts = "-p no:warnings --tb=short"

python_injection-0.8.2/injection/common/tools/threading.py

@@ -1,13 +0,0 @@
-from contextlib import ContextDecorator, contextmanager
-from threading import RLock
-from typing import ContextManager
-
-__all__ = ("synchronized",)
-
-__lock = RLock()
-
-
-@contextmanager
-def synchronized() -> ContextManager | ContextDecorator:
-    with __lock:
-        yield

python_injection-0.8.2/injection/integrations/blacksheep.py

@@ -1,28 +0,0 @@
-from typing import Any, TypeVar
-
-from injection import Module, default_module
-
-__all__ = ("InjectionServices",)
-
-_T = TypeVar("_T")
-
-
-class InjectionServices:
-    """
-    BlackSheep dependency injection container implemented with `python-injection`.
-    """
-
-    __slots__ = ("__module",)
-
-    def __init__(self, module: Module = default_module):
-        self.__module = module
-
-    def __contains__(self, cls: type | Any, /) -> bool:
-        return cls in self.__module
-
-    def register(self, cls: type | Any, *__args, **__kwargs):
-        self.__module.injectable(cls)
-        return self
-
-    def resolve(self, cls: type[_T] | Any, *__args, **__kwargs) -> _T:
-        return self.__module.get_instance(cls, none=False)