streamlit-nightly 1.34.1.dev20240522__py2.py3-none-any.whl → 1.35.1.dev20240524__py2.py3-none-any.whl

streamlit/runtime/caching/__init__.py

@@ -30,6 +30,7 @@ from streamlit.runtime.caching.cache_resource_api import (
     CacheResourceAPI,
     _resource_caches,
 )
+from streamlit.runtime.caching.legacy_cache_api import cache as _cache
 from streamlit.runtime.state.common import WidgetMetadata
 
 
@@ -92,6 +93,9 @@ from streamlit.runtime.caching.cache_resource_api import (
 # Create and export public API singletons.
 cache_data = CacheDataAPI(decorator_metric_name="cache_data")
 cache_resource = CacheResourceAPI(decorator_metric_name="cache_resource")
+# TODO(lukasmasuch): This is the legacy cache API name which is deprecated
+# and it should be removed in the future.
+cache = _cache
 
 # Deprecated singletons
 _MEMO_WARNING = (
@@ -115,6 +119,7 @@ experimental_singleton = CacheResourceAPI(
 
 
 __all__ = [
+    "cache",
     "CACHE_DOCS_URL",
     "save_element_message",
     "save_block_message",

streamlit/runtime/caching/legacy_cache_api.py

@@ -0,0 +1,164 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+#
+# 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.
+
+"""A library of caching utilities."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, TypeVar
+
+from streamlit import deprecation_util
+from streamlit.runtime.caching import CACHE_DOCS_URL
+from streamlit.runtime.metrics_util import gather_metrics
+
+if TYPE_CHECKING:
+    from streamlit.runtime.caching.hashing import HashFuncsDict
+
+# Type-annotate the decorator function.
+# (See https://mypy.readthedocs.io/en/stable/generics.html#decorator-factories)
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+@gather_metrics("cache")
+def cache(
+    func: F | None = None,
+    persist: bool = False,
+    allow_output_mutation: bool = False,
+    show_spinner: bool = True,
+    suppress_st_warning: bool = False,
+    hash_funcs: HashFuncsDict | None = None,
+    max_entries: int | None = None,
+    ttl: float | None = None,
+):
+    """Function decorator to memoize function executions.
+
+    Parameters
+    ----------
+    func : callable
+        The function to cache. Streamlit hashes the function and dependent code.
+
+    persist : bool
+        Whether to persist the cache on disk.
+
+    allow_output_mutation : bool
+        Streamlit shows a warning when return values are mutated, as that
+        can have unintended consequences. This is done by hashing the return value internally.
+
+        If you know what you're doing and would like to override this warning, set this to True.
+
+    show_spinner : bool
+        Enable the spinner. Default is True to show a spinner when there is
+        a cache miss.
+
+    suppress_st_warning : bool
+        Suppress warnings about calling Streamlit commands from within
+        the cached function.
+
+    hash_funcs : dict or None
+        Mapping of types or fully qualified names to hash functions. This is used to override
+        the behavior of the hasher inside Streamlit's caching mechanism: when the hasher
+        encounters an object, it will first check to see if its type matches a key in this
+        dict and, if so, will use the provided function to generate a hash for it. See below
+        for an example of how this can be used.
+
+    max_entries : int or None
+        The maximum number of entries to keep in the cache, or None
+        for an unbounded cache. (When a new entry is added to a full cache,
+        the oldest cached entry will be removed.) The default is None.
+
+    ttl : float or None
+        The maximum number of seconds to keep an entry in the cache, or
+        None if cache entries should not expire. The default is None.
+
+    Example
+    -------
+    >>> import streamlit as st
+    >>>
+    >>> @st.cache
+    ... def fetch_and_clean_data(url):
+    ...     # Fetch data from URL here, and then clean it up.
+    ...     return data
+    ...
+    >>> d1 = fetch_and_clean_data(DATA_URL_1)
+    >>> # Actually executes the function, since this is the first time it was
+    >>> # encountered.
+    >>>
+    >>> d2 = fetch_and_clean_data(DATA_URL_1)
+    >>> # Does not execute the function. Instead, returns its previously computed
+    >>> # value. This means that now the data in d1 is the same as in d2.
+    >>>
+    >>> d3 = fetch_and_clean_data(DATA_URL_2)
+    >>> # This is a different URL, so the function executes.
+
+    To set the ``persist`` parameter, use this command as follows:
+
+    >>> @st.cache(persist=True)
+    ... def fetch_and_clean_data(url):
+    ...     # Fetch data from URL here, and then clean it up.
+    ...     return data
+
+    To disable hashing return values, set the ``allow_output_mutation`` parameter to ``True``:
+
+    >>> @st.cache(allow_output_mutation=True)
+    ... def fetch_and_clean_data(url):
+    ...     # Fetch data from URL here, and then clean it up.
+    ...     return data
+
+
+    To override the default hashing behavior, pass a custom hash function.
+    You can do that by mapping a type (e.g. ``MongoClient``) to a hash function (``id``) like this:
+
+    >>> @st.cache(hash_funcs={MongoClient: id})
+    ... def connect_to_database(url):
+    ...     return MongoClient(url)
+
+    Alternatively, you can map the type's fully-qualified name
+    (e.g. ``"pymongo.mongo_client.MongoClient"``) to the hash function instead:
+
+    >>> @st.cache(hash_funcs={"pymongo.mongo_client.MongoClient": id})
+    ... def connect_to_database(url):
+    ...     return MongoClient(url)
+
+    """
+    import streamlit as st
+
+    deprecation_util.show_deprecation_warning(
+        f"""
+`st.cache` is deprecated and will be removed soon. Please use one of Streamlit's new caching commands, `st.cache_data` or `st.cache_resource`.
+More information [in our docs]({CACHE_DOCS_URL}).
+
+**Note**: The behavior of `st.cache` was updated in Streamlit 1.36 to the new caching logic used by `st.cache_data` and `st.cache_resource`.
+This might lead to some problems or unexpected behavior in certain edge cases.
+"""
+    )
+
+    # suppress_st_warning is unused since its not supported by the new caching commands
+
+    if allow_output_mutation:
+        return st.cache_resource(  # type: ignore
+            func,
+            show_spinner=show_spinner,
+            hash_funcs=hash_funcs,
+            max_entries=max_entries,
+            ttl=ttl,
+        )
+
+    return st.cache_data(  # type: ignore
+        func,
+        persist=persist,
+        show_spinner=show_spinner,
+        hash_funcs=hash_funcs,
+        max_entries=max_entries,
+        ttl=ttl,
+    )

streamlit/runtime/fragment.py

@@ -93,6 +93,96 @@ class MemoryFragmentStorage(FragmentStorage):
         self._fragments.clear()
 
 
+def _fragment(
+    func: F | None = None, *, run_every: int | float | timedelta | str | None = None
+) -> Callable[[F], F] | F:
+    """Contains the actual fragment logic.
+
+    This function should be used by our internal functions that use fragments under-the-hood,
+    so that fragment metrics are not tracked for those elements (note that the @gather_metrics annotation is only on the publicly exposed function)
+    """
+
+    if func is None:
+        # Support passing the params via function decorator
+        def wrapper(f: F) -> F:
+            return fragment(
+                func=f,
+                run_every=run_every,
+            )
+
+        return wrapper
+    else:
+        non_optional_func = func
+
+    @wraps(non_optional_func)
+    def wrap(*args, **kwargs):
+        from streamlit.delta_generator import dg_stack
+
+        ctx = get_script_run_ctx()
+        if ctx is None:
+            return
+
+        cursors_snapshot = deepcopy(ctx.cursors)
+        dg_stack_snapshot = deepcopy(dg_stack.get())
+        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"
+            )
+        )
+        fragment_id = h.hexdigest()
+
+        def wrapped_fragment():
+            import streamlit as st
+
+            # NOTE: We need to call get_script_run_ctx here again and can't just use the
+            # value of ctx from above captured by the closure because subsequent
+            # 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.fragment_ids_this_run:
+                # This script run is a run of one or more fragments. We restore the
+                # state of ctx.cursors and dg_stack to the snapshots we took when this
+                # fragment was declared.
+                ctx.cursors = deepcopy(cursors_snapshot)
+                dg_stack.set(deepcopy(dg_stack_snapshot))
+            else:
+                # Otherwise, we must be in a full script run. We need to temporarily set
+                # ctx.current_fragment_id so that elements corresponding to this
+                # fragment get tagged with the appropriate ID. ctx.current_fragment_id
+                # gets reset after the fragment function finishes running.
+                ctx.current_fragment_id = fragment_id
+
+            try:
+                with st.container():
+                    result = non_optional_func(*args, **kwargs)
+            finally:
+                ctx.current_fragment_id = None
+
+            return result
+
+        ctx.fragment_storage.set(fragment_id, wrapped_fragment)
+
+        if run_every:
+            msg = ForwardMsg()
+            msg.auto_rerun.interval = time_to_seconds(run_every)
+            msg.auto_rerun.fragment_id = fragment_id
+            ctx.enqueue(msg)
+
+        return wrapped_fragment()
+
+    with contextlib.suppress(AttributeError):
+        # Make this a well-behaved decorator by preserving important function
+        # attributes.
+        wrap.__dict__.update(non_optional_func.__dict__)
+        wrap.__signature__ = inspect.signature(non_optional_func)  # type: ignore
+
+    return wrap
+
+
 @overload
 def fragment(
     func: F,
@@ -228,83 +318,4 @@ def fragment(
         height: 400px
 
     """
-
-    if func is None:
-        # Support passing the params via function decorator
-        def wrapper(f: F) -> F:
-            return fragment(
-                func=f,
-                run_every=run_every,
-            )
-
-        return wrapper
-    else:
-        non_optional_func = func
-
-    @wraps(non_optional_func)
-    def wrap(*args, **kwargs):
-        from streamlit.delta_generator import dg_stack
-
-        ctx = get_script_run_ctx()
-        if ctx is None:
-            return
-
-        cursors_snapshot = deepcopy(ctx.cursors)
-        dg_stack_snapshot = deepcopy(dg_stack.get())
-        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"
-            )
-        )
-        fragment_id = h.hexdigest()
-
-        def wrapped_fragment():
-            import streamlit as st
-
-            # NOTE: We need to call get_script_run_ctx here again and can't just use the
-            # value of ctx from above captured by the closure because subsequent
-            # 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.fragment_ids_this_run:
-                # This script run is a run of one or more fragments. We restore the
-                # state of ctx.cursors and dg_stack to the snapshots we took when this
-                # fragment was declared.
-                ctx.cursors = deepcopy(cursors_snapshot)
-                dg_stack.set(deepcopy(dg_stack_snapshot))
-            else:
-                # Otherwise, we must be in a full script run. We need to temporarily set
-                # ctx.current_fragment_id so that elements corresponding to this
-                # fragment get tagged with the appropriate ID. ctx.current_fragment_id
-                # gets reset after the fragment function finishes running.
-                ctx.current_fragment_id = fragment_id
-
-            try:
-                with st.container():
-                    result = non_optional_func(*args, **kwargs)
-            finally:
-                ctx.current_fragment_id = None
-
-            return result
-
-        ctx.fragment_storage.set(fragment_id, wrapped_fragment)
-
-        if run_every:
-            msg = ForwardMsg()
-            msg.auto_rerun.interval = time_to_seconds(run_every)
-            msg.auto_rerun.fragment_id = fragment_id
-            ctx.enqueue(msg)
-
-        return wrapped_fragment()
-
-    with contextlib.suppress(AttributeError):
-        # Make this a well-behaved decorator by preserving important function
-        # attributes.
-        wrap.__dict__.update(non_optional_func.__dict__)
-        wrap.__signature__ = inspect.signature(non_optional_func)  # type: ignore
-
-    return wrap
+    return _fragment(func, run_every=run_every)

streamlit/runtime/runtime.py

@@ -40,7 +40,6 @@ from streamlit.runtime.forward_msg_cache import (
     create_reference_msg,
     populate_hash_if_needed,
 )
-from streamlit.runtime.legacy_caching.caching import _mem_caches
 from streamlit.runtime.media_file_manager import MediaFileManager
 from streamlit.runtime.media_file_storage import MediaFileStorage
 from streamlit.runtime.memory_session_storage import MemorySessionStorage
@@ -218,7 +217,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(_mem_caches)
         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))

