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

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
@@ -25,21 +24,21 @@ def test_round_zero_to_zero(dtype):
     # Don't understand Milan's original test:
     # How is it possible to have negative keepbits?
     # for k in range(-5, 50):
-    for k in range(0, max_bits[dtype]):
+    for k in range(max_bits[dtype]):
         ar = round(a, k)
         np.testing.assert_equal(a, ar)
 
 
 def test_round_one_to_one(dtype):
     a = np.ones((3, 2), dtype=dtype)
-    for k in range(0, max_bits[dtype]):
+    for k in range(max_bits[dtype]):
         ar = round(a, k)
         np.testing.assert_equal(a, ar)
 
 
 def test_round_minus_one_to_minus_one(dtype):
     a = -np.ones((3, 2), dtype=dtype)
-    for k in range(0, max_bits[dtype]):
+    for k in range(max_bits[dtype]):
         ar = round(a, k)
         np.testing.assert_equal(a, ar)
 

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),
@@ -136,7 +133,7 @@ def test_compress_blocksize_default(use_threads):
     assert blocksize > 0
 
 
-@pytest.mark.parametrize('bs', (2**7, 2**8))
+@pytest.mark.parametrize('bs', [2**7, 2**8])
 def test_compress_blocksize(use_threads, bs):
     arr = np.arange(1000, dtype='i4')
 
@@ -228,7 +225,7 @@ def _decode_worker(enc):
     return data
 
 
-@pytest.mark.parametrize('pool', (Pool, ThreadPool))
+@pytest.mark.parametrize('pool', [Pool, ThreadPool])
 def test_multiprocessing(use_threads, pool):
     data = np.arange(1000000)
     enc = _encode_worker(data)

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,18 @@
 import itertools
 
-
 import numpy as np
 import pytest
 
-
-from numcodecs.checksum32 import CRC32, Adler32
+from numcodecs.checksum32 import CRC32, CRC32C, Adler32
 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,
 )
 
-
 # mix of dtypes: integer, float, bool, string
 # mix of shapes: 1D, 2D, 3D
 # mix of orders: C, F
@@ -24,38 +22,117 @@ 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]'),
+]
+
+codecs = [
+    CRC32(),
+    CRC32(location="end"),
+    CRC32C(location="start"),
+    CRC32C(),
+    Adler32(),
+    Adler32(location="end"),
 ]
 
-codecs = [CRC32(), Adler32()]
 
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(codecs, arrays))
+def test_encode_decode(codec, arr):
+    check_encode_decode(arr, codec)
+
+
+@pytest.mark.parametrize(("codec", "arr"), itertools.product(codecs, arrays))
+def test_errors(codec, arr):
+    enc = codec.encode(arr)
+    with pytest.raises(RuntimeError):
+        codec.decode(enc[:-1])
 
-def test_encode_decode():
-    for codec, arr in itertools.product(codecs, arrays):
-        check_encode_decode(arr, codec)
 
+@pytest.mark.parametrize("codec", codecs)
+def test_config(codec):
+    check_config(codec)
 
-def test_errors():
-    for codec, arr in itertools.product(codecs, arrays):
-        enc = codec.encode(arr)
-        with pytest.raises(RuntimeError):
-            codec.decode(enc[:-1])
 
+@pytest.mark.parametrize("codec", codecs)
+def test_err_input_too_small(codec):
+    buf = b'000'  # 3 bytes are too little for a 32-bit checksum
+    with pytest.raises(ValueError):
+        codec.decode(buf)
 
-def test_config():
-    for codec in codecs:
-        check_config(codec)
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_encode_non_contiguous(codec):
+    # non-contiguous memory
+    arr = np.arange(1000, dtype='i4')[::2]
+    with pytest.raises(ValueError):
+        codec.encode(arr)
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_encode_list(codec):
+    data = ['foo', 'bar', 'baz']
+    with pytest.raises(TypeError):
+        codec.encode(data)
+
+
+def test_err_location():
+    with pytest.raises(ValueError):
+        CRC32(location="foo")
+    with pytest.raises(ValueError):
+        CRC32C(location="foo")
+    with pytest.raises(ValueError):
+        Adler32(location="foo")
 
 
 def test_repr():
-    check_repr("CRC32()")
-    check_repr("Adler32()")
+    check_repr("CRC32(location='start')")
+    check_repr("CRC32C(location='start')")
+    check_repr("Adler32(location='start')")
+    check_repr("CRC32(location='end')")
+    check_repr("CRC32C(location='end')")
+    check_repr("Adler32(location='end')")
 
 
 def test_backwards_compatibility():
     check_backwards_compatibility(CRC32.codec_id, arrays, [CRC32()])
     check_backwards_compatibility(Adler32.codec_id, arrays, [Adler32()])
+    check_backwards_compatibility(CRC32C.codec_id, arrays, [CRC32C()])
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_encode_object_buffer(codec):
+    check_err_encode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_decode_object_buffer(codec):
+    check_err_decode_object_buffer(codec)
+
+
+@pytest.mark.parametrize("codec", codecs)
+def test_err_out_too_small(codec):
+    arr = np.arange(10, dtype='i4')
+    out = np.empty_like(arr)[:-1]
+    with pytest.raises(ValueError):
+        codec.decode(codec.encode(arr), out)
+
+
+def test_crc32c_checksum():
+    arr = np.arange(0, 64, dtype="uint8")
+    buf = CRC32C(location="end").encode(arr)
+    assert np.frombuffer(buf, dtype="<u4", offset=(len(buf) - 4))[0] == np.uint32(4218238699)
 
 
-def test_err_encode_object_buffer():
-    check_err_encode_object_buffer(CRC32())
-    check_err_encode_object_buffer(Adler32())
+@pytest.mark.parametrize("codec", codecs)
+def test_err_checksum(codec):
+    arr = np.arange(0, 64, dtype="uint8")
+    buf = bytearray(codec.encode(arr))
+    buf[-1] = 0  # corrupt the checksum
+    with pytest.raises(RuntimeError):
+        codec.decode(buf)

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():
@@ -66,6 +64,9 @@ def test_ensure_bytes_invalid_inputs():
             ensure_bytes(e)
 
 
+@pytest.mark.filterwarnings(
+    "ignore:The 'u' type code is deprecated and will be removed in Python 3.16"
+)
 def test_ensure_contiguous_ndarray_invalid_inputs():
     # object array not allowed
     a = np.array(['Xin chào thế giới'], dtype=object)

numcodecs/tests/test_delta.py

@@ -1,21 +1,20 @@
 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
 arrays = [
+    np.random.randint(0, 1, size=110, dtype='?').reshape(10, 11),
     np.arange(1000, dtype='<i4'),
     np.linspace(1000, 1001, 1000, dtype='<f4').reshape(100, 10),
     np.random.normal(loc=1000, scale=1, size=(10, 10, 10)).astype('<f8'),

numcodecs/tests/test_entrypoints.py

@@ -5,11 +5,10 @@ import pytest
 
 import numcodecs.registry
 
-
 here = os.path.abspath(os.path.dirname(__file__))
 
 
-@pytest.fixture()
+@pytest.fixture
 def set_path():
     sys.path.append(here)
     numcodecs.registry.run_entrypoints()

numcodecs/tests/test_entrypoints_backport.py

@@ -1,14 +1,14 @@
+import importlib.util
 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
+importlib_spec = importlib.util.find_spec("importlib_metadata")
+if importlib_spec is None or importlib_spec.loader is None:  # pragma: no cover
     pytest.skip(
         "This test module requires importlib_metadata to be installed",
         allow_module_level=True,

numcodecs/tests/test_fixedscaleoffset.py

@@ -1,20 +1,17 @@
 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_backwards_compatibility,
     check_config,
+    check_encode_decode,
     check_repr,
-    check_backwards_compatibility,
 )
 
-
 arrays = [
     np.linspace(1000, 1001, 1000, dtype='<f8'),
     np.random.normal(loc=1000, scale=1, size=1000).astype('<f8'),
@@ -39,12 +36,20 @@ def test_encode_decode():
         check_encode_decode(arr, codec, precision=precision)
 
 
-def test_encode():
+@pytest.mark.parametrize(
+    ("offset", "scale", "expected"),
+    [
+        (1000, 10, [0, 6, 11, 17, 22, 28, 33, 39, 44, 50]),
+        (1002.5, 10, [-25, -19, -14, -8, -3, 3, 8, 14, 19, 25]),
+        (1000, 0.5, [0, 0, 1, 1, 1, 1, 2, 2, 2, 2]),
+    ],
+)
+def test_encode(offset: float, scale: float, expected: list[int]):
     dtype = '<f8'
-    astype = '|u1'
-    codec = FixedScaleOffset(scale=10, offset=1000, dtype=dtype, astype=astype)
-    arr = np.linspace(1000, 1001, 10, dtype=dtype)
-    expect = np.array([0, 1, 2, 3, 4, 6, 7, 8, 9, 10], dtype=astype)
+    astype = np.int16
+    codec = FixedScaleOffset(scale=scale, offset=offset, dtype=dtype, astype=astype)
+    arr = np.linspace(1000, 1005, 10, dtype=dtype)
+    expect = np.array(expected, dtype=astype)
     actual = codec.encode(arr)
     assert_array_equal(expect, actual)
     assert np.dtype(astype) == actual.dtype

numcodecs/tests/test_gzip.py

@@ -1,21 +1,18 @@
 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_config,
+    check_encode_decode,
     check_err_decode_object_buffer,
     check_err_encode_object_buffer,
+    check_repr,
 )
 
-
 codecs = [
     GZip(),
     GZip(level=-1),

numcodecs/tests/test_jenkins.py

@@ -1,8 +1,8 @@
 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():
@@ -84,38 +84,38 @@ def test_jenkins_lookup3_codec():
 
     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"
+        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)

numcodecs/tests/test_json.py

@@ -5,10 +5,10 @@ import pytest
 
 from numcodecs.json import JSON
 from numcodecs.tests.common import (
+    check_backwards_compatibility,
     check_config,
-    check_repr,
     check_encode_decode_array,
-    check_backwards_compatibility,
+    check_repr,
     greetings,
 )
 
@@ -59,7 +59,7 @@ def test_backwards_compatibility():
 
 
 @pytest.mark.parametrize(
-    "input_data, dtype",
+    ('input_data', 'dtype'),
     [
         ([0, 1], None),
         ([[0, 1], [2, 3]], None),