implement empty_like, zeros_like, etc.

Author: alimanfoo

zarr/__init__.py

@@ -2,7 +2,8 @@
 from __future__ import absolute_import, print_function, division
 
 
-from zarr.core import empty, zeros, ones, full, array, open
+from zarr.create import empty, zeros, ones, full, array, open, empty_like, \
+    zeros_like, ones_like, full_like, open_like
 from zarr.ext import blosc_version
 from zarr import defaults
 from zarr import constants

zarr/core.py renamed to zarr/create.py

@@ -287,7 +287,7 @@ def array(data, chunks=None, dtype=None, cname=None, clevel=None,
 
 # noinspection PyShadowingBuiltins
 def open(path, mode='a', shape=None, chunks=None, dtype=None, cname=None,
-         clevel=None, shuffle=None, fill_value=None, synchronized=True,
+         clevel=None, shuffle=None, fill_value=0, synchronized=True,
          lazy=False):
     """Open a persistent array.
 
@@ -343,3 +343,94 @@ def open(path, mode='a', shape=None, chunks=None, dtype=None, cname=None,
     return cls(path=path, mode=mode, shape=shape, chunks=chunks, dtype=dtype,
                cname=cname, clevel=clevel, shuffle=shuffle,
                fill_value=fill_value)
+
+
+def empty_like(z, shape=None, chunks=None, dtype=None, cname=None, clevel=None,
+               shuffle=None, synchronized=None, lazy=None):
+    """Create an empty array like 'z'."""
+    
+    shape = shape if shape is not None else z.shape
+    chunks = chunks if chunks is not None else z.chunks
+    dtype = dtype if dtype is not None else z.dtype
+    cname = cname if cname is not None else z.cname
+    clevel = clevel if clevel is not None else z.clevel
+    shuffle = shuffle if shuffle is not None else z.shuffle
+    synchronized = synchronized if synchronized is not None \
+        else z.is_synchronized
+    lazy = lazy if lazy is not None else z.is_lazy
+    return empty(shape, chunks, dtype=dtype, cname=cname, clevel=clevel, 
+                 shuffle=shuffle, synchronized=synchronized, lazy=lazy)
+
+
+def zeros_like(z, shape=None, chunks=None, dtype=None, cname=None, clevel=None,
+               shuffle=None, synchronized=None, lazy=None):
+    """Create an array of zeros like 'z'."""
+    
+    shape = shape if shape is not None else z.shape
+    chunks = chunks if chunks is not None else z.chunks
+    dtype = dtype if dtype is not None else z.dtype
+    cname = cname if cname is not None else z.cname
+    clevel = clevel if clevel is not None else z.clevel
+    shuffle = shuffle if shuffle is not None else z.shuffle
+    synchronized = synchronized if synchronized is not None \
+        else z.is_synchronized
+    lazy = lazy if lazy is not None else z.is_lazy
+    return zeros(shape, chunks, dtype=dtype, cname=cname, clevel=clevel, 
+                 shuffle=shuffle, synchronized=synchronized, lazy=lazy)
+
+
+def ones_like(z, shape=None, chunks=None, dtype=None, cname=None, clevel=None,
+              shuffle=None, synchronized=None, lazy=None):
+    """Create an array of ones like 'z'."""
+    
+    shape = shape if shape is not None else z.shape
+    chunks = chunks if chunks is not None else z.chunks
+    dtype = dtype if dtype is not None else z.dtype
+    cname = cname if cname is not None else z.cname
+    clevel = clevel if clevel is not None else z.clevel
+    shuffle = shuffle if shuffle is not None else z.shuffle
+    synchronized = synchronized if synchronized is not None \
+        else z.is_synchronized
+    lazy = lazy if lazy is not None else z.is_lazy
+    return ones(shape, chunks, dtype=dtype, cname=cname, clevel=clevel, 
+                shuffle=shuffle, synchronized=synchronized, lazy=lazy)
+
+
+def full_like(z, shape=None, chunks=None, fill_value=None, dtype=None, 
+              cname=None, clevel=None, shuffle=None, synchronized=None, 
+              lazy=None):
+    """Create a filled array like 'z'."""
+    
+    shape = shape if shape is not None else z.shape
+    chunks = chunks if chunks is not None else z.chunks
+    dtype = dtype if dtype is not None else z.dtype
+    cname = cname if cname is not None else z.cname
+    clevel = clevel if clevel is not None else z.clevel
+    shuffle = shuffle if shuffle is not None else z.shuffle
+    fill_value = fill_value if fill_value is not None else z.fill_value
+    synchronized = synchronized if synchronized is not None \
+        else z.is_synchronized
+    lazy = lazy if lazy is not None else z.is_lazy
+    return full(shape, chunks, fill_value, dtype=dtype, cname=cname,
+                clevel=clevel, shuffle=shuffle, synchronized=synchronized,
+                lazy=lazy)
+
+
+def open_like(z, path, mode='a', shape=None, chunks=None, dtype=None,
+              cname=None, clevel=None, shuffle=None, fill_value=None,
+              synchronized=None, lazy=None):
+    """Open a persistent array like 'z'."""
+
+    shape = shape if shape is not None else z.shape
+    chunks = chunks if chunks is not None else z.chunks
+    dtype = dtype if dtype is not None else z.dtype
+    cname = cname if cname is not None else z.cname
+    clevel = clevel if clevel is not None else z.clevel
+    shuffle = shuffle if shuffle is not None else z.shuffle
+    fill_value = fill_value if fill_value is not None else z.fill_value
+    synchronized = synchronized if synchronized is not None \
+        else z.is_synchronized
+    lazy = lazy if lazy is not None else z.is_lazy
+    return open(path, mode=mode, shape=shape, chunks=chunks, dtype=dtype,
+                cname=cname, clevel=clevel, shuffle=shuffle,
+                fill_value=fill_value, synchronized=synchronized, lazy=lazy)

zarr/ext.pyx

@@ -801,6 +801,10 @@ cdef class BaseArray:
         def __get__(self):
             return self._shuffle
 
+    property fill_value:
+        def __get__(self):
+            return self._fill_value
+
     # derived properties
 
     property size:
@@ -823,6 +827,18 @@ cdef class BaseArray:
         def __get__(self):
             return self.chunk_size * self.itemsize
 
+    property is_synchronized:
+        def __get__(self):
+            return False
+
+    property is_lazy:
+        def __get__(self):
+            return False
+
+    property is_persistent:
+        def __get__(self):
+            return False
+
     def __getitem__(self, item):
         cdef ndarray dest
         cdef BaseChunk chunk
@@ -1132,6 +1148,10 @@ cdef class SynchronizedArray(Array):
                                  shuffle=self._shuffle,
                                  fill_value=self._fill_value)
 
+    property is_synchronized:
+        def __get__(self):
+            return True
+
 
 # noinspection PyAttributeOutsideInit
 cdef class PersistentArray(BaseArray):
@@ -1254,6 +1274,10 @@ cdef class PersistentArray(BaseArray):
             a.flat = [c.is_initialized for c in self._cdata.flat]
             return a
 
+    property is_persistent:
+        def __get__(self):
+            return True
+
     cdef BaseChunk get_chunk(self, tuple cidx):
         return self._cdata[cidx]
 
@@ -1316,6 +1340,10 @@ cdef class SynchronizedPersistentArray(PersistentArray):
             shuffle=self._shuffle, fill_value=self._fill_value
         )
 
+    property is_synchronized:
+        def __get__(self):
+            return True
+
 
 ###############################################################################
 # LAZY ARRAY CLASSES                                                          #
@@ -1410,6 +1438,10 @@ cdef class LazyArray(BaseArray):
                 a[cidx] = chunk.is_initialized
             return a
 
+    property is_lazy:
+        def __get__(self):
+            return True
+
     cdef BaseChunk create_chunk(self, tuple cidx):
         # ignore chunk index here, not needed
         return Chunk(shape=self._chunks, dtype=self._dtype, cname=self._cname,
@@ -1449,6 +1481,10 @@ cdef class SynchronizedLazyArray(LazyArray):
                                  shuffle=self._shuffle,
                                  fill_value=self._fill_value)
 
+    property is_synchronized:
+        def __get__(self):
+            return True
+
 
 # noinspection PyAbstractClass,PyAttributeOutsideInit
 cdef class LazyPersistentArray(PersistentArray):
@@ -1480,6 +1516,10 @@ cdef class LazyPersistentArray(PersistentArray):
                 a[cidx] = True
             return a
 
+    property is_lazy:
+        def __get__(self):
+            return True
+
     cdef BaseChunk get_chunk(self, tuple cidx):
         return _lazy_get_chunk(self, cidx)
 
@@ -1547,3 +1587,7 @@ cdef class SynchronizedLazyPersistentArray(LazyPersistentArray):
             cname=self._cname, clevel=self._clevel, shuffle=self._shuffle,
             fill_value=self._fill_value
         )
+
+    property is_synchronized:
+        def __get__(self):
+            return True

zarr/tests/test_create.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import, print_function, division
+
+
+import tempfile
+import shutil
+import atexit
+import os
+import numpy as np
+from nose.tools import eq_ as eq
+from numpy.testing import assert_array_equal
+
+
+from zarr import array, empty, zeros, ones, full, open, empty_like, \
+    zeros_like, ones_like, full_like, open_like
+
+
+def test_array():
+    a = np.arange(100)
+    z = array(a, chunks=10)
+    eq(a.shape, z.shape)
+    eq(a.dtype, z.dtype)
+    assert_array_equal(a, z[:])
+
+
+def test_empty():
+    z = empty(100, 10)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+
+
+def test_zeros():
+    z = zeros(100, 10)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.zeros(100), z[:])
+
+
+def test_ones():
+    z = ones(100, 10)
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.ones(100), z[:])
+
+
+def test_full():
+    z = full(100, 10, fill_value=42, dtype='i4')
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.full(100, fill_value=42, dtype='i4'), z[:])
+
+
+def test_open():
+    path = tempfile.mktemp()
+    atexit.register(
+        lambda: shutil.rmtree(path) if os.path.exists(path) else None
+    )
+    z = open(path, mode='w', shape=100, chunks=10, dtype='i4')
+    z[:] = 42
+    eq((100,), z.shape)
+    eq((10,), z.chunks)
+    assert_array_equal(np.full(100, fill_value=42, dtype='i4'), z[:])
+    z2 = open(path, mode='r')
+    eq((100,), z2.shape)
+    eq((10,), z2.chunks)
+    assert_array_equal(z[:], z2[:])
+
+
+def test_empty_like():
+    z = empty(100, 10)
+    z2 = empty_like(z)
+    eq(z.shape, z2.shape)
+    eq(z.chunks, z2.chunks)
+    eq(z.dtype, z2.dtype)
+    eq(z.cname, z2.cname)
+    eq(z.clevel, z2.clevel)
+    eq(z.shuffle, z2.shuffle)
+    eq(z.fill_value, z2.fill_value)
+
+
+def test_zeros_like():
+    z = zeros(100, 10)
+    z2 = zeros_like(z)
+    eq(z.shape, z2.shape)
+    eq(z.chunks, z2.chunks)
+    eq(z.dtype, z2.dtype)
+    eq(z.cname, z2.cname)
+    eq(z.clevel, z2.clevel)
+    eq(z.shuffle, z2.shuffle)
+    eq(z.fill_value, z2.fill_value)
+
+
+def test_ones_like():
+    z = ones(100, 10)
+    z2 = ones_like(z)
+    eq(z.shape, z2.shape)
+    eq(z.chunks, z2.chunks)
+    eq(z.dtype, z2.dtype)
+    eq(z.cname, z2.cname)
+    eq(z.clevel, z2.clevel)
+    eq(z.shuffle, z2.shuffle)
+    eq(z.fill_value, z2.fill_value)
+
+
+def test_full_like():
+    z = full(100, 10, fill_value=42)
+    z2 = full_like(z)
+    eq(z.shape, z2.shape)
+    eq(z.chunks, z2.chunks)
+    eq(z.dtype, z2.dtype)
+    eq(z.cname, z2.cname)
+    eq(z.clevel, z2.clevel)
+    eq(z.shuffle, z2.shuffle)
+    eq(z.fill_value, z2.fill_value)
+
+
+def test_open_like():
+    path = tempfile.mktemp()
+    atexit.register(
+        lambda: shutil.rmtree(path) if os.path.exists(path) else None
+    )
+    z = full(100, 10, fill_value=42)
+    z2 = open_like(z, path)
+    eq(z.shape, z2.shape)
+    eq(z.chunks, z2.chunks)
+    eq(z.dtype, z2.dtype)
+    eq(z.cname, z2.cname)
+    eq(z.clevel, z2.clevel)
+    eq(z.shuffle, z2.shuffle)
+    eq(z.fill_value, z2.fill_value)