streamlit/static/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.3aaaea00.css",
-    "main.js": "./static/js/main.7e42f54d.js",
+    "main.js": "./static/js/main.e93f99a3.js",
     "static/js/9336.3e046ad7.chunk.js": "./static/js/9336.3e046ad7.chunk.js",
     "static/js/9330.2b4c99e0.chunk.js": "./static/js/9330.2b4c99e0.chunk.js",
     "static/js/2736.4336e2b9.chunk.js": "./static/js/2736.4336e2b9.chunk.js",
@@ -151,6 +151,6 @@
   },
   "entrypoints": [
     "static/css/main.3aaaea00.css",
-    "static/js/main.7e42f54d.js"
+    "static/js/main.e93f99a3.js"
   ]
 }

streamlit/static/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no"/><link rel="shortcut icon" href="./favicon.png"/><link rel="preload" href="./static/media/SourceSansPro-Regular.0d69e5ff5e92ac64a0c9.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-SemiBold.abed79cd0df1827e18cf.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-Bold.118dea98980e20a81ced.woff2" as="font" type="font/woff2" crossorigin><title>Streamlit</title><script>window.prerenderReady=!1</script><script defer="defer" src="./static/js/main.7e42f54d.js"></script><link href="./static/css/main.3aaaea00.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no"/><link rel="shortcut icon" href="./favicon.png"/><link rel="preload" href="./static/media/SourceSansPro-Regular.0d69e5ff5e92ac64a0c9.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-SemiBold.abed79cd0df1827e18cf.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-Bold.118dea98980e20a81ced.woff2" as="font" type="font/woff2" crossorigin><title>Streamlit</title><script>window.prerenderReady=!1</script><script defer="defer" src="./static/js/main.e93f99a3.js"></script><link href="./static/css/main.3aaaea00.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>