Fix using Optional in named tuples

Fatal1ty · Mar 20, 2022 · 15d002e · 15d002e
1 parent a40ac29
commit 15d002e
Show file tree

Hide file tree

Showing 3 changed files with 33 additions and 6 deletions.
diff --git a/mashumaro/core/meta/builder.py b/mashumaro/core/meta/builder.py
@@ -1726,6 +1726,7 @@ def _pack_named_tuple(
                 parent,
                 f"{value_name}[{idx}]",
                 metadata=metadata,
+                could_be_none=True,
             )
             packers.append(packer)
         if as_dict:
@@ -1762,6 +1763,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
@@ -228,6 +228,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,
@@ -1241,18 +1242,37 @@ def test_tuple_with_optional():
     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({"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]}
+    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({"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]}
+    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]}