fixup

Author: jhamman

src/zarr/core/metadata/v3.py

@@ -216,8 +216,7 @@ 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
-        if _data["data_type"] not in DataType:
-            raise ValueError(f"Invalid V3 data_type: {_data['data_type']}")
+        _ = DataType(_data["data_type"])
 
         # dimension_names key is optional, normalize missing to `None`
         _data["dimension_names"] = _data.pop("dimension_names", None)
@@ -264,23 +263,38 @@ def update_attributes(self, attributes: dict[str, JSON]) -> Self:
 
 
 @overload
-def parse_fill_value(fill_value: object, dtype: BOOL_DTYPE) -> BOOL: ...
+def parse_fill_value(
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
+    dtype: BOOL_DTYPE,
+) -> BOOL: ...
 
 
 @overload
-def parse_fill_value(fill_value: object, dtype: INTEGER_DTYPE) -> INTEGER: ...
+def parse_fill_value(
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
+    dtype: INTEGER_DTYPE,
+) -> INTEGER: ...
 
 
 @overload
-def parse_fill_value(fill_value: object, dtype: FLOAT_DTYPE) -> FLOAT: ...
+def parse_fill_value(
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
+    dtype: FLOAT_DTYPE,
+) -> FLOAT: ...
 
 
 @overload
-def parse_fill_value(fill_value: object, dtype: COMPLEX_DTYPE) -> COMPLEX: ...
+def parse_fill_value(
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
+    dtype: COMPLEX_DTYPE,
+) -> COMPLEX: ...
 
 
 @overload
-def parse_fill_value(fill_value: object, dtype: np.dtype[Any]) -> Any:
+def parse_fill_value(
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
+    dtype: np.dtype[Any],
+) -> Any:
     # This dtype[Any] is unfortunately necessary right now.
     # See https://github.com/zarr-developers/zarr-python/issues/2131#issuecomment-2318010899
     # for more details, but `dtype` here (which comes from `parse_dtype`)
@@ -292,7 +306,7 @@ def parse_fill_value(fill_value: object, dtype: np.dtype[Any]) -> Any:
 
 
 def parse_fill_value(
-    fill_value: object,
+    fill_value: int | float | complex | str | bytes | np.generic | Sequence[Any] | bool | None,
     dtype: BOOL_DTYPE | INTEGER_DTYPE | FLOAT_DTYPE | COMPLEX_DTYPE | np.dtype[Any],
 ) -> BOOL | INTEGER | FLOAT | COMPLEX | Any:
     """
@@ -326,11 +340,11 @@ def parse_fill_value(
             else:
                 msg = (
                     f"Got an invalid fill value for complex data type {dtype}."
-                    f"Expected a sequence with 2 elements, but {fill_value} has "
+                    f"Expected a sequence with 2 elements, but {fill_value!r} has "
                     f"length {len(fill_value)}."
                 )
                 raise ValueError(msg)
-        msg = f"Cannot parse non-string sequence {fill_value} as a scalar with type {dtype}."
+        msg = f"Cannot parse non-string sequence {fill_value!r} as a scalar with type {dtype}."
         raise TypeError(msg)
 
     # Cast the fill_value to the given dtype
@@ -339,7 +353,7 @@ def parse_fill_value(
     except (ValueError, OverflowError, TypeError) as e:
         raise ValueError(f"fill value {fill_value!r} is not valid for dtype {dtype}") from e
     # Check if the value is still representable by the dtype
-    if fill_value != casted_value:
+    if fill_value != casted_value and not (np.isnan(fill_value) and np.isnan(casted_value)):
         raise ValueError(f"fill value {fill_value!r} is not valid for dtype {dtype}")
 
     return casted_value
@@ -434,7 +448,7 @@ def from_dtype(cls, dtype: np.dtype[Any]) -> DataType:
 def parse_dtype(data: npt.DTypeLike) -> np.dtype[Any]:
     try:
         dtype = np.dtype(data)
-    except TypeError as e:
+    except (ValueError, TypeError) as e:
         raise ValueError(f"Invalid V3 data_type: {data}") from e
     # check that this is a valid v3 data_type
     try:

tests/v3/test_array.py

@@ -122,8 +122,10 @@ def test_array_v3_fill_value_default(
 
 
 @pytest.mark.parametrize("store", ["memory"], indirect=True)
-@pytest.mark.parametrize("fill_value", [False, 0.0, 1, 2.3])
-@pytest.mark.parametrize("dtype_str", ["bool", "uint8", "float32", "complex64"])
+@pytest.mark.parametrize(
+    "dtype_str,fill_value",
+    [("bool", True), ("uint8", 99), ("float32", -99.9), ("complex64", 3 + 4j)],
+)
 def test_array_v3_fill_value(store: MemoryStore, fill_value: int, dtype_str: str) -> None:
     shape = (10,)
     arr = Array.create(

tests/v3/test_metadata/test_v3.py

@@ -79,8 +79,19 @@ def test_parse_auto_fill_value(dtype_str: str) -> None:
     assert parse_fill_value(fill_value, dtype) == dtype.type(0)
 
 
-@pytest.mark.parametrize("fill_value", [0, 1.11, False, True])
-@pytest.mark.parametrize("dtype_str", dtypes)
+@pytest.mark.parametrize(
+    "fill_value,dtype_str",
+    [
+        (True, "bool"),
+        (False, "bool"),
+        (-8, "int8"),
+        (0, "int16"),
+        (1e10, "uint64"),
+        (-999, "float32"),
+        (1e32, "float64"),
+        (0j, "complex64"),
+    ],
+)
 def test_parse_fill_value_valid(fill_value: Any, dtype_str: str) -> None:
     """
     Test that parse_fill_value(fill_value, dtype) casts fill_value to the given dtype.
@@ -141,8 +152,7 @@ def test_parse_fill_value_invalid_type(fill_value: Any, dtype_str: str) -> None:
     This test excludes bool because the bool constructor takes anything.
     """
     dtype = np.dtype(dtype_str)
-    match = "must be"
-    with pytest.raises(TypeError, match=match):
+    with pytest.raises(ValueError, match=r"fill value .* is not valid for dtype .*"):
         parse_fill_value(fill_value, dtype)
 
 
@@ -269,13 +279,13 @@ async def test_invalid_dtype_raises() -> None:
         "codecs": (),
         "fill_value": np.datetime64(0, "ns"),
     }
-    with pytest.raises(ValueError, match=r"Invalid V3 data_type"):
+    with pytest.raises(ValueError, match=r".* is not a valid DataType"):
         ArrayV3Metadata.from_dict(metadata_dict)
 
 
 @pytest.mark.parametrize("data", ["datetime64[s]", "foo", object()])
 def test_parse_invalid_dtype_raises(data):
-    with pytest.raises(ValueError, match=r"Invalid V3 data_type"):
+    with pytest.raises(ValueError, match=r"Invalid V3 data_type: .*"):
         parse_dtype(data)
 
 
@@ -293,5 +303,5 @@ async def test_invalid_fill_value_raises(data_type: str, fill_value: int | float
         "codecs": (),
         "fill_value": fill_value,  # this is not a valid fill value for uint8
     }
-    with pytest.raises(ValueError, match=rf"fill value .* is not valid for dtype {data_type}"):
+    with pytest.raises(ValueError, match=r"fill value .* is not valid for dtype .*"):
         ArrayV3Metadata.from_dict(metadata_dict)