Remove dead code

Author: maxrjones

docs/design/chunk-grid.md

@@ -44,7 +44,7 @@ Prior iterations on the chunk grid design were based on the Zarr V3 spec's defin
 
 1. **A chunk grid is a concrete arrangement of chunks.** Not an abstract tiling pattern. This means that the chunk grid is bound to specific array dimensions, which enables the chunk grid to answer any question about any chunk (offset, size, count) without external parameters.
 2. **One implementation, multiple serialization forms.** A single `ChunkGrid` class handles all chunking logic. The serialization format (`"regular"` vs `"rectilinear"`) is chosen by the metadata layer, not the grid.
-3. **No chunk grid registry.** Simple name-based dispatch in `parse_chunk_grid()`.
+3. **No chunk grid registry.** Simple name-based dispatch in the metadata layer's `parse_chunk_grid()`.
 4. **Fixed vs Varying per dimension.** `FixedDimension(size, extent)` for uniform chunks; `VaryingDimension(edges, extent)` for per-chunk edge lengths with precomputed prefix sums. Avoids expanding regular dimensions into lists of identical values.
 5. **Transparent transitions.** Operations like `resize()` can move an array from regular to rectilinear chunking.
 
@@ -274,15 +274,15 @@ When `extent < sum(edges)`, the dimension is always stored as `VaryingDimension`
 {"name": "rectilinear", "configuration": {"kind": "inline", "chunk_shapes": [[10, 20, 30], [[25, 4]]]}}
 ```
 
-Both names deserialize to the same `ChunkGrid` class. The serialized form does not include the array extent — that comes from `shape` in array metadata and is passed to `parse_chunk_grid()` at construction time.
+Both names deserialize to the same `ChunkGrid` class. The serialized form does not include the array extent — that comes from `shape` in array metadata and is combined with the chunk grid when constructing a behavioral `ChunkGrid` via `ChunkGrid.from_metadata()`.
 
-**The `ChunkGrid` does not serialize itself.** The format choice (`"regular"` vs `"rectilinear"`) belongs to `ArrayV3Metadata`. The name is inferred from the chunk grid metadata DTO type (`RegularChunkGrid` → `"regular"`, `RectilinearChunkGrid` → `"rectilinear"`) or from `grid.is_regular` when a behavioral `ChunkGrid` is passed directly.
+**The `ChunkGrid` does not serialize itself.** The format choice (`"regular"` vs `"rectilinear"`) belongs to `ArrayV3Metadata`. Serialization and deserialization are handled by the metadata-layer chunk grid classes (`RegularChunkGrid` and `RectilinearChunkGrid` in `metadata/v3.py`), which provide `to_dict()` and `from_dict()` methods.
 
 For `create_array`, the format is inferred from the `chunks` argument: a flat tuple produces `"regular"`, a nested list produces `"rectilinear"`. The `_is_rectilinear_chunks()` helper detects nested sequences like `[[10, 20], [5, 5]]`.
 
 ##### Rectilinear spec compliance
 
-The rectilinear format requires `"kind": "inline"` (validated by `_validate_rectilinear_kind()`). Per the spec, each element of `chunk_shapes` can be:
+The rectilinear format requires `"kind": "inline"` (validated by `validate_rectilinear_kind()`). Per the spec, each element of `chunk_shapes` can be:
 
 - A bare integer `m`: repeated until `sum >= array_extent`
 - A list of bare integers: explicit per-chunk sizes
@@ -291,13 +291,13 @@ The rectilinear format requires `"kind": "inline"` (validated by `_validate_rect
 RLE compression is used when serializing: runs of identical sizes become `[value, count]` pairs, singletons stay as bare integers.
 
 ```python
-# _compress_rle([10, 10, 10, 5]) -> [[10, 3], 5]
-# _expand_rle([[10, 3], 5])      -> [10, 10, 10, 5]
+# compress_rle([10, 10, 10, 5]) -> [[10, 3], 5]
+# expand_rle([[10, 3], 5])      -> [10, 10, 10, 5]
 ```
 
