coverage back to 100

Author: alimanfoo

requirements_dev.txt

@@ -8,6 +8,7 @@ fasteners==0.14.1
 flake8==3.3.0
 mccabe==0.6.1
 monotonic==1.2
+msgpack-python==0.4.8
 nose==1.3.7
 numcodecs==0.2.0
 numpy==1.12.0

zarr/creation.py

@@ -71,6 +71,45 @@ def create(shape, chunks=None, dtype=None, compressor='default',
           compressor: Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
           store: dict
 
+    Create an array with different some different configuration options::
+
+        >>> from numcodecs import Blosc
+        >>> z = zarr.create((10000, 10000), chunks=(1000, 1000), dtype='i1', order='F',
+        ...                 compressor=Blosc(cname='zstd', clevel=1, shuffle=Blosc.BITSHUFFLE))
+        >>> z
+        Array((10000, 10000), int8, chunks=(1000, 1000), order=F)
+          nbytes: 95.4M; nbytes_stored: ...; ratio: ...; initialized: 0/100
+          compressor: Blosc(cname='zstd', clevel=1, shuffle=BITSHUFFLE, blocksize=0)
+          store: dict
+
+    To create an array with object dtype requires a filter that can handle Python object encoding,
+    e.g., `MsgPack` or `Pickle` from `numcodecs`::
+
+        >>> from numcodecs import MsgPack
+        >>> z = zarr.create((10000, 10000), chunks=(1000, 1000), dtype='object',
+        ...                 filters=[MsgPack()])
+        >>> z
+        Array((10000, 10000), object, chunks=(1000, 1000), order=C)
+          nbytes: 762.9M; nbytes_stored: ...; ratio: ...; initialized: 0/100
+          filters: MsgPack(encoding='utf-8')
+          compressor: Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
+          store: dict
+
+    Example with some filters, and also storing chunks separately from metadata::
+
+        >>> from numcodecs import Quantize, Adler32
+        >>> store, chunk_store = dict(), dict()
+        >>> z = zarr.create((10000, 10000), chunks=(1000, 1000), dtype='f8',
+        ...                 filters=[Quantize(digits=2, dtype='f8'), Adler32()],
+        ...                 store=store, chunk_store=chunk_store)
+        >>> z
+        Array((10000, 10000), float64, chunks=(1000, 1000), order=C)
+          nbytes: 762.9M; nbytes_stored: ...; ratio: ...; initialized: 0/100
+          filters: Quantize(digits=2, dtype='<f8')
+                   Adler32()
+          compressor: Blosc(cname='lz4', clevel=5, shuffle=SHUFFLE, blocksize=0)
+          store: dict; chunk_store: dict
+
     """  # flake8: noqa
 
     # handle polymorphic store arg

zarr/tests/test_filters.py

@@ -11,7 +11,6 @@
     Quantize
 from zarr.creation import array
 from zarr.compat import PY2
-from zarr.util import buffer_tobytes
 
 
 compressors = [
@@ -220,8 +219,8 @@ def test_compressor_as_filter():
 
         # check storage
         for i in range(10):
-            x = buffer_tobytes(a1.store[str(i)])
-            y = buffer_tobytes(a2.store[str(i)])
+            x = bytes(a1.store[str(i)])
+            y = bytes(a2.store[str(i)])
             eq(x, y)
 
         # check data

zarr/util.py

@@ -293,13 +293,3 @@ def buffer_size(v):
     else:
         v = memoryview(v)
         return reduce(operator.mul, v.shape) * v.itemsize
-
-
-def buffer_tobytes(v):
-    from array import array as _stdlib_array
-    if isinstance(v, np.ndarray):
-        return v.tobytes(order='A')
-    elif PY2 and isinstance(v, _stdlib_array):  # pragma: no cover
-        return v.tostring()
-    else:
-        return memoryview(v).tobytes()