Clean up a little in preparation for #6059.

• [ ] 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

xref: #6244

Make #6239 cleaner by running pyupgrade separately.

pyupgrade fixes typing only if from __future__ import annotations has been manually added to the file. Could probably do this in other files as well.

xref: #6244

Activate typing on these mixins by removing the Any.

• [ ] 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

This removes the need for the # type: ignore to make mypy happy. It is also clearer when this compatibillity code can be removed.

Inspired by #5734, remove the non-bottleneck build and instead use xr.set_options on the relevant tests. This makes the report much more readable and reduces testing time quite a bit since everything isn't accelerated by bottleneck.

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

When there's a lot of dims, create a new line and continue printing. If there's even more dims that even a few rows can't display them all then limit the number of dims displayed in similar fashion to coordinates.

Questions: * Where should this be used? Datasets, dataarrays, dimensions without coords? * Should dim_summary_limited be a straight replacement for dim_summary? I'm not super familiar with all the places it is used so I'm unsure. * Should we print the number of dims shown and the total number of dims? If yes, then we need to rethink how the dimensions are displayed, as it's not possible with the current style. See the example with short names.

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

Test case: ```python import numpy as np import xarray as xr

A few dims with long names:

a = np.arange(0, 24) data_vars = dict() for i in a: data_vars[f"long_variable_name_{i}"] = xr.DataArray( name=f"long_variable_name_{i}", data=np.arange(0, 20), dims=[f"long_coord_name_{i}x"], coords={f"long_coord_name{i}x": np.arange(0, 20) * 2}, ) ds0 = xr.Dataset(data_vars) ds0.attrs = {f"attr{k}": 2 for k in a}

print(ds0) <xarray.Dataset> Dimensions: (long_coord_name_0_x: 20, long_coord_name_10_x: 20, long_coord_name_11_x: 20, long_coord_name_12_x: 20, long_coord_name_13_x: 20, long_coord_name_14_x: 20, long_coord_name_15_x: 20, long_coord_name_16_x: 20, long_coord_name_17_x: 20, long_coord_name_18_x: 20, long_coord_name_19_x: 20, long_coord_name_1_x: 20, long_coord_name_20_x: 20, long_coord_name_21_x: 20, long_coord_name_22_x: 20, long_coord_name_23_x: 20, long_coord_name_2_x: 20, long_coord_name_3_x: 20, long_coord_name_4_x: 20, long_coord_name_5_x: 20, long_coord_name_6_x: 20, long_coord_name_7_x: 20, long_coord_name_8_x: 20, long_coord_name_9_x: 20) Coordinates: (12/24) * long_coord_name_0_x (long_coord_name_0_x) int32 0 2 4 6 8 ... 32 34 36 38 * long_coord_name_1_x (long_coord_name_1_x) int32 0 2 4 6 8 ... 32 34 36 38 * long_coord_name_2_x (long_coord_name_2_x) int32 0 2 4 6 8 ... 32 34 36 38 * long_coord_name_3_x (long_coord_name_3_x) int32 0 2 4 6 8 ... 32 34 36 38 * long_coord_name_4_x (long_coord_name_4_x) int32 0 2 4 6 8 ... 32 34 36 38 * long_coord_name_5_x (long_coord_name_5_x) int32 0 2 4 6 8 ... 32 34 36 38 ... * long_coord_name_18_x (long_coord_name_18_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_19_x (long_coord_name_19_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_20_x (long_coord_name_20_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_21_x (long_coord_name_21_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_22_x (long_coord_name_22_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_23_x (long_coord_name_23_x) int32 0 2 4 6 ... 32 34 36 38 Data variables: (12/24) long_variable_name_0 (long_coord_name_0_x) int32 0 1 2 3 4 ... 16 17 18 19 long_variable_name_1 (long_coord_name_1_x) int32 0 1 2 3 4 ... 16 17 18 19 long_variable_name_2 (long_coord_name_2_x) int32 0 1 2 3 4 ... 16 17 18 19 long_variable_name_3 (long_coord_name_3_x) int32 0 1 2 3 4 ... 16 17 18 19 long_variable_name_4 (long_coord_name_4_x) int32 0 1 2 3 4 ... 16 17 18 19 long_variable_name_5 (long_coord_name_5_x) int32 0 1 2 3 4 ... 16 17 18 19 ... long_variable_name_18 (long_coord_name_18_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_19 (long_coord_name_19_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_20 (long_coord_name_20_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_21 (long_coord_name_21_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_22 (long_coord_name_22_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_23 (long_coord_name_23_x) int32 0 1 2 3 ... 16 17 18 19 Attributes: (12/24) attr_0: 2 attr_1: 2 attr_2: 2 attr_3: 2 attr_4: 2 attr_5: 2 ... attr_18: 2 attr_19: 2 attr_20: 2 attr_21: 2 attr_22: 2 attr_23: 2 ```

```python

Many dims with long names:

a = np.arange(0, 200) data_vars = dict() for i in a: data_vars[f"long_variable_name_{i}"] = xr.DataArray( name=f"long_variable_name_{i}", data=np.arange(0, 20), dims=[f"long_coord_name_{i}x"], coords={f"long_coord_name{i}x": np.arange(0, 20) * 2}, ) ds1 = xr.Dataset(data_vars) ds1.attrs = {f"attr{k}": 2 for k in a}

print(ds1) <xarray.Dataset> Dimensions: (long_coord_name_0_x: 20, long_coord_name_100_x: 20, long_coord_name_101_x: 20, long_coord_name_102_x: 20, long_coord_name_103_x: 20, long_coord_name_104_x: 20, ... long_coord_name_94_x: 20, long_coord_name_95_x: 20, long_coord_name_96_x: 20, long_coord_name_97_x: 20, long_coord_name_98_x: 20, long_coord_name_99_x: 20, long_coord_name_9_x: 20) Coordinates: (12/200) * long_coord_name_0_x (long_coord_name_0_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_1_x (long_coord_name_1_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_2_x (long_coord_name_2_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_3_x (long_coord_name_3_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_4_x (long_coord_name_4_x) int32 0 2 4 6 ... 32 34 36 38 * long_coord_name_5_x (long_coord_name_5_x) int32 0 2 4 6 ... 32 34 36 38 ... * long_coord_name_194_x (long_coord_name_194_x) int32 0 2 4 6 ... 34 36 38 * long_coord_name_195_x (long_coord_name_195_x) int32 0 2 4 6 ... 34 36 38 * long_coord_name_196_x (long_coord_name_196_x) int32 0 2 4 6 ... 34 36 38 * long_coord_name_197_x (long_coord_name_197_x) int32 0 2 4 6 ... 34 36 38 * long_coord_name_198_x (long_coord_name_198_x) int32 0 2 4 6 ... 34 36 38 * long_coord_name_199_x (long_coord_name_199_x) int32 0 2 4 6 ... 34 36 38 Data variables: (12/200) long_variable_name_0 (long_coord_name_0_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_1 (long_coord_name_1_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_2 (long_coord_name_2_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_3 (long_coord_name_3_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_4 (long_coord_name_4_x) int32 0 1 2 3 ... 16 17 18 19 long_variable_name_5 (long_coord_name_5_x) int32 0 1 2 3 ... 16 17 18 19 ... long_variable_name_194 (long_coord_name_194_x) int32 0 1 2 3 ... 17 18 19 long_variable_name_195 (long_coord_name_195_x) int32 0 1 2 3 ... 17 18 19 long_variable_name_196 (long_coord_name_196_x) int32 0 1 2 3 ... 17 18 19 long_variable_name_197 (long_coord_name_197_x) int32 0 1 2 3 ... 17 18 19 long_variable_name_198 (long_coord_name_198_x) int32 0 1 2 3 ... 17 18 19 long_variable_name_199 (long_coord_name_199_x) int32 0 1 2 3 ... 17 18 19 Attributes: (12/200) attr_0: 2 attr_1: 2 attr_2: 2 attr_3: 2 attr_4: 2 attr_5: 2 ... attr_194: 2 attr_195: 2 attr_196: 2 attr_197: 2 attr_198: 2 attr_199: 2 ```

