numcodecs 0.14.0__cp313-cp313-win_amd64.whl → 0.15.0__cp313-cp313-win_amd64.whl

numcodecs/__init__.py

@@ -36,41 +36,32 @@ from numcodecs.bz2 import BZ2
 
 register_codec(BZ2)
 
-with suppress(ImportError):
-    from numcodecs.lzma import LZMA
+from numcodecs.lzma import LZMA
 
-    register_codec(LZMA)
+register_codec(LZMA)
 
-with suppress(ImportError):
-    from numcodecs import blosc
-    from numcodecs.blosc import Blosc
-
-    register_codec(Blosc)
-    # initialize blosc
-    try:
-        ncores = multiprocessing.cpu_count()
-    except OSError:  # pragma: no cover
-        ncores = 1
-    blosc.init()
-    blosc.set_nthreads(min(8, ncores))
-    atexit.register(blosc.destroy)
+from numcodecs import blosc
+from numcodecs.blosc import Blosc
 
-with suppress(ImportError):
-    from numcodecs import zstd as zstd
-    from numcodecs.zstd import Zstd
+register_codec(Blosc)
+# initialize blosc
+try:
+    ncores = multiprocessing.cpu_count()
+except OSError:  # pragma: no cover
+    ncores = 1
+blosc._init()
+blosc.set_nthreads(min(8, ncores))
+atexit.register(blosc.destroy)
 
-    register_codec(Zstd)
+from numcodecs import zstd as zstd
+from numcodecs.zstd import Zstd
 
-with suppress(ImportError):
-    from numcodecs import lz4 as lz4
-    from numcodecs.lz4 import LZ4
+register_codec(Zstd)
 
-    register_codec(LZ4)
-
-with suppress(ImportError):
-    from numcodecs.zfpy import ZFPY
+from numcodecs import lz4 as lz4
+from numcodecs.lz4 import LZ4
 
-    register_codec(ZFPY)
+register_codec(LZ4)
 
 from numcodecs.astype import AsType
 
@@ -112,15 +103,9 @@ from numcodecs.bitround import BitRound
 
 register_codec(BitRound)
 
-with suppress(ImportError):
-    from numcodecs.msgpacks import MsgPack
-
-    register_codec(MsgPack)
-
-from numcodecs.checksum32 import CRC32, CRC32C, Adler32, JenkinsLookup3
+from numcodecs.checksum32 import CRC32, Adler32, JenkinsLookup3
 
 register_codec(CRC32)
-register_codec(CRC32C)
 register_codec(Adler32)
 register_codec(JenkinsLookup3)
 
@@ -128,18 +113,34 @@ from numcodecs.json import JSON
 
 register_codec(JSON)
 
-with suppress(ImportError):
-    from numcodecs import vlen as vlen
-    from numcodecs.vlen import VLenArray, VLenBytes, VLenUTF8
+from numcodecs import vlen as vlen
+from numcodecs.vlen import VLenArray, VLenBytes, VLenUTF8
 
-    register_codec(VLenUTF8)
-    register_codec(VLenBytes)
-    register_codec(VLenArray)
+register_codec(VLenUTF8)
+register_codec(VLenBytes)
+register_codec(VLenArray)
 
 from numcodecs.fletcher32 import Fletcher32
 
 register_codec(Fletcher32)
 
-from numcodecs.pcodec import PCodec
+# Optional depenedencies
+with suppress(ImportError):
+    from numcodecs.zfpy import ZFPY
+
+    register_codec(ZFPY)
+
+with suppress(ImportError):
+    from numcodecs.msgpacks import MsgPack
+
+    register_codec(MsgPack)
+
+with suppress(ImportError):
+    from numcodecs.checksum32 import CRC32C
+
+    register_codec(CRC32C)
+
+with suppress(ImportError):
+    from numcodecs.pcodec import PCodec
 
-register_codec(PCodec)
+    register_codec(PCodec)

numcodecs/abc.py

@@ -84,7 +84,7 @@ class Codec(ABC):
         # override in sub-class if need special encoding of config values
 
         # setup config object
-        config = dict(id=self.codec_id)
+        config = {'id': self.codec_id}
 
         # by default, assume all non-private members are configuration
         # parameters - override this in sub-class if not the case

numcodecs/astype.py

