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.

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

from dataclasses import dataclass
from typing import Any

import pytest

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

HAS_PANDAS = DependencyManager.pandas.has()
HAS_NUMPY = DependencyManager.numpy.has()


def test_number_init() -> None:
    number = ui.number(1, 10)
    assert number.start == 1
    assert number.stop == 10
    assert number.step is None
    assert number.value == 1

    number = ui.number(1, 10, value=5)
    assert number.start == 1
    assert number.stop == 10
    assert number.step is None
    assert number.value == 5
    number._update(6)
    assert number.value == 6
    number._update(6.5)
    # unlike slider, number should not round because users can type
    # arbitrary numbers
    assert number.value == 6.5


def test_number_out_of_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.number(1, 10, value=11)

    assert "must be less than or equal" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.number(1, 10, value=0)

    assert "must be greater than or equal" in str(e.value)


def test_number_invalid_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.number(1, 0)

    assert "must be less than or equal to" in str(e.value)


def test_number_default_value() -> None:
    # Test default value when not specified
    number = ui.number(1, 10)
    assert number.value == 1

    # Test default value when only stop is specified
    number = ui.number(stop=10)
    assert number.value == 10

    # Test default value when neither start nor stop is specified
    number = ui.number()
    assert number.value is None

    # Test default value with step
    number = ui.number(1, 10, step=2)
    assert number.value == 1

    # Test that explicitly set value overrides default
    number = ui.number(1, 10, value=5)
    assert number.value == 5


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

    df = pd.DataFrame({"A": [1, 2, 3]})
    number = ui.number.from_series(df["A"], step=0.1, label="Custom label")
    assert number.start == 1
    assert number.stop == 3
    assert number.value == 1
    assert number.step == 0.1
    assert number._args.label == "Custom label"


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

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

    element = widget.from_series(series, start=0, stop=100)
    assert element.start == 0
    assert element.stop == 100


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

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


@pytest.mark.parametrize("widget", [ui.number, ui.slider, ui.range_slider])
@pytest.mark.parametrize(
    "values", [[float("nan"), float("nan")], [None, float("nan")]]
)
def test_numeric_from_pyarrow_nan_series(widget, values) -> None:
    pa = pytest.importorskip("pyarrow")
    series = pa.table({"x": values})["x"]

    with pytest.raises(ValueError, match="provide explicit bounds"):
        widget.from_series(series)

    element = widget.from_series(series, start=0, stop=100)
    assert element.start == 0
    assert element.stop == 100


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

    series = pd.Series([], dtype=object)
    element = widget.from_series(series)
    assert element.options == {}

    element = widget.from_series(series, options=["a", "b"])
    assert element.options == {"a": "a", "b": "b"}


def test_slider_init() -> None:
    slider = ui.slider(1, 10)
    assert slider.start == 1
    assert slider.stop == 10
    assert slider.step is None
    assert slider.value == 1
    assert slider.steps is None

    slider = ui.slider(1, 10, value=5)
    assert slider.start == 1
    assert slider.stop == 10
    assert slider.step is None
    assert slider.value == 5
    assert slider.steps is None
    assert isinstance(slider.value, int)

    slider = ui.slider(1, 10, value=5.0)
    assert slider.value == 5.0
    assert isinstance(slider.value, float)

    slider._update(6)
    assert slider.value == 6.0
    assert isinstance(slider.value, float)

    slider = ui.slider(steps=[1, 3, 6], value=3)
    assert slider.start == 1
    assert slider.stop == 6
    assert slider.step is None
    assert slider.value == 3
    assert slider.steps == [1, 3, 6]

    # value not in steps, set to first value in steps
    slider = ui.slider(steps=[1, 3, 6], value=7)
    assert slider.value == 1


def test_slider_invalid_steps() -> None:
    """Tests for invalid steps"""
    # test for empty steps
    with pytest.raises(TypeError) as e:
        ui.slider(steps=[])

    assert "Invalid steps" in str(e.value)

    # test for non-numeric steps
    with pytest.raises(TypeError) as e:
        ui.slider(steps=[1, 4, "3"])

    assert "Invalid steps" in str(e.value)


