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

numcodecs/pcodec.py

@@ -0,0 +1,89 @@
+from typing import Optional, Literal
+
+import numcodecs
+import numcodecs.abc
+from numcodecs.compat import ensure_contiguous_ndarray
+
+try:
+    from pcodec import standalone, ChunkConfig, PagingSpec, ModeSpec
+except ImportError:  # pragma: no cover
+    standalone = None
+
+
+DEFAULT_MAX_PAGE_N = 262144
+
+
+class PCodec(numcodecs.abc.Codec):
+    """
+    PCodec (or pco, pronounced "pico") losslessly compresses and decompresses
+    numerical sequences with high compression ratio and fast speed.
+
+    See `PCodec Repo <https://github.com/mwlon/pcodec>`_ for more information.
+
+    PCodec supports only the following numerical dtypes: uint16, uint32, uint64,
+    int16, int32, int64, float16, float32, and float64.
+
+    Parameters
+    ----------
+    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'}
+        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).
+    equal_pages_up_to : int
+        Divide the chunk into equal pages of up to this many numbers.
+    """
+
+    codec_id = "pcodec"
+
+    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',
+    ):
+        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.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)
+
+        match self.mode_spec:
+            case 'auto':
+                mode_spec = ModeSpec.auto()
+            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)
+
+        config = ChunkConfig(
+            compression_level=self.level,
+            delta_encoding_order=self.delta_encoding_order,
+            mode_spec=mode_spec,
+            paging_spec=paging_spec,
+        )
+        return standalone.simple_compress(buf, config)
+
+    def decode(self, buf, out=None):
+        if out is not None:
+            out = ensure_contiguous_ndarray(out)
+            standalone.simple_decompress_into(buf, out)
+            return out
+        else:
+            return standalone.simple_decompress(buf)

numcodecs/pickles.py

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

numcodecs/quantize.py

@@ -60,19 +60,18 @@ class Quantize(Codec):
             raise ValueError('only floating point data types are supported')
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(self.dtype)
 
         # apply scaling
-        precision = 10. ** -self.digits
+        precision = 10.0**-self.digits
         exp = math.log(precision, 10)
         if exp < 0:
             exp = int(math.floor(exp))
         else:
             exp = int(math.ceil(exp))
-        bits = math.ceil(math.log(10. ** -exp, 2))
-        scale = 2. ** bits
+        bits = math.ceil(math.log(10.0**-exp, 2))
+        scale = 2.0**bits
         enc = np.around(scale * arr) / scale
 
         # cast dtype
@@ -92,12 +91,15 @@ class Quantize(Codec):
             id=self.codec_id,
             digits=self.digits,
             dtype=self.dtype.str,
-            astype=self.astype.str
+            astype=self.astype.str,
         )
 
     def __repr__(self):
-        r = '%s(digits=%s, dtype=%r' % \
-            (type(self).__name__, self.digits, self.dtype.str)
+        r = '%s(digits=%s, dtype=%r' % (
+            type(self).__name__,
+            self.digits,
+            self.dtype.str,
+        )
         if self.astype != self.dtype:
             r += ', astype=%r' % self.astype.str
         r += ')'

numcodecs/registry.py

