refactor(zarr-metadata): build each drawn configuration as its TypedDict

Each configuration strategy now returns a strategy of its definition's
configuration TypedDict, built with the TypedDict's constructor, so
pyright checks every key and value it draws. Optional keys are set on
the built TypedDict rather than drawn through `fixed_dictionaries`.

Assisted-by: ClaudeCode:claude-opus-5-5

Author: d-v-b

packages/zarr-metadata/src/zarr_metadata/testing/_chunk_grid.py

@@ -14,13 +14,16 @@
 from hypothesis import strategies as st
 
 from zarr_metadata.testing._strategy import ChunkGridStrategy
-from zarr_metadata.v3.chunk_grid.rectilinear import RECTILINEAR_CHUNK_GRID
-from zarr_metadata.v3.chunk_grid.regular import REGULAR_CHUNK_GRID
+from zarr_metadata.v3.chunk_grid.rectilinear import (
+    RECTILINEAR_CHUNK_GRID,
+    RectilinearChunkGridConfiguration,
+    RectilinearDimSpec,
+)
+from zarr_metadata.v3.chunk_grid.regular import REGULAR_CHUNK_GRID, RegularChunkGridConfiguration
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
-    from zarr_metadata._common import JSONValue
     from zarr_metadata.testing._strategy import Strategies
     from zarr_metadata.v3._definition import ChunkGridDefinition
 
@@ -46,24 +49,24 @@ def _length(extent: int | None) -> st.SearchStrategy[int]:
 
 def _regular(
     shape: tuple[int, ...] | None, _strategies: Strategies
-) -> st.SearchStrategy[Mapping[str, JSONValue]]:
+) -> st.SearchStrategy[RegularChunkGridConfiguration]:
     """A chunk length for each dimension."""
     if shape is None:
         lengths = st.lists(_length(None), max_size=_MAX_RANK).map(tuple)
     else:
         lengths = st.tuples(*(_length(extent) for extent in shape))
-    return lengths.map(lambda chunk_shape: {"chunk_shape": chunk_shape})
+    return lengths.map(lambda chunk_shape: RegularChunkGridConfiguration(chunk_shape=chunk_shape))
 
 
-def _spelled_run(draw: st.DrawFn, size: int, count: int) -> list[JSONValue]:
+def _spelled_run(draw: st.DrawFn, size: int, count: int) -> list[int | tuple[int, int]]:
     """`count` chunks of `size`: one `[size, count]` pair, or the size written once for each."""
     if draw(st.booleans()):
         return [(size, count)]
     return [size] * count
 
 
 @st.composite
-def _edges(draw: st.DrawFn, extent: int | None) -> JSONValue:
+def _edges(draw: st.DrawFn, extent: int | None) -> tuple[int | tuple[int, int], ...]:
     """Edge lengths along a dimension, covering `extent`, in runs spelled as pairs or written out.
 
     Runs are drawn apart, so two of one size can sit side by side and a
@@ -81,26 +84,30 @@ def _edges(draw: st.DrawFn, extent: int | None) -> JSONValue:
     covered = sum(size * count for size, count in runs)
     if extent is not None and covered < extent:
         runs.append((extent - covered, 1))
-    spelled: list[JSONValue] = []
+    spelled: list[int | tuple[int, int]] = []
     for size, count in runs:
         spelled.extend(_spelled_run(draw, size, count))
     return tuple(spelled)
 
 
-def _rectilinear_dimension(extent: int | None) -> st.SearchStrategy[JSONValue]:
+def _rectilinear_dimension(extent: int | None) -> st.SearchStrategy[RectilinearDimSpec]:
     """A bare length, which repeats until it covers the dimension, or edges that cover it."""
     return _length(extent) | _edges(extent)
 
 
 def _rectilinear(
     shape: tuple[int, ...] | None, _strategies: Strategies
-) -> st.SearchStrategy[Mapping[str, JSONValue]]:
+) -> st.SearchStrategy[RectilinearChunkGridConfiguration]:
     """Inline chunk shapes, one entry for each dimension."""
     if shape is None:
         dimensions = st.lists(_rectilinear_dimension(None), max_size=_MAX_RANK).map(tuple)
     else:
         dimensions = st.tuples(*(_rectilinear_dimension(extent) for extent in shape))
-    return dimensions.map(lambda chunk_shapes: {"kind": "inline", "chunk_shapes": chunk_shapes})
+    return dimensions.map(
+        lambda chunk_shapes: RectilinearChunkGridConfiguration(
+            kind="inline", chunk_shapes=chunk_shapes
+        )
+    )
 
 
 CHUNK_GRID_STRATEGIES: Final[Mapping[ChunkGridDefinition[Any], ChunkGridStrategy]] = {

packages/zarr-metadata/src/zarr_metadata/testing/_chunk_key_encoding.py

@@ -10,29 +10,35 @@
 from zarr_metadata.v3.chunk_key_encoding.default import (
     DEFAULT_CHUNK_KEY_ENCODING,
     DEFAULT_CHUNK_KEY_ENCODING_SEPARATOR,
+    DefaultChunkKeyEncodingConfiguration,
 )
 from zarr_metadata.v3.chunk_key_encoding.v2 import (
     V2_CHUNK_KEY_ENCODING,
     V2_CHUNK_KEY_ENCODING_SEPARATOR,
+    V2ChunkKeyEncodingConfiguration,
 )
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
     from zarr_metadata.v3._definition import ChunkKeyEncodingDefinition
 
+_DEFAULT_SEPARATORS: Final = st.just(DefaultChunkKeyEncodingConfiguration()) | st.sampled_from(
+    DEFAULT_CHUNK_KEY_ENCODING_SEPARATOR
+).map(lambda separator: DefaultChunkKeyEncodingConfiguration(separator=separator))
+
+_V2_SEPARATORS: Final = st.just(V2ChunkKeyEncodingConfiguration()) | st.sampled_from(
+    V2_CHUNK_KEY_ENCODING_SEPARATOR
+).map(lambda separator: V2ChunkKeyEncodingConfiguration(separator=separator))
+
 CHUNK_KEY_ENCODING_STRATEGIES: Final[
     Mapping[ChunkKeyEncodingDefinition[Any], ChunkKeyEncodingStrategy]
 ] = {
     DEFAULT_CHUNK_KEY_ENCODING: ChunkKeyEncodingStrategy(
-        configurations=lambda _strategies: st.fixed_dictionaries(
-            {}, optional={"separator": st.sampled_from(DEFAULT_CHUNK_KEY_ENCODING_SEPARATOR)}
-        )
+        configurations=lambda _strategies: _DEFAULT_SEPARATORS
     ),
     V2_CHUNK_KEY_ENCODING: ChunkKeyEncodingStrategy(
-        configurations=lambda _strategies: st.fixed_dictionaries(
-            {}, optional={"separator": st.sampled_from(V2_CHUNK_KEY_ENCODING_SEPARATOR)}
-        )
+        configurations=lambda _strategies: _V2_SEPARATORS
     ),
 }
 """A strategy for each chunk key encoding: a `separator`, or none, which means the encoding's default."""