add packbits

Author: alimanfoo

MANIFEST.in

@@ -1,6 +1,4 @@
 recursive-include c-blosc *
-recursive-include numcodecs *.pxd
 recursive-include numcodecs *.pyx
-recursive-include numcodecs *.h
 recursive-include numcodecs *.c
 include cpuinfo.py

docs/index.rst

@@ -29,6 +29,7 @@ Contents
     lzma
     delta
     fixedscaleoffset
+    packbits
     release
 
 Acknowledgments

docs/packbits.rst

@@ -0,0 +1,5 @@
+PackBits
+========
+.. module:: numcodecs.packbits
+
+.. autoclass:: PackBits

numcodecs/__init__.py

@@ -28,3 +28,6 @@
 
 from numcodecs.fixedscaleoffset import FixedScaleOffset
 register_codec(FixedScaleOffset)
+
+from numcodecs.packbits import PackBits
+register_codec(PackBits)

numcodecs/abc.py

@@ -57,8 +57,7 @@ def get_config(self):
         codec. Must include an 'id' field with the codec ID. All values must be
         compatible with JSON encoding."""
         # override in sub-class if need special encoding of config values
-        config = dict()
-        config['id'] = self.codec_id
+        config = dict(id=self.codec_id)
         # add in all non-private members
         for k in self.__dict__:
             if not k.startswith('_'):
@@ -75,10 +74,17 @@ def from_config(cls, config):
 
     def __eq__(self, other):
         # override in sub-class if need special equality comparison
-        attrs = ['codec_id']
-        # compare all non-private members
-        attrs += [k for k in self.__dict__ if not k.startswith('_')]
         try:
-            return all([getattr(self, k) == getattr(other, k) for k in attrs])
+            return self.get_config() == other.get_config()
         except AttributeError:
             return False
+
+    def __repr__(self):
+        # override in sub-class if need special representation
+        r = '%s(' % type(self).__name__
+        # by default, include all non-private members
+        params = ['%s=%r' % (k, getattr(self, k))
+                  for k in sorted(self.__dict__)
+                  if not k.startswith('_')]
+        r += ', '.join(params) + ')'
+        return r

numcodecs/bz2.py

@@ -50,7 +50,3 @@ def decode(self, buf, out=None):
         # support direct decompression into buffer, so we have to copy into
         # out if given
         return buffer_copy(dec, out)
-
-    def __repr__(self):
-        r = '%s(level=%s)' % (type(self).__name__, self.level)
-        return r

numcodecs/packbits.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, division
+
+
+import numpy as np
+
+
+from numcodecs.abc import Codec
+from numcodecs.compat import ndarray_from_buffer, buffer_copy
+
+
+class PackBits(Codec):
+    """Codec to pack elements of a boolean array into bits in a uint8 array.
+
+    Examples
+    --------
+    >>> import numcodecs as codecs
+    >>> import numpy as np
+    >>> codec = codecs.PackBits()
+    >>> x = np.array([True, False, False, True], dtype=bool)
+    >>> y = codec.encode(x)
+    >>> y
+    array([  4, 144], dtype=uint8)
+    >>> z = codec.decode(y)
+    >>> z
+    array([ True, False, False,  True], dtype=bool)
+
+    Notes
+    -----
+    The first element of the encoded array stores the number of bits that
+    were padded to complete the final byte.
+
+    """
+
+    codec_id = 'packbits'
+
+    def __init__(self):
+        pass
+
+    def encode(self, buf):
+
+        # view input as ndarray
+        arr = ndarray_from_buffer(buf, bool)
+
+        # determine size of packed data
+        n = arr.size
+        n_bytes_packed = (n // 8)
+        n_bits_leftover = n % 8
+        if n_bits_leftover > 0:
+            n_bytes_packed += 1
+
+        # setup output
+        enc = np.empty(n_bytes_packed + 1, dtype='u1')
+
+        # store how many bits were padded
+        if n_bits_leftover:
+            n_bits_padded = 8 - n_bits_leftover
+        else:
+            n_bits_padded = 0
+        enc[0] = n_bits_padded
+
+        # apply encoding
+        enc[1:] = np.packbits(arr)
+
+        return enc
+
+    def decode(self, buf, out=None):
+
+        # view encoded data as ndarray
+        enc = ndarray_from_buffer(buf, 'u1')
+
+        # find info how many bits were padded
+        n_bits_padded = int(enc[0])
+
+        # apply decoding
+        dec = np.unpackbits(enc[1:])
+
+        # remove padded bits
+        if n_bits_padded:
+            dec = dec[:-n_bits_padded]
+
+        # view as boolean array
+        dec = dec.view(bool)
+
+        # handle destination
+        return buffer_copy(dec, out)

numcodecs/tests/test_packbits.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, division
+
+
+import numpy as np
+
+
+from numcodecs.packbits import PackBits
+from numcodecs.tests.common import check_encode_decode, check_config, \
+    check_repr
+
+
+arrays = [
+    np.random.randint(0, 2, size=1000, dtype=bool),
+    np.random.randint(0, 2, size=(100, 10), dtype=bool),
+    np.random.randint(0, 2, size=(10, 10, 10), dtype=bool),
+    np.random.randint(0, 2, size=1000, dtype=bool).reshape(10, 10, 10,
+                                                           order='F'),
+]
+
+
+def test_encode_decode():
+    codec = PackBits()
+    for arr in arrays:
+        check_encode_decode(arr, codec)
+    # check different number of left-over bits
+    arr = np.random.randint(0, 2, size=1000, dtype=bool)
+    for size in list(range(1, 17)):
+        check_encode_decode(arr[:size], codec)
+
+
+def test_config():
+    codec = PackBits()
+    check_config(codec)
+
+
+def test_repr():
+    check_repr("PackBits()")

numcodecs/zlib.py

@@ -44,7 +44,3 @@ def decode(self, buf, out=None):
         # support direct decompression into buffer, so we have to copy into
         # out if given
         return buffer_copy(dec, out)
-
-    def __repr__(self):
-        r = '%s(level=%s)' % (type(self).__name__, self.level)
-        return r