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

streamlit/runtime/caching/storage/in_memory_cache_storage_wrapper.py

@@ -57,7 +57,9 @@ class InMemoryCacheStorageWrapper(CacheStorage):
     it from multiple threads.
     """
 
-    def __init__(self, persist_storage: CacheStorage, context: CacheStorageContext):
+    def __init__(
+        self, persist_storage: CacheStorage, context: CacheStorageContext
+    ) -> None:
         self.function_key = context.function_key
         self.function_display_name = context.function_display_name
         self._ttl_seconds = context.ttl_seconds
@@ -108,18 +110,15 @@ class InMemoryCacheStorageWrapper(CacheStorage):
 
     def get_stats(self) -> list[CacheStat]:
         """Returns a list of stats in bytes for the cache memory storage per item."""
-        stats = []
-
         with self._mem_cache_lock:
-            for item in self._mem_cache.values():
-                stats.append(
-                    CacheStat(
-                        category_name="st_cache_data",
-                        cache_name=self.function_display_name,
-                        byte_length=len(item),
-                    )
+            return [
+                CacheStat(
+                    category_name="st_cache_data",
+                    cache_name=self.function_display_name,
+                    byte_length=len(item),
                 )
-        return stats
+                for item in self._mem_cache.values()
+            ]
 
     def close(self) -> None:
         """Closes the cache storage."""
@@ -132,9 +131,8 @@ class InMemoryCacheStorageWrapper(CacheStorage):
                 _LOGGER.debug("Memory cache HIT: %s", key)
                 return entry
 
-            else:
-                _LOGGER.debug("Memory cache MISS: %s", key)
-                raise CacheStorageKeyNotFoundError("Key not found in mem cache")
+            _LOGGER.debug("Memory cache MISS: %s", key)
+            raise CacheStorageKeyNotFoundError("Key not found in mem cache")
 
     def _write_to_mem_cache(self, key: str, entry_bytes: bytes) -> None:
         with self._mem_cache_lock:

streamlit/runtime/caching/storage/local_disk_cache_storage.py

@@ -109,9 +109,9 @@ class LocalDiskCacheStorageManager(CacheStorageManager):
             and not math.isinf(context.ttl_seconds)
         ):
             _LOGGER.warning(
-                f"The cached function '{context.function_display_name}' has a TTL "
-                "that will be ignored. Persistent cached functions currently don't "
-                "support TTL."
+                "The cached function '%s' has a TTL that will be ignored. "
+                "Persistent cached functions currently don't support TTL.",
+                context.function_display_name,
             )
 
 
@@ -120,7 +120,7 @@ class LocalDiskCacheStorage(CacheStorage):
     This is the default cache persistence layer for `@st.cache_data`.
     """
 
-    def __init__(self, context: CacheStorageContext):
+    def __init__(self, context: CacheStorageContext) -> None:
         self.function_key = context.function_key
         self.persist = context.persist
         self._ttl_seconds = context.ttl_seconds
@@ -143,8 +143,8 @@ class LocalDiskCacheStorage(CacheStorage):
         if self.persist == "disk":
             path = self._get_cache_file_path(key)
             try:
-                with streamlit_read(path, binary=True) as input:
-                    value = input.read()
+                with streamlit_read(path, binary=True) as file:
+                    value = file.read()
                     _LOGGER.debug("Disk cache HIT: %s", key)
                     return bytes(value)
             except FileNotFoundError:

streamlit/runtime/connection_factory.py

@@ -38,13 +38,13 @@ if TYPE_CHECKING:
 #   2. Writing two new @overloads for connection_factory (one for the case where the
 #      only the connection name is specified and another when both name and type are).
 #   3. Updating test_get_first_party_connection_helper in connection_factory_test.py.
