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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.14.3
+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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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,
@@ -63,12 +63,15 @@ 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,6 +225,20 @@ class Updater[T]:
     def make_record(self) -> Record[T]:
         return Record(self.injectable, self.mode)
 
+    @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)
 class Locator(Broker):
@@ -420,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
 
@@ -445,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):
@@ -465,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,
@@ -526,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.3 → 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.3 → 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.3 → 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.3 → python_injection-0.14.4}/pyproject.toml

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