Merge pull request #164 from dargueta/generic-types

Author: altendky

changelog.d/140.change.rst

@@ -0,0 +1,30 @@
+It is now possible to use `type-variant generics`_ in your dataclasses, such as ``Sequence``
+or ``MutableSequence`` instead of ``List``, ``Mapping`` instead of ``Dict``, etc.
+
+This allows you to hide implementation details from users of your dataclasses. If a field
+in your dataclass works just as fine with a tuple as a list, you no longer need to force
+your users to pass in a ``list`` just to satisfy type checkers.
+
+For example, by using ``Mapping`` or ``MutableMapping``, users can pass ``OrderedDict`` to
+a ``Dict`` attribute without MyPy complaining.
+
+.. code-block:: python
+
+    @dataclass
+    class OldWay:
+        str_list: List[str]
+        num_map: Dict[str, float]
+
+
+    # MyPy will reject this even though Marshmallow works just fine. If you use
+    # type-variant generics, MyPy will accept this code.
+    instance = OldClass([], collections.ChainMap(MY_DEFAULTS))
+
+
+    @dataclass
+    class NewWay:
+        str_list: List[str]                     # Type-invariants still work
+        num_map: MutableMapping[str, float]     # Now generics do too
+
+
+.. _type-variant generics: https://mypy.readthedocs.io/en/stable/generics.html

src/desert/_make.py

@@ -54,6 +54,7 @@ class User:
       Schema: t.ClassVar[Type[Schema]] = Schema # For the type checker
 """
 
+import collections.abc
 import dataclasses
 import datetime
 import decimal
@@ -244,7 +245,14 @@ 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,
+            t.Sequence,
+            t.MutableSequence,
+            collections.abc.Sequence,
+            collections.abc.MutableSequence,
+        ):
             field = marshmallow.fields.List(field_for_schema(arguments[0]))
 
         if origin in (tuple, t.Tuple) and Ellipsis not in arguments:
@@ -256,7 +264,14 @@ 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,
+            t.Mapping,
+            t.MutableMapping,
+            collections.abc.Mapping,
+            collections.abc.MutableMapping,
+        ):
             field = marshmallow.fields.Dict(
                 keys=field_for_schema(arguments[0]),
                 values=field_for_schema(arguments[1]),

tests/test_make.py

@@ -163,29 +163,27 @@ 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]
+    cls = type("A", (object,), {"__annotations__": {"y": annotation_class[int]}})  # type: ignore[index]
+    A = module.dataclass(cls)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": [1]})
-    assert data == A([1])  # type: ignore[call-arg]
+    assert data == A([1])
 
 
-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]
+    cls = type("A", (object,), {"__annotations__": {"y": annotation_class[int, int]}})  # type: ignore[index]
+    A = module.dataclass(cls)
 
     schema = desert.schema_class(A)()
     data = schema.load({"y": {1: 2, 3: 4}})
 
-    assert data == A({1: 2, 3: 4})  # type: ignore[call-arg]
+    assert data == A({1: 2, 3: 4})
 
 
 def test_nested(module: DataclassModule) -> None:
@@ -527,6 +525,13 @@ class A:
         desert.schema_class(A)
 
 
+T = t.TypeVar("T")
+
+
+class UnknownGeneric(t.Generic[T]):
+    pass
+
+
 @pytest.mark.skipif(
     sys.version_info[:2] <= (3, 6), reason="3.6 has isinstance(t.Sequence[int], type)."
 )
@@ -535,7 +540,7 @@ def test_raise_unknown_generic(module: DataclassModule) -> None:
 
     @module.dataclass
     class A:
-        x: t.Sequence[int]
+        x: UnknownGeneric[int]
 
     with pytest.raises(desert.exceptions.UnknownType):
         desert.schema_class(A)