The following code creates a small (100x100) chunked DataArray, and then re-indexes it into a huge one (100000x100000):

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

n = 100 x = np.arange(n) y = np.arange(n) da = xr.DataArray(np.zeros(n*n).reshape(n, n), coords=[x, y], dims=['x', 'y']).chunk(n, n)

n2 = 100000 x2 = np.arange(n2) y2 = np.arange(n2) da2 = da.reindex({'x': x2, 'y': y2}) da2 ```

But the re-indexed DataArray has chunksize=(100000, 100000) instead of chunksize=(100, 100):

<xarray.DataArray (x: 100000, y: 100000)> dask.array<shape=(100000, 100000), dtype=float64, chunksize=(100000, 100000)> Coordinates: * x (x) int64 0 1 2 3 4 5 6 ... 99994 99995 99996 99997 99998 99999 * y (y) int64 0 1 2 3 4 5 6 ... 99994 99995 99996 99997 99998 99999

Which immediately leads to a memory error when trying to e.g. store it to a zarr archive:

python ds2 = da2.to_dataset(name='foo') ds2.to_zarr(store='foo', mode='w')

Trying to re-chunk to 100x100 before storing it doesn't help, but this time it takes a lot more time before crashing with a memory error:

python da3 = da2.chunk(n, n) ds3 = da3.to_dataset(name='foo') ds3.to_zarr(store='foo', mode='w')

What happened?

There used to be a xarray.core.rolling, and the documentation suggests it still exists, but with xarray-2022.6.0 I get: module xarray.core has no attribute rolling. It works with xarray-2022.3.0.

What did you expect to happen?

Shouldn't we be able to access xarray.core.rolling?

Minimal Complete Verifiable Example

```Python import xarray as xr

xr.core.rolling

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: module 'xarray.core' has no attribute 'rolling'

```

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

```python import xarray as xr

da = xr.DataArray(['foo']) ds = da.to_dataset(name='da') ds.to_zarr('ds') # no special encoding specified

ds = xr.open_zarr('ds') print(ds.da.values) ```

The following code prints ['foo'] (string type). The encoding chosen by zarr is "dtype": "|S3", which corresponds to bytes, but it seems to be decoded to a string, which is what we want.

$ cat ds/da/.zarray { "chunks": [ 1 ], "compressor": { "blocksize": 0, "clevel": 5, "cname": "lz4", "id": "blosc", "shuffle": 1 }, "dtype": "|S3", "fill_value": null, "filters": null, "order": "C", "shape": [ 1 ], "zarr_format": 2 }

The problem is that if I want to append to the zarr archive, like so:

```python import zarr

ds = zarr.open('ds', mode='a') da_new = xr.DataArray(['barbar']) ds.da.append(da_new)

ds = xr.open_zarr('ds') print(ds.da.values) ```

It prints ['foo' 'bar']. Indeed the encoding was kept as "dtype": "|S3", which is fine for a string of 3 characters but not for 6.

If I want to specify the encoding with the maximum length, e.g:

python ds.to_zarr('ds', encoding={'da': {'dtype': '|S6'}})

It solves the length problem, but now my strings are kept as bytes: [b'foo' b'barbar']. If I specify a Unicode encoding:

python ds.to_zarr('ds', encoding={'da': {'dtype': 'U6'}})

It is not taken into account. The zarr encoding is "dtype": "|S3" and I am back to my length problem: ['foo' 'bar'].

The solution with 'dtype': '|S6' is acceptable, but I need to encode my strings to bytes when indexing, which is annoying.

MCVE Code Sample

```python import xarray as xr

da = xr.DataArray(1) da.attrs['foo'] = 'bar' xr.where(da==0, -1, da).attrs

shows: {}

```

Expected Output

{'foo': 'bar'}

Problem Description

I would expect the attributes to remain in the data array.

Versions

When e.g. creating a Dataset from multiple DataArrays that are supposed to share the same grid, but are not exactly aligned (as is often the case with floating point coordinates), we usually end up with undesirable NaNs inserted in the data set. For instance, consider the following data arrays that are not exactly aligned: ```python import xarray as xr

