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

numcodecs/__init__.py

@@ -1,4 +1,4 @@
-# flake8: noqa
+# ruff: noqa: E402
 """Numcodecs is a Python package providing buffer compression and
 transformation codecs for use in data storage and communication
 applications. These include:
@@ -17,14 +17,13 @@ contribute code, please `raise an issue on GitHub
 
 """
 
-import multiprocessing
 import atexit
+import multiprocessing
 from contextlib import suppress
 
-
-from numcodecs.version import version as __version__
-from numcodecs.registry import get_codec, register_codec
-
+from numcodecs.registry import get_codec as get_codec
+from numcodecs.registry import register_codec
+from numcodecs.version import version as __version__  # noqa: F401
 from numcodecs.zlib import Zlib
 
 register_codec(Zlib)
@@ -57,13 +56,13 @@ with suppress(ImportError):
     atexit.register(blosc.destroy)
 
 with suppress(ImportError):
-    from numcodecs import zstd
+    from numcodecs import zstd as zstd
     from numcodecs.zstd import Zstd
 
     register_codec(Zstd)
 
 with suppress(ImportError):
-    from numcodecs import lz4
+    from numcodecs import lz4 as lz4
     from numcodecs.lz4 import LZ4
 
     register_codec(LZ4)
@@ -118,9 +117,10 @@ with suppress(ImportError):
 
     register_codec(MsgPack)
 
-from numcodecs.checksum32 import CRC32, Adler32, JenkinsLookup3
+from numcodecs.checksum32 import CRC32, CRC32C, Adler32, JenkinsLookup3
 
 register_codec(CRC32)
+register_codec(CRC32C)
 register_codec(Adler32)
 register_codec(JenkinsLookup3)
 
@@ -129,8 +129,8 @@ from numcodecs.json import JSON
 register_codec(JSON)
 
 with suppress(ImportError):
-    from numcodecs import vlen
-    from numcodecs.vlen import VLenUTF8, VLenBytes, VLenArray
+    from numcodecs import vlen as vlen
+    from numcodecs.vlen import VLenArray, VLenBytes, VLenUTF8
 
     register_codec(VLenUTF8)
     register_codec(VLenBytes)

numcodecs/abc.py

@@ -29,13 +29,14 @@ other and vice versa.
 """
 
 from abc import ABC, abstractmethod
+from typing import Optional
 
 
 class Codec(ABC):
     """Codec abstract base class."""
 
     # override in sub-class
-    codec_id = None
+    codec_id: Optional[str] = None
     """Codec identifier."""
 
     @abstractmethod
@@ -118,11 +119,9 @@ class Codec(ABC):
         # by default, assume all non-private members are configuration
         # parameters and valid keyword arguments to constructor function
 
-        r = '%s(' % type(self).__name__
+        r = f'{type(self).__name__}('
         params = [
-            '{}={!r}'.format(k, getattr(self, k))
-            for k in sorted(self.__dict__)
-            if not k.startswith('_')
+            f'{k}={getattr(self, k)!r}' for k in sorted(self.__dict__) if not k.startswith('_')
         ]
         r += ', '.join(params) + ')'
         return r

numcodecs/astype.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from .abc import Codec
-from .compat import ndarray_copy, ensure_ndarray
+from .compat import ensure_ndarray, ndarray_copy
 
 
 class AsType(Codec):
@@ -73,6 +73,4 @@ class AsType(Codec):
         }
 
     def __repr__(self):
-        return '{}(encode_dtype={!r}, decode_dtype={!r})'.format(
-            type(self).__name__, self.encode_dtype.str, self.decode_dtype.str
-        )
+        return f'{type(self).__name__}(encode_dtype={self.encode_dtype.str!r}, decode_dtype={self.decode_dtype.str!r})'

numcodecs/bitround.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray_like, ndarray_copy
 
@@ -60,7 +59,8 @@ class BitRound(Codec):
             return a
         if self.keepbits > bits:
             raise ValueError("Keepbits too large for given dtype")
-        b = a.view(a_int_dtype)
+        b = a.copy()
+        b = b.view(a_int_dtype)
         maskbits = bits - self.keepbits
         mask = (all_set >> maskbits) << maskbits
         half_quantum1 = (1 << (maskbits - 1)) - 1

numcodecs/bz2.py

@@ -1,8 +1,7 @@
 import bz2 as _bz2
 
-
 from numcodecs.abc import Codec
-from numcodecs.compat import ndarray_copy, ensure_contiguous_ndarray
+from numcodecs.compat import ensure_contiguous_ndarray, ndarray_copy
 
 
 class BZ2(Codec):

numcodecs/categorize.py

@@ -1,9 +1,8 @@
-from .abc import Codec
-from .compat import ensure_ndarray, ndarray_copy, ensure_text
-
-
 import numpy as np
 
+from .abc import Codec
+from .compat import ensure_ndarray, ensure_text, ndarray_copy
+
 
 class Categorize(Codec):
     """Filter encoding categorical string data as integers.
