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, iter_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,
         )
 
 
@@ -263,9 +262,9 @@ class Locator(Broker):
     )
 
     def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        for input_class in self.__standardize_inputs((cls,)):
+        for key_type in self.__iter_key_types((cls,)):
             try:
-                record = self.__records[input_class]
+                record = self.__records[key_type]
             except KeyError:
                 continue
 
@@ -275,8 +274,7 @@ def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
 
     def __contains__(self, cls: InputType[Any], /) -> bool:
         return any(
-            input_class in self.__records
-            for input_class in self.__standardize_inputs((cls,))
+            key_type in self.__records for key_type in self.__iter_key_types((cls,))
         )
 
     @property
@@ -289,8 +287,8 @@ def __injectables(self) -> frozenset[Injectable[Any]]:
 
     def update[T](self, updater: Updater[T]) -> Self:
         record = updater.make_record()
-        classes = self.__reduce_classes(updater)
-        records = dict(self.__prepare_for_updating(classes, record))
+        key_types = self.__build_key_types(updater.classes)
+        records = dict(self.__prepare_for_updating(key_types, record))
 
         if records:
             event = LocatorDependenciesUpdated(self, records.keys(), record.mode)
@@ -335,6 +333,21 @@ def __prepare_for_updating[T](
 
             yield cls, record
 
+    @staticmethod
+    def __build_key_types[T](classes: Iterable[InputType[T]]) -> frozenset[TypeDef[T]]:
+        config = MatchingTypesConfig(ignore_none=True)
+        return frozenset(
+            itertools.chain.from_iterable(
+                iter_matching_types(cls, config) for cls in classes
+            )
+        )
+
+    @staticmethod
+    def __iter_key_types[T](classes: Iterable[InputType[T]]) -> Iterator[InputType[T]]:
+        config = MatchingTypesConfig(with_origin=True, with_type_alias_value=True)
+        for cls in classes:
+            yield from iter_matching_types(cls, config)
+
     @staticmethod
     def __keep_new_record[T](
         new: Record[T],
@@ -351,21 +364,6 @@ def __keep_new_record[T](
 
         return new_mode.rank > existing_mode.rank
 
-    @staticmethod
-    def __reduce_classes[T](updater: Updater[T]) -> frozenset[TypeDef[T]]:
-        return frozenset(
-            standardize_types(
-                *updater.classes,
-                ignore_none_type=updater.ignore_none_type,
-            )
-        )
-
-    @staticmethod
-    def __standardize_inputs[T](
-        classes: Iterable[InputType[T]],
-    ) -> Iterator[InputType[T]]:
-        return standardize_types(*classes, with_origin=True)
-
 
 """
 Module
@@ -564,10 +562,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])