streamlit-nightly 1.36.1.dev20240713__py2.py3-none-any.whl → 1.36.1.dev20240715__py2.py3-none-any.whl

streamlit/__init__.py

@@ -72,7 +72,10 @@ from streamlit.delta_generator import (
     bottom_dg as _bottom_dg,
 )
 
-from streamlit.elements.dialog_decorator import dialog_decorator as _dialog_decorator
+from streamlit.elements.dialog_decorator import (
+    dialog_decorator as _dialog_decorator,
+    experimental_dialog_decorator as _experimental_dialog_decorator,
+)
 from streamlit.runtime.caching import (
     cache_resource as _cache_resource,
     cache_data as _cache_data,
@@ -81,9 +84,13 @@ from streamlit.runtime.caching import (
 from streamlit.runtime.connection_factory import (
     connection_factory as _connection,
 )
-from streamlit.runtime.fragment import fragment as _fragment
+from streamlit.runtime.fragment import (
+    experimental_fragment as _experimental_fragment,
+    fragment as _fragment,
+)
 from streamlit.runtime.metrics_util import gather_metrics as _gather_metrics
 from streamlit.runtime.secrets import secrets_singleton as _secrets_singleton
+from streamlit.runtime.context import ContextProxy as _ContextProxy
 from streamlit.runtime.state import (
     SessionStateProxy as _SessionStateProxy,
     QueryParamsProxy as _QueryParamsProxy,
@@ -96,7 +103,6 @@ from streamlit.commands.experimental_query_params import (
 
 import streamlit.column_config as _column_config
 
-
 # Modules that the user should have access to. These are imported with the "as" syntax and the same name; note that renaming the import with "as" does not make it an explicit export.
 # In this case, you should import it with an underscore to make clear that it is internal and then assign it to a variable with the new intended name.
 # You can check the export behavior by running 'mypy --strict example_app.py', which disables implicit_reexport, where you use the respective command in the example_app.py Streamlit app.
@@ -126,7 +132,6 @@ def _update_logger() -> None:
 # in an alternative config.
 _config.on_config_parsed(_update_logger, True)
 
-
 secrets = _secrets_singleton
 
 # DeltaGenerator methods:
@@ -222,6 +227,8 @@ session_state = _SessionStateProxy()
 
 query_params = _QueryParamsProxy()
 
+context = _ContextProxy()
+
 # Caching
 cache_data = _cache_data
 cache_resource = _cache_resource
@@ -234,9 +241,23 @@ column_config = _column_config
 # Connection
 connection = _connection
 
+# Fragment and dialog
+dialog = _dialog_decorator
+fragment = _fragment
+
 # Experimental APIs
-experimental_dialog = _dialog_decorator
-experimental_fragment = _fragment
+experimental_dialog = _deprecate_func_name(
+    _experimental_dialog_decorator,
+    "experimental_dialog",
+    "2025-01-01",
+    name_override="dialog",
+)
+experimental_fragment = _deprecate_func_name(
+    _experimental_fragment,
+    "experimental_fragment",
+    "2025-01-01",
+    name_override="fragment",
+)
 experimental_user = _UserInfoProxy()
 
 _EXPERIMENTAL_QUERY_PARAMS_DEPRECATE_MSG = "Refer to our [docs page](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.query_params) for more information."

streamlit/commands/execution_control.py

@@ -15,7 +15,8 @@
 from __future__ import annotations
 
 import os
-from typing import Final, NoReturn
+from itertools import dropwhile
+from typing import Final, Literal, NoReturn
 
 import streamlit as st
 from streamlit.errors import NoSessionContext, StreamlitAPIException
@@ -23,7 +24,11 @@ from streamlit.file_util import get_main_script_directory, normalize_path_join
 from streamlit.logger import get_logger
 from streamlit.navigation.page import StreamlitPage
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.scriptrunner import RerunData, get_script_run_ctx
+from streamlit.runtime.scriptrunner import (
+    RerunData,
+    ScriptRunContext,
+    get_script_run_ctx,
+)
 
 _LOGGER: Final = get_logger(__name__)
 
@@ -54,22 +59,76 @@ def stop() -> NoReturn:  # type: ignore[misc]
         st.empty()
 
 
+def _new_fragment_id_queue(
+    ctx: ScriptRunContext,
+    scope: Literal["app", "fragment"],
+) -> list[str]:
+    if scope == "app":
+        return []
+
+    else:  # scope == "fragment"
+        curr_queue = (
+            ctx.script_requests.fragment_id_queue if ctx.script_requests else []
+        )
+
+        # If st.rerun(scope="fragment") is called during a full script run, we raise an
+        # exception. This occurs, of course, if st.rerun(scope="fragment") is called
+        # outside of a fragment, but it somewhat surprisingly occurs if it gets called
+        # from within a fragment during a run of the full script. While this behvior may
+        # be surprising, it seems somewhat reasonable given that the correct behavior of
+        # calling st.rerun(scope="fragment") in this situation is unclear to me:
+        #   * Rerunning just the fragment immediately may cause weirdness down the line
+        #     as any part of the script that occurs after the fragment will not be
+        #     executed.
+        #   * Waiting until the full script run completes before rerunning the fragment
+        #     seems odd (even if we normally do this before running a fragment not
+        #     triggered by st.rerun()) because it defers the execution of st.rerun().
+        #   * Rerunning the full app feels incorrect as we're seemingly ignoring the
+        #     `scope` argument.
+        # With these issues and given that it seems pretty unnatural to have a
+        # fragment-scoped rerun happen during a full script run to begin with, it seems
+        # reasonable to just disallow this completely for now.
+        if not curr_queue:
+            raise StreamlitAPIException(
+                'scope="fragment" can only be specified from `@st.fragment`-decorated '
+                "functions during fragment reruns."
+            )
+
+        assert (
+            new_queue := list(
+                dropwhile(lambda x: x != ctx.current_fragment_id, curr_queue)
+            )
+        ), "Could not find current_fragment_id in fragment_id_queue. This should never happen."
+
+        return new_queue
+
+
 @gather_metrics("rerun")
-def rerun() -> NoReturn:  # type: ignore[misc]
+def rerun(  # type: ignore[misc]
+    *,  # The scope argument can only be passed via keyword.
+    scope: Literal["app", "fragment"] = "app",
+) -> NoReturn:
     """Rerun the script immediately.
 
     When ``st.rerun()`` is called, the script is halted - no more statements will
-    be run, and the script will be queued to re-run from the top.
+    be run, and the script will be queued to re-run.
+
+    Parameters
+    ----------
+    scope : Literal["app", "fragment"]
+        Specifies what part of the app should rerun. Setting scope="app" reruns the
+        full script; scope="fragment" limits the rerun to only the fragment from which
+        this function is called. If unspecified, defaults to "app".
+
+        Note that setting scope="fragment" is only valid
+            * inside of a fragment
+            * *not* during a full script run.
+        Passing this argument to ``st.rerun()`` from outside of a fragment or within a
+        fragment but when the full script is running raises a ``StreamlitAPIException``.
     """
 
     ctx = get_script_run_ctx()
 
-    # TODO: (rerun[scope] project): in order to make it a fragment-scoped rerun, pass
-    # the fragment_id_queue to the RerunData object and add the following line:
-    # fragment_id_queue=[ctx.current_fragment_id] if scope == "fragment" else []
-    # The script_runner RerunException is checking for the fragment_id_queue to decide
-    # whether or not to reset the dg_stack.
-
     if ctx and ctx.script_requests:
         query_string = ctx.query_string
         page_script_hash = ctx.page_script_hash
@@ -78,6 +137,8 @@ def rerun() -> NoReturn:  # type: ignore[misc]
             RerunData(
                 query_string=query_string,
                 page_script_hash=page_script_hash,
+                fragment_id_queue=_new_fragment_id_queue(ctx, scope),
+                is_fragment_scoped_rerun=True,
             )
         )
         # Force a yield point so the runner can do the rerun

streamlit/delta_generator.py

@@ -441,9 +441,9 @@ class DeltaGenerator(
         ctx = get_script_run_ctx()
         if ctx and ctx.current_fragment_id and _writes_directly_to_sidebar(dg):
             raise StreamlitAPIException(
-                "Calling `st.sidebar` in a function wrapped with `st.experimental_fragment` "
-                "is not supported. To write elements to the sidebar with a fragment, "
-                "call your fragment function inside a `with st.sidebar` context manager."
+                "Calling `st.sidebar` in a function wrapped with `st.fragment` is not "
+                "supported. To write elements to the sidebar with a fragment, call your "
+                "fragment function inside a `with st.sidebar` context manager."
             )
 
         # Warn if an element is being changed but the user isn't running the streamlit server.

streamlit/elements/dialog_decorator.py

@@ -28,11 +28,15 @@ if TYPE_CHECKING:
 
 def _assert_no_nested_dialogs() -> None:
     """Check the current stack for existing DeltaGenerator's of type 'dialog'.
-    Note that the check like this only works when Dialog is called as a context manager, as this populates the dg_stack in delta_generator correctly.
+    Note that the check like this only works when Dialog is called as a context manager,
+    as this populates the dg_stack in delta_generator correctly.
 
-    This does not detect the edge case in which someone calls, for example, `with st.sidebar` inside of a dialog function and opens a dialog in there,
-    as `with st.sidebar` pushes the new DeltaGenerator to the stack. In order to check for that edge case, we could try to check all DeltaGenerators in the stack,
-    and not only the last one. Since we deem this to be an edge case, we lean towards simplicity here.
+    This does not detect the edge case in which someone calls, for example,
+    `with st.sidebar` inside of a dialog function and opens a dialog in there, as
+    `with st.sidebar` pushes the new DeltaGenerator to the stack. In order to check for
+    that edge case, we could try to check all DeltaGenerators in the stack, and not only
+    the last one. Since we deem this to be an edge case, we lean towards simplicity
+    here.
 
     Raises
     ------
@@ -54,25 +58,34 @@ def _dialog_decorator(
 ) -> F:
     if title is None or title == "":
         raise StreamlitAPIException(
-            'A non-empty `title` argument has to be provided for dialogs, for example `@st.experimental_dialog("Example Title")`.'
+            "A non-empty `title` argument has to be provided for dialogs, for example "
+            '`@st.dialog("Example Title")`.'
         )
 
     @wraps(non_optional_func)
     def wrap(*args, **kwargs) -> None:
         _assert_no_nested_dialogs()
         # Call the Dialog on the event_dg because it lives outside of the normal
-        # Streamlit UI flow. For example, if it is called from the sidebar, it should not
-        # inherit the sidebar theming.
+        # Streamlit UI flow. For example, if it is called from the sidebar, it should
+        # not inherit the sidebar theming.
         dialog = event_dg._dialog(title=title, dismissible=True, width=width)
         dialog.open()
 
         def dialog_content() -> None:
-            # if the dialog should be closed, st.rerun() has to be called (same behavior as with st.fragment)
+            # if the dialog should be closed, st.rerun() has to be called
+            # (same behavior as with st.fragment)
             _ = non_optional_func(*args, **kwargs)
             return None
 
-        # the fragment decorator has multiple return types so that you can pass arguments to it. Here we know the return type, so we cast
-        fragmented_dialog_content = cast(Callable[[], None], _fragment(dialog_content))
+        # the fragment decorator has multiple return types so that you can pass
+        # arguments to it. Here we know the return type, so we cast
+        fragmented_dialog_content = cast(
+            Callable[[], None],
+            _fragment(
+                dialog_content, additional_hash_info=non_optional_func.__qualname__
+            ),
+        )
+
         with dialog:
             fragmented_dialog_content()
             return None
@@ -86,21 +99,23 @@ def dialog_decorator(
 ) -> Callable[[F], F]: ...
 
 
-# 'title' can be a function since `dialog_decorator` is a decorator. We just call it 'title' here though
-# to make the user-doc more friendly as we want the user to pass a title, not a function.
-# The user is supposed to call it like @st.dialog("my_title") , which makes 'title' a positional arg, hence
-# this 'trick'. The overload is required to have a good type hint for the decorated function args.
+# 'title' can be a function since `dialog_decorator` is a decorator.
+# We just call it 'title' here though to make the user-doc more friendly as
+# we want the user to pass a title, not a function. The user is supposed to
+# call it like @st.dialog("my_title") , which makes 'title' a positional arg, hence
+# this 'trick'. The overload is required to have a good type hint for the decorated
+# function args.
 @overload
 def dialog_decorator(title: F, *, width: DialogWidth = "small") -> F: ...
 
 
-@gather_metrics("experimental_dialog")
+@gather_metrics("dialog")
 def dialog_decorator(
     title: F | str, *, width: DialogWidth = "small"
 ) -> F | Callable[[F], F]:
     """Function decorator to create a modal dialog.
 
-    A function decorated with ``@st.experimental_dialog`` becomes a dialog
+    A function decorated with ``@st.dialog`` becomes a dialog
     function. When you call a dialog function, Streamlit inserts a modal dialog
     into your app. Streamlit element commands called within the dialog function
     render inside the modal dialog.
@@ -115,7 +130,7 @@ def dialog_decorator(
     dialog programmatically, call ``st.rerun()`` explicitly inside of the
     dialog function.
 
-    ``st.experimental_dialog`` inherits behavior from |st.experimental_fragment|_.
+    ``st.dialog`` inherits behavior from |st.fragment|_.
     When a user interacts with an input widget created inside a dialog function,
     Streamlit only reruns the dialog function instead of the full script.
 
@@ -128,13 +143,10 @@ def dialog_decorator(
 
     .. warning::
         Only one dialog function may be called in a script run, which means
-        that only one dialog can be open at any given time. Since a dialog is
-        also a fragment, all fragment limitations apply. Dialogs can't contain
-        fragments, and fragments can't contain dialogs. Using dialogs in widget
-        callback functions is not supported.
+        that only one dialog can be open at any given time.
 
-    .. |st.experimental_fragment| replace:: ``st.experimental_fragment``
-    .. _st.experimental_fragment: https://docs.streamlit.io/develop/api-reference/execution-flow/st.fragment
+    .. |st.fragment| replace:: ``st.fragment``
+    .. _st.fragment: https://docs.streamlit.io/develop/api-reference/execution-flow/st.fragment
 
     Parameters
     ----------
@@ -147,7 +159,7 @@ def dialog_decorator(
 
     Examples
     --------
-    The following example demonstrates the basic usage of ``@st.experimental_dialog``.
+    The following example demonstrates the basic usage of ``@st.dialog``.
     In this app, clicking "**A**" or "**B**" will open a modal dialog and prompt you
     to enter a reason for your vote. In the modal dialog, click "**Submit**" to record
     your vote into Session State and rerun the app. This will close the modal dialog
@@ -155,7 +167,7 @@ def dialog_decorator(
 
     >>> import streamlit as st
     >>>
-    >>> @st.experimental_dialog("Cast your vote")
+    >>> @st.dialog("Cast your vote")
     >>> def vote(item):
     >>>     st.write(f"Why is {item} your favorite?")
     >>>     reason = st.text_input("Because...")
@@ -189,3 +201,25 @@ def dialog_decorator(
 
     func: F = func_or_title
     return _dialog_decorator(func, "", width=width)
+
+
+@overload
+def experimental_dialog_decorator(
+    title: str, *, width: DialogWidth = "small"
+) -> Callable[[F], F]: ...
+
+
+# 'title' can be a function since `dialog_decorator` is a decorator. We just call it
+# 'title' here though to make the user-doc more friendly as we want the user to pass a
+#  title, not a function. The user is supposed to call it like @st.dialog("my_title"),
+#  which makes 'title' a positional arg, hence this 'trick'. The overload is required to
+#  have a good type hint for the decorated function args.
+@overload
+def experimental_dialog_decorator(title: F, *, width: DialogWidth = "small") -> F: ...
+
+
+@gather_metrics("experimental_dialog")
+def experimental_dialog_decorator(
+    title: F | str, *, width: DialogWidth = "small"
+) -> F | Callable[[F], F]:
+    return dialog_decorator(title, width=width)

streamlit/elements/json.py

@@ -18,6 +18,7 @@ import json
 from typing import TYPE_CHECKING, Any, cast
 
 from streamlit.proto.Json_pb2 import Json as JsonProto
+from streamlit.runtime.context import StreamlitCookies, StreamlitHeaders
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.state import QueryParamsProxy, SessionStateProxy
 from streamlit.user_info import UserInfoProxy
@@ -78,7 +79,16 @@ class JsonMixin:
         """
         import streamlit as st
 
-        if isinstance(body, (SessionStateProxy, UserInfoProxy, QueryParamsProxy)):
+        if isinstance(
+            body,
+            (
+                SessionStateProxy,
+                UserInfoProxy,
+                QueryParamsProxy,
+                StreamlitHeaders,
+                StreamlitCookies,
+            ),
+        ):
             body = body.to_dict()
 
         if not isinstance(body, str):

streamlit/elements/widgets/chat.py

@@ -293,8 +293,9 @@ class ChatMixin:
             height: 350px
 
         The chat input can also be used inline by nesting it inside any layout
-        container (container, columns, tabs, sidebar, etc). Create chat
-        interfaces embedded next to other content or have multiple chat bots!
+        container (container, columns, tabs, sidebar, etc) or fragment. Create
+        chat interfaces embedded next to other content or have multiple
+        chatbots!
 
         >>> import streamlit as st
         >>>

streamlit/elements/write.py

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING, Any, Callable, Final, Generator, Iterable, Lis
 from streamlit import dataframe_util, type_util
 from streamlit.errors import StreamlitAPIException
 from streamlit.logger import get_logger
+from streamlit.runtime.context import StreamlitCookies, StreamlitHeaders
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.state import QueryParamsProxy, SessionStateProxy
 from streamlit.string_util import (
@@ -36,7 +37,6 @@ from streamlit.user_info import UserInfoProxy
 if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
-
 # Special methods:
 HELP_TYPES: Final[tuple[type[Any], ...]] = (
     types.BuiltinFunctionType,
@@ -441,7 +441,16 @@ class WriteMixin:
                 dot = vis_utils.model_to_dot(arg)
                 self.dg.graphviz_chart(dot.to_string())
             elif isinstance(
-                arg, (dict, list, SessionStateProxy, UserInfoProxy, QueryParamsProxy)
+                arg,
+                (
+                    dict,
+                    list,
+                    SessionStateProxy,
+                    UserInfoProxy,
+                    QueryParamsProxy,
+                    StreamlitHeaders,
+                    StreamlitCookies,
+                ),
             ):
                 flush_buffer()
                 self.dg.json(arg)

streamlit/errors.py

@@ -38,6 +38,21 @@ class DeprecationError(Error):
     pass
 
 
+class FragmentStorageKeyError(Error, KeyError):
+    """A KeyError raised when a KeyError is encountered during a FragmentStorage
+    operation."""
+
+    pass
+
+
+class FragmentHandledException(Exception):
+    """An exception that is raised by the fragment
+    when it has handled the exception itself.
+    """
+
+    pass
+
+
 class NoStaticFiles(Error):
     pass
 

streamlit/runtime/app_session.py

@@ -122,6 +122,7 @@ class AppSession:
             service that a Streamlit Runtime is running in wants to tie the lifecycle of
             a Streamlit session to some other session-like object that it manages.
         """
+
         # Each AppSession has a unique string ID.
         self.id = session_id_override or str(uuid.uuid4())
 
@@ -361,7 +362,7 @@ class AppSession:
                 client_state.widget_states,
                 client_state.page_script_hash,
                 client_state.page_name,
-                fragment_id_queue=[fragment_id] if fragment_id else [],
+                fragment_id=fragment_id if fragment_id else None,
             )
         else:
             rerun_data = RerunData()
@@ -369,7 +370,7 @@ class AppSession:
         if self._scriptrunner is not None:
             if (
                 bool(config.get_option("runner.fastReruns"))
-                and not rerun_data.fragment_id_queue
+                and not rerun_data.fragment_id
             ):
                 # 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
@@ -477,8 +478,9 @@ 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,
+        fragment_ids_this_run: list[str] | None = None,
         pages: dict[PageHash, PageInfo] | None = None,
+        clear_forward_msg_queue: bool = True,
     ) -> None:
         """Called when our ScriptRunner emits an event.
 
@@ -496,6 +498,7 @@ class AppSession:
                 page_script_hash,
                 fragment_ids_this_run,
                 pages,
+                clear_forward_msg_queue,
             )
         )
 
@@ -507,8 +510,9 @@ 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,
+        fragment_ids_this_run: list[str] | None = None,
         pages: dict[PageHash, PageInfo] | None = None,
+        clear_forward_msg_queue: bool = True,
     ) -> None:
         """Handle a ScriptRunner event.
 
@@ -540,10 +544,14 @@ class AppSession:
             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
+        fragment_ids_this_run : list[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.
+
+        clear_forward_msg_queue : bool
+            If set (the default), clears the queue of forward messages to be sent to the
+            browser. Set only for the SCRIPT_STARTED event.
         """
 
         assert (
@@ -569,13 +577,7 @@ class AppSession:
                 page_script_hash is not None
             ), "page_script_hash must be set for the SCRIPT_STARTED event"
 
-            # 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:
+            if clear_forward_msg_queue:
                 self._clear_queue()
 
             self._enqueue_forward_msg(
@@ -677,7 +679,7 @@ class AppSession:
     def _create_new_session_message(
         self,
         page_script_hash: str,
-        fragment_ids_this_run: set[str] | None = None,
+        fragment_ids_this_run: list[str] | None = None,
         pages: dict[PageHash, PageInfo] | None = None,
     ) -> ForwardMsg:
         """Create and return a new_session ForwardMsg."""