refactoring: ⚡️ Inject self

Author: remimd

injection/common/lazy.py

@@ -1,7 +1,6 @@
 from collections.abc import Callable, Iterator, Mapping
-from contextlib import suppress
 from types import MappingProxyType
-from typing import Any, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from injection.common.tools.threading import thread_lock
 
@@ -13,35 +12,32 @@
 
 
 class Lazy(Generic[_T]):
-    __slots__ = ("is_set", "__generator")
+    __slots__ = ("__cache", "__is_set")
 
     def __init__(self, factory: Callable[[], _T]):
-        def generator() -> Iterator[_T]:
-            nonlocal factory
-
-            with thread_lock:
-                value = factory()
-                self.is_set = True
-                del factory
+        self.__setup_cache(factory)
 
-            while True:
-                yield value
+    def __invert__(self) -> _T:
+        return next(self.__cache)
 
-        self.is_set = False
-        self.__generator = generator()
+    @property
+    def is_set(self) -> bool:
+        return self.__is_set
 
-    def __invert__(self) -> _T:
-        return next(self.__generator)
+    def __setup_cache(self, factory: Callable[[], _T]):
+        def new_cache() -> Iterator[_T]:
+            with thread_lock:
+                self.__is_set = True
 
-    def __call__(self) -> _T:
-        return ~self
+            nonlocal factory
+            cached = factory()
+            del factory
 
-    def __setattr__(self, name: str, value: Any, /):
-        with suppress(AttributeError):
-            if self.is_set:
-                raise TypeError(f"`{self}` is frozen.")
+            while True:
+                yield cached
 
-        return super().__setattr__(name, value)
+        self.__cache = new_cache()
+        self.__is_set = False
 
 
 class LazyMapping(Mapping[_K, _V]):

injection/common/queue.py

@@ -0,0 +1,68 @@
+from abc import abstractmethod
+from collections import deque
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import NoReturn, Protocol, TypeVar
+
+from injection.common.tools.threading import thread_lock
+
+__all__ = ("LimitedQueue",)
+
+_T = TypeVar("_T")
+
+
+class Queue(Iterator[_T], Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def add(self, item: _T):
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class SimpleQueue(Queue[_T]):
+    __items: deque[_T] = field(default_factory=deque, init=False)
+
+    def __next__(self) -> _T:
+        try:
+            return self.__items.popleft()
+        except IndexError as exc:
+            raise StopIteration from exc
+
+    def add(self, item: _T):
+        self.__items.append(item)
+        return self
+
+
+class NoQueue(Queue[_T]):
+    __slots__ = ()
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __next__(self) -> NoReturn:
+        raise StopIteration
+
+    def add(self, item: _T) -> NoReturn:
+        raise TypeError("Queue doesn't exist.")
+
+
+@dataclass(repr=False, slots=True)
+class LimitedQueue(Queue[_T]):
+    __queue: Queue[_T] = field(default_factory=SimpleQueue)
+
+    def __next__(self) -> _T:
+        if not self.__queue:
+            raise StopIteration
+
+        try:
+            return next(self.__queue)
+        except StopIteration as exc:
+            with thread_lock:
+                self.__queue = NoQueue()
+
+            raise exc
+
+    def add(self, item: _T):
+        self.__queue.add(item)
+        return self

injection/core/module.py

@@ -38,6 +38,7 @@
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
+from injection.common.queue import LimitedQueue
 from injection.common.tools.threading import (
     frozen_collection,
     synchronized,
@@ -418,9 +419,14 @@ def decorator(wp):
                 wp.__init__ = self.inject(wp.__init__)
                 return wp
 
-            wrapper = InjectedFunction(wp).update(self)
-            self.add_listener(wrapper)
-            return wrapper
+            function = InjectedFunction(wp)
+
+            @function.setup
+            def listen():
+                function.update(self)
+                self.add_listener(function)
+
+            return function
 
         return decorator(wrapped) if wrapped else decorator
 
@@ -612,22 +618,36 @@ class Arguments(NamedTuple):
 
 
 class InjectedFunction(EventListener):
-    __slots__ = ("__dict__", "__wrapper", "__dependencies", "__owner")
+    __slots__ = (
+        "__dict__",
+        "__signature__",
+        "__dependencies",
+        "__owner",
+        "__setup_queue",
+        "__wrapper",
+    )
 
     def __init__(self, wrapped: Callable[..., Any], /):
         update_wrapper(self, wrapped)
-        self.__signature__ = Lazy[Signature](
-            lambda: inspect.signature(wrapped, eval_str=True)
-        )
 
         @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.setup(
+            lambda: self.__set_signature(
+                inspect.signature(
+                    wrapped,
+                    eval_str=True,
+                )
+            )
+        )
 
     def __repr__(self) -> str:
         return repr(self.__wrapper)
@@ -638,7 +658,7 @@ def __str__(self) -> str:
     def __call__(self, /, *args, **kwargs) -> Any:
         return self.__wrapper(*args, **kwargs)
 
-    def __get__(self, instance: object | None, owner: type):
+    def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
             return self
 
@@ -647,7 +667,7 @@ def __get__(self, instance: object | None, owner: type):
     def __set_name__(self, owner: type, name: str):
         if self.__dependencies.are_resolved:
             raise TypeError(
-                "`__set_name__` is called after dependencies have been resolved."
+                "Function owner must be assigned before dependencies are resolved."
             )
 
         if self.__owner:
@@ -657,7 +677,7 @@ def __set_name__(self, owner: type, name: str):
 
     @property
     def signature(self) -> Signature:
-        return self.__signature__()
+        return self.__signature__
 
     def bind(
         self,
@@ -671,9 +691,9 @@ def bind(
             return Arguments(args, kwargs)
 
         bound = self.signature.bind_partial(*args, **kwargs)
-        dependencies = self.__dependencies.arguments
-        bound.arguments = dependencies | bound.arguments
-
+        bound.arguments = (
+            bound.arguments | self.__dependencies.arguments | bound.arguments
+        )
         return Arguments(bound.args, bound.kwargs)
 
     def update(self, module: Module):
@@ -686,6 +706,13 @@ def update(self, module: Module):
 
         return self
 
+    def setup(self, wrapped: Callable[[], Any] = None, /):
+        def decorator(wp):
+            self.__setup_queue.add(wp)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
     @singledispatchmethod
     def on_event(self, event: Event, /):
         pass
@@ -695,3 +722,15 @@ def on_event(self, event: Event, /):
     def _(self, event: ModuleEvent, /) -> ContextManager:
         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):
+        with thread_lock:
+            self.__signature__ = signature
+
+        return self

tests/test_inject.py

@@ -53,6 +53,13 @@ def test_inject_with_annotated_and_union(self):
     def test_inject_with_optional(self):
         self.assert_inject(Optional[SomeInjectable])
 
+    def test_inject_with_no_parameter(self):
+        @inject
+        def my_function():
+            pass
+
+        my_function()
+
     def test_inject_with_positional_only_parameter(self):
         @inject
         def my_function(instance: SomeInjectable, /, **kw):