streamlit-nightly 1.38.1.dev20240923__py2.py3-none-any.whl → 1.38.1.dev20240925__py2.py3-none-any.whl

streamlit/__init__.py

@@ -204,7 +204,6 @@ metric = _main.metric
 multiselect = _main.multiselect
 number_input = _main.number_input
 page_link = _main.page_link
-pills = _main.pills
 plotly_chart = _main.plotly_chart
 popover = _main.popover
 progress = _main.progress
@@ -266,6 +265,7 @@ dialog = _dialog_decorator
 fragment = _fragment
 
 # Experimental APIs
+experimental_audio_input = _main.experimental_audio_input
 experimental_dialog = _experimental_dialog_decorator
 experimental_fragment = _experimental_fragment
 experimental_user = _UserInfoProxy()

streamlit/config_option.py

@@ -179,6 +179,8 @@ class ConfigOption:
         self.where_defined = ConfigOption.DEFAULT_DEFINITION
         self.type = type_
         self.sensitive = sensitive
+        # infer multiple values if the default value is a list or tuple
+        self.multiple = isinstance(default_val, (list, tuple))
 
         if self.replaced_by:
             self.deprecated = True

streamlit/delta_generator.py

@@ -74,6 +74,7 @@ from streamlit.elements.snow import SnowMixin
 from streamlit.elements.text import TextMixin
 from streamlit.elements.toast import ToastMixin
 from streamlit.elements.vega_charts import VegaChartsMixin
+from streamlit.elements.widgets.audio_input import AudioInputMixin
 from streamlit.elements.widgets.button import ButtonMixin
 from streamlit.elements.widgets.button_group import ButtonGroupMixin
 from streamlit.elements.widgets.camera_input import CameraInputMixin
@@ -144,6 +145,7 @@ def _maybe_print_use_warning() -> None:
 
 class DeltaGenerator(
     AlertMixin,
+    AudioInputMixin,
     BalloonsMixin,
     BokehMixin,
     ButtonMixin,

streamlit/elements/deck_gl_json_chart.py

@@ -15,11 +15,35 @@
 from __future__ import annotations
 
 import json
-from typing import TYPE_CHECKING, Any, Dict, Final, Mapping, cast
+from dataclasses import dataclass
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Final,
+    Iterable,
+    Literal,
+    Mapping,
+    TypedDict,
+    cast,
+    overload,
+)
+
+from typing_extensions import TypeAlias
 
 from streamlit import config
+from streamlit.elements.lib.event_utils import AttributeDictionary
+from streamlit.elements.lib.form_utils import current_form_id
+from streamlit.elements.lib.policies import check_widget_policies
+from streamlit.elements.lib.utils import Key, compute_and_register_element_id, to_key
+from streamlit.errors import StreamlitAPIException
 from streamlit.proto.DeckGlJsonChart_pb2 import DeckGlJsonChart as PydeckProto
 from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.runtime.state import (
+    WidgetCallback,
+    register_widget,
+)
 
 if TYPE_CHECKING:
     from pydeck import Deck
@@ -32,16 +56,146 @@ EMPTY_MAP: Final[Mapping[str, Any]] = {
     "initialViewState": {"latitude": 0, "longitude": 0, "pitch": 0, "zoom": 1},
 }
 
