What happened?

Found by hypothesis ``` import xarray as xr import numpy as np

var = xr.Variable(dims="2", data=np.array(['1970-01-01T00:00:00.000000000', '1970-01-01T00:00:00.000000002', '1970-01-01T00:00:00.000000001'], dtype='datetime64[ns]')) var1 = xr.Variable(data=np.array([0], dtype=np.uint32), dims=['1'], attrs={})

state = xr.Dataset() state['2'] = var state = state.stack({"0": ["2"]}) state['1'] = var1 state['1_'] = var1#.copy(deep=True) state = state.swap_dims({"1": "1_"}) xr.testing.assertions._assert_internal_invariants(state, False) ```

This swaps simple pandas indexed dims, but the multi-index that is in the dataset and not affected by the swap_dims op ends up broken.

cc @benbovy

What did you expect to happen?

No response

Minimal Complete Verifiable Example

No response

MVCE confirmation

• [ ] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [ ] Complete example — the example is self-contained, including all data and the text of any traceback.
• [ ] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [ ] New issue — a search of GitHub Issues suggests this is not a duplicate.
• [ ] Recent environment — the issue occurs with the latest version of xarray and its dependencies.

Relevant log output

No response

Anything else we need to know?

No response

Environment

Discussed in https://github.com/pydata/xarray/discussions/8751

What is your issue?

Thanks to @keewis for volunteering at today's meeting :()

What is your issue?

Thanks @TomNicholas for volunteering to drive this release!

What is your issue?

Looks like we can bump a number of min versions: ``` Package Required Policy Status

cartopy 0.20 (2021-09-17) 0.21 (2022-09-10) < dask-core 2022.7 (2022-07-08) 2022.12 (2022-12-02) < distributed 2022.7 (2022-07-08) 2022.12 (2022-12-02) < flox 0.5 (2022-05-03) 0.6 (2022-10-12) < iris 3.2 (2022-02-15) 3.4 (2022-12-01) < matplotlib-base 3.5 (2021-11-18) 3.6 (2022-09-16) < numba 0.55 (2022-01-14) 0.56 (2022-09-28) < numpy 1.22 (2022-01-03) 1.23 (2022-06-23) < packaging 21.3 (2021-11-18) 22.0 (2022-12-08) < pandas 1.4 (2022-01-22) 1.5 (2022-09-19) < scipy 1.8 (2022-02-06) 1.9 (2022-07-30) < seaborn 0.11 (2020-09-08) 0.12 (2022-09-06) < typing_extensions 4.3 (2022-07-01) 4.4 (2022-10-07) < zarr 2.12 (2022-06-23) 2.13 (2022-09-27) < ```

Discussed in https://github.com/pydata/xarray/discussions/8567

The new asv version comes with decorators for parameterizing and skipping, and the ability to use mamba to create environments.

https://github.com/airspeed-velocity/asv/releases

https://asv.readthedocs.io/en/v0.6.1/writing_benchmarks.html#skipping-benchmarks

This might help us reduce benchmark times a bit, or at least simplify the code some.

What happened?

xarray/namedarray/core.py:758: error: Value of type Never is not indexable [index] xarray/core/alignment.py:684: error: Unused "type: ignore" comment [unused-ignore] xarray/core/alignment.py:1156: error: Unused "type: ignore" comment [unused-ignore] xarray/core/dataset.py: note: In member "sortby" of class "Dataset": xarray/core/dataset.py:7967: error: Incompatible types in assignment (expression has type "tuple[Alignable, ...]", variable has type "tuple[DataArray, ...]") [assignment] xarray/core/dataset.py:7979: error: "Alignable" has no attribute "isel" [attr-defined]

What is your issue?

Copying over @max-sixty's comment from https://github.com/pydata/xarray/pull/8304#discussion_r1358873522

I haven't been in touch with the NameArray discussions so forgive a glib comment — but re https://github.com/pydata/xarray/issues/3891 — this would be a "once-in-a-library" opportunity to always retain attrs in aggregations, removing the keep_attrs option in methods.

(Xarray could still handle them as it wished, so xarray's external interface wouldn't need to change immediately...)

@pydata/xarray Should we just delete the keep_attrs kwarg completely for NamedArray and always propagate attrs? obj.attrs.clear() seems just as easy to type.

ideally GroupBy._infer_concat_args() would return a xr.Coordinates object that contains both the coordinate(s) and their (multi-)index to assign to the result (combined) object.

The goal is to avoid calling create_default_index_implicit(coord) below where coord is a pd.MultiIndex or a single IndexVariable wrapping a multi-index. If coord is a Coordinates object, we could do combined = combined.assign_coords(coord) instead.

https://github.com/pydata/xarray/blob/e2b6f3468ef829b8a83637965d34a164bf3bca78/xarray/core/groupby.py#L1573-L1587

There are actually more general issues:

• The group parameter of Dataset.groupby being a single variable or variable name, it won't be possible to do groupby on a full pandas multi-index once we drop its dimension coordinate (#8143). How can we still support it? Maybe passing a dimension name to group and check that there's only one index for that dimension?
• How can we support custom, multi-coordinate indexes with groupby? I don't have any practical example in mind, but in theory just passing a single coordinate name as group will invalidate the index. Should we drop the index in the result? Or, like suggested above pass a dimension name as group and check the index?

