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

streamlit/elements/lib/policies.py

@@ -0,0 +1,194 @@
+# 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 TYPE_CHECKING, Any, Final
+
+from streamlit import config, errors, logger, runtime
+from streamlit.elements.lib.form_utils import is_in_form
+from streamlit.errors import (
+    StreamlitAPIWarning,
+    StreamlitFragmentWidgetsNotAllowedOutsideError,
+    StreamlitInvalidFormCallbackError,
+    StreamlitValueAssignmentNotAllowedError,
+)
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    get_script_run_ctx,
+    in_cached_function,
+)
+from streamlit.runtime.state import WidgetCallback, get_session_state
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from streamlit.delta_generator import DeltaGenerator
+
+
+_LOGGER: Final = logger.get_logger(__name__)
+
+
+def check_callback_rules(dg: DeltaGenerator, on_change: WidgetCallback | None) -> None:
+    """Ensures that widgets other than `st.form_submit_button` within a form don't have
+    an on_change callback set.
+
+    Raises
+    ------
+    StreamlitInvalidFormCallbackError:
+        Raised when the described rule is violated.
+    """
+
+    if runtime.exists() and is_in_form(dg) and on_change is not None:
+        raise StreamlitInvalidFormCallbackError()
+
+
+_shown_default_value_warning: bool = False
+
+
+def check_session_state_rules(
+    default_value: Any, key: str | None, writes_allowed: bool = True
+) -> None:
+    """Ensures that no values are set for widgets with the given key when writing
+    is not allowed.
+
+    Additionally, if `global.disableWidgetStateDuplicationWarning` is False a warning is
+    shown when a widget has a default value but its value is also set via session state.
+
+    Raises
+    ------
+    StreamlitAPIException:
+        Raised when the described rule is violated.
+    """
+    global _shown_default_value_warning
+
+    if key is None or not runtime.exists():
+        return
+
+    session_state = get_session_state()
+    if not session_state.is_new_state_value(key):
+        return
+
+    if not writes_allowed:
+        raise StreamlitValueAssignmentNotAllowedError(key=key)
+
+    if (
+        default_value is not None
+        and not _shown_default_value_warning
+        and not config.get_option("global.disableWidgetStateDuplicationWarning")
+    ):
+        from streamlit import warning
+
+        warning(
+            f'The widget with key "{key}" was created with a default value but'
+            " also had its value set via the Session State API."
+        )
+        _shown_default_value_warning = True
+
+
+class CachedWidgetWarning(StreamlitAPIWarning):
+    def __init__(self):
+        super().__init__(
+            """
+Your script uses a widget command in a cached function
+(function decorated with `@st.cache_data` or `@st.cache_resource`).
+This code will only be called when we detect a cache "miss",
+which can lead to unexpected results.
+
+To fix this, move all widget commands outside the cached function.
+"""
+        )
+
+
+def check_cache_replay_rules() -> None:
+    """Check if a widget is allowed to be used in the current context.
+    More specifically, this checks if the current context is inside a
+    cached function that disallows widget usage. If so, it raises a warning.
+
+    If there are other similar checks in the future, we could extend this
+    function to check for those as well. And rename it to check_widget_usage_rules.
+    """
+    if in_cached_function.get():
+        from streamlit import exception
+
+        # We use an exception here to show a proper stack trace
+        # that indicates to the user where the issue is.
+        exception(CachedWidgetWarning())
+
+
+def check_fragment_path_policy(dg: DeltaGenerator):
+    """Ensures that the current widget is not written outside of the
+    fragment's delta path.
+
+    Should be called by ever element that acts as a widget.
+    We don't allow writing widgets from within a widget to the outside path
+    because it can lead to unexpected behavior. For elements, this is okay
+    because they do not trigger a re-run.
+    """
+
+    ctx = get_script_run_ctx()
+    # Check is only relevant for fragments
+    if ctx is None or ctx.current_fragment_id is None:
+        return
+
+    current_fragment_delta_path = ctx.current_fragment_delta_path
+    current_cursor = dg._active_dg._cursor
+    if current_cursor is None:
+        return
+
+    current_cursor_delta_path = current_cursor.delta_path
+
+    # the elements delta path cannot be smaller than the fragment's delta path if it is
+    # inside of the fragment
+    if len(current_cursor_delta_path) < len(current_fragment_delta_path):
+        raise StreamlitFragmentWidgetsNotAllowedOutsideError()
+
+    # all path indices of the fragment-path must occur in the inner-elements delta path,
+    # otherwise it is outside of the fragment container
+    for index, path_index in enumerate(current_fragment_delta_path):
+        if current_cursor_delta_path[index] != path_index:
+            raise StreamlitFragmentWidgetsNotAllowedOutsideError()
+
+
+def check_widget_policies(
+    dg: DeltaGenerator,
+    key: str | None,
+    on_change: WidgetCallback | None = None,
+    *,
+    default_value: Sequence[Any] | Any | None = None,
+    writes_allowed: bool = True,
+    enable_check_callback_rules: bool = True,
+):
+    """Check all widget policies for the given DeltaGenerator."""
+    check_fragment_path_policy(dg)
+    check_cache_replay_rules()
+    if enable_check_callback_rules:
+        check_callback_rules(dg, on_change)
+    check_session_state_rules(
+        default_value=default_value, key=key, writes_allowed=writes_allowed
+    )
+
+
+def maybe_raise_label_warnings(label: str | None, label_visibility: str | None):
+    if not label:
+        _LOGGER.warning(
+            "`label` got an empty value. This is discouraged for accessibility "
+            "reasons and may be disallowed in the future by raising an exception. "
+            "Please provide a non-empty label and hide it with label_visibility "
+            "if needed."
+        )
+    if label_visibility not in ("visible", "hidden", "collapsed"):
+        raise errors.StreamlitAPIException(
+            f"Unsupported label_visibility option '{label_visibility}'. "
+            f"Valid values are 'visible', 'hidden' or 'collapsed'."
+        )

