Towards the strict goal in #8239.

Is your feature request related to a problem?

I was making sure the test in #6832 failed on main, when it did I wrote a few lines in the what's new file but forgot switching back to the other branch and accidentally pushed directly to main. :(

Describe the solution you'd like

I think it's best if we require a pull request for merging. We seem to pretty much do this anyway.

Seems to be this setting if I understand correctly:

Describe alternatives you've considered

No response

Additional context

No response

dask has added py.typed files so now the ignores shouldn't be needed anymore: https://github.com/dask/dask/pull/8854 https://github.com/dask/distributed/pull/5328 As does numpy and pint

pycompat.py doesn't error anymore, so it's good to type check that one as well. Fixed also a python 3.8 related error in it.

Fixes these errors that I've been seeing locally for a while:

python !mypy C:\Users\J.W\Documents\GitHub\xarray\xarray\core\coordinates.py --ignore-missing-imports C:\Users\J.W\Documents\GitHub\xarray\xarray\core\pycompat.py:48: error: Incompatible types in assignment (expression has type "Tuple[]", variable has type "Tuple[Any]") C:\Users\J.W\Documents\GitHub\xarray\xarray\core\pycompat.py:50: error: Incompatible types in assignment (expression has type "Optional[Module]", variable has type "Optional[Literal['dask', 'pint', 'cupy', 'sparse']]") Found 2 errors in 1 file (checked 1 source file)

Not sure why the CI isn't catching these?

Splitting up #5622 as the scope of it has grown too large now.

• Adds support for dataarray scatter plots and replaces the dataset version.
• Scatter now has 3d support with the z argument.
• Scatter now always returns a single pathcollection, earlier it could return a list of pathcollection when using categoricals
• Better legend, handles now categoricals. Making continous/discrete options slightly redundant, still there though.
• Facetgrid generalized slightly to handle 3d plots.

TODO: * sharex sharey test https://github.com/pydata/xarray/pull/7047: len(list(ax.get_shared_x_axes())) != 0

• [x] Tests added
• [x] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [ ] New functions/methods are listed in api.rst

Matplotlibs 3d plots appears to not support sharex/sharey. So reset to default values instead. This improves the look of the plot as axis values aren't deleted.

Example: ```python import matplotlib.pyplot as plt

fig = plt.figure() subplot_kws = {"projection":"3d"} ax1 = fig.add_subplot(211, subplot_kws) ax1.plot([0, 1, 2], [5,6,6]) ax2 = fig.add_subplot(212, sharex = ax1, subplot_kws) ax2.plot([0, 1, 2], [5,4,2]) # x axis is not linked. ``` Split up from #6778.

Cache some small properties that are rather slow to calculate but doesn't change that often.

Questions that needs to be resolved:

• [ ] Can these properties change during the lifetime of the class? If so the cache needs to be reset when that happens.

• [ ] Related to #3514
• [ ] 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

Notes * Mixin classes makes it difficult to cache properties. For example ndim in NdimSizeLenMixin cannot be easily be replaced with cache_readonly.

Hello,

I would like an option in da.interp()that instead of returning NaNs during extrapolation returns the data corresponding to the end of the breakpoint data set range.

One way to do this is to limit the new coordinates to the array coordinates minimum and maximum value, I did a simple example with this solution down below. I think this is a rather safe way as we are just modifying the inputs to all the various interpolation classes that xarray is using at the moment. But it does look a little weird when printing the extrapolated value, the coordinates shows the limited value instead of the requested coordinates. Maybe this can be handled elegantly somewhere in the source code?

MATLAB uses this quite frequently in their interpolation functions: * https://mathworks.com/help/simulink/ug/methods-for-estimating-missing-points.html * https://mathworks.com/help/simulink/slref/2dlookuptable.html

MCVE Code Sample

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

def interp(da, coords, extrapolation='clip'): """ Linear interpolation that clips the inputs to the coords min and max value.

Parameters
----------
da : DataArray
    DataArray to interpolate.
coords : dict
    Coordinates for the interpolated value.
"""
if extrapolation == 'clip':
    for k, v in da.coords.items():
        coords[k] = np.maximum(coords[k], np.min(v.values))
        coords[k] = np.minimum(coords[k], np.max(v.values))

return da.interp(coords)

Create coordinates:

x = np.linspace(1000, 6000, 4) y = np.linspace(100, 1200, 3)

Create data:

X = np.meshgrid(*[x, y], indexing='ij') data = X[0] * X[1]

Create DataArray:

da = xr.DataArray(data=data, coords=[('x', x), ('y', y)], name='data')

Attempt to extrapolate:

datai = interp(da, {'x': 7000, 'y': 375}) ```

Expected Output

python print(datai) <xarray.DataArray 'data' ()> array(2250000.) Coordinates: x float64 6e+03 y float64 375.0

Versions

The backend classes are initialized in the build_engine function: https://github.com/pydata/xarray/blob/8b95da8e21a9d31de9f79cb0506720595f49e1dd/xarray/backends/plugins.py#L93

This wasn't the case for custom backends: https://github.com/pydata/xarray/blob/8b95da8e21a9d31de9f79cb0506720595f49e1dd/xarray/backends/plugins.py#L161

This PR initializes the engine, fixes the incorrect signature in the test (#5033) and reverts the doc changes done in #5532.

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

Attempt to fix these errors found in #5365.

xarray/core/computation.py:1533: error: Argument "variable_dim" to "to_stacked_array" of "Dataset" has incompatible type "Hashable"; expected "str" [arg-type] xarray/core/computation.py:1533: error: Argument "sample_dims" to "to_stacked_array" of "Dataset" has incompatible type "Mapping[Hashable, int]"; expected "Sequence[Hashable]" [arg-type] - [x] Passes pre-commit run --all-files

Removing a commented improvement that required that the minimum version requirement for dask to be increased.

• [x] Requires #5556
• [x] Passes pre-commit run --all-files

Make the transpose faster. * get_axis_num seems slow, avoid triggering it unnecessarily for example when using 1d arrays. * .copy(deep=False) is the bottleneck for 1d arrays. Not sure if it can be dealt with though.

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

Found some checks that should always be true nowadays.