Fix the tests, rebased on UpdateClass

This fixes a couple actual bugs:
 * need to eval types in UpdateClass
 * evaluating strings in _eval_type_type shouldn't be needed, we'll do
   it when we have to with _apply_generic

Author: msullivan

tests/test_fastapilike_1.py

@@ -1,3 +1,6 @@
+# We should have at least *one* test with this...
+from __future__ import annotations
+
 import dataclasses
 import enum
 import textwrap
@@ -164,7 +167,7 @@ class Hero:
         HasDefault[int | None, None]
     ]  # = Field(default=None, primary_key=True)
 
-    name: str
+    name: "str"
     age: HasDefault[int | None, None]  # = Field(default=None, index=True)
 
     secret_name: Hidden[str]

tests/test_type_eval.py

@@ -1827,12 +1827,13 @@ def g(self) -> int: ...  # omitted
     assert m == Never
 
 
+type AttrsAsSets[T] = UpdateClass[
+    *[Member[GetName[m], set[GetType[m]]] for m in Iter[Attrs[T]]]
+]
+
+
 def test_update_class_members_03():
     # Generic UpdateClass, uses T
-    type AttrsAsSets[T] = UpdateClass[
-        *[Member[GetName[m], set[GetType[m]]] for m in Iter[Attrs[T]]]
-    ]
-
     class A:
         a: int
 
@@ -1906,9 +1907,8 @@ def g(self) -> int: ...
 
     # Attrs
     attrs = eval_typing(Attrs[B])
