Upstream numpy has become a bit more particular with which types you can use for inplace operations. This PR fixes ``` __ TestImshow.test_imshow_rgb_values_in_valid_range __

self = <xarray.tests.test_plot.TestImshow object at 0x7f88320c2780>

def test_imshow_rgb_values_in_valid_range(self) -> None:
    da = DataArray(np.arange(75, dtype="uint8").reshape((5, 5, 3)))
    _, ax = plt.subplots()

  out = da.plot.imshow(ax=ax).get_array()

/home/runner/work/xarray/xarray/xarray/tests/test_plot.py:2034:

/home/runner/work/xarray/xarray/xarray/plot/accessor.py:421: in imshow return dataarray_plot.imshow(self._da, args, kwargs) /home/runner/work/xarray/xarray/xarray/plot/dataarray_plot.py:1601: in newplotfunc primitive = plotfunc( /home/runner/work/xarray/xarray/xarray/plot/dataarray_plot.py:1853: in imshow alpha = 255

self = masked_array( data=[[[1], [1], [1], [1], [1]],

    [[1],
     [1],
...,
     [1],
     [1],
     [1],
     [1]]],

mask=False, fill_value=np.int64(999999), dtype=uint8) other = 255

def __imul__(self, other):
    """
    Multiply self by other in-place.

    """
    m = getmask(other)
    if self._mask is nomask:
        if m is not nomask and m.any():
            self._mask = make_mask_none(self.shape, self.dtype)
            self._mask += m
    elif m is not nomask:
        self._mask += m
    other_data = getdata(other)
    other_data = np.where(self._mask, other_data.dtype.type(1), other_data)

  self._data.__imul__(other_data)

E numpy._core._exceptions._UFuncOutputCastingError: Cannot cast ufunc 'multiply' output from dtype('int64') to dtype('uint8') with casting rule 'same_kind'

/home/runner/micromamba/envs/xarray-tests/lib/python3.12/site-packages/numpy/ma/core.py:4415: UFuncTypeError ```

Some curious behaviors seen while debugging: ```python alpha = np.array([1], dtype=np.int8) alpha *= 255 repr(alpha) # 'array([-1], dtype=int8)'

alpha = np.array([1], dtype=np.int16) alpha *= 255 repr(alpha) # 'array([255], dtype=int16)' ```

xref: #8844

I noticed that seaborn's plot was responding much faster than xarray's version with the same data. Turn's out seaborn drops any nulls: https://github.com/mwaskom/seaborn/blob/056413d7393e3daec597d430c076e45938d53376/seaborn/relational.py#L399

• [x] Tests added
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst

The typing of Variable.data has been the very wide Variable.data: Any because of the difficulties defining the typing of a duckarray.

This has led to confusion in downstream functions that uses .data. Sometimes arguments uses Any, np.typing.ArrayLike, np.ndarray or dask array typing which is unnecessarily narrow when xarray also supports for example sparse arrays or cupy arrays.

This PR is a start at cleaning this up by defining a T_DuckArray typevar that symbolizes an array api compliant array.

Seems https://github.com/actions/labeler/issues/112 is fixed. So using false should work.

xref: #7431

Was hunting some low-hanging performance fruits when reading in files.

• Use Variable(..., fastpath=True) for cases when a Variable has been unpacked and modified slightly.
• Don't check if variable is variable in decode_cf_variable
• Don't import DataArray until necessary in as_compatible_data.

• Add typing to touched files to make sure only Variables are used.

• [ ] Closes #xxxx

• [ ] Tests added
• [ ] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [ ] New functions/methods are listed in api.rst

.coords were still using DataArray types switch to T_DataArray instead.

• [x] Fixes mypy error seen in #7277

This PR adds a helper method that sets the same axis limits for all plots in a facetgrid. Helpful when * wanting specific limits for all plots. * you want to make sure all data is visible by simply using the method without any inputs. Which is not certain if sharex/sharey isn't used, relevant when using 3d plots as they don't work.

Split up from #6778.

Following: https://importlib-resources.readthedocs.io/en/latest/migration.html#pkg-resources-resource-string

• [ ] Closes #xxxx
• [ ] Tests added
• [ ] Passes pre-commit run --all-files
• [ ] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [ ] New functions/methods are listed in api.rst

Reduce diffs in #6778. * Handle None as the error message suggest should be possible * Add some typing while at it.

mypy noticed that Hashable cannot use ", ".join-method so forcing them to str instead. Should be the same problem in #6856 but Frozen returns Any instead of Hashable for some reason.

Minor change inspired by #5365.

• [x] Passes pre-commit run --all-files

• [x] Closes #4260
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst

python a = xr.DataArray( [0, 1, 2], dims=("dim_1"), coords=dict(dim_1=(["dim_1"], ["u", "v", "w"])), ) a.plot()

python a = xr.DataArray( [[0, 1, 2], [3, 4, 5]], dims=("dim_0", "dim_1"), coords=dict(dim_0=(["dim_0"], [0, 1]), dim_1=(["dim_1"], ["u", "v", "w"])), ) a.plot()

The suggestion appears to be copy/paste-friendly but the format was slightly off.

The checks that didn't install cftime skipped the entire test_missing.py. Because cftime is also imported when importing the list of calenders _CFTIME_CALENDERS.

Added also skips for the cases that assumed cftime was installed so they are correctly skipped.

• [x] Passes pre-commit run --all-files

Found a few more places where modules are being imported just for version checking.

scipy.interpolate.interp1d always forces float so make sure that da.blockwise understands that as well.

• [x] Workaround for #4770
• [x] Tests added
• [x] Passes isort . && black . && mypy . && flake8

What happened: When I was interpolating datasets I noticed that the coordinate variables disappeared.

What you expected to happen: Coordinate attributes should be retained just like variables are.

Minimal Complete Verifiable Example:

```python import numpy as np import xarray as xr

names = np.core.defchararray.add("long_variable_name", np.arange(0, 2).astype(str)) coords = dict(time=np.array([0, 1])) data_vars = dict() for v in names: data_vars[v] = xr.Variable( "time", np.array([0, 1], dtype=int), attrs=dict(unit="kg") ) ds1 = xr.Dataset(data_vars=data_vars, coords=coords) ds1.attrs = { k: 2 for k in np.core.defchararray.add("attr_", np.arange(0, 3).astype(str)) } ds1.time.attrs.update(unit="s")

Print time:

ds1.time Out[115]: <xarray.DataArray 'time' (time: 2)> array([0, 1]) Coordinates: * time (time) int32 0 1 Attributes: unit: s

Interpolate:

ds1 = ds1.interp( time=np.array([0, 0.5, 1, 2]), assume_sorted=True, method="linear", kwargs=dict(fill_value="extrapolate"), )

Print interpolated time, units are lost:

ds1.time Out[117]: <xarray.DataArray 'time' (time: 4)> array([0. , 0.5, 1. , 2. ]) Coordinates: * time (time) float64 0.0 0.5 1.0 2. ```

Anything else we need to know?:

Environment: