refactor: Now analyze type hints with type-analyzer

Author: remimd

injection/_core/common/type.py

@@ -10,12 +10,10 @@
     Iterator,
 )
 from inspect import isclass, isfunction
-from types import GenericAlias, NoneType, UnionType
+from types import GenericAlias, UnionType
 from typing import (
-    Annotated,
     Any,
     TypeAliasType,
-    Union,
     get_args,
     get_origin,
     get_type_hints,
@@ -67,43 +65,3 @@ def get_yield_hint[T](
             return (arg,)
 
     return ()
-
-
-def standardize_types(
-    *types: InputType[Any],
-    with_origin: bool = False,
-    ignore_none_type: bool = False,
-) -> Iterator[TypeDef[Any]]:
-    for tp in types:
-        if tp is None or (ignore_none_type and tp is NoneType):
-            continue
-
-        origin = get_origin(tp)
-
-        if origin is Union or isinstance(tp, UnionType):
-            inner_types = get_args(tp)
-
-        elif origin is Annotated:
-            inner_types = get_args(tp)[:1]
-
-        else:
-            yield tp
-
-            if with_origin:
-                if origin is not None:
-                    yield origin
-
-                for alias in (tp, origin):
-                    if isinstance(alias, TypeAliasType):
-                        yield from standardize_types(
-                            alias.__value__,
-                            with_origin=with_origin,
-                        )
-
-            continue
-
-        yield from standardize_types(
-            *inner_types,
-            with_origin=with_origin,
-            ignore_none_type=ignore_none_type,
-        )

injection/_core/descriptors.py

@@ -53,11 +53,7 @@ def __generate_keys(
             if name == descriptor_name:
                 continue
 
-            key = self.__module.reserve_scoped_slot(
-                hint,
-                scope_name=self.__name,
-                ignore_none_type=True,
-            )
+            key = self.__module.reserve_scoped_slot(hint, scope_name=self.__name)
             yield name, key
 
     def __mapping_from(self, instance: object) -> dict[SlotKey[Any], Any]:

injection/_core/module.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools
 from abc import ABC, abstractmethod
 from collections import OrderedDict, deque
 from collections.abc import (
@@ -42,6 +43,8 @@
     runtime_checkable,
 )
 
+from type_analyzer import MatchingTypesConfig, matching_types
+
 from injection._core.common.asynchronous import (
     AsyncCaller,
     Caller,
@@ -59,7 +62,6 @@
     TypeInfo,
     get_return_types,
     get_yield_hint,
-    standardize_types,
 )
 from injection._core.injectables import (
     AsyncCMScopedInjectable,
@@ -229,7 +231,6 @@ class Updater[T]:
     classes: Iterable[InputType[T]]
     injectable: Injectable[T]
     mode: Mode
-    ignore_none_type: bool
 
     def make_record(self) -> Record[T]:
         return Record(self.injectable, self.mode)
@@ -241,13 +242,11 @@ def with_basics(
         /,
         injectable: Injectable[T],
         mode: Mode | ModeStr,
-        ignore_none_type: bool = False,
     ) -> Self:
         return cls(
             classes=get_return_types(on),
             injectable=injectable,
             mode=Mode(mode),
-            ignore_none_type=ignore_none_type,
         )
 
 
@@ -353,18 +352,25 @@ def __keep_new_record[T](
 
     @staticmethod
     def __reduce_classes[T](updater: Updater[T]) -> frozenset[TypeDef[T]]:
+        config = MatchingTypesConfig(ignore_none=True)
         return frozenset(
-            standardize_types(
-                *updater.classes,
-                ignore_none_type=updater.ignore_none_type,
+            itertools.chain.from_iterable(
+                matching_types(cls, config) for cls in updater.classes
             )
         )
 
     @staticmethod
     def __standardize_inputs[T](
         classes: Iterable[InputType[T]],
     ) -> Iterator[InputType[T]]:
-        return standardize_types(*classes, with_origin=True)
+        config = MatchingTypesConfig(
+            with_bases=True,
+            with_origin=True,
+            with_type_alias_value=True,
+        )
+
+        for cls in classes:
+            yield from matching_types(cls, config)
 
 
 """
@@ -564,10 +570,9 @@ def reserve_scoped_slot[T](
         scope_name: str,
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-        ignore_none_type: bool = False,
     ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
-        updater = Updater.with_basics(cls, injectable, mode, ignore_none_type)
+        updater = Updater.with_basics(cls, injectable, mode)
         self.update(updater)
         return injectable.key
 

pyproject.toml

@@ -55,7 +55,9 @@ classifiers = [
     "Natural Language :: English",
     "Typing :: Typed",
 ]
-dependencies = []
+dependencies = [
+    "type-analyzer",
+]
 
 [project.optional-dependencies]
 async = [

tests/test_inject.py

@@ -36,16 +36,16 @@ def test_inject_with_annotated(self):
         self.assert_inject(Annotated[SomeInjectable, "metadata"])
 
     def test_inject_with_union(self):
-        self.assert_inject(Union[T, SomeInjectable])
+        self.assert_inject(Union[str, SomeInjectable])
 
     def test_inject_with_new_union(self):
-        self.assert_inject(T | SomeInjectable)
+        self.assert_inject(str | SomeInjectable)
 
     def test_inject_with_union_and_none(self):
         self.assert_inject(None | SomeInjectable)
 
     def test_inject_with_annotated_and_union(self):
-        self.assert_inject(Annotated[T | SomeInjectable, "metadata"])
+        self.assert_inject(Annotated[str | SomeInjectable, "metadata"])
 
     def test_inject_with_optional(self):
         self.assert_inject(Optional[SomeInjectable])