streamlit-nightly 1.52.3.dev20260102__tar.gz → 1.52.3.dev20260105__tar.gz

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-nightly
-Version: 1.52.3.dev20260102
+Version: 1.52.3.dev20260105
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/setup.py

@@ -23,7 +23,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.52.3.dev20260102"  # PEP-440
+VERSION = "1.52.3.dev20260105"  # PEP-440
 
 # IMPORTANT: We should try very hard *not* to add dependencies to Streamlit.
 # And if you do add one, make the required version as general as possible:

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/elements/layouts.py

@@ -167,13 +167,17 @@ class LayoutsMixin:
               When ``horizontal`` is ``True``, ``"distribute"`` aligns the
               elements the same as ``"top"``.
 
-        gap : "small", "medium", "large", or None
+        gap : "xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge", or None
             The minimum gap size between the elements inside the container.
             This can be one of the following:
 
+            - ``"xxsmall"``: 0.25rem gap between the elements.
+            - ``"xsmall"``: 0.5rem gap between the elements.
             - ``"small"`` (default): 1rem gap between the elements.
             - ``"medium"``: 2rem gap between the elements.
             - ``"large"``: 4rem gap between the elements.
+            - ``"xlarge"``: 6rem gap between the elements.
+            - ``"xxlarge"``: 8rem gap between the elements.
             - ``None``: No gap between the elements.
 
             The rem unit is relative to the ``theme.baseFontSize``
@@ -364,13 +368,17 @@ class LayoutsMixin:
               Or ``[1, 2, 3]`` creates three columns where the second one is two times
               the width of the first one, and the third one is three times that width.
 
-        gap : "small", "medium", "large", or None
+        gap : "xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge", or None
             The size of the gap between the columns. This can be one of the
             following:
 
+            - ``"xxsmall"``: 0.25rem gap between the columns.
+            - ``"xsmall"``: 0.5rem gap between the columns.
             - ``"small"`` (default): 1rem gap between the columns.
             - ``"medium"``: 2rem gap between the columns.
             - ``"large"``: 4rem gap between the columns.
+            - ``"xlarge"``: 6rem gap between the columns.
+            - ``"xxlarge"``: 8rem gap between the columns.
             - ``None``: No gap between the columns.
 
             The rem unit is relative to the ``theme.baseFontSize``

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/elements/lib/layout_utils.py

@@ -35,8 +35,15 @@ WidthWithoutContent: TypeAlias = int | Literal["stretch"]
 Width: TypeAlias = int | Literal["stretch", "content"]
 HeightWithoutContent: TypeAlias = int | Literal["stretch"]
 Height: TypeAlias = int | Literal["stretch", "content"]
-SpaceSize: TypeAlias = int | Literal["stretch", "small", "medium", "large"]
-Gap: TypeAlias = Literal["small", "medium", "large"]
+SpaceSize: TypeAlias = (
+    int
+    | Literal[
+        "stretch", "xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge"
+    ]
+)
+Gap: TypeAlias = Literal[
+    "xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge"
+]
 HorizontalAlignment: TypeAlias = Literal["left", "center", "right", "distribute"]
 VerticalAlignment: TypeAlias = Literal["top", "center", "bottom", "distribute"]
 TextAlignment: TypeAlias = Literal["left", "center", "right", "justify"]
@@ -45,9 +52,13 @@ TextAlignment: TypeAlias = Literal["left", "center", "right", "justify"]
 # If changing these, also check streamlit/frontend/lib/src/theme/primitives/sizes.ts
 # to ensure sizes are kept in sync.
 SIZE_TO_REM_MAPPING = {
+    "xxsmall": 0.25,  # Aligns with gap "xxsmall" (4px)
+    "xsmall": 0.5,  # Aligns with gap "xsmall" (8px)
     "small": 0.75,  # Height of widget label minus gap
     "medium": 2.5,  # Height of button/input field
     "large": 4.25,  # Height of large widget without label
+    "xlarge": 6,  # Aligns with gap "xlarge" (96px)
+    "xxlarge": 8,  # Aligns with gap "xxlarge" (128px)
 }
 
 
@@ -147,7 +158,16 @@ def validate_space_size(size: SpaceSize) -> None:
         raise StreamlitInvalidSizeError(size)
 
     if isinstance(size, str):
