Fix lazy negative slice rewriting.

xarray/backends/zarr.py

@@ -77,7 +77,13 @@ def __getitem__(self, key):
             ]
         else:
             assert isinstance(key, indexing.OuterIndexer)
-            return array.oindex[key.tuple]
+            # decompose so that negative slices are now positive slices for the zarr library
+            # Then reverse the in-memory data.
+            backend_indexer, numpy_indexer = indexing._decompose_outer_indexer(
+                key, self.shape, indexing.IndexingSupport.OUTER
+            )
+            part = array.oindex[backend_indexer.tuple]
+            return part[numpy_indexer.tuple]
         # if self.ndim == 0:
         # could possibly have a work-around for 0d data here
 

xarray/core/indexing.py

@@ -829,20 +829,32 @@ def decompose_indexer(
     raise TypeError(f"unexpected key type: {indexer}")
 
 
-def _decompose_slice(key, size):
+def _decompose_slice(key: slice, size: int) -> tuple[slice, ...]:
     """convert a slice to successive two slices. The first slice always has
     a positive step.
+
+    >>> _decompose_slice(slice(2, 98, 2), 99)
+    (slice(2, 98, 2), slice(None, None, None))
+
+    >>> _decompose_slice(slice(98, 2, -2), 99)
+    (slice(4, 99, 2), slice(None, None, -1))
+
+    >>> _decompose_slice(slice(98, 2, -2), 98)
+    (slice(3, 98, 2), slice(None, None, -1))
+
+    >>> _decompose_slice(slice(360, None, -10), 361)
+    (slice(0, 361, 10), slice(None, None, -1))
     """
     start, stop, step = key.indices(size)
     if step > 0:
         # If key already has a positive step, use it as is in the backend
         return key, slice(None)
     else:
         # determine stop precisely for step > 1 case
+        # Use the range object to do the calculation
         # e.g. [98:2:-2] -> [98:3:-2]
-        stop = start + int((stop - start - 1) / step) * step + 1
-        start, stop = stop + 1, start + 1
-        return slice(start, stop, -step), slice(None, None, -1)
+        exact_stop = range(start, stop, step)[-1]
+        return slice(exact_stop, start + 1, -step), slice(None, None, -1)
 
 
 def _decompose_vectorized_indexer(

xarray/tests/test_backends.py

@@ -711,9 +711,6 @@ def multiple_indexing(indexers):
         ]
         multiple_indexing(indexers5)
 
-    @pytest.mark.xfail(
-        reason="zarr without dask handles negative steps in slices incorrectly",
-    )
     def test_vectorized_indexing_negative_step(self) -> None:
         # use dask explicitly when present
         open_kwargs: dict[str, Any] | None
@@ -753,6 +750,24 @@ def multiple_indexing(indexers):
         ]
         multiple_indexing(indexers)
 
+    def test_outer_indexing_reversed(self) -> None:
+        # regression test for GH6560
+        ds = xr.Dataset(
+            {
+                "z": (
+                    ("time", "isoBaricInhPa", "latitude", "longitude"),
+                    np.ones((1, 5, 721, 1440)),
+                )
+            },
+            coords={"latitude": np.linspace(-90, 90, 721)},
+        )
+
+        with self.roundtrip(ds) as on_disk:
+            subset = on_disk.isel(time=[0], isoBaricInhPa=1).z[:, ::10, ::10][
+                :, ::-1, :
+            ]
+            assert subset.sizes == subset.load().sizes
+
     def test_isel_dataarray(self) -> None:
         # Make sure isel works lazily. GH:issue:1688
         in_memory = create_test_data()