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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.2
+Version: 0.14.4
 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.4}/injection/__init__.py

@@ -2,6 +2,7 @@ from ._core.descriptors import LazyInstance
 from ._core.injectables import Injectable
 from ._core.module import Mode, Module, Priority, mod
 from ._core.scope import adefine_scope, define_scope
+from ._core.slots import Slot
 
 __all__ = (
     "Injectable",
@@ -9,6 +10,7 @@ __all__ = (
     "Mode",
     "Module",
     "Priority",
+    "Slot",
     "adefine_scope",
     "afind_instance",
     "aget_instance",
@@ -21,6 +23,7 @@ __all__ = (
     "inject",
     "injectable",
     "mod",
+    "reserve_scoped_slot",
     "scoped",
     "set_constant",
     "should_be_injectable",
@@ -36,6 +39,7 @@ get_instance = mod().get_instance
 get_lazy_instance = mod().get_lazy_instance
 inject = mod().inject
 injectable = mod().injectable
+reserve_scoped_slot = mod().reserve_scoped_slot
 scoped = mod().scoped
 set_constant = mod().set_constant
 should_be_injectable = mod().should_be_injectable

{python_injection-0.14.2 → python_injection-0.14.4}/injection/__init__.pyi

@@ -23,6 +23,7 @@ get_instance = __MODULE.get_instance
 get_lazy_instance = __MODULE.get_lazy_instance
 inject = __MODULE.inject
 injectable = __MODULE.injectable
+reserve_scoped_slot = __MODULE.reserve_scoped_slot
 scoped = __MODULE.scoped
 set_constant = __MODULE.set_constant
 should_be_injectable = __MODULE.should_be_injectable
@@ -46,6 +47,11 @@ class Injectable[T](Protocol):
     @abstractmethod
     def get_instance(self) -> T: ...
 
+@runtime_checkable
+class Slot[T](Protocol):
+    @abstractmethod
+    def set(self, instance: T, /) -> Self: ...
+
 class LazyInstance[T]:
     def __init__(
         self,
@@ -171,6 +177,14 @@ class Module:
         that no dependencies are resolved, so the module doesn't need to be locked.
         """
 
+    def reserve_scoped_slot[T](
+        self,
+        on: _TypeInfo[T],
+        /,
+        scope_name: str,
+        *,
+        mode: Mode | ModeStr = ...,
+    ) -> Slot[T]: ...
     def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, T],

{python_injection-0.14.2 → python_injection-0.14.4}/injection/_core/common/type.py

@@ -2,6 +2,7 @@ from collections.abc import (
     AsyncGenerator,
     AsyncIterable,
     AsyncIterator,
+    Awaitable,
     Callable,
     Generator,
     Iterable,
@@ -21,7 +22,12 @@ from typing import (
 
 type TypeDef[T] = type[T] | TypeAliasType | GenericAlias
 type InputType[T] = TypeDef[T] | UnionType
-type TypeInfo[T] = InputType[T] | Callable[..., T] | Iterable[TypeInfo[T]]
+type TypeInfo[T] = (
+    InputType[T]
+    | Callable[..., T]
+    | Callable[..., Awaitable[T]]
+    | Iterable[TypeInfo[T]]
+)
 
 
 def get_return_types(*args: TypeInfo[Any]) -> Iterator[InputType[Any]]:

{python_injection-0.14.2 → python_injection-0.14.4}/injection/_core/injectables.py

@@ -107,25 +107,31 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
         raise NotImplementedError
 
     async def aget_instance(self) -> T:
-        scope = get_scope(self.scope_name)
+        scope = self.get_scope()
 
         with suppress(KeyError):
             return scope.cache[self]
 
         instance = await self.abuild(scope)
-        scope.cache[self] = instance
+        self.set_instance(instance, scope)
         return instance
 
     def get_instance(self) -> T:
-        scope = get_scope(self.scope_name)
+        scope = self.get_scope()
 
         with suppress(KeyError):
             return scope.cache[self]
 
         instance = self.build(scope)
-        scope.cache[self] = instance
+        self.set_instance(instance, scope)
         return instance
 
+    def get_scope(self) -> Scope:
+        return get_scope(self.scope_name)
+
+    def set_instance(self, instance: T, scope: Scope) -> None:
+        scope.cache[self] = instance
+
     def unlock(self) -> None:
         if self.is_locked:
             raise RuntimeError(f"To unlock, close the `{self.scope_name}` scope.")

{python_injection-0.14.2 → python_injection-0.14.4}/injection/_core/module.py

@@ -16,7 +16,7 @@ from collections.abc import (
 from contextlib import asynccontextmanager, contextmanager, nullcontext, suppress
 from dataclasses import dataclass, field
 from enum import StrEnum
-from functools import partialmethod, singledispatchmethod, update_wrapper
+from functools import partial, partialmethod, singledispatchmethod, update_wrapper
 from inspect import (
     Signature,
     isasyncgenfunction,
@@ -57,18 +57,21 @@ 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,
     Injectable,
+    ScopedInjectable,
     ShouldBeInjectable,
     SimpleInjectable,
     SimpleScopedInjectable,
     SingletonInjectable,
 )
+from injection._core.slots import ScopedSlot, Slot
 from injection.exceptions import (
+    EmptySlotError,
     ModuleError,
     ModuleLockError,
     ModuleNotUsedError,
@@ -222,21 +225,19 @@ class Updater[T]:
     def make_record(self) -> Record[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,
-    )
+    @classmethod
+    def with_basics(
+        cls,
+        on: TypeInfo[T],
+        /,
+        injectable: Injectable[T],
+        mode: Mode | ModeStr,
+    ) -> Self:
+        return cls(
+            classes=get_return_types(on),
+            injectable=injectable,
+            mode=Mode(mode),
+        )
 
 
 @dataclass(repr=False, frozen=True, slots=True)
@@ -250,8 +251,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 +325,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
 
 
 """
@@ -433,12 +437,9 @@ class Module(Broker, EventListener):
     ) -> Any:
         def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
             factory = extract_caller(self.make_injected_function(wp) if inject else wp)
+            injectable = cls(factory)  # type: ignore[arg-type]
             hints = on if ignore_type_hint else (wp, on)
-            updater = Updater(
-                classes=get_return_types(hints),
-                injectable=cls(factory),  # type: ignore[arg-type]
-                mode=Mode(mode),
-            )
+            updater = Updater.with_basics(hints, injectable, mode)
             self.update(updater)
             return wp
 
@@ -458,7 +459,7 @@ class Module(Broker, EventListener):
         def decorator(
             wrapped: Recipe[P, T] | GeneratorRecipe[P, T],
         ) -> Recipe[P, T] | GeneratorRecipe[P, T]:
-            injectable_class: Callable[[Caller[P, Any], str], Injectable[T]]
+            injectable_class: type[ScopedInjectable[Any, T]]
             wrapper: Recipe[P, T] | ContextManagerLikeRecipe[P, T]
 
             if isasyncgenfunction(wrapped):
@@ -478,7 +479,7 @@ class Module(Broker, EventListener):
             hints = on if hint is None else (hint, on)
             self.injectable(
                 wrapper,
-                cls=lambda factory: injectable_class(factory, scope_name),
+                cls=partial(injectable_class, scope_name=scope_name),
                 ignore_type_hint=True,
                 inject=inject,
                 on=hints,
@@ -539,6 +540,24 @@ class Module(Broker, EventListener):
         )
         return self
 
+    def reserve_scoped_slot[T](
+        self,
+        on: TypeInfo[T],
+        /,
+        scope_name: str,
+        *,
+        mode: Mode | ModeStr = Mode.get_default(),
+    ) -> Slot[T]:
+        def when_empty() -> T:
+            raise EmptySlotError(
+                f"The slot for `{on}` is unset in the current `{scope_name}` scope."
+            )
+
+        injectable = SimpleScopedInjectable(SyncCaller(when_empty), scope_name)
+        updater = Updater.with_basics(on, injectable, mode)
+        self.update(updater)
+        return ScopedSlot(injectable)
+
     def inject[**P, T](
         self,
         wrapped: Callable[P, T] | None = None,

python_injection-0.14.4/injection/_core/slots.py

@@ -0,0 +1,24 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, Protocol, runtime_checkable
+
+from injection._core.injectables import ScopedInjectable
+
+
+@runtime_checkable
+class Slot[T](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def set(self, instance: T, /) -> None:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class ScopedSlot[T](Slot[T]):
+    injectable: ScopedInjectable[Any, T]
+
+    def set(self, instance: T, /) -> None:
+        injectable = self.injectable
+        scope = injectable.get_scope()
+        injectable.set_instance(instance, scope)

{python_injection-0.14.2 → python_injection-0.14.4}/injection/exceptions.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 __all__ = (
-    "HookError",
+    "EmptySlotError",
     "InjectionError",
     "ModuleError",
     "ModuleLockError",
@@ -34,6 +34,9 @@ class NoInjectable[T](KeyError, InjectionError):
 class SkipInjectable(InjectionError): ...
 
 
+class EmptySlotError(SkipInjectable, InjectionError): ...
+
+
 class ModuleError(InjectionError): ...
 
 
@@ -50,6 +53,3 @@ class ScopeUndefinedError(LookupError, SkipInjectable, ScopeError): ...
 
 
 class ScopeAlreadyDefinedError(ScopeError): ...
-
-
-class HookError(InjectionError): ...

{python_injection-0.14.2 → python_injection-0.14.4}/injection/testing/__init__.py

@@ -5,6 +5,7 @@ from injection.utils import load_profile
 
 __all__ = (
     "load_test_profile",
+    "reserve_scoped_test_slot",
     "set_test_constant",
     "should_be_test_injectable",
     "test_constant",
@@ -15,6 +16,7 @@ __all__ = (
 
 _TEST_PROFILE_NAME: Final[str] = "__testing__"
 
+reserve_scoped_test_slot = mod(_TEST_PROFILE_NAME).reserve_scoped_slot
 set_test_constant = mod(_TEST_PROFILE_NAME).set_constant
 should_be_test_injectable = mod(_TEST_PROFILE_NAME).should_be_injectable
 test_constant = mod(_TEST_PROFILE_NAME).constant

{python_injection-0.14.2 → python_injection-0.14.4}/injection/testing/__init__.pyi

@@ -4,6 +4,7 @@ from injection import Module
 
 __MODULE: Final[Module] = ...
 
+reserve_scoped_test_slot = __MODULE.reserve_scoped_slot
 set_test_constant = __MODULE.set_constant
 should_be_test_injectable = __MODULE.should_be_injectable
 test_constant = __MODULE.constant

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

@@ -24,7 +24,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.14.2"
+version = "0.14.4"
 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)