objects for datatype, chunk_key_encodings, chunk_grid

Author: brokkoli71

src/zarr/core/chunk_grids.py

@@ -179,9 +179,17 @@ def __init__(self, *, chunk_shape: ChunkCoordsLike) -> None:
 
     @classmethod
     def _from_dict(cls, data: dict[str, JSON]) -> Self:
-        _, configuration_parsed = parse_named_configuration(data, "regular")
+        _, config_parsed = parse_named_configuration(data, "regular")
+
+        if config_parsed and not all(
+            k == "chunk_shape" or (isinstance(v, dict) and v.get("must_understand") is False)
+            for k, v in config_parsed.items()
+        ):
+            raise ValueError(
+                f"The chunk grid expects a 'chunk_shape' key. Got {list(config_parsed.keys())}."
+            )
 
-        return cls(**configuration_parsed)  # type: ignore[arg-type]
+        return cls(chunk_shape=config_parsed.get("chunk_shape"))  # type: ignore[arg-type]
 
     def to_dict(self) -> dict[str, JSON]:
         return {"name": "regular", "configuration": {"chunk_shape": tuple(self.chunk_shape)}}

src/zarr/core/chunk_key_encodings.py

@@ -44,24 +44,34 @@ def from_dict(cls, data: dict[str, JSON] | ChunkKeyEncodingLike) -> ChunkKeyEnco
             return data
 
         # handle ChunkKeyEncodingParams
-        if "name" in data and "separator" in data:
+        if isinstance(data, dict) and data.keys() == {"name", "separator"}:
             data = {"name": data["name"], "configuration": {"separator": data["separator"]}}
 
         # TODO: remove this cast when we are statically typing the JSON metadata completely.
         data = cast(dict[str, JSON], data)
 
         # configuration is optional for chunk key encodings
         name_parsed, config_parsed = parse_named_configuration(data, require_configuration=False)
+
+        if config_parsed and not all(
+            k == "separator" or (isinstance(v, dict) and v.get("must_understand") is False)
+            for k, v in config_parsed.items()
+        ):
+            raise ValueError(
+                f"The chunk key encoding expects a 'separator' key. Got {list(config_parsed.keys())}."
+            )
+
         if name_parsed == "default":
-            if config_parsed is None:
-                # for default, normalize missing configuration to use the "/" separator.
-                config_parsed = {"separator": "/"}
-            return DefaultChunkKeyEncoding(**config_parsed)  # type: ignore[arg-type]
+            # for default, normalize missing configuration to use the "/" separator.
+            return DefaultChunkKeyEncoding(
+                separator=config_parsed.get("separator") if config_parsed else "/"  # type: ignore[arg-type]
+            )
         if name_parsed == "v2":
-            if config_parsed is None:
-                # for v2, normalize missing configuration to use the "." separator.
-                config_parsed = {"separator": "."}
-            return V2ChunkKeyEncoding(**config_parsed)  # type: ignore[arg-type]
+            # for v2, normalize missing configuration to use the "." separator.
+            return V2ChunkKeyEncoding(
+                separator=config_parsed.get("separator") if config_parsed else "."  # type: ignore[arg-type]
+            )
+
         msg = f"Unknown chunk key encoding. Got {name_parsed}, expected one of ('v2', 'default')."
         raise ValueError(msg)
 
@@ -77,7 +87,7 @@ def encode_chunk_key(self, chunk_coords: ChunkCoords) -> str:
         pass
 
 
-ChunkKeyEncodingLike: TypeAlias = ChunkKeyEncodingParams | ChunkKeyEncoding
+ChunkKeyEncodingLike: TypeAlias = ChunkKeyEncodingParams | ChunkKeyEncoding | str
 
 
 @dataclass(frozen=True)

src/zarr/core/common.py

