numcodecs 0.12.1__cp312-cp312-macosx_11_0_arm64.whl → 0.13.0__cp312-cp312-macosx_11_0_arm64.whl

numcodecs/tests/test_delta.py

@@ -4,8 +4,12 @@ import pytest
 
 
 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_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+)
 
 
 # mix of dtypes: integer, float

numcodecs/tests/test_entrypoints_backport.py

@@ -9,7 +9,10 @@ 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")
+    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 +22,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

@@ -7,8 +7,12 @@ import pytest
 
 
 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_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+)
 
 
 arrays = [

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

@@ -6,10 +6,14 @@ 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_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+)
 
 
 codecs = [
@@ -35,10 +39,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

@@ -7,13 +7,13 @@ from numcodecs.checksum32 import JenkinsLookup3
 
 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" + \
-        b"n\x96\x07\x85"
+    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_config,
+    check_repr,
+    check_encode_decode_array,
+    check_backwards_compatibility,
+    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

@@ -8,16 +8,18 @@ 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_encode_decode,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+    check_max_buffer_size,
+)
 
 
 codecs = [
@@ -44,10 +46,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_lzma.py

@@ -13,10 +13,14 @@ except ImportError:  # pragma: no cover
     raise unittest.SkipTest("LZMA not available")
 
 
-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 = [
@@ -24,7 +28,7 @@ codecs = [
     LZMA(preset=1),
     LZMA(preset=5),
     LZMA(preset=9),
-    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)])
+    LZMA(format=_lzma.FORMAT_RAW, filters=[dict(id=_lzma.FILTER_LZMA2, preset=1)]),
 ]
 
 
@@ -41,10 +45,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_msgpacks.py

@@ -11,8 +11,13 @@ except ImportError:  # pragma: no cover
     raise unittest.SkipTest("msgpack not available")
 
 
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings)
+from numcodecs.tests.common import (
+    check_config,
+    check_repr,
+    check_encode_decode_array,
+    check_backwards_compatibility,
+    greetings,
+)
 
 
 # object array with strings
@@ -69,7 +74,7 @@ def test_backwards_compatibility():
         ([b"11", b"11"], None),
         ([b"11", b"1", b"1"], None),
         ([{b"key": b"value"}, [b"list", b"of", b"strings"]], object),
-    ]
+    ],
 )
 def test_non_numpy_inputs(input_data, dtype):
     codec = MsgPack()

numcodecs/tests/test_packbits.py

@@ -2,8 +2,12 @@ import numpy as np
 
 
 from numcodecs.packbits import PackBits
-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,
+)
 
 
 arrays = [

numcodecs/tests/test_pcodec.py

@@ -0,0 +1,81 @@
+import pytest
+import numpy as np
+
+from numcodecs.pcodec import PCodec
+
+try:
+    # initializing codec triggers ImportError
+    PCodec()
+except ImportError:  # pragma: no cover
+    pytest.skip("pcodec not available", allow_module_level=True)
+
+from numcodecs.tests.common import (
+    check_encode_decode_array_to_bytes,
+    check_config,
+    check_repr,
+    check_backwards_compatibility,
+    check_err_decode_object_buffer,
+    check_err_encode_object_buffer,
+)
+
+
+codecs = [
+    PCodec(),
+    PCodec(level=1),
+    PCodec(level=5),
+    PCodec(level=9),
+    PCodec(mode_spec='classic'),
+    PCodec(equal_pages_up_to=300),
+]
+
+
+# mix of dtypes: integer, float
+# mix of shapes: 1D, 2D
+# mix of orders: C, F
+arrays = [
+    np.arange(1000, dtype="u4"),
+    np.arange(1000, dtype="u8"),
+    np.arange(1000, dtype="i4"),
+    np.arange(1000, dtype="i8"),
+    np.linspace(1000, 1001, 1000, dtype="f4"),
+    np.linspace(1000, 1001, 1000, dtype="f8"),
+    np.random.normal(loc=1000, scale=1, size=(100, 10)),
+    np.asfortranarray(np.random.normal(loc=1000, scale=1, size=(100, 10))),
+    np.random.randint(0, 2**60, size=1000, dtype="u8"),
+    np.random.randint(-(2**63), -(2**63) + 20, size=1000, dtype="i8"),
+]
+
+
+@pytest.mark.parametrize("arr", arrays)
+@pytest.mark.parametrize("codec", codecs)
+def test_encode_decode(arr, codec):
+    check_encode_decode_array_to_bytes(arr, codec)
+
+
+def test_config():
+    codec = PCodec(level=3)
+    check_config(codec)
+
+
+def test_invalid_config_error():
+    with pytest.raises(ValueError):
+        codec = PCodec(mode_spec='bogus')
+        check_encode_decode_array_to_bytes(arrays[0], codec)
+
+
+def test_repr():
+    check_repr(
+        "PCodec(delta_encoding_order=None, equal_pages_up_to=262144, level=3, mode_spec='auto')"
+    )
+
+
+def test_backwards_compatibility():
+    check_backwards_compatibility(PCodec.codec_id, arrays, codecs)
+
+
+def test_err_decode_object_buffer():
+    check_err_decode_object_buffer(PCodec())
+
+
+def test_err_encode_object_buffer():
+    check_err_encode_object_buffer(PCodec())

numcodecs/tests/test_pickles.py

@@ -5,8 +5,13 @@ import numpy as np
 import pytest
 
 from numcodecs.pickles import Pickle
-from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
-                                    check_backwards_compatibility, greetings)
+from numcodecs.tests.common import (
+    check_config,
+    check_repr,
+    check_encode_decode_array,
+    check_backwards_compatibility,
+    greetings,
+)
 
 
 codecs = [Pickle(protocol=i) for i in range(5)]