def test_slider_invalid_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.slider(1, 0)

    assert "Invalid bounds" in str(e.value)


def test_slider_exclusive_args() -> None:
    with pytest.raises(ValueError) as e:
        ui.slider(start=1, steps=[1, 3, 6])

    assert "Invalid arguments" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.slider(step=2, start=3)

    assert "Missing arguments" in str(e.value)


def test_slider_out_of_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.slider(1, 10, value=11)

    assert "out of bounds" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.slider(1, 10, value=0)

    assert "out of bounds" in str(e.value)


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

    df = pd.DataFrame({"A": [1, 2, 3]})
    slider = ui.slider.from_series(df["A"], step=0.1, label="Custom label")
    assert slider.start == 1
    assert slider.stop == 3
    assert slider.value == 1
    assert slider.step == 0.1
    assert slider._args.label == "Custom label"


def test_range_slider_init() -> None:
    slider = ui.range_slider(1, 10)
    assert slider.start == 1
    assert slider.stop == 10
    assert slider.step is None
    assert slider.value == [1, 10]
    assert slider.steps is None

    slider = ui.range_slider(1, 10, value=[2, 5])
    assert slider.start == 1
    assert slider.stop == 10
    assert slider.step is None
    assert slider.value == [2, 5]
    assert slider.steps is None
    assert all(isinstance(num, int) for num in slider.value)

    slider = ui.range_slider(1, 10, value=[2.1, 5.1])
    assert slider.value == [2.1, 5.1]
    assert all(isinstance(num, float) for num in slider.value)

    slider._update([3, 6])
    assert slider.value == [3.0, 6.0]
    for num in slider.value:
        # initial value was a float, so ints should be
        # cast to floats
        assert isinstance(num, float)

    slider = ui.range_slider(steps=[1, 3, 6, 10, 17, 20], value=[3, 17])
    assert slider.start == 1
    assert slider.stop == 20
    assert slider.step is None
    assert slider.value == [3, 17]
    assert slider.steps == [1, 3, 6, 10, 17, 20]

    # value not in steps, set to first value in steps
    slider = ui.range_slider(steps=[1, 3, 6, 10, 17, 20], value=[7, 10])
    assert slider.value == [1, 20]


def test_range_slider_invalid_steps() -> None:
    """Tests for invalid steps"""
    # test for empty steps
    with pytest.raises(TypeError) as e:
        ui.range_slider(steps=[])

    assert "Invalid steps" in str(e.value)

    # test for non-numeric steps
    with pytest.raises(TypeError) as e:
        ui.range_slider(steps=[1, 4, "3"])

    assert "Invalid steps" in str(e.value)


def test_range_slider_invalid_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.range_slider(1, 0)

    assert "Invalid bounds" in str(e.value)


def test_range_slider_exclusive_args() -> None:
    with pytest.raises(ValueError) as e:
        ui.range_slider(start=1, steps=[1, 3, 6])

    assert "Invalid arguments" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.range_slider(step=2, start=3)

    assert "Missing arguments" in str(e.value)


def test_range_slider_out_of_bounds() -> None:
    with pytest.raises(ValueError) as e:
        ui.range_slider(1, 10, value=[1, 11])

    assert "out of bounds" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.range_slider(1, 10, value=[0, 10])

    assert "out of bounds" in str(e.value)


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

    df = pd.DataFrame({"A": [1, 2, 3]})
    slider = ui.range_slider.from_series(
        df["A"], step=0.1, label="Custom label"
    )
    assert slider.start == 1
    assert slider.stop == 3
    assert slider.value == [1, 3]
    assert slider.step == 0.1
    assert slider._args.label == "Custom label"


def test_text() -> None:
    assert ui.text().value == ""
    assert ui.text(value="hello world").value == "hello world"

    text = ui.text()
    text._update("value")
    assert text.value == "value"


def test_text_password_masking() -> None:
    from marimo._plugins.core.web_component import parse_initial_value

    t = ui.text(value="secret123", kind="password")

    # Python-side values are the real password
    assert t.value == "secret123"
    assert t._initial_value == "secret123"

    # Frontend-facing values are sanitized
    assert "secret123" not in t.text
    assert t._initial_value_frontend == ""
    assert parse_initial_value(t._inner_text) == ""

    # password-has-value arg is set
    assert t._component_args.get("password-has-value") is True

    # Update works normally
    t._update("new_password")
    assert t.value == "new_password"

    # Password without value: no masking needed
    t = ui.text(kind="password")
    assert t.value == ""
    assert t._component_args.get("password-has-value") is None

    # Non-password text: value appears in HTML normally
    t = ui.text(value="hello")
    assert "hello" in t.text


def test_text_password_masking_clone() -> None:
    from marimo._plugins.core.web_component import parse_initial_value

    t = ui.text(value="secret123", kind="password")
    clone = t._clone()

    # Clone preserves the real password in Python
    assert clone.value == "secret123"
    assert clone._initial_value == "secret123"

    # Clone's HTML is also sanitized
    assert "secret123" not in clone.text
    assert clone._initial_value_frontend == ""
    assert parse_initial_value(clone._inner_text) == ""


def test_text_password_masking_form_submit() -> None:
    # Form wraps a clone — password is preserved
    t = ui.text(value="secret123", kind="password")
    f = t.form()
    assert f.element.value == "secret123"

    # Submit without editing: "" is ignored while masked
    f._update("")
    assert f.value == "secret123"

    # Submit after user types: new value is used
    f2 = ui.text(value="secret123", kind="password").form()
    f2._update("new_password")
    assert f2.value == "new_password"

    # After unmasking, intentionally clearing to "" is accepted
    t2 = ui.text(value="secret123", kind="password")
    t2._update("a")  # unmask
    t2._update("")  # intentional clear
    assert t2.value == ""


def test_checkbox_init() -> None:
    assert not ui.checkbox().value
    assert ui.checkbox(value=True).value


def test_checkbox_rejects_non_bool_value() -> None:
    # `checkbox` is typed `UIElement[bool, bool]`; a non-bool value must raise
    # instead of being silently accepted.
    for bad in ("yes", 1, 0, [], None):
        with pytest.raises(ValueError, match="must be a bool"):
            ui.checkbox(value=bad)

    # bools still work
    assert ui.checkbox(value=True).value is True
    assert ui.checkbox(value=False).value is False
    assert ui.checkbox().value is False


def test_radio() -> None:
    radio = ui.radio(options=["1", "2", "3"], value="1")
    assert radio.value == "1"

    radio._update("2")
    assert radio.value == "2"

    radio = ui.radio(options={"1": 1, "2": 2, "3": 3}, value="1")
    assert radio.value == 1

    radio._update("2")
    assert radio.value == 2


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

    df = pd.DataFrame({"A": ["a", "b", "c"]})
    radio = ui.radio.from_series(df["A"], value="b")
    assert radio.options == {
        "a": "a",
        "b": "b",
        "c": "c",
    }
    assert radio.value == "b"


def test_radio_invalid_value() -> None:
    with pytest.raises(ValueError) as e:
        ui.radio(options=["1", "2", "3"], value="4")

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)

    radio = ui.radio(options=["1", "2", "3"], value="1")
    with pytest.raises(ValueError) as e:
        radio._update("4")

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)


def test_dropdown() -> None:
    dd = ui.dropdown(options=["1", "2", "3"])
    assert dd.value is None

    dd._update(["2"])
    assert dd.value == "2"

    dd = ui.dropdown(options={"1": 1, "2": 2, "3": 3}, value="1")
    assert dd.value == 1

    dd._update(["2"])
    assert dd.value == 2


@dataclass
class SomeObject:
    a: int


