streamlit-nightly 1.35.1.dev20240610__py2.py3-none-any.whl → 1.35.1.dev20240612__py2.py3-none-any.whl

streamlit/runtime/pages_manager.py

@@ -18,15 +18,15 @@ import contextlib
 import os
 import threading
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Final, Type
+from typing import TYPE_CHECKING, Any, Callable, Final
 
 from streamlit import source_util
 from streamlit.logger import get_logger
-from streamlit.runtime.scriptrunner.script_cache import ScriptCache
 from streamlit.util import calc_md5
 from streamlit.watcher import watch_dir
 
 if TYPE_CHECKING:
+    from streamlit.runtime.scriptrunner.script_cache import ScriptCache
     from streamlit.source_util import PageHash, PageInfo, PageName, ScriptPath
 
 _LOGGER: Final = get_logger(__name__)
@@ -76,17 +76,17 @@ class PagesStrategyV1:
 
     # In MPA v1, there's no difference between the active hash
     # and the page script hash.
-    def get_active_script_hash(self) -> "PageHash":
+    def get_active_script_hash(self) -> PageHash:
         return self.pages_manager.current_page_hash
 
-    def set_active_script_hash(self, _page_hash: "PageHash"):
+    def set_active_script_hash(self, _page_hash: PageHash):
         # Intentionally do nothing as MPA v1 active_script_hash does not
         # differentiate the active_script_hash and the page_script_hash
         pass
 
     def get_initial_active_script(
-        self, page_script_hash: "PageHash", page_name: "PageName"
-    ) -> "PageInfo" | None:
+        self, page_script_hash: PageHash, page_name: PageName
+    ) -> PageInfo | None:
         pages = self.get_pages()
 
         if page_script_hash:
@@ -114,7 +114,7 @@ class PagesStrategyV1:
         main_page_info = list(pages.values())[0]
         return main_page_info
 
-    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+    def get_pages(self) -> dict[PageHash, PageInfo]:
         return source_util.get_pages(self.pages_manager.main_script_path)
 
     def register_pages_changed_callback(
@@ -123,10 +123,10 @@ class PagesStrategyV1:
     ) -> Callable[[], None]:
         return source_util.register_pages_changed_callback(callback)
 
-    def set_pages(self, _pages: dict["PageHash", "PageInfo"]) -> None:
+    def set_pages(self, _pages: dict[PageHash, PageInfo]) -> None:
         raise NotImplementedError("Unable to set pages in this V1 strategy")
 
-    def get_page_script(self, _fallback_page_hash: "PageHash") -> "PageInfo" | None:
+    def get_page_script(self, _fallback_page_hash: PageHash) -> PageInfo | None:
         raise NotImplementedError("Unable to get page script in this V1 strategy")
 
 
@@ -147,18 +147,18 @@ class PagesStrategyV2:
 
     def __init__(self, pages_manager: PagesManager, **kwargs):
         self.pages_manager = pages_manager
-        self._active_script_hash: "PageHash" = self.pages_manager.main_script_hash
-        self._pages: dict["PageHash", "PageInfo"] | None = None
+        self._active_script_hash: PageHash = self.pages_manager.main_script_hash
+        self._pages: dict[PageHash, PageInfo] | None = None
 
-    def get_active_script_hash(self) -> "PageHash":
+    def get_active_script_hash(self) -> PageHash:
         return self._active_script_hash
 
-    def set_active_script_hash(self, page_hash: "PageHash"):
+    def set_active_script_hash(self, page_hash: PageHash):
         self._active_script_hash = page_hash
 
     def get_initial_active_script(
-        self, page_script_hash: "PageHash", page_name: "PageName"
-    ) -> "PageInfo":
+        self, page_script_hash: PageHash, page_name: PageName
+    ) -> PageInfo:
         return {
             # We always run the main script in V2 as it's the common code
             "script_path": self.pages_manager.main_script_path,
@@ -166,7 +166,7 @@ class PagesStrategyV2:
             or self.pages_manager.main_script_hash,  # Default Hash
         }
 