@@ -41,7 +40,7 @@ class Categorize(Codec):
     def __init__(self, labels, dtype, astype='u1'):
         self.dtype = np.dtype(dtype)
         if self.dtype.kind not in 'UO':
-            raise TypeError("only unicode ('U') and object ('O') dtypes are " "supported")
+            raise TypeError("only unicode ('U') and object ('O') dtypes are supported")
         self.labels = [ensure_text(label) for label in labels]
         self.astype = np.dtype(astype)
         if self.astype == np.dtype(object):
@@ -99,10 +98,4 @@ class Categorize(Codec):
         labels = repr(self.labels[:3])
         if len(self.labels) > 3:
             labels = labels[:-1] + ', ...]'
-        r = '%s(dtype=%r, astype=%r, labels=%s)' % (
-            type(self).__name__,
-            self.dtype.str,
-            self.astype.str,
-            labels,
-        )
-        return r
+        return f'{type(self).__name__}(dtype={self.dtype.str!r}, astype={self.astype.str!r}, labels={labels})'

numcodecs/checksum32.py

@@ -1,44 +1,115 @@
+import struct
 import zlib
-
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
-import struct
-
 
 from .abc import Codec
 from .compat import ensure_contiguous_ndarray, ndarray_copy
 from .jenkins import jenkins_lookup3
 
+if TYPE_CHECKING:
+    from typing_extensions import Buffer
+
+CHECKSUM_LOCATION = Literal['start', 'end']
+
 
 class Checksum32(Codec):
     # override in sub-class
-    checksum = None
+    checksum: Callable[["Buffer", int], int] | None = None
+    location: CHECKSUM_LOCATION = 'start'
+
+    def __init__(self, location: CHECKSUM_LOCATION | None = None):
+        if location is not None:
+            self.location = location
+        if self.location not in ['start', 'end']:
+            raise ValueError(f"Invalid checksum location: {self.location}")
 
     def encode(self, buf):
         arr = ensure_contiguous_ndarray(buf).view('u1')
         checksum = self.checksum(arr) & 0xFFFFFFFF
         enc = np.empty(arr.nbytes + 4, dtype='u1')
-        enc[:4].view('<u4')[0] = checksum
-        ndarray_copy(arr, enc[4:])
+        if self.location == 'start':
+            checksum_view = enc[:4]
+            payload_view = enc[4:]
+        else:
+            checksum_view = enc[-4:]
+            payload_view = enc[:-4]
+        checksum_view.view('<u4')[0] = checksum
+        ndarray_copy(arr, payload_view)
         return enc
 
     def decode(self, buf, out=None):
+        if len(buf) < 4:
+            raise ValueError("Input buffer is too short to contain a 32-bit checksum.")
+        if out is not None:
+            ensure_contiguous_ndarray(out)  # check that out is a valid ndarray
+
         arr = ensure_contiguous_ndarray(buf).view('u1')
-        expect = arr[:4].view('<u4')[0]
-        checksum = self.checksum(arr[4:]) & 0xFFFFFFFF
+        if self.location == 'start':
+            checksum_view = arr[:4]
+            payload_view = arr[4:]
+        else:
+            checksum_view = arr[-4:]
+            payload_view = arr[:-4]
+        expect = checksum_view.view('<u4')[0]
+        checksum = self.checksum(payload_view) & 0xFFFFFFFF
         if expect != checksum:
