streamlit-nightly 1.35.1.dev20240616__py2.py3-none-any.whl → 1.36.1.dev20240620__py2.py3-none-any.whl

streamlit/runtime/app_session.py

@@ -435,7 +435,9 @@ class AppSession:
         return True
 
     def _on_source_file_changed(self, filepath: str | None = None) -> None:
-        """One of our source files changed. Clear the cache and schedule a rerun if appropriate."""
+        """One of our source files changed. Clear the cache and schedule a rerun if
+        appropriate.
+        """
         self._script_cache.clear()
 
         if filepath is not None and not self._should_rerun_on_file_change(filepath):
@@ -449,11 +451,13 @@ class AppSession:
     def _on_secrets_file_changed(self, _) -> None:
         """Called when `secrets.file_change_listener` emits a Signal."""
 
-        # NOTE: At the time of writing, this function only calls `_on_source_file_changed`.
-        # The reason behind creating this function instead of just passing `_on_source_file_changed`
-        # to `connect` / `disconnect` directly is that every function that is passed to `connect` / `disconnect`
-        # must have at least one argument for `sender` (in this case we don't really care about it, thus `_`),
-        # and introducing an unnecessary argument to `_on_source_file_changed` just for this purpose sounded finicky.
+        # NOTE: At the time of writing, this function only calls
+        # `_on_source_file_changed`. The reason behind creating this function instead of
+        # just passing `_on_source_file_changed` to `connect` / `disconnect` directly is
+        # that every function that is passed to `connect` / `disconnect` must have at
+        # least one argument for `sender` (in this case we don't really care about it,
+        # thus `_`), and introducing an unnecessary argument to
+        # `_on_source_file_changed` just for this purpose sounded finicky.
         self._on_source_file_changed()
 
     def _on_pages_changed(self, _) -> None:

streamlit/runtime/fragment.py

@@ -25,6 +25,7 @@ from typing import TYPE_CHECKING, 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.runtime.scriptrunner.exec_code import exec_func_with_error_handling
 from streamlit.time_util import time_to_seconds
 
 if TYPE_CHECKING:
@@ -100,8 +101,9 @@ def _fragment(
 ) -> 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)
+    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:
@@ -191,7 +193,15 @@ def _fragment(
             msg.auto_rerun.fragment_id = fragment_id
             ctx.enqueue(msg)
 
-        return wrapped_fragment()
+        # Wrap the fragment function in the same try-except block as in a normal
+        # script_run so that for a main-app run (this execution) and a fragment-rerun
+        # the same execution and error-handling logic is used. This makes errors in the
+        # fragment appear in the fragment path also for the first execution here in
+        # context of a full app run.
+        result, _, _, _ = exec_func_with_error_handling(
+            wrapped_fragment, ctx, reraise_rerun_exception=True
+        )
+        return result
 
     with contextlib.suppress(AttributeError):
         # Make this a well-behaved decorator by preserving important function

streamlit/runtime/metrics_util.py

@@ -362,7 +362,7 @@ def gather_metrics(name: str, func: F | None = None) -> Callable[[F], F] | F:
         exec_start = timer()
         # Local imports to prevent circular dependencies
         from streamlit.runtime.scriptrunner import get_script_run_ctx
-        from streamlit.runtime.scriptrunner.script_runner import RerunException
+        from streamlit.runtime.scriptrunner.exceptions import RerunException
 
         ctx = get_script_run_ctx(suppress_warning=True)
 

streamlit/runtime/scriptrunner/__init__.py

@@ -12,18 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from streamlit.runtime.scriptrunner.exceptions import RerunException, StopException
 from streamlit.runtime.scriptrunner.script_requests import RerunData
 from streamlit.runtime.scriptrunner.script_run_context import (
     ScriptRunContext,
     add_script_run_ctx,
     get_script_run_ctx,
 )
-from streamlit.runtime.scriptrunner.script_runner import (
-    RerunException,
-    ScriptRunner,
-    ScriptRunnerEvent,
-    StopException,
-)
+from streamlit.runtime.scriptrunner.script_runner import ScriptRunner, ScriptRunnerEvent
 
 __all__ = [
     "RerunData",

streamlit/runtime/scriptrunner/exceptions.py

@@ -0,0 +1,45 @@
+# 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 streamlit.runtime.scriptrunner.script_requests import RerunData
+from streamlit.util import repr_
+
+
+class ScriptControlException(Exception):
+    """Base exception for ScriptRunner."""
+
+    pass
+
+
+class StopException(ScriptControlException):
+    """Silently stop the execution of the user's script."""
+
+    pass
+
+
+class RerunException(ScriptControlException):
+    """Silently stop and rerun the user's script."""
+
+    def __init__(self, rerun_data: RerunData):
+        """Construct a RerunException
+
+        Parameters
+        ----------
+        rerun_data : RerunData
+            The RerunData that should be used to rerun the script
+        """
+        self.rerun_data = rerun_data
+
+    def __repr__(self) -> str:
+        return repr_(self)

streamlit/runtime/scriptrunner/exec_code.py

@@ -0,0 +1,126 @@
+# 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
+
+from typing import TYPE_CHECKING, Any, Callable
+
+from streamlit.error_util import handle_uncaught_app_exception
+from streamlit.runtime.scriptrunner.exceptions import RerunException, StopException
+
+if TYPE_CHECKING:
+    from streamlit.runtime.scriptrunner.script_requests import RerunData
+    from streamlit.runtime.scriptrunner.script_run_context import ScriptRunContext
+
+
+def exec_func_with_error_handling(
+    func: Callable[[], None],
+    ctx: ScriptRunContext,
+    *,
+    reraise_rerun_exception: bool = False,
+) -> tuple[Any | None, bool, RerunData | None, bool]:
+    """Execute the passed function wrapped in a try/except block.
+
+    This function is called by the script runner to execute the user's script or
+    fragment reruns, but also for the execution of fragment code in context of a normal
+    app run. This wrapper ensures that handle_uncaught_exception messages show up in the
+    correct context.
+
+    Parameters
+    ----------
+    func : callable
+        The function to execute wrapped in the try/except block.
+    ctx : ScriptRunContext
+        The context in which the script is being run.
+    reraise_rerun_exception : bool, default False
+        If True, an occuring RerunException will be raised instead of handled. This can
+        be used if this function is called outside of the script_run context and we want
+        the script_runner to react on the rerun exception.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - The result of the passed function.
+        - A boolean indicating whether the script ran without errors (RerunException and
+            StopException don't count as errors).
+        - The RerunData instance belonging to a RerunException if the script was
+            interrupted by a RerunException.
+        - A boolean indicating whether the script was stopped prematurely (False for
+            RerunExceptions, True for all other exceptions).
+    """
+
+    # Avoid circular imports
+    from streamlit.delta_generator import dg_stack, get_default_dg_stack
+
+    run_without_errors = True
+
+    # This will be set to a RerunData instance if our execution
+    # is interrupted by a RerunException.
+    rerun_exception_data: RerunData | None = None
+
+    # Saving and restoring our original cursors/dg_stack is needed
+    # specifically to handle the case where a RerunException is raised while
+    # running a fragment. In this case, we need to restore both to their states
+    # at the start of the script run to ensure that we write to the correct
+    # places in the app during the rerun (without this, ctx.cursors and dg_stack
+    # will still be set to the snapshots they were restored from when running
+    # the fragment).
+    original_cursors = ctx.cursors
+    original_dg_stack = dg_stack.get()
+
+    # If the script stops early, we don't want to remove unseen widgets,
+    # so we track this to potentially skip session state cleanup later.
+    premature_stop: bool = False
+
+    # The result of the passed function
+    result: Any | None = None
+
+    try:
+        result = func()
+    except RerunException as e:
+        if reraise_rerun_exception:
+            raise e
+
+        rerun_exception_data = e.rerun_data
+        if rerun_exception_data.fragment_id_queue:
+            # This is a fragment-specific rerun, so we need to restore the stack
+            ctx.cursors = original_cursors
+            dg_stack.set(original_dg_stack)
+        else:
+            # If it is a full-app rerun, the stack needs to be refreshed.
+            # We should land here when `st.rerun` is called from within a
+            # fragment. Since we re-use the same thread, we have to clear the
+            # stack or otherwise we might render the main app in the old
+            # fragment's dg_stack.
+            ctx.cursors.clear()
+            dg_stack.set(get_default_dg_stack())
+        # Interruption due to a rerun is usually from `st.rerun()`, which
+        # we want to count as a script completion so triggers reset.
+        # It is also possible for this to happen if fast reruns is off,
+        # but this is very rare.
+        premature_stop = False
+
+    except StopException:
+        # This is thrown when the script executes `st.stop()`.
+        # We don't have to do anything here.
+        premature_stop = True
+
+    except Exception as ex:
+        run_without_errors = False
+        uncaught_exception = ex
+        handle_uncaught_app_exception(uncaught_exception)
+        premature_stop = True
+
+    return result, run_without_errors, rerun_exception_data, premature_stop

streamlit/runtime/scriptrunner/script_runner.py

@@ -26,10 +26,12 @@ from typing import TYPE_CHECKING, Callable, Final
 from blinker import Signal
 
 from streamlit import config, runtime, util
-from streamlit.error_util import handle_uncaught_app_exception
 from streamlit.logger import get_logger
 from streamlit.proto.ClientState_pb2 import ClientState
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.runtime.scriptrunner.exceptions import RerunException, StopException
+from streamlit.runtime.scriptrunner.exec_code import exec_func_with_error_handling
+from streamlit.runtime.scriptrunner.script_cache import ScriptCache
 from streamlit.runtime.scriptrunner.script_requests import (
     RerunData,
     ScriptRequests,
@@ -267,7 +269,8 @@ class ScriptRunner:
         if ctx is None:
             # This should never be possible on the script_runner thread.
             raise RuntimeError(
-                "ScriptRunner thread has a null ScriptRunContext. Something has gone very wrong!"
+                "ScriptRunner thread has a null ScriptRunContext. "
+                "Something has gone very wrong!"
             )
         return ctx
 
@@ -414,8 +417,6 @@ class ScriptRunner:
             The RerunData to use.
 
         """
-        # Avoid circular imports
-        from streamlit.delta_generator import dg_stack
 
         assert self._is_in_script_thread()
 
@@ -522,43 +523,25 @@ class ScriptRunner:
             if config.get_option("runner.installTracer"):
                 self._install_tracer()
 
-            # This will be set to a RerunData instance if our execution
-            # is interrupted by a RerunException.
-            rerun_exception_data: RerunData | None = None
-
-            # Saving and restoring our original cursors/dg_stack is needed
-            # specifically to handle the case where a RerunException is raised while
-            # running a fragment. In this case, we need to restore both to their states
-            # at the start of the script run to ensure that we write to the correct
-            # places in the app during the rerun (without this, ctx.cursors and dg_stack
-            # will still be set to the snapshots they were restored from when running
-            # the fragment).
-            original_cursors = ctx.cursors
-            original_dg_stack = dg_stack.get()
-
-            # If the script stops early, we don't want to remove unseen widgets,
-            # so we track this to potentially skip session state cleanup later.
-            premature_stop: bool = False
-
-            try:
-                # Create fake module. This gives us a name global namespace to
-                # execute the code in.
-                module = self._new_module("__main__")
-
-                # Install the fake module as the __main__ module. This allows
-                # the pickle module to work inside the user's code, since it now
-                # can know the module where the pickled objects stem from.
-                # IMPORTANT: This means we can't use "if __name__ == '__main__'" in
-                # our code, as it will point to the wrong module!!!
-                sys.modules["__main__"] = module
-
-                # Add special variables to the module's globals dict.
-                # Note: The following is a requirement for the CodeHasher to
-                # work correctly. The CodeHasher is scoped to
-                # files contained in the directory of __main__.__file__, which we
-                # assume is the main script directory.
-                module.__dict__["__file__"] = script_path
-
+            # Create fake module. This gives us a name global namespace to
+            # execute the code in.
+            module = self._new_module("__main__")
+
+            # Install the fake module as the __main__ module. This allows
+            # the pickle module to work inside the user's code, since it now
+            # can know the module where the pickled objects stem from.
+            # IMPORTANT: This means we can't use "if __name__ == '__main__'" in
+            # our code, as it will point to the wrong module!!!
+            sys.modules["__main__"] = module
+
+            # Add special variables to the module's globals dict.
+            # Note: The following is a requirement for the CodeHasher to
+            # work correctly. The CodeHasher is scoped to
+            # files contained in the directory of __main__.__file__, which we
+            # assume is the main script directory.
+            module.__dict__["__file__"] = script_path
+
+            def code_to_exec(code=code, module=module, ctx=ctx, rerun_data=rerun_data):
                 with modified_sys_path(
                     self._main_script_path
                 ), self._set_execing_flag():
@@ -569,7 +552,6 @@ class ScriptRunner:
                         )
 
                     ctx.on_script_start()
-                    prep_time = timer() - start_time
 
                     if rerun_data.fragment_id_queue:
                         for fragment_id in rerun_data.fragment_id_queue:
@@ -589,67 +571,58 @@ class ScriptRunner:
                         exec(code, module.__dict__)
 
                     self._session_state.maybe_check_serializable()
-                    self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = True
-            except RerunException as e:
-                rerun_exception_data = e.rerun_data
-                ctx.cursors = original_cursors
-                dg_stack.set(original_dg_stack)
-                # Interruption due to a rerun is usually from `st.rerun()`, which
-                # we want to count as a script completion so triggers reset.
-                # It is also possible for this to happen if fast reruns is off,
-                # but this is very rare.
-                premature_stop = False
-
-            except StopException:
-                # This is thrown when the script executes `st.stop()`.
-                # We don't have to do anything here.
-                premature_stop = True
-
-            except Exception as ex:
-                self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = False
-                uncaught_exception = ex
-                handle_uncaught_app_exception(uncaught_exception)
-                premature_stop = True
-
-            finally:
-                if rerun_exception_data:
-                    # The handling for when a full script run or a fragment is stopped early
-                    # is the same, so we only have one ScriptRunnerEvent for this scenario.
-                    finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN
-                elif rerun_data.fragment_id_queue:
-                    finished_event = ScriptRunnerEvent.FRAGMENT_STOPPED_WITH_SUCCESS
-                else:
-                    finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
-
-                if ctx.gather_usage_stats:
-                    try:
-                        # Prevent issues with circular import
-                        from streamlit.runtime.metrics_util import (
-                            create_page_profile_message,
-                            to_microseconds,
-                        )
-
-                        # Create and send page profile information
-                        ctx.enqueue(
-                            create_page_profile_message(
-                                ctx.tracked_commands,
-                                exec_time=to_microseconds(timer() - start_time),
-                                prep_time=to_microseconds(prep_time),
-                                uncaught_exception=(
-                                    type(uncaught_exception).__name__
-                                    if uncaught_exception
-                                    else None
-                                ),
-                            )
+                    # check for control requests, e.g. rerun requests have arrived
+                    self._maybe_handle_execution_control_request()
+
+            prep_time = timer() - start_time
+            (
+                _,
+                run_without_errors,
+                rerun_exception_data,
+                premature_stop,
+            ) = exec_func_with_error_handling(code_to_exec, ctx)
+            # setting the session state here triggers a yield-callback call
+            # which reads self._requests and checks for rerun data
+            self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = run_without_errors
+
+            if rerun_exception_data:
+                # The handling for when a full script run or a fragment is stopped early
+                # is the same, so we only have one ScriptRunnerEvent for this scenario.
+                finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN
+            elif rerun_data.fragment_id_queue:
+                finished_event = ScriptRunnerEvent.FRAGMENT_STOPPED_WITH_SUCCESS
+            else:
+                finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
+
+            if ctx.gather_usage_stats:
+                try:
+                    # Prevent issues with circular import
+                    from streamlit.runtime.metrics_util import (
+                        create_page_profile_message,
+                        to_microseconds,
+                    )
+
+                    # Create and send page profile information
+                    ctx.enqueue(
+                        create_page_profile_message(
+                            ctx.tracked_commands,
+                            exec_time=to_microseconds(timer() - start_time),
+                            prep_time=to_microseconds(prep_time),
+                            uncaught_exception=(
+                                type(uncaught_exception).__name__
+                                if uncaught_exception
+                                else None
+                            ),
                         )
-                    except Exception as ex:
-                        # Always capture all exceptions since we want to make sure that
-                        # the telemetry never causes any issues.
-                        _LOGGER.debug("Failed to create page profile", exc_info=ex)
-                self._on_script_finished(ctx, finished_event, premature_stop)
-
-            # Use _log_if_error() to make sure we never ever ever stop running the
-            # script without meaning to.
+                    )
+                except Exception as ex:
+                    # Always capture all exceptions since we want to make sure that
+                    # the telemetry never causes any issues.
+                    _LOGGER.debug("Failed to create page profile", exc_info=ex)
+            self._on_script_finished(ctx, finished_event, premature_stop)
+
+            # # Use _log_if_error() to make sure we never ever ever stop running the
+            # # script without meaning to.
             _log_if_error(_clean_problem_modules)
 
             if rerun_exception_data is not None:
@@ -687,35 +660,6 @@ class ScriptRunner:
         return types.ModuleType(name)
 
 
-class ScriptControlException(BaseException):
-    """Base exception for ScriptRunner."""
-
-    pass
-
-
-class StopException(ScriptControlException):
-    """Silently stop the execution of the user's script."""
-
-    pass
-
-
-class RerunException(ScriptControlException):
-    """Silently stop and rerun the user's script."""
-
-    def __init__(self, rerun_data: RerunData):
-        """Construct a RerunException
-
-        Parameters
-        ----------
-        rerun_data : RerunData
-            The RerunData that should be used to rerun the script
-        """
-        self.rerun_data = rerun_data
-
-    def __repr__(self) -> str:
-        return util.repr_(self)
-
-
 def _clean_problem_modules() -> None:
     """Some modules are stateful, so we have to clear their state."""
 

streamlit/static/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.3aaaea00.css",
-    "main.js": "./static/js/main.7994a814.js",
+    "main.js": "./static/js/main.ba32d829.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.7994a814.js"
+    "static/js/main.ba32d829.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.7994a814.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.ba32d829.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>