Harden P1 fixes: frozen dataclasses + numeric hash equivalence

Self-review before pushing caught two subtle regressions in the prior two
commits:

1. ``_reconstruct`` used plain ``setattr`` to restore ``init=False`` fields
   after construction, which raises ``FrozenInstanceError`` on
   ``@dataclass(frozen=True)``. Switch to ``object.__setattr__`` — the same
   bypass frozen dataclasses themselves use in ``__post_init__``.

2. ``Json.__hash__`` / ``Struct.__hash__`` hashed the canonical JSON string.
   That renders ``1`` and ``1.0`` as distinct strings, violating the
   ``__eq__`` / ``__hash__`` contract when users mix numeric types
   (``1 == 1.0 == True`` in Python, but ``hash('1') != hash('1.0')``).
   Replace with a recursive ``_make_hashable`` that converts dicts to
   ``frozenset`` of items and lists to ``tuple``s. Python's built-in
   hashing then collapses ``1 == 1.0 == True`` to the same bucket, and
   equal wrapped values produce equal hashes.

``_make_hashable`` lives in ``base.py`` so any future IOType wrapping
unhashable values can reuse it.

Regression tests added for:
- Frozen dataclass with ``init=False`` field round-trip.
- ``Json({'x': 1}) == Json({'x': 1.0})`` and ``hash()`` equality.
- Same for ``Struct({'x': 1})`` / ``Struct({'x': 1.0})``.
- ``Json({'x': True}) == Json({'x': 1})`` hash equality.
- ``Json([1, 2, 3]) == Json([1.0, 2.0, 3.0])`` hash equality.

Author: Saeid Barati

metaflow/io_types/base.py

@@ -39,6 +39,27 @@ def get_iotype_by_name(type_name):
     return _TYPE_REGISTRY.get(type_name)
 
 
+def _make_hashable(value):
+    """
+    Recursively convert a JSON-like value to a hashable form.
+
+    dicts -> frozenset of (key, hashable(value)) pairs.
+    lists -> tuple of hashable elements.
+    Everything else assumed hashable (int, float, bool, str, None, ...).
+
+    Using ``frozenset``/``tuple`` preserves Python's numeric equivalence
+    (``1 == 1.0 == True`` -> equal hashes) that ``json.dumps`` would
+    otherwise break by rendering each as a distinct string. This keeps the
+    ``__eq__`` / ``__hash__`` contract intact when IOType subclasses delegate
+    value equality to the wrapped Python object.
+    """
+    if isinstance(value, dict):
+        return frozenset((k, _make_hashable(v)) for k, v in value.items())
+    if isinstance(value, list):
+        return tuple(_make_hashable(v) for v in value)
+    return value
+
+
 class IOType(object, metaclass=ABCMeta):
     """
     Base class for typed Metaflow artifacts.

metaflow/io_types/json_type.py

@@ -1,7 +1,7 @@
 import json
 
 from ..datastore.artifacts.serializer import SerializedBlob
-from .base import IOType, _UNSET
+from .base import IOType, _UNSET, _make_hashable
 
 
 class Json(IOType):
@@ -28,10 +28,10 @@ def _storage_deserialize(cls, blobs, **kwargs):
 
     def __hash__(self):
         # ``_value`` is typically a dict or list (unhashable), so the base
-        # class ``hash((type, _value))`` raises TypeError. Hash the canonical
-        # JSON representation instead — stable across equal values and
-        # consistent with ``__eq__`` (which compares ``_value`` directly:
-        # equal dicts/lists produce identical sorted-key JSON).
+        # class ``hash((type, _value))`` raises TypeError. Convert to a
+        # frozenset/tuple form that preserves Python's numeric equivalence
+        # (``1 == 1.0 == True`` hash identically), so ``__eq__`` and
+        # ``__hash__`` stay consistent even when users mix int/float/bool.
         if self._value is _UNSET:
             return hash((type(self), _UNSET))
-        return hash((type(self), self._wire_serialize()))
+        return hash((type(self), _make_hashable(self._value)))

metaflow/io_types/struct_type.py

@@ -4,7 +4,7 @@
 import typing
 
 from ..datastore.artifacts.serializer import SerializedBlob
-from .base import IOType, _UNSET
+from .base import IOType, _UNSET, _make_hashable
 
 
 def _reconstruct(dc_type, data):
@@ -18,7 +18,8 @@ def _reconstruct(dc_type, data):
 
     Fields declared with ``field(init=False, ...)`` are not accepted by the
     generated ``__init__``, but ``dataclasses.asdict`` emits them. Pass only
-    init-eligible fields as kwargs, then ``setattr`` the remainder so the
+    init-eligible fields as kwargs, then assign the remainder via
+    ``object.__setattr__`` (which works on frozen dataclasses too) so the
     serialized values are not lost to defaults or ``__post_init__``.
     """
     try:
@@ -45,8 +46,11 @@ def _reconstruct(dc_type, data):
         else:
             post_init_fields.append((f.name, value))
     instance = dc_type(**kwargs)
