Move parallelcompat and chunkmanagers to NamedArray

doc/internals/chunked-arrays.rst

@@ -35,44 +35,44 @@ The implementation of these functions is specific to the type of arrays passed t
 whereas :py:class:`cubed.Array` objects must be processed by :py:func:`cubed.map_blocks`.
 
 In order to use the correct implementation of a core operation for the array type encountered, xarray dispatches to the
-corresponding subclass of :py:class:`~xarray.core.parallelcompat.ChunkManagerEntrypoint`,
+corresponding subclass of :py:class:`~xarray.namedarray.parallelcompat.ChunkManagerEntrypoint`,
 also known as a "Chunk Manager". Therefore **a full list of the operations that need to be defined is set by the
-API of the** :py:class:`~xarray.core.parallelcompat.ChunkManagerEntrypoint` **abstract base class**. Note that chunked array
+API of the** :py:class:`~xarray.namedarray.parallelcompat.ChunkManagerEntrypoint` **abstract base class**. Note that chunked array
 methods are also currently dispatched using this class.
 
 Chunked array creation is also handled by this class. As chunked array objects have a one-to-one correspondence with
 in-memory numpy arrays, it should be possible to create a chunked array from a numpy array by passing the desired
-chunking pattern to an implementation of :py:class:`~xarray.core.parallelcompat.ChunkManagerEntrypoint.from_array``.
+chunking pattern to an implementation of :py:class:`~xarray.namedarray.parallelcompat.ChunkManagerEntrypoint.from_array``.
 
 .. note::
 
-    The :py:class:`~xarray.core.parallelcompat.ChunkManagerEntrypoint` abstract base class is mostly just acting as a
+    The :py:class:`~xarray.namedarray.parallelcompat.ChunkManagerEntrypoint` abstract base class is mostly just acting as a
     namespace for containing the chunked-aware function primitives. Ideally in the future we would have an API standard
     for chunked array types which codified this structure, making the entrypoint system unnecessary.
 
-.. currentmodule:: xarray.core.parallelcompat
+.. currentmodule:: xarray.namedarray.parallelcompat
 
-.. autoclass:: xarray.core.parallelcompat.ChunkManagerEntrypoint
+.. autoclass:: xarray.namedarray.parallelcompat.ChunkManagerEntrypoint
    :members:
 
 Registering a new ChunkManagerEntrypoint subclass
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Rather than hard-coding various chunk managers to deal with specific chunked array implementations, xarray uses an
 entrypoint system to allow developers of new chunked array implementations to register their corresponding subclass of
-:py:class:`~xarray.core.parallelcompat.ChunkManagerEntrypoint`.
+:py:class:`~xarray.namedarray.parallelcompat.ChunkManagerEntrypoint`.
 
 
 To register a new entrypoint you need to add an entry to the ``setup.cfg`` like this::
 
     [options.entry_points]
     xarray.chunkmanagers =
-        dask = xarray.core.daskmanager:DaskManager
+        dask = xarray.namedarray.daskmanager:DaskManager
 
 See also `cubed-xarray <https://github.com/xarray-contrib/cubed-xarray>`_ for another example.
 
 To check that the entrypoint has worked correctly, you may find it useful to display the available chunkmanagers using
-the internal function :py:func:`~xarray.core.parallelcompat.list_chunkmanagers`.
+the internal function :py:func:`~xarray.namedarray.parallelcompat.list_chunkmanagers`.
 
 .. autofunction:: list_chunkmanagers
 

pyproject.toml

@@ -35,7 +35,7 @@ issue-tracker = "https://github.com/pydata/xarray/issues"
 source-code = "https://github.com/pydata/xarray"
 
 [project.entry-points."xarray.chunkmanagers"]
-dask = "xarray.core.daskmanager:DaskManager"
+dask = "xarray.namedarray.daskmanager:DaskManager"
 
 [project.optional-dependencies]
 accel = ["scipy", "bottleneck", "numbagg", "flox"]

xarray/backends/api.py

@@ -33,12 +33,12 @@
     _nested_combine,
     combine_by_coords,
 )
-from xarray.core.daskmanager import DaskManager
 from xarray.core.dataarray import DataArray
 from xarray.core.dataset import Dataset, _get_chunk, _maybe_chunk
 from xarray.core.indexes import Index
-from xarray.core.parallelcompat import guess_chunkmanager
 from xarray.core.utils import is_remote_uri
