python-injection 0.6.7__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

@@ -17,6 +17,8 @@ inject = default_module.inject
 injectable = default_module.injectable
 singleton = default_module.singleton
 
+set_constant = default_module.set_constant
+
 @final
 class Module:
     """
@@ -59,12 +61,22 @@ class Module:
         singleton will be constructed. At injection time, the injected instance will
         always be the same.
         """
-    def get_instance(self, cls: type[_T] | UnionType) -> _T | None:
+    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
         parameter or return `None`.
         """
-    def get_lazy_instance(self, cls: type[_T] | UnionType) -> Lazy[_T | None]:
+    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Lazy` object. To access the instance contained

injection/common/tools/_type.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator
 from types import NoneType, UnionType
-from typing import Any, Iterator, Union, get_args
+from typing import Annotated, Any, Union, get_args, get_origin
 
 __all__ = ("format_type", "get_origins")
 
@@ -11,25 +12,25 @@ def format_type(cls: type | Any) -> str:
         return str(cls)
 
 
-def get_full_origin(cls: type | Any) -> type | Any:
-    try:
-        origin = cls.__origin__
-    except AttributeError:
-        return cls
-
-    return get_full_origin(origin)
-
-
 def get_origins(*classes: type | Any) -> Iterator[type | Any]:
     for cls in classes:
-        if cls in (None, NoneType):
+        origin = get_origin(cls) or cls
+
+        if origin in (None, NoneType):
             continue
 
-        origin = get_full_origin(cls)
+        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
 
-        if origin is Union or isinstance(cls, UnionType):
-            for argument in get_args(cls):
-                yield from get_origins(argument)
+            yield from get_origins(annotated)
 
         else:
             yield origin

injection/core/module.py

@@ -46,6 +46,7 @@ _logger = logging.getLogger(__name__)
 _thread_lock = RLock()
 
 _T = TypeVar("_T")
+Types = Iterable[type] | UnionType
 
 
 """
@@ -211,7 +212,7 @@ class Container:
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Iterable[type] | UnionType, injectable: Injectable):
+    def update(self, classes: Types, injectable: Injectable):
         classes = frozenset(get_origins(*classes))
 
         if classes:
@@ -308,7 +309,16 @@ class Module(EventListener):
         yield from tuple(self.__modules)
         yield self.__container
 
-    def get_instance(self, cls: type[_T] | UnionType) -> _T | None:
+    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]
         except KeyError:
@@ -317,10 +327,10 @@ class Module(EventListener):
         instance = injectable.get_instance()
         return cast(cls, instance)
 
-    def get_lazy_instance(self, cls: type[_T] | UnionType) -> Lazy[_T | None]:
+    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         return Lazy(lambda: self.get_instance(cls))
 
-    def update(self, classes: Iterable[type] | UnionType, injectable: Injectable):
+    def update(self, classes: Types, injectable: Injectable):
         self.__container.update(classes, injectable)
         return self
 
@@ -548,39 +558,29 @@ class InjectableDecorator:
         wrapped: Callable[..., Any] = None,
         /,
         *,
-        on: type | Iterable[type] | UnionType = None,
+        on: type | Types = None,
     ):
         def decorator(wp):
-            @lambda fn: fn()
-            def classes():
-                if cls := self.__get_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_class(wrapped: Callable[..., Any]) -> type | None:
-        if isclass(wrapped):
-            return wrapped
+    @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 isfunction(wrapped):
-            return get_annotations(wrapped, eval_str=True).get("return")
+            elif isfunction(obj):
+                yield get_annotations(obj, eval_str=True).get("return")
 
-        return None
+            else:
+                yield obj

{python_injection-0.6.7.dist-info → python_injection-0.6.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.6.7
+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.7.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=fiAYzNipfLXrVTpWgILJD4STMGNYK4oYmefBSTKjWFQ,3784
+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=7zht0nR_4gASQ17f82_W-nI1bPM0XpDCPNaBsIBzm5Y,840
+injection/common/tools/_type.py,sha256=3hElLUPtiG6_kmxeWiNabX5zNKN_m1vUc3gBVdOf9WY,887
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=dshKX-j2czcnSKe4evsj_mwdKuxjm-9934szrPESgs8,15570
+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.7.dist-info/METADATA,sha256=u9N4uiu4iFPfajG1whWYGjeHPYDGl6diUWc46klkXf8,3019
-python_injection-0.6.7.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-python_injection-0.6.7.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,,