streamlit-nightly 1.53.1.dev20260120__py3-none-any.whl → 1.53.2.dev20260122__py3-none-any.whl

streamlit/connections/snowflake_connection.py

@@ -135,7 +135,9 @@ class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
             ),
             wait=wait_fixed(1),
         )
-        def _query(sql: str) -> DataFrame:
+        # `params` must be an explicit parameter (not captured from closure) so that
+        # `@st.cache_data` includes it in the cache key.
+        def _query(sql: str, params: Any = None) -> DataFrame:
             cur = self._instance.cursor()
             cur.execute(sql, params=params, **kwargs)
             return cur.fetch_pandas_all()  # type: ignore
@@ -153,7 +155,7 @@ class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
             ttl=ttl,
         )(_query)
 
-        return _query(sql)
+        return _query(sql, params)
 
     def write_pandas(
         self,
@@ -349,6 +351,7 @@ class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         """Closes the underlying Snowflake connection."""
         if self._raw_instance is not None:
             self._raw_instance.close()
+            self._raw_instance = None
 
 
 class SnowflakeConnection(BaseSnowflakeConnection):

streamlit/elements/lib/options_selector_utils.py

@@ -290,6 +290,7 @@ def validate_and_sync_value_with_options(
     opt: Sequence[T],
     default_index: int | None,
     key: str | int | None,
+    format_func: Callable[[Any], str] = str,
 ) -> tuple[T | None, bool]:
     """Validate current value against options, resetting session state if invalid.
 
@@ -306,6 +307,11 @@ def validate_and_sync_value_with_options(
         The default index to reset to if value is invalid.
     key
         The widget key for session state updates.
+    format_func
+        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.
 
     Returns
     -------
@@ -315,30 +321,50 @@ def validate_and_sync_value_with_options(
     if current_value is None:
         return current_value, False
 
-    # Check if current value is still in the new options
-    try:
-        index_(opt, current_value)
-        return current_value, False
-    except ValueError:
-        # Value not in options - reset to default
-        if default_index is not None and len(opt) > 0:
-            new_value: T | None = opt[default_index]
-        else:
-            new_value = None
+    # For Enum values, use the original index_() approach which uses == comparison.
+    # This correctly handles enum class identity - enums from different classes
+    # (e.g., after script rerun) should NOT be considered equal, which is important
+    # for enum coercion to work correctly when coercion is disabled.
+    if isinstance(current_value, Enum):
+        try:
+            index_(opt, current_value)
+            return current_value, False
+        except ValueError:
+            pass  # Fall through to reset logic below
+    else:
+        # For non-Enum values, use format_func comparison. This handles custom objects
+        # without __eq__ where widget values are deepcopied and the deepcopied instances
+        # would fail identity comparison with ==.
+        try:
+            formatted_value = format_func(current_value)
+        except Exception:
+            # format_func failed - value is invalid
+            formatted_value = None
+
+        formatted_options_set = {format_func(o) for o in opt}
+        if formatted_value is not None and formatted_value in formatted_options_set:
+            return current_value, False
+
+    # Value not in options - reset to default
+    if default_index is not None and len(opt) > 0:
+        new_value: T | None = opt[default_index]
+    else:
+        new_value = None
 
-        if key is not None:
-            # Update session_state so subsequent accesses in this run
-            # return the corrected value. Use reset_state_value to avoid
-            # the "cannot be modified after widget instantiated" error.
-            get_session_state().reset_state_value(str(key), new_value)
+    if key is not None:
+        # Update session_state so subsequent accesses in this run
+        # return the corrected value. Use reset_state_value to avoid
+        # the "cannot be modified after widget instantiated" error.
+        get_session_state().reset_state_value(str(key), new_value)
 
-        return new_value, True
+    return new_value, True
 
 
 def validate_and_sync_multiselect_value_with_options(
     current_values: list[T] | list[T | str],
     opt: Sequence[T],
     key: str | int | None,
+    format_func: Callable[[Any], str] = str,
 ) -> tuple[list[T] | list[T | str], bool]:
     """Validate multiselect values against options, syncing session state if needed.
 
@@ -356,6 +382,11 @@ def validate_and_sync_multiselect_value_with_options(
         The sequence of valid options.
     key
         The widget key for session state updates.
+    format_func
+        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.
 
     Returns
     -------
@@ -365,13 +396,26 @@ def validate_and_sync_multiselect_value_with_options(
     if not current_values:
         return current_values, False
 
+    # Create a set of formatted options for O(1) lookup.
+    # We use format_func 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.
+    formatted_options_set = {format_func(o) for o in opt}
+
     valid_values: list[T | str] = []
     for value in current_values:
         try:
-            index_(opt, value)
+            formatted_value = format_func(value)
+        except Exception:  # noqa: S112
+            # format_func failed on this value (e.g., a string value from a previous
+            # session when format_func expects an object with specific attributes).
+            # In this case, the value is definitely not valid since the current options
+            # can be formatted successfully.
+            continue
+
+        if formatted_value in formatted_options_set:
             valid_values.append(value)
-        except ValueError:  # noqa: PERF203
-            pass
 
     if len(valid_values) == len(current_values):
         return current_values, False

streamlit/elements/widgets/multiselect.py

@@ -82,6 +82,7 @@ class MultiSelectSerde(Generic[T]):
     formatted_options: list[str]
     formatted_option_to_option_index: dict[str, int]
     default_options_indices: list[int]
+    format_func: Callable[[Any], str]
 
     def __init__(
         self,
@@ -90,6 +91,7 @@ class MultiSelectSerde(Generic[T]):
         formatted_options: list[str],
         formatted_option_to_option_index: dict[str, int],
         default_options_indices: list[int] | None = None,
+        format_func: Callable[[Any], str] = str,
     ) -> None:
         """Initialize the MultiSelectSerde.
 
@@ -111,24 +113,45 @@ class MultiSelectSerde(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_options_indices = default_options_indices or []
+        self.format_func = format_func
 
     def serialize(self, value: list[T | str] | list[T]) -> list[str]:
         converted_value = convert_anything_to_list(value)
         values: list[str] = []
         for v in converted_value:
+            # Use format_func to find the formatted option instead of using
+            # self.options.index(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 = self.options.index(v)
-                values.append(self.formatted_options[option_index])
-            except ValueError:  # noqa: PERF203
-                # at this point we know that v is a string, otherwise
-                # it would have been found in the options
-                values.append(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 append
+                # 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
+                values.append(str(v))
+                continue
+
+            if formatted_value in self.formatted_option_to_option_index:
+                values.append(formatted_value)
+            else:
+                # Value not found in options - it's likely a user-entered string
+                # (when accept_new_options=True) or an invalid value. Use the
+                # formatted string (not the original object) for type consistency.
+                values.append(formatted_value)
         return values
 
     def deserialize(self, ui_value: list[str] | None) -> list[T | str] | list[T]:
@@ -530,6 +553,7 @@ class MultiSelectMixin:
             formatted_options=formatted_options,
             formatted_option_to_option_index=formatted_option_to_option_index,
             default_options_indices=default_values,
+            format_func=format_func,
         )
 
         widget_state = register_widget(
@@ -560,7 +584,7 @@ class MultiSelectMixin:
             # previously selected values are no longer available.
             current_values, value_needs_reset = (
                 validate_and_sync_multiselect_value_with_options(
-                    widget_state.value, indexable_options, key
+                    widget_state.value, indexable_options, key, format_func
                 )
             )
 

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/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/proto/Radio_pb2.py

@@ -15,7 +15,7 @@ _sym_db = _symbol_database.Default()
 from streamlit.proto import LabelVisibilityMessage_pb2 as streamlit_dot_proto_dot_LabelVisibilityMessage__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bstreamlit/proto/Radio.proto\x1a,streamlit/proto/LabelVisibilityMessage.proto\"\x90\x02\n\x05Radio\x12\n\n\x02id\x18\x01 \x01(\t\x12\r\n\x05label\x18\x02 \x01(\t\x12\x14\n\x07\x64\x65\x66\x61ult\x18\x03 \x01(\x05H\x00\x88\x01\x01\x12\x0f\n\x07options\x18\x04 \x03(\t\x12\x0c\n\x04help\x18\x05 \x01(\t\x12\x0f\n\x07\x66orm_id\x18\x06 \x01(\t\x12\x12\n\x05value\x18\x07 \x01(\x05H\x01\x88\x01\x01\x12\x11\n\tset_value\x18\x08 \x01(\x08\x12\x10\n\x08\x64isabled\x18\t \x01(\x08\x12\x12\n\nhorizontal\x18\n \x01(\x08\x12\x31\n\x10label_visibility\x18\x0b \x01(\x0b\x32\x17.LabelVisibilityMessage\x12\x10\n\x08\x63\x61ptions\x18\x0c \x03(\tB\n\n\x08_defaultB\x08\n\x06_valueB*\n\x1c\x63om.snowflake.apps.streamlitB\nRadioProtob\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bstreamlit/proto/Radio.proto\x1a,streamlit/proto/LabelVisibilityMessage.proto\"\xba\x02\n\x05Radio\x12\n\n\x02id\x18\x01 \x01(\t\x12\r\n\x05label\x18\x02 \x01(\t\x12\x14\n\x07\x64\x65\x66\x61ult\x18\x03 \x01(\x05H\x00\x88\x01\x01\x12\x0f\n\x07options\x18\x04 \x03(\t\x12\x0c\n\x04help\x18\x05 \x01(\t\x12\x0f\n\x07\x66orm_id\x18\x06 \x01(\t\x12\x16\n\x05value\x18\x07 \x01(\x05\x42\x02\x18\x01H\x01\x88\x01\x01\x12\x16\n\traw_value\x18\r \x01(\tH\x02\x88\x01\x01\x12\x11\n\tset_value\x18\x08 \x01(\x08\x12\x10\n\x08\x64isabled\x18\t \x01(\x08\x12\x12\n\nhorizontal\x18\n \x01(\x08\x12\x31\n\x10label_visibility\x18\x0b \x01(\x0b\x32\x17.LabelVisibilityMessage\x12\x10\n\x08\x63\x61ptions\x18\x0c \x03(\tB\n\n\x08_defaultB\x08\n\x06_valueB\x0c\n\n_raw_valueB*\n\x1c\x63om.snowflake.apps.streamlitB\nRadioProtob\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -23,6 +23,8 @@ _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'streamlit.proto.Radio_pb2',
 if not _descriptor._USE_C_DESCRIPTORS:
   _globals['DESCRIPTOR']._loaded_options = None
   _globals['DESCRIPTOR']._serialized_options = b'\n\034com.snowflake.apps.streamlitB\nRadioProto'
+  _globals['_RADIO'].fields_by_name['value']._loaded_options = None
+  _globals['_RADIO'].fields_by_name['value']._serialized_options = b'\030\001'
   _globals['_RADIO']._serialized_start=78
-  _globals['_RADIO']._serialized_end=350
+  _globals['_RADIO']._serialized_end=392
 # @@protoc_insertion_point(module_scope)

streamlit/proto/Radio_pb2.pyi

@@ -31,6 +31,11 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeAlias as _TypeAlias
 
+if sys.version_info >= (3, 13):
+    from warnings import deprecated as _deprecated
+else:
+    from typing_extensions import deprecated as _deprecated
+
 DESCRIPTOR: _descriptor.FileDescriptor
 
 @_typing.final
@@ -44,6 +49,7 @@ class Radio(_message.Message):
     HELP_FIELD_NUMBER: _builtins.int
     FORM_ID_FIELD_NUMBER: _builtins.int
     VALUE_FIELD_NUMBER: _builtins.int
+    RAW_VALUE_FIELD_NUMBER: _builtins.int
     SET_VALUE_FIELD_NUMBER: _builtins.int
     DISABLED_FIELD_NUMBER: _builtins.int
     HORIZONTAL_FIELD_NUMBER: _builtins.int
@@ -54,7 +60,13 @@ class Radio(_message.Message):
     default: _builtins.int
     help: _builtins.str
     form_id: _builtins.str
-    value: _builtins.int
+    @_builtins.property
+    @_deprecated("""This field has been marked as deprecated using proto field options.""")
+    def value(self) -> _builtins.int: ...
+    @value.setter
+    @_deprecated("""This field has been marked as deprecated using proto field options.""")
+    def value(self, value: _builtins.int) -> None: ...
+    raw_value: _builtins.str
     set_value: _builtins.bool
     disabled: _builtins.bool
     horizontal: _builtins.bool
@@ -74,23 +86,28 @@ class Radio(_message.Message):
         help: _builtins.str = ...,
         form_id: _builtins.str = ...,
         value: _builtins.int | None = ...,
+        raw_value: _builtins.str | None = ...,
         set_value: _builtins.bool = ...,
         disabled: _builtins.bool = ...,
         horizontal: _builtins.bool = ...,
         label_visibility: _LabelVisibilityMessage_pb2.LabelVisibilityMessage | None = ...,
         captions: _abc.Iterable[_builtins.str] | None = ...,
     ) -> None: ...
-    _HasFieldArgType: _TypeAlias = _typing.Literal["_default", b"_default", "_value", b"_value", "default", b"default", "label_visibility", b"label_visibility", "value", b"value"]  # noqa: Y015
+    _HasFieldArgType: _TypeAlias = _typing.Literal["_default", b"_default", "_raw_value", b"_raw_value", "_value", b"_value", "default", b"default", "label_visibility", b"label_visibility", "raw_value", b"raw_value", "value", b"value"]  # noqa: Y015
     def HasField(self, field_name: _HasFieldArgType) -> _builtins.bool: ...
-    _ClearFieldArgType: _TypeAlias = _typing.Literal["_default", b"_default", "_value", b"_value", "captions", b"captions", "default", b"default", "disabled", b"disabled", "form_id", b"form_id", "help", b"help", "horizontal", b"horizontal", "id", b"id", "label", b"label", "label_visibility", b"label_visibility", "options", b"options", "set_value", b"set_value", "value", b"value"]  # noqa: Y015
+    _ClearFieldArgType: _TypeAlias = _typing.Literal["_default", b"_default", "_raw_value", b"_raw_value", "_value", b"_value", "captions", b"captions", "default", b"default", "disabled", b"disabled", "form_id", b"form_id", "help", b"help", "horizontal", b"horizontal", "id", b"id", "label", b"label", "label_visibility", b"label_visibility", "options", b"options", "raw_value", b"raw_value", "set_value", b"set_value", "value", b"value"]  # noqa: Y015
     def ClearField(self, field_name: _ClearFieldArgType) -> None: ...
     _WhichOneofReturnType__default: _TypeAlias = _typing.Literal["default"]  # noqa: Y015
     _WhichOneofArgType__default: _TypeAlias = _typing.Literal["_default", b"_default"]  # noqa: Y015
+    _WhichOneofReturnType__raw_value: _TypeAlias = _typing.Literal["raw_value"]  # noqa: Y015
+    _WhichOneofArgType__raw_value: _TypeAlias = _typing.Literal["_raw_value", b"_raw_value"]  # noqa: Y015
     _WhichOneofReturnType__value: _TypeAlias = _typing.Literal["value"]  # noqa: Y015
     _WhichOneofArgType__value: _TypeAlias = _typing.Literal["_value", b"_value"]  # noqa: Y015
     @_typing.overload
     def WhichOneof(self, oneof_group: _WhichOneofArgType__default) -> _WhichOneofReturnType__default | None: ...
     @_typing.overload
+    def WhichOneof(self, oneof_group: _WhichOneofArgType__raw_value) -> _WhichOneofReturnType__raw_value | None: ...
+    @_typing.overload
     def WhichOneof(self, oneof_group: _WhichOneofArgType__value) -> _WhichOneofReturnType__value | None: ...
 
 Global___Radio: _TypeAlias = Radio  # noqa: Y015

streamlit/static/index.html

@@ -37,7 +37,7 @@
     <script>
       window.prerenderReady = false
     </script>
-    <script type="module" crossorigin src="./static/js/index.qjO5OK90.js"></script>
+    <script type="module" crossorigin src="./static/js/index.BB_iwaVr.js"></script>
     <link rel="stylesheet" crossorigin href="./static/css/index.BUP6fTcR.css">
   </head>
   <body>