issues

What happened?

I'm updating builds for Fedora to 2022.06.0, and running tests, the process runs out of memory and is OOM-killed. Running all the steps manually, this gets to the to_netcdf call in createTestNCZarr._create_nczarr. At that point, memory usage rises to 8.9G resident / 17.7G virtual, and the process is killed (actually, the entire SSH session is killed).

What did you expect to happen?

Tests pass without issue.

Minimal Complete Verifiable Example

Python import xarray as xr from xarray.tests.test_dataset import create_test_data ds = create_test_data() ds = ds.drop_vars("dim3") ds.to_netcdf(f"file://foo.zarr#mode=nczarr,noxarray")

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

Python Jul 31 22:56:07 hostnmme systemd-oomd[805]: Killed /user.slice/user-1000.slice/session-131.scope due to memory used (15294935040) / total (15569043456) and swap used (15308353536) / total (16978534400) being more than 90.00% Jul 31 22:56:07 hostname systemd[1]: session-131.scope: systemd-oomd killed 6 process(es) in this unit.

Anything else we need to know?

No response

Environment

• [x] Closes #5342
• [ ] Tests added
• [x] Passes pre-commit run --all-files
• [n/a] User visible changes (including notable bug fixes) are documented in whats-new.rst
• [n/a] New functions/methods are listed in api.rst

What happened: When building the Fedora package of xarray 0.18.0/0.18.1, test_push_dask failed. This did not happen in previous versions (or the test did not exist then.)

Minimal Complete Verifiable Example:

```pytb _____ testpush_dask ______ [gw2] linux -- Python 3.9.5 /usr/bin/python3 @requires_dask @requires_bottleneck def test_push_dask(): import bottleneck import dask.array

    array = np.array([np.nan, np.nan, np.nan, 1, 2, 3, np.nan, np.nan, 4, 5, np.nan, 6])
    expected = bottleneck.push(array, axis=0)
    for c in range(1, 11):
        with raise_if_dask_computes():

          actual = push(dask.array.from_array(array, chunks=c), axis=0, n=None)

/builddir/build/BUILDROOT/python-xarray-0.18.1-1.fc35.x86_64/usr/lib/python3.9/site-packages/xarray/tests/test_duck_array_ops.py:886:

/builddir/build/BUILDROOT/python-xarray-0.18.1-1.fc35.x86_64/usr/lib/python3.9/site-packages/xarray/core/duck_array_ops.py:663: in push return dask_array_ops.push(array, n, axis) /builddir/build/BUILDROOT/python-xarray-0.18.1-1.fc35.x86_64/usr/lib/python3.9/site-packages/xarray/core/dask_array_ops.py:69: in push pushed = array.map_blocks(push, axis=axis, n=n) /usr/lib/python3.9/site-packages/dask/array/core.py:2333: in map_blocks return map_blocks(func, self, args, *kwargs) /usr/lib/python3.9/site-packages/dask/array/core.py:683: in map_blocks dtype = apply_infer_dtype(func, args, original_kwargs, "map_blocks")

func = <built-in function push>, args = [array([1.])] kwargs = {'axis': 0, 'n': None}, funcname = 'map_blocks' suggest_dtype = 'dtype', nout = None def apply_infer_dtype(func, args, kwargs, funcname, suggest_dtype="dtype", nout=None): """ Tries to infer output dtype of func for a small set of input arguments.

    Parameters
    ----------
    func: Callable
        Function for which output dtype is to be determined

    args: List of array like
        Arguments to the function, which would usually be used. Only attributes
        ``ndim`` and ``dtype`` are used.

    kwargs: dict
        Additional ``kwargs`` to the ``func``

    funcname: String
        Name of calling function to improve potential error messages

    suggest_dtype: None/False or String
        If not ``None`` adds suggestion to potential error message to specify a dtype
        via the specified kwarg. Defaults to ``'dtype'``.

    nout: None or Int
        ``None`` if function returns single output, integer if many.
        Deafults to ``None``.

    Returns
    -------
    : dtype or List of dtype
        One or many dtypes (depending on ``nout``)
    """
    args = [
        np.ones((1,) * x.ndim, dtype=x.dtype) if isinstance(x, Array) else x
        for x in args
    ]
    try:
        with np.errstate(all="ignore"):
            o = func(*args, **kwargs)
    except Exception as e:
        exc_type, exc_value, exc_traceback = sys.exc_info()
        tb = "".join(traceback.format_tb(exc_traceback))
        suggest = (
            (
                "Please specify the dtype explicitly using the "
                "`{dtype}` kwarg.\n\n".format(dtype=suggest_dtype)
            )
            if suggest_dtype
            else ""
        )
        msg = (
            "`dtype` inference failed in `{0}`.\n\n"
            "{1}"
            "Original error is below:\n"
            "------------------------\n"
            "{2}\n\n"
            "Traceback:\n"
            "---------\n"
            "{3}"
        ).format(funcname, suggest, repr(e), tb)
    else:
        msg = None
    if msg is not None:

      raise ValueError(msg)

E ValueError: dtype inference failed in map_blocks. E
E Please specify the dtype explicitly using the dtype kwarg. E
E Original error is below: E ------------------------ E TypeError('n must be an integer') E
E Traceback: E --------- E File "/usr/lib/python3.9/site-packages/dask/array/core.py", line 383, in apply_infer_dtype E o = func(args, *kwargs) /usr/lib/python3.9/site-packages/dask/array/core.py:408: ValueError ```

