refactor(chunk-grids): compare RunLengthEdges only with RunLengthEdges

A `RunLengthEdges` is not a `tuple`, so `==` against one is now false
instead of an edge-by-edge comparison. This also removes the mismatch
between equality and hashing. Tests compare `tuple(edges)` or whole
metadata objects instead.

Assisted-by: ClaudeCode:claude-fable-5.1

Author: d-v-b

changes/4479.bugfix.md

@@ -1 +1 @@
-Opening an array with a rectilinear chunk grid, and indexing it, now costs time and memory proportional to the size of the grid's run-length encoded metadata rather than to its number of chunks: a stored grid such as `[[1, 1000000000000]]`, a few hundred bytes of JSON, previously took seconds per ten million chunks to open and could exhaust memory. The explicit edges in `RectilinearChunkGridMetadata.chunk_shapes` and `VaryingDimension.edges` are now held as `zarr.core.common.RunLengthEdges`, an immutable sequence that reads like the tuple of edges and compares equal to it, but is not a `tuple` instance. `VaryingDimension.cumulative` is now computed on access. The repr of a chunk grid shows a dimension of more than 100 chunks in its run-length encoded form.
+Opening an array with a rectilinear chunk grid, and indexing it, now costs time and memory proportional to the size of the grid's run-length encoded metadata rather than to its number of chunks: a stored grid such as `[[1, 1000000000000]]`, a few hundred bytes of JSON, previously took seconds per ten million chunks to open and could exhaust memory. The explicit edges in `RectilinearChunkGridMetadata.chunk_shapes` and `VaryingDimension.edges` are now held as `zarr.core.common.RunLengthEdges`, an immutable sequence of the edges that is not a `tuple` and does not compare equal to one: use `tuple(edges)` to compare against a tuple. `VaryingDimension.cumulative` is now computed on access. The repr of a chunk grid shows a dimension of more than 100 chunks in its run-length encoded form.

src/zarr/core/common.py

@@ -331,15 +331,14 @@ class RunLengthEdges(Sequence[int]):
     The sequence is held as `(size, count)` runs, with adjacent runs of the same size
     merged, so construction, lookups and prefix sums cost time and memory in the number
     of runs, not in the number of edges: `RunLengthEdges([(1, 2**40)])` is one run. It
-    reads like the tuple of edges it stands for (`len`, indexing, iteration, and `==`
-    against a `tuple`), but only iteration and the comparison with a `tuple` visit every
-    edge.
+    reads like the sequence of edges it stands for (`len`, indexing, iteration), but
+    only iteration visits every edge.
 
     Sizes are not checked here: what a valid edge length is, and how to report an invalid
     one, is up to the caller (see `parse_chunk_edge`). Each count must be at least 1.
 
