streamlit-nightly 1.33.1.dev20240426__py2.py3-none-any.whl → 1.33.1.dev20240429__py2.py3-none-any.whl

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/elements/plotly_chart.py

@@ -17,19 +17,37 @@
 from __future__ import annotations
 
 import json
-import urllib.parse
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Union, cast
+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.legacy_caching import caching
 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
@@ -41,19 +59,6 @@ if TYPE_CHECKING:
 # We need to configure the Plotly theme before any Plotly figures are created:
 configure_streamlit_plotly_theme()
 
-SharingMode: TypeAlias = Literal["streamlit", "private", "public", "secret"]
-
-SHARING_MODES: set[SharingMode] = {
-    # This means the plot will be sent to the Streamlit app rather than to
-    # Plotly.
-    "streamlit",
-    # The three modes below are for plots that should be hosted in Plotly.
-    # These are the names Plotly uses for them.
-    "private",
-    "public",
-    "secret",
-}
-
 _AtomicFigureOrData: TypeAlias = Union[
     "go.Figure",
     "go.Data",
@@ -69,17 +74,154 @@ FigureOrData: TypeAlias = Union[
     "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:
-    @gather_metrics("plotly_chart")
+    @overload
     def plotly_chart(
         self,
         figure_or_data: FigureOrData,
         use_container_width: bool = False,
-        sharing: SharingMode = "streamlit",
+        *,
         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
@@ -100,16 +242,33 @@ class PlotlyMixin:
             If True, set the chart width to the column width. This takes
             precedence over the figure's native `width` value.
 
-        sharing : "streamlit", "private", "secret", or "public"
-            Use "streamlit" to insert the plot and all its dependencies
-            directly in the Streamlit app using plotly's offline mode (default).
-            Use any other sharing mode to send the chart to Plotly chart studio, which
-            requires an account. See https://plot.ly/python/chart-studio/ for more information.
-
         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.
 
@@ -144,104 +303,111 @@ class PlotlyMixin:
            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.
 
-        plotly_chart_proto = PlotlyChartProto()
-        if theme != "streamlit" and theme != None:
+        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.'
             )
-        marshall(
-            plotly_chart_proto,
-            figure_or_data,
-            use_container_width,
-            sharing,
-            theme,
-            **kwargs,
-        )
-        return self.dg._enqueue("plotly_chart", plotly_chart_proto)
-
-    @property
-    def dg(self) -> DeltaGenerator:
-        """Get our DeltaGenerator."""
-        return cast("DeltaGenerator", self)
-
-
-def marshall(
-    proto: PlotlyChartProto,
-    figure_or_data: FigureOrData,
-    use_container_width: bool,
-    sharing: SharingMode,
-    theme: Literal["streamlit"] | None,
-    **kwargs: Any,
-) -> None:
-    """Marshall a proto with a Plotly spec.
-
-    See DeltaGenerator.plotly_chart for docs.
-    """
-    # NOTE: "figure_or_data" is the name used in Plotly's .plot() method
-    # for their main parameter. I don't like the name, but its best to keep
-    # it in sync with what Plotly calls it.
 
-    import plotly.tools
+        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."
+            )
 
-    if type_util.is_type(figure_or_data, "matplotlib.figure.Figure"):
-        figure = plotly.tools.mpl_to_plotly(figure_or_data)
+        key = to_key(key)
+        is_selection_activated = on_select != "ignore"
 
-    else:
-        figure = plotly.tools.return_figure_from_figure_or_data(
-            figure_or_data, validate_figure=True
-        )
+        if is_selection_activated:
+            # Run some checks that are only relevant when selections are activated
 
-    if not isinstance(sharing, str) or sharing.lower() not in SHARING_MODES:
-        raise ValueError("Invalid sharing mode for Plotly chart: %s" % sharing)
+            # Import here to avoid circular imports
+            from streamlit.elements.utils import (
+                check_cache_replay_rules,
+                check_callback_rules,
+                check_session_state_rules,
+            )
 
-    proto.use_container_width = use_container_width
+            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
+            )
 
-    if sharing == "streamlit":
-        import plotly.io
+        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))
 
-        proto.figure.spec = plotly.io.to_json(figure, validate=False)
-        proto.figure.config = json.dumps(config)
-
-    else:
-        url = _plot_to_url_or_load_cached_url(
-            figure, sharing=sharing, auto_open=False, **kwargs
+        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,
         )
-        proto.url = _get_embed_url(url)
-    proto.theme = theme or ""
 
+        if is_selection_activated:
+            # Selections are activated, treat plotly chart as a widget:
+            plotly_chart_proto.selection_mode.extend(
+                parse_selection_mode(selection_mode)
+            )
 
-@caching.cache
-def _plot_to_url_or_load_cached_url(*args: Any, **kwargs: Any) -> go.Figure:
-    """Call plotly.plot wrapped in st.cache.
-
-    This is so we don't unnecessarily upload data to Plotly's SASS if nothing
-    changed since the previous upload.
-    """
-    try:
-        # Plotly 4 changed its main package.
-        import chart_studio.plotly as ply
-    except ImportError:
-        import plotly.plotly as ply
-
-    return ply.plot(*args, **kwargs)
-
+            serde = PlotlyChartSelectionSerde()
 
-def _get_embed_url(url: str) -> str:
-    parsed_url = urllib.parse.urlparse(url)
+            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,
+            )
 
-    # Plotly's embed URL is the normal URL plus ".embed".
-    # (Note that our use namedtuple._replace is fine because that's not a
-    # private method! It just has an underscore to avoid clashing with the
-    # tuple field names)
-    parsed_embed_url = parsed_url._replace(path=parsed_url.path + ".embed")
+            self.dg._enqueue("plotly_chart", plotly_chart_proto)
+            return cast(PlotlyState, widget_state.value)
+        else:
+            return self.dg._enqueue("plotly_chart", plotly_chart_proto)
 
-    return urllib.parse.urlunparse(parsed_embed_url)
+    @property
+    def dg(self) -> DeltaGenerator:
+        """Get our DeltaGenerator."""
+        return cast("DeltaGenerator", self)

streamlit/proto/PlotlyChart_pb2.py

@@ -13,7 +13,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n!streamlit/proto/PlotlyChart.proto\"x\n\x0bPlotlyChart\x12\r\n\x03url\x18\x01 \x01(\tH\x00\x12\x19\n\x06\x66igure\x18\x02 \x01(\x0b\x32\x07.FigureH\x00\x12\x1b\n\x13use_container_width\x18\x05 \x01(\x08\x12\r\n\x05theme\x18\x06 \x01(\tB\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')
+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())
@@ -21,8 +21,10 @@ if _descriptor._USE_C_DESCRIPTORS == False:
 
   DESCRIPTOR._options = None
   DESCRIPTOR._serialized_options = b'\n\034com.snowflake.apps.streamlitB\020PlotlyChartProto'
-  _PLOTLYCHART._serialized_start=37
-  _PLOTLYCHART._serialized_end=157
-  _FIGURE._serialized_start=159
-  _FIGURE._serialized_end=197
+  _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/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/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/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",
     }
 )