Using oindex and vindex instead of ExplicitIndexer objects.

xarray/backends/common.py

@@ -31,6 +31,7 @@
 if TYPE_CHECKING:
     from xarray.core.dataset import Dataset
     from xarray.core.types import NestedSequence
+    from xarray.namedarray._typing import _OuterIndexerKey, _VectorizedIndexerKey
 
     T_Name = Union[Hashable, None]
 
@@ -268,11 +269,35 @@ def robust_getitem(array, key, catch=Exception, max_retries=6, initial_delay=500
 
 
 class BackendArray(NdimSizeLenMixin, indexing.ExplicitlyIndexed):
-    __slots__ = ()
-
     def get_duck_array(self, dtype: np.typing.DTypeLike = None):
         key = indexing.BasicIndexer((slice(None),) * self.ndim)
-        return self[key]  # type: ignore[index]
+        return self[key]  # type: ignore [index]
+
+
+class NewBackendArray(NdimSizeLenMixin, indexing.ExplicitlyIndexed):
+    __slots__ = ("indexing_support",)
+
+    def get_duck_array(self, dtype: np.typing.DTypeLike = None):
+        key = (slice(None),) * self.ndim
+        return self[key]  # type: ignore [index]
+
+    def _oindex_get(self, key: _OuterIndexerKey) -> Any:
+        raise NotImplementedError(
+            f"{self.__class__.__name__}._oindex_get method should be overridden"
+        )
+
+    def _vindex_get(self, key: _VectorizedIndexerKey) -> Any:
+        raise NotImplementedError(
+            f"{self.__class__.__name__}._vindex_get method should be overridden"
+        )
+
+    @property
+    def oindex(self) -> indexing.IndexCallable:
+        return indexing.IndexCallable(self._oindex_get)
+
+    @property
+    def vindex(self) -> indexing.IndexCallable:
+        return indexing.IndexCallable(self._vindex_get)
 
 
 class AbstractDataStore:

xarray/backends/h5netcdf_.py

@@ -44,16 +44,33 @@
     from xarray.core.dataset import Dataset
     from xarray.core.datatree import DataTree
     from xarray.core.types import ReadBuffer
+    from xarray.namedarray._typing import (
+        _BasicIndexerKey,
+        _OuterIndexerKey,
+        _VectorizedIndexerKey,
+    )
 
 
 class H5NetCDFArrayWrapper(BaseNetCDF4Array):
+    indexing_support = indexing.IndexingSupport.OUTER_1VECTOR
+
     def get_array(self, needs_lock=True):
         ds = self.datastore._acquire(needs_lock)
         return ds.variables[self.variable_name]
 
-    def __getitem__(self, key):
-        return indexing.explicit_indexing_adapter(
-            key, self.shape, indexing.IndexingSupport.OUTER_1VECTOR, self._getitem
+    def _oindex_get(self, key: _OuterIndexerKey) -> Any:
+        return indexing.outer_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def _vindex_get(self, key: _VectorizedIndexerKey) -> Any:
+        return indexing.vectorized_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def __getitem__(self, key: _BasicIndexerKey) -> Any:
+        return indexing.basic_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
         )
 
     def _getitem(self, key):

xarray/backends/netCDF4_.py

@@ -12,8 +12,8 @@
 from xarray import coding
 from xarray.backends.common import (
     BACKEND_ENTRYPOINTS,
-    BackendArray,
     BackendEntrypoint,
+    NewBackendArray,
     WritableCFDataStore,
     _normalize_path,
     datatree_from_dict_with_io_cleanup,
@@ -48,6 +48,11 @@
     from xarray.core.dataset import Dataset
     from xarray.core.datatree import DataTree
     from xarray.core.types import ReadBuffer
+    from xarray.namedarray._typing import (
+        _BasicIndexerKey,
+        _OuterIndexerKey,
+        _VectorizedIndexerKey,
+    )
 
 # This lookup table maps from dtype.byteorder to a readable endian
 # string used by netCDF4.
@@ -56,7 +61,7 @@
 NETCDF4_PYTHON_LOCK = combine_locks([NETCDFC_LOCK, HDF5_LOCK])
 
 
-class BaseNetCDF4Array(BackendArray):
+class BaseNetCDF4Array(NewBackendArray):
     __slots__ = ("datastore", "dtype", "shape", "variable_name")
 
     def __init__(self, variable_name, datastore):
@@ -88,7 +93,7 @@ def get_array(self, needs_lock=True):
 
 
 class NetCDF4ArrayWrapper(BaseNetCDF4Array):
-    __slots__ = ()
+    indexing_support = indexing.IndexingSupport.OUTER
 
     def get_array(self, needs_lock=True):
         ds = self.datastore._acquire(needs_lock)
@@ -99,9 +104,19 @@ def get_array(self, needs_lock=True):
             variable.set_auto_chartostring(False)
         return variable
 
-    def __getitem__(self, key):
-        return indexing.explicit_indexing_adapter(
-            key, self.shape, indexing.IndexingSupport.OUTER, self._getitem
+    def _oindex_get(self, key: _OuterIndexerKey):
+        return indexing.outer_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def _vindex_get(self, key: _VectorizedIndexerKey):
+        return indexing.vectorized_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def __getitem__(self, key: _BasicIndexerKey):
+        return indexing.basic_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
         )
 
     def _getitem(self, key):

xarray/backends/pydap_.py

@@ -8,8 +8,8 @@
 from xarray.backends.common import (
     BACKEND_ENTRYPOINTS,
     AbstractDataStore,
-    BackendArray,
     BackendEntrypoint,
+    NewBackendArray,
     robust_getitem,
 )
 from xarray.backends.store import StoreBackendEntrypoint
@@ -29,10 +29,17 @@
 
     from xarray.core.dataset import Dataset
     from xarray.core.types import ReadBuffer
+    from xarray.namedarray._typing import (
+        _BasicIndexerKey,
+        _OuterIndexerKey,
+        _VectorizedIndexerKey,
+    )
 
 
-class PydapArrayWrapper(BackendArray):
-    def __init__(self, array):
+class PydapArrayWrapper(NewBackendArray):
+    indexing_support = indexing.IndexingSupport.BASIC
+
+    def __init__(self, array) -> None:
         self.array = array
 
     @property
@@ -43,9 +50,19 @@ def shape(self) -> tuple[int, ...]:
     def dtype(self):
         return self.array.dtype
 
-    def __getitem__(self, key):
-        return indexing.explicit_indexing_adapter(
-            key, self.shape, indexing.IndexingSupport.BASIC, self._getitem
+    def _oindex_get(self, key: _OuterIndexerKey) -> Any:
+        return indexing.outer_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def _vindex_get(self, key: _VectorizedIndexerKey) -> Any:
+        return indexing.vectorized_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+
+    def __getitem__(self, key: _BasicIndexerKey) -> Any:
+        return indexing.basic_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
         )
 
     def _getitem(self, key):

xarray/backends/scipy_.py

@@ -10,8 +10,8 @@
 
 from xarray.backends.common import (
     BACKEND_ENTRYPOINTS,
-    BackendArray,
     BackendEntrypoint,
+    NewBackendArray,
     WritableCFDataStore,
     _normalize_path,
 )
@@ -37,6 +37,11 @@
     from xarray.backends.common import AbstractDataStore
     from xarray.core.dataset import Dataset
     from xarray.core.types import ReadBuffer
+    from xarray.namedarray._typing import (
+        _BasicIndexerKey,
+        _OuterIndexerKey,
+        _VectorizedIndexerKey,
+    )
 
 
 HAS_NUMPY_2_0 = module_available("numpy", minversion="2.0.0.dev0")
@@ -54,7 +59,9 @@ def _decode_attrs(d):
     return {k: v if k == "_FillValue" else _decode_string(v) for (k, v) in d.items()}
 
 
-class ScipyArrayWrapper(BackendArray):
+class ScipyArrayWrapper(NewBackendArray):
+    indexing_support = indexing.IndexingSupport.OUTER_1VECTOR
+
     def __init__(self, variable_name, datastore):
         self.datastore = datastore
         self.variable_name = variable_name
@@ -66,15 +73,7 @@ def get_variable(self, needs_lock=True):
         ds = self.datastore._manager.acquire(needs_lock)
         return ds.variables[self.variable_name]
 
-    def _getitem(self, key):
-        with self.datastore.lock:
-            data = self.get_variable(needs_lock=False).data
-            return data[key]
-
-    def __getitem__(self, key):
-        data = indexing.explicit_indexing_adapter(
-            key, self.shape, indexing.IndexingSupport.OUTER_1VECTOR, self._getitem
-        )
+    def _finalize_result(self, data):
         # Copy data if the source file is mmapped. This makes things consistent
         # with the netCDF4 library by ensuring we can safely read arrays even
         # after closing associated files.
@@ -87,7 +86,30 @@ def __getitem__(self, key):
 
         return np.array(data, dtype=self.dtype, copy=copy)
 
-    def __setitem__(self, key, value):
+    def _getitem(self, key):
+        with self.datastore.lock:
+            data = self.get_variable(needs_lock=False).data
+            return data[key]
+
+    def _vindex_get(self, key: _VectorizedIndexerKey) -> Any:
+        data = indexing.vectorized_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+        return self._finalize_result(data)
+
+    def _oindex_get(self, key: _OuterIndexerKey) -> Any:
+        data = indexing.outer_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+        return self._finalize_result(data)
+
+    def __getitem__(self, key: _BasicIndexerKey) -> Any:
+        data = indexing.basic_indexing_adapter(
+            key, self.shape, self.indexing_support, self._getitem
+        )
+        return self._finalize_result(data)
+
+    def __setitem__(self, key, value) -> None:
         with self.datastore.lock:
             data = self.get_variable(needs_lock=False)
             try:

xarray/backends/zarr.py

@@ -14,8 +14,8 @@
 from xarray.backends.common import (
     BACKEND_ENTRYPOINTS,
     AbstractWritableDataStore,
-    BackendArray,
     BackendEntrypoint,
+    NewBackendArray,
     _encode_variable_name,
     _normalize_path,
     datatree_from_dict_with_io_cleanup,
@@ -42,6 +42,11 @@
     from xarray.core.dataset import Dataset
     from xarray.core.datatree import DataTree
     from xarray.core.types import ReadBuffer, ZarrArray, ZarrGroup
+    from xarray.namedarray._typing import (
+        _BasicIndexerKey,
+        _OuterIndexerKey,
+        _VectorizedIndexerKey,
+    )
 
 
 def _get_mappers(*, storage_options, store, chunk_store):
@@ -179,8 +184,8 @@ def encode_zarr_attr_value(value):
     return encoded
 
 
-class ZarrArrayWrapper(BackendArray):
-    __slots__ = ("_array", "dtype", "shape")
+class ZarrArrayWrapper(NewBackendArray):
+    indexing_support = indexing.IndexingSupport.VECTORIZED
 
     def __init__(self, zarr_array):
         # some callers attempt to evaluate an array if an `array` property exists on the object.
@@ -203,25 +208,28 @@ def __init__(self, zarr_array):
     def get_array(self):
         return self._array
 
-    def _oindex(self, key):
-        return self._array.oindex[key]
-
-    def _vindex(self, key):
-        return self._array.vindex[key]
-
-    def _getitem(self, key):
-        return self._array[key]
-
-    def __getitem__(self, key):
-        array = self._array
-        if isinstance(key, indexing.BasicIndexer):
-            method = self._getitem
-        elif isinstance(key, indexing.VectorizedIndexer):
-            method = self._vindex
-        elif isinstance(key, indexing.OuterIndexer):
-            method = self._oindex
-        return indexing.explicit_indexing_adapter(
-            key, array.shape, indexing.IndexingSupport.VECTORIZED, method
+    def _oindex_get(self, key: _OuterIndexerKey) -> Any:
+        def raw_indexing_method(key):
+            return self._array.oindex[key]
+
+        return indexing.outer_indexing_adapter(
+            key, self._array.shape, self.indexing_support, raw_indexing_method
+        )
+
+    def _vindex_get(self, key: _VectorizedIndexerKey) -> Any:
+        def raw_indexing_method(key):
+            return self._array.vindex[key]
+
+        return indexing.vectorized_indexing_adapter(
+            key, self._array.shape, self.indexing_support, raw_indexing_method
+        )
+
+    def __getitem__(self, key: _BasicIndexerKey) -> Any:
+        def raw_indexing_method(key):
+            return self._array[key]
+
+        return indexing.basic_indexing_adapter(
+            key, self._array.shape, self.indexing_support, raw_indexing_method
         )
 
         # if self.ndim == 0: