refactoring: ♻️ Remove Scoped type annotation

Author: remimd

documentation/integrations/fastapi.md

@@ -29,7 +29,7 @@ from dataclasses import dataclass
 from enum import StrEnum, auto
 
 from fastapi import Depends, FastAPI, Request
-from injection import MappedScope, Scoped, adefine_scope
+from injection import MappedScope, adefine_scope
 
 class InjectionScope(StrEnum):
     LIFESPAN = auto()
@@ -42,7 +42,7 @@ async def lifespan(_: FastAPI) -> AsyncIterator[None]:
 
 @dataclass
 class FastAPIRequestBindings:
-    request: Scoped[Request]
+    request: Request
 
     scope = MappedScope(InjectionScope.REQUEST)
 

documentation/scoped-dependencies.md

@@ -43,12 +43,12 @@ def main() -> None:
 
 ## MappedScope
 
-`MappedScope` allows you to open a dependency injection scope and register values annotated with `Scoped[...]` so they 
-can be retrieved by other dependencies within that scope.
+`MappedScope` allows you to open a dependency injection scope and register values with type annotation so they can be 
+retrieved by other dependencies within that scope.
 
 ### How it works
 
-1. **Define bindings**: Create a class with fields annotated with `Scoped`.
+1. **Define bindings**: Create a class with type annotated fields.
 2. **Create scope**: Instantiate `MappedScope` with a scope name.
 3. **Open scope**: Use `define` or `adefine` context manager to register the scoped values.
 4. **Access dependencies**: Other dependencies can now inject these scoped values within the context.
@@ -60,13 +60,13 @@ Example:
 
 ```python
 from dataclasses import dataclass
-from injection import MappedScope, Scoped
+from injection import MappedScope
 
 class Request: ...
 
 @dataclass
 class RequestBindings:
-    request: Scoped[Request]
+    request: Request
 
     scope = MappedScope("request")
 

injection/__init__.py

@@ -1,5 +1,5 @@
 from ._core.asfunction import asfunction
-from ._core.descriptors import LazyInstance, MappedScope, Scoped
+from ._core.descriptors import LazyInstance, MappedScope
 from ._core.injectables import Injectable
 from ._core.module import Mode, Module, Priority, mod
 from ._core.scope import ScopeFacade as Scope
@@ -14,7 +14,6 @@
     "Module",
     "Priority",
     "Scope",
-    "Scoped",
     "ScopeKind",
     "SlotKey",
     "adefine_scope",

injection/__init__.pyi

@@ -13,7 +13,6 @@ from ._core.module import InjectableFactory as _InjectableFactory
 from ._core.module import ModeStr, PriorityStr
 from ._core.scope import ScopeKindStr
 
-type Scoped[T] = T
 type _Decorator[T] = Callable[[T], T]
 
 __MODULE: Final[Module] = ...

injection/_core/descriptors.py

@@ -4,16 +4,14 @@
 from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass
 from types import MappingProxyType
-from typing import Any, Self, get_args, get_origin, get_type_hints
+from typing import Any, Self, get_type_hints
 
 from injection._core.common.invertible import Invertible
 from injection._core.common.type import InputType
 from injection._core.module import Module, mod
 from injection._core.scope import ScopeKind, ScopeKindStr, adefine_scope, define_scope
 from injection._core.slots import SlotKey
 
-type Scoped[T] = T
-
 
 class MappedScope:
     __slots__ = ("__keys", "__module", "__name", "__owner")
@@ -43,16 +41,19 @@ def __set_name__(self, owner: type, name: str) -> None:
         if self.__owner:
             raise TypeError(f"`{self}` owner is already defined.")
 
-        self.__keys = MappingProxyType(dict(self.__generate_keys(owner)))
+        self.__keys = MappingProxyType(dict(self.__generate_keys(owner, name)))
         self.__owner = owner
 
-    def __generate_keys(self, cls: type) -> Iterator[tuple[str, SlotKey[Any]]]:
+    def __generate_keys(
+        self,
+        cls: type,
+        descriptor_name: str,
+    ) -> Iterator[tuple[str, SlotKey[Any]]]:
         for name, hint in get_type_hints(cls).items():
-            if get_origin(hint) is not Scoped:
+            if name == descriptor_name:
                 continue
 
-            annotation = get_args(hint)[0]
-            key = self.__module.reserve_scoped_slot(annotation, scope_name=self.__name)
+            key = self.__module.reserve_scoped_slot(hint, scope_name=self.__name)
             yield name, key
 
     def __mapping_from(self, instance: object) -> dict[SlotKey[Any], Any]:

tests/core/test_descriptors.py

@@ -1,8 +1,9 @@
 from dataclasses import dataclass
+from typing import ClassVar
 
 import pytest
 
-from injection import LazyInstance, MappedScope, Scoped, injectable
+from injection import LazyInstance, MappedScope, injectable
 
 
 class _RawData: ...
@@ -18,12 +19,12 @@ class BindingsA:
             class BindingsB:
                 scope = BindingsA.scope
 
-    async def test_aopen_with_success(self, module):
+    async def test_adefine_with_success(self, module):
         @dataclass
         class Bindings:
-            data: Scoped[_RawData]
+            data: _RawData
 
-            scope = MappedScope("some_scope", module=module)
+            scope: ClassVar[MappedScope] = MappedScope("some_scope", module)
 
         data = _RawData()
         context = Bindings(data)
@@ -35,16 +36,15 @@ class Bindings:
 
         assert module.get_instance(_RawData) is NotImplemented
 
-    def test_open_with_success(self, module):
+    def test_define_with_success(self, module):
         @dataclass
         class Bindings:
-            data: Scoped[_RawData]
-            unscoped_data: int
+            data: _RawData
 
-            scope = MappedScope("some_scope", module=module)
+            scope: ClassVar[MappedScope] = MappedScope("some_scope", module)
 
         data = _RawData()
-        context = Bindings(data, 2)
+        context = Bindings(data)
 
         assert module.get_instance(_RawData) is NotImplemented
 
@@ -54,13 +54,13 @@ class Bindings:
 
         assert module.get_instance(_RawData) is NotImplemented
 
-    def test_open_with_optional_types(self, module):
+    def test_define_with_optional_types(self, module):
         @dataclass
         class Bindings:
-            data: Scoped[_RawData | None] = None
-            name: Scoped[str | None] = None
+            data: _RawData | None = None
+            name: str | None = None
 
-            scope = MappedScope("some_scope", module=module)
+            scope: ClassVar[MappedScope] = MappedScope("some_scope", module)
 
         data = _RawData()
         context = Bindings(data)