python-injection 0.14.1__tar.gz → 0.14.3__tar.gz

{python_injection-0.14.1 → python_injection-0.14.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.1
+Version: 0.14.3
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.14.1 → python_injection-0.14.3}/injection/_core/module.py

@@ -57,8 +57,8 @@ from injection._core.common.type import (
     TypeInfo,
     get_return_types,
     get_yield_hint,
+    standardize_types,
 )
-from injection._core.hook import Hook, apply_hooks
 from injection._core.injectables import (
     AsyncCMScopedInjectable,
     CMScopedInjectable,
@@ -73,6 +73,7 @@ from injection.exceptions import (
     ModuleLockError,
     ModuleNotUsedError,
     NoInjectable,
+    SkipInjectable,
 )
 
 """
@@ -222,22 +223,6 @@ class Updater[T]:
         return Record(self.injectable, self.mode)
 
 
-@dataclass(repr=False, eq=False, frozen=True, slots=True)
-class LocatorHooks[T]:
-    on_conflict: Hook[[Record[T], Record[T], InputType[T]], bool] = field(
-        default_factory=Hook,
-        init=False,
-    )
-    on_input: Hook[[Iterable[InputType[T]]], Iterable[InputType[T]]] = field(
-        default_factory=Hook,
-        init=False,
-    )
-    on_update: Hook[[Updater[T]], Updater[T]] = field(
-        default_factory=Hook,
-        init=False,
-    )
-
-
 @dataclass(repr=False, frozen=True, slots=True)
 class Locator(Broker):
     __records: dict[InputType[Any], Record[Any]] = field(
@@ -249,8 +234,6 @@ class Locator(Broker):
         init=False,
     )
 
-    static_hooks: ClassVar[LocatorHooks[Any]] = LocatorHooks()
-
     def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
         for input_class in self.__standardize_inputs((cls,)):
             try:
@@ -325,25 +308,30 @@ class Locator(Broker):
 
             yield cls, record
 
+    @staticmethod
     def __keep_new_record[T](
-        self,
         new: Record[T],
         existing: Record[T],
         cls: InputType[T],
     ) -> bool:
-        return apply_hooks(
-            lambda *args, **kwargs: False,
-            self.static_hooks.on_conflict,
-        )(new, existing, cls)
+        new_mode, existing_mode = new.mode, existing.mode
+        is_override = new_mode == Mode.OVERRIDE
+
+        if new_mode == existing_mode and not is_override:
+            raise RuntimeError(f"An injectable already exists for the class `{cls}`.")
+
+        return is_override or new_mode.rank > existing_mode.rank
 
+    @staticmethod
     def __standardize_inputs[T](
-        self,
         classes: Iterable[InputType[T]],
     ) -> Iterable[InputType[T]]:
-        return apply_hooks(lambda c: c, self.static_hooks.on_input)(classes)
+        return tuple(standardize_types(*classes, with_origin=True))
 
-    def __update_preprocessing[T](self, updater: Updater[T]) -> Updater[T]:
-        return apply_hooks(lambda u: u, self.static_hooks.on_update)(updater)
+    @staticmethod
+    def __update_preprocessing[T](updater: Updater[T]) -> Updater[T]:
+        updater.classes = frozenset(standardize_types(*updater.classes))
+        return updater
 
 
 """
@@ -620,7 +608,7 @@ class Module(Broker, EventListener):
     async def aget_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
         try:
             return await self.afind_instance(cls)
-        except KeyError:
+        except (KeyError, SkipInjectable):
             return default
 
     @overload
@@ -640,7 +628,7 @@ class Module(Broker, EventListener):
     def get_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
         try:
             return self.find_instance(cls)
-        except KeyError:
+        except (KeyError, SkipInjectable):
             return default
 
     @overload
@@ -866,29 +854,28 @@ class Dependencies:
     lazy_mapping: Lazy[Mapping[str, Injectable[Any]]]
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for name, injectable in self.mapping.items():
-            instance = injectable.get_instance()
-            yield name, instance
+        for name, injectable in self.items():
+            with suppress(SkipInjectable):
+                yield name, injectable.get_instance()
 
     async def __aiter__(self) -> AsyncIterator[tuple[str, Any]]:
-        for name, injectable in self.mapping.items():
-            instance = await injectable.aget_instance()
-            yield name, instance
+        for name, injectable in self.items():
+            with suppress(SkipInjectable):
+                yield name, await injectable.aget_instance()
 
     @property
     def are_resolved(self) -> bool:
         return self.lazy_mapping.is_set
 
-    @property
-    def mapping(self) -> Mapping[str, Injectable[Any]]:
-        return ~self.lazy_mapping
-
     async def aget_arguments(self) -> dict[str, Any]:
         return {key: value async for key, value in self}
 
     def get_arguments(self) -> dict[str, Any]:
         return dict(self)
 
+    def items(self) -> Iterator[tuple[str, Injectable[Any]]]:
+        return iter((~self.lazy_mapping).items())
+
     @classmethod
     def from_iterable(cls, iterable: Iterable[tuple[str, Injectable[Any]]]) -> Self:
         lazy_mapping = Lazy(lambda: dict(iterable))

{python_injection-0.14.1 → python_injection-0.14.3}/injection/exceptions.py

@@ -10,6 +10,7 @@ __all__ = (
     "ScopeAlreadyDefinedError",
     "ScopeError",
     "ScopeUndefinedError",
+    "SkipInjectable",
 )
 
 
@@ -30,6 +31,9 @@ class NoInjectable[T](KeyError, InjectionError):
         return self.__class
 
 
+class SkipInjectable(InjectionError): ...
+
+
 class ModuleError(InjectionError): ...
 
 
@@ -42,7 +46,7 @@ class ModuleNotUsedError(KeyError, ModuleError): ...
 class ScopeError(InjectionError): ...
 
 
-class ScopeUndefinedError(LookupError, ScopeError): ...
+class ScopeUndefinedError(LookupError, SkipInjectable, ScopeError): ...
 
 
 class ScopeAlreadyDefinedError(ScopeError): ...

{python_injection-0.14.1 → python_injection-0.14.3}/pyproject.toml

@@ -24,7 +24,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.14.1"
+version = "0.14.3"
 description = "Fast and easy dependency injection framework."
 license = { text = "MIT" }
 readme = "README.md"

python_injection-0.14.1/injection/_core/__init__.py

@@ -1,53 +0,0 @@
-from collections.abc import Iterable
-from typing import Any
-
-from injection._core.common.type import InputType, standardize_types
-from injection._core.hook import HookGenerator
-from injection._core.module import Locator, Mode, Record, Updater
-
-__all__ = ()
-
-
-@Locator.static_hooks.on_conflict
-def check_mode[T](
-    new: Record[T],
-    existing: Record[T],
-    cls: InputType[T],
-    *_: Any,
-    **__: Any,
-) -> HookGenerator[bool]:
-    new_mode = new.mode
-    is_override = new_mode == Mode.OVERRIDE
-
-    if new_mode == existing.mode and not is_override:
-        raise RuntimeError(f"An injectable already exists for the class `{cls}`.")
-
-    value = yield
-    return value or is_override
-
-
-@Locator.static_hooks.on_conflict
-def compare_mode_rank[T](
-    new: Record[T],
-    existing: Record[T],
-    *_: Any,
-    **__: Any,
-) -> HookGenerator[bool]:
-    value = yield
-    return value or new.mode.rank > existing.mode.rank
-
-
-@Locator.static_hooks.on_input
-def standardize_input_classes[T](
-    *_: Any,
-    **__: Any,
-) -> HookGenerator[Iterable[InputType[T]]]:
-    classes = yield
-    return tuple(standardize_types(*classes, with_origin=True))
-
-
-@Locator.static_hooks.on_update
-def standardize_classes[T](*_: Any, **__: Any) -> HookGenerator[Updater[T]]:
-    updater = yield
-    updater.classes = frozenset(standardize_types(*updater.classes))
-    return updater

python_injection-0.14.1/injection/_core/hook.py

@@ -1,106 +0,0 @@
-import itertools
-from collections.abc import Callable, Generator, Iterator
-from dataclasses import dataclass, field
-from inspect import isclass, isgeneratorfunction
-from typing import Any, Self, TypeGuard
-
-from injection.exceptions import HookError
-
-type HookGenerator[T] = Generator[None, T, T]
-type HookGeneratorFunction[**P, T] = Callable[P, HookGenerator[T]]
-type HookFunction[**P, T] = Callable[P, T] | HookGeneratorFunction[P, T]
-
-
-@dataclass(eq=False, frozen=True, slots=True)
-class Hook[**P, T]:
-    __functions: list[HookFunction[P, T]] = field(
-        default_factory=list,
-        init=False,
-        repr=False,
-    )
-
-    def __call__(
-        self,
-        wrapped: HookFunction[P, T] | type[HookFunction[P, T]] | None = None,
-        /,
-    ) -> Any:
-        def decorator(wp: Any) -> Any:
-            self.add(wp() if isclass(wp) else wp)
-            return wp
-
-        return decorator(wrapped) if wrapped else decorator
-
-    @property
-    def __stack(self) -> Iterator[HookFunction[P, T]]:
-        return iter(self.__functions)
-
-    def add(self, *functions: HookFunction[P, T]) -> Self:
-        self.__functions.extend(reversed(functions))
-        return self
-
-    @classmethod
-    def apply_several(cls, handler: Callable[P, T], *hooks: Self) -> Callable[P, T]:
-        stack = itertools.chain.from_iterable((hook.__stack for hook in hooks))
-        return cls.__apply_stack(handler, stack)
-
-    @classmethod
-    def __apply_function(
-        cls,
-        handler: Callable[P, T],
-        function: HookFunction[P, T],
-    ) -> Callable[P, T]:
-        if not cls.__is_hook_generator_function(function):
-            return function  # type: ignore[return-value]
-
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
-            hook: HookGenerator[T] = function(*args, **kwargs)
-
-            try:
-                next(hook)
-
-                try:
-                    value = handler(*args, **kwargs)
-                except BaseException as exc:
-                    hook.throw(exc)
-                else:
-                    hook.send(value)
-
-            except StopIteration as stop:
-                return stop.value
-
-            finally:
-                hook.close()
-
-            raise HookError("Missing return value.")
-
-        return wrapper
-
-    @classmethod
-    def __apply_stack(
-        cls,
-        handler: Callable[P, T],
-        stack: Iterator[HookFunction[P, T]],
-    ) -> Callable[P, T]:
-        for function in stack:
-            new_handler = cls.__apply_function(handler, function)
-            return cls.__apply_stack(new_handler, stack)
-
-        return handler
-
-    @staticmethod
-    def __is_hook_generator_function[**_P, _T](
-        function: HookFunction[_P, _T],
-    ) -> TypeGuard[HookGeneratorFunction[_P, _T]]:
-        for fn in function, getattr(function, "__call__", None):
-            if isgeneratorfunction(fn):
-                return True
-
-        return False
-
-
-def apply_hooks[**P, T](
-    handler: Callable[P, T],
-    hook: Hook[P, T],
-    *hooks: Hook[P, T],
-) -> Callable[P, T]:
-    return Hook.apply_several(handler, hook, *hooks)