streamlit-nightly 1.37.2.dev20240818__py2.py3-none-any.whl → 1.37.2.dev20240820__py2.py3-none-any.whl

streamlit/runtime/caching/cache_errors.py

@@ -29,7 +29,7 @@ CACHE_DOCS_URL = "https://docs.streamlit.io/develop/concepts/architecture/cachin
 def get_cached_func_name_md(func: Any) -> str:
     """Get markdown representation of the function name."""
     if hasattr(func, "__name__"):
-        return "`%s()`" % func.__name__
+        return f"`{func.__name__}()`"
     elif hasattr(type(func), "__name__"):
         return f"`{type(func).__name__}`"
     return f"`{type(func)}`"
@@ -105,9 +105,10 @@ class CacheReplayClosureError(StreamlitAPIException):
 
         msg = (
             f"""
-While running {func_name}, a streamlit element is called on some layout block created outside the function.
-This is incompatible with replaying the cached effect of that element, because the
-the referenced block might not exist when the replay happens.
+While running {func_name}, a streamlit element is called on some layout block
+created outside the function. This is incompatible with replaying the cached
+effect of that element, because the the referenced block might not exist when
+the replay happens.
 
 How to fix this:
 * Move the creation of $THING inside {func_name}.
@@ -124,11 +125,14 @@ class UnserializableReturnValueError(MarkdownFormattedException):
         MarkdownFormattedException.__init__(
             self,
             f"""
-            Cannot serialize the return value (of type {get_return_value_type(return_value)}) in {get_cached_func_name_md(func)}.
-            `st.cache_data` uses [pickle](https://docs.python.org/3/library/pickle.html) to
-            serialize the function’s return value and safely store it in the cache without mutating the original object. Please convert the return value to a pickle-serializable type.
-            If you want to cache unserializable objects such as database connections or Tensorflow
-            sessions, use `st.cache_resource` instead (see [our docs]({CACHE_DOCS_URL}) for differences).""",
+            Cannot serialize the return value (of type {get_return_value_type(return_value)})
+            in {get_cached_func_name_md(func)}. `st.cache_data` uses
+            [pickle](https://docs.python.org/3/library/pickle.html) to serialize the
+            function's return value and safely store it in the cache
+            without mutating the original object. Please convert the return value to a
+            pickle-serializable type. If you want to cache unserializable objects such
+            as database connections or Tensorflow sessions, use `st.cache_resource`
+            instead (see [our docs]({CACHE_DOCS_URL}) for differences).""",
         )
 
 

streamlit/runtime/caching/cache_resource_api.py

@@ -37,13 +37,10 @@ from streamlit.runtime.caching.cache_utils import (
 from streamlit.runtime.caching.cached_message_replay import (
     CachedMessageReplayContext,
     CachedResult,
-    ElementMsgData,
     MsgData,
-    MultiCacheResults,
     show_widget_replay_deprecation,
 )
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.time_util import time_to_seconds
 
@@ -83,7 +80,6 @@ class ResourceCaches(CacheStatsProvider):
         max_entries: int | float | None,
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
-        allow_widgets: bool,
     ) -> ResourceCache:
         """Return the mem cache for the given key.
 
@@ -114,7 +110,6 @@ class ResourceCaches(CacheStatsProvider):
                 max_entries=max_entries,
                 ttl_seconds=ttl_seconds,
                 validate=validate,
-                allow_widgets=allow_widgets,
             )
             self._function_caches[key] = cache
             return cache
@@ -155,13 +150,11 @@ class CachedResourceFuncInfo(CachedFuncInfo):
         max_entries: int | None,
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None = None,
     ):
         super().__init__(
             func,
             show_spinner=show_spinner,
-            allow_widgets=allow_widgets,
             hash_funcs=hash_funcs,
         )
         self.max_entries = max_entries
@@ -188,7 +181,6 @@ class CachedResourceFuncInfo(CachedFuncInfo):
             max_entries=self.max_entries,
             ttl=self.ttl,
             validate=self.validate,
-            allow_widgets=self.allow_widgets,
         )
 
 
@@ -315,9 +307,11 @@ class CacheResourceAPI:
 
         experimental_allow_widgets : bool
             Allow widgets to be used in the cached function. Defaults to False.
-            Support for widgets in cached functions is currently experimental.
-            Setting this parameter to True may lead to excessive memory use since the
-            widget value is treated as an additional input parameter to the cache.
+
+            .. deprecated::
+                The cached widget replay functionality was removed in 1.38. Please
+                remove the ``experimental_allow_widgets`` parameter from your
+                caching decorators.
 
         hash_funcs : dict or None
             Mapping of types or fully qualified names to hash functions.
@@ -327,10 +321,6 @@ class CacheResourceAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
-        .. deprecated::
-            ``experimental_allow_widgets`` is deprecated and will be removed in
-            a later version.
-
         Example
         -------
         >>> import streamlit as st
@@ -426,7 +416,6 @@ class CacheResourceAPI:
                     max_entries=max_entries,
                     ttl=ttl,
                     validate=validate,
-                    allow_widgets=experimental_allow_widgets,
                     hash_funcs=hash_funcs,
                 )
             )
@@ -438,7 +427,6 @@ class CacheResourceAPI:
                 max_entries=max_entries,
                 ttl=ttl,
                 validate=validate,
-                allow_widgets=experimental_allow_widgets,
                 hash_funcs=hash_funcs,
             )
         )
@@ -459,17 +447,15 @@ class ResourceCache(Cache):
         ttl_seconds: float,
         validate: ValidateFunc | None,
         display_name: str,
-        allow_widgets: bool,
     ):
         super().__init__()
         self.key = key
         self.display_name = display_name
-        self._mem_cache: TTLCache[str, MultiCacheResults] = TTLCache(
+        self._mem_cache: TTLCache[str, CachedResult] = TTLCache(
             maxsize=max_entries, ttl=ttl_seconds, timer=cache_utils.TTLCACHE_TIMER
         )
         self._mem_cache_lock = threading.Lock()
         self.validate = validate
-        self.allow_widgets = allow_widgets
 
     @property
     def max_entries(self) -> float:
@@ -488,24 +474,11 @@ class ResourceCache(Cache):
                 # key does not exist in cache.
                 raise CacheKeyNotFoundError()
 
-            multi_results: MultiCacheResults = self._mem_cache[key]
-
-            ctx = get_script_run_ctx()
-            if not ctx:
-                # ScriptRunCtx does not exist (we're probably running in "raw" mode).
-                raise CacheKeyNotFoundError()
-
-            widget_key = multi_results.get_current_widget_key(ctx, CacheType.RESOURCE)
-            if widget_key not in multi_results.results:
-                # widget_key does not exist in cache (this combination of widgets hasn't been
-                # seen for the value_key yet).
-                raise CacheKeyNotFoundError()
-
-            result = multi_results.results[widget_key]
+            result = self._mem_cache[key]
 
             if self.validate is not None and not self.validate(result.value):
                 # Validate failed: delete the entry and raise an error.
-                del multi_results.results[widget_key]
+                del self._mem_cache[key]
                 raise CacheKeyNotFoundError()
 
             return result
@@ -513,33 +486,11 @@ class ResourceCache(Cache):
     @gather_metrics("_cache_resource_object")
     def write_result(self, key: str, value: Any, messages: list[MsgData]) -> None:
         """Write a value and associated messages to the cache."""
-        ctx = get_script_run_ctx()
-        if ctx is None:
-            return
-
         main_id = st._main.id
         sidebar_id = st.sidebar.id
-        if self.allow_widgets:
-            widgets = {
-                msg.widget_metadata.widget_id
-                for msg in messages
-                if isinstance(msg, ElementMsgData) and msg.widget_metadata is not None
-            }
-        else:
-            widgets = set()
 
         with self._mem_cache_lock:
-            try:
-                multi_results = self._mem_cache[key]
-            except KeyError:
-                multi_results = MultiCacheResults(widget_ids=widgets, results={})
-
-            multi_results.widget_ids.update(widgets)
-            widget_key = multi_results.get_current_widget_key(ctx, CacheType.RESOURCE)
-
-            result = CachedResult(value, messages, main_id, sidebar_id)
-            multi_results.results[widget_key] = result
-            self._mem_cache[key] = multi_results
+            self._mem_cache[key] = CachedResult(value, messages, main_id, sidebar_id)
 
     def _clear(self, key: str | None = None) -> None:
         with self._mem_cache_lock:

streamlit/runtime/caching/cache_utils.py

@@ -16,6 +16,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import functools
 import hashlib
 import inspect
@@ -125,12 +126,10 @@ class CachedFuncInfo:
         self,
         func: FunctionType,
         show_spinner: bool | str,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None,
     ):
         self.func = func
         self.show_spinner = show_spinner
-        self.allow_widgets = allow_widgets
         self.hash_funcs = hash_funcs
 
     @property
@@ -230,11 +229,9 @@ class CachedFunc:
             hash_funcs=self._info.hash_funcs,
         )
 
-        try:
+        with contextlib.suppress(CacheKeyNotFoundError):
             cached_result = cache.read_result(value_key)
             return self._handle_cache_hit(cached_result)
-        except CacheKeyNotFoundError:
-            pass
         return self._handle_cache_miss(cache, value_key, func_args, func_kwargs)
 
     def _handle_cache_hit(self, result: CachedResult) -> Any:
@@ -279,17 +276,14 @@ class CachedFunc:
             # We've acquired the lock - but another thread may have acquired it first
             # and already computed the value. So we need to test for a cache hit again,
             # before computing.
-            try:
+            with contextlib.suppress(CacheKeyNotFoundError):
                 cached_result = cache.read_result(value_key)
                 # Another thread computed the value before us. Early exit!
                 return self._handle_cache_hit(cached_result)
 
-            except CacheKeyNotFoundError:
-                pass
-
             # We acquired the lock before any other thread. Compute the value!
             with self._info.cached_message_replay_ctx.calling_cached_function(
-                self._info.func, self._info.allow_widgets
+                self._info.func
             ):
                 computed_value = self._info.func(*func_args, **func_kwargs)
 
@@ -329,8 +323,10 @@ class CachedFunc:
 
         Parameters
         ----------
+
         *args: Any
             Arguments of the cached functions.
+
         **kwargs: Any
             Keyword arguments of the cached function.
 
@@ -471,8 +467,7 @@ def _make_function_key(cache_type: CacheType, func: FunctionType) -> str:
         source_code, hasher=func_hasher, cache_type=cache_type, hash_source=func
     )
 
-    cache_key = func_hasher.hexdigest()
-    return cache_key
+    return func_hasher.hexdigest()
 
 
 def _get_positional_arg_name(func: FunctionType, arg_index: int) -> str | None:

streamlit/runtime/caching/cached_message_replay.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import contextlib
-import hashlib
 import threading
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Iterator, Literal, Union
@@ -24,12 +23,9 @@ import streamlit as st
 from streamlit import runtime, util
 from streamlit.deprecation_util import show_deprecation_warning
 from streamlit.runtime.caching.cache_errors import CacheReplayClosureError
-from streamlit.runtime.caching.hashing import update_hash
 from streamlit.runtime.scriptrunner_utils.script_run_context import (
-    ScriptRunContext,
-    get_script_run_ctx,
+    in_cached_function,
 )
-from streamlit.util import HASHLIB_KWARGS
 
 if TYPE_CHECKING:
     from types import FunctionType
@@ -39,18 +35,6 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
     from streamlit.proto.Block_pb2 import Block
     from streamlit.runtime.caching.cache_type import CacheType
-    from streamlit.runtime.state.common import WidgetMetadata
-
-
-@dataclass(frozen=True)
-class WidgetMsgMetadata:
-    """Everything needed for replaying a widget and treating it as an implicit
-    argument to a cached function, beyond what is stored for all elements.
-    """
-
-    widget_id: str
-    widget_value: Any
-    metadata: WidgetMetadata[Any]
 
 
 @dataclass(frozen=True)
@@ -65,7 +49,6 @@ class ElementMsgData:
     """An element's message and related metadata for
     replaying that element's function call.
 
-    widget_metadata is filled in if and only if this element is a widget.
     media_data is filled in iff this is a media element (image, audio, video).
     """
 
@@ -73,7 +56,6 @@ class ElementMsgData:
     message: Message
     id_of_dg_called_on: str
     returned_dgs_id: str
-    widget_metadata: WidgetMsgMetadata | None = None
     media_data: list[MediaMsgData] | None = None
 
 
@@ -86,62 +68,6 @@ class BlockMsgData:
 
 MsgData = Union[ElementMsgData, BlockMsgData]
 
-"""
-Note [Cache result structure]
-
-The cache for a decorated function's results is split into two parts to enable
-handling widgets invoked by the function.
-
-Widgets act as implicit additional inputs to the cached function, so they should
-be used when deriving the cache key. However, we don't know what widgets are
-involved without first calling the function! So, we use the first execution
-of the function with a particular cache key to record what widgets are used,
-and use the current values of those widgets to derive a second cache key to
-look up the function execution's results. The combination of first and second
-cache keys act as one true cache key, just split up because the second part depends
-on the first.
-
-We need to treat widgets as implicit arguments of the cached function, because
-the behavior of the function, including what elements are created and what it
-returns, can be and usually will be influenced by the values of those widgets.
-For example:
-> @st.cache_data
-> def example_fn(x):
->     y = x + 1
->     if st.checkbox("hi"):
->         st.write("you checked the thing")
->         y = 0
->     return y
->
-> example_fn(2)
-
-If the checkbox is checked, the function call should return 0 and the checkbox and
-message should be rendered. If the checkbox isn't checked, only the checkbox should
-render, and the function will return 3.
-
-
-There is a small catch in this. Since what widgets execute could depend on the values of
-any prior widgets, if we replace the `st.write` call in the example with a slider,
-the first time it runs, we would miss the slider because it wasn't called,
-so when we later execute the function with the checkbox checked, the widget cache key
-would not include the state of the slider, and would incorrectly get a cache hit
-for a different slider value.
-
-In principle the cache could be function+args key -> 1st widget key -> 2nd widget key
-... -> final widget key, with each widget dependent on the exact values of the widgets
-seen prior. This would prevent unnecessary cache misses due to differing values of widgets
-that wouldn't affect the function's execution because they aren't even created.
-But this would add even more complexity and both conceptual and runtime overhead, so it is
-unclear if it would be worth doing.
-
-Instead, we can keep the widgets as one cache key, and if we encounter a new widget
-while executing the function, we just update the list of widgets to include it.
-This will cause existing cached results to be invalidated, which is bad, but to
-avoid it we would need to keep around the full list of widgets and values for each
-widget cache key so we could compute the updated key, which is probably too expensive
-to be worth it.
-"""
-
 
 @dataclass
 class CachedResult:
@@ -155,32 +81,6 @@ class CachedResult:
     sidebar_id: str
 
 
-@dataclass
-class MultiCacheResults:
-    """Widgets called by a cache-decorated function, and a mapping of the
-    widget-derived cache key to the final results of executing the function.
-    """
-
-    widget_ids: set[str]
-    results: dict[str, CachedResult]
-
-    def get_current_widget_key(
-        self, ctx: ScriptRunContext, cache_type: CacheType
-    ) -> str:
-        state = ctx.session_state
-        # Compute the key using only widgets that have values. A missing widget
-        # can be ignored because we only care about getting different keys
-        # for different widget values, and for that purpose doing nothing
-        # to the running hash is just as good as including the widget with a
-        # sentinel value. But by excluding it, we might get to reuse a result
-        # saved before we knew about that widget.
-        widget_values = [
-            (wid, state[wid]) for wid in sorted(self.widget_ids) if wid in state
-        ]
-        widget_key = _make_widget_key(widget_values, cache_type)
-        return widget_key
-
-
 """
 Note [DeltaGenerator method invocation]
 There are two top level DG instances defined for all apps:
@@ -224,52 +124,37 @@ class CachedMessageReplayContext(threading.local):
         self._cached_message_stack: list[list[MsgData]] = []
         self._seen_dg_stack: list[set[str]] = []
         self._most_recent_messages: list[MsgData] = []
-        self._registered_metadata: WidgetMetadata[Any] | None = None
         self._media_data: list[MediaMsgData] = []
         self._cache_type = cache_type
-        self._allow_widgets: bool = False
 
     def __repr__(self) -> str:
         return util.repr_(self)
 
     @contextlib.contextmanager
-    def calling_cached_function(
-        self, func: FunctionType, allow_widgets: bool
-    ) -> Iterator[None]:
+    def calling_cached_function(self, func: FunctionType) -> Iterator[None]:
         """Context manager that should wrap the invocation of a cached function.
-        It allows us to track any `st.foo` messages that are generated from inside the function
-        for playback during cache retrieval.
+        It allows us to track any `st.foo` messages that are generated from inside the
+        function for playback during cache retrieval.
         """
         self._cached_message_stack.append([])
         self._seen_dg_stack.append(set())
-        self._allow_widgets = allow_widgets
-
         nested_call = False
-        ctx = get_script_run_ctx()
-        if ctx:
-            if ctx.disallow_cached_widget_usage:
-                # The disallow_cached_widget_usage is already set to true.
-                # This indicates that this cached function run is called from another
-                # cached function that disallows widget usage.
-                # We need to deactivate the widget usage for this cached function run
-                # even if it was allowed.
-                self._allow_widgets = False
-                nested_call = True
-
-            if not self._allow_widgets:
-                # If we're in a cached function that disallows widget usage, we need to set
-                # the disallow_cached_widget_usage to true for this cached function run
-                # to prevent widget usage (triggers a warning).
-                ctx.disallow_cached_widget_usage = True
+        if in_cached_function.get():
+            nested_call = True
+        # If we're in a cached function. To disallow usage of widget-like element,
+        # we need to set the in_cached_function to true for this cached function run
+        # to prevent widget usage (triggers a warning).
+        in_cached_function.set(True)
+
         try:
             yield
         finally:
             self._most_recent_messages = self._cached_message_stack.pop()
             self._seen_dg_stack.pop()
-            if ctx and not nested_call:
-                # Reset the disallow_cached_widget_usage flag. But only if this
+            if not nested_call:
+                # Reset the in_cached_function flag. But only if this
                 # is not nested inside a cached function that disallows widget usage.
-                ctx.disallow_cached_widget_usage = False
+                in_cached_function.set(False)
 
     def save_element_message(
         self,
@@ -288,23 +173,6 @@ class CachedMessageReplayContext(threading.local):
         if len(self._cached_message_stack) >= 1:
             id_to_save = self.select_dg_to_save(invoked_dg_id, used_dg_id)
 
-            # Widget replay is deprecated and will be removed soon:
-            # https://github.com/streamlit/streamlit/pull/8817.
-            # Therefore, its fine to keep this part a bit messy for now.
-
-            if (
-                hasattr(element_proto, "id")
-                and element_proto.id
-                and self._registered_metadata
-            ):
-                # The element has an ID and has associated widget metadata
-                # -> looks like a valid registered widget
-                widget_meta = WidgetMsgMetadata(
-                    element_proto.id, None, metadata=self._registered_metadata
-                )
-            else:
-                widget_meta = None
-
             media_data = self._media_data
 
             element_msg_data = ElementMsgData(
@@ -312,17 +180,14 @@ class CachedMessageReplayContext(threading.local):
                 element_proto,
                 id_to_save,
                 returned_dg_id,
-                widget_meta,
                 media_data,
             )
             for msgs in self._cached_message_stack:
-                if self._allow_widgets or widget_meta is None:
-                    msgs.append(element_msg_data)
+                msgs.append(element_msg_data)
 
         # Reset instance state, now that it has been used for the
         # associated element.
         self._media_data = []
-        self._registered_metadata = None
 
         for s in self._seen_dg_stack:
             s.add(returned_dg_id)
@@ -355,9 +220,6 @@ class CachedMessageReplayContext(threading.local):
         else:
             return invoked_id
 
-    def save_widget_metadata(self, metadata: WidgetMetadata[Any]) -> None:
-        self._registered_metadata = metadata
-
     def save_image_data(
         self, image_data: bytes | str, mimetype: str, image_id: str
     ) -> None:
@@ -384,24 +246,15 @@ def replay_cached_messages(
     call is on one of them.
     """
     from streamlit.delta_generator import DeltaGenerator
-    from streamlit.runtime.state.widgets import register_widget_from_metadata
 
     # Maps originally recorded dg ids to this script run's version of that dg
-    returned_dgs: dict[str, DeltaGenerator] = {}
-    returned_dgs[result.main_id] = st._main
-    returned_dgs[result.sidebar_id] = st.sidebar
-    ctx = get_script_run_ctx()
-
+    returned_dgs: dict[str, DeltaGenerator] = {
+        result.main_id: st._main,
+        result.sidebar_id: st.sidebar,
+    }
     try:
         for msg in result.messages:
             if isinstance(msg, ElementMsgData):
-                if msg.widget_metadata is not None:
-                    register_widget_from_metadata(
-                        msg.widget_metadata.metadata,
-                        ctx,
-                        None,
-                        msg.delta_type,
-                    )
                 if msg.media_data is not None:
                     for data in msg.media_data:
                         runtime.get_instance().media_file_mgr.add(
@@ -415,31 +268,22 @@ def replay_cached_messages(
                 dg = returned_dgs[msg.id_of_dg_called_on]
                 new_dg = dg._block(msg.message)
                 returned_dgs[msg.returned_dgs_id] = new_dg
-    except KeyError:
-        raise CacheReplayClosureError(cache_type, cached_func)
-
-
-def _make_widget_key(widgets: list[tuple[str, Any]], cache_type: CacheType) -> str:
-    """Generate a key for the given list of widgets used in a cache-decorated function.
-
-    Keys are generated by hashing the IDs and values of the widgets in the given list.
-    """
-    func_hasher = hashlib.new("md5", **HASHLIB_KWARGS)
-    for widget_id_val in widgets:
-        update_hash(widget_id_val, func_hasher, cache_type)
-
-    return func_hasher.hexdigest()
+    except KeyError as ex:
+        raise CacheReplayClosureError(cache_type, cached_func) from ex
 
 
 def show_widget_replay_deprecation(
     decorator: Literal["cache_data", "cache_resource"],
 ) -> None:
     show_deprecation_warning(
-        "The `experimental_allow_widgets` parameter is deprecated and will be removed "
+        "The cached widget replay feature was removed in 1.38. The "
+        "`experimental_allow_widgets` parameter will also be removed "
         "in a future release. Please remove the `experimental_allow_widgets` parameter "
         f"from the `@st.{decorator}` decorator and move all widget commands outside of "
-        "cached functions.\n\nTo speed up your app, we recommend moving your widgets into fragments. "
-        "Find out more about fragments in [our docs](https://docs.streamlit.io/develop/api-reference/execution-flow/st.fragment). "
-        "\n\nIf you have a specific use-case that requires the `experimental_allow_widgets` functionality, "
-        "please tell us via an [issue on Github](https://github.com/streamlit/streamlit/issues)."
+        "cached functions.\n\nTo speed up your app, we recommend moving your widgets "
+        "into fragments. Find out more about fragments in "
+        "[our docs](https://docs.streamlit.io/develop/api-reference/execution-flow/st.fragment). "
+        "\n\nIf you have a specific use-case that requires the "
+        "`experimental_allow_widgets` functionality, please tell us via an "
+        "[issue on Github](https://github.com/streamlit/streamlit/issues)."
     )