python-injection 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

injection/_pkg.py

@@ -1,9 +1,9 @@
-from .core import Injectable, Module, ModulePriorities
+from .core import Injectable, Module, ModulePriority
 
 __all__ = (
     "Injectable",
     "Module",
-    "ModulePriorities",
+    "ModulePriority",
     "default_module",
     "get_instance",
     "get_lazy_instance",

injection/_pkg.pyi

@@ -85,14 +85,7 @@ class Module:
         always be the same.
         """
 
-    def should_be_injectable(
-        self,
-        wrapped: Callable[..., Any] = ...,
-        /,
-        *,
-        on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
-    ):
+    def should_be_injectable(self, wrapped: type = ..., /):
         """
         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
@@ -128,7 +121,7 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
-    def use(self, module: Module, priority: ModulePriorities = ...):
+    def use(self, module: Module, priority: ModulePriority = ...):
         """
         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
@@ -143,13 +136,13 @@ class Module:
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriorities = ...,
+        priority: ModulePriority = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
         """
 
-    def change_priority(self, module: Module, priority: ModulePriorities):
+    def change_priority(self, module: Module, priority: ModulePriority):
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -164,7 +157,7 @@ class Module:
         """
 
 @final
-class ModulePriorities(Enum):
+class ModulePriority(Enum):
     HIGH = ...
     LOW = ...
 

injection/core/module.py

@@ -11,6 +11,7 @@ from collections.abc import (
     Iterator,
     Mapping,
     MutableMapping,
+    Set,
 )
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
@@ -41,7 +42,7 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Module", "ModulePriorities")
+__all__ = ("Injectable", "Module", "ModulePriority")
 
 _logger = logging.getLogger(__name__)
 _thread_lock = RLock()
@@ -117,7 +118,7 @@ class ModuleRemoved(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModulePriorityUpdated(ModuleEvent):
     module_updated: Module
-    priority: ModulePriorities
+    priority: ModulePriority
 
     def __str__(self) -> str:
         return (
@@ -135,13 +136,15 @@ Injectables
 class Injectable(Protocol[_T]):
     __slots__ = ()
 
-    def __init__(self, __factory: Callable[[], _T] = ..., /): ...
+    def __init__(self, __factory: Callable[[], _T] = None, /):
+        pass
 
     @property
     def is_locked(self) -> bool:
         return False
 
-    def unlock(self): ...
+    def unlock(self):
+        pass
 
     @abstractmethod
     def get_instance(self) -> _T:
@@ -187,31 +190,15 @@ class SingletonInjectable(BaseInjectable[_T]):
         return instance
 
 
-class InjectableWarning(BaseInjectable[_T], ABC):
-    __slots__ = ()
+@dataclass(repr=False, frozen=True, slots=True)
+class ShouldBeInjectable(Injectable[_T]):
+    cls: type[_T]
 
     def __bool__(self) -> bool:
         return False
 
-    @property
-    def formatted_type(self) -> str:
-        return format_type(self.factory)
-
-    @property
-    @abstractmethod
-    def exception(self) -> BaseException:
-        raise NotImplementedError
-
     def get_instance(self) -> NoReturn:
-        raise self.exception
-
-
-class ShouldBeInjectable(InjectableWarning[_T]):
-    __slots__ = ()
-
-    @property
-    def exception(self) -> BaseException:
-        return InjectionError(f"`{self.formatted_type}` should be an injectable.")
+        raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
 
 
 """
@@ -265,23 +252,30 @@ class Container(Broker):
     def is_locked(self) -> bool:
         return any(injectable.is_locked for injectable in self.__injectables)
 
+    @property
+    def __classes(self) -> frozenset[type]:
+        return frozenset(self.__data.keys())
+
     @property
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Types, injectable: Injectable, override: bool):
-        values = MappingProxyType(
-            {origin: injectable for origin in get_origins(*classes)}
-        )
+    def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
+        classes = frozenset(get_origins(*classes))
+
+        with _thread_lock:
+            if not injectable:
+                classes -= self.__classes
+                override = True
 
