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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.2
+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.2 → 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,
@@ -223,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(
@@ -250,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:
@@ -326,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
 
 
 """

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

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

python_injection-0.14.2/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.2/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)