def test_dropdown_with_non_string_options() -> None:
    # Integer options
    dd = ui.dropdown(options=[1, 2, 3], value=1)
    assert dd.options == {"1": 1, "2": 2, "3": 3}
    assert dd.value == 1

    dd._update(["2"])
    assert dd.value == 2

    # Float options
    dd = ui.dropdown(options=[1.0, 2.0, 3.0], value=1.0)
    assert dd.options == {"1.0": 1.0, "2.0": 2.0, "3.0": 3.0}
    assert dd.value == 1.0

    dd._update(["2.0"])
    assert dd.value == 2.0

    # Boolean options
    dd = ui.dropdown(options=[True, False], value=True)
    assert dd.options == {"True": True, "False": False}
    assert dd.value is True

    dd._update(["False"])
    assert dd.value is False

    # Rich objects
    dd = ui.dropdown(
        options=[SomeObject(a=1), SomeObject(a=2), SomeObject(a=3)],
        value=SomeObject(a=1),
    )
    assert dd.options == {
        "SomeObject(a=1)": SomeObject(a=1),
        "SomeObject(a=2)": SomeObject(a=2),
        "SomeObject(a=3)": SomeObject(a=3),
    }
    assert dd.value == SomeObject(a=1)

    dd._update(["SomeObject(a=2)"])
    assert dd.value == SomeObject(a=2)

    # Mixed types
    dd = ui.dropdown(
        options=[1, "2", SomeObject(a=3)],
        value="2",
    )
    assert dd.options == {"1": 1, "2": "2", "SomeObject(a=3)": SomeObject(a=3)}
    assert dd.value == "2"


def test_dropdown_lots_of_options() -> None:
    dropdown = ui.dropdown(options={str(i): i for i in range(2000)})
    assert dropdown._component_args["searchable"] is True


def test_dropdown_invalid_value() -> None:
    with pytest.raises(ValueError) as e:
        ui.dropdown(options=["1", "2", "3"], value="4")

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)

    dd = ui.dropdown(options=["1", "2", "3"], value="1")
    with pytest.raises(ValueError) as e:
        dd._update(["4"])

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)


def test_dropdown_duplicate_option_names_raise() -> None:
    # Repeated names collapse silently without this guard.
    with pytest.raises(ValueError, match="Duplicate option name"):
        ui.dropdown(options=["a", "a", "b"])

    # Distinct values that stringify to the same name (int 1 vs str "1").
    with pytest.raises(ValueError, match="Duplicate option name"):
        ui.dropdown(options=[1, "1"])

    # Non-colliding options are unaffected; all are kept.
    dd = ui.dropdown(options=[1, "2", 3])
    assert len(dd.options) == 3

    # Explicit dict input is untouched (keys are already unique).
    dd = ui.dropdown(options={"a": 1, "b": 2})
    assert len(dd.options) == 2


def test_dropdown_disallow_select_none_infers_value() -> None:
    dd = ui.dropdown(options=["1", "2", "3"], allow_select_none=False)
    assert dd.value == "1"

    dd = ui.dropdown(options={"1": "a", "2": "b"}, allow_select_none=False)
    assert dd.value == "a"


def test_dropdown_disallow_select_none_with_empty_options_raises() -> None:
    msg = "when `allow_select_none` is False, `options` must not be empty"

    with pytest.raises(ValueError, match=msg):
        ui.dropdown(options={}, allow_select_none=False)

    with pytest.raises(ValueError, match=msg):
        ui.dropdown(options=[], allow_select_none=False)


def test_multiselect_duplicate_option_names_raise() -> None:
    with pytest.raises(ValueError, match="Duplicate option name"):
        ui.multiselect(options=["a", "a", "b"])

    with pytest.raises(ValueError, match="Duplicate option name"):
        ui.multiselect(options=[1, "1"])

    ms = ui.multiselect(options=[1, "2", 3])
    assert len(ms.options) == 3


