streamlit 1.45.0__py3-none-any.whl → 1.46.0__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()