fix is_initialised bug

Author: alimanfoo

zarr/ext.pyx

@@ -815,6 +815,14 @@ cdef class BaseArray:
         def __get__(self):
             return self.size * self.itemsize
 
+    property chunk_size:
+        def __get__(self):
+            return reduce(operator.mul, self._chunks)
+
+    property chunk_nbytes:
+        def __get__(self):
+            return self.chunk_size * self.itemsize
+
     def __getitem__(self, item):
         cdef ndarray dest
         cdef BaseChunk chunk
@@ -928,6 +936,8 @@ cdef class BaseArray:
         r += '; cbytes: %s' % _util.human_readable_size(self.cbytes)
         if self.cbytes > 0:
             r += '; ratio: %.1f' % (self.nbytes / self.cbytes)
+        # r += '; chunk_nbytes: %s' % \
+        #      _util.human_readable_size(self.chunk_nbytes)
         n_chunks = reduce(operator.mul, self._cdata_shape)
         r += '; initialized: %s/%s' % (np.count_nonzero(self.is_initialized),
                                        n_chunks)
@@ -1140,7 +1150,7 @@ cdef class PersistentArray(BaseArray):
         meta_path = os.path.join(path, defaults.metapath)
 
         if mode in ['r', 'r+']:
-            self._open(path)
+            self._open(path, **kwargs)
 
         elif mode == 'w':
             if os.path.exists(path):
@@ -1154,7 +1164,7 @@ cdef class PersistentArray(BaseArray):
 
         elif mode == 'a':
             if os.path.exists(meta_path):
-                self._open(path)
+                self._open(path, **kwargs)
             else:
                 self._create(path, **kwargs)
 
@@ -1207,19 +1217,32 @@ cdef class PersistentArray(BaseArray):
                     'fill_value': self._fill_value}
         _write_array_metadata(path, metadata)
 
-    def _open(self, path):
+    def _open(self, path, shape=None, chunks=None, dtype=None, cname=None, 
+              clevel=None, shuffle=None, fill_value=None):
 
         # read metadata
         metadata = _read_array_metadata(path)
 
         # set attributes
         self._shape = metadata['shape']
-        self._dtype = metadata['dtype']
         self._chunks = metadata['chunks']
+        self._dtype = metadata['dtype']
         self._cname = metadata['cname']
         self._clevel = metadata['clevel']
         self._shuffle = metadata['shuffle']
         self._fill_value = metadata['fill_value']
+        
+        # check consistency with user arguments
+        if shape is not None and _normalize_shape(shape) != self._shape:
+            raise ValueError('shape %r not consistent with existing %r' %
+                             (shape, self._shape))
+        if chunks is not None and \
+                _normalize_chunks(chunks, self._shape) != self._chunks:
+            raise ValueError('chunks %r not consistent with existing %r' %
+                             (chunks, self._chunks))
+        if dtype is not None and np.dtype(dtype) != self._dtype:
+            raise ValueError('dtype %r not consistent with existing %r' %
+                             (dtype, self._dtype))
 
     property cbytes:
         def __get__(self):
@@ -1455,6 +1478,7 @@ cdef class LazyPersistentArray(PersistentArray):
                 bn = os.path.basename(fn)[:-len(defaults.datasuffix)]
                 cidx = tuple(map(int, bn.split('.')))
                 a[cidx] = True
+            return a
 
     cdef BaseChunk get_chunk(self, tuple cidx):
         return _lazy_get_chunk(self, cidx)
@@ -1486,6 +1510,8 @@ cdef class LazyPersistentArray(PersistentArray):
             yield cidx, chunk
 
     def resize(self, *args):
+        if self._mode == 'r':
+            raise ValueError('array is read-only')
 
         # do resize
         _lazy_resize(self, *args)

zarr/tests/test_array.py

@@ -36,13 +36,15 @@ def test_1d(self):
         eq(defaults.shuffle, z.shuffle)
         eq(a.nbytes, z.nbytes)
         eq(0, z.cbytes)
+        eq(0, np.count_nonzero(z.is_initialized))
 
         # set data
         z[:] = a
 
         # check properties
         eq(a.nbytes, z.nbytes)
         eq(sum(c.cbytes for c in z.iter_chunks()), z.cbytes)
+        eq(11, np.count_nonzero(z.is_initialized))
 
         # check round-trip
         assert_array_equal(a, z[:])
@@ -108,13 +110,15 @@ def test_array_2d(self):
         eq(defaults.cname, z.cname)
         eq(defaults.clevel, z.clevel)
         eq(defaults.shuffle, z.shuffle)
+        eq(0, np.count_nonzero(z.is_initialized))
 
         # set data
         z[:] = a
 
         # check properties
         eq(a.nbytes, z.nbytes)
         eq(sum(c.cbytes for c in z.iter_chunks()), z.cbytes)
+        eq(50, np.count_nonzero(z.is_initialized))
 
         # check round-trip
         assert_array_equal(a, z[:])
@@ -329,11 +333,14 @@ def _test_persistence(self, a, chunks):
         eq(a.nbytes, z2.nbytes)
         eq(z.cbytes, z2.cbytes)
         assert_array_equal(z.is_initialized, z2.is_initialized)
+        assert_true(np.count_nonzero(z2.is_initialized) > 0)
         assert_array_equal(a, z2[:])
 
         # check read-only
         with assert_raises(ValueError):
             z2[:] = 0
+        with assert_raises(ValueError):
+            z2.resize(100)
 
         # open for read/write if exists
         z3 = self.create_array(path=path, mode='r+')
@@ -346,6 +353,7 @@ def _test_persistence(self, a, chunks):
         eq(a.nbytes, z3.nbytes)
         eq(z.cbytes, z3.cbytes)
         assert_array_equal(z.is_initialized, z3.is_initialized)
+        assert_true(np.count_nonzero(z3.is_initialized) > 0)
         assert_array_equal(a, z3[:])
 
         # check can write