numcodecs 0.12.1__cp311-cp311-macosx_10_9_x86_64.whl → 0.13.0__cp311-cp311-macosx_10_9_x86_64.whl

numcodecs/__init__.py

@@ -13,9 +13,10 @@ pipelines in a variety of ways.
 
 If you have a question, find a bug, would like to make a suggestion or
 contribute code, please `raise an issue on GitHub
-<https://github.com/alimanfoo/numcodecs/issues>`_.
+<https://github.com/zarr-developers/numcodecs/issues>`_.
 
 """
+
 import multiprocessing
 import atexit
 from contextlib import suppress
@@ -25,21 +26,26 @@ from numcodecs.version import version as __version__
 from numcodecs.registry import get_codec, register_codec
 
 from numcodecs.zlib import Zlib
+
 register_codec(Zlib)
 
 from numcodecs.gzip import GZip
+
 register_codec(GZip)
 
 from numcodecs.bz2 import BZ2
+
 register_codec(BZ2)
 
 with suppress(ImportError):
     from numcodecs.lzma import LZMA
+
     register_codec(LZMA)
 
 with suppress(ImportError):
     from numcodecs import blosc
     from numcodecs.blosc import Blosc
+
     register_codec(Blosc)
     # initialize blosc
     try:
@@ -53,65 +59,87 @@ with suppress(ImportError):
 with suppress(ImportError):
     from numcodecs import zstd
     from numcodecs.zstd import Zstd
+
     register_codec(Zstd)
 
 with suppress(ImportError):
     from numcodecs import lz4
     from numcodecs.lz4 import LZ4
+
     register_codec(LZ4)
 
 with suppress(ImportError):
     from numcodecs.zfpy import ZFPY
+
     register_codec(ZFPY)
 
 from numcodecs.astype import AsType
+
 register_codec(AsType)
 
 from numcodecs.delta import Delta
+
 register_codec(Delta)
 
 from numcodecs.quantize import Quantize
+
 register_codec(Quantize)
 
 from numcodecs.fixedscaleoffset import FixedScaleOffset
+
 register_codec(FixedScaleOffset)
 
 from numcodecs.packbits import PackBits
+
 register_codec(PackBits)
 
 from numcodecs.categorize import Categorize
+
 register_codec(Categorize)
 
 from numcodecs.pickles import Pickle
+
 register_codec(Pickle)
 
 from numcodecs.base64 import Base64
+
 register_codec(Base64)
 
 from numcodecs.shuffle import Shuffle
+
 register_codec(Shuffle)
 
 from numcodecs.bitround import BitRound
+
 register_codec(BitRound)
 
 with suppress(ImportError):
     from numcodecs.msgpacks import MsgPack
+
     register_codec(MsgPack)
 
 from numcodecs.checksum32 import CRC32, Adler32, JenkinsLookup3
+
 register_codec(CRC32)
 register_codec(Adler32)
 register_codec(JenkinsLookup3)
 
 from numcodecs.json import JSON
+
 register_codec(JSON)
 
 with suppress(ImportError):
     from numcodecs import vlen
     from numcodecs.vlen import VLenUTF8, VLenBytes, VLenArray
+
     register_codec(VLenUTF8)
     register_codec(VLenBytes)
     register_codec(VLenArray)
 
 from numcodecs.fletcher32 import Fletcher32
+
 register_codec(Fletcher32)
+
+from numcodecs.pcodec import PCodec
+
+register_codec(PCodec)

numcodecs/abc.py

@@ -28,7 +28,6 @@ other and vice versa.
 
 """
 
-
 from abc import ABC, abstractmethod
 
 
@@ -114,15 +113,16 @@ class Codec(ABC):
             return False
 
     def __repr__(self):
-
         # override in sub-class if need special representation
 
         # by default, assume all non-private members are configuration
         # parameters and valid keyword arguments to constructor function
 
         r = '%s(' % type(self).__name__
-        params = ['{}={!r}'.format(k, getattr(self, k))
-                  for k in sorted(self.__dict__)
-                  if not k.startswith('_')]
+        params = [
+            '{}={!r}'.format(k, getattr(self, k))
+            for k in sorted(self.__dict__)
+            if not k.startswith('_')
+        ]
         r += ', '.join(params) + ')'
         return r

numcodecs/astype.py

@@ -45,7 +45,6 @@ class AsType(Codec):
         self.decode_dtype = np.dtype(decode_dtype)
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(self.decode_dtype)
 
