streamlit-nightly 1.44.1.dev20250327__tar.gz → 1.44.2.dev20250403__tar.gz

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-nightly
-Version: 1.44.1.dev20250327
+Version: 1.44.2.dev20250403
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/setup.py

@@ -21,7 +21,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.44.1.dev20250327"  # PEP-440
+VERSION = "1.44.2.dev20250403"  # PEP-440
 
 # IMPORTANT: We should try very hard *not* to add dependencies to Streamlit.
 # And if you do add one, make the required version as general as possible:

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/commands/execution_control.py

@@ -140,6 +140,7 @@ def rerun(  # type: ignore[misc]
     if ctx and ctx.script_requests:
         query_string = ctx.query_string
         page_script_hash = ctx.page_script_hash
+        cached_message_hashes = ctx.cached_message_hashes
 
         ctx.script_requests.request_rerun(
             RerunData(
@@ -147,6 +148,7 @@ def rerun(  # type: ignore[misc]
                 page_script_hash=page_script_hash,
                 fragment_id_queue=_new_fragment_id_queue(ctx, scope),
                 is_fragment_scoped_rerun=scope == "fragment",
+                cached_message_hashes=cached_message_hashes,
             )
         )
         # Force a yield point so the runner can do the rerun
@@ -232,6 +234,7 @@ def switch_page(page: str | Path | StreamlitPage) -> NoReturn:  # type: ignore[m
         RerunData(
             query_string=ctx.query_string,
             page_script_hash=page_script_hash,
+            cached_message_hashes=ctx.cached_message_hashes,
         )
     )
     # Force a yield point so the runner can do the rerun

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/commands/page_config.py

@@ -102,7 +102,7 @@ def _get_favicon_string(page_icon: PageIcon) -> str:
 
     # If page_icon is an emoji, return it as is.
     if isinstance(page_icon, str) and is_emoji(page_icon):
-        return page_icon
+        return f"emoji:{page_icon}"
 
     if isinstance(page_icon, str) and page_icon.startswith(":material"):
         return validate_material_icon(page_icon)

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/config.py

@@ -444,32 +444,6 @@ _create_option(
     type_=int,
 )
 
-_create_option(
-    "global.storeCachedForwardMessagesInMemory",
-    description="""
-        If True, store cached ForwardMsgs in backend memory. This is an
-        internal flag to validate a potential removal of the in-memory
-        forward message cache.
-    """,
-    visibility="hidden",
-    default_val=True,
-    type_=bool,
-)
-
-_create_option(
-    "global.includeFragmentRunsInForwardMessageCacheCount",
-    description="""
-        If True, the server will include fragment runs in the count for the
-        forward message cache. The implication is that apps with fragments may
-        see messages being removed from the cache faster. This aligns the server
-        count with the frontend count. This is a temporary fix while we assess the
-        design of the cache.
-    """,
-    visibility="hidden",
-    default_val=False,
-    type_=bool,
-)
-
 
 # Config Section: Logger #
 _create_section("logger", "Settings to customize Streamlit log messages.")

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/elements/write.py

@@ -407,6 +407,14 @@ class WriteMixin:
                 kwargs,
             )
 
+        if len(args) == 1 and isinstance(args[0], str):
+            # Optimization: If there is only one arg, and it's a string,
+            # we can just call markdown directly and skip the buffer logic.
+            # This also prevents unnecessary usage of `st.empty()`.
+            # This covers > 80% of all `st.write` uses.
+            self.dg.markdown(args[0], unsafe_allow_html=unsafe_allow_html)
+            return
+
         string_buffer: list[str] = []
 
         # This bans some valid cases like: e = st.empty(); e.write("a", "b").

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/proto/ClientState_pb2.py