-            raise RuntimeError('checksum failed')
-        return ndarray_copy(arr[4:], out)
+            raise RuntimeError(
+                f"Stored and computed {self.codec_id} checksum do not match. Stored: {expect}. Computed: {checksum}."
+            )
+        return ndarray_copy(payload_view, out)
 
 
 class CRC32(Checksum32):
+    """Codec add a crc32 checksum to the buffer.
+
+    Parameters
+    ----------
+    location : 'start' or 'end'
+        Where to place the checksum in the buffer.
+    """
+
     codec_id = 'crc32'
     checksum = zlib.crc32
+    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.
+
+    Parameters
+    ----------
+    location : 'start' or 'end'
+        Where to place the checksum in the buffer.
+    """
+
     codec_id = 'adler32'
     checksum = zlib.adler32
+    location = 'start'
 
 
 class JenkinsLookup3(Checksum32):
@@ -52,9 +123,12 @@ class JenkinsLookup3(Checksum32):
     the data portion and compared with the four-byte checksum, raising
     RuntimeError if inconsistent.
 
-    Attributes:
-       initval: initial seed passed to the hash algorithm, default: 0
-       prefix: bytes prepended to the buffer before evaluating the hash, default: None
+    Parameters
+    ----------
+    initval : int
+        initial seed passed to the hash algorithm, default: 0
+    prefix : int
+        bytes prepended to the buffer before evaluating the hash, default: None
     """
 
     checksum = jenkins_lookup3

numcodecs/compat.py

@@ -1,9 +1,5 @@
-# flake8: noqa
-import functools
-import sys
-import codecs
 import array
-from functools import reduce
+import codecs
 
 import numpy as np
 
@@ -104,7 +100,7 @@ def ensure_contiguous_ndarray_like(buf, max_buffer_size=None, flatten=True) -> N
 
     # check for datetime or timedelta ndarray, the buffer interface doesn't support those
     if arr.dtype.kind in "Mm":
-        arr = arr.view(np.int64)
+        arr = arr.view(np.int64)  # type: ignore[arg-type]
 
     # check memory is contiguous, if so flatten
     if arr.flags.c_contiguous or arr.flags.f_contiguous:
@@ -115,13 +111,13 @@ def ensure_contiguous_ndarray_like(buf, max_buffer_size=None, flatten=True) -> N
         raise ValueError("an array with contiguous memory is required")
 
     if max_buffer_size is not None and arr.nbytes > max_buffer_size:
-        msg = "Codec does not support buffers of > {} bytes".format(max_buffer_size)
+        msg = f"Codec does not support buffers of > {max_buffer_size} bytes"
         raise ValueError(msg)
 
     return arr
 
 
