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

numcodecs/msgpacks.py

@@ -1,6 +1,5 @@
-import numpy as np
 import msgpack
-
+import numpy as np
 
 from .abc import Codec
 from .compat import ensure_contiguous_ndarray
@@ -58,8 +57,11 @@ class MsgPack(Codec):
             buf = np.asarray(buf, dtype=object)
         items = buf.tolist()
         items.extend((buf.dtype.str, buf.shape))
-        return msgpack.packb(items, use_bin_type=self.use_bin_type,
-                             use_single_float=self.use_single_float)
+        return msgpack.packb(
+            items,
+            use_bin_type=self.use_bin_type,
+            use_single_float=self.use_single_float,
+        )
 
     def decode(self, buf, out=None):
         buf = ensure_contiguous_ndarray(buf)
@@ -73,13 +75,12 @@ class MsgPack(Codec):
             return dec
 
     def get_config(self):
-        return dict(id=self.codec_id,
-                    raw=self.raw,
-                    use_single_float=self.use_single_float,
-                    use_bin_type=self.use_bin_type)
+        return dict(
+            id=self.codec_id,
+            raw=self.raw,
+            use_single_float=self.use_single_float,
+            use_bin_type=self.use_bin_type,
+        )
 
     def __repr__(self):
-        return (
-            'MsgPack(raw={!r}, use_bin_type={!r}, use_single_float={!r})'
-            .format(self.raw, self.use_bin_type, self.use_single_float)
-        )
+        return f'MsgPack(raw={self.raw!r}, use_bin_type={self.use_bin_type!r}, use_single_float={self.use_single_float!r})'

numcodecs/ndarray_like.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Protocol, Tuple, Type, runtime_checkable
+from typing import Any, ClassVar, Optional, Protocol, runtime_checkable
 
 
 class _CachedProtocolMeta(Protocol.__class__):
@@ -10,7 +10,8 @@ class _CachedProtocolMeta(Protocol.__class__):
     This metaclass keeps an unbounded cache of the result of
     isinstance checks using the object's class as the cache key.
     """
-    _instancecheck_cache: Dict[Tuple[Type, Type], bool] = {}
+
+    _instancecheck_cache: ClassVar[dict[tuple[type, type], bool]] = {}
 
     def __instancecheck__(self, instance):
         key = (self, instance.__class__)
@@ -38,31 +39,25 @@ class FlagsObj(Protocol, metaclass=_CachedProtocolMeta):
 @runtime_checkable
 class NDArrayLike(Protocol, metaclass=_CachedProtocolMeta):
     dtype: DType
-    shape: Tuple[int, ...]
-    strides: Tuple[int, ...]
+    shape: tuple[int, ...]
+    strides: tuple[int, ...]
     ndim: int
     size: int
     itemsize: int
     nbytes: int
     flags: FlagsObj
 
-    def __len__(self) -> int:
-        ...    # pragma: no cover
+    def __len__(self) -> int: ...  # pragma: no cover
 
-    def __getitem__(self, key) -> Any:
-        ...    # pragma: no cover
+    def __getitem__(self, key) -> Any: ...  # pragma: no cover
 
-    def __setitem__(self, key, value):
-        ...    # pragma: no cover
+    def __setitem__(self, key, value): ...  # pragma: no cover
 
-    def tobytes(self, order: Optional[str] = ...) -> bytes:
-        ...    # pragma: no cover
+    def tobytes(self, order: Optional[str] = ...) -> bytes: ...  # pragma: no cover
 
-    def reshape(self, *shape: int, order: str = ...) -> "NDArrayLike":
-        ...    # pragma: no cover
+    def reshape(self, *shape: int, order: str = ...) -> "NDArrayLike": ...  # pragma: no cover
 
-    def view(self, dtype: DType = ...) -> "NDArrayLike":
-        ...    # pragma: no cover
+    def view(self, dtype: DType = ...) -> "NDArrayLike": ...  # pragma: no cover
 
 
 def is_ndarray_like(obj: object) -> bool:

numcodecs/packbits.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -34,7 +33,6 @@ class PackBits(Codec):
         pass
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(bool)
 
@@ -43,7 +41,7 @@ class PackBits(Codec):
 
         # determine size of packed data
         n = arr.size
-        n_bytes_packed = (n // 8)
+        n_bytes_packed = n // 8
         n_bits_leftover = n % 8
         if n_bits_leftover > 0:
             n_bytes_packed += 1
@@ -64,7 +62,6 @@ class PackBits(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view('u1')
 

numcodecs/pcodec.py

@@ -0,0 +1,89 @@
+from typing import Literal, Optional
+
+import numcodecs
+import numcodecs.abc
+from numcodecs.compat import ensure_contiguous_ndarray
+
+try:
+    from pcodec import ChunkConfig, ModeSpec, PagingSpec, standalone
+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
+        return f'Pickle(protocol={self.protocol})'

numcodecs/quantize.py

@@ -1,9 +1,7 @@
 import math
 
-
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -60,19 +58,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
-        exp = math.log(precision, 10)
+        precision = 10.0**-self.digits
+        exp = math.log10(precision)
         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.log2(10.0**-exp))
+        scale = 2.0**bits
         enc = np.around(scale * arr) / scale
 
         # cast dtype
@@ -92,13 +89,12 @@ 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 = f'{type(self).__name__}(digits={self.digits}, dtype={self.dtype.str!r}'
         if self.astype != self.dtype:
-            r += ', astype=%r' % self.astype.str
+            r += f', astype={self.astype.str!r}'
         r += ')'
         return r

numcodecs/registry.py

@@ -1,7 +1,8 @@
 """The registry module provides some simple convenience functions to enable
 applications to dynamically register and look-up codec classes."""
-from importlib.metadata import entry_points
+
 import logging
+from importlib.metadata import entry_points
 
 logger = logging.getLogger("numcodecs")
 codec_registry = {}
@@ -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({e.name: e for e in eps.get("numcodecs.codecs", [])})
+    entries.update({e.name: e for e in eps.select(group="numcodecs.codecs")})
 
 
 run_entrypoints()
@@ -53,7 +49,7 @@ def get_codec(config):
             register_codec(cls, codec_id=codec_id)
     if cls:
         return cls.from_config(config)
-    raise ValueError('codec not available: %r' % codec_id)
+    raise ValueError(f'codec not available: {codec_id!r}')
 
 
 def register_codec(cls, codec_id=None):

numcodecs/shuffle.py

@@ -1,7 +1,8 @@
 import numpy as np
-from .compat import ensure_contiguous_ndarray
-from .abc import Codec
+
 from ._shuffle import _doShuffle, _doUnshuffle
+from .abc import Codec
+from .compat import ensure_contiguous_ndarray
 
 
 class Shuffle(Codec):
@@ -28,7 +29,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 +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,26 +3,32 @@ 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!', '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 +49,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 +117,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 +126,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 +139,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 +160,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')
@@ -193,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:
@@ -203,7 +206,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 +219,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 +244,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)
@@ -243,13 +254,12 @@ 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)
 
     # 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,12 +270,11 @@ 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")
 
             # 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)
 
@@ -280,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
@@ -334,7 +343,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

@@ -1,11 +1,13 @@
 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_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
@@ -55,7 +57,6 @@ def test_repr():
 
 
 def test_backwards_compatibility():
-
     # integers
     arrs = [
         np.arange(1000, dtype='<i4'),
@@ -70,5 +71,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

@@ -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(),
 ]
@@ -29,14 +26,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_bitround.py

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