-        valid_strings = ["stretch", "small", "medium", "large"]
+        valid_strings = [
+            "stretch",
+            "xxsmall",
+            "xsmall",
+            "small",
+            "medium",
+            "large",
+            "xlarge",
+            "xxlarge",
+        ]
         if size not in valid_strings:
             raise StreamlitInvalidSizeError(size)
     elif isinstance(size, int) and size <= 0:
@@ -183,9 +203,13 @@ def get_height_config(height: Height | SpaceSize) -> HeightConfig:
 def get_gap_size(gap: str | None, element_type: str) -> GapSize.ValueType:
     """Convert a gap string or None to a GapSize proto value."""
     gap_mapping = {
+        "xxsmall": GapSize.XXSMALL,
+        "xsmall": GapSize.XSMALL,
         "small": GapSize.SMALL,
         "medium": GapSize.MEDIUM,
         "large": GapSize.LARGE,
+        "xlarge": GapSize.XLARGE,
+        "xxlarge": GapSize.XXLARGE,
     }
 
     if isinstance(gap, str):

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/elements/space.py

@@ -42,15 +42,23 @@ class SpaceMixin:
 
         Parameters
         ----------
-        size : "small", "medium", "large", "stretch", or int
+        size : "xxsmall", "xsmall", "small", "medium", "large", "xlarge", "xxlarge", "stretch", or int
             The size of the space. This can be one of the following values:
 
+            - ``"xxsmall"``: 0.25rem, matching the ``"xxsmall"`` gap in
+              ``st.container`` and ``st.columns``.
+            - ``"xsmall"``: 0.5rem, matching the ``"xsmall"`` gap in
+              ``st.container`` and ``st.columns``.
             - ``"small"`` (default): 0.75rem, which is the height of a widget
               label. This is useful for aligning buttons with labeled widgets.
             - ``"medium"``: 2.5rem, which is the height of a button or
               (unlabeled) input field.
             - ``"large"``: 4.25rem, which is the height of a labeled input
-              field or unlabeled media widget, like `st.file_uploader`.
+              field or unlabeled media widget, like ``st.file_uploader``.
+            - ``"xlarge"``: 6rem, matching the ``"xlarge"`` gap in
+              ``st.container`` and ``st.columns``.
+            - ``"xxlarge"``: 8rem, matching the ``"xxlarge"`` gap in
+              ``st.container`` and ``st.columns``.
             - ``"stretch"``: Expands to fill remaining space in the container.
             - An integer: Fixed size in pixels.
 

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/errors.py

