streamlit 1.45.0__py3-none-any.whl → 1.46.0__py3-none-any.whl

streamlit/runtime/scriptrunner/script_runner.py

@@ -62,6 +62,8 @@ from streamlit.runtime.state import (
 from streamlit.source_util import page_sort_key
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
+
     from streamlit.runtime.fragment import FragmentStorage
     from streamlit.runtime.scriptrunner.script_cache import ScriptCache
     from streamlit.runtime.uploaded_file_manager import UploadedFileManager
@@ -121,36 +123,35 @@ it in the future.
 # is designed to leverage our original v1 version of multi-page apps. This
 # function will be called to run the script in lieu of the main script. This
 # function simulates the v1 setup using the modern v2 commands (st.navigation)
-def _mpa_v1(main_script_path: str):
+def _mpa_v1(main_script_path: str) -> None:
     from pathlib import Path
 
     from streamlit.commands.navigation import PageType, _navigation
     from streamlit.navigation.page import StreamlitPage
 
     # Select the folder that should be used for the pages:
-    MAIN_SCRIPT_PATH = Path(main_script_path).resolve()
-    PAGES_FOLDER = MAIN_SCRIPT_PATH.parent / "pages"
+    resolved_main_script_path: Final = Path(main_script_path).resolve()
+    pages_folder: Final = resolved_main_script_path.parent / "pages"
 
     # Read out the my_pages folder and create a page for every script:
-    pages = PAGES_FOLDER.glob("*.py")
     pages = sorted(
         [
             page
-            for page in pages
+            for page in pages_folder.glob("*.py")
             if page.name.endswith(".py")
             and not page.name.startswith(".")
-            and not page.name == "__init__.py"
+            and page.name != "__init__.py"
         ],
         key=page_sort_key,
     )
 
     # Use this script as the main page and
-    main_page = StreamlitPage(MAIN_SCRIPT_PATH, default=True)
+    main_page = StreamlitPage(resolved_main_script_path, default=True)
     all_pages = [main_page] + [
-        StreamlitPage(PAGES_FOLDER / page.name) for page in pages
+        StreamlitPage(pages_folder / page.name) for page in pages
     ]
     # Initialize the navigation with all the pages:
-    position: Literal["sidebar", "hidden"] = (
+    position: Literal["sidebar", "hidden", "top"] = (
         "hidden"
         if config.get_option("client.showSidebarNavigation") is False
         else "sidebar"
@@ -161,11 +162,7 @@ def _mpa_v1(main_script_path: str):
         expanded=False,
     )
 
-    if page._page != main_page._page:
-        # Only run the page if it is not pointing to this script:
-        page.run()
-        # Finish the script execution here to only run the selected page
-        raise StopException()
+    page.run()
 
 
 class ScriptRunner:
@@ -180,7 +177,7 @@ class ScriptRunner:
         user_info: dict[str, str | bool | None],
         fragment_storage: FragmentStorage,
         pages_manager: PagesManager,
-    ):
+    ) -> None:
         """Initialize the ScriptRunner.
 
         (The ScriptRunner won't start executing until start() is called.)
@@ -265,7 +262,7 @@ class ScriptRunner:
         # _maybe_handle_execution_control_request.
         self._execing = False
 
-        # This is initialized in start()
+        # This is initialized in the start() method
         self._script_thread: threading.Thread | None = None
 
     def __repr__(self) -> str:
@@ -301,7 +298,7 @@ class ScriptRunner:
 
         """
         if self._script_thread is not None:
