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

injection/_pkg.py

@@ -1,6 +1,7 @@
-from .core import Module, ModulePriorities
+from .core import Injectable, Module, ModulePriorities
 
 __all__ = (
+    "Injectable",
     "Module",
     "ModulePriorities",
     "default_module",
@@ -16,9 +17,7 @@ default_module = Module(f"{__name__}:default_module")
 
 get_instance = default_module.get_instance
 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
+singleton = default_module.singleton

injection/_pkg.pyi

@@ -1,8 +1,17 @@
+from abc import abstractmethod
 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 typing import (
+    Any,
+    ContextManager,
+    Final,
+    Protocol,
+    TypeVar,
+    final,
+    runtime_checkable,
+)
 
 from injection.common.lazy import Lazy
 
@@ -12,12 +21,10 @@ default_module: Final[Module] = ...
 
 get_instance = default_module.get_instance
 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
+singleton = default_module.singleton
 
 @final
 class Module:
@@ -42,6 +49,7 @@ class Module:
         wrapped: Callable[..., Any] = ...,
         /,
         *,
+        cls: type[Injectable] = ...,
         on: type | Iterable[type] | UnionType = ...,
     ):
         """
@@ -119,3 +127,12 @@ class Module:
 class ModulePriorities(Enum):
     HIGH = ...
     LOW = ...
+
+@runtime_checkable
+class Injectable(Protocol[_T]):
+    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs): ...
+    @property
+    def is_locked(self) -> bool: ...
+    def unlock(self): ...
+    @abstractmethod
+    def get_instance(self) -> _T: ...

injection/common/tools/_type.py

@@ -1,8 +1,9 @@
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
+from inspect import get_annotations, isfunction
 from types import NoneType, UnionType
 from typing import Annotated, Any, Union, get_args, get_origin
 
-__all__ = ("format_type", "get_origins")
+__all__ = ("find_types", "format_type", "get_origins")
 
 
 def format_type(cls: type | Any) -> str:
@@ -12,25 +13,36 @@ def format_type(cls: type | Any) -> str:
         return str(cls)
 
 
-def get_origins(*classes: type | Any) -> Iterator[type | Any]:
-    for cls in classes:
-        origin = get_origin(cls) or cls
+def get_origins(*types: type | Any) -> Iterator[type | Any]:
+    for tp in types:
+        origin = get_origin(tp) or tp
 
         if origin in (None, NoneType):
             continue
 
-        arguments = get_args(cls)
+        elif origin in (Union, UnionType):
+            args = get_args(tp)
 
-        if origin in (Union, UnionType):
-            yield from get_origins(*arguments)
+        elif origin is Annotated is not tp:
+            args = (tp.__origin__,)
+
+        else:
+            yield origin
+            continue
+
+        yield from get_origins(*args)
 
-        elif origin is Annotated:
-            try:
-                annotated = arguments[0]
-            except IndexError:
-                continue
 
-            yield from get_origins(annotated)
+def find_types(*args: Any) -> Iterator[type | UnionType]:
+    for argument in args:
+        if isinstance(argument, Iterable) and not isinstance(argument, type | str):
+            arguments = argument
+
+        elif isfunction(argument):
+            arguments = (get_annotations(argument, eval_str=True).get("return"),)
 
         else:
-            yield origin
+            yield argument
+            continue
+
+        yield from find_types(*arguments)

injection/core/module.py

@@ -15,8 +15,8 @@ from collections.abc import (
 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, isclass, isfunction
+from functools import partialmethod, singledispatchmethod, wraps
+from inspect import Signature, isclass
 from threading import RLock
 from types import MappingProxyType, UnionType
 from typing import (
@@ -26,13 +26,12 @@ from typing import (
     Protocol,
     TypeVar,
     cast,
-    final,
     runtime_checkable,
 )
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools import format_type, get_origins
+from injection.common.tools import find_types, format_type, get_origins
 from injection.exceptions import (
     ModuleError,
     ModuleLockError,
@@ -133,6 +132,9 @@ Injectables
 class Injectable(Protocol[_T]):
     __slots__ = ()
 
+    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs):
+        ...
+
     @property
     def is_locked(self) -> bool:
         return False
@@ -288,18 +290,6 @@ class Module(EventListener):
     def __str__(self) -> str:
         return self.name or object.__str__(self)
 
-    @property
-    def inject(self) -> InjectDecorator:
-        return InjectDecorator(self)
-
-    @property
-    def injectable(self) -> InjectableDecorator:
-        return InjectableDecorator(self, NewInjectable)
-
-    @property
-    def singleton(self) -> InjectableDecorator:
-        return InjectableDecorator(self, SingletonInjectable)
-
     @property
     def is_locked(self) -> bool:
         return any(broker.is_locked for broker in self.__brokers)
@@ -309,6 +299,25 @@ class Module(EventListener):
         yield from tuple(self.__modules)
         yield self.__container
 
+    def injectable(
+        self,
+        wrapped: Callable[..., Any] = None,
+        /,
+        *,
+        cls: type[Injectable] = NewInjectable,
+        on: type | Types = None,
+    ):
+        def decorator(wp):
+            factory = self.inject(wp, return_factory=True)
+            injectable = cls(factory)
+            classes = find_types(wp, on)
+            self.update(classes, injectable)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
+    singleton = partialmethod(injectable, cls=SingletonInjectable)
+
     def set_constant(self, instance: _T, on: type | Types = None) -> _T:
         cls = type(instance)
 
@@ -318,6 +327,29 @@ class Module(EventListener):
 
         return instance
 
+    def inject(
+        self,
+        wrapped: Callable[..., Any] = None,
+        /,
+        *,
+        return_factory: bool = False,
+    ):
+        def decorator(wp):
+            if not return_factory and isclass(wp):
+                wp.__init__ = decorator(wp.__init__)
+                return wp
+
+            lazy_binder = Lazy[Binder](lambda: self.__new_binder(wp))
+
+            @wraps(wp)
+            def wrapper(*args, **kwargs):
+                arguments = (~lazy_binder).bind(*args, **kwargs)
+                return wp(*arguments.args, **arguments.kwargs)
+
+            return wrapper
+
+        return decorator(wrapped) if wrapped else decorator
+
     def get_instance(self, cls: type[_T]) -> _T | None:
         try:
             injectable = self[cls]
@@ -420,6 +452,12 @@ class Module(EventListener):
                 f"`{module}` can't be found in the modules used by `{self}`."
             ) from exc
 
+    def __new_binder(self, target: Callable[..., Any]) -> Binder:
+        signature = inspect.signature(target, eval_str=True)
+        binder = Binder(signature).update(self)
+        self.add_listener(binder)
+        return binder
+
 
 """
 Binder
