numcodecs 0.16.0__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

numcodecs/zarr3.py

@@ -0,0 +1,401 @@
+"""
+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
+>>>
+>>> array = zarr.create_array(
+...   store="data.zarr",
+...   shape=(1024, 1024),
+...   chunks=(64, 64),
+...   dtype="uint32",
+...   filters=[numcodecs.zarr3.Delta()],
+...   compressors=[numcodecs.zarr3.BZ2(level=5)])
+>>> 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 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
+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,
+            stacklevel=2,
+        )
+
+    @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()
+        codec_config.pop("id", None)
+        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
+
+    # 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:
+        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 self.codec_config.get("elementsize", None) is None:
+            return Shuffle(**{**self.codec_config, "elementsize": array_spec.dtype.itemsize})
+        return self  # pragma: no cover
+
+
+# array-to-array codecs ("filters")
+@_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[call-overload]
+        return chunk_spec
+
+
+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[call-overload]
+        return chunk_spec
+
+    def evolve_from_array_spec(self, array_spec: ArraySpec) -> FixedScaleOffset:
+        if self.codec_config.get("dtype", None) is None:
+            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 self.codec_config.get("dtype", None) is None:
+            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:
+        if self.codec_config.get("decode_dtype", None) is None:
+            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__ = [
+    "BZ2",
+    "CRC32",
+    "CRC32C",
+    "LZ4",
+    "LZMA",
+    "ZFPY",
+    "Adler32",
+    "AsType",
+    "BitRound",
+    "Blosc",
+    "Delta",
+    "FixedScaleOffset",
+    "Fletcher32",
+    "GZip",
+    "JenkinsLookup3",
+    "PCodec",
+    "PackBits",
+    "Quantize",
+    "Shuffle",
+    "Zlib",
+    "Zstd",
+]

numcodecs/zfpy.py

@@ -0,0 +1,113 @@
+import warnings
+from contextlib import suppress
+from importlib.metadata import PackageNotFoundError, version
+from types import ModuleType
+from typing import Optional
+
+_zfpy: Optional[ModuleType] = None
+
+_zfpy_version: tuple = ()
+with suppress(PackageNotFoundError):
+    _zfpy_version = tuple(map(int, version("zfpy").split(".")))
+
+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
+        _zfpy_version = ()
+        warnings.warn(
+            "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  # type: ignore[no-redef]
+
+if _zfpy:
+    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
+        library.
+
+        Parameters
+        ----------
+        mode : integer
+            One of the zfpy mode choice, e.g., ``zfpy.mode_fixed_accuracy``.
+        tolerance : double, optional
+            A double-precision number, specifying the compression accuracy needed.
+        rate : double, optional
+            A double-precision number, specifying the compression rate needed.
+        precision : int, optional
+            A integer number, specifying the compression precision needed.
+
+        """
+
+        codec_id = "zfpy"
+
+        def __init__(
+            self,
+            mode=_zfpy.mode_fixed_accuracy,
+            tolerance=-1,
+            rate=-1,
+            precision=-1,
+            compression_kwargs=None,
+        ):
+            self.mode = mode
+            if mode == _zfpy.mode_fixed_accuracy:
+                self.compression_kwargs = {"tolerance": tolerance}
+            elif mode == _zfpy.mode_fixed_rate:
+                self.compression_kwargs = {"rate": rate}
+            elif mode == _zfpy.mode_fixed_precision:
+                self.compression_kwargs = {"precision": precision}
+
+            self.tolerance = tolerance
+            self.rate = rate
+            self.precision = precision
+
+        def encode(self, buf):
+            # not flatten c-order array and raise exception for f-order array
+            if not isinstance(buf, np.ndarray):
+                raise TypeError(
+                    "The zfp codec does not support none numpy arrays."
+                    f" Your buffers were {type(buf)}."
+                )
+            if buf.flags.c_contiguous:
+                flatten = False
+            else:
+                raise ValueError(
+                    "The zfp codec does not support F order arrays. "
+                    f"Your arrays flags were {buf.flags}."
+                )
+            buf = ensure_contiguous_ndarray(buf, flatten=flatten)
+
+            # do compression
+            return _zfpy.compress_numpy(buf, write_header=True, **self.compression_kwargs)
+
+        def decode(self, buf, out=None):
+            # normalise inputs
+            buf = ensure_bytes(buf)
+            if out is not None:
+                out = ensure_contiguous_ndarray(out)
+
+            # do decompression
+            dec = _zfpy.decompress_numpy(buf)
+
+            # handle destination
+            if out is not None:
+                return ndarray_copy(dec, out)
+            else:
+                return dec
+
+        def __repr__(self):
+            return (
+                f"{type(self).__name__}(mode={self.mode!r}, "
+                f"tolerance={self.tolerance}, rate={self.rate}, "
+                f"precision={self.precision})"
+            )

