route requests for v2 codecs to use the v3-adapted codecs

Author: d-v-b

src/zarr/codecs/__init__.py

@@ -7,25 +7,21 @@
 from zarr.codecs.numcodecs import (
     BZ2,
     CRC32,
-    CRC32C,
     LZ4,
     LZMA,
     ZFPY,
     Adler32,
     AsType,
     BitRound,
-    Blosc,
     Delta,
     FixedScaleOffset,
     Fletcher32,
-    GZip,
     JenkinsLookup3,
     PackBits,
     PCodec,
     Quantize,
     Shuffle,
     Zlib,
-    Zstd,
 )
 from zarr.codecs.sharding import ShardingCodec, ShardingCodecIndexLocation
 from zarr.codecs.transpose import TransposeCodec
@@ -65,29 +61,46 @@
 # Register all the codecs formerly contained in numcodecs.zarr3
 
 register_codec("numcodecs.bz2", BZ2, qualname="zarr.codecs.numcodecs.BZ2")
+register_codec("bz2", BZ2, qualname="zarr.codecs.numcodecs.BZ2")
 register_codec("numcodecs.crc32", CRC32, qualname="zarr.codecs.numcodecs.CRC32")
-register_codec("numcodecs.crc32c", CRC32C, qualname="zarr.codecs.numcodecs.CRC32C")
+register_codec("crc32", CRC32, qualname="zarr.codecs.numcodecs.CRC32")
 register_codec("numcodecs.lz4", LZ4, qualname="zarr.codecs.numcodecs.LZ4")
+register_codec("lz4", LZ4, qualname="zarr.codecs.numcodecs.LZ4")
 register_codec("numcodecs.lzma", LZMA, qualname="zarr.codecs.numcodecs.LZMA")
+register_codec("lzma", LZMA, qualname="zarr.codecs.numcodecs.LZMA")
 register_codec("numcodecs.zfpy", ZFPY, qualname="zarr.codecs.numcodecs.ZFPY")
+register_codec("zfpy", ZFPY, qualname="zarr.codecs.numcodecs.ZFPY")
 register_codec("numcodecs.adler32", Adler32, qualname="zarr.codecs.numcodecs.Adler32")
+register_codec("adler32", Adler32, qualname="zarr.codecs.numcodecs.Adler32")
 register_codec("numcodecs.astype", AsType, qualname="zarr.codecs.numcodecs.AsType")
+register_codec("astype", AsType, qualname="zarr.codecs.numcodecs.AsType")
 register_codec("numcodecs.bitround", BitRound, qualname="zarr.codecs.numcodecs.BitRound")
-register_codec("numcodecs.blosc", Blosc, qualname="zarr.codecs.numcodecs.Blosc")
+register_codec("bitround", BitRound, qualname="zarr.codecs.numcodecs.BitRound")
 register_codec("numcodecs.delta", Delta, qualname="zarr.codecs.numcodecs.Delta")
+register_codec("delta", Delta, qualname="zarr.codecs.numcodecs.Delta")
 register_codec(
     "numcodecs.fixedscaleoffset",
     FixedScaleOffset,
     qualname="zarr.codecs.numcodecs.FixedScaleOffset",
 )
+register_codec(
+    "fixedscaleoffset",
+    FixedScaleOffset,
+    qualname="zarr.codecs.numcodecs.FixedScaleOffset",
+)
 register_codec("numcodecs.fletcher32", Fletcher32, qualname="zarr.codecs.numcodecs.Fletcher32")
-register_codec("numcodecs.gzip", GZip, qualname="zarr.codecs.numcodecs.GZip")
+register_codec("fletcher32", Fletcher32, qualname="zarr.codecs.numcodecs.Fletcher32")
 register_codec(
     "numcodecs.jenkins_lookup3", JenkinsLookup3, qualname="zarr.codecs.numcodecs.JenkinsLookup3"
 )
+register_codec("jenkins_lookup3", JenkinsLookup3, qualname="zarr.codecs.numcodecs.JenkinsLookup3")
 register_codec("numcodecs.pcodec", PCodec, qualname="zarr.codecs.numcodecs.pcodec")