-    assert (
-        attrs
-        == tuple[
+    assert str(attrs) == str(
+        tuple[
             Member[Literal["a"], int, Never, Never, A],
             Member[Literal["b"], int, Never, Never, B],
         ]
@@ -1963,10 +1963,6 @@ def g(self) -> int: ...
 
 def test_update_class_inheritance_01():
     # current class init subclass is not applied
-    type AttrsAsSets[T] = UpdateClass[
-        *[Member[GetName[m], set[GetType[m]]] for m in Iter[Attrs[T]]]
-    ]
-
     class A:
         a: int
 
@@ -1993,18 +1989,16 @@ def __init_subclass__[T](
     )
 
 
+type AttrsAsList[T] = UpdateClass[
+    *[Member[GetName[m], list[GetType[m]]] for m in Iter[Attrs[T]]]
+]
+type AttrsAsTuple[T] = UpdateClass[
+    *[Member[GetName[m], tuple[GetType[m]]] for m in Iter[Attrs[T]]]
+]
+
+
 def test_update_class_inheritance_02():
     # __init_subclass__ calls follow normal MRO
-    type AttrsAsSets[T] = UpdateClass[
-        *[Member[GetName[m], set[GetType[m]]] for m in Iter[Attrs[T]]]
-    ]
-    type AttrsAsList[T] = UpdateClass[
-        *[Member[GetName[m], list[GetType[m]]] for m in Iter[Attrs[T]]]
-    ]
-    type AttrsAsTuple[T] = UpdateClass[
-        *[Member[GetName[m], tuple[GetType[m]]] for m in Iter[Attrs[T]]]
-    ]
-
     class A:
         a: int
 

typemap/type_eval/_eval_operators.py

@@ -7,14 +7,15 @@
 import re
 import types
 import typing
+import sys
+
 from typing_extensions import _AnnotatedAlias as typing_AnnotatedAlias
 
 from typemap import type_eval
 from typemap.type_eval import _apply_generic, _typing_inspect
 from typemap.type_eval._eval_typing import (
     _child_context,
     _eval_types,
-    _get_class_type_hint_namespaces,
 )
 from typemap.typing import (
     Attrs,
@@ -180,11 +181,10 @@ def _get_update_class_members(
 ) -> list[Member] | None:
     if (
         (init_subclass := base.__dict__.get("__init_subclass__"))
-        and (
-            init_subclass_annos := getattr(
-                init_subclass, "__annotations__", None
-            )
-        )
+        # XXX: We're using get_type_hints now to evaluate hints but
+        # we should have our own generic infrastructure instead.
+        # (I'm working on it -sully)
+        and (init_subclass_annos := typing.get_type_hints(init_subclass))
         and (ret_annotation := init_subclass_annos.get("return"))
     ):
         # Substitute the cls type var with the current class
@@ -751,6 +751,38 @@ def _resolved_function_signature(func, receiver_type=None):
     return sig
 
 
+def _get_class_type_hint_namespaces(
+    obj: type,
+) -> tuple[dict[str, typing.Any], dict[str, typing.Any]]:
+    globalns: dict[str, typing.Any] = {}
+    localns: dict[str, typing.Any] = {}
+
+    # Get module globals
+    if obj.__module__ and (module := sys.modules.get(obj.__module__)):
+        globalns.update(module.__dict__)
+
+    # Annotations may use typevars defined in the class
+    localns.update(obj.__dict__)
+
+    if _typing_inspect.is_generic_alias(obj):
+        # We need the origin's type vars
+        localns.update(obj.__origin__.__dict__)
+
+        # Extract type parameters from the class
+        args = typing.get_args(obj)
+        origin = typing.get_origin(obj)
+        tps = getattr(obj, '__type_params__', ()) or getattr(
+            origin, '__parameters__', ()
+        )
+        for tp, arg in zip(tps, args, strict=False):
+            localns[tp.__name__] = arg
+
+    # Add the class itself for self-references
+    localns[obj.__name__] = obj
+
+    return globalns, localns
+
+
 def _get_function_hint_namespaces(func, receiver_type=None):
     globalns = {}
     localns = {}

typemap/type_eval/_eval_typing.py

@@ -22,7 +22,7 @@
 if typing.TYPE_CHECKING:
     from typing import Any, Sequence
 
-from . import _apply_generic, _typing_inspect
+from . import _apply_generic
 
 
 __all__ = ("eval_typing",)
@@ -282,59 +282,8 @@ def _eval_func(
     return _apply_generic.make_func(func, annos)
 
 
-def _get_class_type_hint_namespaces(
-    obj: type,
-) -> tuple[dict[str, typing.Any], dict[str, typing.Any]]:
-    globalns: dict[str, typing.Any] = {}
-    localns: dict[str, typing.Any] = {}
-
-    # Get module globals
-    if obj.__module__ and (module := sys.modules.get(obj.__module__)):
-        globalns.update(module.__dict__)
-
-    # Annotations may use typevars defined in the class
-    localns.update(obj.__dict__)
-
-    if _typing_inspect.is_generic_alias(obj):
-        # We need the origin's type vars
-        localns.update(obj.__origin__.__dict__)
-
-        # Extract type parameters from the class
-        args = typing.get_args(obj)
-        origin = typing.get_origin(obj)
-        tps = getattr(obj, '__type_params__', ()) or getattr(
-            origin, '__parameters__', ()
-        )
-        for tp, arg in zip(tps, args, strict=False):
-            localns[tp.__name__] = arg
-
-    # Add the class itself for self-references
-    localns[obj.__name__] = obj
-
-    return globalns, localns
-
-
 @_eval_types_impl.register
 def _eval_type_type(obj: type, ctx: EvalContext):
-    # Ensure that any string annotations are resolved
-    if (
-        hasattr(obj, '__annotations__')
-        and obj.__annotations__
-        and any(isinstance(v, str) for v in obj.__annotations__.values())
-    ):
-        # Ensure we don't recurse infinitely
-        ctx.seen[obj] = obj
-
-        # Replace string annotations with resolved types
-        globalns, localns = _get_class_type_hint_namespaces(obj)
-        hints = {
-            k: _eval_types(v, ctx)
-            for k, v in typing.get_type_hints(
-                obj, globalns=globalns, localns=localns, include_extras=True
-            ).items()
-        }
-        obj.__annotations__.update(hints)
-
     return obj