streamlit-nightly 1.33.1.dev20240426__tar.gz → 1.33.1.dev20240429__tar.gz

{streamlit_nightly-1.33.1.dev20240426 → streamlit_nightly-1.33.1.dev20240429}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: streamlit-nightly
-Version: 1.33.1.dev20240426
+Version: 1.33.1.dev20240429
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.33.1.dev20240426 → streamlit_nightly-1.33.1.dev20240429}/setup.py

@@ -21,7 +21,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.33.1.dev20240426"  # PEP-440
+VERSION = "1.33.1.dev20240429"  # PEP-440
 
 # IMPORTANT: We should try very hard *not* to add dependencies to Streamlit.
 # And if you do add one, make the required version as general as possible:

streamlit_nightly-1.33.1.dev20240429/streamlit/elements/lib/event_utils.py

@@ -0,0 +1,37 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+#
+# 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 typing import Any, Dict
+
+
+class AttributeDictionary(Dict[Any, Any]):
+    """
+    A dictionary subclass that supports attribute-style access.
+
+    This class extends the functionality of a standard dictionary to allow items to be accessed
+    via attribute-style dot notation in addition to the traditional key-based access. If a dictionary
+    item is accessed and is itself a dictionary, it is automatically wrapped in another `AttributeDictionary`,
+    enabling recursive attribute-style access.
+    """
+
+    def __getattr__(self, key):
+        try:
+            item = self.__getitem__(key)
+            return AttributeDictionary(item) if isinstance(item, dict) else item
+        except KeyError as err:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{key}'"
+            ) from err
+
+    __setattr__ = dict.__setitem__

streamlit_nightly-1.33.1.dev20240429/streamlit/elements/plotly_chart.py

