python-injection 0.15.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

injection/__init__.py

@@ -1,8 +1,9 @@
 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
+from ._core.scope import ScopeFacade as Scope
+from ._core.scope import ScopeKind, adefine_scope, define_scope
+from ._core.slots import SlotKey
 
 __all__ = (
     "Injectable",
@@ -10,7 +11,9 @@ __all__ = (
     "Mode",
     "Module",
     "Priority",
-    "Slot",
+    "Scope",
+    "ScopeKind",
+    "SlotKey",
     "adefine_scope",
     "afind_instance",
     "aget_instance",

injection/__init__.pyi

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Mapping
 from contextlib import asynccontextmanager, contextmanager
 from enum import Enum
 from logging import Logger
@@ -11,6 +11,7 @@ from ._core.common.type import TypeInfo as _TypeInfo
 from ._core.module import InjectableFactory as _InjectableFactory
 from ._core.module import ModeStr, PriorityStr
 from ._core.module import Recipe as _Recipe
+from ._core.scope import ScopeKindStr
 
 __MODULE: Final[Module] = ...
 
@@ -30,9 +31,17 @@ should_be_injectable = __MODULE.should_be_injectable
 singleton = __MODULE.singleton
 
 @asynccontextmanager
-def adefine_scope(name: str, *, shared: bool = ...) -> AsyncIterator[None]: ...
+def adefine_scope(
+    name: str,
+    /,
+    kind: ScopeKind | ScopeKindStr = ...,
+) -> AsyncIterator[Scope]: ...
 @contextmanager
-def define_scope(name: str, *, shared: bool = ...) -> Iterator[None]: ...
+def define_scope(
+    name: str,
+    /,
+    kind: ScopeKind | ScopeKindStr = ...,
+) -> Iterator[Scope]: ...
 def mod(name: str = ..., /) -> Module:
     """
     Short syntax for `Module.from_name`.
@@ -47,10 +56,19 @@ class Injectable[T](Protocol):
     @abstractmethod
     def get_instance(self) -> T: ...
 
+@final
+class ScopeKind(Enum):
+    CONTEXTUAL = ...
+    SHARED = ...
+
 @runtime_checkable
-class Slot[T](Protocol):
+class Scope(Protocol):
     @abstractmethod
-    def set(self, instance: T, /) -> None: ...
+    def set_slot[T](self, key: SlotKey[T], value: T) -> Self: ...
+    @abstractmethod
+    def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self: ...
+
+class SlotKey[T]: ...
 
 class LazyInstance[T]:
     def __init__(
@@ -179,12 +197,12 @@ class Module:
 
     def reserve_scoped_slot[T](
         self,
-        on: _TypeInfo[T],
+        cls: type[T],
         /,
         scope_name: str,
         *,
         mode: Mode | ModeStr = ...,
-    ) -> Slot[T]: ...
+    ) -> SlotKey[T]: ...
     def make_injected_function[**P, T](
         self,
         wrapped: Callable[P, T],

injection/_core/injectables.py

@@ -17,8 +17,14 @@ from injection._core.common.asynchronous import Caller
 from injection._core.common.asynchronous import (
     create_semaphore as _create_async_semaphore,
 )
-from injection._core.scope import Scope, get_active_scopes, get_scope
-from injection.exceptions import InjectionError
+from injection._core.scope import (
+    Scope,
+    get_scope,
+    in_scope_cache,
+    remove_scoped_values,
+)
+from injection._core.slots import SlotKey
+from injection.exceptions import EmptySlotError, InjectionError
 
 
 @runtime_checkable
@@ -123,7 +129,7 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
 
     @property
     def is_locked(self) -> bool:
-        return any(self in scope.cache for scope in get_active_scopes(self.scope_name))
+        return in_scope_cache(self, self.scope_name)
 
     @abstractmethod
     async def abuild(self, scope: Scope) -> T:
@@ -143,10 +149,6 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
         factory = partial(self.build, scope)
         return self.logic.get_or_create(scope.cache, self, factory)
 
-    def setdefault(self, instance: T) -> T:
-        scope = self.__get_scope()
-        return self.logic.get_or_create(scope.cache, self, lambda: instance)
-
     def unlock(self) -> None:
         if self.is_locked:
             raise RuntimeError(f"To unlock, close the `{self.scope_name}` scope.")
@@ -188,8 +190,35 @@ class SimpleScopedInjectable[T](ScopedInjectable[T, T]):
         return self.factory.call()
 
     def unlock(self) -> None:
-        for scope in get_active_scopes(self.scope_name):
-            scope.cache.pop(self, None)
+        remove_scoped_values(self, self.scope_name)
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class ScopedSlotInjectable[T](Injectable[T]):
+    cls: type[T]
+    scope_name: str
+    key: SlotKey[T] = field(default_factory=SlotKey)
+
+    @property
+    def is_locked(self) -> bool:
+        return in_scope_cache(self.key, self.scope_name)
+
+    async def aget_instance(self) -> T:
+        return self.get_instance()
+
+    def get_instance(self) -> T:
+        scope_name = self.scope_name
+        scope = get_scope(scope_name)
+
+        try:
+            return scope.cache[self.key]
+        except KeyError as exc:
+            raise EmptySlotError(
+                f"The slot for `{self.cls}` isn't set in the current `{scope_name}` scope."
+            ) from exc
+
+    def unlock(self) -> None:
+        remove_scoped_values(self.key, self.scope_name)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

injection/_core/module.py

@@ -64,14 +64,14 @@ from injection._core.injectables import (
     CMScopedInjectable,
     Injectable,
     ScopedInjectable,
+    ScopedSlotInjectable,
     ShouldBeInjectable,
     SimpleInjectable,
     SimpleScopedInjectable,
     SingletonInjectable,
 )
-from injection._core.slots import ScopedSlot, Slot
+from injection._core.slots import SlotKey
 from injection.exceptions import (
-    EmptySlotError,
     ModuleError,
     ModuleLockError,
     ModuleNotUsedError,
@@ -492,11 +492,8 @@ class Module(Broker, EventListener):
 
     def should_be_injectable[T](self, wrapped: type[T] | None = None, /) -> Any:
         def decorator(wp: type[T]) -> type[T]:
-            updater = Updater(
-                classes=(wp,),
-                injectable=ShouldBeInjectable(wp),
-                mode=Mode.FALLBACK,
-            )
+            injectable = ShouldBeInjectable(wp)
+            updater = Updater.with_basics(wp, injectable, Mode.FALLBACK)
             self.update(updater)
             return wp
 
@@ -543,21 +540,16 @@ class Module(Broker, EventListener):
 
     def reserve_scoped_slot[T](
         self,
-        on: TypeInfo[T],
+        cls: type[T],
         /,
         scope_name: str,
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-    ) -> Slot[T]:
-        def when_empty() -> T:
-            raise EmptySlotError(
-                f"The slot for `{on}` isn't set in the current `{scope_name}` scope."
-            )
-
-        injectable = SimpleScopedInjectable(SyncCaller(when_empty), scope_name)
-        updater = Updater.with_basics(on, injectable, mode)
+    ) -> SlotKey[T]:
+        injectable = ScopedSlotInjectable(cls, scope_name)
+        updater = Updater.with_basics(cls, injectable, mode)
         self.update(updater)
-        return ScopedSlot(injectable)
+        return injectable.key
 
     def inject[**P, T](
         self,

injection/_core/scope.py

@@ -7,12 +7,14 @@ from collections.abc import AsyncIterator, Iterator, Mapping, MutableMapping
 from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
+from enum import StrEnum
 from types import EllipsisType, TracebackType
 from typing import (
     Any,
     AsyncContextManager,
     ContextManager,
     Final,
+    Literal,
     NoReturn,
     Protocol,
     Self,
@@ -21,13 +23,27 @@ from typing import (
 )
 
 from injection._core.common.key import new_short_key
+from injection._core.slots import SlotKey
 from injection.exceptions import (
+    InjectionError,
     ScopeAlreadyDefinedError,
     ScopeError,
     ScopeUndefinedError,
 )
 
 
+class ScopeKind(StrEnum):
+    CONTEXTUAL = "contextual"
+    SHARED = "shared"
+
+    @classmethod
+    def get_default(cls) -> ScopeKind:
+        return cls.CONTEXTUAL
+
+
+type ScopeKindStr = Literal["contextual", "shared"]
+
+
 @runtime_checkable
 class ScopeState(Protocol):
     __slots__ = ()
@@ -109,17 +125,25 @@ __SHARED_SCOPES: Final[Mapping[str, ScopeState]] = defaultdict(
 
 
 @asynccontextmanager
-async def adefine_scope(name: str, *, shared: bool = False) -> AsyncIterator[None]:
+async def adefine_scope(
+    name: str,
+    /,
+    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+) -> AsyncIterator[ScopeFacade]:
     async with AsyncScope() as scope:
-        scope.enter(_bind_scope(name, scope, shared))
-        yield
+        with _bind_scope(name, scope, kind) as facade:
+            yield facade
 
 
 @contextmanager
-def define_scope(name: str, *, shared: bool = False) -> Iterator[None]:
+def define_scope(
+    name: str,
+    /,
+    kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
+) -> Iterator[ScopeFacade]:
     with SyncScope() as scope:
-        scope.enter(_bind_scope(name, scope, shared))
-        yield
+        with _bind_scope(name, scope, kind) as facade:
+            yield facade
 
 
 def get_active_scopes(name: str) -> tuple[Scope, ...]:
@@ -153,15 +177,32 @@ def get_scope(name, default=...):  # type: ignore[no-untyped-def]
     return default
 
 
-@contextmanager
-def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
-    if shared:
-        is_already_defined = bool(get_active_scopes(name))
-        states = __SHARED_SCOPES
+def in_scope_cache(key: Any, scope_name: str) -> bool:
+    return any(key in scope.cache for scope in get_active_scopes(scope_name))
+
 
-    else:
-        is_already_defined = bool(get_scope(name, default=None))
-        states = __CONTEXTUAL_SCOPES
+def remove_scoped_values(key: Any, scope_name: str) -> None:
+    for scope in get_active_scopes(scope_name):
+        scope.cache.pop(key, None)
+
+
+@contextmanager
+def _bind_scope(
+    name: str,
+    scope: Scope,
+    kind: ScopeKind | ScopeKindStr,
+) -> Iterator[ScopeFacade]:
+    match ScopeKind(kind):
+        case ScopeKind.CONTEXTUAL:
+            is_already_defined = bool(get_scope(name, default=None))
+            states = __CONTEXTUAL_SCOPES
+
+        case ScopeKind.SHARED:
+            is_already_defined = bool(get_active_scopes(name))
+            states = __SHARED_SCOPES
+
+        case _:
+            raise NotImplementedError
 
     if is_already_defined:
         raise ScopeAlreadyDefinedError(
@@ -169,7 +210,7 @@ def _bind_scope(name: str, scope: Scope, shared: bool) -> Iterator[None]:
         )
 
     with states[name].bind(scope):
-        yield
+        yield _UserScope(scope)
 
 
 @runtime_checkable
@@ -245,3 +286,34 @@ class SyncScope(BaseScope[ExitStack]):
 
     def enter[T](self, context_manager: ContextManager[T]) -> T:
         return self.delegate.enter_context(context_manager)
+
+
+@runtime_checkable
+class ScopeFacade(Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
+        raise NotImplementedError
+
+    @abstractmethod
+    def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class _UserScope(ScopeFacade):
+    scope: Scope
+
+    def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
+        return self.slot_map({key: value})
+
+    def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self:
+        cache = self.scope.cache
+
+        for slot_key in mapping:
+            if slot_key in cache:
+                raise InjectionError("Slot already set.")
+
+        cache.update(mapping)
+        return self

injection/_core/slots.py

@@ -1,24 +1,2 @@
-from abc import abstractmethod
-from dataclasses import dataclass
-from typing import Any, Protocol, runtime_checkable
-
-from injection._core.injectables import ScopedInjectable
-from injection.exceptions import InjectionError
-
-
-@runtime_checkable
-class Slot[T](Protocol):
+class SlotKey[T]:
     __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:
-        if self.injectable.setdefault(instance) is not instance:
-            raise InjectionError("Slot already set.")

{python_injection-0.15.0.dist-info → python_injection-0.17.0.dist-info}/METADATA

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

{python_injection-0.15.0.dist-info → python_injection-0.17.0.dist-info}/RECORD

@@ -1,14 +1,14 @@
-injection/__init__.py,sha256=a-rBAlBTiH6TzZ-11NGK6diovfibyKmmnf99PZUog1A,1166
-injection/__init__.pyi,sha256=rOl1kA9BkIeXDr7OdBMifAg9xWwvme447yjDZooir18,10398
+injection/__init__.py,sha256=7ZRUlO5EEPWO7IlbYHD-8DOX-cg4Np4nYq5fpw-U56o,1259
+injection/__init__.pyi,sha256=O2W6ZWcwH58JnDmJNkJ6cdoaO0D2NE7PEVFgfJNTwB0,10717
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
 injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/utils.py,sha256=bLIVA_3N3mTEQ3kGV4YzrWEnokHxUGqWYNKPggOOnpg,4065
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=7fSHlgAqmgR_Uta8KocBapOt1Xyj2dI7RY9ZdoStTzw,726
-injection/_core/injectables.py,sha256=idNkQZZ29vd73G_lE-eS5C7zGeVe_ALNkUt8M6YjZrk,5519
-injection/_core/module.py,sha256=KrEr66q1lazwz7F7jYscpr-ExX8aOwYHEho1IotXa54,31814
-injection/_core/scope.py,sha256=LGT_Sk0b2FXB_ScXfLhU2BWz_bEE0vdJOV5p-ijCDq4,6552
-injection/_core/slots.py,sha256=6LoG0XtaRnIGDSG8s-FfUIw_50gL0bl4X3Fo_n-hdak,680
+injection/_core/injectables.py,sha256=yeW_AHCZSsxyiN1oT_E9MLc1DcYA37XlmQGAkUc4eR8,6189
+injection/_core/module.py,sha256=GNDnYbD7oXVCS_CH_w7Io-rbWZxMConoOMNy1XJKotY,31575
+injection/_core/scope.py,sha256=J6O0fgaz7IstYDx1hjRPaZUNIzIS_cHc29fp-qIrUA0,8291
+injection/_core/slots.py,sha256=g9TG6CbqRzCsjg01iPyfRtTTUCJnnJOwcj9mJabH0dc,37
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/common/asynchronous.py,sha256=QeS2Lc4gEBFvTA_snOWfme5mTL4BFZWqZ8EzJwOdVos,1816
 injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
@@ -16,10 +16,10 @@ injection/_core/common/invertible.py,sha256=gA_vw5nBjgp_w9MrDK5jMO8lhuOQWON8BbPp
 injection/_core/common/key.py,sha256=ghkZD-Y8Moz6SEPNgMh3xgsZUjDVq-XYAmXaCu5VuCA,80
 injection/_core/common/lazy.py,sha256=6xh5h0lmaNvl32V0WoX4VCTsNJ3zUJdWVqpLJ_YeIIU,1363
 injection/_core/common/type.py,sha256=SCDtmBv9qFvEf5o5tTgCuwMDfuo1fgjSW0bUqA8ACis,2251
-injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/integrations/fastapi.py,sha256=YHSs85_3m6TUVtOwUcV157b3UZJQIw_aXWAg199a-YE,594
+injection/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+injection/ext/fastapi.py,sha256=YHSs85_3m6TUVtOwUcV157b3UZJQIw_aXWAg199a-YE,594
 injection/testing/__init__.py,sha256=SiImXDd0-DO1a8S5nbUQRtgDX8iaU_nHcp8DdqwtD2M,896
 injection/testing/__init__.pyi,sha256=iOii0i9F5n7znltGeGQYI2KXC_if9SAogLh1h03yx-0,540
-python_injection-0.15.0.dist-info/METADATA,sha256=LA4sTrPDIUAk-dwOH1zKj1Rjk-feJwq1r2eYHpLIJTw,3199
-python_injection-0.15.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.15.0.dist-info/RECORD,,
+python_injection-0.17.0.dist-info/METADATA,sha256=I1L9Clj5aiursJyGnauGg8HmLfFg6ybWnnLU5FZ3ssE,3199
+python_injection-0.17.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.17.0.dist-info/RECORD,,