@@ -502,85 +540,3 @@ class Binder(EventListener):
     def _(self, event: ModuleEvent, /) -> ContextManager:
         yield
         self.update(event.on_module)
-
-
-"""
-Decorators
-"""
-
-
-@final
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectDecorator:
-    __module: Module
-
-    def __call__(self, wrapped: Callable[..., Any] = None, /):
-        def decorator(wp):
-            if isclass(wp):
-                return self.__class_decorator(wp)
-
-            return self.__decorator(wp)
-
-        return decorator(wrapped) if wrapped else decorator
-
-    def __decorator(self, function: Callable[..., Any], /) -> Callable[..., Any]:
-        lazy_binder = Lazy[Binder](lambda: self.__new_binder(function))
-
-        @wraps(function)
-        def wrapper(*args, **kwargs):
-            arguments = (~lazy_binder).bind(*args, **kwargs)
-            return function(*arguments.args, **arguments.kwargs)
-
-        return wrapper
-
-    def __class_decorator(self, cls: type, /) -> type:
-        cls.__init__ = self.__decorator(cls.__init__)
-        return cls
-
-    def __new_binder(self, function: Callable[..., Any]) -> Binder:
-        signature = inspect.signature(function, eval_str=True)
-        binder = Binder(signature).update(self.__module)
-        self.__module.add_listener(binder)
-        return binder
-
-
-@final
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectableDecorator:
-    __module: Module
-    __injectable_type: type[BaseInjectable]
-
-    def __repr__(self) -> str:
-        return f"<{self.__injectable_type.__qualname__} decorator>"
-
-    def __call__(
-        self,
-        wrapped: Callable[..., Any] = None,
-        /,
-        *,
-        on: type | Types = None,
-    ):
-        def decorator(wp):
-            @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
-
-    @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)
-
-            elif isfunction(obj):
-                yield get_annotations(obj, eval_str=True).get("return")
-
-            else:
-                yield obj

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.6.8
+Version: 0.6.9
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT

{python_injection-0.6.8.dist-info → python_injection-0.6.9.dist-info}/RECORD

@@ -1,17 +1,17 @@
 injection/__init__.py,sha256=9_AVJILxKIBiL_6KJSh2RRydgSHXH38uahAGD0S1-dI,20
-injection/_pkg.py,sha256=7Ns-9VxyGeIf2fOVfOAa5rD_kxAcY1WSHGSkKYAW4T0,536
-injection/_pkg.pyi,sha256=YfSr-pwahHfVx8wak4JxDcXsgrIohd2ZJ73GgysFLNA,4209
+injection/_pkg.py,sha256=dM48pyMks5CDaUdl4Mv6h_BudbAl8QfYsLbYW9-8Wfw,564
+injection/_pkg.pyi,sha256=EFMxWfYDqf2aI3UosWNXacof8kPsoiu_9GuqFZg4pOQ,4602
 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=3hElLUPtiG6_kmxeWiNabX5zNKN_m1vUc3gBVdOf9WY,887
+injection/common/tools/_type.py,sha256=-zL0dtoVZme71Mscvav7iEWxY2-JltzNTekbWOCPSFo,1276
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=Lm0uc0uUvVQLfnXwfH6xaXoHYuPvdbR8HgFXWrZmi5Y,15595
+injection/core/module.py,sha256=d_dkGRQzEkR_frxdNbxBxbp0jqB-mU0UZ4mwg5aIATA,14407
 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.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,,
+python_injection-0.6.9.dist-info/METADATA,sha256=Y8KBbVJPazkix_y012d70rivwFLvdRwrhEnbpCItOXA,3227
+python_injection-0.6.9.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+python_injection-0.6.9.dist-info/RECORD,,