streamlit-nightly 1.36.1.dev20240702__py2.py3-none-any.whl → 1.36.1.dev20240704__py2.py3-none-any.whl

streamlit/delta_generator.py

@@ -38,10 +38,10 @@ from streamlit import (
     cli_util,
     config,
     cursor,
+    dataframe_util,
     env_util,
     logger,
     runtime,
-    type_util,
     util,
 )
 from streamlit.elements.alert import AlertMixin
@@ -100,7 +100,7 @@ if TYPE_CHECKING:
     from pandas import DataFrame
 
     from streamlit.cursor import Cursor
-    from streamlit.elements.arrow import Data
+    from streamlit.dataframe_util import Data
     from streamlit.elements.lib.built_in_chart_utils import AddRowsMetadata
 
 
@@ -705,8 +705,10 @@ def _prep_data_for_add_rows(
     add_rows_metadata: AddRowsMetadata | None,
 ) -> tuple[Data, AddRowsMetadata | None]:
     if not add_rows_metadata:
-        # When calling add_rows on st.table or st.dataframe we want styles to pass through.
-        return type_util.convert_anything_to_df(data, allow_styler=True), None
+        if dataframe_util.is_pandas_styler(data):
+            # When calling add_rows on st.table or st.dataframe we want styles to pass through.
+            return data, None
+        return dataframe_util.convert_anything_to_pandas_df(data), None
 
     # If add_rows_metadata is set, it indicates that the add_rows used called
     # on a chart based on our built-in chart commands.

streamlit/elements/arrow.py

@@ -18,21 +18,17 @@ import json
 from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
-    Any,
-    Dict,
     Final,
     Iterable,
-    List,
     Literal,
     TypedDict,
-    Union,
     cast,
     overload,
 )
 
 from typing_extensions import TypeAlias
 
