Fix IOType.__hash__ TypeError for unhashable wrapped values

The base ``IOType.__hash__`` does ``hash((type(self), self._value))``, which
raises ``TypeError`` when ``_value`` is inherently unhashable — a dict
wrapped by ``Json({...})`` or a dataclass with mutable fields (``list``,
``dict``) wrapped by ``Struct(...)``. Both are the primary ways users
create instances of these types, so the wrapper ends up mis-behaving in
any set/dict or cache keyed by artifacts.

Override ``__hash__`` on both subclasses to hash the canonical JSON
representation (already produced by the wire/storage path). This is:

- Stable — ``sort_keys=True`` makes the JSON deterministic across equal
  dicts/dataclasses regardless of key insertion order.
- Contract-safe — ``__eq__`` compares raw values; equal values flatten to
  identical sorted-key JSON, so ``a == b`` implies ``hash(a) == hash(b)``.
- Descriptor-aware — when ``_value is _UNSET`` (no value, pure type
  descriptor), fall back to hashing the sentinel directly.

Adds regression tests covering ``Json({...})``, ``Json([...])``,
``Struct(dc_with_list)``, plain ``Struct({...})``, and the ``Struct()``
descriptor.

Author: Saeid Barati

metaflow/io_types/json_type.py

@@ -1,7 +1,7 @@
 import json
 
 from ..datastore.artifacts.serializer import SerializedBlob
-from .base import IOType
+from .base import IOType, _UNSET
 
 
 class Json(IOType):
@@ -25,3 +25,13 @@ def _storage_serialize(self):
     @classmethod
     def _storage_deserialize(cls, blobs, **kwargs):
         return cls(json.loads(blobs[0].decode("utf-8")))
+
+    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).
+        if self._value is _UNSET:
+            return hash((type(self), _UNSET))
+        return hash((type(self), self._wire_serialize()))

metaflow/io_types/struct_type.py

@@ -140,3 +140,19 @@ def _storage_deserialize(cls, blobs, **kwargs):
             return cls(_reconstruct(dc_type, data), dataclass_type=dc_type)
         # Fallback: return as plain dict wrapped in Struct
         return cls(data)
+
+    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).
+        if self._value is _UNSET:
+            return hash((type(self), _UNSET))
+        return hash(
+            (
+                type(self),
+                json.dumps(self._to_dict(), separators=(",", ":"), sort_keys=True),
+            )
+        )

test/unit/io_types/test_json_type.py

@@ -47,3 +47,29 @@ def test_json_deeply_nested():
     s = j.serialize(format="wire")
     j2 = Json.deserialize(s, format="wire")
     assert j2.value == data
+
+
+def test_json_hashable_with_dict_value():
+    """Json wrapping a dict must be hashable. The base class default
+    ``hash((type(self), self._value))`` raises TypeError for unhashable
+    values, so Json overrides it with a wire-format-based hash.
+    """
+    j = Json({"a": 1, "b": [2, 3]})
+    # No TypeError.
+    h = hash(j)
+    assert isinstance(h, int)
+
+    # Equal values must hash equal — even when insertion order differs.
+    j2 = Json({"b": [2, 3], "a": 1})
+    assert j == j2
+    assert hash(j) == hash(j2)
+
+    # Works inside a set.
+    assert {Json({"x": 1}), Json({"x": 1})} == {Json({"x": 1})}
+
+
+def test_json_hashable_with_list_value():
+    j = Json([1, 2, 3])
+    h = hash(j)
+    assert isinstance(h, int)
+    assert hash(Json([1, 2, 3])) == hash(j)

test/unit/io_types/test_struct_type.py

@@ -179,6 +179,38 @@ def test_struct_plain_dict_value():
     assert s2.value == {"x": 1, "y": "hello"}
 
 
+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.
+    """
+
+    @dataclass
+    class WithList:
+        x: int
+        items: list = dataclasses.field(default_factory=list)
+
+    s = Struct(WithList(x=1, items=[1, 2, 3]))
+    h = hash(s)
+    assert isinstance(h, int)
+
+    # Hash/eq contract: equal values hash equal.
+    s2 = Struct(WithList(x=1, items=[1, 2, 3]))
+    assert s == s2
+    assert hash(s) == hash(s2)
+
+    # Wrapping a plain dict also hashes without TypeError.
+    s3 = Struct({"a": [1, 2], "b": {"nested": True}})
+    assert isinstance(hash(s3), int)
+
+
+def test_struct_descriptor_is_hashable():
+    """Struct() (no value) must still be hashable via the _UNSET sentinel."""
+    s = Struct()
+    assert isinstance(hash(s), int)
+
+
 def test_struct_descriptor_uses_unset_sentinel():
     """Struct() (no value) must behave as a pure descriptor via the same
     _UNSET sentinel the base IOType uses. Two empty descriptors should be