What is your issue?

Just something I caught while looking at the docs. I think this should be variables?

https://github.com/pydata/xarray/blob/d639d6e151bdeba070127aa7e286c5bfa6048194/xarray/core/dataset.py#L7925 https://github.com/pydata/xarray/blob/d639d6e151bdeba070127aa7e286c5bfa6048194/xarray/core/dataset.py#L7948-L7953

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

What happened?

A numpy DeprecationWarning regarding DType is being outputted when using xr.testing.assert_all_close() to compare two chunked Datasets. This does warning does not appear with two non-chunked datasets.

What did you expect to happen?

The warning should not appear.

Minimal Complete Verifiable Example

```python class TestTemporalAvg: class TestTimeseries: @pytest.fixture(autouse=True) def setup(self): self.ds: xr.Dataset = generate_dataset(cf_compliant=True, has_bounds=True)

    # No warning with this test
    def test_weighted_annual_avg(self):
        ds = self.ds.copy()

        result = ds.temporal.temporal_avg("timeseries", "year", data_var="ts")
        expected = ds.copy()
        expected["ts"] = xr.DataArray(
            name="ts",
            data=np.ones((2, 4, 4)),
            coords={
                "lat": self.ds.lat,
                "lon": self.ds.lon,
                "year": pd.MultiIndex.from_tuples(
                    [(2000,), (2001,)],
                ),
            },
            dims=["year", "lat", "lon"],
            attrs={
                "operation": "temporal_avg",
                "mode": "timeseries",
                "freq": "year",
                "groupby": "year",
                "weighted": "True",
                "centered_time": "True",
            },
        )

        # For some reason, there is a floating point difference between both
        # for ts so we have to use floating point comparison
        xr.testing.assert_allclose(result, expected)
        assert result.ts.attrs == expected.ts.attrs

    # Warning with this test
    @requires_dask
    def test_weighted_annual_avg_with_chunking(self):
        ds = self.ds.copy().chunk({"time": 2})

        result = ds.temporal.temporal_avg("timeseries", "year", data_var="ts")
        expected = ds.copy()
        expected["ts"] = xr.DataArray(
            name="ts",
            data=np.ones((2, 4, 4)),
            coords={
                "lat": ds.lat,
                "lon": ds.lon,
                "year": pd.MultiIndex.from_tuples(
                    [(2000,), (2001,)],
                ),
            },
            dims=["year", "lat", "lon"],
            attrs={
                "operation": "temporal_avg",
                "mode": "timeseries",
                "freq": "year",
                "groupby": "year",
                "weighted": "True",
                "centered_time": "True",
            },
        )

        # For some reason, there is a floating point difference between both
        # for ts so we have to use floating point comparison
        xr.testing.assert_allclose(result, expected)
        assert result.ts.attrs == expected.ts.attrs

```

Relevant log output

python DeprecationWarning: The `dtype` and `signature` arguments to ufuncs only select the general DType and not details such as the byte order or time unit (with rare exceptions see release notes). To avoid this warning please use the scalar types `np.float64`, or string notation. In rare cases where the time unit was preserved, either cast the inputs or provide an output array. In the future NumPy may transition to allow providing `dtype=` to denote the outputs `dtype` as well. (Deprecated NumPy 1.21) return ufunc.reduce(obj, axis, dtype, out, **passkwargs)

Anything else we need to know?

No response

Environment

INSTALLED VERSIONS

commit: None python: 3.9.7 | packaged by conda-forge | (default, Sep 29 2021, 19:20:46) [GCC 9.4.0] python-bits: 64 OS: Linux OS-release: 3.10.0-1160.45.1.el7.x86_64 machine: x86_64 processor: x86_64 byteorder: little LC_ALL: None LANG: en_US.UTF-8 LOCALE: ('en_US', 'UTF-8') libhdf5: 1.12.1 libnetcdf: 4.8.1