+    # ``object.__setattr__`` bypasses ``@dataclass(frozen=True)``'s lock,
+    # matching the pattern frozen dataclasses themselves use to populate
+    # ``init=False`` fields inside ``__post_init__``.
     for name, value in post_init_fields:
-        setattr(instance, name, value)
+        object.__setattr__(instance, name, value)
     return instance
 
 
@@ -144,15 +148,10 @@ def _storage_deserialize(cls, blobs, **kwargs):
     def __hash__(self):
         # ``_value`` is typically a dataclass instance or dict (often
         # unhashable), so the base class ``hash((type, _value))`` raises
-        # TypeError. Hash the canonical JSON representation of the flattened
-        # value instead — stable across equal values and consistent with
-        # ``__eq__`` (equal dataclasses/dicts flatten to identical sorted-key
-        # JSON).
+        # TypeError. Flatten to a dict via ``_to_dict`` then convert to a
+        # frozenset/tuple form that preserves Python's numeric equivalence
+        # (``1 == 1.0 == True`` hash identically), so ``__eq__`` and
+        # ``__hash__`` stay consistent for mixed-type fields.
         if self._value is _UNSET:
             return hash((type(self), _UNSET))
-        return hash(
-            (
-                type(self),
-                json.dumps(self._to_dict(), separators=(",", ":"), sort_keys=True),
-            )
-        )
+        return hash((type(self), _make_hashable(self._to_dict())))

test/unit/io_types/test_json_type.py

@@ -73,3 +73,24 @@ def test_json_hashable_with_list_value():
     h = hash(j)
     assert isinstance(h, int)
     assert hash(Json([1, 2, 3])) == hash(j)
+
+
+def test_json_hash_preserves_numeric_equivalence():
+    """``1 == 1.0 == True`` in Python — equal dicts must hash equal even
+    when they mix numeric types. A naive JSON-string hash renders ``1``
+    and ``1.0`` as distinct strings and violates the hash/eq contract.
+    """
+    a = Json({"x": 1})
+    b = Json({"x": 1.0})
+    assert a == b
+    assert hash(a) == hash(b)
+
+    c = Json({"x": True})
+    d = Json({"x": 1})
+    assert c == d
+    assert hash(c) == hash(d)
+
+    e = Json([1, 2, 3])
+    f = Json([1.0, 2.0, 3.0])
+    assert e == f
+    assert hash(e) == hash(f)

test/unit/io_types/test_struct_type.py

@@ -41,6 +41,16 @@ def __post_init__(self):
         self.computed = self.a * 10
 
 
+@dataclass(frozen=True)
+class FrozenWithInitFalse:
+    a: int
+    computed: int = dataclasses.field(init=False, default=0)
+
+    def __post_init__(self):
+        # Frozen dataclasses must use object.__setattr__ to touch fields.
+        object.__setattr__(self, "computed", self.a * 10)
+
+
 def test_struct_wire_round_trip():
     s = Struct(SimpleData(name="test", count=5, score=3.14, active=True))
     wire = s.serialize(format="wire")
@@ -179,11 +189,28 @@ def test_struct_plain_dict_value():
     assert s2.value == {"x": 1, "y": "hello"}
 
 
+def test_struct_frozen_dataclass_with_init_false_field_round_trip():
+    """Frozen dataclasses reject plain ``setattr``. Reconstructing one with
+    an ``init=False`` field must use ``object.__setattr__`` so the
+    serialized value survives, matching how frozen dataclasses initialize
+    such fields in their own ``__post_init__``.
+    """
+    original = FrozenWithInitFalse(a=7)
+    assert original.computed == 70
+
+    s = Struct(original)
+    blobs, meta = s.serialize(format="storage")
+    s2 = Struct.deserialize([b.value for b in blobs], format="storage", metadata=meta)
+    assert type(s2.value) is FrozenWithInitFalse
+    assert s2.value.a == 7
+    assert s2.value.computed == 70
+
+
 def test_struct_hashable_with_unhashable_dataclass():
     """Struct wrapping a dataclass with mutable fields (list, dict) must be
     hashable. The base ``hash((type, _value))`` raises TypeError because
     dataclasses with mutable fields are unhashable; Struct overrides
-    ``__hash__`` with a canonical-JSON-based hash.
+    ``__hash__`` via ``_make_hashable``.
     """
 
     @dataclass
@@ -205,6 +232,18 @@ class WithList:
     assert isinstance(hash(s3), int)
 
 
+def test_struct_hash_preserves_numeric_equivalence():
+    """Same contract as Json: equal dicts with int/float/bool members must
+    hash equal. Confirms the frozenset/tuple based ``_make_hashable`` is
+    used (not ``json.dumps``, which would render ``1`` and ``1.0`` as
+    distinct strings).
+    """
+    s_int = Struct({"x": 1})
+    s_float = Struct({"x": 1.0})
+    assert s_int == s_float
+    assert hash(s_int) == hash(s_float)
+
+
 def test_struct_descriptor_is_hashable():
     """Struct() (no value) must still be hashable via the _UNSET sentinel."""
     s = Struct()