-from streamlit import type_util
+from streamlit import dataframe_util
 from streamlit.elements.lib.column_config_utils import (
     INDEX_IDENTIFIER,
     ColumnConfigMappingInput,
@@ -43,38 +39,19 @@ from streamlit.elements.lib.column_config_utils import (
 )
 from streamlit.elements.lib.event_utils import AttributeDictionary
 from streamlit.elements.lib.pandas_styler_utils import marshall_styler
-from streamlit.elements.lib.policies import (
-    check_cache_replay_rules,
-    check_callback_rules,
-    check_session_state_rules,
-)
+from streamlit.elements.lib.policies import check_widget_policies
+from streamlit.elements.lib.utils import Key, to_key
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 from streamlit.runtime.state import WidgetCallback, register_widget
 from streamlit.runtime.state.common import compute_widget_id
-from streamlit.type_util import Key, to_key
 
 if TYPE_CHECKING:
-    import pyarrow as pa
-    from numpy import ndarray
-    from pandas import DataFrame, Index, Series
-    from pandas.io.formats.style import Styler
-
+    from streamlit.dataframe_util import Data
     from streamlit.delta_generator import DeltaGenerator
 
-Data: TypeAlias = Union[
-    "DataFrame",
-    "Series",
-    "Styler",
-    "Index",
-    "pa.Table",
-    "ndarray",
-    Iterable,
-    Dict[str, List[Any]],
-    None,
-]
 
 SelectionMode: TypeAlias = Literal[
     "single-row", "multi-row", "single-column", "multi-column"
@@ -489,10 +466,15 @@ class ArrowMixin:
 
         if is_selection_activated:
             # Run some checks that are only relevant when selections are activated
-            check_cache_replay_rules()
-            if callable(on_select):
-                check_callback_rules(self.dg, on_select)
-            check_session_state_rules(default_value=None, key=key, writes_allowed=False)
+            is_callback = callable(on_select)
+            check_widget_policies(
+                self.dg,
+                key,
+                on_change=cast(WidgetCallback, on_select) if is_callback else None,
+                default_value=None,
+                writes_allowed=False,
+                enable_check_callback_rules=is_callback,
+            )
 
         # Convert the user provided column config into the frontend compatible format:
         column_config_mapping = process_config_mapping(column_config)
@@ -511,15 +493,15 @@ class ArrowMixin:
 
         if isinstance(data, pa.Table):
             # For pyarrow tables, we can just serialize the table directly
-            proto.data = type_util.pyarrow_table_to_bytes(data)
+            proto.data = dataframe_util.convert_arrow_table_to_arrow_bytes(data)
         else:
             # For all other data formats, we need to convert them to a pandas.DataFrame
             # thereby, we also apply some data specific configs
 
             # Determine the input data format
-            data_format = type_util.determine_data_format(data)
+            data_format = dataframe_util.determine_data_format(data)
 
-            if type_util.is_pandas_styler(data):
+            if dataframe_util.is_pandas_styler(data):
                 # If pandas.Styler uuid is not provided, a hash of the position
                 # of the element will be used. This will cause a rerender of the table
                 # when the position of the element is changed.
@@ -528,7 +510,9 @@ class ArrowMixin:
                 marshall_styler(proto, data, default_uuid)
 
             # Convert the input data into a pandas.DataFrame
-            data_df = type_util.convert_anything_to_df(data, ensure_copy=False)
+            data_df = dataframe_util.convert_anything_to_pandas_df(
+                data, ensure_copy=False
+            )
             apply_data_specific_configs(
                 column_config_mapping,
                 data_df,
@@ -536,7 +520,7 @@ class ArrowMixin:
                 check_arrow_compatibility=False,
             )
             # Serialize the data to bytes:
-            proto.data = type_util.data_frame_to_bytes(data_df)
+            proto.data = dataframe_util.convert_pandas_df_to_arrow_bytes(data_df)
 
         if hide_index is not None:
             update_column_config(
@@ -615,8 +599,10 @@ class ArrowMixin:
 
         # Check if data is uncollected, and collect it but with 100 rows max, instead of 10k rows, which is done in all other cases.
         # Avoid this and use 100 rows in st.table, because large tables render slowly, take too much screen space, and can crush the app.
-        if type_util.is_unevaluated_data_object(data):
-            data = type_util.convert_anything_to_df(data, max_unevaluated_rows=100)
+        if dataframe_util.is_unevaluated_data_object(data):
+            data = dataframe_util.convert_anything_to_pandas_df(
+                data, max_unevaluated_rows=100
+            )
 
         # If pandas.Styler uuid is not provided, a hash of the position
         # of the element will be used. This will cause a rerender of the table
@@ -705,9 +691,8 @@ def marshall(proto: ArrowProto, data: Data, default_uuid: str | None = None) ->
         (e.g. charts) can ignore it.
 
     """
-    import pyarrow as pa
 
-    if type_util.is_pandas_styler(data):
+    if dataframe_util.is_pandas_styler(data):
         # default_uuid is a string only if the data is a `Styler`,
         # and `None` otherwise.
         assert isinstance(
@@ -715,8 +700,4 @@ def marshall(proto: ArrowProto, data: Data, default_uuid: str | None = None) ->
         ), "Default UUID must be a string for Styler data."
         marshall_styler(proto, data, default_uuid)
 
-    if isinstance(data, pa.Table):
-        proto.data = type_util.pyarrow_table_to_bytes(data)
-    else:
-        df = type_util.convert_anything_to_df(data)
-        proto.data = type_util.data_frame_to_bytes(df)
+    proto.data = dataframe_util.convert_anything_to_arrow_bytes(data)

streamlit/elements/lib/built_in_chart_utils.py

@@ -25,12 +25,15 @@ from typing import (
     Collection,
     Final,
     Hashable,
+    Literal,
     Sequence,
     TypedDict,
     cast,
 )
 
-from streamlit import type_util
+from typing_extensions import TypeAlias
+
+from streamlit import dataframe_util, type_util
 from streamlit.color_util import (
     Color,
     is_color_like,
@@ -44,8 +47,10 @@ if TYPE_CHECKING:
     import altair as alt
     import pandas as pd
 
-    from streamlit.elements.arrow import Data
-    from streamlit.type_util import ChartStackType, DataFrameCompatible
+    from streamlit.dataframe_util import Data
+
+VegaLiteType: TypeAlias = Literal["quantitative", "ordinal", "temporal", "nominal"]
+ChartStackType: TypeAlias = Literal["normalize", "center", "layered"]
 
 
 class PrepDataColumns(TypedDict):
@@ -129,7 +134,7 @@ def generate_chart(
     """Function to use the chart's type, data columns and indices to figure out the chart's spec."""
     import altair as alt
 
-    df = type_util.convert_anything_to_df(data, ensure_copy=True)
+    df = dataframe_util.convert_anything_to_pandas_df(data, ensure_copy=True)
 
     # From now on, use "df" instead of "data". Deleting "data" to guarantee we follow this.
     del data
@@ -248,7 +253,7 @@ def prep_chart_data_for_add_rows(
     """
     import pandas as pd
 
-    df = cast(pd.DataFrame, type_util.convert_anything_to_df(data))
+    df = cast(pd.DataFrame, dataframe_util.convert_anything_to_pandas_df(data))
 
     # Make range indices start at last_index.
     if isinstance(df.index, pd.RangeIndex):
@@ -273,6 +278,66 @@ def prep_chart_data_for_add_rows(
     return out_data, add_rows_metadata
 
 
+def _infer_vegalite_type(
+    data: pd.Series[Any],
+) -> VegaLiteType:
+    """
+    From an array-like input, infer the correct vega typecode
+    ('ordinal', 'nominal', 'quantitative', or 'temporal')
+
+    Parameters
+    ----------
+    data: Numpy array or Pandas Series
+    """
+    # The code below is copied from Altair, and slightly modified.
+    # We copy this code here so we don't depend on private Altair functions.
+    # Source: https://github.com/altair-viz/altair/blob/62ca5e37776f5cecb27e83c1fbd5d685a173095d/altair/utils/core.py#L193
+
+    from pandas.api.types import infer_dtype
+
+    # STREAMLIT MOD: I'm using infer_dtype directly here, rather than using Altair's wrapper. Their
+    # wrapper is only there to support Pandas < 0.20, but Streamlit requires Pandas 1.3.
+    typ = infer_dtype(data)
+
+    if typ in [
+        "floating",
+        "mixed-integer-float",
+        "integer",
+        "mixed-integer",
+        "complex",
+    ]:
+        return "quantitative"
+
+    elif typ == "categorical" and data.cat.ordered:
+        # STREAMLIT MOD: The original code returns a tuple here:
+        # return ("ordinal", data.cat.categories.tolist())
+        # But returning the tuple here isn't compatible with our
+        # built-in chart implementation. And it also doesn't seem to be necessary.
+        # Altair already extracts the correct sort order somewhere else.
+        # More info about the issue here: https://github.com/streamlit/streamlit/issues/7776
+        return "ordinal"
+    elif typ in ["string", "bytes", "categorical", "boolean", "mixed", "unicode"]:
+        return "nominal"
+    elif typ in [
+        "datetime",
+        "datetime64",
+        "timedelta",
+        "timedelta64",
+        "date",
+        "time",
+        "period",
+    ]:
+        return "temporal"
+    else:
+        # STREAMLIT MOD: I commented this out since Streamlit doesn't have a warnings object.
+        # warnings.warn(
+        #     "I don't know how to infer vegalite type from '{}'.  "
+        #     "Defaulting to nominal.".format(typ),
+        #     stacklevel=1,
+        # )
+        return "nominal"
+
+
 def _get_pandas_index_attr(
     data: pd.DataFrame | pd.Series,
     attr: str,
@@ -325,15 +390,9 @@ def _prep_data(
 
 
 def _last_index_for_melted_dataframes(
-    data: DataFrameCompatible | Any,
+    data: pd.DataFrame,
 ) -> Hashable | None:
-    if type_util.is_dataframe_compatible(data):
-        data = type_util.convert_anything_to_df(data)
-
-        if data.index.size > 0:
-            return cast(Hashable, data.index[-1])
-
-    return None
+    return cast(Hashable, data.index[-1]) if data.index.size > 0 else None
 
 
 def _is_date_column(df: pd.DataFrame, name: str | None) -> bool:
@@ -434,7 +493,7 @@ def _melt_data(
 
     # Arrow has problems with object types after melting two different dtypes
     # pyarrow.lib.ArrowTypeError: "Expected a <TYPE> object, got a object"
-    fixed_df = type_util.fix_arrow_incompatible_column_types(
+    fixed_df = dataframe_util.fix_arrow_incompatible_column_types(
         melted_df,
         selected_columns=[
             *columns_to_leave_alone,
@@ -862,7 +921,7 @@ def _get_color_encoding(
         if color_column == _MELTED_COLOR_COLUMN_NAME:
             column_type = "nominal"
         else:
-            column_type = type_util.infer_vegalite_type(df[color_column])
+            column_type = _infer_vegalite_type(df[color_column])
 
         color_enc = alt.Color(
             field=color_column, legend=_COLOR_LEGEND_SETTINGS, type=column_type
@@ -982,7 +1041,7 @@ def _get_tooltip_encoding(
 
 def _get_x_encoding_type(
     df: pd.DataFrame, chart_type: ChartType, x_column: str | None
-) -> type_util.VegaLiteType:
+) -> VegaLiteType:
     if x_column is None:
         return "quantitative"  # Anything. If None, Vega-Lite may hide the axis.
 
@@ -991,18 +1050,18 @@ def _get_x_encoding_type(
     if chart_type == ChartType.VERTICAL_BAR and not _is_date_column(df, x_column):
         return "ordinal"
 
-    return type_util.infer_vegalite_type(df[x_column])
+    return _infer_vegalite_type(df[x_column])
 
 
 def _get_y_encoding_type(
     df: pd.DataFrame, chart_type: ChartType, y_column: str | None
-) -> type_util.VegaLiteType:
+) -> VegaLiteType:
     # Horizontal bar charts should have a discrete (ordinal) y-axis, UNLESS type is date/time
     if chart_type == ChartType.HORIZONTAL_BAR and not _is_date_column(df, y_column):
         return "ordinal"
 
     if y_column:
-        return type_util.infer_vegalite_type(df[y_column])
+        return _infer_vegalite_type(df[y_column])
 
     return "quantitative"  # Pick anything. If undefined, Vega-Lite may hide the axis.
 

streamlit/elements/lib/column_config_utils.py

@@ -21,10 +21,10 @@ from typing import TYPE_CHECKING, Dict, Final, Literal, Mapping, Union
 
 from typing_extensions import TypeAlias
 
+from streamlit.dataframe_util import DataFormat, is_colum_type_arrow_incompatible
 from streamlit.elements.lib.column_types import ColumnConfig, ColumnType
 from streamlit.elements.lib.dicttools import remove_none_values
 from streamlit.errors import StreamlitAPIException
-from streamlit.type_util import DataFormat, is_colum_type_arrow_incompatible
 
 if TYPE_CHECKING:
     import pyarrow as pa

streamlit/elements/lib/pandas_styler_utils.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping, TypeVar
 
-from streamlit import type_util
+from streamlit import dataframe_util
 from streamlit.errors import StreamlitAPIException
 
 if TYPE_CHECKING:
@@ -236,7 +236,9 @@ def _marshall_display_values(
 
     """
     new_df = _use_display_values(df, styles)
-    proto.styler.display_values = type_util.data_frame_to_bytes(new_df)
+    proto.styler.display_values = dataframe_util.convert_pandas_df_to_arrow_bytes(
+        new_df
+    )
 
 
 def _use_display_values(df: DataFrame, styles: Mapping[str, Any]) -> DataFrame:

streamlit/elements/lib/policies.py

@@ -14,9 +14,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Final, Sequence
 
-from streamlit import config, runtime
+from streamlit import config, errors, logger, runtime
 from streamlit.elements.form import is_in_form
 from streamlit.errors import StreamlitAPIException, StreamlitAPIWarning
 from streamlit.runtime.scriptrunner.script_run_context import get_script_run_ctx
@@ -26,8 +26,12 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
 
+_LOGGER: Final = logger.get_logger(__name__)
+
+
 def check_callback_rules(dg: DeltaGenerator, on_change: WidgetCallback | None) -> None:
-    """Ensures that widgets other than `st.form_submit` within a form don't have an on_change callback set.
+    """Ensures that widgets other than `st.form_submit_button` within a form don't have
+    an on_change callback set.
 
     Raises
     ------
@@ -48,9 +52,11 @@ _shown_default_value_warning: bool = False
 def check_session_state_rules(
     default_value: Any, key: str | None, writes_allowed: bool = True
 ) -> None:
-    """Ensures that no values are set for widgets with the given key when writing is not allowed.
+    """Ensures that no values are set for widgets with the given key when writing
+    is not allowed.
 
-    Additionally, if `global.disableWidgetStateDuplicationWarning` is False a warning is shown when a widget has a default value but its value is also set via session state.
+    Additionally, if `global.disableWidgetStateDuplicationWarning` is False a warning is
+    shown when a widget has a default value but its value is also set via session state.
 
     Raises
     ------
@@ -68,7 +74,8 @@ def check_session_state_rules(
 
     if not writes_allowed:
         raise StreamlitAPIException(
-            f'Values for the widget with key "{key}" cannot be set using `st.session_state`.'
+            f"Values for the widget with key '{key}' cannot be set using"
+            " `st.session_state`."
         )
 
     if (
@@ -123,6 +130,15 @@ _fragment_writes_widget_to_outside_error = (
 
 
 def check_fragment_path_policy(dg: DeltaGenerator):
+    """Ensures that the current widget is not written outside of the
+    fragment's delta path.
+
+    Should be called by ever element that acts as a widget.
+    We don't allow writing widgets from within a widget to the outside path
+    because it can lead to unexpected behavior. For elements, this is okay
+    because they do not trigger a re-run.
+    """
+
     ctx = get_script_run_ctx()
     # Check is only relevant for fragments
     if ctx is None or ctx.current_fragment_id is None:
@@ -135,11 +151,47 @@ def check_fragment_path_policy(dg: DeltaGenerator):
 
     current_cursor_delta_path = current_cursor.delta_path
 
-    # the elements delta path cannot be smaller than the fragment's delta path if it is inside of the fragment
+    # the elements delta path cannot be smaller than the fragment's delta path if it is
+    # inside of the fragment
     if len(current_cursor_delta_path) < len(current_fragment_delta_path):
         raise StreamlitAPIException(_fragment_writes_widget_to_outside_error)
 
-    # all path indices of the fragment-path must occur in the inner-elements delta path, otherwise it is outside of the fragment container
+    # all path indices of the fragment-path must occur in the inner-elements delta path,
+    # otherwise it is outside of the fragment container
     for index, path_index in enumerate(current_fragment_delta_path):
         if current_cursor_delta_path[index] != path_index:
             raise StreamlitAPIException(_fragment_writes_widget_to_outside_error)
+
+
+def check_widget_policies(
+    dg: DeltaGenerator,
+    key: str | None,
+    on_change: WidgetCallback | None = None,
+    *,
+    default_value: Sequence[Any] | Any | None = None,
+    writes_allowed: bool = True,
+    enable_check_callback_rules: bool = True,
+):
+    """Check all widget policies for the given DeltaGenerator."""
+    check_fragment_path_policy(dg)
+    check_cache_replay_rules()
+    if enable_check_callback_rules:
+        check_callback_rules(dg, on_change)
+    check_session_state_rules(
+        default_value=default_value, key=key, writes_allowed=writes_allowed
+    )
+
+
+def maybe_raise_label_warnings(label: str | None, label_visibility: str | None):
+    if not label:
+        _LOGGER.warning(
+            "`label` got an empty value. This is discouraged for accessibility "
+            "reasons and may be disallowed in the future by raising an exception. "
+            "Please provide a non-empty label and hide it with label_visibility "
+            "if needed."
+        )
+    if label_visibility not in ("visible", "hidden", "collapsed"):
+        raise errors.StreamlitAPIException(
+            f"Unsupported label_visibility option '{label_visibility}'. "
+            f"Valid values are 'visible', 'hidden' or 'collapsed'."
+        )

streamlit/elements/lib/utils.py

@@ -15,9 +15,21 @@
 from __future__ import annotations
 
 from enum import Enum, EnumMeta
-from typing import TYPE_CHECKING, Any, Iterable, Sequence, overload
-
-from streamlit import type_util
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Final,
+    Iterable,
+    Literal,
+    Sequence,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from typing_extensions import TypeAlias
+
+from streamlit import config, dataframe_util, errors, logger
 from streamlit.proto.LabelVisibilityMessage_pb2 import LabelVisibilityMessage
 from streamlit.runtime.state.common import RegisterWidgetResult
 
@@ -25,8 +37,15 @@ if TYPE_CHECKING:
     from streamlit.type_util import T
 
 
+_LOGGER: Final = logger.get_logger(__name__)
+
+Key: TypeAlias = Union[str, int]
+
+LabelVisibility: TypeAlias = Literal["visible", "hidden", "collapsed"]
+
+
 def get_label_visibility_proto_value(
-    label_visibility_string: type_util.LabelVisibility,
+    label_visibility_string: LabelVisibility,
 ) -> LabelVisibilityMessage.LabelVisibilityOptions.ValueType:
     """Returns one of LabelVisibilityMessage enum constants.py based on string value."""
 
@@ -40,6 +59,78 @@ def get_label_visibility_proto_value(
     raise ValueError(f"Unknown label visibility value: {label_visibility_string}")
 
 
+@overload
+def to_key(key: None) -> None: ...
+
+
+@overload
+def to_key(key: Key) -> str: ...
+
+
+def to_key(key: Key | None) -> str | None:
+    return None if key is None else str(key)
+
+
+E1 = TypeVar("E1", bound=Enum)
+E2 = TypeVar("E2", bound=Enum)
+
+_ALLOWED_ENUM_COERCION_CONFIG_SETTINGS = ("off", "nameOnly", "nameAndValue")
+
+
+def _coerce_enum(from_enum_value: E1, to_enum_class: type[E2]) -> E1 | E2:
+    """Attempt to coerce an Enum value to another EnumMeta.
+
+    An Enum value of EnumMeta E1 is considered coercable to EnumType E2
+    if the EnumMeta __qualname__ match and the names of their members
+    match as well. (This is configurable in streamlist configs)
+    """
+    if not isinstance(from_enum_value, Enum):
+        raise ValueError(
+            f"Expected an Enum in the first argument. Got {type(from_enum_value)}"
+        )
+    if not isinstance(to_enum_class, EnumMeta):
+        raise ValueError(
+            f"Expected an EnumMeta/Type in the second argument. Got {type(to_enum_class)}"
+        )
+    if isinstance(from_enum_value, to_enum_class):
+        return from_enum_value  # Enum is already a member, no coersion necessary
+
+    coercion_type = config.get_option("runner.enumCoercion")
+    if coercion_type not in _ALLOWED_ENUM_COERCION_CONFIG_SETTINGS:
+        raise errors.StreamlitAPIException(
+            "Invalid value for config option runner.enumCoercion. "
+            f"Expected one of {_ALLOWED_ENUM_COERCION_CONFIG_SETTINGS}, "
+            f"but got '{coercion_type}'."
+        )
+    if coercion_type == "off":
+        return from_enum_value  # do not attempt to coerce
+
+    # We now know this is an Enum AND the user has configured coercion enabled.
+    # Check if we do NOT meet the required conditions and log a failure message
+    # if that is the case.
+    from_enum_class = from_enum_value.__class__
+    if (
+        from_enum_class.__qualname__ != to_enum_class.__qualname__
+        or (
+            coercion_type == "nameOnly"
+            and set(to_enum_class._member_names_) != set(from_enum_class._member_names_)
+        )
+        or (
+            coercion_type == "nameAndValue"
+            and set(to_enum_class._value2member_map_)
+            != set(from_enum_class._value2member_map_)
+        )
+    ):
+        _LOGGER.debug("Failed to coerce %s to class %s", from_enum_value, to_enum_class)
+        return from_enum_value  # do not attempt to coerce
+
+    # At this point we think the Enum is coercable, and we know
+    # E1 and E2 have the same member names. We convert from E1 to E2 using _name_
+    # (since user Enum subclasses can override the .name property in 3.11)
+    _LOGGER.debug("Coerced %s to class %s", from_enum_value, to_enum_class)
+    return to_enum_class[from_enum_value._name_]
+
+
 @overload
 def maybe_coerce_enum(
     register_widget_result: RegisterWidgetResult[Enum],
@@ -51,7 +142,7 @@ def maybe_coerce_enum(
 @overload
 def maybe_coerce_enum(
     register_widget_result: RegisterWidgetResult[T],
-    options: type_util.OptionSequence[T],
+    options: dataframe_util.OptionSequence[T],
     opt_sequence: Sequence[T],
 ) -> RegisterWidgetResult[T]: ...
 
@@ -74,7 +165,7 @@ def maybe_coerce_enum(register_widget_result, options, opt_sequence):
             return register_widget_result
 
     return RegisterWidgetResult(
-        type_util.coerce_enum(register_widget_result.value, coerce_class),
+        _coerce_enum(register_widget_result.value, coerce_class),
         register_widget_result.value_changed,
     )
 
@@ -84,7 +175,7 @@ def maybe_coerce_enum(register_widget_result, options, opt_sequence):
 @overload
 def maybe_coerce_enum_sequence(
     register_widget_result: RegisterWidgetResult[list[T]],
-    options: type_util.OptionSequence[T],
+    options: dataframe_util.OptionSequence[T],
     opt_sequence: Sequence[T],
 ) -> RegisterWidgetResult[list[T]]: ...
 
@@ -92,7 +183,7 @@ def maybe_coerce_enum_sequence(
 @overload
 def maybe_coerce_enum_sequence(
     register_widget_result: RegisterWidgetResult[tuple[T, T]],
-    options: type_util.OptionSequence[T],
+    options: dataframe_util.OptionSequence[T],
     opt_sequence: Sequence[T],
 ) -> RegisterWidgetResult[tuple[T, T]]: ...
 
@@ -118,8 +209,7 @@ def maybe_coerce_enum_sequence(register_widget_result, options, opt_sequence):
     # Return a new RegisterWidgetResult with the coerced enum values sequence
     return RegisterWidgetResult(
         type(register_widget_result.value)(
-            type_util.coerce_enum(val, coerce_class)
-            for val in register_widget_result.value
+            _coerce_enum(val, coerce_class) for val in register_widget_result.value
         ),
         register_widget_result.value_changed,
     )