@@ -15,7 +15,7 @@ _sym_db = _symbol_database.Default()
 from streamlit.proto import WidgetStates_pb2 as streamlit_dot_proto_dot_WidgetStates__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!streamlit/proto/ClientState.proto\x1a\"streamlit/proto/WidgetStates.proto\"\x9d\x01\n\x0b\x43ontextInfo\x12\x15\n\x08timezone\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x1c\n\x0ftimezone_offset\x18\x02 \x01(\x05H\x01\x88\x01\x01\x12\x13\n\x06locale\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x10\n\x03url\x18\x04 \x01(\tH\x03\x88\x01\x01\x42\x0b\n\t_timezoneB\x12\n\x10_timezone_offsetB\t\n\x07_localeB\x06\n\x04_url\"\xc6\x01\n\x0b\x43lientState\x12\x14\n\x0cquery_string\x18\x01 \x01(\t\x12$\n\rwidget_states\x18\x02 \x01(\x0b\x32\r.WidgetStates\x12\x18\n\x10page_script_hash\x18\x03 \x01(\t\x12\x11\n\tpage_name\x18\x04 \x01(\t\x12\x13\n\x0b\x66ragment_id\x18\x05 \x01(\t\x12\x15\n\ris_auto_rerun\x18\x06 \x01(\x08\x12\"\n\x0c\x63ontext_info\x18\x08 \x01(\x0b\x32\x0c.ContextInfoB0\n\x1c\x63om.snowflake.apps.streamlitB\x10\x43lientStateProtob\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!streamlit/proto/ClientState.proto\x1a\"streamlit/proto/WidgetStates.proto\"\x9d\x01\n\x0b\x43ontextInfo\x12\x15\n\x08timezone\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x1c\n\x0ftimezone_offset\x18\x02 \x01(\x05H\x01\x88\x01\x01\x12\x13\n\x06locale\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x10\n\x03url\x18\x04 \x01(\tH\x03\x88\x01\x01\x42\x0b\n\t_timezoneB\x12\n\x10_timezone_offsetB\t\n\x07_localeB\x06\n\x04_url\"\xe5\x01\n\x0b\x43lientState\x12\x14\n\x0cquery_string\x18\x01 \x01(\t\x12$\n\rwidget_states\x18\x02 \x01(\x0b\x32\r.WidgetStates\x12\x18\n\x10page_script_hash\x18\x03 \x01(\t\x12\x11\n\tpage_name\x18\x04 \x01(\t\x12\x13\n\x0b\x66ragment_id\x18\x05 \x01(\t\x12\x15\n\ris_auto_rerun\x18\x06 \x01(\x08\x12\x1d\n\x15\x63\x61\x63hed_message_hashes\x18\x07 \x03(\t\x12\"\n\x0c\x63ontext_info\x18\x08 \x01(\x0b\x32\x0c.ContextInfoB0\n\x1c\x63om.snowflake.apps.streamlitB\x10\x43lientStateProtob\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -26,5 +26,5 @@ if not _descriptor._USE_C_DESCRIPTORS:
   _globals['_CONTEXTINFO']._serialized_start=74
   _globals['_CONTEXTINFO']._serialized_end=231
   _globals['_CLIENTSTATE']._serialized_start=234
-  _globals['_CLIENTSTATE']._serialized_end=432
+  _globals['_CLIENTSTATE']._serialized_end=463
 # @@protoc_insertion_point(module_scope)

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/proto/ClientState_pb2.pyi

