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

streamlit/runtime/caching/storage/cache_storage_protocol.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-""" Declares the CacheStorageContext dataclass, which contains parameter information for
+"""Declares the CacheStorageContext dataclass, which contains parameter information for
 each function decorated by `@st.cache_data` (for example: ttl, max_entries etc.)
 
 Declares the CacheStorageManager protocol, which implementations are used

streamlit/runtime/connection_factory.py

@@ -16,8 +16,7 @@ from __future__ import annotations
 
 import os
 import re
-from datetime import timedelta
-from typing import Any, Final, Literal, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Final, Literal, TypeVar, overload
 
 from streamlit.connections import (
     BaseConnection,
@@ -31,6 +30,9 @@ from streamlit.runtime.caching import cache_resource
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.secrets import secrets_singleton
 
+if TYPE_CHECKING:
+    from datetime import timedelta
+
 # NOTE: Adding support for a new first party connection requires:
 #   1. Adding the new connection name and class to this dict.
 #   2. Writing two new @overloads for connection_factory (one for the case where the

streamlit/runtime/credentials.py

@@ -20,9 +20,8 @@ import json
 import os
 import sys
 import textwrap
-from collections import namedtuple
 from datetime import datetime
-from typing import Final, NoReturn
+from typing import Final, NamedTuple, NoReturn
 from uuid import uuid4
 
 from streamlit import cli_util, env_util, file_util, util
@@ -36,13 +35,10 @@ if env_util.IS_WINDOWS:
 else:
     _CONFIG_FILE_PATH = "~/.streamlit/config.toml"
 
-_Activation = namedtuple(
-    "_Activation",
-    [
-        "email",  # str : the user's email.
-        "is_valid",  # boolean : whether the email is valid.
-    ],
-)
+
+class _Activation(NamedTuple):
+    email: str | None  # the user's email.
+    is_valid: bool  # whether the email is valid.
 
 
 def email_prompt() -> str:
@@ -55,19 +51,14 @@ def email_prompt() -> str:
     )
 
     # IMPORTANT: Break the text below at 80 chars.
-    return """
-      {0}%(welcome)s
+    return f"""
+      {"👋 " if show_emoji else ""}{cli_util.style_for_cli("Welcome to Streamlit!", bold=True)}
 
       If you’d like to receive helpful onboarding emails, news, offers, promotions,
       and the occasional swag, please enter your email address below. Otherwise,
       leave this field blank.
 
-      %(email)s""".format(
-        "👋 " if show_emoji else ""
-    ) % {
-        "welcome": cli_util.style_for_cli("Welcome to Streamlit!", bold=True),
-        "email": cli_util.style_for_cli("Email: ", fg="blue"),
-    }
+      {cli_util.style_for_cli("Email: ", fg="blue")}"""
 
 
 _TELEMETRY_HEADLESS_TEXT = """
@@ -119,10 +110,10 @@ def _send_email(email: str) -> None:
     response.raise_for_status()
 
 
-class Credentials(object):
+class Credentials:
     """Credentials class."""
 
-    _singleton: "Credentials" | None = None
+    _singleton: Credentials | None = None
 
     @classmethod
     def get_current(cls):
@@ -156,7 +147,7 @@ class Credentials(object):
         import toml
 
         try:
-            with open(self._conf_file, "r") as f:
+            with open(self._conf_file) as f:
                 data = toml.load(f).get("general")
             if data is None:
                 raise Exception

streamlit/runtime/forward_msg_cache.py

@@ -111,9 +111,9 @@ class ForwardMsgCache(CacheStatsProvider):
 
         def __init__(self, msg: ForwardMsg | None):
             self.msg = msg
-            self._session_script_run_counts: MutableMapping[
-                AppSession, int
-            ] = WeakKeyDictionary()
+            self._session_script_run_counts: MutableMapping[AppSession, int] = (
+                WeakKeyDictionary()
+            )
 
         def __repr__(self) -> str:
             return util.repr_(self)
@@ -285,13 +285,12 @@ class ForwardMsgCache(CacheStatsProvider):
         self._entries.clear()
 
     def get_stats(self) -> list[CacheStat]:
-        stats: list[CacheStat] = []
-        for entry_hash, entry in self._entries.items():
-            stats.append(
-                CacheStat(
-                    category_name="ForwardMessageCache",
-                    cache_name="",
-                    byte_length=entry.msg.ByteSize() if entry.msg is not None else 0,
-                )
+        stats: list[CacheStat] = [
+            CacheStat(
+                category_name="ForwardMessageCache",
+                cache_name="",
+                byte_length=entry.msg.ByteSize() if entry.msg is not None else 0,
             )
+            for _, entry in self._entries.items()
+        ]
         return group_stats(stats)

streamlit/runtime/forward_msg_queue.py

@@ -14,11 +14,13 @@
 
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from streamlit.proto.Delta_pb2 import Delta
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 
+if TYPE_CHECKING:
+    from streamlit.proto.Delta_pb2 import Delta
+
 
 class ForwardMsgQueue:
     """Accumulates a session's outgoing ForwardMsgs.
