cudf-polars-cu12 24.12.0__py3-none-any.whl → 25.2.1__py3-none-any.whl

cudf_polars/VERSION

@@ -1 +1 @@
-24.12.00
+25.02.01

cudf_polars/__init__.py

@@ -21,8 +21,8 @@ _ensure_polars_version()
 del _ensure_polars_version
 
 __all__: list[str] = [
-    "execute_with_cudf",
     "Translator",
     "__git_commit__",
     "__version__",
+    "execute_with_cudf",
 ]

cudf_polars/callback.py

@@ -9,7 +9,7 @@ import contextlib
 import os
 import warnings
 from functools import cache, partial
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 import nvtx
 
@@ -181,6 +181,7 @@ def _callback(
     *,
     device: int | None,
     memory_resource: int | None,
+    executor: Literal["pylibcudf", "dask-experimental"] | None,
 ) -> pl.DataFrame:
     assert with_columns is None
     assert pyarrow_predicate is None
@@ -191,7 +192,14 @@ def _callback(
         set_device(device),
         set_memory_resource(memory_resource),
     ):
-        return ir.evaluate(cache={}).to_polars()
+        if executor is None or executor == "pylibcudf":
+            return ir.evaluate(cache={}).to_polars()
+        elif executor == "dask-experimental":
+            from cudf_polars.experimental.parallel import evaluate_dask
+
+            return evaluate_dask(ir).to_polars()
+        else:
+            raise ValueError(f"Unknown executor '{executor}'")
 
 
 def validate_config_options(config: dict) -> None:
@@ -208,7 +216,10 @@ def validate_config_options(config: dict) -> None:
     ValueError
         If the configuration contains unsupported options.
     """
-    if unsupported := (config.keys() - {"raise_on_fail", "parquet_options"}):
+    if unsupported := (
+        config.keys()
+        - {"raise_on_fail", "parquet_options", "executor", "executor_options"}
+    ):
         raise ValueError(
             f"Engine configuration contains unsupported settings: {unsupported}"
         )
@@ -216,6 +227,18 @@ def validate_config_options(config: dict) -> None:
         config.get("parquet_options", {})
     )
 
+    # Validate executor_options
+    executor = config.get("executor", "pylibcudf")
+    if executor == "dask-experimental":
+        unsupported = config.get("executor_options", {}).keys() - {
+            "max_rows_per_partition",
+            "parquet_blocksize",
+        }
+    else:
+        unsupported = config.get("executor_options", {}).keys()
+    if unsupported:
+        raise ValueError(f"Unsupported executor_options for {executor}: {unsupported}")
+
 
 def execute_with_cudf(nt: NodeTraverser, *, config: GPUEngine) -> None:
     """
@@ -243,6 +266,7 @@ def execute_with_cudf(nt: NodeTraverser, *, config: GPUEngine) -> None:
     device = config.device
     memory_resource = config.memory_resource
     raise_on_fail = config.config.get("raise_on_fail", False)
+    executor = config.config.get("executor", None)
     validate_config_options(config.config)
 
     with nvtx.annotate(message="ConvertIR", domain="cudf_polars"):
@@ -272,5 +296,6 @@ def execute_with_cudf(nt: NodeTraverser, *, config: GPUEngine) -> None:
                     ir,
                     device=device,
                     memory_resource=memory_resource,
+                    executor=executor,
                 )
             )

cudf_polars/containers/__init__.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-__all__: list[str] = ["DataFrame", "Column"]
+__all__: list[str] = ["Column", "DataFrame"]
 
 from cudf_polars.containers.column import Column
 from cudf_polars.containers.dataframe import DataFrame

cudf_polars/dsl/expr.py

@@ -36,27 +36,27 @@ from cudf_polars.dsl.expressions.ternary import Ternary
 from cudf_polars.dsl.expressions.unary import Cast, Len, UnaryFunction
 
 __all__ = [
-    "Expr",
+    "Agg",
+    "AggInfo",
+    "BinOp",
+    "BooleanFunction",
+    "Cast",
+    "Col",
+    "ColRef",
     "ErrorExpr",
-    "NamedExpr",
+    "Expr",
+    "Filter",
+    "Gather",
+    "GroupedRollingWindow",
+    "Len",
     "Literal",
     "LiteralColumn",
-    "Len",
-    "Col",
-    "ColRef",
-    "BooleanFunction",
-    "StringFunction",
-    "TemporalFunction",
+    "NamedExpr",
+    "RollingWindow",
     "Sort",
     "SortBy",
-    "Gather",
-    "Filter",
-    "RollingWindow",
-    "GroupedRollingWindow",
-    "Cast",
-    "Agg",
-    "AggInfo",
+    "StringFunction",
+    "TemporalFunction",
     "Ternary",
-    "BinOp",
     "UnaryFunction",
 ]

cudf_polars/dsl/expressions/aggregation.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
 # SPDX-License-Identifier: Apache-2.0
 # TODO: remove need for this
 # ruff: noqa: D101
@@ -31,7 +31,7 @@ __all__ = ["Agg"]
 
 
 class Agg(Expr):
-    __slots__ = ("name", "options", "op", "request")
+    __slots__ = ("name", "op", "options", "request")
     _non_child = ("dtype", "name", "options")
 
     def __init__(
@@ -40,6 +40,7 @@ class Agg(Expr):
         self.dtype = dtype
         self.name = name
         self.options = options
+        self.is_pointwise = False
         self.children = children
         if name not in Agg._SUPPORTED:
             raise NotImplementedError(
@@ -68,7 +69,11 @@ class Agg(Expr):
             # TODO: handle nans
             req = plc.aggregation.variance(ddof=options)
         elif name == "count":
-            req = plc.aggregation.count(null_handling=plc.types.NullPolicy.EXCLUDE)
+            req = plc.aggregation.count(
+                null_handling=plc.types.NullPolicy.EXCLUDE
+                if not options
+                else plc.types.NullPolicy.INCLUDE
+            )
         elif name == "quantile":
             _, quantile = self.children
             if not isinstance(quantile, Literal):
@@ -86,7 +91,7 @@ class Agg(Expr):
             op = partial(self._reduce, request=req)
         elif name in {"min", "max"}:
             op = partial(op, propagate_nans=options)
-        elif name in {"count", "first", "last"}:
+        elif name in {"count", "sum", "first", "last"}:
             pass
         else:
             raise NotImplementedError(
@@ -175,6 +180,18 @@ class Agg(Expr):
             )
         )
 
+    def _sum(self, column: Column) -> Column:
+        if column.obj.size() == 0:
+            return Column(
+                plc.Column.from_scalar(
+                    plc.interop.from_arrow(
+                        pa.scalar(0, type=plc.interop.to_arrow(self.dtype))
+                    ),
+                    1,
+                )
+            )
+        return self._reduce(column, request=plc.aggregation.sum())
+
     def _min(self, column: Column, *, propagate_nans: bool) -> Column:
         if propagate_nans and column.nan_count > 0:
             return Column(

cudf_polars/dsl/expressions/base.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
     from cudf_polars.containers import Column, DataFrame
 
-__all__ = ["Expr", "NamedExpr", "Col", "AggInfo", "ExecutionContext", "ColRef"]
+__all__ = ["AggInfo", "Col", "ColRef", "ExecutionContext", "Expr", "NamedExpr"]
 
 
 class AggInfo(NamedTuple):
@@ -36,9 +36,11 @@ class ExecutionContext(IntEnum):
 class Expr(Node["Expr"]):
     """An abstract expression object."""
 
-    __slots__ = ("dtype",)
+    __slots__ = ("dtype", "is_pointwise")
     dtype: plc.DataType
     """Data type of the expression."""
+    is_pointwise: bool
+    """Whether this expression acts pointwise on its inputs."""
     # This annotation is needed because of https://github.com/python/mypy/issues/17981
     _non_child: ClassVar[tuple[str, ...]] = ("dtype",)
     """Names of non-child data (not Exprs) for reconstruction."""
@@ -164,6 +166,7 @@ class ErrorExpr(Expr):
         self.dtype = dtype
         self.error = error
         self.children = ()
+        self.is_pointwise = True
 
 
 class NamedExpr:
@@ -243,6 +246,7 @@ class Col(Expr):
     def __init__(self, dtype: plc.DataType, name: str) -> None:
         self.dtype = dtype
         self.name = name
+        self.is_pointwise = True
         self.children = ()
 
     def do_evaluate(
@@ -280,6 +284,7 @@ class ColRef(Expr):
         self.dtype = dtype
         self.index = index
         self.table_ref = table_ref
+        self.is_pointwise = True
         self.children = (column,)
 
     def do_evaluate(

cudf_polars/dsl/expressions/binaryop.py

@@ -42,6 +42,7 @@ class BinOp(Expr):
             op = BinOp._BOOL_KLEENE_MAPPING.get(op, op)
         self.op = op
         self.children = (left, right)
+        self.is_pointwise = True
         if not plc.binaryop.is_supported_operation(
             self.dtype, left.dtype, right.dtype, op
         ):

cudf_polars/dsl/expressions/boolean.py

@@ -6,13 +6,12 @@
 
 from __future__ import annotations
 
+from enum import IntEnum, auto
 from functools import partial, reduce
 from typing import TYPE_CHECKING, Any, ClassVar
 
 import pyarrow as pa
 
-from polars.polars import _expr_nodes as pl_expr
-
 import pylibcudf as plc
 
 from cudf_polars.containers import Column
@@ -24,7 +23,10 @@ from cudf_polars.dsl.expressions.base import (
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
+    from typing_extensions import Self
+
     import polars.type_aliases as pl_types
+    from polars.polars import _expr_nodes as pl_expr
 
     from cudf_polars.containers import DataFrame
 
@@ -32,13 +34,46 @@ __all__ = ["BooleanFunction"]
 
 
 class BooleanFunction(Expr):
+    class Name(IntEnum):
+        """Internal and picklable representation of polars' `BooleanFunction`."""
+
+        All = auto()
+        AllHorizontal = auto()
+        Any = auto()
+        AnyHorizontal = auto()
+        IsBetween = auto()
+        IsDuplicated = auto()
+        IsFinite = auto()
+        IsFirstDistinct = auto()
+        IsIn = auto()
+        IsInfinite = auto()
+        IsLastDistinct = auto()
+        IsNan = auto()
+        IsNotNan = auto()
+        IsNotNull = auto()
+        IsNull = auto()
+        IsUnique = auto()
+        Not = auto()
+
+        @classmethod
+        def from_polars(cls, obj: pl_expr.BooleanFunction) -> Self:
+            """Convert from polars' `BooleanFunction`."""
+            try:
+                function, name = str(obj).split(".", maxsplit=1)
+            except ValueError:
+                # Failed to unpack string
+                function = None
+            if function != "BooleanFunction":
+                raise ValueError("BooleanFunction required")
+            return getattr(cls, name)
+
     __slots__ = ("name", "options")
     _non_child = ("dtype", "name", "options")
 
     def __init__(
         self,
         dtype: plc.DataType,
-        name: pl_expr.BooleanFunction,
+        name: BooleanFunction.Name,
         options: tuple[Any, ...],
         *children: Expr,
     ) -> None:
@@ -46,7 +81,15 @@ class BooleanFunction(Expr):
         self.options = options
         self.name = name
         self.children = children
-        if self.name == pl_expr.BooleanFunction.IsIn and not all(
+        self.is_pointwise = self.name not in (
+            BooleanFunction.Name.All,
+            BooleanFunction.Name.Any,
+            BooleanFunction.Name.IsDuplicated,
+            BooleanFunction.Name.IsFirstDistinct,
+            BooleanFunction.Name.IsLastDistinct,
+            BooleanFunction.Name.IsUnique,
+        )
+        if self.name is BooleanFunction.Name.IsIn and not all(
             c.dtype == self.children[0].dtype for c in self.children
         ):
             # TODO: If polars IR doesn't put the casts in, we need to
@@ -110,12 +153,12 @@ class BooleanFunction(Expr):
     ) -> Column:
         """Evaluate this expression given a dataframe for context."""
         if self.name in (
-            pl_expr.BooleanFunction.IsFinite,
-            pl_expr.BooleanFunction.IsInfinite,
+            BooleanFunction.Name.IsFinite,
+            BooleanFunction.Name.IsInfinite,
         ):
             # Avoid evaluating the child if the dtype tells us it's unnecessary.
             (child,) = self.children
-            is_finite = self.name == pl_expr.BooleanFunction.IsFinite
+            is_finite = self.name is BooleanFunction.Name.IsFinite
             if child.dtype.id() not in (plc.TypeId.FLOAT32, plc.TypeId.FLOAT64):
                 value = plc.interop.from_arrow(
                     pa.scalar(value=is_finite, type=plc.interop.to_arrow(self.dtype))
@@ -142,10 +185,10 @@ class BooleanFunction(Expr):
         ]
         # Kleene logic for Any (OR) and All (AND) if ignore_nulls is
         # False
-        if self.name in (pl_expr.BooleanFunction.Any, pl_expr.BooleanFunction.All):
+        if self.name in (BooleanFunction.Name.Any, BooleanFunction.Name.All):
             (ignore_nulls,) = self.options
             (column,) = columns
-            is_any = self.name == pl_expr.BooleanFunction.Any
+            is_any = self.name is BooleanFunction.Name.Any
             agg = plc.aggregation.any() if is_any else plc.aggregation.all()
             result = plc.reduce.reduce(column.obj, agg, self.dtype)
             if not ignore_nulls and column.obj.null_count() > 0:
@@ -160,32 +203,32 @@ class BooleanFunction(Expr):
                 # If the input null count was non-zero, we must
                 # post-process the result to insert the correct value.
                 h_result = plc.interop.to_arrow(result).as_py()
-                if is_any and not h_result or not is_any and h_result:
+                if (is_any and not h_result) or (not is_any and h_result):
                     # Any                     All
                     # False || Null => Null   True && Null => Null
                     return Column(plc.Column.all_null_like(column.obj, 1))
             return Column(plc.Column.from_scalar(result, 1))
-        if self.name == pl_expr.BooleanFunction.IsNull:
+        if self.name is BooleanFunction.Name.IsNull:
             (column,) = columns
             return Column(plc.unary.is_null(column.obj))
-        elif self.name == pl_expr.BooleanFunction.IsNotNull:
+        elif self.name is BooleanFunction.Name.IsNotNull:
             (column,) = columns
             return Column(plc.unary.is_valid(column.obj))
-        elif self.name == pl_expr.BooleanFunction.IsNan:
+        elif self.name is BooleanFunction.Name.IsNan:
             (column,) = columns
             return Column(
                 plc.unary.is_nan(column.obj).with_mask(
                     column.obj.null_mask(), column.obj.null_count()
                 )
             )
-        elif self.name == pl_expr.BooleanFunction.IsNotNan:
+        elif self.name is BooleanFunction.Name.IsNotNan:
             (column,) = columns
             return Column(
                 plc.unary.is_not_nan(column.obj).with_mask(
                     column.obj.null_mask(), column.obj.null_count()
                 )
             )
-        elif self.name == pl_expr.BooleanFunction.IsFirstDistinct:
+        elif self.name is BooleanFunction.Name.IsFirstDistinct:
             (column,) = columns
             return self._distinct(
                 column,
@@ -197,7 +240,7 @@ class BooleanFunction(Expr):
                     pa.scalar(value=False, type=plc.interop.to_arrow(self.dtype))
                 ),
             )
-        elif self.name == pl_expr.BooleanFunction.IsLastDistinct:
+        elif self.name is BooleanFunction.Name.IsLastDistinct:
             (column,) = columns
             return self._distinct(
                 column,
@@ -209,7 +252,7 @@ class BooleanFunction(Expr):
                     pa.scalar(value=False, type=plc.interop.to_arrow(self.dtype))
                 ),
             )
-        elif self.name == pl_expr.BooleanFunction.IsUnique:
+        elif self.name is BooleanFunction.Name.IsUnique:
             (column,) = columns
             return self._distinct(
                 column,
@@ -221,7 +264,7 @@ class BooleanFunction(Expr):
                     pa.scalar(value=False, type=plc.interop.to_arrow(self.dtype))
                 ),
             )
-        elif self.name == pl_expr.BooleanFunction.IsDuplicated:
+        elif self.name is BooleanFunction.Name.IsDuplicated:
             (column,) = columns
             return self._distinct(
                 column,
@@ -233,7 +276,7 @@ class BooleanFunction(Expr):
                     pa.scalar(value=True, type=plc.interop.to_arrow(self.dtype))
                 ),
             )
-        elif self.name == pl_expr.BooleanFunction.AllHorizontal:
+        elif self.name is BooleanFunction.Name.AllHorizontal:
             return Column(
                 reduce(
                     partial(
@@ -244,7 +287,7 @@ class BooleanFunction(Expr):
                     (c.obj for c in columns),
                 )
             )
-        elif self.name == pl_expr.BooleanFunction.AnyHorizontal:
+        elif self.name is BooleanFunction.Name.AnyHorizontal:
             return Column(
                 reduce(
                     partial(
@@ -255,10 +298,10 @@ class BooleanFunction(Expr):
                     (c.obj for c in columns),
                 )
             )
-        elif self.name == pl_expr.BooleanFunction.IsIn:
+        elif self.name is BooleanFunction.Name.IsIn:
             needles, haystack = columns
             return Column(plc.search.contains(haystack.obj, needles.obj))
-        elif self.name == pl_expr.BooleanFunction.Not:
+        elif self.name is BooleanFunction.Name.Not:
             (column,) = columns
             return Column(
                 plc.unary.unary_operation(column.obj, plc.unary.UnaryOperator.NOT)

cudf_polars/dsl/expressions/datetime.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES.
 # SPDX-License-Identifier: Apache-2.0
 # TODO: remove need for this
 # ruff: noqa: D101
@@ -6,12 +6,11 @@
 
 from __future__ import annotations
 
+from enum import IntEnum, auto
 from typing import TYPE_CHECKING, Any, ClassVar
 
 import pyarrow as pa
 
-from polars.polars import _expr_nodes as pl_expr
-
 import pylibcudf as plc
 
 from cudf_polars.containers import Column
@@ -20,33 +19,95 @@ from cudf_polars.dsl.expressions.base import ExecutionContext, Expr
 if TYPE_CHECKING:
     from collections.abc import Mapping
 
+    from typing_extensions import Self
+
+    from polars.polars import _expr_nodes as pl_expr
+
     from cudf_polars.containers import DataFrame
 
 __all__ = ["TemporalFunction"]
 
 
 class TemporalFunction(Expr):
+    class Name(IntEnum):
+        """Internal and picklable representation of polars' `TemporalFunction`."""
+
+        BaseUtcOffset = auto()
+        CastTimeUnit = auto()
+        Century = auto()
+        Combine = auto()
+        ConvertTimeZone = auto()
+        DSTOffset = auto()
+        Date = auto()
+        Datetime = auto()
+        DatetimeFunction = auto()
+        Day = auto()
+        Duration = auto()
+        Hour = auto()
+        IsLeapYear = auto()
+        IsoYear = auto()
+        Microsecond = auto()
+        Millennium = auto()
+        Millisecond = auto()
+        Minute = auto()
+        Month = auto()
+        MonthEnd = auto()
+        MonthStart = auto()
+        Nanosecond = auto()
+        OffsetBy = auto()
+        OrdinalDay = auto()
+        Quarter = auto()
+        Replace = auto()
+        ReplaceTimeZone = auto()
+        Round = auto()
+        Second = auto()
+        Time = auto()
+        TimeStamp = auto()
+        ToString = auto()
+        TotalDays = auto()
+        TotalHours = auto()
+        TotalMicroseconds = auto()
+        TotalMilliseconds = auto()
+        TotalMinutes = auto()
+        TotalNanoseconds = auto()
+        TotalSeconds = auto()
+        Truncate = auto()
+        Week = auto()
+        WeekDay = auto()
+        WithTimeUnit = auto()
+        Year = auto()
+
+        @classmethod
+        def from_polars(cls, obj: pl_expr.TemporalFunction) -> Self:
+            """Convert from polars' `TemporalFunction`."""
+            try:
+                function, name = str(obj).split(".", maxsplit=1)
+            except ValueError:
+                # Failed to unpack string
+                function = None
+            if function != "TemporalFunction":
+                raise ValueError("TemporalFunction required")
+            return getattr(cls, name)
+
     __slots__ = ("name", "options")
-    _COMPONENT_MAP: ClassVar[
-        dict[pl_expr.TemporalFunction, plc.datetime.DatetimeComponent]
-    ] = {
-        pl_expr.TemporalFunction.Year: plc.datetime.DatetimeComponent.YEAR,
-        pl_expr.TemporalFunction.Month: plc.datetime.DatetimeComponent.MONTH,
-        pl_expr.TemporalFunction.Day: plc.datetime.DatetimeComponent.DAY,
-        pl_expr.TemporalFunction.WeekDay: plc.datetime.DatetimeComponent.WEEKDAY,
-        pl_expr.TemporalFunction.Hour: plc.datetime.DatetimeComponent.HOUR,
-        pl_expr.TemporalFunction.Minute: plc.datetime.DatetimeComponent.MINUTE,
-        pl_expr.TemporalFunction.Second: plc.datetime.DatetimeComponent.SECOND,
-        pl_expr.TemporalFunction.Millisecond: plc.datetime.DatetimeComponent.MILLISECOND,
-        pl_expr.TemporalFunction.Microsecond: plc.datetime.DatetimeComponent.MICROSECOND,
-        pl_expr.TemporalFunction.Nanosecond: plc.datetime.DatetimeComponent.NANOSECOND,
-    }
     _non_child = ("dtype", "name", "options")
+    _COMPONENT_MAP: ClassVar[dict[Name, plc.datetime.DatetimeComponent]] = {
+        Name.Year: plc.datetime.DatetimeComponent.YEAR,
+        Name.Month: plc.datetime.DatetimeComponent.MONTH,
+        Name.Day: plc.datetime.DatetimeComponent.DAY,
+        Name.WeekDay: plc.datetime.DatetimeComponent.WEEKDAY,
+        Name.Hour: plc.datetime.DatetimeComponent.HOUR,
+        Name.Minute: plc.datetime.DatetimeComponent.MINUTE,
+        Name.Second: plc.datetime.DatetimeComponent.SECOND,
+        Name.Millisecond: plc.datetime.DatetimeComponent.MILLISECOND,
+        Name.Microsecond: plc.datetime.DatetimeComponent.MICROSECOND,
+        Name.Nanosecond: plc.datetime.DatetimeComponent.NANOSECOND,
+    }
 
     def __init__(
         self,
         dtype: plc.DataType,
-        name: pl_expr.TemporalFunction,
+        name: TemporalFunction.Name,
         options: tuple[Any, ...],
         *children: Expr,
     ) -> None:
@@ -54,6 +115,7 @@ class TemporalFunction(Expr):
         self.options = options
         self.name = name
         self.children = children
+        self.is_pointwise = True
         if self.name not in self._COMPONENT_MAP:
             raise NotImplementedError(f"Temporal function {self.name}")
 
@@ -70,7 +132,7 @@ class TemporalFunction(Expr):
             for child in self.children
         ]
         (column,) = columns
-        if self.name == pl_expr.TemporalFunction.Microsecond:
+        if self.name is TemporalFunction.Name.Microsecond:
             millis = plc.datetime.extract_datetime_component(
                 column.obj, plc.datetime.DatetimeComponent.MILLISECOND
             )
@@ -90,7 +152,7 @@ class TemporalFunction(Expr):
                 plc.types.DataType(plc.types.TypeId.INT32),
             )
             return Column(total_micros)
-        elif self.name == pl_expr.TemporalFunction.Nanosecond:
+        elif self.name is TemporalFunction.Name.Nanosecond:
             millis = plc.datetime.extract_datetime_component(
                 column.obj, plc.datetime.DatetimeComponent.MILLISECOND
             )

cudf_polars/dsl/expressions/literal.py

@@ -38,6 +38,7 @@ class Literal(Expr):
         assert value.type == plc.interop.to_arrow(dtype)
         self.value = value
         self.children = ()
+        self.is_pointwise = True
 
     def do_evaluate(
         self,
@@ -65,6 +66,7 @@ class LiteralColumn(Expr):
         data = value.to_arrow()
         self.value = data.cast(dtypes.downcast_arrow_lists(data.type))
         self.children = ()
+        self.is_pointwise = True
 
     def get_hashable(self) -> Hashable:
         """Compute a hash of the column."""

cudf_polars/dsl/expressions/rolling.py

@@ -13,7 +13,7 @@ from cudf_polars.dsl.expressions.base import Expr
 if TYPE_CHECKING:
     import pylibcudf as plc
 
-__all__ = ["RollingWindow", "GroupedRollingWindow"]
+__all__ = ["GroupedRollingWindow", "RollingWindow"]
 
 
 class RollingWindow(Expr):
@@ -24,6 +24,7 @@ class RollingWindow(Expr):
         self.dtype = dtype
         self.options = options
         self.children = (agg,)
+        self.is_pointwise = False
         raise NotImplementedError("Rolling window not implemented")
 
 
@@ -35,4 +36,5 @@ class GroupedRollingWindow(Expr):
         self.dtype = dtype
         self.options = options
         self.children = (agg, *by)
+        self.is_pointwise = False
         raise NotImplementedError("Grouped rolling window not implemented")