🐛 Getting generic schema more than once

Author: mvanderlee

CHANGELOG.md

@@ -1,5 +1,10 @@
 # marshmallow\_dataclass2 change log
 
+## v8.8.1 (2025-02-01)
+
+ - Update Readme
+ - Fix getting generic schema more than once
+ 
 ## v8.8.0 (2025-02-01)
 
  - Drop support for python 3.8

marshmallow_dataclass2/__init__.py

@@ -105,6 +105,29 @@ class User:
 MAX_CLASS_SCHEMA_CACHE_SIZE = 1024
 
 
+class LazyGenericSchema:
+    """Exists to cache generic instances"""
+
+    def __init__(self, base_schema, frame):
+        self.base_schema = base_schema
+        self.frame = frame
+
+        self.__resolved_generic_schemas = {}
+
+    def get_schema(self, instance):
+        instance_args = get_args(instance)
+        schema = self.__resolved_generic_schemas.get(instance_args)
+        if schema is None:
+            schema = class_schema(
+                instance,
+                self.base_schema,
+                self.frame,
+            )
+            self.__resolved_generic_schemas[instance_args] = schema
+
+        return schema
+
+
 def _maybe_get_callers_frame(
     cls: type, stacklevel: int = 1
 ) -> Optional[types.FrameType]:
@@ -296,12 +319,17 @@ def decorator(clazz: Type[_U], stacklevel: int = stacklevel) -> Type[_U]:
         else:
             frame = _maybe_get_callers_frame(clazz, stacklevel=stacklevel)
 
-        # noinspection PyTypeHints
-        clazz.Schema = lazy_class_attribute(  # type: ignore
-            partial(class_schema, clazz, base_schema, frame),
-            "Schema",
-            clazz.__name__,
-        )
+        if not typing_inspect.is_generic_type(clazz):
+            # noinspection PyTypeHints
+            clazz.Schema = lazy_class_attribute(  # type: ignore
+                partial(class_schema, clazz, base_schema, frame),
+                "Schema",
+                clazz.__name__,
+            )
+        else:
+            # noinspection PyTypeHints
+            clazz.Schema = LazyGenericSchema(base_schema, frame)  # type: ignore
+
         return clazz
 
     if _cls is None:
@@ -999,10 +1027,15 @@ def _field_for_schema(
     forward_reference = getattr(typ, "__forward_arg__", None)
 
     nested = (
-        nested_schema
-        or forward_reference
-        or _schema_ctx_stack.top.seen_classes.get(typ)
-        or _internal_class_schema(typ, base_schema)  # type: ignore [arg-type]
+        # Pass the type instance. This is required for generics
+        nested_schema.get_schema(typ)
+        if isinstance(nested_schema, LazyGenericSchema)
+        else (
+            nested_schema
+            or forward_reference
+            or _schema_ctx_stack.top.seen_classes.get(typ)
+            or _internal_class_schema(typ, base_schema)  # type: ignore [arg-type]
+        )
     )
 
     return marshmallow.fields.Nested(nested, **metadata)

setup.py

@@ -1,6 +1,6 @@
 from setuptools import find_packages, setup
 
-VERSION = "8.8.0"
+VERSION = "8.8.1"
 
 CLASSIFIERS = [
     "Development Status :: 4 - Beta",

tests/test_generics.py

@@ -110,6 +110,67 @@ class NestedGeneric(typing.Generic[T]):
         with self.assertRaises(ValidationError):
             schema_nested_generic.load({"data": {"data": "str"}})
 
+    def test_generic_dataclass_cached(self):
+        T = typing.TypeVar("T")
+
+        @dataclass
+        class SimpleGeneric(typing.Generic[T]):
+            data1: T
+
+        @dataclass
+        class NestedFixed:
+            data2: SimpleGeneric[int]
+
+        @dataclass
+        class NestedGeneric(typing.Generic[T]):
+            data3: SimpleGeneric[T]
+
+        self.assertTrue(is_generic_alias_of_dataclass(SimpleGeneric[int]))
+        self.assertFalse(is_generic_alias_of_dataclass(SimpleGeneric))
+
+        schema_s = class_schema(SimpleGeneric[str])()
+        self.assertEqual(SimpleGeneric(data1="a"), schema_s.load({"data1": "a"}))
+        self.assertEqual(schema_s.dump(SimpleGeneric(data1="a")), {"data1": "a"})
+        with self.assertRaises(ValidationError):
+            schema_s.load({"data1": 2})
+
+        schema_nested = class_schema(NestedFixed)()
+        self.assertEqual(
+            NestedFixed(data2=SimpleGeneric(1)),
+            schema_nested.load({"data2": {"data1": 1}}),
+        )
+        self.assertEqual(
+            schema_nested.dump(NestedFixed(data2=SimpleGeneric(data1=1))),
+            {"data2": {"data1": 1}},
+        )
+        with self.assertRaises(ValidationError):
+            schema_nested.load({"data2": {"data1": "str"}})
+
+        schema_nested_generic = class_schema(NestedGeneric[int])()
+        self.assertEqual(
+            NestedGeneric(data3=SimpleGeneric(1)),
+            schema_nested_generic.load({"data3": {"data1": 1}}),
+        )
+        self.assertEqual(
+            schema_nested_generic.dump(NestedGeneric(data3=SimpleGeneric(data1=1))),
+            {"data3": {"data1": 1}},
+        )
+        with self.assertRaises(ValidationError):
+            schema_nested_generic.load({"data3": {"data1": "str"}})
+
+        # Copy test again so that we trigger a cache hit
+        schema_nested_generic = class_schema(NestedGeneric[int])()
+        self.assertEqual(
+            NestedGeneric(data3=SimpleGeneric(1)),
+            schema_nested_generic.load({"data3": {"data1": 1}}),
+        )
+        self.assertEqual(
+            schema_nested_generic.dump(NestedGeneric(data3=SimpleGeneric(data1=1))),
+            {"data3": {"data1": 1}},
+        )
+        with self.assertRaises(ValidationError):
+            schema_nested_generic.load({"data3": {"data1": "str"}})
+
     def test_generic_dataclass_repeated_fields(self):
         T = typing.TypeVar("T")