streamlit 1.45.1__py3-none-any.whl → 1.46.1__py3-none-any.whl

streamlit/runtime/media_file_manager.py

@@ -38,14 +38,13 @@ def _get_session_id() -> str:
         # "streamlit run myscript.py". In which case the session ID doesn't
         # matter and can just be a constant, as there's only ever "session".
         return "dontcare"
-    else:
-        return ctx.session_id
+    return ctx.session_id
 
 
 class MediaFileMetadata:
     """Metadata that the MediaFileManager needs for each file it manages."""
 
-    def __init__(self, kind: MediaFileKind = MediaFileKind.MEDIA):
+    def __init__(self, kind: MediaFileKind = MediaFileKind.MEDIA) -> None:
         self._kind = kind
         self._is_marked_for_delete = False
 
@@ -80,7 +79,7 @@ class MediaFileManager:
       we should address it at some point.)
     """
 
-    def __init__(self, storage: MediaFileStorage):
+    def __init__(self, storage: MediaFileStorage) -> None:
         self._storage = storage
 
         # Dict of [file_id -> MediaFileMetadata]

streamlit/runtime/memory_media_file_storage.py

@@ -89,7 +89,7 @@ class MemoryFile(NamedTuple):
 
 
 class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
-    def __init__(self, media_endpoint: str):
+    def __init__(self, media_endpoint: str) -> None:
         """Create a new MemoryMediaFileStorage instance.
 
         Parameters
@@ -110,10 +110,11 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
     ) -> str:
         """Add a file to the manager and return its ID."""
         file_data: bytes
-        if isinstance(path_or_data, str):
-            file_data = self._read_file(path_or_data)
-        else:
-            file_data = path_or_data
+        file_data = (
+            self._read_file(path_or_data)
+            if isinstance(path_or_data, str)
+            else path_or_data
+        )
 
         # Because our file_ids are stable, if we already have a file with the
         # given ID, we don't need to create a new one.

streamlit/runtime/memory_uploaded_file_manager.py