streamlit/elements/lib/streamlit_plotly_theme.py

@@ -0,0 +1,207 @@
+# 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 contextlib
+
+
+def configure_streamlit_plotly_theme() -> None:
+    """Configure the Streamlit chart theme for Plotly.
+
+    The theme is only configured if Plotly is installed.
+    """
+    # We do nothing if Plotly is not installed. This is expected since Plotly is an optional dependency.
+    with contextlib.suppress(ImportError):
+        import plotly.graph_objects as go
+        import plotly.io as pio
+
+        # This is the streamlit theme for plotly where we pass in a template.data
+        # and a template.layout.
+        # Template.data is for changing specific graph properties in a general aspect
+        # such as Contour plots or Waterfall plots.
+        # Template.layout is for changing things such as the x axis and fonts and other
+        # general layout properties for general graphs.
+        # We pass in temporary colors to the frontend and the frontend will replace
+        # those colors because we want to change colors based on the background color.
+        # Start at #0000001 because developers may be likely to use #000000
+        CATEGORY_0 = "#000001"
+        CATEGORY_1 = "#000002"
+        CATEGORY_2 = "#000003"
+        CATEGORY_3 = "#000004"
+        CATEGORY_4 = "#000005"
+        CATEGORY_5 = "#000006"
+        CATEGORY_6 = "#000007"
+        CATEGORY_7 = "#000008"
+        CATEGORY_8 = "#000009"
+        CATEGORY_9 = "#000010"
+
+        SEQUENTIAL_0 = "#000011"
+        SEQUENTIAL_1 = "#000012"
+        SEQUENTIAL_2 = "#000013"
+        SEQUENTIAL_3 = "#000014"
+        SEQUENTIAL_4 = "#000015"
+        SEQUENTIAL_5 = "#000016"
+        SEQUENTIAL_6 = "#000017"
+        SEQUENTIAL_7 = "#000018"
+        SEQUENTIAL_8 = "#000019"
+        SEQUENTIAL_9 = "#000020"
+
+        DIVERGING_0 = "#000021"
+        DIVERGING_1 = "#000022"
+        DIVERGING_2 = "#000023"
+        DIVERGING_3 = "#000024"
+        DIVERGING_4 = "#000025"
+        DIVERGING_5 = "#000026"
+        DIVERGING_6 = "#000027"
+        DIVERGING_7 = "#000028"
+        DIVERGING_8 = "#000029"
+        DIVERGING_9 = "#000030"
+        DIVERGING_10 = "#000031"
+
+        INCREASING = "#000032"
+        DECREASING = "#000033"
+        TOTAL = "#000034"
+
+        GRAY_70 = "#000036"
+        GRAY_90 = "#000037"
+        BG_COLOR = "#000038"
+        FADED_TEXT_05 = "#000039"
+        BG_MIX = "#000040"
+
+        # Plotly represents continuous colorscale through an array of pairs.
+        # The pair's first index is the starting point and the next pair's first index is the end point.
+        # The pair's second index is the starting color and the next pair's second index is the end color.
+        # For more information, please refer to https://plotly.com/python/colorscales/
+
+        streamlit_colorscale = [
+            [0.0, SEQUENTIAL_0],
+            [0.1111111111111111, SEQUENTIAL_1],
+            [0.2222222222222222, SEQUENTIAL_2],
+            [0.3333333333333333, SEQUENTIAL_3],
+            [0.4444444444444444, SEQUENTIAL_4],
+            [0.5555555555555556, SEQUENTIAL_5],
+            [0.6666666666666666, SEQUENTIAL_6],
+            [0.7777777777777778, SEQUENTIAL_7],
+            [0.8888888888888888, SEQUENTIAL_8],
+            [1.0, SEQUENTIAL_9],
+        ]
+
+        pio.templates["streamlit"] = go.layout.Template(
+            data=go.layout.template.Data(
+                candlestick=[
+                    go.layout.template.data.Candlestick(
+                        decreasing=go.candlestick.Decreasing(
+                            line=go.candlestick.decreasing.Line(color=DECREASING)
+                        ),
+                        increasing=go.candlestick.Increasing(
+                            line=go.candlestick.increasing.Line(color=INCREASING)
+                        ),
+                    )
+                ],
+                contour=[
+                    go.layout.template.data.Contour(colorscale=streamlit_colorscale)
+                ],
+                contourcarpet=[
+                    go.layout.template.data.Contourcarpet(
+                        colorscale=streamlit_colorscale
+                    )
+                ],
+                heatmap=[
+                    go.layout.template.data.Heatmap(colorscale=streamlit_colorscale)
+                ],
+                histogram2d=[
+                    go.layout.template.data.Histogram2d(colorscale=streamlit_colorscale)
+                ],
+                icicle=[
+                    go.layout.template.data.Icicle(
+                        textfont=go.icicle.Textfont(color="white")
+                    )
+                ],
+                sankey=[
+                    go.layout.template.data.Sankey(
+                        textfont=go.sankey.Textfont(color=GRAY_70)
+                    )
+                ],
+                scatter=[
+                    go.layout.template.data.Scatter(
+                        marker=go.scatter.Marker(line=go.scatter.marker.Line(width=0))
+                    )
+                ],
+                table=[
+                    go.layout.template.data.Table(
+                        cells=go.table.Cells(
+                            fill=go.table.cells.Fill(color=BG_COLOR),
+                            font=go.table.cells.Font(color=GRAY_90),
+                            line=go.table.cells.Line(color=FADED_TEXT_05),
+                        ),
+                        header=go.table.Header(
+                            font=go.table.header.Font(color=GRAY_70),
+                            line=go.table.header.Line(color=FADED_TEXT_05),
+                            fill=go.table.header.Fill(color=BG_MIX),
+                        ),
+                    )
+                ],
+                waterfall=[
+                    go.layout.template.data.Waterfall(
+                        increasing=go.waterfall.Increasing(
+                            marker=go.waterfall.increasing.Marker(color=INCREASING)
+                        ),
+                        decreasing=go.waterfall.Decreasing(
+                            marker=go.waterfall.decreasing.Marker(color=DECREASING)
+                        ),
+                        totals=go.waterfall.Totals(
+                            marker=go.waterfall.totals.Marker(color=TOTAL)
+                        ),
+                        connector=go.waterfall.Connector(
+                            line=go.waterfall.connector.Line(color=GRAY_70, width=2)
+                        ),
+                    )
+                ],
+            ),
+            layout=go.Layout(
+                colorway=[
+                    CATEGORY_0,
+                    CATEGORY_1,
+                    CATEGORY_2,
+                    CATEGORY_3,
+                    CATEGORY_4,
+                    CATEGORY_5,
+                    CATEGORY_6,
+                    CATEGORY_7,
+                    CATEGORY_8,
+                    CATEGORY_9,
+                ],
+                colorscale=go.layout.Colorscale(
+                    sequential=streamlit_colorscale,
+                    sequentialminus=streamlit_colorscale,
+                    diverging=[
+                        [0.0, DIVERGING_0],
+                        [0.1, DIVERGING_1],
+                        [0.2, DIVERGING_2],
+                        [0.3, DIVERGING_3],
+                        [0.4, DIVERGING_4],
+                        [0.5, DIVERGING_5],
+                        [0.6, DIVERGING_6],
+                        [0.7, DIVERGING_7],
+                        [0.8, DIVERGING_8],
+                        [0.9, DIVERGING_9],
+                        [1.0, DIVERGING_10],
+                    ],
+                ),
+                coloraxis=go.layout.Coloraxis(colorscale=streamlit_colorscale),
+            ),
+        )
+
+        pio.templates.default = "streamlit"