Originally posted by @benbovy in https://github.com/pydata/xarray/issues/8140#issuecomment-1709775666

Should say that Y and M cannot be supported with datetime64

Discussed in https://github.com/pydata/xarray/discussions/8000

Is your feature request related to a problem?

flox recently added support for first, last, nanfirst, nanlast. So we should support that on the Xarray GroupBy object.

What happened?

From https://discourse.pangeo.io/t/xarray-unable-to-allocate-memory-how-to-size-up-problem/3233/4

Consider ``` python

ds is dataset with big dask arrays

mean = ds.groupby("time.day").mean() mean.to_netcdf() mean = xr.open_dataset(...)

ds.groupby("time.day") - mean ```

In GroupBy._binary_op https://github.com/pydata/xarray/blob/39caafae4452f5327a7cd671b18d4bb3eb3785ba/xarray/core/groupby.py#L616

we will eagerly construct other that is of the same size as ds.

What did you expect to happen?

I think the only solution is to automatically chunk if ds has dask arrays, and other (or mean) isn't backed by dask arrays. A chunk size of 1 seems sensible.

Minimal Complete Verifiable Example

No response

MVCE confirmation

• [ ] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [ ] Complete example — the example is self-contained, including all data and the text of any traceback.
• [ ] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [ ] New issue — a search of GitHub Issues suggests this is not a duplicate.

Relevant log output

No response

Anything else we need to know?

No response

Environment

What is your issue?

See https://github.com/matplotlib/matplotlib/issues/16296

Looks like the MPL API may have advanced enough that we can delete some of our use of private attributes.

What happened?

```python with xr.set_options(display_style="text", use_flox=False): with xr.set_options(use_flox=False): display( xr.DataArray( data=np.array([np.nan, 1, 1, np.nan, 1, 1]), dims="x", coords={"labels": ("x", np.array([1, 2, 3, 1, 2, 3]))}, ) .groupby("labels") .sum() )

with xr.set_options(use_flox=True):
    display(
        xr.DataArray(
            data=np.array([np.nan, 1, 1, np.nan, 1, 1]),
            dims="x",
            coords={"labels": ("x", np.array([1, 2, 3, 1, 2, 3]))},
        )
        .groupby("labels")
        .sum()
    )

```

```

without flox

<xarray.DataArray (labels: 3)> array([0., 2., 2.]) Coordinates: * labels (labels) int64 1 2 3

with flox

<xarray.DataArray (labels: 3)> array([nan, 2., 2.]) Coordinates: * labels (labels) int64 1 2 3 ```

What did you expect to happen?

The same answer. We should set min_count=0 when min_count is None

Minimal Complete Verifiable Example

No response

MVCE confirmation

• [ ] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [ ] Complete example — the example is self-contained, including all data and the text of any traceback.
• [ ] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [ ] New issue — a search of GitHub Issues suggests this is not a duplicate.

Relevant log output

No response

Anything else we need to know?

No response

Environment

Is your feature request related to a problem?

Scipy 1.10.0 has some great improvements to interpolation (release notes) particularly around the fancier methods like pchip.

It'd be good to see if we can simplify some of our code (or even enable using these options).

Describe the solution you'd like

No response

Describe alternatives you've considered

No response

Additional context

No response

Seen in #4103

MCVE Code Sample

```python from xarray.tests import assert_identical

coord_1 = xr.DataArray([1, 2], dims=["coord_1"], attrs={"attrs": True}) da = xr.DataArray([1, 0], [coord_1]) obj = da.reset_index("coord_1").rename({"coord_1_": "coord_1"}) assert_identical(da, obj) ```

Expected Output

Problem Description

``` AssertionErrorTraceback (most recent call last) <ipython-input-19-02ef6bd89884> in <module> ----> 1 assert_identical(da, obj)

~/work/python/xarray/xarray/tests/init.py in assert_identical(a, b) 160 xarray.testing.assert_identical(a, b) 161 xarray.testing._assert_internal_invariants(a) --> 162 xarray.testing._assert_internal_invariants(b) 163 164

~/work/python/xarray/xarray/testing.py in _assert_internal_invariants(xarray_obj) 265 _assert_variable_invariants(xarray_obj) 266 elif isinstance(xarray_obj, DataArray): --> 267 _assert_dataarray_invariants(xarray_obj) 268 elif isinstance(xarray_obj, Dataset): 269 _assert_dataset_invariants(xarray_obj)

~/work/python/xarray/xarray/testing.py in _assert_dataarray_invariants(da) 210 assert all( 211 isinstance(v, IndexVariable) for (k, v) in da._coords.items() if v.dims == (k,) --> 212 ), {k: type(v) for k, v in da._coords.items()} 213 for k, v in da._coords.items(): 214 _assert_variable_invariants(v, k)

AssertionError: {'coord_1': <class 'xarray.core.variable.Variable'>} ```

Versions

What is your issue?

File roundtripping tests in test_distributed.py don't use the roundtrip context manager (thpugh one uses create_tmp_file) so I don't think any created files are being cleaned up.

Example: https://github.com/pydata/xarray/blob/09e467a6a3a8ed68c6c29647ebf2b09288145da1/xarray/tests/test_distributed.py#L91-L119

Discussed in https://github.com/pydata/xarray/discussions/6738