-    def get_page_script(self, fallback_page_hash: "PageHash") -> "PageInfo" | None:
+    def get_page_script(self, fallback_page_hash: PageHash) -> PageInfo | None:
         if self._pages is None:
             return None
 
@@ -196,7 +196,7 @@ class PagesStrategyV2:
 
         return self._pages.get(fallback_page_hash, None)
 
-    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+    def get_pages(self) -> dict[PageHash, PageInfo]:
         # If pages are not set, provide the common page info where
         # - the main script path is the executing script to start
         # - the page script hash and name reflects the intended page requested
@@ -209,7 +209,7 @@ class PagesStrategyV2:
             }
         }
 
-    def set_pages(self, pages: dict["PageHash", "PageInfo"]) -> None:
+    def set_pages(self, pages: dict[PageHash, PageInfo]) -> None:
         self._pages = pages
 
     def register_pages_changed_callback(
@@ -233,60 +233,60 @@ class PagesManager:
     NOTE: Each strategy handles its own thread safety when accessing the pages
     """
 
-    DefaultStrategy: Type[PagesStrategyV1 | PagesStrategyV2] = PagesStrategyV1
+    DefaultStrategy: type[PagesStrategyV1 | PagesStrategyV2] = PagesStrategyV1
 
     def __init__(
         self,
-        main_script_path: "ScriptPath",
+        main_script_path: ScriptPath,
         script_cache: ScriptCache | None = None,
         **kwargs,
     ):
         self._main_script_path = main_script_path
-        self._main_script_hash: "PageHash" = calc_md5(main_script_path)
-        self._current_page_hash: "PageHash" = self._main_script_hash
+        self._main_script_hash: PageHash = calc_md5(main_script_path)
+        self._current_page_hash: PageHash = self._main_script_hash
         self.pages_strategy = PagesManager.DefaultStrategy(self, **kwargs)
         self._script_cache = script_cache
-        self._intended_page_script_hash: "PageHash" | None = None
-        self._intended_page_name: "PageName" | None = None
+        self._intended_page_script_hash: PageHash | None = None
+        self._intended_page_name: PageName | None = None
 
     @property
-    def current_page_hash(self) -> "PageHash":
+    def current_page_hash(self) -> PageHash:
         return self._current_page_hash
 
     @property
-    def main_script_path(self) -> "ScriptPath":
+    def main_script_path(self) -> ScriptPath:
         return self._main_script_path
 
     @property
-    def main_script_hash(self) -> "PageHash":
+    def main_script_hash(self) -> PageHash:
         return self._main_script_hash
 
     @property
-    def intended_page_name(self) -> "PageName" | None:
+    def intended_page_name(self) -> PageName | None:
         return self._intended_page_name
 
     @property
-    def intended_page_script_hash(self) -> "PageHash" | None:
+    def intended_page_script_hash(self) -> PageHash | None:
         return self._intended_page_script_hash
 
-    def get_main_page(self) -> "PageInfo":
+    def get_main_page(self) -> PageInfo:
         return {
             "script_path": self._main_script_path,
             "page_script_hash": self._main_script_hash,
         }
 
-    def get_current_page_script_hash(self) -> "PageHash":
+    def get_current_page_script_hash(self) -> PageHash:
         """Gets the script hash of the associated page of a script."""
         return self._current_page_hash
 
-    def set_current_page_script_hash(self, page_hash: "PageHash") -> None:
+    def set_current_page_script_hash(self, page_hash: PageHash) -> None:
         self._current_page_hash = page_hash
 
-    def get_active_script_hash(self) -> "PageHash":
+    def get_active_script_hash(self) -> PageHash:
         """Gets the script hash of the currently executing script."""
         return self.pages_strategy.get_active_script_hash()
 
-    def set_active_script_hash(self, page_hash: "PageHash"):
+    def set_active_script_hash(self, page_hash: PageHash):
         return self.pages_strategy.set_active_script_hash(page_hash)
 
     def reset_active_script_hash(self):
@@ -294,20 +294,20 @@ class PagesManager:
         self.set_active_script_hash(self.main_script_hash)
 
     def set_script_intent(
-        self, page_script_hash: "PageHash", page_name: "PageName"
+        self, page_script_hash: PageHash, page_name: PageName
     ) -> None:
         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:
+        self, page_script_hash: PageHash, page_name: PageName
+    ) -> PageInfo | None:
         return self.pages_strategy.get_initial_active_script(
             page_script_hash, page_name
         )
 
     @contextlib.contextmanager
-    def run_with_active_hash(self, page_hash: "PageHash"):
+    def run_with_active_hash(self, page_hash: PageHash):
         original_page_hash = self.get_active_script_hash()
         self.set_active_script_hash(page_hash)
         try:
@@ -316,10 +316,10 @@ class PagesManager:
             # in the event of any exception, ensure we set the active hash back
             self.set_active_script_hash(original_page_hash)
 
-    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+    def get_pages(self) -> dict[PageHash, PageInfo]:
         return self.pages_strategy.get_pages()
 
-    def set_pages(self, pages: dict["PageHash", "PageInfo"]) -> None:
+    def set_pages(self, pages: dict[PageHash, PageInfo]) -> None:
         # Manually setting the pages indicates we are using MPA v2.
         if isinstance(self.pages_strategy, PagesStrategyV1):
             if os.path.exists(Path(self.main_script_path).parent / "pages"):
@@ -331,7 +331,7 @@ class PagesManager:
 
         self.pages_strategy.set_pages(pages)
 
-    def get_page_script(self, fallback_page_hash: "PageHash" = "") -> "PageInfo" | None:
+    def get_page_script(self, fallback_page_hash: PageHash = "") -> PageInfo | None:
         # We assume the pages strategy is V2 cause this is used
         # in the st.navigation call, but we just swallow the error
         try:

streamlit/runtime/runtime.py

@@ -23,9 +23,7 @@ from typing import TYPE_CHECKING, Awaitable, Final, NamedTuple
 
 from streamlit import config
 from streamlit.components.lib.local_component_registry import LocalComponentRegistry
-from streamlit.components.types.base_component_registry import BaseComponentRegistry
 from streamlit.logger import get_logger
-from streamlit.proto.BackMsg_pb2 import BackMsg
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.app_session import AppSession
 from streamlit.runtime.caching import (
@@ -41,7 +39,6 @@ from streamlit.runtime.forward_msg_cache import (
     populate_hash_if_needed,
 )
 from streamlit.runtime.media_file_manager import MediaFileManager
-from streamlit.runtime.media_file_storage import MediaFileStorage
 from streamlit.runtime.memory_session_storage import MemorySessionStorage
 from streamlit.runtime.runtime_util import is_cacheable_msg
 from streamlit.runtime.script_data import ScriptData
@@ -58,11 +55,14 @@ from streamlit.runtime.state import (
     SessionStateStatProvider,
 )
 from streamlit.runtime.stats import StatsManager
-from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 from streamlit.runtime.websocket_session_manager import WebsocketSessionManager
 
 if TYPE_CHECKING:
+    from streamlit.components.types.base_component_registry import BaseComponentRegistry
+    from streamlit.proto.BackMsg_pb2 import BackMsg
     from streamlit.runtime.caching.storage import CacheStorageManager
+    from streamlit.runtime.media_file_storage import MediaFileStorage
+    from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
 # Wait for the script run result for 60s and if no result is available give up
 SCRIPT_RUN_CHECK_TIMEOUT: Final = 60

streamlit/runtime/runtime_util.py

@@ -16,13 +16,15 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from streamlit import config
 from streamlit.errors import MarkdownFormattedException, StreamlitAPIException
-from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.forward_msg_cache import populate_hash_if_needed
 
+if TYPE_CHECKING:
+    from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+
 
 class MessageSizeError(MarkdownFormattedException):
     """Exception raised when a websocket message is larger than the configured limit."""
@@ -34,9 +36,8 @@ class MessageSizeError(MarkdownFormattedException):
     def _get_message(self, failed_msg_str: Any) -> str:
         # This needs to have zero indentation otherwise the markdown will render incorrectly.
         return (
-            (
-                """
-**Data of size {message_size_mb:.1f} MB exceeds the message size limit of {message_size_limit_mb} MB.**
+            f"""
+**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`.
@@ -45,13 +46,7 @@ to the browser, or increase the limit by setting the config option `server.maxMe
 _Note that increasing the limit may lead to long loading times and large memory consumption
 of the client's browser and the Streamlit server._
 """
-            )
-            .format(
-                message_size_mb=len(failed_msg_str) / 1e6,
-                message_size_limit_mb=(get_max_message_size_bytes() / 1e6),
-            )
-            .strip("\n")
-        )
+        ).strip("\n")
 
 
 class BadDurationStringError(StreamlitAPIException):