numcodecs/zlib.py

@@ -0,0 +1,42 @@
+import zlib as _zlib
+
+from .abc import Codec
+from .compat import ensure_contiguous_ndarray, ndarray_copy
+
+
+class Zlib(Codec):
+    """Codec providing compression using zlib via the Python standard library.
+
+    Parameters
+    ----------
+    level : int
+        Compression level.
+
+    """
+
+    codec_id = 'zlib'
+
+    def __init__(self, level=1):
+        self.level = level
+
+    def encode(self, buf):
+        # normalise inputs
+        buf = ensure_contiguous_ndarray(buf)
+
+        # do compression
+        return _zlib.compress(buf, self.level)
+
+    # noinspection PyMethodMayBeStatic
+    def decode(self, buf, out=None):
+        # normalise inputs
+        buf = ensure_contiguous_ndarray(buf)
+        if out is not None:
+            out = ensure_contiguous_ndarray(out)
+
+        # do decompression
+        dec = _zlib.decompress(buf)
+
+        # handle destination - Python standard library zlib module does not
+        # support direct decompression into buffer, so we have to copy into
+        # out if given
+        return ndarray_copy(dec, out)

numcodecs-0.16.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: numcodecs
+Version: 0.16.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
+Project-URL: Bug Tracker, https://github.com/zarr-developers/numcodecs/issues
+Project-URL: Changelog, https://numcodecs.readthedocs.io/en/stable/release.html
+Project-URL: Documentation, https://numcodecs.readthedocs.io/
+Project-URL: Homepage, https://github.com/zarr-developers/numcodecs
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+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.11
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24
+Requires-Dist: typing_extensions
+Provides-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"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: test-extras
+Requires-Dist: importlib_metadata; extra == "test-extras"
+Provides-Extra: msgpack
+Requires-Dist: msgpack; extra == "msgpack"
+Provides-Extra: zfpy
+Requires-Dist: zfpy>=1.0.0; extra == "zfpy"
+Provides-Extra: pcodec
+Requires-Dist: pcodec<0.4,>=0.3; extra == "pcodec"
+Provides-Extra: crc32c
+Requires-Dist: crc32c>=2.7; extra == "crc32c"
+Dynamic: license-file
+
+Numcodecs
+=========
+
+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
+    :target: https://numcodecs.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://github.com/zarr-developers/numcodecs/workflows/Linux%20CI/badge.svg?branch=main
+    :target: https://github.com/zarr-developers/numcodecs/actions?query=workflow%3A%22Linux+CI%22
+
+.. image:: https://github.com/zarr-developers/numcodecs/workflows/OSX%20CI/badge.svg?branch=main
+    :target: https://github.com/zarr-developers/numcodecs/actions?query=workflow%3A%22OSX+CI%22
+
+.. image:: https://github.com/zarr-developers/numcodecs/workflows/Wheels/badge.svg?branch=main
+    :target: https://github.com/zarr-developers/numcodecs/actions?query=workflow%3AWheels
+
+.. image:: https://codecov.io/gh/zarr-developers/numcodecs/branch/main/graph/badge.svg
+    :target: https://codecov.io/gh/zarr-developers/numcodecs