Build software better, together

GitHub Actions / Test Results failed Nov 9, 2023 in 0s

21 fail, 2 351 skipped, 16 291 pass in 1h 51m 45s

          7 files +          7           7 suites +7 1h 51m 45s ⏱️ + 1h 51m 45s
  18 663 tests +  18 663   16 291 ✔️ +  16 291   2 351 💤 +  2 351 21 ❌ +21
122 468 runs +122 468 108 413 ✔️ +108 413 13 983 💤 +13 983 72 ❌ +72

Results for commit 91ebf2b. ± Comparison against earlier commit 48478f1.

Annotations

Check warning on line 0 in xarray.tests.test_units.TestVariable

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_max] (xarray.tests.test_units.TestVariable)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestVariable object at 0x15db5c130>
func = method_max, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("argsort"),
            method("cumprod"),
            method("cumsum"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("std"),
            method("sum"),
            method("var"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        array = np.linspace(0, 1, 10).astype(dtype) * (
            unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless
        )
        variable = xr.Variable("x", array)
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in func.kwargs:
            numpy_kwargs["axis"] = variable.get_axis_num(numpy_kwargs.pop("dim"))
    
        units = extract_units(func(array, **numpy_kwargs))
        expected = attach_units(func(strip_units(variable)), units)
>       actual = func(variable)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:1560: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/namedarray/_aggregations.py:250: in max
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:761: in reduce
    data = func(self.data, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'meter')>, axis = None, skipna = None
kwargs = {}, func = <function max at 0x10fab9fb0>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestVariable

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_min] (xarray.tests.test_units.TestVariable)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestVariable object at 0x15db5c2e0>
func = method_min, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("argsort"),
            method("cumprod"),
            method("cumsum"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("std"),
            method("sum"),
            method("var"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        array = np.linspace(0, 1, 10).astype(dtype) * (
            unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless
        )
        variable = xr.Variable("x", array)
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in func.kwargs:
            numpy_kwargs["axis"] = variable.get_axis_num(numpy_kwargs.pop("dim"))
    
        units = extract_units(func(array, **numpy_kwargs))
        expected = attach_units(func(strip_units(variable)), units)
>       actual = func(variable)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:1560: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/namedarray/_aggregations.py:318: in min
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:761: in reduce
    data = func(self.data, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'meter')>, axis = None, skipna = None
kwargs = {}, func = <function min at 0x10fabc2f0>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

6 out of 7 runs failed: test_aggregation[float64-function_max] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for Windows-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dc979a0>
func = function_max, dtype = dtype('float64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # units differ based on the applied function, so we need to
        # first compute the units
>       units = extract_units(func(array))

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2425: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = function_max
args = (<Quantity([0. 1. 2. 3. 4. 5. 6. 7. 8. 9.], 'meter')>,), kwargs = {}
all_args = [<Quantity([0. 1. 2. 3. 4. 5. 6. 7. 8. 9.], 'meter')>]
all_kwargs = {}

    def __call__(self, *args, **kwargs):
        all_args = merge_args(self.args, args)
        all_kwargs = {**self.kwargs, **kwargs}
    
>       return self.func(*all_args, **all_kwargs)
E       TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:373: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

6 out of 7 runs failed: test_aggregation[float64-function_min] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for Windows-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dc97b50>
func = function_min, dtype = dtype('float64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # units differ based on the applied function, so we need to
        # first compute the units
>       units = extract_units(func(array))

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2425: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = function_min
args = (<Quantity([0. 1. 2. 3. 4. 5. 6. 7. 8. 9.], 'meter')>,), kwargs = {}
all_args = [<Quantity([0. 1. 2. 3. 4. 5. 6. 7. 8. 9.], 'meter')>]
all_kwargs = {}

    def __call__(self, *args, **kwargs):
        all_args = merge_args(self.args, args)
        all_kwargs = {**self.kwargs, **kwargs}
    
>       return self.func(*all_args, **all_kwargs)
E       TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:373: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-function_max] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcaa9a0>
func = function_max, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # units differ based on the applied function, so we need to
        # first compute the units
>       units = extract_units(func(array))

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2425: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = function_max, args = (<Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>,)
kwargs = {}, all_args = [<Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>]
all_kwargs = {}

    def __call__(self, *args, **kwargs):
        all_args = merge_args(self.args, args)
        all_kwargs = {**self.kwargs, **kwargs}
    
>       return self.func(*all_args, **all_kwargs)
E       TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:373: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-function_min] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcaab50>
func = function_min, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # units differ based on the applied function, so we need to
        # first compute the units
>       units = extract_units(func(array))

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2425: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = function_min, args = (<Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>,)
kwargs = {}, all_args = [<Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>]
all_kwargs = {}

    def __call__(self, *args, **kwargs):
        all_args = merge_args(self.args, args)
        all_kwargs = {**self.kwargs, **kwargs}
    
>       return self.func(*all_args, **all_kwargs)
E       TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:373: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_max] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcb71c0>
func = method_max, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # 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)
>       actual = func(data_array)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2427: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/core/_aggregations.py:1501: in max
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/dataarray.py:3750: in reduce
    var = self.variable.reduce(func, dim, axis, keep_attrs, keepdims, **kwargs)
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:761: in reduce
    data = func(self.data, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>, axis = None, skipna = None
kwargs = {}, func = <function max at 0x10fab9fb0>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_min] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcb7370>
func = method_min, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            function("all"),
            function("any"),
            pytest.param(
                function("argmax"),
                marks=pytest.mark.skip(
                    reason="calling np.argmax as a function on xarray objects is not "
                    "supported"
                ),
            ),
            pytest.param(
                function("argmin"),
                marks=pytest.mark.skip(
                    reason="calling np.argmin as a function on xarray objects is not "
                    "supported"
                ),
            ),
            function("max"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.skip(
                    reason="median does not work with dataarrays yet"
                ),
            ),
            function("min"),
            function("prod"),
            function("sum"),
            function("std"),
            function("var"),
            function("cumsum"),
            function("cumprod"),
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            method("prod"),
            method("sum"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        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")
    
        numpy_kwargs = func.kwargs.copy()
        if "dim" in numpy_kwargs:
            numpy_kwargs["axis"] = data_array.get_axis_num(numpy_kwargs.pop("dim"))
    
        # 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)
>       actual = func(data_array)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2427: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/core/_aggregations.py:1580: in min
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/dataarray.py:3750: in reduce
    var = self.variable.reduce(func, dim, axis, keep_attrs, keepdims, **kwargs)
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:761: in reduce
    data = func(self.data, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 1 2 3 4 5 6 7 8 9], 'meter')>, axis = None, skipna = None
kwargs = {}, func = <function min at 0x10fabc2f0>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

6 out of 7 runs failed: test_unary_operations[float64-round] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for Windows-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.round' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcb7b80>
func = <function round at 0x10fabcbf0>, dtype = dtype('float64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(operator.neg, id="negate"),
            pytest.param(abs, id="absolute"),
            pytest.param(np.round, id="round"),
        ),
    )
    def test_unary_operations(self, func, dtype):
        array = np.arange(10).astype(dtype) * unit_registry.m
        data_array = xr.DataArray(data=array)
    
>       units = extract_units(func(array))
E       TypeError: no implementation found for 'numpy.round' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2448: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataArray

github-actions / Test Results

All 5 runs failed: test_unary_operations[int64-round] (xarray.tests.test_units.TestDataArray)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.round' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataArray object at 0x15dcb7d30>
func = <function round at 0x10fabcbf0>, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(operator.neg, id="negate"),
            pytest.param(abs, id="absolute"),
            pytest.param(np.round, id="round"),
        ),
    )
    def test_unary_operations(self, func, dtype):
        array = np.arange(10).astype(dtype) * unit_registry.m
        data_array = xr.DataArray(data=array)
    
