on progress

Author: remimd

injection/common/lazy.py

@@ -56,3 +56,7 @@ def __iter__(self) -> Iterator[_K]:
 
     def __len__(self) -> int:
         return len(~self.__lazy)
+
+    @property
+    def is_set(self) -> bool:
+        return self.__lazy.is_set

injection/core/module.py

@@ -25,7 +25,7 @@
     wraps,
 )
 from inspect import Signature, isclass
-from types import MappingProxyType, UnionType
+from types import UnionType
 from typing import (
     Any,
     ClassVar,
@@ -421,7 +421,7 @@ def decorator(wp):
                 wp.__init__ = self.inject(wp.__init__, force=force)
                 return wp
 
-            wrapper = Injected(wp, force=force).update(self)
+            wrapper = InjectionFunction(wp, force=force).update(self)
             self.add_listener(wrapper)
             return wrapper
 
@@ -540,45 +540,35 @@ def __move_module(self, module: Module, priority: ModulePriority):
 
 
 """
-Injected
+InjectionFunction
 """
 
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Dependencies:
-    mapping: MappingProxyType[str, Injectable]
-
-    __SELF_KEY: ClassVar[str] = "$self"
+    mapping: Mapping[str, Injectable]
 
     def __bool__(self) -> bool:
         return bool(self.mapping)
 
-    @property
-    def arguments(self) -> OrderedDict[str, Any]:
-        return OrderedDict(self.items(exclude={self.__SELF_KEY}))
-
-    @property
-    def self(self) -> Any | None:
-        return self.get(self.__SELF_KEY)
-
-    def items(self, /, *, exclude: Set[str] = frozenset()) -> Iterator[tuple[str, Any]]:
+    def __iter__(self) -> Iterator[tuple[str, Any]]:
         for name, injectable in self.mapping.items():
-            if name in exclude:
-                continue
-
             yield name, injectable.get_instance()
 
-    def get(self, key: str) -> Any | None:
-        injectable = self.mapping.get(key)
+    @property
+    def are_resolved(self) -> bool:
+        if isinstance(self.mapping, LazyMapping) and not self.mapping.is_set:
+            return False
 
-        if injectable is None:
-            return None
+        return bool(self)
 
-        return injectable.get_instance()
+    @property
+    def arguments(self) -> OrderedDict[str, Any]:
+        return OrderedDict(self)
 
     @classmethod
     def from_mapping(cls, mapping: Mapping[str, Injectable]):
-        return cls(mapping=MappingProxyType(mapping))
+        return cls(mapping=mapping)
 
     @classmethod
     def empty(cls):
@@ -602,8 +592,9 @@ def __resolver(
         )
 
         if owner:
+            name, _ = next(hints)
             hints = itertools.chain(
-                ((cls.__SELF_KEY, owner),),
+                ((name, owner),),
                 hints,
             )
 
@@ -621,48 +612,47 @@ class Arguments(NamedTuple):
     kwargs: Mapping[str, Any]
 
 
-class Injected(EventListener):
-    __slots__ = ("__dict__", "__function", "__dependencies", "__owner")
+class InjectionFunction(EventListener):
+    __slots__ = ("__dict__", "__wrapped__", "__wrapper", "__dependencies", "__owner")
 
     def __init__(self, wrapped: Callable[..., Any], *, force: bool = False):
-        update_wrapper(self, wrapped)
+        update_wrapper(self, wrapped, updated=())
 
         @wraps(wrapped)
         def wrapper(*args, **kwargs):
             args, kwargs = self.bind(args, kwargs, force)
             return wrapped(*args, **kwargs)
 
-        self.__function = wrapper
+        self.__wrapper = wrapper
         self.__dependencies = Dependencies.empty()
         self.__owner = None
 
     def __repr__(self) -> str:
-        return repr(self.__function)
+        return repr(self.__wrapped__)
 
     def __str__(self) -> str:
-        return str(self.__function)
+        return str(self.__wrapped__)
 
     def __call__(self, /, *args, **kwargs) -> Any:
-        return self.__function(*args, **kwargs)
+        return self.__wrapper(*args, **kwargs)
 
     def __get__(self, instance: object | None, owner: type):
         if instance is None:
-            instance = self.__dependencies.self
+            return self
 
-        return self.__function.__get__(instance, owner)
+        return self.__wrapper.__get__(instance, owner)
 
     def __set_name__(self, owner: type, name: str):
-        if self.__dependencies:
-            raise TypeError
+        if self.__dependencies.are_resolved:
+            raise TypeError("TODO")
 
         if self.__owner:
-            raise TypeError
+            raise TypeError("TODO")
 
-        with thread_lock:
-            self.__owner = owner
+        self.__owner = owner
 
     @cached_property
-    def __signature(self) -> Signature:
+    def __signature__(self) -> Signature:
         return inspect.signature(self.__wrapped__, eval_str=True)
 
     def bind(
@@ -674,22 +664,23 @@ def bind(
         if kwargs is None:
             kwargs = {}
 
-        if not (arguments := self.__dependencies.arguments):
+        if not self.__dependencies:
             return Arguments(args, kwargs)
 
-        bound = self.__signature.bind_partial(*args, **kwargs)
+        bound = self.__signature__.bind_partial(*args, **kwargs)
+        dependencies = self.__dependencies.arguments
 
         if force:
-            bound.arguments |= arguments
+            bound.arguments |= dependencies
         else:
-            bound.arguments = arguments | bound.arguments
+            bound.arguments = dependencies | bound.arguments
 
         return Arguments(bound.args, bound.kwargs)
 
     def update(self, module: Module):
         with thread_lock:
             self.__dependencies = Dependencies.resolve(
-                self.__signature,
+                self.__signature__,
                 module,
                 self.__owner,
             )

tests/test_inject.py

@@ -175,13 +175,11 @@ def test_inject_with_self_injectable(self):
         class A:
             @inject
             def my_method(self, dependency: SomeInjectable):
-                pass
+                assert isinstance(self, A)
+                assert isinstance(dependency, SomeInjectable)
 
         with pytest.raises(TypeError):
             A.my_method()
 
         injectable(A)
         assert A.my_method() is None
-
-        a = A.my_method.__self__
-        assert isinstance(a, A)