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.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
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.pyindex 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 failingdiff --git a/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.py b/marimo/_plugins/ui/_impl/dataframes/transforms/print_code.pyindex 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_datatypesdiff --git a/marimo/_smoke_tests/polars/temporal_conversion.py b/marimo/_smoke_tests/polars/temporal_conversion.pynew file mode 100644index 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.pyindex 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")