fix error afer rebase

Original commit before rebase was 3ae237f

Author: Carreau

docs/release.rst

@@ -1,7 +1,6 @@
 Release notes
 =============
 
-
 2.6.0
 -----
 
@@ -41,7 +40,6 @@ merged PR tagged with the 2.6 milestone.
   chunks and is stored contiguously (last dimensions for C layout, firsts for
   F). Set ``partial_decompress=True`` when creating an ``Array``
 
-
 2.5.0
 -----
 

zarr/core.py

@@ -12,18 +12,36 @@
 from zarr.attrs import Attributes
 from zarr.codecs import AsType, get_codec
 from zarr.errors import ArrayNotFoundError, ReadOnlyError, ArrayIndexError
-from zarr.indexing import (BasicIndexer, CoordinateIndexer, MaskIndexer,
-                           OIndex, OrthogonalIndexer, VIndex, PartialChunkIterator,
-                           check_fields,
-                           check_no_multi_fields, ensure_tuple,
-                           err_too_many_indices, is_contiguous_selection,
-                           is_scalar, pop_fields)
+from zarr.indexing import (
+    BasicIndexer,
+    CoordinateIndexer,
+    MaskIndexer,
+    OIndex,
+    OrthogonalIndexer,
+    VIndex,
+    PartialChunkIterator,
+    check_fields,
+    check_no_multi_fields,
+    ensure_tuple,
+    err_too_many_indices,
+    is_contiguous_selection,
+    is_scalar,
+    pop_fields,
+)
 from zarr.meta import decode_array_metadata, encode_array_metadata
 from zarr.storage import array_meta_key, attrs_key, getsize, listdir
-from zarr.util import (InfoReporter, check_array_shape, human_readable_size,
-                       is_total_slice, nolock, normalize_chunks,
-                       normalize_resize_args, normalize_shape,
-                       normalize_storage_path, PartialReadBuffer)
+from zarr.util import (
+    InfoReporter,
+    check_array_shape,
+    human_readable_size,
+    is_total_slice,
+    nolock,
+    normalize_chunks,
+    normalize_resize_args,
+    normalize_shape,
+    normalize_storage_path,
+    PartialReadBuffer,
+)
 
 
 # noinspection PyUnresolvedReferences