+from xarray.namedarray.daskmanager import DaskManager
+from xarray.namedarray.parallelcompat import guess_chunkmanager
 
 if TYPE_CHECKING:
     try:

xarray/backends/common.py

@@ -12,9 +12,9 @@
 
 from xarray.conventions import cf_encoder
 from xarray.core import indexing
-from xarray.core.parallelcompat import get_chunked_array_type
-from xarray.core.pycompat import is_chunked_array
 from xarray.core.utils import FrozenDict, NdimSizeLenMixin, is_remote_uri
+from xarray.namedarray.parallelcompat import get_chunked_array_type
+from xarray.namedarray.pycompat import is_chunked_array
 
 if TYPE_CHECKING:
     from io import BufferedIOBase

xarray/backends/pydap_.py

@@ -14,15 +14,15 @@
 )
 from xarray.backends.store import StoreBackendEntrypoint
 from xarray.core import indexing
-from xarray.core.pycompat import integer_types
 from xarray.core.utils import (
     Frozen,
     FrozenDict,
     close_on_error,
-    is_dict_like,
     is_remote_uri,
 )
 from xarray.core.variable import Variable
+from xarray.namedarray.pycompat import integer_types
+from xarray.namedarray.utils import is_dict_like
 
 if TYPE_CHECKING:
     import os

xarray/backends/zarr.py

@@ -19,14 +19,14 @@
 )
 from xarray.backends.store import StoreBackendEntrypoint
 from xarray.core import indexing
-from xarray.core.parallelcompat import guess_chunkmanager
-from xarray.core.pycompat import integer_types
 from xarray.core.utils import (
     FrozenDict,
     HiddenKeyDict,
     close_on_error,
 )
 from xarray.core.variable import Variable
+from xarray.namedarray.parallelcompat import guess_chunkmanager
+from xarray.namedarray.pycompat import integer_types
 
 if TYPE_CHECKING:
     from io import BufferedIOBase

xarray/coding/strings.py

@@ -14,8 +14,8 @@
     unpack_for_encoding,
 )
 from xarray.core import indexing
-from xarray.core.parallelcompat import get_chunked_array_type, is_chunked_array
 from xarray.core.variable import Variable
+from xarray.namedarray.parallelcompat import get_chunked_array_type, is_chunked_array
 
 
 def create_vlen_dtype(element_type):

xarray/coding/times.py

@@ -24,9 +24,9 @@
 from xarray.core.common import contains_cftime_datetimes, is_np_datetime_like
 from xarray.core.formatting import first_n_items, format_timestamp, last_item
 from xarray.core.pdcompat import nanosecond_precision_timestamp
-from xarray.core.pycompat import is_duck_dask_array
 from xarray.core.utils import emit_user_level_warning
 from xarray.core.variable import Variable
+from xarray.namedarray.pycompat import is_duck_dask_array
 
 try:
     import cftime

xarray/coding/variables.py

@@ -10,9 +10,9 @@
 import pandas as pd
 
 from xarray.core import dtypes, duck_array_ops, indexing
-from xarray.core.parallelcompat import get_chunked_array_type
-from xarray.core.pycompat import is_chunked_array
 from xarray.core.variable import Variable
+from xarray.namedarray.parallelcompat import get_chunked_array_type
+from xarray.namedarray.pycompat import is_chunked_array
 
 if TYPE_CHECKING:
     T_VarTuple = tuple[tuple[Hashable, ...], Any, dict, dict]

xarray/conventions.py

@@ -14,9 +14,9 @@
     _contains_datetime_like_objects,
     contains_cftime_datetimes,
 )
-from xarray.core.pycompat import is_duck_dask_array
 from xarray.core.utils import emit_user_level_warning
 from xarray.core.variable import IndexVariable, Variable
+from xarray.namedarray.pycompat import is_duck_dask_array
 
 CF_RELATED_DATA = (
     "bounds",

xarray/convert.py

@@ -10,7 +10,7 @@
 from xarray.core import duck_array_ops
 from xarray.core.dataarray import DataArray
 from xarray.core.dtypes import get_fill_value
-from xarray.core.pycompat import array_type
+from xarray.namedarray.pycompat import array_type
 
 cdms2_ignored_attrs = {"name", "tileIndex"}
 iris_forbidden_keys = {

xarray/core/accessor_dt.py

@@ -13,9 +13,9 @@
     is_np_datetime_like,
     is_np_timedelta_like,
 )
-from xarray.core.pycompat import is_duck_dask_array
 from xarray.core.types import T_DataArray
 from xarray.core.variable import IndexVariable
+from xarray.namedarray.pycompat import is_duck_dask_array
 
 if TYPE_CHECKING:
     from numpy.typing import DTypeLike

xarray/core/alignment.py

@@ -20,8 +20,9 @@
     safe_cast_to_index,
 )
 from xarray.core.types import T_Alignable