-            raise Exception("ScriptRunner was already started")
+            raise RuntimeError("ScriptRunner was already started")
 
         self._script_thread = threading.Thread(
             target=self._run_script_thread,
@@ -325,7 +322,10 @@ class ScriptRunner:
             If there is no ScriptRunContext for the current thread.
 
         """
-        assert self._is_in_script_thread()
+        if not self._is_in_script_thread():
+            raise RuntimeError(
+                "ScriptRunner._get_script_run_ctx must be called from the script thread."
+            )
 
         ctx = get_script_run_ctx()
         if ctx is None:
@@ -345,7 +345,10 @@ class ScriptRunner:
         When the ScriptRequestQueue is empty, or when a SHUTDOWN request is
         dequeued, this function will exit and its thread will terminate.
         """
-        assert self._is_in_script_thread()
+        if not self._is_in_script_thread():
+            raise RuntimeError(
+                "ScriptRunner._run_script_thread must be called from the script thread."
+            )
 
         _LOGGER.debug("Beginning script thread")
 
@@ -375,13 +378,18 @@ class ScriptRunner:
             self._run_script(request.rerun_data)
             request = self._requests.on_scriptrunner_ready()
 
-        assert request.type == ScriptRequestType.STOP
+        if request.type != ScriptRequestType.STOP:
+            raise RuntimeError(
+                f"Unrecognized ScriptRequestType: {request.type}. This should never happen."
+            )
 
         # Send a SHUTDOWN event before exiting, so some state can be saved
         # for use in a future script run when not triggered by the client.
         client_state = ClientState()
         client_state.query_string = ctx.query_string
         client_state.page_script_hash = ctx.page_script_hash
+        if ctx.context_info:
+            client_state.context_info.CopyFrom(ctx.context_info)
         self.on_event.send(
             self, event=ScriptRunnerEvent.SHUTDOWN, client_state=client_state
         )
@@ -437,11 +445,14 @@ class ScriptRunner:
         if request.type == ScriptRequestType.RERUN:
             raise RerunException(request.rerun_data)
 
-        assert request.type == ScriptRequestType.STOP
+        if request.type != ScriptRequestType.STOP:
+            raise RuntimeError(
+                f"Unrecognized ScriptRequestType: {request.type}. This should never happen."
+            )
         raise StopException()
 
     @contextmanager
-    def _set_execing_flag(self):
+    def _set_execing_flag(self) -> Generator[None, None, None]:
         """A context for setting the ScriptRunner._execing flag.
 
         Used by _maybe_handle_execution_control_request to ensure that
@@ -465,7 +476,10 @@ class ScriptRunner:
 
         """
 
-        assert self._is_in_script_thread()
+        if not self._is_in_script_thread():
+            raise RuntimeError(
+                "ScriptRunner._run_script must be called from the script thread."
+            )
 
         # An explicit loop instead of recursion to avoid stack overflows
         while True:
@@ -484,7 +498,7 @@ class ScriptRunner:
                 rerun_data.page_script_hash, rerun_data.page_name
             )
             active_script = self._pages_manager.get_initial_active_script(
-                rerun_data.page_script_hash, rerun_data.page_name
+                rerun_data.page_script_hash
             )
             main_page_info = self._pages_manager.get_main_page()
 
@@ -589,7 +603,12 @@ class ScriptRunner:
             # assume is the main script directory.
             module.__dict__["__file__"] = script_path
 
-            def code_to_exec(code=code, module=module, ctx=ctx, rerun_data=rerun_data):
+            def code_to_exec(
+                code: str = code,
+                module: types.ModuleType = module,
+                ctx: ScriptRunContext = ctx,
+                rerun_data: RerunData = rerun_data,
+            ) -> None:
                 with (
                     modified_sys_path(self._main_script_path),
                     self._set_execing_flag(),
@@ -610,7 +629,7 @@ class ScriptRunner:
                                 )
                                 wrapped_fragment()
 
-                            except FragmentStorageKeyError:
+                            except FragmentStorageKeyError:  # noqa: PERF203
                                 # This can happen if the fragment_id is removed from the
                                 # storage before the script runner gets to it. In this
                                 # case, the fragment is simply skipped.
@@ -622,20 +641,21 @@ class ScriptRunner:
                                 # (see https://github.com/streamlit/streamlit/issues/9080).
                                 if not rerun_data.is_auto_rerun:
                                     _LOGGER.warning(
-                                        f"Couldn't find fragment with id {fragment_id}."
+                                        "Couldn't find fragment with id %s."
                                         " This can happen if the fragment does not"
                                         " exist anymore when this request is processed,"
                                         " for example because a full app rerun happened"
                                         " that did not register the fragment."
                                         " Usually this doesn't happen or no action is"
-                                        " required, so its mainly for debugging."
+                                        " required, so its mainly for debugging.",
+                                        fragment_id,
                                     )
-                            except (RerunException, StopException) as e:
+                            except (RerunException, StopException):
                                 # The wrapped_fragment function is executed
                                 # inside of a exec_func_with_error_handling call, so
                                 # there is a correct handler for these exceptions.
-                                raise e
-                            except Exception:
+                                raise
+                            except Exception:  # noqa: S110
                                 # Ignore exceptions raised by fragments here as we don't
                                 # want to stop the execution of other fragments. The
                                 # error itself is already rendered within the wrapped
@@ -645,7 +665,8 @@ class ScriptRunner:
                     else:
                         if PagesManager.uses_pages_directory:
                             _mpa_v1(self._main_script_path)