+SelectionMode: TypeAlias = Literal["single-object", "multi-object"]
+_SELECTION_MODES: Final[set[SelectionMode]] = {
+    "single-object",
+    "multi-object",
+}
+
+
+def parse_selection_mode(
+    selection_mode: SelectionMode | Iterable[SelectionMode],
+) -> set[PydeckProto.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.
+        # This is not yet supported as a functionality, but the infra is here to
+        # support it in the future!
+        # @see DeckGlJsonChart.tsx
+        raise StreamlitAPIException(
+            f"Invalid selection mode: {selection_mode}. ",
+            "Selection mode must be a single value, but got a set instead.",
+        )
+
+    if not selection_mode_set.issubset(_SELECTION_MODES):
+        raise StreamlitAPIException(
+            f"Invalid selection mode: {selection_mode}. "
+            f"Valid options are: {_SELECTION_MODES}"
+        )
+
+    if selection_mode_set.issuperset({"single-object", "multi-object"}):
+        raise StreamlitAPIException(
+            "Only one of `single-object` or `multi-object` can be selected as selection mode."
+        )
+
+    parsed_selection_modes = []
+    for selection_mode in selection_mode_set:
+        if selection_mode == "single-object":
+            parsed_selection_modes.append(PydeckProto.SelectionMode.SINGLE_OBJECT)
+        elif selection_mode == "multi-object":
+            parsed_selection_modes.append(PydeckProto.SelectionMode.MULTI_OBJECT)
+    return set(parsed_selection_modes)
+
+
+class LayerSelectionState(TypedDict, total=False):
+    """
+    The schema for the PyDeck Layer Selection State
+
+    Attributes
+    ----------
+    indices : dict[str, list[int]]
+        Dictionary where keys are the layer id and values are lists of indices
+        of selected objects.
+    objects : dict[str, list[dict[str, Any]]]
+        Dictionary where keys are the layer id and values are lists of metadata
+        objects for the selected items.
+    """
+
+    indices: dict[str, list[int]]
+    objects: dict[str, list[dict[str, Any]]]
+
+
+class PydeckState(TypedDict, total=False):
+    """
+    The schema for the PyDeck State
+
+    Attributes
+    ----------
+    selection : LayerSelectionState
+        The selection state of the PyDeck layers.
+    """
+
+    selection: LayerSelectionState
+
+
+@dataclass
+class PydeckSelectionSerde:
+    """PydeckSelectionSerde is used to serialize and deserialize the Pydeck selection state."""
+
+    def deserialize(self, ui_value: str | None, widget_id: str = "") -> PydeckState:
+        empty_selection_state: PydeckState = {
+            "selection": {
+                "indices": {},
+                "objects": {},
+            }
+        }
+
+        selection_state = (
+            empty_selection_state if ui_value is None else json.loads(ui_value)
+        )
+
+        # We have seen some situations where the ui_value was just an empty
+        # dict, so we want to ensure that it always returns the empty state in
+        # case this happens.
+        if "selection" not in selection_state:
+            selection_state = empty_selection_state
+
+        return cast(PydeckState, AttributeDictionary(selection_state))
+
+    def serialize(self, selection_state: PydeckState) -> str:
+        return json.dumps(selection_state, default=str)
+
 
 class PydeckMixin:
+    @overload
+    def pydeck_chart(
+        self,
+        pydeck_obj: Deck | None = None,
+        *,
+        use_container_width: bool = False,
+        selection_mode: Literal[
+            "single-object"
+        ],  # Selection mode will only be activated by on_select param, this is a default value here to make it work with mypy
+        on_select: Literal["ignore"],  # No default value here to make it work with mypy
+        key: Key | None = None,
+    ) -> DeltaGenerator: ...
+
+    @overload
+    def pydeck_chart(
+        self,
+        pydeck_obj: Deck | None = None,
+        *,
+        use_container_width: bool = False,
+        selection_mode: SelectionMode = "single-object",
+        on_select: Literal["rerun"] | WidgetCallback = "rerun",
+        key: Key | None = None,
+    ) -> PydeckState: ...
+
     @gather_metrics("pydeck_chart")
     def pydeck_chart(
         self,
         pydeck_obj: Deck | None = None,
+        *,
         use_container_width: bool = False,
         width: int | None = None,
         height: int | None = None,
-    ) -> DeltaGenerator:
+        selection_mode: SelectionMode = "single-object",
+        on_select: Literal["rerun", "ignore"] | WidgetCallback = "ignore",
+        key: Key | None = None,
+    ) -> DeltaGenerator | PydeckState:
         """Draw a chart using the PyDeck library.
 
         This supports 3D maps, point clouds, and more! More info about PyDeck
@@ -92,6 +246,37 @@ class PydeckMixin:
             Desired height of the chart expressed in pixels. If ``height`` is
             ``None`` (default), Streamlit sets the height of the chart to fit
             its contents according to the plotting library.
+        on_select : "ignore" or "rerun" or callable
+            How the chart should respond to user selection events. This controls
+            whether or not the dataframe behaves like an input widget.
+            ``on_select`` can be one of the following:
+
+            - ``"ignore"`` (default): Streamlit will not react to any selection
+              events in the dataframe. The dataframe will not behave like an
+              input widget.
+            - ``"rerun"``: Rerun the script when a selection is made.
+            - callable: A Python callable that will be called when a selection
+                is made. The callable will be passed the selection state as a
+                dictionary.
+
+            If ``on_select`` is not ``"ignore"``, ensure that the layers given
+            to the ``pydeck_obj`` have stable IDs so that selection state can be
+            maintained across reruns.
+        selection_mode : "single-object" or "multi-object"
+            The types of selections Streamlit should allow. This can be one of
+            the following:
+
+            - ``"single-object"`` (default): Only one object can be selected at
+              a time.
+            - ``"multi-object"``: Multiple objects can be selected at a time.
+        key : str
+            An optional string to use for giving this element a stable
+            identity. If ``key`` is ``None`` (default), this element's identity
+            will be determined based on the values of the other parameters.
+
+            Additionally, if selections are activated and ``key`` is provided,
+            Streamlit will register the key in Session State to store the
+            selection state. The selection state is read-only.
 
         Example
         -------
@@ -149,9 +334,79 @@ class PydeckMixin:
 
         """
         pydeck_proto = PydeckProto()
