streamlit-nightly 1.37.2.dev20240818__py2.py3-none-any.whl → 1.37.2.dev20240820__py2.py3-none-any.whl

streamlit/dataframe_util.py

@@ -70,29 +70,30 @@ _LOGGER: Final = logger.get_logger(__name__)
 _MAX_UNEVALUATED_DF_ROWS = 10000
 
 _PANDAS_DATA_OBJECT_TYPE_RE: Final = re.compile(r"^pandas.*$")
-_PANDAS_STYLER_TYPE_STR: Final = "pandas.io.formats.style.Styler"
-_XARRAY_DATA_ARRAY_TYPE_STR: Final = "xarray.core.dataarray.DataArray"
-_XARRAY_DATASET_TYPE_STR: Final = "xarray.core.dataset.Dataset"
-_SNOWPARK_DF_TYPE_STR: Final = "snowflake.snowpark.dataframe.DataFrame"
-_SNOWPARK_DF_ROW_TYPE_STR: Final = "snowflake.snowpark.row.Row"
-_SNOWPARK_TABLE_TYPE_STR: Final = "snowflake.snowpark.table.Table"
-_PYSPARK_DF_TYPE_STR: Final = "pyspark.sql.dataframe.DataFrame"
+
+_DASK_DATAFRAME: Final = "dask.dataframe.core.DataFrame"
+_DASK_INDEX: Final = "dask.dataframe.core.Index"
+_DASK_SERIES: Final = "dask.dataframe.core.Series"
+_DUCKDB_RELATION: Final = "duckdb.duckdb.DuckDBPyRelation"
 _MODIN_DF_TYPE_STR: Final = "modin.pandas.dataframe.DataFrame"
 _MODIN_SERIES_TYPE_STR: Final = "modin.pandas.series.Series"
+_PANDAS_STYLER_TYPE_STR: Final = "pandas.io.formats.style.Styler"
+_POLARS_DATAFRAME: Final = "polars.dataframe.frame.DataFrame"
+_POLARS_LAZYFRAME: Final = "polars.lazyframe.frame.LazyFrame"
+_POLARS_SERIES: Final = "polars.series.series.Series"
+_PYSPARK_DF_TYPE_STR: Final = "pyspark.sql.dataframe.DataFrame"
+_RAY_DATASET: Final = "ray.data.dataset.Dataset"
+_RAY_MATERIALIZED_DATASET: Final = "ray.data.dataset.MaterializedDataset"
 _SNOWPANDAS_DF_TYPE_STR: Final = "snowflake.snowpark.modin.pandas.dataframe.DataFrame"
-_SNOWPANDAS_SERIES_TYPE_STR: Final = "snowflake.snowpark.modin.pandas.series.Series"
 _SNOWPANDAS_INDEX_TYPE_STR: Final = (
     "snowflake.snowpark.modin.plugin.extensions.index.Index"
 )
-_POLARS_DATAFRAME: Final = "polars.dataframe.frame.DataFrame"
-_POLARS_SERIES: Final = "polars.series.series.Series"
-_POLARS_LAZYFRAME: Final = "polars.lazyframe.frame.LazyFrame"
-_DASK_DATAFRAME: Final = "dask.dataframe.core.DataFrame"
-_DASK_SERIES: Final = "dask.dataframe.core.Series"
-_DASK_INDEX: Final = "dask.dataframe.core.Index"
-_RAY_MATERIALIZED_DATASET: Final = "ray.data.dataset.MaterializedDataset"
-_RAY_DATASET: Final = "ray.data.dataset.Dataset"
-_DUCKDB_RELATION: Final = "duckdb.duckdb.DuckDBPyRelation"
+_SNOWPANDAS_SERIES_TYPE_STR: Final = "snowflake.snowpark.modin.pandas.series.Series"
+_SNOWPARK_DF_ROW_TYPE_STR: Final = "snowflake.snowpark.row.Row"
+_SNOWPARK_DF_TYPE_STR: Final = "snowflake.snowpark.dataframe.DataFrame"
+_SNOWPARK_TABLE_TYPE_STR: Final = "snowflake.snowpark.table.Table"
+_XARRAY_DATASET_TYPE_STR: Final = "xarray.core.dataset.Dataset"
+_XARRAY_DATA_ARRAY_TYPE_STR: Final = "xarray.core.dataarray.DataArray"
 
 V_co = TypeVar(
     "V_co",
@@ -195,37 +196,38 @@ class DataFormat(Enum):
 
     UNKNOWN = auto()
     EMPTY = auto()  # None
-    PANDAS_DATAFRAME = auto()  # pd.DataFrame
-    PANDAS_SERIES = auto()  # pd.Series
-    PANDAS_INDEX = auto()  # pd.Index
-    PANDAS_ARRAY = auto()  # pd.array
+
+    COLUMN_INDEX_MAPPING = auto()  # {column: {index: value}}
+    COLUMN_SERIES_MAPPING = auto()  # {column: Series(values)}
+    COLUMN_VALUE_MAPPING = auto()  # {column: List[values]}
+    DASK_OBJECT = auto()  # dask.dataframe.core.DataFrame, Series, Index
+    DBAPI_CURSOR = auto()  # DBAPI Cursor (PEP 249)
+    DUCKDB_RELATION = auto()  # DuckDB Relation
+    KEY_VALUE_DICT = auto()  # {index: value}
+    LIST_OF_RECORDS = auto()  # List[Dict[str, Scalar]]
+    LIST_OF_ROWS = auto()  # List[List[Scalar]]
+    LIST_OF_VALUES = auto()  # List[Scalar]
+    MODIN_OBJECT = auto()  # Modin DataFrame, Series
     NUMPY_LIST = auto()  # np.array[Scalar]
     NUMPY_MATRIX = auto()  # np.array[List[Scalar]]
-    PYARROW_TABLE = auto()  # pyarrow.Table
-    PYARROW_ARRAY = auto()  # pyarrow.Array
-    SNOWPARK_OBJECT = auto()  # Snowpark DataFrame, Table, List[Row]
-    PYSPARK_OBJECT = auto()  # pyspark.DataFrame
-    MODIN_OBJECT = auto()  # Modin DataFrame, Series
-    SNOWPANDAS_OBJECT = auto()  # Snowpandas DataFrame, Series
+    PANDAS_ARRAY = auto()  # pd.array
+    PANDAS_DATAFRAME = auto()  # pd.DataFrame
+    PANDAS_INDEX = auto()  # pd.Index
+    PANDAS_SERIES = auto()  # pd.Series
     PANDAS_STYLER = auto()  # pandas Styler
     POLARS_DATAFRAME = auto()  # polars.dataframe.frame.DataFrame
     POLARS_LAZYFRAME = auto()  # polars.lazyframe.frame.LazyFrame
     POLARS_SERIES = auto()  # polars.series.series.Series
-    XARRAY_DATASET = auto()  # xarray.Dataset
-    XARRAY_DATA_ARRAY = auto()  # xarray.DataArray
-    DASK_OBJECT = auto()  # dask.dataframe.core.DataFrame, Series, Index
+    PYARROW_ARRAY = auto()  # pyarrow.Array
+    PYARROW_TABLE = auto()  # pyarrow.Table
+    PYSPARK_OBJECT = auto()  # pyspark.DataFrame
     RAY_DATASET = auto()  # ray.data.dataset.Dataset, MaterializedDataset
-    LIST_OF_RECORDS = auto()  # List[Dict[str, Scalar]]
-    LIST_OF_ROWS = auto()  # List[List[Scalar]]
-    LIST_OF_VALUES = auto()  # List[Scalar]
-    TUPLE_OF_VALUES = auto()  # Tuple[Scalar]
     SET_OF_VALUES = auto()  # Set[Scalar]
-    COLUMN_INDEX_MAPPING = auto()  # {column: {index: value}}
-    COLUMN_VALUE_MAPPING = auto()  # {column: List[values]}
-    COLUMN_SERIES_MAPPING = auto()  # {column: Series(values)}
-    KEY_VALUE_DICT = auto()  # {index: value}
-    DBAPI_CURSOR = auto()  # DBAPI Cursor (PEP 249)
-    DUCKDB_RELATION = auto()  # DuckDB Relation
+    SNOWPANDAS_OBJECT = auto()  # Snowpandas DataFrame, Series
+    SNOWPARK_OBJECT = auto()  # Snowpark DataFrame, Table, List[Row]
+    TUPLE_OF_VALUES = auto()  # Tuple[Scalar]
+    XARRAY_DATASET = auto()  # xarray.Dataset
+    XARRAY_DATA_ARRAY = auto()  # xarray.DataArray
 
 
 def is_pyarrow_version_less_than(v: str) -> bool:
@@ -288,30 +290,30 @@ def is_dataframe_like(obj: object) -> bool:
         # return False early to avoid unnecessary checks.
         return False
 
-    return determine_data_format(obj) in [
+    return determine_data_format(obj) in {
+        DataFormat.COLUMN_SERIES_MAPPING,
+        DataFormat.DASK_OBJECT,
+        DataFormat.DBAPI_CURSOR,
+        DataFormat.MODIN_OBJECT,
+        DataFormat.NUMPY_LIST,
+        DataFormat.NUMPY_MATRIX,
+        DataFormat.PANDAS_ARRAY,
         DataFormat.PANDAS_DATAFRAME,
-        DataFormat.PANDAS_SERIES,
         DataFormat.PANDAS_INDEX,
+        DataFormat.PANDAS_SERIES,
         DataFormat.PANDAS_STYLER,
-        DataFormat.PANDAS_ARRAY,
-        DataFormat.NUMPY_LIST,
-        DataFormat.NUMPY_MATRIX,
-        DataFormat.PYARROW_TABLE,
+        DataFormat.POLARS_DATAFRAME,
+        DataFormat.POLARS_LAZYFRAME,
+        DataFormat.POLARS_SERIES,
         DataFormat.PYARROW_ARRAY,
-        DataFormat.SNOWPARK_OBJECT,
+        DataFormat.PYARROW_TABLE,
         DataFormat.PYSPARK_OBJECT,
-        DataFormat.MODIN_OBJECT,
+        DataFormat.RAY_DATASET,
         DataFormat.SNOWPANDAS_OBJECT,
-        DataFormat.POLARS_SERIES,
-        DataFormat.POLARS_DATAFRAME,
-        DataFormat.POLARS_LAZYFRAME,
+        DataFormat.SNOWPARK_OBJECT,
         DataFormat.XARRAY_DATASET,
         DataFormat.XARRAY_DATA_ARRAY,
-        DataFormat.DASK_OBJECT,
-        DataFormat.RAY_DATASET,
-        DataFormat.COLUMN_SERIES_MAPPING,
-        DataFormat.DBAPI_CURSOR,
-    ]
+    }
 
 
 def is_unevaluated_data_object(obj: object) -> bool:
@@ -892,7 +894,7 @@ def convert_anything_to_arrow_bytes(
     return convert_pandas_df_to_arrow_bytes(df)
 
 
-def convert_anything_to_sequence(obj: OptionSequence[V_co]) -> list[V_co]:
+def convert_anything_to_list(obj: OptionSequence[V_co]) -> list[V_co]:
     """Try to convert different formats to a list.
 
     If the input is a dataframe-like object, we just select the first
@@ -1309,21 +1311,21 @@ def convert_pandas_df_to_data_format(
         The converted dataframe.
     """
 
-    if data_format in [
+    if data_format in {
         DataFormat.EMPTY,
+        DataFormat.DASK_OBJECT,
+        DataFormat.DBAPI_CURSOR,
+        DataFormat.DUCKDB_RELATION,
+        DataFormat.MODIN_OBJECT,
+        DataFormat.PANDAS_ARRAY,
         DataFormat.PANDAS_DATAFRAME,
-        DataFormat.SNOWPARK_OBJECT,
-        DataFormat.PYSPARK_OBJECT,
         DataFormat.PANDAS_INDEX,
         DataFormat.PANDAS_STYLER,
-        DataFormat.PANDAS_ARRAY,
-        DataFormat.MODIN_OBJECT,
-        DataFormat.SNOWPANDAS_OBJECT,
-        DataFormat.DASK_OBJECT,
+        DataFormat.PYSPARK_OBJECT,
         DataFormat.RAY_DATASET,
-        DataFormat.DBAPI_CURSOR,
-        DataFormat.DUCKDB_RELATION,
-    ]:
+        DataFormat.SNOWPANDAS_OBJECT,
+        DataFormat.SNOWPARK_OBJECT,
+    }:
         return df
     elif data_format == DataFormat.NUMPY_LIST:
         import numpy as np
@@ -1347,10 +1349,7 @@ def convert_pandas_df_to_data_format(
         return pa.Array.from_pandas(_pandas_df_to_series(df))
     elif data_format == DataFormat.PANDAS_SERIES:
         return _pandas_df_to_series(df)
-    elif (
-        data_format == DataFormat.POLARS_DATAFRAME
-        or data_format == DataFormat.POLARS_LAZYFRAME
-    ):
+    elif data_format in {DataFormat.POLARS_DATAFRAME, DataFormat.POLARS_LAZYFRAME}:
         import polars as pl  # type: ignore[import-not-found]
 
         return pl.from_pandas(df)

streamlit/elements/image.py

@@ -25,7 +25,7 @@ import io
 import os
 import re
 from enum import IntEnum
-from typing import TYPE_CHECKING, Final, List, Literal, Sequence, Union, cast
+from typing import TYPE_CHECKING, Final, Literal, Sequence, Union, cast
 
 from typing_extensions import TypeAlias
 
@@ -54,7 +54,7 @@ PILImage: TypeAlias = Union[
     "ImageFile.ImageFile", "Image.Image", "GifImagePlugin.GifImageFile"
 ]
 AtomicImage: TypeAlias = Union[PILImage, "npt.NDArray[Any]", io.BytesIO, str, bytes]
-ImageOrImageList: TypeAlias = Union[AtomicImage, List[AtomicImage]]
+ImageOrImageList: TypeAlias = Union[AtomicImage, Sequence[AtomicImage]]
 UseColumnWith: TypeAlias = Union[Literal["auto", "always", "never"], bool, None]
 Channels: TypeAlias = Literal["RGB", "BGR"]
 ImageFormat: TypeAlias = Literal["JPEG", "PNG", "GIF"]
@@ -178,14 +178,11 @@ class ImageMixin:
 
 
 def _image_may_have_alpha_channel(image: PILImage) -> bool:
-    if image.mode in ("RGBA", "LA", "P"):
-        return True
-    else:
-        return False
+    return image.mode in ("RGBA", "LA", "P")
 
 
 def _image_is_gif(image: PILImage) -> bool:
-    return bool(image.format == "GIF")
+    return image.format == "GIF"
 
 
 def _validate_image_format_string(
@@ -199,7 +196,7 @@ def _validate_image_format_string(
     "GIF" if the image is a GIF, and "JPEG" otherwise.
     """
     format = format.upper()
-    if format == "JPEG" or format == "PNG":
+    if format in {"JPEG", "PNG"}:
         return cast(ImageFormat, format)
 
     # We are forgiving on the spelling of JPEG
@@ -509,30 +506,23 @@ def marshall_images(
 
     # Turn single image and caption into one element list.
     images: Sequence[AtomicImage]
-    if isinstance(image, list):
-        images = image
+    if isinstance(image, (list, set, tuple)):
+        images = list(image)
     elif isinstance(image, np.ndarray) and len(cast(NumpyShape, image.shape)) == 4:
         images = _4d_to_list_3d(image)
     else:
-        images = [image]
+        images = [image]  # type: ignore
 
     if isinstance(caption, list):
         captions: Sequence[str | None] = caption
+    elif isinstance(caption, str):
+        captions = [caption]
+    elif isinstance(caption, np.ndarray) and len(cast(NumpyShape, caption.shape)) == 1:
+        captions = caption.tolist()
+    elif caption is None:
+        captions = [None] * len(images)
     else:
-        if isinstance(caption, str):
-            captions = [caption]
-        # You can pass in a 1-D Numpy array as captions.
-        elif (
-            isinstance(caption, np.ndarray)
-            and len(cast(NumpyShape, caption.shape)) == 1
-        ):
-            captions = caption.tolist()
-        # If there are no captions then make the captions list the same size
-        # as the images list.
-        elif caption is None:
-            captions = [None] * len(images)
-        else:
-            captions = [str(caption)]
+        captions = [str(caption)]
 
     assert isinstance(
         captions, list

streamlit/elements/lib/built_in_chart_utils.py

@@ -643,7 +643,7 @@ def _parse_y_columns(
 
     else:
         y_column_list = [
-            str(col) for col in dataframe_util.convert_anything_to_sequence(y_from_user)
+            str(col) for col in dataframe_util.convert_anything_to_list(y_from_user)
         ]
 
     for col in y_column_list:

streamlit/elements/lib/options_selector_utils.py

@@ -19,7 +19,7 @@ from typing import (
     Sequence,
 )
 
-from streamlit.dataframe_util import OptionSequence, convert_anything_to_sequence
+from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.errors import StreamlitAPIException
 from streamlit.type_util import (
     T,
@@ -34,7 +34,7 @@ def check_and_convert_to_indices(
     if default_values is None:
         return None
 
-    default_values = convert_anything_to_sequence(default_values)
+    default_values = convert_anything_to_list(default_values)
 
     for value in default_values:
         if value not in opt:
@@ -47,7 +47,7 @@ def check_and_convert_to_indices(
 
 
 def convert_to_sequence_and_check_comparable(options: OptionSequence[T]) -> Sequence[T]:
-    indexable_options = convert_anything_to_sequence(options)
+    indexable_options = convert_anything_to_list(options)
     check_python_comparable(indexable_options)
     return indexable_options
 

streamlit/elements/lib/policies.py

@@ -19,7 +19,10 @@ from typing import TYPE_CHECKING, Any, Final, Sequence
 from streamlit import config, errors, logger, runtime
 from streamlit.elements.form_utils import is_in_form
 from streamlit.errors import StreamlitAPIException, StreamlitAPIWarning
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    get_script_run_ctx,
+    in_cached_function,
+)
 from streamlit.runtime.state import WidgetCallback, get_session_state
 
 if TYPE_CHECKING:
@@ -114,14 +117,12 @@ def check_cache_replay_rules() -> None:
     If there are other similar checks in the future, we could extend this
     function to check for those as well. And rename it to check_widget_usage_rules.
     """
-    if runtime.exists():
-        ctx = get_script_run_ctx()
-        if ctx and ctx.disallow_cached_widget_usage:
-            from streamlit import exception
-
-            # We use an exception here to show a proper stack trace
-            # that indicates to the user where the issue is.
-            exception(CachedWidgetWarning())
+    if in_cached_function.get():
+        from streamlit import exception
+
+        # We use an exception here to show a proper stack trace
+        # that indicates to the user where the issue is.
+        exception(CachedWidgetWarning())
 
 
 _fragment_writes_widget_to_outside_error = (

streamlit/elements/widgets/radio.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, cast
 
-from streamlit.dataframe_util import OptionSequence, convert_anything_to_sequence
+from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.form_utils import current_form_id
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -270,7 +270,7 @@ class RadioMixin:
         )
         maybe_raise_label_warnings(label, label_visibility)
 
-        opt = convert_anything_to_sequence(options)
+        opt = convert_anything_to_list(options)
         check_python_comparable(opt)
 
         id = compute_widget_id(

streamlit/elements/widgets/select_slider.py

@@ -20,7 +20,7 @@ from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, Tuple, cast
 
 from typing_extensions import TypeGuard
 
-from streamlit.dataframe_util import OptionSequence, convert_anything_to_sequence
+from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.form_utils import current_form_id
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -287,7 +287,7 @@ class SelectSliderMixin:
         )
         maybe_raise_label_warnings(label, label_visibility)
 
-        opt = convert_anything_to_sequence(options)
+        opt = convert_anything_to_list(options)
         check_python_comparable(opt)
 
         if len(opt) == 0:

streamlit/elements/widgets/selectbox.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass
 from textwrap import dedent
 from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, cast, overload
 
-from streamlit.dataframe_util import OptionSequence, convert_anything_to_sequence
+from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.form_utils import current_form_id
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -281,7 +281,7 @@ class SelectboxMixin:
         )
         maybe_raise_label_warnings(label, label_visibility)
 
-        opt = convert_anything_to_sequence(options)
+        opt = convert_anything_to_list(options)
         check_python_comparable(opt)
 
         id = compute_widget_id(

streamlit/runtime/caching/__init__.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING
 
 from streamlit.runtime.caching.cache_data_api import (
     CACHE_DATA_MESSAGE_REPLAY_CTX,
@@ -33,7 +33,6 @@ if TYPE_CHECKING:
     from google.protobuf.message import Message
 
     from streamlit.proto.Block_pb2 import Block
-    from streamlit.runtime.state.common import WidgetMetadata
 
 
 def save_element_message(
@@ -73,14 +72,6 @@ def save_block_message(
     )
 
 
-def save_widget_metadata(metadata: WidgetMetadata[Any]) -> None:
-    """Save a widget's metadata to a thread-local callstack, so the widget
-    can be registered again when that widget is replayed.
-    """
-    CACHE_DATA_MESSAGE_REPLAY_CTX.save_widget_metadata(metadata)
-    CACHE_RESOURCE_MESSAGE_REPLAY_CTX.save_widget_metadata(metadata)
-
-
 def save_media_data(image_data: bytes | str, mimetype: str, image_id: str) -> None:
     CACHE_DATA_MESSAGE_REPLAY_CTX.save_image_data(image_data, mimetype, image_id)
     CACHE_RESOURCE_MESSAGE_REPLAY_CTX.save_image_data(image_data, mimetype, image_id)
@@ -99,7 +90,6 @@ __all__ = [
     "CACHE_DOCS_URL",
     "save_element_message",
     "save_block_message",
-    "save_widget_metadata",
     "save_media_data",
     "get_data_cache_stats_provider",
     "get_resource_cache_stats_provider",

streamlit/runtime/caching/cache_data_api.py

@@ -47,9 +47,7 @@ from streamlit.runtime.caching.cache_utils import (
 from streamlit.runtime.caching.cached_message_replay import (
     CachedMessageReplayContext,
     CachedResult,
-    ElementMsgData,
     MsgData,
-    MultiCacheResults,
     show_widget_replay_deprecation,
 )
 from streamlit.runtime.caching.storage import (
@@ -66,7 +64,6 @@ from streamlit.runtime.caching.storage.dummy_cache_storage import (
     MemoryCacheStorageManager,
 )
 from streamlit.runtime.metrics_util import gather_metrics
-from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.time_util import time_to_seconds
 
@@ -93,13 +90,11 @@ class CachedDataFuncInfo(CachedFuncInfo):
         persist: CachePersistType,
         max_entries: int | None,
         ttl: float | timedelta | str | None,
-        allow_widgets: bool,
         hash_funcs: HashFuncsDict | None = None,
     ):
         super().__init__(
             func,
             show_spinner=show_spinner,
-            allow_widgets=allow_widgets,
             hash_funcs=hash_funcs,
         )
         self.persist = persist
@@ -128,7 +123,6 @@ class CachedDataFuncInfo(CachedFuncInfo):
             max_entries=self.max_entries,
             ttl=self.ttl,
             display_name=self.display_name,
-            allow_widgets=self.allow_widgets,
         )
 
     def validate_params(self) -> None:
@@ -160,7 +154,6 @@ class DataCaches(CacheStatsProvider):
         max_entries: int | None,
         ttl: int | float | timedelta | str | None,
         display_name: str,
-        allow_widgets: bool,
     ) -> DataCache:
         """Return the mem cache for the given key.
 
@@ -220,7 +213,6 @@ class DataCaches(CacheStatsProvider):
                 max_entries=max_entries,
                 ttl_seconds=ttl_seconds,
                 display_name=display_name,
-                allow_widgets=allow_widgets,
             )
             self._function_caches[key] = cache
             return cache
@@ -443,9 +435,11 @@ class CacheDataAPI:
 
         experimental_allow_widgets : bool
             Allow widgets to be used in the cached function. Defaults to False.
-            Support for widgets in cached functions is currently experimental.
-            Setting this parameter to True may lead to excessive memory use since the
-            widget value is treated as an additional input parameter to the cache.
+
+            .. deprecated::
+                The cached widget replay functionality was removed in 1.38. Please
+                remove the ``experimental_allow_widgets`` parameter from your
+                caching decorators.
 
         hash_funcs : dict or None
             Mapping of types or fully qualified names to hash functions.
@@ -455,10 +449,6 @@ class CacheDataAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
-        .. deprecated::
-            ``experimental_allow_widgets`` is deprecated and will be removed in
-            a later version.
-
         Example
         -------
         >>> import streamlit as st
@@ -574,7 +564,6 @@ class CacheDataAPI:
                     show_spinner=show_spinner,
                     max_entries=max_entries,
                     ttl=ttl,
-                    allow_widgets=experimental_allow_widgets,
                     hash_funcs=hash_funcs,
                 )
             )
@@ -589,7 +578,6 @@ class CacheDataAPI:
                 show_spinner=show_spinner,
                 max_entries=max_entries,
                 ttl=ttl,
-                allow_widgets=experimental_allow_widgets,
                 hash_funcs=hash_funcs,
             )
         )
@@ -611,7 +599,6 @@ class DataCache(Cache):
         max_entries: int | None,
         ttl_seconds: float | None,
         display_name: str,
-        allow_widgets: bool = False,
     ):
         super().__init__()
         self.key = key
@@ -620,7 +607,6 @@ class DataCache(Cache):
         self.ttl_seconds = ttl_seconds
         self.max_entries = max_entries
         self.persist = persist
-        self.allow_widgets = allow_widgets
 
     def get_stats(self) -> list[CacheStat]:
         if isinstance(self.storage, CacheStatsProvider):
@@ -641,21 +627,12 @@ class DataCache(Cache):
 
         try:
             entry = pickle.loads(pickled_entry)
-            if not isinstance(entry, MultiCacheResults):
+            if not isinstance(entry, CachedResult):
                 # Loaded an old cache file format, remove it and let the caller
                 # rerun the function.
                 self.storage.delete(key)
                 raise CacheKeyNotFoundError()
-
-            ctx = get_script_run_ctx()
-            if not ctx:
-                raise CacheKeyNotFoundError()
-
-            widget_key = entry.get_current_widget_key(ctx, CacheType.DATA)
-            if widget_key in entry.results:
-                return entry.results[widget_key]
-            else:
-                raise CacheKeyNotFoundError()
+            return entry
         except pickle.UnpicklingError as exc:
             raise CacheError(f"Failed to unpickle {key}") from exc
 
@@ -664,43 +641,13 @@ class DataCache(Cache):
         """Write a value and associated messages to the cache.
         The value must be pickleable.
         """
-        ctx = get_script_run_ctx()
-        if ctx is None:
-            return
-
-        main_id = st._main.id
-        sidebar_id = st.sidebar.id
-
-        if self.allow_widgets:
-            widgets = {
-                msg.widget_metadata.widget_id
-                for msg in messages
-                if isinstance(msg, ElementMsgData) and msg.widget_metadata is not None
-            }
-        else:
-            widgets = set()
-
-        multi_cache_results: MultiCacheResults | None = None
-
-        # Try to find in cache storage, then falling back to a new result instance
-        try:
-            multi_cache_results = self._read_multi_results_from_storage(key)
-        except (CacheKeyNotFoundError, pickle.UnpicklingError):
-            pass
-
-        if multi_cache_results is None:
-            multi_cache_results = MultiCacheResults(widget_ids=widgets, results={})
-        multi_cache_results.widget_ids.update(widgets)
-        widget_key = multi_cache_results.get_current_widget_key(ctx, CacheType.DATA)
-
-        result = CachedResult(value, messages, main_id, sidebar_id)
-        multi_cache_results.results[widget_key] = result
-
         try:
-            pickled_entry = pickle.dumps(multi_cache_results)
+            main_id = st._main.id
+            sidebar_id = st.sidebar.id
+            entry = CachedResult(value, messages, main_id, sidebar_id)
+            pickled_entry = pickle.dumps(entry)
         except (pickle.PicklingError, TypeError) as exc:
             raise CacheError(f"Failed to pickle {key}") from exc
-
         self.storage.set(key, pickled_entry)
 
     def _clear(self, key: str | None = None) -> None:
@@ -708,22 +655,3 @@ class DataCache(Cache):
             self.storage.clear()
         else:
             self.storage.delete(key)
-
-    def _read_multi_results_from_storage(self, key: str) -> MultiCacheResults:
-        """Look up the results from storage and ensure it has the right type.
-
-        Raises a `CacheKeyNotFoundError` if the key has no entry, or if the
-        entry is malformed.
-        """
-        try:
-            pickled = self.storage.get(key)
-        except CacheStorageKeyNotFoundError as e:
-            raise CacheKeyNotFoundError(str(e)) from e
-
-        maybe_results = pickle.loads(pickled)
-
-        if isinstance(maybe_results, MultiCacheResults):
-            return maybe_results
-        else:
-            self.storage.delete(key)
-            raise CacheKeyNotFoundError()