-def ensure_contiguous_ndarray(buf, max_buffer_size=None, flatten=True) -> np.array:
+def ensure_contiguous_ndarray(buf, max_buffer_size=None, flatten=True) -> np.ndarray:
     """Convenience function to coerce `buf` to a numpy array, if it is not already a
     numpy array. Also ensures that the returned value exports fully contiguous memory,
     and supports the new-style buffer interface. If the optional max_buffer_size is

numcodecs/delta.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -64,7 +63,11 @@ class Delta(Codec):
         enc[0] = arr[0]
 
         # compute differences
-        enc[1:] = np.diff(arr)
+        # 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:])
 
         return enc
 
@@ -91,8 +94,8 @@ class Delta(Codec):
         return dict(id=self.codec_id, dtype=self.dtype.str, astype=self.astype.str)
 
     def __repr__(self):
-        r = '{}(dtype={!r}'.format(type(self).__name__, self.dtype.str)
+        r = f'{type(self).__name__}(dtype={self.dtype.str!r}'
         if self.astype != self.dtype:
-            r += ', astype=%r' % self.astype.str
+            r += f', astype={self.astype.str!r}'
         r += ')'
         return r

numcodecs/fixedscaleoffset.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -15,7 +14,7 @@ class FixedScaleOffset(Codec):
     ----------
     offset : float
         Value to subtract from data.
-    scale : int
+    scale : float
         Value to multiply by data.
     dtype : dtype
         Data type to use for decoded data.
@@ -126,13 +125,8 @@ class FixedScaleOffset(Codec):
         )
 
     def __repr__(self):
-        r = '%s(scale=%s, offset=%s, dtype=%r' % (
-            type(self).__name__,
-            self.scale,
-            self.offset,
-            self.dtype.str,
-        )
+        r = f'{type(self).__name__}(scale={self.scale}, offset={self.offset}, dtype={self.dtype.str!r}'
         if self.astype != self.dtype:
-            r += ', astype=%r' % self.astype.str
+            r += f', astype={self.astype.str!r}'
         r += ')'
         return r

numcodecs/json.py

@@ -1,10 +1,8 @@
 import json as _json
 import textwrap
 
-
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_text
 
@@ -97,12 +95,13 @@ class JSON(Codec):
         return config
 
     def __repr__(self):
-        params = ['encoding=%r' % self._text_encoding]
+        params = [f'encoding={self._text_encoding!r}']
         for k, v in sorted(self._encoder_config.items()):
-            params.append('{}={!r}'.format(k, v))
+            params.append(f'{k}={v!r}')
         for k, v in sorted(self._decoder_config.items()):
-            params.append('{}={!r}'.format(k, v))
+            params.append(f'{k}={v!r}')
         classname = type(self).__name__
-        r = '{}({})'.format(classname, ', '.join(params))
-        r = textwrap.fill(r, width=80, break_long_words=False, subsequent_indent='     ')
-        return r
+        params = ', '.join(params)
+        return textwrap.fill(
+            f'{classname}({params})', width=80, break_long_words=False, subsequent_indent='     '
+        )

numcodecs/lzma.py

@@ -1,16 +1,19 @@
-_lzma = None
+from types import ModuleType
+from typing import Optional
+
+_lzma: Optional[ModuleType] = None
 try:
     import lzma as _lzma
 except ImportError:  # pragma: no cover
     try:
-        from backports import lzma as _lzma
+        from backports import lzma as _lzma  # type: ignore[no-redef]
     except ImportError:
         pass
 
 
 if _lzma:
     from .abc import Codec
-    from .compat import ndarray_copy, ensure_contiguous_ndarray
+    from .compat import ensure_contiguous_ndarray, ndarray_copy
 
     # noinspection PyShadowingBuiltins
     class LZMA(Codec):
@@ -66,11 +69,4 @@ if _lzma:
             return ndarray_copy(dec, out)
 
         def __repr__(self):
-            r = '%s(format=%r, check=%r, preset=%r, filters=%r)' % (
-                type(self).__name__,
-                self.format,
-                self.check,
-                self.preset,
-                self.filters,
-            )
-            return r
+            return f'{type(self).__name__}(format={self.format!r}, check={self.check!r}, preset={self.preset!r}, filters={self.filters!r})'

numcodecs/msgpacks.py

@@ -1,6 +1,5 @@
-import numpy as np
 import msgpack
-
+import numpy as np
 
 from .abc import Codec
 from .compat import ensure_contiguous_ndarray
@@ -84,6 +83,4 @@ class MsgPack(Codec):
         )
 
     def __repr__(self):
-        return 'MsgPack(raw={!r}, use_bin_type={!r}, use_single_float={!r})'.format(
-            self.raw, self.use_bin_type, self.use_single_float
-        )
+        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,7 +1,7 @@
-from typing import Any, Dict, Optional, Protocol, Tuple, Type, runtime_checkable
+from typing import Any, ClassVar, Optional, Protocol, runtime_checkable
 
 
-class _CachedProtocolMeta(Protocol.__class__):
+class _CachedProtocolMeta(Protocol.__class__):  # type: ignore[name-defined]
     """Custom implementation of @runtime_checkable
 
     The native implementation of @runtime_checkable is slow,