@@ -18,7 +18,9 @@ limitations under the License.
 """
 
 import builtins
+import collections.abc
 import google.protobuf.descriptor
+import google.protobuf.internal.containers
 import google.protobuf.message
 import streamlit.proto.WidgetStates_pb2
 import typing
@@ -68,6 +70,7 @@ class ClientState(google.protobuf.message.Message):
     PAGE_NAME_FIELD_NUMBER: builtins.int
     FRAGMENT_ID_FIELD_NUMBER: builtins.int
     IS_AUTO_RERUN_FIELD_NUMBER: builtins.int
+    CACHED_MESSAGE_HASHES_FIELD_NUMBER: builtins.int
     CONTEXT_INFO_FIELD_NUMBER: builtins.int
     query_string: builtins.str
     page_script_hash: builtins.str
@@ -76,6 +79,12 @@ class ClientState(google.protobuf.message.Message):
     is_auto_rerun: builtins.bool
     @property
     def widget_states(self) -> streamlit.proto.WidgetStates_pb2.WidgetStates: ...
+    @property
+    def cached_message_hashes(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
+        """List of hashes of messages that are currently cached in
+        the frontend forward message cache.
+        """
+
     @property
     def context_info(self) -> global___ContextInfo: ...
     def __init__(
@@ -87,9 +96,10 @@ class ClientState(google.protobuf.message.Message):
         page_name: builtins.str = ...,
         fragment_id: builtins.str = ...,
         is_auto_rerun: builtins.bool = ...,
+        cached_message_hashes: collections.abc.Iterable[builtins.str] | None = ...,
         context_info: global___ContextInfo | None = ...,
     ) -> None: ...
     def HasField(self, field_name: typing.Literal["context_info", b"context_info", "widget_states", b"widget_states"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["context_info", b"context_info", "fragment_id", b"fragment_id", "is_auto_rerun", b"is_auto_rerun", "page_name", b"page_name", "page_script_hash", b"page_script_hash", "query_string", b"query_string", "widget_states", b"widget_states"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["cached_message_hashes", b"cached_message_hashes", "context_info", b"context_info", "fragment_id", b"fragment_id", "is_auto_rerun", b"is_auto_rerun", "page_name", b"page_name", "page_script_hash", b"page_script_hash", "query_string", b"query_string", "widget_states", b"widget_states"]) -> None: ...
 
 global___ClientState = ClientState

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/proto/ForwardMsg_pb2.pyi

@@ -107,10 +107,9 @@ class ForwardMsg(google.protobuf.message.Message):
     """A hash that uniquely identifies this ForwardMsg, for caching."""
     script_finished: global___ForwardMsg.ScriptFinishedStatus.ValueType
     ref_hash: builtins.str
-    """A reference to a ForwardMsg that has already been delivered.
-    The client should substitute the message with the given hash
-    for this one. If the client does not have the referenced message
-    in its cache, it can retrieve it from the server.
+    """A reference to a ForwardMsg that has already been delivered
+    and cached in the frontend. The client should substitute the message
+    with the given hash for this one.
     """
     debug_last_backmsg_id: builtins.str
     """The ID of the last BackMsg that we received before sending this
@@ -214,9 +213,7 @@ class ForwardMsgMetadata(google.protobuf.message.Message):
     ELEMENT_DIMENSION_SPEC_FIELD_NUMBER: builtins.int
     ACTIVE_SCRIPT_HASH_FIELD_NUMBER: builtins.int
     cacheable: builtins.bool
-    """If this is set, the server will have cached this message,
-    and a client that receives it should do the same.
-    """
+    """Marks a message as cacheable for the frontend."""
     active_script_hash: builtins.str
     """active_script_hash the forward message is associated from.
     For multipage apps v1, this will always be the page file running

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/app_session.py

@@ -383,12 +383,13 @@ class AppSession:
                 self._client_state.context_info.CopyFrom(client_state.context_info)
 
             rerun_data = RerunData(
-                client_state.query_string,
-                client_state.widget_states,
-                client_state.page_script_hash,
-                client_state.page_name,
+                query_string=client_state.query_string,
+                widget_states=client_state.widget_states,
+                page_script_hash=client_state.page_script_hash,
+                page_name=client_state.page_name,
                 fragment_id=fragment_id if fragment_id else None,
                 is_auto_rerun=client_state.is_auto_rerun,
+                cached_message_hashes=set(client_state.cached_message_hashes),
                 context_info=client_state.context_info,
             )
         else:

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/context.py

@@ -307,3 +307,17 @@ class ContextProxy:
         if ctx is None or ctx.context_info is None:
             return None
         return ctx.context_info.url
+
+    @property
+    @gather_metrics("context.ip_address")
+    def ip_address(self) -> str | None:
+        """The read-only IP address of the user's connection.
+        This should not be used for security measures as it can be easily spoofed.
+        """
+        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":
+                return None
+            return remote_ip
+        return None