```python

Many dims with short names:

data_vars = dict() for i in a: data_vars[f"n_{i}"] = xr.DataArray( name=f"n_{i}", data=np.arange(0, 20), dims=[f"{i}x"], coords={f"{i}_x": np.arange(0, 20) * 2}, ) ds2 = xr.Dataset(data_vars) ds2.attrs = {f"attr{k}": 2 for k in a}

print(ds2) <xarray.Dataset> Dimensions: (0_x: 20, 100_x: 20, 101_x: 20, 102_x: 20, 103_x: 20, 104_x: 20, 105_x: 20, 106_x: 20, 107_x: 20, 108_x: 20, 109_x: 20, 10_x: 20, 110_x: 20, 111_x: 20, 112_x: 20, 113_x: 20, 114_x: 20, 115_x: 20, 116_x: 20, 117_x: 20, 118_x: 20, 119_x: 20, 11_x: 20, 120_x: 20, 121_x: 20, 122_x: 20, 123_x: 20, 124_x: 20, 125_x: 20, 126_x: 20, 127_x: 20, 128_x: 20, 129_x: 20, 12_x: 20, 130_x: 20, 131_x: 20, ... 71_x: 20, 72_x: 20, 73_x: 20, 74_x: 20, 75_x: 20, 76_x: 20, 77_x: 20, 78_x: 20, 79_x: 20, 7_x: 20, 80_x: 20, 81_x: 20, 82_x: 20, 83_x: 20, 84_x: 20, 85_x: 20, 86_x: 20, 87_x: 20, 88_x: 20, 89_x: 20, 8_x: 20, 90_x: 20, 91_x: 20, 92_x: 20, 93_x: 20, 94_x: 20, 95_x: 20, 96_x: 20, 97_x: 20, 98_x: 20, 99_x: 20, 9_x: 20) Coordinates: (12/200) * 0_x (0_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 * 1_x (1_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 * 2_x (2_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 * 3_x (3_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 * 4_x (4_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 * 5_x (5_x) int32 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 ... * 194_x (194_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 * 195_x (195_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 * 196_x (196_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 * 197_x (197_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 * 198_x (198_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 * 199_x (199_x) int32 0 2 4 6 8 10 12 14 16 ... 22 24 26 28 30 32 34 36 38 Data variables: (12/200) n_0 (0_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_1 (1_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_2 (2_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_3 (3_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_4 (4_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_5 (5_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ... n_194 (194_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_195 (195_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_196 (196_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_197 (197_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_198 (198_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 n_199 (199_x) int32 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 Attributes: (12/200) attr_0: 2 attr_1: 2 attr_2: 2 attr_3: 2 attr_4: 2 attr_5: 2 ... attr_194: 2 attr_195: 2 attr_196: 2 attr_197: 2 attr_198: 2 attr_199: 2 ```

```python

DataArray with many dimensions:

dims = {f"dim_{v}": 2 for v in np.arange(12)} a = xr.DataArray( name="LongDataArrayName", data=np.random.randn(*dims.values()), dims=dims.keys(), coords={k: np.arange(v) * (i + 1) for i, (k, v) in enumerate(dims.items())}, ) print(a) <xarray.DataArray 'LongDataArrayName' (dim_0: 2, dim_1: 2, dim_2: 2, dim_3: 2, dim_4: 2, dim_5: 2, dim_6: 2, dim_7: 2, dim_8: 2, dim_9: 2, dim_10: 2, dim_11: 2)> array([[[[[[[[[[[[ 8.28296160e-01, 2.08993090e-01], [ 8.70468836e-01, 8.90423004e-01]],

            [[ 7.34784427e-01,  2.05408058e-01],
             [-8.57071909e-02,  8.44265228e-01]]],


           [[[-9.35953498e-01, -1.28911601e+00],
             [ 1.10041466e+00,  6.65778297e-02]],

            [[-1.20951652e+00,  6.75763964e-01],
             [-4.71836513e-02,  9.06088516e-01]]]],



          [[[[ 1.59629635e+00,  7.32189004e-01],
             [-3.93944434e-01,  2.46067012e+00]],

            [[ 1.20534658e-01, -1.10855175e+00],
             [ 1.75768289e+00,  1.82771876e+00]]],

... [[[ 1.24664897e+00, 1.72548620e+00], [-7.64230130e-02, -7.96243220e-01]],

            [[-7.02358327e-01,  2.20921513e+00],
             [-7.45919399e-01,  8.16166442e-01]]]],



          [[[[-1.06278662e+00, -3.01061594e-01],
             [-2.68674730e-01,  7.61941899e-01]],

            [[-7.40916926e-01,  1.85122750e+00],
             [-5.42460065e-02, -7.57741769e-01]]],


           [[[-4.12356234e-02,  7.41777992e-01],
             [-1.36243505e+00, -1.25845181e+00]],

            [[-7.42535368e-01,  1.13262286e-01],
             [ 1.03699306e+00, -8.51127899e-01]]]]]]]]]]]])

Coordinates: * dim_0 (dim_0) int32 0 1 * dim_1 (dim_1) int32 0 2 * dim_2 (dim_2) int32 0 3 * dim_3 (dim_3) int32 0 4 * dim_4 (dim_4) int32 0 5 * dim_5 (dim_5) int32 0 6 * dim_6 (dim_6) int32 0 7 * dim_7 (dim_7) int32 0 8 * dim_8 (dim_8) int32 0 9 * dim_9 (dim_9) int32 0 10 * dim_10 (dim_10) int32 0 11 * dim_11 (dim_11) int32 0 12 ```