@@ -114,21 +114,26 @@ def parse_named_configuration(
 
 
 def parse_named_configuration(
-    data: JSON, expected_name: str | None = None, *, require_configuration: bool = True
+    data: JSON,
+    expected_name: str | None = None,
+    *,
+    require_configuration: bool = True,
 ) -> tuple[str, JSON | None]:
+    if isinstance(data, str):
+        data = {"name": data}
     if not isinstance(data, dict):
         raise TypeError(f"Expected dict, got {type(data)}")
-
-    if not all(
+    elif not all(
         k in {"name", "configuration"}
         or (isinstance(v, dict) and (v.get("must_understand") is False))
         for k, v in data.items()
     ):
         raise ValueError(
             f"Named configuration expects keys 'name' and 'configuration'. Got {list(data.keys())}."
         )
-    if "name" not in data:
+    elif "name" not in data:
         raise ValueError(f"Named configuration does not have a 'name' key. Got {data}.")
+
     name_parsed = parse_name(data["name"], expected_name)
     if "configuration" in data:
         configuration_parsed = parse_configuration(data["configuration"])

src/zarr/core/metadata/v3.py

@@ -413,7 +413,10 @@ def from_dict(cls, data: dict[str, JSON]) -> Self:
         _ = parse_node_type_array(_data.pop("node_type"))
 
         # check that the data_type attribute is valid
-        data_type = DataType.parse(_data.pop("data_type"))
+        dt = _data.pop("data_type")
+        if isinstance(dt, dict):
+            dt, _ = parse_named_configuration(dt, require_configuration=False)
+        data_type = DataType.parse(dt)
 
         # dimension_names key is optional, normalize missing to `None`
         _data["dimension_names"] = _data.pop("dimension_names", None)

tests/test_metadata/test_v3.py

@@ -428,32 +428,94 @@ def default_metadata_dict(**kwargs: Any) -> dict[str, Any]:
     return d
 
 
-def test_fail_on_invalid_key() -> None:
-    ArrayV3Metadata.from_dict(default_metadata_dict())
-    # Metadata contains invalid keys
-    with pytest.raises(ValueError, match=re.escape("Unexpected zarr metadata keys: ['unknown']")):
-        ArrayV3Metadata.from_dict(default_metadata_dict(unknown="value"))
-    # accepts invalid key with must_understand=false
-    ArrayV3Metadata.from_dict(
-        default_metadata_dict(unknown={"name": "value", "must_understand": False})
-    )
-    # Named configuration contains invalid keys
-    with pytest.raises(
-        ValueError,
-        match=re.escape(
-            "Named configuration expects keys 'name' and 'configuration'. Got ['name', 'unknown', 'configuration']."
+@pytest.mark.parametrize(
+    ("metadata_dict", "is_valid", "fail_msg"),
+    [
+        (default_metadata_dict(), True, ""),
+        (
+            default_metadata_dict(unknown="value"),
+            False,
+            "Unexpected zarr metadata keys: ['unknown']",
         ),
-    ):
-        ArrayV3Metadata.from_dict(
-            default_metadata_dict(codecs=[{"name": "bytes", "unknown": {}, "configuration": {}}])
-        )
-
-    # accepts invalid key with must_understand=false
-    ArrayV3Metadata.from_dict(
-        default_metadata_dict(
-            codecs=[{"name": "bytes", "configuration": {}, "unknown": {"must_understand": False}}]
-        )
-    )
+        (default_metadata_dict(unknown={"name": "value", "must_understand": False}), True, ""),
+        (
+            default_metadata_dict(codecs=[{"name": "bytes", "unknown": {}, "configuration": {}}]),
+            False,
+            "Named configuration expects keys 'name' and 'configuration'. Got ['name', 'unknown', 'configuration'].",
+        ),
+        (
+            default_metadata_dict(
+                codecs=[
+                    {"name": "bytes", "configuration": {}, "unknown": {"must_understand": False}}
+                ]
+            ),
+            True,
+            "",
+        ),
+        (
+            default_metadata_dict(data_type={"name": "int8", "value": {"must_understand": False}}),
+            True,
+            "",
+        ),
+        (
+            default_metadata_dict(
+                chunk_key_encoding={
+                    "name": "default",
+                    "configuration": {"unknown": {"name": "value", "must_understand": False}},
+                }
+            ),
+            True,
+            "",
+        ),
+        (
+            default_metadata_dict(
+                chunk_key_encoding={"name": "default", "configuration": {"unknown": "value"}}
+            ),
+            False,
+            "The chunk key encoding expects a 'separator' key. Got ['unknown'].",
+        ),
+        (default_metadata_dict(chunk_key_encoding="default"), True, ""),
+        (default_metadata_dict(chunk_key_encoding="invalid"), False, ""),
+        (
+            default_metadata_dict(
+                chunk_grid={"name": "regular", "configuration": {"chunk_shape": [2]}}
+            ),
+            True,
+            "",
+        ),
+        (
+            default_metadata_dict(
+                chunk_grid={
+                    "name": "regular",
+                    "configuration": {"chunk_shape": [2], "unknown": "value"},
+                }
+            ),
+            False,
+            "The chunk grid expects a 'chunk_shape' key. Got ['chunk_shape', 'unknown'].",
+        ),
+        (
+            default_metadata_dict(
+                chunk_grid={
+                    "name": "regular",
+                    "configuration": {
+                        "chunk_shape": [2],
+                        "unknown": {"name": "value", "must_understand": False},
+                    },
+                }
+            ),
+            True,
+            "",
+        ),
+    ],
+)
+def test_fail_on_invalid_metadata_key(
+    metadata_dict: dict[str, Any], is_valid: bool, fail_msg: str
+) -> None:
+    if is_valid:
+        ArrayV3Metadata.from_dict(metadata_dict)
+    else:
+        with pytest.raises(ValueError, match=re.escape(fail_msg)):
+            ArrayV3Metadata.from_dict(metadata_dict)
 
 
 @pytest.mark.parametrize(