xarray: 0.20.1 pandas: 1.3.4 numpy: 1.21.4 scipy: None netCDF4: 1.5.8 pydap: None h5netcdf: None h5py: None Nio: None zarr: None cftime: 1.5.1.1 nc_time_axis: None PseudoNetCDF: None rasterio: None cfgrib: None iris: None bottleneck: 1.3.2 dask: 2021.11.2 distributed: 2021.11.2 matplotlib: None cartopy: None seaborn: None numbagg: None fsspec: 2021.11.1 cupy: None pint: None sparse: None setuptools: 59.6.0 pip: 21.3.1 conda: None pytest: 6.2.5 IPython: 7.30.1 sphinx: 4.3.1

• [x] Closes #7577

What is your issue?

Hello, my name is Tom and I'm a core developer for xCDAT (Xarray Climate Data Analysis Tools). xCDAT is an extension of xarray for climate data analysis on structured grids. It serves as a modern successor to the Community Data Analysis Tools (CDAT) library.

I've had a GH Issue to try to get xCDAT added to the "Xarray related projects" list. It would be awesome xCDAT if can be included on there while the project and community continues to grow!

What happened: I am attempting to mask specific time_bnds coordinate points using loc, but am receiving TypeError: '_ElementwiseFunctionArray' object does not support item assignment.

This happens when calling ds = xr.open_dataset("path/to/file", decode_times=False), followed by ds = xr.decode_cf(ds, decode_times=True).

What you expected to happen:

The time_bnds coordinate points selected using .loc should mask.

Minimal Complete Verifiable Example:

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

file_path = "./input/ts_Amon_ACCESS1-0_historical_r1i1p1_185001-200512.nc"

This works fine

ds = xr.open_dataset(file_path, decode_times=True) ds["time_bnds"].loc[dict(time="1850-01")] = np.nan

This breaks

ds2 = xr.open_dataset(file_path, decode_times=False) ds2 = xr.decode_cf(ds2, decode_times=True) ds2["time_bnds"].loc[dict(time="1850-01")] = np.nan

TypeError Traceback (most recent call last) ~/Documents/Repositories/XCDAT/xcdat/qa/PR47 temporal avg/bugs/qa_seasonal_bug.py in <module> 13 ds2 = xr.open_dataset(file_path, decode_times=False) 14 ds2 = xr.decode_cf(ds2, decode_times=True) ----> 15 ds2["time_bnds"].loc[dict(time="1850-01")] = np.nan

/opt/miniconda3/envs/xcdat_dev/lib/python3.9/site-packages/xarray/core/dataarray.py in setitem(self, key, value) 212 213 pos_indexers, _ = remap_label_indexers(self.data_array, key) --> 214 self.data_array[pos_indexers] = value 215 216

/opt/miniconda3/envs/xcdat_dev/lib/python3.9/site-packages/xarray/core/dataarray.py in setitem(self, key, value) 765 for k, v in self._item_key_to_dict(key).items() 766 } --> 767 self.variable[key] = value 768 769 def delitem(self, key: Any) -> None:

/opt/miniconda3/envs/xcdat_dev/lib/python3.9/site-packages/xarray/core/variable.py in setitem(self, key, value) 852 853 indexable = as_indexable(self._data) --> 854 indexable[index_tuple] = value 855 856 @property

/opt/miniconda3/envs/xcdat_dev/lib/python3.9/site-packages/xarray/core/indexing.py in setitem(self, key, value) 435 ) 436 full_key = self._updated_key(key) --> 437 self.array[full_key] = value 438 439 def repr(self):

TypeError: '_ElementwiseFunctionArray' object does not support item assignment

```

Anything else we need to know?:

The workaround is to perform .load() after xr.decode_cf() ```python

This works

ds3 = xr.open_dataset(file_path, decode_times=False) ds3 = xr.decode_cf(ds3, decode_times=True) ds3.load() ds3["time_bnds"].loc[dict(time="1850-01")] = np.nan ```

Environment: