1841801 – python-xarray fails to build due to test failures

Note: This is a public test instance of Red Hat Bugzilla. The data contained within is a snapshot of the live data so any changes you make will not be reflected in the production Bugzilla. Email is disabled so feel free to test any aspect of the site that you want. File any problems you find or give feedback at bugzilla.redhat.com.

Bug 1841801 - python-xarray fails to build due to test failures

Summary: python-xarray fails to build due to test failures

Keywords:
Status:	CLOSED RAWHIDE
Alias:	None
Product:	Fedora
Classification:	Fedora
Component:	python-xarray
Sub Component:
Version:	rawhide
Hardware:	Unspecified
OS:	Unspecified
Priority:	unspecified
Severity:	unspecified
Target Milestone:	---
Assignee:	Elliott Sales de Andrade
QA Contact:	Fedora Extras Quality Assurance
Docs Contact:
URL:
Whiteboard:
Depends On:
Blocks:	F33FTBFS F33FailsToInstall PYTHON39 1841771 1841783
TreeView+	depends on / blocked

Reported:	2020-05-29 14:38 UTC by Igor Raits
Modified:	2020-06-24 20:50 UTC (History)
CC List:	6 users (show)
Fixed In Version:	python-xarray-0.15.1-3.fc33
Doc Type:	If docs needed, set a value
Doc Text:
Clone Of:
Environment:
Last Closed:	2020-06-24 20:50:57 UTC
Type:	---
Embargoed:
Dependent Products:

Attachments	(Terms of Use)

Description Igor Raits 2020-05-29 14:38:42 UTC

Hello,

Please note that this comment was generated automatically. If you feel that this output has mistakes, please contact me via email (ignatenkobrain).

Your package (python-xarray) Fails To Install in Fedora 33:

can't install python3-xarray:
  - nothing provides python3.8dist(numpy) >= 1.15 needed by python3-xarray-0.15.1-2.fc33.noarch
  - nothing provides python3.8dist(pandas) >= 0.25 needed by python3-xarray-0.15.1-2.fc33.noarch
  - nothing provides python3.8dist(setuptools) >= 41.2 needed by python3-xarray-0.15.1-2.fc33.noarch
  
If you don't react accordingly to the policy for FTBFS/FTI bugs (https://docs.fedoraproject.org/en-US/fesco/Fails_to_build_from_source_Fails_to_install/), your package may be orphaned in 8+ weeks.

P.S. The data was generated solely from koji buildroot, so it might be newer than the latest compose or the content on mirrors.

P.P.S. If this bug has been reported in the middle of upgrading multiple dependent packages, please consider using side tags: https://docs.fedoraproject.org/en-US/rawhide-gating/multi-builds/

Thanks!

Comment 1 Miro Hrončok 2020-06-04 17:22:52 UTC

