streamlit-nightly 1.43.2.dev20250307__py3-none-any.whl

streamlit/runtime/runtime_util.py

@@ -0,0 +1,106 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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.
+
+"""Runtime-related utility functions"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from streamlit import config
+from streamlit.errors import MarkdownFormattedException, StreamlitAPIException
+from streamlit.runtime.forward_msg_cache import populate_hash_if_needed
+
+if TYPE_CHECKING:
+    from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+
+
+class MessageSizeError(MarkdownFormattedException):
+    """Exception raised when a websocket message is larger than the configured limit."""
+
+    def __init__(self, failed_msg_str: Any):
+        msg = self._get_message(failed_msg_str)
+        super().__init__(msg)
+
+    def _get_message(self, failed_msg_str: Any) -> str:
+        # This needs to have zero indentation otherwise the markdown will render incorrectly.
+        return (
+            f"""
+**Data of size {len(failed_msg_str) / 1e6:.1f} MB exceeds the message size limit of {get_max_message_size_bytes() / 1e6} MB.**
+
+This is often caused by a large chart or dataframe. Please decrease the amount of data sent
+to the browser, or increase the limit by setting the config option `server.maxMessageSize`.
+[Click here to learn more about config options](https://docs.streamlit.io/develop/api-reference/configuration/config.toml).
+
+_Note that increasing the limit may lead to long loading times and large memory consumption
+of the client's browser and the Streamlit server._
+"""
+        ).strip("\n")
+
+
+class BadDurationStringError(StreamlitAPIException):
+    """Raised when a bad duration argument string is passed."""
+
+    def __init__(self, duration: str):
+        MarkdownFormattedException.__init__(
+            self,
+            "TTL string doesn't look right. It should be formatted as"
+            f"`'1d2h34m'` or `2 days`, for example. Got: {duration}",
+        )
+
+
+def is_cacheable_msg(msg: ForwardMsg) -> bool:
+    """True if the given message qualifies for caching."""
+    if msg.WhichOneof("type") in {"ref_hash", "initialize"}:
+        # Some message types never get cached
+        return False
+    return msg.ByteSize() >= int(config.get_option("global.minCachedMessageSize"))
+
+
+def serialize_forward_msg(msg: ForwardMsg) -> bytes:
+    """Serialize a ForwardMsg to send to a client.
+
+    If the message is too large, it will be converted to an exception message
+    instead.
+    """
+    populate_hash_if_needed(msg)
+    msg_str = msg.SerializeToString()
+
+    if len(msg_str) > get_max_message_size_bytes():
+        import streamlit.elements.exception as exception
+
+        # Overwrite the offending ForwardMsg.delta with an error to display.
+        # This assumes that the size limit wasn't exceeded due to metadata.
+        exception.marshall(msg.delta.new_element.exception, MessageSizeError(msg_str))
+        msg_str = msg.SerializeToString()
+
+    return msg_str
+
+
+# This needs to be initialized lazily to avoid calling config.get_option() and
+# thus initializing config options when this file is first imported.
+_max_message_size_bytes: int | None = None
+
+
+def get_max_message_size_bytes() -> int:
+    """Returns the max websocket message size in bytes.
+
+    This will lazyload the value from the config and store it in the global symbol table.
+    """
+    global _max_message_size_bytes
+
+    if _max_message_size_bytes is None:
+        _max_message_size_bytes = config.get_option("server.maxMessageSize") * int(1e6)
+
+    return _max_message_size_bytes

streamlit/runtime/script_data.py

@@ -0,0 +1,46 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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 os
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class ScriptData:
+    """Contains parameters related to running a script."""
+
+    main_script_path: str
+    is_hello: bool = False
+    script_folder: str = field(init=False)
+    name: str = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Set some computed values derived from main_script_path.
+
+        The usage of object.__setattr__ is necessary because trying to set
+        self.script_folder or self.name normally, even within the __init__ method, will
+        explode since we declared this dataclass to be frozen.
+
+        We do this in __post_init__ so that we can use the auto-generated __init__
+        method that most dataclasses use.
+        """
+        main_script_path = os.path.abspath(self.main_script_path)
+        script_folder = os.path.dirname(main_script_path)
+        object.__setattr__(self, "script_folder", script_folder)
+
+        basename = os.path.basename(main_script_path)
+        name = str(os.path.splitext(basename)[0])
+        object.__setattr__(self, "name", name)

streamlit/runtime/scriptrunner/__init__.py

@@ -0,0 +1,38 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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_runner import ScriptRunner, ScriptRunnerEvent
+from streamlit.runtime.scriptrunner_utils.exceptions import (
+    RerunException,
+    StopException,
+)
+from streamlit.runtime.scriptrunner_utils.script_requests import RerunData
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    ScriptRunContext,
+    add_script_run_ctx,
+    enqueue_message,
+    get_script_run_ctx,
+)
+
+__all__ = [
+    "RerunData",
+    "ScriptRunContext",
+    "add_script_run_ctx",
+    "get_script_run_ctx",
+    "enqueue_message",
+    "RerunException",
+    "ScriptRunner",
+    "ScriptRunnerEvent",
+    "StopException",
+]

