refactoring: ♻️ Many things

Author: remimd

injection/_core/descriptors.py

@@ -17,8 +17,7 @@ def __init__(
         default: T = NotImplemented,
         module: Module | None = None,
     ) -> None:
-        module = module or mod()
-        self.__value = module.get_lazy_instance(cls, default)
+        self.__value = (module or mod()).get_lazy_instance(cls, default)
 
     def __get__(
         self,

injection/_core/injectables.py

@@ -48,7 +48,7 @@ def get_instance(self) -> T:
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class SimpleInjectable[T](Injectable[T]):
+class TransientInjectable[T](Injectable[T]):
     factory: Caller[..., T]
 
     async def aget_instance(self) -> T:

injection/_core/module.py

@@ -66,9 +66,9 @@
     ScopedInjectable,
     ScopedSlotInjectable,
     ShouldBeInjectable,
-    SimpleInjectable,
     SimpleScopedInjectable,
     SingletonInjectable,
+    TransientInjectable,
 )
 from injection._core.slots import SlotKey
 from injection.exceptions import (
@@ -430,7 +430,7 @@ def injectable[**P, T](
         wrapped: Recipe[P, T] | None = None,
         /,
         *,
-        cls: InjectableFactory[T] = SimpleInjectable,
+        cls: InjectableFactory[T] = TransientInjectable,
         ignore_type_hint: bool = False,
         inject: bool = True,
         on: TypeInfo[T] = (),
@@ -583,7 +583,12 @@ def make_injected_function[**P, T](
         threadsafe: bool = ...,
     ) -> AsyncInjectedFunction[P, T]: ...
 
-    def make_injected_function(self, wrapped, /, threadsafe=False):  # type: ignore[no-untyped-def]
+    def make_injected_function[**P, T](
+        self,
+        wrapped: Callable[P, T],
+        /,
+        threadsafe: bool = False,
+    ) -> InjectedFunction[P, T]:
         metadata = InjectMetadata(wrapped, threadsafe)
 
         @metadata.task
@@ -592,7 +597,7 @@ def listen() -> None:
             self.add_listener(metadata)
 
         if iscoroutinefunction(wrapped):
-            return AsyncInjectedFunction(metadata)
+            return AsyncInjectedFunction(metadata)  # type: ignore[arg-type, return-value]
 
         return SyncInjectedFunction(metadata)
 
@@ -630,7 +635,11 @@ async def aget_instance[T](
         default: None = ...,
     ) -> T | None: ...
 
-    async def aget_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
+    async def aget_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default | None = None,
+    ) -> T | Default | None:
         try:
             return await self.afind_instance(cls)
         except (KeyError, SkipInjectable):
@@ -650,7 +659,11 @@ def get_instance[T](
         default: None = ...,
     ) -> T | None: ...
 
-    def get_instance(self, cls, default=None):  # type: ignore[no-untyped-def]
+    def get_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default | None = None,
+    ) -> T | Default | None:
         try:
             return self.find_instance(cls)
         except (KeyError, SkipInjectable):
@@ -674,7 +687,13 @@ def aget_lazy_instance[T](
         cache: bool = ...,
     ) -> Awaitable[T | None]: ...
 
-    def aget_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
+    def aget_lazy_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default | None = None,
+        *,
+        cache: bool = False,
+    ) -> Awaitable[T | Default | None]:
         if cache:
             return alazy(lambda: self.aget_instance(cls, default))
 
@@ -700,7 +719,13 @@ def get_lazy_instance[T](
         cache: bool = ...,
     ) -> Invertible[T | None]: ...
 
-    def get_lazy_instance(self, cls, default=None, *, cache=False):  # type: ignore[no-untyped-def]
+    def get_lazy_instance[T, Default](
+        self,
+        cls: InputType[T],
+        default: Default | None = None,
+        *,
+        cache: bool = False,
+    ) -> Invertible[T | Default | None]:
         if cache:
             return lazy(lambda: self.get_instance(cls, default))
 
@@ -790,8 +815,6 @@ def load_profile(self, *names: str) -> ContextManager[Self]:
 
         self.unlock().init_modules(*modules)
 
-        del module, modules
-
         @contextmanager
         def cleaner() -> Iterator[Self]:
             yield self

injection/_core/scope.py

@@ -163,7 +163,7 @@ def get_scope(name: str, default: EllipsisType = ...) -> Scope: ...
 def get_scope[T](name: str, default: T) -> Scope | T: ...
 
 
-def get_scope(name, default=...):  # type: ignore[no-untyped-def]
+def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:
     for states in (__CONTEXTUAL_SCOPES, __SHARED_SCOPES):
         state = states.get(name)
         if state and (scope := state.get_scope()):

injection/ext/fastapi.py

@@ -18,25 +18,23 @@ def __call__[T](
         default: T = NotImplemented,
         module: Module | None = None,
     ) -> Any:
-        module = module or mod()
-        lazy_instance = module.aget_lazy_instance(cls, default)
+        ainstance = (module or mod()).aget_lazy_instance(cls, default)
 
-        async def getter() -> T:
-            return await lazy_instance
+        async def dependency() -> T:
+            return await ainstance
 
-        return Depends(getter, use_cache=False)
+        class_name = getattr(cls, "__name__", str(cls))
+        dependency.__name__ = f"inject({class_name})"
+        return Depends(dependency, use_cache=False)
 
     def __getitem__(self, params: Any, /) -> Any:
-        if not isinstance(params, tuple):
-            params = (params,)
-
-        iter_params = iter(params)
+        iter_params = iter(params if isinstance(params, tuple) else (params,))
         cls = next(iter_params)
         return Annotated[cls, self(cls), *iter_params]
 
 
 if TYPE_CHECKING:
-    type Inject[T, *Args] = Annotated[T, Depends(), *Args]
+    type Inject[T, *Metadata] = Annotated[T, Depends(...), *Metadata]
 
 else:
     Inject = FastAPIInject()