Merge pull request yukinarit#123 from ydylla/bugfixes

Some bugfixes

Author: yukinarit

serde/compat.py

@@ -159,6 +159,8 @@ def iter_unions(cls: Type) -> Iterator[Type]:
     """
     if is_union(cls):
         yield cls
+        for arg in type_args(cls):
+            yield from iter_unions(arg)
     if is_dataclass(cls):
         for f in fields(cls):
             yield from iter_unions(f.type)

serde/de.py

@@ -503,11 +503,11 @@ def tuple(self, arg: DeField) -> str:
         ... @dataclass
         ... class Foo: pass
         >>> Renderer('foo').render(DeField(Tuple[str, int, List[int], Foo], 'd', datavar='data'))
-        '(data["d"][0], data["d"][1], [v for v in data["d"][2]], Foo.__serde__.funcs[\\'foo\\'](data["d"][3], reuse_instances=reuse_instances))'
+        '(data["d"][0], data["d"][1], [v for v in data["d"][2]], Foo.__serde__.funcs[\\'foo\\'](data["d"][3], reuse_instances=reuse_instances),)'
 
         >>> field = DeField(Tuple[str, int, List[int], Foo], 'd', datavar='data', index=0, iterbased=True)
         >>> Renderer('foo').render(field)
-        "(data[0][0], data[0][1], [v for v in data[0][2]], Foo.__serde__.funcs['foo'](data[0][3], reuse_instances=reuse_instances))"
+        "(data[0][0], data[0][1], [v for v in data[0][2]], Foo.__serde__.funcs['foo'](data[0][3], reuse_instances=reuse_instances),)"
         """
         if is_bare_tuple(arg.type):
             return f'tuple({arg.data})'
@@ -516,7 +516,7 @@ def tuple(self, arg: DeField) -> str:
             for i, typ in enumerate(type_args(arg.type)):
                 inner = arg[i]
                 values.append(self.render(inner))
-            return f'({", ".join(values)})'
+            return f'({", ".join(values)},)'  # trailing , is required for single element tuples
 
     def dict(self, arg: DeField) -> str:
         """

serde/se.py

@@ -370,7 +370,7 @@ def {{func}}(obj, reuse_instances = {{serde_scope.reuse_instances_default}}, con
 
 def render_union_func(cls: Type, union_args: List[Type]) -> str:
     template = """
-def {{func}}(obj, reuse_instances):
+def {{func}}(obj, reuse_instances, convert_sets):
   {% for name in serde_scope.types.keys() %}
   {{name}} = serde_scope.types['{{name}}']
   {% endfor %}
@@ -432,7 +432,7 @@ def render(self, arg: SeField) -> str:
         "{k.__serde__.funcs['to_iter'](k, reuse_instances=reuse_instances, convert_sets=convert_sets): v.__serde__.funcs['to_iter'](v, reuse_instances=reuse_instances, convert_sets=convert_sets) for k, v in foo.items()}"
 
         >>> Renderer(TO_ITER).render(SeField(Tuple[str, Foo, int], 'foo'))
-        "(foo[0], foo[1].__serde__.funcs['to_iter'](foo[1], reuse_instances=reuse_instances, convert_sets=convert_sets), foo[2])"
+        "(foo[0], foo[1].__serde__.funcs['to_iter'](foo[1], reuse_instances=reuse_instances, convert_sets=convert_sets), foo[2],)"
         """
         if is_dataclass(arg.type):
             return self.dataclass(arg)
@@ -524,7 +524,7 @@ def tuple(self, arg: SeField) -> str:
                 r = arg[i]
                 r.name = f'{arg.varname}[{i}]'
                 rvalues.append(self.render(r))
-            return f"({', '.join(rvalues)})"
+            return f"({', '.join(rvalues)},)"  # trailing , is required for single element tuples
 
     def dict(self, arg: SeField) -> str:
         """
@@ -553,7 +553,7 @@ def str(self, arg: SeField) -> str:
 
     def union_func(self, arg: SeField) -> str:
         func_name = union_func_name(UNION_SE_PREFIX, type_args(arg.type))