streamlit/runtime/scriptrunner/magic.py

@@ -229,7 +229,7 @@ def _get_st_write_from_expr(
 
 
 def _is_string_constant_node(node) -> bool:
-    return type(node) is ast.Constant and type(node.value) is str
+    return isinstance(node, ast.Constant) and isinstance(node.value, str)
 
 
 def _is_docstring_node(node, node_index, parent_type) -> bool:

streamlit/runtime/scriptrunner/script_requests.py

@@ -17,12 +17,14 @@ from __future__ import annotations
 import threading
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import cast
+from typing import TYPE_CHECKING, cast
 
 from streamlit import util
-from streamlit.proto.WidgetStates_pb2 import WidgetStates
 from streamlit.runtime.state import coalesce_widget_states
 
+if TYPE_CHECKING:
+    from streamlit.proto.WidgetStates_pb2 import WidgetStates
+
 
 class ScriptRequestType(Enum):
     # The ScriptRunner should continue running its script.

streamlit/runtime/scriptrunner/script_run_context.py

@@ -25,16 +25,16 @@ from typing_extensions import TypeAlias
 from streamlit import runtime
 from streamlit.errors import StreamlitAPIException
 from streamlit.logger import get_logger
-from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
-from streamlit.proto.PageProfile_pb2 import Command
-from streamlit.runtime.scriptrunner.script_requests import ScriptRequests
-from streamlit.runtime.state import SafeSessionState
-from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
 if TYPE_CHECKING:
+    from streamlit.cursor import RunningCursor
+    from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+    from streamlit.proto.PageProfile_pb2 import Command
     from streamlit.runtime.fragment import FragmentStorage
     from streamlit.runtime.pages_manager import PagesManager
-
+    from streamlit.runtime.scriptrunner.script_requests import ScriptRequests
+    from streamlit.runtime.state import SafeSessionState
+    from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 _LOGGER: Final = get_logger(__name__)
 
 UserInfo: TypeAlias = Dict[str, Union[str, None]]
@@ -62,8 +62,8 @@ class ScriptRunContext:
     uploaded_file_mgr: UploadedFileManager
     main_script_path: str
     user_info: UserInfo
-    fragment_storage: "FragmentStorage"
-    pages_manager: "PagesManager"
+    fragment_storage: FragmentStorage
+    pages_manager: PagesManager
 
     gather_usage_stats: bool = False
     command_tracking_deactivated: bool = False
@@ -74,7 +74,7 @@ class ScriptRunContext:
     widget_ids_this_run: set[str] = field(default_factory=set)
     widget_user_keys_this_run: set[str] = field(default_factory=set)
     form_ids_this_run: set[str] = field(default_factory=set)
-    cursors: dict[int, "streamlit.cursor.RunningCursor"] = field(default_factory=dict)
+    cursors: dict[int, RunningCursor] = field(default_factory=dict)
     script_requests: ScriptRequests | None = None
     current_fragment_id: str | None = None
     fragment_ids_this_run: set[str] | None = None
@@ -139,9 +139,9 @@ class ScriptRunContext:
         if msg.HasField("page_config_changed") and not self._set_page_config_allowed:
             raise StreamlitAPIException(
                 "`set_page_config()` can only be called once per app page, "
-                + "and must be called as the first Streamlit command in your script.\n\n"
-                + "For more information refer to the [docs]"
-                + "(https://docs.streamlit.io/library/api-reference/utilities/st.set_page_config)."
+                "and must be called as the first Streamlit command in your script.\n\n"
+                "For more information refer to the [docs]"
+                "(https://docs.streamlit.io/library/api-reference/utilities/st.set_page_config)."
             )
 
         # We want to disallow set_page config if one of the following occurs:
@@ -161,8 +161,8 @@ class ScriptRunContext:
         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` "
-                + "or `st.experimental_set_query_params` is not supported. Please convert your app "
-                + "to only use `st.query_params`"
+                "or `st.experimental_set_query_params` is not supported. Please convert your app "
+                "to only use `st.query_params`"
             )
 
     def mark_experimental_query_params_used(self):
@@ -233,4 +233,4 @@ def get_script_run_ctx(suppress_warning: bool = False) -> ScriptRunContext | Non
 
 
 # Needed to avoid circular dependencies while running tests.
-import streamlit
+import streamlit  # noqa: E402, F401

streamlit/runtime/scriptrunner/script_runner.py

@@ -25,12 +25,11 @@ from typing import TYPE_CHECKING, Callable, Final
 
 from blinker import Signal
 
-from streamlit import config, runtime, source_util, util
+from streamlit import config, runtime, util
 from streamlit.error_util import handle_uncaught_app_exception
 from streamlit.logger import get_logger
 from streamlit.proto.ClientState_pb2 import ClientState
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
-from streamlit.runtime.scriptrunner.script_cache import ScriptCache
 from streamlit.runtime.scriptrunner.script_requests import (
     RerunData,
     ScriptRequests,
@@ -46,18 +45,19 @@ from streamlit.runtime.state import (
     SafeSessionState,
     SessionState,
 )
-from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 from streamlit.vendor.ipython.modified_sys_path import modified_sys_path
 
 if TYPE_CHECKING:
     from streamlit.runtime.fragment import FragmentStorage
     from streamlit.runtime.pages_manager import PagesManager
+    from streamlit.runtime.scriptrunner.script_cache import ScriptCache
+    from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
 _LOGGER: Final = get_logger(__name__)
 
 
 class ScriptRunnerEvent(Enum):
-    ## "Control" events. These are emitted when the ScriptRunner's state changes.
+    # "Control" events. These are emitted when the ScriptRunner's state changes.
 
     # The script started running.
     SCRIPT_STARTED = "SCRIPT_STARTED"
@@ -80,8 +80,8 @@ class ScriptRunnerEvent(Enum):
     # is shut down.
     SHUTDOWN = "SHUTDOWN"
 
-    ## "Data" events. These are emitted when the ScriptRunner's script has
-    ## data to send to the frontend.
+    # "Data" events. These are emitted when the ScriptRunner's script has
+    # data to send to the frontend.
 
     # The script has a ForwardMsg to send to the frontend.
     ENQUEUE_FORWARD_MSG = "ENQUEUE_FORWARD_MSG"
@@ -114,8 +114,8 @@ class ScriptRunner:
         script_cache: ScriptCache,
         initial_rerun_data: RerunData,
         user_info: dict[str, str | None],
-        fragment_storage: "FragmentStorage",
-        pages_manager: "PagesManager",
+        fragment_storage: FragmentStorage,
+        pages_manager: PagesManager,
     ):
         """Initialize the ScriptRunner.
 

streamlit/runtime/secrets.py

@@ -25,7 +25,6 @@ from typing import (
     KeysView,
     Mapping,
     NoReturn,
-    Union,
     ValuesView,
 )
 
@@ -45,12 +44,11 @@ SECRETS_FILE_LOCS: Final[list[str]] = [
 ]
 
 
-def _convert_to_dict(obj: Union[Mapping[str, Any], AttrDict]) -> dict[str, Any]:
-    """Recursively convert Mapping or AttrDict objects to dictionaries."""
+def _convert_to_dict(obj: Mapping[str, Any] | AttrDict) -> dict[str, Any]:
+    """Convert Mapping or AttrDict objects to dictionaries."""
     if isinstance(obj, AttrDict):
         return obj.to_dict()
-    elif isinstance(obj, Mapping):
-        return {k: _convert_to_dict(v) for k, v in obj.items()}
+    return {k: v.to_dict() if isinstance(v, AttrDict) else v for k, v in obj.items()}
 
 
 def _missing_attr_error_message(attr_name: str) -> str:

streamlit/runtime/session_manager.py

@@ -16,13 +16,14 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Callable, Protocol, cast
-
-from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
-from streamlit.runtime.app_session import AppSession
-from streamlit.runtime.script_data import ScriptData
-from streamlit.runtime.scriptrunner.script_cache import ScriptCache
-from streamlit.runtime.uploaded_file_manager import UploadedFileManager
+from typing import TYPE_CHECKING, Callable, Protocol, cast
+
+if TYPE_CHECKING:
+    from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+    from streamlit.runtime.app_session import AppSession
+    from streamlit.runtime.script_data import ScriptData
+    from streamlit.runtime.scriptrunner.script_cache import ScriptCache
+    from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
 
 class SessionClientDisconnectedError(Exception):

streamlit/runtime/state/common.py

@@ -57,7 +57,6 @@ from streamlit.proto.Slider_pb2 import Slider
 from streamlit.proto.TextArea_pb2 import TextArea
 from streamlit.proto.TextInput_pb2 import TextInput
 from streamlit.proto.TimeInput_pb2 import TimeInput
-from streamlit.type_util import ValueFieldName
 from streamlit.util import HASHLIB_KWARGS
 
 if TYPE_CHECKING:
@@ -65,6 +64,7 @@ if TYPE_CHECKING:
 
     from streamlit.runtime.scriptrunner.script_run_context import ScriptRunContext
     from streamlit.runtime.state.widgets import NoValue
+    from streamlit.type_util import ValueFieldName
 
 
 # Protobuf types for all widgets.

streamlit/runtime/state/query_params_proxy.py

@@ -74,18 +74,15 @@ class QueryParamsProxy(MutableMapping[str, str]):
     @overload
     def update(
         self, mapping: SupportsKeysAndGetItem[str, str | Iterable[str]], /, **kwds: str
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @overload
     def update(
         self, keys_and_values: Iterable[tuple[str, str | Iterable[str]]], /, **kwds: str
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @overload
-    def update(self, **kwds: str | Iterable[str]) -> None:
-        ...
+    def update(self, **kwds: str | Iterable[str]) -> None: ...
 
     def update(self, other=(), /, **kwds):
         """
@@ -167,14 +164,12 @@ class QueryParamsProxy(MutableMapping[str, str]):
     @overload
     def from_dict(
         self, keys_and_values: Iterable[tuple[str, str | Iterable[str]]]
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @overload
     def from_dict(
         self, mapping: SupportsKeysAndGetItem[str, str | Iterable[str]]
-    ) -> None:
-        ...
+    ) -> None: ...
 
     @gather_metrics("query_params.from_dict")
     def from_dict(self, params):

streamlit/runtime/state/safe_session_state.py

@@ -16,13 +16,14 @@ from __future__ import annotations
 
 import threading
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator
-
-from streamlit.proto.WidgetStates_pb2 import WidgetState as WidgetStateProto
-from streamlit.proto.WidgetStates_pb2 import WidgetStates as WidgetStatesProto
-from streamlit.runtime.state.common import RegisterWidgetResult, T, WidgetMetadata
-from streamlit.runtime.state.query_params import QueryParams
-from streamlit.runtime.state.session_state import SessionState
+from typing import TYPE_CHECKING, Any, Callable, Iterator
+
+if TYPE_CHECKING:
+    from streamlit.proto.WidgetStates_pb2 import WidgetState as WidgetStateProto
+    from streamlit.proto.WidgetStates_pb2 import WidgetStates as WidgetStatesProto
+    from streamlit.runtime.state.common import RegisterWidgetResult, T, WidgetMetadata
+    from streamlit.runtime.state.query_params import QueryParams
+    from streamlit.runtime.state.session_state import SessionState
 
 
 class SafeSessionState: