fix: restore float values in nested tuple[dict] fields

Author: JohananOppongAmoateng

src/django_unicorn/serializer.py

@@ -275,7 +275,17 @@ def _fix_floats(current: dict, data: dict | None = None, paths: list | None = No
             paths.append(key)
             _fix_floats(val, data, paths=paths)
             paths.pop()
-    elif isinstance(current, list):
+    elif isinstance(current, (list, tuple)):
+        if isinstance(current, tuple) and paths:
+            # Tuples are immutable; convert to list in the parent container so
+            # we can mutate float values inside it.
+            _piece = data
+            for idx, path in enumerate(paths):
+                if idx == len(paths) - 1:
+                    _piece[path] = list(current)
+                else:
+                    _piece = _piece[path]
+            current = _piece[paths[-1]]
         for idx, item in enumerate(current):
             paths.append(idx)
             _fix_floats(item, data, paths=paths)

src/django_unicorn/typer.py

@@ -145,6 +145,25 @@ def cast_value(type_hint, value):
             # casting each item individually
             return [cast_value(arg, item) for item in value]
 
+    if get_origin(type_hint) is tuple:
+        type_args = get_args(type_hint)
+        if len(type_args) == 1:
+            # Homogeneous tuple hint like tuple[dict[str, float|str]] —
+            # the single arg applies to every element
+            arg = type_args[0]
+            return tuple(cast_value(arg, item) for item in value)
+        elif len(type_args) >= 2 and type_args[-1] is not Ellipsis:
+            # Fixed-length heterogeneous tuple: tuple[str, int, float]
+            return tuple(cast_value(t, item) for t, item in zip(type_args, value))
+
+    if get_origin(type_hint) is dict:
+        type_args = get_args(type_hint)
+        if len(type_args) == 2 and isinstance(value, dict):
+            # dict[K, V] — cast each value to the V type so that e.g.
+            # dict[str, float|str] converts string "3.4" back to float 3.4
+            value_type = type_args[1]
+            return {k: cast_value(value_type, v) for k, v in value.items()}
+
     # Handle Optional type hint and the value is None
     if type(None) in type_hints and value is None:
         return value
@@ -178,8 +197,13 @@ def cast_value(type_hint, value):
                 value = _type_hint(**value)
                 break
 
-            value = _type_hint(value)
-            break
+            try:
+                value = _type_hint(value)
+                break
+            except ValueError:
+                # float("abc") raises ValueError; continue to the next type in a
+                # Union (e.g. the `str` in float|str) before giving up.
+                continue
 
     return value
 

tests/serializer/test_dumps.py

@@ -841,3 +841,33 @@ def test_dictionary_with_int_keys_as_strings_no_sort():
     )
 
     assert expected == actual
+
+
+def test_tuple_float():
+    """Float inside a tuple is stringified for safe JS transmission (#641)."""
+    import json
+
+    actual = serializer.dumps({"ranks": ({"name": "abc", "score": 3.4},)})
+    data = json.loads(actual)
+
+    assert data["ranks"][0]["score"] == "3.4"
+
+
+def test_tuple_of_dicts_mixed_types():
+    """Multiple floats and non-floats inside a tuple of dicts are handled (#641)."""
+    import json
+
+    actual = serializer.dumps(
+        {
+            "ranks": (
+                {"name": "abc", "score": 3.4},
+                {"name": "def", "score": 1.0},
+                {"name": "ghi", "score": 5},
+            )
+        }
+    )
+    data = json.loads(actual)
+
+    assert data["ranks"][0]["score"] == "3.4"
+    assert data["ranks"][1]["score"] == "1.0"
+    assert data["ranks"][2]["score"] == 5  # int stays as int

tests/test_typer.py

@@ -170,3 +170,57 @@ def test_cast_value_list_pydantic():
     type_hint = type_hints["pydantic_list_data"]
     actual = cast_value(type_hint, [{"name": "foo"}])
     assert actual == [test_data]
+
+class ComponentWithRanks:
+    ranks: tuple[dict[str, float | str]]
+
+
+def test_cast_value_tuple_of_dicts_gh641():
+    """cast_value restores float values inside tuple[dict[str, float|str]] (#641)."""
+    type_hints = typing_get_type_hints(ComponentWithRanks)
+    type_hint = type_hints["ranks"]
+
+    # Simulates data arriving from browser: floats were stringified by _fix_floats
+    value = [{"name": "abc", "score": "3.4"}]
+    actual = cast_value(type_hint, value)
+
+    # Result must be a tuple (not a list)
+    assert isinstance(actual, tuple)
+    assert len(actual) == 1
+    # String "3.4" must be cast back to float 3.4 via the float|str value type hint
+    assert actual[0]["name"] == "abc"
+    assert actual[0]["score"] == 3.4
+    assert isinstance(actual[0]["score"], float)
+
+
+def test_cast_value_dict_float_str_gh641():
+    """cast_value casts string float values inside dict[str, float|str] (#641)."""
+    from typing import get_type_hints as typing_get_type_hints
+
+    class ComponentWithDict:
+        data: dict[str, float | str]
+
+    type_hints = typing_get_type_hints(ComponentWithDict)
+    type_hint = type_hints["data"]
+
+    actual = cast_value(type_hint, {"name": "abc", "score": "3.4"})
+
+    assert actual["name"] == "abc"
+    assert actual["score"] == 3.4
+    assert isinstance(actual["score"], float)
+
+
+class ComponentWithTupleOfDataclasses:
+    items: tuple[DataClass]
+
+
+def test_cast_value_tuple_of_dataclasses_gh641():
+    """cast_value recursively casts items inside a tuple[Dataclass] (#641)."""
+    type_hints = typing_get_type_hints(ComponentWithTupleOfDataclasses)
+    type_hint = type_hints["items"]
+
+    value = [{"name": "foo"}, {"name": "bar"}]
+    actual = cast_value(type_hint, value)
+
+    assert isinstance(actual, tuple)
+    assert actual == (DataClass(name="foo"), DataClass(name="bar"))