issues

What happened: I’m running tests of xarray while building it for packaging (Arch Linux), and they are 6 tests failures, all with this error message.

What you expected to happen: Tests should work. I’m not sure why a version 0.0.0 is reported while running tests in the build environment.

Full error log

``` __________________ TestDataArray.test_from_series_multiindex ___________________ self = <xarray.tests.test_dataarray.TestDataArray object at 0x7fcb3b23c2b0> def test_from_series_multiindex(self): # GH:3951 df = pd.DataFrame({"B": [1, 2, 3], "A": [4, 5, 6]}) df = df.rename_axis("num").rename_axis("alpha", axis=1) > actual = df.stack("alpha").to_xarray() /build/python-xarray/src/xarray-0.17.0/xarray/tests/test_dataarray.py:3697: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError _______________________ TestDataset.test_sel_categorical _______________________ self = <xarray.tests.test_dataset.TestDataset object at 0x7fcb3afb8640> def test_sel_categorical(self): ind = pd.Series(["foo", "bar"], dtype="category") df = pd.DataFrame({"ind": ind, "values": [1, 2]}) > ds = df.set_index("ind").to_xarray() /build/python-xarray/src/xarray-0.17.0/xarray/tests/test_dataset.py:1432: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError ____________________ TestDataset.test_sel_categorical_error ____________________ self = <xarray.tests.test_dataset.TestDataset object at 0x7fcb3b199220> def test_sel_categorical_error(self): ind = pd.Series(["foo", "bar"], dtype="category") df = pd.DataFrame({"ind": ind, "values": [1, 2]}) > ds = df.set_index("ind").to_xarray() /build/python-xarray/src/xarray-0.17.0/xarray/tests/test_dataset.py:1440: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError ___________________ TestDataset.test_categorical_multiindex ____________________ self = <xarray.tests.test_dataset.TestDataset object at 0x7fcb3ae86670> def test_categorical_multiindex(self): i1 = pd.Series([0, 0]) cat = pd.CategoricalDtype(categories=["foo", "baz", "bar"]) i2 = pd.Series(["baz", "bar"], dtype=cat) df = pd.DataFrame({"i1": i1, "i2": i2, "values": [1, 2]}).set_index( ["i1", "i2"] ) > actual = df.to_xarray() /build/python-xarray/src/xarray-0.17.0/xarray/tests/test_dataset.py:1487: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError _________________ TestDataset.test_from_dataframe_categorical __________________ self = <xarray.tests.test_dataset.TestDataset object at 0x7fcb3ab0b880> def test_from_dataframe_categorical(self): cat = pd.CategoricalDtype( categories=["foo", "bar", "baz", "qux", "quux", "corge"] ) i1 = pd.Series(["foo", "bar", "foo"], dtype=cat) i2 = pd.Series(["bar", "bar", "baz"], dtype=cat) df = pd.DataFrame({"i1": i1, "i2": i2, "values": [1, 2, 3]}) > ds = df.set_index("i1").to_xarray() /build/python-xarray/src/xarray-0.17.0/xarray/tests/test_dataset.py:4131: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError _________________________ test_roundtrip_pandas_series _________________________ @given(numeric_series, st.text()) > def test_roundtrip_pandas_series(ser, ix_name): /build/python-xarray/src/xarray-0.17.0/properties/test_pandas_roundtrip.py:73: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /build/python-xarray/src/xarray-0.17.0/properties/test_pandas_roundtrip.py:79: in test_roundtrip_pandas_series xr.testing.assert_identical(arr, roundtripped.to_xarray()) /usr/lib/python3.9/site-packages/pandas/core/generic.py:3011: in to_xarray xarray = import_optional_dependency("xarray") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ name = 'xarray', extra = '', raise_on_missing = True, on_version = 'raise' def import_optional_dependency( name: str, extra: str = "", raise_on_missing: bool = True, on_version: str = "raise" ): """ Import an optional dependency. By default, if a dependency is missing an ImportError with a nice message will be raised. If a dependency is present, but too old, we raise. Parameters ---------- name : str The module name. This should be top-level only, so that the version may be checked. extra : str Additional text to include in the ImportError message. raise_on_missing : bool, default True Whether to raise if the optional dependency is not found. When False and the module is not present, None is returned. on_version : str {'raise', 'warn'} What to do when a dependency's version is too old. * raise : Raise an ImportError * warn : Warn that the version is too old. Returns None * ignore: Return the module, even if the version is too old. It's expected that users validate the version locally when using ``on_version="ignore"`` (see. ``io/html.py``) Returns ------- maybe_module : Optional[ModuleType] The imported module, when found and the version is correct. None is returned when the package is not found and `raise_on_missing` is False, or when the package's version is too old and `on_version` is ``'warn'``. """ package_name = INSTALL_MAPPING.get(name) install_name = package_name if package_name is not None else name msg = ( f"Missing optional dependency '{install_name}'. {extra} " f"Use pip or conda to install {install_name}." ) try: module = importlib.import_module(name) except ImportError: if raise_on_missing: raise ImportError(msg) from None else: return None minimum_version = VERSIONS.get(name) if minimum_version: version = get_version(module) if distutils.version.LooseVersion(version) < minimum_version: assert on_version in {"warn", "raise", "ignore"} msg = ( f"Pandas requires version '{minimum_version}' or newer of '{name}' " f"(version '{version}' currently installed)." ) if on_version == "warn": warnings.warn(msg, UserWarning) return None elif on_version == "raise": > raise ImportError(msg) E ImportError: Pandas requires version '0.12.3' or newer of 'xarray' (version '0.0.0' currently installed). /usr/lib/python3.9/site-packages/pandas/compat/_optional.py:126: ImportError ```

Environment:

Output of <tt>xr.show_versions()</tt>

commit: None python: 3.9.2 (default, Feb 20 2021, 18:40:11) [GCC 10.2.0] python-bits: 64 OS: Linux OS-release: 5.11.5-arch1-1 machine: x86_64 processor: byteorder: little LC_ALL: None LANG: en_US.UTF-8 LOCALE: en_US.UTF-8 libhdf5: 1.12.0 libnetcdf: 4.7.4 xarray: 0.0.0 pandas: 1.2.3 numpy: 1.20.1 scipy: 1.6.1 netCDF4: 1.5.5.1 pydap: None h5netcdf: None h5py: 3.1.0 Nio: None zarr: None cftime: 1.4.1 nc_time_axis: None PseudoNetCDF: None rasterio: None cfgrib: None iris: None bottleneck: 1.3.2 dask: 2021.03.0 distributed: 2021.03.0 matplotlib: 3.3.4 cartopy: None seaborn: 0.11.1 numbagg: None pint: 0.16.1 setuptools: 54.1.1 pip: None conda: None pytest: 6.2.2 IPython: None sphinx: None

Setup is as described in #3777.

The two failures are the following ones: ``` ____ TestVariable.test_index_0d_not_a_time _______

self = <xarray.tests.test_units.TestVariable object at 0x7f3926b2ad00>

def test_index_0d_not_a_time(self):
    d = np.datetime64("NaT", "ns")
    x = self.cls(["x"], [d])

  self._assertIndexedLikeNDArray(x, d)

xarray/tests/test_variable.py:206:

---

self = <xarray.tests.test_units.TestVariable object at 0x7f3926b2ad00> variable = <xarray.Variable (x: 1)> <Quantity(['NaT'], 'meter')> expected_value0 = numpy.datetime64('NaT'), expected_dtype = None

def _assertIndexedLikeNDArray(self, variable, expected_value0, expected_dtype=None):
    """Given a 1-dimensional variable, verify that the variable is indexed
    like a numpy.ndarray.
    """
    assert variable[0].shape == ()
    assert variable[0].ndim == 0
    assert variable[0].size == 1
    # test identity

  assert variable.equals(variable.copy())

E AssertionError: assert False E + where False = <bound method Variable.equals of \<xarray.Variable (x: 1)>\n\<Quantity(['NaT'], 'meter')>>(<xarray.Variable (x: 1)>\n<Quantity(['NaT'], 'meter')>) E + where <bound method Variable.equals of \<xarray.Variable (x: 1)>\n\<Quantity(['NaT'], 'meter')>> = <xarray.Variable (x: 1)>\n<Quantity(['NaT'], 'meter')>.equals E + and <xarray.Variable (x: 1)>\n<Quantity(['NaT'], 'meter')> = <bound method Variable.copy of \<xarray.Variable (x: 1)>\n\<Quantity(['NaT'], 'meter')>>() E + where <bound method Variable.copy of \<xarray.Variable (x: 1)>\n\<Quantity(['NaT'], 'meter')>> = <xarray.Variable (x: 1)>\n<Quantity(['NaT'], 'meter')>.copy

xarray/tests/test_variable.py:151: AssertionError ___ TestVariable.test_equals_all_dtypes ____

self = <xarray.tests.test_units.TestVariable object at 0x7f39282b4e50>

def test_equals_all_dtypes(self):
    for v, _ in self.example_1d_objects():
        v2 = v.copy()

      assert v.equals(v2)

E AssertionError: assert False E + where False = <bound method Variable.equals of \<xarray.Variable (x: 3)>\n\<Quantity(['2000-01-01T00:00:00.000000000' '2000-01-02T00:00:00.000000000'\n '2000-01-03T00:00:00.000000000'], 'meter')>>(<xarray.Variable (x: 3)>\n<Quantity(['2000-01-01T00:00:00.000000000' '2000-01-02T00:00:00.000000000'\n '2000-01-03T00:00:00.000000000'], 'meter')>) E + where <bound method Variable.equals of \<xarray.Variable (x: 3)>\n\<Quantity(['2000-01-01T00:00:00.000000000' '2000-01-02T00:00:00.000000000'\n '2000-01-03T00:00:00.000000000'], 'meter')>> = <xarray.Variable (x: 3)>\n<Quantity(['2000-01-01T00:00:00.000000000' '2000-01-02T00:00:00.000000000'\n '2000-01-03T00:00:00.000000000'], 'meter')>.equals

xarray/tests/test_variable.py:386: AssertionError ```

I have no idea what’s wrong here.

Follow-up of #3777.

The three failing tests seems to be failing because dask_array=None, which is likely the same kind of issue as #3777: dask-dependant tests ran while dask is not available. The other printed error is strange to me, because numpy is at version 1.18.1 on this system.

``` __ TestVariable.test_aggregation[int-method_median] __

values = array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]), axis = None, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f3927bdbe50> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:

      return func(values, axis=axis, **kwargs)

xarray/core/duck_array_ops.py:307:

---

args = (array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),), kwargs = {'axis': None} dispatch_args = (array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]),)

def f(*args, **kwargs):
    if list_of_args:
        dispatch_args = args[0]
    else:
        dispatch_args = args[array_args]

  if any(isinstance(a, dask_array.Array) for a in dispatch_args):

xarray/core/duck_array_ops.py:40:

---

.0 = <tuple_iterator object at 0x7f3927966f70>

if any(isinstance(a, dask_array.Array) for a in dispatch_args): E AttributeError: 'NoneType' object has no attribute 'Array'

xarray/core/duck_array_ops.py:40: AttributeError

During handling of the above exception, another exception occurred:

self = <xarray.tests.test_units.TestVariable object at 0x7f3927966640> func = method_median, dtype = <class 'int'>

@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)

xarray/tests/test_units.py:1389:

---

xarray/tests/test_units.py:374: in call return func(all_args, all_kwargs) xarray/core/common.py:46: in wrapped_func return self.reduce(func, dim, axis, skipna=skipna, kwargs) xarray/core/variable.py:1537: in reduce data = func(input_data, *kwargs)

---

values = array([0, 0, 0, 0, 0, 0, 0, 0, 0, 1]), axis = None, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f3927bdbe50> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:
        return func(values, axis=axis, **kwargs)
    except AttributeError:
        if isinstance(values, dask_array_type):
            try:  # dask/dask#3133 dask sometimes needs dtype argument
                # if func does not accept dtype, then raises TypeError
                return func(values, axis=axis, dtype=values.dtype, **kwargs)
            except (AttributeError, TypeError):
                msg = "%s is not yet implemented on dask arrays" % name
        else:
            msg = (
                "%s is not available with skipna=False with the "
                "installed version of numpy; upgrade to numpy 1.12 "
                "or newer to use skipna=True or skipna=None" % name
            )

      raise NotImplementedError(msg)

E NotImplementedError: median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None

xarray/core/duck_array_ops.py:321: NotImplementedError __ TestDataArray.test_aggregation[int-method_median] ___

values = array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), axis = None, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f39286dbc10> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:

      return func(values, axis=axis, **kwargs)

xarray/core/duck_array_ops.py:307:

---

args = (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),), kwargs = {'axis': None} dispatch_args = (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),)

def f(*args, **kwargs):
    if list_of_args:
        dispatch_args = args[0]
    else:
        dispatch_args = args[array_args]

  if any(isinstance(a, dask_array.Array) for a in dispatch_args):

xarray/core/duck_array_ops.py:40:

---

.0 = <tuple_iterator object at 0x7f39288ad880>

if any(isinstance(a, dask_array.Array) for a in dispatch_args): E AttributeError: 'NoneType' object has no attribute 'Array'

xarray/core/duck_array_ops.py:40: AttributeError

During handling of the above exception, another exception occurred:

self = <xarray.tests.test_units.TestDataArray object at 0x7f39288ad190> func = method_median, dtype = <class 'int'>

@pytest.mark.parametrize(
    "func",
    (
        pytest.param(
            function("all"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        pytest.param(
            function("any"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        function("argmax"),
        function("argmin"),
        function("max"),
        function("mean"),
        pytest.param(
            function("median"),
            marks=pytest.mark.xfail(reason="not implemented by xarray"),
        ),
        function("min"),
        pytest.param(
            function("prod"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        function("sum"),
        function("std"),
        function("var"),
        function("cumsum"),
        pytest.param(
            function("cumprod"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        pytest.param(
            method("all"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        pytest.param(
            method("any"),
            marks=pytest.mark.xfail(reason="not implemented by pint yet"),
        ),
        method("argmax"),
        method("argmin"),
        method("max"),
        method("mean"),
        method("median"),
        method("min"),
        pytest.param(
            method("prod"),
            marks=pytest.mark.xfail(
                reason="comparison of quantity with ndarrays in nanops not implemented"
            ),
        ),
        method("sum"),
        method("std"),
        method("var"),
        method("cumsum"),
        pytest.param(
            method("cumprod"),
            marks=pytest.mark.xfail(reason="pint does not implement cumprod yet"),
        ),
    ),
    ids=repr,
)
def test_aggregation(self, func, dtype):
    array = np.arange(10).astype(dtype) * (
        unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless
    )
    data_array = xr.DataArray(data=array, dims="x")

    # units differ based on the applied function, so we need to
    # first compute the units
    units = extract_units(func(array))

  expected = attach_units(func(strip_units(data_array)), units)

xarray/tests/test_units.py:2226:

---

xarray/tests/test_units.py:374: in call return func(all_args, all_kwargs) xarray/core/common.py:46: in wrapped_func return self.reduce(func, dim, axis, skipna=skipna, kwargs) xarray/core/dataarray.py:2235: in reduce var = self.variable.reduce(func, dim, axis, keep_attrs, keepdims, kwargs) xarray/core/variable.py:1537: in reduce data = func(input_data, *kwargs)

---

values = array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), axis = None, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f39286dbc10> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:
        return func(values, axis=axis, **kwargs)
    except AttributeError:
        if isinstance(values, dask_array_type):
            try:  # dask/dask#3133 dask sometimes needs dtype argument
                # if func does not accept dtype, then raises TypeError
                return func(values, axis=axis, dtype=values.dtype, **kwargs)
            except (AttributeError, TypeError):
                msg = "%s is not yet implemented on dask arrays" % name
        else:
            msg = (
                "%s is not available with skipna=False with the "
                "installed version of numpy; upgrade to numpy 1.12 "
                "or newer to use skipna=True or skipna=None" % name
            )

      raise NotImplementedError(msg)

E NotImplementedError: median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None

xarray/core/duck_array_ops.py:321: NotImplementedError ___ TestDataset.test_aggregation[int-method_median] ____

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>, axis = 0, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f392619b820> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:

      return func(values, axis=axis, **kwargs)

xarray/core/duck_array_ops.py:307:

---

args = (<Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>,), kwargs = {'axis': 0} dispatch_args = (<Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>,)

def f(*args, **kwargs):
    if list_of_args:
        dispatch_args = args[0]
    else:
        dispatch_args = args[array_args]

  if any(isinstance(a, dask_array.Array) for a in dispatch_args):

xarray/core/duck_array_ops.py:40:

---

.0 = <tuple_iterator object at 0x7f39269995e0>

if any(isinstance(a, dask_array.Array) for a in dispatch_args): E AttributeError: 'NoneType' object has no attribute 'Array'

xarray/core/duck_array_ops.py:40: AttributeError

During handling of the above exception, another exception occurred:

self = <xarray.tests.test_units.TestDataset object at 0x7f3927adf880> func = method_median, dtype = <class 'int'>

@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)

xarray/tests/test_units.py:3733:

---

xarray/tests/test_units.py:374: in call return func(all_args, all_kwargs) xarray/core/common.py:83: in wrapped_func return self.reduce( xarray/core/dataset.py:4230: in reduce variables[name] = var.reduce( xarray/core/variable.py:1535: in reduce data = func(input_data, axis=axis, *kwargs)

---

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>, axis = 0, skipna = None kwargs = {}, func = <function _dask_or_eager_func.\<locals>.f at 0x7f392619b820> msg = 'median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None'

def f(values, axis=None, skipna=None, **kwargs):
    if kwargs.pop("out", None) is not None:
        raise TypeError(f"`out` is not valid for {name}")

    values = asarray(values)

    if coerce_strings and values.dtype.kind in "SU":
        values = values.astype(object)

    func = None
    if skipna or (skipna is None and values.dtype.kind in "cfO"):
        nanname = "nan" + name
        func = getattr(nanops, nanname)
    else:
        func = _dask_or_eager_func(name, dask_module=dask_module)

    try:
        return func(values, axis=axis, **kwargs)
    except AttributeError:
        if isinstance(values, dask_array_type):
            try:  # dask/dask#3133 dask sometimes needs dtype argument
                # if func does not accept dtype, then raises TypeError
                return func(values, axis=axis, dtype=values.dtype, **kwargs)
            except (AttributeError, TypeError):
                msg = "%s is not yet implemented on dask arrays" % name
        else:
            msg = (
                "%s is not available with skipna=False with the "
                "installed version of numpy; upgrade to numpy 1.12 "
                "or newer to use skipna=True or skipna=None" % name
            )

      raise NotImplementedError(msg)

E NotImplementedError: median is not available with skipna=False with the installed version of numpy; upgrade to numpy 1.12 or newer to use skipna=True or skipna=None

xarray/core/duck_array_ops.py:321: NotImplementedError ```

