numcodecs 0.13.0__cp311-cp311-win_amd64.whl → 0.13.1__cp311-cp311-win_amd64.whl

numcodecs/__init__.py

@@ -1,4 +1,4 @@
-# flake8: noqa
+# ruff: noqa: E402,F401
 """Numcodecs is a Python package providing buffer compression and
 transformation codecs for use in data storage and communication
 applications. These include:
@@ -17,14 +17,12 @@ 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.version import version as __version__
 from numcodecs.zlib import Zlib
 
 register_codec(Zlib)
@@ -130,7 +128,7 @@ register_codec(JSON)
 
 with suppress(ImportError):
     from numcodecs import vlen
-    from numcodecs.vlen import VLenUTF8, VLenBytes, VLenArray
+    from numcodecs.vlen import VLenArray, VLenBytes, VLenUTF8
 
     register_codec(VLenUTF8)
     register_codec(VLenBytes)

numcodecs/abc.py

@@ -118,11 +118,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
 

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,9 +1,7 @@
+import struct
 import zlib
 
-
 import numpy as np
-import struct
-
 
 from .abc import Codec
 from .compat import ensure_contiguous_ndarray, ndarray_copy

numcodecs/compat.py

@@ -1,9 +1,7 @@
-# flake8: noqa
-import functools
-import sys
-import codecs
+# ruff: noqa: F401
 import array
-from functools import reduce
+import codecs
+import functools
 
 import numpy as np
 
@@ -115,7 +113,7 @@ 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

numcodecs/delta.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -91,8 +90,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

@@ -10,7 +10,7 @@ except ImportError:  # pragma: no cover
 
 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 +66,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,4 +1,4 @@
-from typing import Any, Dict, Optional, Protocol, Tuple, Type, runtime_checkable
+from typing import Any, ClassVar, Optional, Protocol, runtime_checkable
 
 
 class _CachedProtocolMeta(Protocol.__class__):
@@ -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
 

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,8 +1,8 @@
 """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 entry_points
 
 logger = logging.getLogger("numcodecs")
 codec_registry = {}
@@ -49,7 +49,7 @@ def get_codec(config):
             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):

numcodecs/shuffle.py

@@ -1,7 +1,8 @@
 import numpy as np
-from .compat import ensure_contiguous_ndarray
-from .abc import Codec
+
 from ._shuffle import _doShuffle, _doUnshuffle
+from .abc import Codec
+from .compat import ensure_contiguous_ndarray
 
 
 class Shuffle(Codec):
@@ -57,5 +58,4 @@ class Shuffle(Codec):
         return out
 
     def __repr__(self):
-        r = '%s(elementsize=%s)' % (type(self).__name__, self.elementsize)
-        return r
+        return f'{type(self).__name__}(elementsize={self.elementsize})'

numcodecs/tests/common.py

@@ -3,19 +3,15 @@ import json as _json
 import os
 from glob import glob
 
-
 import numpy as np
-from numpy.testing import assert_array_almost_equal, assert_array_equal
 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.compat import ensure_bytes, ensure_ndarray
 from numcodecs.registry import get_codec
 
