streamlit 1.51.0__py3-none-any.whl → 1.52.1__py3-none-any.whl

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/metrics_util.py

@@ -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,8 +413,10 @@ def _get_command_telemetry(
     ):
         name = f"component:{self_arg.name}"
 
-    if name == "_bidi_component" and len(args) > 0 and isinstance(args[0], str):
-        component_name = args[0]
+    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/scriptrunner/script_runner.py

@@ -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/state/query_params.py

@@ -14,18 +14,21 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable, Iterator, MutableMapping
+from collections.abc import Iterable, Iterator, Mapping, MutableMapping
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Final, cast
 from urllib import parse
 
-from streamlit.errors import StreamlitAPIException
+from streamlit.errors import StreamlitAPIException, StreamlitQueryParamDictValueError
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
 
 if TYPE_CHECKING:
     from _typeshed import SupportsKeysAndGetItem
 
+QueryParamValue = str | Iterable[str]
+QueryParamsInput = Mapping[str, QueryParamValue] | Iterable[tuple[str, QueryParamValue]]
+
 
 EMBED_QUERY_PARAM: Final[str] = "embed"
 EMBED_OPTIONS_QUERY_PARAM: Final[str] = "embed_options"
@@ -47,7 +50,9 @@ class QueryParams(MutableMapping[str, str]):
         self._ensure_single_query_api_used()
 
         return iter(
-            key for key in self._query_params if key not in EMBED_QUERY_PARAMS_KEYS
+            key
+            for key in self._query_params
+            if key.lower() not in EMBED_QUERY_PARAMS_KEYS
         )
 
     def __getitem__(self, key: str) -> str:
@@ -56,7 +61,7 @@ class QueryParams(MutableMapping[str, str]):
         If the key is not present, raise KeyError.
         """
         self._ensure_single_query_api_used()
-        if key in EMBED_QUERY_PARAMS_KEYS:
+        if key.lower() in EMBED_QUERY_PARAMS_KEYS:
             raise KeyError(missing_key_error_message(key))
 
         try:
@@ -73,29 +78,15 @@ class QueryParams(MutableMapping[str, str]):
 
     def __setitem__(self, key: str, value: str | Iterable[str]) -> None:
         self._ensure_single_query_api_used()
-        self.__set_item_internal(key, value)
+        self._set_item_internal(key, value)
         self._send_query_param_msg()
 
-    def __set_item_internal(self, key: str, value: str | Iterable[str]) -> None:
-        if isinstance(value, dict):
-            raise StreamlitAPIException(
-                f"You cannot set a query params key `{key}` to a dictionary."
-            )
-
-        if key in EMBED_QUERY_PARAMS_KEYS:
-            raise StreamlitAPIException(
-                "Query param embed and embed_options (case-insensitive) cannot be set programmatically."
-            )
-        # Type checking users should handle the string serialization themselves
-        # We will accept any type for the list and serialize to str just in case
-        if isinstance(value, Iterable) and not isinstance(value, str):
-            self._query_params[key] = [str(item) for item in value]
-        else:
-            self._query_params[key] = str(value)
+    def _set_item_internal(self, key: str, value: str | Iterable[str]) -> None:
+        _set_item_in_dict(self._query_params, key, value)
 
     def __delitem__(self, key: str) -> None:
         self._ensure_single_query_api_used()
-        if key in EMBED_QUERY_PARAMS_KEYS:
+        if key.lower() in EMBED_QUERY_PARAMS_KEYS:
             raise KeyError(missing_key_error_message(key))
         try:
             del self._query_params[key]
@@ -116,17 +107,17 @@ class QueryParams(MutableMapping[str, str]):
         if hasattr(other, "keys") and hasattr(other, "__getitem__"):
             other = cast("SupportsKeysAndGetItem[str, str | Iterable[str]]", other)
             for key in other.keys():  # noqa: SIM118
-                self.__set_item_internal(key, other[key])
+                self._set_item_internal(key, other[key])
         else:
             for key, value in other:
-                self.__set_item_internal(key, value)
+                self._set_item_internal(key, value)
         for key, value in kwds.items():
-            self.__set_item_internal(key, value)
+            self._set_item_internal(key, value)
         self._send_query_param_msg()
 
     def get_all(self, key: str) -> list[str]:
         self._ensure_single_query_api_used()
-        if key not in self._query_params or key in EMBED_QUERY_PARAMS_KEYS:
+        if key not in self._query_params or key.lower() in EMBED_QUERY_PARAMS_KEYS:
             return []
         value = self._query_params[key]
         return value if isinstance(value, list) else [value]
@@ -134,7 +125,11 @@ class QueryParams(MutableMapping[str, str]):
     def __len__(self) -> int:
         self._ensure_single_query_api_used()
         return len(
-            {key for key in self._query_params if key not in EMBED_QUERY_PARAMS_KEYS}
+            {
+                key
+                for key in self._query_params
+                if key.lower() not in EMBED_QUERY_PARAMS_KEYS
+            }
         )
 
     def __str__(self) -> str:
@@ -165,7 +160,7 @@ class QueryParams(MutableMapping[str, str]):
         return {
             key: self[key]
             for key in self._query_params
-            if key not in EMBED_QUERY_PARAMS_KEYS
+            if key.lower() not in EMBED_QUERY_PARAMS_KEYS
         }
 
     def from_dict(
@@ -190,7 +185,7 @@ class QueryParams(MutableMapping[str, str]):
         self._query_params = {
             key: value
             for key, value in self._query_params.items()
-            if key in EMBED_QUERY_PARAMS_KEYS and preserve_embed
+            if key.lower() in EMBED_QUERY_PARAMS_KEYS and preserve_embed
         }
 
     def _ensure_single_query_api_used(self) -> None:
@@ -202,3 +197,59 @@ class QueryParams(MutableMapping[str, str]):
 
 def missing_key_error_message(key: str) -> str:
     return f'st.query_params has no key "{key}".'
+
+
+def _set_item_in_dict(
+    target_dict: dict[str, list[str] | str], key: str, value: str | Iterable[str]
+) -> None:
+    """Set an item in a dictionary."""
+    if isinstance(value, dict):
+        raise StreamlitQueryParamDictValueError(key)
+
+    if key.lower() in EMBED_QUERY_PARAMS_KEYS:
+        raise StreamlitAPIException(
+            "Query param embed and embed_options (case-insensitive) cannot be set programmatically."
+        )
+    # Type checking users should handle the string serialization themselves
+    # We will accept any type for the list and serialize to str just in case
+    if isinstance(value, Iterable) and not isinstance(value, str):
+        target_dict[key] = [str(item) for item in value]
+    else:
+        target_dict[key] = str(value)
+
+
+def process_query_params(
+    query_params: Iterable[tuple[str, str | Iterable[str]]]
+    | SupportsKeysAndGetItem[str, str | Iterable[str]],
+) -> str:
+    """Convert query params into a URL-encoded query string."""
+    processed_params: dict[str, list[str] | str] = {}
+
+    if hasattr(query_params, "keys") and hasattr(query_params, "__getitem__"):
+        query_params = cast(
+            "SupportsKeysAndGetItem[str, str | Iterable[str]]", query_params
+        )
+        for key in query_params.keys():  # noqa: SIM118
+            value = query_params[key]
+            _set_item_in_dict(processed_params, key, value)
+    else:
+        for key, value in query_params:
+            if key in processed_params:
+                # If the key already exists, we need to accumulate the values.
+                if isinstance(value, dict):
+                    raise StreamlitQueryParamDictValueError(key)
+
+                current_val = processed_params[key]
+                if not isinstance(current_val, list):
+                    current_val = [current_val]
+
+                if isinstance(value, Iterable) and not isinstance(value, str):
+                    current_val.extend([str(item) for item in value])
+                else:
+                    current_val.append(str(value))
+
+                processed_params[key] = current_val
+            else:
+                _set_item_in_dict(processed_params, key, value)
+
+    return parse.urlencode(processed_params, doseq=True)

streamlit/runtime/state/session_state.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import json
 import pickle
-from collections.abc import Iterator, KeysView, MutableMapping
+from collections.abc import Iterator, KeysView, Mapping, MutableMapping
 from copy import deepcopy
 from dataclasses import dataclass, field, replace
 from typing import (
@@ -726,7 +726,7 @@ class SessionState:
 
             for payload in payloads:
                 if isinstance(payload, dict):
-                    event_name = payload.get("event")
+                    event_name = cast("Mapping[str, object]", payload).get("event")
                     if isinstance(event_name, str) and metadata.callbacks:
                         cb = metadata.callbacks.get(event_name)
                         if cb is not None:

streamlit/static/index.html

@@ -37,7 +37,7 @@
     <script>
       window.prerenderReady = false
     </script>
-    <script type="module" crossorigin src="./static/js/index.CAj-7vWz.js"></script>
+    <script type="module" crossorigin src="./static/js/index.CqTPbV5Y.js"></script>
     <link rel="stylesheet" crossorigin href="./static/css/index.BpABIXK9.css">
   </head>
   <body>