-For `FixedDimension` serialized as rectilinear, `_serialize_fixed_dim()` returns the bare integer `dim.size`. Per the rectilinear spec, a bare integer is repeated until the sum >= extent, preserving the full codec buffer size for boundary chunks.
+For a single-element `chunk_shapes` tuple like `(10,)`, `RectilinearChunkGrid.to_dict()` serializes it as a bare integer `10`. Per the rectilinear spec, a bare integer is repeated until the sum >= extent, preserving the full codec buffer size for boundary chunks.
 
-**Zero-extent handling:** Regular grids serialize zero-extent dimensions without issue (the format encodes only `chunk_shape`, no edges). Rectilinear grids reject zero-extent dimensions because the spec requires at least one positive-integer edge length per axis. This asymmetry is intentional and spec-compliant — documented in `serialize_chunk_grid()`.
+**Zero-extent handling:** Regular grids serialize zero-extent dimensions without issue (the format encodes only `chunk_shape`, no edges). Rectilinear grids cannot represent zero-extent dimensions because the spec requires at least one positive-integer edge length per axis.
 
 #### read_chunk_sizes / write_chunk_sizes
 
@@ -418,7 +418,7 @@ Level 3 — Shard index: ceil(shard_dim / subchunk_dim) entries per dimension
 
 The chunk grid is a concrete arrangement, not an abstract tiling pattern. A finite collection naturally has an extent. Storing it enables `__getitem__`, eliminates `dim_len` parameters from every method, and makes the grid self-describing.
 
-This does *not* mean `ArrayV3Metadata.shape` should delegate to the grid. The array shape remains an independent field in metadata. The extent is passed into the grid at construction time so it can answer boundary questions without external parameters. It is **not** serialized as part of the chunk grid JSON — it comes from the `shape` field in array metadata and is passed to `parse_chunk_grid()`.
+This does *not* mean `ArrayV3Metadata.shape` should delegate to the grid. The array shape remains an independent field in metadata. The extent is passed into the grid at construction time so it can answer boundary questions without external parameters. It is **not** serialized as part of the chunk grid JSON — it comes from the `shape` field in array metadata and is combined with the chunk grid configuration in `ChunkGrid.from_metadata()`.
 
 ### Why distinguish chunk_size from data_size?
 
@@ -466,7 +466,7 @@ The resolution:
 
 @d-v-b raised in #3534 that users need a way to say "these chunks are regular, but serialize as rectilinear" (e.g., to allow future append/extend workflows without format changes). @jhamman initially made nested-list input always produce `RectilinearChunkGrid`.
 
-The current branch resolves this via `_infer_chunk_grid_name()`, which extracts or infers the serialization name from the chunk grid input. When metadata is deserialized, the original name (from `{"name": "regular"}` or `{"name": "rectilinear"}`) flows through to `serialize_chunk_grid()` at write time. When a `ChunkGrid` is passed directly, the name is inferred from `grid.is_regular`. Current inference behavior:
+The current branch resolves this via the metadata-layer chunk grid classes. When metadata is deserialized, the original name (from `{"name": "regular"}` or `{"name": "rectilinear"}`) determines which metadata class is instantiated (`RegularChunkGrid` or `RectilinearChunkGrid`), and that class handles serialization via `to_dict()`. Current inference behavior for `create_array`:
 - `chunks=(10, 20)` (flat tuple) → infers `"regular"`
 - `chunks=[[10, 20], [5, 5]]` (nested lists with varying sizes) → infers `"rectilinear"`
 - `chunks=[[10, 10], [20, 20]]` (nested lists with uniform sizes) → `from_rectilinear` collapses to `FixedDimension`, so `is_regular=True` and infers `"regular"`
@@ -498,7 +498,7 @@ The current implementation partially realizes this separation:
 
 This means `ArrayV3Metadata.chunk_grid` is now a `ChunkGridMetadata` (the DTO union type), **not** the behavioral `ChunkGrid`. Code that previously accessed behavioral methods on `metadata.chunk_grid` (e.g., `all_chunk_coords()`, `__getitem__`) must now use the behavioral grid from the array layer instead.
 