def test_dropdown_disabled() -> None:
    dd = ui.dropdown(options=["1", "2", "3"])
    assert dd._component_args["disabled"] is False

    dd = ui.dropdown(options=["1", "2", "3"], disabled=True)
    assert dd._component_args["disabled"] is True


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

    df = pd.DataFrame({"A": ["a", "b", "c"]})
    dd = ui.dropdown.from_series(df["A"], value="b")
    assert dd.options == {
        "a": "a",
        "b": "b",
        "c": "c",
    }
    assert dd.value == "b"


def test_multiselect() -> None:
    options_list = ["Apples", "Oranges", "Bananas"]
    ms = ui.multiselect(options=options_list)
    assert ms.value == []

    ms._update(["Apples"])
    assert ms.value == ["Apples"]

    ms._update(["Apples", "Oranges"])
    assert ms.value == ["Apples", "Oranges"]

    options_dict = {"Apples": 1, "Oranges": 2, "Bananas": 3}
    ms = ui.multiselect(options=options_dict, value=["Apples"])
    assert ms.value == [1]

    ms._update(["Apples", "Oranges", "Bananas"])
    assert ms.value == [1, 2, 3]

    ms = ui.multiselect(options=options_list, max_selections=2)
    assert ms.value == []

    ms._update(["Apples"])
    assert ms.value == ["Apples"]

    with pytest.raises(ValueError):
        ms = ui.multiselect(
            options=options_list, value=options_list, max_selections=0
        )

    with pytest.raises(ValueError):
        ms = ui.multiselect(
            options=options_list, value=options_list, max_selections=2
        )

    with pytest.raises(ValueError):
        ms = ui.multiselect(options=options_list, max_selections=-10)


def test_multiselect_non_string_options() -> None:
    # Integer options
    options_list = [1, 2, 3]
    ms = ui.multiselect(options=options_list)
    assert ms.options == {"1": 1, "2": 2, "3": 3}
    assert ms.value == []

    ms._update(["1"])
    assert ms.value == [1]

    ms._update(["1", "2"])
    assert ms.value == [1, 2]

    # Float options
    options_list = [1.0, 2.0, 3.0]
    ms = ui.multiselect(options=options_list, value=[1.0])
    assert ms.options == {"1.0": 1.0, "2.0": 2.0, "3.0": 3.0}
    assert ms.value == [1.0]

    # Boolean options
    options_list = [True, False]
    ms = ui.multiselect(options=options_list, value=[True])
    assert ms.options == {"True": True, "False": False}
    assert ms.value == [True]

    # Rich objects
    options_list = [SomeObject(a=1), SomeObject(a=2), SomeObject(a=3)]
    ms = ui.multiselect(options=options_list, value=[SomeObject(a=1)])
    assert ms.options == {
        "SomeObject(a=1)": SomeObject(a=1),
        "SomeObject(a=2)": SomeObject(a=2),
        "SomeObject(a=3)": SomeObject(a=3),
    }
    assert ms.value == [SomeObject(a=1)]

    ms._update(["SomeObject(a=2)"])
    assert ms.value == [SomeObject(a=2)]

    # Mixed types
    options_list = [1, "2", (3, 4)]
    ms = ui.multiselect(options=options_list, value=["1"])
    assert ms.options == {"1": 1, "2": "2", "(3, 4)": (3, 4)}
    assert ms.value == [1]

    ms._update(["1", "(3, 4)"])
    assert ms.value == [1, (3, 4)]


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

    df = pd.DataFrame({"A": [1, 2, 3]})
    ms = ui.multiselect.from_series(df["A"], value=["2"])
    assert ms.options == {
        "1": 1,
        "2": 2,
        "3": 3,
    }
    assert ms.value == [2]


def test_multiselect_too_many_options() -> None:
    with pytest.raises(ValueError) as e:
        ui.multiselect(options={str(i): i for i in range(200000)})

    assert "maximum number" in str(e.value)


