Handle total=False TypedDicts by injecting NotRequired qual

Use __optional_keys__ from the outermost TypedDict class to identify
fields that are implicitly NotRequired due to total=False, since
TypedDict's metaclass flattens parent annotations into subclasses.

Author: msullivan

tests/test_ts_utility.py

@@ -6,7 +6,7 @@
 """
 
 import textwrap
-from typing import Literal, NotRequired, TypedDict
+from typing import Literal, Never, NotRequired, Required, TypedDict
 
 import typemap_extensions as typing
 from typemap.type_eval import eval_typing
@@ -119,3 +119,40 @@ def test_partial_td():
         "description": NotRequired[str],
         "completed": NotRequired[bool],
     }
+
+
+class OptionalTD(TypedDict, total=False):
+    x: int
+    y: Required[str]
+
+
+class ChildTD(OptionalTD):
+    z: bool
+
+
+def _get_quals(cls):
+    """Return {name: quals} for all Attrs of cls."""
+    result = {}
+    for p in eval_typing(typing.Iter[typing.Attrs[cls]]):
+        name = eval_typing(p.name).__args__[0]
+        quals = eval_typing(p.quals)
+        result[name] = quals
+    return result
+
+
+def test_td_total_false():
+    quals = _get_quals(OptionalTD)
+    # x is bare in total=False -> NotRequired
+    assert quals["x"] == Literal["NotRequired"]
+    # y has explicit Required -> no qual
+    assert quals["y"] is Never
+
+
+def test_td_total_false_inherited():
+    quals = _get_quals(ChildTD)
+    # x inherited from total=False parent -> still NotRequired
+    assert quals["x"] == Literal["NotRequired"]
+    # y had explicit Required in parent -> no qual
+    assert quals["y"] is Never
+    # z defined in total=True child -> no qual
+    assert quals["z"] is Never

typemap/type_eval/_eval_operators.py

@@ -109,6 +109,12 @@ def get_annotated_type_hints(cls, *, ctx, attrs_only=False, **kwargs):
 
     box = cached_box(cls, ctx=ctx)
 
+    # For TypedDicts with total=False, use __optional_keys__ to
+    # identify which fields are NotRequired. TypedDict's metaclass
+    # flattens parent annotations into subclasses, so we can't
+    # reliably check __total__ per-class in our own MRO walk.
+    td_optional_keys = getattr(cls, "__optional_keys__", frozenset())
+
     hints = {}
     for abox in reversed(box.mro):
         acls = abox.alias_type()
@@ -119,6 +125,7 @@ def get_annotated_type_hints(cls, *, ctx, attrs_only=False, **kwargs):
 
             # Strip ClassVar/Final/NotRequired/ReadOnly/Required from ty
             # and add them to quals
+            had_required_marker = False
             while True:
                 for form in [
                     typing.ClassVar,
@@ -128,6 +135,11 @@ def get_annotated_type_hints(cls, *, ctx, attrs_only=False, **kwargs):
                     typing.Required,
                 ]:
                     if _typing_inspect.is_special_form(ty, form):
+                        if form in (
+                            typing.Required,
+                            typing.NotRequired,
+                        ):
+                            had_required_marker = True
                         # Required is the default; strip but don't add a qual
                         if form is not typing.Required:
                             quals.add(form.__name__)
@@ -140,6 +152,11 @@ def get_annotated_type_hints(cls, *, ctx, attrs_only=False, **kwargs):
                 else:
                     break
 
+            # For TypedDict fields without explicit Required/NotRequired,
+            # check if they're optional (from total=False)
+            if not had_required_marker and k in td_optional_keys:
+                quals.add("NotRequired")
+
             # Skip method-like ClassVars when only attributes are wanted
             if attrs_only and "ClassVar" in quals and _is_method_like(ty):
                 continue