-FIRST_PARTY_CONNECTIONS = {
+_FIRST_PARTY_CONNECTIONS: Final[dict[str, type[BaseConnection[Any]]]] = {
     "snowflake": SnowflakeConnection,
     "snowpark": SnowparkConnection,
     "sql": SQLConnection,
 }
-MODULE_EXTRACTION_REGEX = re.compile(r"No module named \'(.+)\'")
-MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
+_MODULE_EXTRACTION_REGEX = re.compile(r"No module named \'(.+)\'")
+_MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
     "MySQLdb": "mysqlclient",
     "psycopg2": "psycopg2-binary",
     "sqlalchemy": "sqlalchemy",
@@ -52,6 +52,7 @@ MODULES_TO_PYPI_PACKAGES: Final[dict[str, str]] = {
     "snowflake.connector": "snowflake-connector-python",
     "snowflake.snowpark": "snowflake-snowpark-python",
 }
+_USE_ENV_PREFIX: Final = "env:"
 
 # The BaseConnection bound is parameterized to `Any` below as subclasses of
 # BaseConnection are responsible for binding the type parameter of BaseConnection to a
@@ -65,7 +66,7 @@ def _create_connection(
     connection_class: type[ConnectionClass],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> ConnectionClass:
     """Create an instance of connection_class with the given name and kwargs.
 
@@ -76,7 +77,7 @@ def _create_connection(
     """
 
     def __create_connection(
-        name: str, connection_class: type[ConnectionClass], **kwargs
+        name: str, connection_class: type[ConnectionClass], **kwargs: Any
     ) -> ConnectionClass:
         return connection_class(connection_name=name, **kwargs)
 
@@ -103,13 +104,13 @@ def _create_connection(
     return __create_connection(name, connection_class, **kwargs)
 
 
-def _get_first_party_connection(connection_class: str):
-    if connection_class in FIRST_PARTY_CONNECTIONS:
-        return FIRST_PARTY_CONNECTIONS[connection_class]
+def _get_first_party_connection(connection_class: str) -> type[BaseConnection[Any]]:
+    if connection_class in _FIRST_PARTY_CONNECTIONS:
+        return _FIRST_PARTY_CONNECTIONS[connection_class]
 
     raise StreamlitAPIException(
         f"Invalid connection '{connection_class}'. "
-        f"Supported connection classes: {FIRST_PARTY_CONNECTIONS}"
+        f"Supported connection classes: {_FIRST_PARTY_CONNECTIONS}"
     )
 
 
@@ -119,7 +120,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SQLConnection:
     pass
 
@@ -131,7 +132,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SQLConnection:
     pass
 
@@ -142,7 +143,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowflakeConnection:
     pass
 
@@ -154,7 +155,7 @@ def connection_factory(
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
     autocommit: bool = False,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowflakeConnection:
     pass
 
@@ -164,7 +165,7 @@ def connection_factory(
     name: Literal["snowpark"],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowparkConnection:
     pass
 
@@ -175,7 +176,7 @@ def connection_factory(
     type: Literal["snowpark"],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> SnowparkConnection:
     pass
 
@@ -186,7 +187,7 @@ def connection_factory(
     type: type[ConnectionClass],
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> ConnectionClass:
     pass
 
@@ -197,12 +198,12 @@ def connection_factory(
     type: str | None = None,
     max_entries: int | None = None,
     ttl: float | timedelta | None = None,
-    **kwargs,
+    **kwargs: Any,
 ) -> BaseConnection[Any]:
     pass
 
 
-def connection_factory(
+def connection_factory(  # type: ignore
     name,
     type=None,
     max_entries=None,
@@ -233,7 +234,7 @@ def connection_factory(
         The type of connection to create. This can be one of the following:
 
         - ``None`` (default): Streamlit will infer the connection type from
-          ``name``. If the type is not inferrable from ``name``, the type must
+          ``name``. If the type is not inferable from ``name``, the type must
           be specified in ``secrets.toml`` instead.
         - ``"snowflake"``: Streamlit will initialize a connection with
           |SnowflakeConnection|_.
@@ -267,7 +268,7 @@ def connection_factory(
     **kwargs : any
         Connection-specific keyword arguments that are passed to the
         connection's ``._connect()`` method. ``**kwargs`` are typically
-        combined with (and take precendence over) key-value pairs in
+        combined with (and take precedence over) key-value pairs in
         ``secrets.toml``. To learn more, see the specific connection's
         documentation.
 
@@ -366,19 +367,23 @@ def connection_factory(
     >>> conn = st.connection("my_sql_connection", type=SQLConnection)
 
     """
-    USE_ENV_PREFIX = "env:"
 
-    if name.startswith(USE_ENV_PREFIX):
+    if name.startswith(_USE_ENV_PREFIX):
         # It'd be nice to use str.removeprefix() here, but we won't be able to do that
-        # until the minimium Python version we support is 3.9.
-        envvar_name = name[len(USE_ENV_PREFIX) :]
+        # until the minimum Python version we support is 3.9.
+        envvar_name = name[len(_USE_ENV_PREFIX) :]
         name = os.environ[envvar_name]
 
-    if type is None:
-        if name in FIRST_PARTY_CONNECTIONS:
+    # type is a nice kwarg name for the st.connection user but is annoying to work with
+    # since it conflicts with the builtin function name and thus gets syntax
+    # highlighted.
+    connection_class = type
+
+    if connection_class is None:
+        if name in _FIRST_PARTY_CONNECTIONS:
             # We allow users to simply write `st.connection("sql")` instead of
             # `st.connection("sql", type="sql")`.
-            type = _get_first_party_connection(name)
+            connection_class = _get_first_party_connection(name)
         else:
             # The user didn't specify a type, so we try to pull it out from their
             # secrets.toml file. NOTE: we're okay with any of the dict lookups below
@@ -386,12 +391,7 @@ def connection_factory(
             # it must be the case that it's defined in secrets.toml and should raise an
             # Exception otherwise.
             secrets_singleton.load_if_toml_exists()
-            type = secrets_singleton["connections"][name]["type"]
-
-    # type is a nice kwarg name for the st.connection user but is annoying to work with
-    # since it conflicts with the builtin function name and thus gets syntax
-    # highlighted.
-    connection_class = type
+            connection_class = secrets_singleton["connections"][name]["type"]
 
     if isinstance(connection_class, str):
         # We assume that a connection_class specified via string is either the fully
@@ -424,12 +424,12 @@ def connection_factory(
         return conn
     except ModuleNotFoundError as e:
         err_string = str(e)
-        missing_module = re.search(MODULE_EXTRACTION_REGEX, err_string)
+        missing_module = re.search(_MODULE_EXTRACTION_REGEX, err_string)
 
         extra_info = "You may be missing a dependency required to use this connection."
         if missing_module:
-            pypi_package = MODULES_TO_PYPI_PACKAGES.get(missing_module.group(1))
+            pypi_package = _MODULES_TO_PYPI_PACKAGES.get(missing_module.group(1))
             if pypi_package:
                 extra_info = f"You need to install the '{pypi_package}' package to use this connection."
 
-        raise ModuleNotFoundError(f"{str(e)}. {extra_info}")
+        raise ModuleNotFoundError(f"{e}. {extra_info}")

streamlit/runtime/context.py

@@ -17,12 +17,13 @@ from __future__ import annotations
 from collections.abc import Iterable, Iterator, Mapping
 from functools import lru_cache
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any, Literal, cast
 
 from streamlit import runtime
 from streamlit.runtime.context_util import maybe_add_page_path, maybe_trim_page_path
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.util import AttributeDictionary
 
 if TYPE_CHECKING:
     from http.cookies import Morsel
@@ -63,8 +64,28 @@ def _normalize_header(name: str) -> str:
     return "-".join(w.capitalize() for w in name.split("-"))
 
 
+class StreamlitTheme(AttributeDictionary):
+    """A dictionary-like object containing theme information.
+
+    This class extends the functionality of a standard dictionary to allow items
+    to be accessed via attribute-style dot notation in addition to the traditional
+    key-based access. If a dictionary item is accessed and is itself a dictionary,
+    it is automatically wrapped in another `AttributeDictionary`, enabling recursive
+    attribute-style access.
+    """
+
+    type: Literal["dark", "light"] | None
+
+    def __init__(self, theme_info: dict[str, str | None]):
+        super().__init__(theme_info)
+
+    @classmethod
+    def from_context_info(cls, context_dict: dict[str, str | None]) -> StreamlitTheme:
+        return cls(context_dict)
+
+
 class StreamlitHeaders(Mapping[str, str]):
-    def __init__(self, headers: Iterable[tuple[str, str]]):
+    def __init__(self, headers: Iterable[tuple[str, str]]) -> None:
         dict_like_headers: dict[str, list[str]] = {}
 
         for key, value in headers:
@@ -98,7 +119,7 @@ class StreamlitHeaders(Mapping[str, str]):
 
 
 class StreamlitCookies(Mapping[str, str]):
-    def __init__(self, cookies: Mapping[str, str]):
+    def __init__(self, cookies: Mapping[str, str]) -> None:
         self._cookies = MappingProxyType(cookies)
 
     @classmethod
@@ -215,6 +236,38 @@ class ContextProxy:
         cookies = session_client_request.cookies
         return StreamlitCookies.from_tornado_cookies(cookies)
 
+    @property
+    @gather_metrics("context.theme")
+    def theme(self) -> StreamlitTheme:
+        """A read-only, dictionary-like object containing theme information.
+
+        Theme information is restricted to the ``type`` of the theme (dark or
+        light) and is inferred from the background color of the app.
+
+        .. note::
+            Changes made to the background color through CSS are not included.
+
+        Attributes
+        ----------
+        type : "light", "dark"
+            The theme type inferred from the background color of the app.
+
+        Example
+        -------
+        Access the theme type of the app:
+
+        >>> import streamlit as st
+        >>>
+        >>> st.write(f"The current theme type is {st.context.theme.type}.")
+
+        """
+        ctx = get_script_run_ctx()
+
+        if ctx is None or ctx.context_info is None:
+            return StreamlitTheme({"type": None})
+
+        return StreamlitTheme.from_context_info({"type": ctx.context_info.color_scheme})
+
     @property
     @gather_metrics("context.timezone")
     def timezone(self) -> str | None:
@@ -328,11 +381,7 @@ class ContextProxy:
         url_without_page_prefix = maybe_trim_page_path(
             url_from_frontend, ctx.pages_manager
         )
-        url_with_page_prefix = maybe_add_page_path(
-            url_without_page_prefix, ctx.pages_manager
-        )
-
-        return url_with_page_prefix
+        return maybe_add_page_path(url_without_page_prefix, ctx.pages_manager)
 
     @property
     @gather_metrics("context.ip_address")
@@ -367,7 +416,7 @@ class ContextProxy:
         session_client_request = _get_request()
         if session_client_request is not None:
             remote_ip = session_client_request.remote_ip
-            if remote_ip == "::1" or remote_ip == "127.0.0.1":
+            if remote_ip in {"::1", "127.0.0.1"}:
                 return None
             return remote_ip
         return None

streamlit/runtime/credentials.py

@@ -20,7 +20,7 @@ import json
 import os
 import sys
 import textwrap
-from typing import Final, NamedTuple, NoReturn
+from typing import Final, NamedTuple, NoReturn, cast
 from uuid import uuid4
 
 from streamlit import cli_util, env_util, file_util, util
@@ -29,10 +29,11 @@ from streamlit.logger import get_logger
 _LOGGER: Final = get_logger(__name__)
 
 
-if env_util.IS_WINDOWS:
-    _CONFIG_FILE_PATH = r"%userprofile%/.streamlit/config.toml"
-else:
-    _CONFIG_FILE_PATH = "~/.streamlit/config.toml"
+_CONFIG_FILE_PATH: Final = (
+    r"%userprofile%/.streamlit/config.toml"
+    if env_util.IS_WINDOWS
+    else "~/.streamlit/config.toml"
+)
 
 
 class _Activation(NamedTuple):
@@ -53,7 +54,7 @@ def email_prompt() -> str:
     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,
+      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.
 
@@ -65,7 +66,7 @@ Collecting usage statistics. To deactivate, set browser.gatherUsageStats to fals
 """
 
 
-def _send_email(email: str) -> None:
+def _send_email(email: str | None) -> None:
     """Send the user's email for metrics, if submitted."""
     import requests
 
@@ -79,7 +80,7 @@ def _send_email(email: str) -> None:
         ).json()
         metrics_url = response_json.get("url", "")
     except Exception:
-        _LOGGER.error("Failed to fetch metrics URL")
+        _LOGGER.exception("Failed to fetch metrics URL")
         return
 
     headers = {
@@ -104,6 +105,7 @@ def _send_email(email: str) -> None:
         metrics_url,
         headers=headers,
         data=json.dumps(data).encode(),
+        timeout=10,
     )
 
     response.raise_for_status()
@@ -115,22 +117,22 @@ class Credentials:
     _singleton: Credentials | None = None
 
     @classmethod
-    def get_current(cls):
+    def get_current(cls) -> Credentials:
         """Return the singleton instance."""
         if cls._singleton is None:
             Credentials()
 
-        return Credentials._singleton
+        return cast("Credentials", Credentials._singleton)
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize class."""
         if Credentials._singleton is not None:
             raise RuntimeError(
                 "Credentials already initialized. Use .get_current() instead"
             )
 
-        self.activation = None
-        self._conf_file = _get_credential_file_path()
+        self.activation: _Activation | None = None
+        self._conf_file: str = _get_credential_file_path()
 
         Credentials._singleton = self
 
@@ -149,7 +151,7 @@ class Credentials:
             with open(self._conf_file) as f:
                 data = toml.load(f).get("general")
             if data is None:
-                raise Exception
+                raise RuntimeError  # noqa: TRY301
             self.activation = _verify_email(data.get("email"))
         except FileNotFoundError:
             if auto_resolve:
@@ -163,7 +165,7 @@ class Credentials:
                 self.reset()
                 self.activate(show_instructions=not auto_resolve)
                 return
-            raise Exception(
+            raise RuntimeError(
                 textwrap.dedent(
                     """
                 Unable to load credentials from %s.
@@ -261,43 +263,30 @@ class Credentials:
                 if self.activation.is_valid:
                     self.save()
                     # IMPORTANT: Break the text below at 80 chars.
-                    TELEMETRY_TEXT = """
-  You can find our privacy policy at %(link)s
+                    telemetry_text = f"""
+  You can find our privacy policy at {cli_util.style_for_cli("https://streamlit.io/privacy-policy", underline=True)}
 
   Summary:
   - This open source library collects usage statistics.
   - We cannot see and do not store information contained inside Streamlit apps,
     such as text, charts, images, etc.
   - Telemetry data is stored in servers in the United States.
-  - If you'd like to opt out, add the following to %(config)s,
+  - If you'd like to opt out, add the following to {cli_util.style_for_cli(_CONFIG_FILE_PATH)},
     creating that file if necessary:
 
     [browser]
     gatherUsageStats = false
-""" % {
-                        "link": cli_util.style_for_cli(
-                            "https://streamlit.io/privacy-policy", underline=True
-                        ),
-                        "config": cli_util.style_for_cli(_CONFIG_FILE_PATH),
-                    }
-
-                    cli_util.print_to_cli(TELEMETRY_TEXT)
+"""
+
+                    cli_util.print_to_cli(telemetry_text)
                     if show_instructions:
                         # IMPORTANT: Break the text below at 80 chars.
-                        INSTRUCTIONS_TEXT = """
-  %(start)s
-  %(prompt)s %(hello)s
-""" % {
-                            "start": cli_util.style_for_cli(
-                                "Get started by typing:", fg="blue", bold=True
-                            ),
-                            "prompt": cli_util.style_for_cli("$", fg="blue"),
-                            "hello": cli_util.style_for_cli(
-                                "streamlit hello", bold=True
-                            ),
-                        }
-
-                        cli_util.print_to_cli(INSTRUCTIONS_TEXT)
+                        instructions_text = f"""
+  {cli_util.style_for_cli("Get started by typing:", fg="blue", bold=True)}
+  {cli_util.style_for_cli("$", fg="blue")} {cli_util.style_for_cli("streamlit hello", bold=True)}
+"""
+
+                        cli_util.print_to_cli(instructions_text)
                     activated = True
                 else:  # pragma: nocover
                     _LOGGER.error("Please try again.")

streamlit/runtime/forward_msg_queue.py

@@ -41,7 +41,7 @@ class ForwardMsgQueue:
         """
         ForwardMsgQueue._before_enqueue_msg = before_enqueue_msg
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._queue: list[ForwardMsg] = []
         # A mapping of (delta_path -> _queue.indexof(msg)) for each
         # Delta message in the queue. We use this for coalescing
@@ -82,13 +82,13 @@ class ForwardMsgQueue:
         # since the queue can be flushed to the browser at any time.
         # For example:
         # queue 1:
-        # empty [0, 0]  <- skipped
-        # markdown [0, 0]
-        # empty [1, 0]  <- send to frontend
+        # > empty [0, 0]  <- skipped
+        # > markdown [0, 0]
+        # > empty [1, 0]  <- send to frontend
         #
         # queue 2:
-        # markdown [1, 0]
-        # ...
+        # > markdown [1, 0]
+        # > ...
 
         delta_key = tuple(msg.metadata.delta_path)
         if delta_key in self._delta_index_map:
@@ -184,7 +184,7 @@ def _is_composable_message(msg: ForwardMsg) -> bool:
     # operation can raise errors, and we don't have a good way of handling
     # those errors in the message queue.
     delta_type = msg.delta.WhichOneof("type")
-    return delta_type != "add_rows" and delta_type != "arrow_add_rows"
+    return delta_type not in {"add_rows", "arrow_add_rows"}
 
 
 def _maybe_compose_delta_msgs(
@@ -204,9 +204,9 @@ def _maybe_compose_delta_msgs(
         # We never replace add_block deltas, because blocks can have
         # other dependent deltas later in the queue. For example:
         #
-        #   placeholder = st.empty()
-        #   placeholder.columns(1)
-        #   placeholder.empty()
+        # >  placeholder = st.empty()
+        # >  placeholder.columns(1)
+        # >  placeholder.empty()
         #
         # The call to "placeholder.columns(1)" creates two blocks, a parent
         # container with delta_path (0, 0), and a column child with
@@ -222,7 +222,7 @@ def _maybe_compose_delta_msgs(
         return new_msg
 
     new_delta_type = new_msg.delta.WhichOneof("type")
-    if new_delta_type == "new_element" or new_delta_type == "add_block":
+    if new_delta_type in {"new_element", "add_block"}:
         return new_msg
 
     return None

streamlit/runtime/fragment.py

@@ -155,11 +155,10 @@ def _fragment(
             )
 
         return wrapper
-    else:
-        non_optional_func = func
+    non_optional_func = func
 
     @wraps(non_optional_func)
-    def wrap(*args, **kwargs):
+    def wrap(*args: Any, **kwargs: Any) -> Any:
         from streamlit.delta_generator_singletons import context_dg_stack
 
         ctx = get_script_run_ctx()
@@ -176,7 +175,7 @@ def _fragment(
         # that the fragment is associated with the correct script running.
         initialized_active_script_hash = ctx.active_script_hash
 
-        def wrapped_fragment():
+        def wrapped_fragment() -> Any:
             import streamlit as st
 
             if should_show_deprecation_warning:
@@ -193,7 +192,8 @@ def _fragment(
             # fragment runs will generally run in a new script run, thus we'll have a
             # new ctx.
             ctx = get_script_run_ctx(suppress_warning=True)
-            assert ctx is not None
+            if ctx is None:
+                raise RuntimeError("ctx is None. This should never happen.")
 
             if ctx.fragment_ids_this_run:
                 # This script run is a run of one or more fragments. We restore the
@@ -246,11 +246,11 @@ def _fragment(
                         except (
                             RerunException,
                             StopException,
-                        ) as e:
+                        ):
                             # 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
+                            raise
                         except Exception as e:
                             # render error here so that the delta path is correct
                             # for full app runs, the error will be displayed by the