numcodecs 0.14.0__cp312-cp312-win_amd64.whl → 0.15.0__cp312-cp312-win_amd64.whl

numcodecs/tests/test_blosc.py

@@ -124,12 +124,12 @@ def test_compress_blocksize_default(use_threads):
 
     # default blocksize
     enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE)
-    _, _, blocksize = blosc.cbuffer_sizes(enc)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
     assert blocksize > 0
 
     # explicit default blocksize
     enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE, 0)
-    _, _, blocksize = blosc.cbuffer_sizes(enc)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
     assert blocksize > 0
 
 
@@ -140,7 +140,7 @@ def test_compress_blocksize(use_threads, bs):
     blosc.use_threads = use_threads
 
     enc = blosc.compress(arr, b'lz4', 1, Blosc.NOSHUFFLE, bs)
-    _, _, blocksize = blosc.cbuffer_sizes(enc)
+    _, _, blocksize = blosc._cbuffer_sizes(enc)
     assert blocksize == bs
 
 
@@ -174,7 +174,7 @@ def test_compress_metainfo(dtype, use_threads):
         blosc.use_threads = use_threads
         for cname in blosc.list_compressors():
             enc = blosc.compress(arr, cname.encode(), 1, shuffle)
-            typesize, did_shuffle, _ = blosc.cbuffer_metainfo(enc)
+            typesize, did_shuffle, _ = blosc._cbuffer_metainfo(enc)
             assert typesize == arr.dtype.itemsize
             assert did_shuffle == shuffle
 
@@ -186,7 +186,7 @@ def test_compress_autoshuffle(use_threads):
         blosc.use_threads = use_threads
         for cname in blosc.list_compressors():
             enc = blosc.compress(varr, cname.encode(), 1, Blosc.AUTOSHUFFLE)
-            typesize, did_shuffle, _ = blosc.cbuffer_metainfo(enc)
+            typesize, did_shuffle, _ = blosc._cbuffer_metainfo(enc)
             assert typesize == varr.dtype.itemsize
             if typesize == 1:
                 assert did_shuffle == Blosc.BITSHUFFLE
@@ -199,12 +199,12 @@ def test_config_blocksize():
     # explicitly stated
 
     # blocksize not stated
-    config = dict(cname='lz4', clevel=1, shuffle=Blosc.SHUFFLE)
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE}
     codec = Blosc.from_config(config)
     assert codec.blocksize == 0
 
     # blocksize stated
-    config = dict(cname='lz4', clevel=1, shuffle=Blosc.SHUFFLE, blocksize=2**8)
+    config = {"cname": 'lz4', "clevel": 1, "shuffle": Blosc.SHUFFLE, "blocksize": 2**8}
     codec = Blosc.from_config(config)
     assert codec.blocksize == 2**8
 
@@ -215,14 +215,12 @@ def test_backwards_compatibility():
 
 def _encode_worker(data):
     compressor = Blosc(cname='zlib', clevel=9, shuffle=Blosc.SHUFFLE)
-    enc = compressor.encode(data)
-    return enc
+    return compressor.encode(data)
 
 
 def _decode_worker(enc):
     compressor = Blosc()
-    data = compressor.decode(enc)
-    return data
+    return compressor.decode(enc)
 
 
 @pytest.mark.parametrize('pool', [Pool, ThreadPool])

numcodecs/tests/test_checksum32.py

@@ -1,9 +1,10 @@
 import itertools
+from contextlib import suppress
 
 import numpy as np
 import pytest
 