-        marshall(
-            pydeck_proto, pydeck_obj, use_container_width, width=width, height=height
-        )
+
+        ctx = get_script_run_ctx()
+
+        if pydeck_obj is None:
+            spec = json.dumps(EMPTY_MAP)
+        else:
+            spec = pydeck_obj.to_json()
+
+        pydeck_proto.json = spec
+        pydeck_proto.use_container_width = use_container_width
+
+        if width:
+            pydeck_proto.width = width
+        if height:
+            pydeck_proto.height = height
+
+        tooltip = _get_pydeck_tooltip(pydeck_obj)
+        if tooltip:
+            pydeck_proto.tooltip = json.dumps(tooltip)
+
+        mapbox_token = config.get_option("mapbox.token")
+        if mapbox_token:
+            pydeck_proto.mapbox_token = mapbox_token
+
+        key = to_key(key)
+        is_selection_activated = on_select != "ignore"
+
+        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 is_selection_activated:
+            # Selections are activated, treat Pydeck as a widget:
+            pydeck_proto.selection_mode.extend(parse_selection_mode(selection_mode))
+
+            # Run some checks that are only relevant when selections are activated
+            is_callback = callable(on_select)
+            check_widget_policies(
+                self.dg,
+                key,
+                on_change=cast(WidgetCallback, on_select) if is_callback else None,
+                default_value=None,
+                writes_allowed=False,
+                enable_check_callback_rules=is_callback,
+            )
+            pydeck_proto.form_id = current_form_id(self.dg)
+
+            pydeck_proto.id = compute_and_register_element_id(
+                "deck_gl_json_chart",
+                user_key=key,
+                is_selection_activated=is_selection_activated,
+                selection_mode=selection_mode,
+                use_container_width=use_container_width,
+                spec=spec,
+                form_id=pydeck_proto.form_id,
+            )
+
+            serde = PydeckSelectionSerde()
+
+            widget_state = register_widget(
+                "deck_gl_json_chart",
+                pydeck_proto,
+                ctx=ctx,
+                deserializer=serde.deserialize,
+                on_change_handler=on_select if callable(on_select) else None,
+                serializer=serde.serialize,
+            )
+
+            self.dg._enqueue("deck_gl_json_chart", pydeck_proto)
+
+            return cast(PydeckState, widget_state.value)
+
         return self.dg._enqueue("deck_gl_json_chart", pydeck_proto)
 
     @property
@@ -176,34 +431,3 @@ def _get_pydeck_tooltip(pydeck_obj: Deck | None) -> dict[str, str] | None:
         return cast(Dict[str, str], tooltip)
 
     return None
-
-
-def marshall(
-    pydeck_proto: PydeckProto,
-    pydeck_obj: Deck | None,
-    use_container_width: bool,
-    width: int | None = None,
-    height: int | None = None,
-) -> None:
-    if pydeck_obj is None:
-        spec = json.dumps(EMPTY_MAP)
-    else:
-        spec = pydeck_obj.to_json()
-
-    pydeck_proto.json = spec
-    pydeck_proto.use_container_width = use_container_width
-
-    if width:
-        pydeck_proto.width = width
-    if height:
-        pydeck_proto.height = height
-
-    pydeck_proto.id = ""
-
-    tooltip = _get_pydeck_tooltip(pydeck_obj)
-    if tooltip:
-        pydeck_proto.tooltip = json.dumps(tooltip)
-
-    mapbox_token = config.get_option("mapbox.token")
-    if mapbox_token:
-        pydeck_proto.mapbox_token = mapbox_token

streamlit/elements/widgets/audio_input.py