@@ -107,9 +125,17 @@ class Array(object):
 
     """
 
-    def __init__(self, store, path=None, read_only=False, chunk_store=None,
-                 synchronizer=None, cache_metadata=True, cache_attrs=True,
-                 partial_decompress=True):
+    def __init__(
+        self,
+        store,
+        path=None,
+        read_only=False,
+        chunk_store=None,
+        synchronizer=None,
+        cache_metadata=True,
+        cache_attrs=True,
+        partial_decompress=True,
+    ):
         # N.B., expect at this point store is fully initialized with all
         # configuration metadata fully specified and normalized
 
@@ -1026,8 +1052,9 @@ def _get_selection(self, indexer, out=None, fields=None):
         else:
             check_array_shape('out', out, out_shape)
 
-        # iterate over chunks, not self.size becuase then indexer none and cant be zipped, will raise error
-        if not hasattr(self.chunk_store, "getitems") or not self.size:
+        # iterate over chunks
+        if not hasattr(self.chunk_store, "getitems") or \
+           any(map(lambda x: x == 0, self.shape)):
             # sequentially get one key at a time from storage
             for chunk_coords, chunk_selection, out_selection in indexer:
 
@@ -1586,9 +1613,17 @@ def _set_selection(self, indexer, value, fields=None):
             self._chunk_setitems(lchunk_coords, lchunk_selection, chunk_values,
                                  fields=fields)
 
-    def _process_chunk(self, out, cdata, chunk_selection, drop_axes,
-                       out_is_ndarray, fields, out_selection,
-                       partial_read_decode=False):
+    def _process_chunk(
+        self,
+        out,
+        cdata,
+        chunk_selection,
+        drop_axes,
+        out_is_ndarray,
+        fields,
+        out_selection,
+        partial_read_decode=False,
+    ):
         """Take binary data from storage and fill output array"""
         if (out_is_ndarray and
                 not fields and
@@ -1630,13 +1665,20 @@ def _process_chunk(self, out, cdata, chunk_selection, drop_axes,
                 index_selection = PartialChunkIterator(chunk_selection, self.chunks)
                 for start, nitems, partial_out_selection in index_selection:
                     expected_shape = [
-                        len(range(*partial_out_selection[i].indices(self.chunks[0]+1)))
-                        if i < len(partial_out_selection) else dim
-                        for i, dim in enumerate(self.chunks)]
+                        len(
+                            range(*partial_out_selection[i].indices(self.chunks[0] + 1))
+                        )
+                        if i < len(partial_out_selection)
+                        else dim
+                        for i, dim in enumerate(self.chunks)
+                    ]
                     cdata.read_part(start, nitems)
                     chunk_partial = self._decode_chunk(
-                        cdata.buff, start=start, nitems=nitems,
-                        expected_shape=expected_shape)
+                        cdata.buff,
+                        start=start,
+                        nitems=nitems,
+                        expected_shape=expected_shape,
+                    )
                     tmp[partial_out_selection] = chunk_partial
                 out[out_selection] = tmp[chunk_selection]
                 return
@@ -1716,20 +1758,35 @@ def _chunk_getitems(self, lchunk_coords, lchunk_selection, out, lout_selection,
             out_is_ndarray = False
 
         ckeys = [self._chunk_key(ch) for ch in lchunk_coords]
-        if self._partial_decompress and self._compressor \
-           and self._compressor.codec_id == 'blosc' and not fields \
-           and self.dtype != object and hasattr(self.chunk_store, "getitems"):
+        if (
+            self._partial_decompress
+            and self._compressor
+            and self._compressor.codec_id == "blosc"
+            and not fields
+            and self.dtype != object
+            and hasattr(self.chunk_store, "getitems")
+        ):
             partial_read_decode = True
-            cdatas = {ckey: PartialReadBuffer(ckey, self.chunk_store)
-                      for ckey in ckeys if ckey in self.chunk_store}
+            cdatas = {
+                ckey: PartialReadBuffer(ckey, self.chunk_store)
+                for ckey in ckeys
+                if ckey in self.chunk_store
+            }
         else:
             partial_read_decode = False
             cdatas = self.chunk_store.getitems(ckeys, on_error="omit")
         for ckey, chunk_select, out_select in zip(ckeys, lchunk_selection, lout_selection):
             if ckey in cdatas:
-                self._process_chunk(out, cdatas[ckey], chunk_select, drop_axes,
-                                    out_is_ndarray, fields, out_select,
-                                    partial_read_decode=partial_read_decode)
+                self._process_chunk(
+                    out,
+                    cdatas[ckey],
+                    chunk_select,
+                    drop_axes,
+                    out_is_ndarray,
+                    fields,
+                    out_select,
+                    partial_read_decode=partial_read_decode,
+                )
             else:
                 # check exception type
                 if self._fill_value is not None:
@@ -1842,9 +1899,10 @@ def _decode_chunk(self, cdata, start=None, nitems=None, expected_shape=None):
         # decompress
         if self._compressor:
             # only decode requested items
-            if ((all([x is not None for x in [start, nitems]])
-                    and self._compressor.codec_id == 'blosc')
-                    and hasattr(self._compressor, 'decode_partial')):
+            if (
+                all([x is not None for x in [start, nitems]])
+                and self._compressor.codec_id == "blosc"
+            ) and hasattr(self._compressor, "decode_partial"):
                 chunk = self._compressor.decode_partial(cdata, start, nitems)
             else:
                 chunk = self._compressor.decode(cdata)

zarr/errors.py

@@ -11,12 +11,14 @@ class CopyError(RuntimeError):
 class _BaseZarrError(ValueError):
     _msg = ""
 
-class ArrayIndexError(IndexError):
-
     def __init__(self, *args):
         super().__init__(self._msg.format(*args))
 
 
+class ArrayIndexError(IndexError):
+    pass
+
+
 class _BaseZarrIndexError(IndexError):
     _msg = ""
 

zarr/indexing.py

@@ -7,9 +7,10 @@
 
 from zarr.errors import (
     NegativeStepError,
+    err_too_many_indices,
     VindexInvalidSelectionError,
     BoundsCheckError,
-    ArrayIndexError
+    ArrayIndexError,
 )
 
 
@@ -828,7 +829,7 @@ def pop_fields(selection):
 
 
 def int_to_slice(dim_selection):
-    return slice(dim_selection, dim_selection+1, 1)
+    return slice(dim_selection, dim_selection + 1, 1)
 
 
 def make_slice_selection(selection):
@@ -868,19 +869,27 @@ def __init__(self, selection, arr_shape):
 
         # number of selection dimensions can't be greater than the number of chunk dimensions
         if len(self.selection) > len(self.arr_shape):
-            raise ValueError('Selection has more dimensions then the array:\n'
-                             'selection dimensions = {len(self.selection)\n'
-                             'array dimensions = {len(self.arr_shape)}')
+            raise ValueError(
+                "Selection has more dimensions then the array:\n"
+                "selection dimensions = {len(self.selection)\n"
+                "array dimensions = {len(self.arr_shape)}"
+            )
 
         # any selection can not be out of the range of the chunk
         self.selection_shape = np.empty(self.arr_shape)[self.selection].shape
-        if any([selection_dim < 0 or selection_dim > arr_dim for selection_dim, arr_dim
-                in zip(self.selection_shape, self.arr_shape)]):
-            raise IndexError('a selection index is out of range for the dimension') # pragma: no cover
+        if any(
+            [
+                selection_dim < 0 or selection_dim > arr_dim
+                for selection_dim, arr_dim in zip(self.selection_shape, self.arr_shape)
+            ]
+        ):
+            raise IndexError(
+                "a selection index is out of range for the dimension"
+            )  # pragma: no cover
 
         for i, dim_size in enumerate(self.arr_shape[::-1]):
-            index = len(self.arr_shape) - (i+1)
-            if index <= len(self.selection)-1:
+            index = len(self.arr_shape) - (i + 1)
+            if index <= len(self.selection) - 1:
                 slice_size = self.selection_shape[index]
                 if slice_size == dim_size and index > 0:
                     self.selection.pop()
@@ -892,17 +901,19 @@ def __init__(self, selection, arr_shape):
         for i, sl in enumerate(self.selection):
             dim_chunk_loc_slices = []
             for i, x in enumerate(slice_to_range(sl, arr_shape[i])):
-                dim_chunk_loc_slices.append(slice(x, x+1, 1))
+                dim_chunk_loc_slices.append(slice(x, x + 1, 1))
             chunk_loc_slices.append(dim_chunk_loc_slices)
         if last_dim_slice:
             chunk_loc_slices.append([last_dim_slice])
         self.chunk_loc_slices = list(itertools.product(*chunk_loc_slices))
 
     def __iter__(self):
         chunk1 = self.chunk_loc_slices[0]
-        nitems = (chunk1[-1].stop - chunk1[-1].start) * np.prod(self.arr_shape[len(chunk1):])
+        nitems = (chunk1[-1].stop - chunk1[-1].start) * np.prod(
+            self.arr_shape[len(chunk1) :]
+        )
         for chunk_selection in self.chunk_loc_slices:
             start = 0
             for i, sl in enumerate(chunk_selection):
-                start += sl.start * np.prod(self.arr_shape[i+1:])
+                start += sl.start * np.prod(self.arr_shape[i + 1 :])
             yield int(start), int(nitems), chunk_selection