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

streamlit/elements/lib/layout_utils.py

@@ -14,11 +14,19 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Literal, Union
+from typing import Literal, Union, cast
 
 from typing_extensions import TypeAlias
 
-from streamlit.errors import StreamlitInvalidHeightError, StreamlitInvalidWidthError
+from streamlit.errors import (
+    StreamlitInvalidColumnGapError,
+    StreamlitInvalidHeightError,
+    StreamlitInvalidHorizontalAlignmentError,
+    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.WidthConfig_pb2 import WidthConfig
 
@@ -26,6 +34,9 @@ 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"]]
+Gap: TypeAlias = Literal["small", "medium", "large"]
+HorizontalAlignment: TypeAlias = Literal["left", "center", "right", "distribute"]
+VerticalAlignment: TypeAlias = Literal["top", "center", "bottom", "distribute"]
 
 
 @dataclass
@@ -113,3 +124,78 @@ def get_height_config(height: Height) -> HeightConfig:
     else:
         height_config.use_stretch = True
     return height_config
+
+
+def get_gap_size(gap: str | None, element_type: str) -> GapSize.ValueType:
+    """Convert a gap string or None to a GapSize proto value."""
+    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, element_type=element_type)
+
+
+def validate_horizontal_alignment(horizontal_alignment: HorizontalAlignment) -> None:
+    valid_horizontal_alignments = ["left", "center", "right", "distribute"]
+    if horizontal_alignment not in valid_horizontal_alignments:
+        raise StreamlitInvalidHorizontalAlignmentError(
+            horizontal_alignment, "st.container"
+        )
+
+
+def validate_vertical_alignment(vertical_alignment: VerticalAlignment) -> None:
+    valid_vertical_alignments = ["top", "center", "bottom", "distribute"]
+    if vertical_alignment not in valid_vertical_alignments:
+        raise StreamlitInvalidVerticalAlignmentError(vertical_alignment, "st.container")
+
+
+map_to_flex_terminology = {
+    "left": "start",
+    "center": "center",
+    "right": "end",
+    "top": "start",
+    "bottom": "end",
+    "distribute": "space_between",
+}
+
+
+def get_justify(
+    alignment: HorizontalAlignment | VerticalAlignment,
+) -> Block.FlexContainer.Justify.ValueType:
+    valid_justify = ["start", "center", "end", "space_between"]
+    justify = map_to_flex_terminology[alignment]
+    if justify not in valid_justify:
+        return Block.FlexContainer.Justify.JUSTIFY_UNDEFINED
+    if justify in ["start", "end", "center"]:
+        return cast(
+            "Block.FlexContainer.Justify.ValueType",
+            getattr(Block.FlexContainer.Justify, f"JUSTIFY_{justify.upper()}"),
+        )
+    return cast(
+        "Block.FlexContainer.Justify.ValueType",
+        getattr(Block.FlexContainer.Justify, f"{justify.upper()}"),
+    )
+
+
+def get_align(
+    alignment: HorizontalAlignment | VerticalAlignment,
+) -> Block.FlexContainer.Align.ValueType:
+    valid_align = ["start", "end", "center"]
+    align = map_to_flex_terminology[alignment]
+    if align not in valid_align:
+        return Block.FlexContainer.Align.ALIGN_UNDEFINED
+    return cast(
+        "Block.FlexContainer.Align.ValueType",
+        getattr(Block.FlexContainer.Align, f"ALIGN_{align.upper()}"),
+    )

streamlit/elements/lib/options_selector_utils.py

@@ -22,7 +22,6 @@ from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.errors import StreamlitAPIException
 from streamlit.runtime.state.common import RegisterWidgetResult
 from streamlit.type_util import (
-    T,
     check_python_comparable,
 )
 
@@ -33,6 +32,7 @@ _LOGGER: Final = logger.get_logger(__name__)
 
 _FLOAT_EQUALITY_EPSILON: Final[float] = 0.000000000005
 _Value = TypeVar("_Value")
+T = TypeVar("T")
 
 
 def index_(iterable: Iterable[_Value], x: _Value) -> int:

streamlit/elements/lib/utils.py

@@ -186,6 +186,7 @@ def compute_and_register_element_id(
     user_key: str | None,
     form_id: str | None,
     dg: DeltaGenerator | None = None,
+    style: str | None = None,
     **kwargs: SAFE_VALUES | Iterable[SAFE_VALUES],
 ) -> str:
     """Compute and register the ID for the given element.
@@ -219,6 +220,11 @@ def compute_and_register_element_id(
     dg : DeltaGenerator | None
         The DeltaGenerator of each element. `None` if the element is not a widget.
 
+    style: str | None
+        The style of the element, to provide more context to the user in the
+        error message. This should be `None` if the element does not support
+        the style parameter.
+
     kwargs : SAFE_VALUES | Iterable[SAFE_VALUES]
         The arguments to use to compute the element ID.
         The arguments must be stable, deterministic values.
@@ -228,8 +234,22 @@ def compute_and_register_element_id(
     """
     ctx = get_script_run_ctx()
 
-    # If form_id is provided, add it to the kwargs.
-    kwargs_to_use = {"form_id": form_id, **kwargs} if form_id else kwargs
+    kwargs_to_use = {**kwargs}
+    if form_id:
+        kwargs_to_use["form_id"] = form_id
+    if style:
+        kwargs_to_use["style"] = style
+
+    # If style is provided, use it for the error message, to provide more
+    # context to the user.
+    if style == "borderless":
+        # The borderless style is used by st.feedback, but users expect to see
+        # "feedback" in errors
+        element_type_for_error = "feedback"
+    elif style:
+        element_type_for_error = style
+    else:
+        element_type_for_error = element_type
 
     if ctx:
         # Add the active script hash to give elements on different
@@ -251,7 +271,7 @@ def compute_and_register_element_id(
     )
 
     if ctx:
-        _register_element_id(ctx, element_type, element_id)
+        _register_element_id(ctx, element_type_for_error, element_id)
     return element_id
 
 

streamlit/elements/map.py

@@ -188,14 +188,15 @@ class MapMixin:
 
         Examples
         --------
-        >>> import streamlit as st
         >>> import pandas as pd
-        >>> import numpy as np
+        >>> import streamlit as st
+        >>> from numpy.random import default_rng as rng
         >>>
         >>> df = pd.DataFrame(
-        ...     np.random.randn(1000, 2) / [50, 50] + [37.76, -122.4],
-        ...     columns=["lat", "lon"],
-        ... )
+        >>>     rng(0).standard_normal((1000, 2)) / [50, 50] + [37.76, -122.4],
+        >>>     columns=["lat", "lon"],
+        >>> )
+        >>>
         >>> st.map(df)
 
         .. output::
@@ -210,16 +211,16 @@ class MapMixin:
         and longitude components, as well as set size and color of each
         datapoint dynamically based on other columns:
 
-        >>> import streamlit as st
         >>> import pandas as pd
-        >>> import numpy as np
+        >>> import streamlit as st
+        >>> from numpy.random import default_rng as rng
         >>>
         >>> df = pd.DataFrame(
         ...     {
-        ...         "col1": np.random.randn(1000) / 50 + 37.76,
-        ...         "col2": np.random.randn(1000) / 50 + -122.4,
-        ...         "col3": np.random.randn(1000) * 100,
-        ...         "col4": np.random.rand(1000, 4).tolist(),
+        ...         "col1": rng(0).standard_normal(1000) / 50 + 37.76,
+        ...         "col2": rng(1).standard_normal(1000) / 50 + -122.4,
+        ...         "col3": rng(2).standard_normal(1000) * 100,
+        ...         "col4": rng(3).standard_normal((1000, 4)).tolist(),
         ...     }
         ... )
         >>>

streamlit/elements/plotly_chart.py

@@ -112,8 +112,8 @@ class PlotlySelectionState(TypedDict, total=False):
     displays additional information. Try selecting points in the following
     example:
 
-    >>> import streamlit as st
     >>> import plotly.express as px
