ci: cuDF fixup (#2739)

Author: MarcoGorelli

narwhals/_duckdb/expr.py

@@ -103,9 +103,9 @@ def __narwhals_namespace__(self) -> DuckDBNamespace:  # pragma: no cover
 
     def _cum_window_func(
         self,
+        func_name: Literal["sum", "max", "min", "count", "product"],
         *,
         reverse: bool,
-        func_name: Literal["sum", "max", "min", "count", "product"],
     ) -> DuckDBWindowFunction:
         def func(df: DuckDBLazyFrame, inputs: DuckDBWindowInputs) -> list[Expression]:
             return [
@@ -125,12 +125,12 @@ def func(df: DuckDBLazyFrame, inputs: DuckDBWindowInputs) -> list[Expression]:
 
     def _rolling_window_func(
         self,
-        *,
         func_name: Literal["sum", "mean", "std", "var"],
-        center: bool,
         window_size: int,
         min_samples: int,
         ddof: int | None = None,
+        *,
+        center: bool,
     ) -> DuckDBWindowFunction:
         supported_funcs = ["sum", "mean", "std", "var"]
         if center:
@@ -640,54 +640,36 @@ def func(df: DuckDBLazyFrame, inputs: DuckDBWindowInputs) -> list[Expression]:
 
     @requires.backend_version((1, 3))
     def cum_sum(self, *, reverse: bool) -> Self:
-        return self._with_window_function(
-            self._cum_window_func(reverse=reverse, func_name="sum")
-        )
+        return self._with_window_function(self._cum_window_func("sum", reverse=reverse))
 
     @requires.backend_version((1, 3))
     def cum_max(self, *, reverse: bool) -> Self:
-        return self._with_window_function(
-            self._cum_window_func(reverse=reverse, func_name="max")
-        )
+        return self._with_window_function(self._cum_window_func("max", reverse=reverse))
 
     @requires.backend_version((1, 3))
     def cum_min(self, *, reverse: bool) -> Self:
-        return self._with_window_function(
-            self._cum_window_func(reverse=reverse, func_name="min")
-        )
+        return self._with_window_function(self._cum_window_func("min", reverse=reverse))
 
     @requires.backend_version((1, 3))
     def cum_count(self, *, reverse: bool) -> Self:
-        return self._with_window_function(
-            self._cum_window_func(reverse=reverse, func_name="count")
-        )
+        return self._with_window_function(self._cum_window_func("count", reverse=reverse))
 
     @requires.backend_version((1, 3))
     def cum_prod(self, *, reverse: bool) -> Self:
         return self._with_window_function(
-            self._cum_window_func(reverse=reverse, func_name="product")
+            self._cum_window_func("product", reverse=reverse)
         )
 
     @requires.backend_version((1, 3))
     def rolling_sum(self, window_size: int, *, min_samples: int, center: bool) -> Self:
         return self._with_window_function(
-            self._rolling_window_func(
-                func_name="sum",
-                center=center,
-                window_size=window_size,
-                min_samples=min_samples,
-            )
+            self._rolling_window_func("sum", window_size, min_samples, center=center)
         )
 
     @requires.backend_version((1, 3))
     def rolling_mean(self, window_size: int, *, min_samples: int, center: bool) -> Self:
         return self._with_window_function(
-            self._rolling_window_func(
-                func_name="mean",
-                center=center,
-                window_size=window_size,
-                min_samples=min_samples,
-            )
+            self._rolling_window_func("mean", window_size, min_samples, center=center)
         )
 
     @requires.backend_version((1, 3))
@@ -696,11 +678,7 @@ def rolling_var(
     ) -> Self:
         return self._with_window_function(
             self._rolling_window_func(
-                func_name="var",
-                center=center,
-                window_size=window_size,
-                min_samples=min_samples,
-                ddof=ddof,
+                "var", window_size, min_samples, ddof=ddof, center=center
             )
         )
 
@@ -710,11 +688,7 @@ def rolling_std(
     ) -> Self:
         return self._with_window_function(
             self._rolling_window_func(
-                func_name="std",
-                center=center,
-                window_size=window_size,
-                min_samples=min_samples,
-                ddof=ddof,
+                "std", window_size, min_samples, ddof=ddof, center=center
             )
         )
 

narwhals/_pandas_like/namespace.py

@@ -16,6 +16,7 @@
 from narwhals._pandas_like.selectors import PandasSelectorNamespace
 from narwhals._pandas_like.series import PandasLikeSeries
 from narwhals._pandas_like.typing import NativeDataFrameT, NativeSeriesT
+from narwhals._pandas_like.utils import is_non_nullable_boolean
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Sequence
@@ -147,7 +148,7 @@ def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
             it = (
                 (
                     # NumPy-backed 'bool' dtype can't contain nulls so doesn't need filling.
-                    s if s.native.dtype == "bool" else s.fill_null(True, None, None)  # noqa: FBT003
+                    s if is_non_nullable_boolean(s) else s.fill_null(True, None, None)  # noqa: FBT003
                     for s in series
                 )
                 if ignore_nulls
@@ -180,7 +181,7 @@ def func(df: PandasLikeDataFrame) -> list[PandasLikeSeries]:
             it = (
                 (
                     # NumPy-backed 'bool' dtype can't contain nulls so doesn't need filling.
-                    s if s.native.dtype == "bool" else s.fill_null(False, None, None)  # noqa: FBT003
+                    s if is_non_nullable_boolean(s) else s.fill_null(False, None, None)  # noqa: FBT003
                     for s in series
                 )
                 if ignore_nulls

narwhals/_pandas_like/utils.py

@@ -603,6 +603,15 @@ def check_column_names_are_unique(columns: pd.Index[str]) -> None:
         raise DuplicateError(msg)
 
 
+def is_non_nullable_boolean(s: PandasLikeSeries) -> bool:
+    # cuDF booleans are nullable but the native dtype is still 'bool'.
+    return (
+        s._implementation
+        in {Implementation.PANDAS, Implementation.MODIN, Implementation.DASK}
+        and s.native.dtype == "bool"
+    )
+
+
 class PandasLikeSeriesNamespace(EagerSeriesNamespace["PandasLikeSeries", Any]):
     @property
     def implementation(self) -> Implementation:

tests/expr_and_series/all_horizontal_test.py

@@ -18,7 +18,7 @@ def test_allh(constructor: Constructor) -> None:
     assert_equal_data(result, expected)
 
 
-def test_anyh_ignore_nulls(constructor: Constructor) -> None:
+def test_all_ignore_nulls(constructor: Constructor) -> None:
     if "dask" in str(constructor):
         # Dask infers `[True, None, None, None]` as `object` dtype, and then `__or__` fails.
         # test it below separately

tests/expr_and_series/rolling_mean_test.py

@@ -123,9 +123,6 @@ def test_rolling_mean_expr_lazy_grouped(
         pytest.skip()
     if any(x in str(constructor) for x in ("dask", "pyarrow_table")):
         request.applymarker(pytest.mark.xfail)
-    if "cudf" in str(constructor) and center:
-        # center is not implemented for offset-based windows
-        request.applymarker(pytest.mark.xfail)
     if "modin" in str(constructor):
         # unreliable
         pytest.skip()

tests/expr_and_series/rolling_std_test.py

@@ -317,9 +317,6 @@ def test_rolling_std_expr_lazy_grouped(
         pytest.skip()
     if any(x in str(constructor) for x in ("dask", "pyarrow_table")):
         request.applymarker(pytest.mark.xfail)
-    if "cudf" in str(constructor) and center:
-        # center is not implemented for offset-based windows
-        request.applymarker(pytest.mark.xfail)
     if "modin" in str(constructor):
         # unreliable
         pytest.skip()

tests/expr_and_series/rolling_sum_test.py

@@ -131,9 +131,6 @@ def test_rolling_sum_expr_lazy_grouped(
         pytest.skip()
     if any(x in str(constructor) for x in ("dask", "pyarrow_table")):
         request.applymarker(pytest.mark.xfail)
-    if "cudf" in str(constructor) and center:
-        # center is not implemented for offset-based windows
-        request.applymarker(pytest.mark.xfail)
     if "modin" in str(constructor):
         # unreliable
         pytest.skip()

tests/expr_and_series/rolling_var_test.py

@@ -275,9 +275,6 @@ def test_rolling_var_expr_lazy_grouped(
         pytest.skip()
     if any(x in str(constructor) for x in ("dask", "pyarrow_table")):
         request.applymarker(pytest.mark.xfail)
-    if "cudf" in str(constructor) and center:
-        # center is not implemented for offset-based windows
-        request.applymarker(pytest.mark.xfail)
     if "modin" in str(constructor):
         # unreliable
         pytest.skip()

tests/frame/getitem_test.py

@@ -314,12 +314,7 @@ def test_slice_with_series(
     assert_equal_data(result, expected)
 
 
-def test_horizontal_slice_with_series(
-    constructor_eager: ConstructorEager, request: pytest.FixtureRequest
-) -> None:
-    if "cudf" in str(constructor_eager):
-        # https://github.com/rapidsai/cudf/issues/18556
-        request.applymarker(pytest.mark.xfail)
+def test_horizontal_slice_with_series(constructor_eager: ConstructorEager) -> None:
     data = {"a": [1, 2], "c": [0, 2], "d": ["c", "a"]}
     nw_df = nw.from_native(constructor_eager(data), eager_only=True)
     result = nw_df[nw_df["d"]]