Add support for type-variant generics

Author: Diego Argueta

src/desert/_make.py

@@ -54,6 +54,7 @@ class User:
       Schema: t.ClassVar[Type[Schema]] = Schema # For the type checker
 """
 
+import collections.abc as coll_abc
 import dataclasses
 import datetime
 import decimal
@@ -244,7 +245,7 @@ def field_for_schema(
     if origin:
         arguments = typing_inspect.get_args(typ, True)
 
-        if origin in (list, t.List):
+        if origin in (list, t.List, coll_abc.Sequence, coll_abc.MutableSequence):
             field = marshmallow.fields.List(field_for_schema(arguments[0]))
 
         if origin in (tuple, t.Tuple) and Ellipsis not in arguments:
@@ -256,7 +257,7 @@ def field_for_schema(
             field = VariadicTuple(
                 field_for_schema(only(arg for arg in arguments if arg != Ellipsis))
             )
-        elif origin in (dict, t.Dict):
+        elif origin in (dict, t.Dict, coll_abc.Mapping, coll_abc.MutableMapping):
             field = marshmallow.fields.Dict(
                 keys=field_for_schema(arguments[0]),
                 values=field_for_schema(arguments[1]),

tests/test_make.py

@@ -163,24 +163,22 @@ class A:
     assert data == A(1)  # type: ignore[call-arg]
 
 
-def test_list(module: DataclassModule) -> None:
+@pytest.mark.parametrize("annotation_class", (t.List, t.Sequence, t.MutableSequence))
+def test_list(module: DataclassModule, annotation_class: type) -> None:
     """Build a generic list *without* setting a factory on the dataclass."""
-
-    @module.dataclass
-    class A:
-        y: t.List[int]
+    klass = type("A", (object,), {"__annotations__": {"y": annotation_class[int]}})
+    A = module.dataclass(klass)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": [1]})
     assert data == A([1])  # type: ignore[call-arg]
 
 
-def test_dict(module: DataclassModule) -> None:
+@pytest.mark.parametrize("annotation_class", (t.Dict, t.Mapping, t.MutableMapping))
+def test_dict(module: DataclassModule, annotation_class: type) -> None:
     """Build a dict without setting a factory on the dataclass."""
-
-    @module.dataclass
-    class A:
-        y: t.Dict[int, int]
+    klass = type("A", (object,), {"__annotations__": {"y": annotation_class[int, int]}})
+    A = module.dataclass(klass)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": {1: 2, 3: 4}})
@@ -527,15 +525,12 @@ class A:
         desert.schema_class(A)
 
 
-@pytest.mark.skipif(
-    sys.version_info[:2] <= (3, 6), reason="3.6 has isinstance(t.Sequence[int], type)."
-)
 def test_raise_unknown_generic(module: DataclassModule) -> None:
     """Raise UnknownType for unknown generics."""
 
     @module.dataclass
     class A:
-        x: t.Sequence[int]
+        x: t.Iterable[int]
 
     with pytest.raises(desert.exceptions.UnknownType):
         desert.schema_class(A)