python-injection 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

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

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

injection/common/tools/_type.py

@@ -1,6 +1,8 @@
-from typing import Any
+from collections.abc import Iterator
+from types import NoneType, UnionType
+from typing import Annotated, Any, Union, get_args, get_origin
 
-__all__ = ("format_type", "get_origin")
+__all__ = ("format_type", "get_origins")
 
 
 def format_type(cls: type | Any) -> str:
@@ -10,5 +12,25 @@ def format_type(cls: type | Any) -> str:
         return str(cls)
 
 
-def get_origin(cls: type | Any) -> type | Any:
-    return getattr(cls, "__origin__", 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

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.dist-info → python_injection-0.6.8.dist-info}/METADATA

@@ -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.dist-info → python_injection-0.6.8.dist-info}/RECORD

@@ -1,17 +1,17 @@
 injection/__init__.py,sha256=9_AVJILxKIBiL_6KJSh2RRydgSHXH38uahAGD0S1-dI,20
-injection/_pkg.py,sha256=OnmTG62FZMZteNRfxQKBejiOiedY5I0_C3UWzikex-4,472
-injection/_pkg.pyi,sha256=4I7mMRot03oKjsdZQPlJmR_YOD3huFY0O2CFsawB1RQ,3696
+injection/_pkg.py,sha256=7Ns-9VxyGeIf2fOVfOAa5rD_kxAcY1WSHGSkKYAW4T0,536
+injection/_pkg.pyi,sha256=YfSr-pwahHfVx8wak4JxDcXsgrIohd2ZJ73GgysFLNA,4209
 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=0nPMAwcobITVbd7_MOZXmiZFF8bQnb5FeTPNveH9Flo,313
+injection/common/tools/_type.py,sha256=3hElLUPtiG6_kmxeWiNabX5zNKN_m1vUc3gBVdOf9WY,887
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=HlM9-x5evGIgVImP9Zdnx_DdlLvLMHvCRQ0Fnz2j18s,15537
+injection/core/module.py,sha256=Lm0uc0uUvVQLfnXwfH6xaXoHYuPvdbR8HgFXWrZmi5Y,15595
 injection/exceptions.py,sha256=wd4OxmpneGEmlZ0yeNBfnCYfPYqUksfbmA2mopLNm_s,688
 injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/integrations/blacksheep.py,sha256=F4h85VS9dLGHn-ARDARYMB02Htsd3nKMT9Y-EF4cOqE,818
 injection/utils.py,sha256=a4w2SXyXP1A8AC_4hyEypByVUZOwSFIA3lh8StLxuLY,590
-python_injection-0.6.6.dist-info/METADATA,sha256=fJTPLAW6_b1sfFXSsjuY40zRGGiokvRMH0l8uCiZcJ8,3019
-python_injection-0.6.6.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-python_injection-0.6.6.dist-info/RECORD,,
+python_injection-0.6.8.dist-info/METADATA,sha256=4E21PIf33RBie3Wje2_h58VBDSkBwhKGn7gZAuai6q0,3227
+python_injection-0.6.8.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+python_injection-0.6.8.dist-info/RECORD,,