streamlit-nightly 1.52.3.dev20251222__py3-none-any.whl → 1.52.3.dev20251223__py3-none-any.whl

streamlit/elements/lib/column_types.py

@@ -45,6 +45,13 @@ NumberFormat: TypeAlias = Literal[
     "bytes",
 ]
 
+DateTimeFormat: TypeAlias = Literal[
+    "localized",
+    "distance",
+    "calendar",
+    "iso8601",
+]
+
 ColumnWidth: TypeAlias = Literal["small", "medium", "large"] | int
 
 # Type alias that represents all available column types
@@ -194,9 +201,7 @@ class MultiselectColumnConfig(TypedDict):
 
 class DatetimeColumnConfig(TypedDict):
     type: Literal["datetime"]
-    format: NotRequired[
-        str | Literal["localized", "distance", "calendar", "iso8601"] | None
-    ]
+    format: NotRequired[str | DateTimeFormat | None]
     min_value: NotRequired[str | None]
     max_value: NotRequired[str | None]
     step: NotRequired[int | float | None]
@@ -1972,7 +1977,7 @@ def DatetimeColumn(
     required: bool | None = None,
     pinned: bool | None = None,
     default: datetime.datetime | None = None,
-    format: str | Literal["localized", "distance", "calendar", "iso8601"] | None = None,
+    format: str | DateTimeFormat | None = None,
     min_value: datetime.datetime | None = None,
     max_value: datetime.datetime | None = None,
     step: int | float | datetime.timedelta | None = None,

streamlit/elements/vega_charts.py

@@ -279,6 +279,41 @@ def _patch_null_legend_titles(spec: VegaLiteSpec) -> None:
         legend["title"] = " "
 
 
+def _has_nested_composition(spec: VegaLiteSpec) -> bool:
+    """Check if a vconcat spec contains nested composition operators.
+
+    This function checks if a vconcat chart contains nested hconcat, vconcat,
+    concat, or layer operators. Such nested compositions don't work well with
+    the fit-x autosize type and can cause infinite extent errors.
+
+    In valid Vega-Lite specs, composition operators (hconcat, vconcat, concat, layer)
+    are always top-level keys of a view specification. They cannot be buried inside
+    encoding, mark, or other nested properties. This allows us to check only the
+    immediate children of vconcat for nested composition operators.
+
+    Parameters
+    ----------
+    spec : VegaLiteSpec
+        The Vega-Lite spec to check.
+
+    Returns
+    -------
+    bool
+        True if the spec contains nested composition operators, False otherwise.
+    """
+    # Check if vconcat contains nested compositions.
+    # We only need to check top-level keys of each child spec since composition
+    # operators are always top-level in valid Vega-Lite specs.
+    if "vconcat" in spec and isinstance(spec["vconcat"], list):
+        for item in spec["vconcat"]:
+            # Check if this item is a dict containing any composition operator
+            if isinstance(item, dict) and any(
+                k in item for k in ["hconcat", "vconcat", "concat", "layer"]
+            ):
+                return True
+    return False
+
+
 def _prepare_vega_lite_spec(
     spec: VegaLiteSpec,
     use_container_width: bool,
@@ -306,10 +341,33 @@ def _prepare_vega_lite_spec(
             "encoding" in spec
             and (any(x in spec["encoding"] for x in ["row", "column", "facet"]))
         )
-        if "vconcat" in spec and use_container_width:
-            spec["autosize"] = {"type": "fit-x", "contains": "padding"}
+        has_nested_comp = _has_nested_composition(spec)
 
-        elif is_facet_chart:
+        if "vconcat" in spec and use_container_width:
+            # For vconcat charts with container width stretching:
+            # - Simple vconcat: use fit-x (fits width only, better control)
+            # - Nested compositions (vconcat+hconcat): use pad (no automatic fitting)
+            #   fit-x causes "Infinite extent" errors with nested hconcat (issue #13410)
+            #
+            # Known limitation: Nested compositions may overflow the container because
+            # Vega-Lite's width property only controls the plotting area (data marks),
+            # not the total SVG width which includes axes, labels, legends, and padding.
+            # The frontend sets spec.width to containerWidth, but with autosize: pad,
+            # Vega adds decorations on top, causing total SVG to exceed container bounds.
+            # This is a Vega-Lite architectural limitation similar to facet charts
+            # (see https://github.com/vega/vega-lite/issues/5219).
+            # Trade-off: Accept overflow to ensure charts render correctly rather than
+            # appear as empty elements with "Infinite extent" errors.
+            if has_nested_comp:
+                # use pad = "no automatic fitting" - accurate description of what's happening
+                # produces same overflow behavior as fit
+                spec["autosize"] = {"type": "pad", "contains": "padding"}
+            else:
+                spec["autosize"] = {"type": "fit-x", "contains": "padding"}
+
+        elif is_facet_chart or (has_nested_comp and not use_container_width):
+            # Facet charts and nested compositions without stretching use pad
+            # (no automatic sizing, uses natural/content size)
             spec["autosize"] = {"type": "pad", "contains": "padding"}
 
         else:
@@ -1780,6 +1838,10 @@ class VegaChartsMixin:
                 - Horizontal concatenation charts: the spec contains
                   ``"hconcat"``.
                 - Repeat charts: the spec contains ``"repeat"``.
+                - Nested composition charts: the spec contains ``"vconcat"``
+                  with nested ``"hconcat"``, ``"vconcat"``, ``"concat"``, or
+                  ``"layer"`` operators (e.g., scatter plots with marginal
+                  histograms).
 
         height : "content", "stretch", or int
             The height of the chart element. This can be one of the following:
@@ -1999,6 +2061,10 @@ class VegaChartsMixin:
                 - Horizontal concatenation charts: the spec contains
                   ``"hconcat"``.
                 - Repeat charts: the spec contains ``"repeat"``.
+                - Nested composition charts: the spec contains ``"vconcat"``
+                  with nested ``"hconcat"``, ``"vconcat"``, ``"concat"``, or
+                  ``"layer"`` operators (e.g., scatter plots with marginal
+                  histograms).
 
         height : "content", "stretch", or int
             The height of the chart element. This can be one of the following:
@@ -2263,13 +2329,21 @@ class VegaChartsMixin:
             # those charts (see https://github.com/streamlit/streamlit/issues/9091).
             # All other charts (including vertical concatenation) default to
             # `width=stretch` unless width is provided.
+            # Nested vconcat+hconcat charts (issue #13410) also don't work well
+            # with width=stretch, so we treat them like hconcat charts.
             is_facet_chart = "facet" in spec or (
                 "encoding" in spec
                 and (any(x in spec["encoding"] for x in ["row", "column", "facet"]))
             )
+            has_nested_comp = _has_nested_composition(spec)
             width = (
                 "stretch"
-                if not (is_facet_chart or "hconcat" in spec or "repeat" in spec)
+                if not (
+                    is_facet_chart
+                    or "hconcat" in spec
+                    or "repeat" in spec
+                    or has_nested_comp
+                )
                 else "content"
             )
 

streamlit/elements/widgets/slider.py

@@ -62,6 +62,7 @@ from streamlit.runtime.state import (
 
 if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
+    from streamlit.elements.lib.column_types import DateTimeFormat, NumberFormat
     from streamlit.elements.lib.layout_utils import WidthWithoutContent
 
 SliderNumericT = TypeVar("SliderNumericT", int, float)
@@ -229,7 +230,7 @@ class SliderMixin:
         max_value: None = None,
         value: None = None,
         step: int | None = None,
-        format: str | None = None,
+        format: str | NumberFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -251,7 +252,7 @@ class SliderMixin:
         max_value: SliderNumericT | None = None,
         value: SliderNumericT | None = None,
         step: StepNumericT[SliderNumericT] | None = None,
-        format: str | None = None,
+        format: str | NumberFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -274,7 +275,7 @@ class SliderMixin:
         *,
         value: SliderNumericSpanT[SliderNumericT],
         step: StepNumericT[SliderNumericT] | None = None,
-        format: str | None = None,
+        format: str | NumberFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -295,7 +296,7 @@ class SliderMixin:
         max_value: SliderNumericT,
         value: SliderNumericSpanT[SliderNumericT],
         step: StepNumericT[SliderNumericT] | None = None,
-        format: str | None = None,
+        format: str | NumberFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -317,7 +318,7 @@ class SliderMixin:
         max_value: SliderDatelikeT | None = None,
         value: SliderDatelikeT | None = None,
         step: StepDatelikeT | None = None,
-        format: str | None = None,
+        format: str | DateTimeFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -340,7 +341,7 @@ class SliderMixin:
         max_value: SliderDatelikeT,
         value: SliderDatelikeT | None = None,
         step: StepDatelikeT | None = None,
-        format: str | None = None,
+        format: str | DateTimeFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -361,7 +362,7 @@ class SliderMixin:
         *,
         value: SliderDatelikeT,
         step: StepDatelikeT | None = None,
-        format: str | None = None,
+        format: str | DateTimeFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -385,7 +386,7 @@ class SliderMixin:
         | tuple[SliderDatelikeT]
         | tuple[SliderDatelikeT, SliderDatelikeT],
         step: StepDatelikeT | None = None,
-        format: str | None = None,
+        format: str | DateTimeFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -407,7 +408,7 @@ class SliderMixin:
         value: SliderDatelikeSpanT[SliderDatelikeT],
         /,
         step: StepDatelikeT | None = None,
-        format: str | None = None,
+        format: str | DateTimeFormat | None = None,
         key: Key | None = None,
         help: str | None = None,
         on_change: WidgetCallback | None = None,
@@ -517,16 +518,43 @@ class SliderMixin:
             (or if max_value - min_value < 1 day)
 
         format : str or None
-            A printf-style format string controlling how the interface should
-            display numbers. This does not impact the return value.
-
-            For information about formatting integers and floats, see
+            A printf-style format string or a predefined format name controlling
+            how the interface should display values. This does not impact the
+            return value.
+
+            For integers and floats, you can use a printf-style format string
+            or one of the following predefined formats:
+
+            - ``"plain"``: Show the full number without formatting (e.g. ``1234.567``).
+            - ``"localized"``: Show the number in the user's locale format (e.g. ``1,234.567``).
+            - ``"percent"``: Show as a percentage (e.g. ``50%`` from ``0.5``).
+            - ``"dollar"``: Show as US dollars (e.g. ``$1,234.57``).
+            - ``"euro"``: Show as euros (e.g. ``€1,234.57``).
+            - ``"yen"``: Show as Japanese yen (e.g. ``¥1,235``).
+            - ``"compact"``: Show in compact notation (e.g. ``1.2K``).
+            - ``"scientific"``: Show in scientific notation (e.g. ``1.235E3``).
+            - ``"engineering"``: Show in engineering notation (e.g. ``1.235E3``).
+            - ``"accounting"``: Show in accounting format with parentheses for negatives.
+            - ``"bytes"``: Show in byte units (e.g. ``1.2KB``).
+
+            For information about printf-style format strings, see
             `sprintf.js
             <https://github.com/alexei/sprintf.js?tab=readme-ov-file#format-specification>`_.
             For example, ``format="%0.1f"`` adjusts the displayed decimal
             precision to only show one digit after the decimal.
 
-            For information about formatting datetimes, dates, and times, see
+            For datetimes, dates, and times, you can use a momentJS format string
+            or one of the following predefined formats:
+
+            - ``"localized"``: Show in the user's locale format.
+            - ``"distance"``: Show as relative time (e.g. ``"2 hours ago"``).
+            - ``"calendar"``: Show as calendar time (e.g. ``"Tomorrow 12:00"``).
+              Works best with datetime values. For date-only values, displays
+              relative day names (e.g. ``"Yesterday"``). For time-only values,
+              this format may produce unexpected results.
+            - ``"iso8601"``: Show in ISO 8601 format.
+
+            For information about momentJS format strings, see
             `momentJS <https://momentjs.com/docs/#/displaying/format/>`_.
             For example, ``format="ddd ha"`` adjusts the displayed datetime to
             show the day of the week and the hour ("Tue 8pm").

streamlit/runtime/caching/cache_resource_api.py

@@ -29,7 +29,6 @@ from typing import (
     overload,
 )
 
-from cachetools import TTLCache
 from typing_extensions import ParamSpec
 
 import streamlit as st
@@ -41,6 +40,7 @@ from streamlit.runtime.caching.cache_utils import (
     Cache,
     CachedFunc,
     CachedFuncInfo,
+    OnRelease,
     make_cached_func_wrapper,
 )
 from streamlit.runtime.caching.cached_message_replay import (
@@ -48,6 +48,7 @@ from streamlit.runtime.caching.cached_message_replay import (
     CachedResult,
     MsgData,
 )
+from streamlit.runtime.caching.ttl_cleanup_cache import TTLCleanupCache
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.stats import (
     CACHE_MEMORY_FAMILY,
@@ -79,6 +80,10 @@ def _equal_validate_funcs(a: ValidateFunc | None, b: ValidateFunc | None) -> boo
     return (a is None and b is None) or (a is not None and b is not None)
 
 
+def _no_op_release(ignored: Any) -> None:
+    """No-op OnRelease function."""
+
+
 class ResourceCaches(StatsProvider):
     """Manages all ResourceCache instances."""
 
@@ -97,6 +102,7 @@ class ResourceCaches(StatsProvider):
         max_entries: int | float | None,
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
+        on_release: OnRelease,
     ) -> ResourceCache[Any]:
         """Return the mem cache for the given key.
 
@@ -127,15 +133,22 @@ class ResourceCaches(StatsProvider):
                 max_entries=max_entries,
                 ttl_seconds=ttl_seconds,
                 validate=validate,
+                on_release=on_release,
             )
             self._function_caches[key] = cache
             return cache
 
     def clear_all(self) -> None:
         """Clear all resource caches."""
+        # Hold the lock long enough to copy the caches.
         with self._caches_lock:
+            caches = list(self._function_caches.values())
             self._function_caches = {}
 
+        # Clear each cache to ensure any on_release functions are called.
+        for cache in caches:
+            cache.clear()
+
     def get_stats(
         self, _family_names: Sequence[str] | None = None
     ) -> dict[str, list[CacheStat]]:
@@ -182,6 +195,7 @@ class CachedResourceFuncInfo(CachedFuncInfo[P, R]):
         validate: ValidateFunc | None,
         hash_funcs: HashFuncsDict | None = None,
         show_time: bool = False,
+        on_release: OnRelease | None = None,
     ) -> None:
         super().__init__(
             func,
@@ -192,6 +206,7 @@ class CachedResourceFuncInfo(CachedFuncInfo[P, R]):
         self.max_entries = max_entries
         self.ttl = ttl
         self.validate = validate
+        self.on_release = on_release or _no_op_release
 
     @property
     def cache_type(self) -> CacheType:
@@ -213,6 +228,7 @@ class CachedResourceFuncInfo(CachedFuncInfo[P, R]):
             max_entries=self.max_entries,
             ttl=self.ttl,
             validate=self.validate,
+            on_release=self.on_release,
         )
 
 
@@ -264,6 +280,7 @@ class CacheResourceAPI:
         show_time: bool = False,
         validate: ValidateFunc | None = None,
         hash_funcs: HashFuncsDict | None = None,
+        on_release: OnRelease | None = None,
     ) -> CachedFunc[P, R] | Callable[[Callable[P, R]], CachedFunc[P, R]]:
         return self._decorator(  # ty: ignore[missing-argument]
             func,  # ty: ignore[invalid-argument-type]
@@ -273,6 +290,7 @@ class CacheResourceAPI:
             show_time=show_time,
             validate=validate,
             hash_funcs=hash_funcs,
+            on_release=on_release,
         )
 
     def _decorator(
@@ -285,6 +303,7 @@ class CacheResourceAPI:
         show_time: bool = False,
         validate: ValidateFunc | None,
         hash_funcs: HashFuncsDict | None = None,
+        on_release: OnRelease | None = None,
     ) -> CachedFunc[P, R] | Callable[[Callable[P, R]], CachedFunc[P, R]]:
         """Decorator to cache functions that return global resources (e.g. database connections, ML models).
 
@@ -340,16 +359,21 @@ class CacheResourceAPI:
             - A number specifying the time in seconds.
             - A string specifying the time in a format supported by `Pandas's
               Timedelta constructor <https://pandas.pydata.org/docs/reference/api/pandas.Timedelta.html>`_,
-              e.g. ``"1d"``, ``"1.5 days"``, or ``"1h23s"``.
+              e.g. ``"1d"``, ``"1.5 days"``, or ``"1h23s"``. Note that number strings
+              without units are treated by Pandas as nanoseconds.
             - A ``timedelta`` object from `Python's built-in datetime library
               <https://docs.python.org/3/library/datetime.html#timedelta-objects>`_,
               e.g. ``timedelta(days=1)``.
 
+            Changes to this value will trigger a new cache to be created.
+
         max_entries : int or None
             The maximum number of entries to keep in the cache, or None
             for an unbounded cache. When a new entry is added to a full cache,
             the oldest cached entry will be removed. Defaults to None.
 
+            Changes to this value will trigger a new cache to be created.
+
         show_spinner : bool or str
             Enable the spinner. Default is True to show a spinner when there is
             a "cache miss" and the cached resource is being created. If string,
@@ -362,7 +386,7 @@ class CacheResourceAPI:
             format is not configurable.
 
         validate : callable or None
-            An optional validation function for cached data. ``validate`` is called
+            An optional validation function for cached resources. ``validate`` is called
             each time the cached value is accessed. It receives the cached value as
             its only parameter and it must return a boolean. If ``validate`` returns
             False, the current cached value is discarded, and the decorated function
@@ -377,6 +401,20 @@ class CacheResourceAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
+        on_release : callable or None
+            If set, a function to call when a cache entry is removed from the cache.
+            The removed item will be provided to the function as an argument.
+
+            This is only useful for caches which will remove entries normally: Those
+            with ``max_entries`` or ``ttl`` settings. Note that TTL expiration does not
+            happen on all reads - so ``ttl`` should not be used to guarantee timely
+            cleanup, only cleanup when expired resources are accessed. Also note that
+            expiration can happen on any app render or load, so care should be taken
+            to ensure that ``on_release`` functions are thread-safe and do not rely on
+            session state.
+
+            This will NOT be called when an app is shut down.
+
         Example
         -------
         >>> import streamlit as st
@@ -472,6 +510,7 @@ class CacheResourceAPI:
                     ttl=ttl,
                     validate=validate,
                     hash_funcs=hash_funcs,
+                    on_release=on_release,
                 )
             )
 
@@ -484,6 +523,7 @@ class CacheResourceAPI:
                 ttl=ttl,
                 validate=validate,
                 hash_funcs=hash_funcs,
+                on_release=on_release,
             )
         )
 