>       units = extract_units(func(array))
E       TypeError: no implementation found for 'numpy.round' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:2448: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataset

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_max] (xarray.tests.test_units.TestDataset)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataset object at 0x15b3a89a0>
func = method_max, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            method("prod"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        unit_a, unit_b = (
            (unit_registry.Pa, unit_registry.degK)
            if func.name != "cumprod"
            else (unit_registry.dimensionless, unit_registry.dimensionless)
        )
    
        a = np.linspace(0, 1, 10).astype(dtype) * unit_a
        b = np.linspace(-1, 0, 10).astype(dtype) * unit_b
    
        ds = xr.Dataset({"a": ("x", a), "b": ("x", b)})
    
        if "dim" in func.kwargs:
            numpy_kwargs = func.kwargs.copy()
            dim = numpy_kwargs.pop("dim")
    
            axis_a = ds.a.get_axis_num(dim)
            axis_b = ds.b.get_axis_num(dim)
    
            numpy_kwargs_a = numpy_kwargs.copy()
            numpy_kwargs_a["axis"] = axis_a
            numpy_kwargs_b = numpy_kwargs.copy()
            numpy_kwargs_b["axis"] = axis_b
        else:
            numpy_kwargs_a = {}
            numpy_kwargs_b = {}
    
        units_a = array_extract_units(func(a, **numpy_kwargs_a))
        units_b = array_extract_units(func(b, **numpy_kwargs_b))
        units = {"a": units_a, "b": units_b}
    
>       actual = func(ds)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:4150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/core/_aggregations.py:330: in max
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/dataset.py:6815: in reduce
    variables[name] = var.reduce(
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:759: in reduce
    data = func(self.data, axis=axis, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>, axis = 0, skipna = None
kwargs = {}, func = <function max at 0x10ced0330>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.max' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestDataset

github-actions / Test Results

All 5 runs failed: test_aggregation[int64-method_min] (xarray.tests.test_units.TestDataset)

artifacts/Test results for Linux-3.10/pytest.xml [took 0s]
artifacts/Test results for Linux-3.11/pytest.xml [took 0s]
artifacts/Test results for Linux-3.9/pytest.xml [took 0s]
artifacts/Test results for macOS-3.11/pytest.xml [took 0s]
artifacts/Test results for macOS-3.9/pytest.xml [took 0s]

Raw output


            TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]
self = <xarray.tests.test_units.TestDataset object at 0x15b3a8a30>
func = method_min, dtype = dtype('int64')

    @pytest.mark.skipif(
        (sys.version_info >= (3, 11)) and sys.platform.startswith("win"),
        reason="fails for some reason on win and 3.11, GH7971",
    )
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax", dim="x"),
            method("argmin", dim="x"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            method("prod"),
            method("std"),
            method("var"),
            method("cumsum"),
            method("cumprod"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        if (
            func.name == "prod"
            and dtype.kind == "f"
            and version.parse(pint.__version__) < version.parse("0.19")
        ):
            pytest.xfail(reason="nanprod is not by older `pint` versions")
    
        unit_a, unit_b = (
            (unit_registry.Pa, unit_registry.degK)
            if func.name != "cumprod"
            else (unit_registry.dimensionless, unit_registry.dimensionless)
        )
    
        a = np.linspace(0, 1, 10).astype(dtype) * unit_a
        b = np.linspace(-1, 0, 10).astype(dtype) * unit_b
    
        ds = xr.Dataset({"a": ("x", a), "b": ("x", b)})
    
        if "dim" in func.kwargs:
            numpy_kwargs = func.kwargs.copy()
            dim = numpy_kwargs.pop("dim")
    
            axis_a = ds.a.get_axis_num(dim)
            axis_b = ds.b.get_axis_num(dim)
    
            numpy_kwargs_a = numpy_kwargs.copy()
            numpy_kwargs_a["axis"] = axis_a
            numpy_kwargs_b = numpy_kwargs.copy()
            numpy_kwargs_b["axis"] = axis_b
        else:
            numpy_kwargs_a = {}
            numpy_kwargs_b = {}
    
        units_a = array_extract_units(func(a, **numpy_kwargs_a))
        units_b = array_extract_units(func(b, **numpy_kwargs_b))
        units = {"a": units_a, "b": units_b}
    
>       actual = func(ds)

/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:4150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/Users/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/Users/runner/work/xarray/xarray/xarray/core/_aggregations.py:417: in min
    return self.reduce(
/Users/runner/work/xarray/xarray/xarray/core/dataset.py:6815: in reduce
    variables[name] = var.reduce(
/Users/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/Users/runner/work/xarray/xarray/xarray/namedarray/core.py:759: in reduce
    data = func(self.data, axis=axis, **kwargs)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

values = <Quantity([0 0 0 0 0 0 0 0 0 1], 'pascal')>, axis = 0, skipna = None
kwargs = {}, func = <function min at 0x10ced0630>
xp = <module 'numpy' from '/Users/runner/micromamba/envs/xarray-tests/lib/python3.9/site-packages/numpy/__init__.py'>

    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}")
    
        # The data is invariant in the case of 0d data, so do not
        # change the data (and dtype)
        # See https://github.com/pydata/xarray/issues/4885
        if invariant_0d and axis == ():
            return values
    
        values = asarray(values)
    
        if coerce_strings and values.dtype.kind in "SU":
            values = astype(values, object)
    
        func = None
        if skipna or (skipna is None and values.dtype.kind in "cfO"):
            nanname = "nan" + name
            func = getattr(nanops, nanname)
        else:
            if name in ["sum", "prod"]:
                kwargs.pop("min_count", None)
    
            xp = get_array_namespace(values)
            func = getattr(xp, name)
    
        try:
            with warnings.catch_warnings():
                warnings.filterwarnings("ignore", "All-NaN slice encountered")
>               return func(values, axis=axis, **kwargs)
E               TypeError: no implementation found for 'numpy.min' on types that implement __array_function__: [<class 'pint.util.Quantity'>]

/Users/runner/work/xarray/xarray/xarray/core/duck_array_ops.py:399: TypeError

Check warning on line 0 in xarray.tests.test_units.TestVariable