New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Rename `to_array` to `to_dataarray` #8438

Merged

max-sixty merged 2 commits into pydata:main from max-sixty:to_dataarray

Nov 10, 2023

Merged

Rename `to_array` to `to_dataarray` #8438

[pre-commit.ci] auto fixes from pre-commit.com hooks

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

21 fail, 2 351 skipped, 16 291 pass in 1h 40m 30s

          7 files +          7           7 suites +7 1h 40m 30s ⏱️ + 1h 40m 30s
  18 663 tests +  18 663   16 291 ✔️ +  16 291   2 351 💤 +  2 351 21 ❌ +21
122 468 runs +122 468 108 414 ✔️ +108 414 13 982 💤 +13 982 72 ❌ +72

Results for commit 9f3c2b1. ± Comparison against earlier commit 2c23117.

Annotations

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 0x7f24713ac1d0>
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))

/home/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'>]

/home/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 0x7f24713acc10>
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))

/home/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'>]

/home/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 0x7f24713b5dd0>
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))

/home/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'>]

/home/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 0x7f24713b67d0>
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))

/home/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'>]

/home/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 0x7f24713c0bd0>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:2427: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/core/_aggregations.py:1501: in max
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/dataarray.py:3750: in reduce
    var = self.variable.reduce(func, dim, axis, keep_attrs, keepdims, **kwargs)
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f24ccc0dcf0>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

/home/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 0x7f24713c1590>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:2427: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/core/_aggregations.py:1580: in min
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/dataarray.py:3750: in reduce
    var = self.variable.reduce(func, dim, axis, keep_attrs, keepdims, **kwargs)
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f24ccc0e070>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

/home/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 0x7f24713c8450>
func = <function round at 0x7f24ccc0eb30>, 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'>]

/home/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 0x7f24713c8f10>
func = <function round at 0x7f24ccc0eb30>, 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'>]

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

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 0x7f4a00a48f10>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:1560: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/namedarray/_aggregations.py:250: in max
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f4a5812e370>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

/home/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 0x7f4a00a49910>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:1560: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/namedarray/_aggregations.py:318: in min
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f4a5812e6f0>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

/home/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_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 0x7f4a00cbcc90>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:4150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/core/_aggregations.py:330: in max
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/dataset.py:6815: in reduce
    variables[name] = var.reduce(
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f4a5812e370>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

/home/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 0x7f4a00cbcfd0>
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)

/home/runner/work/xarray/xarray/xarray/tests/test_units.py:4150: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/home/runner/work/xarray/xarray/xarray/tests/test_units.py:338: in __call__
    return func(*all_args, **all_kwargs)
/home/runner/work/xarray/xarray/xarray/core/_aggregations.py:417: in min
    return self.reduce(
/home/runner/work/xarray/xarray/xarray/core/dataset.py:6815: in reduce
    variables[name] = var.reduce(
/home/runner/work/xarray/xarray/xarray/core/variable.py:1756: in reduce
    result = super().reduce(
/home/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 0x7f4a5812e6f0>
xp = <module 'numpy' from '/home/runner/micromamba/envs/xarray-tests/lib/python3.11/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'>]

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

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