@@ -55,7 +54,6 @@ class AsType(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view(self.encode_dtype)
 
@@ -75,10 +73,6 @@ class AsType(Codec):
         }
 
     def __repr__(self):
-        return (
-            '{}(encode_dtype={!r}, decode_dtype={!r})'.format(
-                type(self).__name__,
-                self.encode_dtype.str,
-                self.decode_dtype.str
-            )
+        return '{}(encode_dtype={!r}, decode_dtype={!r})'.format(
+            type(self).__name__, self.encode_dtype.str, self.decode_dtype.str
         )

numcodecs/bz2.py

@@ -21,7 +21,6 @@ class BZ2(Codec):
         self.level = level
 
     def encode(self, buf):
-
         # normalise input
         buf = ensure_contiguous_ndarray(buf)
 
@@ -30,7 +29,6 @@ class BZ2(Codec):
 
     # noinspection PyMethodMayBeStatic
     def decode(self, buf, out=None):
-
         # normalise inputs
         buf = ensure_contiguous_ndarray(buf)
         if out is not None:

numcodecs/categorize.py

@@ -41,17 +41,15 @@ class Categorize(Codec):
     def __init__(self, labels, dtype, astype='u1'):
         self.dtype = np.dtype(dtype)
         if self.dtype.kind not in 'UO':
-            raise TypeError("only unicode ('U') and object ('O') dtypes are "
-                            "supported")
+            raise TypeError("only unicode ('U') and object ('O') dtypes are " "supported")
         self.labels = [ensure_text(label) for label in labels]
         self.astype = np.dtype(astype)
-        if self.astype == object:
+        if self.astype == np.dtype(object):
             raise TypeError('encoding as object array not supported')
 
     def encode(self, buf):
-
         # normalise input
-        if self.dtype == object:
+        if self.dtype == np.dtype(object):
             arr = np.asarray(buf, dtype=object)
         else:
             arr = ensure_ndarray(buf).view(self.dtype)
@@ -63,13 +61,12 @@ class Categorize(Codec):
         enc = np.zeros_like(arr, dtype=self.astype)
 
         # apply encoding, reserving 0 for values not specified in labels
-        for i, l in enumerate(self.labels):
-            enc[arr == l] = i + 1
+        for i, label in enumerate(self.labels):
+            enc[arr == label] = i + 1
 
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view(self.astype)
 
@@ -80,8 +77,8 @@ class Categorize(Codec):
         dec = np.full_like(enc, fill_value='', dtype=self.dtype)
 
         # apply decoding
-        for i, l in enumerate(self.labels):
-            dec[enc == (i + 1)] = l
+        for i, label in enumerate(self.labels):
+            dec[enc == (i + 1)] = label
 
         # handle output
         dec = ndarray_copy(dec, out)
@@ -93,7 +90,7 @@ class Categorize(Codec):
             id=self.codec_id,
             labels=self.labels,
             dtype=self.dtype.str,
-            astype=self.astype.str
+            astype=self.astype.str,
         )
         return config
 
@@ -102,6 +99,10 @@ class Categorize(Codec):
         labels = repr(self.labels[:3])
         if len(self.labels) > 3:
             labels = labels[:-1] + ', ...]'
-        r = '%s(dtype=%r, astype=%r, labels=%s)' % \
-            (type(self).__name__, self.dtype.str, self.astype.str, labels)
+        r = '%s(dtype=%r, astype=%r, labels=%s)' % (
+            type(self).__name__,
+            self.dtype.str,
+            self.astype.str,
+            labels,
+        )
         return r

numcodecs/checksum32.py

@@ -11,13 +11,12 @@ from .jenkins import jenkins_lookup3
 
 
 class Checksum32(Codec):
-
     # override in sub-class
     checksum = None
 
     def encode(self, buf):
         arr = ensure_contiguous_ndarray(buf).view('u1')
-        checksum = self.checksum(arr) & 0xffffffff
+        checksum = self.checksum(arr) & 0xFFFFFFFF
         enc = np.empty(arr.nbytes + 4, dtype='u1')
         enc[:4].view('<u4')[0] = checksum
         ndarray_copy(arr, enc[4:])
@@ -26,20 +25,18 @@ class Checksum32(Codec):
     def decode(self, buf, out=None):
         arr = ensure_contiguous_ndarray(buf).view('u1')
         expect = arr[:4].view('<u4')[0]
-        checksum = self.checksum(arr[4:]) & 0xffffffff
+        checksum = self.checksum(arr[4:]) & 0xFFFFFFFF
         if expect != checksum:
             raise RuntimeError('checksum failed')
         return ndarray_copy(arr[4:], out)
 
 
 class CRC32(Checksum32):