-The name controls serialization format; `serialize_chunk_grid()` is called by `ArrayV3Metadata.to_dict()`. The behavioral grid handles all runtime queries.
+The name controls serialization format; each metadata DTO class provides its own `to_dict()` method for serialization. The behavioral grid handles all runtime queries.
 
 ## Prior art
 
@@ -569,10 +569,9 @@ If the design is accepted, the POC branch can be split into 5 incremental PRs. P
 - Zero changes to existing code
 
 **PR 2: Unified ChunkGrid class + serialization** (replaces hierarchy)
-- `ChunkGrid` with `from_regular`, `from_rectilinear`, `__getitem__`, `__iter__`, `all_chunk_coords`, `is_regular`, `chunk_shape`, `chunk_sizes`, `unique_edge_lengths`
-- `parse_chunk_grid()`, `serialize_chunk_grid()`, `_infer_chunk_grid_name()`
+- `ChunkGrid` with `from_regular`, `from_rectilinear`, `from_metadata`, `__getitem__`, `__iter__`, `all_chunk_coords`, `is_regular`, `chunk_shape`, `chunk_sizes`, `unique_edge_lengths`
 - `RegularChunkGrid` deprecation shim
-- `_infer_chunk_grid_name()` for serialization format inference
+- Metadata-layer serialization via `RegularChunkGrid.to_dict()`/`RectilinearChunkGrid.to_dict()`
 - Feature flag (`array.rectilinear_chunks`)
 
 **PR 3: Indexing generalization**

src/zarr/core/chunk_grids.py

@@ -6,7 +6,6 @@
 import numbers
 import operator
 import warnings
-from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from functools import reduce
 from typing import TYPE_CHECKING, Any, Literal, Protocol, TypeGuard, cast, runtime_checkable
@@ -16,21 +15,14 @@
 
 import zarr
 from zarr.core.common import (
-    JSON,
-    NamedConfig,
     ShapeLike,
     ceildiv,
-    compress_rle,
-    expand_rle,
-    parse_named_configuration,
     parse_shapelike,
-    validate_rectilinear_edges,
-    validate_rectilinear_kind,
 )
 from zarr.errors import ZarrUserWarning
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator
+    from collections.abc import Iterable, Iterator, Sequence
 
     from zarr.core.array import ShardsLike
     from zarr.core.metadata import ArrayMetadata
@@ -107,7 +99,7 @@ def with_extent(self, new_extent: int) -> FixedDimension:
         """Re-bind to *new_extent* without modifying edges.
 
         Used when constructing a grid from existing metadata where edges
-        are already correct (e.g. ``parse_chunk_grid``). Raises on
+        are already correct. Raises on
         ``VaryingDimension`` if edges don't cover the new extent.
         """
         return FixedDimension(size=self.size, extent=new_extent)
@@ -203,7 +195,7 @@ def with_extent(self, new_extent: int) -> VaryingDimension:
         """Re-bind to *new_extent* without modifying edges.
 
         Used when constructing a grid from existing metadata where edges
-        are already correct (e.g. ``parse_chunk_grid``). Raises if the
+        are already correct. Raises if the
         existing edges don't cover *new_extent*.
         """
         edge_sum = self.cumulative[-1]
@@ -275,66 +267,6 @@ def is_boundary(self) -> bool:
         return self.shape != self.codec_shape
 
 
