streamlit-nightly 1.53.1.dev20260117__py3-none-any.whl → 1.53.1.dev20260121__py3-none-any.whl

streamlit/__init__.py

@@ -111,7 +111,6 @@ from streamlit.runtime.state import (
 )
 from streamlit.user_info import (
     UserInfoProxy as _UserInfoProxy,
-    DeprecatedUserInfoProxy as _DeprecatedUserInfoProxy,
     login as _login,
     logout as _logout,
 )
@@ -275,9 +274,6 @@ logout = _logout
 # User
 user = _UserInfoProxy()
 
-# Experimental APIs
-experimental_user = _DeprecatedUserInfoProxy()
-
 # make it possible to call streamlit.components.v1.html etc. by importing it here
 # import in the very end to avoid partially-initialized module import errors, because
 # streamlit.components.v1 also uses some streamlit imports

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/dataframe_util.py

@@ -1072,8 +1072,10 @@ def is_colum_type_arrow_incompatible(column: Series[Any] | Index[Any]) -> bool:
         return True
 
     if column.dtype == "object":
-        # The dtype of mixed type columns is always object, the actual type of the column
-        # values can be determined via the infer_dtype function:
+        # The dtype of mixed type columns is always object. In pandas 3.0+, pure
+        # string columns use StringDtype instead of object, so they won't enter
+        # this block (and they're Arrow-compatible anyway). The actual type of
+        # object dtype column values can be determined via the infer_dtype function:
         # https://pandas.pydata.org/docs/reference/api/pandas.api.types.infer_dtype.html
         inferred_type = infer_dtype(column, skipna=True)
 

streamlit/elements/lib/built_in_chart_utils.py

@@ -611,6 +611,9 @@ def _melt_data(
 
     y_series = melted_df[new_y_column_name]
     if (
+        # After melting columns of different dtypes, the result has object dtype.
+        # In pandas 3.0+, melting columns with the same StringDtype keeps StringDtype,
+        # so this check correctly identifies only truly mixed-type scenarios.
         y_series.dtype == "object"
         and "mixed" in infer_dtype(y_series)
         and len(y_series.unique()) > 100

streamlit/elements/lib/column_config_utils.py

@@ -255,7 +255,9 @@ def _determine_data_kind_via_pandas_dtype(
     if pd.api.types.is_object_dtype(
         column_dtype
     ) is False and pd.api.types.is_string_dtype(column_dtype):
-        # The is_string_dtype
+        # This handles pandas 3.0+ StringDtype (and PyArrow-backed string types).
+        # We exclude object dtype here because object columns with string values
+        # are handled via _determine_data_kind_via_inferred_type in the caller.
         return ColumnDataKind.STRING
 
     return ColumnDataKind.UNKNOWN

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/time_widgets.py

@@ -539,6 +539,42 @@ def _validate_date_value(
     return cast("DateWidgetReturn", tuple(parsed_values.value)), True
 
 
+def _validate_datetime_value(
+    current_value: datetime | None,
+    parsed_values: _DateTimeInputValues,
+    has_explicit_bounds: bool,
+) -> tuple[datetime | None, bool]:
+    """Validate current datetime value against min/max bounds and determine if reset is needed.
+
+    Only validates when has_explicit_bounds is True (user provided min_value or max_value).
+    This avoids incorrectly determining if reset is needed against computed default bounds.
+
+    Parameters
+    ----------
+    current_value : datetime | None
+        The current value of the datetime input widget.
+    parsed_values : _DateTimeInputValues
+        Parsed configuration containing min, max, and default value.
+    has_explicit_bounds : bool
+        Whether the user explicitly provided min_value or max_value. If False, validation
+        is skipped to avoid resetting against computed default bounds.
+
+    Returns
+    -------
+    tuple[datetime | None, bool]
+        A tuple of (validated_value, was_reset) where validated_value is either the
+        original value (if valid) or the default value (if reset was needed), and
+        was_reset indicates whether a reset occurred.
+    """
+    if current_value is None or not has_explicit_bounds:
+        return current_value, False
+
+    if current_value < parsed_values.min or current_value > parsed_values.max:
+        return parsed_values.value, True
+
+    return current_value, False
+
+
 @dataclass
 class DateInputSerde:
     value: _DateInputValues
@@ -1132,9 +1168,10 @@ class TimeWidgetsMixin:
         element_id = compute_and_register_element_id(
             "date_time_input",
             user_key=key,
-            # Ensure stable IDs when the key is provided; whitelist parameters that
-            # affect the selectable range or formatting.
-            key_as_main_identity={"min_value", "max_value", "format", "step"},
+            # Format is whitelisted because of a bug in the BaseWeb date input component.
+            # Step is whitelisted because it invalidates the current selection.
+            # We might be able to unlock this as a follow-up.
+            key_as_main_identity={"format", "step"},
             dg=self.dg,
             label=label,
             value=value_for_id,
@@ -1145,7 +1182,9 @@ class TimeWidgetsMixin:
             step=step,
             width=width,
         )
-        del value
+        # Track if user explicitly set bounds (before del)
+        has_explicit_bounds = min_value is not None or max_value is not None
+        del value, min_value, max_value
 
         if not bool(ALLOWED_DATE_FORMATS.match(format)):
             raise StreamlitAPIException(
@@ -1208,8 +1247,20 @@ class TimeWidgetsMixin:
             value_type="string_array_value",
         )
 
-        if widget_state.value_changed:
-            date_time_input_proto.value[:] = serde.serialize(widget_state.value)
+        # Validate the current value against the new min/max bounds.
+        # Only validate when user explicitly provided min_value or max_value.
+        current_value, value_needs_reset = _validate_datetime_value(
+            widget_state.value, datetime_values, has_explicit_bounds
+        )
+
+        if value_needs_reset and 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(key, current_value)
+
+        if value_needs_reset or widget_state.value_changed:
+            date_time_input_proto.value[:] = serde.serialize(current_value)
             date_time_input_proto.set_value = True
 
         validate_width(width)
@@ -1218,7 +1269,7 @@ class TimeWidgetsMixin:
         self.dg._enqueue(
             "date_time_input", date_time_input_proto, layout_config=layout_config
         )
-        return widget_state.value
+        return current_value
 
     @overload
     def date_input(

streamlit/hello/dataframe_demo.py

@@ -54,7 +54,7 @@ def data_frame_demo() -> None:
                     color="Region:N",
                 )
             )
-            st.altair_chart(chart, use_container_width=True)
+            st.altair_chart(chart, width="stretch")
     except URLError as e:
         st.error(f"This demo requires internet access. Connection error: {e.reason}")
 

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.Cpn4aUEp.js"></script>
     <link rel="stylesheet" crossorigin href="./static/css/index.BUP6fTcR.css">
   </head>
   <body>