@@ -0,0 +1,413 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+#
+# 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.
+
+"""Streamlit support for Plotly charts."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Final,
+    Iterable,
+    List,
+    Literal,
+    TypedDict,
+    Union,
+    cast,
+    overload,
+)
+
+from typing_extensions import TypeAlias
+
+from streamlit import type_util
+from streamlit.deprecation_util import show_deprecation_warning
+from streamlit.elements.form import current_form_id
+from streamlit.elements.lib.event_utils import AttributeDictionary
+from streamlit.elements.lib.streamlit_plotly_theme import (
+    configure_streamlit_plotly_theme,
+)
+from streamlit.errors import StreamlitAPIException
+from streamlit.proto.PlotlyChart_pb2 import PlotlyChart as PlotlyChartProto
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner import get_script_run_ctx
+from streamlit.runtime.state import WidgetCallback, register_widget
+from streamlit.runtime.state.common import compute_widget_id
+from streamlit.type_util import Key, to_key
+
+if TYPE_CHECKING:
+    import matplotlib
+    import plotly.graph_objs as go
+    from plotly.basedatatypes import BaseFigure
+
+    from streamlit.delta_generator import DeltaGenerator
+
+# We need to configure the Plotly theme before any Plotly figures are created:
+configure_streamlit_plotly_theme()
+
+_AtomicFigureOrData: TypeAlias = Union[
+    "go.Figure",
+    "go.Data",
+]
+FigureOrData: TypeAlias = Union[
+    _AtomicFigureOrData,
+    List[_AtomicFigureOrData],
+    # It is kind of hard to figure out exactly what kind of dict is supported
+    # here, as plotly hasn't embraced typing yet. This version is chosen to
+    # align with the docstring.
+    Dict[str, _AtomicFigureOrData],
+    "BaseFigure",
+    "matplotlib.figure.Figure",
+]
+
+SelectionMode: TypeAlias = Literal["lasso", "points", "box"]
+_SELECTION_MODES: Final[set[SelectionMode]] = {"lasso", "points", "box"}
+
+
+class PlotlySelectionState(TypedDict, total=False):
+    """
+    A dictionary representing the current selection state of the plotly chart.
+
+    Attributes
+    ----------
+    points : list[dict[str, Any]]
+        The selected data points in the chart, this also includes
+        the the data points selected by the box and lasso mode.
+
+    point_indices : list[int]
+        The numerical indices of all selected data points in the chart,
+        this also includes the indices of the points selected by the box
+        and lasso mode.
+
+    box : list[dict[str, Any]]
+        The metadata related to the box selection. This includes the
+        coordinates of the selected area.
+
+    lasso : list[dict[str, Any]]
+        The metadata related to the lasso selection. This includes the
+        coordinates of the selected area.
+    """
+
+    points: list[dict[str, Any]]
+    point_indices: list[int]
+    box: list[dict[str, Any]]
+    lasso: list[dict[str, Any]]
+
+
+class PlotlyState(TypedDict, total=False):
+    """
+    A dictionary representing the current selection state of the plotly chart.
+
+    Attributes
+    ----------
+    select : PlotlySelectionState
+        The state of the `on_select` event.
+    """
+
+    select: PlotlySelectionState
+
+
+@dataclass
+class PlotlyChartSelectionSerde:
+    """PlotlyChartSelectionSerde is used to serialize and deserialize the Plotly Chart selection state."""
+
+    def deserialize(self, ui_value: str | None, widget_id: str = "") -> PlotlyState:
+        empty_selection_state: PlotlyState = {
+            "select": {
+                "points": [],
+                "point_indices": [],
+                "box": [],
+                "lasso": [],
+            },
+        }
+
+        selection_state = (
+            empty_selection_state
+            if ui_value is None
+            else cast(PlotlyState, AttributeDictionary(json.loads(ui_value)))
+        )
+
+        if "select" not in selection_state:
+            selection_state = empty_selection_state
+
+        return cast(PlotlyState, AttributeDictionary(selection_state))
+
+    def serialize(self, selection_state: PlotlyState) -> str:
+        return json.dumps(selection_state, default=str)
+
+
+def parse_selection_mode(
+    selection_mode: SelectionMode | Iterable[SelectionMode],
+) -> set[PlotlyChartProto.SelectionMode.ValueType]:
+    """Parse and check the user provided selection modes."""
+    if isinstance(selection_mode, str):
+        # Only a single selection mode was passed
+        selection_mode_set = {selection_mode}
+    else:
+        # Multiple selection modes were passed
+        selection_mode_set = set(selection_mode)
+
+    if not selection_mode_set.issubset(_SELECTION_MODES):
+        raise StreamlitAPIException(
+            f"Invalid selection mode: {selection_mode}. "
+            f"Valid options are: {_SELECTION_MODES}"
+        )
+
+    parsed_selection_modes = []
+    for selection_mode in selection_mode_set:
+        if selection_mode == "points":
+            parsed_selection_modes.append(PlotlyChartProto.SelectionMode.POINTS)
+        elif selection_mode == "lasso":
+            parsed_selection_modes.append(PlotlyChartProto.SelectionMode.LASSO)
+        elif selection_mode == "box":
+            parsed_selection_modes.append(PlotlyChartProto.SelectionMode.BOX)
+    return set(parsed_selection_modes)
+
+
+class PlotlyMixin:
+    @overload
+    def plotly_chart(
+        self,
+        figure_or_data: FigureOrData,
+        use_container_width: bool = False,
+        *,
+        theme: Literal["streamlit"] | None = "streamlit",
+        key: Key | None = None,
+        on_select: Literal["ignore"],  # No default value here to make it work with mypy
+        selection_mode: SelectionMode
+        | Iterable[SelectionMode] = ("points", "box", "lasso"),
+        **kwargs: Any,
+    ) -> DeltaGenerator:
+        ...
+
+    @overload
+    def plotly_chart(
+        self,
+        figure_or_data: FigureOrData,
+        use_container_width: bool = False,
+        *,
+        theme: Literal["streamlit"] | None = "streamlit",
+        key: Key | None = None,
+        on_select: Literal["rerun"] | WidgetCallback = "rerun",
+        selection_mode: SelectionMode
+        | Iterable[SelectionMode] = ("points", "box", "lasso"),
+        **kwargs: Any,
+    ) -> PlotlyState:
+        ...
+
+    @gather_metrics("plotly_chart")
+    def plotly_chart(
+        self,
+        figure_or_data: FigureOrData,
+        use_container_width: bool = False,
+        *,
+        theme: Literal["streamlit"] | None = "streamlit",
+        key: Key | None = None,
+        on_select: Literal["rerun", "ignore"] | WidgetCallback = "ignore",
+        selection_mode: SelectionMode
+        | Iterable[SelectionMode] = ("points", "box", "lasso"),
+        **kwargs: Any,
+    ) -> DeltaGenerator | PlotlyState:
+        """Display an interactive Plotly chart.
+
+        Plotly is a charting library for Python. The arguments to this function
+        closely follow the ones for Plotly's `plot()` function. You can find
+        more about Plotly at https://plot.ly/python.
+
+        To show Plotly charts in Streamlit, call `st.plotly_chart` wherever you
+        would call Plotly's `py.plot` or `py.iplot`.
+
+        Parameters
+        ----------
+        figure_or_data : plotly.graph_objs.Figure, plotly.graph_objs.Data,\
+            dict/list of plotly.graph_objs.Figure/Data
+
+            See https://plot.ly/python/ for examples of graph descriptions.
+
+        use_container_width : bool
+            If True, set the chart width to the column width. This takes
+            precedence over the figure's native `width` value.
+
+        theme : "streamlit" or None
+            The theme of the chart. Currently, we only support "streamlit" for the Streamlit
+            defined design or None to fallback to the default behavior of the library.
+
+        key : str
+            An optional string to use as the unique key for this element when used in combination
+            with ```on_select```. If this is omitted, a key will be generated for the widget based
+            on its content. Multiple widgets of the same type may not share the same key.
+
+        on_select : "ignore" or "rerun" or callable
+            Controls the behavior in response to selection events on the charts. Can be one of:
+            - "ignore" (default): Streamlit will not react to any selection events in the chart.
+            - "rerun: Streamlit will rerun the app when the user selects data in the chart. In this case,
+              ```st.plotly_chart``` will return the selection data as a dictionary.
+            - callable: If a callable is provided, Streamlit will rerun and execute the callable as a
+              callback function before the rest of the app. The selection data can be retrieved through
+              session state by setting the key parameter.
+
+        selection_mode : "points", "box", "lasso" or an iterable of these
+            The selection mode of the table. Can be one of:
+            - "points": The chart will allow selections based on individual data points.
+            - "box": The chart will allow selections based on rectangular areas.
+            - "lasso": The chart will allow selections based on freeform areas.
+            - An iterable of the above options: The chart will allow selections based on the modes specified.
+
+            All selections modes are activated by default.
+
+        **kwargs
+            Any argument accepted by Plotly's `plot()` function.
+
+        Example
+        -------
+        The example below comes straight from the examples at
+        https://plot.ly/python:
+
+        >>> import streamlit as st
+        >>> import numpy as np
+        >>> import plotly.figure_factory as ff
+        >>>
+        >>> # 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']
+        >>>
+        >>> # Create distplot with custom bin_size
+        >>> fig = ff.create_distplot(
+        ...         hist_data, group_labels, bin_size=[.1, .25, .5])
+        >>>
+        >>> # Plot!
+        >>> st.plotly_chart(fig, use_container_width=True)
+
+        .. output::
+           https://doc-plotly-chart.streamlit.app/
+           height: 400px
+
+        """
+        import plotly.io
+        import plotly.tools
+
+        # NOTE: "figure_or_data" is the name used in Plotly's .plot() method
+        # for their main parameter. I don't like the name, but it's best to
+        # keep it in sync with what Plotly calls it.
+
+        if "sharing" in kwargs:
+            show_deprecation_warning(
+                "The `sharing` parameter has been deprecated and will be removed in a future release. "
+                "Plotly charts will always be rendered using Streamlit's offline mode."
+            )
+
+        if theme not in ["streamlit", None]:
+            raise StreamlitAPIException(
+                f'You set theme="{theme}" while Streamlit charts only support theme=”streamlit” or theme=None to fallback to the default library theme.'
+            )
+
+        if on_select not in ["ignore", "rerun"] and not callable(on_select):
+            raise StreamlitAPIException(
+                f"You have passed {on_select} to `on_select`. But only 'ignore', 'rerun', or a callable is supported."
+            )
+
+        key = to_key(key)
+        is_selection_activated = on_select != "ignore"
+
+        if is_selection_activated:
+            # Run some checks that are only relevant when selections are activated
+
+            # Import here to avoid circular imports
+            from streamlit.elements.utils import (
+                check_cache_replay_rules,
+                check_callback_rules,
+                check_session_state_rules,
+            )
+
+            check_cache_replay_rules()
+            if callable(on_select):
+                check_callback_rules(self.dg, on_select)
+            check_session_state_rules(default_value=None, key=key, writes_allowed=False)
+
+        if type_util.is_type(figure_or_data, "matplotlib.figure.Figure"):
+            # Convert matplotlib figure to plotly figure:
+            figure = plotly.tools.mpl_to_plotly(figure_or_data)
+        else:
+            figure = plotly.tools.return_figure_from_figure_or_data(
+                figure_or_data, validate_figure=True
+            )
+
+        plotly_chart_proto = PlotlyChartProto()
+        plotly_chart_proto.use_container_width = use_container_width
+        plotly_chart_proto.theme = theme or ""
+        plotly_chart_proto.form_id = current_form_id(self.dg)
+
+        config = dict(kwargs.get("config", {}))
+        # Copy over some kwargs to config dict. Plotly does the same in plot().
+        config.setdefault("showLink", kwargs.get("show_link", False))
+        config.setdefault("linkText", kwargs.get("link_text", False))
+
+        plotly_chart_proto.spec = plotly.io.to_json(figure, validate=False)
+        plotly_chart_proto.config = json.dumps(config)
+
+        ctx = get_script_run_ctx()
+
+        # We are computing the widget id for all plotly uses
+        # to also allow non-widget Plotly charts to keep their state
+        # when the frontend component gets unmounted and remounted.
+        plotly_chart_proto.id = compute_widget_id(
+            "plotly_chart",
+            user_key=key,
+            key=key,
+            plotly_spec=plotly_chart_proto.spec,
+            plotly_config=plotly_chart_proto.config,
+            selection_mode=selection_mode,
+            is_selection_activated=is_selection_activated,
+            theme=theme,
+            form_id=plotly_chart_proto.form_id,
+            use_container_width=use_container_width,
+            page=ctx.page_script_hash if ctx else None,
+        )
+
+        if is_selection_activated:
+            # Selections are activated, treat plotly chart as a widget:
+            plotly_chart_proto.selection_mode.extend(
+                parse_selection_mode(selection_mode)
+            )
+
+            serde = PlotlyChartSelectionSerde()
+
+            widget_state = register_widget(
+                "plotly_chart",
+                plotly_chart_proto,
+                user_key=key,
+                on_change_handler=on_select if callable(on_select) else None,
+                deserializer=serde.deserialize,
+                serializer=serde.serialize,
+                ctx=ctx,
+            )
+
+            self.dg._enqueue("plotly_chart", plotly_chart_proto)
+            return cast(PlotlyState, widget_state.value)
+        else:
+            return self.dg._enqueue("plotly_chart", plotly_chart_proto)
+
+    @property
+    def dg(self) -> DeltaGenerator:
+        """Get our DeltaGenerator."""
+        return cast("DeltaGenerator", self)

streamlit_nightly-1.33.1.dev20240429/streamlit/proto/PlotlyChart_pb2.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: streamlit/proto/PlotlyChart.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!streamlit/proto/PlotlyChart.proto\"\x98\x02\n\x0bPlotlyChart\x12\x1b\n\x13use_container_width\x18\x05 \x01(\x08\x12\r\n\x05theme\x18\x06 \x01(\t\x12\n\n\x02id\x18\x07 \x01(\t\x12\x32\n\x0eselection_mode\x18\x08 \x03(\x0e\x32\x1a.PlotlyChart.SelectionMode\x12\x0f\n\x07\x66orm_id\x18\t \x01(\t\x12\x0c\n\x04spec\x18\n \x01(\t\x12\x0e\n\x06\x63onfig\x18\x0b \x01(\t\x12\r\n\x03url\x18\x01 \x01(\tH\x00\x12\x19\n\x06\x66igure\x18\x02 \x01(\x0b\x32\x07.FigureH\x00\"/\n\rSelectionMode\x12\n\n\x06POINTS\x10\x00\x12\x07\n\x03\x42OX\x10\x01\x12\t\n\x05LASSO\x10\x02\x42\x07\n\x05\x63hartJ\x04\x08\x03\x10\x04J\x04\x08\x04\x10\x05\"&\n\x06\x46igure\x12\x0c\n\x04spec\x18\x01 \x01(\t\x12\x0e\n\x06\x63onfig\x18\x02 \x01(\tB0\n\x1c\x63om.snowflake.apps.streamlitB\x10PlotlyChartProtob\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'streamlit.proto.PlotlyChart_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\034com.snowflake.apps.streamlitB\020PlotlyChartProto'
+  _PLOTLYCHART._serialized_start=38
+  _PLOTLYCHART._serialized_end=318
+  _PLOTLYCHART_SELECTIONMODE._serialized_start=250
+  _PLOTLYCHART_SELECTIONMODE._serialized_end=297
+  _FIGURE._serialized_start=320
+  _FIGURE._serialized_end=358
+# @@protoc_insertion_point(module_scope)

{streamlit_nightly-1.33.1.dev20240426 → streamlit_nightly-1.33.1.dev20240429}/streamlit/proto/PlotlyChart_pb2.pyi

@@ -17,11 +17,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 import builtins
+import collections.abc
 import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.internal.enum_type_wrapper
 import google.protobuf.message
 import sys
+import typing
 
-if sys.version_info >= (3, 8):
+if sys.version_info >= (3, 10):
     import typing as typing_extensions
 else:
     import typing_extensions
@@ -31,46 +35,86 @@ DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
 class PlotlyChart(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    URL_FIELD_NUMBER: builtins.int
-    FIGURE_FIELD_NUMBER: builtins.int
+    class _SelectionMode:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _SelectionModeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PlotlyChart._SelectionMode.ValueType], builtins.type):  # noqa: F821
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        POINTS: PlotlyChart._SelectionMode.ValueType  # 0
+        """Point selection mode"""
+        BOX: PlotlyChart._SelectionMode.ValueType  # 1
+        """Box selection mode"""
+        LASSO: PlotlyChart._SelectionMode.ValueType  # 2
+        """Lasso selection mode"""
+
+    class SelectionMode(_SelectionMode, metaclass=_SelectionModeEnumTypeWrapper):
+        """Available selection modes:"""
+
+    POINTS: PlotlyChart.SelectionMode.ValueType  # 0
+    """Point selection mode"""
+    BOX: PlotlyChart.SelectionMode.ValueType  # 1
+    """Box selection mode"""
+    LASSO: PlotlyChart.SelectionMode.ValueType  # 2
+    """Lasso selection mode"""
+
     USE_CONTAINER_WIDTH_FIELD_NUMBER: builtins.int
     THEME_FIELD_NUMBER: builtins.int
-    url: builtins.str
-    """If the user chose to send the plot to Plotly's server, then this is the
-    URL that can be used to embed to the plot.
-    """
-    @property
-    def figure(self) -> global___Figure:
-        """If the user chose to not send the plot to Plotly's server, then we pass
-        here the plot's dict spec as JSON.
-        """
+    ID_FIELD_NUMBER: builtins.int
+    SELECTION_MODE_FIELD_NUMBER: builtins.int
+    FORM_ID_FIELD_NUMBER: builtins.int
+    SPEC_FIELD_NUMBER: builtins.int
+    CONFIG_FIELD_NUMBER: builtins.int
+    URL_FIELD_NUMBER: builtins.int
+    FIGURE_FIELD_NUMBER: builtins.int
     use_container_width: builtins.bool
     """If True, will overwrite the chart width spec to fit to container."""
     theme: builtins.str
     """override the properties with a theme. Currently, only "streamlit" or None are accepted."""
+    id: builtins.str
+    """The unique element ID of this chart."""
+    @property
+    def selection_mode(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[global___PlotlyChart.SelectionMode.ValueType]:
+        """Activate selections types on the chart."""
+    form_id: builtins.str
+    """Form ID, filled if selections are activated."""
+    spec: builtins.str
+    """JSON-serialized dict containing keys from the set {data, frames, layout}."""
+    config: builtins.str
+    """JSON-serialized dict with Plotly's config object."""
+    url: builtins.str
+    """DEPRECATED and unused."""
+    @property
+    def figure(self) -> global___Figure:
+        """DEPRECATED and unused."""
     def __init__(
         self,
         *,
-        url: builtins.str = ...,
-        figure: global___Figure | None = ...,
         use_container_width: builtins.bool = ...,
         theme: builtins.str = ...,
+        id: builtins.str = ...,
+        selection_mode: collections.abc.Iterable[global___PlotlyChart.SelectionMode.ValueType] | None = ...,
+        form_id: builtins.str = ...,
+        spec: builtins.str = ...,
+        config: builtins.str = ...,
+        url: builtins.str = ...,
+        figure: global___Figure | None = ...,
     ) -> None: ...
     def HasField(self, field_name: typing_extensions.Literal["chart", b"chart", "figure", b"figure", "url", b"url"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing_extensions.Literal["chart", b"chart", "figure", b"figure", "theme", b"theme", "url", b"url", "use_container_width", b"use_container_width"]) -> None: ...
+    def ClearField(self, field_name: typing_extensions.Literal["chart", b"chart", "config", b"config", "figure", b"figure", "form_id", b"form_id", "id", b"id", "selection_mode", b"selection_mode", "spec", b"spec", "theme", b"theme", "url", b"url", "use_container_width", b"use_container_width"]) -> None: ...
     def WhichOneof(self, oneof_group: typing_extensions.Literal["chart", b"chart"]) -> typing_extensions.Literal["url", "figure"] | None: ...
 
 global___PlotlyChart = PlotlyChart
 
 class Figure(google.protobuf.message.Message):
+    """DEPRECATED and unused."""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     SPEC_FIELD_NUMBER: builtins.int
     CONFIG_FIELD_NUMBER: builtins.int
     spec: builtins.str
-    """JSON-serialized dict containing keys from the set {data, frames, layout}."""
     config: builtins.str
-    """JSON-serialized dict with Plotly's config object."""
     def __init__(
         self,
         *,

{streamlit_nightly-1.33.1.dev20240426 → streamlit_nightly-1.33.1.dev20240429}/streamlit/runtime/state/common.py

@@ -26,7 +26,7 @@ from typing import (
     Dict,
     Final,
     Generic,
-    Sequence,
+    Iterable,
     Tuple,
     TypeVar,
     Union,
@@ -49,6 +49,7 @@ from streamlit.proto.DownloadButton_pb2 import DownloadButton
 from streamlit.proto.FileUploader_pb2 import FileUploader
 from streamlit.proto.MultiSelect_pb2 import MultiSelect
 from streamlit.proto.NumberInput_pb2 import NumberInput
+from streamlit.proto.PlotlyChart_pb2 import PlotlyChart
 from streamlit.proto.Radio_pb2 import Radio
 from streamlit.proto.Selectbox_pb2 import Selectbox
 from streamlit.proto.Slider_pb2 import Slider
@@ -85,6 +86,7 @@ WidgetProto: TypeAlias = Union[
     TextArea,
     TextInput,
     TimeInput,
+    PlotlyChart,
 ]
 
 GENERATED_WIDGET_ID_PREFIX: Final = "$$WIDGET_ID"
@@ -180,7 +182,7 @@ SAFE_VALUES = Union[
 def compute_widget_id(
     element_type: str,
     user_key: str | None = None,
-    **kwargs: SAFE_VALUES | Sequence[SAFE_VALUES],
+    **kwargs: SAFE_VALUES | Iterable[SAFE_VALUES],
 ) -> str:
     """Compute the widget id for the given widget. This id is stable: a given
     set of inputs to this function will always produce the same widget id output.

{streamlit_nightly-1.33.1.dev20240426 → streamlit_nightly-1.33.1.dev20240429}/streamlit/runtime/state/widgets.py

@@ -70,6 +70,7 @@ ELEMENT_TYPE_TO_VALUE_TYPE: Final[
         "time_input": "string_value",
         "component_instance": "json_value",
         "data_editor": "string_value",
+        "plotly_chart": "string_value",
     }
 )