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

streamlit/connections/snowflake_connection.py

@@ -349,6 +349,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/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/static/index.html

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