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

streamlit/column_config.py

@@ -0,0 +1,56 @@
+# 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.
+
+"""Column types that can be configured via the ``column_config`` parameter of ``st.dataframe`` and ``st.data_editor``."""
+
+from __future__ import annotations
+
+__all__ = [
+    "AreaChartColumn",
+    "Column",
+    "TextColumn",
+    "NumberColumn",
+    "BarChartColumn",
+    "CheckboxColumn",
+    "DatetimeColumn",
+    "ImageColumn",
+    "SelectboxColumn",
+    "ProgressColumn",
+    "LinkColumn",
+    "LineChartColumn",
+    "ListColumn",
+    "DateColumn",
+    "TimeColumn",
+    "JsonColumn",
+]
+
+
+from streamlit.elements.lib.column_types import (
+    AreaChartColumn,
+    BarChartColumn,
+    CheckboxColumn,
+    Column,
+    DateColumn,
+    DatetimeColumn,
+    ImageColumn,
+    JsonColumn,
+    LineChartColumn,
+    LinkColumn,
+    ListColumn,
+    NumberColumn,
+    ProgressColumn,
+    SelectboxColumn,
+    TextColumn,
+    TimeColumn,
+)

streamlit/commands/__init__.py

@@ -0,0 +1,13 @@
+# 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.

streamlit/commands/echo.py

@@ -0,0 +1,126 @@
+# 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 contextlib
+import re
+import textwrap
+import traceback
+from typing import TYPE_CHECKING, Any
+
+from streamlit.runtime.metrics_util import gather_metrics
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+_SPACES_RE = re.compile("\\s*")
+_EMPTY_LINE_RE = re.compile("\\s*\n")
+
+
+@gather_metrics("echo")
+@contextlib.contextmanager
+def echo(code_location="above"):
+    """Use in a `with` block to draw some code on the app, then execute it.
+
+    Parameters
+    ----------
+    code_location : "above" or "below"
+        Whether to show the echoed code before or after the results of the
+        executed code block.
+
+    Example
+    -------
+    >>> import streamlit as st
+    >>>
+    >>> with st.echo():
+    >>>     st.write('This code will be printed')
+
+    """
+    from streamlit import code, empty, source_util, warning
+
+    if code_location == "below":
+        show_code = code
+        show_warning = warning
+    else:
+        placeholder = empty()
+        show_code = placeholder.code
+        show_warning = placeholder.warning
+
+    try:
+        # Get stack frame *before* running the echoed code. The frame's
+        # line number will point to the `st.echo` statement we're running.
+        frame = traceback.extract_stack()[-3]
+        filename, start_line = frame.filename, frame.lineno or 0
+
+        # Read the file containing the source code of the echoed statement.
+        with source_util.open_python_file(filename) as source_file:
+            source_lines = source_file.readlines()
+
+        # Use ast to parse the Python file and find the code block to display
+        root_node = ast.parse("".join(source_lines))
+        line_to_node_map: dict[int, Any] = {}
+
+        def collect_body_statements(node: ast.AST) -> None:
+            if not hasattr(node, "body"):
+                return
+            for child in ast.iter_child_nodes(node):
+                # If child doesn't have "lineno", it is not something we could display
+                if hasattr(child, "lineno"):
+                    line_to_node_map[child.lineno] = child
+                    collect_body_statements(child)
+
+        collect_body_statements(root_node)
+
+        # In AST module the lineno (line numbers) are 1-indexed,
+        # so we decrease it by 1 to lookup in source lines list
+        echo_block_start_line = line_to_node_map[start_line].body[0].lineno - 1
+        echo_block_end_line = line_to_node_map[start_line].end_lineno
+        lines_to_display = source_lines[echo_block_start_line:echo_block_end_line]
+
+        code_string = textwrap.dedent("".join(lines_to_display))
+
+        # Run the echoed code...
+        yield
+
+        # And draw the code string to the app!
+        show_code(code_string, "python")
+
+    except FileNotFoundError as err:
+        show_warning("Unable to display code. %s" % err)
+
+
+def _get_initial_indent(lines: Iterable[str]) -> int:
+    """Return the indent of the first non-empty line in the list.
+    If all lines are empty, return 0.
+    """
+    for line in lines:
+        indent = _get_indent(line)
+        if indent is not None:
+            return indent
+
+    return 0
+
+
+def _get_indent(line: str) -> int | None:
+    """Get the number of whitespaces at the beginning of the given line.
+    If the line is empty, or if it contains just whitespace and a newline,
+    return None.
+    """
+    if _EMPTY_LINE_RE.match(line) is not None:
+        return None
+
+    match = _SPACES_RE.match(line)
+    return match.end() if match is not None else 0

streamlit/commands/execution_control.py

@@ -0,0 +1,238 @@
+# 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 itertools import dropwhile
+from pathlib import Path
+from typing import Literal, NoReturn
+
+import streamlit as st
+from streamlit.errors import NoSessionContext, StreamlitAPIException
+from streamlit.file_util import get_main_script_directory, normalize_path_join
+from streamlit.navigation.page import StreamlitPage
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner import (
+    RerunData,
+    ScriptRunContext,
+    get_script_run_ctx,
+)
+
+
+@gather_metrics("stop")
+def stop() -> NoReturn:  # type: ignore[misc]
+    """Stops execution immediately.
+
+    Streamlit will not run any statements after `st.stop()`.
+    We recommend rendering a message to explain why the script has stopped.
+
+    Example
+    -------
+    >>> import streamlit as st
+    >>>
+    >>> name = st.text_input("Name")
+    >>> if not name:
+    >>>   st.warning('Please input a name.')
+    >>>   st.stop()
+    >>> st.success("Thank you for inputting a name.")
+
+    """
+    ctx = get_script_run_ctx()
+
+    if ctx and ctx.script_requests:
+        ctx.script_requests.request_stop()
+        # Force a yield point so the runner can stop
+        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.fragment_ids_this_run
+
+        # 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(  # 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, Streamlit halts the current script run and
+    executes no further statements. Streamlit immediately queues the script to
+    rerun.
+
+    When using ``st.rerun`` in a fragment, you can scope the rerun to the
+    fragment. However, if a fragment is running as part of a full-app rerun,
+    a fragment-scoped rerun is not allowed.
+
+    Parameters
+    ----------
+    scope : "app" or "fragment"
+        Specifies what part of the app should rerun. If ``scope`` is ``"app"``
+        (default), the full app reruns. If ``scope`` is ``"fragment"``,
+        Streamlit only reruns the fragment from which this command is called.
+
+        Setting ``scope="fragment"`` is only valid inside a fragment during a
+        fragment rerun. If ``st.rerun(scope="fragment")`` is called during a
+        full-app rerun or outside of a fragment, Streamlit will raise a
+        ``StreamlitAPIException``.
+
+    """
+
+    if scope not in ["app", "fragment"]:
+        raise StreamlitAPIException(
+            f"'{scope}'is not a valid rerun scope. Valid scopes are 'app' and 'fragment'."
+        )
+
+    ctx = get_script_run_ctx()
+
+    if ctx and ctx.script_requests:
+        query_string = ctx.query_string
+        page_script_hash = ctx.page_script_hash
+
+        ctx.script_requests.request_rerun(
+            RerunData(
+                query_string=query_string,
+                page_script_hash=page_script_hash,
+                fragment_id_queue=_new_fragment_id_queue(ctx, scope),
+                is_fragment_scoped_rerun=scope == "fragment",
+            )
+        )
+        # Force a yield point so the runner can do the rerun
+        st.empty()
+
+
+@gather_metrics("switch_page")
+def switch_page(page: str | Path | StreamlitPage) -> NoReturn:  # type: ignore[misc]
+    """Programmatically switch the current page in a multipage app.
+
+    When ``st.switch_page`` is called, the current page execution stops and
+    the specified page runs as if the user clicked on it in the sidebar
+    navigation. The specified page must be recognized by Streamlit's multipage
+    architecture (your main Python file or a Python file in a ``pages/``
+    folder). Arbitrary Python scripts cannot be passed to ``st.switch_page``.
+
+    Parameters
+    ----------
+    page: str, Path, or st.Page
+        The file path (relative to the main script) or an st.Page indicating
+        the page to switch to.
+
+
+    Example
+    -------
+    Consider the following example given this file structure:
+
+    >>> your-repository/
+    >>> ├── pages/
+    >>> │   ├── page_1.py
+    >>> │   └── page_2.py
+    >>> └── your_app.py
+
+    >>> import streamlit as st
+    >>>
+    >>> if st.button("Home"):
+    >>>     st.switch_page("your_app.py")
+    >>> if st.button("Page 1"):
+    >>>     st.switch_page("pages/page_1.py")
+    >>> if st.button("Page 2"):
+    >>>     st.switch_page("pages/page_2.py")
+
+    .. output ::
+        https://doc-switch-page.streamlit.app/
+        height: 350px
+
+    """
+
+    ctx = get_script_run_ctx()
+
+    if not ctx or not ctx.script_requests:
+        # This should never be the case
+        raise NoSessionContext()
+
+    page_script_hash = ""
+    if isinstance(page, StreamlitPage):
+        page_script_hash = page._script_hash
+    else:
+        # Convert Path to string if necessary
+        if isinstance(page, Path):
+            page = str(page)
+
+        main_script_directory = get_main_script_directory(ctx.main_script_path)
+        requested_page = os.path.realpath(
+            normalize_path_join(main_script_directory, page)
+        )
+        all_app_pages = ctx.pages_manager.get_pages().values()
+
+        matched_pages = [p for p in all_app_pages if p["script_path"] == requested_page]
+
+        if len(matched_pages) == 0:
+            raise StreamlitAPIException(
+                f"Could not find page: `{page}`. Must be the file path relative to the main script, from the directory: `{os.path.basename(main_script_directory)}`. Only the main app file and files in the `pages/` directory are supported."
+            )
+
+        page_script_hash = matched_pages[0]["page_script_hash"]
+
+    # We want to reset query params (with exception of embed) when switching pages
+    with ctx.session_state.query_params() as qp:
+        qp.clear()
+
+    ctx.script_requests.request_rerun(
+        RerunData(
+            query_string=ctx.query_string,
+            page_script_hash=page_script_hash,
+        )
+    )
+    # Force a yield point so the runner can do the rerun
+    st.empty()

streamlit/commands/experimental_query_params.py

@@ -0,0 +1,169 @@
+# 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 urllib.parse as parse
+from typing import Any
+
+from streamlit.errors import StreamlitAPIException
+from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.runtime.state.query_params import (
+    EMBED_OPTIONS_QUERY_PARAM,
+    EMBED_QUERY_PARAM,
+    EMBED_QUERY_PARAMS_KEYS,
+)
+
+
+@gather_metrics("experimental_get_query_params")
+def get_query_params() -> dict[str, list[str]]:
+    """Return the query parameters that is currently showing in the browser's URL bar.
+
+    Returns
+    -------
+    dict
+      The current query parameters as a dict. "Query parameters" are the part of the URL that comes
+      after the first "?".
+
+    Example
+    -------
+    Let's say the user's web browser is at
+    `http://localhost:8501/?show_map=True&selected=asia&selected=america`.
+    Then, you can get the query parameters using the following:
+
+    >>> import streamlit as st
+    >>>
+    >>> st.experimental_get_query_params()
+    {"show_map": ["True"], "selected": ["asia", "america"]}
+
+    Note that the values in the returned dict are *always* lists. This is
+    because we internally use Python's urllib.parse.parse_qs(), which behaves
+    this way. And this behavior makes sense when you consider that every item
+    in a query string is potentially a 1-element array.
+
+    """
+    ctx = get_script_run_ctx()
+    if ctx is None:
+        return {}
+    ctx.mark_experimental_query_params_used()
+    # Return new query params dict, but without embed, embed_options query params
+    return _exclude_keys_in_dict(
+        parse.parse_qs(ctx.query_string, keep_blank_values=True),
+        keys_to_exclude=EMBED_QUERY_PARAMS_KEYS,
+    )
+
+
+@gather_metrics("experimental_set_query_params")
+def set_query_params(**query_params: Any) -> None:
+    """Set the query parameters that are shown in the browser's URL bar.
+
+    .. warning::
+        Query param `embed` cannot be set using this method.
+
+    Parameters
+    ----------
+    **query_params : dict
+        The query parameters to set, as key-value pairs.
+
+    Example
+    -------
+
+    To point the user's web browser to something like
+    "http://localhost:8501/?show_map=True&selected=asia&selected=america",
+    you would do the following:
+
+    >>> import streamlit as st
+    >>>
+    >>> st.experimental_set_query_params(
+    ...     show_map=True,
+    ...     selected=["asia", "america"],
+    ... )
+
+    """
+    ctx = get_script_run_ctx()
+    if ctx is None:
+        return
+    ctx.mark_experimental_query_params_used()
+
+    msg = ForwardMsg()
+    msg.page_info_changed.query_string = _ensure_no_embed_params(
+        query_params, ctx.query_string
+    )
+    ctx.query_string = msg.page_info_changed.query_string
+    ctx.enqueue(msg)
+
+
+def _exclude_keys_in_dict(
+    d: dict[str, Any], keys_to_exclude: list[str]
+) -> dict[str, Any]:
+    """Returns new object but without keys defined in keys_to_exclude"""
+    return {
+        key: value for key, value in d.items() if key.lower() not in keys_to_exclude
+    }
+
+
+def _extract_key_query_params(
+    query_params: dict[str, list[str]], param_key: str
+) -> set[str]:
+    """Extracts key (case-insensitive) query params from Dict, and returns them as Set of str."""
+    return {
+        item.lower()
+        for sublist in [
+            [value.lower() for value in query_params[key]]
+            for key in query_params.keys()
+            if key.lower() == param_key and query_params.get(key)
+        ]
+        for item in sublist
+    }
+
+
+def _ensure_no_embed_params(
+    query_params: dict[str, list[str] | str], query_string: str
+) -> str:
+    """Ensures there are no embed params set (raises StreamlitAPIException) if there is a try,
+    also makes sure old param values in query_string are preserved. Returns query_string : str.
+    """
+    # Get query params dict without embed, embed_options params
+    query_params_without_embed = _exclude_keys_in_dict(
+        query_params, keys_to_exclude=EMBED_QUERY_PARAMS_KEYS
+    )
+    if query_params != query_params_without_embed:
+        raise StreamlitAPIException(
+            "Query param embed and embed_options (case-insensitive) cannot be set using set_query_params method."
+        )
+
+    all_current_params = parse.parse_qs(query_string, keep_blank_values=True)
+    current_embed_params = parse.urlencode(
+        {
+            EMBED_QUERY_PARAM: list(
+                _extract_key_query_params(
+                    all_current_params, param_key=EMBED_QUERY_PARAM
+                )
+            ),
+            EMBED_OPTIONS_QUERY_PARAM: list(
+                _extract_key_query_params(
+                    all_current_params, param_key=EMBED_OPTIONS_QUERY_PARAM
+                )
+            ),
+        },
+        doseq=True,
+    )
+    query_string = parse.urlencode(query_params, doseq=True)
+
+    if query_string:
+        separator = "&" if current_embed_params else ""
+        return separator.join([query_string, current_embed_params])
+    return current_embed_params