@@ -11,7 +11,7 @@ class _CachedProtocolMeta(Protocol.__class__):
     isinstance checks using the object's class as the cache key.
     """
 
-    _instancecheck_cache: Dict[Tuple[Type, Type], bool] = {}
+    _instancecheck_cache: ClassVar[dict[tuple[type, type], bool]] = {}
 
     def __instancecheck__(self, instance):
         key = (self, instance.__class__)
@@ -39,8 +39,8 @@ class FlagsObj(Protocol, metaclass=_CachedProtocolMeta):
 @runtime_checkable
 class NDArrayLike(Protocol, metaclass=_CachedProtocolMeta):
     dtype: DType
-    shape: Tuple[int, ...]
-    strides: Tuple[int, ...]
+    shape: tuple[int, ...]
+    strides: tuple[int, ...]
     ndim: int
     size: int
     itemsize: int

numcodecs/packbits.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -30,9 +29,6 @@ class PackBits(Codec):
 
     codec_id = 'packbits'
 
-    def __init__(self):
-        pass
-
     def encode(self, buf):
         # normalise input
         arr = ensure_ndarray(buf).view(bool)

numcodecs/pcodec.py

@@ -1,11 +1,11 @@
-from typing import Optional, Literal
+from typing import Literal, Optional
 
 import numcodecs
 import numcodecs.abc
 from numcodecs.compat import ensure_contiguous_ndarray
 
 try:
-    from pcodec import standalone, ChunkConfig, PagingSpec, ModeSpec
+    from pcodec import ChunkConfig, ModeSpec, PagingSpec, standalone
 except ImportError:  # pragma: no cover
     standalone = None
 

numcodecs/pickles.py

@@ -52,4 +52,4 @@ class Pickle(Codec):
         return dict(id=self.codec_id, protocol=self.protocol)
 
     def __repr__(self):
-        return 'Pickle(protocol=%s)' % self.protocol
+        return f'Pickle(protocol={self.protocol})'

numcodecs/quantize.py

@@ -1,9 +1,7 @@
 import math
 
-
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -65,12 +63,12 @@ class Quantize(Codec):
 
         # apply scaling
         precision = 10.0**-self.digits
-        exp = math.log(precision, 10)
+        exp = math.log10(precision)
         if exp < 0:
             exp = int(math.floor(exp))
         else:
             exp = int(math.ceil(exp))
-        bits = math.ceil(math.log(10.0**-exp, 2))
+        bits = math.ceil(math.log2(10.0**-exp))
         scale = 2.0**bits
         enc = np.around(scale * arr) / scale
 
@@ -95,12 +93,8 @@ class Quantize(Codec):
         )
 
     def __repr__(self):
-        r = '%s(digits=%s, dtype=%r' % (
-            type(self).__name__,
-            self.digits,
-            self.dtype.str,
-        )
+        r = f'{type(self).__name__}(digits={self.digits}, dtype={self.dtype.str!r}'
         if self.astype != self.dtype:
-            r += ', astype=%r' % self.astype.str
+            r += f', astype={self.astype.str!r}'
         r += ')'
         return r

numcodecs/registry.py

@@ -1,12 +1,14 @@
 """The registry module provides some simple convenience functions to enable
 applications to dynamically register and look-up codec classes."""
 
-from importlib.metadata import entry_points
 import logging
+from importlib.metadata import EntryPoints, entry_points
+
+from numcodecs.abc import Codec
 
 logger = logging.getLogger("numcodecs")
-codec_registry = {}
-entries = {}
+codec_registry: dict[str, Codec] = {}
+entries: dict[str, "EntryPoints"] = {}
 
 
 def run_entrypoints():
@@ -42,14 +44,13 @@ def get_codec(config):
     config = dict(config)
     codec_id = config.pop('id', None)
     cls = codec_registry.get(codec_id)
-    if cls is None:
-        if codec_id in entries:
-            logger.debug("Auto loading codec '%s' from entrypoint", codec_id)
-            cls = entries[codec_id].load()
-            register_codec(cls, codec_id=codec_id)
+    if cls is None and codec_id in entries:
+        logger.debug("Auto loading codec '%s' from entrypoint", codec_id)
+        cls = entries[codec_id].load()
+        register_codec(cls, codec_id=codec_id)
     if cls:
         return cls.from_config(config)
-    raise ValueError('codec not available: %r' % codec_id)
+    raise ValueError(f'codec not available: {codec_id!r}')
 
 
 def register_codec(cls, codec_id=None):