first attempt at an adjacently tagged union for consideration

src/desert/_fields.py

@@ -0,0 +1,83 @@
+import typing
+
+import attr
+import marshmallow.fields
+
+
+T = typing.TypeVar("T")
+
+
+@attr.s(frozen=True, auto_attribs=True)
+class TypeTagField:
+    cls: type
+    tag: str
+    field: typing.Type[marshmallow.fields.Field]
+
+
+@attr.s(auto_attribs=True)
+class TypeDictRegistry:
+    the_dict: typing.Dict[typing.Union[type, str], marshmallow.fields.Field] = attr.ib(
+        factory=dict
+    )
+
+    def register(self, cls, tag, field):
+        if any(key in self.the_dict for key in [cls, tag]):
+            raise Exception()
+
+        type_tag_field = TypeTagField(cls=cls, tag=tag, field=field)
+
+        self.the_dict[cls] = type_tag_field
+        self.the_dict[tag] = type_tag_field
+
+    # TODO: this type hinting...  doesn't help much as it could return
+    #       another cls
+    def __call__(self, tag: str, field: marshmallow.fields) -> typing.Callable[[T], T]:
+        return lambda cls: self.register(cls=cls, tag=tag, field=field)
+
+    def from_object(self, value):
+        return self.the_dict[type(value)]
+
+    def from_tag(self, tag):
+        return self.the_dict[tag]
+
+
+class AdjacentlyTaggedUnion(marshmallow.fields.Field):
+    def __init__(
+        self,
+        *,
+        from_object: typing.Callable[[typing.Any], TypeTagField],
+        from_tag: typing.Callable[[str], TypeTagField],
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.from_object = from_object
+        self.from_tag = from_tag
+
+    def _deserialize(
+        self,
+        value: typing.Any,
+        attr: typing.Optional[str],
+        data: typing.Optional[typing.Mapping[str, typing.Any]],
+        **kwargs,
+    ) -> typing.Any:
+        tag = value["type"]
+        serialized_value = value["value"]
+
+        if len(value) > 2:
+            raise Exception()
+
+        type_tag_field = self.from_tag(tag)
+        field = type_tag_field.field()
+
+        return field.deserialize(serialized_value)
+
+    def _serialize(
+        self, value: typing.Any, attr: str, obj: typing.Any, **kwargs,
+    ) -> typing.Any:
+        type_tag_field = self.from_object(value)
+        field = type_tag_field.field()
+        tag = type_tag_field.tag
+        serialized_value = field.serialize(attr, obj)
+
+        return {"type": tag, "value": serialized_value}

tests/test_fields.py

@@ -0,0 +1,98 @@
+import decimal
+import typing
+
+import attr
+import marshmallow
+import pytest
+
+import desert._fields
+
+
+# TODO: test that field constructor doesn't tromple Field parameters
+
+
+@attr.s(auto_attribs=True)
+class ExampleData:
+    object: typing.Any
+    tag: str
+    field: typing.Callable[[], marshmallow.fields.Field]
+
+
+example_data_list = [
+    ExampleData(object=3.7, tag="float_tag", field=marshmallow.fields.Float),
+    ExampleData(object="29", tag="str_tag", field=marshmallow.fields.String),
+    ExampleData(
+        object=decimal.Decimal("4.2"),
+        tag="decimal_tag",
+        field=marshmallow.fields.Decimal,
+    ),
+    ExampleData(
+        object=[1, 2, 3],
+        tag="integer_list_tag",
+        field=lambda: marshmallow.fields.List(marshmallow.fields.Integer()),
+    ),
+    ExampleData(
+        object=['abc', '2', 'mno'],
+        tag="string_list_tag",
+        field=lambda: marshmallow.fields.List(marshmallow.fields.String()),
+    ),
+]
+
+
+@pytest.fixture(
+    name="example_data",
+    params=example_data_list,
+    ids=[str(example) for example in example_data_list],
+)
+def _example_data(request):
+    return request.param
+
+
+@pytest.fixture(name="registry", scope="session")
+def _registry():
+    registry = desert._fields.TypeDictRegistry()
+
+    for example in example_data_list:
+        registry.register(
+            cls=type(example.object), tag=example.tag, field=example.field,
+        )
+
+    return registry
+
+
+@pytest.fixture(name="adjacently_tagged_field", scope="session")
+def _adjacently_tagged_field(registry):
+    return desert._fields.AdjacentlyTaggedUnion(
+        from_object=registry.from_object, from_tag=registry.from_tag,
+    )
+
+
+def test_adjacently_tagged_deserialize(example_data, adjacently_tagged_field):
+    serialized_value = {"type": example_data.tag, "value": example_data.object}
+
+    deserialized_value = adjacently_tagged_field.deserialize(serialized_value)
+
+    assert (type(deserialized_value) == type(example_data.object)) and (
+        deserialized_value == example_data.object
+    )
+
+
+def test_adjacently_tagged_deserialize_extra_key_raises(
+    example_data, adjacently_tagged_field,
+):
+    serialized_value = {
+        "type": example_data.tag,
+        "value": example_data.object,
+        "extra": 29,
+    }
+
+    with pytest.raises(expected_exception=Exception):
+        adjacently_tagged_field.deserialize(serialized_value)
+
+
+def test_adjacently_tagged_serialize(example_data, adjacently_tagged_field):
+    obj = {"key": example_data.object}
+
+    serialized_value = adjacently_tagged_field.serialize("key", obj)
+
+    assert serialized_value == {"type": example_data.tag, "value": example_data.object}