Add support for Tuple[int, ...].

Author: desert

changelog.d/16.change

@@ -0,0 +1 @@
+Add support for Tuple[int, ...] per https://docs.python.org/3/library/typing.html#typing.Tuple

src/desert/_make.py

@@ -60,6 +60,7 @@ class User:
 import datetime
 import decimal
 import inspect
+import typing as t
 import typing
 import uuid
 from enum import Enum
@@ -75,7 +76,6 @@ class User:
 from typing import Type
 from typing import Union
 from typing import cast
-
 import attr
 import marshmallow
 import typing_inspect
@@ -86,6 +86,7 @@ class User:
 __all__ = ["dataclass", "add_schema", "class_schema", "field_for_schema"]
 
 NoneType = type(None)
+T = t.TypeVar("T")
 
 
 def class_schema(clazz: type, meta: Dict[str, Any] = {}) -> Type[marshmallow.Schema]:
@@ -157,6 +158,19 @@ def class_schema(clazz: type, meta: Dict[str, Any] = {}) -> Type[marshmallow.Sch
 }
 
 
+class VariadicTuple(marshmallow.fields.List):
+    """Homogenous tuple with variable number of entries."""
+
+    def _deserialize(self, *args, **kwargs):
+        return tuple(super()._deserialize(*args, **kwargs))
+
+
+def only(items: t.Iterable[T]) -> T:
+    """Return the only item in an iterable or raise ValueError."""
+    [x] = items
+    return x
+
+
 def field_for_schema(
     typ: type, default=marshmallow.missing, metadata: Mapping[str, Any] = None
 ) -> marshmallow.fields.Field:
@@ -201,7 +215,7 @@ def field_for_schema(
 
     if default is not marshmallow.missing:
         desert_metadata.setdefault("default", default)
-        desert_metadata.setdefault('allow_none', True)
+        desert_metadata.setdefault("allow_none", True)
         if not desert_metadata.get(
             "required"
         ):  # 'missing' must not be set for required fields.
@@ -223,14 +237,22 @@ def field_for_schema(
 
     # Generic types
     origin = typing_inspect.get_origin(typ)
+
     if origin:
         arguments = typing_inspect.get_args(typ, True)
+
         if origin in (list, List):
             field = marshmallow.fields.List(field_for_schema(arguments[0]))
-        if origin in (tuple, Tuple):
+
+        if origin in (tuple, t.Tuple) and Ellipsis not in arguments:
             field = marshmallow.fields.Tuple(
                 tuple(field_for_schema(arg) for arg in arguments)
             )
+        elif origin in (tuple, t.Tuple) and Ellipsis in arguments:
+
+            field = VariadicTuple(
+                field_for_schema(only(arg for arg in arguments if arg != Ellipsis))
+            )
         elif origin in (dict, Dict):
             field = marshmallow.fields.Dict(
                 keys=field_for_schema(arguments[0]),
@@ -243,7 +265,6 @@ def field_for_schema(
             metadata[_DESERT_SENTINEL]["missing"] = metadata.get("missing", None)
             metadata[_DESERT_SENTINEL]["required"] = False
 
-
             field = field_for_schema(subtyp, metadata=metadata, default=None)
             field.default = None
             field.missing = None

tests/test_make.py

@@ -137,6 +137,7 @@ class A:
     data = desert.schema_class(A)().load({})
     assert data == A(None)
 
+
 def test_optional_present(module):
     """Setting an optional type allows passing None."""
 
@@ -380,3 +381,36 @@ class A:
 
     with pytest.raises(desert.exceptions.UnknownType):
         desert.schema_class(A)
+
+
+def test_tuple_ellipsis(module):
+    """Tuple with ellipsis allows variable length tuple.
+
+    See :class:`typing.Tuple`.
+    """
+
+    @module.dataclass
+    class A:
+        x: t.Tuple[int, ...]
+
+    schema = desert.schema_class(A)()
+    dumped = {"x": (1, 2, 3)}
+    loaded = A(x=(1, 2, 3))
+
+    assert schema.load(dumped) == loaded
+    assert schema.dump(loaded) == {"x": [1, 2, 3]}
+    assert schema.loads(schema.dumps(loaded)) == loaded
+
+
+def test_only():
+    """only() extracts the only item in an iterable."""
+    assert desert._make.only([1]) == 1
+
+
+def test_only_raises():
+    """only() raises if the iterable has an unexpected number of entries.'"""
+    with pytest.raises(ValueError):
+        desert._make.only([])
+
+    with pytest.raises(ValueError):
+        desert._make.only([1, 2])