streamlit/runtime/scriptrunner/exec_code.py

@@ -0,0 +1,159 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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 sys
+from typing import TYPE_CHECKING, Any, Callable
+
+from streamlit import util
+from streamlit.delta_generator_singletons import (
+    context_dg_stack,
+    get_default_dg_stack_value,
+)
+from streamlit.error_util import handle_uncaught_app_exception
+from streamlit.errors import FragmentHandledException
+from streamlit.runtime.scriptrunner_utils.exceptions import (
+    RerunException,
+    StopException,
+)
+
+if TYPE_CHECKING:
+    from streamlit.runtime.scriptrunner_utils.script_requests import RerunData
+    from streamlit.runtime.scriptrunner_utils.script_run_context import ScriptRunContext
+
+
+class modified_sys_path:
+    """A context for prepending a directory to sys.path for a second.
+
+    Code inspired by IPython:
+    Source: https://github.com/ipython/ipython/blob/master/IPython/utils/syspathcontext.py#L42
+    """
+
+    def __init__(self, main_script_path: str):
+        self._main_script_path = main_script_path
+        self._added_path = False
+
+    def __repr__(self) -> str:
+        return util.repr_(self)
+
+    def __enter__(self):
+        if self._main_script_path not in sys.path:
+            sys.path.insert(0, self._main_script_path)
+            self._added_path = True
+
+    def __exit__(self, type, value, traceback):
+        if self._added_path:
+            try:
+                sys.path.remove(self._main_script_path)
+            except ValueError:
+                # It's already removed.
+                pass
+
+        # Returning False causes any exceptions to be re-raised.
+        return False
+
+
+def exec_func_with_error_handling(
+    func: Callable[[], Any], ctx: ScriptRunContext
+) -> tuple[
+    Any | None,
+    bool,
+    RerunData | None,
+    bool,
+    Exception | None,
+]:
+    """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.
+
+    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).
+        - The uncaught exception if one occurred, None otherwise
+    """
+    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
+
+    # 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
+
+    # The uncaught exception if one occurred, None otherwise
+    uncaught_exception: Exception | None = None
+
+    try:
+        result = func()
+    except RerunException as e:
+        rerun_exception_data = e.rerun_data
+
+        # Since the script is about to rerun, we may need to reset our cursors/dg_stack
+        # so that we write to the right place in the app. For full script runs, this
+        # needs to happen in case the same thread reruns our script (a different thread
+        # would automatically come with fresh cursors/dg_stack values). For fragments,
+        # it doesn't matter either way since the fragment resets these values from its
+        # snapshot before execution.
+        ctx.cursors.clear()
+        context_dg_stack.set(get_default_dg_stack_value())
+
+        # 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 FragmentHandledException:
+        run_without_errors = False
+        premature_stop = True
+    except Exception as ex:
+        run_without_errors = False
+        premature_stop = True
+        handle_uncaught_app_exception(ex)
+        uncaught_exception = ex
+
+    return (
+        result,
+        run_without_errors,
+        rerun_exception_data,
+        premature_stop,
+        uncaught_exception,
+    )

streamlit/runtime/scriptrunner/magic.py

@@ -0,0 +1,273 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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 ast
+import sys
+from typing import Any, Final
+
+from streamlit import config
+
+# When a Streamlit app is magicified, we insert a `magic_funcs` import near the top of
+# its module's AST:
+# import streamlit.runtime.scriptrunner.magic_funcs as __streamlitmagic__
+MAGIC_MODULE_NAME: Final = "__streamlitmagic__"
+
+
+def add_magic(code: str, script_path: str) -> Any:
+    """Modifies the code to support magic Streamlit commands.
+
+    Parameters
+    ----------
+    code : str
+        The Python code.
+    script_path : str
+        The path to the script file.
+
+    Returns
+    -------
+    ast.Module
+        The syntax tree for the code.
+
+    """
+    # Pass script_path so we get pretty exceptions.
+    tree = ast.parse(code, script_path, "exec")
+
+    file_ends_in_semicolon = _does_file_end_in_semicolon(tree, code)
+
+    _modify_ast_subtree(
+        tree, is_root=True, file_ends_in_semicolon=file_ends_in_semicolon
+    )
+
+    return tree
+
+
+def _modify_ast_subtree(
+    tree: Any,
+    body_attr: str = "body",
+    is_root: bool = False,
+    file_ends_in_semicolon: bool = False,
+):
+    """Parses magic commands and modifies the given AST (sub)tree."""
+
+    body = getattr(tree, body_attr)
+
+    for i, node in enumerate(body):
+        node_type = type(node)
+
+        # Recursively parses the content of the statements
+        # `with` as well as function definitions.
+        # Also covers their async counterparts
+        if (
+            node_type is ast.FunctionDef
+            or node_type is ast.With
+            or node_type is ast.AsyncFunctionDef
+            or node_type is ast.AsyncWith
+        ):
+            _modify_ast_subtree(node)
+
+        # Recursively parses the content of the statements
+        # `for` and `while`.
+        # Also covers their async counterparts
+        elif (
+            node_type is ast.For or node_type is ast.While or node_type is ast.AsyncFor
+        ):
+            _modify_ast_subtree(node)
+            _modify_ast_subtree(node, "orelse")
+
+        # Recursively parses methods in a class.
+        elif node_type is ast.ClassDef:
+            for inner_node in node.body:
+                if type(inner_node) in {ast.FunctionDef, ast.AsyncFunctionDef}:
+                    _modify_ast_subtree(inner_node)
+
+        # Recursively parses the contents of try statements,
+        # all their handlers (except and else) and the finally body
+        elif node_type is ast.Try or (
+            sys.version_info >= (3, 11) and node_type is ast.TryStar
+        ):
+            _modify_ast_subtree(node)
+            _modify_ast_subtree(node, body_attr="finalbody")
+            _modify_ast_subtree(node, body_attr="orelse")
+            for handler_node in node.handlers:
+                _modify_ast_subtree(handler_node)
+
+        # Recursively parses if blocks, as well as their else/elif blocks
+        # (else/elif are both mapped to orelse)
+        # it intentionally does not parse the test expression.
+        elif node_type is ast.If:
+            _modify_ast_subtree(node)
+            _modify_ast_subtree(node, "orelse")
+
+        elif sys.version_info >= (3, 10) and node_type is ast.Match:
+            for case_node in node.cases:
+                _modify_ast_subtree(case_node)
+
+        # Convert standalone expression nodes to st.write
+        elif node_type is ast.Expr:
+            value = _get_st_write_from_expr(
+                node,
+                i,
+                parent_type=type(tree),
+                is_root=is_root,
+                is_last_expr=(i == len(body) - 1),
+                file_ends_in_semicolon=file_ends_in_semicolon,
+            )
+            if value is not None:
+                node.value = value
+
+    if is_root:
+        # Import Streamlit so we can use it in the new_value above.
+        _insert_import_statement(tree)
+
+    ast.fix_missing_locations(tree)
+
+
+def _insert_import_statement(tree: Any) -> None:
+    """Insert Streamlit import statement at the top(ish) of the tree."""
+
+    st_import = _build_st_import_statement()
+
+    # If the 0th node is already an import statement, put the Streamlit
+    # import below that, so we don't break "from __future__ import".
+    if tree.body and type(tree.body[0]) in {ast.ImportFrom, ast.Import}:
+        tree.body.insert(1, st_import)
+
+    # If the 0th node is a docstring and the 1st is an import statement,
+    # put the Streamlit import below those, so we don't break "from
+    # __future__ import".
+    elif (
+        len(tree.body) > 1
+        and (
+            type(tree.body[0]) is ast.Expr
+            and _is_string_constant_node(tree.body[0].value)
+        )
+        and type(tree.body[1]) in {ast.ImportFrom, ast.Import}
+    ):
+        tree.body.insert(2, st_import)
+
+    else:
+        tree.body.insert(0, st_import)
+
+
+def _build_st_import_statement():
+    """Build AST node for `import magic_funcs as __streamlitmagic__`."""
+    return ast.Import(
+        names=[
+            ast.alias(
+                name="streamlit.runtime.scriptrunner.magic_funcs",
+                asname=MAGIC_MODULE_NAME,
+            )
+        ]
+    )
+
+
+def _build_st_write_call(nodes):
+    """Build AST node for `__streamlitmagic__.transparent_write(*nodes)`."""
+    return ast.Call(
+        func=ast.Attribute(
+            attr="transparent_write",
+            value=ast.Name(id=MAGIC_MODULE_NAME, ctx=ast.Load()),
+            ctx=ast.Load(),
+        ),
+        args=nodes,
+        keywords=[],
+    )
+
+
+def _get_st_write_from_expr(
+    node, i, parent_type, is_root, is_last_expr, file_ends_in_semicolon
+):
+    # Don't wrap function calls
+    # (Unless the function call happened at the end of the root node, AND
+    # magic.displayLastExprIfNoSemicolon is True. This allows us to support notebook-like
+    # behavior, where we display the last function in a cell)
+    if type(node.value) is ast.Call and not _is_displayable_last_expr(
+        is_root, is_last_expr, file_ends_in_semicolon
+    ):
+        return None
+
+    # Don't wrap DocString nodes
+    # (Unless magic.displayRootDocString, in which case we do wrap the root-level
+    # docstring with st.write. This allows us to support notebook-like behavior
+    # where you can have a cell with a markdown string)
+    if _is_docstring_node(
+        node.value, i, parent_type
+    ) and not _should_display_docstring_like_node_anyway(is_root):
+        return None
+
+    # Don't wrap yield nodes
+    if type(node.value) is ast.Yield or type(node.value) is ast.YieldFrom:
+        return None
+
+    # Don't wrap await nodes
+    if type(node.value) is ast.Await:
+        return None
+
+    # If tuple, call st.write(*the_tuple). This allows us to add a comma at the end of a
+    # statement to turn it into an expression that should be st-written. Ex:
+    # "np.random.randn(1000, 2),"
+    args = node.value.elts if type(node.value) is ast.Tuple else [node.value]
+    return _build_st_write_call(args)
+
+
+def _is_string_constant_node(node) -> bool:
+    return isinstance(node, ast.Constant) and isinstance(node.value, str)
+
+
+def _is_docstring_node(node, node_index, parent_type) -> bool:
+    return (
+        node_index == 0
+        and _is_string_constant_node(node)
+        and parent_type in {ast.FunctionDef, ast.AsyncFunctionDef, ast.Module}
+    )
+
+
+def _does_file_end_in_semicolon(tree, code: str) -> bool:
+    file_ends_in_semicolon = False
+
+    # Avoid spending time with this operation if magic.displayLastExprIfNoSemicolon is
+    # not set.
+    if config.get_option("magic.displayLastExprIfNoSemicolon"):
+        if len(tree.body) == 0:
+            return False
+
+        last_line_num = getattr(tree.body[-1], "end_lineno", None)
+
+        if last_line_num is not None:
+            last_line_str: str = code.split("\n")[last_line_num - 1]
+            file_ends_in_semicolon = last_line_str.strip(" ").endswith(";")
+
+    return file_ends_in_semicolon
+
+
+def _is_displayable_last_expr(
+    is_root: bool, is_last_expr: bool, file_ends_in_semicolon: bool
+) -> bool:
+    return (
+        # This is a "displayable last expression" if...
+        # ...it's actually the last expression...
+        is_last_expr
+        # ...in the root scope...
+        and is_root
+        # ...it does not end in a semicolon...
+        and not file_ends_in_semicolon
+        # ...and this config option is telling us to show it
+        and config.get_option("magic.displayLastExprIfNoSemicolon")
+    )
+
+
+def _should_display_docstring_like_node_anyway(is_root: bool) -> bool:
+    return config.get_option("magic.displayRootDocString") and is_root

streamlit/runtime/scriptrunner/magic_funcs.py

@@ -0,0 +1,32 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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 Any
+
+from streamlit.runtime.metrics_util import gather_metrics
+
+
+@gather_metrics("magic")
+def transparent_write(*args: Any) -> Any:
+    """The function that gets magic-ified into Streamlit apps.
+    This is just st.write, but returns the arguments you passed to it.
+    """
+    import streamlit as st
+
+    st.write(*args)
+    if len(args) == 1:
+        return args[0]
+    return args