@@ -265,7 +265,9 @@ class StreamlitInvalidColumnGapError(LocalizableStreamlitException):
 
     def __init__(self, gap: str, element_type: str) -> None:
         super().__init__(
-            'The `gap` argument to `{element_type}` must be `"small"`, `"medium"`, `"large"`, or `"none"`. \n'
+            'The `gap` argument to `{element_type}` must be `"xxsmall"`, '
+            '`"xsmall"`, `"small"`, `"medium"`, `"large"`, `"xlarge"`, '
+            '`"xxlarge"`, or `"none"`. \n'
             "The argument passed was {gap}.",
             gap=gap,
             element_type=element_type,

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/proto/GapSize_pb2.py

@@ -14,7 +14,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dstreamlit/proto/GapSize.proto\x12\tstreamlit\"?\n\tGapConfig\x12&\n\x08gap_size\x18\x01 \x01(\x0e\x32\x12.streamlit.GapSizeH\x00\x42\n\n\x08gap_spec*H\n\x07GapSize\x12\x11\n\rGAP_UNDEFINED\x10\x00\x12\t\n\x05SMALL\x10\x01\x12\n\n\x06MEDIUM\x10\x02\x12\t\n\x05LARGE\x10\x03\x12\x08\n\x04NONE\x10\x04\x42,\n\x1c\x63om.snowflake.apps.streamlitB\x0cGapSizeProtob\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1dstreamlit/proto/GapSize.proto\x12\tstreamlit\"?\n\tGapConfig\x12&\n\x08gap_size\x18\x01 \x01(\x0e\x32\x12.streamlit.GapSizeH\x00\x42\n\n\x08gap_spec*z\n\x07GapSize\x12\x11\n\rGAP_UNDEFINED\x10\x00\x12\t\n\x05SMALL\x10\x01\x12\n\n\x06MEDIUM\x10\x02\x12\t\n\x05LARGE\x10\x03\x12\x08\n\x04NONE\x10\x04\x12\x0b\n\x07XXSMALL\x10\x05\x12\n\n\x06XSMALL\x10\x06\x12\n\n\x06XLARGE\x10\x07\x12\x0b\n\x07XXLARGE\x10\x08\x42,\n\x1c\x63om.snowflake.apps.streamlitB\x0cGapSizeProtob\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -23,7 +23,7 @@ if not _descriptor._USE_C_DESCRIPTORS:
   _globals['DESCRIPTOR']._loaded_options = None
   _globals['DESCRIPTOR']._serialized_options = b'\n\034com.snowflake.apps.streamlitB\014GapSizeProto'
   _globals['_GAPSIZE']._serialized_start=109
-  _globals['_GAPSIZE']._serialized_end=181
+  _globals['_GAPSIZE']._serialized_end=231
   _globals['_GAPCONFIG']._serialized_start=44
   _globals['_GAPCONFIG']._serialized_end=107
 # @@protoc_insertion_point(module_scope)

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/proto/GapSize_pb2.pyi

@@ -42,6 +42,10 @@ class _GapSizeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTy
     MEDIUM: _GapSize.ValueType  # 2
     LARGE: _GapSize.ValueType  # 3
     NONE: _GapSize.ValueType  # 4
+    XXSMALL: _GapSize.ValueType  # 5
+    XSMALL: _GapSize.ValueType  # 6
+    XLARGE: _GapSize.ValueType  # 7
+    XXLARGE: _GapSize.ValueType  # 8
 
 class GapSize(_GapSize, metaclass=_GapSizeEnumTypeWrapper): ...
 
@@ -50,6 +54,10 @@ SMALL: GapSize.ValueType  # 1
 MEDIUM: GapSize.ValueType  # 2
 LARGE: GapSize.ValueType  # 3
 NONE: GapSize.ValueType  # 4
+XXSMALL: GapSize.ValueType  # 5
+XSMALL: GapSize.ValueType  # 6
+XLARGE: GapSize.ValueType  # 7
+XXLARGE: GapSize.ValueType  # 8
 Global___GapSize: typing_extensions.TypeAlias = GapSize
 
 @typing.final

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/runtime/app_session.py

@@ -221,6 +221,15 @@ class AppSession:
         self._stop_config_listener = None
         self._stop_pages_listener = None
 
+    def clear_session_caches(self) -> None:
+        """Clears session-level caches for this session.
+
+        This should be called when a session is disconnected or shut down, since this
+        ensures memory is freed up and resource release hooks are called.
+        """
+        caching.clear_session_data_cache(self.id)
+        caching.clear_session_resource_cache(self.id)
+
     def flush_browser_queue(self) -> list[ForwardMsg]:
         """Clear the forward message queue and return the messages it contained.
 
@@ -264,6 +273,9 @@ class AppSession:
             # generally already done so by the time we get here.
             self.disconnect_file_watchers()
 
+            # Clear any session caches. This ensures shutdown hooks are called.
+            self.clear_session_caches()
+
     def _enqueue_forward_msg(self, msg: ForwardMsg) -> None:
         """Enqueue a new ForwardMsg to our browser queue.
 
@@ -691,9 +703,10 @@ class AppSession:
                 )
 
             if self._state == AppSessionState.SHUTDOWN_REQUESTED:
-                # Only clear media files if the script is done running AND the
-                # session is actually shutting down.
+                # Only clear media files and session caches if the script is done
+                # running AND the session is actually shutting down.
                 runtime.get_instance().media_file_mgr.clear_session_refs(self.id)
+                self.clear_session_caches()
 
             self._client_state = client_state
             self._scriptrunner = None

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/runtime/caching/__init__.py

@@ -21,12 +21,18 @@ from streamlit.runtime.caching.cache_data_api import (
     CacheDataAPI,
     get_data_cache_stats_provider,
 )
+from streamlit.runtime.caching.cache_data_api import (
+    clear_session_cache as clear_session_data_cache,
+)
 from streamlit.runtime.caching.cache_errors import CACHE_DOCS_URL
 from streamlit.runtime.caching.cache_resource_api import (
     CACHE_RESOURCE_MESSAGE_REPLAY_CTX,
     CacheResourceAPI,
     get_resource_cache_stats_provider,
 )
