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

streamlit/runtime/download_data_util.py

@@ -0,0 +1,53 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# 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
+
+import io
+
+
+def convert_data_to_bytes_and_infer_mime(
+    data: object, unsupported_error: Exception
+) -> tuple[bytes, str]:
+    # Convert data to bytes and infer mimetype if needed
+    data_as_bytes: bytes
+    inferred_mime_type: str
+
+    if isinstance(data, str):
+        data_as_bytes = data.encode()
+        inferred_mime_type = "text/plain"
+    elif isinstance(data, io.TextIOWrapper):
+        string_data = data.read()
+        data_as_bytes = string_data.encode()
+        inferred_mime_type = "text/plain"
+    # Assume bytes; try methods until we run out.
+    elif isinstance(data, bytes):
+        data_as_bytes = data
+        inferred_mime_type = "application/octet-stream"
+    elif isinstance(data, io.BytesIO):
+        data.seek(0)
+        data_as_bytes = data.getvalue()
+        inferred_mime_type = "application/octet-stream"
+    elif isinstance(data, io.BufferedReader):
+        data.seek(0)
+        data_as_bytes = data.read()
+        inferred_mime_type = "application/octet-stream"
+    elif isinstance(data, io.RawIOBase):
+        data.seek(0)
+        data_as_bytes = data.read() or b""
+        inferred_mime_type = "application/octet-stream"
+    else:
+        raise unsupported_error
+
+    return data_as_bytes, inferred_mime_type

streamlit/runtime/forward_msg_queue.py

@@ -14,10 +14,13 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 
 class ForwardMsgQueue:
     """Accumulates a session's outgoing ForwardMsgs.
@@ -134,6 +137,7 @@ class ForwardMsgQueue:
                     "script_finished",
                     "session_status_changed",
                     "parent_message",
+                    "page_info_changed",
                 }
                 or (
                     # preserve all messages if this is a fragment rerun and...

streamlit/runtime/fragment.py

@@ -17,9 +17,10 @@ from __future__ import annotations
 import contextlib
 import inspect
 from abc import abstractmethod
+from collections.abc import Callable
 from copy import deepcopy
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Protocol, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, overload
 
 from streamlit.error_util import handle_uncaught_app_exception
 from streamlit.errors import FragmentHandledException, FragmentStorageKeyError

streamlit/runtime/media_file_manager.py

@@ -18,14 +18,33 @@ from __future__ import annotations
 
 import collections
 import threading
-from typing import Final
+import uuid
+from typing import TYPE_CHECKING, BinaryIO, Final, TextIO, TypedDict, cast
 
 from streamlit.logger import get_logger
-from streamlit.runtime.media_file_storage import MediaFileKind, MediaFileStorage
+from streamlit.runtime.download_data_util import convert_data_to_bytes_and_infer_mime
+from streamlit.runtime.media_file_storage import (
+    MediaFileKind,
+    MediaFileStorage,
+    MediaFileStorageError,
+)
+
+if TYPE_CHECKING:
+    import io
+    from collections.abc import Callable
 
 _LOGGER: Final = get_logger(__name__)
 
 
+class DeferredCallableEntry(TypedDict):
+    """Typed metadata for deferred download callables."""
+
+    callable: Callable[[], bytes | str | BinaryIO | TextIO | io.RawIOBase]
+    mimetype: str | None
+    filename: str | None
+    coordinates: str
+
+
 def _get_session_id() -> str:
     """Get the active AppSession's session_id."""
     from streamlit.runtime.scriptrunner_utils.script_run_context import (
@@ -90,6 +109,10 @@ class MediaFileManager:
             collections.defaultdict(dict)
         )
 
+        # Dict of [file_id -> deferred callable metadata]
+        # Used for deferred download button execution
+        self._deferred_callables: dict[str, DeferredCallableEntry] = {}
+
         # MediaFileManager is used from multiple threads, so all operations
         # need to be protected with a Lock. (This is not an RLock, which
         # means taking it multiple times from the same thread will deadlock.)
