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

Add missing DataArray.dt.total_seconds() method #8435

Merged

max-sixty merged 1 commit into pydata:main from maresb:total-seconds

Nov 10, 2023

Merged

Add missing DataArray.dt.total_seconds() method #8435

Add missing DataArray.dt.total_seconds() method

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