python-injection 0.6.6__tar.gz → 0.6.8__tar.gz

{python_injection-0.6.6 → python_injection-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.6.6
+Version: 0.6.8
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -19,6 +19,8 @@ Description-Content-Type: text/markdown
 
 ## Create an injectable
 
+> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+
 If you wish to inject a singleton, use `singleton` decorator.
 
 ```python
@@ -39,7 +41,14 @@ class Injectable:
     """ class implementation """
 ```
 
-> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+If you have a constant (such as a global variable) and wish to register it as an injectable, use `set_constant`
+function.
+
+```python
+from injection import set_constant
+
+app = set_constant(Application())
+```
 
 ## Inject an instance
 
@@ -57,6 +66,9 @@ def my_function(instance: Injectable):
 If `inject` decorates a class, it will be applied to the `__init__` method.
 _Especially useful for dataclasses:_
 
+> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
+> dependencies.
+
 ```python
 from dataclasses import dataclass
 
@@ -68,9 +80,6 @@ class DataClass:
     instance: Injectable = ...
 ```
 
-> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
-> dependencies.
-
 ## Get an instance
 
 _Example with `get_instance` function:_

{python_injection-0.6.6 → python_injection-0.6.8}/documentation/basic-usage.md

@@ -2,6 +2,8 @@
 
 ## Create an injectable
 
+> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+
 If you wish to inject a singleton, use `singleton` decorator.
 
 ```python
@@ -22,7 +24,14 @@ class Injectable:
     """ class implementation """
 ```
 
-> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+If you have a constant (such as a global variable) and wish to register it as an injectable, use `set_constant`
+function.
+
+```python
+from injection import set_constant
+
+app = set_constant(Application())
+```
 
 ## Inject an instance
 
@@ -40,6 +49,9 @@ def my_function(instance: Injectable):
 If `inject` decorates a class, it will be applied to the `__init__` method.
 _Especially useful for dataclasses:_
 
+> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
+> dependencies.
+
 ```python
 from dataclasses import dataclass
 
@@ -51,9 +63,6 @@ class DataClass:
     instance: Injectable = ...
 ```
 
-> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
-> dependencies.
-
 ## Get an instance
 
 _Example with `get_instance` function:_

{python_injection-0.6.6 → python_injection-0.6.8}/injection/_pkg.py

@@ -8,6 +8,7 @@ __all__ = (
     "get_lazy_instance",
     "inject",
     "injectable",
+    "set_constant",
     "singleton",
 )
 
@@ -19,3 +20,5 @@ get_lazy_instance = default_module.get_lazy_instance
 inject = default_module.inject
 injectable = default_module.injectable
 singleton = default_module.singleton
+
+set_constant = default_module.set_constant

{python_injection-0.6.6 → python_injection-0.6.8}/injection/_pkg.pyi

@@ -1,6 +1,7 @@
 from collections.abc import Callable, Iterable
 from contextlib import ContextDecorator
 from enum import Enum
+from types import UnionType
 from typing import Any, ContextManager, Final, TypeVar, final
 
 from injection.common.lazy import Lazy
@@ -16,6 +17,8 @@ inject = default_module.inject
 injectable = default_module.injectable
 singleton = default_module.singleton
 
+set_constant = default_module.set_constant
+
 @final
 class Module:
     """
@@ -27,7 +30,7 @@ class Module:
     """
 
     def __init__(self, name: str = ...): ...
-    def __contains__(self, cls: type, /) -> bool: ...
+    def __contains__(self, cls: type | UnionType, /) -> bool: ...
     def inject(self, wrapped: Callable[..., Any] = ..., /):
         """
         Decorator applicable to a class or function. Inject function dependencies using
@@ -39,7 +42,7 @@ class Module:
         wrapped: Callable[..., Any] = ...,
         /,
         *,
-        on: type | Iterable[type] = ...,
+        on: type | Iterable[type] | UnionType = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -51,13 +54,23 @@ class Module:
         wrapped: Callable[..., Any] = ...,
         /,
         *,
-        on: type | Iterable[type] = ...,
+        on: type | Iterable[type] | UnionType = ...,
     ):
         """
         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 = ...,
+    ) -> _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:
         """
         Function used to retrieve an instance associated with the type passed in

python_injection-0.6.8/injection/common/tools/_type.py

@@ -0,0 +1,36 @@
+from collections.abc import Iterator
+from types import NoneType, UnionType
+from typing import Annotated, Any, Union, get_args, get_origin
+
+__all__ = ("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(*classes: type | Any) -> Iterator[type | Any]:
+    for cls in classes:
+        origin = get_origin(cls) or cls
+
+        if origin in (None, NoneType):
+            continue
+
+        arguments = get_args(cls)
+
+        if origin in (Union, UnionType):
+            yield from get_origins(*arguments)
+
+        elif origin is Annotated:
+            try:
+                annotated = arguments[0]
+            except IndexError:
+                continue
+
+            yield from get_origins(annotated)
+
+        else:
+            yield origin

{python_injection-0.6.6 → python_injection-0.6.8}/injection/core/module.py

@@ -16,9 +16,9 @@ from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from functools import singledispatchmethod, wraps
-from inspect import Signature, get_annotations
+from inspect import Signature, get_annotations, isclass, isfunction
 from threading import RLock
-from types import MappingProxyType
+from types import MappingProxyType, UnionType
 from typing import (
     Any,
     ContextManager,
@@ -32,7 +32,7 @@ from typing import (
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools import format_type, get_origin
+from injection.common.tools import format_type, get_origins
 from injection.exceptions import (
     ModuleError,
     ModuleLockError,
@@ -46,6 +46,7 @@ _logger = logging.getLogger(__name__)
 _thread_lock = RLock()
 
 _T = TypeVar("_T")
+Types = Iterable[type] | UnionType
 
 
 """
