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

streamlit/elements/lib/pandas_styler_utils.py

@@ -0,0 +1,302 @@
+# 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
+
+from collections import defaultdict
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from streamlit import dataframe_util
+from streamlit.errors import StreamlitAPIException
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+    from pandas.io.formats.style import Styler
+
+    from streamlit.proto.ArrowData_pb2 import ArrowData as ArrowDataProto
+
+from enum import Enum
+
+
+def marshall_styler(proto: ArrowDataProto, styler: Styler, default_uuid: str) -> None:
+    """Marshall pandas.Styler into an ArrowData proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowData
+        Output. The protobuf for Streamlit ArrowData proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    default_uuid : str
+        If pandas.Styler uuid is not provided, this value will be used.
+
+    """
+    import pandas as pd
+
+    styler_data_df: pd.DataFrame = styler.data  # type: ignore[attr-defined]
+    if styler_data_df.size > int(pd.options.styler.render.max_elements):
+        raise StreamlitAPIException(
+            f"The dataframe has `{styler_data_df.size}` cells, but the maximum number "
+            "of cells allowed to be rendered by Pandas Styler is configured to "
+            f"`{pd.options.styler.render.max_elements}`. To allow more cells to be "
+            'styled, you can change the `"styler.render.max_elements"` config. For example: '
+            f'`pd.set_option("styler.render.max_elements", {styler_data_df.size})`'
+        )
+
+    # pandas.Styler uuid should be set before _compute is called.
+    _marshall_uuid(proto, styler, default_uuid)
+
+    # We're using protected members of pandas.Styler to get styles,
+    # which is not ideal and could break if the interface changes.
+    styler._compute()  # type: ignore
+
+    pandas_styles = styler._translate(False, False)  # type: ignore
+
+    _marshall_caption(proto, styler)
+    _marshall_styles(proto, styler, pandas_styles)
+    _marshall_display_values(proto, styler_data_df, pandas_styles)
+
+
+def _marshall_uuid(proto: ArrowDataProto, styler: Styler, default_uuid: str) -> None:
+    """Marshall pandas.Styler uuid into an ArrowData proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowData
+        Output. The protobuf for Streamlit ArrowData proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    default_uuid : str
+        If pandas.Styler uuid is not provided, this value will be used.
+
+    """
+    if styler.uuid is None:  # type: ignore[attr-defined]
+        styler.set_uuid(default_uuid)
+
+    proto.styler.uuid = str(styler.uuid)  # type: ignore[attr-defined]
+
+
+def _marshall_caption(proto: ArrowDataProto, styler: Styler) -> None:
+    """Marshall pandas.Styler caption into an ArrowData proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowData
+        Output. The protobuf for Streamlit ArrowData proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    """
+    if styler.caption is not None:  # type: ignore[attr-defined]
+        proto.styler.caption = styler.caption  # type: ignore[attr-defined]
+
+
+def _marshall_styles(
+    proto: ArrowDataProto, styler: Styler, styles: Mapping[str, Any]
+) -> None:
+    """Marshall pandas.Styler styles into an ArrowData proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowData
+        Output. The protobuf for Streamlit ArrowData proto.
+
+    styler : pandas.Styler
+        Helps style a DataFrame or Series according to the data with HTML and CSS.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    css_rules = []
+
+    if "table_styles" in styles:
+        table_styles = styles["table_styles"]
+        table_styles = _trim_pandas_styles(table_styles)
+        for style in table_styles:
+            # styles in "table_styles" have a space
+            # between the uuid and selector.
+            rule = _pandas_style_to_css(
+                "table_styles",
+                style,
+                styler.uuid,  # type: ignore[attr-defined]
+                separator=" ",
+            )
+            css_rules.append(rule)
+
+    if "cellstyle" in styles:
+        cellstyle = styles["cellstyle"]
+        cellstyle = _trim_pandas_styles(cellstyle)
+        for style in cellstyle:
+            rule = _pandas_style_to_css(
+                "cell_style",
+                style,
+                styler.uuid,  # type: ignore[attr-defined]
+                separator="_",
+            )
+            css_rules.append(rule)
+
+    if len(css_rules) > 0:
+        proto.styler.styles = "\n".join(css_rules)
+
+
+M = TypeVar("M", bound=Mapping[str, Any])
+
+
+def _trim_pandas_styles(styles: list[M]) -> list[M]:
+    """Filter out empty styles.
+
+    Every cell will have a class, but the list of props
+    may just be [['', '']].
+
+    Parameters
+    ----------
+    styles : list
+        pandas.Styler translated styles.
+
+    """
+    return [x for x in styles if any(any(y) for y in x["props"])]
+
+
+def _pandas_style_to_css(
+    style_type: str,
+    style: Mapping[str, Any],
+    uuid: str,
+    separator: str = "_",
+) -> str:
+    """Convert pandas.Styler translated style to CSS.
+
+    Parameters
+    ----------
+    style_type : str
+        Either "table_styles" or "cell_style".
+
+    style : dict
+        pandas.Styler translated style.
+
+    uuid : str
+        pandas.Styler uuid.
+
+    separator : str
+        A string separator used between table and cell selectors.
+
+    """
+    declarations = []
+    for css_property, css_value in style["props"]:
+        declaration = str(css_property).strip() + ": " + str(css_value).strip()
+        declarations.append(declaration)
+
+    table_selector = f"#T_{uuid}"
+
+    # In pandas >= 1.1.0
+    # translated_style["cellstyle"] has the following shape:
+    # > [
+    # >   {
+    # >       "props": [("color", " black"), ("background-color", "orange"), ("", "")],
+    # >       "selectors": ["row0_col0"]
+    # >   }
+    # >   ...
+    # > ]
+    cell_selectors = (
+        [style["selector"]] if style_type == "table_styles" else style["selectors"]
+    )
+
+    selectors = [
+        table_selector + separator + cell_selector for cell_selector in cell_selectors
+    ]
+    selector = ", ".join(selectors)
+
+    declaration_block = "; ".join(declarations)
+    return selector + " { " + declaration_block + " }"
+
+
+def _marshall_display_values(
+    proto: ArrowDataProto, df: DataFrame, styles: Mapping[str, Any]
+) -> None:
+    """Marshall pandas.Styler display values into an ArrowData proto.
+
+    Parameters
+    ----------
+    proto : proto.ArrowData
+        Output. The protobuf for Streamlit ArrowData proto.
+
+    df : pandas.DataFrame
+        A dataframe with original values.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    new_df = _use_display_values(df, styles)
+    proto.styler.display_values = dataframe_util.convert_pandas_df_to_arrow_bytes(
+        new_df
+    )
+
+
+def _use_display_values(df: DataFrame, styles: Mapping[str, Any]) -> DataFrame:
+    """Create a new pandas.DataFrame where display values are used instead of original ones.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        A dataframe with original values.
+
+    styles : dict
+        pandas.Styler translated styles.
+
+    """
+    import re
+
+    # If values in a column are not of the same type, Arrow
+    # serialization would fail. Thus, we need to cast all values
+    # of the dataframe to strings before assigning them display values.
+
+    new_df = df.astype(str)
+    cell_selector_regex = re.compile(r"row(\d+)_col(\d+)")
+    # Outer key = column index; inner key = row index -> target string value
+    updates_by_col: defaultdict[int, dict[int, str]] = defaultdict(dict)
+    for row in styles.get("body", []):
+        for cell in row:
+            cell_id = cell.get("id")
+            if not cell_id:
+                continue
+            match = cell_selector_regex.match(cell_id)
+            if not match:
+                continue
+            row_idx, col_idx = map(int, match.groups())
+            display_value = cell.get("display_value")
+
+            str_value = (
+                str(display_value.value)
+                # Check if the display value is an Enum type. Enum values need to be
+                # converted to their `.value` attribute to ensure proper serialization
+                # and display logic.
+                if isinstance(display_value, Enum)
+                else str(display_value)
+            )
+            updates_by_col[col_idx][row_idx] = str_value
+
+    for col_idx, values_by_row in updates_by_col.items():
+        row_indices = list(values_by_row.keys())
+        values = list(values_by_row.values())
+        # Batch-assign updates for this column using iloc for performance.
+        new_df.iloc[row_indices, col_idx] = values
+
+    return new_df  # type: ignore[no-any-return, unused-ignore]