```python

DataArray with many dimensions but no coords:

dims = {f"dim_{v}": 2 for v in np.arange(12)} a = xr.DataArray( name="LongDataArrayName", data=np.random.randn(*dims.values()), dims=dims.keys(), ) print(a) <xarray.DataArray 'LongDataArrayName' (dim_0: 2, dim_1: 2, dim_2: 2, dim_3: 2, dim_4: 2, dim_5: 2, dim_6: 2, dim_7: 2, dim_8: 2, dim_9: 2, dim_10: 2, dim_11: 2)> array([[[[[[[[[[[[ 2.53218063e-02, -2.01034380e+00], [ 3.07624042e-01, 1.82085569e-01]],

            [[ 1.23998647e+00,  2.80961964e-01],
             [ 5.22623248e-01, -2.10621456e-01]]],


           [[[ 1.55794218e+00, -1.32803310e+00],
             [-7.41474289e-01, -3.35995545e-01]],

            [[ 9.96489723e-03, -1.84197059e-01],
             [-1.24173835e+00,  4.94205388e-01]]]],



          [[[[-2.11962358e-01,  1.18012909e+00],
             [-4.62991218e-01, -9.49171994e-01]],

            [[ 3.90534280e-01, -2.63453002e+00],
             [ 3.57944636e-01,  2.16335768e-01]]],

... [[[-1.11275429e+00, -9.33574221e-01], [ 8.62574702e-01, 1.14185983e+00]],

            [[ 1.36795402e+00,  1.14331852e+00],
             [ 5.96785305e-01,  1.47307855e+00]]]],



          [[[[ 1.95270558e+00, -7.76150298e-01],
             [ 2.05301468e+00, -1.15633640e+00]],

            [[-9.45507288e-01,  1.21096830e+00],
             [ 1.59340121e+00, -3.60261023e-01]]],


           [[[ 2.25343528e+00, -2.84332626e-01],
             [ 1.86644712e-01, -2.78371182e-01]],

            [[-8.86245009e-01, -4.00356195e-01],
             [-2.44036388e-01, -1.53543170e+00]]]]]]]]]]]])

Dimensions without coordinates: dim_0, dim_1, dim_2, dim_3, dim_4, dim_5, dim_6, dim_7, dim_8, dim_9, dim_10, dim_11 ```

Creating a ordered list for filtering purposes using .items() turns out being rather slow. Use .keys() instead as that doesn't trigger a bunch of dataarray initializations.

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

Test case:

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

a = np.arange(0, 2000) data_vars = dict() for i in a: data_vars[f"long_variable_name_{i}"] = xr.DataArray( name=f"long_variable_name_{i}", data=np.arange(0, 20), dims=[f"long_coord_name_{i}x"], coords={f"long_coord_name{i}x": np.arange(0, 20) * 2}, ) ds0 = xr.Dataset(data_vars) ds0.attrs = {f"attr{k}": 2 for k in a} ```

Before: python %timeit print(ds0) 14.6 s ± 215 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

After: python %timeit print(ds0) 120 ms ± 2.06 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Minor change to align with other booleans.

Some minor import oddities I noticed while reading the code.

Use math instead of numpy where possible, looks better and seems faster as well. Idea from https://github.com/pydata/xarray/pull/6702#discussion_r903986442, https://github.com/dask/dask/pull/9232

Example: ```python %timeit math.prod((1, 2, 3)) 161 ns ± 10.5 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

%timeit int(np.prod((1, 2, 3))) 11.9 µs ± 248 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) ```

ref #5582

• [ ] 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

Small edit to #6121.

The shape methods can have multiple integers inside the tuple, this fixes that and adds to typing to all shape methods I found.

Reduce number of imports inside functions. I think it helps making the code easier to read as well, as now you know that plt is always available.

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

Seems to not be a major difference in initial imports from (my small sample of) repeated tests:

This branch: ```python %timeit -n1 -r1 import xarray

3.81 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.83 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.87 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.77 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.91 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)