streamlit/elements/lib/subtitle_utils.py

@@ -0,0 +1,176 @@
+# 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 io
+import os
+import re
+from pathlib import Path
+
+from streamlit import runtime
+from streamlit.runtime import caching
+from streamlit.util import calc_md5
+
+# Regular expression to match the SRT timestamp format
+# It matches the
+# "hours:minutes:seconds,milliseconds --> hours:minutes:seconds,milliseconds" format
+SRT_VALIDATION_REGEX = r"\d{2}:\d{2}:\d{2},\d{3} --> \d{2}:\d{2}:\d{2},\d{3}"
+
+SRT_CONVERSION_REGEX = r"(\d{2}:\d{2}:\d{2}),(\d{3})"
+
+SUBTITLE_ALLOWED_FORMATS = (".srt", ".vtt")
+
+
+def _is_srt(stream: str | io.BytesIO | bytes) -> bool:
+    # Handle raw bytes
+    if isinstance(stream, bytes):
+        stream = io.BytesIO(stream)
+
+    # Convert str to io.BytesIO if 'stream' is a string
+    if isinstance(stream, str):
+        stream = io.BytesIO(stream.encode("utf-8"))
+
+    # Set the stream position to the beginning in case it's been moved
+    stream.seek(0)
+
+    # Read enough bytes to reliably check for SRT patterns
+    # This might be adjusted, but 33 bytes should be enough to read the first numeric
+    # line, the full timestamp line, and a bit of the next line
+    header = stream.read(33)
+
+    try:
+        header_str = header.decode("utf-8").strip()  # Decode and strip whitespace
+    except UnicodeDecodeError:
+        # If it's not valid utf-8, it's probably not a valid SRT file
+        return False
+
+    # Split the header into lines and process them
+    lines = header_str.split("\n")
+
+    # Check for the pattern of an SRT file: digit(s), newline, timestamp
+    if len(lines) >= 2 and lines[0].isdigit():
+        match = re.search(SRT_VALIDATION_REGEX, lines[1])
+        if match:
+            return True
+
+    return False
+
+
+def _srt_to_vtt(srt_data: str | bytes) -> bytes:
+    """
+    Convert subtitles from SubRip (.srt) format to WebVTT (.vtt) format.
+    This function accepts the content of the .srt file either as a string
+    or as a BytesIO stream.
+    Parameters
+    ----------
+    srt_data : str or bytes
+        The content of the .srt file as a string or a bytes stream.
+    Returns
+    -------
+    bytes
+        The content converted into .vtt format.
+    """
+
+    # If the input is a bytes stream, convert it to a string
+    if isinstance(srt_data, bytes):
+        # Decode the bytes to a UTF-8 string
+        try:
+            srt_data = srt_data.decode("utf-8")
+        except UnicodeDecodeError as e:
+            raise ValueError("Could not decode the input stream as UTF-8.") from e
+    if not isinstance(srt_data, str):
+        # If it's not a string by this point, something is wrong.
+        raise TypeError(
+            f"Input must be a string or a bytes stream, not {type(srt_data)}."
+        )
+
+    # Replace SubRip timing with WebVTT timing
+    vtt_data = re.sub(SRT_CONVERSION_REGEX, r"\1.\2", srt_data)
+
+    # Add WebVTT file header
+    vtt_content = "WEBVTT\n\n" + vtt_data
+    # Convert the vtt content to bytes
+    vtt_content = vtt_content.strip().encode("utf-8")
+
+    return vtt_content
+
+
+def _handle_string_or_path_data(data_or_path: str | Path) -> bytes:
+    """Handles string data, either as a file path or raw content."""
+    if os.path.isfile(data_or_path):
+        path = Path(data_or_path)
+        file_extension = path.suffix.lower()
+
+        if file_extension not in SUBTITLE_ALLOWED_FORMATS:
+            raise ValueError(
+                f"Incorrect subtitle format {file_extension}. Subtitles must be in "
+                f"one of the following formats: {', '.join(SUBTITLE_ALLOWED_FORMATS)}"
+            )
+        with open(data_or_path, "rb") as file:
+            content = file.read()
+        return _srt_to_vtt(content) if file_extension == ".srt" else content
+    elif isinstance(data_or_path, Path):
+        raise ValueError(f"File {data_or_path} does not exist.")
+
+    content_string = data_or_path.strip()
+
+    if content_string.startswith("WEBVTT") or content_string == "":
+        return content_string.encode("utf-8")
+    elif _is_srt(content_string):
+        return _srt_to_vtt(content_string)
+    raise ValueError("The provided string neither matches valid VTT nor SRT format.")
+
+
+def _handle_stream_data(stream: io.BytesIO) -> bytes:
+    """Handles io.BytesIO data, converting SRT to VTT content if needed."""
+    stream.seek(0)
+    stream_data = stream.getvalue()
+    return _srt_to_vtt(stream_data) if _is_srt(stream) else stream_data
+
+
+def _handle_bytes_data(data: bytes) -> bytes:
+    """Handles io.BytesIO data, converting SRT to VTT content if needed."""
+    return _srt_to_vtt(data) if _is_srt(data) else data
+
+
+def process_subtitle_data(
+    coordinates: str,
+    data: str | bytes | Path | io.BytesIO,
+    label: str,
+) -> str:
+    # Determine the type of data and process accordingly
+    if isinstance(data, (str, Path)):
+        subtitle_data = _handle_string_or_path_data(data)
+    elif isinstance(data, io.BytesIO):
+        subtitle_data = _handle_stream_data(data)
+    elif isinstance(data, bytes):
+        subtitle_data = _handle_bytes_data(data)
+    else:
+        raise TypeError(f"Invalid binary data format for subtitle: {type(data)}.")
+
+    if runtime.exists():
+        filename = calc_md5(label.encode())
+        # Save the processed data and return the file URL
+        file_url = runtime.get_instance().media_file_mgr.add(
+            path_or_data=subtitle_data,
+            mimetype="text/vtt",
+            coordinates=coordinates,
+            file_name=f"{filename}.vtt",
+        )
+        caching.save_media_data(subtitle_data, "text/vtt", coordinates)
+        return file_url
+    else:
+        # When running in "raw mode", we can't access the MediaFileManager.
+        return ""