streamlit_nightly-1.44.2.dev20250403/streamlit/runtime/forward_msg_cache.py

@@ -0,0 +1,101 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import Final
+
+from streamlit import config, util
+from streamlit.logger import get_logger
+from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+
+_LOGGER: Final = get_logger(__name__)
+
+
+def populate_hash_if_needed(msg: ForwardMsg) -> None:
+    """Computes and assigns the unique hash for a ForwardMsg.
+
+    If the ForwardMsg already has a hash, this is a no-op.
+
+    Parameters
+    ----------
+    msg : ForwardMsg
+
+    """
+    if msg.hash == "" and msg.WhichOneof("type") not in {"ref_hash", "initialize"}:
+        # Move the message's metadata aside. It's not part of the
+        # hash calculation.
+        metadata = msg.metadata
+        msg.ClearField("metadata")
+
+        # Serialize the message to bytes using the deterministic serializer to
+        # ensure consistent hashing.
+        serialized_msg = msg.SerializeToString(deterministic=True)
+
+        # TODO(lukasmasuch): Evaluate more optimized hashing for larger messages:
+        # - Add the type element type and number of bytes to the hash.
+        # - Only hash the first N bytes of the message.
+
+        # MD5 is good enough for what we need, which is uniqueness.
+        msg.hash = util.calc_md5(serialized_msg)
+
+        # Restore metadata.
+        msg.metadata.CopyFrom(metadata)
+
+        # Set cacheable flag if above the min cached size and if its a `new_element`
+        # delta. We only cache new_element and add_block deltas since container's
+        # are not expected to be larger than a few KB and have other side-effects
+        # to consider if cached. But `add_block` deltas should still get a hash.
+        # In case we ever allow other delta types to be cached, we should
+        # also need to adapt the composable logic in forward_msg_queue.
+        msg.metadata.cacheable = (
+            len(serialized_msg) >= int(config.get_option("global.minCachedMessageSize"))
+            and msg.WhichOneof("type") == "delta"
+            and msg.delta.WhichOneof("type") == "new_element"
+        )
+
+
+def create_reference_msg(msg: ForwardMsg) -> ForwardMsg:
+    """Create a ForwardMsg that refers to the given message via its hash.
+
+    The reference message will also get a copy of the source message's
+    metadata.
+
+    Parameters
+    ----------
+    msg : ForwardMsg
+        The ForwardMsg to create the reference to.
+
+    Returns
+    -------
+    ForwardMsg
+        A new ForwardMsg that "points" to the original message via the
+        ref_hash field.
+
+    """
+    if not msg.hash:
+        _LOGGER.warning(
+            "Failed to create a reference message for a ForwardMsg since the "
+            "message does not have a hash. This is not expected to happen, "
+            "please report this as a bug. Falling back to the original message."
+        )
+        # Fallback to the original message if the hash is not set.
+        # This is not expected to happen.
+        return msg
+
+    ref_msg = ForwardMsg()
+    ref_msg.ref_hash = msg.hash
+    ref_msg.metadata.CopyFrom(msg.metadata)
+    ref_msg.metadata.cacheable = False
+    return ref_msg

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/forward_msg_queue.py

@@ -14,13 +14,10 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable
+from typing import Any, Callable
 
 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.
@@ -79,16 +76,27 @@ class ForwardMsgQueue:
         # the app - we attempt to combine this new Delta into the old
         # one. This is an optimization that prevents redundant Deltas
         # from being sent to the frontend.
+        # One common case where this happens is with `st.write` since
+        # it uses a trick with `st.empty` to handle lists of args.
+        # Note: its not guaranteed that the optimization is always applied
+        # 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
+        #
+        # queue 2:
+        # markdown [1, 0]
+        # ...
+
         delta_key = tuple(msg.metadata.delta_path)
         if delta_key in self._delta_index_map:
             index = self._delta_index_map[delta_key]
             old_msg = self._queue[index]
