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

numcodecs/__init__.py

@@ -1,4 +1,4 @@
-# flake8: noqa
+# ruff: noqa: E402,F401
 """Numcodecs is a Python package providing buffer compression and
 transformation codecs for use in data storage and communication
 applications. These include:
@@ -13,33 +13,37 @@ 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
+import multiprocessing
 from contextlib import suppress
 
-
-from numcodecs.version import version as __version__
 from numcodecs.registry import get_codec, register_codec
-
+from numcodecs.version import version as __version__
 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 +57,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
+    from numcodecs.vlen import VLenArray, VLenBytes, VLenUTF8
+
     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,14 @@ 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('_')]
+        r = f'{type(self).__name__}('
+        params = [
+            f'{k}={getattr(self, k)!r}' for k in sorted(self.__dict__) if not k.startswith('_')
+        ]
         r += ', '.join(params) + ')'
         return r

numcodecs/astype.py

@@ -1,7 +1,7 @@
 import numpy as np
 
 from .abc import Codec
-from .compat import ndarray_copy, ensure_ndarray
+from .compat import ensure_ndarray, ndarray_copy
 
 
 class AsType(Codec):
@@ -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,4 @@ 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 f'{type(self).__name__}(encode_dtype={self.encode_dtype.str!r}, decode_dtype={self.decode_dtype.str!r})'

numcodecs/bitround.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray_like, ndarray_copy
 

numcodecs/bz2.py

@@ -1,8 +1,7 @@
 import bz2 as _bz2
 
-
 from numcodecs.abc import Codec
-from numcodecs.compat import ndarray_copy, ensure_contiguous_ndarray
+from numcodecs.compat import ensure_contiguous_ndarray, ndarray_copy
 
 
 class BZ2(Codec):
@@ -21,7 +20,6 @@ class BZ2(Codec):
         self.level = level
 
     def encode(self, buf):
-
         # normalise input
         buf = ensure_contiguous_ndarray(buf)
 
@@ -30,7 +28,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

@@ -1,9 +1,8 @@
-from .abc import Codec
-from .compat import ensure_ndarray, ndarray_copy, ensure_text
-
-
 import numpy as np
 
+from .abc import Codec
+from .compat import ensure_ndarray, ensure_text, ndarray_copy
+
 
 class Categorize(Codec):
     """Filter encoding categorical string data as integers.
@@ -41,17 +40,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 +60,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 +76,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 +89,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 +98,4 @@ 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)
-        return r
+        return f'{type(self).__name__}(dtype={self.dtype.str!r}, astype={self.astype.str!r}, labels={labels})'

numcodecs/checksum32.py

@@ -1,9 +1,7 @@
+import struct
 import zlib
 
-
 import numpy as np
-import struct
-
 
 from .abc import Codec
 from .compat import ensure_contiguous_ndarray, ndarray_copy
@@ -11,13 +9,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 +23,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

@@ -1,9 +1,7 @@
-# flake8: noqa
-import functools
-import sys
-import codecs
+# ruff: noqa: F401
 import array
-from functools import reduce
+import codecs
+import functools
 
 import numpy as np
 
@@ -67,9 +65,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
@@ -117,7 +113,7 @@ def ensure_contiguous_ndarray_like(
         raise ValueError("an array with contiguous memory is required")
 
     if max_buffer_size is not None and arr.nbytes > max_buffer_size:
-        msg = "Codec does not support buffers of > {} bytes".format(max_buffer_size)
+        msg = f"Codec does not support buffers of > {max_buffer_size} bytes"
         raise ValueError(msg)
 
     return arr
@@ -152,9 +148,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

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -47,11 +46,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 +68,6 @@ class Delta(Codec):
         return enc
 
     def decode(self, buf, out=None):
-
         # normalise input
         enc = ensure_ndarray(buf).view(self.astype)
 
@@ -90,15 +87,11 @@ 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)
+        r = f'{type(self).__name__}(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/fixedscaleoffset.py

@@ -1,6 +1,5 @@
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_ndarray, ndarray_copy
 
@@ -15,7 +14,7 @@ class FixedScaleOffset(Codec):
     ----------
     offset : float
         Value to subtract from data.
-    scale : int
+    scale : float
         Value to multiply by data.
     dtype : dtype
         Data type to use for decoded data.
@@ -78,11 +77,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 +99,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,13 +121,12 @@ 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 = f'{type(self).__name__}(scale={self.scale}, offset={self.offset}, 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/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

@@ -1,10 +1,8 @@
 import json as _json
 import textwrap
 
-
 import numpy as np
 
-
 from .abc import Codec
 from .compat import ensure_text
 
@@ -33,9 +31,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 +52,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 +70,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
@@ -79,12 +95,13 @@ class JSON(Codec):
         return config
 
     def __repr__(self):
-        params = ['encoding=%r' % self._text_encoding]
+        params = [f'encoding={self._text_encoding!r}']
         for k, v in sorted(self._encoder_config.items()):
-            params.append('{}={!r}'.format(k, v))
+            params.append(f'{k}={v!r}')
         for k, v in sorted(self._decoder_config.items()):
-            params.append('{}={!r}'.format(k, v))
+            params.append(f'{k}={v!r}')
         classname = type(self).__name__
-        r = '{}({})'.format(classname, ', '.join(params))
-        r = textwrap.fill(r, width=80, break_long_words=False, subsequent_indent='     ')
-        return r
+        params = ', '.join(params)
+        return textwrap.fill(
+            f'{classname}({params})', width=80, break_long_words=False, subsequent_indent='     '
+        )

numcodecs/lzma.py

@@ -9,9 +9,8 @@ except ImportError:  # pragma: no cover
 
 
 if _lzma:
-
     from .abc import Codec
-    from .compat import ndarray_copy, ensure_contiguous_ndarray
+    from .compat import ensure_contiguous_ndarray, ndarray_copy
 
     # noinspection PyShadowingBuiltins
     class LZMA(Codec):
@@ -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,4 @@ 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)
-            return r
+            return f'{type(self).__name__}(format={self.format!r}, check={self.check!r}, preset={self.preset!r}, filters={self.filters!r})'