@@ -49,9 +49,7 @@ class AsType(Codec):
         arr = ensure_ndarray(buf).view(self.decode_dtype)
 
         # convert and copy
-        enc = arr.astype(self.encode_dtype)
-
-        return enc
+        return arr.astype(self.encode_dtype)
 
     def decode(self, buf, out=None):
         # normalise input
@@ -61,9 +59,7 @@ class AsType(Codec):
         dec = enc.astype(self.decode_dtype)
 
         # handle output
-        out = ndarray_copy(dec, out)
-
-        return out
+        return ndarray_copy(dec, out)
 
     def get_config(self):
         return {

numcodecs/base64.py

@@ -13,8 +13,7 @@ class Base64(Codec):
         # normalise inputs
         buf = ensure_contiguous_ndarray(buf)
         # do compression
-        compressed = _base64.standard_b64encode(buf)
-        return compressed
+        return _base64.standard_b64encode(buf)
 
     def decode(self, buf, out=None):
         # normalise inputs

numcodecs/categorize.py

@@ -80,18 +80,15 @@ class Categorize(Codec):
             dec[enc == (i + 1)] = label
 
         # handle output
-        dec = ndarray_copy(dec, out)
-
-        return dec
+        return ndarray_copy(dec, out)
 
     def get_config(self):
-        config = dict(
-            id=self.codec_id,
-            labels=self.labels,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
-        return config
+        return {
+            'id': self.codec_id,
+            'labels': self.labels,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
 
     def __repr__(self):
         # make sure labels part is not too long

numcodecs/checksum32.py

@@ -1,7 +1,9 @@
 import struct
 import zlib
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Literal
+from contextlib import suppress
+from types import ModuleType
+from typing import TYPE_CHECKING, Literal, Optional
 
 import numpy as np
 
@@ -9,7 +11,11 @@ from .abc import Codec
 from .compat import ensure_contiguous_ndarray, ndarray_copy
 from .jenkins import jenkins_lookup3
 
-if TYPE_CHECKING:
+_crc32c: Optional[ModuleType] = None
+with suppress(ImportError):
+    import crc32c as _crc32c  # type: ignore[no-redef]
+
+if TYPE_CHECKING:  # pragma: no cover
     from typing_extensions import Buffer
 
 CHECKSUM_LOCATION = Literal['start', 'end']
@@ -76,28 +82,6 @@ class CRC32(Checksum32):
     location = 'start'
 
 
-class CRC32C(Checksum32):
-    """Codec add a crc32c checksum to the buffer.
-
-    Parameters
-    ----------
-    location : 'start' or 'end'
-        Where to place the checksum in the buffer.
-    """
-
-    codec_id = 'crc32c'
-
-    def checksum(self, buf):
-        try:
-            from crc32c import crc32c as crc32c_
-
-            return crc32c_(buf)
-        except ImportError:  # pragma: no cover
-            raise ImportError("crc32c must be installed to use the CRC32C checksum codec.")
-
-    location = 'end'
-
-
 class Adler32(Checksum32):
     """Codec add a adler32 checksum to the buffer.
 
@@ -168,3 +152,19 @@ class JenkinsLookup3(Checksum32):
             out.view("uint8")[:] = b[:-4]
             return out
         return memoryview(b[:-4])
+
+
+if _crc32c:
+
+    class CRC32C(Checksum32):
+        """Codec add a crc32c checksum to the buffer.
+
+        Parameters
+        ----------
+        location : 'start' or 'end'
+            Where to place the checksum in the buffer.
+        """
+
+        codec_id = 'crc32c'
+        checksum = _crc32c.crc32c  # type: ignore[union-attr]
+        location = 'end'

numcodecs/delta.py

@@ -63,12 +63,7 @@ class Delta(Codec):
         enc[0] = arr[0]
 
         # compute differences
-        # using np.subtract for in-place operations
-        if arr.dtype == bool:
-            np.not_equal(arr[1:], arr[:-1], out=enc[1:])
-        else:
-            np.subtract(arr[1:], arr[:-1], out=enc[1:])
-
+        enc[1:] = np.diff(arr)
         return enc
 
     def decode(self, buf, out=None):
@@ -85,13 +80,11 @@ class Delta(Codec):
         np.cumsum(enc, out=dec)
 
         # handle output
-        out = ndarray_copy(dec, out)
-
-        return out
+        return ndarray_copy(dec, out)
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(id=self.codec_id, dtype=self.dtype.str, astype=self.astype.str)
+        return {'id': self.codec_id, 'dtype': self.dtype.str, 'astype': self.astype.str}
 
     def __repr__(self):
         r = f'{type(self).__name__}(dtype={self.dtype.str!r}'

numcodecs/fixedscaleoffset.py

@@ -94,9 +94,7 @@ class FixedScaleOffset(Codec):
         enc = np.around(enc)
 
         # convert dtype
-        enc = enc.astype(self.astype, copy=False)
-
-        return enc
+        return enc.astype(self.astype, copy=False)
 
     def decode(self, buf, out=None):
         # interpret buffer as numpy array
@@ -116,13 +114,13 @@ class FixedScaleOffset(Codec):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(
-            id=self.codec_id,
-            scale=self.scale,
-            offset=self.offset,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
+        return {
+            'id': self.codec_id,
+            'scale': self.scale,
+            'offset': self.offset,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
 
     def __repr__(self):
         r = f'{type(self).__name__}(scale={self.scale}, offset={self.offset}, dtype={self.dtype.str!r}'

numcodecs/gzip.py

@@ -28,9 +28,7 @@ class GZip(Codec):
         compressed = io.BytesIO()
         with _gzip.GzipFile(fileobj=compressed, mode='wb', compresslevel=self.level) as compressor:
             compressor.write(buf)
-        compressed = compressed.getvalue()
-
-        return compressed
+        return compressed.getvalue()
 
     # noinspection PyMethodMayBeStatic
     def decode(self, buf, out=None):

numcodecs/json.py

@@ -52,17 +52,17 @@ class JSON(Codec):
             else:
                 separators = ', ', ': '
         separators = tuple(separators)
-        self._encoder_config = dict(
-            skipkeys=skipkeys,
-            ensure_ascii=ensure_ascii,
-            check_circular=check_circular,
-            allow_nan=allow_nan,
-            indent=indent,
-            separators=separators,
-            sort_keys=sort_keys,
-        )
+        self._encoder_config = {
+            'skipkeys': skipkeys,
+            'ensure_ascii': ensure_ascii,
+            'check_circular': check_circular,
+            'allow_nan': allow_nan,
+            'indent': indent,
+            'separators': separators,
+            'sort_keys': sort_keys,
+        }
         self._encoder = _json.JSONEncoder(**self._encoder_config)
-        self._decoder_config = dict(strict=strict)
+        self._decoder_config = {'strict': strict}
         self._decoder = _json.JSONDecoder(**self._decoder_config)
 
     def encode(self, buf):
@@ -89,7 +89,7 @@ class JSON(Codec):
             return dec
 
     def get_config(self):
-        config = dict(id=self.codec_id, encoding=self._text_encoding)
+        config = {'id': self.codec_id, 'encoding': self._text_encoding}
         config.update(self._encoder_config)
         config.update(self._decoder_config)
         return config

numcodecs/lzma.py

@@ -5,7 +5,7 @@ _lzma: Optional[ModuleType] = None
 try:
     import lzma as _lzma
 except ImportError:  # pragma: no cover
-    try:
+    try:  # noqa: SIM105
         from backports import lzma as _lzma  # type: ignore[no-redef]
     except ImportError:
         pass

numcodecs/msgpacks.py

@@ -75,12 +75,12 @@ class MsgPack(Codec):
             return dec
 
     def get_config(self):
-        return dict(
-            id=self.codec_id,
-            raw=self.raw,
-            use_single_float=self.use_single_float,
-            use_bin_type=self.use_bin_type,
-        )
+        return {
+            'id': self.codec_id,
+            'raw': self.raw,
+            'use_single_float': self.use_single_float,
+            'use_bin_type': self.use_bin_type,
+        }
 
     def __repr__(self):
         return f'MsgPack(raw={self.raw!r}, use_bin_type={self.use_bin_type!r}, use_single_float={self.use_single_float!r})'

numcodecs/ndarray_like.py

@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, Optional, Protocol, runtime_checkable
+from typing import Any, ClassVar, Protocol, runtime_checkable
 
 
 class _CachedProtocolMeta(Protocol.__class__):  # type: ignore[name-defined]
@@ -53,7 +53,7 @@ class NDArrayLike(Protocol, metaclass=_CachedProtocolMeta):
 
     def __setitem__(self, key, value): ...  # pragma: no cover
 
-    def tobytes(self, order: Optional[str] = ...) -> bytes: ...  # pragma: no cover
+    def tobytes(self, order: str | None = ...) -> bytes: ...  # pragma: no cover
 
     def reshape(self, *shape: int, order: str = ...) -> "NDArrayLike": ...  # pragma: no cover
 

numcodecs/pcodec.py

@@ -1,19 +1,13 @@
-from typing import Literal, Optional
+from typing import Literal
 
-import numcodecs
-import numcodecs.abc
+from numcodecs.abc import Codec
 from numcodecs.compat import ensure_contiguous_ndarray
-
-try:
-    from pcodec import ChunkConfig, ModeSpec, PagingSpec, standalone
-except ImportError:  # pragma: no cover
-    standalone = None
-
+from pcodec import ChunkConfig, DeltaSpec, ModeSpec, PagingSpec, standalone
 
 DEFAULT_MAX_PAGE_N = 262144
 
 
-class PCodec(numcodecs.abc.Codec):
+class PCodec(Codec):
     """
     PCodec (or pco, pronounced "pico") losslessly compresses and decompresses
     numerical sequences with high compression ratio and fast speed.
@@ -28,14 +22,21 @@ class PCodec(numcodecs.abc.Codec):
     level : int
         A compression level from 0-12, where 12 take the longest and compresses
         the most.
-    delta_encoding_order : init or None
-        Either a delta encoding level from 0-7 or None. If set to None, pcodec
-        will try to infer the optimal delta encoding order.
-    mode_spec : {'auto', 'classic'}
+    mode_spec : {"auto", "classic"}
         Configures whether Pcodec should try to infer the best "mode" or
         structure of the data (e.g. approximate multiples of 0.1) to improve
         compression ratio, or skip this step and just use the numbers as-is
-        (Classic mode).
+        (Classic mode). Note that the "try*" specs are not currently supported.
+    delta_spec : {"auto", "none", "try_consecutive", "try_lookback"}
+        Configures the delta encoding strategy. By default, uses "auto" which
+        will try to infer the best encoding order.
+    paging_spec : {"equal_pages_up_to"}
+        Configures the paging strategy. Only "equal_pages_up_to" is currently
+        supported.
+    delta_encoding_order : int or None
+        Explicit delta encoding level from 0-7. Only valid if delta_spec is
+        "try_consecutive" or "auto" (to support backwards compatibility with
+        older versions of this codec).
     equal_pages_up_to : int
         Divide the chunk into equal pages of up to this many numbers.
     """
@@ -45,39 +46,67 @@ class PCodec(numcodecs.abc.Codec):
     def __init__(
         self,
         level: int = 8,
-        delta_encoding_order: Optional[int] = None,
-        equal_pages_up_to: int = 262144,
-        # TODO one day, add support for the Try* mode specs
-        mode_spec: Literal['auto', 'classic'] = 'auto',
+        *,
+        mode_spec: Literal["auto", "classic"] = "auto",
+        delta_spec: Literal["auto", "none", "try_consecutive", "try_lookback"] = "auto",
+        paging_spec: Literal["equal_pages_up_to"] = "equal_pages_up_to",
+        delta_encoding_order: int | None = None,
+        equal_pages_up_to: int = DEFAULT_MAX_PAGE_N,
     ):
-        if standalone is None:  # pragma: no cover
-            raise ImportError("pcodec must be installed to use the PCodec codec.")
-
         # note that we use `level` instead of `compression_level` to
         # match other codecs
         self.level = level
+        self.mode_spec = mode_spec
+        self.delta_spec = delta_spec
+        self.paging_spec = paging_spec
         self.delta_encoding_order = delta_encoding_order
         self.equal_pages_up_to = equal_pages_up_to
-        self.mode_spec = mode_spec
-
-    def encode(self, buf):
-        buf = ensure_contiguous_ndarray(buf)
 
+    def _get_chunk_config(self):
         match self.mode_spec:
-            case 'auto':
+            case "auto":
                 mode_spec = ModeSpec.auto()
-            case 'classic':
+            case "classic":
                 mode_spec = ModeSpec.classic()
             case _:
-                raise ValueError(f"unknown value for mode_spec: {self.mode_spec}")
-        paging_spec = PagingSpec.equal_pages_up_to(self.equal_pages_up_to)
+                raise ValueError(f"mode_spec {self.mode_spec} is not supported")
+
+        if self.delta_encoding_order is not None and self.delta_spec == "auto":
+            # backwards compat for before delta_spec was introduced
+            delta_spec = DeltaSpec.try_consecutive(self.delta_encoding_order)
+        elif self.delta_encoding_order is not None and self.delta_spec != "try_consecutive":
+            raise ValueError(
+                "delta_encoding_order can only be set for delta_spec='try_consecutive'"
+            )
+        else:
+            match self.delta_spec:
+                case "auto":
+                    delta_spec = DeltaSpec.auto()
+                case "none":
+                    delta_spec = DeltaSpec.none()
+                case "try_consecutive":
+                    delta_spec = DeltaSpec.try_consecutive(self.delta_encoding_order)
+                case "try_lookback":
+                    delta_spec = DeltaSpec.try_lookback()
+                case _:
+                    raise ValueError(f"delta_spec {self.delta_spec} is not supported")
+
+        match self.paging_spec:
+            case "equal_pages_up_to":
+                paging_spec = PagingSpec.equal_pages_up_to(self.equal_pages_up_to)
+            case _:
+                raise ValueError(f"paging_spec {self.paging_spec} is not supported")
 
-        config = ChunkConfig(
+        return ChunkConfig(
             compression_level=self.level,
-            delta_encoding_order=self.delta_encoding_order,
+            delta_spec=delta_spec,
             mode_spec=mode_spec,
             paging_spec=paging_spec,
         )
+
+    def encode(self, buf):
+        buf = ensure_contiguous_ndarray(buf)
+        config = self._get_chunk_config()
         return standalone.simple_compress(buf, config)
 
     def decode(self, buf, out=None):

numcodecs/pickles.py

@@ -49,7 +49,7 @@ class Pickle(Codec):
             return dec
 
     def get_config(self):
-        return dict(id=self.codec_id, protocol=self.protocol)
+        return {'id': self.codec_id, 'protocol': self.protocol}
 
     def __repr__(self):
         return f'Pickle(protocol={self.protocol})'

numcodecs/quantize.py

@@ -73,9 +73,7 @@ class Quantize(Codec):
         enc = np.around(scale * arr) / scale
 
         # cast dtype
-        enc = enc.astype(self.astype, copy=False)
-
-        return enc
+        return enc.astype(self.astype, copy=False)
 
     def decode(self, buf, out=None):
         # filter is lossy, decoding is no-op
@@ -85,12 +83,12 @@ class Quantize(Codec):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(
-            id=self.codec_id,
-            digits=self.digits,
-            dtype=self.dtype.str,
-            astype=self.astype.str,
-        )
+        return {
+            'id': self.codec_id,
+            'digits': self.digits,
+            'dtype': self.dtype.str,
+            'astype': self.astype.str,
+        }
 
     def __repr__(self):
         r = f'{type(self).__name__}(digits={self.digits}, dtype={self.dtype.str!r}'

numcodecs/registry.py

@@ -8,7 +8,7 @@ from numcodecs.abc import Codec
 
 logger = logging.getLogger("numcodecs")
 codec_registry: dict[str, Codec] = {}
-entries: dict[str, "EntryPoints"] = {}
+entries: dict[str, EntryPoints] = {}
 
 
 def run_entrypoints():

numcodecs/tests/common.py

@@ -7,8 +7,7 @@ import numpy as np
 import pytest
 from numpy.testing import assert_array_almost_equal, assert_array_equal
 
-# star import needed for repr tests so eval finds names
-from numcodecs import *  # noqa: F403
+from numcodecs import *  # noqa: F403  # for eval to find names in repr tests
 from numcodecs.compat import ensure_bytes, ensure_ndarray
 from numcodecs.registry import get_codec
 
@@ -19,9 +18,9 @@ greetings = [
     'Hei maailma!',
     'Xin chào thế giới',
     'Njatjeta Botë!',
-    'Γεια σου κόσμε!',
+    'Γεια σου κόσμε!',  # noqa: RUF001
     'こんにちは世界',
-    '世界，你好！',
+    '世界，你好！',  # noqa: RUF001
     'Helló, világ!',
     'Zdravo svete!',
     'เฮลโลเวิลด์',