refacto

Author: remimd

documentation/integrations.md

@@ -63,14 +63,14 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
 
 app = FastAPI(lifespan=lifespan)
 
-request_slot = reserve_scoped_slot(Request, InjectionScope.REQUEST)
+request_slot_key = reserve_scoped_slot(Request, InjectionScope.REQUEST)
 
 @app.middleware("http")
 async def define_request_scope_middleware(
     request: Request,
     handler: Callable[[Request], Awaitable[Response]],
 ) -> Response:
     async with adefine_scope(InjectionScope.REQUEST) as scope:
-        scope.set_slot(request_slot, request)
+        scope.set_slot(request_slot_key, request)
         return await handler(request)
 ```

documentation/scoped-dependencies.md

@@ -110,10 +110,10 @@ from injection import define_scope, reserve_scoped_slot
 
 class Request: ...
 
-request_slot = reserve_scoped_slot(Request, scope_name="request")
+request_slot_key = reserve_scoped_slot(Request, scope_name="request")
 
 def process_request(request: Request) -> None:
     with define_scope("request") as scope:
-        scope.set_slot(request_slot, request)
+        scope.set_slot(request_slot_key, request)
         # ...
 ```

injection/__init__.py

@@ -3,7 +3,7 @@
 from ._core.module import Mode, Module, Priority, mod
 from ._core.scope import ScopeFacade as Scope
 from ._core.scope import ScopeKind, adefine_scope, define_scope
-from ._core.slots import Slot
+from ._core.slots import SlotKey
 
 __all__ = (
     "Injectable",
@@ -13,7 +13,7 @@
     "Priority",
     "Scope",
     "ScopeKind",
-    "Slot",
+    "SlotKey",
     "adefine_scope",
     "afind_instance",
     "aget_instance",

injection/__init__.pyi

@@ -33,11 +33,13 @@ singleton = __MODULE.singleton
 @asynccontextmanager
 def adefine_scope(
     name: str,
+    /,
     kind: ScopeKind | ScopeKindStr = ...,
 ) -> AsyncIterator[Scope]: ...
 @contextmanager
 def define_scope(
     name: str,
+    /,
     kind: ScopeKind | ScopeKindStr = ...,
 ) -> Iterator[Scope]: ...
 def mod(name: str = ..., /) -> Module:
@@ -59,11 +61,14 @@ class ScopeKind(Enum):
     CONTEXTUAL = ...
     SHARED = ...
 
-class Scope:
-    def set_slot[T](self, slot: Slot[T], value: T) -> Self: ...
-    def slot_map(self, values: Mapping[Slot[Any], Any]) -> Self: ...
+@runtime_checkable
+class Scope(Protocol):
+    @abstractmethod
+    def set_slot[T](self, key: SlotKey[T], value: T) -> Self: ...
+    @abstractmethod
+    def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self: ...
 
-class Slot[T]: ...
+class SlotKey[T]: ...
 
 class LazyInstance[T]:
     def __init__(
@@ -197,7 +202,7 @@ class Module:
         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

@@ -23,7 +23,7 @@
     in_scope_cache,
     remove_scoped_values,
 )
-from injection._core.slots import Slot
+from injection._core.slots import SlotKey
 from injection.exceptions import EmptySlotError, InjectionError
 
 
@@ -197,11 +197,11 @@ def unlock(self) -> None:
 class ScopedSlotInjectable[T](Injectable[T]):
     cls: type[T]
     scope_name: str
-    slot: Slot[T] = field(default_factory=Slot)
+    key: SlotKey[T] = field(default_factory=SlotKey)
 
     @property
     def is_locked(self) -> bool:
-        return in_scope_cache(self.slot, self.scope_name)
+        return in_scope_cache(self.key, self.scope_name)
 
     async def aget_instance(self) -> T:
         return self.get_instance()
@@ -211,14 +211,14 @@ def get_instance(self) -> T:
         scope = get_scope(scope_name)
 
         try:
-            return scope.cache[self.slot]
+            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.slot, self.scope_name)
+        remove_scoped_values(self.key, self.scope_name)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

