Fix namedtuple serde (#49)

NiklasRosenstein · GitHub Action · web-flow · commit a32378cf34b1 · 2023-06-09T15:13:53.000+02:00
* add unit tests for namedtuple

* update tests

* fix collections.namedtuple case

* databind.json/: fix: Fix serde of `collections.namedtuple` (to array) and `typing.NamedTuple` (to object)

* remove anyconvert in test

* fix check for __annotations__

* Updated PR references in 1 changelogs.

skip-checks: true

* use ubuntu-20.04 for py 3.6

---------

Co-authored-by: GitHub Action &lt;github-action@users.noreply.github.com&gt;
diff --git a/.github/workflows/python.yaml b/.github/workflows/python.yaml
@@ -6,7 +6,7 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     strategy:
       matrix:
         python-version: ["3.6", "3.7", "3.8", "3.9", "3.10", "3.11", "3.x"]
diff --git a/databind.json/.changelog/_unreleased.toml b/databind.json/.changelog/_unreleased.toml
@@ -0,0 +1,6 @@
+[[entries]]
+id = "8504f1e4-679f-4a09-8888-bfca54bd4201"
+type = "fix"
+description = "Fix serde of `collections.namedtuple` (to array) and `typing.NamedTuple` (to object)"
+author = "@NiklasRosenstein"
+pr = "https://github.com/NiklasRosenstein/python-databind/pull/49"
diff --git a/databind.json/src/databind/json/converters.py b/databind.json/src/databind/json/converters.py
@@ -88,6 +88,31 @@ def convert(self, ctx: Context) -> t.Any:
         ) and not isinstance(datatype, TupleTypeHint):
             raise NotImplementedError
 
+        # NamedTuples with type information are a lot like data classes, so we delegate to the SchemaConverter.
+        if (
+            isinstance(datatype, ClassTypeHint)
+            and issubclass(datatype.type, tuple)
+            and getattr(datatype.type, "__annotations__", None)
+        ):
+            schema = Schema(
+                fields={
+                    name: Field(
+                        datatype=TypeHint(type_),
+                    )
+                    for name, type_ in getattr(datatype.type, "__annotations__").items()
+                },
+                constructor=datatype.type,
+                type=datatype.type,
+            )
+            if ctx.direction.is_serialize():
+                return SchemaConverter().serialize_from_schema(ctx, schema)
+            elif ctx.direction.is_deserialize():
+                return SchemaConverter().deserialize_from_schema(ctx, schema)
+            else:
+                assert False, ctx.direction
+
+        # TODO(@niklas.rosenstein): Should we support an object-based JSON representation for collections.namedtuple?
+
         if isinstance(datatype, TupleTypeHint) and not datatype.repeated:
             # Require that the length of the input data matches the tuple.
             item_types_iterator = iter(datatype)
@@ -129,6 +154,9 @@ def _length_check() -> None:
             values = list(values)
             if python_type == list:
                 return values
+            elif hasattr(python_type, "_fields"):  # For collections.namedtuple
+                return python_type(*values)
+
             try:
                 return python_type(values)
             except TypeError:
@@ -431,9 +459,7 @@ def _get_schema(self, ctx: Context) -> Schema:
         except ValueError as exc:
             raise NotImplementedError(str(exc))
 
-    def serialize(self, ctx: Context) -> t.MutableMapping[str, t.Any]:
-        schema = self._get_schema(ctx)
-
+    def serialize_from_schema(self, ctx: Context, schema: Schema) -> t.MutableMapping[str, t.Any]:
         try:
             is_instance = isinstance(ctx.value, schema.type)
         except TypeError:
@@ -502,9 +528,7 @@ def _get_field_value(field_name: str, field: Field) -> t.Any:
 
         return result
 
-    def deserialize(self, ctx: Context) -> t.Any:
-        schema = self._get_schema(ctx)
-
+    def deserialize_from_schema(self, ctx: Context, schema: Schema) -> t.Any:
         if not isinstance(ctx.value, t.Mapping):
             raise ConversionError.expected(self, ctx, t.Mapping)
 
@@ -575,6 +599,14 @@ def _extract_fields(fields: t.Dict[str, Field]) -> t.Dict[str, t.Any]:
 
         return schema.constructor(**result)
 
+    def deserialize(self, ctx: Context) -> t.Any:
+        schema = self._get_schema(ctx)
+        return self.deserialize_from_schema(ctx, schema)
+
+    def serialize(self, ctx: Context) -> t.MutableMapping[str, t.Any]:
+        schema = self._get_schema(ctx)
+        return self.serialize_from_schema(ctx, schema)
+
 
 class StringifyConverter(Converter):
     """A useful helper converter that matches on a given type or its subclasses and converts them to a string for
diff --git a/databind.json/src/databind/json/tests/converters_test.py b/databind.json/src/databind/json/tests/converters_test.py
@@ -4,6 +4,7 @@
 import enum
 import typing as t
 import uuid
+from collections import namedtuple
 
 import pytest
 import typing_extensions as te
@@ -520,3 +521,25 @@ def test_deserialize_tuple() -> None:
     with pytest.raises(ConversionError) as excinfo:
         databind.json.load([1, 42, 3], t.Tuple[int, int])
     assert excinfo.value.message == "expected a tuple of length 2, found 3"
+
+
+def test__namedtuple() -> None:
+    # NOTE: Need the AnyConverter because the namedtuple is not a dataclass and we don't have type information
+    #       for the fields.
+    mapper = make_mapper([CollectionConverter(), PlainDatatypeConverter(), AnyConverter()])
+
+    nt = namedtuple("nt", ["a", "b"])
+
+    assert mapper.serialize(nt(1, 2), nt) == [1, 2]
+    assert mapper.deserialize([1, 2], nt) == nt(1, 2)
+
+
+def test__typing_NamedTuple() -> None:
+    mapper = make_mapper([CollectionConverter(), PlainDatatypeConverter()])
+
+    class Nt(t.NamedTuple):
+        a: int
+        b: str
+
+    assert mapper.serialize(Nt(1, "2"), Nt) == {"a": 1, "b": "2"}
+    assert mapper.deserialize({"a": 1, "b": "2"}, Nt) == Nt(1, "2")
