fix: keep NoneType argument when serializing typing generics

haystack/utils/type_serialization.py

@@ -75,10 +75,14 @@ def serialize_type(target: Any) -> str:
         # This avoids issues with Python's internal cache, where List[Union[str, int]] and List[str | int] are treated
         # as the same key. GenericAlias (builtins like list[...]) can keep the PEP 604 syntax.
         is_typing_generic = not isinstance(target, GenericAlias)
+        # Optional[X] is normalized by Python to Union[X, None]; the trailing None is already implied by the
+        # "Optional" name, so we drop it. For any other generic (e.g. Dict[str, None], Tuple[int, None] or a
+        # Union with more than two members) NoneType is a regular argument and must be kept.
+        skip_nonetype = name == "Optional"
         args_str = ", ".join(
             serialize_type(Union[tuple(get_args(a))] if is_typing_generic and isinstance(a, UnionType) else a)  # noqa: UP007
             for a in args
-            if a is not NoneType
+            if not (skip_nonetype and a is NoneType)
         )
         return f"{module_name}.{name}[{args_str}]" if module_name else f"{name}[{args_str}]"
 

releasenotes/notes/fix-serialize-type-nonetype-arg-444581c0b19217a7.yaml

@@ -0,0 +1,8 @@
+---
+fixes:
+  - |
+    Fixed `serialize_type` dropping `NoneType` when it appears as a regular argument of a `typing` generic.
+    Types such as `typing.Dict[str, None]`, `typing.Tuple[int, None]`, `typing.List[None]` and unions with more
+    than two members like `typing.Union[str, int, None]` were serialized incorrectly (for example to
+    `typing.Dict[str]`), which produced malformed type strings that could not be deserialized again.
+    `typing.Optional[X]` is still serialized as `typing.Optional[X]` without a redundant trailing `None`.

test/utils/test_type_serialization.py

@@ -195,6 +195,31 @@ def test_output_type_deserialization_nested():
     assert deserialize_type("list[dict[str, int] | None]") == list[Union[dict[str, int], None]]
 
 
+def test_output_type_serialization_typing_generic_with_nonetype():
+    # NoneType used as a regular argument of a typing generic (not the implicit None of Optional)
+    # must be kept, otherwise the serialized type is malformed (e.g. "typing.Dict[str]") or loses information.
+    assert serialize_type(Dict[str, type(None)]) == "typing.Dict[str, None]"
+    assert serialize_type(Dict[type(None), str]) == "typing.Dict[None, str]"
+    assert serialize_type(Tuple[int, type(None)]) == "typing.Tuple[int, None]"
+    assert serialize_type(List[type(None)]) == "typing.List[None]"
+    # A Union with more than two members that includes None must keep None as well.
+    assert serialize_type(Union[str, int, None]) == "typing.Union[str, int, None]"
+    # Optional must still be serialized without a redundant trailing None.
+    assert serialize_type(Optional[str]) == "typing.Optional[str]"
+
+
+def test_output_type_round_trip_typing_generic_with_nonetype():
+    for type_ in [
+        Dict[str, type(None)],
+        Dict[type(None), str],
+        Tuple[int, type(None)],
+        List[type(None)],
+        Union[str, int, None],
+        Optional[str],
+    ]:
+        assert deserialize_type(serialize_type(type_)) == type_
+
+
 def test_output_type_serialization_haystack_dataclasses():
     # typing
     # Answer