However I’m not much knowledgeable on all this, so I’ll defer to you for finding the root cause.

Since y-day, pint 0.11 was released and it results in a new test failure (in addition to the ones in #3778 and #3779): ``` ____ TestVariable.test_pad _____

self = <xarray.tests.test_units.TestVariable object at 0x7f6bfd8c1b20>

def test_pad(self):
    data = np.arange(4 * 3 * 2).reshape(4, 3, 2)
    v = self.cls(["x", "y", "z"], data)

    xr_args = [{"x": (2, 1)}, {"y": (0, 3)}, {"x": (3, 1), "z": (2, 0)}]
    np_args = [
        ((2, 1), (0, 0), (0, 0)),
        ((0, 0), (0, 3), (0, 0)),
        ((3, 1), (0, 0), (2, 0)),
    ]
    for xr_arg, np_arg in zip(xr_args, np_args):
        actual = v.pad_with_fill_value(**xr_arg)
        expected = np.pad(
            np.array(v.data.astype(float)),
            np_arg,
            mode="constant",
            constant_values=np.nan,
        )
        assert_array_equal(actual, expected)
        assert isinstance(actual._data, type(v._data))

    # for the boolean array, we pad False
    data = np.full_like(data, False, dtype=bool).reshape(4, 3, 2)
    v = self.cls(["x", "y", "z"], data)
    for xr_arg, np_arg in zip(xr_args, np_args):

      actual = v.pad_with_fill_value(fill_value=False, **xr_arg)

xarray/tests/test_variable.py:813:

---

xarray/core/variable.py:1210: in pad_with_fill_value array = np.pad( <array_function internals>:5: in pad ??? /usr/lib/python3.8/site-packages/pint/quantity.py:1543: in array_function return numpy_wrap("function", func, args, kwargs, types) /usr/lib/python3.8/site-packages/pint/numpy_func.py:894: in numpy_wrap return handledname /usr/lib/python3.8/site-packages/pint/numpy_func.py:671: in _pad kwargs["constant_values"] = _recursive_convert(kwargs["constant_values"], units) /usr/lib/python3.8/site-packages/pint/numpy_func.py:659: in _recursive_convert arg = unit._REGISTRY.Quantity(arg, unit) /usr/lib/python3.8/site-packages/pint/quantity.py:200: in new inst._magnitude = _to_magnitude(

---

value = False, force_ndarray = True, force_ndarray_like = False

def _to_magnitude(value, force_ndarray=False, force_ndarray_like=False):
    if isinstance(value, (dict, bool)) or value is None:

      raise TypeError("Invalid magnitude for Quantity: {0!r}".format(value))

E TypeError: Invalid magnitude for Quantity: False

/usr/lib/python3.8/site-packages/pint/compat.py:49: TypeError ```

I’m currently packaging xarray (0.15.0) for ArchLinux, and I’m running the test suite with all our currently available packages (in addition to python-numpy, python-pandas and python-pytest of course):

python-netcdf4
python-scipy
python-cftime
python-bottleneck
python-matplotlib
python-seaborn
python-pint

I was greatly impressed at the automatic selection of tests depending on what is available on the system. :) I’m only seeing 10 tests failures (10 failed, 8057 passed, 1384 skipped, 518 xfailed, 277 xpassed, 5268 warnings), and amongst them one is happening because a test requiring dask is run even without it being installed: test_open_mfdataset_list_attr.

Corresponding test output: ``` ___ testopen_mfdataset_list_attr _____

@requires_netCDF4
def test_open_mfdataset_list_attr():
    """
    Case when an attribute of type list differs across the multiple files
    """
    from netCDF4 import Dataset

    with create_tmp_files(2) as nfiles:
        for i in range(2):
            f = Dataset(nfiles[i], "w") 
            f.createDimension("x", 3)
            vlvar = f.createVariable("test_var", np.int32, ("x"))
            # here create an attribute as a list 
            vlvar.test_attr = [f"string a {i}", f"string b {i}"]
            vlvar[:] = np.arange(3)
            f.close()
        ds1 = open_dataset(nfiles[0])
        ds2 = open_dataset(nfiles[1])
        original = xr.concat([ds1, ds2], dim="x")

      with xr.open_mfdataset(
            [nfiles[0], nfiles[1]], combine="nested", concat_dim="x"
        ) as actual:

xarray/tests/test_backends.py:2561:

---

xarray/backends/api.py:908: in open_mfdataset datasets = [open_(p, open_kwargs) for p in paths] xarray/backends/api.py:908: in <listcomp> datasets = [open_(p, open_kwargs) for p in paths] xarray/backends/api.py:538: in open_dataset ds = maybe_decode_store(store)

---

store = <xarray.backends.netCDF4_.NetCDF4DataStore object at 0x7f392aebc640> lock = False

def maybe_decode_store(store, lock=False):
    ds = conventions.decode_cf(
        store,
        mask_and_scale=mask_and_scale,
        decode_times=decode_times,
        concat_characters=concat_characters,
        decode_coords=decode_coords,
        drop_variables=drop_variables,
        use_cftime=use_cftime,
    )

    _protect_dataset_variables_inplace(ds, cache)

    if chunks is not None:

      from dask.base import tokenize

E ModuleNotFoundError: No module named 'dask'

xarray/backends/api.py:459: ModuleNotFoundError ``` I think this test should thus not be selected if dask is not installed. ;)