@@ -45,14 +50,13 @@ def test_repr():
 
 # Details on xfail
 # https://stackoverflow.com/questions/58194852/modulenotfounderror-no-module-named-numpy-core-multiarray-r
-@pytest.mark.skipif(
-    sys.byteorder != "little", reason="Pickle does not restore byte orders"
-)
+@pytest.mark.skipif(sys.byteorder != "little", reason="Pickle does not restore byte orders")
 @pytest.mark.xfail(
-    sys.platform == "win32", reason=(
+    sys.platform == "win32",
+    reason=(
         "Pickle fails to read w/ Windows carriage return "
         "( https://github.com/zarr-developers/numcodecs/issues/271 )"
-    )
+    ),
 )
 def test_backwards_compatibility():
     check_backwards_compatibility(Pickle.codec_id, arrays, codecs)

numcodecs/tests/test_quantize.py

@@ -7,8 +7,12 @@ import pytest
 
 
 from numcodecs.quantize import Quantize
-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,
+)
 
 
 arrays = [

numcodecs/tests/test_shuffle.py

@@ -9,21 +9,21 @@ import pytest
 try:
     from numcodecs.shuffle import Shuffle
 except ImportError:  # pragma: no cover
-    pytest.skip(
-        "numcodecs.shuffle not available", allow_module_level=True
-    )
+    pytest.skip("numcodecs.shuffle not available", allow_module_level=True)
 
 
-from numcodecs.tests.common import (check_encode_decode,
-                                    check_config,
-                                    check_backwards_compatibility)
+from numcodecs.tests.common import (
+    check_encode_decode,
+    check_config,
+    check_backwards_compatibility,
+)
 
 
 codecs = [
     Shuffle(),
     Shuffle(elementsize=0),
     Shuffle(elementsize=4),
-    Shuffle(elementsize=8)
+    Shuffle(elementsize=8),
 ]
 
 
@@ -40,10 +40,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]'),
 ]
 
 
@@ -132,22 +132,33 @@ def test_backwards_compatibility():
 #         with pytest.raises(RuntimeError):
 #             codec.decode(bytearray(0))
 
+
 def test_expected_result():
     # If the input is treated as a 2D byte array, with shape (size of element, number of elements),
     # the shuffle is essentially a transpose. This can be made more apparent by using an array of
     # big-endian integers, as below.
-    arr = np.array([0x0001020304050607, 0x08090a0b0c0d0e0f, 0x1011121314151617, 0x18191a1b1c1d1e1f],
-                   dtype='>u8')
-    expected = np.array([
-        0x00081018,
-        0x01091119,
-        0x020a121a,
-        0x030b131b,
-        0x040c141c,
-        0x050d151d,
-        0x060e161e,
-        0x070f171f,
-    ], dtype='u4')
+    arr = np.array(
+        [
+            0x0001020304050607,
+            0x08090A0B0C0D0E0F,
+            0x1011121314151617,
+            0x18191A1B1C1D1E1F,
+        ],
+        dtype='>u8',
+    )
+    expected = np.array(
+        [
+            0x00081018,
+            0x01091119,
+            0x020A121A,
+            0x030B131B,
+            0x040C141C,
+            0x050D151D,
+            0x060E161E,
+            0x070F171F,
+        ],
+        dtype='u4',
+    )
     codec = Shuffle(elementsize=arr.data.itemsize)
     enc = codec.encode(arr)
     np.testing.assert_array_equal(np.frombuffer(enc.data, '>u4'), expected)