@@ -0,0 +1,248 @@
+# 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 __future__ import annotations
+
+from dataclasses import dataclass
+from textwrap import dedent
+from typing import TYPE_CHECKING, Union, cast
+
+from typing_extensions import TypeAlias
+
+from streamlit.elements.lib.form_utils import current_form_id
+from streamlit.elements.lib.policies import (
+    check_widget_policies,
+    maybe_raise_label_warnings,
+)
+from streamlit.elements.lib.utils import (
+    Key,
+    LabelVisibility,
+    compute_and_register_element_id,
+    get_label_visibility_proto_value,
+    to_key,
+)
+from streamlit.elements.widgets.file_uploader import _get_upload_files
+from streamlit.proto.AudioInput_pb2 import AudioInput as AudioInputProto
+from streamlit.proto.Common_pb2 import FileUploaderState as FileUploaderStateProto
+from streamlit.proto.Common_pb2 import UploadedFileInfo as UploadedFileInfoProto
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner import ScriptRunContext, get_script_run_ctx
+from streamlit.runtime.state import (
+    WidgetArgs,
+    WidgetCallback,
+    WidgetKwargs,
+    register_widget,
+)
+from streamlit.runtime.uploaded_file_manager import DeletedFile, UploadedFile
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+
+SomeUploadedAudioFile: TypeAlias = Union[UploadedFile, DeletedFile, None]
+
+
+@dataclass
+class AudioInputSerde:
+    def serialize(
+        self,
+        audio_file: SomeUploadedAudioFile,
+    ) -> FileUploaderStateProto:
+        state_proto = FileUploaderStateProto()
+
+        if audio_file is None or isinstance(audio_file, DeletedFile):
+            return state_proto
+
+        file_info: UploadedFileInfoProto = state_proto.uploaded_file_info.add()
+        file_info.file_id = audio_file.file_id
+        file_info.name = audio_file.name
+        file_info.size = audio_file.size
+        file_info.file_urls.CopyFrom(audio_file._file_urls)
+
+        return state_proto
+
+    def deserialize(
+        self, ui_value: FileUploaderStateProto | None, widget_id: str
+    ) -> SomeUploadedAudioFile:
+        upload_files = _get_upload_files(ui_value)
+        if len(upload_files) == 0:
+            return_value = None
+        else:
+            return_value = upload_files[0]
+        return return_value
+
+
+class AudioInputMixin:
+    @gather_metrics("experimental_audio_input")
+    def experimental_audio_input(
+        self,
+        label: str,
+        *,
+        key: Key | None = None,
+        help: str | None = None,
+        on_change: WidgetCallback | None = None,
+        args: WidgetArgs | None = None,
+        kwargs: WidgetKwargs | None = None,
+        disabled: bool = False,
+        label_visibility: LabelVisibility = "visible",
+    ) -> UploadedFile | None:
+        r"""Display a widget that returns audio recording from the user's microphone.
+
+        Parameters
+        ----------
+        label : str
+            A short label explaining to the user what this widget is used for.
+            The label can optionally contain GitHub-flavored Markdown of the
+            following types: Bold, Italics, Strikethroughs, Inline Code, and
+            Links.
+
+            Unsupported Markdown elements are unwrapped so only their children
+            (text contents) render. Display unsupported elements as literal
+            characters by backslash-escaping them. E.g.,
+            ``"1\. Not an ordered list"``.
+
+            See the ``body`` parameter of |st.markdown|_ for additional,
+            supported Markdown directives.
+
+            For accessibility reasons, you should never set an empty label (label="")
+            but hide it with label_visibility if needed. In the future, we may disallow
+            empty labels by raising an exception.
+
+            .. |st.markdown| replace:: ``st.markdown``
+            .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown
+
+        key : str or int
+            An optional string or integer to use as the unique key for the widget.
+            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.
+
+        help : str
+            A tooltip that gets displayed next to the audio input.
+
+        on_change : callable
+            An optional callback invoked when this audio_input's value
+            changes.
+
+        args : tuple
+            An optional tuple of args to pass to the callback.
+
+        kwargs : dict
+            An optional dict of kwargs to pass to the callback.
+
+        disabled : bool
+            An optional boolean, which disables the audio input if set to
+            True. Default is False.
+        label_visibility : "visible", "hidden", or "collapsed"
+            The visibility of the label. If "hidden", the label doesn't show but there
+            is still empty space for it above the widget (equivalent to label="").
+            If "collapsed", both the label and the space are removed. Default is
+            "visible".
+
+        Returns
+        -------
+        None or UploadedFile
+            The UploadedFile class is a subclass of BytesIO, and therefore
+            it is "file-like". This means you can pass them anywhere where
+            a file is expected.
+
+        Examples
+        --------
+        >>> import streamlit as st
+        >>>
+        >>> audio_value = st.experimental_audio_input("Record a voice message")
+        >>>
+        >>> if audio_value:
+        ...     st.audio(audio_value)
+
+        """
+        ctx = get_script_run_ctx()
+        return self._audio_input(
+            label=label,
+            key=key,
+            help=help,
+            on_change=on_change,
+            args=args,
+            kwargs=kwargs,
+            disabled=disabled,
+            label_visibility=label_visibility,
+            ctx=ctx,
+        )
+
+    def _audio_input(
+        self,
+        label: str,
+        key: Key | None = None,
+        help: str | None = None,
+        on_change: WidgetCallback | None = None,
+        args: WidgetArgs | None = None,
+        kwargs: WidgetKwargs | None = None,
+        *,  # keyword-only arguments:
+        disabled: bool = False,
+        label_visibility: LabelVisibility = "visible",
+        ctx: ScriptRunContext | None = None,
+    ) -> UploadedFile | None:
+        key = to_key(key)
+
+        check_widget_policies(
+            self.dg,
+            key,
+            on_change,
+            default_value=None,
+            writes_allowed=False,
+        )
+        maybe_raise_label_warnings(label, label_visibility)
+
+        element_id = compute_and_register_element_id(
+            "audio_input",
+            user_key=key,
+            form_id=current_form_id(self.dg),
+            label=label,
+            help=help,
+        )
+
+        audio_input_proto = AudioInputProto()
+        audio_input_proto.id = element_id
+        audio_input_proto.label = label
+        audio_input_proto.form_id = current_form_id(self.dg)
+        audio_input_proto.disabled = disabled
+        audio_input_proto.label_visibility.value = get_label_visibility_proto_value(
+            label_visibility
+        )
+
+        if label and help is not None:
+            audio_input_proto.help = dedent(help)
+
+        serde = AudioInputSerde()
+
+        audio_input_state = register_widget(
+            "audio_input",
+            audio_input_proto,
+            on_change_handler=on_change,
+            args=args,
+            kwargs=kwargs,
+            deserializer=serde.deserialize,
+            serializer=serde.serialize,
+            ctx=ctx,
+        )
+
+        self.dg._enqueue("audio_input", audio_input_proto)
+
+        if isinstance(audio_input_state.value, DeletedFile):
+            return None
+        return audio_input_state.value
+
+    @property
+    def dg(self) -> DeltaGenerator:
+        """Get our DeltaGenerator."""
+        return cast("DeltaGenerator", self)