I think we only describe available options in the API reference for xr.set_options It'd be nice to add a "Configuring Xarray" section in the User Guide.

What is your issue?

@aurghs developed some nice backend tutorial material for the Dask Summit: https://github.com/aurghs/xarray-backend-tutorial

It'd be nice to add it either to our main documentation or to https://github.com/xarray-contrib/xarray-tutorial.

What happened?

From @malmans2

``` python import numpy as np

import xarray as xr

ds = xr.Dataset( dict(a=(("z",), np.ones(10))), coords=dict(b=(("z"), np.arange(2).repeat(5)), c=(("z"), np.arange(5).repeat(2))), ).set_index(bc=["b", "c"]) grouped = ds.groupby("bc")

with xr.set_options(use_flox=False): grouped.sum() # OK

with xr.set_options(use_flox=True): grouped.sum() # Error ```

What did you expect to happen?

No response

Minimal Complete Verifiable Example

No response

MVCE confirmation

• [ ] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [ ] Complete example — the example is self-contained, including all data and the text of any traceback.
• [ ] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [ ] New issue — a search of GitHub Issues suggests this is not a duplicate.

Relevant log output

```Python ctests/test_xarray.py:329: in test_multi_index_groupby_sum actual = xarray_reduce(ds, "bc", func="sum") flox/xarray.py:374: in xarray_reduce actual[k] = v.expand_dims(missing_group_dims) ../xarray/xarray/core/dataset.py:1427: in setitem self.update({key: value}) ../xarray/xarray/core/dataset.py:4432: in update merge_result = dataset_update_method(self, other) ../xarray/xarray/core/merge.py:1070: in dataset_update_method return merge_core( ../xarray/xarray/core/merge.py:722: in merge_core aligned = deep_align( ../xarray/xarray/core/alignment.py:824: in deep_align aligned = align( ../xarray/xarray/core/alignment.py:761: in align aligner.align() ../xarray/xarray/core/alignment.py:550: in align self.assert_unindexed_dim_sizes_equal() ../xarray/xarray/core/alignment.py:450: in assert_unindexed_dim_sizes_equal raise ValueError( E ValueError: cannot reindex or align along dimension 'bc' because of conflicting dimension sizes: {10, 6} (note: an index is found along that dimension with size=10) ____ test_multi_index_groupby_sum[numpy] _______________________________ tests/test_xarray.py:329: in test_multi_index_groupby_sum actual = xarray_reduce(ds, "bc", func="sum") flox/xarray.py:374: in xarray_reduce actual[k] = v.expand_dims(missing_group_dims) ../xarray/xarray/core/dataset.py:1427: in __setitem self.update({key: value}) ../xarray/xarray/core/dataset.py:4432: in update merge_result = dataset_update_method(self, other) ../xarray/xarray/core/merge.py:1070: in dataset_update_method return merge_core( ../xarray/xarray/core/merge.py:722: in merge_core aligned = deep_align( ../xarray/xarray/core/alignment.py:824: in deep_align aligned = align( ../xarray/xarray/core/alignment.py:761: in align aligner.align() ../xarray/xarray/core/alignment.py:550: in align self.assert_unindexed_dim_sizes_equal() ../xarray/xarray/core/alignment.py:450: in assert_unindexed_dim_sizes_equal raise ValueError( E ValueError: cannot reindex or align along dimension 'bc' because of conflicting dimension sizes: {10, 6} (note: an index is found along that dimension with size=10)

Anything else we need to know?

No response

Environment

What is your issue?

It's failing during setup: https://github.com/pydata/xarray/runs/6424624397?check_suite_focus=true

``` · Discovering benchmarks ·· Uninstalling from conda-py3.8-bottleneck-dask-distributed-flox-netcdf4-numpy-numpy_groupies-pandas-scipy-sparse ·· Building dd20d07f for conda-py3.8-bottleneck-dask-distributed-flox-netcdf4-numpy-numpy_groupies-pandas-scipy-sparse ·· Error running /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/bin/python -mpip wheel --no-deps --no-index -w /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/asv-build-cache/dd20d07f4057a9e29222ca132c36cbaaf3fbb242 /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project (exit status 1) STDOUT --------> Processing /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project STDERR --------> ERROR: Some build dependencies for file:///home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project are missing: 'setuptools_scm[toml]>=3.4', 'setuptools_scm_git_archive'.

·· Failed: trying different commit/environment ·· Uninstalling from conda-py3.8-bottleneck-dask-distributed-flox-netcdf4-numpy-numpy_groupies-pandas-scipy-sparse ·· Building c34ef8a6 for conda-py3.8-bottleneck-dask-distributed-flox-netcdf4-numpy-numpy_groupies-pandas-scipy-sparse ·· Error running /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/bin/python -mpip wheel --no-deps --no-index -w /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/asv-build-cache/c34ef8a60227720724e90aa11a6266c0026a812a /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project (exit status 1) STDOUT --------> Processing /home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project STDERR --------> ERROR: Some build dependencies for file:///home/runner/work/xarray/xarray/asv_bench/.asv/env/e8ce5703538597037a298414451d04d2/project are missing: 'setuptools_scm[toml]>=3.4', 'setuptools_scm_git_archive'. ```

Is your feature request related to a problem?

polyval does not handle dask inputs well.

