streamlit 1.53.0__py3-none-any.whl → 1.54.0__py3-none-any.whl

streamlit/elements/widgets/radio.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast, overload
 
@@ -27,7 +26,11 @@ from streamlit.elements.lib.layout_utils import (
     Width,
     validate_width,
 )
-from streamlit.elements.lib.options_selector_utils import index_, maybe_coerce_enum
+from streamlit.elements.lib.options_selector_utils import (
+    create_mappings,
+    maybe_coerce_enum,
+    validate_and_sync_value_with_options,
+)
 from streamlit.elements.lib.policies import (
     check_widget_policies,
     maybe_raise_label_warnings,
@@ -63,27 +66,70 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-@dataclass
 class RadioSerde(Generic[T]):
+    """Serializer/deserializer for Radio widget values.
+
+    Uses string-based values (formatted option strings) for robust handling
+    of dynamic option changes, similar to SelectboxSerde.
+    """
+
     options: Sequence[T]
-    index: int | None
+    formatted_options: list[str]
+    formatted_option_to_option_index: dict[str, int]
+    default_option_index: int | None
+    format_func: Callable[[Any], str]
 
-    def serialize(self, v: object) -> int | None:
+    def __init__(
+        self,
+        options: Sequence[T],
+        *,
+        formatted_options: list[str],
+        formatted_option_to_option_index: dict[str, int],
+        default_option_index: int | None = None,
+        format_func: Callable[[Any], str] = str,
+    ) -> None:
+        self.options = options
+        self.formatted_options = formatted_options
+        self.formatted_option_to_option_index = formatted_option_to_option_index
+        self.default_option_index = default_option_index
+        self.format_func = format_func
+
+    def serialize(self, v: T | str | None) -> str | None:
         if v is None:
             return None
+        if len(self.options) == 0:
+            return None
 
-        return 0 if len(self.options) == 0 else index_(self.options, v)
+        # Use format_func to find the formatted option instead of using
+        # index_(self.options, v) which relies on == comparison. This is necessary
+        # because widget values are deepcopied, and for custom classes without
+        # __eq__, the deepcopied instances would fail identity comparison.
+        try:
+            formatted_value = self.format_func(v)
+        except Exception:
+            # format_func failed (e.g., v is a string but format_func expects
+            # an object with specific attributes). Treat v as a raw string.
+            return cast("str", v)
+
+        if formatted_value in self.formatted_option_to_option_index:
+            return formatted_value
+        # Value not found in options - return as raw string
+        return cast("str", v)
+
+    def deserialize(self, ui_value: str | None) -> T | str | None:
+        # If no options, there's no valid value - return None
+        if len(self.options) == 0:
+            return None
 
-    def deserialize(self, ui_value: int | None) -> T | None:
-        idx = ui_value if ui_value is not None else self.index
+        if ui_value is None:
+            return (
+                self.options[self.default_option_index]
+                if self.default_option_index is not None
+                else None
+            )
 
-        return (
-            self.options[idx]
-            if idx is not None
-            and len(self.options) > 0
-            and self.options[idx] is not None
-            else None
-        )
+        option_index = self.formatted_option_to_option_index.get(ui_value)
+        return self.options[option_index] if option_index is not None else ui_value
 
 
 class RadioMixin:
@@ -368,18 +414,17 @@ class RadioMixin:
         opt = convert_anything_to_list(options)
         check_python_comparable(opt)
 
+        formatted_options, formatted_option_to_option_index = create_mappings(
+            opt, format_func
+        )
+
         element_id = compute_and_register_element_id(
             "radio",
             user_key=key,
-            # Treat provided key as the main widget identity. Only include the
-            # following parameters in the identity computation since they can
-            # invalidate the current selection mapping.
-            # Changes to format_func also invalidate the current selection,
-            # but this is already handled via the `options` parameter below:
-            key_as_main_identity={"options"},
+            key_as_main_identity=True,
             dg=self.dg,
             label=label,
-            options=[str(format_func(option)) for option in opt],
+            options=formatted_options,
             index=index,
             help=help,
             horizontal=horizontal,
@@ -415,7 +460,7 @@ class RadioMixin:
         radio_proto.label = label
         if index is not None:
             radio_proto.default = index
-        radio_proto.options[:] = [str(format_func(option)) for option in opt]
+        radio_proto.options[:] = formatted_options
         radio_proto.form_id = current_form_id(self.dg)
         radio_proto.horizontal = horizontal
         radio_proto.disabled = disabled
@@ -429,7 +474,13 @@ class RadioMixin:
         if help is not None:
             radio_proto.help = dedent(help)
 
-        serde = RadioSerde(opt, index)
+        serde = RadioSerde(
+            opt,
+            formatted_options=formatted_options,
+            formatted_option_to_option_index=formatted_option_to_option_index,
+            default_option_index=index,
+            format_func=format_func,
+        )
 
         widget_state = register_widget(
             radio_proto.id,
@@ -439,21 +490,30 @@ class RadioMixin:
             deserializer=serde.deserialize,
             serializer=serde.serialize,
             ctx=ctx,
-            value_type="int_value",
+            value_type="string_value",
         )
         widget_state = maybe_coerce_enum(widget_state, options, opt)
 
-        if widget_state.value_changed:
-            if widget_state.value is not None:
-                serialized_value = serde.serialize(widget_state.value)
-                if serialized_value is not None:
-                    radio_proto.value = serialized_value
+        # Validate the current value against the new options.
+        # If the value is no longer valid (not in options), reset to default.
+        # This handles the case where options change dynamically and the
+        # previously selected value is no longer available.
+        # Cast to T | None since radio doesn't support accept_new_options,
+        # so string values that aren't in options will be reset to default.
+        current_value, value_needs_reset = validate_and_sync_value_with_options(
+            cast("T | None", widget_state.value), opt, index, key
+        )
+
+        if value_needs_reset or widget_state.value_changed:
+            serialized_value = serde.serialize(current_value)
+            if serialized_value is not None:
+                radio_proto.raw_value = serialized_value
             radio_proto.set_value = True
 
         if ctx:
             save_for_app_testing(ctx, element_id, format_func)
         self.dg._enqueue("radio", radio_proto, layout_config=layout_config)
-        return widget_state.value
+        return current_value
 
     @property
     def dg(self) -> DeltaGenerator:

streamlit/elements/widgets/select_slider.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from textwrap import dedent
 from typing import (
     TYPE_CHECKING,
@@ -30,9 +29,12 @@ from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.lib.form_utils import current_form_id
 from streamlit.elements.lib.layout_utils import LayoutConfig, validate_width
 from streamlit.elements.lib.options_selector_utils import (
+    create_mappings,
     index_,
     maybe_coerce_enum,
     maybe_coerce_enum_sequence,
+    validate_and_sync_range_value_with_options,
+    validate_and_sync_value_with_options,
 )
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -72,37 +74,79 @@ def _is_range_value(value: T | Sequence[T]) -> TypeGuard[Sequence[T]]:
     return isinstance(value, (list, tuple))
 
 
-@dataclass
 class SelectSliderSerde(Generic[T]):
-    options: Sequence[T]
-    value: list[int]
-    is_range_value: bool
+    """Serializer/deserializer for select_slider widget values.
 
-    def serialize(self, v: object) -> list[int]:
-        return self._as_index_list(v)
+    Uses formatted option strings for robust handling of dynamic option changes.
+    """
 
-    def deserialize(self, ui_value: list[int] | None) -> T | tuple[T, T]:
-        if not ui_value:
-            # Widget has not been used; fallback to the original value,
-            ui_value = self.value
+    def __init__(
+        self,
+        options: Sequence[T],
+        *,
+        formatted_option_to_index: dict[str, int],
+        default_indices: list[int],
+        format_func: Callable[[Any], str] = str,
+    ) -> None:
+        self.options = options
+        self.formatted_option_to_index = formatted_option_to_index
+        self.default_indices = default_indices
+        self.format_func = format_func
+
+    def _get_default(self, is_range: bool) -> T | tuple[T, T]:
+        """Return the default value based on default_indices."""
+        if is_range or len(self.default_indices) >= 2:
+            end_idx = (
+                self.default_indices[1]
+                if len(self.default_indices) > 1
+                else len(self.options) - 1
+            )
+            return (self.options[self.default_indices[0]], self.options[end_idx])
+        return self.options[self.default_indices[0]]
 
-        # The widget always returns floats, so convert to ints before indexing
-        return_value: tuple[T, T] = cast(
-            "tuple[T, T]",
-            tuple(self.options[int(x)] for x in ui_value),
-        )
+    def serialize(self, v: T | tuple[T, T] | list[T]) -> list[str]:
+        """Convert option value(s) to formatted string list."""
+        # Check if v is a single option (handles options that are tuples/lists)
+        try:
+            formatted = self.format_func(v)
+            if formatted in self.formatted_option_to_index:
+                return [formatted]
+        except Exception:  # noqa: S110
+            pass
 
-        # If the original value was a list/tuple, so will be the output (and vice versa)
-        return return_value if self.is_range_value else return_value[0]
+        # Handle as range/sequence
+        if isinstance(v, (tuple, list)):
+            return [self.format_func(x) for x in v]
 
-    def _as_index_list(self, v: Any) -> list[int]:
-        if _is_range_value(v):
-            slider_value = [index_(self.options, val) for val in v]
-            start, end = slider_value
-            if start > end:
-                slider_value = [end, start]
-            return slider_value
-        return [index_(self.options, v)]
+        return [self.format_func(v)]
+
+    def deserialize(self, ui_value: list[str] | None) -> T | tuple[T, T]:
+        """Convert formatted string list back to option value(s)."""
+        is_range = ui_value is not None and len(ui_value) >= 2
+
+        if not ui_value:
+            return self._get_default(is_range=len(self.default_indices) >= 2)
+
+        # Look up each string value
+        results: list[tuple[int, T]] = []
+        for i, s in enumerate(ui_value):
+            idx = self.formatted_option_to_index.get(s)
+            if idx is not None and idx < len(self.options):
+                results.append((idx, self.options[idx]))
+            else:
+                # Fallback to default for this position
+                default_idx = self.default_indices[
+                    min(i, len(self.default_indices) - 1)
+                ]
+                results.append((default_idx, self.options[default_idx]))
+
+        if is_range and len(results) >= 2:
+            # Ensure start <= end by returning deserialized range value in ascending order
+            if results[0][0] > results[1][0]:
+                return (results[1][1], results[0][1])
+            return (results[0][1], results[1][1])
+
+        return results[0][1]
 
 
 class SelectSliderMixin:
@@ -378,16 +422,18 @@ class SelectSliderMixin:
         # Convert element to index of the elements
         slider_value = as_index_list(value)
 
+        # Create formatted options and mapping for string-based storage
+        formatted_options, formatted_option_to_option_index = create_mappings(
+            opt, format_func
+        )
+
         element_id = compute_and_register_element_id(
             "select_slider",
             user_key=key,
-            # Treat the provided key as the main identity; only include
-            # changes to the options (and implicitly their formatting) in the
-            # identity computation as those can invalidate the current value.
-            key_as_main_identity={"options", "format_func"},
+            key_as_main_identity=True,
             dg=self.dg,
             label=label,
-            options=[str(format_func(option)) for option in opt],
+            options=formatted_options,
             value=slider_value,
             help=help,
             width=width,
@@ -403,7 +449,7 @@ class SelectSliderMixin:
         slider_proto.max = len(opt) - 1
         slider_proto.step = 1  # default for index changes
         slider_proto.data_type = SliderProto.INT
-        slider_proto.options[:] = [str(format_func(option)) for option in opt]
+        slider_proto.options[:] = formatted_options
         slider_proto.form_id = current_form_id(self.dg)
         slider_proto.disabled = disabled
         slider_proto.label_visibility.value = get_label_visibility_proto_value(
@@ -415,7 +461,12 @@ class SelectSliderMixin:
         validate_width(width)
         layout_config = LayoutConfig(width=width)
 
-        serde = SelectSliderSerde(opt, slider_value, _is_range_value(value))
+        serde = SelectSliderSerde(
+            opt,
+            formatted_option_to_index=formatted_option_to_option_index,
+            default_indices=slider_value,
+            format_func=format_func,
+        )
 
         widget_state = register_widget(
             slider_proto.id,
@@ -425,7 +476,7 @@ class SelectSliderMixin:
             deserializer=serde.deserialize,
             serializer=serde.serialize,
             ctx=ctx,
-            value_type="double_array_value",
+            value_type="string_array_value",
         )
         if isinstance(widget_state.value, tuple):
             widget_state = maybe_coerce_enum_sequence(
@@ -434,15 +485,50 @@ class SelectSliderMixin:
         else:
             widget_state = maybe_coerce_enum(widget_state, options, opt)
 
-        if widget_state.value_changed:
-            slider_proto.value[:] = serde.serialize(widget_state.value)
+        # Validate the current value against the new options.
+        # If the value is no longer valid (not in options), reset to default.
+        # This handles the case where options change dynamically and the
+        # previously selected value is no longer available.
+        # Determine if we're dealing with a range value based on the actual
+        # widget state value, not just the value parameter (range can come from
+        # session state even when value param is None).
+        actual_is_range = isinstance(widget_state.value, tuple)
+        if actual_is_range:
+            # Range value: validate using range-specific function.
+            range_value = cast("tuple[T, T]", widget_state.value)
+            validated_range, value_needs_reset = (
+                validate_and_sync_range_value_with_options(
+                    range_value,
+                    opt,
+                    slider_value,
+                    key,
+                    format_func,
+                )
+            )
+            current_value: T | tuple[T, T] = validated_range
+        else:
+            # Single value: use the standard validation function.
+            validated_single, value_needs_reset = validate_and_sync_value_with_options(
+                widget_state.value,
+                opt,
+                slider_value[0],
+                key,
+                format_func,
+            )
+            # validated_single is guaranteed to be T (not None) because
+            # deserialize() always returns a default value, never None.
+            current_value = cast("T", validated_single)
+
+        if value_needs_reset or widget_state.value_changed:
+            serialized_value = serde.serialize(current_value)
+            slider_proto.raw_value[:] = serialized_value
             slider_proto.set_value = True
 
         if ctx:
             save_for_app_testing(ctx, element_id, format_func)
 
         self.dg._enqueue("slider", slider_proto, layout_config=layout_config)
-        return widget_state.value
+        return current_value
 
     @property
     def dg(self) -> DeltaGenerator:

streamlit/elements/widgets/selectbox.py

@@ -35,7 +35,6 @@ from streamlit.elements.lib.layout_utils import (
 )
 from streamlit.elements.lib.options_selector_utils import (
     create_mappings,
-    index_,
     maybe_coerce_enum,
     validate_and_sync_value_with_options,
 )
@@ -79,6 +78,7 @@ class SelectboxSerde(Generic[T]):
     formatted_options: list[str]
     formatted_option_to_option_index: dict[str, int]
     default_option_index: int | None
+    format_func: Callable[[Any], str]
 
     def __init__(
         self,
@@ -87,6 +87,7 @@ class SelectboxSerde(Generic[T]):
         formatted_options: list[str],
         formatted_option_to_option_index: dict[str, int],
         default_option_index: int | None = None,
+        format_func: Callable[[Any], str] = str,
     ) -> None:
         """Initialize the SelectboxSerde.
 
@@ -108,33 +109,53 @@ class SelectboxSerde(Generic[T]):
         default_option_index : int or None, optional
             The index of the default option to use when no selection is made.
             If None, no default option is selected.
+        format_func : Callable[[Any], str], optional
+            Function to format options for comparison. Used to compare values by their
+            string representation instead of using == directly. This is necessary because
+            widget values are deepcopied, and for custom classes without __eq__, the
+            deepcopied instances would fail identity comparison.
         """
 
         self.options = options
         self.formatted_options = formatted_options
         self.formatted_option_to_option_index = formatted_option_to_option_index
         self.default_option_index = default_option_index
+        self.format_func = format_func
 
     def serialize(self, v: T | str | None) -> str | None:
         if v is None:
             return None
-        if len(self.options) == 0:
-            return ""
-
-        # we don't check for isinstance(v, str) because this could lead to wrong
-        # results if v is a string that is part of the options itself as it would
-        # skip formatting in that case
+        # Note: We don't short-circuit for empty options here because
+        # accept_new_options=True allows user-entered values even with no options.
+        # The normal flow below handles this correctly.
+
+        # Use format_func to find the formatted option instead of using
+        # index_(self.options, v) which relies on == comparison. This is necessary
+        # because widget values are deepcopied, and for custom classes without
+        # __eq__, the deepcopied instances would fail identity comparison.
         try:
-            option_index = index_(self.options, v)
-            return self.formatted_options[option_index]
-        except ValueError:
-            # we know that v is a string, otherwise it would have been found in the
-            # options
-            return cast("str", v)
+            formatted_value = self.format_func(v)
+        except Exception:
+            # format_func failed (e.g., v is a string but format_func expects
+            # an object with specific attributes). Use str(v) to ensure we return
+            # a proper string, not the original object. This handles both cases:
+            # - v is already a string -> str(v) returns it unchanged
+            # - v is a custom object -> str(v) gives its string representation
+            return str(v)
+
+        if formatted_value in self.formatted_option_to_option_index:
+            return formatted_value
+        # Value not found in options - return the formatted string (not the original
+        # object) to maintain type consistency since serialize() must return str|None
+        return formatted_value
 
     def deserialize(self, ui_value: str | None) -> T | str | None:
-        # check if the option is pointing to a generic option type T,
-        # otherwise return the option itself
+        # Note: We don't short-circuit for empty options here because
+        # accept_new_options=True allows user-entered values even with no options.
+        # The normal flow below handles this: ui_value not in options -> return ui_value.
+
+        # Check if the option is pointing to a generic option type T,
+        # otherwise return the option itself.
         if ui_value is None:
             return (
                 self.options[self.default_option_index]
@@ -583,6 +604,7 @@ class SelectboxMixin:
             formatted_options=formatted_options,
             formatted_option_to_option_index=formatted_option_to_option_index,
             default_option_index=index,
+            format_func=format_func,
         )
         widget_state = register_widget(
             selectbox_proto.id,
@@ -605,7 +627,7 @@ class SelectboxMixin:
             # This handles the case where options change dynamically and the
             # previously selected value is no longer available.
             current_value, value_needs_reset = validate_and_sync_value_with_options(
-                widget_state.value, opt, index, key
+                widget_state.value, opt, index, key, format_func
             )
 
         if value_needs_reset or widget_state.value_changed:

streamlit/elements/widgets/slider.py

@@ -739,7 +739,7 @@ class SliderMixin:
 
         # Ensure that the value is either a single value or a range of values.
         single_value = isinstance(value, tuple(SUPPORTED_TYPES.keys()))
-        range_value = isinstance(value, (list, tuple)) and len(value) in (0, 1, 2)
+        range_value = isinstance(value, (list, tuple)) and len(value) in {0, 1, 2}
         if not single_value and not range_value:
             raise StreamlitAPIException(
                 "Slider value should either be an int/float/datetime or a list/tuple of "
@@ -778,7 +778,7 @@ class SliderMixin:
 
             datetime_min = time.min.replace(tzinfo=prepared_value[0].tzinfo)
             datetime_max = time.max.replace(tzinfo=prepared_value[0].tzinfo)
-        if data_type in (SliderProto.DATETIME, SliderProto.DATE):
+        if data_type in {SliderProto.DATETIME, SliderProto.DATE}:
             prepared_value = cast("Sequence[datetime]", prepared_value)
 
             datetime_min = prepared_value[0] - timedelta(days=14)
@@ -823,10 +823,10 @@ class SliderMixin:
             max_value = defaults[data_type]["max_value"]
         if step is None:
             step = defaults[data_type]["step"]
-            if data_type in (
+            if data_type in {
                 SliderProto.DATETIME,
                 SliderProto.DATE,
-            ) and max_value - min_value < timedelta(days=1):
+            } and max_value - min_value < timedelta(days=1):
                 step = timedelta(minutes=15)
         if format is None:
             format = cast("str", defaults[data_type]["format"])  # noqa: A001
@@ -945,7 +945,7 @@ class SliderMixin:
             # Restore times/datetimes to original timezone (dates are always naive)
             orig_tz = (
                 prepared_value[0].tzinfo
-                if data_type in (SliderProto.TIME, SliderProto.DATETIME)
+                if data_type in {SliderProto.TIME, SliderProto.DATETIME}
                 else None
             )