Add support for TypeVar defaults

Tested with 3.12.0rc2

Author: mvanderlee

marshmallow_dataclass/generic_resolver.py

@@ -18,14 +18,31 @@
 else:
     from typing_extensions import Annotated, get_args, get_origin
 
+if sys.version_info >= (3, 13):
+    from typing import NoDefault
+else:
+    from typing import final
+
+    @final
+    class NoDefault:
+        pass
+
+
 _U = TypeVar("_U")
 
 
 class UnboundTypeVarError(TypeError):
     """TypeVar instance can not be resolved to a type spec.
 
     This exception is raised when an unbound TypeVar is encountered.
+    """
 
+
+class InvalidTypeVarDefaultError(TypeError):
+    """TypeVar default can not be resolved to a type spec.
+
+    This exception is raised when an invalid TypeVar default is encountered.
+    This is most likely a scoping error: https://peps.python.org/pep-0696/#scoping-rules
     """
 
 
@@ -42,9 +59,11 @@ class _Future(Generic[_U]):
 
     _done: bool
     _result: _U
+    _default: _U | "_Future[_U]"
 
-    def __init__(self) -> None:
+    def __init__(self, default=NoDefault) -> None:
         self._done = False
+        self._default = default
 
     def done(self) -> bool:
         """Return ``True`` if the value is available"""
