Remove separators

maxrjones · maxrjones · commit 4a940b1cb30f · 2026-03-21T00:10:37.000-04:00
diff --git a/src/zarr/core/chunk_grids.py b/src/zarr/core/chunk_grids.py
@@ -36,11 +36,6 @@
     from zarr.core.metadata import ArrayMetadata
 
 
-# ---------------------------------------------------------------------------
-# Per-dimension grid types
-# ---------------------------------------------------------------------------
-
-
 @dataclass(frozen=True)
 class FixedDimension:
     """Uniform chunk size. Boundary chunks contain less data but are
@@ -256,11 +251,6 @@ def with_extent(self, new_extent: int) -> DimensionGrid: ...
     def resize(self, new_extent: int) -> DimensionGrid: ...
 
 
-# ---------------------------------------------------------------------------
-# ChunkSpec
-# ---------------------------------------------------------------------------
-
-
 @dataclass(frozen=True)
 class ChunkSpec:
     """Specification of a single chunk's location and size.
@@ -285,11 +275,6 @@ def is_boundary(self) -> bool:
         return self.shape != self.codec_shape
 
 
-# ---------------------------------------------------------------------------
-# RLE helpers (ported from #3534)
-# ---------------------------------------------------------------------------
-
-
 # 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]]
@@ -352,10 +337,6 @@ def _decode_dim_spec(dim_spec: JSON, array_extent: int | None = None) -> list[in
     raise ValueError(f"Invalid chunk_shapes entry: {dim_spec}")
 
 
-# ---------------------------------------------------------------------------
-# Unified ChunkGrid
-# ---------------------------------------------------------------------------
-
 # Type alias for what users can pass as chunks to create_array
 ChunksLike = tuple[int, ...] | list[list[int] | int] | int
 
@@ -771,11 +752,6 @@ def _infer_chunk_grid_name(
     return "regular" if grid.is_regular else "rectilinear"
 
 
-# ---------------------------------------------------------------------------
-# Chunk guessing / normalization (unchanged)
-# ---------------------------------------------------------------------------
-
-
 def _guess_chunks(
     shape: tuple[int, ...] | int,
     typesize: int,
@@ -999,11 +975,6 @@ def _auto_partition(
     return _shards_out, _chunks_out
 
 
-# ---------------------------------------------------------------------------
-# Backwards-compatibility shim for RegularChunkGrid
-# ---------------------------------------------------------------------------
-
-
 class _RegularChunkGridMeta(type):
     """Metaclass that makes ``isinstance(obj, RegularChunkGrid)`` work.
 
diff --git a/src/zarr/core/metadata/v3.py b/src/zarr/core/metadata/v3.py
@@ -171,10 +171,6 @@ def parse_extra_fields(
         return dict(data)
 
 
-# ---------------------------------------------------------------------------
-# Chunk grid metadata types (pure DTOs — no array shape, no behavioral logic)
-# ---------------------------------------------------------------------------
-
 # JSON type for a single dimension's rectilinear spec:
 # bare int (uniform shorthand), or list of ints / [value, count] RLE pairs.
 RectilinearDimSpecJSON = int | list[int | list[int]]
diff --git a/tests/test_unified_chunk_grid.py b/tests/test_unified_chunk_grid.py
@@ -53,11 +53,6 @@ def _edges(grid: ChunkGrid, dim: int) -> tuple[int, ...]:
     raise TypeError(f"Unexpected dimension type: {type(d)}")
 
 
-# ---------------------------------------------------------------------------
-# Index to chunk
-# ---------------------------------------------------------------------------
-
-
 class TestVaryingDimensionIndexToChunkBounds:
     def test_index_at_extent_raises(self) -> None:
         """index_to_chunk(extent) should raise since extent is out of bounds."""
@@ -92,11 +87,6 @@ def test_last_valid_index_works(self) -> None:
         assert dim.index_to_chunk(94) == 9
 
 
-# ---------------------------------------------------------------------------
-# Feature flag gating
-# ---------------------------------------------------------------------------
-
-
 class TestRectilinearFeatureFlag:
     """Test that rectilinear chunks are gated behind the config flag."""
 
@@ -132,11 +122,6 @@ def test_parse_chunk_grid_blocked(self) -> None:
                 )
 
 
-# ---------------------------------------------------------------------------
-# RegularChunkGrid backwards compatibility
-# ---------------------------------------------------------------------------
-
-
 class TestRegularChunkGridCompat:
     """The deprecated RegularChunkGrid shim should work for common patterns."""
 
@@ -168,11 +153,6 @@ def test_isinstance_false_for_unrelated_types(self) -> None:
         assert not isinstance(42, RegularChunkGrid)
 
 
-# ---------------------------------------------------------------------------
-# FixedDimension
-# ---------------------------------------------------------------------------
-
-
 class TestFixedDimension:
     def test_basic(self) -> None:
         d = FixedDimension(size=10, extent=100)
@@ -223,11 +203,6 @@ def test_zero_size_allowed(self) -> None:
     # ChunkGrid.__getitem__ which checks before delegating.
 
 
-# ---------------------------------------------------------------------------
-# VaryingDimension
-# ---------------------------------------------------------------------------
-
-
 class TestVaryingDimension:
     def test_basic(self) -> None:
         d = VaryingDimension([10, 20, 30], extent=60)
@@ -279,11 +254,6 @@ def test_zero_edge_rejected(self) -> None:
             VaryingDimension([10, 0, 5], extent=15)
 
 
-# ---------------------------------------------------------------------------
-# ChunkSpec
-# ---------------------------------------------------------------------------
-
-
 class TestChunkSpec:
     def test_basic(self) -> None:
         spec = ChunkSpec(
@@ -302,11 +272,6 @@ def test_boundary(self) -> None:
         assert spec.is_boundary
 
 
-# ---------------------------------------------------------------------------
-# ChunkGrid construction
-# ---------------------------------------------------------------------------
-
-
 class TestChunkGridConstruction:
     def test_from_regular(self) -> None:
         g = ChunkGrid.from_regular((100, 200), (10, 20))
@@ -341,11 +306,6 @@ def test_all_uniform_becomes_regular(self) -> None:
         assert g.chunk_shape == (10, 25)
 
 
-# ---------------------------------------------------------------------------
-# ChunkGrid queries
-# ---------------------------------------------------------------------------
-
-
 class TestChunkGridQueries:
     def test_regular_shape(self) -> None:
         g = ChunkGrid.from_regular((100, 200), (10, 20))
@@ -453,11 +413,6 @@ def test_iter(self) -> None:
         assert all(isinstance(s, ChunkSpec) for s in specs)
 
 
-# ---------------------------------------------------------------------------
-# RLE helpers
-# ---------------------------------------------------------------------------
-
-
 class TestRLE:
     def test_expand(self) -> None:
         assert expand_rle([[10, 3]]) == [10, 10, 10]
@@ -502,19 +457,14 @@ def test_expand_rejects_negative_rle_count(self) -> None:
 class TestExpandRleHandlesJsonFloats:
     def test_bare_integer_floats_accepted(self) -> None:
         """JSON parsers may emit 10.0 for the integer 10; expand_rle should handle it."""
-        result = expand_rle([10.0, 20.0])
+        result = expand_rle([10.0, 20.0])  # type: ignore[list-item]
         assert result == [10, 20]
 
     def test_rle_pair_with_float_count(self) -> None:
-        result = expand_rle([[10, 3.0]])
+        result = expand_rle([[10, 3.0]])  # type: ignore[list-item]
         assert result == [10, 10, 10]
 
 
-# ---------------------------------------------------------------------------
-# _decode_dim_spec edge cases
-# ---------------------------------------------------------------------------
-
-
 class TestDecodeDimSpec:
     """Edge cases for _decode_dim_spec: floats, empty lists, negatives, missing extent."""
 
@@ -560,11 +510,6 @@ def test_none_raises(self) -> None:
             _decode_dim_spec(None, array_extent=10)
 
 
-# ---------------------------------------------------------------------------
-# _is_rectilinear_chunks edge cases
-# ---------------------------------------------------------------------------
-
-
 class TestIsRectilinearChunks:
     """Edge cases for _is_rectilinear_chunks."""
 
@@ -604,11 +549,6 @@ def test_float(self) -> None:
         assert _is_rectilinear_chunks(3.14) is False
 
 
-# ---------------------------------------------------------------------------
-# _infer_chunk_grid_name edge cases
-# ---------------------------------------------------------------------------
-
-
 class TestInferChunkGridName:
     """Edge cases for _infer_chunk_grid_name."""
 
@@ -639,11 +579,6 @@ def test_dict_with_rectilinear_name(self) -> None:
         assert _infer_chunk_grid_name(d, g) == "rectilinear"
 
 
-# ---------------------------------------------------------------------------
-# Serialization
-# ---------------------------------------------------------------------------
-
-
 class TestSerialization:
     def test_regular_roundtrip(self) -> None:
         g = ChunkGrid.from_regular((100, 200), (10, 20))
@@ -710,7 +645,7 @@ def test_bare_int_roundtrip(self) -> None:
             "name": "rectilinear",
             "configuration": {"kind": "inline", "chunk_shapes": [10, [20, 30]]},
         }
-        meta = RectilinearChunkGrid.from_dict(data)
+        meta = RectilinearChunkGrid.from_dict(data)  # type: ignore[arg-type]
         out = meta.to_dict()
         # Dim 0 was bare int — should stay bare int
         assert out["configuration"]["chunk_shapes"][0] == 10
@@ -729,7 +664,7 @@ def test_serialize_non_regular_as_regular_raises(self) -> None:
     def test_serialize_unknown_name_raises(self) -> None:
         g = ChunkGrid.from_regular((100,), (10,))
         with pytest.raises(ValueError, match="Unknown chunk grid name for serialization"):
-            serialize_chunk_grid(g, "hexagonal")
+            serialize_chunk_grid(g, "hexagonal")  # type: ignore[arg-type]
 
     def test_zero_extent_rectilinear_raises(self) -> None:
         """Zero-extent grids cannot be serialized as rectilinear (spec requires positive edges)."""
@@ -924,11 +859,6 @@ def test_single_chunk_boundary_codec_size_preserved(self) -> None:
         assert parsed.dimensions[0].chunk_size(0) == 10
 
 
-# ---------------------------------------------------------------------------
-# Indexing with rectilinear grids
-# ---------------------------------------------------------------------------
-
-
 class TestRectilinearIndexing:
     """Test that the indexing pipeline works with VaryingDimension."""
 
@@ -999,11 +929,6 @@ def test_oob_block_raises_bounds_check_error(self) -> None:
             a.get_block_selection((2,))
 
 
-# ---------------------------------------------------------------------------
-# End-to-end: array creation with rectilinear chunks
-# ---------------------------------------------------------------------------
-
-
 class TestEndToEnd:
     """Test creating, writing, and reading arrays with rectilinear chunk grids."""
 
@@ -1158,11 +1083,6 @@ def test_get_chunk_spec_rectilinear(self, tmp_path: Path) -> None:
         assert spec2.shape == (30, 50)
 
 
-# ---------------------------------------------------------------------------
-# Sharding compatibility
-# ---------------------------------------------------------------------------
-
-
 class TestShardingCompat:
     def test_sharding_accepts_rectilinear_outer_grid(self) -> None:
         """ShardingCodec.validate should not reject rectilinear outer grids."""
@@ -1180,11 +1100,6 @@ def test_sharding_accepts_rectilinear_outer_grid(self) -> None:
         )
 
 
-# ---------------------------------------------------------------------------
-# Edge cases
-# ---------------------------------------------------------------------------
-
-
 class TestEdgeCases:
     """Edge cases around boundary chunks, zero-size dims, direct construction,
     and serialization round-trips."""
@@ -1562,11 +1477,6 @@ def test_sharding_accepts_divisible_rectilinear(self) -> None:
         )
 
 
-# ---------------------------------------------------------------------------
-# Full-pipeline read/write tests with rectilinear grids
-# ---------------------------------------------------------------------------
-
-
 class TestFullPipelineRectilinear:
     """End-to-end read/write tests through the full Array pipeline."""
 
@@ -1900,10 +1810,6 @@ def test_nchunks(self, tmp_path: Path) -> None:
         assert z.chunk_grid.get_nchunks() == 12
 
 
-# ---------------------------------------------------------------------------
-# Hypothesis property-based tests
-# ---------------------------------------------------------------------------
-
 pytest.importorskip("hypothesis")
 
 import hypothesis.strategies as st  # noqa: E402
@@ -1978,11 +1884,6 @@ def test_property_block_indexing_rectilinear(data: st.DataObject) -> None:
         )
 
 
-# ---------------------------------------------------------------------------
-# V2 regression tests
-# ---------------------------------------------------------------------------
-
-
 class TestV2Regression:
     """Verify V2 arrays still work correctly after the ChunkGrid refactor.
 
@@ -2089,11 +1990,6 @@ def test_v2_chunk_spec_via_grid(self, tmp_path: Path) -> None:
         assert spec.codec_shape == (10, 10)  # full buffer
 
 
-# ---------------------------------------------------------------------------
-# .read_chunk_sizes / .write_chunk_sizes properties
-# ---------------------------------------------------------------------------
-
-
 class TestChunkSizes:
     """Tests for ChunkGrid.chunk_sizes and Array.read_chunk_sizes / write_chunk_sizes."""
 
@@ -2145,11 +2041,6 @@ def test_array_sharded_chunk_sizes(self) -> None:
         assert arr.write_chunk_sizes == ((120,), (80,))
 
 
-# ---------------------------------------------------------------------------
-# .info display for rectilinear grids
-# ---------------------------------------------------------------------------
-
-
 def test_info_display_rectilinear() -> None:
     """Array.info should not crash for rectilinear grids."""
     store = zarr.storage.MemoryStore()
@@ -2166,11 +2057,6 @@ def test_info_display_rectilinear() -> None:
     assert "Array" in text
 
 
-# ---------------------------------------------------------------------------
-# Resize / append for rectilinear grids
-# ---------------------------------------------------------------------------
-
-
 class TestUpdateShape:
     """Unit tests for ChunkGrid.update_shape()."""
 
@@ -2454,11 +2340,6 @@ def test_parse_chunk_grid_regular_from_dict(self) -> None:
         assert g.get_nchunks() == 100
 
 
-# ---------------------------------------------------------------------------
-# Boundary chunk tests
-# ---------------------------------------------------------------------------
-
-
 class TestVaryingDimensionBoundary:
     """VaryingDimension with extent < sum(edges), mirroring how FixedDimension
     handles boundary chunks."""