@@ -193,16 +194,15 @@ class Container:
     __data: dict[type, Injectable] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
-    def __getitem__(self, cls: type[_T], /) -> Injectable[_T]:
-        origin = get_origin(cls)
+    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
+        for origin in get_origins(cls):
+            with suppress(KeyError):
+                return self.__data[origin]
 
-        try:
-            return self.__data[origin]
-        except KeyError as exc:
-            raise NoInjectable(cls) from exc
+        raise NoInjectable(cls)
 
-    def __contains__(self, cls: type, /) -> bool:
-        return get_origin(cls) in self.__data
+    def __contains__(self, cls: type | UnionType, /) -> bool:
+        return any(origin in self.__data for origin in get_origins(cls))
 
     @property
     def is_locked(self) -> bool:
@@ -212,8 +212,8 @@ class Container:
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Iterable[type], injectable: Injectable):
-        classes = frozenset(get_origin(cls) for cls in classes)
+    def update(self, classes: Types, injectable: Injectable):
+        classes = frozenset(get_origins(*classes))
 
         if classes:
             event = ContainerDependenciesUpdated(self, classes)
@@ -272,17 +272,17 @@ class Module(EventListener):
     def __post_init__(self):
         self.__container.add_listener(self)
 
-    def __getitem__(self, cls: type[_T], /) -> Injectable[_T]:
+    def __getitem__(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, injectable: Injectable, /):
+    def __setitem__(self, cls: type | UnionType, injectable: Injectable, /):
         self.update((cls,), injectable)
 
-    def __contains__(self, cls: type, /) -> bool:
+    def __contains__(self, cls: type | UnionType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
 
     def __str__(self) -> str:
@@ -309,6 +309,15 @@ class Module(EventListener):
         yield from tuple(self.__modules)
         yield self.__container
 
+    def set_constant(self, instance: _T, on: type | Types = None) -> _T:
+        cls = type(instance)
+
+        @self.injectable(on=(cls, on))
+        def get_constant():
+            return instance
+
+        return instance
+
     def get_instance(self, cls: type[_T]) -> _T | None:
         try:
             injectable = self[cls]
@@ -321,7 +330,7 @@ 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: Iterable[type], injectable: Injectable):
+    def update(self, classes: Types, injectable: Injectable):
         self.__container.update(classes, injectable)
         return self
 
@@ -395,7 +404,7 @@ class Module(EventListener):
 
         with self.__channel.dispatch(event):
             yield
-            _logger.debug(f"{event}")
+            _logger.debug(event)
 
     def __check_locking(self):
         if self.is_locked:
@@ -507,7 +516,7 @@ class InjectDecorator:
 
     def __call__(self, wrapped: Callable[..., Any] = None, /):
         def decorator(wp):
-            if isinstance(wp, type):
+            if isclass(wp):
                 return self.__class_decorator(wp)
 
             return self.__decorator(wp)
@@ -549,42 +558,29 @@ class InjectableDecorator:
         wrapped: Callable[..., Any] = None,
         /,
         *,
-        on: type | Iterable[type] = None,
+        on: type | Types = None,
     ):
         def decorator(wp):
-            @lambda fn: fn()
-            def classes():
-                if cls := self.__get_target_class(wp):
-                    yield cls
-
-                if on is None:
-                    return
-                elif isinstance(on, type | str):
-                    yield on
-                else:
-                    yield from on
-
             @self.__module.inject
             @wraps(wp, updated=())
             def factory(*args, **kwargs):
                 return wp(*args, **kwargs)
 
             injectable = self.__injectable_type(factory)
+            classes = self.__get_classes(wp, on)
             self.__module.update(classes, injectable)
-
             return wp
 
         return decorator(wrapped) if wrapped else decorator
 
-    @staticmethod
-    def __get_target_class(wrapped: Callable[..., Any]) -> type | None:
-        if isinstance(wrapped, type):
-            return wrapped
-
-        if callable(wrapped):
-            return_type = get_annotations(wrapped, eval_str=True).get("return")
+    @classmethod
+    def __get_classes(cls, *objects: Any) -> Iterator[type | UnionType]:
+        for obj in objects:
+            if isinstance(obj, Iterable) and not isinstance(obj, type | str):
+                yield from cls.__get_classes(*obj)
 
-            if isinstance(return_type, type):
-                return return_type
+            elif isfunction(obj):
+                yield get_annotations(obj, eval_str=True).get("return")
 
-        return None
+            else:
+                yield obj

{python_injection-0.6.6 → python_injection-0.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.6.6"
+version = "0.6.8"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -14,7 +14,7 @@ python = ">=3.10, <4"
 
 [tool.poetry.group.dev.dependencies]
 black = "*"
-blacksheep = "^2.0.4"
+blacksheep = "^2.0.5"
 flake8 = "*"
 isort = "*"
 pydantic = "^2.5.3"

python_injection-0.6.6/injection/common/tools/_type.py

@@ -1,14 +0,0 @@
-from typing import Any
-
-__all__ = ("format_type", "get_origin")
-
-
-def format_type(cls: type | Any) -> str:
-    try:
-        return f"{cls.__module__}.{cls.__qualname__}"
-    except AttributeError:
-        return str(cls)
-
-
-def get_origin(cls: type | Any) -> type | Any:
-    return getattr(cls, "__origin__", cls)