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

numcodecs/tests/test_blosc.py

@@ -1,28 +1,25 @@
 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
 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_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_encode_decode_partial,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_max_buffer_size,
+)
 
 codecs = [
     Blosc(shuffle=Blosc.SHUFFLE),
@@ -54,10 +51,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 +76,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 +106,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

@@ -1,15 +1,16 @@
 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_err_decode_object_buffer,
-                                    check_err_encode_object_buffer)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
 
 codecs = [
     BZ2(),
@@ -32,10 +33,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

@@ -1,13 +1,14 @@
 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_encode_decode_array)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_encode_decode_array,
+)
 
 labels = ['ƒöõ', 'ßàř', 'ßāẑ', 'ƪùüx']
 arrays = [
@@ -20,7 +21,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 +34,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 +60,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 +75,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

@@ -1,15 +1,16 @@
 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_err_encode_object_buffer)
-
+from numcodecs.tests.common import (
+    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
@@ -19,7 +20,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

@@ -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():
@@ -14,7 +12,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 +24,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 +43,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 +57,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 +65,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 +94,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)

numcodecs/tests/test_delta.py

@@ -1,12 +1,14 @@
 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_config, check_repr,
-                                    check_backwards_compatibility)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_repr,
+)
 
 # mix of dtypes: integer, float
 # mix of shapes: 1D, 2D, 3D

numcodecs/tests/test_entrypoints.py

@@ -5,7 +5,6 @@ import pytest
 
 import numcodecs.registry
 
-
 here = os.path.abspath(os.path.dirname(__file__))
 
 

numcodecs/tests/test_entrypoints_backport.py

@@ -1,15 +1,17 @@
+import importlib
 import os.path
-import pkgutil
 import sys
+from multiprocessing import Process
 
 import pytest
 
-from multiprocessing import Process
-
 import numcodecs.registry
 
-if not pkgutil.find_loader("importlib_metadata"):  # pragma: no cover
-    pytest.skip("This test module requires importlib_metadata to be installed")
+if not importlib.util.find_spec("importlib_metadata").loader:  # pragma: no cover
+    pytest.skip(
+        "This test module requires importlib_metadata to be installed",
+        allow_module_level=True,
+    )
 
 here = os.path.abspath(os.path.dirname(__file__))
 
@@ -19,6 +21,7 @@ def get_entrypoints_with_importlib_metadata_loaded():
     # to the APIs of EntryPoint objects used when registering entrypoints. Attempt to
     # isolate those changes to just this test.
     import importlib_metadata  # noqa: F401
+
     sys.path.append(here)
     numcodecs.registry.run_entrypoints()
     cls = numcodecs.registry.get_codec({"id": "test"})

numcodecs/tests/test_fixedscaleoffset.py

@@ -1,15 +1,16 @@
 import itertools
 
-
 import numpy as np
-from numpy.testing import assert_array_equal
 import pytest
-
+from numpy.testing import assert_array_equal
 
 from numcodecs.fixedscaleoffset import FixedScaleOffset
-from numcodecs.tests.common import (check_encode_decode, check_config, check_repr,
-                                    check_backwards_compatibility)
-
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_repr,
+)
 
 arrays = [
     np.linspace(1000, 1001, 1000, dtype='<f8'),

numcodecs/tests/test_fletcher32.py

@@ -4,10 +4,7 @@ import pytest
 from numcodecs.fletcher32 import Fletcher32
 
 
-@pytest.mark.parametrize(
-    "dtype",
-    ["uint8", "int32", "float32"]
-)
+@pytest.mark.parametrize("dtype", ["uint8", "int32", "float32"])
 def test_with_data(dtype):
     data = np.arange(100, dtype=dtype)
     f = Fletcher32()
@@ -33,11 +30,21 @@ def test_known():
         b'\x88\t\x00\x00\x00\x00\x00\x00i\x03\x00\x00\x00\x00\x00\x00'
         b'\x93\xfd\xff\xff\xff\xff\xff\xff\xc3\xfc\xff\xff\xff\xff\xff\xff'
         b"'\x02\x00\x00\x00\x00\x00\x00\xba\xf7\xff\xff\xff\xff\xff\xff"
-        b'\xfd%\x86d')
+        b'\xfd%\x86d'
+    )
     data3 = Fletcher32().decode(data)
     outarr = np.frombuffer(data3, dtype="<i8")
     expected = [
-        1911, -2427, 1897, -2412, 2440, 873, -621, -829, 551, -2118,
+        1911,
+        -2427,
+        1897,
+        -2412,
+        2440,
+        873,
+        -621,
+        -829,
+        551,
+        -2118,
     ]
     assert outarr.tolist() == expected
 

numcodecs/tests/test_gzip.py