streamlit/elements/widgets/button_group.py

@@ -389,7 +389,7 @@ class ButtonGroupMixin:
         return sentiment.value
 
     @gather_metrics("pills")
-    def pills(
+    def _pills(
         self,
         label: str,
         options: OptionSequence[V],

streamlit/proto/AudioInput_pb2.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: streamlit/proto/AudioInput.proto
+# Protobuf Python Version: 5.26.1
+"""Generated protocol buffer code."""
+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
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from streamlit.proto import LabelVisibilityMessage_pb2 as streamlit_dot_proto_dot_LabelVisibilityMessage__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n streamlit/proto/AudioInput.proto\x1a,streamlit/proto/LabelVisibilityMessage.proto\"\x8b\x01\n\nAudioInput\x12\n\n\x02id\x18\x01 \x01(\t\x12\r\n\x05label\x18\x02 \x01(\t\x12\x0c\n\x04help\x18\x03 \x01(\t\x12\x0f\n\x07\x66orm_id\x18\x04 \x01(\t\x12\x10\n\x08\x64isabled\x18\x05 \x01(\x08\x12\x31\n\x10label_visibility\x18\x06 \x01(\x0b\x32\x17.LabelVisibilityMessageB/\n\x1c\x63om.snowflake.apps.streamlitB\x0f\x41udioInputProtob\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'streamlit.proto.AudioInput_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\n\034com.snowflake.apps.streamlitB\017AudioInputProto'
+  _globals['_AUDIOINPUT']._serialized_start=83
+  _globals['_AUDIOINPUT']._serialized_end=222
+# @@protoc_insertion_point(module_scope)