python-injection 0.8.1.post0__tar.gz → 0.8.2__tar.gz

{python_injection-0.8.1.post0 → python_injection-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.1.post0
+Version: 0.8.2
 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 `override` parameter:
+If a class is registered in a package and you want to override it, there is the `mode` parameter:
 
 ```python
 @injectable
@@ -145,7 +145,7 @@ class InaccessibleService:
 
 # ...
 
-@injectable(on=InaccessibleService, override=True)
+@injectable(on=InaccessibleService, mode="override")
 class ServiceOverload(InaccessibleService):
     ...
 ```

{python_injection-0.8.1.post0 → python_injection-0.8.2}/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 `override` parameter:
+If a class is registered in a package and you want to override it, there is the `mode` parameter:
 
 ```python
 @injectable
@@ -128,7 +128,7 @@ class InaccessibleService:
 
 # ...
 
-@injectable(on=InaccessibleService, override=True)
+@injectable(on=InaccessibleService, mode="override")
 class ServiceOverload(InaccessibleService):
     ...
 ```

python_injection-0.8.1.post0/injection/_pkg.py → python_injection-0.8.2/injection/__init__.py

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

python_injection-0.8.1.post0/injection/_pkg.pyi → python_injection-0.8.2/injection/__init__.pyi

@@ -1,19 +1,19 @@
 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,
     ContextManager,
     Final,
+    Literal,
     Protocol,
     TypeVar,
     final,
     runtime_checkable,
 )
 
-from injection.common.invertible import Invertible
+from .common.invertible import Invertible
 
 _T = TypeVar("_T")
 
@@ -54,7 +54,7 @@ class Module:
         cls: type[Injectable] = ...,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -69,7 +69,7 @@ class Module:
         *,
         inject: bool = ...,
         on: type | Iterable[type] | UnionType = ...,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -89,7 +89,7 @@ class Module:
         instance: _T,
         on: type | Iterable[type] | UnionType = ...,
         *,
-        override: bool = ...,
+        mode: Literal["fallback", "normal", "override"] = ...,
     ) -> _T:
         """
         Function for registering a specific instance to be injected. This is useful for
@@ -97,7 +97,7 @@ class Module:
         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 get_instance(self, cls: type[_T], *, none: bool = ...) -> _T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None` but if `none` parameter is `False` an exception
@@ -107,6 +107,7 @@ class Module:
     def get_lazy_instance(
         self,
         cls: type[_T],
+        *,
         cache: bool = ...,
     ) -> Invertible[_T | None]:
         """
