python-injection 0.8.1__py3-none-any.whl → 0.8.1.post0__py3-none-any.whl

injection/core/module.py

@@ -16,14 +16,9 @@ from collections.abc import (
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from functools import (
-    partialmethod,
-    singledispatchmethod,
-    update_wrapper,
-    wraps,
-)
+from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
-from types import UnionType
+from types import MethodType, UnionType
 from typing import (
     Any,
     ClassVar,
@@ -635,48 +630,37 @@ class InjectedFunction(EventListener):
     __slots__ = (
         "__dict__",
         "__signature__",
+        "__wrapped__",
         "__dependencies",
         "__owner",
         "__setup_queue",
-        "__wrapper",
     )
 
     def __init__(self, wrapped: Callable[..., Any], /):
         update_wrapper(self, wrapped)
-
-        @wraps(wrapped)
-        def wrapper(*args, **kwargs):
-            self.__consume_setup_queue()
-            args, kwargs = self.bind(args, kwargs)
-            return wrapped(*args, **kwargs)
-
-        self.__wrapper = wrapper
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
-        self.on_setup(
-            lambda: self.__set_signature(
-                inspect.signature(
-                    wrapped,
-                    eval_str=True,
-                )
-            )
-        )
+        self.on_setup(self.__set_signature)
 
     def __repr__(self) -> str:
-        return repr(self.__wrapper)
+        return repr(self.wrapped)
 
     def __str__(self) -> str:
-        return str(self.__wrapper)
+        return str(self.wrapped)
 
     def __call__(self, /, *args, **kwargs) -> Any:
-        return self.__wrapper(*args, **kwargs)
+        for function in self.__setup_queue:
+            function()
+
+        args, kwargs = self.bind(args, kwargs)
+        return self.wrapped(*args, **kwargs)
 
     def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
             return self
 
-        return self.__wrapper.__get__(instance, owner)
+        return MethodType(self, instance)
 
     def __set_name__(self, owner: type, name: str):
         self.set_owner(owner)
@@ -685,6 +669,10 @@ class InjectedFunction(EventListener):
     def signature(self) -> Signature:
         return self.__signature__
 
+    @property
+    def wrapped(self) -> Callable[..., Any]:
+        return self.__wrapped__
+
     def bind(
         self,
         args: Iterable[Any] = (),
@@ -736,12 +724,6 @@ class InjectedFunction(EventListener):
         yield
         self.update(event.on_module)
 
-    def __consume_setup_queue(self):
-        for function in self.__setup_queue:
-            function()
-
-        return self
-
-    def __set_signature(self, signature: Signature):
-        self.__signature__ = signature
+    def __set_signature(self):
+        self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self

{python_injection-0.8.1.dist-info → python_injection-0.8.1.post0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.1
+Version: 0.8.1.post0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -27,7 +27,7 @@ If you wish to inject a singleton, use `singleton` decorator.
 from injection import singleton
 
 @singleton
-class Singleton:
+class ServiceA:
     """ class implementation """
 ```
 
@@ -37,7 +37,7 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 from injection import injectable
 
 @injectable
-class Injectable:
+class ServiceB:
     """ class implementation """
 ```
 
@@ -47,7 +47,10 @@ function.
 ```python
 from injection import set_constant
 
-app = set_constant(Application())
+class ServiceC:
+    """ class implementation """
+
+service_c = set_constant(ServiceC())
 ```
 
 ## Inject an instance
@@ -59,7 +62,7 @@ _Don't forget to annotate type of parameter to inject._
 from injection import inject
 
 @inject
-def my_function(instance: Injectable):
+def some_function(service_a: ServiceA):
     """ function implementation """
 ```
 
@@ -76,8 +79,8 @@ from injection import inject
 
 @inject
 @dataclass
-class DataClass:
-    instance: Injectable = ...
+class SomeDataClass:
+    service_a: ServiceA = ...
 ```
 
 ## Get an instance
@@ -87,7 +90,7 @@ _Example with `get_instance` function:_
 ```python
 from injection import get_instance
 
-instance = get_instance(Injectable)
+service_a = get_instance(ServiceA)
 ```
 
 _Example with `get_lazy_instance` function:_
@@ -95,9 +98,9 @@ _Example with `get_lazy_instance` function:_
 ```python
 from injection import get_lazy_instance
 
-lazy_instance = get_lazy_instance(Injectable)
+lazy_service_a = get_lazy_instance(ServiceA)
 # ...
-instance = ~lazy_instance
+service_a = ~lazy_service_a
 ```
 
 ## Inheritance
@@ -111,43 +114,39 @@ classes.
 _Example with one class:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-@singleton(on=A)
-class B(A):
+@injectable(on=AbstractService)
+class ConcreteService(AbstractService):
     ...
 ```
 
 _Example with several classes:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-class B(A):
+class ConcreteService(AbstractService):
     ...
 
-@singleton(on=(A, B))
-class C(B):
+@injectable(on=(AbstractService, ConcreteService))
+class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
 If a class is registered in a package and you want to override it, there is the `override` parameter:
 
 ```python
-@singleton
-class A:
+@injectable
+class InaccessibleService:
     ...
 
 # ...
 
-@singleton(on=A, override=True)
-class B(A):
+@injectable(on=InaccessibleService, override=True)
+class ServiceOverload(InaccessibleService):
     ...
 ```
 
@@ -157,10 +156,10 @@ A recipe is a function that tells the injector how to construct the instance to
 the return type annotation when defining the recipe.
 
 ```python
-from injection import singleton
+from injection import injectable
 
-@singleton
-def my_recipe() -> Singleton:
+@injectable
+def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```
 

{python_injection-0.8.1.dist-info → python_injection-0.8.1.post0.dist-info}/RECORD

@@ -10,11 +10,11 @@ injection/common/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 injection/common/tools/threading.py,sha256=02mBkIir2kQaXt47ewMJnOvhCldXCmPI2V-BW_l_6V8,271
 injection/common/tools/type.py,sha256=-zL0dtoVZme71Mscvav7iEWxY2-JltzNTekbWOCPSFo,1276
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=hYnNwFNzw-1TaTjPAtmCpKgghF1JTdbkrJ9jO07KQps,19284
+injection/core/module.py,sha256=YR-_XwYvL7InODB9NB9_d6oLG0hFL-AFdu-GwDe1t7w,18952
 injection/exceptions.py,sha256=nE56jW00ZB1T-Z-dvfPczPShs3CwIc7tIvdYlOXlaXA,653
 injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/integrations/blacksheep.py,sha256=vcLil1IccS7JtXpuVu7s2LqN5Zravfe_7xpAt5cTIU0,723
 injection/utils.py,sha256=_79aiciimZpuoUTz5lojKySUMMzpkU-e7SotiHIFTI8,676
-python_injection-0.8.1.dist-info/METADATA,sha256=Atf1DZFIwYCdMKnK7_xQf_muy_Ma7qQmEAnGYQr5P-M,3433
-python_injection-0.8.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-python_injection-0.8.1.dist-info/RECORD,,
+python_injection-0.8.1.post0.dist-info/METADATA,sha256=7oD5fbqklsTYrYRJX_fSE42rkFU80PCNgCu70MnpPmU,3679
+python_injection-0.8.1.post0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+python_injection-0.8.1.post0.dist-info/RECORD,,