python-injection 0.6.9__tar.gz → 0.7.0__tar.gz

{python_injection-0.6.9 → python_injection-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.6.9
+Version: 0.7.0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -137,6 +137,20 @@ class C(B):
     ...
 ```
 
+If a class is registered in a package and you want to override it, there is the `override` parameter:
+
+```python
+@singleton
+class A:
+    ...
+
+# ...
+
+@singleton(on=A, override=True)
+class B(A):
+    ...
+```
+
 ## Recipes
 
 A recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify 

{python_injection-0.6.9 → python_injection-0.7.0}/documentation/basic-usage.md

@@ -120,6 +120,20 @@ class C(B):
     ...
 ```
 
+If a class is registered in a package and you want to override it, there is the `override` parameter:
+
+```python
+@singleton
+class A:
+    ...
+
+# ...
+
+@singleton(on=A, override=True)
+class B(A):
+    ...
+```
+
 ## Recipes
 
 A recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify 

{python_injection-0.6.9 → python_injection-0.7.0}/injection/_pkg.pyi

@@ -38,12 +38,21 @@ class Module:
 
     def __init__(self, name: str = ...): ...
     def __contains__(self, cls: type | UnionType, /) -> bool: ...
-    def inject(self, wrapped: Callable[..., Any] = ..., /):
+    def inject(
+        self,
+        wrapped: Callable[..., Any] = ...,
+        /,
+        *,
+        force: bool = ...,
+    ):
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
         will be those of the `__init__` method.
+
+        With `force=True`, parameters passed to replace dependencies will be ignored.
         """
+
     def injectable(
         self,
         wrapped: Callable[..., Any] = ...,
@@ -51,39 +60,48 @@ class Module:
         *,
         cls: type[Injectable] = ...,
         on: type | Iterable[type] | UnionType = ...,
+        override: bool = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
         injectable will be constructed. At injection time, a new instance will be
         injected each time.
         """
+
     def singleton(
         self,
         wrapped: Callable[..., Any] = ...,
         /,
         *,
         on: type | Iterable[type] | UnionType = ...,
+        override: bool = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
         singleton will be constructed. At injection time, the injected instance will
         always be the same.
         """
+
     def set_constant(
         self,
         instance: _T,
         on: type | Iterable[type] | UnionType = ...,
+        *,
+        override: bool = ...,
     ) -> _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]) -> _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`.
+        parameter or return `None` but if `none` parameter is `False` an exception
+        will be raised.
         """
+
     def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         """
         Function used to retrieve an instance associated with the type passed in
@@ -92,16 +110,19 @@ class Module:
 
         Example: instance = ~lazy_instance
         """
+
     def use(self, module: Module, priority: ModulePriorities = ...):
         """
         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):
         """
         Function to remove a module in use.
         """
+
     def use_temporarily(
         self,
         module: Module,
@@ -110,6 +131,7 @@ class Module:
         """
         Context manager or decorator for temporary use of a module.
         """
+
     def change_priority(self, module: Module, priority: ModulePriorities):
         """
         Function for changing the priority of a module in use.
@@ -118,6 +140,7 @@ class Module:
         * **LOW**: The module concerned becomes the least important of the modules used.
         * **HIGH**: The module concerned becomes the most important of the modules used.
         """
+
     def unlock(self):
         """
         Function to unlock the module by deleting cached instances of singletons.
@@ -130,7 +153,7 @@ class ModulePriorities(Enum):
 
 @runtime_checkable
 class Injectable(Protocol[_T]):
-    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs): ...
+    def __init__(self, factory: Callable[[], _T] = ..., /): ...
     @property
     def is_locked(self) -> bool: ...
     def unlock(self): ...

{python_injection-0.6.9 → python_injection-0.7.0}/injection/core/module.py

@@ -61,6 +61,7 @@ class ContainerEvent(Event, ABC):
 @dataclass(frozen=True, slots=True)
 class ContainerDependenciesUpdated(ContainerEvent):
     classes: Collection[type]
+    override: bool
 
     def __str__(self) -> str:
         length = len(self.classes)
@@ -132,15 +133,13 @@ Injectables
 class Injectable(Protocol[_T]):
     __slots__ = ()
 
-    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs):
-        ...
+    def __init__(self, __factory: Callable[[], _T] = ..., /): ...
 
     @property
     def is_locked(self) -> bool:
         return False
 