-                        exec(code, module.__dict__)
+                        else:
+                            exec(code, module.__dict__)  # noqa: S102
                         self._fragment_storage.clear(
                             new_fragment_ids=ctx.new_fragment_ids
                         )
@@ -742,7 +763,7 @@ def _clean_problem_modules() -> None:
         try:
             keras = sys.modules["keras"]
             keras.backend.clear_session()
-        except Exception:
+        except Exception:  # noqa: S110
             # We don't want to crash the app if we can't clear the Keras session.
             pass
 
@@ -750,7 +771,7 @@ def _clean_problem_modules() -> None:
         try:
             plt = sys.modules["matplotlib.pyplot"]
             plt.close("all")
-        except Exception:
+        except Exception:  # noqa: S110
             # We don't want to crash the app if we can't close matplotlib
             pass
 

streamlit/runtime/scriptrunner_utils/exceptions.py

@@ -34,7 +34,7 @@ class StopException(ScriptControlException):
 class RerunException(ScriptControlException):
     """Silently stop and rerun the user's script."""
 
-    def __init__(self, rerun_data: RerunData):
+    def __init__(self, rerun_data: RerunData) -> None:
         """Construct a RerunException.
 
         Parameters

streamlit/runtime/scriptrunner_utils/script_requests.py

@@ -111,9 +111,9 @@ def _coalesce_widget_states(
     """
     if not old_states and not new_states:
         return None
-    elif not old_states:
+    if not old_states:
         return new_states
-    elif not new_states:
+    if not new_states:
         return old_states
 
     states_by_id: dict[str, WidgetState] = {
@@ -161,7 +161,7 @@ class ScriptRequests:
     ScriptRunner handles those requests.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._lock = threading.Lock()
         self._state = ScriptRequestType.CONTINUE
         self._rerun_data = RerunData()
@@ -284,7 +284,10 @@ class ScriptRequests:
                 self._state = ScriptRequestType.CONTINUE
                 return ScriptRequest(ScriptRequestType.RERUN, self._rerun_data)
 
-            assert self._state == ScriptRequestType.STOP
+            if self._state != ScriptRequestType.STOP:
+                raise RuntimeError(
+                    f"Unrecognized ScriptRunnerState: {self._state}. This should never happen."
+                )
             return ScriptRequest(ScriptRequestType.STOP)
 
     def on_scriptrunner_ready(self) -> ScriptRequest:

streamlit/runtime/scriptrunner_utils/script_run_context.py

@@ -33,7 +33,6 @@ from typing_extensions import TypeAlias
 from streamlit.errors import (
     NoSessionContext,
     StreamlitAPIException,
-    StreamlitSetPageConfigMustBeFirstCommandError,
 )
 from streamlit.logger import get_logger
 from streamlit.runtime.forward_msg_cache import (
@@ -42,6 +41,7 @@ from streamlit.runtime.forward_msg_cache import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
     from pathlib import Path
 
     from streamlit.cursor import RunningCursor
@@ -97,7 +97,6 @@ class ScriptRunContext:
     command_tracking_deactivated: bool = False
     tracked_commands: list[Command] = field(default_factory=list)
     tracked_commands_counter: Counter[str] = field(default_factory=collections.Counter)
-    _set_page_config_allowed: bool = True
     _has_script_started: bool = False
     widget_ids_this_run: set[str] = field(default_factory=set)
     widget_user_keys_this_run: set[str] = field(default_factory=set)
@@ -107,6 +106,7 @@ class ScriptRunContext:
     current_fragment_id: str | None = None
     fragment_ids_this_run: list[str] | None = None
     new_fragment_ids: set[str] = field(default_factory=set)
+    in_fragment_callback: bool = False
     _active_script_hash: str = ""
     # we allow only one dialog to be open at the same time
     has_dialog_opened: bool = False
@@ -116,11 +116,11 @@ class ScriptRunContext:
     _production_query_params_used = False
 
     @property
-    def page_script_hash(self):
+    def page_script_hash(self) -> str:
         return self.pages_manager.current_page_script_hash
 
     @property
-    def active_script_hash(self):
+    def active_script_hash(self) -> str:
         return self._active_script_hash
 
     @property
@@ -128,7 +128,7 @@ class ScriptRunContext:
         return self.pages_manager.main_script_parent
 
     @contextlib.contextmanager
-    def run_with_active_hash(self, page_hash: str):
+    def run_with_active_hash(self, page_hash: str) -> Generator[None, None, None]:
         original_page_hash = self._active_script_hash
         self._active_script_hash = page_hash
         try:
@@ -137,7 +137,7 @@ class ScriptRunContext:
             # in the event of any exception, ensure we set the active hash back
             self._active_script_hash = original_page_hash
 
-    def set_mpa_v2_page(self, page_script_hash: str):
+    def set_mpa_v2_page(self, page_script_hash: str) -> None:
         self._active_script_hash = self.pages_manager.main_script_hash
         self.pages_manager.set_current_page_script_hash(page_script_hash)
 
@@ -157,8 +157,6 @@ class ScriptRunContext:
         self.context_info = context_info
         self.pages_manager.set_current_page_script_hash(page_script_hash)
         self._active_script_hash = self.pages_manager.main_script_hash
-        # Permit set_page_config when the ScriptRunContext is reused on a rerun
-        self._set_page_config_allowed = True
         self._has_script_started = False
         self.command_tracking_deactivated: bool = False
         self.tracked_commands = []
@@ -188,17 +186,6 @@ class ScriptRunContext:
 
     def enqueue(self, msg: ForwardMsg) -> None:
         """Enqueue a ForwardMsg for this context's session."""
-        if msg.HasField("page_config_changed") and not self._set_page_config_allowed:
-            raise StreamlitSetPageConfigMustBeFirstCommandError()
-
-        # We want to disallow set_page config if one of the following occurs:
-        # - set_page_config was called on this message
-        # - The script has already started and a different st call occurs (a delta)
-        if msg.HasField("page_config_changed") or (
-            msg.HasField("delta") and self._has_script_started
-        ):
-            self._set_page_config_allowed = False
-
         msg.metadata.active_script_hash = self.active_script_hash
 
         # We populate the hash and cacheable field for all messages.
@@ -217,7 +204,7 @@ class ScriptRunContext:
         # Pass the message up to our associated ScriptRunner.
         self._enqueue(msg_to_send)
 
-    def ensure_single_query_api_used(self):
+    def ensure_single_query_api_used(self) -> None:
         if self._experimental_query_params_used and self._production_query_params_used:
             raise StreamlitAPIException(
                 "Using `st.query_params` together with either `st.experimental_get_query_params` "
@@ -225,11 +212,11 @@ class ScriptRunContext:
                 " convert your app to only use `st.query_params`"
             )
 
-    def mark_experimental_query_params_used(self):
+    def mark_experimental_query_params_used(self) -> None:
         self._experimental_query_params_used = True
         self.ensure_single_query_api_used()
 
-    def mark_production_query_params_used(self):
+    def mark_production_query_params_used(self) -> None:
         self._production_query_params_used = True
         self.ensure_single_query_api_used()
 
@@ -239,7 +226,7 @@ SCRIPT_RUN_CONTEXT_ATTR_NAME: Final = "streamlit_script_run_ctx"
 
 def add_script_run_ctx(
     thread: threading.Thread | None = None, ctx: ScriptRunContext | None = None
-):
+) -> threading.Thread:
     """Adds the current ScriptRunContext to a newly-created thread.
 
     This should be called from this thread's parent thread,

streamlit/runtime/secrets.py

@@ -27,9 +27,8 @@ from typing import (
 
 from blinker import Signal
 
-import streamlit as st
 import streamlit.watcher.path_watcher
-from streamlit import runtime
+from streamlit import config, runtime
 from streamlit.errors import StreamlitSecretNotFoundError
 from streamlit.logger import get_logger
 
@@ -37,34 +36,40 @@ _LOGGER: Final = get_logger(__name__)
 
 
 class SecretErrorMessages:
-    """SecretErrorMessages stores all error messages we use for secrets to allow customization for different environments.
+    """SecretErrorMessages stores all error messages we use for secrets to allow customization
+    for different environments.
+
     For example Streamlit Cloud can customize the message to be different than the open source.
 
     For internal use, may change in future releases without notice.
     """
 
-    def __init__(self):
-        self.missing_attr_message = lambda attr_name: (
+    def __init__(self) -> None:
+        self.missing_attr_message: Callable[[str], str] = lambda attr_name: (
             f'st.secrets has no attribute "{attr_name}". '
-            f"Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings on Streamlit Cloud? "
-            f"More info: https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
+            "Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings "
+            "on Streamlit Cloud? More info: "
+            "https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
         )
-        self.missing_key_message = lambda key: (
+        self.missing_key_message: Callable[[str], str] = lambda key: (
             f'st.secrets has no key "{key}". '
-            f"Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings on Streamlit Cloud? "
-            f"More info: https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
+            "Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings "
+            "on Streamlit Cloud? More info: "
+            "https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
         )
-        self.no_secrets_found = lambda file_paths: (
+        self.no_secrets_found: Callable[[list[str]], str] = lambda file_paths: (
             f"No secrets found. Valid paths for a secrets.toml file or secret directories are: {', '.join(file_paths)}"
         )
-        self.error_parsing_file_at_path = (
+        self.error_parsing_file_at_path: Callable[[str, Exception], str] = (
             lambda path, ex: f"Error parsing secrets file at {path}: {ex}"
         )
-        self.subfolder_path_is_not_a_folder = lambda sub_folder_path: (
-            f"{sub_folder_path} is not a folder. "
-            "To use directory based secrets, mount every secret in a subfolder under the secret directory"
+        self.subfolder_path_is_not_a_folder: Callable[[str], str] = (
+            lambda sub_folder_path: (
+                f"{sub_folder_path} is not a folder. "
+                "To use directory based secrets, mount every secret in a subfolder under the secret directory"
+            )
         )
-        self.invalid_secret_path = lambda path: (
+        self.invalid_secret_path: Callable[[str], str] = lambda path: (
             f"Invalid secrets path: {path}: path is not a .toml file or a directory"
         )
 
@@ -144,15 +149,14 @@ class AttrDict(Mapping[str, Any]):
     to provide dot access to nested secrets.
     """
 
-    def __init__(self, value):
+    def __init__(self, value: Mapping[str, Any]) -> None:
         self.__dict__["__nested_secrets__"] = dict(value)
 
     @staticmethod
-    def _maybe_wrap_in_attr_dict(value) -> Any:
+    def _maybe_wrap_in_attr_dict(value: Any) -> Any:
         if not isinstance(value, Mapping):
             return value
-        else:
-            return AttrDict(value)
+        return AttrDict(value)
 
     def __len__(self) -> int:
         return len(self.__nested_secrets__)
@@ -174,13 +178,13 @@ class AttrDict(Mapping[str, Any]):
         except KeyError:
             raise AttributeError(_missing_attr_error_message(attr_name))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self.__nested_secrets__)
 
-    def __setitem__(self, key, value) -> NoReturn:
+    def __setitem__(self, key: str, value: Any) -> NoReturn:
         raise TypeError("Secrets does not support item assignment.")
 
-    def __setattr__(self, key, value) -> NoReturn:
+    def __setattr__(self, key: str, value: Any) -> NoReturn:
         raise TypeError("Secrets does not support attribute assignment.")
 
     def to_dict(self) -> dict[str, Any]:
@@ -194,7 +198,7 @@ class Secrets(Mapping[str, Any]):
     Safe to use from multiple threads.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Our secrets dict.
         self._secrets: Mapping[str, Any] | None = None
         self._lock = threading.RLock()
@@ -272,7 +276,8 @@ class Secrets(Mapping[str, Any]):
         return secrets, found_secrets_file
 
     def _parse_directory(self, path: str) -> tuple[Mapping[str, Any], bool]:
-        """Parse a directory for secrets. Directory style can be used to support Kubernetes secrets that are mounted to folders.
+        """Parse a directory for secrets. Directory style can be used to support Kubernetes secrets that are
+        mounted to folders.
 
         Example structure:
         - top_level_secret_folder
@@ -310,7 +315,7 @@ class Secrets(Mapping[str, Any]):
 
             if len(sub_secrets) == 1:
                 # if there's just one file, collapse it so it's directly under `dirname`
-                secrets[dirname] = sub_secrets[list(sub_secrets.keys())[0]]
+                secrets[dirname] = sub_secrets[next(iter(sub_secrets.keys()))]
             else:
                 secrets[dirname] = sub_secrets
 
@@ -356,7 +361,7 @@ class Secrets(Mapping[str, Any]):
 
             secrets = {}
 
-            file_paths = st.config.get_option("secrets.files")
+            file_paths = config.get_option("secrets.files")
             found_secrets_file = False
             for path in file_paths:
                 path_secrets, found_secrets_file_in_path = self._parse_file_path(path)
@@ -380,7 +385,9 @@ class Secrets(Mapping[str, Any]):
             return self._secrets
 
     def to_dict(self) -> dict[str, Any]:
-        """Converts the secrets store into a nested dictionary, where nested AttrDict objects are also converted into dictionaries."""
+        """Converts the secrets store into a nested dictionary, where nested AttrDict objects are
+        also converted into dictionaries.
+        """
         secrets = self._parse()
         return _convert_to_dict(secrets)
 
@@ -407,7 +414,7 @@ class Secrets(Mapping[str, Any]):
             if self._file_watchers_installed:
                 return
 
-            file_paths = st.config.get_option("secrets.files")
+            file_paths = config.get_option("secrets.files")
             for path in file_paths:
                 try:
                     if path.endswith(".toml"):
@@ -422,7 +429,7 @@ class Secrets(Mapping[str, Any]):
                             self._on_secrets_changed,
                             watcher_type="poll",
                         )
-                except FileNotFoundError:
+                except FileNotFoundError:  # noqa: PERF203
                     # A user may only have one secrets.toml file defined, so we'd expect
                     # FileNotFoundErrors to be raised when attempting to install a
                     # watcher on the nonexistent ones.
@@ -432,7 +439,7 @@ class Secrets(Mapping[str, Any]):
             # failed to avoid repeatedly trying to install it.
             self._file_watchers_installed = True
 
-    def _on_secrets_changed(self, changed_file_path) -> None:
+    def _on_secrets_changed(self, changed_file_path: str) -> None:
         with self._lock:
             _LOGGER.debug("Secret path %s changed, reloading", changed_file_path)
             self._reset()
@@ -452,8 +459,7 @@ class Secrets(Mapping[str, Any]):
             value = self._parse()[key]
             if not isinstance(value, Mapping):
                 return value
-            else:
-                return AttrDict(value)
+            return AttrDict(value)
         # We add FileNotFoundError since __getattr__ is expected to only raise
         # AttributeError. Without handling FileNotFoundError, unittests.mocks
         # fails during mock creation on Python3.9
@@ -470,8 +476,7 @@ class Secrets(Mapping[str, Any]):
             value = self._parse()[key]
             if not isinstance(value, Mapping):
                 return value
-            else:
-                return AttrDict(value)
+            return AttrDict(value)
         except KeyError:
             raise KeyError(_missing_key_error_message(key))
 

streamlit/runtime/session_manager.py

@@ -72,7 +72,8 @@ class SessionInfo:
         return self.client is not None
 
     def to_active(self) -> ActiveSessionInfo:
-        assert self.is_active(), "A SessionInfo with no client cannot be active!"
+        if not self.is_active():
+            raise RuntimeError("A SessionInfo with no client cannot be active!")
 
         # NOTE: The cast here (rather than copying this SessionInfo's fields into a new
         # ActiveSessionInfo) is important as the Runtime expects to be able to mutate

streamlit/runtime/state/__init__.py

@@ -27,15 +27,15 @@ from streamlit.runtime.state.session_state_proxy import (
 from streamlit.runtime.state.widgets import register_widget
 
 __all__ = [
-    "WidgetArgs",
-    "WidgetCallback",
-    "WidgetKwargs",
+    "SCRIPT_RUN_WITHOUT_ERRORS_KEY",
     "QueryParamsProxy",
     "SafeSessionState",
-    "SCRIPT_RUN_WITHOUT_ERRORS_KEY",
     "SessionState",
-    "SessionStateStatProvider",
     "SessionStateProxy",
+    "SessionStateStatProvider",
+    "WidgetArgs",
+    "WidgetCallback",
+    "WidgetKwargs",
     "get_session_state",
     "register_widget",
 ]

streamlit/runtime/state/common.py

@@ -51,7 +51,7 @@ WidgetCallback: TypeAlias = Callable[..., None]
 # WidgetState proto, and returns a regular python value. A serializer
 # receives a regular python value, and returns something suitable for
 # a value field on WidgetState proto. They should be inverses.
-WidgetDeserializer: TypeAlias = Callable[[Any, str], T]
+WidgetDeserializer: TypeAlias = Callable[[Any], T]
 WidgetSerializer: TypeAlias = Callable[[T], Any]
 
 # The array value field names are part of the larger set of possible value
@@ -156,7 +156,7 @@ class RegisterWidgetResult(Generic[T_co]):
         """The canonical way to construct a RegisterWidgetResult in cases
         where the true widget value could not be determined.
         """
-        return cls(value=deserializer(None, ""), value_changed=False)
+        return cls(value=deserializer(None), value_changed=False)
 
 
 def user_key_from_element_id(element_id: str) -> str | None: