streamlit-data-editor-plus 0.1.0__py3-none-any.whl

streamlit/elements/lib/streamlit_plotly_theme.py

@@ -0,0 +1,206 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# 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
+from typing import Final
+
+# 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: Final = "#000001"
+CATEGORY_1: Final = "#000002"
+CATEGORY_2: Final = "#000003"
+CATEGORY_3: Final = "#000004"
+CATEGORY_4: Final = "#000005"
+CATEGORY_5: Final = "#000006"
+CATEGORY_6: Final = "#000007"
+CATEGORY_7: Final = "#000008"
+CATEGORY_8: Final = "#000009"
+CATEGORY_9: Final = "#000010"
+
+SEQUENTIAL_0: Final = "#000011"
+SEQUENTIAL_1: Final = "#000012"
+SEQUENTIAL_2: Final = "#000013"
+SEQUENTIAL_3: Final = "#000014"
+SEQUENTIAL_4: Final = "#000015"
+SEQUENTIAL_5: Final = "#000016"
+SEQUENTIAL_6: Final = "#000017"
+SEQUENTIAL_7: Final = "#000018"
+SEQUENTIAL_8: Final = "#000019"
+SEQUENTIAL_9: Final = "#000020"
+
+DIVERGING_0: Final = "#000021"
+DIVERGING_1: Final = "#000022"
+DIVERGING_2: Final = "#000023"
+DIVERGING_3: Final = "#000024"
+DIVERGING_4: Final = "#000025"
+DIVERGING_5: Final = "#000026"
+DIVERGING_6: Final = "#000027"
+DIVERGING_7: Final = "#000028"
+DIVERGING_8: Final = "#000029"
+DIVERGING_9: Final = "#000030"
+
+INCREASING: Final = "#000032"
+DECREASING: Final = "#000033"
+TOTAL: Final = "#000034"
+
+GRAY_70: Final = "#000036"
+GRAY_90: Final = "#000037"
+BG_COLOR: Final = "#000038"
+FADED_TEXT_05: Final = "#000039"
+BG_MIX: Final = "#000040"
+
+
+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
+
+        # 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.1111111111111111, DIVERGING_1],
+                        [0.2222222222222222, DIVERGING_2],
+                        [0.3333333333333333, DIVERGING_3],
+                        [0.4444444444444444, DIVERGING_4],
+                        [0.5555555555555556, DIVERGING_5],
+                        [0.6666666666666666, DIVERGING_6],
+                        [0.7777777777777778, DIVERGING_7],
+                        [0.8888888888888888, DIVERGING_8],
+                        [1.0, DIVERGING_9],
+                    ],
+                ),
+                coloraxis=go.layout.Coloraxis(colorscale=streamlit_colorscale),
+            ),
+        )
+
+        pio.templates.default = "streamlit"

streamlit/elements/lib/subtitle_utils.py

@@ -0,0 +1,175 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# 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
+    return vtt_content.strip().encode("utf-8")
+
+
+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
+    if isinstance(data_or_path, Path):
+        raise ValueError(f"File {data_or_path} does not exist.")  # noqa: TRY004
+
+    content_string = data_or_path.strip()
+
+    if content_string.startswith("WEBVTT") or content_string == "":
+        return content_string.encode("utf-8")
+    if _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
+    # When running in "raw mode", we can't access the MediaFileManager.
+    return ""

streamlit/elements/lib/utils.py

@@ -0,0 +1,274 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2026)
+#
+# 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 hashlib
+from datetime import date, datetime, time, timedelta
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypeAlias,
+    Union,
+    overload,
+)
+
+from google.protobuf.message import Message
+
+from streamlit import config
+from streamlit.elements.lib.form_utils import current_form_id
+from streamlit.errors import StreamlitDuplicateElementId, StreamlitDuplicateElementKey
+from streamlit.proto.ChatInput_pb2 import ChatInput
+from streamlit.proto.LabelVisibility_pb2 import LabelVisibility as LabelVisibilityProto
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    ScriptRunContext,
+    get_script_run_ctx,
+)
+from streamlit.runtime.state.common import (
+    GENERATED_ELEMENT_ID_PREFIX,
+    TESTING_KEY,
+    user_key_from_element_id,
+)
+
+if TYPE_CHECKING:
+    from builtins import ellipsis
+    from collections.abc import Iterable
+
+    from streamlit.delta_generator import DeltaGenerator
+
+
+Key: TypeAlias = str | int
+
+LabelVisibility: TypeAlias = Literal["visible", "hidden", "collapsed"]
+
+PROTO_SCALAR_VALUE: TypeAlias = float | int | bool | str | bytes
+SAFE_VALUES: TypeAlias = Union[
+    date,
+    time,
+    datetime,
+    timedelta,
+    "ellipsis",
+    Message,
+    PROTO_SCALAR_VALUE,
+    None,
+]
+
+
+def get_label_visibility_proto_value(
+    label_visibility_string: LabelVisibility,
+) -> LabelVisibilityProto.LabelVisibilityOptions.ValueType:
+    """Returns one of LabelVisibilityProto enum constants based on string value."""
+
+    if label_visibility_string == "visible":
+        return LabelVisibilityProto.LabelVisibilityOptions.VISIBLE
+    if label_visibility_string == "hidden":
+        return LabelVisibilityProto.LabelVisibilityOptions.HIDDEN
+    if label_visibility_string == "collapsed":
+        return LabelVisibilityProto.LabelVisibilityOptions.COLLAPSED
+
+    raise ValueError(f"Unknown label visibility value: {label_visibility_string}")
+
+
+def get_chat_input_accept_file_proto_value(
+    accept_file_value: Literal["multiple", "directory"] | bool,
+) -> ChatInput.AcceptFile.ValueType:
+    """Returns one of ChatInput.AcceptFile enum value based on string value."""
+
+    if accept_file_value is False:
+        return ChatInput.AcceptFile.NONE
+    if accept_file_value is True:
+        return ChatInput.AcceptFile.SINGLE
+    if accept_file_value == "multiple":
+        return ChatInput.AcceptFile.MULTIPLE
+    if accept_file_value == "directory":
+        return ChatInput.AcceptFile.DIRECTORY
+
+    raise ValueError(f"Unknown accept file value: {accept_file_value}")
+
+
+@overload
+def to_key(key: None) -> None: ...
+
+
+@overload
+def to_key(key: Key) -> str: ...
+
+
+def to_key(key: Key | None) -> str | None:
+    return None if key is None else str(key)
+
+
+def _register_element_id(
+    ctx: ScriptRunContext, element_type: str, element_id: str
+) -> None:
+    """Register the element ID and key for the given element.
+
+    If the element ID or key is not unique, an error is raised.
+
+    Parameters
+    ----------
+    element_type : str
+        The type of the element to register.
+
+    element_id : str
+        The ID of the element to register.
+
+    Raises
+    ------
+    StreamlitDuplicateElementKey
+        If the element key is not unique.
+
+    StreamlitDuplicateElementID
+        If the element ID is not unique.
+
+    """
+
+    if not element_id:
+        return
+
+    if user_key := user_key_from_element_id(element_id):
+        if user_key not in ctx.widget_user_keys_this_run:
+            ctx.widget_user_keys_this_run.add(user_key)
+        else:
+            raise StreamlitDuplicateElementKey(user_key)
+
+    if element_id not in ctx.widget_ids_this_run:
+        ctx.widget_ids_this_run.add(element_id)
+    else:
+        raise StreamlitDuplicateElementId(element_type)
+
+
+def _compute_element_id(
+    element_type: str,
+    user_key: str | None = None,
+    **kwargs: SAFE_VALUES | Iterable[SAFE_VALUES],
+) -> str:
+    """Compute the ID for the given element.
+
+    This ID is stable: a given set of inputs to this function will always produce
+    the same ID output. Only stable, deterministic values should be used to compute
+    element IDs. Using nondeterministic values as inputs can cause the resulting
+    element ID to change between runs.
+
+    The element ID includes the user_key so elements with identical arguments can
+    use it to be distinct. The element ID includes an easily identified prefix, and the
+    user_key as a suffix, to make it easy to identify it and know if a key maps to it.
+    """
+    h = hashlib.new("md5", usedforsecurity=False)
+    h.update(element_type.encode("utf-8"))
+    if user_key:
+        # Adding this to the hash isn't necessary for uniqueness since the
+        # key is also appended to the ID as raw text. But since the hash and
+        # the appending of the key are two slightly different aspects, it
+        # still gets put into the hash.
+        h.update(user_key.encode("utf-8"))
+    # This will iterate in a consistent order when the provided arguments have
+    # consistent order; dicts are always in insertion order.
+    for k, v in kwargs.items():
+        h.update(str(k).encode("utf-8"))
+        h.update(str(v).encode("utf-8"))
+    return f"{GENERATED_ELEMENT_ID_PREFIX}-{h.hexdigest()}-{user_key}"
+
+
+def compute_and_register_element_id(
+    element_type: str,
+    *,
+    user_key: str | None,
+    dg: DeltaGenerator | None,
+    key_as_main_identity: bool | set[str],
+    **kwargs: SAFE_VALUES | Iterable[SAFE_VALUES],
+) -> str:
+    """Compute and register the ID for the given element.
+
+    This ID is stable: a given set of inputs to this function will always produce
+    the same ID output. Only stable, deterministic values should be used to compute
+    element IDs. Using nondeterministic values as inputs can cause the resulting
+    element ID to change between runs.
+
+    The element ID includes the user_key so elements with identical arguments can
+    use it to be distinct. The element ID includes an easily identified prefix, and the
+    user_key as a suffix, to make it easy to identify it and know if a key maps to it.
+
+    The element ID gets registered to make sure that only one ID and user-specified
+    key exists at the same time. If there are duplicated IDs or keys, an error
+    is raised.
+
+    Parameters
+    ----------
+    element_type : str
+        The type (command name) of the element to register.
+
+    user_key : str | None
+        The user-specified key for the element. `None` if no key is provided
+        or if the element doesn't support a specifying a key.
+
+    dg : DeltaGenerator | None
+        The DeltaGenerator of each element. `None` if the element is not a widget.
+
+    kwargs : SAFE_VALUES | Iterable[SAFE_VALUES]
+        The arguments to use to compute the element ID.
+        The arguments must be stable, deterministic values.
+        Some common parameters like key, disabled,
+        format_func, label_visibility, args, kwargs, on_change, and
+        the active_script_hash are not supposed to be added here
+
+    key_as_main_identity : bool | set[str]
+        If True and a key is provided by the user, we don't include
+        command kwargs in the element ID computation.
+        If a set of kwarg names is provided and a key is provided,
+        only the kwargs with names in this set will be included
+        in the element ID computation.
+    """
+    ctx = get_script_run_ctx()
+
+    # When a user_key is present and key_as_main_identity is True OR a set (even empty),
+    # we should ignore general command kwargs and form/sidebar context. For the set case,
+    # only explicitly whitelisted kwargs will be included below.
+    ignore_command_kwargs = user_key is not None and (
+        (key_as_main_identity is True) or isinstance(key_as_main_identity, set)
+    )
+
+    if isinstance(key_as_main_identity, set) and user_key:
+        # Only include the explicitly whitelisted kwargs in the computation
+        kwargs_to_use = {k: v for k, v in kwargs.items() if k in key_as_main_identity}
+    else:
+        kwargs_to_use = {} if ignore_command_kwargs else {**kwargs}
+
+    if ctx:
+        # Add the active script hash to give elements on different
+        # pages unique IDs. This is added even if
+        # key_as_main_identity is specified.
+        kwargs_to_use["active_script_hash"] = ctx.active_script_hash
+
+    if dg and not ignore_command_kwargs:
+        kwargs_to_use["form_id"] = current_form_id(dg)
+        # If no key is provided and the widget element is inside the sidebar area
+        # add it to the kwargs
+        # allowing the same widget to be both in main area and sidebar.
+        kwargs_to_use["active_dg_root_container"] = dg._active_dg._root_container
+
+    element_id = _compute_element_id(element_type, user_key, **kwargs_to_use)
+
+    if ctx:
+        _register_element_id(ctx, element_type, element_id)
+    return element_id
+
+
+def save_for_app_testing(ctx: ScriptRunContext, k: str, v: Any) -> None:
+    if config.get_option("global.appTest"):
+        try:
+            ctx.session_state[TESTING_KEY][k] = v
+        except KeyError:
+            ctx.session_state[TESTING_KEY] = {k: v}