numcodecs 0.13.0__cp311-cp311-macosx_11_0_arm64.whl → 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

numcodecs/tests/test_zstd.py

@@ -1,10 +1,8 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.zstd import Zstd
 except ImportError:  # pragma: no cover
@@ -12,15 +10,14 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 codecs = [
     Zstd(),
     Zstd(level=-1),
@@ -90,6 +87,6 @@ def test_checksum():
 
 def test_native_functions():
     # Note, these assertions might need to be changed for new versions of zstd
-    assert Zstd.default_level == 3
-    assert Zstd.min_level == -131072
-    assert Zstd.max_level == 22
+    assert Zstd.default_level() == 3
+    assert Zstd.min_level() == -131072
+    assert Zstd.max_level() == 22

numcodecs/version.py

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

numcodecs/zarr3.py

@@ -0,0 +1,379 @@
+"""
+This module provides the compatibility for :py:mod:`numcodecs` in Zarr version 3.
+
+A compatibility module is required because the codec handling in Zarr version 3 is different from Zarr version 2.
+
+You can use codecs from :py:mod:`numcodecs` by constructing codecs from :py:mod:`numcodecs.zarr3` using the same parameters as the original codecs.
+
+>>> 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),
+...   dtype="uint32",
+...   codecs=codecs)
+>>> array[:] = np.arange(*array.shape).astype(array.dtype)
+
+.. note::
+
+    Please note that the codecs in :py:mod:`numcodecs.zarr3` are not part of the Zarr version 3 specification.
+    Using these codecs might cause interoperability issues with other Zarr implementations.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import math
+from dataclasses import dataclass, replace
+from functools import cached_property, partial
+from typing import Any, Self, TypeVar
+from warnings import warn
+
+import numpy as np
+
+import numcodecs
+
+try:
+    import zarr
+
+    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.")
+
+from zarr.abc.codec import ArrayArrayCodec, ArrayBytesCodec, BytesBytesCodec
+from zarr.abc.metadata import Metadata
+from zarr.core.array_spec import ArraySpec
+from zarr.core.buffer import Buffer, BufferPrototype, NDBuffer
+from zarr.core.buffer.cpu import as_numpy_array_wrapper
+from zarr.core.common import JSON, parse_named_configuration, product
+
+CODEC_PREFIX = "numcodecs."
+
+
+def _expect_name_prefix(codec_name: str) -> str:
+    if not codec_name.startswith(CODEC_PREFIX):
+        raise ValueError(
+            f"Expected name to start with '{CODEC_PREFIX}'. Got {codec_name} instead."
+        )  # pragma: no cover
+    return codec_name.removeprefix(CODEC_PREFIX)
+
+
+def _parse_codec_configuration(data: dict[str, JSON]) -> dict[str, JSON]:
+    parsed_name, parsed_configuration = parse_named_configuration(data)
+    if not parsed_name.startswith(CODEC_PREFIX):
+        raise ValueError(
+            f"Expected name to start with '{CODEC_PREFIX}'. Got {parsed_name} instead."
+        )  # pragma: no cover
+    id = _expect_name_prefix(parsed_name)
+    return {"id": id, **parsed_configuration}
+
+
+@dataclass(frozen=True)
+class _NumcodecsCodec(Metadata):
+    codec_name: str
+    codec_config: dict[str, JSON]
+
+    def __init__(self, **codec_config: JSON) -> None:
+        if not self.codec_name:
+            raise ValueError(
+                "The codec name needs to be supplied through the `codec_name` attribute."
+            )  # pragma: no cover
+        unprefixed_codec_name = _expect_name_prefix(self.codec_name)
+
+        if "id" not in codec_config:
+            codec_config = {"id": unprefixed_codec_name, **codec_config}
+        elif codec_config["id"] != unprefixed_codec_name:
+            raise ValueError(
+                f"Codec id does not match {unprefixed_codec_name}. Got: {codec_config['id']}."
+            )  # pragma: no cover
+
+        object.__setattr__(self, "codec_config", codec_config)
+        warn(
+            "Numcodecs codecs are not in the Zarr version 3 specification and "
+            "may not be supported by other zarr implementations.",
+            category=UserWarning,
+        )
+
+    @cached_property
+    def _codec(self) -> numcodecs.abc.Codec:
+        return numcodecs.get_codec(self.codec_config)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, JSON]) -> Self:
+        codec_config = _parse_codec_configuration(data)
+        return cls(**codec_config)
+
+    def to_dict(self) -> dict[str, JSON]:
+        codec_config = self.codec_config.copy()
+        return {
+            "name": self.codec_name,
+            "configuration": codec_config,
+        }
+
+    def compute_encoded_size(self, input_byte_length: int, chunk_spec: ArraySpec) -> int:
+        raise NotImplementedError  # pragma: no cover
+
+
+class _NumcodecsBytesBytesCodec(_NumcodecsCodec, BytesBytesCodec):
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    async def _decode_single(self, chunk_bytes: Buffer, chunk_spec: ArraySpec) -> Buffer:
+        return await asyncio.to_thread(
+            as_numpy_array_wrapper,
+            self._codec.decode,
+            chunk_bytes,
+            chunk_spec.prototype,
+        )
+
+    def _encode(self, chunk_bytes: Buffer, prototype: BufferPrototype) -> Buffer:
+        encoded = self._codec.encode(chunk_bytes.as_array_like())
+        if isinstance(encoded, np.ndarray):  # Required for checksum codecs
+            return prototype.buffer.from_bytes(encoded.tobytes())
+        return prototype.buffer.from_bytes(encoded)
+
+    async def _encode_single(self, chunk_bytes: Buffer, chunk_spec: ArraySpec) -> Buffer:
+        return await asyncio.to_thread(self._encode, chunk_bytes, chunk_spec.prototype)
+
+
+class _NumcodecsArrayArrayCodec(_NumcodecsCodec, ArrayArrayCodec):
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    async def _decode_single(self, chunk_array: NDBuffer, chunk_spec: ArraySpec) -> NDBuffer:
+        chunk_ndarray = chunk_array.as_ndarray_like()
+        out = await asyncio.to_thread(self._codec.decode, chunk_ndarray)
+        return chunk_spec.prototype.nd_buffer.from_ndarray_like(out.reshape(chunk_spec.shape))
+
+    async def _encode_single(self, chunk_array: NDBuffer, chunk_spec: ArraySpec) -> NDBuffer:
+        chunk_ndarray = chunk_array.as_ndarray_like()
+        out = await asyncio.to_thread(self._codec.encode, chunk_ndarray)
+        return chunk_spec.prototype.nd_buffer.from_ndarray_like(out)
+
+
+class _NumcodecsArrayBytesCodec(_NumcodecsCodec, ArrayBytesCodec):
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    async def _decode_single(self, chunk_buffer: Buffer, chunk_spec: ArraySpec) -> NDBuffer:
+        chunk_bytes = chunk_buffer.to_bytes()
+        out = await asyncio.to_thread(self._codec.decode, chunk_bytes)
+        return chunk_spec.prototype.nd_buffer.from_ndarray_like(out.reshape(chunk_spec.shape))
+
+    async def _encode_single(self, chunk_ndbuffer: NDBuffer, chunk_spec: ArraySpec) -> Buffer:
+        chunk_ndarray = chunk_ndbuffer.as_ndarray_like()
+        out = await asyncio.to_thread(self._codec.encode, chunk_ndarray)
+        return chunk_spec.prototype.buffer.from_bytes(out)
+
+
+T = TypeVar("T", bound=_NumcodecsCodec)
+
+
+def _add_docstring(cls: type[T], ref_class_name: str) -> type[T]:
+    cls.__doc__ = f"""
+        See :class:`{ref_class_name}` for more details and parameters.
+        """
+    return cls
+
+
+def _add_docstring_wrapper(ref_class_name: str) -> partial:
+    return partial(_add_docstring, ref_class_name=ref_class_name)
+
+
+def _make_bytes_bytes_codec(codec_name: str, cls_name: str) -> type[_NumcodecsBytesBytesCodec]:
+    # rename for class scope
+    _codec_name = CODEC_PREFIX + codec_name
+
+    class _Codec(_NumcodecsBytesBytesCodec):
+        codec_name = _codec_name
+
+        def __init__(self, **codec_config: JSON) -> None:
+            super().__init__(**codec_config)
+
+    _Codec.__name__ = cls_name
+    return _Codec
+
+
+def _make_array_array_codec(codec_name: str, cls_name: str) -> type[_NumcodecsArrayArrayCodec]:
+    # rename for class scope
+    _codec_name = CODEC_PREFIX + codec_name
+
+    class _Codec(_NumcodecsArrayArrayCodec):
+        codec_name = _codec_name
+
+        def __init__(self, **codec_config: JSON) -> None:
+            super().__init__(**codec_config)
+
+    _Codec.__name__ = cls_name
+    return _Codec
+
+
+def _make_array_bytes_codec(codec_name: str, cls_name: str) -> type[_NumcodecsArrayBytesCodec]:
+    # rename for class scope
+    _codec_name = CODEC_PREFIX + codec_name
+
+    class _Codec(_NumcodecsArrayBytesCodec):
+        codec_name = _codec_name
+
+        def __init__(self, **codec_config: JSON) -> None:
+            super().__init__(**codec_config)
+
+    _Codec.__name__ = cls_name
+    return _Codec
+
+
+def _make_checksum_codec(codec_name: str, cls_name: str) -> type[_NumcodecsBytesBytesCodec]:
+    # rename for class scope
+    _codec_name = CODEC_PREFIX + codec_name
+
+    class _ChecksumCodec(_NumcodecsBytesBytesCodec):
+        codec_name = _codec_name
+
+        def __init__(self, **codec_config: JSON) -> None:
+            super().__init__(**codec_config)
+
+        def compute_encoded_size(self, input_byte_length: int, chunk_spec: ArraySpec) -> int:
+            return input_byte_length + 4  # pragma: no cover
+
+    _ChecksumCodec.__name__ = cls_name
+    return _ChecksumCodec
+
+
+# bytes-to-bytes codecs
+Blosc = _add_docstring(_make_bytes_bytes_codec("blosc", "Blosc"), "numcodecs.blosc.Blosc")
+LZ4 = _add_docstring(_make_bytes_bytes_codec("lz4", "LZ4"), "numcodecs.lz4.LZ4")
+Zstd = _add_docstring(_make_bytes_bytes_codec("zstd", "Zstd"), "numcodecs.zstd.Zstd")
+Zlib = _add_docstring(_make_bytes_bytes_codec("zlib", "Zlib"), "numcodecs.zlib.Zlib")
+GZip = _add_docstring(_make_bytes_bytes_codec("gzip", "GZip"), "numcodecs.gzip.GZip")
+BZ2 = _add_docstring(_make_bytes_bytes_codec("bz2", "BZ2"), "numcodecs.bz2.BZ2")
+LZMA = _add_docstring(_make_bytes_bytes_codec("lzma", "LZMA"), "numcodecs.lzma.LZMA")
+
+
+@_add_docstring_wrapper("numcodecs.shuffle.Shuffle")
+class Shuffle(_NumcodecsBytesBytesCodec):
+    codec_name = f"{CODEC_PREFIX}shuffle"
+
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> Shuffle:
+        if array_spec.dtype.itemsize != self.codec_config.get("elementsize"):
+            return Shuffle(**{**self.codec_config, "elementsize": array_spec.dtype.itemsize})
+        return self  # pragma: no cover
+
+
+# array-to-array codecs ("filters")
+Delta = _add_docstring(_make_array_array_codec("delta", "Delta"), "numcodecs.delta.Delta")
+BitRound = _add_docstring(
+    _make_array_array_codec("bitround", "BitRound"), "numcodecs.bitround.BitRound"
+)
+
+
+@_add_docstring_wrapper("numcodecs.fixedscaleoffset.FixedScaleOffset")
+class FixedScaleOffset(_NumcodecsArrayArrayCodec):
+    codec_name = f"{CODEC_PREFIX}fixedscaleoffset"
+
+    def __init__(self, **codec_config: 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
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> FixedScaleOffset:
+        if str(array_spec.dtype) != self.codec_config.get("dtype"):
+            return FixedScaleOffset(**{**self.codec_config, "dtype": str(array_spec.dtype)})
+        return self
+
+
+@_add_docstring_wrapper("numcodecs.quantize.Quantize")
+class Quantize(_NumcodecsArrayArrayCodec):
+    codec_name = f"{CODEC_PREFIX}quantize"
+
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> Quantize:
+        if str(array_spec.dtype) != self.codec_config.get("dtype"):
+            return Quantize(**{**self.codec_config, "dtype": str(array_spec.dtype)})
+        return self
+
+
+@_add_docstring_wrapper("numcodecs.packbits.PackBits")
+class PackBits(_NumcodecsArrayArrayCodec):
+    codec_name = f"{CODEC_PREFIX}packbits"
+
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    def resolve_metadata(self, chunk_spec: ArraySpec) -> ArraySpec:
+        return replace(
+            chunk_spec,
+            shape=(1 + math.ceil(product(chunk_spec.shape) / 8),),
+            dtype=np.dtype("uint8"),
+        )
+
+    def validate(self, *, dtype: np.dtype[Any], **_kwargs) -> None:
+        if dtype != np.dtype("bool"):
+            raise ValueError(f"Packbits filter requires bool dtype. Got {dtype}.")
+
+
+@_add_docstring_wrapper("numcodecs.astype.AsType")
+class AsType(_NumcodecsArrayArrayCodec):
+    codec_name = f"{CODEC_PREFIX}astype"
+
+    def __init__(self, **codec_config: JSON) -> None:
+        super().__init__(**codec_config)
+
+    def resolve_metadata(self, chunk_spec: ArraySpec) -> ArraySpec:
+        return replace(chunk_spec, dtype=np.dtype(self.codec_config["encode_dtype"]))  # type: ignore[arg-type]
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> AsType:
+        decode_dtype = self.codec_config.get("decode_dtype")
+        if str(array_spec.dtype) != decode_dtype:
+            return AsType(**{**self.codec_config, "decode_dtype": str(array_spec.dtype)})
+        return self
+
+
+# bytes-to-bytes checksum codecs
+CRC32 = _add_docstring(_make_checksum_codec("crc32", "CRC32"), "numcodecs.checksum32.CRC32")
+CRC32C = _add_docstring(_make_checksum_codec("crc32c", "CRC32C"), "numcodecs.checksum32.CRC32C")
+Adler32 = _add_docstring(_make_checksum_codec("adler32", "Adler32"), "numcodecs.checksum32.Adler32")
+Fletcher32 = _add_docstring(
+    _make_checksum_codec("fletcher32", "Fletcher32"), "numcodecs.fletcher32.Fletcher32"
+)
+JenkinsLookup3 = _add_docstring(
+    _make_checksum_codec("jenkins_lookup3", "JenkinsLookup3"), "numcodecs.checksum32.JenkinsLookup3"
+)
+
+# array-to-bytes codecs
+PCodec = _add_docstring(_make_array_bytes_codec("pcodec", "PCodec"), "numcodecs.pcodec.PCodec")
+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",
+    "Adler32",
+    "Fletcher32",
+    "JenkinsLookup3",
+    "PCodec",
+    "ZFPY",
+]

numcodecs/zfpy.py

@@ -1,8 +1,10 @@
+import warnings
 from contextlib import suppress
 from importlib.metadata import PackageNotFoundError, version
-import warnings
+from types import ModuleType
+from typing import Optional
 
-_zfpy = None
+_zfpy: Optional[ModuleType] = None
 
 _zfpy_version: tuple = ()
 with suppress(PackageNotFoundError):
@@ -17,16 +19,18 @@ if _zfpy_version:
             "NumPy version >= 2.0.0 detected. The zfpy library is incompatible with this version of NumPy. "
             "Please downgrade to NumPy < 2.0.0 or wait for an update from zfpy.",
             UserWarning,
+            stacklevel=2,
         )
     else:
         with suppress(ImportError):
-            import zfpy as _zfpy
+            import zfpy as _zfpy  # type: ignore[no-redef]
 
 if _zfpy:
-    from .abc import Codec
-    from .compat import ndarray_copy, ensure_contiguous_ndarray, ensure_bytes
     import numpy as np
 
+    from .abc import Codec
+    from .compat import ensure_bytes, ensure_contiguous_ndarray, ndarray_copy
+
     # noinspection PyShadowingBuiltins
     class ZFPY(Codec):
         """Codec providing compression using zfpy via the Python standard
@@ -102,11 +106,8 @@ if _zfpy:
                 return dec
 
         def __repr__(self):
-            r = "%s(mode=%r, tolerance=%s, rate=%s, precision=%s)" % (
-                type(self).__name__,
-                self.mode,
-                self.tolerance,
-                self.rate,
-                self.precision,
+            return (
+                f"{type(self).__name__}(mode={self.mode!r}, "
+                f"tolerance={self.tolerance}, rate={self.rate}, "
+                f"precision={self.precision})"
             )
-            return r

numcodecs/zlib.py

@@ -1,8 +1,7 @@
 import zlib as _zlib
 
-
 from .abc import Codec
-from .compat import ndarray_copy, ensure_contiguous_ndarray
+from .compat import ensure_contiguous_ndarray, ndarray_copy
 
 
 class Zlib(Codec):

{numcodecs-0.13.0.dist-info → numcodecs-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numcodecs
-Version: 0.13.0
+Version: 0.14.0
 Summary: A Python package providing buffer compression and transformation codecs for use in data storage and communication applications.
 Maintainer-email: Alistair Miles <alimanfoo@googlemail.com>
 License: MIT
@@ -18,12 +18,14 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: numpy >=1.7
+Requires-Dist: numpy >=1.24
+Provides-Extra: crc32c
+Requires-Dist: crc32c >=2.7 ; extra == 'crc32c'
 Provides-Extra: docs
-Requires-Dist: sphinx <7.0.0 ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
 Requires-Dist: sphinx-issues ; extra == 'docs'
 Requires-Dist: pydata-sphinx-theme ; extra == 'docs'
 Requires-Dist: numpydoc ; extra == 'docs'
@@ -31,7 +33,7 @@ Requires-Dist: mock ; extra == 'docs'
 Provides-Extra: msgpack
 Requires-Dist: msgpack ; extra == 'msgpack'
 Provides-Extra: pcodec
-Requires-Dist: pcodec >=0.2.0 ; extra == 'pcodec'
+Requires-Dist: pcodec <0.3,>=0.2 ; extra == 'pcodec'
 Provides-Extra: test
 Requires-Dist: coverage ; extra == 'test'
 Requires-Dist: pytest ; extra == 'test'
@@ -45,7 +47,7 @@ Requires-Dist: numpy <2.0.0 ; extra == 'zfpy'
 Numcodecs
 =========
 
-Numcodecs is a Python package providing buffer compression and transformation 
+Numcodecs is a Python package providing buffer compression and transformation
 codecs for use in data storage and communication applications.
 
 .. image:: https://readthedocs.org/projects/numcodecs/badge/?version=latest

numcodecs-0.14.0.dist-info/RECORD

@@ -0,0 +1,78 @@
+numcodecs-0.14.0.dist-info/RECORD,,
+numcodecs-0.14.0.dist-info/WHEEL,sha256=_QqtAaLoE5KabRyxEbihBVXZ2UYm7nzGTKq7KzoM3cQ,109
+numcodecs-0.14.0.dist-info/entry_points.txt,sha256=3W3FHKrwE52X3fLq8KdioOtf93lh5KaoGV5t2D10DBI,919
+numcodecs-0.14.0.dist-info/top_level.txt,sha256=JkHllzt6IuVudg4Tk--wF-yfPPsdVOiMTag1tjGIihw,10
+numcodecs-0.14.0.dist-info/LICENSE.txt,sha256=lJysaEeeE7bJeSRjUVC04e9eaXZq2eRy6oWgjBV2u5Y,1124
+numcodecs-0.14.0.dist-info/METADATA,sha256=sTRfpHqmugtMbGMkTSRf2XoBjGPiERfVOIaEk876DNE,3008
+numcodecs/compat_ext.cpython-311-darwin.so,sha256=tNtHtvb_72WnW0X7TrxXNbp54ePFRS7OH2_iA4JLCxo,78720
+numcodecs/lzma.py,sha256=T46qhtfl1910bMIbcat6bp6_XBcfP9u-3HElBwHiAOU,2241
+numcodecs/fletcher32.cpython-311-darwin.so,sha256=2PDzQ96JzRy69-hDp7yQT1iZFd80lDsso6FdgJvAJ0w,206032
+numcodecs/astype.py,sha256=0M9nV2Jb-8EwyoZGmOhCssaBvMej_B6hQ2p41VkmDdA,2137
+numcodecs/gzip.py,sha256=7TyUzc9oliPqKA58VV7fNkCi_c9PP04MioAKG7a1oV0,1469
+numcodecs/base64.py,sha256=i-WpnY7A-vT-71By_tVBvHi41O4DzuqYyB829eNd29E,784
+numcodecs/bz2.py,sha256=4Ups3IMVsjvBlXyaeYONPdE14TaK9V-4LH5LSNe7AGc,1174
+numcodecs/version.py,sha256=9XbM6DRatFmjNkeSNxF4a6enpQeo8nPyAy9RTPPwPpY,413
+numcodecs/compat.py,sha256=JadagE6pTEcrX3V8wDml0n1tdkHvOWo6D21J3a4P0mw,6505
+numcodecs/checksum32.py,sha256=CQACDazagg5bvM07XQUnpMFiWBfkVVP_u_SIOYdxRe4,5378
+numcodecs/ndarray_like.py,sha256=Kl5O-oKpdvt_MsfYsD73d4dIr3WXaOJLdHUEsc6tIrc,1896
+numcodecs/quantize.py,sha256=WNgbVPNR6CnaF58yBbVHIQ_jg1mBe8dirkZ2ErNpQOI,3037
+numcodecs/registry.py,sha256=iGnnBJ1fuWBMQTvnLMMliXXMk2gmhaHq7o3m7i9kNsk,1833
+numcodecs/pickles.py,sha256=qWNRLnWZnZ9nq_QhNNI2x-s1Uoq9Eq1lsgwCSRTTxJo,1288
+numcodecs/fixedscaleoffset.py,sha256=3J5JWZcE13lAJz9axSEpTUpAC9H-yI2RBOX8oGhtwns,4196
+numcodecs/__init__.py,sha256=fyEDQ93UsiZhacarMJ5YOUvmWZpvDi8-tWWF6S5tRFs,3207
+numcodecs/bitround.py,sha256=4lei39ZG4G2GGkDxl12q29nR5_8a4Icx4T-OgP1A1D4,2845
+numcodecs/zlib.py,sha256=gLPUICEQc5p6DICC_63nOsbUqxzJH_5ynuzenTQXzOQ,1049
+numcodecs/shuffle.py,sha256=hYOFJOCEeDSNI-TqT1JrbQxbprkQD4R8VfSzD4IPI3I,1575
+numcodecs/blosc.cpython-311-darwin.so,sha256=QJXM7vieXMfYAtWv7z56nyZ0IplwJLlqKz05BLINDu0,1058168
+numcodecs/zarr3.py,sha256=yKajHAoBvJMWzGw59qiYrmhP9atPGzAlfNlpwcAIhac,13948
+numcodecs/lz4.cpython-311-darwin.so,sha256=h3csnzvVvHpwu8xHayOchjKej_yj58LtXt1ACSz1mi8,248600
+numcodecs/delta.py,sha256=XMETqU9gvhvf3O2GoBQottuOg87GJr1DeaFRGEJGxfE,2984
+numcodecs/vlen.cpython-311-darwin.so,sha256=oOytzANsbTTov5fiR9L-Hf-pZqkkKdKS7EuE00aTWmw,261368
+numcodecs/zfpy.py,sha256=ScGPw-w8t8CFHvijnwgE3pW4JIKD98QpSOH24sZsH60,3901
+numcodecs/msgpacks.py,sha256=sd3uuMN1wQz9XecP8eZOQY-huqbjC6BlOzx4NsJ95kY,2611
+numcodecs/jenkins.cpython-311-darwin.so,sha256=9Hkx-dslQ7ztCy64lDkTDWSWWAxSONaUVq8iFIi5e6g,187040
+numcodecs/packbits.py,sha256=L7gM-8AQQTPC2IOPbatzNp-tH67EUp0Tonx_JSYHje4,1993
+numcodecs/categorize.py,sha256=yUzeAuPTNbMiI2vhkPRcxpEi0yQnr1orFs_I_BVoEoo,2983
+numcodecs/zstd.cpython-311-darwin.so,sha256=VGW8Vbq56DLVYQAqbRqreA85SvUM3ShfVdjaI8uhW_A,731272
+numcodecs/json.py,sha256=Xu4dN-FydFaV-5jOewJxVBsV6rUfGUWIp4IncrjIR-E,3355
+numcodecs/_shuffle.cpython-311-darwin.so,sha256=TcmEeNVPSduBU-HkEcnUC3Ymj0t-XEvByrPue6KeOJ0,182560
+numcodecs/abc.py,sha256=a8EcPXbuKXaHuNfAj6CoeAVb6kphgKGoLsHcre2aXxg,4505
+numcodecs/pcodec.py,sha256=7fOqhKUWURCbfbQFoEy8772UGna59F6v_6k_4QJrzZg,3079
+numcodecs/tests/test_categorize.py,sha256=ftL-LSVq63R-kGuQxUb96uL1e563mlF9CWAf3yQB-Bk,2756
+numcodecs/tests/test_registry.py,sha256=9eUhr3PDw_rj7mk5k8Gh4Szl3pUXbXXZuTfZXKW-ZPU,1052
+numcodecs/tests/test_vlen_utf8.py,sha256=H92YtqNY0kpO2Icu1Ey2iItK38ZhKMnJi_2FBwcKSvU,2474
+numcodecs/tests/test_bitround.py,sha256=ayCuANNDA0cP3mqZkJ90QU9eI7ws4-lPRKU_gkflOlg,2349
+numcodecs/tests/test_gzip.py,sha256=I685q0_vu3b_JibUz3nhW1mQtlLSQzGdgGD2twbGPXc,2925
+numcodecs/tests/test_zarr3.py,sha256=RqWJMvsCDKFfsCufptIyTCnypE0xEIPRCbCHo1hkYY8,7547
+numcodecs/tests/test_delta.py,sha256=1_XnV1JYMEnxO0iXDXVSzTltjRPtdoEb4Y8TpmllS-o,1636
+numcodecs/tests/test_lzma.py,sha256=VyepAqH5Bzne-_VdTIV8E8KHkGwK9QoLdrD-1iRX5p4,2721
+numcodecs/tests/test_bz2.py,sha256=pefO_YlOLr-RIswHas8DAQ4j81jhqLT5XGEuQ2i8DtI,1889
+numcodecs/tests/__init__.py,sha256=Q6sNFjGUjcEU3MvCUd-PDtmYcS79Yvys3wbWWXvU5qY,72
+numcodecs/tests/test_pickles.py,sha256=p7LfH5qJp1mmJC0nRWJbyPVCvt46raS_A6pjOZYOXqY,1679
+numcodecs/tests/test_quantize.py,sha256=KvOyoj-u4S_-z8pT4syR6yE4i1ftFGkRfCTmgafumGw,2151
+numcodecs/tests/test_entrypoints_backport.py,sha256=3IVVH4VmXu6e1gzUpU5S8koCtR3X-3HAqAlPqdRlv6M,1108
+numcodecs/tests/test_pcodec.py,sha256=cM0Knn6gzuqF8cMqn-aTspCAu6T45Dp53PfT4F_WejI,2024
+numcodecs/tests/test_lz4.py,sha256=63bjnBmT-bHCduj9w_LRTkJKBvo8emBzwVpzoDC5-A0,2353
+numcodecs/tests/test_msgpacks.py,sha256=03FEZBME1z7vRAzDTX-xdOQ-_ZMzn4R9GRMrsZeKI0s,3950
+numcodecs/tests/test_astype.py,sha256=Wu1HtHZA6K_rW-JCxSWmU4Wwp9U83JUbUZ2ro9xDk9s,2367
+numcodecs/tests/test_jenkins.py,sha256=DoOXdTLD25aXA0nwiO1zk_vG4N2UI6Wc3C72yqIByNc,4446
+numcodecs/tests/test_fletcher32.py,sha256=hNf2zSAi16k4222qI2k-n5X4GgswVBfOqvKHSgSoRxQ,1456
+numcodecs/tests/test_packbits.py,sha256=8B2sQnM-DiAEtehCEm5xm7fQ1xWm0rMk_z7Uk8OXvGI,989
+numcodecs/tests/common.py,sha256=cLiS3SwUORLL0N8Yx4TjqgrB7Y9nwxx_5-T2qL0vqD0,12168
+numcodecs/tests/test_base64.py,sha256=QseE5-aDwz7yv5-0dAG_6vTjeN3OpFvgcg8IhklRA4Y,2315
+numcodecs/tests/test_shuffle.py,sha256=OH-3B3q6nY0wmBfR93jndtm0dNX4k8BQCHuQYPHvur0,4689
+numcodecs/tests/test_fixedscaleoffset.py,sha256=3RclYFw3WFu36WUIciZ23gNIiBmzboXvrEugMw1311A,2536
+numcodecs/tests/test_compat.py,sha256=YdaGiNsXgounzSX7uFXOz_7uh6Wf1n6kO0Ql6eICtIY,3728
+numcodecs/tests/test_zlib.py,sha256=TFa-I15xHd4h2nNC2goChWdlB_xZLbK_vAL7s4upPWI,2539
+numcodecs/tests/test_json.py,sha256=od5MZbSclKFWM_RjS2DsVWGIYlJXG6-wm0yQLdkBTh0,2292
+numcodecs/tests/test_ndarray_like.py,sha256=Bh8wDqkbSL-yr_MDQqE5XUoWzZav5J_VzC8Lfv3BBlA,1273
+numcodecs/tests/test_vlen_array.py,sha256=QaWVuflGxQUFToVcWVIzZHG_b8Vm4JJG6mBZVGNasK0,2477
+numcodecs/tests/test_zstd.py,sha256=79R6VMhni-6kg9LmlmBzGe22HXhg0RvSVjw4jVNPMJQ,2610
+numcodecs/tests/test_vlen_bytes.py,sha256=BpASj3-ap_ZjyK_nYP7YQSZg4gsECCh5DW_4pdNlhRs,2473
+numcodecs/tests/test_entrypoints.py,sha256=zWbyosPRhbSevwp4grlfjfnEyIneny-u7XmMe1xcoLI,504
+numcodecs/tests/test_zarr3_import.py,sha256=JBDyrL57lbZMI9axb9eA1OZnd_Lg-ppfsNV3VvxwVxk,332
+numcodecs/tests/test_checksum32.py,sha256=IR1ZXf2XJFh0Vrpxyz4P7RFym2kxtagp-yYDZowicPc,4238
+numcodecs/tests/test_zfpy.py,sha256=g_2txraHDbnBPtbymJXsgAiD6MBH44-JYRkNx9tttYw,2762
+numcodecs/tests/test_blosc.py,sha256=VixIjcQNlzIdXrs1yvEMA1q7EMAu1jLy_VtRmgjcQU4,8866
+numcodecs/tests/package_with_entrypoint-0.1.dist-info/entry_points.txt,sha256=wel2k9KStuNez__clm2tjAwrcXiP17De8yNScHYtQZU,60
+numcodecs/tests/package_with_entrypoint/__init__.py,sha256=wLyrk73nqKO8rcFtA_sXlcC8PKMzdYbbBRY8eH8Xc10,212

{numcodecs-0.13.0.dist-info → numcodecs-0.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-macosx_11_0_arm64
 

numcodecs-0.14.0.dist-info/entry_points.txt

@@ -0,0 +1,22 @@
+[zarr.codecs]
+numcodecs.adler32 = numcodecs.zarr3:Adler32
+numcodecs.astype = numcodecs.zarr3:AsType
+numcodecs.bitround = numcodecs.zarr3:BitRound
+numcodecs.blosc = numcodecs.zarr3:Blosc
+numcodecs.bz2 = numcodecs.zarr3:BZ2
+numcodecs.crc32 = numcodecs.zarr3:CRC32
+numcodecs.crc32c = numcodecs.zarr3:CRC32C
+numcodecs.delta = numcodecs.zarr3:Delta
+numcodecs.fixedscaleoffset = numcodecs.zarr3:FixedScaleOffset
+numcodecs.fletcher32 = numcodecs.zarr3:Fletcher32
+numcodecs.gzip = numcodecs.zarr3:GZip
+numcodecs.jenkins_lookup3 = numcodecs.zarr3:JenkinsLookup3
+numcodecs.lz4 = numcodecs.zarr3:LZ4
+numcodecs.lzma = numcodecs.zarr3:LZMA
+numcodecs.packbits = numcodecs.zarr3:PackBits
+numcodecs.pcodec = numcodecs.zarr3:PCodec
+numcodecs.quantize = numcodecs.zarr3:Quantize
+numcodecs.shuffle = numcodecs.zarr3:Shuffle
+numcodecs.zfpy = numcodecs.zarr3:ZFPY
+numcodecs.zlib = numcodecs.zarr3:Zlib
+numcodecs.zstd = numcodecs.zarr3:Zstd