-# A single dimension's rectilinear chunk spec: bare int (uniform shorthand),
-# list of ints (explicit edges), or mixed RLE (e.g. [[10, 3], 5]).
-RectilinearDimSpec = int | list[int | list[int]]
-
-# The serialization format name for a chunk grid.
-ChunkGridName = Literal["regular", "rectilinear"]
-
-
-def _serialize_fixed_dim(dim: FixedDimension) -> RectilinearDimSpec:
-    """Compact rectilinear representation for a fixed-size dimension.
-
-    Per the rectilinear spec, a bare integer is repeated until the sum
-    >= extent.  This preserves the full codec buffer size for boundary
-    chunks, matching the regular grid spec ("chunks at the border always
-    have the full chunk size").
-    """
-    return dim.size
-
-
-def _serialize_varying_dim(dim: VaryingDimension) -> RectilinearDimSpec:
-    """RLE-compressed rectilinear representation for a varying dimension."""
-    edges = list(dim.edges)
-    rle = compress_rle(edges)
-    if len(rle) < len(edges):
-        return rle
-    # mypy: list[int] is invariant, so it won't widen to list[int | list[int]]
-    return cast("RectilinearDimSpec", edges)
-
-
-def _decode_dim_spec(dim_spec: JSON, array_extent: int | None = None) -> list[int]:
-    """Decode a single dimension's chunk edge specification per the rectilinear spec.
-
-    Per the spec, each element of ``chunk_shapes`` can be:
-    - a bare integer ``m``: repeat ``m`` until the sum >= array extent
-    - an array of bare integers and/or ``[value, count]`` RLE pairs
-
-    Parameters
-    ----------
-    dim_spec
-        The raw JSON value for one dimension's chunk edges.
-    array_extent
-        Array length along this dimension. Required when *dim_spec* is a bare
-        integer (to know how many repetitions).
-    """
-    if isinstance(dim_spec, int):
-        if array_extent is None:
-            raise ValueError("Integer chunk_shapes shorthand requires array shape to expand.")
-        if dim_spec <= 0:
-            raise ValueError(f"Integer chunk edge length must be > 0, got {dim_spec}")
-        n = ceildiv(array_extent, dim_spec)
-        return [dim_spec] * n
-    if isinstance(dim_spec, list):
-        has_sublists = any(isinstance(e, list) for e in dim_spec)
-        if has_sublists:
-            return expand_rle(dim_spec)
-        else:
-            return [int(e) for e in dim_spec]
-    raise ValueError(f"Invalid chunk_shapes entry: {dim_spec}")
-
-
 def _is_rectilinear_chunks(chunks: Any) -> TypeGuard[Sequence[Sequence[int]]]:
     """Check if chunks is a nested sequence (e.g. [[10, 20], [5, 5]]).
 
@@ -628,118 +560,6 @@ def update_shape(self, new_shape: tuple[int, ...]) -> ChunkGrid:
         )
         return ChunkGrid(dimensions=dims)
 
-    # ChunkGrid does not serialize itself. The format choice ("regular" vs
-    # "rectilinear") belongs to the metadata layer. Use serialize_chunk_grid()
-    # for output and parse_chunk_grid() for input.
-
-
-def parse_chunk_grid(
-    data: dict[str, JSON] | ChunkGrid | NamedConfig[str, Any],
-    array_shape: tuple[int, ...],
-) -> ChunkGrid:
-    """Create a ChunkGrid from a metadata dict or existing grid, binding array shape.
-
-    This is the primary entry point for constructing a ChunkGrid from serialized
-    metadata. It always produces a grid with correct extent values.
-
-    Both ``"regular"`` and ``"rectilinear"`` grid names are supported. Rectilinear
-    grids are experimental and require the ``array.rectilinear_chunks`` config
-    option to be enabled; a ``ValueError`` is raised otherwise.
-    """
-    if isinstance(data, ChunkGrid):
-        # Re-bind extent if array_shape differs from what's stored
-        dims = tuple(
-            dim.with_extent(extent)
-            for dim, extent in zip(data.dimensions, array_shape, strict=True)
-        )
-        return ChunkGrid(dimensions=dims)
-
-    name_parsed, configuration_parsed = parse_named_configuration(data)
-
-    if name_parsed == "regular":
-        chunk_shape_raw = configuration_parsed.get("chunk_shape")
-        if chunk_shape_raw is None:
-            raise ValueError("Regular chunk grid requires 'chunk_shape' configuration")
-        if not isinstance(chunk_shape_raw, Sequence):
-            raise TypeError(f"chunk_shape must be a sequence, got {type(chunk_shape_raw)}")
-        return ChunkGrid.from_regular(array_shape, cast("Sequence[int]", chunk_shape_raw))
-
-    if name_parsed == "rectilinear":
-        validate_rectilinear_kind(cast("str | None", configuration_parsed.get("kind")))
-        chunk_shapes_raw = configuration_parsed.get("chunk_shapes")
-        if chunk_shapes_raw is None:
-            raise ValueError("Rectilinear chunk grid requires 'chunk_shapes' configuration")
-        if not isinstance(chunk_shapes_raw, Sequence):
-            raise TypeError(f"chunk_shapes must be a sequence, got {type(chunk_shapes_raw)}")
-        if len(chunk_shapes_raw) != len(array_shape):
-            raise ValueError(
-                f"chunk_shapes has {len(chunk_shapes_raw)} dimensions but array shape "
-                f"has {len(array_shape)} dimensions"
-            )
-        decoded: list[list[int]] = []
-        for dim_spec, extent in zip(chunk_shapes_raw, array_shape, strict=True):
-            decoded.append(_decode_dim_spec(dim_spec, array_extent=extent))
-        validate_rectilinear_edges(decoded, array_shape)
-        return ChunkGrid.from_rectilinear(decoded, array_shape=array_shape)
-
-    raise ValueError(f"Unknown chunk grid name: {name_parsed!r}")
-
-
-def serialize_chunk_grid(grid: ChunkGrid, name: ChunkGridName) -> dict[str, JSON]:
-    """Serialize a ChunkGrid to a metadata dict using the given format name.
-
-    The format choice ("regular" vs "rectilinear") belongs to the metadata layer,
-    not the grid itself. This function is called by ArrayV3Metadata.to_dict().
-    """
-    if name == "regular":
-        if not grid.is_regular:
-            raise ValueError(
-                "Cannot serialize a non-regular chunk grid as 'regular'. Use 'rectilinear' instead."
-            )
-        # The regular grid spec encodes only chunk_shape, not per-axis edges,
-        # so zero-extent dimensions are valid (they simply produce zero chunks).
-        return {
-            "name": "regular",
-            "configuration": {"chunk_shape": tuple(grid.chunk_shape)},
-        }
-
-    if name == "rectilinear":
-        # Zero-extent dimensions cannot be represented as rectilinear because
-        # the spec requires at least one positive-integer edge length per axis.
-        # This is intentionally asymmetric with the regular grid, which encodes
-        # only chunk_shape (no per-axis edges) and thus handles zero-extent
-        # arrays without issue.
-        if any(d.extent == 0 for d in grid.dimensions):
-            raise ValueError(
-                "Cannot serialize a zero-extent grid as 'rectilinear': "
-                "the spec requires all edge lengths to be positive integers."
-            )
-        chunk_shapes: list[RectilinearDimSpec] = []
-        for dim in grid.dimensions:
-            if isinstance(dim, FixedDimension):
-                chunk_shapes.append(_serialize_fixed_dim(dim))
-            elif isinstance(dim, VaryingDimension):
-                chunk_shapes.append(_serialize_varying_dim(dim))
-            else:
-                raise TypeError(f"Unexpected dimension type: {type(dim)}")
-        return {
-            "name": "rectilinear",
-            "configuration": {"kind": "inline", "chunk_shapes": chunk_shapes},
-        }
-
-    raise ValueError(f"Unknown chunk grid name for serialization: {name!r}")
-
-
-def _infer_chunk_grid_name(
-    data: dict[str, JSON] | ChunkGrid | NamedConfig[str, Any],
-    grid: ChunkGrid,
-) -> ChunkGridName:
-    """Extract or infer the chunk grid serialization name from the input."""
-    if isinstance(data, dict):
-        name, _ = parse_named_configuration(data)
-        return cast("ChunkGridName", name)
-    return "regular" if grid.is_regular else "rectilinear"
-
 
 def _guess_chunks(
     shape: tuple[int, ...] | int,

src/zarr/core/metadata/v3.py

@@ -360,9 +360,6 @@ def resolve_chunks(
     Flat inputs like ``(10, 10)`` or a scalar ``int`` produce a ``RegularChunkGrid``
     after normalization via :func:`~zarr.core.chunk_grids.normalize_chunks`.
 
-    See Also
-    --------
-    parse_chunk_grid : Deserialize a chunk grid from stored JSON metadata.
     """
     from zarr.core.chunk_grids import _is_rectilinear_chunks, normalize_chunks