da1 = xr.DataArray([[0, 1, 2], [3, 4, 5], [6, 7, 8]], coords=[[0, 1, 2], [0, 1, 2]], dims=['x', 'y']).rename('da1') da2 = xr.DataArray([[0, 1, 2], [3, 4, 5], [6, 7, 8]], coords=[[1.1, 2.1, 3.1], [1.1, 2.1, 3.1]], dims=['x', 'y']).rename('da2') da1.plot.imshow() da2.plot.imshow() ![image](https://user-images.githubusercontent.com/4711805/103482830-542bbe80-4de3-11eb-814b-bb1f705967c4.png) ![image](https://user-images.githubusercontent.com/4711805/103482836-61e14400-4de3-11eb-804b-f549c2551562.png) They show gaps when combined in a data set:python ds = xr.Dataset({'da1': da1, 'da2': da2}) ds['da1'].plot.imshow() ds['da2'].plot.imshow() ![image](https://user-images.githubusercontent.com/4711805/103482959-3f9bf600-4de4-11eb-9513-900319cb485a.png) ![image](https://user-images.githubusercontent.com/4711805/103482966-47f43100-4de4-11eb-853b-2b44f7bc8d7f.png) I think this is a frequent enough situation that we would like a function to re-align all the data arrays together. There is a `reindex_like` method, which accepts a tolerance, but calling it successively on every data array, like so:python da1r = da1.reindex_like(da2, method='nearest', tolerance=0.2) da2r = da2.reindex_like(da1r, method='nearest', tolerance=0.2) ``` would result in the intersection of the coordinates, rather than their union. What I would like is a function like the following:

```python import numpy as np from functools import reduce

def reindex_all(arrays, dims, tolerance): coords = {} for dim in dims: coord = reduce(np.union1d, [array[dim] for array in arrays[1:]], arrays[0][dim]) diff = coord[:-1] - coord[1:] keep = np.abs(diff) > tolerance coords[dim] = np.append(coord[:-1][keep], coord[-1]) reindexed = [array.reindex(coords, method='nearest', tolerance=tolerance) for array in arrays] return reindexed

da1r, da2r = reindex_all([da1, da2], ['x', 'y'], 0.2) dsr = xr.Dataset({'da1': da1r, 'da2': da2r}) dsr['da1'].plot.imshow() dsr['da2'].plot.imshow() ``` I have not found something equivalent. If you think this is worth it, I could try and send a PR to implement such a feature.

Code Sample

```python import numpy as np import xarray as xr import matplotlib.pyplot as plt %matplotlib inline

a = np.ones((4000, 4000), dtype=np.uint8) a[:1000, :1000] = 0 lat = np.array([0-i for i in range(a.shape[0])]) lon = np.array([0+i for i in range(a.shape[1])]) da = xr.DataArray(a, coords=[lat, lon], dims=['lat', 'lon'])

da.plot.pcolormesh() ```

Problem description

The code above shows an empty plot in a notebook (but not in the console).

Expected Output

If I replace da.plot.pcolormesh() with da.plot.imshow() or plt.pcolormesh(a), it works fine. Also, if I decrease the size of the array, it works.

Output of xr.show_versions()

I would like to concatenate many DataArray whose dimension coordinates are almost aligned, allowing for some offset in the coordinates:

python import xarray as xr da1 = xr.DataArray([[0, 1], [2, 3]], coords=[[0, 1], [0, 1]], dims=['x', 'y']) da2 = xr.DataArray([[4, 5], [6, 7]], coords=[[1.1, 2.1], [1.1, 2.1]], dims=['x', 'y']) da = xr.concat([da1, da2], 'z', method='nearest', tolerance=0.2) # doesn't exist yet da

And I would get:

``` <xarray.DataArray (z: 2, x: 3, y: 3)> array([[[ 0., 1., nan], [ 2., 3., nan], [nan, nan, nan]],

   [[nan, nan, nan],
    [nan,  4.,  5.],
    [nan,  6.,  7.]]])

Coordinates: * x (x) float64 0 1 2.1 * y (y) float64 0 1 2.1 Dimensions without coordinates: z ```

@jhamman suggested to use reindex_like in this StackOverflow question, but it doesn't produce the union of coordinates, so I cannot chain them like this:

python da2 = da2.reindex_like(da1, method='nearest', tolerance=0.2)

Is there another work around? Do you think it would be worth having this feature in concat?

• [x] Closes #3100
• [x] Tests updated
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

When appending to a zarr store, we need to set append_dim=dim_name but also mode='a'. Any reason to also specify the writing mode? I think it should automatically be set to 'a' if append_dim is not None.

rechunk is not a methode of DataArray or Dataset, chunk does rechunk.

MCVE Code Sample

```python In [1]: import numpy as np ...: import pandas as pd ...: import xarray as xr

In [2]: da = xr.DataArray([1, 2], [('time', pd.date_range('2000-01-01', '2000-01-02', periods=2))]) ...: da
Out[2]: <xarray.DataArray (time: 2)> array([1, 2]) Coordinates: * time (time) datetime64[ns] 2000-01-01 2000-01-02

In [3]: da.interp(time=da.time-np.timedelta64(1, 'D'))
Out[3]: <xarray.DataArray (time: 2)> array([nan, 1.]) Coordinates: * time (time) datetime64[ns] 2000-01-01 2000-01-02 ```

Problem Description

The data has been interpolated, but not the time coordinate.

Expected Output

When we explicitly get the values of the time coordinate, it works fine:

python In [4]: da.interp(time=da.time.values-np.timedelta64(1, 'D')) Out[4]: <xarray.DataArray (time: 2)> array([nan, 1.]) Coordinates: * time (time) datetime64[ns] 1999-12-31 2000-01-01

Output of xr.show_versions()

For instance in http://xarray.pydata.org/en/stable/generated/xarray.apply_ufunc.html, there is no space between the parameters and their type description, e.g. funccallable instead of func : callable.

When using coarsen, we often need to align the original DataArray with the coarser coordinates. For instance: ```python import xarray as xr import numpy as np

da = xr.DataArray(np.arange(4*4).reshape(4, 4), coords=[np.arange(4, 0, -1) + 0.5, np.arange(4) + 0.5], dims=['lat', 'lon'])

<xarray.DataArray (lat: 4, lon: 4)>

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11],

[12, 13, 14, 15]])

Coordinates:

* lat (lat) float64 4.5 3.5 2.5 1.5

* lon (lon) float64 0.5 1.5 2.5 3.5

da.coarsen(lat=2, lon=2).mean()

<xarray.DataArray (lat: 2, lon: 2)>

array([[ 2.5, 4.5],

[10.5, 12.5]])

Coordinates:

* lat (lat) float64 4.0 2.0

* lon (lon) float64 1.0 3.0

But if the coarser coordinates are aligned like: lat: ... 5 3 1 ... lon: ... 1 3 5 ... Then directly applying `coarsen` will not work (here on the `lat` dimension). The following function extends the original DataArray so that it is aligned with the coarser coordinates:python def adjust_bbox(da, dims): """Adjust the bounding box of a DaskArray to a coarser resolution.

Args:
    da: the DaskArray to adjust.
    dims: a dictionary where keys are the name of the dimensions on which to adjust, and the values are of the form [unsigned_coarse_resolution, signed_original_resolution]
Returns:
    The DataArray bounding box adjusted to the coarser resolution.
"""
coords = {}
for k, v in dims.items():
    every, step = v
    offset = step / 2
    dim0 = da[k].values[0] - offset
    dim1 = da[k].values[-1] + offset
    if step < 0: # decreasing coordinate
        dim0 = dim0 + (every - dim0 % every) % every
        dim1 = dim1 - dim1 % every
    else: # increasing coordinate
        dim0 = dim0 - dim0 % every
        dim1 = dim1 + (every - dim1 % every) % every
    coord0 = np.arange(dim0+offset, da[k].values[0]-offset, step)
    coord1 = da[k].values
    coord2 = np.arange(da[k].values[-1]+step, dim1, step)
    coord = np.hstack((coord0, coord1, coord2))
    coords[k] = coord
return da.reindex(**coords).fillna(0)

da = adjust_bbox(da, {'lat': (2, -1), 'lon': (2, 1)})

<xarray.DataArray (lat: 6, lon: 4)>

array([[ 0., 0., 0., 0.],

[ 0., 1., 2., 3.],

[ 4., 5., 6., 7.],

[ 8., 9., 10., 11.],

[12., 13., 14., 15.],

[ 0., 0., 0., 0.]])

Coordinates:

* lat (lat) float64 5.5 4.5 3.5 2.5 1.5 0.5

* lon (lon) float64 0.5 1.5 2.5 3.5

da.coarsen(lat=2, lon=2).mean()

<xarray.DataArray (lat: 3, lon: 2)>

array([[0.25, 1.25],

[6.5 , 8.5 ],

[6.25, 7.25]])

Coordinates:

* lat (lat) float64 5.0 3.0 1.0

* lon (lon) float64 1.0 3.0

`` Nowcoarsengives the right result. Butadjust_bbox` is rather complicated and specific to this use case (evenly spaced coordinate points...). Do you know of a better/more general way of doing it?