```python nt = 8772 // 4 ny = 489 nx = 655

chunks like the data is stored on disk

small in time, big in space

because the chunk sizes are -1 along lat, lon;

reshaping this array to (time, latlon) prior to fitting is pretty cheap

chunks = (8, -1, -1)

da = xr.DataArray( dask.array.random.random((nt, ny, nx), chunks=chunks), dims=("ocean_time", "eta_rho", "xi_rho"), )

dim = "ocean_time" deg = 1

p = da.polyfit(dim="ocean_time", deg=1, skipna=False)

create a chunked version of the "ocean_time" dimension

chunked_dim = xr.DataArray( dask.array.from_array(da[dim].data, chunks=da.chunksizes[dim]), dims=dim, name=dim ) xr.polyval(chunked_dim, p.polyfit_coefficients) ```

Describe the solution you'd like

Here's a partial solution. It does not handle datetime inputs (polyval handles this using get_clean_interp_index which computes dask inputs). But I've replaced the call to np.vander and used xr.dot.

```python def polyval(coord, coeffs, degree_dim="degree"): x = coord.data

deg_coord = coeffs[degree_dim]
N = int(deg_coord.max()) + 1

lhs = xr.DataArray(
    np.stack([x ** (N - 1 - i) for i in range(N)], axis=1),
    dims=(coord.name, degree_dim),
    coords={coord.name: coord, degree_dim: np.arange(deg_coord.max() + 1)[::-1]},
)
return xr.dot(lhs, coeffs, dims=degree_dim)

polyval(chunked_dim, p.polyfit_coefficients) ```

This looks like what I expected

cc @aulemahal

Describe alternatives you've considered

No response

Additional context

No response

What is your issue?

From @benbovy in https://github.com/pydata/xarray/pull/6477

• extract common indexes and explicitly pass them to the Dataset and DataArray constructors (when implemented) that are called in the broadcast helper functions (there are some temporary and ugly hacks in create_default_index_implicit so that it works now with pandas multi-indexes wrapped in coordinate variables without the need to pass those indexes explicitly)
• extract common indexes based on the dimension(s) of their coordinates and not their name (e.g., case of non-dimension but indexed coordinate)

What happened?

python ds = xr.Dataset( {"a": ("x", [1, 2, 3])}, coords={"c": ("x", [1, 2, 3]), "d": ("y", [1, 2, 3, 4])} ) print(ds.coords) mapped = ds.map(lambda x: x) print(mapped.coords)

Variables d gets dropped in the map call. It does not share any dimensions with any of the data variables. Coordinates: c (x) int64 1 2 3 d (y) int64 1 2 3 4 Coordinates: c (x) int64 1 2 3

What did you expect to happen?

No response

Minimal Complete Verifiable Example

No response

Relevant log output

No response

Anything else we need to know?

No response

Environment

xarray 2022.03.0

What happened?

From https://github.com/pydata/xarray/discussions/6370