-from numcodecs.checksum32 import CRC32, CRC32C, Adler32
+from numcodecs.checksum32 import CRC32, Adler32
 from numcodecs.tests.common import (
     check_backwards_compatibility,
     check_config,
@@ -13,6 +14,12 @@ from numcodecs.tests.common import (
     check_repr,
 )
 
+has_crc32c = False
+with suppress(ImportError):
+    from numcodecs.checksum32 import CRC32C
+
+    has_crc32c = True
+
 # mix of dtypes: integer, float, bool, string
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F
@@ -35,11 +42,16 @@ arrays = [
 codecs = [
     CRC32(),
     CRC32(location="end"),
-    CRC32C(location="start"),
-    CRC32C(),
     Adler32(),
     Adler32(location="end"),
 ]
+if has_crc32c:
+    codecs.extend(
+        [
+            CRC32C(location="start"),
+            CRC32C(),
+        ]
+    )
 
 
 @pytest.mark.parametrize(("codec", "arr"), itertools.product(codecs, arrays))
@@ -84,25 +96,28 @@ def test_err_encode_list(codec):
 def test_err_location():
     with pytest.raises(ValueError):
         CRC32(location="foo")
-    with pytest.raises(ValueError):
-        CRC32C(location="foo")
     with pytest.raises(ValueError):
         Adler32(location="foo")
+    if has_crc32c:
+        with pytest.raises(ValueError):
+            CRC32C(location="foo")
 
 
 def test_repr():
     check_repr("CRC32(location='start')")
-    check_repr("CRC32C(location='start')")
-    check_repr("Adler32(location='start')")
     check_repr("CRC32(location='end')")
-    check_repr("CRC32C(location='end')")
+    check_repr("Adler32(location='start')")
     check_repr("Adler32(location='end')")
+    if has_crc32c:
+        check_repr("CRC32C(location='start')")
+        check_repr("CRC32C(location='end')")
 
 
 def test_backwards_compatibility():
     check_backwards_compatibility(CRC32.codec_id, arrays, [CRC32()])
     check_backwards_compatibility(Adler32.codec_id, arrays, [Adler32()])
-    check_backwards_compatibility(CRC32C.codec_id, arrays, [CRC32C()])
+    if has_crc32c:
+        check_backwards_compatibility(CRC32C.codec_id, arrays, [CRC32C()])
 
 
 @pytest.mark.parametrize("codec", codecs)
@@ -123,6 +138,7 @@ def test_err_out_too_small(codec):
         codec.decode(codec.encode(arr), out)
 
 
+@pytest.mark.skipif(not has_crc32c, reason="Needs `crc32c` installed")
 def test_crc32c_checksum():
     arr = np.arange(0, 64, dtype="uint8")
     buf = CRC32C(location="end").encode(arr)

numcodecs/tests/test_lzma.py

@@ -29,7 +29,7 @@ codecs = [
     LZMA(preset=1),
     LZMA(preset=5),
     LZMA(preset=9),
-    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)]),
+    LZMA(format=_lzma.FORMAT_RAW, filters=[{"id": _lzma.FILTER_LZMA2, "preset": 1}]),
 ]
 
 

numcodecs/tests/test_pcodec.py

@@ -1,11 +1,8 @@
 import numpy as np
 import pytest
 
-from numcodecs.pcodec import PCodec
-
 try:
-    # initializing codec triggers ImportError
-    PCodec()
+    from numcodecs.pcodec import PCodec
 except ImportError:  # pragma: no cover
     pytest.skip("pcodec not available", allow_module_level=True)
 
@@ -23,8 +20,12 @@ codecs = [
     PCodec(level=1),
     PCodec(level=5),
     PCodec(level=9),
-    PCodec(mode_spec='classic'),
+    PCodec(mode_spec="classic"),
     PCodec(equal_pages_up_to=300),
+    PCodec(delta_encoding_order=2),
+    PCodec(delta_spec="try_lookback"),
+    PCodec(delta_spec="none"),
+    PCodec(delta_spec="try_consecutive", delta_encoding_order=1),
 ]
 
 
@@ -56,15 +57,24 @@ def test_config():
     check_config(codec)
 
 
