fix(imshow): validate slots so bad assignments raise a clear error

Two slot assignments reached px.imshow and crashed inside its own
slicing with an error that named nothing the caller had written:

- The same dimension in two slots popped the same index twice, giving
  "IndexError: pop index out of range".
- Facet and animation slots consuming all but one dimension left nothing
  for the second heatmap axis, giving "IndexError: list index out of
  range". Duplicates that reached the transpose first surfaced as
  "ValueError: axes don't match array" instead.

Validate the assignment before transposing: every slot needs its own
dimension, and both y and x must be filled. The error now names the
dimension and the two slots that want it, or the slots that consumed
the axes.

Sweeping all 3125 combinations of auto/None/each dimension across the
five slots of a 4D array: every one now either builds a figure or
raises a ValueError that says what to change, with no change to the
1056 combinations that already worked.

Also drop mypy's python_version = "3.10" pin, which failed CI on the
3.12 and 3.13 matrix entries -- numpy's stubs now use `type` statements
that mypy rejects when targeting 3.10. Reproduced on origin/main with
no other changes. Unpinned, mypy targets the interpreter it runs under,
so each matrix entry checks its own version against the numpy stubs
resolved for it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01TKhPQzJgQr7khmzDPYAXA9

Author: claude

pyproject.toml

@@ -92,7 +92,9 @@ ignore = [
 known-first-party = ["xarray_plotly"]
 
 [tool.mypy]
-python_version = "3.10"
+# No python_version pin: mypy then targets the interpreter it runs under, so
+# each CI matrix entry checks its own version against the numpy stubs resolved
+# for it.  Pinning 3.10 made mypy reject numpy's `type` statements outright.
 strict = true
 warn_return_any = true
 warn_unused_ignores = true

tests/test_accessor.py

@@ -547,6 +547,51 @@ def test_imshow_facet_col_wrap_kept_without_facet_row(self) -> None:
         domains = {tuple(fig.layout[k].domain) for k in fig.layout if k.startswith("yaxis")}
         assert len(domains) == 2
 
+    def test_imshow_duplicate_dim_across_slots(self) -> None:
+        """Test a clear error when one dimension is asked to fill two slots.
+
+        px.imshow otherwise dies with "IndexError: pop index out of range".
+        """
+        with pytest.raises(ValueError, match=r"'scenario' is assigned to both"):
+            self.da_3d.plotly.imshow(y="lat", x="lon", facet_col="scenario", facet_row="scenario")
+
+    def test_imshow_duplicate_dim_facet_row_and_animation(self) -> None:
+        """Test the duplicate check across facet_row and animation_frame."""
+        with pytest.raises(ValueError, match=r"'year' is assigned to both"):
+            self.da_4d.plotly.imshow(
+                y="lat", x="lon", facet_col="scenario", facet_row="year", animation_frame="year"
+            )
+
+    def test_imshow_no_dimension_left_for_x(self) -> None:
+        """Test a clear error when facet/animation slots eat the heatmap axes.
+
+        px.imshow otherwise dies with "IndexError: list index out of range".
+        """
+        with pytest.raises(ValueError, match=r"needs a dimension for both 'y' and 'x'"):
+            self.da_4d.plotly.imshow(facet_col="lat", facet_row="lon", animation_frame="scenario")
+
+    def test_imshow_2d_with_both_facets_leaves_no_axes(self) -> None:
+        """Test the error when a 2D array puts both of its dims into facets."""
+        da = xr.DataArray(
+            np.random.rand(2, 3), dims=["a", "b"], coords={"a": [0, 1], "b": [0, 1, 2]}
+        )
+        with pytest.raises(ValueError, match=r"needs a dimension for both 'y' and 'x'"):
+            da.plotly.imshow(facet_col="a", facet_row="b")
+
+    @requires_imshow_facet_row
+    def test_imshow_explicit_x_y_facet_col_facet_row_4d(self) -> None:
+        """Test that naming all four slots on a 4D array builds the full grid."""
+        fig = self.da_4d.plotly.imshow(x="lon", y="lat", facet_col="scenario", facet_row="year")
+        assert len(fig.data) == 6
+        facet_titles = {a.text for a in fig.layout.annotations if "=" in (a.text or "")}
+        assert facet_titles == {
+            "scenario=low",
+            "scenario=high",
+            "year=2020",
+            "year=2021",
+            "year=2022",
+        }
+
     @requires_imshow_facet_row
     def test_imshow_facet_grid_places_data_in_right_subplot(self) -> None:
         """Test that each (facet_col, facet_row) pair lands in its own subplot."""

xarray_plotly/plotting.py

@@ -671,6 +671,49 @@ def _imshow_supports_facet_row() -> bool:
     return "facet_row" in inspect.signature(px.imshow).parameters
 
 
+_IMSHOW_SLOTS = ("y", "x", "facet_col", "facet_row", "animation_frame")
+
+
+def _validate_imshow_slots(slots: dict[str, Hashable]) -> None:
+    """Check that imshow's slots form a usable heatmap before handing them to plotly.
+
+    Every imshow slot is a separate axis of the data, so each needs its own
+    dimension and both heatmap axes must be filled.  ``px.imshow`` does not
+    check either, and fails deep inside its own slicing with ``IndexError:
+    pop index out of range`` (a dimension used twice) or ``IndexError: list
+    index out of range`` (nothing left for y/x).
+
+    Args:
+        slots: Slot assignment from :func:`assign_slots`.
+
+    Raises:
+        ValueError: If a dimension fills two slots, or y/x is left empty.
+    """
+    seen: dict[Hashable, str] = {}
+    for slot in _IMSHOW_SLOTS:
+        dim = slots.get(slot)
+        if dim is None:
+            continue
+        if dim in seen:
+            msg = (
+                f"Dimension {dim!r} is assigned to both {seen[dim]!r} and {slot!r}. "
+                f"Each imshow slot needs its own dimension."
+            )
+            raise ValueError(msg)
+        seen[dim] = slot
+
+    missing = [slot for slot in ("y", "x") if slots.get(slot) is None]
+    if missing:
+        taken = {slot: dim for dim, slot in seen.items()}
+        msg = (
+            f"imshow needs a dimension for both 'y' and 'x', but {missing} "
+            f"came up empty; the other slots took {taken}. Free one with "
+            f"facet_col=None, facet_row=None or animation_frame=None, or reduce "
+            f"a dimension with .sel(), .isel() or .mean() before plotting."
+        )
+        raise ValueError(msg)
+
+
 def _handle_unsupported_facet_row(slots: dict[str, Hashable], *, explicit: bool) -> None:
     """Resolve an imshow ``facet_row`` slot that the installed plotly cannot draw.
 
@@ -788,6 +831,8 @@ def imshow(
         animation_frame=animation_frame,
     )
 
+    _validate_imshow_slots(slots)
+
     if slots.get("facet_row") is not None and not _imshow_supports_facet_row():
         _handle_unsupported_facet_row(slots, explicit=facet_row is not auto)