-
     codec_id = 'crc32'
     checksum = zlib.crc32
 
 
 class Adler32(Checksum32):
-
     codec_id = 'adler32'
     checksum = zlib.adler32
 

numcodecs/compat.py

@@ -67,9 +67,7 @@ def ensure_ndarray(buf) -> np.ndarray:
     return np.array(ensure_ndarray_like(buf), copy=False)
 
 
-def ensure_contiguous_ndarray_like(
-    buf, max_buffer_size=None, flatten=True
-) -> NDArrayLike:
+def ensure_contiguous_ndarray_like(buf, max_buffer_size=None, flatten=True) -> NDArrayLike:
     """Convenience function to coerce `buf` to ndarray-like array.
     Also ensures that the returned value exports fully contiguous memory,
     and supports the new-style buffer interface. If the optional max_buffer_size is
@@ -152,9 +150,7 @@ def ensure_contiguous_ndarray(buf, max_buffer_size=None, flatten=True) -> np.arr
     """
 
     return ensure_ndarray(
-        ensure_contiguous_ndarray_like(
-            buf, max_buffer_size=max_buffer_size, flatten=flatten
-        )
+        ensure_contiguous_ndarray_like(buf, max_buffer_size=max_buffer_size, flatten=flatten)
     )
 
 

numcodecs/delta.py

@@ -47,11 +47,10 @@ class Delta(Codec):
             self.astype = self.dtype
         else:
             self.astype = np.dtype(astype)
-        if self.dtype == object or self.astype == object:
+        if self.dtype == np.dtype(object) or self.astype == np.dtype(object):
             raise ValueError('object arrays are not supported')
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(self.dtype)
 