Anything else we need to know?:

Environment:

What happened: When building happens on any of the above architectures, the test_aggregation test fails. This appears to be due to some small precision errors: ``` ___ TestVariable.test_aggregation[float-method_std] ____ [gw4] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestVariable object at 0xffff72adc850> func = method_std, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( method("all"), method("any"), method("argmax"), method("argmin"), method("argsort"), method("cumprod"), method("cumsum"), method("max"), method("mean"), method("median"), method("min"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("sum"), method("var"), ), ids=repr, ) def test_aggregation(self, func, dtype): array = np.linspace(0, 1, 10).astype(dtype) * ( unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless ) variable = xr.Variable("x", array)

    units = extract_units(func(array))
    expected = attach_units(func(strip_units(variable)), units)
    actual = func(variable)

    assert_units_equal(expected, actual)

  xr.testing.assert_identical(expected, actual)

E AssertionError: Left and right Variable objects are not identical E
E Differing values: E L E array(0.319142) E R E array(0.319142) ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:1451: AssertionError ___ TestVariable.test_aggregation[float-method_var] ____ [gw4] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestVariable object at 0xffff72f66ac0> func = method_var, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( method("all"), method("any"), method("argmax"), method("argmin"), method("argsort"), method("cumprod"), method("cumsum"), method("max"), method("mean"), method("median"), method("min"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("sum"), method("var"), ), ids=repr, ) def test_aggregation(self, func, dtype): array = np.linspace(0, 1, 10).astype(dtype) * ( unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless ) variable = xr.Variable("x", array)

    units = extract_units(func(array))
    expected = attach_units(func(strip_units(variable)), units)
    actual = func(variable)

    assert_units_equal(expected, actual)

  xr.testing.assert_identical(expected, actual)

E AssertionError: Left and right Variable objects are not identical E
E Differing values: E L E array(0.101852) E R E array(0.101852) ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:1451: AssertionError __ TestDataset.test_aggregation[float-function_std] __ [gw0] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestDataset object at 0xffff6524e340> func = function_std, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( pytest.param( function("all"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), pytest.param( function("any"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("argmax"), function("argmin"), function("max"), function("min"), function("mean"), pytest.param( function("median"), marks=pytest.mark.xfail( reason="np.median does not work with dataset yet" ), ), function("sum"), pytest.param( function("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("std"), function("var"), function("cumsum"), pytest.param( function("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray"), ), pytest.param( method("all"), marks=pytest.mark.xfail(reason="not implemented by pint") ), pytest.param( method("any"), marks=pytest.mark.xfail(reason="not implemented by pint") ), method("argmax"), method("argmin"), method("max"), method("min"), method("mean"), method("median"), method("sum"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("var"), method("cumsum"), pytest.param( method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray") ), ), ids=repr, ) def test_aggregation(self, func, dtype): unit_a = ( unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless ) unit_b = ( unit_registry.kg / unit_registry.m ** 3 if func.name != "cumprod" else unit_registry.dimensionless ) a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x") b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x") x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x") y = xr.DataArray( data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x" )

    ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})

    actual = func(ds)
    expected = attach_units(
        func(strip_units(ds)),
        {
            "a": extract_units(func(a)).get(None),
            "b": extract_units(func(b)).get(None),
        },
    )

  assert_equal_with_units(actual, expected)

E AssertionError: Left and right Dataset objects are not equal E
E
E Differing data variables: E L a float64 <Quantity(0.31914236925211265, 'pascal')> E R a float64 <Quantity(0.3191423692521127, 'pascal')> E L b float64 <Quantity(0.31914236925211265, 'kilogram / meter ** 3')> E R b float64 <Quantity(0.3191423692521127, 'kilogram / meter ** 3')> E assert False E + where False = <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191>(<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191) E + where <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191> = <xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191.equals ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError __ TestDataset.test_aggregation[float-function_var] __ [gw0] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestDataset object at 0xffff695c6520> func = function_var, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( pytest.param( function("all"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), pytest.param( function("any"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("argmax"), function("argmin"), function("max"), function("min"), function("mean"), pytest.param( function("median"), marks=pytest.mark.xfail( reason="np.median does not work with dataset yet" ), ), function("sum"), pytest.param( function("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("std"), function("var"), function("cumsum"), pytest.param( function("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray"), ), pytest.param( method("all"), marks=pytest.mark.xfail(reason="not implemented by pint") ), pytest.param( method("any"), marks=pytest.mark.xfail(reason="not implemented by pint") ), method("argmax"), method("argmin"), method("max"), method("min"), method("mean"), method("median"), method("sum"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("var"), method("cumsum"), pytest.param( method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray") ), ), ids=repr, ) def test_aggregation(self, func, dtype): unit_a = ( unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless ) unit_b = ( unit_registry.kg / unit_registry.m ** 3 if func.name != "cumprod" else unit_registry.dimensionless ) a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x") b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x") x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x") y = xr.DataArray( data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x" )

    ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})

    actual = func(ds)
    expected = attach_units(
        func(strip_units(ds)),
        {
            "a": extract_units(func(a)).get(None),
            "b": extract_units(func(b)).get(None),
        },
    )

  assert_equal_with_units(actual, expected)

E AssertionError: Left and right Dataset objects are not equal E
E
E Differing data variables: E L a float64 <Quantity(0.10185185185185183, 'pascal ** 2')> E R a float64 <Quantity(0.10185185185185186, 'pascal ** 2')> E L b float64 <Quantity(0.10185185185185183, 'kilogram ** 2 / meter ... E R b float64 <Quantity(0.10185185185185186, 'kilogram ** 2 / meter ... E assert False E + where False = <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019>(<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019) E + where <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019> = <xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019.equals ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError __ TestDataset.test_aggregation[float-method_std] __ [gw0] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestDataset object at 0xffff65305c10> func = method_std, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( pytest.param( function("all"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), pytest.param( function("any"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("argmax"), function("argmin"), function("max"), function("min"), function("mean"), pytest.param( function("median"), marks=pytest.mark.xfail( reason="np.median does not work with dataset yet" ), ), function("sum"), pytest.param( function("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("std"), function("var"), function("cumsum"), pytest.param( function("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray"), ), pytest.param( method("all"), marks=pytest.mark.xfail(reason="not implemented by pint") ), pytest.param( method("any"), marks=pytest.mark.xfail(reason="not implemented by pint") ), method("argmax"), method("argmin"), method("max"), method("min"), method("mean"), method("median"), method("sum"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("var"), method("cumsum"), pytest.param( method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray") ), ), ids=repr, ) def test_aggregation(self, func, dtype): unit_a = ( unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless ) unit_b = ( unit_registry.kg / unit_registry.m ** 3 if func.name != "cumprod" else unit_registry.dimensionless ) a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x") b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x") x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x") y = xr.DataArray( data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x" )

    ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})

    actual = func(ds)
    expected = attach_units(
        func(strip_units(ds)),
        {
            "a": extract_units(func(a)).get(None),
            "b": extract_units(func(b)).get(None),
        },
    )

  assert_equal_with_units(actual, expected)

E AssertionError: Left and right Dataset objects are not equal E
E
E Differing data variables: E L a float64 <Quantity(0.31914236925211265, 'pascal')> E R a float64 <Quantity(0.3191423692521127, 'pascal')> E L b float64 <Quantity(0.31914236925211265, 'kilogram / meter ** 3')> E R b float64 <Quantity(0.3191423692521127, 'kilogram / meter ** 3')> E assert False E + where False = <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191>(<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191) E + where <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191> = <xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.3191\n b float64 0.3191.equals ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError __ TestDataset.test_aggregation[float-method_var] __ [gw0] linux -- Python 3.9.0 /usr/bin/python3 self = <xarray.tests.test_units.TestDataset object at 0xffff6a1c2b80> func = method_var, dtype = <class 'float'> @pytest.mark.parametrize( "func", ( pytest.param( function("all"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), pytest.param( function("any"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("argmax"), function("argmin"), function("max"), function("min"), function("mean"), pytest.param( function("median"), marks=pytest.mark.xfail( reason="np.median does not work with dataset yet" ), ), function("sum"), pytest.param( function("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), function("std"), function("var"), function("cumsum"), pytest.param( function("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray"), ), pytest.param( method("all"), marks=pytest.mark.xfail(reason="not implemented by pint") ), pytest.param( method("any"), marks=pytest.mark.xfail(reason="not implemented by pint") ), method("argmax"), method("argmin"), method("max"), method("min"), method("mean"), method("median"), method("sum"), pytest.param( method("prod"), marks=pytest.mark.xfail(reason="not implemented by pint"), ), method("std"), method("var"), method("cumsum"), pytest.param( method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray") ), ), ids=repr, ) def test_aggregation(self, func, dtype): unit_a = ( unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless ) unit_b = ( unit_registry.kg / unit_registry.m ** 3 if func.name != "cumprod" else unit_registry.dimensionless ) a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x") b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x") x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x") y = xr.DataArray( data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x" )

    ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})

    actual = func(ds)
    expected = attach_units(
        func(strip_units(ds)),
        {
            "a": extract_units(func(a)).get(None),
            "b": extract_units(func(b)).get(None),
        },
    )

  assert_equal_with_units(actual, expected)

E AssertionError: Left and right Dataset objects are not equal E
E
E Differing data variables: E L a float64 <Quantity(0.10185185185185183, 'pascal ** 2')> E R a float64 <Quantity(0.10185185185185186, 'pascal ** 2')> E L b float64 <Quantity(0.10185185185185183, 'kilogram ** 2 / meter ... E R b float64 <Quantity(0.10185185185185186, 'kilogram ** 2 / meter ... E assert False E + where False = <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019>(<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019) E + where <bound method Dataset.equals of \<xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019> = <xarray.Dataset>\nDimensions: ()\nData variables:\n a float64 0.1019\n b float64 0.1019.equals ../../BUILDROOT/python-xarray-0.15.1-3.fc33.aarch64/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError ```