-    Instances hash by their runs, so an instance does not hash like the `tuple` it
-    compares equal to.
+    It is not a `tuple` and equals only another `RunLengthEdges` with the same edges;
+    compare `tuple(edges)` against a tuple.
     """
 
     __slots__ = ("_index_stops", "_lookup_tables", "_offset_stops", "counts", "sizes")
@@ -430,10 +429,6 @@ def __getitem__(self, index: int | slice) -> int | RunLengthEdges:
     def __eq__(self, other: object) -> bool:
         if isinstance(other, RunLengthEdges):
             return self.sizes == other.sizes and self.counts == other.counts
-        if isinstance(other, tuple):
-            return len(other) == self.num_edges and all(
-                a == b for a, b in zip(self, other, strict=True)
-            )
         return NotImplemented
 
     def __hash__(self) -> int:

src/zarr/core/metadata/v3.py

@@ -314,8 +314,8 @@ class RectilinearChunkGridMetadata(Metadata):
       (the spec's single-integer shorthand).
     - A sequence of ``int`` — explicit per-chunk edge lengths. It is given
       as a ``tuple`` or a ``list`` and held as a `RunLengthEdges`, which
-      reads like the tuple of edges (and compares equal to it) but stores
-      one entry per run of equal edges, so a grid costs time and memory in
+      reads like the sequence of edges (but is not a ``tuple``, and does
+      not compare equal to one) and stores one entry per run of equal edges, so a grid costs time and memory in
       the size of its run-length encoded form, not in its number of chunks.
 
     This distinction matters for faithful round-tripping: a bare int

tests/test_chunk_grids.py

@@ -44,7 +44,7 @@ def _assert_chunks_equal(
             assert isinstance(a, VaryingDimension), (
                 f"axis {axis}: expected VaryingDimension, got {a!r}"
             )
-            assert a.edges == tuple(e), f"axis {axis}: edges {a.edges} != {tuple(e)}"
+            assert tuple(a.edges) == tuple(e), f"axis {axis}: edges {a.edges} != {tuple(e)}"
         assert a.extent == span, f"axis {axis}: extent {a.extent} != {span}"
 
 

tests/test_properties.py

@@ -618,7 +618,7 @@ def test_chunks_param_from_rectilinear_bare_int_roundtrip() -> None:
         src = zarr.create_array(MemoryStore(), shape=(3, 3), chunks=([1, 2], 1), dtype="uint8")
         grid = src.metadata.chunk_grid  # type: ignore[union-attr]
         assert isinstance(grid, RectilinearChunkGridMetadata)
-        assert grid.chunk_shapes == ((1, 2), 1)
+        assert grid == RectilinearChunkGridMetadata(chunk_shapes=((1, 2), 1))
         chunks = chunks_param_from_rectilinear(grid)
         # a list of lists, not tuples (`[1, 2] != (1, 2)`)
         assert chunks == [[1, 2], 1]
@@ -646,7 +646,7 @@ def test_rectilinear_chunk_grid_declarations(data: st.DataObject) -> None:
         "configuration": {"kind": "inline", "chunk_shapes": declaration},
     }
     meta = RectilinearChunkGridMetadata.from_dict(stored)
-    assert meta.chunk_shapes == chunk_shapes
+    assert meta == RectilinearChunkGridMetadata(chunk_shapes=chunk_shapes)
 
     serialized = json.loads(json.dumps(meta.to_dict()))
     assert serialized["name"] == "rectilinear"

tests/test_unified_chunk_grid.py

@@ -250,7 +250,7 @@ def test_fixed_dimension_rejects_invalid(size: int, extent: int, match: str) ->
 def test_varying_dimension_construction() -> None:
     """VaryingDimension stores edges, cumulative sums, nchunks, and extent correctly"""
     d = VaryingDimension([10, 20, 30], extent=60)
-    assert d.edges == (10, 20, 30)
+    assert tuple(d.edges) == (10, 20, 30)
     assert d.cumulative == (10, 30, 60)
     assert d.nchunks == 3
     assert d.extent == 60
@@ -646,7 +646,7 @@ def test_rle_expand_names_dimension(
 def test_parse_rle(rle_input: list[Any]) -> None:
     """parse_rle reads the edges expand_rle expands, as merged runs"""
     parsed = parse_rle(rle_input)
-    assert parsed == tuple(expand_rle(rle_input))
+    assert list(parsed) == expand_rle(rle_input)
     assert parsed.to_rle() == compress_rle(expand_rle(rle_input))
 
 
@@ -667,30 +667,31 @@ def test_parse_rle(rle_input: list[Any]) -> None:
     ids=["one-edge", "one-run", "mixed-runs", "no-repeats", "adjacent-equal-runs"],
 )
 def test_run_length_edges(runs: list[tuple[int, int]]) -> None:
-    """RunLengthEdges reads like the tuple of edges it encodes: length, indexing, slicing,
-    iteration, equality, prefix sums and position lookups all agree with the expanded
-    edges, and adjacent runs of one size are merged"""
+    """RunLengthEdges reads like the sequence of edges it encodes: length, indexing,
+    slicing, iteration, prefix sums and position lookups all agree with the expanded
+    edges, adjacent runs of one size are merged, and it equals only a RunLengthEdges of
+    the same edges, never the tuple of them"""
     expanded = tuple(size for size, count in runs for _ in range(count))
     offsets = (0, *itertools.accumulate(expanded))
     edges = RunLengthEdges(runs)
 
-    assert edges == expanded
+    assert edges != expanded
     assert edges == RunLengthEdges.from_edges(expanded)
     assert hash(edges) == hash(RunLengthEdges.from_edges(expanded))
-    assert edges != (*expanded, 1)
+    assert edges != RunLengthEdges.from_edges((*expanded, 1))
     assert pickle.loads(pickle.dumps(edges)) == edges
     assert all(a != b for (a, _), (b, _) in itertools.pairwise(edges.runs))
     assert len(edges) == edges.num_edges == len(expanded)
     assert edges.total == sum(expanded)
     assert tuple(edges) == expanded
     assert [edges[i] for i in range(-len(expanded), len(expanded))] == [*expanded, *expanded]
-    assert edges[1:] == expanded[1:]
-    assert edges[:-1] == expanded[:-1]
-    assert edges[::2] == expanded[::2]
+    assert tuple(edges[1:]) == expanded[1:]
+    assert tuple(edges[:-1]) == expanded[:-1]
+    assert tuple(edges[::2]) == expanded[::2]
     assert all(edges.count(size) == expanded.count(size) for size in {*expanded, 99})
     assert all((size in edges) == (size in expanded) for size in {*expanded, 99})
     assert edges.to_rle() == compress_rle(expanded)
-    assert edges.with_edge(7) == (*expanded, 7)
+    assert tuple(edges.with_edge(7)) == (*expanded, 7)
     assert [edges.offset_of(i) for i in range(len(expanded) + 1)] == list(offsets)
     positions = np.arange(-2, edges.total + 3, dtype=np.intp)
     expected_indices = np.searchsorted(offsets[1:], positions, side="right")
@@ -1352,7 +1353,7 @@ def test_mixed_scalar_and_list_dims_keep_shorthand(tmp_path: Path) -> None:
     assert isinstance(arr.metadata, ArrayV3Metadata)
     grid = arr.metadata.chunk_grid
     assert isinstance(grid, RectilinearChunkGridMetadata)
-    assert grid.chunk_shapes == (5, (10, 20, 70))
+    assert grid == RectilinearChunkGridMetadata(chunk_shapes=(5, (10, 20, 70)))
 
 
 # The chunk/shard spec matrix for `from_array` round-trip tests. Every kind of
@@ -1599,7 +1600,7 @@ def test_from_array_keep_is_o1_in_chunk_count() -> None:
     dst = zarr.from_array(MemoryStore(), data=src, name="0", write_data=False)
     grid = dst.metadata.chunk_grid
     assert isinstance(grid, RectilinearChunkGridMetadata)
-    assert grid.chunk_shapes == (3, (10, 20))
+    assert grid == RectilinearChunkGridMetadata(chunk_shapes=(3, (10, 20)))
 
 
 @pytest.mark.parametrize(
@@ -1624,7 +1625,7 @@ def test_resize_uniform_rectilinear_appends_edge(
     assert isinstance(rect.metadata, ArrayV3Metadata)
     rect_grid = rect.metadata.chunk_grid
     assert isinstance(rect_grid, RectilinearChunkGridMetadata)
-    assert rect_grid.chunk_shapes == ((10, 10, 10, 15),)
+    assert rect_grid == RectilinearChunkGridMetadata(chunk_shapes=((10, 10, 10, 15),))
     assert rect.nchunks == 4
     # the appended region is exactly the new edge chunk
     rect[30:45] = 1
@@ -2770,7 +2771,7 @@ def test_update_shape_shrink_creates_boundary() -> None:
     new_grid = grid.update_shape((45,))
     dim = new_grid._dimensions[0]
     assert isinstance(dim, VaryingDimension)
-    assert dim.edges == (10, 20, 30)
+    assert tuple(dim.edges) == (10, 20, 30)
     assert dim.extent == 45
     assert dim.chunk_size(2) == 30
     assert dim.data_size(2) == 15
@@ -2782,7 +2783,7 @@ def test_update_shape_shrink_to_exact_boundary() -> None:
     new_grid = grid.update_shape((30,))
     dim = new_grid._dimensions[0]
     assert isinstance(dim, VaryingDimension)
-    assert dim.edges == (10, 20, 30)
+    assert tuple(dim.edges) == (10, 20, 30)
     assert dim.nchunks == 2
     assert dim.ngridcells == 3
     assert dim.extent == 30
@@ -3314,7 +3315,7 @@ def test_rectilinear_from_dict(
 ) -> None:
     """RectilinearChunkGridMetadata.from_dict correctly parses all spec forms."""
     grid = RectilinearChunkGridMetadata.from_dict(json_input)
-    assert grid.chunk_shapes == expected_chunk_shapes
+    assert grid == RectilinearChunkGridMetadata(chunk_shapes=expected_chunk_shapes)
 
 
 @pytest.mark.parametrize(