-def test_invalid_config_error():
-    codec = PCodec(mode_spec='bogus')
+@pytest.mark.parametrize("param", ["mode_spec", "delta_spec", "paging_spec"])
+def test_invalid_config_error(param):
+    codec = PCodec(**{param: "bogus"})
+    with pytest.raises(ValueError):
+        check_encode_decode_array_to_bytes(arrays[0], codec)
+
+
+def test_invalid_delta_encoding_combo():
+    codec = PCodec(delta_encoding_order=2, delta_spec="none")
     with pytest.raises(ValueError):
         check_encode_decode_array_to_bytes(arrays[0], codec)
 
 
 def test_repr():
     check_repr(
-        "PCodec(delta_encoding_order=None, equal_pages_up_to=262144, level=3, mode_spec='auto')"
+        "PCodec(delta_encoding_order=None, delta_spec='auto',"
+        " equal_pages_up_to=262144, level=3, mode_spec='auto',"
+        " paging_spec='equal_pages_up_to')"
     )
 
 

numcodecs/tests/test_registry.py

@@ -26,7 +26,7 @@ def test_all_classes_registered():
 
     see #346 for more info
     """
-    missing = set(
+    missing = {
         obj.codec_id
         for _, submod in inspect.getmembers(numcodecs, inspect.ismodule)
         for _, obj in inspect.getmembers(submod)
@@ -36,7 +36,7 @@ def test_all_classes_registered():
             and obj.codec_id not in numcodecs.registry.codec_registry
             and obj.codec_id is not None  # remove `None`
         )
-    )
+    }
 
     if missing:
         raise Exception(f"these codecs are missing: {missing}")  # pragma: no cover

numcodecs/tests/test_shuffle.py

@@ -79,14 +79,12 @@ def test_eq():
 
 def _encode_worker(data):
     compressor = Shuffle()
-    enc = compressor.encode(data)
-    return enc
+    return compressor.encode(data)
 
 
 def _decode_worker(enc):
     compressor = Shuffle()
-    data = compressor.decode(enc)
-    return data
+    return compressor.decode(enc)
 
 
 @pytest.mark.parametrize('pool', [Pool, ThreadPool])

numcodecs/tests/test_vlen_bytes.py

@@ -84,6 +84,9 @@ def test_decode_errors():
         codec.decode(enc, out=np.zeros(10, dtype='i4'))
 
 
+# TODO: fix this test on GitHub actions somehow...
+# See https://github.com/zarr-developers/numcodecs/issues/683
+@pytest.mark.skip("Test is failing on GitHub actions.")
 def test_encode_none():
     a = np.array([b'foo', None, b'bar'], dtype=object)
     codec = VLenBytes()

numcodecs/tests/test_zarr3.py

@@ -5,10 +5,10 @@ from typing import TYPE_CHECKING
 import numpy as np
 import pytest
 
-if not TYPE_CHECKING:
-    zarr = pytest.importorskip("zarr")
-else:
+if TYPE_CHECKING:  # pragma: no cover
     import zarr
+else:
+    zarr = pytest.importorskip("zarr")
 
 import zarr.storage
 from zarr.core.common import JSON
@@ -36,7 +36,7 @@ EXPECTED_WARNING_STR = "Numcodecs codecs are not in the Zarr version 3.*"
 
 @pytest.fixture
 def store() -> StorePath:
-    return StorePath(MemoryStore(mode="w"))
+    return StorePath(MemoryStore(read_only=False))
 
 
 ALL_CODECS = [getattr(numcodecs.zarr3, cls_name) for cls_name in numcodecs.zarr3.__all__]
@@ -50,9 +50,7 @@ def test_entry_points(codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
 
 @pytest.mark.parametrize("codec_class", ALL_CODECS)
 def test_docstring(codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
-    if codec_class.__doc__ is None:
-        pytest.skip()
-    assert "See :class:`numcodecs." in codec_class.__doc__
+    assert "See :class:`numcodecs." in codec_class.__doc__  # type: ignore[operator]
 
 
 @pytest.mark.parametrize(
@@ -68,17 +66,19 @@ def test_docstring(codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
         numcodecs.zarr3.Shuffle,
     ],
 )
-def test_generic_codec_class(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+def test_generic_compressor(
+    store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsBytesBytesCodec]
+):
     data = np.arange(0, 256, dtype="uint16").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[BytesCodec(), codec_class()],
+            compressors=[codec_class()],
         )
 
     a[:, :] = data.copy()
@@ -102,26 +102,25 @@ def test_generic_codec_class(store: StorePath, codec_class: type[numcodecs.zarr3
 )
 def test_generic_filter(
     store: StorePath,
-    codec_class: type[numcodecs.zarr3._NumcodecsCodec],
+    codec_class: type[numcodecs.zarr3._NumcodecsArrayArrayCodec],
     codec_config: dict[str, JSON],
 ):
     data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[
+            filters=[
                 codec_class(**codec_config),
-                BytesCodec(),
             ],
         )
 
         a[:, :] = data.copy()
-        a = Array.open(store / "generic")
+        a = zarr.open_array(store / "generic", mode="r")
     np.testing.assert_array_equal(data, a[:, :])
 
 
@@ -129,17 +128,17 @@ def test_generic_filter_bitround(store: StorePath):
     data = np.linspace(0, 1, 256, dtype="float32").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic_bitround",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[numcodecs.zarr3.BitRound(keepbits=3), BytesCodec()],
+            filters=[numcodecs.zarr3.BitRound(keepbits=3)],
         )
 
         a[:, :] = data.copy()
-        a = Array.open(store / "generic_bitround")
+        a = zarr.open_array(store / "generic_bitround", mode="r")
     assert np.allclose(data, a[:, :], atol=0.1)
 
 
@@ -147,17 +146,17 @@ def test_generic_filter_quantize(store: StorePath):
     data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic_quantize",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[numcodecs.zarr3.Quantize(digits=3), BytesCodec()],
+            filters=[numcodecs.zarr3.Quantize(digits=3)],
         )
 
         a[:, :] = data.copy()
-        a = Array.open(store / "generic_quantize")
+        a = zarr.open_array(store / "generic_quantize", mode="r")
     assert np.allclose(data, a[:, :], atol=0.001)
 
 
@@ -166,27 +165,27 @@ def test_generic_filter_packbits(store: StorePath):
     data[0:4, :] = True
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic_packbits",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[numcodecs.zarr3.PackBits(), BytesCodec()],
+            filters=[numcodecs.zarr3.PackBits()],
         )
 
         a[:, :] = data.copy()
-        a = Array.open(store / "generic_packbits")
+        a = zarr.open_array(store / "generic_packbits", mode="r")
     np.testing.assert_array_equal(data, a[:, :])
 
     with pytest.raises(ValueError, match=".*requires bool dtype.*"):
-        Array.create(
+        zarr.create_array(
             store / "generic_packbits_err",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype="uint32",
             fill_value=0,
-            codecs=[numcodecs.zarr3.PackBits(), BytesCodec()],
+            filters=[numcodecs.zarr3.PackBits()],
         )
 
 
@@ -200,26 +199,30 @@ def test_generic_filter_packbits(store: StorePath):
         numcodecs.zarr3.JenkinsLookup3,
     ],
 )
-def test_generic_checksum(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+def test_generic_checksum(
+    store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsBytesBytesCodec]
+):
     data = np.linspace(0, 10, 256, dtype="float32").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic_checksum",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[BytesCodec(), codec_class()],
+            compressors=[codec_class()],
         )
 
         a[:, :] = data.copy()
-        a = Array.open(store / "generic_checksum")
+        a = zarr.open_array(store / "generic_checksum", mode="r")
     np.testing.assert_array_equal(data, a[:, :])
 
 
 @pytest.mark.parametrize("codec_class", [numcodecs.zarr3.PCodec, numcodecs.zarr3.ZFPY])
-def test_generic_bytes_codec(store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsCodec]):
+def test_generic_bytes_codec(
+    store: StorePath, codec_class: type[numcodecs.zarr3._NumcodecsArrayBytesCodec]
+):
     try:
         codec_class()._codec  # noqa: B018
     except ValueError as e:
@@ -227,22 +230,45 @@ def test_generic_bytes_codec(store: StorePath, codec_class: type[numcodecs.zarr3
             pytest.xfail(f"{codec_class.codec_name} is not available: {e}")
         else:
             raise  # pragma: no cover
-    except ImportError as e:
+    except ImportError as e:  # pragma: no cover
         pytest.xfail(f"{codec_class.codec_name} is not available: {e}")
 
     data = np.arange(0, 256, dtype="float32").reshape((16, 16))
 
     with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
-        a = Array.create(
+        a = zarr.create_array(
             store / "generic",
             shape=data.shape,
-            chunk_shape=(16, 16),
+            chunks=(16, 16),
             dtype=data.dtype,
             fill_value=0,
-            codecs=[
-                codec_class(),
-            ],
+            serializer=codec_class(),
         )
 
     a[:, :] = data.copy()
     np.testing.assert_array_equal(data, a[:, :])
+
+
+def test_delta_astype(store: StorePath):
+    data = np.linspace(0, 10, 256, dtype="i8").reshape((16, 16))
+
+    with pytest.warns(UserWarning, match=EXPECTED_WARNING_STR):
+        a = zarr.create_array(
+            store / "generic",
+            shape=data.shape,
+            chunks=(16, 16),
+            dtype=data.dtype,
+            fill_value=0,
+            filters=[
+                numcodecs.zarr3.Delta(dtype="i8", astype="i2"),  # type: ignore[arg-type]
+            ],
+        )
+
+        a[:, :] = data.copy()
+        a = zarr.open_array(store / "generic", mode="r")
+    np.testing.assert_array_equal(data, a[:, :])
+
+
+def test_repr():
+    codec = numcodecs.zarr3.LZ4(level=5)
+    assert repr(codec) == "LZ4(codec_name='numcodecs.lz4', codec_config={'level': 5})"

numcodecs/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.14.0'
-__version_tuple__ = version_tuple = (0, 14, 0)
+__version__ = version = '0.15.0'
+__version_tuple__ = version_tuple = (0, 15, 0)

numcodecs/zarr3.py

@@ -8,12 +8,13 @@ You can use codecs from :py:mod:`numcodecs` by constructing codecs from :py:mod:
 >>> import zarr
 >>> import numcodecs.zarr3
 >>>
->>> codecs = [zarr.codecs.BytesCodec(), numcodecs.zarr3.BZ2(level=5)]
->>> array = zarr.open(
-...   "data.zarr", mode="w",
-...   shape=(1024, 1024), chunks=(64, 64),
+>>> array = zarr.create_array(
+...   store="data.zarr",
+...   shape=(1024, 1024),
+...   chunks=(64, 64),
 ...   dtype="uint32",
-...   codecs=codecs)
+...   filters=[numcodecs.zarr3.Delta()],
+...   compressors=[numcodecs.zarr3.BZ2(level=5)])
 >>> array[:] = np.arange(*array.shape).astype(array.dtype)
 
 .. note::
@@ -40,8 +41,10 @@ try:
 
     if zarr.__version__ < "3.0.0":  # pragma: no cover
         raise ImportError("zarr 3.0.0 or later is required to use the numcodecs zarr integration.")
-except ImportError:  # pragma: no cover
-    raise ImportError("zarr 3.0.0 or later is required to use the numcodecs zarr integration.")
+except ImportError as e:  # pragma: no cover
+    raise ImportError(
+        "zarr 3.0.0 or later is required to use the numcodecs zarr integration."
+    ) from e
 
 from zarr.abc.codec import ArrayArrayCodec, ArrayBytesCodec, BytesBytesCodec
 from zarr.abc.metadata import Metadata
@@ -95,6 +98,7 @@ class _NumcodecsCodec(Metadata):
             "Numcodecs codecs are not in the Zarr version 3 specification and "
             "may not be supported by other zarr implementations.",
             category=UserWarning,
+            stacklevel=2,
         )
 
     @cached_property
@@ -116,6 +120,12 @@ class _NumcodecsCodec(Metadata):
     def compute_encoded_size(self, input_byte_length: int, chunk_spec: ArraySpec) -> int:
         raise NotImplementedError  # pragma: no cover
 
+    # Override __repr__ because dynamically constructed classes don't seem to work otherwise
+    def __repr__(self) -> str:
+        codec_config = self.codec_config.copy()
+        codec_config.pop("id", None)
+        return f"{self.__class__.__name__}(codec_name={self.codec_name!r}, codec_config={codec_config!r})"
+
 
 class _NumcodecsBytesBytesCodec(_NumcodecsCodec, BytesBytesCodec):
     def __init__(self, **codec_config: JSON) -> None:
@@ -266,7 +276,19 @@ class Shuffle(_NumcodecsBytesBytesCodec):
 
 
 # array-to-array codecs ("filters")
-Delta = _add_docstring(_make_array_array_codec("delta", "Delta"), "numcodecs.delta.Delta")
+@_add_docstring_wrapper("numcodecs.delta.Delta")
+class Delta(_NumcodecsArrayArrayCodec):
+    codec_name = f"{CODEC_PREFIX}delta"
+
+    def __init__(self, **codec_config: dict[str, JSON]) -> None:
+        super().__init__(**codec_config)
+
+    def resolve_metadata(self, chunk_spec: ArraySpec) -> ArraySpec:
+        if astype := self.codec_config.get("astype"):
+            return replace(chunk_spec, dtype=np.dtype(astype))  # type: ignore[arg-type]
+        return chunk_spec
+
+
 BitRound = _add_docstring(
     _make_array_array_codec("bitround", "BitRound"), "numcodecs.bitround.BitRound"
 )
@@ -355,25 +377,25 @@ PCodec = _add_docstring(_make_array_bytes_codec("pcodec", "PCodec"), "numcodecs.
 ZFPY = _add_docstring(_make_array_bytes_codec("zfpy", "ZFPY"), "numcodecs.zfpy.ZFPY")
 
 __all__ = [
-    "Blosc",
-    "LZ4",
-    "Zstd",
-    "Zlib",
-    "GZip",
     "BZ2",
-    "LZMA",
-    "Shuffle",
-    "Delta",
-    "BitRound",
-    "FixedScaleOffset",
-    "Quantize",
-    "PackBits",
-    "AsType",
     "CRC32",
     "CRC32C",
+    "LZ4",
+    "LZMA",
+    "ZFPY",
     "Adler32",
+    "AsType",
+    "BitRound",
+    "Blosc",
+    "Delta",
+    "FixedScaleOffset",
     "Fletcher32",
+    "GZip",
     "JenkinsLookup3",
     "PCodec",
-    "ZFPY",
+    "PackBits",
+    "Quantize",
+    "Shuffle",
+    "Zlib",
+    "Zstd",
 ]

numcodecs/zfpy.py

@@ -13,7 +13,7 @@ with suppress(PackageNotFoundError):
 if _zfpy_version:
     # Check NumPy version
     _numpy_version: tuple = tuple(map(int, version("numpy").split('.')))
-    if _numpy_version >= (2, 0, 0) and _zfpy_version <= (1, 0, 1):  # pragma: no cover
+    if _numpy_version >= (2, 0, 0) and _zfpy_version < (1, 0, 1):  # pragma: no cover
         _zfpy_version = ()
         warnings.warn(
             "NumPy version >= 2.0.0 detected. The zfpy library is incompatible with this version of NumPy. "