Rename our is_generic_type and only utilize where absolutely necessary

Author: mvanderlee

marshmallow_dataclass/__init__.py

@@ -72,7 +72,6 @@ class User:
     UnboundTypeVarError,
     get_generic_dataclass_fields,
     is_generic_alias,
-    is_generic_type,
 )
 from marshmallow_dataclass.lazy_class_attribute import lazy_class_attribute
 
@@ -586,7 +585,7 @@ def _internal_class_schema(
 
     # Update the schema members to contain marshmallow fields instead of dataclass fields
     type_hints = {}
-    if not is_generic_type(clazz):
+    if not typing_inspect.is_generic_type(clazz):
         type_hints = _get_type_hints(clazz, schema_ctx)
 
     attributes.update(
@@ -595,7 +594,7 @@ def _internal_class_schema(
             _field_for_schema(
                 (
                     type_hints[field.name]
-                    if not is_generic_type(clazz)
+                    if not typing_inspect.is_generic_type(clazz)
                     else _resolve_forward_type_refs(field.type, schema_ctx)
                 ),
                 _get_field_default(field),
@@ -758,7 +757,10 @@ def _field_for_annotated_type(
             for arg in arguments[1:]
             if _is_marshmallow_field(arg)
             # Support `CustomGenericField[mf.String]`
-            or (is_generic_type(arg) and _is_marshmallow_field(get_origin(arg)))
+            or (
+                typing_inspect.is_generic_type(arg)
+                and _is_marshmallow_field(get_origin(arg))
+            )
         ]
         if marshmallow_annotations:
             if len(marshmallow_annotations) > 1:
@@ -1069,7 +1071,7 @@ class X:
 
 
 def _dataclass_fields(clazz: type) -> Tuple[dataclasses.Field, ...]:
-    if not is_generic_type(clazz):
+    if not typing_inspect.is_generic_type(clazz):
         return dataclasses.fields(clazz)
 
     else:

marshmallow_dataclass/generic_resolver.py

@@ -79,14 +79,18 @@ class A(Generic[T]):
 
     ``A[int]`` is a _generic alias_ (while ``A`` is a *generic type*, but not a *generic alias*).
     """
-    is_generic = is_generic_type(clazz)
+    is_generic = typing_inspect.is_generic_type(clazz)
     type_arguments = get_args(clazz)
     return is_generic and len(type_arguments) > 0
 
 
-def is_generic_type(clazz: type) -> bool:
+def may_contain_typevars(clazz: type) -> bool:
     """
-    typing_inspect.is_generic_type explicitly ignores Union and Tuple
+    Check if the class can contain typevars. This includes Special Forms.
+
+    Different from typing_inspect.is_generic_type as that explicitly ignores Union and Tuple.
+
+    We still need to resolve typevars for Union and Tuple
     """
     origin = get_origin(clazz)
     return origin is not Annotated and (
@@ -141,14 +145,18 @@ def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
 def _replace_typevars(
     clazz: type, resolved_generics: Optional[Dict[TypeVar, _Future]] = None
 ) -> type:
-    if not resolved_generics or inspect.isclass(clazz) or not is_generic_type(clazz):
+    if (
+        not resolved_generics
+        or inspect.isclass(clazz)
+        or not may_contain_typevars(clazz)
+    ):
         return clazz
 
     return clazz.copy_with(  # type: ignore
         tuple(
             (
                 _replace_typevars(arg, resolved_generics)
-                if is_generic_type(arg)
+                if may_contain_typevars(arg)
                 else (
                     resolved_generics[arg].result() if arg in resolved_generics else arg
                 )
@@ -179,7 +187,7 @@ def get_generic_dataclass_fields(clazz: type) -> Tuple[dataclasses.Field, ...]:
                 # Either the first time we see this field, or it got overridden
                 # If it's a class we handle it later as a Nested. Nothing to resolve now.
                 new_field = field
-                if not inspect.isclass(field.type) and is_generic_type(field.type):
+                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]

tests/test_generics.py

@@ -3,6 +3,7 @@
 import sys
 import typing
 import unittest
+from typing_inspect import is_generic_type
 
 import marshmallow.fields
 from marshmallow import ValidationError
@@ -14,7 +15,6 @@
     dataclass,
     is_generic_alias_of_dataclass,
 )
-from marshmallow_dataclass.generic_resolver import is_generic_type
 
 if sys.version_info >= (3, 9):
     from typing import Annotated
@@ -319,12 +319,29 @@ def test_generic_dataclass_with_forwardref(self):
         T = typing.TypeVar("T")
 
         @dataclasses.dataclass
-        class SimpleGeneric(typing.Generic[T]):
+        class ForwardGeneric(typing.Generic[T]):
             data: T
 
-        schema_s = class_schema(SimpleGeneric["str"])()
-        self.assertEqual(SimpleGeneric(data="a"), schema_s.load({"data": "a"}))
-        self.assertEqual(schema_s.dump(SimpleGeneric(data="a")), {"data": "a"})
+        schema_s = class_schema(ForwardGeneric["str"])()
+        self.assertEqual(ForwardGeneric(data="a"), schema_s.load({"data": "a"}))
+        self.assertEqual(schema_s.dump(ForwardGeneric(data="a")), {"data": "a"})
+        with self.assertRaises(ValidationError):
+            schema_s.load({"data": 2})
+
+    def test_generic_dataclass_with_optional(self):
+        T = typing.TypeVar("T")
+
+        @dataclasses.dataclass
+        class OptionalGeneric(typing.Generic[T]):
+            data: typing.Optional[T]
+
+        schema_s = class_schema(OptionalGeneric["str"])()
+        self.assertEqual(OptionalGeneric(data="a"), schema_s.load({"data": "a"}))
+        self.assertEqual(schema_s.dump(OptionalGeneric(data="a")), {"data": "a"})
+
+        self.assertEqual(OptionalGeneric(data=None), schema_s.load({}))
+        self.assertEqual(schema_s.dump(OptionalGeneric(data=None)), {"data": None})
+
         with self.assertRaises(ValidationError):
             schema_s.load({"data": 2})