Better uv compatibility

`uv sync` now installs dev dependencies automatically. I don't think this should affect other tools negatively, lmk if I'm unaware of something

Author: max-sixty

pyproject.toml

@@ -30,22 +30,6 @@ dependencies = ["numpy>=1.24", "packaging>=23.2", "pandas>=2.1"]
 [project.optional-dependencies]
 accel = ["scipy", "bottleneck", "numbagg", "numba>=0.54", "flox", "opt_einsum"]
 complete = ["xarray[accel,etc,io,parallel,viz]"]
-dev = [
-  "hypothesis",
-  "jinja2",
-  "mypy",
-  "pre-commit",
-  "pytest",
-  "pytest-cov",
-  "pytest-env",
-  "pytest-mypy-plugins",
-  "pytest-timeout",
-  "pytest-xdist",
-  "ruff>=0.8.0",
-  "sphinx",
-  "sphinx_autosummary_accessors",
-  "xarray[complete,types]",
-]
 io = [
   "netCDF4",
   "h5netcdf",
@@ -76,6 +60,25 @@ types = [
   "types-setuptools",
 ]
 
+[dependency-groups]
+dev = [
+  "hypothesis",
+  "jinja2",
+  "mypy",
+  "pre-commit",
+  "pytest",
+  "pytest-cov",
+  "pytest-env",
+  "pytest-mypy-plugins",
+  "pytest-timeout",
+  "pytest-xdist",
+  "ruff>=0.8.0",
+  "sphinx",
+  "sphinx_autosummary_accessors",
+  "xarray[complete,types]",
+
+]
+
 [project.urls]
 Documentation = "https://docs.xarray.dev"
 SciPy2015-talk = "https://www.youtube.com/watch?v=X0pAhJgySxk"

xarray/core/dataarray.py

@@ -5991,26 +5991,30 @@ def idxmin(
 
     def idxmax(
         self,
-        dim: Hashable = None,
+        dim: Dims = None,
         *,
         skipna: bool | None = None,
         fill_value: Any = dtypes.NA,
         keep_attrs: bool | None = None,
-    ) -> Self:
-        """Return the coordinate label of the maximum value along a dimension.
+    ) -> Self | dict[Hashable, Self]:
+        """Return the coordinate label of the maximum value along one or more dimensions.
 
         Returns a new `DataArray` named after the dimension with the values of
         the coordinate labels along that dimension corresponding to maximum
         values along that dimension.
 
+        If a sequence is passed to 'dim', then result is returned as dict of DataArrays.
+        If a single str is passed to 'dim' then returns a DataArray.
+
         In comparison to :py:meth:`~DataArray.argmax`, this returns the
         coordinate label while :py:meth:`~DataArray.argmax` returns the index.
+        Internally, this method uses argmax to locate the maximum values.
 
         Parameters
         ----------
-        dim : Hashable, optional
-            Dimension over which to apply `idxmax`.  This is optional for 1D
-            arrays, but required for arrays with 2 or more dimensions.
+        dim : "...", str, Iterable of Hashable or None, optional
+            The dimensions over which to find the maximum. By default, finds maximum over
+            all dimensions if array is 1D, otherwise requires explicit specification.
         skipna : bool or None, default: None
             If True, skip missing values (as marked by NaN). By default, only
             skips missing values for ``float``, ``complex``, and ``object``
@@ -6029,9 +6033,9 @@ def idxmax(
 
         Returns
         -------
-        reduced : DataArray
-            New `DataArray` object with `idxmax` applied to its data and the
-            indicated dimension removed.
+        reduced : DataArray or dict of DataArray
+            New `DataArray` object(s) with `idxmax` applied to its data and the
+            indicated dimension(s) removed.
 
         See Also
         --------
@@ -6076,15 +6080,40 @@ def idxmax(
         array([0., 4., 4.])
         Coordinates:
           * y        (y) int64 24B -1 0 1
-        """
-        return computation._calc_idxminmax(
-            array=self,
-            func=lambda x, *args, **kwargs: x.argmax(*args, **kwargs),
-            dim=dim,
-            skipna=skipna,
-            fill_value=fill_value,
-            keep_attrs=keep_attrs,
-        )
+        >>> array.idxmax(dim=["x", "y"])
+        {'x': <xarray.DataArray 'x' ()> Size: 8B
+        array(0.),
+         'y': <xarray.DataArray 'y' ()> Size: 8B
+        array(-1)}
+        """
+        # Check if dim is multi-dimensional (either ellipsis or a sequence, not a string or tuple)
+        if (dim is ... or (isinstance(dim, Iterable) and not isinstance(dim, str))) and not isinstance(
+            dim, tuple
+        ):
+            # For multiple dimensions, process each dimension separately
+            # This matches the behavior pattern of argmax when given multiple dimensions,
+            # but returns coordinate labels instead of indices
+            result = {}
+            for k in dim if dim is not ... else self.dims:
+                result[k] = self.idxmax(
+                    dim=k,
+                    skipna=skipna,
+                    fill_value=fill_value,
+                    keep_attrs=keep_attrs,
+                )
+            return result
+        else:
+            # Use the existing implementation for single dimension
+            # This wraps argmax through the _calc_idxminmax helper function
+            # which converts indices to coordinate values
+            return computation._calc_idxminmax(
+                array=self,
+                func=lambda x, *args, **kwargs: x.argmax(*args, **kwargs),
+                dim=dim,
+                skipna=skipna,
+                fill_value=fill_value,
+                keep_attrs=keep_attrs,
+            )
 
     def argmin(
         self,

xarray/tests/test_dataarray.py

@@ -5716,6 +5716,22 @@ def test_idxmax(
             ar0 = ar0_raw.chunk({})
         else:
             ar0 = ar0_raw
+            
+        # Test multi-dimensional idxmax
+        if not np.isnan(maxindex).any():
+            # Get the indices for the maximum values along both dimensions
+            idx_y = ar0.argmax(dim="x")
+            idx_x = ar0.argmax(dim="y")
+            
+            # Get the coordinate labels for these maximum values using idxmax
+            idxmax_result = ar0.idxmax(dim=["x", "y"])
+            
+            # Verify we have the expected keys in the result dictionary
+            assert set(idxmax_result.keys()) == {"x", "y"}
+            
+            # Verify the values match what we'd expect from individually applying idxmax
+            assert_identical(idxmax_result["x"], ar0.idxmax(dim="x"))
+            assert_identical(idxmax_result["y"], ar0.idxmax(dim="y"))
 
         # No dimension specified
         with pytest.raises(ValueError):