streamlit 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

streamlit/elements/lib/column_types.py

@@ -19,9 +19,9 @@ from __future__ import annotations
 
 import datetime
 import itertools
-from typing import TYPE_CHECKING, Callable, Literal, TypedDict, Union
+from typing import TYPE_CHECKING, Literal, TypeAlias, TypedDict
 
-from typing_extensions import NotRequired, TypeAlias
+from typing_extensions import NotRequired
 
 from streamlit.elements.lib.color_util import is_css_color_like
 from streamlit.errors import StreamlitValueError
@@ -29,7 +29,7 @@ from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.string_util import validate_material_icon
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Iterator
+    from collections.abc import Callable, Iterable, Iterator
 
 NumberFormat: TypeAlias = Literal[
     "plain",
@@ -45,7 +45,7 @@ NumberFormat: TypeAlias = Literal[
     "bytes",
 ]
 
-ColumnWidth: TypeAlias = Union[Literal["small", "medium", "large"], int]
+ColumnWidth: TypeAlias = Literal["small", "medium", "large"] | int
 
 # Type alias that represents all available column types
 # which are configurable by the user.
@@ -83,11 +83,7 @@ ThemeColor: TypeAlias = Literal[
 ]
 
 # Color options for chart columns:
-ChartColor: TypeAlias = Union[
-    Literal["auto", "auto-inverse"],
-    ThemeColor,
-    str,
-]
+ChartColor: TypeAlias = Literal["auto", "auto-inverse"] | ThemeColor | str
 
 
 def _validate_chart_color(maybe_color: str) -> None:
@@ -135,7 +131,7 @@ class CheckboxColumnConfig(TypedDict):
     type: Literal["checkbox"]
 
 
-SelectboxOptionValue: TypeAlias = Union[str, int, float, bool]
+SelectboxOptionValue: TypeAlias = str | int | float | bool
 
 
 class SelectboxOption(TypedDict):
@@ -187,7 +183,7 @@ class ListColumnConfig(TypedDict):
 class MultiselectOption(TypedDict):
     value: str
     label: NotRequired[str | None]
-    color: NotRequired[str | ThemeColor | None]
+    color: NotRequired[str | Literal["auto"] | ThemeColor | None]
 
 
 class MultiselectColumnConfig(TypedDict):
@@ -229,6 +225,7 @@ class ProgressColumnConfig(TypedDict):
     min_value: NotRequired[int | float | None]
     max_value: NotRequired[int | float | None]
     step: NotRequired[int | float | None]
+    color: NotRequired[ChartColor | None]
 
 
 class JsonColumnConfig(TypedDict):
@@ -1732,10 +1729,15 @@ def MultiselectColumn(
     help: str | None = None,
     disabled: bool | None = None,
     required: bool | None = None,
+    pinned: bool | None = None,
     default: Iterable[str] | None = None,
     options: Iterable[str] | None = None,
     accept_new_options: bool | None = None,
-    color: str | ThemeColor | Iterable[str | ThemeColor] | None = None,
+    color: str
+    | Literal["auto"]
+    | ThemeColor
+    | Iterable[str | ThemeColor]
+    | None = None,
     format_func: Callable[[str], str] | None = None,
 ) -> ColumnConfig:
     """Configure a multiselect column in ``st.dataframe`` or ``st.data_editor``.
@@ -1788,6 +1790,12 @@ def MultiselectColumn(
         Whether edited cells in the column need to have a value. If True, an edited cell
         can only be submitted if it has a value other than None. Defaults to False.
 
+    pinned : bool or None
+        Whether the column is pinned. A pinned column will stay visible on the
+        left side no matter where the user scrolls. If this is ``None``
+        (default), Streamlit will decide: index columns are pinned, and data
+        columns are not pinned.
+
     default : Iterable of str or None
         Specifies the default value in this column when a new row is added by the user.
 
@@ -1808,6 +1816,7 @@ def MultiselectColumn(
         The color to use for different options. This can be:
 
         - None (default): The options are displayed without color.
+        - ``"auto"``: The options are colored based on the configured categorical chart colors.
         - A single color value that is used for all options. This can be one of
           the following strings:
 
@@ -1943,6 +1952,7 @@ def MultiselectColumn(
         help=help,
         disabled=disabled,
         required=required,
+        pinned=pinned,
         default=None if default is None else list(default),
         type_config=MultiselectColumnConfig(
             type="multiselect",
@@ -2446,6 +2456,7 @@ def ProgressColumn(
     min_value: int | float | None = None,
     max_value: int | float | None = None,
     step: int | float | None = None,
+    color: ChartColor | None = None,
 ) -> ColumnConfig:
     """Configure a progress column in ``st.dataframe`` or ``st.data_editor``.
 
@@ -2528,6 +2539,19 @@ def ProgressColumn(
         Setting ``step`` for float columns will ensure a consistent number of
         digits after the decimal are displayed.
 
+    color : "auto", "auto-inverse", str, or None
+        The color to use for the chart. This can be one of the following:
+
+        - ``None`` (default): The primary color is used.
+        - ``"auto"``: If the value is more than half, the bar is green; if the
+          value is less than half, the bar is red.
+        - ``"auto-inverse"``: If the value is more than half, the bar is red;
+          if the value is less than half, the bar is green.
+        - A single color value that is applied to all charts in the column.
+          In addition to the basic color palette (red, orange, yellow, green,
+          blue, violet, gray/grey, and primary), this supports hex codes like
+          ``"#483d8b"``.
+
     Examples
     --------
     >>> import pandas as pd
@@ -2558,6 +2582,9 @@ def ProgressColumn(
         height: 300px
     """  # noqa: E501
 
+    if color is not None:
+        _validate_chart_color(color)
+
     return ColumnConfig(
         label=label,
         width=width,
@@ -2569,6 +2596,7 @@ def ProgressColumn(
             min_value=min_value,
             max_value=max_value,
             step=step,
+            color=color,
         ),
     )
 

streamlit/elements/lib/dialog.py

@@ -14,9 +14,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, cast
+from typing import TYPE_CHECKING, Literal, TypeAlias, cast
 
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from streamlit.delta_generator import DeltaGenerator
 from streamlit.elements.lib.utils import compute_and_register_element_id

streamlit/elements/lib/image_utils.py

@@ -20,9 +20,7 @@ import re
 from collections.abc import Sequence
 from enum import IntEnum
 from pathlib import Path
-from typing import TYPE_CHECKING, Final, Literal, Union, cast
-
-from typing_extensions import TypeAlias
+from typing import TYPE_CHECKING, Final, Literal, TypeAlias, Union, cast
 
 from streamlit import runtime, url_util
 from streamlit.errors import StreamlitAPIException
@@ -48,7 +46,7 @@ AtomicImage: TypeAlias = Union[
 Channels: TypeAlias = Literal["RGB", "BGR"]
 ImageFormat: TypeAlias = Literal["JPEG", "PNG", "GIF"]
 ImageFormatOrAuto: TypeAlias = Literal[ImageFormat, "auto"]
-ImageOrImageList: TypeAlias = Union[AtomicImage, Sequence[AtomicImage]]
+ImageOrImageList: TypeAlias = AtomicImage | Sequence[AtomicImage]
 
 # This constant is related to the frontend maximum content width specified
 # in App.jsx main container
@@ -434,7 +432,7 @@ def marshall_images(
 
     # Each image in an image list needs to be kept track of at its own coordinates.
     for coord_suffix, (single_image, single_caption) in enumerate(
-        zip(images, captions)
+        zip(images, captions, strict=False)
     ):
         proto_img = proto_imgs.imgs.add()
         if single_caption is not None:

streamlit/elements/lib/layout_utils.py

@@ -14,35 +14,48 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Literal, Union, cast
-
-from typing_extensions import TypeAlias
+from typing import Literal, TypeAlias, cast
 
 from streamlit.errors import (
     StreamlitInvalidColumnGapError,
     StreamlitInvalidHeightError,
     StreamlitInvalidHorizontalAlignmentError,
+    StreamlitInvalidSizeError,
+    StreamlitInvalidTextAlignmentError,
     StreamlitInvalidVerticalAlignmentError,
     StreamlitInvalidWidthError,
 )
 from streamlit.proto.Block_pb2 import Block
 from streamlit.proto.GapSize_pb2 import GapSize
 from streamlit.proto.HeightConfig_pb2 import HeightConfig
+from streamlit.proto.TextAlignmentConfig_pb2 import TextAlignmentConfig
 from streamlit.proto.WidthConfig_pb2 import WidthConfig
 
-WidthWithoutContent: TypeAlias = Union[int, Literal["stretch"]]
-Width: TypeAlias = Union[int, Literal["stretch", "content"]]
-HeightWithoutContent: TypeAlias = Union[int, Literal["stretch"]]
-Height: TypeAlias = Union[int, Literal["stretch", "content"]]
+WidthWithoutContent: TypeAlias = int | Literal["stretch"]
+Width: TypeAlias = int | Literal["stretch", "content"]
+HeightWithoutContent: TypeAlias = int | Literal["stretch"]
+Height: TypeAlias = int | Literal["stretch", "content"]
+SpaceSize: TypeAlias = int | Literal["stretch", "small", "medium", "large"]
 Gap: TypeAlias = Literal["small", "medium", "large"]
 HorizontalAlignment: TypeAlias = Literal["left", "center", "right", "distribute"]
 VerticalAlignment: TypeAlias = Literal["top", "center", "bottom", "distribute"]
+TextAlignment: TypeAlias = Literal["left", "center", "right", "justify"]
+
+# Mapping of size literals to rem values for st.space
+# If changing these, also check streamlit/frontend/lib/src/theme/primitives/sizes.ts
+# to ensure sizes are kept in sync.
+SIZE_TO_REM_MAPPING = {
+    "small": 0.75,  # Height of widget label minus gap
+    "medium": 2.5,  # Height of button/input field
+    "large": 4.25,  # Height of large widget without label
+}
 
 
 @dataclass
 class LayoutConfig:
-    width: Width | None = None
-    height: Height | None = None
+    width: Width | SpaceSize | None = None
+    height: Height | SpaceSize | None = None
+    text_alignment: TextAlignment | None = None
 
 
 def validate_width(width: Width, allow_content: bool = False) -> None:
@@ -117,9 +130,35 @@ def validate_height(
         raise StreamlitInvalidHeightError(height, allow_content)
 
 
-def get_width_config(width: Width) -> WidthConfig:
+def validate_space_size(size: SpaceSize) -> None:
+    """Validate the size parameter for st.space.
+
+    Parameters
+    ----------
+    size : Any
+        The size value to validate.
+
+    Raises
+    ------
+    StreamlitInvalidSizeError
+        If the size value is invalid.
+    """
+    if not isinstance(size, (int, str)):
+        raise StreamlitInvalidSizeError(size)
+
+    if isinstance(size, str):
+        valid_strings = ["stretch", "small", "medium", "large"]
+        if size not in valid_strings:
+            raise StreamlitInvalidSizeError(size)
+    elif isinstance(size, int) and size <= 0:
+        raise StreamlitInvalidSizeError(size)
+
+
+def get_width_config(width: Width | SpaceSize) -> WidthConfig:
     width_config = WidthConfig()
-    if isinstance(width, (int, float)):
+    if isinstance(width, str) and width in SIZE_TO_REM_MAPPING:
+        width_config.rem_width = SIZE_TO_REM_MAPPING[width]
+    elif isinstance(width, (int, float)):
         width_config.pixel_width = int(width)
     elif width == "content":
         width_config.use_content = True
@@ -128,9 +167,11 @@ def get_width_config(width: Width) -> WidthConfig:
     return width_config
 
 
-def get_height_config(height: Height) -> HeightConfig:
+def get_height_config(height: Height | SpaceSize) -> HeightConfig:
     height_config = HeightConfig()
-    if isinstance(height, (int, float)):
+    if isinstance(height, str) and height in SIZE_TO_REM_MAPPING:
+        height_config.rem_height = SIZE_TO_REM_MAPPING[height]
+    elif isinstance(height, (int, float)):
         height_config.pixel_height = int(height)
     elif height == "content":
         height_config.use_content = True
@@ -173,6 +214,24 @@ def validate_vertical_alignment(vertical_alignment: VerticalAlignment) -> None:
         raise StreamlitInvalidVerticalAlignmentError(vertical_alignment, "st.container")
 
 
+def validate_text_alignment(text_alignment: TextAlignment) -> None:
+    """Validate the text_alignment parameter.
+
+    Parameters
+    ----------
+    text_alignment : TextAlignment
+        The text alignment value to validate.
+
+    Raises
+    ------
+    StreamlitInvalidTextAlignmentError
+        If the text_alignment value is invalid.
+    """
+    valid_alignments = ["left", "center", "right", "justify"]
+    if text_alignment not in valid_alignments:
+        raise StreamlitInvalidTextAlignmentError(text_alignment)
+
+
 map_to_flex_terminology = {
     "left": "start",
     "center": "center",
@@ -212,3 +271,31 @@ def get_align(
         "Block.FlexContainer.Align.ValueType",
         getattr(Block.FlexContainer.Align, f"ALIGN_{align.upper()}"),
     )
+
+
+def get_text_alignment_config(
+    text_alignment: TextAlignment,
+) -> TextAlignmentConfig:
+    """Convert text alignment string to proto config.
+
+    Parameters
+    ----------
+    text_alignment : TextAlignment
+        The text alignment value ("left", "center", "right", "justify").
+
+    Returns
+    -------
+    TextAlignmentConfig
+        Proto message with alignment set.
+    """
+
+    alignment_mapping = {
+        "left": TextAlignmentConfig.Alignment.LEFT,
+        "center": TextAlignmentConfig.Alignment.CENTER,
+        "right": TextAlignmentConfig.Alignment.RIGHT,
+        "justify": TextAlignmentConfig.Alignment.JUSTIFY,
+    }
+
+    config = TextAlignmentConfig()
+    config.alignment = alignment_mapping[text_alignment]
+    return config

streamlit/elements/lib/mutable_status_container.py

@@ -15,9 +15,9 @@
 from __future__ import annotations
 
 import time
-from typing import TYPE_CHECKING, Literal, cast
+from typing import TYPE_CHECKING, Literal, TypeAlias, cast
 
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from streamlit.delta_generator import DeltaGenerator
 from streamlit.elements.lib.layout_utils import (

streamlit/elements/lib/options_selector_utils.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from enum import Enum, EnumMeta
-from typing import TYPE_CHECKING, Any, Callable, Final, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Final, TypeVar, overload
 
 from streamlit import config, logger
 from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
@@ -26,7 +26,7 @@ from streamlit.type_util import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable, Sequence
+    from collections.abc import Callable, Iterable, Sequence
 
 _LOGGER: Final = logger.get_logger(__name__)
 

streamlit/elements/lib/pandas_styler_utils.py

@@ -47,7 +47,7 @@ def marshall_styler(proto: ArrowProto, styler: Styler, default_uuid: str) -> Non
     """
     import pandas as pd
 
-    styler_data_df: pd.DataFrame = styler.data
+    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 "
@@ -62,9 +62,9 @@ def marshall_styler(proto: ArrowProto, styler: Styler, default_uuid: str) -> Non
 
     # We're using protected members of pandas.Styler to get styles,
     # which is not ideal and could break if the interface changes.
-    styler._compute()
+    styler._compute()  # type: ignore
 
-    pandas_styles = styler._translate(False, False)
+    pandas_styles = styler._translate(False, False)  # type: ignore
 
     _marshall_caption(proto, styler)
     _marshall_styles(proto, styler, pandas_styles)
@@ -86,10 +86,10 @@ def _marshall_uuid(proto: ArrowProto, styler: Styler, default_uuid: str) -> None
         If pandas.Styler uuid is not provided, this value will be used.
 
     """
-    if styler.uuid is None:
+    if styler.uuid is None:  # type: ignore[attr-defined]
         styler.set_uuid(default_uuid)
 
-    proto.styler.uuid = str(styler.uuid)
+    proto.styler.uuid = str(styler.uuid)  # type: ignore[attr-defined]
 
 
 def _marshall_caption(proto: ArrowProto, styler: Styler) -> None:
@@ -104,8 +104,8 @@ def _marshall_caption(proto: ArrowProto, styler: Styler) -> None:
         Helps style a DataFrame or Series according to the data with HTML and CSS.
 
     """
-    if styler.caption is not None:
-        proto.styler.caption = styler.caption
+    if styler.caption is not None:  # type: ignore[attr-defined]
+        proto.styler.caption = styler.caption  # type: ignore[attr-defined]
 
 
 def _marshall_styles(
@@ -134,7 +134,10 @@ def _marshall_styles(
             # styles in "table_styles" have a space
             # between the uuid and selector.
             rule = _pandas_style_to_css(
-                "table_styles", style, styler.uuid, separator=" "
+                "table_styles",
+                style,
+                styler.uuid,  # type: ignore[attr-defined]
+                separator=" ",
             )
             css_rules.append(rule)
 
@@ -142,7 +145,12 @@ def _marshall_styles(
         cellstyle = styles["cellstyle"]
         cellstyle = _trim_pandas_styles(cellstyle)
         for style in cellstyle:
-            rule = _pandas_style_to_css("cell_style", style, styler.uuid, separator="_")
+            rule = _pandas_style_to_css(
+                "cell_style",
+                style,
+                styler.uuid,  # type: ignore[attr-defined]
+                separator="_",
+            )
             css_rules.append(rule)
 
     if len(css_rules) > 0:

streamlit/elements/lib/shortcut_utils.py

@@ -0,0 +1,152 @@
+# 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 (
+    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)

streamlit/elements/lib/utils.py

@@ -20,12 +20,12 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Literal,
+    TypeAlias,
     Union,
     overload,
 )
 
 from google.protobuf.message import Message
-from typing_extensions import TypeAlias
 
 from streamlit import config
 from streamlit.elements.lib.form_utils import current_form_id
@@ -49,12 +49,12 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
 
-Key: TypeAlias = Union[str, int]
+Key: TypeAlias = str | int
 
 LabelVisibility: TypeAlias = Literal["visible", "hidden", "collapsed"]
 
-PROTO_SCALAR_VALUE = Union[float, int, bool, str, bytes]
-SAFE_VALUES = Union[
+PROTO_SCALAR_VALUE: TypeAlias = float | int | bool | str | bytes
+SAFE_VALUES: TypeAlias = Union[
     date,
     time,
     datetime,