@@ -35,7 +35,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
     This class can be used safely from multiple threads simultaneously.
     """
 
-    def __init__(self, upload_endpoint: str):
+    def __init__(self, upload_endpoint: str) -> None:
         self.file_storage: dict[str, dict[str, UploadedFileRec]] = defaultdict(dict)
         self.endpoint = upload_endpoint
 
@@ -92,7 +92,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
 
         self.file_storage[session_id][file.file_id] = file
 
-    def remove_file(self, session_id, file_id):
+    def remove_file(self, session_id: str, file_id: str) -> None:
         """Remove file with given file_id associated with a given session."""
         session_storage = self.file_storage[session_id]
         session_storage.pop(file_id, None)

streamlit/runtime/metrics_util.py

@@ -201,8 +201,8 @@ def _get_machine_id_v4() -> str:
     stable_id = None
 
     if os.path.exists(filepath):
-        with file_util.streamlit_read(filepath) as input:
-            stable_id = input.read()
+        with file_util.streamlit_read(filepath) as file:
+            stable_id = file.read()
 
     if not stable_id:
         stable_id = str(uuid.uuid4())
@@ -228,7 +228,7 @@ class Installation:
                     cls._instance = Installation()
         return cls._instance
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.installation_id_v3 = str(
             uuid.uuid5(uuid.NAMESPACE_DNS, _get_machine_id_v3())
         )
@@ -239,7 +239,7 @@ class Installation:
         return util.repr_(self)
 
     @property
-    def installation_id(self):
+    def installation_id(self) -> str:
         return self.installation_id_v3
 
 
@@ -284,7 +284,7 @@ def _get_arg_metadata(arg: object) -> str | None:
 
 
 def _get_command_telemetry(
-    _command_func: Callable[..., Any], _command_name: str, *args, **kwargs
+    _command_func: Callable[..., Any], _command_name: str, *args: Any, **kwargs: Any
 ) -> Command:
     """Get telemetry information for the given callable and its arguments."""
     arg_keywords = inspect.getfullargspec(_command_func).args
@@ -391,12 +391,11 @@ def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:
             )
 
         return wrapper
-    else:
-        # To make mypy type narrow F | None -> F
-        non_optional_func = func
+    # To make mypy type narrow F | None -> F
+    non_optional_func = func
 
     @wraps(non_optional_func)
-    def wrapped_func(*args, **kwargs):
+    def wrapped_func(*args: Any, **kwargs: Any) -> Any:
         from timeit import default_timer as timer
 
         exec_start = timer()
@@ -442,12 +441,12 @@ def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:
                 _LOGGER.debug("Failed to collect command telemetry", exc_info=ex)
         try:
             result = non_optional_func(*args, **kwargs)
-        except RerunException as ex:
+        except RerunException:
             # Duplicated from below, because static analysis tools get confused
             # by deferring the rethrow.
             if tracking_activated and command_telemetry:
                 command_telemetry.time = to_microseconds(timer() - exec_start)
-            raise ex
+            raise
         finally:
             # Activate tracking again if command executes without any exceptions
             # we only want to do that if this command has set the
@@ -488,7 +487,7 @@ def create_page_profile_message(
     # Collect all config options that have been manually set
     config_options: set[str] = set()
     if config._config_options:
-        for option_name in config._config_options.keys():
+        for option_name in config._config_options:
             if not config.is_manually_set(option_name):
                 # We only care about manually defined options
                 continue

streamlit/runtime/pages_manager.py

@@ -38,8 +38,8 @@ class PagesManager:
         self,
         main_script_path: ScriptPath,
         script_cache: ScriptCache | None = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         self._main_script_path = main_script_path
         self._main_script_hash: PageHash = calc_md5(main_script_path)
         self._script_cache = script_cache
@@ -99,9 +99,7 @@ class PagesManager:
         self._intended_page_script_hash = page_script_hash
         self._intended_page_name = page_name
 
-    def get_initial_active_script(
-        self, page_script_hash: PageHash, page_name: PageName
-    ) -> PageInfo | None:
+    def get_initial_active_script(self, page_script_hash: PageHash) -> PageInfo | None:
         return {
             # We always run the main script in V2 as it's the common code
             "script_path": self.main_script_path,
@@ -137,7 +135,7 @@ class PagesManager:
                 self.intended_page_script_hash,
                 self._pages.get(fallback_page_hash, None),
             )
-        elif self.intended_page_name:
+        if self.intended_page_name:
             # If a user navigates directly to a non-main page of an app, the
             # the page name can identify the page script to run
             return next(

streamlit/runtime/runtime.py

@@ -167,7 +167,7 @@ class Runtime:
         """
         return cls._instance is not None
 
-    def __init__(self, config: RuntimeConfig):
+    def __init__(self, config: RuntimeConfig) -> None:
         """Create a Runtime instance. It won't be started yet.
 
         Runtime is *not* thread-safe. Its public methods are generally
@@ -313,7 +313,7 @@ class Runtime:
 
         async_objs = self._get_async_objs()
 
-        def stop_on_eventloop():
+        def stop_on_eventloop() -> None:
             if self._state in (RuntimeState.STOPPING, RuntimeState.STOPPED):
                 return
 
@@ -374,9 +374,11 @@ class Runtime:
         -----
         Threading: UNSAFE. Must be called on the eventloop thread.
         """
-        assert not (existing_session_id and session_id_override), (
-            "Only one of existing_session_id and session_id_override should be set!"
-        )
+        if existing_session_id and session_id_override:
+            raise RuntimeError(
+                "Only one of existing_session_id and session_id_override should be set. "
+                "This should never happen."
+            )
 
         if self._state in (RuntimeState.STOPPING, RuntimeState.STOPPED):
             raise RuntimeStoppedError(f"Can't connect_session (state={self._state})")
@@ -596,7 +598,7 @@ class Runtime:
             elif self._state == RuntimeState.ONE_OR_MORE_SESSIONS_CONNECTED:
                 pass
             else:
-                raise RuntimeError(f"Bad Runtime state at start: {self._state}")
+                raise RuntimeError(f"Bad Runtime state at start: {self._state}")  # noqa: TRY301
 
             # Signal that we're started and ready to accept sessions
             async_objs.started.set_result(None)

streamlit/runtime/runtime_util.py

@@ -31,7 +31,7 @@ _LOGGER: Final = getLogger(__name__)
 class MessageSizeError(MarkdownFormattedException):
     """Exception raised when a websocket message is larger than the configured limit."""
 
