streamlit-nightly 1.32.3.dev20240326__py2.py3-none-any.whl → 1.32.3.dev20240329__py2.py3-none-any.whl

streamlit/runtime/app_session.py

@@ -38,6 +38,7 @@ from streamlit.proto.NewSession_pb2 import (
 from streamlit.proto.PagesChanged_pb2 import PagesChanged
 from streamlit.runtime import caching, legacy_caching
 from streamlit.runtime.forward_msg_queue import ForwardMsgQueue
+from streamlit.runtime.fragment import FragmentStorage, MemoryFragmentStorage
 from streamlit.runtime.metrics_util import Installation
 from streamlit.runtime.script_data import ScriptData
 from streamlit.runtime.scriptrunner import RerunData, ScriptRunner, ScriptRunnerEvent
@@ -161,6 +162,8 @@ class AppSession:
 
         self._debug_last_backmsg_id: str | None = None
 
+        self._fragment_storage: FragmentStorage = MemoryFragmentStorage()
+
         _LOGGER.debug("AppSession initialized (id=%s)", self.id)
 
     def __del__(self) -> None:
@@ -353,26 +356,33 @@ class AppSession:
             return
 
         if client_state:
+            fragment_id = client_state.fragment_id
+
             rerun_data = RerunData(
                 client_state.query_string,
                 client_state.widget_states,
                 client_state.page_script_hash,
                 client_state.page_name,
+                fragment_id_queue=[fragment_id] if fragment_id else [],
             )
         else:
             rerun_data = RerunData()
 
         if self._scriptrunner is not None:
-            if bool(config.get_option("runner.fastReruns")):
-                # If fastReruns is enabled, we don't send rerun requests to our
-                # existing ScriptRunner. Instead, we tell it to shut down. We'll
-                # then spin up a new ScriptRunner, below, to handle the rerun
-                # immediately.
+            if (
+                bool(config.get_option("runner.fastReruns"))
+                and not rerun_data.fragment_id_queue
+            ):
+                # If fastReruns is enabled and this is *not* a rerun of a fragment,
+                # we don't send rerun requests to our existing ScriptRunner. Instead, we
+                # tell it to shut down. We'll then spin up a new ScriptRunner, below, to
+                # handle the rerun immediately.
                 self._scriptrunner.request_stop()
                 self._scriptrunner = None
             else:
-                # fastReruns is not enabled. Send our ScriptRunner a rerun
-                # request. If the request is accepted, we're done.
+                # Either fastReruns is not enabled or this RERUN request is a request to
+                # run a fragment. We send our current ScriptRunner a rerun request, and
+                # if it's accepted, we're done.
                 success = self._scriptrunner.request_rerun(rerun_data)
                 if success:
                     return
@@ -400,6 +410,7 @@ class AppSession:
             script_cache=self._script_cache,
             initial_rerun_data=initial_rerun_data,
             user_info=self._user_info,
+            fragment_storage=self._fragment_storage,
         )
         self._scriptrunner.on_event.connect(self._on_scriptrunner_event)
         self._scriptrunner.start()
@@ -464,6 +475,7 @@ class AppSession:
         exception: BaseException | None = None,
         client_state: ClientState | None = None,
         page_script_hash: str | None = None,
+        fragment_ids_this_run: set[str] | None = None,
     ) -> None:
         """Called when our ScriptRunner emits an event.
 
@@ -473,7 +485,13 @@ class AppSession:
         """
         self._event_loop.call_soon_threadsafe(
             lambda: self._handle_scriptrunner_event_on_event_loop(
-                sender, event, forward_msg, exception, client_state, page_script_hash
+                sender,
+                event,
+                forward_msg,
+                exception,
+                client_state,
+                page_script_hash,
+                fragment_ids_this_run,
             )
         )
 
@@ -485,6 +503,7 @@ class AppSession:
         exception: BaseException | None = None,
         client_state: ClientState | None = None,
         page_script_hash: str | None = None,
+        fragment_ids_this_run: set[str] | None = None,
     ) -> None:
         """Handle a ScriptRunner event.
 
@@ -515,6 +534,11 @@ class AppSession:
         page_script_hash : str | None
             A hash of the script path corresponding to the page currently being
             run. Set only for the SCRIPT_STARTED event.
+
+        fragment_ids_this_run : set[str] | None
+            The fragment IDs of the fragments being executed in this script run. Only
+            set for the SCRIPT_STARTED event. If this value is falsy, this script run
+            must be for the full script.
         """
 
         assert (
@@ -540,30 +564,43 @@ class AppSession:
                 page_script_hash is not None
             ), "page_script_hash must be set for the SCRIPT_STARTED event"
 
-            self._clear_queue()
+            # When running the full script, we clear the browser ForwardMsg queue since
+            # anything from a previous script run that has yet to be sent to the browser
+            # will be overwritten. For fragment runs, however, we don't want to do this
+            # as the ForwardMsgs in the queue may not correspond to the running
+            # fragment, so dropping the messages may result in the app missing
+            # information.
+            if not fragment_ids_this_run:
+                self._clear_queue()
+
             self._enqueue_forward_msg(
-                self._create_new_session_message(page_script_hash)
+                self._create_new_session_message(
+                    page_script_hash, fragment_ids_this_run
+                )
             )
 
         elif (
             event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
             or event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_COMPILE_ERROR
+            or event == ScriptRunnerEvent.FRAGMENT_STOPPED_WITH_SUCCESS
         ):
             if self._state != AppSessionState.SHUTDOWN_REQUESTED:
                 self._state = AppSessionState.APP_NOT_RUNNING
 
-            script_succeeded = event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
-
-            script_finished_msg = self._create_script_finished_message(
-                ForwardMsg.FINISHED_SUCCESSFULLY
-                if script_succeeded
-                else ForwardMsg.FINISHED_WITH_COMPILE_ERROR
-            )
-            self._enqueue_forward_msg(script_finished_msg)
+            if event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS:
+                status = ForwardMsg.FINISHED_SUCCESSFULLY
+            elif event == ScriptRunnerEvent.FRAGMENT_STOPPED_WITH_SUCCESS:
+                status = ForwardMsg.FINISHED_FRAGMENT_RUN_SUCCESSFULLY
+            else:
+                status = ForwardMsg.FINISHED_WITH_COMPILE_ERROR
 
+            self._enqueue_forward_msg(self._create_script_finished_message(status))
             self._debug_last_backmsg_id = None
 
-            if script_succeeded:
+            if (
+                event == ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
+                or event == ScriptRunnerEvent.FRAGMENT_STOPPED_WITH_SUCCESS
+            ):
                 # The script completed successfully: update our
                 # LocalSourcesWatcher to account for any source code changes
                 # that change which modules should be watched.
@@ -582,11 +619,12 @@ class AppSession:
                 self._enqueue_forward_msg(msg)
 
         elif event == ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN:
-            script_finished_msg = self._create_script_finished_message(
-                ForwardMsg.FINISHED_EARLY_FOR_RERUN
-            )
             self._state = AppSessionState.APP_NOT_RUNNING
-            self._enqueue_forward_msg(script_finished_msg)
+            self._enqueue_forward_msg(
+                self._create_script_finished_message(
+                    ForwardMsg.FINISHED_EARLY_FOR_RERUN
+                )
+            )
             if self._local_sources_watcher:
                 self._local_sources_watcher.update_watched_modules()
 
@@ -630,7 +668,9 @@ class AppSession:
         msg.session_event.script_changed_on_disk = True
         return msg
 
-    def _create_new_session_message(self, page_script_hash: str) -> ForwardMsg:
+    def _create_new_session_message(
+        self, page_script_hash: str, fragment_ids_this_run: set[str] | None = None
+    ) -> ForwardMsg:
         """Create and return a new_session ForwardMsg."""
         msg = ForwardMsg()
 
@@ -639,6 +679,9 @@ class AppSession:
         msg.new_session.main_script_path = self._script_data.main_script_path
         msg.new_session.page_script_hash = page_script_hash
 
+        if fragment_ids_this_run:
+            msg.new_session.fragment_ids_this_run.extend(fragment_ids_this_run)
+
         _populate_app_pages(msg.new_session, self._script_data.main_script_path)
         _populate_config_msg(msg.new_session.config)
         _populate_theme_msg(msg.new_session.custom_theme)

streamlit/runtime/caching/cache_data_api.py

@@ -58,9 +58,9 @@ from streamlit.runtime.caching.storage.dummy_cache_storage import (
     MemoryCacheStorageManager,
 )
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.runtime_util import duration_to_seconds
 from streamlit.runtime.scriptrunner.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
 
 _LOGGER: Final = get_logger(__name__)
 
@@ -154,7 +154,7 @@ class DataCaches(CacheStatsProvider):
         If it doesn't exist, create a new one with the given params.
         """
 
-        ttl_seconds = duration_to_seconds(ttl, coerce_none_to_inf=False)
+        ttl_seconds = time_to_seconds(ttl, coerce_none_to_inf=False)
 
         # Get the existing cache, if it exists, and validate that its params
         # haven't changed.
@@ -254,7 +254,7 @@ class DataCaches(CacheStatsProvider):
             CacheStorageContext.
         """
 
-        ttl_seconds = duration_to_seconds(ttl, coerce_none_to_inf=False)
+        ttl_seconds = time_to_seconds(ttl, coerce_none_to_inf=False)
 
         cache_context = self.create_cache_storage_context(
             function_key="DUMMY_KEY",

streamlit/runtime/caching/cache_resource_api.py

@@ -45,9 +45,9 @@ from streamlit.runtime.caching.cached_message_replay import (
 )
 from streamlit.runtime.caching.hashing import HashFuncsDict
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.runtime_util import duration_to_seconds
 from streamlit.runtime.scriptrunner.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
 
 _LOGGER: Final = get_logger(__name__)
 
@@ -89,7 +89,7 @@ class ResourceCaches(CacheStatsProvider):
         if max_entries is None:
             max_entries = math.inf
 
-        ttl_seconds = duration_to_seconds(ttl)
+        ttl_seconds = time_to_seconds(ttl)
 
         # Get the existing cache, if it exists, and validate that its params
         # haven't changed.

streamlit/runtime/fragment.py

@@ -0,0 +1,239 @@
+# 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.
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import inspect
+from abc import abstractmethod
+from copy import deepcopy
+from datetime import timedelta
+from functools import wraps
+from typing import Any, Callable, Protocol, TypeVar, overload
+
+from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner import get_script_run_ctx
+from streamlit.time_util import time_to_seconds
+
+F = TypeVar("F", bound=Callable[..., Any])
+Fragment = Callable[[], Any]
+
+
+class FragmentStorage(Protocol):
+    """A key-value store for Fragments. Used to implement the @st.experimental_fragment
+    decorator.
+
+    We intentionally define this as its own protocol despite how generic it appears to
+    be at first glance. The reason why is that, in any case where fragments aren't just
+    stored as Python closures in memory, storing and retrieving Fragments will generally
+    involve serializing and deserializing function bytecode, which is a tricky aspect
+    to implementing FragmentStorages that won't generally appear with our other *Storage
+    protocols.
+    """
+
+    @abstractmethod
+    def get(self, key: str) -> Fragment:
+        """Returns the stored fragment for the given key."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def set(self, key: str, value: Fragment) -> None:
+        """Saves a fragment under the given key."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self, key: str) -> None:
+        """Delete the fragment corresponding to the given key."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def clear(self) -> None:
+        """Remove all fragments saved in this FragmentStorage."""
+        raise NotImplementedError
+
+
+# NOTE: Ideally, we'd like to add a MemoryFragmentStorageStatProvider implementation to
+# keep track of memory usage due to fragments, but doing something like this ends up
+# being difficult in practice as the memory usage of a closure is hard to measure (the
+# vendored implementation of pympler.asizeof that we use elsewhere is unable to measure
+# the size of a function).
+class MemoryFragmentStorage(FragmentStorage):
+    """A simple, memory-backed implementation of FragmentStorage.
+
+    MemoryFragmentStorage is just a wrapper around a plain Python dict that complies with
+    the FragmentStorage protocol.
+    """
+
+    def __init__(self):
+        self._fragments: dict[str, Fragment] = {}
+
+    def get(self, key: str) -> Fragment:
+        return self._fragments[key]
+
+    def set(self, key: str, value: Fragment) -> None:
+        self._fragments[key] = value
+
+    def delete(self, key: str) -> None:
+        del self._fragments[key]
+
+    def clear(self) -> None:
+        self._fragments.clear()
+
+
+@overload
+def fragment(
+    func: F,
+    *,
+    run_every: int | float | timedelta | str | None = None,
+) -> F:
+    ...
+
+
+# Support being able to pass parameters to this decorator (that is, being able to write
+# `@fragment(run_every=5.0)`).
+@overload
+def fragment(
+    func: None = None,
+    *,
+    run_every: int | float | timedelta | str | None = None,
+) -> Callable[[F], F]:
+    ...
+
+
+@gather_metrics("experimental_fragment")
+def fragment(
+    func: F | None = None,
+    *,
+    run_every: int | float | timedelta | str | None = None,
+) -> Callable[[F], F] | F:
+    """Allow a function to be run independently of the full script.
+
+    Functions decorated with ``@st.experimental_fragment`` are handled specially within
+    an app: when a widget created within an invocation of the function (a fragment) is
+    interacted with, then only that fragment is rerun rather than the full streamlit app.
+
+    Parameters
+    ----------
+    run_every: int, float, timedelta, str, or None
+        If set, fragments created from this function rerun periodically at the specified
+        time interval.
+
+    Example
+    -------
+    The following example demonstrates basic usage of ``@st.experimental_fragment``. In
+    this app, clicking on the "rerun full script" button will increment both counters,
+    but the "rerun fragment" button will only increment the counter within the fragment.
+
+    ```python3
+    import streamlit as st
+
+    if "script_runs" not in st.session_state:
+        st.session_state.script_runs = 0
+        st.session_state.fragment_runs = 0
+
+    @st.experimental_fragment
+    def fragment():
+        st.button("rerun fragment")
+        st.write(f"fragment runs: {st.session_state.fragment_runs}")
+        st.session_state.fragment_runs += 1
+
+    fragment()
+
+    st.button("rerun full script")
+    st.write(f"full script runs: {st.session_state.script_runs}")
+    st.session_state.script_runs += 1
+    ```
+    """
+
+    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

streamlit/runtime/metrics_util.py

@@ -427,12 +427,17 @@ def create_page_profile_message(
     uncaught_exception: str | None = None,
 ) -> ForwardMsg:
     """Create and return the full PageProfile ForwardMsg."""
+    # Local import to prevent circular dependencies
+    from streamlit.runtime.scriptrunner import get_script_run_ctx
+
     msg = ForwardMsg()
-    msg.page_profile.commands.extend(commands)
-    msg.page_profile.exec_time = exec_time
-    msg.page_profile.prep_time = prep_time
+    page_profile = msg.page_profile
+
+    page_profile.commands.extend(commands)
+    page_profile.exec_time = exec_time
+    page_profile.prep_time = prep_time
 
-    msg.page_profile.headless = config.get_option("server.headless")
+    page_profile.headless = config.get_option("server.headless")
 
     # Collect all config options that have been manually set
     config_options: set[str] = set()
@@ -447,7 +452,7 @@ def create_page_profile_message(
                 option_name = f"{option_name}:default"
             config_options.add(option_name)
 
-    msg.page_profile.config.extend(config_options)
+    page_profile.config.extend(config_options)
 
     # Check the predefined set of modules for attribution
     attributions: set[str] = {
@@ -456,11 +461,14 @@ def create_page_profile_message(
         if attribution in sys.modules
     }
 
-    msg.page_profile.os = str(sys.platform)
-    msg.page_profile.timezone = str(time.tzname)
-    msg.page_profile.attributions.extend(attributions)
+    page_profile.os = str(sys.platform)
+    page_profile.timezone = str(time.tzname)
+    page_profile.attributions.extend(attributions)
 
     if uncaught_exception:
-        msg.page_profile.uncaught_exception = uncaught_exception
+        page_profile.uncaught_exception = uncaught_exception
+
+    if ctx := get_script_run_ctx():
+        page_profile.is_fragment_run = bool(ctx.current_fragment_id)
 
     return msg

streamlit/runtime/runtime.py

@@ -22,8 +22,6 @@ from enum import Enum
 from typing import TYPE_CHECKING, Awaitable, Final, NamedTuple
 
 from streamlit import config
-from streamlit.components.lib.local_component_registry import LocalComponentRegistry
-from streamlit.components.types.base_component_registry import BaseComponentRegistry
 from streamlit.logger import get_logger
 from streamlit.proto.BackMsg_pb2 import BackMsg
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
@@ -98,11 +96,6 @@ class RuntimeConfig:
         default_factory=LocalDiskCacheStorageManager
     )
 
-    # The ComponentRegistry instance to use.
-    component_registry: BaseComponentRegistry = field(
-        default_factory=LocalComponentRegistry
-    )
-
     # The SessionManager class to be used.
     session_manager_class: type[SessionManager] = WebsocketSessionManager
 
@@ -112,6 +105,12 @@ class RuntimeConfig:
     # True if the command used to start Streamlit was `streamlit hello`.
     is_hello: bool = False
 
+    # TODO(vdonato): Eventually add a new fragment_storage_class field enabling the code
+    # creating a new Streamlit Runtime to configure the FragmentStorage instances
+    # created by each new AppSession. We choose not to do this for now to avoid adding
+    # additional complexity to RuntimeConfig/SessionManager/etc when it's unlikely
+    # we'll have a custom implementation of this class anytime soon.
+
 
 class RuntimeState(Enum):
     INITIAL = "INITIAL"
@@ -196,7 +195,6 @@ class Runtime:
         self._state = RuntimeState.INITIAL
 
         # 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)
@@ -222,10 +220,6 @@ class Runtime:
     def state(self) -> RuntimeState:
         return self._state
 
-    @property
-    def component_registry(self) -> BaseComponentRegistry:
-        return self._component_registry
-
     @property
     def message_cache(self) -> ForwardMsgCache:
         return self._message_cache