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.

12.6 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations

import datetime
from typing import cast

import pytest

from marimo._dependencies.dependencies import DependencyManager
from marimo._plugins import ui

HAS_PANDAS = DependencyManager.pandas.has()


@pytest.mark.parametrize("widget", [ui.date, ui.date_range])
@pytest.mark.parametrize(
    ("start", "stop"),
    [
        (datetime.datetime(2024, 1, 1, 12), None),
        (None, datetime.datetime(2024, 1, 31, 12)),
        (
            datetime.datetime(2024, 1, 1, 12),
            datetime.datetime(2024, 1, 31, 12),
        ),
        (datetime.datetime(2024, 1, 1, 12), datetime.date(2024, 1, 31)),
        ("2024-01-01", datetime.datetime(2024, 1, 31, 12)),
    ],
)
def test_date_datetime_bounds(widget, start, stop) -> None:
    picker = widget(start=start, stop=stop)
    first = datetime.date(2024, 1, 1)
    last = datetime.date(2024, 1, 31)
    assert (picker.start, picker.stop) == (
        first if start is not None else datetime.date.min,
        last if stop is not None else datetime.date.max,
    )
    if widget is ui.date:
        assert picker.value == (first if start is not None else last)
    else:
        assert picker.value == (
            first if start is not None else last,
            last if stop is not None else first,
        )
    assert picker._args.args == {
        "start": first.isoformat() if start is not None else "0001-01-01",
        "stop": last.isoformat() if stop is not None else "9999-12-31",
        "full-width": False,
        "disabled": False,
    }


@pytest.mark.parametrize("widget", [ui.date, ui.date_range])
@pytest.mark.parametrize(
    "value",
    [
        datetime.datetime(2024, 1, 1, 12),
        datetime.datetime(
            2024,
            1,
            1,
            23,
            tzinfo=datetime.timezone(datetime.timedelta(hours=-8)),
        ),
    ],
)
def test_date_datetime_value(widget, value) -> None:
    expected = datetime.date(2024, 1, 1)
    picker = widget(value=value if widget is ui.date else (value, value))
    assert picker.value == (
        expected if widget is ui.date else (expected, expected)
    )

    # Bounds and values are compared by date, regardless of time of day.
    picker = widget(
        start=datetime.datetime(2024, 1, 1, 18),
        stop=datetime.datetime(2024, 1, 1, 6),
        value=value if widget is ui.date else (value, value),
    )
    assert picker.value == (
        expected if widget is ui.date else (expected, expected)
    )

    with pytest.raises(ValueError, match="The default value"):
        widget(
            start="2024-01-02",
            value=value if widget is ui.date else (value, value),
        )


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
@pytest.mark.parametrize("widget", [ui.date, ui.date_range])
def test_date_pandas_timestamps(widget) -> None:
    import pandas as pd

    series = pd.Series(
        [pd.Timestamp("2024-01-01 12:00"), pd.Timestamp("2024-01-31 18:00")]
    )
    first, last = datetime.date(2024, 1, 1), datetime.date(2024, 1, 31)
    picker = widget(start=series.min(), stop=series.max())
    assert (picker.start, picker.stop, picker.value) == (
        first,
        last,
        first if widget is ui.date else (first, last),
    )
    picker = widget(
        value=series.max()
        if widget is ui.date
        else (series.min(), series.max())
    )
    assert picker.value == (last if widget is ui.date else (first, last))


def test_date() -> None:
    date = ui.date()
    today = date.value
    assert today == datetime.date.today()

    date._update("2024-01-01")
    assert date.value == datetime.date(2024, 1, 1)

    date = ui.date(value="2024-01-01")
    assert date.value == datetime.date(2024, 1, 1)

    date = ui.date(value="2024-1-2")
    assert date.value == datetime.date(2024, 1, 2)

    date = ui.date(value="2024-01-01")
    date._update("2024-01-02")
    assert date.value == datetime.date(2024, 1, 2)


