streamlit 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

streamlit/elements/widgets/chat.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator, MutableMapping, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import (
     TYPE_CHECKING,
@@ -47,13 +47,18 @@ from streamlit.elements.lib.utils import (
     save_for_app_testing,
     to_key,
 )
+from streamlit.elements.widgets.audio_input import ALLOWED_SAMPLE_RATES
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.proto.ChatInput_pb2 import ChatInput as ChatInputProto
 from streamlit.proto.Common_pb2 import ChatInputValue as ChatInputValueProto
 from streamlit.proto.Common_pb2 import FileUploaderState as FileUploaderStateProto
+from streamlit.proto.Common_pb2 import UploadedFileInfo as UploadedFileInfoProto
 from streamlit.proto.RootContainer_pb2 import RootContainer
 from streamlit.proto.WidthConfig_pb2 import WidthConfig
+from streamlit.runtime.memory_uploaded_file_manager import (
+    MemoryUploadedFileManager,
+)
 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 (
@@ -70,34 +75,117 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
 
+# Audio file validation constants
+_ACCEPTED_AUDIO_EXTENSION: str = ".wav"
+_ACCEPTED_AUDIO_MIME_TYPES: frozenset[str] = frozenset(
+    {
+        "audio/wav",
+        "audio/wave",
+        "audio/x-wav",
+    }
+)
+
+
 @dataclass
 class ChatInputValue(MutableMapping[str, Any]):
+    """Represents the value returned by `st.chat_input` after user interaction.
+
+    This dataclass contains the user's input text, any files uploaded, and optionally
+    an audio recording. It provides a dict-like interface for accessing and modifying
+    its attributes.
+
+    Attributes
+    ----------
+    text : str
+        The text input provided by the user.
+    files : list[UploadedFile]
+        A list of files uploaded by the user. Only present when accept_file=True.
+    audio : UploadedFile or None, optional
+        An audio recording uploaded by the user, if any. Only present when accept_audio=True.
+
+    Notes
+    -----
+    - Supports dict-like access via `__getitem__`, `__setitem__`, and `__delitem__`.
+    - Use `to_dict()` to convert the value to a standard dictionary.
+    - The 'files' key is only present when accept_file=True.
+    - The 'audio' key is only present when accept_audio=True.
+    """
+
     text: str
-    files: list[UploadedFile]
+    files: list[UploadedFile] = field(default_factory=list)
+    audio: UploadedFile | None = None
+    _include_files: bool = field(default=False, repr=False, compare=False)
+    _include_audio: bool = field(default=False, repr=False, compare=False)
+    _included_keys: tuple[str, ...] = field(init=False, repr=False, compare=False)
+
+    def __post_init__(self) -> None:
+        """Compute and cache the included keys after initialization."""
+        keys: list[str] = ["text"]
+        if self._include_files:
+            keys.append("files")
+        if self._include_audio:
+            keys.append("audio")
+        object.__setattr__(self, "_included_keys", tuple(keys))
+
+    def _get_included_keys(self) -> tuple[str, ...]:
+        """Return tuple of keys that should be exposed based on inclusion flags."""
+        return self._included_keys
 
     def __len__(self) -> int:
-        return len(vars(self))
+        return len(self._get_included_keys())
 
     def __iter__(self) -> Iterator[str]:
-        return iter(vars(self))
+        return iter(self._get_included_keys())
 
-    def __getitem__(self, item: str) -> str | list[UploadedFile]:
+    def __contains__(self, key: object) -> bool:
+        if not isinstance(key, str):
+            return False
+        return key in self._get_included_keys()
+
+    def __getitem__(self, item: str) -> str | list[UploadedFile] | UploadedFile | None:
+        if item not in self._get_included_keys():
+            raise KeyError(f"Invalid key: {item}")
         try:
             return getattr(self, item)  # type: ignore[no-any-return]
         except AttributeError:
             raise KeyError(f"Invalid key: {item}") from None
 
+    def __getattribute__(self, name: str) -> Any:
+        # Intercept access to files/audio when they're excluded
+        # Use object.__getattribute__ to avoid infinite recursion
+        if name == "files" and not object.__getattribute__(self, "_include_files"):
+            raise AttributeError(
+                "'ChatInputValue' object has no attribute 'files' (accept_file=False)"
+            )
+        if name == "audio" and not object.__getattribute__(self, "_include_audio"):
+            raise AttributeError(
+                "'ChatInputValue' object has no attribute 'audio' (accept_audio=False)"
+            )
+        # For all other attributes, use normal lookup
+        return object.__getattribute__(self, name)
+
     def __setitem__(self, key: str, value: Any) -> None:
+        if key not in self._get_included_keys():
+            raise KeyError(f"Invalid key: {key}")
         setattr(self, key, value)
 
     def __delitem__(self, key: str) -> None:
+        if key not in self._get_included_keys():
+            raise KeyError(f"Invalid key: {key}")
         try:
             delattr(self, key)
         except AttributeError:
             raise KeyError(f"Invalid key: {key}") from None
 
-    def to_dict(self) -> dict[str, str | list[UploadedFile]]:
-        return vars(self)
+    def to_dict(self) -> dict[str, str | list[UploadedFile] | UploadedFile | None]:
+        result: dict[str, str | list[UploadedFile] | UploadedFile | None] = {
+            "text": self.text
+        }
+        if self._include_files:
+            result["files"] = self.files
+        if self._include_audio:
+            result["audio"] = self.audio
+        return result
 
 
 class PresetNames(str, Enum):
@@ -188,7 +276,11 @@ def _pop_upload_files(
             uploaded_file = UploadedFile(maybe_file_rec, f.file_urls)
             collected_files.append(uploaded_file)
 
-            if hasattr(ctx.uploaded_file_mgr, "remove_file"):
+            # Remove file from manager after creating UploadedFile object.
+            # Only MemoryUploadedFileManager implements remove_file.
+            # This explicit type check ensures we only use this cleanup logic
+            # with manager types we've explicitly approved.
+            if isinstance(ctx.uploaded_file_mgr, MemoryUploadedFileManager):
                 ctx.uploaded_file_mgr.remove_file(
                     session_id=ctx.session_id,
                     file_id=f.file_id,
@@ -197,9 +289,79 @@ def _pop_upload_files(
     return collected_files
 
 
+def _pop_audio_file(
+    audio_file_info: UploadedFileInfoProto | None,
+) -> UploadedFile | None:
+    """Extract and return a single audio file from the protobuf message.
+
+    Similar to _pop_upload_files but handles a single audio file instead of a list.
+    Validates that the uploaded file is a WAV file.
+
+    Parameters
+    ----------
+    audio_file_info : UploadedFileInfoProto or None
+        The protobuf message containing information about the uploaded audio file.
+
+    Returns
+    -------
+    UploadedFile or None
+        The extracted audio file if available, None otherwise.
+
+    Raises
+    ------
+    StreamlitAPIException
+        If the uploaded audio file does not have a `.wav` extension or its MIME type is not
+        one of the accepted WAV types (`audio/wav`, `audio/wave`, `audio/x-wav`).
+    """
+    if audio_file_info is None:
+        return None
+
+    ctx = get_script_run_ctx()
+    if ctx is None:
+        return None
+
+    file_recs_list = ctx.uploaded_file_mgr.get_files(
+        session_id=ctx.session_id,
+        file_ids=[audio_file_info.file_id],
+    )
+
+    if len(file_recs_list) == 0:
+        return None
+
+    file_rec = file_recs_list[0]
+    uploaded_file = UploadedFile(file_rec, audio_file_info.file_urls)
+
+    # Validate that the file is a WAV file by checking extension and MIME type
+    if not uploaded_file.name.lower().endswith(_ACCEPTED_AUDIO_EXTENSION):
+        raise StreamlitAPIException(
+            f"Invalid file extension for audio input: `{uploaded_file.name}`. "
+            f"Only WAV files ({_ACCEPTED_AUDIO_EXTENSION}) are accepted."
+        )
+
+    # Validate MIME type (browsers may send different variations of WAV MIME types)
+    if uploaded_file.type not in _ACCEPTED_AUDIO_MIME_TYPES:
+        raise StreamlitAPIException(
+            f"Invalid MIME type for audio input: `{uploaded_file.type}`. "
+            f"Expected one of {_ACCEPTED_AUDIO_MIME_TYPES}."
+        )
+
+    # Remove the file from the manager after creating the UploadedFile object.
+    # Only MemoryUploadedFileManager implements remove_file (not part of the
+    # UploadedFileManager Protocol). This explicit type check ensures we only
+    # use this cleanup logic with manager types we've explicitly approved.
+    if audio_file_info and isinstance(ctx.uploaded_file_mgr, MemoryUploadedFileManager):
+        ctx.uploaded_file_mgr.remove_file(
+            session_id=ctx.session_id,
+            file_id=audio_file_info.file_id,
+        )
+
+    return uploaded_file
+
+
 @dataclass
 class ChatInputSerde:
     accept_files: bool = False
+    accept_audio: bool = False
     allowed_types: Sequence[str] | None = None
 
     def deserialize(
@@ -207,16 +369,24 @@ class ChatInputSerde:
     ) -> str | ChatInputValue | None:
         if ui_value is None or not ui_value.HasField("data"):
             return None
-        if not self.accept_files:
+        if not self.accept_files and not self.accept_audio:
             return ui_value.data
         uploaded_files = _pop_upload_files(ui_value.file_uploader_state)
         for file in uploaded_files:
             if self.allowed_types and not isinstance(file, DeletedFile):
                 enforce_filename_restriction(file.name, self.allowed_types)
 
+        # Extract audio file separately from the audio_file_info field
+        audio_file = _pop_audio_file(
+            ui_value.audio_file_info if ui_value.HasField("audio_file_info") else None
+        )
+
         return ChatInputValue(
             text=ui_value.data,
             files=uploaded_files,
+            audio=audio_file,
+            _include_files=self.accept_files,
+            _include_audio=self.accept_audio,
         )
 
     def serialize(self, v: str | None) -> ChatInputValueProto:
@@ -282,6 +452,8 @@ class ChatMixin:
               <https://fonts.google.com/icons?icon.set=Material+Symbols&icon.style=Rounded>`_
               font library.
 
+            - ``"spinner"``: Displays a spinner as an icon.
+
             .. |st.image| replace:: ``st.image``
             .. _st.image: https://docs.streamlit.io/develop/api-reference/media/st.image
 
@@ -313,7 +485,7 @@ class ChatMixin:
         ...     st.write("Hello 👋")
         ...     st.line_chart(np.random.randn(30, 3))
 
-        .. output ::
+        .. output::
             https://doc-chat-message-user.streamlit.app/
             height: 450px
 
@@ -326,7 +498,7 @@ class ChatMixin:
         >>> message.write("Hello human")
         >>> message.bar_chart(np.random.randn(30, 3))
 
-        .. output ::
+        .. output::
             https://doc-chat-message-user1.streamlit.app/
             height: 450px
 
@@ -377,6 +549,7 @@ class ChatMixin:
         max_chars: int | None = None,
         accept_file: Literal[False] = False,
         file_type: str | Sequence[str] | None = None,
+        accept_audio: Literal[False] = False,
         disabled: bool = False,
         on_submit: WidgetCallback | None = None,
         args: WidgetArgs | None = None,
@@ -384,6 +557,24 @@ class ChatMixin:
         width: WidthWithoutContent = "stretch",
     ) -> str | None: ...
 
+    @overload
+    def chat_input(
+        self,
+        placeholder: str = "Your message",
+        *,
+        key: Key | None = None,
+        max_chars: int | None = None,
+        accept_file: Literal[False] = False,
+        file_type: str | Sequence[str] | None = None,
+        accept_audio: Literal[True],
+        audio_sample_rate: int | None = 16000,
+        disabled: bool = False,
+        on_submit: WidgetCallback | None = None,
+        args: WidgetArgs | None = None,
+        kwargs: WidgetKwargs | None = None,
+        width: WidthWithoutContent = "stretch",
+    ) -> ChatInputValue | None: ...
+
     @overload
     def chat_input(
         self,
@@ -393,6 +584,8 @@ class ChatMixin:
         max_chars: int | None = None,
         accept_file: Literal[True, "multiple", "directory"],
         file_type: str | Sequence[str] | None = None,
+        accept_audio: bool = False,
+        audio_sample_rate: int | None = 16000,
         disabled: bool = False,
         on_submit: WidgetCallback | None = None,
         args: WidgetArgs | None = None,
@@ -409,6 +602,8 @@ class ChatMixin:
         max_chars: int | None = None,
         accept_file: bool | Literal["multiple", "directory"] = False,
         file_type: str | Sequence[str] | None = None,
+        accept_audio: bool = False,
+        audio_sample_rate: int | None = 16000,
         disabled: bool = False,
         on_submit: WidgetCallback | None = None,
         args: WidgetArgs | None = None,
@@ -471,6 +666,23 @@ class ChatMixin:
                 or type extensions. The correct handling of uploaded files is
                 part of the app developer's responsibility.
 
+        accept_audio : bool
+            Whether to show an audio recording button in the chat input. This
+            defaults to ``False``. If this is ``True``, users can record and
+            submit audio messages. Recorded audio is available as an
+            ``UploadedFile`` object with MIME type ``audio/wav``.
+
+        audio_sample_rate : int or None
+            The target sample rate for audio recording in Hz when
+            ``accept_audio`` is ``True``. This defaults to ``16000``, which is
+            optimal for speech recognition.
+
+            The following values are supported: ``8000`` (telephone quality),
+            ``11025``, ``16000`` (speech-recognition quality), ``22050``,
+            ``24000``, ``32000``, ``44100``, ``48000`` (high-quality), or
+            ``None``. If this is ``None``, the widget uses the browser's
+            default sample rate (typically 44100 or 48000 Hz).
+
         disabled : bool
             Whether the chat input should be disabled. This defaults to
             ``False``.
@@ -500,33 +712,39 @@ class ChatMixin:
         None, str, or dict-like
             The user's submission. This is one of the following types:
 
-            - ``None``: If the user didn't submit a message or file in the last
-              rerun, the widget returns ``None``.
-            - A string: When the widget is not configured to accept files and
-              the user submitted a message in the last rerun, the widget
-              returns the user's message as a string.
+            - ``None``: If the user didn't submit a message, file, or audio
+              recording in the last rerun, the widget returns ``None``.
+            - A string: When the widget isn't configured to accept files or
+              audio recordings, and the user submitted a message in the last
+              rerun, the widget returns the user's message as a string.
             - A dict-like object: When the widget is configured to accept files
-              and the user submitted a message and/or file(s) in the last
-              rerun, the widget returns a dict-like object with two attributes,
-              ``text`` and ``files``.
-
-            When the widget is configured to accept files and the user submits
-            something in the last rerun, you can access the user's submission
-            with key or attribute notation from the dict-like object. This is
-            shown in Example 3 below.
-
-            The ``text`` attribute holds a string, which is the user's message.
-            This is an empty string if the user only submitted one or more
-            files.
-
-            The ``files`` attribute holds a list of UploadedFile objects.
-            The list is empty if the user only submitted a message. Unlike
-            ``st.file_uploader``, this attribute always returns a list, even
-            when the widget is configured to accept only one file at a time.
-
-            The UploadedFile class is a subclass of BytesIO, and therefore is
-            "file-like". This means you can pass an instance of it anywhere a
-            file is expected.
+              or audio recordings, and the user submitted any content in the
+              last rerun, the widget returns a dict-like object.
+              The object always includes the ``text`` attribute, and
+              optionally includes ``files`` and/or ``audio`` attributes depending
+              on the ``accept_file`` and ``accept_audio`` parameters.
+
+            When the widget is configured to accept files or audio recordings,
+            and the user submitted content in the last rerun, you can access
+            the user's submission with key or attribute notation from the
+            dict-like object. This is shown in Example 3 below.
+
+            - The ``text`` attribute holds a string that is the user's message.
+              This is an empty string if the user only submitted one or more
+              files or audio recordings.
+            - The ``files`` attribute is only present when ``accept_file``
+              isn't ``False``. When present, it holds a list of
+              ``UploadedFile`` objects. The list is empty if the user only
+              submitted a message or audio recording. Unlike
+              ``st.file_uploader``, this attribute always returns a list, even
+              when the widget is configured to accept only one file at a time.
+            - The ``audio`` attribute is only present when ``accept_audio`` is
+              ``True``. When present, it holds an ``UploadedFile`` object if
+              audio was recorded or ``None`` if no audio was recorded.
+
+            The ``UploadedFile`` class is a subclass of ``BytesIO`` and
+            therefore is "file-like". This means you can pass an instance of it
+            anywhere a file is expected.
 
         Examples
         --------
@@ -541,7 +759,7 @@ class ChatMixin:
         >>> if prompt:
         ...     st.write(f"User has sent the following prompt: {prompt}")
 
-        .. output ::
+        .. output::
             https://doc-chat-input.streamlit.app/
             height: 350px
 
@@ -555,12 +773,12 @@ class ChatMixin:
         >>> import streamlit as st
         >>>
         >>> with st.sidebar:
-        >>>     messages = st.container(height=300)
+        >>>     messages = st.container(height=200)
         >>>     if prompt := st.chat_input("Say something"):
         >>>         messages.chat_message("user").write(prompt)
         >>>         messages.chat_message("assistant").write(f"Echo: {prompt}")
 
-        .. output ::
+        .. output::
             https://doc-chat-input-inline.streamlit.app/
             height: 350px
 
@@ -585,7 +803,7 @@ class ChatMixin:
         >>> if prompt and prompt["files"]:
         >>>     st.image(prompt["files"][0])
 
-        .. output ::
+        .. output::
             https://doc-chat-input-file-uploader.streamlit.app/
             height: 350px
 
@@ -600,9 +818,32 @@ class ChatMixin:
         >>> st.chat_input(key="chat_input")
         >>> st.write("Chat input value:", st.session_state.chat_input)
 
-        .. output ::
+        .. output::
             https://doc-chat-input-session-state.streamlit.app/
             height: 350px
+
+        **Example 5: Enable audio recording**
+
+        You can enable audio recording by setting ``accept_audio=True``.
+        The ``accept_audio`` parameter works independently of ``accept_file``,
+        allowing you to enable audio recording with or without file uploads.
+
+        >>> import streamlit as st
+        >>>
+        >>> prompt = st.chat_input(
+        >>>     "Say or record something",
+        >>>     accept_audio=True,
+        >>> )
+        >>> if prompt and prompt.text:
+        >>>     st.write("Text:", prompt.text)
+        >>> if prompt and prompt.audio:
+        >>>     st.audio(prompt.audio)
+        >>>     st.write("Audio file:", prompt.audio.name)
+
+        .. output::
+            https://doc-chat-input-audio.streamlit.app/
+            height: 350px
+
         """
         key = to_key(key)
 
@@ -624,18 +865,36 @@ class ChatMixin:
         element_id = compute_and_register_element_id(
             "chat_input",
             user_key=key,
-            key_as_main_identity=False,
+            # Treat the provided key as the main identity. Only include
+            # properties that can invalidate the current widget state
+            # when changed. For chat_input, those are:
+            # - accept_file: Changes whether files can be attached (and how)
+            # - file_type: Restricts the accepted file types
+            # - max_chars: Changes the maximum allowed characters for the input
+            key_as_main_identity={"accept_file", "file_type", "max_chars"},
             dg=self.dg,
             placeholder=placeholder,
             max_chars=max_chars,
             accept_file=accept_file,
             file_type=file_type,
+            accept_audio=accept_audio,
+            audio_sample_rate=audio_sample_rate,
             width=width,
         )
 
         if file_type:
             file_type = normalize_upload_file_type(file_type)
 
+        # Validate audio_sample_rate if provided
+        if (
+            audio_sample_rate is not None
+            and audio_sample_rate not in ALLOWED_SAMPLE_RATES
+        ):
+            raise StreamlitAPIException(
+                f"Invalid audio_sample_rate: {audio_sample_rate}. "
+                f"Must be one of {sorted(ALLOWED_SAMPLE_RATES)} Hz, or None for browser default."
+            )
+
         # It doesn't make sense to create a chat input inside a form.
         # We throw an error to warn the user about this.
         # We omit this check for scripts running outside streamlit, because
@@ -674,9 +933,14 @@ class ChatMixin:
 
         chat_input_proto.file_type[:] = file_type if file_type is not None else []
         chat_input_proto.max_upload_size_mb = config.get_option("server.maxUploadSize")
+        chat_input_proto.accept_audio = accept_audio
+
+        if audio_sample_rate is not None:
+            chat_input_proto.audio_sample_rate = audio_sample_rate
 
         serde = ChatInputSerde(
             accept_files=accept_file in {True, "multiple", "directory"},
+            accept_audio=accept_audio,
             allowed_types=file_type,
         )
         widget_state = register_widget(  # type: ignore[misc]

streamlit/elements/widgets/color_picker.py

@@ -213,13 +213,20 @@ class ColorPickerMixin:
         )
         maybe_raise_label_warnings(label, label_visibility)
 
+        # Enforce minimum width of 40px to match the color block's intrinsic size.
+        # The color block is always 40x40px, so the widget should never be smaller.
+        min_width_px = 40
+        if isinstance(width, int) and width < min_width_px:
+            width = min_width_px
+
         validate_width(width, allow_content=True)
+
         layout_config = LayoutConfig(width=width)
 
         element_id = compute_and_register_element_id(
             "color_picker",
             user_key=key,
-            key_as_main_identity=False,
+            key_as_main_identity=True,
             dg=self.dg,
             label=label,
             value=str(value),