uxarray 2026.9.0__tar.gz → 2026.9.1__tar.gz

{uxarray-2026.9.0 → uxarray-2026.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uxarray
-Version: 2026.9.0
+Version: 2026.9.1
 Summary: Xarray extension for unstructured climate and global weather data analysis and visualization.
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -221,37 +221,40 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: antimeridian
-Requires-Dist: cartopy
 Requires-Dist: dask[dataframe]
-Requires-Dist: datashader
-Requires-Dist: geoviews
-Requires-Dist: holoviews
-Requires-Dist: matplotlib<3.11
-Requires-Dist: matplotlib-inline
 Requires-Dist: netcdf4
 Requires-Dist: numba>=0.63
 Requires-Dist: numpy
 Requires-Dist: pandas
-Requires-Dist: pyarrow
-Requires-Dist: requests
 Requires-Dist: scikit-learn
 Requires-Dist: scipy
 Requires-Dist: shapely
-Requires-Dist: spatialpandas
-Requires-Dist: geopandas>=1.0
 Requires-Dist: xarray
-Requires-Dist: hvplot
-Requires-Dist: healpix
 Requires-Dist: polars
-Requires-Dist: pyproj
+Provides-Extra: all
+Requires-Dist: uxarray[dev,geo,viz]; extra == "all"
 Provides-Extra: complete
-Requires-Dist: uxarray[dev]; extra == "complete"
+Requires-Dist: uxarray[dev,geo,viz]; extra == "complete"
 Provides-Extra: dev
+Requires-Dist: asv; extra == "dev"
+Requires-Dist: pooch; extra == "dev"
 Requires-Dist: pre_commit; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
-Requires-Dist: asv; extra == "dev"
+Provides-Extra: geo
+Requires-Dist: cartopy; extra == "geo"
+Requires-Dist: geopandas>=1.0; extra == "geo"
+Requires-Dist: healpix; extra == "geo"
+Requires-Dist: pyproj; extra == "geo"
+Requires-Dist: spatialpandas; extra == "geo"
+Provides-Extra: viz
+Requires-Dist: cartopy<0.26; extra == "viz"
+Requires-Dist: datashader; extra == "viz"
+Requires-Dist: matplotlib<3.11; extra == "viz"
+Requires-Dist: geoviews; extra == "viz"
+Requires-Dist: holoviews; extra == "viz"
+Requires-Dist: hvplot; extra == "viz"
 Dynamic: license-file
 
 

{uxarray-2026.9.0 → uxarray-2026.9.1}/pyproject.toml

@@ -22,41 +22,53 @@ requires-python = ">=3.11"
 # minimal dependencies start
 dependencies = [
   "antimeridian",
-  "cartopy",
   "dask[dataframe]",
-  "datashader",
-  "geoviews",
-  "holoviews",
-  "matplotlib<3.11",  # matplotlib 3.11.0 breaks some plots but <3.11 is fine; see issue #1542.
-  "matplotlib-inline",
   "netcdf4",
   "numba>=0.63",  # 0.63 is the first release supporting Python 3.14 (3.10 <= py < 3.15). See #1561.
   "numpy",
   "pandas",
-  "pyarrow",
-  "requests",
   "scikit-learn",
   "scipy",
   "shapely",
-  "spatialpandas",
-  "geopandas>=1.0",  # 1.0 is the first release requiring pyogrio, the file-IO backend read_file needs. See #1693.
   "xarray",
-  "hvplot",
-  "healpix",
   "polars",
-  "pyproj"
 ]
 # minimal dependencies end
 
 [project.optional-dependencies]
-complete = ["uxarray[dev]"]
-dev = ['pre_commit', 'pytest', 'pytest-cov', 'ruff', 'asv']
+all = ["uxarray[dev,geo,viz]"]
+complete = ["uxarray[dev,geo,viz]"]  # alias to "all"
+dev = [
+    'asv',
+    'pooch',
+    'pre_commit',
+    'pytest',
+    'pytest-cov',
+    'ruff',
+]
+geo = [
+    "cartopy",  # in both geo and viz because it is needed by to_geodataframe() and by plotting routines.
+    "geopandas>=1.0",  # 1.0 is the first release requiring pyogrio, the file-IO backend read_file needs. See #1693.
+    "healpix",
+    "pyproj",
+    "spatialpandas",
+]
+viz = [
+    "cartopy<0.26",  # cartopy 0.26.0 breaks some geoviews plots; see issue #1780.
+    # (cartopy pin intentionally here but not in "geo" extras because geoviews is only in "viz".)
+    "datashader",
+    "matplotlib<3.11",  # matplotlib 3.11.0 breaks some plots but <3.11 is fine; see issue #1542.
+    "geoviews",  # no version pin; newer should support any cartopy; see holoviz/geoviews#884.
+    "holoviews",
+    "hvplot",
+]
 
 [project.urls]
 Documentation = "https://uxarray.readthedocs.io/"
 Source = "https://github.com/UXARRAY/uxarray"
 Tracker = "https://github.com/UXARRAY/uxarray/issues"
-
+# please keep [project.urls] immediately after [project.optional-dependencies],
+# or, if rearranging sections, make sure to edit installation.rst accordingly.
 
 [build-system]
 build-backend = "setuptools.build_meta"
@@ -87,3 +99,6 @@ known-first-party = ["uxarray"]
 
 [tool.ruff.format]
 docstring-code-format = true
+
+[tool.pytest.ini_options]
+testpaths = ["test"]  # (intentionally excludes test_optional_deps)

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/core/dataarray.py

@@ -11,7 +11,6 @@ from xarray.core import dtypes
 from xarray.core.options import OPTIONS
 from xarray.core.utils import UncachedAccessor
 
-import uxarray
 from uxarray.constants import GRID_DIMS
 from uxarray.core.aggregation import _uxda_grid_aggregate
 from uxarray.core.gradient import (
@@ -45,7 +44,13 @@ from uxarray.io._healpix import get_zoom_from_cells
 from uxarray.plot.accessor import UxDataArrayPlotAccessor
 from uxarray.remap.accessor import RemapAccessor
 from uxarray.subset import DataArraySubsetAccessor
-from uxarray.utils.coords import _preserve_valid_coords
+from uxarray.utils.coords import (
+    _assert_grid_dim_coord_consistent_if_in_both,
+    _assign_grid_dim_indexer_coords_if_appropriate,
+    _crash_if_1d_xarray_indexer_dim_in_uxarray_obj,
+    _preserve_valid_coords,
+)
+from uxarray.utils.imports import _raise_hint_if_optional_deps_missing
 
 if TYPE_CHECKING:
     import cartopy.crs as ccrs
@@ -183,26 +188,14 @@ class UxDataArray(xr.DataArray):
 
     @property
     def data_mapping(self):
-        """Returns which unstructured grid a data variable is mapped to."""
-        if self._face_centered():
-            return "faces"
-        elif self._edge_centered():
-            return "edges"
-        elif self._node_centered():
-            return "nodes"
-        else:
-            return None
-
-    @property
-    def data_location(self):
-        """Returns where on the grid the data variable is stored.
+        """Returns which grid element a data variable is mapped to.
 
-        The location is inferred from the grid dimension present in the data
-        variable, using UGRID-style names:
+        The mapping is inferred from the grid dimension present in the data
+        variable:
 
-        - ``"face_centered"`` if the data contains the ``n_face`` dimension
-        - ``"node_centered"`` if the data contains the ``n_node`` dimension
-        - ``"edge_centered"`` if the data contains the ``n_edge`` dimension
+        - ``"faces"`` if the data contains the ``n_face`` dimension
+        - ``"edges"`` if the data contains the ``n_edge`` dimension
+        - ``"nodes"`` if the data contains the ``n_node`` dimension
         - ``None`` if the data is not mapped to the grid
 
         Notes
@@ -215,15 +208,14 @@ class UxDataArray(xr.DataArray):
         Returns
         -------
         str or None
-            One of ``"face_centered"``, ``"node_centered"``,
-            ``"edge_centered"``, or ``None``.
+            One of ``"faces"``, ``"edges"``, ``"nodes"``, or ``None``.
         """
         if self._face_centered():
-            return "face_centered"
-        elif self._node_centered():
-            return "node_centered"
+            return "faces"
         elif self._edge_centered():
-            return "edge_centered"
+            return "edges"
+        elif self._node_centered():
+            return "nodes"
         else:
             return None
 
@@ -320,7 +312,7 @@ class UxDataArray(xr.DataArray):
 
         else:
             raise DataCenteringError(
-                f"to_geodataframe() expects face_centered data; got {self.data_location} data "
+                f"to_geodataframe() expects data mapped to faces; got data_mapping={self.data_mapping!r} "
                 f"(with sizes={dict(**self.sizes)}). Consider running "
                 "``UxDataArray.topological_mean(destination='face')`` to aggregate the data onto faces."
             )
@@ -480,6 +472,7 @@ class UxDataArray(xr.DataArray):
         >>> ax.imshow(raster, origin="lower", extent=ax.get_xlim() + ax.get_ylim())
 
         """
+        _raise_hint_if_optional_deps_missing("cartopy")
         from cartopy.mpl.geoaxes import GeoAxes
 
         from uxarray.constants import INT_DTYPE
@@ -524,6 +517,7 @@ class UxDataArray(xr.DataArray):
 
             if _is_default_extent():
                 try:
+                    _raise_hint_if_optional_deps_missing("cartopy")
                     import cartopy.crs as ccrs
 
                     lon_min = float(self.uxgrid.node_lon.min(skipna=True).values)
@@ -596,8 +590,10 @@ class UxDataArray(xr.DataArray):
         -------
         uxds: UxDataSet
         """
+        from uxarray.core.dataset import UxDataset
+
         xrds = super().to_dataset(dim=dim, name=name, promote_attrs=promote_attrs)
-        uxds = uxarray.core.dataset.UxDataset(xrds, uxgrid=self._uxgrid)
+        uxds = UxDataset(xrds, uxgrid=self._uxgrid)
 
         return uxds
 
@@ -645,8 +641,8 @@ class UxDataArray(xr.DataArray):
 
         elif not self._face_centered():
             raise DataCenteringError(
-                "Integration of non-face_centered data is not yet supported. "
-                f"(Got {self.data_location} data with sizes={dict(**self.sizes)})"
+                "Integration of data not mapped to faces is not yet supported. "
+                f"(Got data_mapping={self.data_mapping!r} with sizes={dict(**self.sizes)})"
             )
 
         else:
@@ -1796,7 +1792,7 @@ class UxDataArray(xr.DataArray):
         # Spherical metric term, the companion of the one in curl(). Omitting
         # it is only valid on a plane.
         tan_lat = np.tan(np.deg2rad(self.uxgrid.face_lat.values))
-        metric = other.values * tan_lat
+        metric = other.data * tan_lat
         if scale_by_radius and "sphere_radius" in self.uxgrid._ds.attrs:
             metric = metric / self.uxgrid._ds.attrs["sphere_radius"]
         divergence = divergence - metric
@@ -2006,7 +2002,10 @@ class UxDataArray(xr.DataArray):
         using n_edge=7 selects just the two faces touching edge 7. For data on 'n_face',
         the result would have 'n_face' with just those two faces. For data on 'n_edge',
         the result would have 'n_edge' with all edges located on either of those two faces.
+
         Grid dimension indexers cannot have more than 1 dimension (such as a 2D DataArray).
+        Grid dimensions are never renamed (even if indexed by 1D DataArray with different dim name).
+        Grid dimension indexer cannot have a non-grid dimension which exists in the original UxDataArray.
 
         Parameters
         ----------
@@ -2042,6 +2041,10 @@ class UxDataArray(xr.DataArray):
         -------
         UxDataArray
             A new UxDataArray indexed according to `indexers` and updated grid if applicable.
+            If indexer DataArrays have coordinates that do not conflict with
+            this object, then these coordinates will be attached,
+            except that 1D coordinates of indexers applied along a grid dimension will
+            only be included if it is 'n_face' and the data also has 'n_face' dimension.
 
         Raises
         ------
@@ -2071,22 +2074,27 @@ class UxDataArray(xr.DataArray):
             indexers = indexers.copy()  # don't modify the original dict
             grid_indexer = indexers.pop(grid_dim)
 
+            _crash_if_1d_xarray_indexer_dim_in_uxarray_obj(self, grid_dim, grid_indexer)
+
             sliced_grid = self.uxgrid.isel(
                 **{grid_dim: grid_indexer}, inverse_indices=inverse_indices
             )
 
-            da = self._slice_from_grid(sliced_grid)
+            result = self._slice_from_grid(sliced_grid)
+
+            result = _assign_grid_dim_indexer_coords_if_appropriate(
+                result, grid_dim, grid_indexer
+            )
 
             # if there are any remaining indexers, apply them
             if indexers:
-                xarr = super(UxDataArray, da).isel(
+                result = super(UxDataArray, result).isel(
                     indexers=indexers, drop=drop, missing_dims=missing_dims
                 )
                 # re‐wrap so the grid sticks around
-                return type(self)(xarr, uxgrid=sliced_grid)
+                result = type(self)(result, uxgrid=sliced_grid)
 
-            # no other dims, return the grid‐sliced da
-            return da
+            return result
         else:  # len(grid_dims)>1; _validate_indexers should have crashed.
             raise AssertionError("internal implementation error if reached this line")
 
@@ -2106,7 +2114,10 @@ class UxDataArray(xr.DataArray):
         using n_edge=7 selects just the two faces touching edge 7. For data on 'n_face',
         the result would have 'n_face' with just those two faces. For data on 'n_edge',
         the result would have 'n_edge' with all edges located on either of those two faces.
+
         Grid dimension indexers cannot have more than 1 dimension (such as a 2D DataArray).
+        Grid dimensions are never renamed (even if indexed by 1D DataArray with different dim name).
+        Grid dimension indexer cannot have a non-grid dimension which exists in the original UxDataArray.
 
         By default, grid dims do not have coordinates assigned. But, if they have
         been assigned, `.sel()` respects them in the intuitive way. For example,
@@ -2167,7 +2178,8 @@ class UxDataArray(xr.DataArray):
             and the uxgrid indexed appropriately as well, if indexing any grid dim.
             If indexer DataArrays have coordinates that do not conflict with
             this object, then these coordinates will be attached,
-            except for indexers along a grid dimension (see issue #1712).
+            except that 1D coordinates of indexers applied along a grid dimension will
+            only be included if it is 'n_face' and the data also has 'n_face' dimension.
             In general, the result's data will be a view of the data in this array,
             unless indexing along a grid dimension or otherwise
             triggering vectorized indexing by using an array indexer,
@@ -2213,6 +2225,10 @@ class UxDataArray(xr.DataArray):
             # offload the grid-indexing work to isel():
             result = self.isel({grid_dim: grid_indices}, drop=drop)
 
+            # special case: if grid_dim in indexer and result.coords, ensure consistency.
+            # (all other coords' consistency checks already occurred in isel().)
+            _assert_grid_dim_coord_consistent_if_in_both(result, grid_dim, grid_indexer)
+
             # index by other dims if any remain:
             ds = result.to_xarray().sel(
                 indexers=indexers,  # (grid_dim indexer was popped)
@@ -2321,7 +2337,7 @@ class UxDataArray(xr.DataArray):
                 "Data variable must be either node, edge, or face centered."
             )
 
-        return UxDataArray(da_sliced, uxgrid=sliced_grid)
+        return type(self)(da_sliced, uxgrid=sliced_grid)
 
     def get_dual(self):
         """Compute the dual mesh for a data array, returns a new data array
@@ -2359,9 +2375,7 @@ class UxDataArray(xr.DataArray):
         dims = [dim_map.get(dim, dim) for dim in self.dims]
 
         # Construct the new data array
-        uxda = uxarray.UxDataArray(
-            uxgrid=dual, data=self.data, dims=dims, name=self.name
-        )
+        uxda = type(self)(uxgrid=dual, data=self.data, dims=dims, name=self.name)
 
         return uxda
 

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/core/dataset.py

@@ -11,7 +11,7 @@ from xarray.core import dtypes
 from xarray.core.options import OPTIONS
 from xarray.core.utils import UncachedAccessor
 
-import uxarray
+from uxarray.constants import GRID_DIMS
 from uxarray.core.dataarray import UxDataArray
 from uxarray.core.utils import (
     _map_dims_to_ugrid,
@@ -28,6 +28,11 @@ from uxarray.grid.validation import _check_duplicate_nodes_indices
 from uxarray.io._healpix import get_zoom_from_cells
 from uxarray.plot.accessor import UxDatasetPlotAccessor
 from uxarray.remap.accessor import RemapAccessor
+from uxarray.utils.coords import (
+    _assert_grid_dim_coord_consistent_if_in_both,
+    _assign_grid_dim_indexer_coords_if_appropriate,
+    _crash_if_1d_xarray_indexer_dim_in_uxarray_obj,
+)
 
 
 class UxDataset(xr.Dataset):
@@ -387,33 +392,39 @@ class UxDataset(xr.Dataset):
 
         return cls.from_xarray(ds, uxgrid, {face_dim: "n_face"})
 
-    def _slice_dataset_from_grid(self, sliced_grid, grid_dim: str, grid_indexer):
+    def _slice_from_grid(self, sliced_grid):
+        """returns UxDataset based on slicing self according to sliced_grid.
+        sliced_grid should be a ``Grid`` which came directly from self.uxgrid.isel(...)
+        (or from slicing something equal to self.uxgrid), else behavior is undefined.
+        """
         data_vars = {}
         for name, da in self.data_vars.items():
-            if grid_dim in da.dims:
-                if hasattr(da, "_slice_from_grid"):
-                    data_vars[name] = da._slice_from_grid(sliced_grid)
-                else:
-                    data_vars[name] = da.isel({grid_dim: grid_indexer})
+            if hasattr(da, "_slice_from_grid") and any(
+                dim in da.dims for dim in GRID_DIMS
+            ):
+                data_vars[name] = da._slice_from_grid(sliced_grid)
             else:
                 data_vars[name] = da
 
-        coords = {}
-        for cname, cda in self.coords.items():
-            if grid_dim in cda.dims:
-                # Prefer authoritative coords from the sliced grid if available
-                replacement = getattr(sliced_grid, cname, None)
-                coords[cname] = (
-                    replacement
-                    if replacement is not None
-                    else cda.isel({grid_dim: grid_indexer})
-                )
-            else:
-                coords[cname] = cda
-
-        ds = xr.Dataset(data_vars=data_vars, coords=coords, attrs=self.attrs)
+        # Also account for any coords which aren't attached to any data_var:
+        bonus_coords = {}
+        for coord in self.coords:
+            for data_var in data_vars.values():
+                if coord in data_var.coords:
+                    break
+            else:  # didn't break
+                da = self.coords[coord]
+                if hasattr(da, "_slice_from_grid") and any(
+                    dim in da.dims for dim in GRID_DIMS
+                ):
+                    bonus_coords[coord] = da._slice_from_grid(sliced_grid)
+                else:
+                    bonus_coords[coord] = da
 
-        return ds
+        ds_sliced = xr.Dataset(
+            data_vars=data_vars, coords=bonus_coords, attrs=self.attrs
+        )
+        return type(self)(ds_sliced, uxgrid=sliced_grid)
 
     def isel(
         self,
@@ -435,7 +446,10 @@ class UxDataset(xr.Dataset):
         using n_edge=7 selects just the two faces touching edge 7. For data on 'n_face',
         the result would have 'n_face' with just those two faces. For data on 'n_edge',
         the result would have 'n_edge' with all edges located on either of those two faces.
+
         Grid dimension indexers cannot have more than 1 dimension (such as a 2D DataArray).
+        Grid dimensions are never renamed (even if indexed by 1D DataArray with different dim name).
+        Grid dimension indexer cannot have a non-grid dimension which exists in the original UxDataset.
 
         Parameters
         ----------
@@ -471,6 +485,10 @@ class UxDataset(xr.Dataset):
         -------
         UxDataset
             A new UxDataset indexed according to `indexers` and updated grid if applicable.
+            If indexer DataArrays have coordinates that do not conflict with
+            this object, then these coordinates will be attached,
+            except that 1D coordinates of indexers applied along a grid dimension will
+            only be included if it is 'n_face' and the data also has 'n_face' dimension.
 
         Raises
         ------
@@ -500,23 +518,27 @@ class UxDataset(xr.Dataset):
             indexers = indexers.copy()  # don't modify the original dict
             grid_indexer = indexers.pop(grid_dim)
 
-            # slice the grid
+            _crash_if_1d_xarray_indexer_dim_in_uxarray_obj(self, grid_dim, grid_indexer)
+
             sliced_grid = self.uxgrid.isel(
                 **{grid_dim: grid_indexer}, inverse_indices=inverse_indices
             )
 
-            ds = self._slice_dataset_from_grid(
-                sliced_grid=sliced_grid,
-                grid_dim=grid_dim,
-                grid_indexer=grid_indexer,
+            result = self._slice_from_grid(sliced_grid)
+
+            result = _assign_grid_dim_indexer_coords_if_appropriate(
+                result, grid_dim, grid_indexer
             )
 
+            # if there are any remaining indexers, apply them
             if indexers:
-                ds = xr.Dataset.isel(
-                    ds, indexers=indexers, drop=drop, missing_dims=missing_dims
+                result = super(UxDataset, result).isel(
+                    indexers=indexers, drop=drop, missing_dims=missing_dims
                 )
+                # re‐wrap so the grid sticks around
+                result = type(self)(result, uxgrid=sliced_grid)
 
-            return type(self)(ds, uxgrid=sliced_grid)
+            return result
         else:  # len(grid_dims)>1; _validate_indexers should have crashed.
             raise AssertionError("internal implementation error if reached this line")
 
@@ -537,7 +559,10 @@ class UxDataset(xr.Dataset):
         using n_edge=7 selects just the two faces touching edge 7. For data on 'n_face',
         the result would have 'n_face' with just those two faces. For data on 'n_edge',
         the result would have 'n_edge' with all edges located on either of those two faces.
+
         Grid dimension indexers cannot have more than 1 dimension (such as a 2D DataArray).
+        Grid dimensions are never renamed (even if indexed by 1D DataArray with different dim name).
+        Grid dimension indexer cannot have a non-grid dimension which exists in the original UxDataset.
 
         By default, grid dims do not have coordinates assigned. But, if they have
         been assigned, `.sel()` respects them in the intuitive way. For example,
@@ -566,7 +591,8 @@ class UxDataset(xr.Dataset):
             multi-index, the indexer may also be a dict-like object with keys
             matching index level names.
             If DataArrays are passed as indexers, xarray-style indexing will be
-            carried out. See :ref:`indexing` for the details.
+            carried out (see :ref:`indexing` for the details),
+            with one exception: grid dimensions will never be renamed.
             One of indexers or indexers_kwargs must be provided.
         method : {None, "nearest", "pad", "ffill", "backfill", "bfill"}, optional
             Method to use for inexact matches:
@@ -599,7 +625,8 @@ class UxDataset(xr.Dataset):
             and the uxgrid indexed appropriately as well, if indexing any grid dim.
             If indexer DataArrays have coordinates that do not conflict with
             this object, then these coordinates will be attached,
-            except for indexers along a grid dimension (see issue #1712).
+            except that 1D coordinates of indexers applied along a grid dimension will
+            only be included if it is 'n_face' and the data also has 'n_face' dimension.
             In general, each array's data will be a view of the array's data
             in this dataset, unless indexing along a grid dimension or otherwise
             triggering vectorized indexing by using an array indexer,
@@ -646,6 +673,10 @@ class UxDataset(xr.Dataset):
             # offload the grid-indexing work to isel():
             result = self.isel({grid_dim: grid_indices}, drop=drop)
 
+            # special case: if grid_dim in indexer and result.coords, ensure consistency.
+            # (all other coords' consistency checks already occurred in isel().)
+            _assert_grid_dim_coord_consistent_if_in_both(result, grid_dim, grid_indexer)
+
             # index by other dims if any remain:
             ds = result.to_xarray().sel(
                 indexers=indexers,  # (grid_dim indexer was popped)
@@ -921,7 +952,7 @@ class UxDataset(xr.Dataset):
         )
 
         # Initialize new dataset
-        dataset = uxarray.UxDataset(uxgrid=dual)
+        dataset = type(self)(uxgrid=dual)
 
         # Dictionary to swap dimensions
         dim_map = {"n_face": "n_node", "n_node": "n_face"}
@@ -932,9 +963,7 @@ class UxDataset(xr.Dataset):
             dims = [dim_map.get(dim, dim) for dim in self[var].dims]
 
             # Construct the new data array
-            uxda = uxarray.UxDataArray(
-                uxgrid=dual, data=self[var].data, dims=dims, name=var
-            )
+            uxda = UxDataArray(uxgrid=dual, data=self[var].data, dims=dims, name=var)
 
             # Add data array to dataset
             dataset[var] = uxda

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/core/gradient.py

@@ -350,7 +350,7 @@ def _dual_cell_area(sx, sy, sz, angles, n):
     return np.abs(area)
 
 
-@njit(cache=True, parallel=True)
+@njit(cache=True, parallel=True, nogil=True)
 def _compute_gradients_on_faces(
     data,
     n_face,

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/core/utils.py

@@ -1,3 +1,5 @@
+import warnings
+
 import numpy as np
 import xarray as xr
 from xarray.core.utils import either_dict_or_kwargs
@@ -186,10 +188,7 @@ def _resolve_coordinate_labels_to_indices(
 ):
     """returns indices which would be selected by coord_array.sel({dim: labels_to_sel}, ...)
     coord_array.isel({dim: result}) should be equivalent to coord_array.sel({dim: labels_to_sel}, ...).
-
-    (Implementation here drops extra coordinates from any indexers,
-    but if it is being applied to grid dims for sel() then it will produce behavior
-    which is consistent with isel(), unless issue #1712 gets fixed.)
+    If labels_to_sel is an xr.DataArray, its coords/dims will also be attached to the result.
 
     dim: str
         dimension name to select along
@@ -203,10 +202,26 @@ def _resolve_coordinate_labels_to_indices(
     # (Maybe a more efficient implementation exists, but this is simple and gives correct results.)
     indices = xr.DataArray(np.arange(coord_array.sizes[dim]), dims=dim)
     _indices_coord_name = f"__{dim}_indices__"  # just needs to be any unused name.
+    if _indices_coord_name in coord_array.coords:
+        warnings.warn(
+            f"Coordinate {_indices_coord_name!r} already exists in coord_array.coords "
+            "and will be overwritten, which may cause errors or subtly incorrect results..."
+        )
     if hasattr(coord_array, "to_xarray"):  # convert to xarray to avoid recursive sel()
         coord_array = coord_array.to_xarray()
     coord_with_indices = coord_array.assign_coords({_indices_coord_name: indices})
     selected = coord_with_indices.sel(
         {dim: labels_to_sel}, method=method, tolerance=tolerance
     )
-    return selected[_indices_coord_name].values  # (return as np.ndarray, not DataArray)
+    result = selected[_indices_coord_name]
+    if isinstance(labels_to_sel, xr.DataArray):
+        # handle coords appropriately
+        result = result.drop_vars((dim, _indices_coord_name))
+        # (drop grid dim coords because the caller is expected to handle those directly;
+        # here the goal is just to properly propagate any other coords from labels_to_sel.)
+        result = result.rename(None)  # no reason to keep the _indices_coord_name
+        # (and keeping it for longer could maybe cause confusing error later?)
+    else:
+        # drop all coords/name info which was added internally during this method.
+        result = result.values
+    return result

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/cross_sections/sample.py

@@ -1,9 +1,12 @@
 import numpy as np
 
+from uxarray.utils.imports import _raise_hint_if_optional_deps_missing
+
 
 def sample_geodesic(
     start: tuple[float, float], end: tuple[float, float], steps: int
 ) -> tuple[np.ndarray, np.ndarray]:
+    _raise_hint_if_optional_deps_missing("pyproj")
     from pyproj import Geod
 
     lon0, lat0 = start

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/errors.py

@@ -38,3 +38,10 @@ class GridsMismatchError(ValueError):
 
 class YacNotAvailableError(RuntimeError):
     """Raised when the YAC backend is requested but unavailable."""
+
+
+# # # ----- Miscellaneous Errors ----- # # #
+
+
+class OptionalDependencyNotFoundError(ModuleNotFoundError):
+    """indicates functionality relies on a not-yet-installed optional dependency."""

{uxarray-2026.9.0 → uxarray-2026.9.1}/uxarray/grid/angles.py

@@ -8,7 +8,7 @@ from numba import njit, prange
 from uxarray.grid.utils import _numba_norm3, _small_angle_of_2_vectors
 
 
-@njit(cache=True, parallel=True)
+@njit(cache=True, parallel=True, nogil=True)
 def _compute_face_node_angles_convex(
     node_x,
     node_y,