@@ -129,6 +152,31 @@ class MediaFileManager:
                     else:
                         file.mark_for_delete()
 
+            # Clean up orphaned deferred callables
+            self._remove_orphaned_deferred_callables()
+
+    def _remove_orphaned_deferred_callables(self) -> None:
+        """Remove deferred callables that are not referenced by any active session.
+
+        Thread safety: callers must hold `self._lock`.
+        """
+        _LOGGER.debug("Removing orphaned deferred callables...")
+
+        # Get all file_ids currently referenced by any session
+        active_file_ids = set[str]()
+        for session_file_ids_by_coord in self._files_by_session_and_coord.values():
+            active_file_ids.update(session_file_ids_by_coord.values())
+
+        # Remove deferred callables that are no longer referenced
+        deferred_ids_to_remove = [
+            file_id
+            for file_id in self._deferred_callables
+            if file_id not in active_file_ids
+        ]
+        for file_id in deferred_ids_to_remove:
+            _LOGGER.debug("Removing deferred callable: %s", file_id)
+            del self._deferred_callables[file_id]
+
     def _delete_file(self, file_id: str) -> None:
         """Delete the given file from storage, and remove its metadata from
         self._files_by_id.
@@ -158,6 +206,10 @@ class MediaFileManager:
             if session_id in self._files_by_session_and_coord:
                 del self._files_by_session_and_coord[session_id]
 
+            # Don't immediately delete deferred callables here to avoid race conditions.
+            # They will be cleaned up by remove_orphaned_deferred_callables() which
+            # only removes callables that are not referenced by ANY session.
+
         _LOGGER.debug(
             "Sessions still active: %r", self._files_by_session_and_coord.keys()
         )
@@ -231,3 +283,127 @@ class MediaFileManager:
             self._files_by_session_and_coord[session_id][coordinates] = file_id
 
             return self._storage.get_url(file_id)
+
+    def add_deferred(
+        self,
+        data_callable: Callable[[], bytes | str | BinaryIO | TextIO | io.RawIOBase],
+        mimetype: str | None,
+        coordinates: str,
+        file_name: str | None = None,
+    ) -> str:
+        """Register a callable for deferred execution. Returns placeholder file_id.
+
+        The callable will be executed later when execute_deferred() is called,
+        typically when the user clicks a download button.
+
+        Safe to call from any thread.
+
+        Parameters
+        ----------
+        data_callable : Callable[[], bytes | str | BinaryIO | TextIO | io.RawIOBase]
+            A callable that returns the file data when invoked.
+        mimetype : str or None
+            The mime type for the file. E.g. "text/csv".
+            If None, the mimetype will be inferred from the data type when
+            execute_deferred() is called.
+        coordinates : str
+            Unique string identifying an element's location.
+        file_name : str or None
+            Optional file_name. Used to set the filename in the response header.
+
+        Returns
+        -------
+        str
+            A placeholder file_id that can be used to execute the callable later.
+        """
+        session_id = _get_session_id()
+
+        with self._lock:
+            # Generate a unique placeholder ID for this deferred callable
+            # Expected: a new placeholder ID is created on every script rerun.
+            file_id = uuid.uuid4().hex
+
+            # Store the callable with its metadata
+            self._deferred_callables[file_id] = cast(
+                "DeferredCallableEntry",
+                {
+                    "callable": data_callable,
+                    "mimetype": mimetype,
+                    "filename": file_name,
+                    "coordinates": coordinates,
+                },
+            )
+
+            # Track this deferred file by session and coordinate
+            self._files_by_session_and_coord[session_id][coordinates] = file_id
+
+            return file_id
+
+    def execute_deferred(self, file_id: str) -> str:
+        """Execute a deferred callable and return the URL to the generated file.
+
+        This method retrieves the callable registered with add_deferred(),
+        executes it, stores the result, and returns a URL to access it.
+
+        Safe to call from any thread.
+
+        Parameters
+        ----------
+        file_id : str
+            The placeholder file_id returned by add_deferred().
+
+        Returns
+        -------
+        str
+            The URL that can be used to download the generated file.
+
+        Raises
+        ------
+        MediaFileStorageError
+            If the file_id is not found or if the callable execution fails.
+        """
+        # Retrieve deferred callable metadata while holding lock
+        with self._lock:
+            if file_id not in self._deferred_callables:
+                raise MediaFileStorageError(f"Deferred file {file_id} not found")
+
+            deferred = self._deferred_callables[file_id]
+
+        # Execute callable outside lock to avoid blocking other operations
+        try:
+            data = deferred["callable"]()
+        except Exception as e:
+            raise MediaFileStorageError(f"Callable execution failed: {e}") from e
+
+        # Convert data to bytes and infer mimetype if needed
+        data_as_bytes, inferred_mime_type = convert_data_to_bytes_and_infer_mime(
+            data,
+            unsupported_error=MediaFileStorageError(
+                f"Callable returned unsupported type: {type(data)}"
+            ),
+        )
+
+        # Use provided mimetype if available, otherwise use inferred mimetype
+        mime_type: str = deferred["mimetype"] or inferred_mime_type
+
+        # Store the generated data and get the actual file_id
+        with self._lock:
+            actual_file_id = self._storage.load_and_get_id(
+                data_as_bytes,
+                mime_type,
+                MediaFileKind.DOWNLOADABLE,
+                deferred["filename"],
+            )
+
+            # Create metadata for the actual file
+            metadata = MediaFileMetadata(kind=MediaFileKind.DOWNLOADABLE)
+            self._file_metadata[actual_file_id] = metadata
+
+            # Keep the deferred callable so users can download multiple times
+            # It will be cleaned up when clear_session_refs() is called on rerun
+
+            # We leave actual_file_id unmapped so repeat clicks rerun the callable.
+            # Cleanup prunes the stored file once no session references it.
+
+            # Return the URL to access the file
+            return self._storage.get_url(actual_file_id)

streamlit/runtime/memory_media_file_storage.py

@@ -34,7 +34,7 @@ _LOGGER: Final = get_logger(__name__)
 
 # Mimetype -> filename extension map for the `get_extension_for_mimetype`
 # function. We use Python's `mimetypes.guess_extension` for most mimetypes,
-# but (as of Python 3.9) `mimetypes.guess_extension("audio/wav")` returns None,
+# but (as of Python 3.12) `mimetypes.guess_extension("audio/wav")` returns None,
 # so we handle it ourselves.
 PREFERRED_MIMETYPE_EXTENSION_MAP: Final = {
     "audio/wav": ".wav",

streamlit/runtime/metrics_util.py

@@ -21,9 +21,9 @@ import sys
 import threading
 import time
 import uuid
-from collections.abc import Sized
+from collections.abc import Callable, Sized
 from functools import wraps
-from typing import Any, Callable, Final, TypeVar, cast, overload
+from typing import Any, Final, TypeVar, cast, overload
 
 from streamlit import config, file_util, util
 from streamlit.logger import get_logger
@@ -78,6 +78,7 @@ _ATTRIBUTIONS_TO_CHECK: Final = [
     "duckdb",
     "opensearchpy",
     "supabase",
+    "databricks",
     # Dataframe Libraries:
     "polars",
     "dask",
@@ -92,6 +93,7 @@ _ATTRIBUTIONS_TO_CHECK: Final = [
     "tables",
     "zarr",
     "datasets",
+    "daft",
     # ML & LLM Tools:
     "mistralai",
     "openai",
@@ -131,11 +133,62 @@ _ATTRIBUTIONS_TO_CHECK: Final = [
     "lightgbm",
     "catboost",
     "sklearn",
+    "pydantic_ai",
+    "datachain",
+    "docling",
+    "litserve",
+    "crawl4ai",
+    "baml_client",
+    "browser_use",
+    "crewai",
+    "unsloth",
+    "langgraph",
+    "dspy",
+    "ultralytics",
+    "instructor",
+    "ragas",
+    "swarm",
+    "faster_whisper",
+    "memori",
+    "autogen_agentchat",
+    "xai_sdk",
+    "agno",
+    "langfuse",
+    "smolagents",
+    "ollama",
+    "groq",
+    "together",
+    "ai21",
+    "marvin",
+    "outlines",
+    "guardrails",
+    "promptflow",
+    "semantic_router",
+    "mem0",
+    "aisuite",
+    "mlflow",
+    "optuna",
+    "keras",
+    "jax",
+    "shap",
+    "evidently",
+    "great_expectations",
+    "bentoml",
+    "modal",
+    "sagemaker",
+    "vertexai",
+    "tiktoken",
+    "sentence_transformers",
+    "spacy",
+    "nltk",
+    "onnxruntime",
+    "llama_api_client",
     # Workflow Tools:
     "prefect",
     "luigi",
     "airflow",
     "dagster",
+    "celery",
     # Vector Stores:
     "pgvector",
     "faiss",
@@ -148,11 +201,40 @@ _ATTRIBUTIONS_TO_CHECK: Final = [
     "lancedb",
     # Others:
     "snowflake",
+    "pydantic",
+    "fastapi",
+    "starlette",
+    "playwright",
+    "folium",
+    "geopandas",
+    "httpx",
+    "pyecharts",
+    "fastplotlib",
+    "pygfx",
+    "highcharts_core",
+    # Optional streamlit dependencies:
+    "seaborn",
+    "graphviz",
+    "matplotlib",
+    "uvloop",
+    "orjson",
+    "rich",
     "streamlit_extras",
     "streamlit_pydantic",
-    "pydantic",
+    "pygwalker",
+    "plotly",
+    "bokeh",
     "plost",
     "authlib",
+    # Document Processing:
+    "pypdf",
+    "pdfplumber",
+    "docx",
+    "openpyxl",
+    "xlsxwriter",
+    # Image/Vision:
+    "cv2",
+    "mediapipe",
 ]
 
 _ETC_MACHINE_ID_PATH = "/etc/machine-id"
@@ -331,6 +413,12 @@ def _get_command_telemetry(
     ):
         name = f"component:{self_arg.name}"
 
+    if name == "_bidi_component" and len(args) > 1 and isinstance(args[1], str):
+        # Bound DeltaGenerator methods always receive `self` as args[0], so args[1]
+        # is the user-supplied component name.
+        component_name = args[1]
+        name = f"component_v2:{component_name}"
+
     return Command(name=name, args=arguments)
 
 

streamlit/runtime/runtime.py

@@ -23,6 +23,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Final, NamedTuple
 
 from streamlit.components.lib.local_component_registry import LocalComponentRegistry
+from streamlit.components.v2.component_manager import BidiComponentManager
 from streamlit.logger import get_logger
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.app_session import AppSession
@@ -101,6 +102,11 @@ class RuntimeConfig:
         default_factory=LocalComponentRegistry
     )
 
+    # The BidiComponentManager instance to use for v2 components.
+    bidi_component_registry: BidiComponentManager = field(
+        default_factory=BidiComponentManager
+    )
+
     # The SessionManager class to be used.
     session_manager_class: type[SessionManager] = WebsocketSessionManager
 
@@ -201,11 +207,15 @@ class Runtime:
 
         # Initialize managers
         self._component_registry = config.component_registry
+        self._bidi_component_registry = config.bidi_component_registry
         self._uploaded_file_mgr = config.uploaded_file_manager
         self._media_file_mgr = MediaFileManager(storage=config.media_file_storage)
         self._cache_storage_manager = config.cache_storage_manager
         self._script_cache = ScriptCache()
 
+        # Discover and register components for CCv2 from installed packages
+        self._bidi_component_registry.discover_and_register_components()
+
         self._session_mgr = config.session_manager_class(
             session_storage=config.session_storage,
             uploaded_file_manager=self._uploaded_file_mgr,
@@ -227,6 +237,10 @@ class Runtime:
     def component_registry(self) -> BaseComponentRegistry:
         return self._component_registry
 
+    @property
+    def bidi_component_registry(self) -> BidiComponentManager:
+        return self._bidi_component_registry
+
     @property
     def uploaded_file_mgr(self) -> UploadedFileManager:
         return self._uploaded_file_mgr

streamlit/runtime/scriptrunner/exec_code.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import sys
-from typing import TYPE_CHECKING, Any, Callable, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from streamlit import util
 from streamlit.delta_generator_singletons import (
@@ -30,6 +30,7 @@ from streamlit.runtime.scriptrunner_utils.exceptions import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from types import TracebackType
 
     from streamlit.runtime.scriptrunner_utils.script_requests import RerunData

streamlit/runtime/scriptrunner/script_runner.py

@@ -21,7 +21,7 @@ import types
 from contextlib import contextmanager
 from enum import Enum
 from timeit import default_timer as timer
-from typing import TYPE_CHECKING, Any, Callable, Final, Literal, cast
+from typing import TYPE_CHECKING, Any, Final, Literal, cast
 
 from blinker import Signal
 
@@ -62,7 +62,7 @@ from streamlit.runtime.state import (
 from streamlit.source_util import page_sort_key
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
     from streamlit.runtime.fragment import FragmentStorage
     from streamlit.runtime.scriptrunner.script_cache import ScriptCache
@@ -529,7 +529,9 @@ class ScriptRunner:
                     widget_ids = {w.id for w in rerun_data.widget_states.widgets}
                 self._session_state.on_script_finished(widget_ids)
 
-            fragment_ids_this_run = list(rerun_data.fragment_id_queue)
+            fragment_ids_this_run: list[str] | None = (
+                rerun_data.fragment_id_queue or None
+            )
 
             ctx.reset(
                 query_string=rerun_data.query_string,

streamlit/runtime/scriptrunner_utils/script_run_context.py

@@ -22,14 +22,11 @@ from collections import Counter
 from dataclasses import dataclass, field
 from typing import (
     TYPE_CHECKING,
-    Callable,
     Final,
-    Union,
+    TypeAlias,
 )
 from urllib import parse
 
-from typing_extensions import TypeAlias
-
 from streamlit.errors import (
     NoSessionContext,
     StreamlitAPIException,
@@ -41,7 +38,7 @@ from streamlit.runtime.forward_msg_cache import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
     from pathlib import Path
 
     from streamlit.cursor import RunningCursor
@@ -55,7 +52,7 @@ if TYPE_CHECKING:
     from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 _LOGGER: Final = get_logger(__name__)
 
-UserInfo: TypeAlias = dict[str, Union[str, bool, None]]
+UserInfo: TypeAlias = dict[str, str | bool | None]
 
 
 # If true, it indicates that we are in a cached function that disallows the usage of

streamlit/runtime/secrets.py

@@ -16,11 +16,10 @@ from __future__ import annotations
 
 import os
 import threading
-from collections.abc import ItemsView, Iterator, KeysView, Mapping, ValuesView
+from collections.abc import Callable, ItemsView, Iterator, KeysView, Mapping, ValuesView
 from copy import deepcopy
 from typing import (
     Any,
-    Callable,
     Final,
     NoReturn,
 )
@@ -461,8 +460,7 @@ class Secrets(Mapping[str, Any]):
                 return value
             return AttrDict(value)
         # We add FileNotFoundError since __getattr__ is expected to only raise
-        # AttributeError. Without handling FileNotFoundError, unittests.mocks
-        # fails during mock creation on Python3.9
+        # AttributeError and mocking utilities expect that contract.
         except (KeyError, FileNotFoundError):
             raise AttributeError(_missing_attr_error_message(key))
 

streamlit/runtime/session_manager.py

@@ -16,9 +16,11 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable, Protocol, cast
+from typing import TYPE_CHECKING, Protocol, cast
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
     from streamlit.runtime.app_session import AppSession
     from streamlit.runtime.script_data import ScriptData