Calling apply_ufunc(..., dask="parallelized") with no core dimensions and dask input "works" but raises an error on compute (ValueError: axes don't match array from np.transpose).

python xr.apply_ufunc( lambda x: np.mean(x), dt, dask="parallelized" )

What did you expect to happen?

With numpy data the apply_ufunc call does raise an error:

xr.apply_ufunc( lambda x: np.mean(x), dt.compute(), dask="parallelized" )

ValueError: applied function returned data with unexpected number of dimensions. Received 0 dimension(s) but expected 1 dimensions with names: ('x',)

Minimal Complete Verifiable Example

``` python import xarray as xr

dt = xr.Dataset( data_vars=dict( value=(["x"], [1,1,2,2,2,3,3,3,3,3]), ), coords=dict( lon=(["x"], np.linspace(0,1,10)), ), ).chunk(chunks={'x': tuple([2,3,5])}) # three chunks of different size

xr.apply_ufunc( lambda x: np.mean(x), dt, dask="parallelized" ) ```

Relevant log output

No response

Anything else we need to know?

No response

Environment

N/A

I noticed that we don't test resampling with dask arrays (well just one).

This could be a good opportunity to convert test_groupby.py to use test fixtures like in https://github.com/pydata/xarray/pull/5411

From https://github.com/pydata/xarray/pull/5931

It would be good to add a test checking that custom backend entrypoints work. This might involve creating a dummy package that registers an entrypoint (https://github.com/pydata/xarray/pull/5931#issuecomment-959131968)

Recent dask version support assigning to a list of ints along one dimension. we can use this for unstacking (diff builds on #5577)

```diff diff --git i/xarray/core/variable.py w/xarray/core/variable.py index 222e8dab9..a50dfc574 100644 --- i/xarray/core/variable.py +++ w/xarray/core/variable.py @@ -1593,11 +1593,9 @@ class Variable(AbstractArray, NdimSizeLenMixin, VariableArithmetic): else: dtype = self.dtype

• if sparse:
• if sparse and not is_duck_dask_array(reordered): # unstacking a dense multitindexed array to a sparse array

• Use the sparse.COO constructor until sparse supports advanced indexing

• https://github.com/pydata/sparse/issues/114

• TODO: how do we allow different sparse array types

• Use the sparse.COO constructor since we cannot assign to sparse.COO

       from sparse import COO
  
       codes = zip(*index.codes)
  

  @@ -1618,19 +1616,23 @@ class Variable(AbstractArray, NdimSizeLenMixin, VariableArithmetic): )

   else:
  

  • dask supports assigning to a list of ints along one axis only.

  • So we construct an array with the last dimension flattened,

  • assign the values, then reshape to the final shape.

  • intermediate_shape = reordered.shape[:-1] + (np.prod(new_dim_sizes),)
  • indexer = np.ravel_multi_index(index.codes, new_dim_sizes) data = np.full_like( self.data, fill_value=fill_value,
  • shape=new_shape,

  • shape=intermediate_shape, dtype=dtype, )

     # Indexer is a list of lists of locations. Each list is the locations
     # on the new dimension. This is robust to the data being sparse; in that
     # case the destinations will be NaN / zero.
    

    • sparse doesn't support item assigment,

    • https://github.com/pydata/sparse/issues/114

    • data[(..., *indexer)] = reordered
    • data[(..., indexer)] = reordered
    • data = data.reshape(new_shape)

    return self._replace(dims=new_dims, data=data) ```

This should be what alignment.reindex_variables is doing but I don't fully understand that function.

The annoying bit is figuring out when to use this version and what to do with things like dask wrapping sparse. I think we want to loop over each variable in Dataset.unstack calling Variable.unstack and dispatch based on the type of Variable.data to easily handle all the edge cases.

cc @Illviljan if you're interested in implementing this

This is such a common question that we should address it in the docs.

Just saying that some hdf5 files can be opened with h5netcdf, and that the user needs to manually create xarray objects with everything else should be enough.

https://xarray.pydata.org/en/stable/io.html

Is your feature request related to a problem? Please describe. xarray currently doesn't allow plotting against coordinates with string labels for example.

Describe the solution you'd like Use matplotlib's categorical axis support. Example: https://matplotlib.org/gallery/lines_bars_and_markers/categorical_variables.html

This may be the only place a change is required: https://github.com/pydata/xarray/blob/4e893317240ed1a80e65ea2de107e9179bb65446/xarray/plot/utils.py#L572-L608

I think it would be nice to add a quiver plot function. I got this far in my current project:

``` python @xarray.plot.dataset_plot._dsplot def quiver(ds, x, y, ax, u, v, **kwargs): from xarray import broadcast

if x is None or y is None or u is None or v is None:
    raise ValueError("Must specify x, y, u, v for quiver plots.")

# matplotlib autoscaling algorithm
scale = kwargs.pop("scale", None)
if scale is None:
    npts = ds.dims[x] * ds.dims[y]
    # crude auto-scaling
    # scale is typical arrow length as a multiple of the arrow width
    scale = (
        1.8 * ds.to_array().median().values * np.maximum(10, np.sqrt(npts))
    )  # / span

ds = ds.squeeze()
x, y, u, v = broadcast(ds[x], ds[y], ds[u], ds[v])

# no support for these kwargs right now.
kwargs.pop("cmap_params")
kwargs.pop("hue")
kwargs.pop("hue_style")
hdl = ax.quiver(x.values, y.values, u.values, v.values, scale=scale, **kwargs)

return hdl

```

The autoscaling logic is quite crude; I tried to copy what matplotlib does but got somewhat confused. To get faceting to work properly, we'll need to estimate scale around here: https://github.com/pydata/xarray/blob/a36d0a1d4657c848dcdd76d0ecb9c783ad464057/xarray/plot/facetgrid.py#L339-L343

Can we remove xarray.core.rolling and core.rolling on the left and right respectively? I think the API reference would be a lot more readable if we could do that

Is your feature request related to a problem? Please describe. .encoding is somewhat hidden since we don't show it in a repr.

Describe the solution you'd like I think it'd be nice to add it to the HTML repr, collapsed by default.

pytest -n 4 test_sparse.py results in

``` ====================================================================================== ERRORS ====================================================================================== ___________ ERROR collecting gw0 ___________ Different tests were collected between gw1 and gw0. The difference is: --- gw1

+++ gw0

@@ -11,7 +11,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.any((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.astype((), {'dtype': <class 'int'>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.clip(*(), {'min': 0, 'max': 1})-True] -xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7fc7303f7d08>})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7f6009fa4d08>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.compute(*(), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.conj((), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.copy((), **{})-True] @@ -49,7 +49,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.prod((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.quantile((), {'q': 0.5})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rank(*(), {'dim': 'x'})-False] -xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7fc7303f7d08>, 'dim': 'x'})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7f6009fa4d08>, 'dim': 'x'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rolling_window(*(), {'dim': 'x', 'window': 2, 'window_dim': 'x_win'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.shift((), {'x': 2})-True] xarray/tests/test_sparse.py::test_variable_method[obj.std((), **{})-False] @@ -144,11 +144,11 @@

xarray/tests/test_sparse.py::test_dataarray_method[obj.median((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.min((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.notnull(*(), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7fc7303f7d08>,), {'axis': 1})-True] +xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7f6009fa4d08>,), {'axis': 1})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.prod(*(), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.quantile((), {'q': 0.5})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.rank(('x',), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce(*(<function sum at 0x7fc7303f7d08>,), {'dim': 'x'})-False] +xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce((<function sum at 0x7f6009fa4d08>,), {'dim': 'x'})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.reindex_like((<xarray.DataArray 'test' (x: 10, y: 5)>\n<COO: shape=(10, 5), dtype=float64, nnz=5, fill_value=0.0>\nCoordinates:\n * x (x) float64 0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5\n * y (y) float64 0.5 1.5 2.5 3.5 4.5,), {})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.roll(*(), {'x': 2})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.sel((), *{'x': [0, 1, 2], 'y': [2, 3]})-True] ___________ ERROR collecting gw2 ___________ Different tests were collected between gw1 and gw2. The difference is: --- gw1

+++ gw2

@@ -11,7 +11,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.any((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.astype((), {'dtype': <class 'int'>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.clip(*(), {'min': 0, 'max': 1})-True] -xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7fc7303f7d08>})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7f657c314d08>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.compute(*(), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.conj((), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.copy((), **{})-True] @@ -49,7 +49,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.prod((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.quantile((), {'q': 0.5})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rank(*(), {'dim': 'x'})-False] -xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7fc7303f7d08>, 'dim': 'x'})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7f657c314d08>, 'dim': 'x'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rolling_window(*(), {'dim': 'x', 'window': 2, 'window_dim': 'x_win'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.shift((), {'x': 2})-True] xarray/tests/test_sparse.py::test_variable_method[obj.std((), **{})-False] @@ -118,7 +118,7 @@

xarray/tests/test_sparse.py::test_dataarray_method[obj.sel((), {'x': [0, 1, 2]})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.shift((), {})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.sortby(*('x',), {'ascending': False})-True] -xarray/tests/test_sparse.py::test_dataarray_method[obj.stack((), {'z': {'y', 'x'}})-True] +xarray/tests/test_sparse.py::test_dataarray_method[obj.stack((), {'z': {'x', 'y'}})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.transpose(*(), {})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.broadcast_equals((<xarray.Variable (x: 10, y: 5)>\n<COO: shape=(10, 5), dtype=float64, nnz=5, fill_value=0.0>,), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.equals((<xarray.Variable (x: 10, y: 5)>\n<COO: shape=(10, 5), dtype=float64, nnz=5, fill_value=0.0>,), **{})-False] @@ -144,11 +144,11 @@

xarray/tests/test_sparse.py::test_dataarray_method[obj.median((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.min((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.notnull(*(), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7fc7303f7d08>,), {'axis': 1})-True] +xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7f657c314d08>,), {'axis': 1})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.prod(*(), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.quantile((), {'q': 0.5})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.rank(('x',), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce(*(<function sum at 0x7fc7303f7d08>,), {'dim': 'x'})-False] +xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce((<function sum at 0x7f657c314d08>,), {'dim': 'x'})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.reindex_like((<xarray.DataArray 'test' (x: 10, y: 5)>\n<COO: shape=(10, 5), dtype=float64, nnz=5, fill_value=0.0>\nCoordinates:\n * x (x) float64 0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5\n * y (y) float64 0.5 1.5 2.5 3.5 4.5,), {})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.roll(*(), {'x': 2})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.sel((), *{'x': [0, 1, 2], 'y': [2, 3]})-True] ___________ ERROR collecting gw3 ___________ Different tests were collected between gw1 and gw3. The difference is: --- gw1

+++ gw3

@@ -11,7 +11,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.any((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.astype((), {'dtype': <class 'int'>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.clip(*(), {'min': 0, 'max': 1})-True] -xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7fc7303f7d08>})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.coarsen((), {'windows': {'x': 2}, 'func': <function sum at 0x7f6f284e3d08>})-True] xarray/tests/test_sparse.py::test_variable_method[obj.compute(*(), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.conj((), {})-True] xarray/tests/test_sparse.py::test_variable_method[obj.copy((), **{})-True] @@ -49,7 +49,7 @@

xarray/tests/test_sparse.py::test_variable_method[obj.prod((), {})-False] xarray/tests/test_sparse.py::test_variable_method[obj.quantile((), {'q': 0.5})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rank(*(), {'dim': 'x'})-False] -xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7fc7303f7d08>, 'dim': 'x'})-True] +xarray/tests/test_sparse.py::test_variable_method[obj.reduce((), {'func': <function sum at 0x7f6f284e3d08>, 'dim': 'x'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.rolling_window(*(), {'dim': 'x', 'window': 2, 'window_dim': 'x_win'})-True] xarray/tests/test_sparse.py::test_variable_method[obj.shift((), {'x': 2})-True] xarray/tests/test_sparse.py::test_variable_method[obj.std((), **{})-False] @@ -144,11 +144,11 @@

xarray/tests/test_sparse.py::test_dataarray_method[obj.median((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.min((), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.notnull(*(), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7fc7303f7d08>,), {'axis': 1})-True] +xarray/tests/test_sparse.py::test_dataarray_method[obj.pipe((<function sum at 0x7f6f284e3d08>,), {'axis': 1})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.prod(*(), {})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.quantile((), {'q': 0.5})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.rank(('x',), {})-False] -xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce(*(<function sum at 0x7fc7303f7d08>,), {'dim': 'x'})-False] +xarray/tests/test_sparse.py::test_dataarray_method[obj.reduce((<function sum at 0x7f6f284e3d08>,), {'dim': 'x'})-False] xarray/tests/test_sparse.py::test_dataarray_method[obj.reindex_like((<xarray.DataArray 'test' (x: 10, y: 5)>\n<COO: shape=(10, 5), dtype=float64, nnz=5, fill_value=0.0>\nCoordinates:\n * x (x) float64 0.5 1.5 2.5 3.5 4.5 5.5 6.5 7.5 8.5 9.5\n * y (y) float64 0.5 1.5 2.5 3.5 4.5,), {})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.roll(*(), {'x': 2})-True] xarray/tests/test_sparse.py::test_dataarray_method[obj.sel((), *{'x': [0, 1, 2], 'y': [2, 3]})-True] ================================================================================= warnings summary ================================================================================= /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/client.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/client.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/client.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/client.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/client.py:2: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working from collections import defaultdict, Iterator

/home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/publish.py:1 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/publish.py:1 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/publish.py:1 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/publish.py:1 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/publish.py:1: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working from collections import MutableMapping

/home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2 /home/deepak/miniconda3/envs/dcpy/lib/python3.7/site-packages/distributed/scheduler.py:2: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working from collections import defaultdict, deque, OrderedDict, Mapping, Set

-- Docs: https://docs.pytest.org/en/latest/warnings.html

```

We should list supported options for backend_kwargs in the docstring for open_datasetand possibly in io.rst

xref #4187

TLDR: I think we want A.sel(x=A.x).equals(A) to pass lazily. It doesn't do so currently.

Currently if I do A.sel(x=A.x), this sticks in a getitem call in the dask graph which breaks our lazy array equality optimization. Here's an example

``` python

A = xr.DataArray(np.arange(100), dims="x", coords={"x": np.arange(100)}).chunk({"x": 1}) A.sel(x=A.x).variable.equals(A, equiv=xr.core.duck_array_ops.lazy_array_equiv) None ```

Questions:

1. Where is the best place to do this? In sel or isel? Both? Sticking the following in sel makes the above check return True which is what we want: ``` python if self._indexes: equals = [] for index in indexers: equals.append(indexers[index].to_index().equals(self._indexes[index]))

       if all(equals):
           return self
   

   ```

   This doesn't handle slice objects though so that makes me think we'd want to add something similar to isel too. 2. What is the behaviour we want? A.sel(x=A.x).equals(A) or A.sel(x=A.x) is A? 3. Doing the latter will mean changing _to_temp_dataset and _from_temp_dataset which suggests the constraint A._from_temp_dataset(A._to_temp_dataset()) is A? But this seems too strong to me. Do we only want to lazily satisfy an equals constraint rather than an identical constraint? 4. It seems like we'll want to add such short-circuits in many places (I have not checked all of these): sortby, broadcast, align, reindex (transpose does this now).

We're getting this warning on CI (e.g. https://dev.azure.com/xarray/xarray/_build/results?buildId=2047&view=logs&j=e9c23135-6f4c-5980-91c2-81d28ce70c9b&t=bd167cdf-93c0-5e40-5b11-b5faeb5dc22f)

WARNING: pip is being invoked by an old script wrapper. This will fail in a future version of pip. Please see https://github.com/pypa/pip/issues/5599 for advice on fixing the underlying issue. To avoid this problem you can invoke Python with '-m pip' instead of running pip directly.

cc @crusaderky

What do people think of adding ReviewNB https://www.reviewnb.com/ to facilitate easy reviewing of example notebooks?

This set of lines prevents users from writing files with a handcrafted coordinates attribute. This is useful when not all non-dimensional coordinates in a Dataset are appropriate for every data variable in a dataset.

https://github.com/pydata/xarray/blob/16fdac93c09036b44f90201d9078b17808f819e0/xarray/conventions.py#L667-L675

It seems to me like we should only automatically set "coordinates" when "coordinates" not in attrs. We could raise a warning saying that setting attrs["coordinates"] prevents full roundtripping of Datasets.

What do you think?

Just making a new issue for #3598

The tests for https://github.com/pydata/xarray/pull/3584 fail on dask == 2.8.1 with this interesting bug. Here's a reproducible example.

``` python import dask import xarray as xr

ds = xr.Dataset({'x': (('y',), dask.array.ones(10, chunks=(3,)))}) mapped = ds.map_blocks(lambda x: x) mapped.compute() # works

xr.testing.assert_equal(mapped, ds) # does not work xr.testing.assert_equal(mapped, ds.compute()) # works xr.testing.assert_equal(mapped.compute(), ds) # works xr.testing.assert_equal(mapped.compute(), ds.compute()) # works ```

The traceback is ``` ~/miniconda3/envs/dcpy/lib/python3.7/site-packages/dask/array/optimization.py in optimize(dsk, keys, fuse_keys, fast_functions, inline_functions_fast_functions, rename_fused_keys, **kwargs) 41 if isinstance(dsk, HighLevelGraph): 42 dsk = optimize_blockwise(dsk, keys=keys) ---> 43 dsk = fuse_roots(dsk, keys=keys) 44 45 # Low level task optimizations

~/miniconda3/envs/dcpy/lib/python3.7/site-packages/dask/blockwise.py in fuse_roots(graph, keys) 819 isinstance(layer, Blockwise) 820 and len(deps) > 1 --> 821 and not any(dependencies[dep] for dep in deps) # no need to fuse if 0 or 1 822 and all(len(dependents[dep]) == 1 for dep in deps) 823 ):

~/miniconda3/envs/dcpy/lib/python3.7/site-packages/dask/blockwise.py in <genexpr>(.0) 819 isinstance(layer, Blockwise) 820 and len(deps) > 1 --> 821 and not any(dependencies[dep] for dep in deps) # no need to fuse if 0 or 1 822 and all(len(dependents[dep]) == 1 for dep in deps) 823 ):

KeyError: 'lambda-6720ab0e3639d5c63fc06dfc66a3ce47-x' ```

This key is not in dependencies. From https://github.com/dask/dask/blob/67fb5363009c583c175cb577776a4f2f4e811410/dask/blockwise.py#L816-L826

python for name, layer in graph.layers.items(): deps = graph.dependencies[name] if ( isinstance(layer, Blockwise) and len(deps) > 1 and not any(dependencies[dep] for dep in deps) # no need to fuse if 0 or 1 and all(len(dependents[dep]) == 1 for dep in deps) ): new = toolz.merge(layer, *[layers[dep] for dep in deps]) new, _ = fuse(new, keys, ave_width=len(deps))

I'm not sure whether this is a bug in fuse_roots, HighLevelGraph.from_collections or in how map_blocks calls HighLevelGraph.from_collections here: https://github.com/pydata/xarray/blob/69c85b85a1ef5d13b6ca51b6b655a1f719cc5abf/xarray/core/parallel.py#L315

Currently merge.unique_variable does this

if equals is None: out = out.compute() for var in variables[1:]: equals = getattr(out, compat)(var) if not equals: break

out (=variables[0]) is always computed though it may not be necessary.

One solution would be to loop through once checking attrs, shapes and _data. If these checks were satisfied, then we execute the above code

This passes locally with h5py==2.9.0 but the CI is running h5py==2.10.0. It's probably issuing an extra warning.

``` =================================== FAILURES =================================== ___ TestH5NetCDFData.test_complex[None-FutureWarning-1] ______

self = <xarray.tests.test_backends.TestH5NetCDFData object at 0x7f4509fac358> invalid_netcdf = None, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError ___ TestH5NetCDFData.test_complex[False-FutureWarning-1] _____

self = <xarray.tests.test_backends.TestH5NetCDFData object at 0x7f450a96c748> invalid_netcdf = False, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError ___ TestH5NetCDFData.testcomplex[True-None-0] ____

self = <xarray.tests.test_backends.TestH5NetCDFData object at 0x7f450aa69be0> invalid_netcdf = True, warns = None, num_warns = 0

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 1 == 0 E + where 1 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError _ TestH5NetCDFFileObject.testcomplex[None-FutureWarning-1] ___

self = <xarray.tests.test_backends.TestH5NetCDFFileObject object at 0x7f4509e1a8d0> invalid_netcdf = None, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError _ TestH5NetCDFFileObject.testcomplex[False-FutureWarning-1] __

self = <xarray.tests.test_backends.TestH5NetCDFFileObject object at 0x7f4509c749e8> invalid_netcdf = False, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError __ TestH5NetCDFFileObject.test_complex[True-None-0] __

self = <xarray.tests.test_backends.TestH5NetCDFFileObject object at 0x7f450afe69b0> invalid_netcdf = True, warns = None, num_warns = 0

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 1 == 0 E + where 1 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError _ TestH5NetCDFViaDaskData.testcomplex[None-FutureWarning-1] __

self = <xarray.tests.test_backends.TestH5NetCDFViaDaskData object at 0x7f4509fa0c18> invalid_netcdf = None, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError ___ TestH5NetCDFViaDaskData.test_complex[False-FutureWarning-1] ____

self = <xarray.tests.test_backends.TestH5NetCDFViaDaskData object at 0x7f4509e45e10> invalid_netcdf = False, warns = <class 'FutureWarning'>, num_warns = 1

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 2 == 1 E + where 2 = len(WarningsChecker(record=True))

xarray/tests/test_backends.py:2185: AssertionError __ TestH5NetCDFViaDaskData.test_complex[True-None-0] ___

self = <xarray.tests.test_backends.TestH5NetCDFViaDaskData object at 0x7f450aa3f668> invalid_netcdf = True, warns = None, num_warns = 0

@pytest.mark.filterwarnings("ignore:complex dtypes are supported by h5py")
@pytest.mark.parametrize(
    "invalid_netcdf, warns, num_warns",
    [(None, FutureWarning, 1), (False, FutureWarning, 1), (True, None, 0)],
)
def test_complex(self, invalid_netcdf, warns, num_warns):
    expected = Dataset({"x": ("y", np.ones(5) + 1j * np.ones(5))})
    save_kwargs = {"invalid_netcdf": invalid_netcdf}
    with pytest.warns(warns) as record:
        with self.roundtrip(expected, save_kwargs=save_kwargs) as actual:
            assert_equal(expected, actual)

  assert len(record) == num_warns

E assert 1 == 0 E + where 1 = len(WarningsChecker(record=True)) ```

It would be nice to have a separate page that detailed this for users unfamiliar with netCDF.

We're seeing a lot of errors in the docs build on Travis though the build is reported successful?!

https://travis-ci.org/pydata/xarray/jobs/468535214