-from xarray.core.utils import is_dict_like, is_full_slice
+from xarray.core.utils import is_full_slice
 from xarray.core.variable import Variable, as_compatible_data, calculate_dimensions
+from xarray.namedarray.utils import is_dict_like
 
 if TYPE_CHECKING:
     from xarray.core.dataarray import DataArray

xarray/core/arithmetic.py

@@ -19,7 +19,7 @@
     IncludeReduceMethods,
 )
 from xarray.core.options import OPTIONS, _get_keep_attrs
-from xarray.core.pycompat import is_duck_array
+from xarray.namedarray.pycompat import is_duck_array
 
 
 class SupportsArithmetic:

xarray/core/common.py

@@ -13,14 +13,14 @@
 from xarray.core import dtypes, duck_array_ops, formatting, formatting_html, ops
 from xarray.core.indexing import BasicIndexer, ExplicitlyIndexed
 from xarray.core.options import OPTIONS, _get_keep_attrs
-from xarray.core.parallelcompat import get_chunked_array_type, guess_chunkmanager
-from xarray.core.pycompat import is_chunked_array
 from xarray.core.utils import (
     Frozen,
-    either_dict_or_kwargs,
     emit_user_level_warning,
     is_scalar,
 )
+from xarray.namedarray.parallelcompat import get_chunked_array_type, guess_chunkmanager
+from xarray.namedarray.pycompat import is_chunked_array
+from xarray.namedarray.utils import either_dict_or_kwargs
 
 try:
     import cftime

xarray/core/computation.py

@@ -21,11 +21,12 @@
 from xarray.core.indexes import Index, filter_indexes_from_coords
 from xarray.core.merge import merge_attrs, merge_coordinates_without_align
 from xarray.core.options import OPTIONS, _get_keep_attrs
-from xarray.core.parallelcompat import get_chunked_array_type
-from xarray.core.pycompat import is_chunked_array, is_duck_dask_array
 from xarray.core.types import Dims, T_DataArray
-from xarray.core.utils import is_dict_like, is_scalar
+from xarray.core.utils import is_scalar
 from xarray.core.variable import Variable
+from xarray.namedarray.parallelcompat import get_chunked_array_type
+from xarray.namedarray.pycompat import is_chunked_array, is_duck_dask_array
+from xarray.namedarray.utils import is_dict_like
 
 if TYPE_CHECKING:
     from xarray.core.coordinates import Coordinates

xarray/core/coordinates.py

@@ -27,10 +27,10 @@
 from xarray.core.utils import (
     Frozen,
     ReprObject,
-    either_dict_or_kwargs,
     emit_user_level_warning,
 )
 from xarray.core.variable import Variable, as_variable, calculate_dimensions
+from xarray.namedarray.utils import either_dict_or_kwargs
 
 if TYPE_CHECKING:
     from xarray.core.common import DataWithCoords

xarray/core/dataarray.py

@@ -55,7 +55,6 @@
     HybridMappingProxy,
     ReprObject,
     _default,
-    either_dict_or_kwargs,
     emit_user_level_warning,
 )
 from xarray.core.variable import (
@@ -64,6 +63,7 @@
     as_compatible_data,
     as_variable,
 )
+from xarray.namedarray.utils import either_dict_or_kwargs, is_dict_like
 from xarray.plot.accessor import DataArrayPlotAccessor
 from xarray.plot.utils import _get_units_from_attrs
 from xarray.util.deprecation_helpers import _deprecate_positional_args
@@ -93,7 +93,6 @@
     from xarray.backends import ZarrStore
     from xarray.backends.api import T_NetcdfEngine, T_NetcdfTypes
     from xarray.core.groupby import DataArrayGroupBy
-    from xarray.core.parallelcompat import ChunkManagerEntrypoint
     from xarray.core.resample import DataArrayResample
     from xarray.core.rolling import DataArrayCoarsen, DataArrayRolling
     from xarray.core.types import (
@@ -116,6 +115,7 @@
         T_Xarray,
     )
     from xarray.core.weighted import DataArrayWeighted