Seems like this could have been built at a point, but not with the new numpy :(

https://koschei.fedoraproject.org/package/python-xarray?collection=f33

Comment 2 Igor Raits 2020-06-08 06:59:59 UTC

Hello,

This is the first reminder (step 3 from https://docs.fedoraproject.org/en-US/fesco/Fails_to_build_from_source_Fails_to_install/#_package_removal_for_long_standing_ftbfs_and_fti_bugs).

If you know about this problem and are planning on fixing it, please acknowledge so by setting the bug status to ASSIGNED. If you don't have time to maintain this package, consider orphaning it, so maintainers of dependent packages realize the problem.

Comment 3 Tomáš Hrnčiar 2020-06-11 11:45:32 UTC

python-xarray fails to build due to test failures

=================================== FAILURES ===================================
_______________ TestVariable.test_aggregation[float-method_std] ________________
[gw3] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestVariable object at 0xffff8588aee0>
func = method_std, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax"),
            method("argmin"),
            method("argsort"),
            method("cumprod"),
            method("cumsum"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("sum"),
            method("var"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        array = np.linspace(0, 1, 10).astype(dtype) * (
            unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless
        )
        variable = xr.Variable("x", array)
    
        units = extract_units(func(array))
        expected = attach_units(func(strip_units(variable)), units)
        actual = func(variable)
    
        assert_units_equal(expected, actual)
>       xr.testing.assert_identical(expected, actual)
E       AssertionError: Left and right Variable objects are not identical
E       
E       Differing values:
E       L
E           array(0.319142)
E       R
E           array(0.319142)
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:1451: AssertionError
_______________ TestVariable.test_aggregation[float-method_var] ________________
[gw3] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestVariable object at 0xffff858bfcd0>
func = method_var, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            method("all"),
            method("any"),
            method("argmax"),
            method("argmin"),
            method("argsort"),
            method("cumprod"),
            method("cumsum"),
            method("max"),
            method("mean"),
            method("median"),
            method("min"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("sum"),
            method("var"),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        array = np.linspace(0, 1, 10).astype(dtype) * (
            unit_registry.m if func.name != "cumprod" else unit_registry.dimensionless
        )
        variable = xr.Variable("x", array)
    
        units = extract_units(func(array))
        expected = attach_units(func(strip_units(variable)), units)
        actual = func(variable)
    
        assert_units_equal(expected, actual)
>       xr.testing.assert_identical(expected, actual)
E       AssertionError: Left and right Variable objects are not identical
E       
E       Differing values:
E       L
E           array(0.101852)
E       R
E           array(0.101852)
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:1451: AssertionError
_______________ TestDataset.test_aggregation[float-function_std] _______________
[gw2] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestDataset object at 0xffff7ca9f190>
func = function_std, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(
                function("all"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            pytest.param(
                function("any"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("argmax"),
            function("argmin"),
            function("max"),
            function("min"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.xfail(
                    reason="np.median does not work with dataset yet"
                ),
            ),
            function("sum"),
            pytest.param(
                function("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("std"),
            function("var"),
            function("cumsum"),
            pytest.param(
                function("cumprod"),
                marks=pytest.mark.xfail(reason="fails within xarray"),
            ),
            pytest.param(
                method("all"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            pytest.param(
                method("any"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            method("argmax"),
            method("argmin"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("var"),
            method("cumsum"),
            pytest.param(
                method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray")
            ),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        unit_a = (
            unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless
        )
        unit_b = (
            unit_registry.kg / unit_registry.m ** 3
            if func.name != "cumprod"
            else unit_registry.dimensionless
        )
        a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x")
        b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x")
        x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x")
        y = xr.DataArray(
            data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x"
        )
    
        ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})
    
        actual = func(ds)
        expected = attach_units(
            func(strip_units(ds)),
            {
                "a": extract_units(func(a)).get(None),
                "b": extract_units(func(b)).get(None),
            },
        )
    
>       assert_equal_with_units(actual, expected)
E       AssertionError: Left and right Dataset objects are not equal
E         
E         
E         Differing data variables:
E         L   b        float64 <Quantity(0.31914236925211265, 'kilogram / meter ** 3')>
E         R   b        float64 <Quantity(0.3191423692521127, 'kilogram / meter ** 3')>
E         L   a        float64 <Quantity(0.31914236925211265, 'pascal')>
E         R   a        float64 <Quantity(0.3191423692521127, 'pascal')>
E       assert False
E        +  where False = <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191>(<xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191)
E        +    where <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191> = <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191.equals
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError
_______________ TestDataset.test_aggregation[float-function_var] _______________
[gw2] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestDataset object at 0xffff7df4ebb0>
func = function_var, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(
                function("all"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            pytest.param(
                function("any"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("argmax"),
            function("argmin"),
            function("max"),
            function("min"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.xfail(
                    reason="np.median does not work with dataset yet"
                ),
            ),
            function("sum"),
            pytest.param(
                function("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("std"),
            function("var"),
            function("cumsum"),
            pytest.param(
                function("cumprod"),
                marks=pytest.mark.xfail(reason="fails within xarray"),
            ),
            pytest.param(
                method("all"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            pytest.param(
                method("any"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            method("argmax"),
            method("argmin"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("var"),
            method("cumsum"),
            pytest.param(
                method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray")
            ),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        unit_a = (
            unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless
        )
        unit_b = (
            unit_registry.kg / unit_registry.m ** 3
            if func.name != "cumprod"
            else unit_registry.dimensionless
        )
        a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x")
        b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x")
        x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x")
        y = xr.DataArray(
            data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x"
        )
    
        ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})
    
        actual = func(ds)
        expected = attach_units(
            func(strip_units(ds)),
            {
                "a": extract_units(func(a)).get(None),
                "b": extract_units(func(b)).get(None),
            },
        )
    
>       assert_equal_with_units(actual, expected)
E       AssertionError: Left and right Dataset objects are not equal
E         
E         
E         Differing data variables:
E         L   b        float64 <Quantity(0.10185185185185183, 'kilogram ** 2 / meter **...
E         R   b        float64 <Quantity(0.10185185185185186, 'kilogram ** 2 / meter **...
E         L   a        float64 <Quantity(0.10185185185185183, 'pascal ** 2')>
E         R   a        float64 <Quantity(0.10185185185185186, 'pascal ** 2')>
E       assert False
E        +  where False = <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019>(<xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019)
E        +    where <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019> = <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019.equals
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError
________________ TestDataset.test_aggregation[float-method_std] ________________
[gw2] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestDataset object at 0xffff7d301070>
func = method_std, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(
                function("all"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            pytest.param(
                function("any"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("argmax"),
            function("argmin"),
            function("max"),
            function("min"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.xfail(
                    reason="np.median does not work with dataset yet"
                ),
            ),
            function("sum"),
            pytest.param(
                function("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("std"),
            function("var"),
            function("cumsum"),
            pytest.param(
                function("cumprod"),
                marks=pytest.mark.xfail(reason="fails within xarray"),
            ),
            pytest.param(
                method("all"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            pytest.param(
                method("any"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            method("argmax"),
            method("argmin"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("var"),
            method("cumsum"),
            pytest.param(
                method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray")
            ),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        unit_a = (
            unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless
        )
        unit_b = (
            unit_registry.kg / unit_registry.m ** 3
            if func.name != "cumprod"
            else unit_registry.dimensionless
        )
        a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x")
        b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x")
        x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x")
        y = xr.DataArray(
            data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x"
        )
    
        ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})
    
        actual = func(ds)
        expected = attach_units(
            func(strip_units(ds)),
            {
                "a": extract_units(func(a)).get(None),
                "b": extract_units(func(b)).get(None),
            },
        )
    
>       assert_equal_with_units(actual, expected)
E       AssertionError: Left and right Dataset objects are not equal
E         
E         
E         Differing data variables:
E         L   b        float64 <Quantity(0.31914236925211265, 'kilogram / meter ** 3')>
E         R   b        float64 <Quantity(0.3191423692521127, 'kilogram / meter ** 3')>
E         L   a        float64 <Quantity(0.31914236925211265, 'pascal')>
E         R   a        float64 <Quantity(0.3191423692521127, 'pascal')>
E       assert False
E        +  where False = <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191>(<xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191)
E        +    where <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191> = <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.3191\n    b        float64 0.3191.equals
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError
________________ TestDataset.test_aggregation[float-method_var] ________________
[gw2] linux -- Python 3.9.0 /usr/bin/python3
self = <xarray.tests.test_units.TestDataset object at 0xffff7dd19580>
func = method_var, dtype = <class 'float'>
    @pytest.mark.parametrize(
        "func",
        (
            pytest.param(
                function("all"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            pytest.param(
                function("any"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("argmax"),
            function("argmin"),
            function("max"),
            function("min"),
            function("mean"),
            pytest.param(
                function("median"),
                marks=pytest.mark.xfail(
                    reason="np.median does not work with dataset yet"
                ),
            ),
            function("sum"),
            pytest.param(
                function("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            function("std"),
            function("var"),
            function("cumsum"),
            pytest.param(
                function("cumprod"),
                marks=pytest.mark.xfail(reason="fails within xarray"),
            ),
            pytest.param(
                method("all"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            pytest.param(
                method("any"), marks=pytest.mark.xfail(reason="not implemented by pint")
            ),
            method("argmax"),
            method("argmin"),
            method("max"),
            method("min"),
            method("mean"),
            method("median"),
            method("sum"),
            pytest.param(
                method("prod"),
                marks=pytest.mark.xfail(reason="not implemented by pint"),
            ),
            method("std"),
            method("var"),
            method("cumsum"),
            pytest.param(
                method("cumprod"), marks=pytest.mark.xfail(reason="fails within xarray")
            ),
        ),
        ids=repr,
    )
    def test_aggregation(self, func, dtype):
        unit_a = (
            unit_registry.Pa if func.name != "cumprod" else unit_registry.dimensionless
        )
        unit_b = (
            unit_registry.kg / unit_registry.m ** 3
            if func.name != "cumprod"
            else unit_registry.dimensionless
        )
        a = xr.DataArray(data=np.linspace(0, 1, 10).astype(dtype) * unit_a, dims="x")
        b = xr.DataArray(data=np.linspace(-1, 0, 10).astype(dtype) * unit_b, dims="x")
        x = xr.DataArray(data=np.arange(10).astype(dtype) * unit_registry.m, dims="x")
        y = xr.DataArray(
            data=np.arange(10, 20).astype(dtype) * unit_registry.s, dims="x"
        )
    
        ds = xr.Dataset(data_vars={"a": a, "b": b}, coords={"x": x, "y": y})
    
        actual = func(ds)
        expected = attach_units(
            func(strip_units(ds)),
            {
                "a": extract_units(func(a)).get(None),
                "b": extract_units(func(b)).get(None),
            },
        )
    
>       assert_equal_with_units(actual, expected)
E       AssertionError: Left and right Dataset objects are not equal
E         
E         
E         Differing data variables:
E         L   b        float64 <Quantity(0.10185185185185183, 'kilogram ** 2 / meter **...
E         R   b        float64 <Quantity(0.10185185185185186, 'kilogram ** 2 / meter **...
E         L   a        float64 <Quantity(0.10185185185185183, 'pascal ** 2')>
E         R   a        float64 <Quantity(0.10185185185185186, 'pascal ** 2')>
E       assert False
E        +  where False = <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019>(<xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019)
E        +    where <bound method Dataset.equals of <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019> = <xarray.Dataset>\nDimensions:  ()\nData variables:\n    a        float64 0.1019\n    b        float64 0.1019.equals
../../BUILDROOT/python-xarray-0.15.1-3.fc33.noarch/usr/lib/python3.9/site-packages/xarray/tests/test_units.py:3812: AssertionError

Comment 4 Mukundan Ragavan 2020-06-16 20:15:50 UTC

Any movement in this? Two of my FTBFS packages depend on this. Unfortunately, I do not have the expertise to fix this.

Comment 5 Elliott Sales de Andrade 2020-06-18 07:50:35 UTC

I'm not sure what comment 3 is talking about, as I can't reproduce those failure. What does fail though is every test using cftime. I believe this must be from NumPy 1.19, but cftime itself seems to build fine. There are also several warnings about Pint, which may just be leaking into the cftime tests. Pint is outdated, but I haven't investigated if that will fix anything.

Comment 6 Elliott Sales de Andrade 2020-06-23 08:48:22 UTC

OK, I found an upstream patch, which fixes the cftime tests, but the latest build failed with the errors from comment 3. It turns out those are arch-specific.

Note You need to log in before you can comment on or make changes to this bug.