-    def __init__(self, failed_msg_str: Any):
+    def __init__(self, failed_msg_str: Any) -> None:
         msg = self._get_message(failed_msg_str)
         super().__init__(msg)
 
@@ -39,7 +39,8 @@ class MessageSizeError(MarkdownFormattedException):
         # This needs to have zero indentation otherwise the markdown will render incorrectly.
         return (
             f"""
-**Data of size {len(failed_msg_str) / 1e6:.1f} MB exceeds the message size limit of {get_max_message_size_bytes() / 1e6} MB.**
+**Data of size {len(failed_msg_str) / 1e6:.1f} MB exceeds the message size limit of
+{get_max_message_size_bytes() / 1e6} MB.**
 
 This is often caused by a large chart or dataframe. Please decrease the amount of data sent
 to the browser, or increase the limit by setting the config option `server.maxMessageSize`.
@@ -54,7 +55,7 @@ of the client's browser and the Streamlit server._
 class BadDurationStringError(StreamlitAPIException):
     """Raised when a bad duration argument string is passed."""
 
-    def __init__(self, duration: str):
+    def __init__(self, duration: str) -> None:
         MarkdownFormattedException.__init__(
             self,
             "TTL string doesn't look right. It should be formatted as"
@@ -74,12 +75,12 @@ def serialize_forward_msg(msg: ForwardMsg) -> bytes:
     if len(msg_str) > get_max_message_size_bytes():
         # Overwrite the offending ForwardMsg.delta with an error to display.
         # This assumes that the size limit wasn't exceeded due to metadata.
-        import streamlit.elements.exception as exception
+        from streamlit.elements import exception
 
         msg_size_error = MessageSizeError(msg_str)
         _LOGGER.warning(
-            "Websocket message size limit exceeded. "
-            f"Showing error to the user: {msg_size_error}"
+            "Websocket message size limit exceeded. Showing error to the user: %s",
+            msg_size_error,
         )
         exception.marshall(msg.delta.new_element.exception, msg_size_error)
         # Deactivate caching for this error message:

streamlit/runtime/scriptrunner/__init__.py

@@ -27,12 +27,12 @@ from streamlit.runtime.scriptrunner_utils.script_run_context import (
 
 __all__ = [
     "RerunData",
-    "ScriptRunContext",
-    "add_script_run_ctx",
-    "get_script_run_ctx",
-    "enqueue_message",
     "RerunException",
+    "ScriptRunContext",
     "ScriptRunner",
     "ScriptRunnerEvent",
     "StopException",
+    "add_script_run_ctx",
+    "enqueue_message",
+    "get_script_run_ctx",
 ]

streamlit/runtime/scriptrunner/exec_code.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import sys
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
 from streamlit import util
 from streamlit.delta_generator_singletons import (
@@ -30,30 +30,37 @@ from streamlit.runtime.scriptrunner_utils.exceptions import (
 )
 
 if TYPE_CHECKING:
+    from types import TracebackType
+
     from streamlit.runtime.scriptrunner_utils.script_requests import RerunData
     from streamlit.runtime.scriptrunner_utils.script_run_context import ScriptRunContext
 
 
-class modified_sys_path:
+class modified_sys_path:  # noqa: N801
     """A context for prepending a directory to sys.path for a second.
 
     Code inspired by IPython:
     Source: https://github.com/ipython/ipython/blob/master/IPython/utils/syspathcontext.py#L42
     """
 
-    def __init__(self, main_script_path: str):
+    def __init__(self, main_script_path: str) -> None:
         self._main_script_path = main_script_path
         self._added_path = False
 
     def __repr__(self) -> str:
         return util.repr_(self)
 
-    def __enter__(self):
+    def __enter__(self) -> None:
         if self._main_script_path not in sys.path:
             sys.path.insert(0, self._main_script_path)
             self._added_path = True
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(
+        self,
+        typ: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> Literal[False]:
         if self._added_path:
             try:
                 sys.path.remove(self._main_script_path)

streamlit/runtime/scriptrunner/magic.py

@@ -21,8 +21,7 @@ from typing import Any, Final
 from streamlit import config
 
 # When a Streamlit app is magicified, we insert a `magic_funcs` import near the top of
-# its module's AST:
-# import streamlit.runtime.scriptrunner.magic_funcs as __streamlitmagic__
+# its module's AST: import streamlit.runtime.scriptrunner.magic_funcs as __streamlitmagic__
 MAGIC_MODULE_NAME: Final = "__streamlitmagic__"
 
 
@@ -59,7 +58,7 @@ def _modify_ast_subtree(
     body_attr: str = "body",
     is_root: bool = False,
     file_ends_in_semicolon: bool = False,
-):
+) -> None:
     """Parses magic commands and modifies the given AST (sub)tree."""
 
     body = getattr(tree, body_attr)
@@ -162,7 +161,7 @@ def _insert_import_statement(tree: Any) -> None:
         tree.body.insert(0, st_import)
 
 
-def _build_st_import_statement():
+def _build_st_import_statement() -> ast.Import:
     """Build AST node for `import magic_funcs as __streamlitmagic__`."""
     return ast.Import(
         names=[
@@ -174,7 +173,7 @@ def _build_st_import_statement():
     )
 
 
-def _build_st_write_call(nodes):
+def _build_st_write_call(nodes: list[Any]) -> ast.Call:
     """Build AST node for `__streamlitmagic__.transparent_write(*nodes)`."""
     return ast.Call(
         func=ast.Attribute(
@@ -188,8 +187,13 @@ def _build_st_write_call(nodes):
 
 
 def _get_st_write_from_expr(
-    node, i, parent_type, is_root, is_last_expr, file_ends_in_semicolon
-):
+    node: Any,
+    i: int,
+    parent_type: Any,
+    is_root: bool,
+    is_last_expr: bool,
+    file_ends_in_semicolon: bool,
+) -> ast.Call | None:
     # Don't wrap function calls
     # (Unless the function call happened at the end of the root node, AND
     # magic.displayLastExprIfNoSemicolon is True. This allows us to support notebook-like
@@ -217,17 +221,17 @@ def _get_st_write_from_expr(
         return None
 
     # If tuple, call st.write(*the_tuple). This allows us to add a comma at the end of a
-    # statement to turn it into an expression that should be st-written. Ex:
-    # "np.random.randn(1000, 2),"
+    # statement to turn it into an expression that should be
+    # st-written. Ex: "np.random.randn(1000, 2),"
     args = node.value.elts if type(node.value) is ast.Tuple else [node.value]
     return _build_st_write_call(args)
 
 
-def _is_string_constant_node(node) -> bool:
+def _is_string_constant_node(node: Any) -> bool:
     return isinstance(node, ast.Constant) and isinstance(node.value, str)
 
 
-def _is_docstring_node(node, node_index, parent_type) -> bool:
+def _is_docstring_node(node: Any, node_index: int, parent_type: Any) -> bool:
     return (
         node_index == 0
         and _is_string_constant_node(node)
@@ -235,7 +239,7 @@ def _is_docstring_node(node, node_index, parent_type) -> bool:
     )
 
 
-def _does_file_end_in_semicolon(tree, code: str) -> bool:
+def _does_file_end_in_semicolon(tree: Any, code: str) -> bool:
     file_ends_in_semicolon = False
 
     # Avoid spending time with this operation if magic.displayLastExprIfNoSemicolon is

streamlit/runtime/scriptrunner/script_cache.py

@@ -26,7 +26,7 @@ from streamlit.source_util import open_python_file
 class ScriptCache:
     """Thread-safe cache of Python script bytecode."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Mapping of script_path: bytecode
         self._cache: dict[str, Any] = {}
         self._lock = threading.Lock()

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"
@@ -176,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.)
@@ -261,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:
@@ -297,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,
@@ -321,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:
@@ -341,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")
 
@@ -371,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
         )
@@ -433,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
@@ -461,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:
@@ -480,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()
 
@@ -585,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(),
@@ -606,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.
@@ -618,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
@@ -642,7 +666,7 @@ class ScriptRunner:
                         if PagesManager.uses_pages_directory:
                             _mpa_v1(self._main_script_path)
                         else:
-                            exec(code, module.__dict__)
+                            exec(code, module.__dict__)  # noqa: S102
                         self._fragment_storage.clear(
                             new_fragment_ids=ctx.new_fragment_ids
                         )
@@ -739,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
 
@@ -747,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