streamlit 1.47.1__py3-none-any.whl → 1.48.1__py3-none-any.whl

streamlit/elements/layouts.py

@@ -21,20 +21,30 @@ from typing_extensions import TypeAlias
 
 from streamlit.delta_generator_singletons import get_dg_singleton_instance
 from streamlit.elements.lib.layout_utils import (
+    Gap,
+    Height,
+    HorizontalAlignment,
+    VerticalAlignment,
+    Width,
     WidthWithoutContent,
+    get_align,
+    get_gap_size,
+    get_height_config,
+    get_justify,
     get_width_config,
+    validate_height,
+    validate_horizontal_alignment,
+    validate_vertical_alignment,
     validate_width,
 )
 from streamlit.elements.lib.utils import Key, compute_and_register_element_id, to_key
 from streamlit.errors import (
     StreamlitAPIException,
-    StreamlitInvalidColumnGapError,
     StreamlitInvalidColumnSpecError,
     StreamlitInvalidVerticalAlignmentError,
 )
 from streamlit.proto.Block_pb2 import Block as BlockProto
-from streamlit.proto.GapSize_pb2 import GapConfig, GapSize
-from streamlit.proto.HeightConfig_pb2 import HeightConfig
+from streamlit.proto.GapSize_pb2 import GapConfig
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.string_util import validate_icon_or_emoji
 
@@ -42,6 +52,7 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
     from streamlit.elements.lib.dialog import Dialog
     from streamlit.elements.lib.mutable_status_container import StatusContainer
+    from streamlit.runtime.state import WidgetCallback
 
 SpecType: TypeAlias = Union[int, Sequence[Union[int, float]]]
 
@@ -51,9 +62,14 @@ class LayoutsMixin:
     def container(
         self,
         *,
-        height: int | None = None,
         border: bool | None = None,
         key: Key | None = None,
+        width: WidthWithoutContent = "stretch",
+        height: Height = "content",
+        horizontal: bool = False,
+        horizontal_alignment: HorizontalAlignment = "left",
+        vertical_alignment: VerticalAlignment = "top",
+        gap: Gap | None = "small",
     ) -> DeltaGenerator:
         """Insert a multi-element container.
 
@@ -61,25 +77,12 @@ class LayoutsMixin:
         multiple elements. This allows you to, for example, insert multiple
         elements into your app out of order.
 
-        To add elements to the returned container, you can use the ``with`` notation
-        (preferred) or just call methods directly on the returned object. See
-        examples below.
+        To add elements to the returned container, you can use the ``with``
+        notation (preferred) or just call commands directly on the returned
+        object. See examples below.
 
         Parameters
         ----------
-        height : int or None
-            Desired height of the container expressed in pixels. If ``None`` (default)
-            the container grows to fit its content. If a fixed height, scrolling is
-            enabled for large content and a grey border is shown around the container
-            to visually separate its scroll surface from the rest of the app.
-
-            .. note::
-                Use scrolling containers sparingly. If you use scrolling
-                containers, avoid heights that exceed 500 pixels. Otherwise,
-                the scroll surface of the container might cover the majority of
-                the screen on mobile devices, which makes it hard to scroll the
-                rest of the app.
-
         border : bool or None
             Whether to show a border around the container. If ``None`` (default), a
             border is shown if the container is set to a fixed height and not
@@ -91,10 +94,102 @@ class LayoutsMixin:
             Additionally, if ``key`` is provided, it will be used as CSS
             class name prefixed with ``st-key-``.
 
+        width : "stretch" or int
+            The width of the container. This can be one of the following:
+
+            - ``"stretch"`` (default): The width of the container matches the
+              width of the parent container.
+            - An integer specifying the width in pixels: The container has a
+              fixed width. If the specified width is greater than the width of
+              the parent container, the width of the container matches the width
+              of the parent container.
+
+        height : "content", "stretch", or int
+            The height of the container. This can be one of the following:
+
+            - ``"content"`` (default): The height of the container matches the
+              height of its content.
+            - ``"stretch"``: The height of the container matches the height of
+              its content or the height of the parent container, whichever is
+              larger. If the container is not in a parent container, the height
+              of the container matches the height of its content.
+            - An integer specifying the height in pixels: The container has a
+              fixed height. If the content is larger than the specified
+              height, scrolling is enabled.
+
+            .. note::
+                Use scrolling containers sparingly. If you use scrolling
+                containers, avoid heights that exceed 500 pixels. Otherwise,
+                the scroll surface of the container might cover the majority of
+                the screen on mobile devices, which makes it hard to scroll the
+                rest of the app.
+
+        horizontal : bool
+            Whether to use horizontal flexbox layout. If this is ``False``
+            (default), the container's elements are laid out vertically. If
+            this is ``True``, the container's elements are laid out
+            horizontally and will overflow to the next line if they don't fit
+            within the container's width.
+
+        horizontal_alignment : "left", "center", "right", or "distribute"
+            The horizontal alignment of the elements inside the container. This
+            can be one of the following:
+
+            - ``"left"`` (default): Elements are aligned to the left side of
+              the container.
+            - ``"center"``: Elements are horizontally centered inside the
+              container.
+            - ``"right"``: Elements are aligned to the right side of the
+              container.
+            - ``"distribute"``: Elements are distributed evenly in the
+              container. This increases the horizontal gap between elements to
+              fill the width of the container. A standalone element is aligned
+              to the left.
+
+              When ``horizontal`` is ``False``, ``"distribute"`` aligns the
+              elements the same as ``"left"``.
+
+        vertical_alignment : "top", "center", "bottom", or "distribute"
+            The vertical alignment of the elements inside the container. This
+            can be one of the following:
+
+            - ``"top"`` (default): Elements are aligned to the top of the
+              container.
+            - ``"center"``: Elements are vertically centered inside the
+              container.
+            - ``"bottom"``: Elements are aligned to the bottom of the
+              container.
+            - ``"distribute"``: Elements are distributed evenly in the
+              container. This increases the vertical gap between elements to
+              fill the height of the container. A standalone element is aligned
+              to the top.
+
+              When ``horizontal`` is ``True``, ``"distribute"`` aligns the
+              elements the same as ``"top"``.
+
+        gap : "small", "medium", "large", or None
+            The minimum gap size between the elements inside the container.
+            This can be one of the following:
+
+            - ``"small"`` (default): 1rem gap between the elements.
+            - ``"medium"``: 2rem gap between the elements.
+            - ``"large"``: 4rem gap between the elements.
+            - ``None``: No gap between the elements.
+
+            The rem unit is relative to the ``theme.baseFontSize``
+            configuration option.
+
+            The minimum gap applies to both the vertical and horizontal gaps
+            between the elements. Elements may have larger gaps in one
+            direction if you use a distributed horizontal alignment or fixed
+            height.
 
         Examples
         --------
-        Inserting elements using ``with`` notation:
+        **Example 1: Inserting elements using ``with`` notation**
+
+        You can use the ``with`` statement to insert any element into a
+        container.
 
         >>> import streamlit as st
         >>>
@@ -110,7 +205,12 @@ class LayoutsMixin:
             https://doc-container1.streamlit.app/
             height: 520px
 
-        Inserting elements out of order:
+        **Example 2: Inserting elements out of order**
+
+        When you create a container, its position in the app remains fixed and
+        you can add elements to it at any time. This allows you to insert
+        elements out of order in your app. You can also write to the container
+        by calling commands directly on the container object.
 
         >>> import streamlit as st
         >>>
@@ -118,14 +218,16 @@ class LayoutsMixin:
         >>> container.write("This is inside the container")
         >>> st.write("This is outside the container")
         >>>
-        >>> # Now insert some more in the container
         >>> container.write("This is inside too")
 
         .. output ::
             https://doc-container2.streamlit.app/
             height: 300px
 
-        Using ``height`` to make a grid:
+        **Example 3: Grid layout with columns and containers**
+
+        You can create a grid with a fixed number of elements per row by using
+        columns and containers.
 
         >>> import streamlit as st
         >>>
@@ -140,7 +242,10 @@ class LayoutsMixin:
             https://doc-container3.streamlit.app/
             height: 350px
 
-        Using ``height`` to create a scrolling container for long content:
+        **Example 4: Vertically scrolling container**
+
+        You can create a vertically scrolling container by setting a fixed
+        height.
 
         >>> import streamlit as st
         >>>
@@ -153,28 +258,63 @@ class LayoutsMixin:
             https://doc-container4.streamlit.app/
             height: 400px
 
+        **Example 5: Horizontal container**
+
+        You can create a row of widgets using a horizontal container. Use
+        ``horizontal_alignment`` to specify the alignment of the elements.
+
+        >>> import streamlit as st
+        >>>
+        >>> flex = st.container(horizontal=True, horizontal_alignment="right")
+        >>>
+        >>> for card in range(3):
+        >>>     flex.button(f"Button {card + 1}")
+
+        .. output ::
+            https://doc-container5.streamlit.app/
+            height: 250px
+
         """
         key = to_key(key)
         block_proto = BlockProto()
         block_proto.allow_empty = False
         block_proto.flex_container.border = border or False
-        block_proto.flex_container.wrap = False
+        block_proto.flex_container.gap_config.gap_size = get_gap_size(
+            gap, "st.container"
+        )
+
+        validate_horizontal_alignment(horizontal_alignment)
+        validate_vertical_alignment(vertical_alignment)
+        if horizontal:
+            block_proto.flex_container.wrap = True
+            block_proto.flex_container.direction = (
+                BlockProto.FlexContainer.Direction.HORIZONTAL
+            )
+            block_proto.flex_container.justify = get_justify(horizontal_alignment)
+            block_proto.flex_container.align = get_align(vertical_alignment)
+        else:
+            block_proto.flex_container.wrap = False
+            block_proto.flex_container.direction = (
+                BlockProto.FlexContainer.Direction.VERTICAL
+            )
+            block_proto.flex_container.justify = get_justify(vertical_alignment)
+            block_proto.flex_container.align = get_align(horizontal_alignment)
+
+        validate_width(width)
+        block_proto.width_config.CopyFrom(get_width_config(width))
 
         if isinstance(height, int) or border:
             block_proto.allow_empty = True
 
-        if height:
-            # Activate scrolling container behavior:
-            height_config = HeightConfig()
-            height_config.pixel_height = height
-            # Use block-level height_config instead of flex_container
-            block_proto.height_config.CopyFrom(height_config)
+        if border is not None:
+            block_proto.flex_container.border = border
+        elif isinstance(height, int):
+            block_proto.flex_container.border = True
+        else:
+            block_proto.flex_container.border = False
 
-            if border is None:
-                # If border is None, we activated the
-                # border as default setting for scrolling
-                # containers.
-                block_proto.flex_container.border = True
+        validate_height(height, allow_content=True)
+        block_proto.height_config.CopyFrom(get_height_config(height))
 
         if key:
             # At the moment, the ID is only used for extracting the
@@ -193,9 +333,10 @@ class LayoutsMixin:
         self,
         spec: SpecType,
         *,
-        gap: Literal["small", "medium", "large"] | None = "small",
+        gap: Gap | None = "small",
         vertical_alignment: Literal["top", "center", "bottom"] = "top",
         border: bool = False,
+        width: WidthWithoutContent = "stretch",
     ) -> list[DeltaGenerator]:
         """Insert containers laid out as side-by-side columns.
 
@@ -244,6 +385,14 @@ class LayoutsMixin:
             ``False`` (default), no border is shown. If this is ``True``, a
             border is shown around each column.
 
+        width : int or "stretch"
+            The desired width of the columns expressed in pixels. If this is
+            ``"stretch"`` (default), Streamlit sets the width of the columns to
+            match the width of the parent container. Otherwise, this must be an
+            integer. If the specified width is greater than the width of the
+            parent container, Streamlit sets the width of the columns to match
+            the width of the parent container.
+
         Returns
         -------
         list of containers
@@ -281,16 +430,16 @@ class LayoutsMixin:
         You can just call methods directly on the returned objects:
 
         >>> import streamlit as st
-        >>> import numpy as np
+        >>> from numpy.random import default_rng as rng
         >>>
+        >>> df = rng(0).standard_normal((10, 1))
         >>> col1, col2 = st.columns([3, 1])
-        >>> data = np.random.randn(10, 1)
         >>>
         >>> col1.subheader("A wide column with a chart")
-        >>> col1.line_chart(data)
+        >>> col1.line_chart(df)
         >>>
         >>> col2.subheader("A narrow column with the data")
-        >>> col2.write(data)
+        >>> col2.write(df)
 
         .. output ::
             https://doc-columns2.streamlit.app/
@@ -317,7 +466,6 @@ class LayoutsMixin:
         Adjust vertical alignment to customize your grid layouts.
 
         >>> import streamlit as st
-        >>> import numpy as np
         >>>
         >>> vertical_alignment = st.selectbox(
         >>>     "Vertical alignment", ["top", "center", "bottom"], index=2
@@ -370,28 +518,11 @@ class LayoutsMixin:
 
         if vertical_alignment not in vertical_alignment_mapping:
             raise StreamlitInvalidVerticalAlignmentError(
-                vertical_alignment=vertical_alignment
+                vertical_alignment=vertical_alignment,
+                element_type="st.columns",
             )
 
-        def column_gap(gap: str | None) -> GapSize.ValueType:
-            gap_mapping = {
-                "small": GapSize.SMALL,
-                "medium": GapSize.MEDIUM,
-                "large": GapSize.LARGE,
-            }
-
-            if isinstance(gap, str):
-                gap_size = gap.lower()
-                valid_sizes = gap_mapping.keys()
-
-                if gap_size in valid_sizes:
-                    return gap_mapping[gap_size]
-            elif gap is None:
-                return GapSize.NONE
-
-            raise StreamlitInvalidColumnGapError(gap=gap)
-
-        gap_size = column_gap(gap)
+        gap_size = get_gap_size(gap, "st.columns")
         gap_config = GapConfig()
         gap_config.gap_size = gap_size
 
@@ -413,6 +544,11 @@ class LayoutsMixin:
         block_proto.flex_container.wrap = True
         block_proto.flex_container.gap_config.CopyFrom(gap_config)
         block_proto.flex_container.scale = 1
+        block_proto.flex_container.align = BlockProto.FlexContainer.Align.STRETCH
+
+        validate_width(width=width)
+        block_proto.width_config.CopyFrom(get_width_config(width=width))
+
         row = self.dg._block(block_proto)
         total_weight = sum(weights)
         return [row._block(column_proto(w / total_weight)) for w in weights]
@@ -502,17 +638,17 @@ class LayoutsMixin:
         Or you can just call methods directly on the returned objects:
 
         >>> import streamlit as st
-        >>> import numpy as np
+        >>> from numpy.random import default_rng as rng
+        >>>
+        >>> df = rng(0).standard_normal((10, 1))
         >>>
         >>> tab1, tab2 = st.tabs(["📈 Chart", "🗃 Data"])
-        >>> data = np.random.randn(10, 1)
         >>>
         >>> tab1.subheader("A tab with a chart")
-        >>> tab1.line_chart(data)
+        >>> tab1.line_chart(df)
         >>>
         >>> tab2.subheader("A tab with the data")
-        >>> tab2.write(data)
-
+        >>> tab2.write(df)
 
         .. output ::
             https://doc-tabs2.streamlit.app/
@@ -682,7 +818,8 @@ class LayoutsMixin:
         help: str | None = None,
         icon: str | None = None,
         disabled: bool = False,
-        use_container_width: bool = False,
+        use_container_width: bool | None = None,
+        width: Width = "content",
     ) -> DeltaGenerator:
         r"""Insert a popover container.
 
@@ -752,16 +889,39 @@ class LayoutsMixin:
         use_container_width : bool
             Whether to expand the button's width to fill its parent container.
             If ``use_container_width`` is ``False`` (default), Streamlit sizes
-            the button to fit its contents. If ``use_container_width`` is
+            the button to fit its content. If ``use_container_width`` is
             ``True``, the width of the button matches its parent container.
 
-            In both cases, if the contents of the button are wider than the
-            parent container, the contents will line wrap.
+            In both cases, if the content of the button is wider than the
+            parent container, the content will line wrap.
 
-            The popover containter's minimimun width matches the width of its
+            The popover container's minimum width matches the width of its
+            button. The popover container may be wider than its button to fit
+            the container's content.
+
+        width : int, "stretch", or "content"
+            The width of the button. This can be one of the following:
+
+            - ``"content"`` (default): The width of the button matches the
+              width of its content, but doesn't exceed the width of the parent
+              container.
+            - ``"stretch"``: The width of the button matches the width of the
+              parent container.
+            - An integer specifying the width in pixels: The button has a
+              fixed width. If the specified width is greater than the width of
+              the parent container, the width of the button matches the width
+              of the parent container.
+
+            The popover container's minimum width matches the width of its
             button. The popover container may be wider than its button to fit
             the container's contents.
 
+        .. deprecated::
+            ``use_container_width`` is deprecated and will be removed in a
+            future release. For ``use_container_width=True``, use
+            ``width="stretch"``. For ``use_container_width=False``, use
+            ``width="content"``.
+
         Examples
         --------
         You can use the ``with`` notation to insert any element into a popover:
@@ -799,9 +959,11 @@ class LayoutsMixin:
         if label is None:
             raise StreamlitAPIException("A label is required for a popover")
 
+        if use_container_width is not None:
+            width = "stretch" if use_container_width else "content"
+
         popover_proto = BlockProto.Popover()
         popover_proto.label = label
-        popover_proto.use_container_width = use_container_width
         popover_proto.disabled = disabled
         if help:
             popover_proto.help = str(help)
@@ -812,6 +974,9 @@ class LayoutsMixin:
         block_proto.allow_empty = True
         block_proto.popover.CopyFrom(popover_proto)
 
+        validate_width(width, allow_content=True)
+        block_proto.width_config.CopyFrom(get_width_config(width))
+
         return self.dg._block(block_proto=block_proto)
 
     @gather_metrics("status")
@@ -948,6 +1113,7 @@ class LayoutsMixin:
         *,
         dismissible: bool = True,
         width: Literal["small", "large"] = "small",
+        on_dismiss: Literal["ignore", "rerun"] | WidgetCallback = "ignore",
     ) -> Dialog:
         """Inserts the dialog container.
 
@@ -955,7 +1121,7 @@ class LayoutsMixin:
         The dialog_decorator also has a more descriptive docstring since it is user-facing.
         """
         return get_dg_singleton_instance().dialog_container_cls._create(
-            self.dg, title, dismissible=dismissible, width=width
+            self.dg, title, dismissible=dismissible, width=width, on_dismiss=on_dismiss
         )
 
     @property

streamlit/elements/lib/built_in_chart_utils.py

@@ -356,7 +356,13 @@ def prep_chart_data_for_add_rows(
         df.index = pd.RangeIndex(start=start, stop=stop, step=old_step)
         add_rows_metadata.last_index = stop - 1
 
-    out_data, *_ = _prep_data(df, **add_rows_metadata.columns)
+    out_data, *_ = _prep_data(
+        df,
+        x_column=add_rows_metadata.columns["x_column"],
+        y_column_list=add_rows_metadata.columns["y_column_list"],
+        color_column=add_rows_metadata.columns["color_column"],
+        size_column=add_rows_metadata.columns["size_column"],
+    )
 
     return out_data, add_rows_metadata
 
@@ -597,7 +603,7 @@ def _maybe_reset_index_in_place(
             x_column = _SEPARATED_INDEX_COLUMN_NAME
         else:
             # Reuse index's name for the new column.
-            x_column = df.index.name
+            x_column = str(df.index.name)
 
         df.index.name = x_column
         df.reset_index(inplace=True)  # noqa: PD002
@@ -988,7 +994,9 @@ def _get_color_encoding(
                 return alt.ColorValue(to_css_color(cast("Any", color_value[0])))
             return alt.Color(
                 field=color_column if color_column is not None else alt.Undefined,
-                scale=alt.Scale(range=[to_css_color(c) for c in color_values]),
+                scale=alt.Scale(
+                    domain=y_column_list, range=[to_css_color(c) for c in color_values]
+                ),
                 legend=_COLOR_LEGEND_SETTINGS,
                 type="nominal",
                 title=" ",

streamlit/elements/lib/dialog.py

@@ -19,6 +19,7 @@ from typing import TYPE_CHECKING, Literal, cast
 from typing_extensions import Self, TypeAlias
 
 from streamlit.delta_generator import DeltaGenerator
+from streamlit.elements.lib.utils import compute_and_register_element_id
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
@@ -26,11 +27,13 @@ from streamlit.runtime.scriptrunner_utils.script_run_context import (
     enqueue_message,
     get_script_run_ctx,
 )
+from streamlit.runtime.state import register_widget
 
 if TYPE_CHECKING:
     from types import TracebackType
 
     from streamlit.cursor import Cursor
+    from streamlit.runtime.state import WidgetCallback
 
 DialogWidth: TypeAlias = Literal["small", "large"]
 
@@ -81,12 +84,51 @@ class Dialog(DeltaGenerator):
         *,
         dismissible: bool = True,
         width: DialogWidth = "small",
+        on_dismiss: Literal["ignore", "rerun"] | WidgetCallback = "ignore",
     ) -> Dialog:
+        # Validation for on_dismiss parameter
+        if on_dismiss not in ["ignore", "rerun"] and not callable(on_dismiss):
+            raise StreamlitAPIException(
+                f"You have passed {on_dismiss} to `on_dismiss`. But only 'ignore', "
+                "'rerun', or a callable is supported."
+            )
+
         block_proto = BlockProto()
         block_proto.dialog.title = title
         block_proto.dialog.dismissible = dismissible
         block_proto.dialog.width = _process_dialog_width_input(width)
 
+        # Handle on_dismiss functionality
+        is_dismiss_activated = on_dismiss != "ignore"
+        element_id = None
+
+        if is_dismiss_activated:
+            # Register as widget when on_dismiss is activated
+
+            ctx = get_script_run_ctx()
+
+            element_id = compute_and_register_element_id(
+                "dialog",
+                user_key=None,
+                # Dialogs within forms still trigger a normal rerun:
+                form_id="",
+                dg=parent,
+                title=title,
+                dismissible=dismissible,
+                width=width,
+                on_dismiss=str(on_dismiss) if not callable(on_dismiss) else "callback",
+            )
+            block_proto.dialog.id = element_id
+
+            register_widget(
+                element_id,
+                on_change_handler=on_dismiss if callable(on_dismiss) else None,
+                deserializer=lambda x: x,  # Simple passthrough for trigger values
+                serializer=lambda x: x,  # Simple passthrough for trigger values
+                ctx=ctx,
+                value_type="trigger_value",
+            )
+
         # We store the delta path here, because in _update we enqueue a new proto
         # message to update the open status. Without this, the dialog content is gone
         # when the _update message is sent
@@ -97,6 +139,7 @@ class Dialog(DeltaGenerator):
 
         dialog._delta_path = delta_path
         dialog._current_proto = block_proto
+
         return dialog
 
     def __init__(

streamlit/elements/lib/file_uploader_utils.py

@@ -31,6 +31,18 @@ TYPE_PAIRS = [
 ]
 
 
+def _get_main_filename_and_extension(filename: str) -> tuple[str, str]:
+    """Returns the main part of a filename and its extension."""
+    # Handle NTFS Alternate Data Streams (ADS) on Windows, e.g: "file.txt:ads" -> ("file.txt", ".txt")
+    if os.name == "nt" and ":" in filename:
+        main_filename, ads_part = filename.split(":", 1)
+        # We only treat it as an ADS if the part after the colon has an extension.
+        if os.path.splitext(ads_part)[1]:
+            return main_filename, os.path.splitext(main_filename)[1]
+
+    return filename, os.path.splitext(filename)[1]
+
+
 def normalize_upload_file_type(file_type: str | Sequence[str]) -> Sequence[str]:
     if isinstance(file_type, str):
         file_type = [file_type]
@@ -59,8 +71,15 @@ def enforce_filename_restriction(filename: str, allowed_types: Sequence[str]) ->
     enforce file type check by extension on the frontend, but we check it on backend
     before returning file to the user to protect ourselves.
     """
-    normalized_filename = filename.lower()
-    base_name, extension = os.path.splitext(normalized_filename)
+
+    # Ensure that there isn't a null byte in a filename
+    # since this could be a workaround to bypass the file type check.
+    if "\0" in filename:
+        raise StreamlitAPIException("Filename cannot contain null bytes.")
+
+    main_filename, extension = _get_main_filename_and_extension(filename)
+    normalized_filename = main_filename.lower()
+
     normalized_allowed_types = [allowed_type.lower() for allowed_type in allowed_types]
 
     if not any(