@@ -1,5 +1,6 @@
 """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
 
@@ -11,12 +12,7 @@ entries = {}
 def run_entrypoints():
     entries.clear()
     eps = entry_points()
-    if hasattr(eps, 'select'):
-        # If entry_points() has a select method, use that. Python 3.10+
-        entries.update({e.name: e for e in eps.select(group="numcodecs.codecs")})
-    else:
-        # Otherwise, fallback to using get
-        entries.update(eps.get("numcodecs.codecs", []))
+    entries.update({e.name: e for e in eps.select(group="numcodecs.codecs")})
 
 
 run_entrypoints()

numcodecs/shuffle.py

@@ -28,7 +28,7 @@ class Shuffle(Codec):
             out = ensure_contiguous_ndarray(out)
 
         if self.elementsize <= 1:
-            out.view(buf.dtype)[:len(buf)] = buf[:]  # no shuffling needed
+            out.view(buf.dtype)[: len(buf)] = buf[:]  # no shuffling needed
             return buf, out
 
         if buf.nbytes % self.elementsize != 0:
@@ -57,7 +57,5 @@ class Shuffle(Codec):
         return out
 
     def __repr__(self):
-        r = '%s(elementsize=%s)' % \
-            (type(self).__name__,
-             self.elementsize)
+        r = '%s(elementsize=%s)' % (type(self).__name__, self.elementsize)
         return r

numcodecs/tests/common.py

@@ -11,18 +11,28 @@ import pytest
 
 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!', 'Servus Woid!', 'Hei maailma!',
-             'Xin chào thế giới', 'Njatjeta Botë!', 'Γεια σου κόσμε!',
-             'こんにちは世界', '世界，你好！', 'Helló, világ!', 'Zdravo svete!',
-             'เฮลโลเวิลด์']
+greetings = [
+    '¡Hola mundo!',
+    'Hej Världen!',
+    'Servus Woid!',
+    'Hei maailma!',
+    'Xin chào thế giới',
+    'Njatjeta Botë!',
+    'Γεια σου κόσμε!',
+    'こんにちは世界',
+    '世界，你好！',
+    'Helló, világ!',
+    'Zdravo svete!',
+    'เฮลโลเวิลด์',
+]
 
 
 def compare_arrays(arr, res, precision=None):
-
     # ensure numpy array with matching dtype
     res = ensure_ndarray(res).view(arr.dtype)
 
@@ -43,7 +53,6 @@ def compare_arrays(arr, res, precision=None):
 
 
 def check_encode_decode(arr, codec, precision=None):
-
     # N.B., watch out here with blosc compressor, if the itemsize of
     # the source buffer is different then the results of encoding
     # (i.e., compression) may be different. Hence we *do not* require that
@@ -112,7 +121,6 @@ def check_encode_decode(arr, codec, precision=None):
 
 
 def check_encode_decode_partial(arr, codec, precision=None):
-
     # N.B., watch out here with blosc compressor, if the itemsize of
     # the source buffer is different then the results of encoding
     # (i.e., compression) may be different. Hence we *do not* require that
@@ -122,7 +130,7 @@ def check_encode_decode_partial(arr, codec, precision=None):
 
     itemsize = arr.itemsize
     start, nitems = 5, 10
-    compare_arr = arr[start:start+nitems]
+    compare_arr = arr[start : start + nitems]
     # test encoding of numpy array
     enc = codec.encode(arr)
     dec = codec.decode_partial(enc, start, nitems)
@@ -135,19 +143,19 @@ def check_encode_decode_partial(arr, codec, precision=None):
     # test partial decode of encoded bytes
     buf = arr.tobytes(order='A')
     enc = codec.encode(buf)
-    dec = codec.decode_partial(enc, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(enc, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test partial decode of encoded bytearray
     buf = bytearray(arr.tobytes(order='A'))
     enc = codec.encode(buf)
-    dec = codec.decode_partial(enc, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(enc, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test partial decode of encoded array.array
     buf = array.array('b', arr.tobytes(order='A'))
     enc = codec.encode(buf)
-    dec = codec.decode_partial(enc, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(enc, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # # decoding should support any object exporting the buffer protocol,
@@ -156,32 +164,31 @@ def check_encode_decode_partial(arr, codec, precision=None):
     enc_bytes = ensure_bytes(enc)
 
     # test decoding of raw bytes into numpy array
-    dec = codec.decode_partial(enc_bytes, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(enc_bytes, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test partial decoding of bytearray
-    dec = codec.decode_partial(bytearray(enc_bytes), start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(bytearray(enc_bytes), start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test partial decoding of array.array
     buf = array.array('b', enc_bytes)
-    dec = codec.decode_partial(buf, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(buf, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test decoding of numpy array into numpy array
     buf = np.frombuffer(enc_bytes, dtype='u1')
-    dec = codec.decode_partial(buf, start*itemsize, nitems*itemsize, out=out)
+    dec = codec.decode_partial(buf, start * itemsize, nitems * itemsize, out=out)
     compare_arrays(compare_arr, dec, precision=precision)
 
     # test decoding directly into bytearray
     out = bytearray(compare_arr.nbytes)
-    codec.decode_partial(enc_bytes, start*itemsize, nitems*itemsize, out=out)
+    codec.decode_partial(enc_bytes, start * itemsize, nitems * itemsize, out=out)
     # noinspection PyTypeChecker
     compare_arrays(compare_arr, out, precision=precision)
 
 
 def assert_array_items_equal(res, arr):
-
     assert isinstance(res, np.ndarray)
     res = res.reshape(-1, order='A')
     arr = arr.reshape(-1, order='A')
@@ -203,7 +210,6 @@ def assert_array_items_equal(res, arr):
 
 
 def check_encode_decode_array(arr, codec):
-
     enc = codec.encode(arr)
     dec = codec.decode(enc)
     assert_array_items_equal(arr, dec)
@@ -217,6 +223,16 @@ def check_encode_decode_array(arr, codec):
     assert_array_items_equal(arr, dec)
 
 
+def check_encode_decode_array_to_bytes(arr, codec):
+    enc = codec.encode(arr)
+    dec = codec.decode(enc)
+    assert_array_items_equal(arr, dec)
+
+    out = np.empty_like(arr)
+    codec.decode(enc, out=out)
+    assert_array_items_equal(arr, out)
+
+
 def check_config(codec):
     config = codec.get_config()
     # round-trip through JSON to check serialization
@@ -232,7 +248,6 @@ def check_repr(stmt):
 
 
 def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, prefix=None):
-
     # setup directory to hold data fixture
     if prefix:
         fixture_dir = os.path.join('fixture', codec_id, prefix)
@@ -249,7 +264,6 @@ def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, pref
 
     # load fixture data
     for arr_fn in glob(os.path.join(fixture_dir, 'array.*.npy')):
-
         # setup
         i = int(arr_fn.split('.')[-2])
         arr = np.load(arr_fn, allow_pickle=True)
@@ -260,7 +274,6 @@ def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, pref
             order = 'C'
 
         for j, codec in enumerate(codecs):
-
             if codec is None:
                 pytest.skip("codec has been removed")
 
@@ -334,7 +347,8 @@ def check_max_buffer_size(codec):
                 np.zeros(max_buffer_size + 1, dtype=np.int8),
                 np.zeros(max_buffer_size + 2, dtype=np.int8),
                 np.zeros(max_buffer_size, dtype=np.int16),
-                np.zeros(max_buffer_size, dtype=np.int32)]
+                np.zeros(max_buffer_size, dtype=np.int32),
+            ]
             for buf in buffers:
                 with pytest.raises(ValueError):
                     codec.encode(buf)

numcodecs/tests/package_with_entrypoint/__init__.py

@@ -2,7 +2,6 @@ from numcodecs.abc import Codec
 
 
 class TestCodec(Codec):
-
     codec_id = "test"
 
     def encode(self, buf):  # pragma: no cover

numcodecs/tests/test_astype.py

@@ -3,8 +3,12 @@ from numpy.testing import assert_array_equal
 
 
 from numcodecs.astype import AsType
-from numcodecs.tests.common import check_encode_decode, check_config, \
-    check_repr, check_backwards_compatibility
+from numcodecs.tests.common import (
+    check_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+)
 
 
 # mix of dtypes: integer, float
@@ -55,7 +59,6 @@ def test_repr():
 
 
 def test_backwards_compatibility():
-
     # integers
     arrs = [
         np.arange(1000, dtype='<i4'),
@@ -70,5 +73,4 @@ def test_backwards_compatibility():
         np.random.normal(loc=1000, scale=1, size=(10, 10, 10)).astype('<f8'),
     ]
     codec = AsType(encode_dtype='<f4', decode_dtype='<f8')
-    check_backwards_compatibility(AsType.codec_id, arrs, [codec], precision=[3],
-                                  prefix='f')
+    check_backwards_compatibility(AsType.codec_id, arrs, [codec], precision=[3], prefix='f')

numcodecs/tests/test_base64.py

@@ -29,14 +29,14 @@ arrays = [
     np.random.normal(loc=1000, scale=1, size=(100, 10)),
     np.random.randint(0, 2, size=1000, dtype=bool).reshape(100, 10, order="F"),
     np.random.choice([b"a", b"bb", b"ccc"], size=1000).reshape(10, 10, 10),
-    np.random.randint(0, 2 ** 60, size=1000, dtype="u8").view("M8[ns]"),
-    np.random.randint(0, 2 ** 60, size=1000, dtype="u8").view("m8[ns]"),
-    np.random.randint(0, 2 ** 25, size=1000, dtype="u8").view("M8[m]"),
-    np.random.randint(0, 2 ** 25, size=1000, dtype="u8").view("m8[m]"),
-    np.random.randint(-(2 ** 63), -(2 ** 63) + 20, size=1000, dtype="i8").view("M8[ns]"),
-    np.random.randint(-(2 ** 63), -(2 ** 63) + 20, size=1000, dtype="i8").view("m8[ns]"),
-    np.random.randint(-(2 ** 63), -(2 ** 63) + 20, size=1000, dtype="i8").view("M8[m]"),
-    np.random.randint(-(2 ** 63), -(2 ** 63) + 20, size=1000, dtype="i8").view("m8[m]"),
+    np.random.randint(0, 2**60, size=1000, dtype="u8").view("M8[ns]"),
+    np.random.randint(0, 2**60, size=1000, dtype="u8").view("m8[ns]"),
+    np.random.randint(0, 2**25, size=1000, dtype="u8").view("M8[m]"),
+    np.random.randint(0, 2**25, size=1000, dtype="u8").view("m8[m]"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8").view("M8[ns]"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8").view("m8[ns]"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8").view("M8[m]"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8").view("m8[m]"),
 ]
 
 

numcodecs/tests/test_blosc.py

@@ -10,18 +10,18 @@ try:
     from numcodecs import blosc
     from numcodecs.blosc import Blosc
 except ImportError:  # pragma: no cover
-    pytest.skip(
-        "numcodecs.blosc not available", allow_module_level=True
-    )
+    pytest.skip("numcodecs.blosc not available", allow_module_level=True)
 
 
-from numcodecs.tests.common import (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)
+from numcodecs.tests.common import (
+    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 = [
@@ -54,10 +54,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 
@@ -79,9 +79,13 @@ def test_encode_decode(array, codec):
 
 
 @pytest.mark.parametrize('codec', codecs)
-@pytest.mark.parametrize('array', [pytest.param(x) if len(x.shape) == 1
-                                   else pytest.param(x, marks=[pytest.mark.xfail])
-                                   for x in arrays])
+@pytest.mark.parametrize(
+    'array',
+    [
+        pytest.param(x) if len(x.shape) == 1 else pytest.param(x, marks=[pytest.mark.xfail])
+        for x in arrays
+    ],
+)
 def test_partial_decode(codec, array):
     _skip_null(codec)
     check_encode_decode_partial(array, codec)
@@ -105,8 +109,7 @@ def test_repr():
     actual = repr(Blosc(cname='zlib', clevel=9, shuffle=Blosc.BITSHUFFLE, blocksize=512))
     assert expect == actual
     expect = "Blosc(cname='blosclz', clevel=5, shuffle=AUTOSHUFFLE, blocksize=1024)"
-    actual = repr(Blosc(cname='blosclz', clevel=5, shuffle=Blosc.AUTOSHUFFLE,
-                        blocksize=1024))
+    actual = repr(Blosc(cname='blosclz', clevel=5, shuffle=Blosc.AUTOSHUFFLE, blocksize=1024))
     assert expect == actual
 
 

numcodecs/tests/test_bz2.py

@@ -5,10 +5,14 @@ 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_err_decode_object_buffer,
-                                    check_err_encode_object_buffer)
+from numcodecs.tests.common import (
+    check_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+)
 
 
 codecs = [
@@ -32,10 +36,10 @@ arrays = [
     np.random.randint(0, 2**60, size=1000, dtype='u8').view('m8[ns]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('M8[m]'),
     np.random.randint(0, 2**25, size=1000, dtype='u8').view('m8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[ns]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('M8[m]'),
-    np.random.randint(-2**63, -2**63 + 20, size=1000, dtype='i8').view('m8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[ns]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('M8[m]'),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype='i8').view('m8[m]'),
 ]
 
 

numcodecs/tests/test_categorize.py

@@ -4,9 +4,12 @@ import pytest
 
 
 from numcodecs.categorize import Categorize
-from numcodecs.tests.common import (check_encode_decode, check_config,
-                                    check_backwards_compatibility,
-                                    check_encode_decode_array)
+from numcodecs.tests.common import (
+    check_encode_decode,
+    check_config,
+    check_backwards_compatibility,
+    check_encode_decode_array,
+)
 
 
 labels = ['ƒöõ', 'ßàř', 'ßāẑ', 'ƪùüx']
@@ -20,7 +23,6 @@ arrays_object = [a.astype(object) for a in arrays]
 
 
 def test_encode_decode():
-
     # unicode dtype
     for arr in arrays:
         codec = Categorize(labels, dtype=arr.dtype)
@@ -34,7 +36,6 @@ def test_encode_decode():
 
 def test_encode():
     for dtype in 'U', object:
-
         arr = np.array(['ƒöõ', 'ßàř', 'ƒöõ', 'ßāẑ', 'ƪùüx'], dtype=dtype)
         # miss off quux
         codec = Categorize(labels=labels[:-1], dtype=arr.dtype, astype='u1')
@@ -61,8 +62,7 @@ def test_config():
 def test_repr():
     dtype = '<U3'
     astype = '|u1'
-    codec = Categorize(labels=['foo', 'bar', 'baz', 'qux'],
-                       dtype=dtype, astype=astype)
+    codec = Categorize(labels=['foo', 'bar', 'baz', 'qux'], dtype=dtype, astype=astype)
     expect = "Categorize(dtype='<U3', astype='|u1', labels=['foo', 'bar', 'baz', ...])"
     actual = repr(codec)
     assert expect == actual
@@ -77,11 +77,9 @@ def test_repr():
 
 def test_backwards_compatibility():
     codec = Categorize(labels=labels, dtype='<U4', astype='u1')
-    check_backwards_compatibility(Categorize.codec_id, arrays, [codec],
-                                  prefix='U')
+    check_backwards_compatibility(Categorize.codec_id, arrays, [codec], prefix='U')
     codec = Categorize(labels=labels, dtype=object, astype='u1')
-    check_backwards_compatibility(Categorize.codec_id, arrays_object,
-                                  [codec], prefix='O')
+    check_backwards_compatibility(Categorize.codec_id, arrays_object, [codec], prefix='O')
 
 
 def test_errors():

numcodecs/tests/test_checksum32.py

@@ -6,9 +6,13 @@ import pytest
 
 
 from numcodecs.checksum32 import CRC32, Adler32
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility,
-                                    check_err_encode_object_buffer)
+from numcodecs.tests.common import (
+    check_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+    check_err_encode_object_buffer,
+)
 
 
 # mix of dtypes: integer, float, bool, string
@@ -19,7 +23,7 @@ arrays = [
     np.linspace(1000, 1001, 1000, dtype='f8'),
     np.random.normal(loc=1000, scale=1, size=(100, 10)),
     np.random.randint(0, 2, size=1000, dtype=bool).reshape(100, 10, order='F'),
-    np.random.choice([b'a', b'bb', b'ccc'], size=1000).reshape(10, 10, 10)
+    np.random.choice([b'a', b'bb', b'ccc'], size=1000).reshape(10, 10, 10),
 ]
 
 codecs = [CRC32(), Adler32()]

numcodecs/tests/test_compat.py

@@ -14,7 +14,7 @@ def test_ensure_text():
         b'adsdasdas',
         'adsdasdas',
         np.asarray(memoryview(b'adsdasdas')),
-        array.array('B', b'qwertyuiqwertyui')
+        array.array('B', b'qwertyuiqwertyui'),
     ]
     for buf in bufs:
         b = ensure_text(buf)
@@ -26,7 +26,7 @@ def test_ensure_bytes():
         b'adsdasdas',
         bytes(20),
         np.arange(100),
-        array.array('l', b'qwertyuiqwertyui')
+        array.array('l', b'qwertyuiqwertyui'),
     ]
     for buf in bufs:
         b = ensure_bytes(buf)
@@ -45,7 +45,7 @@ def test_ensure_contiguous_ndarray_shares_memory():
         ('f', 8, array.array('d', b'qwertyuiqwertyui')),
         ('i', 1, array.array('b', b'qwertyuiqwertyui')),
         ('u', 1, array.array('B', b'qwertyuiqwertyui')),
-        ('u', 1, mmap.mmap(-1, 10))
+        ('u', 1, mmap.mmap(-1, 10)),
     ]
     for expected_kind, expected_itemsize, buf in typed_bufs:
         a = ensure_contiguous_ndarray(buf)
@@ -59,7 +59,6 @@ def test_ensure_contiguous_ndarray_shares_memory():
 
 
 def test_ensure_bytes_invalid_inputs():
-
     # object array not allowed
     a = np.array(['Xin chào thế giới'], dtype=object)
     for e in (a, memoryview(a)):
@@ -68,7 +67,6 @@ def test_ensure_bytes_invalid_inputs():
 
 
 def test_ensure_contiguous_ndarray_invalid_inputs():
-
     # object array not allowed
     a = np.array(['Xin chào thế giới'], dtype=object)
     for e in (a, memoryview(a)):
@@ -98,16 +96,15 @@ def test_ensure_contiguous_ndarray_writeable():
 
 def test_ensure_contiguous_ndarray_max_buffer_size():
     for max_buffer_size in (4, 64, 1024):
-        ensure_contiguous_ndarray(
-            np.zeros(max_buffer_size - 1, dtype=np.int8), max_buffer_size)
-        ensure_contiguous_ndarray(
-            np.zeros(max_buffer_size, dtype=np.int8), max_buffer_size)
+        ensure_contiguous_ndarray(np.zeros(max_buffer_size - 1, dtype=np.int8), max_buffer_size)
+        ensure_contiguous_ndarray(np.zeros(max_buffer_size, dtype=np.int8), max_buffer_size)
         buffers = [
             bytes(b"x" * (max_buffer_size + 1)),
             np.zeros(max_buffer_size + 1, dtype=np.int8),
             np.zeros(max_buffer_size + 2, dtype=np.int8),
             np.zeros(max_buffer_size, dtype=np.int16),
-            np.zeros(max_buffer_size, dtype=np.int32)]
+            np.zeros(max_buffer_size, dtype=np.int32),
+        ]
         for buf in buffers:
             with pytest.raises(ValueError):
                 ensure_contiguous_ndarray(buf, max_buffer_size=max_buffer_size)