+register_codec("pcodec", PCodec, qualname="zarr.codecs.numcodecs.pcodec")
 register_codec("numcodecs.packbits", PackBits, qualname="zarr.codecs.numcodecs.PackBits")
+register_codec("packbits", PackBits, qualname="zarr.codecs.numcodecs.PackBits")
 register_codec("numcodecs.quantize", Quantize, qualname="zarr.codecs.numcodecs.Quantize")
+register_codec("quantize", Quantize, qualname="zarr.codecs.numcodecs.Quantize")
 register_codec("numcodecs.shuffle", Shuffle, qualname="zarr.codecs.numcodecs.Shuffle")
+register_codec("shuffle", Shuffle, qualname="zarr.codecs.numcodecs.Shuffle")
 register_codec("numcodecs.zlib", Zlib, qualname="zarr.codecs.numcodecs.Zlib")
-register_codec("numcodecs.zstd", Zstd, qualname="zarr.codecs.numcodecs.Zstd")
+register_codec("zlib", Zlib, qualname="zarr.codecs.numcodecs.Zlib")

src/zarr/codecs/_v2.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Mapping
 from dataclasses import dataclass
 from functools import cached_property
-from typing import TYPE_CHECKING, ClassVar, Literal, Self, overload
+from typing import TYPE_CHECKING, Literal, Self, overload
 
 import numpy as np
 from numcodecs.compat import ensure_bytes, ensure_ndarray_like
@@ -16,16 +15,18 @@
     CodecJSON,
     CodecJSON_V2,
 )
-from zarr.core.chunk_grids import ChunkGrid
-from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar, ZDType
 from zarr.registry import get_ndbuffer_class
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping
+
     from zarr.abc.numcodec import Numcodec
     from zarr.core.array_spec import ArraySpec
     from zarr.core.buffer import Buffer, NDBuffer
     from zarr.core.buffer.core import BufferPrototype
+    from zarr.core.chunk_grids import ChunkGrid
     from zarr.core.common import BaseConfig, NamedConfig, ZarrFormat
+    from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar, ZDType
 
 
 @dataclass(frozen=True)
@@ -114,7 +115,7 @@ def compute_encoded_size(self, _input_byte_length: int, _chunk_spec: ArraySpec)
 
 @dataclass(frozen=True, kw_only=True)
 class NumcodecsWrapper:
-    codec_cls: ClassVar[type[Numcodec]]
+    codec_cls: type[Numcodec]
     config: Mapping[str, object]
 
     @cached_property
@@ -128,7 +129,7 @@ def to_json(self, zarr_format: Literal[3]) -> NamedConfig[str, BaseConfig]: ...
 
     def to_json(self, zarr_format: ZarrFormat) -> CodecJSON_V2[str] | NamedConfig[str, BaseConfig]:
         if zarr_format == 2:
-            return {"id": self.codec_cls.codec_id, **self.config}
+            return self.config
         elif zarr_format == 3:
             config = self.codec.get_config()
             config_no_id = {k: v for k, v in config.items() if k != "id"}
@@ -184,19 +185,19 @@ def to_array_array(self) -> NumcodecsArrayArrayCodec:
         """
         Use the ``_codec`` attribute to create a NumcodecsArrayArrayCodec.
         """
-        return NumcodecsArrayArrayCodec(config=self.config)
+        return NumcodecsArrayArrayCodec(cls=self.codec_cls, config=self.config)
 
     def to_bytes_bytes(self) -> NumcodecsBytesBytesCodec:
         """
         Use the ``_codec`` attribute to create a NumcodecsBytesBytesCodec.
         """
-        return NumcodecsBytesBytesCodec(config=self.config)
+        return NumcodecsBytesBytesCodec(cls=self.codec_cls, config=self.config)
 
     def to_array_bytes(self) -> NumcodecsArrayBytesCodec:
         """
         Use the ``_codec`` attribute to create a NumcodecsArrayBytesCodec.
         """
-        return NumcodecsArrayBytesCodec(config=self.config)
+        return NumcodecsArrayBytesCodec(codec_cls=self.codec_cls, config=self.config)
 
 
 class NumcodecsBytesBytesCodec(NumcodecsWrapper, BytesBytesCodec):

