refactor: Enhance readability

injection/_core/common/type.py

@@ -28,14 +28,14 @@
 )
 
 
-def get_return_hint[T](function: Callable[..., T]) -> InputType[T] | None:
+def get_return_type[T](function: Callable[..., T]) -> Any | None:
     return get_type_hints(function).get("return")
 
 
-def get_yield_hints[T](
+def get_yield_types[T](
     function: Callable[..., Iterator[T]] | Callable[..., AsyncIterator[T]],
-) -> tuple[InputType[T]] | tuple[()]:
-    return_type = get_return_hint(function)
+) -> tuple[Any] | tuple[()]:
+    return_type = get_return_type(function)
 
     if get_origin(return_type) in (
         AsyncGenerator,
@@ -62,8 +62,8 @@ def iter_flat_types(*args: Any) -> Iterator[Any]:
 
 def iter_return_types(*args: Any) -> Iterator[Any]:
     for arg in args:
-        if isfunction(arg) and (return_type := get_return_hint(arg)):
-            yield from iter_return_types(return_type)
+        if isfunction(arg) and (return_type := get_return_type(arg)):
+            yield return_type
 
         else:
             yield arg

injection/_core/module.py

@@ -52,7 +52,7 @@
 from injection._core.common.type import (
     InputType,
     TypeInfo,
-    get_yield_hints,
+    get_yield_types,
     iter_flat_types,
     iter_return_types,
 )
@@ -264,14 +264,14 @@ def decorator(
             if isasyncgenfunction(wrapped):
                 ctx = _ScopedContext(
                     cls=AsyncCMScopedInjectable,
-                    hints=() if ignore_type_hint else get_yield_hints(wrapped),
+                    hints=() if ignore_type_hint else get_yield_types(wrapped),
                     wrapper=asynccontextmanager(wrapped),
                 )
 
             elif isgeneratorfunction(wrapped):
                 ctx = _ScopedContext(
                     cls=CMScopedInjectable,
-                    hints=() if ignore_type_hint else get_yield_hints(wrapped),
+                    hints=() if ignore_type_hint else get_yield_types(wrapped),
                     wrapper=contextmanager(wrapped),
                 )
 
@@ -713,19 +713,19 @@ def default(cls) -> Module:
         return cls.from_name("__default__")
 
     @staticmethod
-    def __build_key_types(input_cls: Any) -> frozenset[Any]:
+    def __build_key_types(input_class: Any) -> frozenset[Any]:
         config = MatchingTypesConfig(ignore_none=True)
         return frozenset(
             matching_type
-            for cls in iter_flat_types(input_cls)
+            for cls in iter_flat_types(input_class)
             for return_type in iter_return_types(cls)
             for matching_type in iter_matching_types(return_type, config)
         )
 
     @staticmethod
-    def __matching_key_types(input_cls: Any) -> tuple[Any, ...]:
+    def __matching_key_types(input_class: Any) -> tuple[Any, ...]:
         config = MatchingTypesConfig(with_origin=True, with_type_alias_value=True)
-        return matching_types(input_cls, config)
+        return matching_types(input_class, config)
 
 
 def mod(name: str | None = None, /) -> Module:

injection/loaders.py

@@ -150,8 +150,11 @@ def __is_empty(self) -> bool:
         return not self.module_subsets
 
     def required_module_names(self, name: str | None = None, /) -> frozenset[str]:
-        names = {n for n in (self.module.name, name) if n is not None}
-        subsets = (self.__walk_subsets_for(name) for name in names)
+        subsets = (
+            self.__walk_subsets_for(module_name)
+            for module_name in (self.module.name, name)
+            if module_name is not None
+        )
         return frozenset(itertools.chain.from_iterable(subsets))
 
     def init(self) -> Self: