chore: add informative error for invalid chunk grid parameter

Author: d-v-b

src/zarr/core/chunk_grids.py

@@ -683,7 +683,7 @@ def _guess_regular_chunks(
 
 
 def normalize_chunks_1d(
-    chunks: int | Iterable[int], span: int
+    chunks: int | Iterable[object], span: int
 ) -> np.ndarray[tuple[int], np.dtype[np.int64]]:
     """
     Normalize a one-dimensional chunk specification into a 1D int64 array of
@@ -707,11 +707,22 @@ def normalize_chunks_1d(
         chunk_list = list(chunks)
         if not chunk_list:
             raise ValueError("Chunk specification must not be empty")
-        if any(c <= 0 for c in chunk_list):
-            raise ValueError(f"All chunk sizes must be positive, got {chunk_list}")
-        if sum(chunk_list) != span:
-            raise ValueError(f"Chunk sizes {chunk_list} do not sum to span {span}")
-        return np.asarray(chunk_list, dtype=np.int64)
+        non_int = [
+            (idx, c) for idx, c in enumerate(chunk_list) if not isinstance(c, numbers.Integral)
+        ]
+        if non_int:
+            non_int_idxs, non_int_vals = [*zip(*non_int, strict=False)]
+            raise TypeError(
+                f"Each chunk size must be an integer; got non-integer element(s) {non_int_vals!r} "
+                f"at indices {non_int_idxs!r}. Chunk sizes must be declareds as a flat sequence of"
+                f"positive integers (e.g. [3, 3, 1])."
+            )
+        ints: list[int] = [int(c) for c in chunk_list]  # type: ignore[call-overload]
+        if any(c <= 0 for c in ints):
+            raise ValueError(f"All chunk sizes must be positive, got {ints}")
+        if sum(ints) != span:
+            raise ValueError(f"Chunk sizes {ints} do not sum to span {span}")
+        return np.asarray(ints, dtype=np.int64)
 
 
 def normalize_chunks_nd(

tests/test_chunk_grids.py

@@ -1,8 +1,10 @@
+import re
 from typing import Any
 
 import numpy as np
 import pytest
 
+from tests.test_codecs.conftest import ExpectErr
 from zarr.core.chunk_grids import (
     _guess_regular_chunks,
     normalize_chunks_nd,
@@ -141,6 +143,49 @@ def test_normalize_chunks_1d_errors() -> None:
         normalize_chunks_1d([10, 20], 100)
 
 
+@pytest.mark.parametrize(
+    "case",
+    [
+        # The motivating case: nested/RLE form for a single dim.
+        ExpectErr(
+            input=([[3, 3], 1], 7),
+            msg="non-integer element(s) ([3, 3],) at indices (0,)",
+            exception_cls=TypeError,
+        ),
+        # Multiple non-int elements report all offending indices.
+        ExpectErr(
+            input=([1, [2, 2], 1, [3]], 9),
+            msg="non-integer element(s) ([2, 2], [3]) at indices (1, 3)",
+            exception_cls=TypeError,
+        ),
+        # Strings are also non-integers and should be reported the same way.
+        ExpectErr(
+            input=([2, "3", 5], 10),
+            msg="non-integer element(s) ('3',) at indices (1,)",
+            exception_cls=TypeError,
+        ),
+    ],
+    ids=["rle-single-dim", "multiple-non-ints", "string-element"],
+)
+def test_normalize_chunks_1d_rejects_non_int_elements(
+    case: ExpectErr[tuple[list[Any], int]],
+) -> None:
+    """Reject nested/RLE-style chunk specs with a precise error pointing at offending indices."""
+    from zarr.core.chunk_grids import normalize_chunks_1d
+
+    chunks, span = case.input
+    with pytest.raises(case.exception_cls, match=re.escape(case.msg)):
+        normalize_chunks_1d(chunks, span=span)
+
+
+def test_normalize_chunks_nd_rejects_rle_inner_dim() -> None:
+    """End-to-end: a per-dim RLE form like [[3, 3], 1] surfaces the precise error."""
+    with pytest.raises(
+        TypeError, match=re.escape("non-integer element(s) ([3, 3],) at indices (0,)")
+    ):
+        normalize_chunks_nd([[6, 4], [[3, 3], 1]], (10, 10))
+
+
 def test_normalize_chunks_errors() -> None:
     with pytest.raises(ValueError, match="does not accept None"):
         normalize_chunks_nd(None, (100,))