streamlit/elements/lib/policies.py

@@ -0,0 +1,198 @@
+# 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
+
+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
+from streamlit.runtime.state.common import require_valid_user_key
+
+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  # noqa: PLW0603
+
+    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) -> None:
+        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) -> None:
+    """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,
+) -> None:
+    """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)
+    if key is not None:
+        require_valid_user_key(key)
+    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) -> 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.",
+            stack_info=True,
+        )
+    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/shortcut_utils.py

@@ -0,0 +1,152 @@
+# 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
+
+from typing import (
+    Final,
+)
+
+from streamlit.errors import (
+    StreamlitAPIException,
+)
+
+_MODIFIER_ALIASES: Final[dict[str, str]] = {
+    "ctrl": "ctrl",
+    "control": "ctrl",
+    "cmd": "cmd",
+    "command": "cmd",
+    "meta": "cmd",
+    "alt": "alt",
+    "option": "alt",
+    "shift": "shift",
+    "mod": "ctrl",
+}
+
+_MODIFIER_ORDER: Final[tuple[str, ...]] = ("ctrl", "cmd", "alt", "shift")
+
+_KEY_ALIASES: Final[dict[str, str]] = {
+    "enter": "enter",
+    "return": "enter",
+    "space": "space",
+    "spacebar": "space",
+    "tab": "tab",
+    "escape": "escape",
+    "esc": "escape",
+    "backspace": "backspace",
+    "delete": "delete",
+    "del": "delete",
+    "home": "home",
+    "end": "end",
+    "pageup": "pageup",
+    "pagedown": "pagedown",
+    "left": "left",
+    "arrowleft": "left",
+    "right": "right",
+    "arrowright": "right",
+    "up": "up",
+    "arrowup": "up",
+    "down": "down",
+    "arrowdown": "down",
+}
+
+_RESERVED_KEYS: Final[set[str]] = {"c", "r"}
+
+
+def _normalize_key_token(lower_token: str) -> str:
+    """Normalize a key token to a format that can be used on the client side."""
+
+    if lower_token in _KEY_ALIASES:
+        return _KEY_ALIASES[lower_token]
+
+    if len(lower_token) == 1 and lower_token.isalnum():
+        return lower_token
+
+    if lower_token.startswith("f") and lower_token[1:].isdigit():
+        return lower_token
+
+    raise StreamlitAPIException(
+        "shortcut must include a single character or one of the supported keys "
+        "(e.g. Enter, Space, Tab, Escape)."
+    )
+
+
+def normalize_shortcut(shortcut: str) -> str:
+    """Normalize a shortcut string to a format that can be used on the client side.
+
+    Parameters
+    ----------
+    shortcut : str
+        The shortcut string to normalize.
+
+    Returns
+    -------
+    str
+        The normalized shortcut string.
+
+    Raises
+    ------
+    StreamlitAPIException
+        If the shortcut is not a string value.
+        If the shortcut does not contain at least one key or modifier.
+        If the shortcut contains a single non-modifier key.
+        If the shortcut uses the keys 'C' or 'R', with or without modifiers.
+        If the shortcut does not include a non-modifier key.
+    """
+    if not isinstance(shortcut, str):
+        raise StreamlitAPIException("shortcut must be a string value.")
+
+    tokens = [token.strip() for token in shortcut.split("+") if token.strip()]
+    if not tokens:
+        raise StreamlitAPIException(
+            "The `shortcut` must contain at least one key or modifier."
+        )
+
+    modifiers: list[str] = []
+    key: str | None = None
+
+    for raw_token in tokens:
+        lower_token = raw_token.lower()
+        if lower_token in _MODIFIER_ALIASES:
+            normalized_modifier = _MODIFIER_ALIASES[lower_token]
+            if normalized_modifier not in modifiers:
+                modifiers.append(normalized_modifier)
+            continue
+
+        if key is not None:
+            raise StreamlitAPIException(
+                "The `shortcut` may only specify a single non-modifier key."
+            )
+
+        normalized_key = _normalize_key_token(lower_token)
+        if normalized_key in _RESERVED_KEYS:
+            raise StreamlitAPIException(
+                "The `shortcut` cannot use the keys 'C' or 'R', with or without modifiers."
+            )
+
+        key = normalized_key
+
+    if key is None:
+        raise StreamlitAPIException(
+            "The `shortcut` must include a non-modifier key such as 'K' or 'Ctrl+K'."
+        )
+
+    normalized_tokens: list[str] = [
+        modifier for modifier in _MODIFIER_ORDER if modifier in modifiers
+    ]
+    if key is not None:
+        normalized_tokens.append(key)
+
+    return "+".join(normalized_tokens)