@@ -57,6 +76,13 @@ def result(self) -> _U:
         """
         if self.done():
             return self._result
+
+        if self._default is not NoDefault:
+            if isinstance(self._default, _Future):
+                return self._default.result()
+
+            return self._default
+
         raise InvalidStateError("result has not been set")
 
     def set_result(self, result: _U) -> None:
@@ -120,13 +146,35 @@ def _resolve_typevars(clazz: type) -> Dict[type, Dict[TypeVar, _Future]]:
                 ):
                     if isinstance(potential_type, TypeVar):
                         subclass_generic_params_to_args.append((potential_type, future))
+                        default = getattr(potential_type, "__default__", NoDefault)
+                        if default is not None:
+                            future._default = default
                     else:
                         future.set_result(potential_type)
 
                 args_by_class[subclass] = tuple(subclass_generic_params_to_args)
 
             else:
-                args_by_class[subclass] = tuple((arg, _Future()) for arg in args)
+                # PEP-696: Typevar's may be used as defaults, but T1 must be used before T2
+                # https://peps.python.org/pep-0696/#scoping-rules
+                seen_type_args: Dict[TypeVar, _Future] = {}
+                for arg in args:
+                    default = getattr(arg, "__default__", NoDefault)
+                    if default is not None:
+                        if isinstance(default, TypeVar):
+                            if default in seen_type_args:
+                                # We've already seen this TypeVar, Set the default to it's _Future
+                                default = seen_type_args[default]
+
+                            else:
+                                # We haven't seen this yet, according to PEP-696 this is invalid.
+                                raise InvalidTypeVarDefaultError(
+                                    f"{subclass.__name__} has an invalid TypeVar default for field {arg}"
+                                )
+
+                    seen_type_args[arg] = _Future(default=default)
+
+                args_by_class[subclass] = tuple(seen_type_args.items())
 
             parent_class = subclass
 

tests/test_generics.py

@@ -6,6 +6,7 @@
 from typing_inspect import is_generic_type
 
 import marshmallow.fields
+import pytest
 from marshmallow import ValidationError
 
 from marshmallow_dataclass import (
@@ -345,6 +346,165 @@ class OptionalGeneric(typing.Generic[T]):
         with self.assertRaises(ValidationError):
             schema_s.load({"data": 2})
 
+    @pytest.mark.skipif(
+        sys.version_info <= (3, 13), reason="requires python 3.13 or higher"
+    )
+    def test_generic_default(self):
+        T = typing.TypeVar("T", default=str)
+
+        @dataclasses.dataclass
+        class SimpleGeneric(typing.Generic[T]):
+            data: T
+
+        @dataclasses.dataclass
+        class NestedFixed:
+            data: SimpleGeneric[int]
+
+        @dataclasses.dataclass
+        class NestedGeneric(typing.Generic[T]):
+            data: SimpleGeneric[T]
+
+        self.assertTrue(is_generic_alias_of_dataclass(SimpleGeneric[int]))
+        self.assertFalse(is_generic_alias_of_dataclass(SimpleGeneric))
+
+        schema_s = class_schema(SimpleGeneric)()
+        self.assertEqual(SimpleGeneric(data="a"), schema_s.load({"data": "a"}))
+        self.assertEqual(schema_s.dump(SimpleGeneric(data="a")), {"data": "a"})
+        with self.assertRaises(ValidationError):
+            schema_s.load({"data": 2})
+
+        schema_nested = class_schema(NestedFixed)()
+        self.assertEqual(
+            NestedFixed(data=SimpleGeneric(1)),
+            schema_nested.load({"data": {"data": 1}}),
+        )
+        self.assertEqual(
+            schema_nested.dump(NestedFixed(data=SimpleGeneric(data=1))),
+            {"data": {"data": 1}},
+        )
+        with self.assertRaises(ValidationError):
+            schema_nested.load({"data": {"data": "str"}})
+
+        schema_nested_generic = class_schema(NestedGeneric[int])()
+        self.assertEqual(
+            NestedGeneric(data=SimpleGeneric(1)),
+            schema_nested_generic.load({"data": {"data": 1}}),
+        )
+        self.assertEqual(
+            schema_nested_generic.dump(NestedGeneric(data=SimpleGeneric(data=1))),
+            {"data": {"data": 1}},
+        )
+        with self.assertRaises(ValidationError):
+            schema_nested_generic.load({"data": {"data": "str"}})
+
+    @pytest.mark.skipif(
+        sys.version_info <= (3, 13), reason="requires python 3.13 or higher"
+    )
+    def test_deep_generic_with_default_overrides(self):
+        T = typing.TypeVar("T", default=bool)
+        U = typing.TypeVar("U", default=int)
+        V = typing.TypeVar("V", default=str)
+        W = typing.TypeVar("W", default=float)
+
+        @dataclasses.dataclass
+        class TestClass(typing.Generic[T, U, V]):
+            pairs: typing.List[typing.Tuple[T, U]]
+            gen: V
+            override: int
+
+        test_schema = class_schema(TestClass)()
+        assert list(test_schema.fields) == ["pairs", "gen", "override"]
+        assert isinstance(test_schema.fields["pairs"], marshmallow.fields.List)
+        assert isinstance(test_schema.fields["pairs"].inner, marshmallow.fields.Tuple)
+        assert isinstance(
+            test_schema.fields["pairs"].inner.tuple_fields[0],
+            marshmallow.fields.Boolean,
+        )
+        assert isinstance(
+            test_schema.fields["pairs"].inner.tuple_fields[1],
+            marshmallow.fields.Integer,
+        )
+
+        assert isinstance(test_schema.fields["gen"], marshmallow.fields.String)
+        assert isinstance(test_schema.fields["override"], marshmallow.fields.Integer)
+
+        # Don't only override typevar, but switch order to further confuse things
+        @dataclasses.dataclass
+        class TestClass2(TestClass[str, W, U]):
+            override: str  # type: ignore  # Want to test that it works, even if incompatible types
+
+        TestAlias = TestClass2[int, T]
+        test_schema2 = class_schema(TestClass2)()
+        assert list(test_schema2.fields) == ["pairs", "gen", "override"]
+        assert isinstance(test_schema2.fields["pairs"], marshmallow.fields.List)
+        assert isinstance(test_schema2.fields["pairs"].inner, marshmallow.fields.Tuple)
+        assert isinstance(
+            test_schema2.fields["pairs"].inner.tuple_fields[0],
+            marshmallow.fields.String,
+        )
+        assert isinstance(
+            test_schema2.fields["pairs"].inner.tuple_fields[1],
+            marshmallow.fields.Float,
+        )
+
+        assert isinstance(test_schema2.fields["gen"], marshmallow.fields.Integer)
+        assert isinstance(test_schema2.fields["override"], marshmallow.fields.String)
+
+        # inherit from alias
+        @dataclasses.dataclass
+        class TestClass3(TestAlias[typing.List[int]]):
+            pass
+
+        test_schema3 = class_schema(TestClass3)()
+        assert list(test_schema3.fields) == ["pairs", "gen", "override"]
+        assert isinstance(test_schema3.fields["pairs"], marshmallow.fields.List)
+        assert isinstance(test_schema3.fields["pairs"].inner, marshmallow.fields.Tuple)
+        assert isinstance(
+            test_schema3.fields["pairs"].inner.tuple_fields[0],
+            marshmallow.fields.String,
+        )
+        assert isinstance(
+            test_schema3.fields["pairs"].inner.tuple_fields[1],
+            marshmallow.fields.Integer,
+        )
+
+        assert isinstance(test_schema3.fields["gen"], marshmallow.fields.List)
+        assert isinstance(test_schema3.fields["gen"].inner, marshmallow.fields.Integer)
+        assert isinstance(test_schema3.fields["override"], marshmallow.fields.String)
+
+        self.assertEqual(
+            test_schema3.load(
+                {"pairs": [("first", "1")], "gen": ["1", 2], "override": "overridden"}
+            ),
+            TestClass3([("first", 1)], [1, 2], "overridden"),
+        )
+
+    @pytest.mark.skipif(
+        sys.version_info <= (3, 13), reason="requires python 3.13 or higher"
+    )
+    def test_generic_default_recursion(self):
+        T = typing.TypeVar("T", default=str)
+        U = typing.TypeVar("U", default=T)
+        V = typing.TypeVar("V", default=U)
+
+        @dataclasses.dataclass
+        class DefaultGenerics(typing.Generic[T, U, V]):
+            a: T
+            b: U
+            c: V
+
+        test_schema = class_schema(DefaultGenerics)()
+        assert list(test_schema.fields) == ["a", "b", "c"]
+        assert isinstance(test_schema.fields["a"], marshmallow.fields.String)
+        assert isinstance(test_schema.fields["b"], marshmallow.fields.String)
+        assert isinstance(test_schema.fields["c"], marshmallow.fields.String)
+
+        test_schema2 = class_schema(DefaultGenerics[int])()
+        assert list(test_schema2.fields) == ["a", "b", "c"]
+        assert isinstance(test_schema2.fields["a"], marshmallow.fields.Integer)
+        assert isinstance(test_schema2.fields["b"], marshmallow.fields.Integer)
+        assert isinstance(test_schema2.fields["c"], marshmallow.fields.Integer)
+
 
 if __name__ == "__main__":
     unittest.main()