What you expected to happen: Tests pass, no matter the architecture.

Minimal Complete Verifiable Example: pytest -ra -n auto -m 'not network' --pyargs xarray

Environment: All builds are run here; you can look at the individual architectures to see actual failures in build.log (though they're the same as above.) Note, other architectures not listed here fail only because this package is supposed to be noarch, but I disabled that here to test all arches.

Mixing the two is deprecated in Matplotlib 3.1, and breaks the doc build if warnings are set to errors (which they are in new IPython sphinx extensions.)

• [x] See #3266
• [x] Tests added
• [x] Passes black . && mypy . && flake8
• [x] Fully documented, including whats-new.rst for all changes and api.rst for new API

It is deprecated in Matplotlib 2.2, removed in 3.1, and appears to have no effect on the result.

• [x] Closes #3219
• [N/A] Tests added
• [x] Passes black . && mypy . && flake8
• [N/A] Fully documented, including whats-new.rst for all changes and api.rst for new API

When building against Matplotlib 3.1, the docs fail (see log) because box-forced is no longer accepted in Matplotlib.

Problem Description

Docs fail on plot_cartopy_facetgrid.py: WARNING: /builddir/build/BUILD/xarray-0.12.3/doc/gallery/plot_cartopy_facetgrid.py failed to execute correctly: Traceback (most recent call last): File "/usr/lib/python3.7/site-packages/sphinx_gallery/gen_rst.py", line 394, in _memory_usage out = func() File "/usr/lib/python3.7/site-packages/sphinx_gallery/gen_rst.py", line 382, in __call__ exec(self.code, self.globals) File "/builddir/build/BUILD/xarray-0.12.3/doc/gallery/plot_cartopy_facetgrid.py", line 42, in <module> ax.set_aspect('equal', 'box-forced') File "/usr/lib/python3.7/site-packages/matplotlib/axes/_base.py", line 1295, in set_aspect self.set_adjustable(adjustable, share=share) # Handle sharing. File "/usr/lib/python3.7/site-packages/matplotlib/axes/_base.py", line 1335, in set_adjustable cbook._check_in_list(["box", "datalim"], adjustable=adjustable) File "/usr/lib/python3.7/site-packages/matplotlib/cbook/__init__.py", line 2164, in _check_in_list .format(v, k, ', '.join(map(repr, values)))) ValueError: 'box-forced' is not a valid value for adjustable; supported values are 'box', 'datalim'

Output of xr.show_versions()

Problem description

The default directory for caching datasets is currently ~/.xarray_tutorial_data: https://github.com/pydata/xarray/blob/225868d232219440b188956531d5764ff4cd1b53/xarray/tutorial.py#L15

This doesn't follow the XDG standard on Linux, and AFAIK isn't actually invisible on Windows.

Expected Output

It would be better if this followed the XDG standard, i.e., ~/.cache/xarray_tutorial_data (or some other places if you've set some environment variables) and something like %LOCALAPPDATA% on Windows. There are packages like appdirs that handle all this for you.

This is not really a bugfix or enhancement. In fact, it's just a bug report right now. I'm having trouble running tests on Python 2 with both netcdf4 and h5netcdf installed due to the cross engine test ( H5NetCDFDataTest.test_cross_engine_read_write_netcdf4).

I noticed that the requirements list netcdf4 twice; I assume this was a typo and the second one should be h5netcdf. By switching the duplicate out, I'm hoping to trigger the problem on CI as a way to report this bug.

• [ ] closes #xxxx
• [ ] tests added / passed
• [ ] passes git diff upstream/master | flake8 --diff
• [ ] whatsnew entry