-            composed_delta = _maybe_compose_deltas(old_msg.delta, msg.delta)
-            if composed_delta is not None:
-                new_msg = ForwardMsg()
-                new_msg.delta.CopyFrom(composed_delta)
-                new_msg.metadata.CopyFrom(msg.metadata)
-                self._queue[index] = new_msg
+            composed_msg = _maybe_compose_delta_msgs(old_msg, msg)
+            if composed_msg is not None:
+                self._queue[index] = composed_msg
                 return
 
         # No composition occurred. Append this message to the queue, and
@@ -163,6 +171,11 @@ class ForwardMsgQueue:
 
 def _is_composable_message(msg: ForwardMsg) -> bool:
     """True if the ForwardMsg is potentially composable with other ForwardMsgs."""
+    if msg.HasField("ref_hash"):
+        # reference messages (cached in frontend) are always composable.
+        # Only new_element deltas can be reference messages.
+        return True
+
     if not msg.HasField("delta"):
         # Non-delta messages are never composable.
         return False
@@ -174,17 +187,20 @@ def _is_composable_message(msg: ForwardMsg) -> bool:
     return delta_type != "add_rows" and delta_type != "arrow_add_rows"
 
 
-def _maybe_compose_deltas(old_delta: Delta, new_delta: Delta) -> Delta | None:
-    """Combines new_delta onto old_delta if possible.
+def _maybe_compose_delta_msgs(
+    old_msg: ForwardMsg, new_msg: ForwardMsg
+) -> ForwardMsg | None:
+    """Optimization logic that composes new_msg onto old_msg if possible.
 
-    If the combination takes place, the function returns a new Delta that
-    should replace old_delta in the queue.
+    If the combination takes place, the function returns a new ForwardMsg that
+    should replace old_msg in the queue. This basically means that the old_msg
+    is not send to the browser since its considered unnecessary.
 
-    If the new_delta is incompatible with old_delta, the function returns None.
-    In this case, the new_delta should just be appended to the queue as normal.
+    If the new_msg is incompatible with old_msg, the function returns None.
+    In this case, the new_msg should just be appended to the queue as normal.
     """
-    old_delta_type = old_delta.WhichOneof("type")
-    if old_delta_type == "add_block":
+
+    if old_msg.HasField("delta") and old_msg.delta.WhichOneof("type") == "add_block":
         # We never replace add_block deltas, because blocks can have
         # other dependent deltas later in the queue. For example:
         #
@@ -200,12 +216,14 @@ def _maybe_compose_deltas(old_delta: Delta, new_delta: Delta) -> Delta | None:
         # now just an element, and not a block.
         return None
 
-    new_delta_type = new_delta.WhichOneof("type")
-    if new_delta_type == "new_element":
-        return new_delta
+    if new_msg.HasField("ref_hash"):
+        # ref_hash messages are always composable.
+        # Only new_element deltas can be reference messages.
+        return new_msg
 
-    if new_delta_type == "add_block":
-        return new_delta
+    new_delta_type = new_msg.delta.WhichOneof("type")
+    if new_delta_type == "new_element" or new_delta_type == "add_block":
+        return new_msg
 
     return None
 

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/runtime.py

@@ -21,7 +21,6 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING, Final, NamedTuple
 
-from streamlit import config
 from streamlit.components.lib.local_component_registry import LocalComponentRegistry
 from streamlit.logger import get_logger
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
@@ -33,14 +32,8 @@ from streamlit.runtime.caching import (
 from streamlit.runtime.caching.storage.local_disk_cache_storage import (
     LocalDiskCacheStorageManager,
 )
-from streamlit.runtime.forward_msg_cache import (
-    ForwardMsgCache,
-    create_reference_msg,
-    populate_hash_if_needed,
-)
 from streamlit.runtime.media_file_manager import MediaFileManager
 from streamlit.runtime.memory_session_storage import MemorySessionStorage
-from streamlit.runtime.runtime_util import is_cacheable_msg
 from streamlit.runtime.script_data import ScriptData
 from streamlit.runtime.scriptrunner.script_cache import ScriptCache
 from streamlit.runtime.session_manager import (
@@ -203,7 +196,6 @@ class Runtime:
 
         # Initialize managers
         self._component_registry = config.component_registry
-        self._message_cache = ForwardMsgCache()
         self._uploaded_file_mgr = config.uploaded_file_manager
         self._media_file_mgr = MediaFileManager(storage=config.media_file_storage)
         self._cache_storage_manager = config.cache_storage_manager
@@ -219,7 +211,6 @@ class Runtime:
         self._stats_mgr = StatsManager()
         self._stats_mgr.register_provider(get_data_cache_stats_provider())
         self._stats_mgr.register_provider(get_resource_cache_stats_provider())
-        self._stats_mgr.register_provider(self._message_cache)
         self._stats_mgr.register_provider(self._uploaded_file_mgr)
         self._stats_mgr.register_provider(SessionStateStatProvider(self._session_mgr))
 
@@ -231,10 +222,6 @@ class Runtime:
     def component_registry(self) -> BaseComponentRegistry:
         return self._component_registry
 
-    @property
-    def message_cache(self) -> ForwardMsgCache:
-        return self._message_cache
-
     @property
     def uploaded_file_mgr(self) -> UploadedFileManager:
         return self._uploaded_file_mgr
@@ -449,7 +436,6 @@ class Runtime:
         """
         session_info = self._session_mgr.get_session_info(session_id)
         if session_info:
