Fixes to setitem for 0 chunks

Author: lshaw8317

src/blosc2/lazyexpr.py

@@ -1201,8 +1201,7 @@ def fast_eval(  # noqa: C901
 
     chunk_operands = {}
     # Check which chunks intersect with _slice
-    chunk_size = ndindex.ChunkSize(chunks)
-    all_chunks = chunk_size.as_subchunks((), shape)  # if _slice is (), returns all chunks
+    all_chunks = get_intersecting_chunks((), shape, chunks)  # if _slice is (), returns all chunks
     for nchunk, chunk_slice in enumerate(all_chunks):
         cslice = chunk_slice.raw
         offset = tuple(s.start for s in cslice)  # offset for the udf
@@ -1404,9 +1403,10 @@ def slices_eval(  # noqa: C901
 
     # Iterate over the operands and get the chunks
     chunk_operands = {}
-    # Check which chunks intersect with _slice
-    chunk_size = ndindex.ChunkSize(chunks)
-    intersecting_chunks = chunk_size.as_subchunks(_slice, shape)  # if _slice is (), returns all chunks
+    # Check which chunks intersect with _slice (handles zero chunks internally)
+    intersecting_chunks = get_intersecting_chunks(
+        _slice, shape, chunks
+    )  # if _slice is (), returns all chunks
 
     for nchunk, chunk_slice in enumerate(intersecting_chunks):
         # get intersection of chunk and target
@@ -1790,7 +1790,7 @@ def reduce_slices(  # noqa: C901
         same_shape = all(operand.shape == o.shape for o in operands.values() if hasattr(o, "shape"))
         same_chunks = all(operand.chunks == o.chunks for o in operands.values() if hasattr(o, "chunks"))
         same_blocks = all(operand.blocks == o.blocks for o in operands.values() if hasattr(o, "blocks"))
-        fast_path = same_shape and same_chunks and same_blocks
+        fast_path = same_shape and same_chunks and same_blocks and (0 not in chunks)
         aligned, iter_disk = False, False
         if fast_path:
             # Check that all operands are NDArray for fast path
@@ -1824,8 +1824,8 @@ def reduce_slices(  # noqa: C901
     # Iterate over the operands and get the chunks
     chunk_operands = {}
     # Check which chunks intersect with _slice
-    chunk_size = ndindex.ChunkSize(chunks)
-    intersecting_chunks = chunk_size.as_subchunks(_slice, shape)  # if _slice is (), returns all chunks
+    # if chunks has 0 we loop once but fast path is false as gives error (schunk has no chunks)
+    intersecting_chunks = get_intersecting_chunks(_slice, shape, chunks)
     out_init = False
 
     for nchunk, chunk_slice in enumerate(intersecting_chunks):
@@ -2882,7 +2882,7 @@ def sort(self, order: str | list[str] | None = None) -> blosc2.LazyArray:
             lazy_expr._order = order
         return lazy_expr
 
-    def compute(self, item=(), **kwargs) -> blosc2.NDArray:  # noqa : C901
+    def compute(self, item=(), **kwargs) -> blosc2.NDArray:
         # When NumPy ufuncs are called, the user may add an `out` parameter to kwargs
         if "out" in kwargs:
             kwargs["_output"] = kwargs.pop("out")
@@ -2900,14 +2900,7 @@ def compute(self, item=(), **kwargs) -> blosc2.NDArray:  # noqa : C901
         if hasattr(self, "_order"):
             kwargs["_order"] = self._order
         # handle empty arrays
-        if 0 in self.shape:
-            result = (
-                np.empty(self.shape, dtype=self.dtype)
-                if "_getitem" in kwargs
-                else blosc2.empty(self.shape, dtype=self.dtype)
-            )
-        else:
-            result = self._compute_expr(item, kwargs)
+        result = self._compute_expr(item, kwargs)
         if "_order" in kwargs and "_indices" not in kwargs:
             # We still need to apply the index in result
             x = self._where_args["_where_x"]
@@ -3618,6 +3611,16 @@ def evaluate(
     return lexpr[()]
 
 
+def get_intersecting_chunks(_slice, shape, chunks):
+    if 0 not in chunks:
+        chunk_size = ndindex.ChunkSize(chunks)
+        return chunk_size.as_subchunks(_slice, shape)  # if _slice is (), returns all chunks
+    else:
+        return (
+            ndindex.ndindex(...).expand(shape),
+        )  # chunk is whole array so just return full tuple to do loop once
+
+
 if __name__ == "__main__":
     from time import time
 

src/blosc2/ndarray.py

@@ -965,7 +965,7 @@ def __rpow__(self, value: int | float | NDArray | NDField | blosc2.C2Array, /) -
 
     def __bool__(self) -> bool:
         if math.prod(self.shape) != 1:
-            raise ValueError("The truth value of an array of shape {self.shape} is ambiguous.")
+            raise ValueError(f"The truth value of an array of shape {self.shape} is ambiguous.")
         return bool(self[()])
 
     @is_documented_by(sum)
@@ -1476,8 +1476,6 @@ def get_fselection_numpy(self, key: list | np.ndarray) -> np.ndarray:
         _slice = _slice.raw
         # now all indices are slices or arrays of integers (or booleans)
         # # moreover, all arrays are consecutive (otherwise an error is raised)
-        # if builtins.any(k.step < 0 for k in _slice if isinstance(k, slice)):
-        #     raise ValueError("Fancy indexing not supported for slices with negative steps.")
 
         if np.all([isinstance(s, (slice, np.ndarray)) for s in _slice]) and np.all(
             [s.dtype is not bool for s in _slice if isinstance(s, np.ndarray)]
@@ -1600,7 +1598,7 @@ def _get_set_findex_default(self, _slice, out_shape=None, updater=None):
             out = self  # default return for no intersecting chunks
         if 0 in self.shape:
             return out
-        chunk_size = ndindex.ChunkSize(self.chunks)
+        chunk_size = ndindex.ChunkSize(self.chunks)  # only works with nonzero chunks
         # repeated indices are grouped together
         intersecting_chunks = chunk_size.as_subchunks(
             _slice, self.shape

src/blosc2/schunk.py

@@ -866,7 +866,8 @@ def update_data(self, nchunk: int, data: object, copy: bool) -> int:
         Number of chunks after update: 4
         """
         blosc2_ext.check_access_mode(self.urlpath, self.mode)
-        return super().update_data(nchunk, data, copy)
+        nchunks = super().nchunks
+        return super().update_data(nchunk, data, copy) if nchunks > 0 else nchunks
 
     def get_slice(self, start: int = 0, stop: int | None = None, out: object = None) -> str | bytes | None:
         """Get a slice from :paramref:`start` to :paramref:`stop`.

tests/ndarray/test_reductions.py

@@ -452,12 +452,20 @@ def test_save_constructor_reduce2(shape, disk, compute):
 def test_reduction_index():
     shape = (20, 20)
     a = blosc2.linspace(0, 20, num=np.prod(shape), shape=shape)
-    arr = blosc2.lazyexpr("sum(a,axis=0)", {"a": a})
+    arr = blosc2.lazyexpr("sum(a, axis=0)", {"a": a})
     newarr = arr.compute()
     assert arr[:10].shape == (10,)
     assert arr[0].shape == ()
     assert arr.shape == newarr.shape
 
+    a = blosc2.ones(shape=(0, 0))
+    arr = blosc2.lazyexpr("sum(a, axis=(0, 1, 2))", {"a": a})
+    with pytest.raises(np.exceptions.AxisError):
+        newarr = arr.compute()
+    arr = blosc2.lazyexpr("sum(a, axis=(0, 0))", {"a": a})
+    with pytest.raises(ValueError):
+        newarr = arr.compute()
+
 
 @pytest.mark.parametrize("idx", [0, 1, (0,), slice(1, 2), (slice(0, 1),), slice(0, 4), (0, 2)])
 def test_reduction_index2(idx):