-    def unlock(self):
-        ...
+    def unlock(self): ...
 
     @abstractmethod
     def get_instance(self) -> _T:
@@ -214,26 +213,19 @@ class Container:
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Types, injectable: Injectable):
-        classes = frozenset(get_origins(*classes))
+    def update(self, classes: Types, injectable: Injectable, override: bool):
+        values = {origin: injectable for origin in get_origins(*classes)}
 
-        if classes:
-            event = ContainerDependenciesUpdated(self, classes)
+        if values:
+            event = ContainerDependenciesUpdated(self, values, override)
 
             with self.notify(event):
-                self.__data.update(
-                    (self.check_if_exists(cls), injectable) for cls in classes
-                )
-
-        return self
+                if not override:
+                    self.__check_if_exists(*values)
 
-    def check_if_exists(self, cls: type) -> type:
-        if cls in self.__data:
-            raise RuntimeError(
-                f"An injectable already exists for the class `{format_type(cls)}`."
-            )
+                self.__data.update(values)
 
-        return cls
+        return self
 
     def unlock(self):
         for injectable in self.__injectables:
@@ -246,6 +238,13 @@ class Container:
     def notify(self, event: Event) -> ContextManager | ContextDecorator:
         return self.__channel.dispatch(event)
 
+    def __check_if_exists(self, *classes: type):
+        for cls in classes:
+            if cls in self.__data:
+                raise RuntimeError(
+                    f"An injectable already exists for the class `{format_type(cls)}`."
+                )
+
 
 """
 Module
@@ -282,7 +281,7 @@ class Module(EventListener):
         raise NoInjectable(cls)
 
     def __setitem__(self, cls: type | UnionType, injectable: Injectable, /):
-        self.update((cls,), injectable)
+        self.update((cls,), injectable, override=True)
 
     def __contains__(self, cls: type | UnionType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
@@ -306,22 +305,29 @@ class Module(EventListener):
         *,
         cls: type[Injectable] = NewInjectable,
         on: type | Types = None,
+        override: bool = False,
     ):
         def decorator(wp):
             factory = self.inject(wp, return_factory=True)
             injectable = cls(factory)
             classes = find_types(wp, on)
-            self.update(classes, injectable)
+            self.update(classes, injectable, override)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
 
     singleton = partialmethod(injectable, cls=SingletonInjectable)
 
-    def set_constant(self, instance: _T, on: type | Types = None) -> _T:
+    def set_constant(
+        self,
+        instance: _T,
+        on: type | Types = None,
+        *,
+        override: bool = False,
+    ) -> _T:
         cls = type(instance)
 
-        @self.injectable(on=(cls, on))
+        @self.injectable(on=(cls, on), override=override)
         def get_constant():
             return instance
 
@@ -332,29 +338,33 @@ class Module(EventListener):
         wrapped: Callable[..., Any] = None,
         /,
         *,
+        force: bool = False,
         return_factory: bool = False,
     ):
         def decorator(wp):
             if not return_factory and isclass(wp):
-                wp.__init__ = decorator(wp.__init__)
+                wp.__init__ = self.inject(wp.__init__, force=force)
                 return wp
 
             lazy_binder = Lazy[Binder](lambda: self.__new_binder(wp))
 
             @wraps(wp)
             def wrapper(*args, **kwargs):
-                arguments = (~lazy_binder).bind(*args, **kwargs)
+                arguments = (~lazy_binder).bind(args, kwargs, force)
                 return wp(*arguments.args, **arguments.kwargs)
 
             return wrapper
 
         return decorator(wrapped) if wrapped else decorator
 
-    def get_instance(self, cls: type[_T]) -> _T | None:
+    def get_instance(self, cls: type[_T], none: bool = True) -> _T | None:
         try:
             injectable = self[cls]
-        except KeyError:
-            return None
+        except KeyError as exc:
+            if none:
+                return None
+
+            raise exc from exc
 
         instance = injectable.get_instance()
         return cast(cls, instance)
@@ -362,8 +372,8 @@ class Module(EventListener):
     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):
-        self.__container.update(classes, injectable)
+    def update(self, classes: Types, injectable: Injectable, override: bool = False):
+        self.__container.update(classes, injectable, override)
         return self
 
     def use(
@@ -476,8 +486,8 @@ class Dependencies:
             yield name, injectable.get_instance()
 
     @property
-    def arguments(self) -> dict[str, Any]:
-        return dict(self)
+    def arguments(self) -> OrderedDict[str, Any]:
+        return OrderedDict(self)
 
     @classmethod
     def from_mapping(cls, mapping: Mapping[str, Injectable]):
@@ -519,12 +529,26 @@ class Binder(EventListener):
         self.__signature = signature
         self.__dependencies = Dependencies.empty()
 
-    def bind(self, /, *args, **kwargs) -> Arguments:
+    def bind(
+        self,
+        args: Iterable[Any] = (),
+        kwargs: Mapping[str, Any] = None,
+        force: bool = False,
+    ) -> Arguments:
+        if kwargs is None:
+            kwargs = {}
+
         if not self.__dependencies:
             return Arguments(args, kwargs)
 
         bound = self.__signature.bind_partial(*args, **kwargs)
-        bound.arguments = self.__dependencies.arguments | bound.arguments
+        dependencies = self.__dependencies.arguments
+
+        if force:
+            bound.arguments |= dependencies
+        else:
+            bound.arguments = dependencies | bound.arguments
+
         return Arguments(bound.args, bound.kwargs)
 
     def update(self, module: Module):
@@ -532,8 +556,7 @@ class Binder(EventListener):
         return self
 
     @singledispatchmethod
-    def on_event(self, event: Event, /):
-        ...
+    def on_event(self, event: Event, /): ...
 
     @on_event.register
     @contextmanager

{python_injection-0.6.9 → python_injection-0.7.0}/injection/integrations/blacksheep.py

@@ -1,7 +1,8 @@
 from typing import Any, TypeVar
 
 from injection import Module, default_module
-from injection.exceptions import NoInjectable
+
+__all__ = ("InjectionServices",)
 
 _T = TypeVar("_T")
 
@@ -24,9 +25,4 @@ class InjectionServices:
         return self
 
     def resolve(self, cls: type[_T] | Any, *__args, **__kwargs) -> _T:
-        instance = self.__module.get_instance(cls)
-
-        if instance is None:
-            raise NoInjectable(cls)
-
-        return instance
+        return self.__module.get_instance(cls, none=False)

python_injection-0.7.0/injection/integrations/typer.py

@@ -0,0 +1,15 @@
+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,
+    )

{python_injection-0.6.9 → python_injection-0.7.0}/injection/utils.py

@@ -5,11 +5,14 @@ from types import ModuleType
 __all__ = ("load_package",)
 
 
-def load_package(package: ModuleType):
+def load_package(package: ModuleType | str):
     """
     Function for importing all modules in a Python package.
     """
 
+    if isinstance(package, str):
+        package = import_module(package)
+
     try:
         path = package.__path__
     except AttributeError as exc:
@@ -17,7 +20,7 @@ def load_package(package: ModuleType):
             "Package has no `__path__` attribute, as it's probably a module."
         ) from exc
 
-    for info in walk_packages(path, prefix=f"{package.__name__}."):
+    for info in walk_packages(path=path, prefix=f"{package.__name__}."):
         if info.ispkg:
             continue
 

{python_injection-0.6.9 → python_injection-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.6.9"
+version = "0.7.0"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -14,13 +14,14 @@ python = ">=3.10, <4"
 
 [tool.poetry.group.dev.dependencies]
 black = "*"
-blacksheep = "^2.0.5"
+blacksheep = "^2.0.6"
 flake8 = "*"
 isort = "*"
-pydantic = "^2.5.3"
-pytest = "*"
+pydantic = "^2.6.1"
+pytest = "<8"
 pytest-asyncio = "*"
 pytest-cov = "*"
+typer = "^0.9.0"
 
 [build-system]
 requires = ["poetry-core"]