update data type names

Author: d-v-b

src/zarr/core/array.py

@@ -30,9 +30,6 @@
 from zarr.abc.codec import ArrayArrayCodec, ArrayBytesCodec, BytesBytesCodec, Codec
 from zarr.abc.store import Store, set_or_delete
 from zarr.codecs._v2 import V2Codec
-from zarr.codecs.bytes import BytesCodec
-from zarr.codecs.vlen_utf8 import VLenBytesCodec, VLenUTF8Codec
-from zarr.codecs.zstd import ZstdCodec
 from zarr.core._info import ArrayInfo
 from zarr.core.array_spec import ArrayConfig, ArrayConfigLike, ArraySpec, parse_array_config
 from zarr.core.attributes import Attributes
@@ -69,8 +66,6 @@
 from zarr.core.config import config as zarr_config
 from zarr.core.dtype import (
     DTypeWrapper,
-    FixedLengthAsciiString,
-    VariableLengthString,
     parse_data_type,
 )
 from zarr.core.indexing import (
@@ -4224,21 +4219,29 @@ def _get_default_chunk_encoding_v3(
     """
     Get the default ArrayArrayCodecs, ArrayBytesCodec, and BytesBytesCodec for a given dtype.
     """
-    filters = ()
-    compressors = (ZstdCodec(level=0, checksum=False),)
     # TODO: find a registry-style solution for this that isn't bloated
     # We need to associate specific dtypes with specific encoding schemes
 
-    if isinstance(dtype, VariableLengthString):
-        serializer = VLenUTF8Codec()
-    elif isinstance(dtype, FixedLengthAsciiString):
-        serializer = VLenBytesCodec()
+    if dtype._zarr_v3_name in zarr_config.get("array.v3_default_filters"):
+        filters = zarr_config.get(f"array.v3_default_filters.{dtype._zarr_v3_name}")
     else:
-        if dtype.to_dtype().itemsize == 1:
-            serializer = BytesCodec(endian=None)
-        else:
-            serializer = BytesCodec()
-    return filters, serializer, compressors
+        filters = zarr_config.get("array.v3_default_filters.default")
+
+    if dtype._zarr_v3_name in zarr_config.get("array.v3_default_compressors"):
+        compressors = zarr_config.get(f"array.v3_default_compressors.{dtype._zarr_v3_name}")
+    else:
+        compressors = zarr_config.get("array.v3_default_compressors.default")
+
+    if dtype._zarr_v3_name in zarr_config.get("array.v3_default_serializer"):
+        serializer = zarr_config.get(f"array.v3_default_serializer.{dtype._zarr_v3_name}")
+    else:
+        serializer = zarr_config.get("array.v3_default_serializer.default")
+
+    return (
+        tuple(_parse_array_array_codec(f) for f in filters),
+        _parse_array_bytes_codec(serializer),
+        tuple(_parse_bytes_bytes_codec(c) for c in compressors),
+    )
 
 
 def _get_default_chunk_encoding_v2(
@@ -4256,7 +4259,11 @@ def _get_default_chunk_encoding_v2(
         compressor = zarr_config.get(f"array.v2_default_compressor.{dtype._zarr_v3_name}")
     else:
         compressor = zarr_config.get("array.v2_default_compressor.default")
-    return filters, compressor
+
+    if filters is not None:
+        filters = tuple(numcodecs.get_codec(f) for f in filters)
+
+    return filters, numcodecs.get_codec(compressor)
 
 
 def _parse_chunk_encoding_v2(

src/zarr/core/config.py

@@ -36,8 +36,6 @@
 if TYPE_CHECKING:
     from donfig.config_obj import ConfigSet
 
-from collections import defaultdict
-
 
 class BadConfigError(ValueError):
     _msg = "bad Config: %r"
@@ -82,15 +80,15 @@ def enable_gpu(self) -> ConfigSet:
                 "v2_default_compressor": {"default": {"id": "zstd", "level": 0, "checksum": False}},
                 "v2_default_filters": {
                     "default": None,
-                    "numpy.variable_length_unicode_string": [{"id": "vlen-utf8"}],
-                    "numpy.fixed_length_unicode_string": [{"id": "vlen-utf8"}],
-                    "r*": [{"id": "vlen-bytes"}],
+                    "variable_length_utf8": [{"id": "vlen-utf8"}],
+                    "fixed_length_ucs4": [{"id": "vlen-utf8"}],
+                    "fixed_length_ascii": [{"id": "vlen-bytes"}],
                 },
-                "v3_default_filters": defaultdict(list),
+                "v3_default_filters": {"default": ()},
                 "v3_default_serializer": {
                     "default": {"name": "bytes", "configuration": {"endian": "little"}},
-                    "numpy.variable_length_unicode_string": [{"name": "vlen-utf8"}],
-                    "numpy.fixed_length_unicode_string": [{"name": "vlen-utf8"}],
+                    "variable_length_utf8": {"name": "vlen-utf8"},
+                    "fixed_length_ucs4": {"name": "vlen-utf8"},
                     "r*": {"name": "vlen-bytes"},
                 },
                 "v3_default_compressors": {

src/zarr/core/dtype/_numpy.py

@@ -496,7 +496,7 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> np.complex1
 @dataclass(frozen=True, kw_only=True)
 class FixedLengthAsciiString(DTypeWrapper[np.dtypes.BytesDType[Any], np.bytes_]):
     dtype_cls = np.dtypes.BytesDType
-    _zarr_v3_name = "numpy.static_byte_string"
+    _zarr_v3_name = "fixed_length_ascii"
     item_size_bits: ClassVar[int] = 8
     length: int = 1
 
@@ -523,20 +523,20 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> np.bytes_:
 
 
 @dataclass(frozen=True, kw_only=True)
-class FixedLengthBytes(DTypeWrapper[np.dtypes.VoidDType[Any], np.void]):
+class FixedLengthBytes(DTypeWrapper[np.dtypes.VoidDType, np.void]):
     dtype_cls = np.dtypes.VoidDType
     _zarr_v3_name = "r*"
     item_size_bits: ClassVar[int] = 8
     length: int = 1
 
     @classmethod
-    def _from_dtype_unsafe(cls, dtype: np.dtypes.VoidDType[Any]) -> Self:
+    def _from_dtype_unsafe(cls, dtype: np.dtypes.VoidDType) -> Self:
         return cls(length=dtype.itemsize // (cls.item_size_bits // 8))
 
     def default_value(self) -> np.void:
         return self.cast_value(("\x00" * self.length).encode("ascii"))
 
-    def to_dtype(self) -> np.dtypes.VoidDType[Any]:
+    def to_dtype(self) -> np.dtypes.VoidDType:
         # Numpy does not allow creating a void type
         # by invoking np.dtypes.VoidDType directly
         return np.dtype(f"V{self.length}")
@@ -577,7 +577,7 @@ def check_dict(cls, data: dict[str, JSON]) -> TypeGuard[dict[str, JSON]]:
             isinstance(data, dict)
             and "name" in data
             and isinstance(data["name"], str)
-            and re.match(r"^r\d+$", data["name"])
+            and (re.match(r"^r\d+$", data["name"]) is not None)
         )
 
     def to_json_value(self, data: np.void, *, zarr_format: ZarrFormat) -> str:
@@ -592,7 +592,7 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> np.void:
 @dataclass(frozen=True, kw_only=True)
 class FixedLengthUnicodeString(DTypeWrapper[np.dtypes.StrDType[int], np.str_]):
     dtype_cls = np.dtypes.StrDType
-    _zarr_v3_name = "numpy.fixed_length_unicode_string"
+    _zarr_v3_name = "fixed_length_ucs4"
     item_size_bits: ClassVar[int] = 32  # UCS4 is 32 bits per code point
     endianness: Endianness | None = "native"
     length: int = 1
@@ -605,7 +605,10 @@ def _from_dtype_unsafe(cls, dtype: np.dtypes.StrDType[int]) -> Self:
         )
 
     def to_dtype(self) -> np.dtypes.StrDType[int]:
-        return self.dtype_cls(self.length).newbyteorder(endianness_to_numpy_str(self.endianness))
+        return cast(
+            np.dtypes.StrDType[int],
+            self.dtype_cls(self.length).newbyteorder(endianness_to_numpy_str(self.endianness)),
+        )
 
     def default_value(self) -> np.str_:
         return np.str_("")
@@ -627,7 +630,7 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> np.str_:
     @dataclass(frozen=True, kw_only=True)
     class VariableLengthString(DTypeWrapper[np.dtypes.StringDType, str]):
         dtype_cls = np.dtypes.StringDType
-        _zarr_v3_name = "numpy.variable_length_string"
+        _zarr_v3_name = "variable_length_utf8"
 
         @classmethod
         def _from_dtype_unsafe(cls, dtype: np.dtypes.StringDType) -> Self:
@@ -658,14 +661,14 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> str:
     @dataclass(frozen=True, kw_only=True)
     class VariableLengthString(DTypeWrapper[np.dtypes.ObjectDType, str]):
         dtype_cls = np.dtypes.ObjectDType
-        _zarr_v3_name = "numpy.variable_length_string"
+        _zarr_v3_name = "variable_length_utf8"
 
         @classmethod
         def _from_dtype_unsafe(cls, dtype: np.dtypes.ObjectDType) -> Self:
             return cls()
 
         def to_dtype(self) -> np.dtypes.ObjectDType:
-            return self.dtype_cls()
+            return cast(np.dtypes.ObjectDType, self.dtype_cls())
 
         def cast_value(self, value: object) -> str:
             return str(value)
@@ -695,7 +698,7 @@ def from_json_value(self, data: JSON, *, zarr_format: ZarrFormat) -> str:
 @dataclass(frozen=True, kw_only=True)
 class DateTime64(DTypeWrapper[np.dtypes.DateTime64DType, np.datetime64]):
     dtype_cls = np.dtypes.DateTime64DType
-    _zarr_v3_name = "numpy.datetime64"
+    _zarr_v3_name = "datetime64"
     unit: DateUnit | TimeUnit = "s"
     endianness: Endianness = "native"
 
@@ -713,7 +716,7 @@ def _from_dtype_unsafe(cls, dtype: np.dtypes.DateTime64DType) -> Self:
         return cls(unit=unit, endianness=endianness_from_numpy_str(dtype.byteorder))
 
     def cast_value(self, value: object) -> np.datetime64:
-        return self.to_dtype().type(value, self.unit)
+        return cast(np.datetime64, self.to_dtype().type(value, self.unit))
 
     def to_dtype(self) -> np.dtypes.DateTime64DType:
         # Numpy does not allow creating datetime64 via
@@ -734,14 +737,14 @@ def to_json_value(self, data: np.datetime64, *, zarr_format: ZarrFormat) -> int:
 @dataclass(frozen=True, kw_only=True)
 class Structured(DTypeWrapper[np.dtypes.VoidDType, np.void]):
     dtype_cls = np.dtypes.VoidDType
-    _zarr_v3_name = "numpy.structured"
+    _zarr_v3_name = "structured"
     fields: tuple[tuple[str, DTypeWrapper[Any, Any]], ...]
 
     def default_value(self) -> np.void:
         return self.cast_value(0)
 
     def cast_value(self, value: object) -> np.void:
-        return np.array([value], dtype=self.to_dtype())[0]
+        return cast(np.void, np.array([value], dtype=self.to_dtype())[0])
 
     @classmethod
     def check_dtype(cls, dtype: np.dtypes.DTypeLike) -> TypeGuard[np.dtypes.VoidDType]:
@@ -787,7 +790,7 @@ def to_dict(self) -> dict[str, JSON]:
         return base_dict
 
     @classmethod
-    def check_dict(cls, data: JSON) -> bool:
+    def check_dict(cls, data: JSON) -> TypeGuard[JSON]:
         return (
             isinstance(data, dict)
             and "name" in data