-            self._message_cache.remove_refs_for_session(session_info.session)
             self._session_mgr.close_session(session_id)
         self._on_session_disconnected()
 
@@ -474,14 +460,6 @@ class Runtime:
         """
         session_info = self._session_mgr.get_active_session_info(session_id)
         if session_info:
-            # NOTE: Ideally, we'd like to keep ForwardMsgCache refs for a session around
-            # when a session is disconnected (and defer their cleanup until the session
-            # is garbage collected), but this would be difficult to do as the
-            # ForwardMsgCache is not thread safe, and we have no guarantee that the
-            # garbage collector will only run on the eventloop thread. Because of this,
-            # we clean up refs now and accept the risk that we're deleting cache entries
-            # that will be useful once the browser tab reconnects.
-            self._message_cache.remove_refs_for_session(session_info.session)
             self._session_mgr.disconnect_session(session_id)
         self._on_session_disconnected()
 
@@ -698,7 +676,6 @@ Please report this bug at https://github.com/streamlit/streamlit/issues.
 
     def _send_message(self, session_info: ActiveSessionInfo, msg: ForwardMsg) -> None:
         """Send a message to a client.
-
         If the client is likely to have already cached the message, we may
         instead send a "reference" message that contains only the hash of the
         message.
@@ -714,51 +691,16 @@ Please report this bug at https://github.com/streamlit/streamlit/issues.
         -----
         Threading: UNSAFE. Must be called on the eventloop thread.
         """
-        msg.metadata.cacheable = is_cacheable_msg(msg)
-        msg_to_send = msg
-        if msg.metadata.cacheable:
-            populate_hash_if_needed(msg)
-
-            if self._message_cache.has_message_reference(
-                msg, session_info.session, session_info.script_run_count
-            ):
-                # This session has probably cached this message. Send
-                # a reference instead.
-                _LOGGER.debug("Sending cached message ref (hash=%s)", msg.hash)
-                msg_to_send = create_reference_msg(msg)
-
-            # Cache the message so it can be referenced in the future.
-            # If the message is already cached, this will reset its
-            # age.
-            _LOGGER.debug("Caching message (hash=%s)", msg.hash)
-            self._message_cache.add_message(
-                msg, session_info.session, session_info.script_run_count
-            )
 
         # If this was a `script_finished` message, we increment the
-        # script_run_count for this session, and update the cache
+        # script_run_count for this session
         if msg.WhichOneof("type") == "script_finished" and (
             msg.script_finished == ForwardMsg.FINISHED_SUCCESSFULLY
-            or (
-                config.get_option(
-                    "global.includeFragmentRunsInForwardMessageCacheCount"
-                )
-                and msg.script_finished == ForwardMsg.FINISHED_FRAGMENT_RUN_SUCCESSFULLY
-            )
         ):
-            _LOGGER.debug(
-                "Script run finished successfully; "
-                "removing expired entries from MessageCache "
-                "(max_age=%s)",
-                config.get_option("global.maxCachedMessageAge"),
-            )
             session_info.script_run_count += 1
-            self._message_cache.remove_expired_entries_for_session(
-                session_info.session, session_info.script_run_count
-            )
 
         # Ship it off!
-        session_info.client.write_forward_msg(msg_to_send)
+        session_info.client.write_forward_msg(msg)
 
     def _enqueued_some_message(self) -> None:
         """Callback called by AppSession after the AppSession has enqueued a

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/runtime_util.py

@@ -16,15 +16,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from logging import getLogger
+from typing import TYPE_CHECKING, Any, Final
 
 from streamlit import config
 from streamlit.errors import MarkdownFormattedException, StreamlitAPIException
-from streamlit.runtime.forward_msg_cache import populate_hash_if_needed
 
 if TYPE_CHECKING:
     from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 
+_LOGGER: Final = getLogger(__name__)
+
 
 class MessageSizeError(MarkdownFormattedException):
     """Exception raised when a websocket message is larger than the configured limit."""
@@ -60,29 +62,28 @@ class BadDurationStringError(StreamlitAPIException):
         )
 
 
-def is_cacheable_msg(msg: ForwardMsg) -> bool:
-    """True if the given message qualifies for caching."""
-    if msg.WhichOneof("type") in {"ref_hash", "initialize"}:
-        # Some message types never get cached
-        return False
-    return msg.ByteSize() >= int(config.get_option("global.minCachedMessageSize"))
-
-
 def serialize_forward_msg(msg: ForwardMsg) -> bytes:
     """Serialize a ForwardMsg to send to a client.
 
     If the message is too large, it will be converted to an exception message
     instead.
     """
-    populate_hash_if_needed(msg)
+
     msg_str = msg.SerializeToString()
 
     if len(msg_str) > get_max_message_size_bytes():
-        import streamlit.elements.exception as exception
-
         # Overwrite the offending ForwardMsg.delta with an error to display.
         # This assumes that the size limit wasn't exceeded due to metadata.
-        exception.marshall(msg.delta.new_element.exception, MessageSizeError(msg_str))
+        import streamlit.elements.exception as exception
+
+        msg_size_error = MessageSizeError(msg_str)
+        _LOGGER.warning(
+            "Websocket message size limit exceeded. "
+            f"Showing error to the user: {msg_size_error}"
+        )
+        exception.marshall(msg.delta.new_element.exception, msg_size_error)
+        # Deactivate caching for this error message:
+        msg.metadata.cacheable = False
         msg_str = msg.SerializeToString()
 
     return msg_str

{streamlit_nightly-1.44.1.dev20250327 → streamlit_nightly-1.44.2.dev20250403}/streamlit/runtime/scriptrunner/script_runner.py

@@ -134,7 +134,14 @@ def _mpa_v1(main_script_path: str):
     # Read out the my_pages folder and create a page for every script:
     pages = PAGES_FOLDER.glob("*.py")
     pages = sorted(
-        [page for page in pages if page.name.endswith(".py")], key=page_sort_key
+        [
+            page
+            for page in pages
+            if page.name.endswith(".py")
+            and not page.name.startswith(".")
+            and not page.name == "__init__.py"
+        ],
+        key=page_sort_key,
     )
 
     # Use this script as the main page and
@@ -514,6 +521,7 @@ class ScriptRunner:
                 query_string=rerun_data.query_string,
                 page_script_hash=page_script_hash,
                 fragment_ids_this_run=fragment_ids_this_run,
+                cached_message_hashes=rerun_data.cached_message_hashes,
                 context_info=rerun_data.context_info,
             )