cudf-polars-cu13 25.10.0__py3-none-any.whl → 26.2.0__py3-none-any.whl

cudf_polars/dsl/expressions/datetime.py

@@ -17,7 +17,7 @@ from cudf_polars.dsl.expressions.base import ExecutionContext, Expr
 if TYPE_CHECKING:
     from typing_extensions import Self
 
-    from polars.polars import _expr_nodes as pl_expr
+    from polars import polars  # type: ignore[attr-defined]
 
     from cudf_polars.containers import DataFrame, DataType
 
@@ -75,7 +75,7 @@ class TemporalFunction(Expr):
         Year = auto()
 
         @classmethod
-        def from_polars(cls, obj: pl_expr.TemporalFunction) -> Self:
+        def from_polars(cls, obj: polars._expr_nodes.TemporalFunction) -> Self:
             """Convert from polars' `TemporalFunction`."""
             try:
                 function, name = str(obj).split(".", maxsplit=1)
@@ -129,7 +129,7 @@ class TemporalFunction(Expr):
             raise NotImplementedError(f"Temporal function {self.name}")
 
         if self.name is TemporalFunction.Name.ToString and plc.traits.is_duration(
-            self.children[0].dtype.plc
+            self.children[0].dtype.plc_type
         ):
             raise NotImplementedError("ToString is not supported on duration types")
 
@@ -140,13 +140,19 @@ class TemporalFunction(Expr):
         columns = [child.evaluate(df, context=context) for child in self.children]
         (column,) = columns
         if self.name is TemporalFunction.Name.CastTimeUnit:
-            return Column(plc.unary.cast(column.obj, self.dtype.plc), dtype=self.dtype)
+            return Column(
+                plc.unary.cast(column.obj, self.dtype.plc_type, stream=df.stream),
+                dtype=self.dtype,
+            )
         if self.name == TemporalFunction.Name.ToString:
             return Column(
                 plc.strings.convert.convert_datetime.from_timestamps(
                     column.obj,
                     self.options[0],
-                    plc.Column.from_iterable_of_py([], dtype=self.dtype.plc),
+                    plc.Column.from_iterable_of_py(
+                        [], dtype=self.dtype.plc_type, stream=df.stream
+                    ),
+                    stream=df.stream,
                 ),
                 dtype=self.dtype,
             )
@@ -156,10 +162,12 @@ class TemporalFunction(Expr):
                     column.obj,
                     format="%V",
                     input_strings_names=plc.Column.from_iterable_of_py(
-                        [], dtype=plc.DataType(plc.TypeId.STRING)
+                        [], dtype=plc.DataType(plc.TypeId.STRING), stream=df.stream
                     ),
+                    stream=df.stream,
                 ),
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             return Column(result, dtype=self.dtype)
         if self.name is TemporalFunction.Name.IsoYear:
@@ -168,97 +176,117 @@ class TemporalFunction(Expr):
                     column.obj,
                     format="%G",
                     input_strings_names=plc.Column.from_iterable_of_py(
-                        [], dtype=plc.DataType(plc.TypeId.STRING)
+                        [], dtype=plc.DataType(plc.TypeId.STRING), stream=df.stream
                     ),
+                    stream=df.stream,
                 ),
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             return Column(result, dtype=self.dtype)
         if self.name is TemporalFunction.Name.MonthStart:
-            ends = plc.datetime.last_day_of_month(column.obj)
-            days_to_subtract = plc.datetime.days_in_month(column.obj)
+            ends = plc.datetime.last_day_of_month(column.obj, stream=df.stream)
+            days_to_subtract = plc.datetime.days_in_month(column.obj, stream=df.stream)
             # must subtract 1 to avoid rolling over to the previous month
             days_to_subtract = plc.binaryop.binary_operation(
                 days_to_subtract,
-                plc.Scalar.from_py(1, plc.DataType(plc.TypeId.INT32)),
+                plc.Scalar.from_py(1, plc.DataType(plc.TypeId.INT32), stream=df.stream),
                 plc.binaryop.BinaryOperator.SUB,
                 plc.DataType(plc.TypeId.DURATION_DAYS),
+                stream=df.stream,
             )
             result = plc.binaryop.binary_operation(
                 ends,
                 days_to_subtract,
                 plc.binaryop.BinaryOperator.SUB,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
 
             return Column(result, dtype=self.dtype)
         if self.name is TemporalFunction.Name.MonthEnd:
             return Column(
                 plc.unary.cast(
-                    plc.datetime.last_day_of_month(column.obj), self.dtype.plc
+                    plc.datetime.last_day_of_month(column.obj, stream=df.stream),
+                    self.dtype.plc_type,
+                    stream=df.stream,
                 ),
                 dtype=self.dtype,
             )
         if self.name is TemporalFunction.Name.IsLeapYear:
             return Column(
-                plc.datetime.is_leap_year(column.obj),
+                plc.datetime.is_leap_year(column.obj, stream=df.stream),
                 dtype=self.dtype,
             )
         if self.name is TemporalFunction.Name.OrdinalDay:
-            return Column(plc.datetime.day_of_year(column.obj), dtype=self.dtype)
+            return Column(
+                plc.datetime.day_of_year(column.obj, stream=df.stream), dtype=self.dtype
+            )
         if self.name is TemporalFunction.Name.Microsecond:
             millis = plc.datetime.extract_datetime_component(
-                column.obj, plc.datetime.DatetimeComponent.MILLISECOND
+                column.obj, plc.datetime.DatetimeComponent.MILLISECOND, stream=df.stream
             )
             micros = plc.datetime.extract_datetime_component(
-                column.obj, plc.datetime.DatetimeComponent.MICROSECOND
+                column.obj, plc.datetime.DatetimeComponent.MICROSECOND, stream=df.stream
             )
             millis_as_micros = plc.binaryop.binary_operation(
                 millis,
-                plc.Scalar.from_py(1_000, plc.DataType(plc.TypeId.INT32)),
+                plc.Scalar.from_py(
+                    1_000, plc.DataType(plc.TypeId.INT32), stream=df.stream
+                ),
                 plc.binaryop.BinaryOperator.MUL,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             total_micros = plc.binaryop.binary_operation(
                 micros,
                 millis_as_micros,
                 plc.binaryop.BinaryOperator.ADD,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             return Column(total_micros, dtype=self.dtype)
         elif self.name is TemporalFunction.Name.Nanosecond:
             millis = plc.datetime.extract_datetime_component(
-                column.obj, plc.datetime.DatetimeComponent.MILLISECOND
+                column.obj, plc.datetime.DatetimeComponent.MILLISECOND, stream=df.stream
             )
             micros = plc.datetime.extract_datetime_component(
-                column.obj, plc.datetime.DatetimeComponent.MICROSECOND
+                column.obj, plc.datetime.DatetimeComponent.MICROSECOND, stream=df.stream
             )
             nanos = plc.datetime.extract_datetime_component(
-                column.obj, plc.datetime.DatetimeComponent.NANOSECOND
+                column.obj, plc.datetime.DatetimeComponent.NANOSECOND, stream=df.stream
             )
             millis_as_nanos = plc.binaryop.binary_operation(
                 millis,
-                plc.Scalar.from_py(1_000_000, plc.DataType(plc.TypeId.INT32)),
+                plc.Scalar.from_py(
+                    1_000_000, plc.DataType(plc.TypeId.INT32), stream=df.stream
+                ),
                 plc.binaryop.BinaryOperator.MUL,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             micros_as_nanos = plc.binaryop.binary_operation(
                 micros,
-                plc.Scalar.from_py(1_000, plc.DataType(plc.TypeId.INT32)),
+                plc.Scalar.from_py(
+                    1_000, plc.DataType(plc.TypeId.INT32), stream=df.stream
+                ),
                 plc.binaryop.BinaryOperator.MUL,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             total_nanos = plc.binaryop.binary_operation(
                 nanos,
                 millis_as_nanos,
                 plc.binaryop.BinaryOperator.ADD,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             total_nanos = plc.binaryop.binary_operation(
                 total_nanos,
                 micros_as_nanos,
                 plc.binaryop.BinaryOperator.ADD,
-                self.dtype.plc,
+                self.dtype.plc_type,
+                stream=df.stream,
             )
             return Column(total_nanos, dtype=self.dtype)
 
@@ -266,6 +294,7 @@ class TemporalFunction(Expr):
             plc.datetime.extract_datetime_component(
                 column.obj,
                 self._COMPONENT_MAP[self.name],
+                stream=df.stream,
             ),
             dtype=self.dtype,
         )

cudf_polars/dsl/expressions/literal.py

@@ -43,7 +43,11 @@ class Literal(Expr):
     ) -> Column:
         """Evaluate this expression given a dataframe for context."""
         return Column(
-            plc.Column.from_scalar(plc.Scalar.from_py(self.value, self.dtype.plc), 1),
+            plc.Column.from_scalar(
+                plc.Scalar.from_py(self.value, self.dtype.plc_type, stream=df.stream),
+                1,
+                stream=df.stream,
+            ),
             dtype=self.dtype,
         )
 
@@ -60,8 +64,8 @@ class Literal(Expr):
         else:
             # Use polars to cast instead of pylibcudf
             # since there are just Python scalars
-            casted = pl.Series(values=[self.value], dtype=self.dtype.polars).cast(
-                dtype.polars
+            casted = pl.Series(values=[self.value], dtype=self.dtype.polars_type).cast(
+                dtype.polars_type
             )[0]
             return Literal(dtype, casted)
 
@@ -82,13 +86,15 @@ class LiteralColumn(Expr):
         # This is stricter than necessary, but we only need this hash
         # for identity in groupby replacements so it's OK. And this
         # way we avoid doing potentially expensive compute.
-        return (type(self), self.dtype.plc, id(self.value))
+        return (type(self), self.dtype.plc_type, id(self.value))
 
     def do_evaluate(
         self, df: DataFrame, *, context: ExecutionContext = ExecutionContext.FRAME
     ) -> Column:
         """Evaluate this expression given a dataframe for context."""
-        return Column(plc.Column.from_arrow(self.value), dtype=self.dtype)
+        return Column(
+            plc.Column.from_arrow(self.value, stream=df.stream), dtype=self.dtype
+        )
 
     @property
     def agg_request(self) -> NoReturn:  # noqa: D102