def test_multiselect_invalid_value() -> None:
    with pytest.raises(ValueError) as e:
        ui.multiselect(options=["1", "2", "3"], value=["4"])

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)

    ms = ui.multiselect(options=["1", "2", "3"], value=["1"])
    with pytest.raises(ValueError) as e:
        ms._update(["1", "4"])

    assert "The option name '4' is not a valid option" in str(e.value)
    assert "['1', '2', '3']" in str(e.value)


def test_multiselect_disabled() -> None:
    ms = ui.multiselect(options=["1", "2", "3"])
    assert ms._component_args["disabled"] is False

    ms = ui.multiselect(options=["1", "2", "3"], disabled=True)
    assert ms._component_args["disabled"] is True


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

    df = pd.DataFrame({"A": ["a", "b", "c"]})
    ms = ui.multiselect.from_series(df["A"], value=["b"])
    assert ms.options == {
        "a": "a",
        "b": "b",
        "c": "c",
    }
    assert ms.value == ["b"]


def test_button() -> None:
    assert ui.button().value is None
    assert ui.button(value=1).value == 1

    # default callback does nothing
    button = ui.button(value=1)
    button._update(None)
    assert button.value == 1

    button = ui.button(on_click=lambda v: v + 1, value=0)
    assert button.value == 0
    button._update(None)
    assert button.value == 1
    button._update(None)
    assert button.value == 2


def test_on_change() -> None:
    state = []
    button = ui.checkbox(on_change=lambda v: state.append(v))
    assert not state
    button._update(False)
    assert state == [False]
    button._update(True)
    assert state == [False, True]


def test_form_in_array_retains_on_change() -> None:
    def on_change(*args: Any) -> None:
        del args

    array = ui.array([ui.form(ui.checkbox(), on_change=on_change)])
    assert array[0]._on_change == on_change


def test_form_in_dictionary_allowed() -> None:
    checkbox = ui.checkbox()
    form = checkbox.form()
    d = ui.dictionary({"form": form})
    assert checkbox._id != d["form"].element._id


def test_file_validation() -> None:
    """Test file type validation in the file class."""
    # Valid filetypes should be accepted
    ui.file(filetypes=[".csv", ".txt"])
    ui.file(filetypes=["audio/*"])
    ui.file(filetypes=["video/*"])
    ui.file(filetypes=["image/*"])
    ui.file(filetypes=["application/json"])
    ui.file(filetypes=["text/plain"])
    ui.file(filetypes=[".csv", "application/json"])  # Mixed types are allowed
    ui.file(filetypes=["text/html", "application/xml"])  # Multiple MIME types

    # Invalid filetypes should raise ValueError
    with pytest.raises(ValueError) as e:
        ui.file(filetypes=["csv"])
    assert "must start with a dot" in str(e.value)
    assert "or contain a forward slash" in str(e.value)
    assert "csv" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.file(filetypes=["txt", ".csv"])
    assert "must start with a dot" in str(e.value)
    assert "or contain a forward slash" in str(e.value)
    assert "txt" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.file(filetypes=["doc", "pdf"])
    assert "must start with a dot" in str(e.value)
    assert "or contain a forward slash" in str(e.value)
    assert "doc, pdf" in str(e.value)

    # Test max_size validation
    with pytest.raises(ValueError) as e:
        ui.file(max_size=0)
    assert "max_size must be greater than 0" in str(e.value)

    with pytest.raises(ValueError) as e:
        ui.file(max_size=-1)
    assert "max_size must be greater than 0" in str(e.value)

    # Test default max_size
    f = ui.file()
    assert f._component_args["max_size"] == 100_000_000  # 100MB

    # Test custom max_size
    f = ui.file(max_size=50_000_000)  # 50MB
    assert f._component_args["max_size"] == 50_000_000