@@ -38,7 +40,7 @@ class ForwardMsgQueue:
         # redundant outgoing Deltas (where a newer Delta supersedes
         # an older Delta, with the same delta_path, that's still in the
         # queue).
-        self._delta_index_map: dict[tuple[int, ...], int] = dict()
+        self._delta_index_map: dict[tuple[int, ...], int] = {}
 
     def get_debug(self) -> dict[str, Any]:
         from google.protobuf.json_format import MessageToDict
@@ -102,7 +104,7 @@ class ForwardMsgQueue:
                 }
             ]
 
-        self._delta_index_map = dict()
+        self._delta_index_map = {}
 
     def flush(self) -> list[ForwardMsg]:
         """Clear the queue and return a list of the messages it contained

streamlit/runtime/fragment.py

@@ -19,15 +19,17 @@ import hashlib
 import inspect
 from abc import abstractmethod
 from copy import deepcopy
-from datetime import timedelta
 from functools import wraps
-from typing import Any, Callable, Protocol, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar, overload
 
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 from streamlit.time_util import time_to_seconds
 
+if TYPE_CHECKING:
+    from datetime import timedelta
+
 F = TypeVar("F", bound=Callable[..., Any])
 Fragment = Callable[[], Any]
 
@@ -127,9 +129,7 @@ def _fragment(
         active_dg = dg_stack_snapshot[-1]
         h = hashlib.new("md5")
         h.update(
-            f"{non_optional_func.__module__}.{non_optional_func.__qualname__}{active_dg._get_delta_path_str()}".encode(
-                "utf-8"
-            )
+            f"{non_optional_func.__module__}.{non_optional_func.__qualname__}{active_dg._get_delta_path_str()}".encode()
         )
         fragment_id = h.hexdigest()
 
@@ -207,8 +207,7 @@ def fragment(
     func: F,
     *,
     run_every: int | float | timedelta | str | None = None,
-) -> F:
-    ...
+) -> F: ...
 
 
 # Support being able to pass parameters to this decorator (that is, being able to write
@@ -218,8 +217,7 @@ def fragment(
     func: None = None,
     *,
     run_every: int | float | timedelta | str | None = None,
-) -> Callable[[F], F]:
-    ...
+) -> Callable[[F], F]: ...
 
 
 @gather_metrics("experimental_fragment")

streamlit/runtime/media_file_manager.py

@@ -82,12 +82,12 @@ class MediaFileManager:
         self._storage = storage
 
         # Dict of [file_id -> MediaFileMetadata]
-        self._file_metadata: dict[str, MediaFileMetadata] = dict()
+        self._file_metadata: dict[str, MediaFileMetadata] = {}
 
         # Dict[session ID][coordinates] -> file_id.
-        self._files_by_session_and_coord: dict[
-            str, dict[str, str]
-        ] = collections.defaultdict(dict)
+        self._files_by_session_and_coord: dict[str, dict[str, str]] = (
+            collections.defaultdict(dict)
+        )
 
         # MediaFileManager is used from multiple threads, so all operations
         # need to be protected with a Lock. (This is not an RLock, which

streamlit/runtime/memory_media_file_storage.py

@@ -171,13 +171,12 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
         # with other threads that may be manipulating the cache.
         files_by_id = self._files_by_id.copy()
 
-        stats: list[CacheStat] = []
-        for file_id, file in files_by_id.items():
-            stats.append(
-                CacheStat(
-                    category_name="st_memory_media_file_storage",
-                    cache_name="",
-                    byte_length=len(file.content),
-                )
+        stats: list[CacheStat] = [
+            CacheStat(
+                category_name="st_memory_media_file_storage",
+                cache_name="",
+                byte_length=len(file.content),
             )
+            for _, file in files_by_id.items()
+        ]
         return group_stats(stats)

streamlit/runtime/metrics_util.py

@@ -306,16 +306,14 @@ F = TypeVar("F", bound=Callable[..., Any])
 def gather_metrics(
     name: str,
     func: F,
-) -> F:
-    ...
+) -> F: ...
 
 
 @overload
 def gather_metrics(
     name: str,
     func: None = None,
-) -> Callable[[F], F]:
-    ...
+) -> Callable[[F], F]: ...
 
 
 def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:

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.