Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

fix(dataframe): restore Polars text-to-temporal conversion (#11135)

Shahmir Varqha2dee1c1458f3
diff --git a/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py b/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py
index b18347ad1c..d71d489a19 100644
--- a/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py
+++ b/marimo/_plugins/ui/_impl/dataframes/transforms/handlers.py
@@ -111,6 +111,17 @@ class NarwhalsTransformHandler(TransformHandler[DataFrame]):
if narwhals_dtype is None:
raise ValueError(f"Unsupported dtype: {transform.data_type}")
+ # Polars 2 requires explicit parsers for string-to-temporal conversions.
+ if (
+ df.implementation.is_polars()
+ and data_type_str in {"date", "datetime64"}
+ and df.collect_schema()[transform.column_id] == nw.String
+ ):
+ column = col(transform.column_id)
+ if data_type_str == "date":
+ return df.with_columns(column.str.to_date())
+ return df.with_columns(column.str.to_datetime())
+
if transform.errors == "ignore":
# For ignore mode, wrap cast in a try-except at the expression level
# This will set invalid values to null rather than failing
diff --git a/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.py b/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.py
index ced183dc58..56bc587832 100644
--- a/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.py
+++ b/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.py
@@ -360,6 +360,26 @@ def python_print_polars(
if transform.type == TransformType.COLUMN_CONVERSION:
column_id, data_type = transform.column_id, transform.data_type
+ temporal_parsers = {
+ "date": ("Date", "to_date"),
+ "datetime64": ("Datetime", "to_datetime"),
+ }
+ temporal_parser = temporal_parsers.get(
+ data_type.replace("_", "").lower()
+ )
+ if temporal_parser is not None:
+ dtype, parser = temporal_parser
+ column = _as_literal(column_id)
+ strict = transform.errors == "raise"
+ return "\n".join(
+ [
+ df_name,
+ f"if {df_name}.collect_schema()[{column}] == pl.String:",
+ f" {df_name} = {df_name}.with_columns(pl.col({column}).str.{parser}())",
+ "else:",
+ f" {df_name} = {df_name}.cast({{{column}: pl.{dtype}}}, strict={strict})",
+ ]
+ )
try:
import polars.datatypes as pl_datatypes
diff --git a/marimo/_smoke_tests/polars/temporal_conversion.py b/marimo/_smoke_tests/polars/temporal_conversion.py
new file mode 100644
index 0000000000..a11e5b77f4
--- /dev/null
+++ b/marimo/_smoke_tests/polars/temporal_conversion.py
@@ -0,0 +1,76 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+# "marimo",
+# "polars>=1.9.0",
+# ]
+# ///
+
+import marimo
+
+__generated_with = "0.25.1"
+app = marimo.App(width="medium")
+
+
+def _():
+ import marimo as mo
+ import polars as pl
+
+ return mo, pl
+
+
+def _(pl):
+ events = pl.DataFrame(
+ {
+ "date_text": ["2026-10-07", "2026-10-08", None],
+ "timestamp_text": [
+ "2026-10-07 12:34:56.123456",
+ "2026-10-08 00:00:00",
+ None,
+ ],
+ }
+ )
+ return (events,)
+
+
+def _(mo):
+ mo.md("""
+ Convert the text columns to **datetime64** in each dataframe below.
+ Check that nulls are preserved and fractional seconds remain accurate.
+ Run the generated Python code to compare its results with the
+ dataframe UI.
+ """)
+ return
+
+
+def _(events, mo):
+ eager = mo.ui.dataframe(events)
+ eager
+ return (eager,)
+
+
+def _(eager):
+ eager.value
+ return
+
+
+def _(events, mo):
+ lazy = mo.ui.dataframe(events.lazy())
+ lazy
+ return (lazy,)
+
+
+def _(lazy):
+ lazy.value
+ return
+
+
+if __name__ == "__main__":
+ app.run()
diff --git a/tests/_plugins/ui/_impl/dataframes/test_print_code.py b/tests/_plugins/ui/_impl/dataframes/test_print_code.py
index fd6997d20d..801de80473 100644
--- a/tests/_plugins/ui/_impl/dataframes/test_print_code.py
+++ b/tests/_plugins/ui/_impl/dataframes/test_print_code.py
@@ -1038,6 +1038,170 @@ def test_print_code_result_matches_actual_transform_polars(
pl_testing.assert_frame_equal(code_result, real_result)
+ not DependencyManager.polars.has(), reason="polars not installed"
+)
[email protected]("lazy", [False, True])
[email protected]("errors", ["raise", "ignore"])
+ ("data_type", "values", "expected_values"),
+ [
+ (
+ "date",
+ ["2026-10-07", None, "2026-10-08"],
+ [datetime.date(2026, 10, 7), None, datetime.date(2026, 10, 8)],
+ ),
+ (
+ "datetime64",
+ ["2026-10-07 12:34:56.123456", None, "2026-10-08 00:00:00"],
+ [
+ datetime.datetime(2026, 10, 7, 12, 34, 56, 123456),
+ None,
+ datetime.datetime(2026, 10, 8),
+ ],
+ ),
+ (
+ "datetime64",
+ [datetime.date(2026, 10, 7), None],
+ [datetime.datetime(2026, 10, 7), None],
+ ),
+ (
+ "date",
+ [datetime.datetime(2026, 10, 7, 12), None],
+ [datetime.date(2026, 10, 7), None],
+ ),
+ (
+ "datetime64",
+ [0, 1_000_000],
+ [
+ datetime.datetime(1970, 1, 1),
+ datetime.datetime(1970, 1, 1, 0, 0, 1),
+ ],
+ ),
+ ],
+)
+def test_polars_temporal_conversion_code_matches_runtime(
+ lazy: bool,
+ errors: Literal["raise", "ignore"],
+ data_type: str,
+ values: list[str | datetime.date | int | None],
+ expected_values: list[datetime.date | None],
+) -> None:
+ import polars as pl
+ import polars.testing as pl_testing
+
+ column = 'event "time"'
+ original = pl.DataFrame({column: values, "id": range(len(values))})
+ source = original.lazy() if lazy else original
+ transform = ColumnConversionTransform(
+ type=TransformType.COLUMN_CONVERSION,
+ column_id=column,
+ data_type=data_type,
+ errors=errors,
+ )
+ runtime = (
+ NarwhalsTransformHandler.handle_column_conversion(
+ nw.from_native(source).lazy(), transform
+ )
+ .collect()
+ .to_native()
+ )
+ namespace = {"pl": pl, "df": source}
+ exec(
+ python_print_transforms(
+ "df", original.columns, [transform], python_print_polars
+ ),
+ namespace,
+ )
+ generated = namespace["df_next"]
+ if lazy:
+ generated = generated.collect()
+ expected = pl.DataFrame(
+ {column: expected_values, "id": range(len(values))}
+ )
+ pl_testing.assert_frame_equal(runtime, expected)
+ pl_testing.assert_frame_equal(generated, expected)
+ pl_testing.assert_frame_equal(
+ original, pl.DataFrame({column: values, "id": range(len(values))})
+ )
+
+
+ not DependencyManager.polars.has(), reason="polars not installed"
+)
[email protected]("values", [[], [None, None]])
[email protected]("data_type", ["date", "datetime64"])
+def test_polars_temporal_conversion_without_non_null_values(
+ values: list[None], data_type: str
+) -> None:
+ import polars as pl
+ import polars.testing as pl_testing
+
+ source = pl.LazyFrame(
+ {"event_time": values}, schema={"event_time": pl.String}
+ )
+ transform = ColumnConversionTransform(
+ type=TransformType.COLUMN_CONVERSION,
+ column_id="event_time",
+ data_type=data_type,
+ errors="raise",
+ )
+ runtime = (
+ NarwhalsTransformHandler.handle_column_conversion(
+ nw.from_native(source), transform
+ )
+ .collect()
+ .to_native()
+ )
+ namespace = {"pl": pl, "df": source}
+ exec(
+ python_print_transforms(
+ "df", ["event_time"], [transform], python_print_polars
+ ),
+ namespace,
+ )
+ dtype = pl.Date if data_type == "date" else pl.Datetime
+ expected = pl.DataFrame(
+ {"event_time": values}, schema={"event_time": dtype}
+ )
+ pl_testing.assert_frame_equal(runtime, expected)
+ pl_testing.assert_frame_equal(namespace["df_next"].collect(), expected)
+
+
+ not DependencyManager.polars.has(), reason="polars not installed"
+)
[email protected]("data_type", ["date", "datetime64"])
[email protected]("errors", ["raise", "ignore"])
+def test_polars_temporal_conversion_invalid_strings(
+ data_type: str, errors: Literal["raise", "ignore"]
+) -> None:
+ import polars as pl
+
+ source = pl.LazyFrame({"event_time": ["2026-10-07", "invalid", None]})
+ transform = ColumnConversionTransform(
+ type=TransformType.COLUMN_CONVERSION,
+ column_id="event_time",
+ data_type=data_type,
+ errors=errors,
+ )
+ runtime = NarwhalsTransformHandler.handle_column_conversion(
+ nw.from_native(source), transform
+ )
+ namespace = {"pl": pl, "df": source}
+ exec(
+ python_print_transforms(
+ "df", ["event_time"], [transform], python_print_polars
+ ),
+ namespace,
+ )
+ generated = namespace["df_next"]
+ with pytest.raises(nw.exceptions.InvalidOperationError):
+ runtime.collect()
+ with pytest.raises(pl.exceptions.InvalidOperationError):
+ generated.collect()
+
+
@pytest.mark.skipif(
not DependencyManager.polars.has(), reason="polars not installed"
)