+    from xarray.namedarray.parallelcompat import ChunkManagerEntrypoint
 
     T_XarrayOther = TypeVar("T_XarrayOther", bound=Union["DataArray", Dataset])
 
@@ -144,11 +144,7 @@ def _infer_coords_and_dims(
 ) -> tuple[Mapping[Hashable, Any], tuple[Hashable, ...]]:
     """All the logic for creating a new DataArray"""
 
-    if (
-        coords is not None
-        and not utils.is_dict_like(coords)
-        and len(coords) != len(shape)
-    ):
+    if coords is not None and not is_dict_like(coords) and len(coords) != len(shape):
         raise ValueError(
             f"coords is not dict-like, but it has {len(coords)} items, "
             f"which does not match the {len(shape)} dimensions of the "
@@ -162,7 +158,7 @@ def _infer_coords_and_dims(
         dims = [f"dim_{n}" for n in range(len(shape))]
         if coords is not None and len(coords) == len(shape):
             # try to infer dimensions from coords
-            if utils.is_dict_like(coords):
+            if is_dict_like(coords):
                 dims = list(coords.keys())
             else:
                 for n, (dim, coord) in enumerate(zip(dims, coords)):
@@ -185,7 +181,7 @@ def _infer_coords_and_dims(
         new_coords = coords
     else:
         new_coords = {}
-        if utils.is_dict_like(coords):
+        if is_dict_like(coords):
             for k, v in coords.items():
                 new_coords[k] = as_variable(v, name=k)
         elif coords is not None:
@@ -203,7 +199,7 @@ def _check_data_shape(data, coords, dims):
     if data is dtypes.NA:
         data = np.nan
     if coords is not None and utils.is_scalar(data, include_0d=False):
-        if utils.is_dict_like(coords):
+        if is_dict_like(coords):
             if dims is None:
                 return data
             else:
@@ -224,14 +220,14 @@ def __init__(self, data_array: T_DataArray):
         self.data_array = data_array
 
     def __getitem__(self, key) -> T_DataArray:
-        if not utils.is_dict_like(key):
+        if not is_dict_like(key):
             # expand the indexer so we can handle Ellipsis
             labels = indexing.expanded_indexer(key, self.data_array.ndim)
             key = dict(zip(self.data_array.dims, labels))
         return self.data_array.sel(key)
 
     def __setitem__(self, key, value) -> None:
-        if not utils.is_dict_like(key):
+        if not is_dict_like(key):
             # expand the indexer so we can handle Ellipsis
             labels = indexing.expanded_indexer(key, self.data_array.ndim)
             key = dict(zip(self.data_array.dims, labels))
@@ -827,7 +823,7 @@ def dims(self, value: Any) -> NoReturn:
         )
 
     def _item_key_to_dict(self, key: Any) -> Mapping[Hashable, Any]:
-        if utils.is_dict_like(key):
+        if is_dict_like(key):
             return key
         key = indexing.expanded_indexer(key, self.ndim)
         return dict(zip(self.dims, key))
@@ -2124,7 +2120,7 @@ def reindex(
         DataArray.reindex_like
         align
         """
-        indexers = utils.either_dict_or_kwargs(indexers, indexers_kwargs, "reindex")
+        indexers = either_dict_or_kwargs(indexers, indexers_kwargs, "reindex")
         return alignment.reindex(
             self,
             indexers=indexers,
@@ -2431,7 +2427,7 @@ def rename(
         if new_name_or_name_dict is None and not names:
             # change name to None?
             return self._replace(name=None)
-        if utils.is_dict_like(new_name_or_name_dict) or new_name_or_name_dict is None:
+        if is_dict_like(new_name_or_name_dict) or new_name_or_name_dict is None:
             # change dims/coords
             name_dict = either_dict_or_kwargs(new_name_or_name_dict, names, "rename")
             dataset = self._to_temp_dataset()._rename(name_dict)
@@ -3370,7 +3366,7 @@ def fillna(self, value: Any) -> Self:
           * Z        (Z) int64 0 1 2 3 4 5
             height   (Z) int64 0 10 20 30 40 50
         """
-        if utils.is_dict_like(value):
+        if is_dict_like(value):
             raise TypeError(
                 "cannot provide fill value as a dictionary with "
                 "fillna on a DataArray"