-        return f"serde_scope.funcs['{func_name}']({arg.varname}, reuse_instances)"
+        return f"serde_scope.funcs['{func_name}']({arg.varname}, reuse_instances, convert_sets)"
 
 
 def enum_value(cls, e):

setup.py

@@ -32,6 +32,7 @@
     'pytest-flake8',
     'mypy',
     'flake8',
+    'pre-commit',
 ]
 
 setup(

tests/test_basics.py

@@ -376,6 +376,21 @@ class Nested:
         assert p == de(Nested, se(p))
 
 
+@pytest.mark.parametrize('se,de', all_formats)
+def test_single_element_tuples(se, de):
+    @deserialize
+    @serialize
+    @dataclass
+    class Foo:
+        a: Tuple[int]
+        b: Tuple[uuid.UUID]
+
+    foo = Foo(a=(1,), b=(uuid.UUID("855f07da-c3cd-46f2-9557-b8dbeb99ff42"),))
+    assert to_dict(foo) == {"a": foo.a, "b": foo.b}
+
+    assert foo == de(Foo, se(foo))
+
+
 @pytest.mark.parametrize('se,de', all_formats)
 def test_dataclass_default_factory(se, de):
     @deserialize

tests/test_union.py

@@ -1,7 +1,7 @@
 import logging
 from dataclasses import dataclass
 from ipaddress import IPv4Address
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional, Tuple, Union
 from uuid import UUID
 
 import pytest
@@ -290,3 +290,65 @@ class Foo:
 
     assert to_dict(Foo(10)) == {'BarBaz': 10}
     assert from_dict(Foo, {'BarBaz': 'foo'}) == Foo('foo')
+
+
+def test_union_with_list_of_other_class():
+    @deserialize
+    @serialize
+    @dataclass
+    class A:
+        a: int
+
+    @deserialize
+    @serialize
+    @dataclass
+    class B:
+        b: Union[List[A], str]
+
+    b = B([A(1)])
+    b_dict = {"b": [{"a": 1}]}
+    assert to_dict(b) == b_dict
+    assert from_dict(B, b_dict) == b
+
+
+# relates to https://github.com/yukinarit/pyserde/issues/113
+def test_union_with_union_in_nested_types():
+    @deserialize
+    @serialize
+    @dataclass
+    class A:
+        v: Union[UUID, List[Union[UUID, int]]]
+
+    a_uuid = A([UUID("00611ee9-7ca3-41d3-9607-ea7268e264ea")])
+    assert to_dict(a_uuid, reuse_instances=False) == {"v": ["00611ee9-7ca3-41d3-9607-ea7268e264ea"]}
+    assert a_uuid == from_dict(A, to_dict(a_uuid, reuse_instances=False), reuse_instances=False)
+    assert a_uuid == from_dict(A, to_dict(a_uuid, reuse_instances=True), reuse_instances=True)
+
+    a_int = A([1])
+    assert to_dict(a_int) == {"v": [1]}
+    assert a_int == from_dict(A, to_dict(a_int, reuse_instances=False), reuse_instances=False)
+    assert a_int == from_dict(A, to_dict(a_int, reuse_instances=True), reuse_instances=True)
+
+
+# relates to https://github.com/yukinarit/pyserde/issues/113
+def test_union_with_union_in_nested_tuple():
+    @deserialize
+    @serialize
+    @dataclass
+    class A:
+        v: Union[bool, Tuple[Union[str, int]]]
+
+    a_bool = A(False)
+    a_bool_dict = {"v": False}
+    assert to_dict(a_bool) == a_bool_dict
+    assert from_dict(A, a_bool_dict) == a_bool
+
+    a_str = A(("a",))
+    a_str_dict = {"v": ("a",)}
+    assert to_dict(a_str) == a_str_dict
+    assert from_dict(A, a_str_dict) == a_str
+
+    a_int = A((1,))
+    a_int_dict = {"v": (1,)}
+    assert to_dict(a_int) == a_int_dict
+    assert from_dict(A, a_int_dict) == a_int