+    >>> import streamlit as st
     >>>
     >>> df = px.data.iris()
     >>> fig = px.scatter(
@@ -189,10 +189,10 @@ class PlotlyState(TypedDict, total=False):
     box, or lasso). The current selection state is available through Session
     State or as the output of the chart function.
 
-    >>> import streamlit as st
     >>> import plotly.express as px
+    >>> import streamlit as st
     >>>
-    >>> df = px.data.iris()  # iris is a pandas DataFrame
+    >>> df = px.data.iris()
     >>> fig = px.scatter(df, x="sepal_width", y="sepal_length")
     >>>
     >>> event = st.plotly_chart(fig, key="iris", on_select="rerun")
@@ -328,8 +328,12 @@ class PlotlyMixin:
         you would call Plotly's ``py.plot`` or ``py.iplot``.
 
         .. Important::
-            You must install ``plotly`` to use this command. Your app's
-            performance may be enhanced by installing ``orjson`` as well.
+            You must install ``plotly>=4.0.0`` to use this command. Your app's
+            performance may be enhanced by installing ``orjson`` as well. You
+            can install all charting dependencies (except Bokeh) as an extra
+            with Streamlit:
+
+            >>> pip install streamlit[charts]
 
         Parameters
         ----------
@@ -428,30 +432,26 @@ class PlotlyMixin:
 
         Examples
         --------
-        **Example 1: Basic Plotly Chart**
+        **Example 1: Basic Plotly chart**
 
         The example below comes from the examples at https://plot.ly/python.
         Note that ``plotly.figure_factory`` requires ``scipy`` to run.
 
-        >>> import streamlit as st
-        >>> import numpy as np
         >>> import plotly.figure_factory as ff
+        >>> import streamlit as st
+        >>> from numpy.random import default_rng as rng
         >>>
-        >>> # Add histogram data
-        >>> x1 = np.random.randn(200) - 2
-        >>> x2 = np.random.randn(200)
-        >>> x3 = np.random.randn(200) + 2
-        >>>
-        >>> # Group data together
-        >>> hist_data = [x1, x2, x3]
-        >>>
-        >>> group_labels = ['Group 1', 'Group 2', 'Group 3']
+        >>> hist_data = [
+        ...     rng(0).standard_normal(200) - 2,
+        ...     rng(1).standard_normal(200),
+        ...     rng(2).standard_normal(200) + 2,
+        ... ]
+        >>> group_labels = ["Group 1", "Group 2", "Group 3"]
         >>>
-        >>> # Create distplot with custom bin_size
         >>> fig = ff.create_distplot(
-        ...         hist_data, group_labels, bin_size=[.1, .25, .5])
+        ...     hist_data, group_labels, bin_size=[0.1, 0.25, 0.5]
+        ... )
         >>>
-        >>> # Plot!
         >>> st.plotly_chart(fig)
 
         .. output::
@@ -466,8 +466,8 @@ class PlotlyMixin:
         zoom. In the following example, scroll zoom is disabled, but the zoom
         buttons are still enabled in the modebar.
 
-        >>> import streamlit as st
         >>> import plotly.graph_objects as go
+        >>> import streamlit as st
         >>>
         >>> fig = go.Figure()
         >>> fig.add_trace(

streamlit/elements/pyplot.py

@@ -42,7 +42,11 @@ class PyplotMixin:
         """Display a matplotlib.pyplot figure.
 
         .. Important::
-            You must install ``matplotlib`` to use this command.
+            You must install ``matplotlib>=3.0.0`` to use this command. You can
+            install all charting dependencies (except Bokeh) as an extra with
+            Streamlit:
+
+            >>> pip install streamlit[charts]
 
         Parameters
         ----------
@@ -79,11 +83,11 @@ class PyplotMixin:
 
         Example
         -------
-        >>> import streamlit as st
         >>> import matplotlib.pyplot as plt
-        >>> import numpy as np
+        >>> import streamlit as st
+        >>> from numpy.random import default_rng as rng
         >>>
-        >>> arr = np.random.normal(1, 1, size=100)
+        >>> arr = rng(0).normal(1, 1, size=100)
         >>> fig, ax = plt.subplots()
         >>> ax.hist(arr, bins=20)
         >>>