def test_datetime() -> None:
    # Test default initialization
    dt = ui.datetime()
    now = datetime.datetime.now()
    assert dt.value
    assert dt.value.date() == now.date()
    assert dt.value.hour == now.hour
    assert dt.value.minute == now.minute

    # Test initialization with a specific value
    dt = ui.datetime(value="2024-01-01T12:30")
    assert dt.value == datetime.datetime(2024, 1, 1, 12, 30)
    # Test initialization with a specific value
    dt = ui.datetime(value="2024-01-01T12")
    assert dt.value == datetime.datetime(2024, 1, 1, 12)
    dt = ui.datetime(value="2024-01-01")
    assert dt.value == datetime.datetime(2024, 1, 1)

    # Test updating the value
    dt._update("2024-02-15T08:45")
    assert dt.value == datetime.datetime(2024, 2, 15, 8, 45)

    # Test with start and stop
    dt = ui.datetime(
        value="2024-01-15T10:00",
        start="2024-01-01T00:00",
        stop="2024-12-31T23:59",
    )
    assert dt.value == datetime.datetime(2024, 1, 15, 10, 0)
    assert dt.start == datetime.datetime(2024, 1, 1, 0, 0)
    assert dt.stop == datetime.datetime(2024, 12, 31, 23, 59)


def test_datetime_min_max_iso_format() -> None:
    """Test that datetime.min and datetime.max are formatted correctly with ISO 8601.

    This test addresses issue #6700 where datetime.min was formatted as
    "1-01-01T00:00:00" instead of "0001-01-01T00:00:00" in some Docker
    environments, causing frontend parsing errors.
    """
    # Test with datetime.min
    dt = ui.datetime()
    start_arg: str = cast(str, dt._args.args.get("start"))
    stop_arg: str = cast(str, dt._args.args.get("stop"))

    # Verify that start and stop are properly formatted ISO 8601 strings
    # with 4-digit years (not single digit years like "1-01-01")
    assert start_arg is not None
    assert stop_arg is not None
    assert start_arg.startswith("0001-"), (
        f"Expected start to begin with '0001-', got: {start_arg}"
    )
    assert stop_arg.startswith("9999-"), (
        f"Expected stop to begin with '9999-', got: {stop_arg}"
    )

    # Verify exact format for datetime.min
    assert start_arg == "0001-01-01T00:00:00"

    # Test with explicit datetime.min and datetime.max
    dt_explicit = ui.datetime(
        start=datetime.datetime.min,
        stop=datetime.datetime.max,
    )
    start_explicit = dt_explicit._args.args.get("start")
    stop_explicit = dt_explicit._args.args.get("stop")

    assert start_explicit == "0001-01-01T00:00:00"
    assert stop_explicit == "9999-12-31T23:59:59"


def test_date_range() -> None:
    # Test default initialization
    dr = ui.date_range()
    today = datetime.date.today()
    assert dr.value == (today, today)

    # Test initialization with specific values
    dr = ui.date_range(value=("2024-01-01", "2024-01-31"))
    assert dr.value == (datetime.date(2024, 1, 1), datetime.date(2024, 1, 31))

    dr = ui.date_range(value=("2024-1-2", "2024-1-3"))
    assert dr.value == (datetime.date(2024, 1, 2), datetime.date(2024, 1, 3))

    # Test updating the value
    dr._update(("2024-02-01", "2024-02-29"))
    assert dr.value == (datetime.date(2024, 2, 1), datetime.date(2024, 2, 29))

    # Test with start and stop
    dr = ui.date_range(
        start="2024-01-01",
        stop="2024-12-31",
    )
    assert dr.start == datetime.date(2024, 1, 1)
    assert dr.stop == datetime.date(2024, 12, 31)
    assert dr.value == (dr.start, dr.stop)

    # Test with start, stop and value
    dr = ui.date_range(
        value=("2024-03-01", "2024-03-15"),
        start="2024-01-01",
        stop="2024-12-31",
    )
    assert dr.value == (datetime.date(2024, 3, 1), datetime.date(2024, 3, 15))
    assert dr.start == datetime.date(2024, 1, 1)
    assert dr.stop == datetime.date(2024, 12, 31)

    # Test invalid range (start date after end date)
    with pytest.raises(ValueError):
        ui.date_range(value=("2024-02-01", "2024-01-01"))