@@ -118,7 +119,7 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
-    def use(self, module: Module, priority: ModulePriority = ...):
+    def use(self, module: Module, *, priority: 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
@@ -133,13 +134,14 @@ class Module:
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriority = ...,
+        *,
+        priority: Literal["low", "high"] = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
         """
 
-    def change_priority(self, module: Module, priority: ModulePriority):
+    def change_priority(self, module: Module, priority: Literal["low", "high"]):
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -153,11 +155,6 @@ class Module:
         Function to unlock the module by deleting cached instances of singletons.
         """
 
-@final
-class ModulePriority(Enum):
-    HIGH = ...
-    LOW = ...
-
 @runtime_checkable
 class Injectable(Protocol[_T]):
     def __init__(self, factory: Callable[[], _T] = ..., /): ...

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

@@ -11,11 +11,9 @@ from collections.abc import (
     Iterator,
     Mapping,
     MutableMapping,
-    Set,
 )
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
-from enum import Enum, auto
 from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
 from types import MethodType, UnionType
@@ -23,11 +21,13 @@ from typing import (
     Any,
     ClassVar,
     ContextManager,
+    Literal,
     NamedTuple,
     NoReturn,
     Protocol,
     TypeVar,
     cast,
+    get_args,
     runtime_checkable,
 )
 
@@ -45,12 +45,21 @@ from injection.exceptions import (
     NoInjectable,
 )
 
-__all__ = ("Injectable", "Module", "ModulePriority")
+__all__ = ("Injectable", "Module")
 
 _logger = logging.getLogger(__name__)
 
 _T = TypeVar("_T")
-Types = Iterable[type] | UnionType
+_Types = Iterable[type] | UnionType
+
+
+"""
+Literal types
+"""
+
+
+_Mode = Literal["fallback", "normal", "override"]
+_Priority = Literal["low", "high"]
 
 
 """
@@ -66,7 +75,7 @@ class ContainerEvent(Event, ABC):
 @dataclass(frozen=True, slots=True)
 class ContainerDependenciesUpdated(ContainerEvent):
     classes: Collection[type]
-    override: bool
+    mode: _Mode
 
     def __str__(self) -> str:
         length = len(self.classes)
@@ -120,11 +129,11 @@ class ModuleRemoved(ModuleEvent):
 @dataclass(frozen=True, slots=True)
 class ModulePriorityUpdated(ModuleEvent):
     module_updated: Module
-    priority: ModulePriority
+    priority: _Priority
 
     def __str__(self) -> str:
         return (
-            f"In `{self.on_module}`, the priority `{self.priority.name}` "
+            f"In `{self.on_module}`, the priority `{self.priority}` "
             f"has been applied to `{self.module_updated}`."
         )
 
@@ -153,13 +162,6 @@ class Injectable(Protocol[_T]):
         raise NotImplementedError
 
 
-class FallbackInjectable(Injectable[_T], ABC):
-    __slots__ = ()
-
-    def __bool__(self) -> bool:
-        return False
-
-
 @dataclass(repr=False, frozen=True, slots=True)
 class BaseInjectable(Injectable[_T], ABC):
     factory: Callable[[], _T]
@@ -200,7 +202,7 @@ class SingletonInjectable(BaseInjectable[_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(FallbackInjectable[_T]):
+class ShouldBeInjectable(Injectable[_T]):
     cls: type[_T]
 
     def get_instance(self) -> NoReturn:
@@ -239,49 +241,50 @@ Container
 """
 
 
+class Record(NamedTuple):
+    injectable: Injectable
+    mode: _Mode
+
+
 @dataclass(repr=False, frozen=True, slots=True)
 class Container(Broker):
-    __data: dict[type, Injectable] = field(default_factory=dict, init=False)
+    __data: 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]:
-        for origin in get_origins(cls):
-            with suppress(KeyError):
-                return self.__data[origin]
+        for cls in get_origins(cls):
+            try:
+                injectable, _ = self.__data[cls]
+            except KeyError:
+                continue
+
+            return injectable
 
         raise NoInjectable(cls)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
-        return any(origin in self.__data for origin in get_origins(cls))
+        return any(cls in self.__data for cls in get_origins(cls))
 
     @property
     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)
-
     @property
     def __injectables(self) -> frozenset[Injectable]:
-        return frozenset(self.__data.values())
+        return frozenset(injectable for injectable, _ in self.__data.values())
 
     @synchronized()
-    def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
-        classes = frozenset(get_origins(*classes))
-
-        if not injectable:
-            classes -= self.__classes
-            override = True
+    def update(self, classes: Iterable[type], injectable: Injectable, mode: _Mode):
+        records = {
+            cls: Record(injectable, mode)
+            for cls in self.__filter_classes(classes, mode)
+        }
 
-        if classes:
-            event = ContainerDependenciesUpdated(self, classes, override)
+        if records:
+            event = ContainerDependenciesUpdated(self, records.keys(), mode)
 
             with self.notify(event):
-                if not override:
-                    self.__check_if_exists(classes)
-
-                self.__data.update((cls, injectable) for cls in classes)
+                self.__data.update(records)
 
         return self
 
@@ -299,28 +302,32 @@ class Container(Broker):
     def notify(self, event: Event) -> ContextManager | ContextDecorator:
         return self.__channel.dispatch(event)
 
-    def __check_if_exists(self, classes: Set[type]):
-        intersection = classes & self.__classes
+    def __filter_classes(self, classes: Iterable[type], mode: _Mode) -> Iterator[type]:
+        modes = get_args(_Mode)
+        rank = modes.index(mode)
 
-        for cls in intersection:
-            if self.__data[cls]:
-                raise RuntimeError(
-                    f"An injectable already exists for the class `{format_type(cls)}`."
-                )
+        for cls in frozenset(get_origins(*classes)):
+            try:
+                _, current_mode = self.__data[cls]
 
+            except KeyError:
+                pass
 
-"""
-Module
-"""
+            else:
+                if mode == current_mode:
+                    raise RuntimeError(
+                        f"An injectable already exists for the class `{format_type(cls)}`."
+                    )
 
+                elif rank < modes.index(current_mode):
+                    continue
 
-class ModulePriority(Enum):
-    HIGH = auto()
-    LOW = auto()
+            yield cls
 