injection/_core/module.py

@@ -70,7 +70,7 @@
     SimpleScopedInjectable,
     SingletonInjectable,
 )
-from injection._core.slots import Slot
+from injection._core.slots import SlotKey
 from injection.exceptions import (
     ModuleError,
     ModuleLockError,
@@ -492,11 +492,8 @@ def decorator(
 
     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
 
@@ -548,11 +545,11 @@ def reserve_scoped_slot[T](
         scope_name: str,
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-    ) -> Slot[T]:
+    ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
         updater = Updater.with_basics(cls, injectable, mode)
         self.update(updater)
-        return injectable.slot
+        return injectable.key
 
     def inject[**P, T](
         self,

injection/_core/scope.py

@@ -23,7 +23,7 @@
 )
 
 from injection._core.common.key import new_short_key
-from injection._core.slots import Slot
+from injection._core.slots import SlotKey
 from injection.exceptions import (
     InjectionError,
     ScopeAlreadyDefinedError,
@@ -127,6 +127,7 @@ def get_scope(self) -> Scope | None:
 @asynccontextmanager
 async def adefine_scope(
     name: str,
+    /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
 ) -> AsyncIterator[ScopeFacade]:
     async with AsyncScope() as scope:
@@ -137,6 +138,7 @@ async def adefine_scope(
 @contextmanager
 def define_scope(
     name: str,
+    /,
     kind: ScopeKind | ScopeKindStr = ScopeKind.get_default(),
 ) -> Iterator[ScopeFacade]:
     with SyncScope() as scope:
@@ -208,7 +210,7 @@ def _bind_scope(
         )
 
     with states[name].bind(scope):
-        yield ScopeFacade(scope)
+        yield _UserScope(scope)
 
 
 @runtime_checkable
@@ -286,19 +288,32 @@ 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 ScopeFacade:
+class _UserScope(ScopeFacade):
     scope: Scope
 
-    def set_slot[T](self, slot: Slot[T], value: T) -> Self:
-        return self.slot_map({slot: value})
+    def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
+        return self.slot_map({key: value})
 
-    def slot_map(self, values: Mapping[Slot[Any], Any]) -> Self:
+    def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self:
         cache = self.scope.cache
 
-        for slot in values:
-            if slot in cache:
+        for slot_key in mapping:
+            if slot_key in cache:
                 raise InjectionError("Slot already set.")
 
-        cache.update(values)
+        cache.update(mapping)
         return self

injection/_core/slots.py

@@ -1,2 +1,2 @@
-class Slot[T]:
+class SlotKey[T]:
     __slots__ = ()

tests/core/test_module.py

@@ -215,11 +215,11 @@ def test_set_constant_with_success_with_type_alias(self, module):
 
     def test_reserve_scoped_slot_with_success(self, module):
         scope_name = "test"
-        slot = module.reserve_scoped_slot(SomeClass, scope_name)
+        slot_key = module.reserve_scoped_slot(SomeClass, scope_name)
 
         with define_scope(scope_name) as scope:
             instance = SomeClass()
-            scope.set_slot(slot, instance)
+            scope.set_slot(slot_key, instance)
 
             assert module.get_instance(SomeClass) is instance
 
@@ -238,16 +238,16 @@ def test_reserve_scoped_slot_with_several_definitions_raise_injection_error(
         module,
     ):
         scope_name = "test"
-        slot = module.reserve_scoped_slot(SomeClass, scope_name)
+        slot_key = module.reserve_scoped_slot(SomeClass, scope_name)
 
         with define_scope(scope_name) as scope:
             instance1 = SomeClass()
-            scope.set_slot(slot, instance1)
+            scope.set_slot(slot_key, instance1)
 
             instance2 = SomeClass()
 
             with pytest.raises(InjectionError):
-                scope.set_slot(slot, instance2)
+                scope.set_slot(slot_key, instance2)
 
     """
     init_modules