Merge branch 'fix-optional-inside-tuple'

Fatal1ty · Apr 15, 2022 · 8ab5856 · 8ab5856
2 parents 9c03c74 + 5ffab59
commit 8ab5856
Show file tree

Hide file tree

Showing 3 changed files with 97 additions and 0 deletions.
diff --git a/mashumaro/core/meta/builder.py b/mashumaro/core/meta/builder.py
@@ -1554,6 +1554,7 @@ def _pack_tuple(self, fname, value_name, args, parent, metadata) -> str:
                 parent,
                 value_name,
                 metadata=metadata,
+                could_be_none=True,
             )
             return f"[{packer} for value in value]"
         else:
@@ -1564,6 +1565,7 @@ def _pack_tuple(self, fname, value_name, args, parent, metadata) -> str:
                     parent,
                     f"{value_name}[{arg_idx}]",
                     metadata=metadata,
+                    could_be_none=True,
                 )
                 for arg_idx, arg_type in enumerate(args)
             ]
@@ -1581,6 +1583,7 @@ def _unpack_tuple(self, fname, value_name, args, parent, metadata) -> str:
                 parent,
                 value_name,
                 metadata=metadata,
+                could_be_none=True,
             )
             return f"tuple([{unpacker} for value in value])"
         else:
@@ -1591,6 +1594,7 @@ def _unpack_tuple(self, fname, value_name, args, parent, metadata) -> str:
                     parent,
                     f"{value_name}[{arg_idx}]",
                     metadata=metadata,
+                    could_be_none=True,
                 )
                 for arg_idx, arg_type in enumerate(args)
             ]
@@ -1622,6 +1626,7 @@ def _pack_typed_dict(
                     parent,
                     f"{value_name}['{key}']",
                     metadata=metadata,
+                    could_be_none=True,
                 )
                 lines.append(f"d['{key}'] = {packer}")
             for key in sorted(optional_keys, key=all_keys.index):
@@ -1634,6 +1639,7 @@ def _pack_typed_dict(
                         parent,
                         "key_value",
                         metadata=metadata,
+                        could_be_none=True,
                     )
                     lines.append(f"d['{key}'] = {packer}")
             lines.append("return d")
@@ -1674,6 +1680,7 @@ def _unpack_typed_dict(
                     parent,
                     f"{value_name}['{key}']",
                     metadata=metadata,
+                    could_be_none=True,
                 )
                 lines.append(f"d['{key}'] = {unpacker}")
             for key in sorted(optional_keys, key=all_keys.index):
@@ -1686,6 +1693,7 @@ def _unpack_typed_dict(
                         parent,
                         "key_value",
                         metadata=metadata,
+                        could_be_none=True,
                     )
                     lines.append(f"d['{key}'] = {unpacker}")
             lines.append("return d")
@@ -1722,6 +1730,7 @@ def _pack_named_tuple(
                 parent,
                 f"{value_name}[{idx}]",
                 metadata=metadata,
+                could_be_none=True,
             )
             packers.append(packer)
         if as_dict:
@@ -1758,6 +1767,7 @@ def _unpack_named_tuple(
                 parent,
                 f"{value_name}[{idx}]",
                 metadata=metadata,
+                could_be_none=True,
             )
             unpackers.append(unpacker)
 

diff --git a/tests/entities.py b/tests/entities.py
@@ -218,6 +218,16 @@ class TypedDictRequiredAndOptionalKeys(TypedDictRequiredKeys, total=False):
     str: str
 
 
+class TypedDictRequiredKeysWithOptional(TypedDict):
+    x: Optional[int]
+    y: int
+
+
+class TypedDictOptionalKeysWithOptional(TypedDict, total=False):
+    x: Optional[int]
+    y: float
+
+
 class MyNamedTuple(NamedTuple):
     i: int
     f: float
@@ -228,6 +238,11 @@ class MyNamedTupleWithDefaults(NamedTuple):
     f: float = 2.0
 
 