@@ -1,16 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 from numcodecs.gzip import GZip
-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_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_repr,
+)
 
 codecs = [
     GZip(),
@@ -35,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_jenkins.py

@@ -1,19 +1,19 @@
 import numpy as np
 import pytest
 
-from numcodecs.jenkins import jenkins_lookup3
 from numcodecs.checksum32 import JenkinsLookup3
+from numcodecs.jenkins import jenkins_lookup3
 
 
 def test_jenkins_lookup3():
     h = jenkins_lookup3(b"", 0)
-    assert h == 0xdeadbeef
-    h = jenkins_lookup3(b"", 0xdeadbeef)
-    assert h == 0xbd5b7dde
+    assert h == 0xDEADBEEF
+    h = jenkins_lookup3(b"", 0xDEADBEEF)
+    assert h == 0xBD5B7DDE
     h = jenkins_lookup3(b"Four score and seven years ago", 0)
     assert h == 0x17770551
     h = jenkins_lookup3(b"Four score and seven years ago", 1)
-    assert h == 0xcd628161
+    assert h == 0xCD628161
 
     # jenkins-cffi example
     h = jenkins_lookup3(b"jenkins", 0)
@@ -69,7 +69,7 @@ def test_jenkins_lookup3_codec():
     assert result[-4:] == b'\x51\x05\x77\x17'
     assert bytes(j.decode(result)) == s
 
-    j = JenkinsLookup3(initval=0xdeadbeef)
+    j = JenkinsLookup3(initval=0xDEADBEEF)
     result = j.encode(s)
     assert bytes(j.decode(result)) == s
 
@@ -82,39 +82,41 @@ def test_jenkins_lookup3_codec():
     result = j.encode(s)
     assert bytes(j.decode(result)) == s
 
-    chunk_index = b"\x00\x08\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x17\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xee'\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xe57\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xdcG\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xd3W\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xcag\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xc1w\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xb8\x87\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xaf\x97\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\xa6\xa7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\x9d\xb7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\x94\xc7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\x8b\xd7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"\x82\xe7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
-        b"y\xf7\x00\x00\x00\x00\x00\x00" + \
-        b"\xf7\x0f\x00\x00\x00\x00\x00\x00" + \
+    chunk_index = (
+        b"\x00\x08\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x17\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xee'\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xe57\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xdcG\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xd3W\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xcag\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xc1w\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xb8\x87\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xaf\x97\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\xa6\xa7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\x9d\xb7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\x94\xc7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\x8b\xd7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"\x82\xe7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
+        b"y\xf7\x00\x00\x00\x00\x00\x00"
+        b"\xf7\x0f\x00\x00\x00\x00\x00\x00"
         b"n\x96\x07\x85"
+    )
     hdf5_fadb_prefix = b'FADB\x00\x01\xcf\x01\x00\x00\x00\x00\x00\x00'
     j = JenkinsLookup3(prefix=hdf5_fadb_prefix)
     result = j.encode(chunk_index[:-4])
@@ -122,10 +124,7 @@ def test_jenkins_lookup3_codec():
     assert result == chunk_index
 
 
-@pytest.mark.parametrize(
-    "dtype",
-    ["uint8", "int32", "float32"]
-)
+@pytest.mark.parametrize("dtype", ["uint8", "int32", "float32"])
 def test_with_data(dtype):
     data = np.arange(100, dtype=dtype)
     j = JenkinsLookup3()

numcodecs/tests/test_json.py

@@ -1,12 +1,17 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
 from numcodecs.json import JSON
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings)
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode_array,
+    check_repr,
+    greetings,
+)
+
 codecs = [
     JSON(),
     JSON(indent=True),
@@ -62,14 +67,19 @@ def test_backwards_compatibility():
         ([[[0, 0]], [[1, 1]], [[2, 3]]], None),
         (["1"], None),
         (["11", "11"], None),
-        (["11", "1", "1"],  None),
+        (["11", "1", "1"], None),
         ([{}], None),
         ([{"key": "value"}, ["list", "of", "strings"]], object),
-    ]
+        ([0], None),
+        ([{'hi': 0}], "object"),
+        (["hi"], "object"),
+        (0, None),
+    ],
 )
 def test_non_numpy_inputs(input_data, dtype):
     # numpy will infer a range of different shapes and dtypes for these inputs.
     # Make sure that round-tripping through encode preserves this.
+    data = np.array(input_data, dtype=dtype)
     for codec in codecs:
-        output_data = codec.decode(codec.encode(input_data))
-        assert np.array_equal(np.array(input_data, dtype=dtype), output_data)
+        output_data = codec.decode(codec.encode(data))
+        assert input_data == output_data.tolist()

numcodecs/tests/test_lz4.py

@@ -1,24 +1,23 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
 try:
     from numcodecs.lz4 import LZ4
 except ImportError:  # pragma: no cover
-    pytest.skip(
-        "numcodecs.lz4 not available", allow_module_level=True
-    )
-
+    pytest.skip("numcodecs.lz4 not available", allow_module_level=True)
 
-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,
-                                    check_max_buffer_size)
 
+from numcodecs.tests.common import (
+    check_backwards_compatibility,
+    check_config,
+    check_encode_decode,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_max_buffer_size,
+    check_repr,
+)
 
 codecs = [
     LZ4(),
@@ -44,10 +43,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]'),
 ]