np.mean([3.81, 3.83, 3.87, 3.7, 3.77, 3.91, 3.8]) Out[3]: 3.812857142857143 ```

Main: ```python %timeit -n1 -r1 import xarray

3.93 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.69 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.64 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.76 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.79 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.81 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each) 3.68 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)

np.mean([3.93, 3.69, 3.64, 3.76, 3.79, 3.81, 3.68]) Out[4]: 3.7571428571428567 ```

While trying to figure out which types are allowed in #5678 I felt that the set_options docstring was rather hard to read. Moving it to typical numpy docstring style helped at least for me.

Allow controlling the randomness of the dataset. It's difficult to catch issues with the dataset if it always changes each run.

This test has been failing with a 404 error for a while. Remove the test because a lot of the functionality is implemented in rioxarray.

• [x] Closes #6363

This PR drops support for python 3.7 and removes a bit of compatibility code related to typing.

• [x] Closes #6138
• [x] Requires #5845
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] Can be merged once we plan to make a release after 2021-12-26. https://numpy.org/neps/nep-0029-deprecation_policy.html

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

Back in 2017 the register_pandas_datetime_converter_if_needed was added to workaround matplotlib crashing when handling datetime objects, (#1669). The example that crashed back then was (#1661): ```python import xarray import numpy

da = xarray.DataArray( numpy.arange(3*4).reshape(3,4), dims=("x", "y"), coords={"x": [1,2,3], "y": [numpy.datetime64(f"2000-01-{x:02d}") for x in range(1, 5)]})

da.plot.pcolormesh() ``` This has probably been working by default in matplotlib since 2.2.0, when datetime support was added https://github.com/matplotlib/matplotlib/releases/tag/v2.2.0. (https://github.com/matplotlib/matplotlib/pull/9779)

Related issues: https://github.com/mwaskom/seaborn/issues/1325

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

Minor touch up looking through #5950.

• [x] xref #6244

xref: #6244

Waiting on * https://github.com/ContinuumIO/anaconda-issues/issues/12669 * https://github.com/conda/conda/pull/10970 * https://github.com/conda-forge/python-feedstock/pull/511 * https://github.com/conda-forge/numba-feedstock/pull/86 * https://github.com/pydap/pydap/pull/210

• [ ] 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.

• [x] Benchmark from #659
• [x] Tests added
• [x] Passes pre-commit run --all-files

Small fix to #5796. The benchmark was only intended to run when the PR has the label run-benchmark. I split the if condition in multiple lines for better readability thinking it didn't change the function but it did.

Reduce diffs in #6778. _interval_to_double_bound_points was returning a list instead of ndarray which I had some issues with.

Make sure name is a string. Use the same .format method as in _get_units_from_attrs to convert to string.

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

Reduce diffs in #6778. I remember finding it annoying that I got a list of the valid strings but not the actual string used.

Workflow based on the version from scikit-image. Modfied to have asv.conf.json inside a subdirectory and triggers every push if the PR has the run-benchmark label.

Notes: * https://github.com/scikit-image/scikit-image doesn't have the same benchmark folder setup, for example config file is in root directory, other folder names. * https://github.com/numpy/numpy has same folder name as sckit-image. config file is in the folder however.

References: * https://labs.quansight.org/blog/2021/08/github-actions-benchmarks/ * https://github.com/scikit-image/scikit-image/pull/5424 * https://github.com/jaimergp/scikit-image/pull/1

Tests checked:

• [x] interp
• [x] pandas
• [x] repr
• [x] combine
• [x] datarray_missing
• [x] dataset_io - Skipped too difficult to understand. Some of the tests are possibly broken.
• [x] indexing
• [x] reindexing
• [x] rolling - Some division by 0 prints left.
• [x] unstacking

TODO: * self.setup_cache

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

Adds support for the cross product.

New tricks possible thanks to xarray: * When coords are defined you can fill with 2 values instead of only 1 like numpy. * When coords are defined you can fill inbetween values as well instead of just appending zeros at the end like numpy.

• [x] Closes #3279
• [x] Tests added
• [x] Passes pre-commit run --all-files
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [x] 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.

Fixes: xarray/tests/test_backends_file_manager.py:56: error: Incompatible types in assignment (expression has type "_GeneratorContextManager[Any]", variable has type "WarningsChecker") [assignment] Just added a ignore.

Add some typing to the open_dataset functions. Was doing some debugging and I only got Any when trying to simplify the problem with tutorial data.