+class MyNamedTupleWithOptional(NamedTuple):
+    i: Optional[int]
+    f: int
+
+
 MyUntypedNamedTuple = namedtuple("MyUntypedNamedTuple", ("i", "f"))
 
 

diff --git a/tests/test_data_types.py b/tests/test_data_types.py
@@ -72,6 +72,7 @@
     MyIntFlag,
     MyNamedTuple,
     MyNamedTupleWithDefaults,
+    MyNamedTupleWithOptional,
     MyStrEnum,
     MyUntypedNamedTuple,
     SerializableTypeDataClass,
@@ -82,8 +83,10 @@
     TIntStr,
     TMyDataClass,
     TypedDictOptionalKeys,
+    TypedDictOptionalKeysWithOptional,
     TypedDictRequiredAndOptionalKeys,
     TypedDictRequiredKeys,
+    TypedDictRequiredKeysWithOptional,
 )
 from .utils import same_types
 
@@ -1234,3 +1237,72 @@ class Config(BaseConfig):
     instance = DataClass("a", MyStr("b"))
     assert DataClass.from_dict({"x": "str_a", "y": "MyStr_b"}) == instance
     assert instance.to_dict() == {"x": "str_a", "y": "MyStr_b"}
+
+
+def test_tuple_with_optional():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: Tuple[Optional[int], int] = field(default_factory=lambda: (None, 7))
+
+    assert DataClass.from_dict({"x": [None, 42]}) == DataClass((None, 42))
+    assert DataClass((None, 42)).to_dict() == {"x": [None, 42]}
+    assert DataClass.from_dict({}) == DataClass((None, 7))
+    assert DataClass().to_dict() == {"x": [None, 7]}
+
+
+def test_tuple_with_optional_and_ellipsis():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: Tuple[Optional[int], ...] = field(default_factory=lambda: (None, 7))
+
+    assert DataClass.from_dict({"x": [None, 42]}) == DataClass((None, 42))
+    assert DataClass((None, 42)).to_dict() == {"x": [None, 42]}
+    assert DataClass.from_dict({}) == DataClass((None, 7))
+    assert DataClass().to_dict() == {"x": [None, 7]}
+
+
+def test_named_tuple_with_optional():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: MyNamedTupleWithOptional = field(
+            default_factory=lambda: MyNamedTupleWithOptional(None, 7)
+        )
+
+    assert DataClass.from_dict({"x": [None, 42]}) == DataClass(
+        MyNamedTupleWithOptional(None, 42)
+    )
+    assert DataClass(MyNamedTupleWithOptional(None, 42)).to_dict() == {
+        "x": [None, 42]
+    }
+    assert DataClass.from_dict({}) == DataClass(
+        MyNamedTupleWithOptional(None, 7)
+    )
+    assert DataClass().to_dict() == {"x": [None, 7]}
+
+
+def test_typed_dict_required_keys_with_optional():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: TypedDictRequiredKeysWithOptional
+
+    obj = DataClass({"x": None, "y": 42})
+    assert DataClass.from_dict({"x": {"x": None, "y": 42}}) == obj
+    assert obj.to_dict() == {"x": {"x": None, "y": 42}}
+
+    obj = DataClass({"x": 33, "y": 42})
+    assert DataClass.from_dict({"x": {"x": 33, "y": 42}}) == obj
+    assert obj.to_dict()
+
+
+def test_typed_dict_optional_keys_with_optional():
+    @dataclass
+    class DataClass(DataClassDictMixin):
+        x: TypedDictOptionalKeysWithOptional
+
+    obj = DataClass({"x": None, "y": 42})
+    assert DataClass.from_dict({"x": {"x": None, "y": 42}}) == obj
+    assert obj.to_dict() == {"x": {"x": None, "y": 42}}
+
+    obj = DataClass({"x": 33, "y": 42})
+    assert DataClass.from_dict({"x": {"x": 33, "y": 42}}) == obj
+    assert obj.to_dict()