-# star import needed for repr tests so eval finds names
-from numcodecs import *  # noqa
-
-
 greetings = [
     '¡Hola mundo!',
     'Hej Världen!',
@@ -200,7 +196,7 @@ def assert_array_items_equal(res, arr):
     # and values
     arr = arr.ravel().tolist()
     res = res.ravel().tolist()
-    for a, r in zip(arr, res):
+    for a, r in zip(arr, res, strict=True):
         if isinstance(a, np.ndarray):
             assert_array_equal(a, r)
         elif a != a:
@@ -258,7 +254,7 @@ def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, pref
 
     # save fixture data
     for i, arr in enumerate(arrays):
-        arr_fn = os.path.join(fixture_dir, 'array.{:02d}.npy'.format(i))
+        arr_fn = os.path.join(fixture_dir, f'array.{i:02d}.npy')
         if not os.path.exists(arr_fn):  # pragma: no cover
             np.save(arr_fn, arr)
 
@@ -278,7 +274,7 @@ def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, pref
                 pytest.skip("codec has been removed")
 
             # setup a directory to hold encoded data
-            codec_dir = os.path.join(fixture_dir, 'codec.{:02d}'.format(j))
+            codec_dir = os.path.join(fixture_dir, f'codec.{j:02d}')
             if not os.path.exists(codec_dir):  # pragma: no cover
                 os.makedirs(codec_dir)
 
@@ -293,7 +289,7 @@ def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, pref
                 config = _json.load(cf)
                 assert codec == get_codec(config)
 
-            enc_fn = os.path.join(codec_dir, 'encoded.{:02d}.dat'.format(i))
+            enc_fn = os.path.join(codec_dir, f'encoded.{i:02d}.dat')
 
             # one time encode and save array
             if not os.path.exists(enc_fn):  # pragma: no cover

numcodecs/tests/test_astype.py

@@ -1,16 +1,14 @@
 import numpy as np
 from numpy.testing import assert_array_equal
 
-
 from numcodecs.astype import AsType
 from numcodecs.tests.common import (
-    check_encode_decode,
+    check_backwards_compatibility,
     check_config,
+    check_encode_decode,
     check_repr,
-    check_backwards_compatibility,
 )
 
-
 # mix of dtypes: integer, float
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F

numcodecs/tests/test_base64.py

@@ -1,20 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 from numcodecs.base64 import Base64
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_repr,
     check_backwards_compatibility,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 codecs = [
     Base64(),
 ]

numcodecs/tests/test_bitround.py

@@ -1,5 +1,4 @@
 import numpy as np
-
 import pytest
 
 from numcodecs.bitround import BitRound, max_bits

numcodecs/tests/test_blosc.py

@@ -1,11 +1,9 @@
 from multiprocessing import Pool
 from multiprocessing.pool import ThreadPool
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs import blosc
     from numcodecs.blosc import Blosc
@@ -14,16 +12,15 @@ except ImportError:  # pragma: no cover
 
 
 from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
     check_encode_decode,
     check_encode_decode_partial,
-    check_config,
-    check_backwards_compatibility,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
     check_max_buffer_size,
 )
 
-
 codecs = [
     Blosc(shuffle=Blosc.SHUFFLE),
     Blosc(clevel=0, shuffle=Blosc.SHUFFLE),

numcodecs/tests/test_bz2.py

@@ -1,20 +1,17 @@
 import itertools
 
-
 import numpy as np
 
-
 from numcodecs.bz2 import BZ2
 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 = [
     BZ2(),
     BZ2(level=1),

numcodecs/tests/test_categorize.py

@@ -1,17 +1,15 @@
 import numpy as np
-from numpy.testing import assert_array_equal
 import pytest
-
+from numpy.testing import assert_array_equal
 
 from numcodecs.categorize import Categorize
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_encode_decode_array,
 )
 
-
 labels = ['ƒöõ', 'ßàř', 'ßāẑ', 'ƪùüx']
 arrays = [
     np.random.choice(labels, size=1000),

numcodecs/tests/test_checksum32.py

@@ -1,20 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 from numcodecs.checksum32 import CRC32, Adler32
 from numcodecs.tests.common import (
-    check_encode_decode,
-    check_config,
-    check_repr,
     check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 # mix of dtypes: integer, float, bool, string
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F

numcodecs/tests/test_compat.py

@@ -1,12 +1,10 @@
 import array
 import mmap
 
-
 import numpy as np
 import pytest
 
-
-from numcodecs.compat import ensure_text, ensure_bytes, ensure_contiguous_ndarray
+from numcodecs.compat import ensure_bytes, ensure_contiguous_ndarray, ensure_text
 
 
 def test_ensure_text():

numcodecs/tests/test_delta.py

@@ -1,17 +1,15 @@
 import numpy as np
-from numpy.testing import assert_array_equal
 import pytest
-
+from numpy.testing import assert_array_equal
 
 from numcodecs.delta import Delta
 from numcodecs.tests.common import (
-    check_encode_decode,
+    check_backwards_compatibility,
     check_config,
+    check_encode_decode,
     check_repr,
-    check_backwards_compatibility,
 )
 
-
 # mix of dtypes: integer, float
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F