@@ -70,7 +69,6 @@ class Delta(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view(self.astype)
 
@@ -90,11 +88,7 @@ class Delta(Codec):
 
     def get_config(self):
         # override to handle encoding dtypes
-        return dict(
-            id=self.codec_id,
-            dtype=self.dtype.str,
-            astype=self.astype.str
-        )
+        return dict(id=self.codec_id, dtype=self.dtype.str, astype=self.astype.str)
 
     def __repr__(self):
         r = '{}(dtype={!r}'.format(type(self).__name__, self.dtype.str)

numcodecs/fixedscaleoffset.py

@@ -78,11 +78,10 @@ class FixedScaleOffset(Codec):
             self.astype = self.dtype
         else:
             self.astype = np.dtype(astype)
-        if self.dtype == object or self.astype == object:
+        if self.dtype == np.dtype(object) or self.astype == np.dtype(object):
             raise ValueError('object arrays are not supported')
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(self.dtype)
 
@@ -101,7 +100,6 @@ class FixedScaleOffset(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # interpret buffer as numpy array
         enc = ensure_ndarray(buf).view(self.astype)
 
@@ -124,12 +122,16 @@ class FixedScaleOffset(Codec):
             scale=self.scale,
             offset=self.offset,
             dtype=self.dtype.str,
-            astype=self.astype.str
+            astype=self.astype.str,
         )
 
     def __repr__(self):
-        r = '%s(scale=%s, offset=%s, dtype=%r' % \
-            (type(self).__name__, self.scale, self.offset, self.dtype.str)
+        r = '%s(scale=%s, offset=%s, dtype=%r' % (
+            type(self).__name__,
+            self.scale,
+            self.offset,
+            self.dtype.str,
+        )
         if self.astype != self.dtype:
             r += ', astype=%r' % self.astype.str
         r += ')'

numcodecs/gzip.py

@@ -21,15 +21,12 @@ class GZip(Codec):
         self.level = level
 
     def encode(self, buf):
-
         # normalise inputs
         buf = ensure_contiguous_ndarray(buf)
 
         # do compression
         compressed = io.BytesIO()
-        with _gzip.GzipFile(fileobj=compressed,
-                            mode='wb',
-                            compresslevel=self.level) as compressor:
+        with _gzip.GzipFile(fileobj=compressed, mode='wb', compresslevel=self.level) as compressor:
             compressor.write(buf)
         compressed = compressed.getvalue()
 
@@ -37,7 +34,6 @@ class GZip(Codec):
 
     # noinspection PyMethodMayBeStatic
     def decode(self, buf, out=None):
-
         # normalise inputs
         # BytesIO only copies if the data is not of `bytes` type.
         # This allows `bytes` objects to pass through without copying.

numcodecs/json.py

@@ -33,9 +33,18 @@ class JSON(Codec):
 
     codec_id = 'json2'
 
-    def __init__(self, encoding='utf-8', skipkeys=False, ensure_ascii=True,
-                 check_circular=True, allow_nan=True, sort_keys=True, indent=None,
-                 separators=None, strict=True):
+    def __init__(
+        self,
+        encoding='utf-8',
+        skipkeys=False,
+        ensure_ascii=True,
+        check_circular=True,
+        allow_nan=True,
+        sort_keys=True,
+        indent=None,
+        separators=None,
+        strict=True,
+    ):
         self._text_encoding = encoding
         if separators is None:
             # ensure separators are explicitly specified, and consistent behaviour across
@@ -45,10 +54,15 @@ class JSON(Codec):
             else:
                 separators = ', ', ': '
         separators = tuple(separators)
-        self._encoder_config = dict(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
-                                    check_circular=check_circular, allow_nan=allow_nan,
-                                    indent=indent, separators=separators,
-                                    sort_keys=sort_keys)
+        self._encoder_config = dict(
+            skipkeys=skipkeys,
+            ensure_ascii=ensure_ascii,
+            check_circular=check_circular,
+            allow_nan=allow_nan,
+            indent=indent,
+            separators=separators,
+            sort_keys=sort_keys,
+        )
         self._encoder = _json.JSONEncoder(**self._encoder_config)
         self._decoder_config = dict(strict=strict)
         self._decoder = _json.JSONDecoder(**self._decoder_config)
@@ -58,14 +72,18 @@ class JSON(Codec):
             buf = np.asarray(buf)
         except ValueError:
             buf = np.asarray(buf, dtype=object)
-        items = buf.tolist()
-        items.extend((buf.dtype.str, buf.shape))
+        items = np.atleast_1d(buf).tolist()
+        items.append(buf.dtype.str)
+        items.append(buf.shape)
         return self._encoder.encode(items).encode(self._text_encoding)
 
     def decode(self, buf, out=None):
         items = self._decoder.decode(ensure_text(buf, self._text_encoding))
         dec = np.empty(items[-1], dtype=items[-2])
-        dec[:] = items[:-2]
+        if not items[-1]:
+            dec[...] = items[0]
+        else:
+            dec[:] = items[:-2]
         if out is not None:
             np.copyto(out, dec)
             return out

numcodecs/lzma.py

@@ -9,7 +9,6 @@ except ImportError:  # pragma: no cover
 
 
 if _lzma:
-
     from .abc import Codec
     from .compat import ndarray_copy, ensure_contiguous_ndarray
 
@@ -42,16 +41,19 @@ if _lzma:
             self.filters = filters
 
         def encode(self, buf):
-
             # normalise inputs
             buf = ensure_contiguous_ndarray(buf)
 
             # do compression
-            return _lzma.compress(buf, format=self.format, check=self.check,
-                                  preset=self.preset, filters=self.filters)
+            return _lzma.compress(
+                buf,
+                format=self.format,
+                check=self.check,
+                preset=self.preset,
+                filters=self.filters,
+            )
 
         def decode(self, buf, out=None):
-
             # normalise inputs
             buf = ensure_contiguous_ndarray(buf)
             if out is not None:
@@ -64,7 +66,11 @@ if _lzma:
             return ndarray_copy(dec, out)
 
         def __repr__(self):
-            r = '%s(format=%r, check=%r, preset=%r, filters=%r)' % \
-                (type(self).__name__, self.format, self.check, self.preset,
-                 self.filters)
+            r = '%s(format=%r, check=%r, preset=%r, filters=%r)' % (
+                type(self).__name__,
+                self.format,
+                self.check,
+                self.preset,
+                self.filters,
+            )
             return r

numcodecs/msgpacks.py

@@ -58,8 +58,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 +76,14 @@ 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 'MsgPack(raw={!r}, use_bin_type={!r}, use_single_float={!r})'.format(
+            self.raw, self.use_bin_type, self.use_single_float
         )

numcodecs/ndarray_like.py

@@ -10,6 +10,7 @@ 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] = {}
 
     def __instancecheck__(self, instance):
@@ -46,23 +47,17 @@ class NDArrayLike(Protocol, metaclass=_CachedProtocolMeta):
     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

@@ -34,7 +34,6 @@ class PackBits(Codec):
         pass
 
     def encode(self, buf):
-
         # normalise input
         arr = ensure_ndarray(buf).view(bool)
 
@@ -43,7 +42,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 +63,6 @@ class PackBits(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view('u1')