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

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

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

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.7 → python_injection-0.6.8}/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 → python_injection-0.6.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.6.7"
+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.7/injection/common/tools/_type.py

@@ -1,35 +0,0 @@
-from types import NoneType, UnionType
-from typing import Any, Iterator, Union, get_args
-
-__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_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):
-            continue
-
-        origin = get_full_origin(cls)
-
-        if origin is Union or isinstance(cls, UnionType):
-            for argument in get_args(cls):
-                yield from get_origins(argument)
-
-        else:
-            yield origin