+from streamlit.runtime.caching.cache_resource_api import (
+    clear_session_cache as clear_session_resource_cache,
+)
 from streamlit.runtime.caching.legacy_cache_api import cache as _cache
 
 if TYPE_CHECKING:
@@ -102,6 +108,8 @@ __all__ = [
     "cache",
     "cache_data",
     "cache_resource",
+    "clear_session_data_cache",
+    "clear_session_resource_cache",
     "get_data_cache_stats_provider",
     "get_resource_cache_stats_provider",
     "save_block_message",

{streamlit_nightly-1.52.3.dev20260102 → streamlit_nightly-1.52.3.dev20260105}/streamlit/runtime/caching/cache_data_api.py

@@ -41,6 +41,8 @@ from streamlit.runtime.caching.cache_utils import (
     Cache,
     CachedFunc,
     CachedFuncInfo,
+    CacheScope,
+    get_session_id_or_throw,
     make_cached_func_wrapper,
 )
 from streamlit.runtime.caching.cached_message_replay import (
@@ -104,12 +106,14 @@ class CachedDataFuncInfo(CachedFuncInfo[P, R]):
         show_spinner: bool | str,
         show_time: bool = False,
         hash_funcs: HashFuncsDict | None = None,
+        scope: CacheScope = "global",
     ) -> None:
         super().__init__(
             func,
             hash_funcs=hash_funcs,
             show_spinner=show_spinner,
             show_time=show_time,
+            scope=scope,
         )
         self.persist = persist
         self.max_entries = max_entries
@@ -137,6 +141,7 @@ class CachedDataFuncInfo(CachedFuncInfo[P, R]):
             max_entries=self.max_entries,
             ttl=self.ttl,
             display_name=self.display_name,
+            scope=self.scope,
         )
 
     def validate_params(self) -> None:
@@ -159,7 +164,8 @@ class DataCaches(StatsProvider):
 
     def __init__(self) -> None:
         self._caches_lock = threading.Lock()
-        self._function_caches: dict[str, DataCache[Any]] = {}
+        # Map of session IDs to map of function keys to caches.
+        self._function_caches: dict[str | None, dict[str, DataCache[Any]]] = {}
 
     @property
     def stats_families(self) -> Sequence[str]:
@@ -172,18 +178,37 @@ class DataCaches(StatsProvider):
         max_entries: int | None,
         ttl: int | float | timedelta | str | None,
         display_name: str,
+        scope: CacheScope = "global",
     ) -> DataCache[Any]:
         """Return the mem cache for the given key.
 
         If it doesn't exist, create a new one with the given params.
+
+        Raises
+        ------
+        StreamlitAPIException
+            Raised when ``scope`` is ``"session"`` and there is no thread-local run
+            context.
         """
 
         ttl_seconds = time_to_seconds(ttl, coerce_none_to_inf=False)
 
+        # Fetch the session ID. Note that this will throw an exception if there is no
+        # session associated with the current thread.
+        session_id: str | None
+        if scope == "global":
+            session_id = None
+        else:
+            session_id = get_session_id_or_throw()
+
         # Get the existing cache, if it exists, and validate that its params
         # haven't changed.
         with self._caches_lock:
-            cache = self._function_caches.get(key)
+            session_caches = self._function_caches.get(session_id)
+            if session_caches is None:
+                session_caches = self._function_caches[session_id] = {}
+
+            cache = session_caches.get(key)
             if (
                 cache is not None
                 and cache.ttl_seconds == ttl_seconds
@@ -232,9 +257,22 @@ class DataCaches(StatsProvider):
                 ttl_seconds=ttl_seconds,
                 display_name=display_name,
             )
-            self._function_caches[key] = cache
+            self._function_caches[session_id][key] = cache
             return cache
 
+    def clear_session(self, session_id: str) -> None:
+        """Clears all caches for the given session ID."""
+        # Hold the lock while removing the cache, but release it while clearing.
+        with self._caches_lock:
+            session_caches = self._function_caches.get(session_id)
+            if session_caches is not None:
+                del self._function_caches[session_id]
+
+        if session_caches is not None:
+            for cache in session_caches.values():
+                cache.clear()
+                cache.storage.close()
+
     def clear_all(self) -> None:
         """Clear all in-memory and on-disk caches."""
         with self._caches_lock:
@@ -245,9 +283,10 @@ class DataCaches(StatsProvider):
                 # available storages one by one
                 self.get_storage_manager().clear_all()
             except NotImplementedError:
-                for data_cache in self._function_caches.values():
-                    data_cache.clear()
-                    data_cache.storage.close()
+                for data_caches in self._function_caches.values():
+                    for data_cache in data_caches.values():
+                        data_cache.clear()
+                        data_cache.storage.close()
             self._function_caches = {}
 
     def get_stats(
@@ -256,10 +295,14 @@ class DataCaches(StatsProvider):
         with self._caches_lock:
             # Shallow-clone our caches. We don't want to hold the global
             # lock during stats-gathering.
-            function_caches = self._function_caches.copy()
+            function_caches = [
+                cache
+                for caches in self._function_caches.values()
+                for cache in caches.values()
+            ]
 
         stats: list[CacheStat] = []
-        for cache in function_caches.values():
+        for cache in function_caches:
             cache_stats = cache.get_stats()
             for family_stats in cache_stats.values():
                 stats.extend(family_stats)
@@ -334,6 +377,11 @@ class DataCaches(StatsProvider):
 _data_caches = DataCaches()
 
 
+def clear_session_cache(session_id: str) -> None:
+    """Clears all caches for the given session ID."""
+    _data_caches.clear_session(session_id)
+
+
 def get_data_cache_stats_provider() -> StatsProvider:
     """Return the StatsProvider for all @st.cache_data functions."""
     return _data_caches
@@ -377,6 +425,7 @@ class CacheDataAPI:
         show_time: bool = False,
         persist: CachePersistType | bool = None,
         hash_funcs: HashFuncsDict | None = None,
+        scope: CacheScope = "global",
     ) -> Callable[[Callable[P, R]], CachedFunc[P, R]]: ...
 
     def __call__(
@@ -389,6 +438,7 @@ class CacheDataAPI:
         show_time: bool = False,
         persist: CachePersistType | bool = None,
         hash_funcs: HashFuncsDict | None = None,
+        scope: CacheScope = "global",
     ) -> CachedFunc[P, R] | Callable[[Callable[P, R]], CachedFunc[P, R]]:
         return self._decorator(
             func,  # ty: ignore[invalid-argument-type]
@@ -398,6 +448,7 @@ class CacheDataAPI:
             show_spinner=show_spinner,
             show_time=show_time,
             hash_funcs=hash_funcs,
+            scope=scope,
         )
 
     def _decorator(
@@ -410,6 +461,7 @@ class CacheDataAPI:
         show_time: bool = False,
         persist: CachePersistType | bool,
         hash_funcs: HashFuncsDict | None = None,
+        scope: CacheScope = "global",
     ) -> CachedFunc[P, R] | Callable[[Callable[P, R]], CachedFunc[P, R]]:
         """Decorator to cache functions that return data (e.g. dataframe transforms, database queries, ML inference).
 
@@ -491,6 +543,15 @@ class CacheDataAPI:
             the provided function to generate a hash for it. See below for an example
             of how this can be used.
 
+        scope : "global" or "session"
+            The scope for the resource. If "global", cache globally. If "session",
+            cache in the session.
+
+            Session-scoped cache entries will be expired when a user's session is
+            disconnected. Note that disconnected sessions can reconnect - so it is
+            possible for the cache to populate multiple times in a single session for
+            the same key.
+
         Example
         -------
         >>> import streamlit as st
@@ -595,6 +656,11 @@ class CacheDataAPI:
                 f"Unsupported persist option '{persist}'. Valid values are 'disk' or None."
             )
 
+        if scope not in ("global", "session"):
+            raise StreamlitAPIException(
+                f"Unsupported scope option '{scope}'. Valid values are 'global' or 'session'."
+            )
+
         def wrapper(f: Callable[P, R]) -> CachedFunc[P, R]:
             return make_cached_func_wrapper(
                 CachedDataFuncInfo(
@@ -605,6 +671,7 @@ class CacheDataAPI:
                     max_entries=max_entries,
                     ttl=ttl,
                     hash_funcs=hash_funcs,
+                    scope=scope,
                 )
             )
 
@@ -620,6 +687,7 @@ class CacheDataAPI:
                 max_entries=max_entries,
                 ttl=ttl,
                 hash_funcs=hash_funcs,
+                scope=scope,
             )
         )