-        if values:
-            event = ContainerDependenciesUpdated(self, values, override)
+            if classes:
+                event = ContainerDependenciesUpdated(self, classes, override)
 
-            with self.notify(event):
-                if not override:
-                    self.__check_if_exists(*values)
+                with self.notify(event):
+                    if not override:
+                        self.__check_if_exists(classes)
 
-                self.__data.update(values)
+                    self.__data.update((cls, injectable) for cls in classes)
 
         return self
 
@@ -296,9 +290,11 @@ class Container(Broker):
     def notify(self, event: Event) -> ContextManager | ContextDecorator:
         return self.__channel.dispatch(event)
 
-    def __check_if_exists(self, *classes: type):
-        for cls in classes:
-            if self.__data.get(cls):
+    def __check_if_exists(self, classes: Set[type]):
+        intersection = classes & self.__classes
+
+        for cls in intersection:
+            if self.__data[cls]:
                 raise RuntimeError(
                     f"An injectable already exists for the class `{format_type(cls)}`."
                 )
@@ -309,7 +305,7 @@ Module
 """
 
 
-class ModulePriorities(Enum):
+class ModulePriority(Enum):
     HIGH = auto()
     LOW = auto()
 
@@ -339,7 +335,7 @@ class Module(EventListener, Broker):
         raise NoInjectable(cls)
 
     def __setitem__(self, cls: type | UnionType, injectable: Injectable, /):
-        self.update((cls,), injectable, override=True)
+        self.update((cls,), injectable)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
@@ -376,11 +372,13 @@ class Module(EventListener, Broker):
         return decorator(wrapped) if wrapped else decorator
 
     singleton = partialmethod(injectable, cls=SingletonInjectable)
-    should_be_injectable = partialmethod(
-        injectable,
-        cls=ShouldBeInjectable,
-        inject=False,
-    )
+
+    def should_be_injectable(self, wrapped: type = None, /):
+        def decorator(wp):
+            self[wp] = ShouldBeInjectable(wp)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
 
     def set_constant(
         self,
@@ -437,14 +435,19 @@ class Module(EventListener, Broker):
     def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         return Lazy(lambda: self.get_instance(cls))
 
-    def update(self, classes: Types, injectable: Injectable, override: bool = False):
+    def update(
+        self,
+        classes: Iterable[type],
+        injectable: Injectable,
+        override: bool = False,
+    ):
         self.__container.update(classes, injectable, override)
         return self
 
     def use(
         self,
         module: Module,
-        priority: ModulePriorities = ModulePriorities.get_default(),
+        priority: ModulePriority = ModulePriority.get_default(),
     ):
         if module is self:
             raise ModuleError("Module can't be used by itself.")
@@ -475,13 +478,13 @@ class Module(EventListener, Broker):
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriorities = ModulePriorities.get_default(),
+        priority: ModulePriority = ModulePriority.get_default(),
     ) -> ContextManager | ContextDecorator:
         self.use(module, priority)
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: ModulePriorities):
+    def change_priority(self, module: Module, priority: ModulePriority):
         event = ModulePriorityUpdated(self, module, priority)
 
         with self.notify(event):
@@ -517,8 +520,8 @@ class Module(EventListener, Broker):
         if self.is_locked:
             raise ModuleLockError(f"`{self}` is locked.")
 
-    def __move_module(self, module: Module, priority: ModulePriorities):
-        last = priority == ModulePriorities.LOW
+    def __move_module(self, module: Module, priority: ModulePriority):
+        last = priority == ModulePriority.LOW
 
         try:
             self.__modules.move_to_end(module, last=last)
@@ -617,11 +620,14 @@ class Binder(EventListener):
         return Arguments(bound.args, bound.kwargs)
 
     def update(self, module: Module):
-        self.__dependencies = Dependencies.resolve(self.__signature, module)
+        with _thread_lock:
+            self.__dependencies = Dependencies.resolve(self.__signature, module)
+
         return self
 
     @singledispatchmethod
-    def on_event(self, event: Event, /): ...
+    def on_event(self, event: Event, /):
+        pass
 
     @on_event.register
     @contextmanager

injection/exceptions.py

@@ -10,7 +10,7 @@ __all__ = (
 
 
 class InjectionError(Exception):
-    __slots__ = ()
+    pass
 
 
 class NoInjectable(KeyError, InjectionError):
@@ -26,12 +26,12 @@ class NoInjectable(KeyError, InjectionError):
 
 
 class ModuleError(InjectionError):
-    __slots__ = ()
+    pass
 
 
 class ModuleLockError(ModuleError):
-    __slots__ = ()
+    pass
 
 
 class ModuleNotUsedError(KeyError, ModuleError):
-    __slots__ = ()
+    pass

{python_injection-0.7.2.dist-info → python_injection-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.7.2
+Version: 0.7.4
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT

{python_injection-0.7.2.dist-info → python_injection-0.7.4.dist-info}/RECORD

@@ -1,18 +1,17 @@
 injection/__init__.py,sha256=9_AVJILxKIBiL_6KJSh2RRydgSHXH38uahAGD0S1-dI,20
-injection/_pkg.py,sha256=VOgHhc4YXs4g0jIhXnqYllI64szC_cyO05IC2qE5BBg,651
-injection/_pkg.pyi,sha256=LcSXTYS7Bg7oAECClxrTq-uoW_DwMQZ99ksksBTwks4,5474
+injection/_pkg.py,sha256=nMIRLAQG6096bcR2Mz1egxe5FItBUsw8zR9yzjt1HDM,647
+injection/_pkg.pyi,sha256=zxbidnUvr-8x7F8hLJUgEBzyefXtNW6Ajtuin6Z0cf8,5327
 injection/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/common/event.py,sha256=uFoGRnxxkohH53JEStn4tN2Pn79HlgGExh7VkXdBwVQ,1316
 injection/common/lazy.py,sha256=HIefQ1z7ivgU791MDSwBmUcdST3bOv0sivSMyR2DfHc,1493
 injection/common/tools/__init__.py,sha256=S2y9DaQ4EaTRty9fKpBtPXA7hSjkzgM5N2jFf5jcmJU,21
 injection/common/tools/_type.py,sha256=-zL0dtoVZme71Mscvav7iEWxY2-JltzNTekbWOCPSFo,1276
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=Rx3Ys1WrYpTBR7QNojpyn18wGettKxxqZdRh7_egP3M,16443
-injection/exceptions.py,sha256=wd4OxmpneGEmlZ0yeNBfnCYfPYqUksfbmA2mopLNm_s,688
+injection/core/module.py,sha256=lEBJ6QGjPyp7bwEWE0RrOr26yrpJr1GKqsA-EV2LOAM,16594
+injection/exceptions.py,sha256=lm79jrBkvK52BpcAo1kx7GeDCUtskNBRt9rQ6IE3B4A,648
 injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/integrations/blacksheep.py,sha256=vcLil1IccS7JtXpuVu7s2LqN5Zravfe_7xpAt5cTIU0,723
-injection/integrations/typer.py,sha256=XtQjQhcd7k-513Wp5cP-7ES8-uWI5iI1T1o4kIEFvjU,266
 injection/utils.py,sha256=_79aiciimZpuoUTz5lojKySUMMzpkU-e7SotiHIFTI8,676
-python_injection-0.7.2.dist-info/METADATA,sha256=JXgUMasRYS2Z-aFXtAuK7133_ziOkpO05YLZ2_exLF4,3433
-python_injection-0.7.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-python_injection-0.7.2.dist-info/RECORD,,
+python_injection-0.7.4.dist-info/METADATA,sha256=JXV2O9HN1D8LGa6CSA5KaQ4lDmm4flzuZioxG4z4hBY,3433
+python_injection-0.7.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+python_injection-0.7.4.dist-info/RECORD,,

injection/integrations/typer.py

@@ -1,15 +0,0 @@
-from typer import Option
-
-__all__ = ("ignore",)
-
-
-def ignore():
-    """
-    Typer option for the CLI to ignore this option and replace it with `None`.
-    """
-
-    return Option(
-        default_factory=str,
-        parser=lambda _: None,
-        hidden=True,
-    )