-    @classmethod
-    def get_default(cls):
-        return cls.LOW
+
+"""
+Module
+"""
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -368,14 +375,14 @@ class Module(EventListener, Broker):
         *,
         cls: type[Injectable] = NewInjectable,
         inject: bool = True,
-        on: type | Types = None,
-        override: bool = False,
+        on: type | _Types = None,
+        mode: _Mode = "normal",
     ):
         def decorator(wp):
             factory = self.inject(wp, return_factory=True) if inject else wp
             injectable = cls(factory)
             classes = find_types(wp, on)
-            self.update(classes, injectable, override)
+            self.update(classes, injectable, mode)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -384,7 +391,11 @@ class Module(EventListener, Broker):
 
     def should_be_injectable(self, wrapped: type = None, /):
         def decorator(wp):
-            self[wp] = ShouldBeInjectable(wp)
+            self.update(
+                (wp,),
+                ShouldBeInjectable(wp),
+                mode="fallback",
+            )
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -392,16 +403,16 @@ class Module(EventListener, Broker):
     def set_constant(
         self,
         instance: _T,
-        on: type | Types = None,
+        on: type | _Types = None,
         *,
-        override: bool = False,
+        mode: _Mode = "normal",
     ) -> _T:
         cls = type(instance)
         self.injectable(
             lambda: instance,
             inject=False,
             on=(cls, on),
-            override=override,
+            mode=mode,
         )
         return instance
 
@@ -428,7 +439,7 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def get_instance(self, cls: type[_T], none: bool = True) -> _T | None:
+    def get_instance(self, cls: type[_T], *, none: bool = True) -> _T | None:
         try:
             injectable = self[cls]
         except KeyError as exc:
@@ -443,6 +454,7 @@ class Module(EventListener, Broker):
     def get_lazy_instance(
         self,
         cls: type[_T],
+        *,
         cache: bool = False,
     ) -> Invertible[_T | None]:
         if cache:
@@ -456,16 +468,12 @@ class Module(EventListener, Broker):
         self,
         classes: Iterable[type],
         injectable: Injectable,
-        override: bool = False,
+        mode: _Mode = "normal",
     ):
-        self.__container.update(classes, injectable, override)
+        self.__container.update(classes, injectable, mode)
         return self
 
-    def use(
-        self,
-        module: Module,
-        priority: ModulePriority = ModulePriority.get_default(),
-    ):
+    def use(self, module: Module, *, priority: _Priority = "low"):
         if module is self:
             raise ModuleError("Module can't be used by itself.")
 
@@ -495,13 +503,14 @@ class Module(EventListener, Broker):
     def use_temporarily(
         self,
         module: Module,
-        priority: ModulePriority = ModulePriority.get_default(),
+        *,
+        priority: _Priority = "low",
     ) -> ContextManager | ContextDecorator:
-        self.use(module, priority)
+        self.use(module, priority=priority)
         yield
         self.stop_using(module)
 
-    def change_priority(self, module: Module, priority: ModulePriority):
+    def change_priority(self, module: Module, priority: _Priority):
         event = ModulePriorityUpdated(self, module, priority)
 
         with self.notify(event):
@@ -540,8 +549,8 @@ class Module(EventListener, Broker):
         if self.is_locked:
             raise ModuleLockError(f"`{self}` is locked.")
 
-    def __move_module(self, module: Module, priority: ModulePriority):
-        last = priority == ModulePriority.LOW
+    def __move_module(self, module: Module, priority: _Priority):
+        last = priority != "high"
 
         try:
             self.__modules.move_to_end(module, last=last)
@@ -637,7 +646,15 @@ class InjectedFunction(EventListener):
     )
 
     def __init__(self, wrapped: Callable[..., Any], /):
-        update_wrapper(self, wrapped)
+        try:
+            variables = vars(wrapped)
+        except TypeError:
+            pass
+        else:
+            self.__update_vars(variables)
+            del variables
+
+        update_wrapper(self, wrapped, updated=())
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
@@ -727,3 +744,15 @@ class InjectedFunction(EventListener):
     def __set_signature(self):
         self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self
+
+    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 = (
+            (var, value)
+            for var, value in variables.items()
+            if var not in restricted_vars
+        )
+        vars(self).update(variables)

{python_injection-0.8.1.post0 → python_injection-0.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.1.post0"
+version = "0.8.2"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]

python_injection-0.8.1.post0/injection/__init__.py

@@ -1 +0,0 @@
-from ._pkg import *