What happened?

Setup

I want to calculate image statistics per chunk in one dimension. Let's assume a very small image for demonstration purposes:

python a = xr.DataArray(np.arange(12).reshape(6,2), dims=('x', 'y')) a Trying to chunk this into three subimages, I use these bins into the x dimension: python x_bins = (0, 2, 4, 6) I look at the groups this creates by default: python for iv, g in a.groupby_bins('x', x_bins): print(iv) print(g) I don't understand the use-case for this grouping, as it's missing the beginning and is having uneven sized last group (Obviously a follow-error from not including the first row).

To force the even chunking of the image I need to call it with these parameters: python groups = a.groupby_bins('x', x_bins, include_lowest=True, right=False) for iv, g in groups: print(iv) print(g)

Issue

But now, calculating the mean value of each group, I get different results when doing it by hand using the groups or doing it using the groups inherent method mean():

Indeed, I verified, that these results are what one gets, using the first version of applying the bins:

The same is true when I use the elliptical operator to receive the mean over the remaining dimensions (note, the 2nd cell here is using the groups variable as defined in the cell before, so should really return the same values, but it doesn't:

Application

I believe that groupby_bins is the most appropriate tool to do this in xarray. I wished that one could enforce the dask-chunks in dask arrays to survive and return stats from them, but haven't found a way to do that.

What did you expect to happen?

That the inherent stats methods of the groups method respect the interval use constraints from the groupby_bins call.

I also have verified that the same problem exists with groups.std().

Minimal Complete Verifiable Example

```Python import xarray as xr import numpy as np

a = xr.DataArray(np.arange(12).reshape(6,2), dims=('x', 'y'))

x_bins = (0, 2, 4, 6)

default_groups = a.groupby_bins('x', x_bins) my_groups = a.groupby_bins('x', x_bins, include_lowest=True, right=False)

print("Weird grouping using default call:") for iv, g in default_groups: print("Interval:",iv) print(g.data) print()

print("Evenly chunked using my_groups:")
for iv, g in my_groups: print("Interval:", iv) print(g.data) print()

print("Calculating mean on my own using loop over groups:") for iv, g in my_groups: print(g.mean('x').data)

print("Calculting same using my_groups.mean()") print("No dim given:") print(my_groups.mean().data.T) print("using mean('x'):") print(my_groups.mean('x').data.T)

print("These results come from the default groups!:") for iv, g in default_groups: print(g.mean('x').data)

print("STD has the same issue") ```

MVCE confirmation

• [X] Minimal example — the example is as focused as reasonably possible to demonstrate the underlying issue in xarray.
• [X] Complete example — the example is self-contained, including all data and the text of any traceback.
• [X] Verifiable example — the example copy & pastes into an IPython prompt or Binder notebook, returning the result.
• [X] 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 happened:

Testing xarray data storage in a jupyter notebook with varying data sizes and storing to a netcdf, i noticed that open_dataset/array (both show this behaviour) continue to return data from the first testing run, ignoring the fact that each run deletes the previously created netcdf file. This only happens once the repr was used to display the xarray object. But once in error mode, even the previously fine printed objects are then showing the wrong data.

This was hard to track down as it depends on the precise sequence in jupyter.

What you expected to happen:

when i use open_dataset/array, the resulting object should reflect reality on disk.

Minimal Complete Verifiable Example:

```python import xarray as xr from pathlib import Path import numpy as np

def test_repr(nx): ds = xr.DataArray(np.random.rand(nx)) path = Path("saved_on_disk.nc") if path.exists(): path.unlink() ds.to_netcdf(path) return path ```

When executed in a cell with print for display, all is fine: python test_repr(4) print(xr.open_dataset("saved_on_disk.nc")) test_repr(5) print(xr.open_dataset("saved_on_disk.nc"))

but as soon as one cell used the jupyter repr:

python xr.open_dataset("saved_on_disk.nc")

all future file reads, even after executing the test function again and even using print and not repr, show the data from the last repr use.

Anything else we need to know?:

Here's a notebook showing the issue: https://gist.github.com/05c2542ed33662cdcb6024815cc0c72c

Environment:

• [x] Closes #4229
• [x] Tests added
• [ ] Passes isort -rc . && black . && mypy . && flake8
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst

Issue description

The overly long output of the text repr of xarray always bugged so I was very happy that the recently implemented html repr collapsed the data part, and equally sad to see that 0.16.0 reverted that, IMHO, correct design implementation back, presumably to align it with the text repr.

Suggested solution

As the opinions will vary on what a good repr should do, similar to existing xarray.set_options I would like to have an option that let's me control if the data part (and maybe other parts?) appear in a collapsed fashion for the html repr.

Additional questions

• Is it worth considering this as well for the text repr? Or is that harder to implement?

Any guidance on * which files need to change * potential pitfalls

would be welcome. I'm happy to work on this, as I seem to be the only one not liking the current implementation.

What happened:

accessing variable attribute seems to work but also throws an AttributeError:

AttributeError: 'Variable' object has no attribute 'variable'

What you expected to happen:

According to https://xarray.pydata.org/en/stable/terminology.html all DataArrays should have "an underlying variable that can be accessed via arr.vairable", so I tried that out and got the error.

Minimal Complete Verifiable Example:

Using the example code from the docs: python data = xr.DataArray(np.random.randn(2, 3), dims=('x', 'y'), coords={'x': [10, 20]}) data.variable

Environment: Python 3.7 on Kubuntu 20.04 using Brave browser in Jupyterlab, up-to-date conda env.