@@ -503,12 +543,24 @@ class ResourceCache(Cache[R]):
         ttl_seconds: float,
         validate: ValidateFunc | None,
         display_name: str,
+        on_release: OnRelease,
     ) -> None:
         super().__init__()
+
+        def wrapped_on_release(result: CachedResult[R]) -> None:
+            # Note that exceptions raised here will bubble out to the calling scope,
+            # which will then treat them as user script errors.
+            # This is also how exceptions thrown when generating cache values are
+            # treated.
+            on_release(result.value)
+
         self.key = key
         self.display_name = display_name
-        self._mem_cache: TTLCache[str, CachedResult[R]] = TTLCache(
-            maxsize=max_entries, ttl=ttl_seconds, timer=cache_utils.TTLCACHE_TIMER
+        self._mem_cache: TTLCleanupCache[str, CachedResult[R]] = TTLCleanupCache(
+            maxsize=max_entries,
+            ttl=ttl_seconds,
+            timer=cache_utils.TTLCACHE_TIMER,
+            on_release=wrapped_on_release,
         )
         self._mem_cache_lock = threading.Lock()
         self.validate = validate
@@ -551,9 +603,28 @@ class ResourceCache(Cache[R]):
     def _clear(self, key: str | None = None) -> None:
         with self._mem_cache_lock:
             if key is None:
-                self._mem_cache.clear()
+                # Clear the whole cache.
+                # TTLCleanupCache will stop a clear() execution when an exception is
+                # thrown by an on_release. To ensure that our clear() actually flushes
+                # the cache and calls all cleanup functions, we clear each item
+                # individually. We also collect exceptions for logging.
+                errors: list[Exception] = []
+                while len(self._mem_cache) > 0:
+                    try:
+                        # TTLCleanupCache only reliably calls on_release for popitem -
+                        # so just use that.
+                        self._mem_cache.popitem()
+                    except Exception as e:  # noqa: PERF203 (we require a tight scope)
+                        errors.append(e)
+
+                # Log all errors encountered at warning. This could potentially result in a
+                # lot of log spam in the worst case - but for resources, a huge cache is very
+                # unlikely.
+                for error in errors:
+                    _LOGGER.warning("Error clearing resource cache: %s", error)
             elif key in self._mem_cache:
-                del self._mem_cache[key]
+                # Note: This code path does not seem to be reachable through public APIs.
+                self._mem_cache.safe_del(key)
 
     def get_stats(
         self, _family_names: Sequence[str] | None = None

streamlit/runtime/caching/ttl_cleanup_cache.py

@@ -30,7 +30,12 @@ V = TypeVar("V")
 
 
 class TTLCleanupCache(TTLCache[K, V]):
-    """A TTLCache that supports hooks called when items are released."""
+    """A TTLCache that supports hooks called when items are released.
+
+    Note that item release only happens reliably when done automatically due to TTL
+    or maxsize expiration - and specifically does not happen when using ``del``. To
+    remove an item and have on_release be called, use safe_del.
+    """
 
     def __init__(
         self,
@@ -69,3 +74,12 @@ class TTLCleanupCache(TTLCache[K, V]):
             self._on_release(value)
 
         return items
+
+    def safe_del(self, key: K) -> None:
+        """Delete that calls _on_release."""
+        has_value = key in self
+        old_value = self.get(key)
+        del self[key]
+        # Check has_value, not None, to allow for None values.
+        if has_value:
+            self._on_release(old_value)

streamlit/static/index.html

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