@pytest.mark.skipif(not HAS_NUMPY, reason="numpy not installed")
def test_numpy_steps() -> None:
    import numpy as np

    steps = np.array([1, 2, 3, 4, 5])
    slider = ui.slider(steps=steps)
    assert slider.steps == [1, 2, 3, 4, 5]
    assert slider.start == 1
    assert slider.stop == 5
    assert slider.step is None

    range_slider = ui.range_slider(steps=steps)
    assert range_slider.steps == [1, 2, 3, 4, 5]
    assert range_slider.start == 1
    assert range_slider.stop == 5
    assert range_slider.step is None


@pytest.mark.skipif(not HAS_NUMPY, reason="numpy not installed")
def test_log_scale() -> None:
    import numpy as np

    steps = np.logspace(0, 3, 4)
    slider = ui.slider(steps=steps)

    assert slider.steps == [1, 10, 100, 1000]
    assert slider.start == 1
    assert slider.stop == 1000
    assert slider.step is None

    range_slider = ui.range_slider(steps=steps)
    assert range_slider.steps == [1, 10, 100, 1000]
    assert range_slider.start == 1
    assert range_slider.stop == 1000
    assert range_slider.step is None


@pytest.mark.skipif(not HAS_NUMPY, reason="numpy not installed")
def test_power_scale() -> None:
    import numpy as np

    steps = np.power([1, 2, 3], 2)
    slider = ui.slider(steps=steps)
    assert slider.steps == [1, 4, 9]
    assert slider.start == 1
    assert slider.stop == 9
    assert slider.step is None

    range_slider = ui.range_slider(steps=steps)
    assert range_slider.steps == [1, 4, 9]
    assert range_slider.start == 1
    assert range_slider.stop == 9
    assert range_slider.step is None


def test_update_value_no_on_change() -> None:
    calls = []
    text = ui.text(on_change=lambda v: calls.append(v))
    text._update_value("hello")
    assert text.value == "hello"
    assert not calls

    # verify that normal _update still calls it
    text._update("world")
    assert text.value == "world"
    assert calls == ["world"]


def test_form_submits_without_triggering_element_on_change() -> None:
    element_calls = []
    form_calls = []

    text = ui.text(on_change=lambda v: element_calls.append(v))
    form = text.form(on_change=lambda v: form_calls.append(v))

    # Simulate submission of form
    form._update("submitted")

    # Form's on_change should fire
    assert form.value == "submitted"
    assert form_calls == ["submitted"]

    # Wrapped element's on_change should NOT fire during form submission
    assert form.element.value == "submitted"
    assert not element_calls


def test_form_with_array_submits_without_triggering_elements_on_change() -> (
    None
):
    c1_calls = []
    c2_calls = []
    form_calls = []

    t1 = ui.text(on_change=lambda v: c1_calls.append(v))
    t2 = ui.text(on_change=lambda v: c2_calls.append(v))
    arr = ui.array([t1, t2])
    form = arr.form(on_change=lambda v: form_calls.append(v))

    form._update({"0": "val1", "1": "val2"})

    assert form.value == ["val1", "val2"]
    assert form_calls == [["val1", "val2"]]
    assert form.element[0].value == "val1"
    assert form.element[1].value == "val2"
    assert not c1_calls
    assert not c2_calls


def test_form_with_batch_submits_without_triggering_elements_on_change() -> (
    None
):
    c1_calls = []
    c2_calls = []
    form_calls = []

    t1 = ui.text(on_change=lambda v: c1_calls.append(v))
    t2 = ui.text(on_change=lambda v: c2_calls.append(v))
    from marimo._output.hypertext import Html

    html_template = Html("{t1} {t2}")  # noqa: RUF027
    batch = ui.batch(html=html_template, elements={"t1": t1, "t2": t2})
    form = batch.form(on_change=lambda v: form_calls.append(v))

    form._update({"t1": "val1", "t2": "val2"})

    assert form.value == {"t1": "val1", "t2": "val2"}
    assert form_calls == [{"t1": "val1", "t2": "val2"}]
    assert form.element["t1"].value == "val1"
    assert form.element["t2"].value == "val2"
    assert not c1_calls
    assert not c2_calls