def test_date_range_single_bound_default() -> None:
    # When only start is given, the default must respect the supplied
    # bound instead of falling back to today (which would be out of the
    # declared [start, stop] range). Mirrors the date/datetime siblings.
    dr = ui.date_range(start="2030-01-01")
    assert dr.start == datetime.date(2030, 1, 1)
    assert dr.value == (datetime.date(2030, 1, 1), datetime.date(2030, 1, 1))
    assert dr.start <= dr.value[0]
    assert dr.value[1] <= dr.stop

    # When only stop is given, the default must respect it as well.
    dr = ui.date_range(stop="2000-01-01")
    assert dr.stop == datetime.date(2000, 1, 1)
    assert dr.value == (datetime.date(2000, 1, 1), datetime.date(2000, 1, 1))
    assert dr.start <= dr.value[0]
    assert dr.value[1] <= dr.stop


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
def test_date_from_dataframe() -> None:
    import pandas as pd

    df = pd.DataFrame(
        {"A": [pd.Timestamp("2024-01-01"), pd.Timestamp("2024-01-02")]}
    )
    date = ui.date.from_series(
        df["A"], value=datetime.date(2024, 1, 2), label="Custom label"
    )
    assert date.value == datetime.date(2024, 1, 2)
    assert date.start == datetime.date(2024, 1, 1)
    assert date.stop == datetime.date(2024, 1, 2)
    assert date._args.label == "Custom label"


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
def test_datetime_from_dataframe() -> None:
    import pandas as pd

    # Test from_series for datetime
    df_datetime = pd.DataFrame(
        {
            "B": [
                pd.Timestamp("2024-01-01 10:00"),
                pd.Timestamp("2024-01-02 14:30"),
            ]
        }
    )
    datetime_ui = ui.datetime.from_series(
        df_datetime["B"], value=datetime.datetime(2024, 1, 2, 14, 30)
    )
    assert datetime_ui.value == datetime.datetime(2024, 1, 2, 14, 30)
    assert datetime_ui.start == datetime.datetime(2024, 1, 1, 10, 0)
    assert datetime_ui.stop == datetime.datetime(2024, 1, 2, 14, 30)


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
def test_date_range_from_dataframe() -> None:
    import pandas as pd

    # Test from_series for date_range
    df_date_range = pd.DataFrame(
        {"C": [pd.Timestamp("2024-01-01"), pd.Timestamp("2024-01-31")]}
    )
    date_range_ui = ui.date_range.from_series(
        df_date_range["C"],
        value=(datetime.date(2024, 1, 15), datetime.date(2024, 1, 20)),
    )
    assert date_range_ui.value == (
        datetime.date(2024, 1, 15),
        datetime.date(2024, 1, 20),
    )
    assert date_range_ui.start == datetime.date(2024, 1, 1)
    assert date_range_ui.stop == datetime.date(2024, 1, 31)


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
@pytest.mark.parametrize("widget", [ui.date, ui.datetime, ui.date_range])
def test_date_from_empty_series(widget) -> None:
    import pandas as pd

    series = pd.Series([], dtype="datetime64[ns]")
    with pytest.raises(ValueError, match="provide explicit bounds"):
        widget.from_series(series)

    if widget is ui.datetime:
        start, stop = "2024-01-01T00:00", "2024-01-02T00:00"
    else:
        start, stop = "2024-01-01", "2024-01-02"
    element = widget.from_series(series, start=start, stop=stop)
    assert element.start.isoformat().startswith("2024-01-01")
    assert element.stop.isoformat().startswith("2024-01-02")


@pytest.mark.skipif(not HAS_PANDAS, reason="pandas not installed")
@pytest.mark.parametrize("widget", [ui.date, ui.datetime, ui.date_range])
def test_date_from_all_null_series(widget) -> None:
    import pandas as pd

    series = pd.Series([pd.NaT, pd.NaT], dtype="datetime64[ns]")
    with pytest.raises(ValueError, match="provide explicit bounds"):
        widget.from_series(series)


def test_datetime_precision_default() -> None:
    """Test that datetime precision defaults to 'minute'."""
    dt = ui.datetime(value="2024-01-01T12:30:45")

    # Check that precision is set to "minute" by default in the args
    precision = dt._args.args.get("precision")
    assert precision == "minute"


def test_datetime_precision_validation() -> None:
    """Test that datetime precision validation raises ValueError for invalid values."""
    # Valid precisions should work
    dt_hour = ui.datetime(value="2024-01-01T12:30:45", precision="hour")
    assert dt_hour._args.args.get("precision") == "hour"

    dt_minute = ui.datetime(value="2024-01-01T12:30:45", precision="minute")
    assert dt_minute._args.args.get("precision") == "minute"

    dt_second = ui.datetime(value="2024-01-01T12:30:45", precision="second")
    assert dt_second._args.args.get("precision") == "second"

    # Invalid precision should raise ValueError
    with pytest.raises(ValueError, match="precision must be"):
        ui.datetime(value="2024-01-01T12:30:45", precision="millisecond")  # type: ignore[arg-type]