python-injection 0.14.2__py3-none-any.whl → 0.14.3__py3-none-any.whl

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

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.dist-info → python_injection-0.14.3.dist-info}/METADATA

@@ -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.dist-info → python_injection-0.14.3.dist-info}/RECORD

@@ -3,11 +3,10 @@ injection/__init__.pyi,sha256=6B5GdRNaAJ15Q-QAL8nNpTBVIKEUPJAwWIlCSjOkkJ8,10058
 injection/exceptions.py,sha256=dp9XYpWHh8R76wbWDJdjmpTHGQp8KuCeveTqarXY_6Y,999
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/utils.py,sha256=Lr0qHaq3_1AkUoAaw2XmMNie_alwYTeTrRlO22FeCnk,2762
-injection/_core/__init__.py,sha256=XERocCxCZBxPGIaOR37yeiQOZyvjHQ6a4rgRmlkUSuU,1367
+injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=7fSHlgAqmgR_Uta8KocBapOt1Xyj2dI7RY9ZdoStTzw,726
-injection/_core/hook.py,sha256=rJyaSwFAHM8qizWANPUSt5KzWdjxc5oJ2U8hcGeZjU8,3097
 injection/_core/injectables.py,sha256=GIumNp0TXf8Voxe1sCPhcqq2gyw4E_hl7I45IJ_tyHE,4512
-injection/_core/module.py,sha256=1eGb4IHVCJByHUnAG83-oPgp8VbZty8x1YZ6OFT0zEU,31232
+injection/_core/module.py,sha256=pIAolGgvBLGcYxxrS3kyVwCsfeRelIFbjXe-Se3dW8g,30884
 injection/_core/scope.py,sha256=pwOqVKOUM_ZteNScgp-hLqyOHg5Ew75jWlfWLLD2PU8,5437
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/common/asynchronous.py,sha256=9bQDVRE6eqo9K0d5H9RzyFalf0WGoGP7cDrKDGbvZPI,1500
@@ -20,6 +19,6 @@ injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 injection/integrations/fastapi.py,sha256=YHSs85_3m6TUVtOwUcV157b3UZJQIw_aXWAg199a-YE,594
 injection/testing/__init__.py,sha256=Bh3JqEXw62-JnUnspOXr2jpjGXZJ_K_K9CgfD7dPZeQ,793
 injection/testing/__init__.pyi,sha256=1h9zNGghxlo4D1jAx5s8EHk54mn7o-qO7WgJa6hwX6U,484
-python_injection-0.14.2.dist-info/METADATA,sha256=9IhlCQv8o9QERwHq1RZwXB83mmrz4stiLxnoKKhX6sI,3199
-python_injection-0.14.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.14.2.dist-info/RECORD,,
+python_injection-0.14.3.dist-info/METADATA,sha256=ZqqveCnqOcvOBf-l8Zvu3NztDTu6QYPRHeHVUel71TE,3199
+python_injection-0.14.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.14.3.dist-info/RECORD,,

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)