src/zarr/codecs/blosc.py

@@ -134,10 +134,10 @@ def parse_shuffle(data: object) -> BloscShuffle:
 class BloscCodec(BytesBytesCodec):
     is_fixed_size = False
 
-    typesize: int
+    typesize: int | None
     cname: BloscCname
     clevel: int
-    shuffle: BloscShuffle
+    shuffle: BloscShuffle | None
     blocksize: int
 
     def __init__(
@@ -149,10 +149,10 @@ def __init__(
         shuffle: BloscShuffle | None = None,
         blocksize: int = 0,
     ) -> None:
-        typesize_parsed = parse_typesize(typesize) if typesize is not None else 1
+        typesize_parsed = parse_typesize(typesize) if typesize is not None else None
         cname_parsed = parse_cname(cname)
         clevel_parsed = parse_clevel(clevel)
-        shuffle_parsed = parse_shuffle(shuffle) if shuffle is not None else "noshuffle"
+        shuffle_parsed = parse_shuffle(shuffle) if shuffle is not None else None
         blocksize_parsed = parse_blocksize(blocksize)
 
         object.__setattr__(self, "typesize", typesize_parsed)
@@ -166,7 +166,20 @@ def from_dict(cls, data: dict[str, JSON]) -> Self:
         return cls.from_json(data, zarr_format=3)
 
     def to_dict(self) -> dict[str, JSON]:
-        return self.to_json(zarr_format=3)
+        if self.shuffle is None:
+            raise ValueError("`shuffle` must be set to serialize to zarr format 3")
+        if self.typesize is None:
+            raise ValueError("`typesize` must be set to serialize to zarr format 3")
+        return {
+            "name": "blosc",
+            "configuration": {
+                "clevel": self.clevel,
+                "cname": self.cname,
+                "shuffle": self.shuffle,
+                "typesize": self.typesize,
+                "blocksize": self.blocksize,
+            },
+        }
 
     @classmethod
     def _from_json_v2(cls, data: CodecJSON) -> Self:
@@ -176,7 +189,7 @@ def _from_json_v2(cls, data: CodecJSON) -> Self:
                 clevel=data["clevel"],
                 shuffle=BLOSC_SHUFFLE[data["shuffle"]],
                 blocksize=data["blocksize"],
-                typesize=data.get("typesize", None),
+                typesize=data.get("typesize", 1),
             )
         msg = (
             "Invalid Zarr V2 JSON representation of the blosc codec. "
@@ -208,6 +221,8 @@ def to_json(self, zarr_format: Literal[3]) -> BloscJSON_V3: ...
 
     def to_json(self, zarr_format: ZarrFormat) -> BloscJSON_V2 | BloscJSON_V3:
         if zarr_format == 2:
+            if self.shuffle is None:
+                raise ValueError("`shuffle` must be set to serialize to zarr format 2")
             return {
                 "id": "blosc",
                 "clevel": self.clevel,
@@ -216,16 +231,7 @@ def to_json(self, zarr_format: ZarrFormat) -> BloscJSON_V2 | BloscJSON_V3:
                 "blocksize": self.blocksize,
             }
         elif zarr_format == 3:
-            return {
-                "name": "blosc",
-                "configuration": {
-                    "clevel": self.clevel,
-                    "cname": self.cname,
-                    "shuffle": self.shuffle,
-                    "typesize": self.typesize,
-                    "blocksize": self.blocksize,
-                },
-            }
+            return self.to_dict()  # type: ignore[return-value]
         raise ValueError(
             f"Unsupported Zarr format {zarr_format}. Expected 2 or 3."
         )  # pragma: no cover
@@ -246,6 +252,8 @@ def evolve_from_array_spec(self, array_spec: ArraySpec) -> Self:
     def _blosc_codec(self) -> Blosc:
         if self.shuffle is None:
             raise ValueError("`shuffle` needs to be set for decoding and encoding.")
+        if self.typesize is None:
+            raise ValueError("`typesize` needs to be set for decoding and encoding.")
         config_dict = {
             "cname": self.cname,
             "clevel": self.clevel,