Fix annotation discovery in 3.10

Author: andystaples

durabletask/serialization.py

@@ -38,6 +38,7 @@
 import inspect
 import json
 import logging
+import sys
 import types
 import typing
 from abc import ABC, abstractmethod
@@ -435,10 +436,67 @@ def _build_dataclass(cls: Any, data: dict[str, Any],
         hints = typing.get_type_hints(cls)
     except Exception:
         hints = {}
+    globalns = _type_namespace(cls)
     kwargs: dict[str, Any] = {}
     for field in dataclasses.fields(cls):
         if field.name not in data:
             continue
-        field_type = hints.get(field.name)
+        # ``get_type_hints`` on Python 3.10 does not deep-resolve forward
+        # references nested inside container args (e.g. the ``"TreeNode"`` in
+        # ``list["TreeNode"]`` on a self-referential dataclass), leaving a bare
+        # string or ``ForwardRef`` that the coercion below would skip. Resolve
+        # them against the class's defining module so reconstruction behaves the
+        # same as it does on 3.11+.
+        field_type = _resolve_forward_refs(hints.get(field.name), globalns)
         kwargs[field.name] = _coerce_to_type(data[field.name], field_type, converter)
     return cls(**kwargs)
+
+
+def _type_namespace(cls: Any) -> dict[str, Any]:
+    """Build the namespace used to resolve forward references in ``cls``'s hints.
+
+    Forward references in a class's annotations are resolved against the
+    module in which the class is defined, plus the class's own name (so a
+    self-referential type like ``list["TreeNode"]`` resolves).
+    """
+    module = sys.modules.get(getattr(cls, "__module__", None) or "")
+    ns: dict[str, Any] = dict(getattr(module, "__dict__", {}))
+    name = getattr(cls, "__name__", None)
+    if name:
+        ns.setdefault(name, cls)
+    return ns
+
+
+def _resolve_forward_refs(tp: Any, globalns: dict[str, Any]) -> Any:
+    """Resolve string / ``ForwardRef`` leaves in a type hint, recursing into args.
+
+    Returns ``tp`` unchanged when it (or a nested name) cannot be resolved, so an
+    unresolvable hint simply falls back to "leave the value as parsed JSON"
+    rather than raising. Only the supported generic shapes (``Union``, ``list``,
+    ``dict``, ``tuple``, etc.) are rebuilt; the destination type is still
+    entirely caller-supplied, so this does not weaken the security model.
+    """
+    if isinstance(tp, str):
+        try:
+            tp = eval(tp, globalns)  # noqa: S307 - resolves caller-authored annotations
+        except Exception:
+            return tp
+    elif isinstance(tp, typing.ForwardRef):
+        try:
+            tp = eval(tp.__forward_arg__, globalns)  # noqa: S307
+        except Exception:
+            return tp
+
+    origin = typing.get_origin(tp)
+    if origin is None:
+        return tp
+    args = typing.get_args(tp)
+    if not args:
+        return tp
+    resolved = [_resolve_forward_refs(a, globalns) for a in args]
+    if origin is typing.Union or origin is types.UnionType:
+        return typing.Union[tuple(resolved)]
+    try:
+        return origin[tuple(resolved) if len(resolved) > 1 else resolved[0]]
+    except TypeError:
+        return tp

tests/durabletask/test_serialization.py

@@ -12,13 +12,14 @@
 from collections import namedtuple
 from dataclasses import dataclass
 from types import SimpleNamespace
-from typing import Optional, Union
+from typing import List, Optional, Union, get_args
 
 import pytest
 
 from durabletask.serialization import _AUTO_SERIALIZED as AUTO_SERIALIZED
 from durabletask.serialization import _coerce_to_type as coerce_to_type
 from durabletask.serialization import _from_json as from_json
+from durabletask.serialization import _resolve_forward_refs as resolve_forward_refs
 from durabletask.serialization import _to_json as to_json
 
 
@@ -485,3 +486,40 @@ def test_coerce_to_type_without_converter_calls_single_arg_hook():
     # the hook could accept it (defensive: no converter available).
     result = coerce_to_type({"label": "gear", "size": 5}, Widget)
     assert result == Widget("gear", 5)
+
+
+# ----- forward-reference resolution (Python 3.10 get_type_hints parity) -----
+#
+# On Python 3.10, ``typing.get_type_hints`` does not deep-resolve forward
+# references nested inside container args (e.g. the element type of
+# ``list["TreeNode"]`` on a self-referential dataclass), leaving a bare string
+# or ``ForwardRef``. ``_resolve_forward_refs`` restores the 3.11+ behavior so
+# nested coercion still fires. These tests run on every supported version.
+
+
+def test_resolve_forward_refs_resolves_string_element_type():
+    # ``list["Address"]`` evaluates to a generic whose arg is the raw string
+    # "Address" -- exactly what 3.10 leaves behind.
+    resolved = resolve_forward_refs(list["Address"], {"Address": Address})
+    assert get_args(resolved) == (Address,)
+
+
+def test_resolve_forward_refs_resolves_forwardref_element_type():
+    resolved = resolve_forward_refs(List["Address"], {"Address": Address})
+    assert get_args(resolved) == (Address,)
+
+
+def test_resolve_forward_refs_then_coerce_reconstructs_nested_dataclass():
+    # The full 3.10 path: resolve the unresolved element type, then coerce the
+    # contained dicts into the target dataclass.
+    field_type = resolve_forward_refs(list["Address"], {"Address": Address})
+    result = coerce_to_type([{"street": "a", "city": "b"}], field_type)
+    assert isinstance(result[0], Address)
+    assert result[0].city == "b"
+
+
+def test_resolve_forward_refs_leaves_unresolvable_name_untouched():
+    # An unknown name is left as a string so coercion harmlessly falls back to
+    # the parsed JSON rather than raising.
+    resolved = resolve_forward_refs(list["DoesNotExist"], {})
+    assert get_args(resolved) == ("DoesNotExist",)