Remove the need to call get_type_hints

I don't want to loop over the fields multiple times so internalized the relevant code from typing.get_type_hints into the generic_resolver

Author: mvanderlee

marshmallow_dataclass/__init__.py

@@ -61,7 +61,6 @@ class User:
     TypeVar,
     Union,
     cast,
-    get_type_hints,
     overload,
 )
 
@@ -70,7 +69,7 @@ class User:
 
 from marshmallow_dataclass.generic_resolver import (
     UnboundTypeVarError,
-    get_generic_dataclass_fields,
+    get_resolved_dataclass_fields,
     is_generic_alias,
 )
 from marshmallow_dataclass.lazy_class_attribute import lazy_class_attribute
@@ -548,7 +547,9 @@ def _internal_class_schema(
     schema_ctx.seen_classes[clazz] = class_name
 
     try:
-        fields = _dataclass_fields(clazz)
+        fields = get_resolved_dataclass_fields(
+            clazz, globalns=schema_ctx.globalns, localns=schema_ctx.localns
+        )
     except UnboundTypeVarError:
         raise
     except TypeError:  # Not a dataclass
@@ -584,19 +585,11 @@ def _internal_class_schema(
     include_non_init = getattr(getattr(clazz, "Meta", None), "include_non_init", False)
 
     # Update the schema members to contain marshmallow fields instead of dataclass fields
-    type_hints = {}
-    if not typing_inspect.is_generic_type(clazz):
-        type_hints = _get_type_hints(clazz, schema_ctx)
-
     attributes.update(
         (
             field.name,
             _field_for_schema(
-                (
-                    type_hints[field.name]
-                    if not typing_inspect.is_generic_type(clazz)
-                    else _resolve_forward_type_refs(field.type, schema_ctx)
-                ),
+                field.type,
                 _get_field_default(field),
                 field.metadata,
                 base_schema,
@@ -1037,47 +1030,6 @@ def is_generic_alias_of_dataclass(clazz: type) -> bool:
     return is_generic_alias(clazz) and dataclasses.is_dataclass(get_origin(clazz))
 
 
-def _get_type_hints(
-    obj,
-    schema_ctx: _SchemaContext,
-):
-    if sys.version_info >= (3, 9):
-        type_hints = get_type_hints(
-            obj,
-            globalns=schema_ctx.globalns,
-            localns=schema_ctx.localns,
-            include_extras=True,
-        )
-    else:
-        type_hints = get_type_hints(
-            obj, globalns=schema_ctx.globalns, localns=schema_ctx.localns
-        )
-
-    return type_hints
-
-
-def _resolve_forward_type_refs(
-    obj,
-    schema_ctx: _SchemaContext,
-) -> type:
-    """
-    Resolve forward references, mainly applies to Generics i.e.: `A["int"]` -> `A[int]`
-    """
-
-    class X:
-        x: obj  # type: ignore[name-defined]
-
-    return _get_type_hints(X, schema_ctx)["x"]
-
-
-def _dataclass_fields(clazz: type) -> Tuple[dataclasses.Field, ...]:
-    if not typing_inspect.is_generic_type(clazz):
-        return dataclasses.fields(clazz)
-
-    else:
-        return get_generic_dataclass_fields(clazz)
-
-
 def _is_marshmallow_field(obj) -> bool:
     return (
         inspect.isclass(obj) and issubclass(obj, marshmallow.fields.Field)

marshmallow_dataclass/generic_resolver.py

@@ -3,7 +3,9 @@
 import inspect
 import sys
 from typing import (
+    Any,
     Dict,
+    ForwardRef,
     Generic,
     List,
     Optional,
@@ -15,9 +17,17 @@
 
 if sys.version_info >= (3, 9):
     from typing import Annotated, get_args, get_origin
+
+    def eval_forward_ref(t: ForwardRef, globalns, localns, recursive_guard=frozenset()):
+        return t._evaluate(globalns, localns, recursive_guard)
+
 else:
     from typing_extensions import Annotated, get_args, get_origin
 
+    def eval_forward_ref(t: ForwardRef, globalns, localns):
+        return t._evaluate(globalns, localns)
+
+
 _U = TypeVar("_U")
 
 
@@ -99,7 +109,35 @@ def may_contain_typevars(clazz: type) -> bool:
     )
 
 
-def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
+def _get_namespaces(
+    clazz: type,
+    globalns: Optional[Dict[str, Any]] = None,
+    localns: Optional[Dict[str, Any]] = None,
+) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    # region - Copied from typing.get_type_hints
+    if globalns is None:
+        base_globals = getattr(sys.modules.get(clazz.__module__, None), "__dict__", {})
+    else:
+        base_globals = globalns
+    base_locals = dict(vars(clazz)) if localns is None else localns
+    if localns is None and globalns is None:
+        # This is surprising, but required.  Before Python 3.10,
+        # get_type_hints only evaluated the globalns of
+        # a class.  To maintain backwards compatibility, we reverse
+        # the globalns and localns order so that eval() looks into
+        # *base_globals* first rather than *base_locals*.
+        # This only affects ForwardRefs.
+        base_globals, base_locals = base_locals, base_globals
+    # endregion - Copied from typing.get_type_hints
+
+    return base_globals, base_locals
+
+
+def _resolve_typevars(
+    clazz: type,
+    globalns: Optional[Dict[str, Any]] = None,
+    localns: Optional[Dict[str, Any]] = None,
+) -> Dict[type, Dict[TypeVar, _Future]]:
     """
     Attemps to resolves all TypeVars in the class bases. Allows us to resolve inherited and aliased generics.
 
@@ -110,6 +148,7 @@ def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
     parent_class: Optional[type] = None
     # Loop in reversed order and iteratively resolve types
     for subclass in reversed(clazz.mro()):
+        base_globals, base_locals = _get_namespaces(subclass, globalns, localns)
         if issubclass(subclass, Generic) and hasattr(subclass, "__orig_bases__"):  # type: ignore[arg-type]
             args = get_args(subclass.__orig_bases__[0])
 
@@ -121,10 +160,17 @@ def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
                     if isinstance(potential_type, TypeVar):
                         subclass_generic_params_to_args.append((potential_type, future))
                     else:
-                        future.set_result(potential_type)
+                        future.set_result(
+                            eval_forward_ref(
+                                potential_type,
+                                globalns=base_globals,
+                                localns=base_locals,
+                            )
+                            if isinstance(potential_type, ForwardRef)
+                            else potential_type
+                        )
 
                 args_by_class[subclass] = tuple(subclass_generic_params_to_args)
-
             else:
                 args_by_class[subclass] = tuple((arg, _Future()) for arg in args)
 
@@ -136,7 +182,11 @@ def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
         args = get_args(clazz)
         for (_arg, future), potential_type in zip(args_by_class[origin], args):  # type: ignore[index]
             if not isinstance(potential_type, TypeVar):
-                future.set_result(potential_type)
+                future.set_result(
+                    eval_forward_ref(potential_type, globalns=globalns, localns=localns)
+                    if isinstance(potential_type, ForwardRef)
+                    else potential_type
+                )
 
     # Convert to nested dict for easier lookup
     return {k: {typ: fut for typ, fut in args} for k, args in args_by_class.items()}
@@ -166,12 +216,16 @@ def _replace_typevars(
     )
 
 
-def get_generic_dataclass_fields(clazz: type) -> Tuple[dataclasses.Field, ...]:
+def get_resolved_dataclass_fields(
+    clazz: type,
+    globalns: Optional[Dict[str, Any]] = None,
+    localns: Optional[Dict[str, Any]] = None,
+) -> Tuple[dataclasses.Field, ...]:
     unbound_fields = set()
     # Need to manually resolve fields because `dataclasses.fields` doesn't handle generics and
     # looses the source class. Thus I don't know how to resolve this at later on.
     # Instead we recreate the type but with all known TypeVars resolved to their actual types.
-    resolved_typevars = _resolve_typevars(clazz)
+    resolved_typevars = _resolve_typevars(clazz, globalns=globalns, localns=localns)
     # Dict[field_name, Tuple[original_field, resolved_field]]
     fields: Dict[str, Tuple[dataclasses.Field, dataclasses.Field]] = {}
 
@@ -190,14 +244,34 @@ def get_generic_dataclass_fields(clazz: type) -> Tuple[dataclasses.Field, ...]:
                 if not inspect.isclass(field.type) and may_contain_typevars(field.type):
                     new_field = copy.copy(field)
                     new_field.type = _replace_typevars(
-                        field.type, resolved_typevars[subclass]
+                        field.type, resolved_typevars.get(subclass)
                     )
                 elif isinstance(field.type, TypeVar):
                     new_field = copy.copy(field)
                     new_field.type = resolved_typevars[subclass][field.type].result()
+                elif isinstance(field.type, ForwardRef):
+                    base_globals, base_locals = _get_namespaces(
+                        subclass, globalns, localns
+                    )
+                    new_field = copy.copy(field)
+                    new_field.type = eval_forward_ref(
+                        field.type, globalns=base_globals, localns=base_locals
+                    )
+                elif isinstance(field.type, str):
+                    base_globals, base_locals = _get_namespaces(
+                        subclass, globalns, localns
+                    )
+                    new_field = copy.copy(field)
+                    new_field.type = eval_forward_ref(
+                        ForwardRef(field.type, is_argument=False, is_class=True)
+                        if sys.version_info >= (3, 9)
+                        else ForwardRef(field.type, is_argument=False),
+                        globalns=base_globals,
+                        localns=base_locals,
+                    )
 
                 fields[field.name] = (field, new_field)
-            except InvalidStateError:
+            except (InvalidStateError, KeyError):
                 unbound_fields.add(field.name)
 
     if unbound_fields: