streamlit-nightly 1.52.3.dev20260113__py3-none-any.whl → 1.53.1.dev20260115__py3-none-any.whl

streamlit/runtime/app_session.py

@@ -53,6 +53,8 @@ from streamlit.watcher import LocalSourcesWatcher
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from google.protobuf.internal.containers import RepeatedScalarFieldContainer
+
     from streamlit.proto.BackMsg_pb2 import BackMsg, DeferredFileRequest
     from streamlit.runtime.script_data import ScriptData
     from streamlit.runtime.scriptrunner.script_cache import ScriptCache
@@ -1016,6 +1018,65 @@ def _populate_config_msg(msg: Config) -> None:
     msg.toolbar_mode = _get_toolbar_mode()
 
 
+def _parse_and_populate_chart_colors(
+    theme_opts: dict[str, Any],
+    config_key: str,
+    msg_field: RepeatedScalarFieldContainer[str],
+    required_length: int | None = None,
+) -> None:
+    """Parse and populate chart colors from theme config to protobuf message field.
+
+    Parameters
+    ----------
+    theme_opts
+        Dictionary of theme options from config.get_options_for_section.
+    config_key
+        The key in theme_opts to look for (e.g., "chartCategoricalColors").
+    msg_field
+        The protobuf repeated string field to append colors to.
+    required_length
+        If provided, log an error if the colors array doesn't have this exact length.
+    """
+    colors = theme_opts.get(config_key)
+
+    # If colors was configured via config.toml, it's already a list of strings.
+    # However, if it was provided via env variable or via CLI arg,
+    # it's a JSON string that needs to be parsed.
+    if isinstance(colors, str):
+        try:
+            colors = json.loads(colors)
+        except json.JSONDecodeError as e:
+            _LOGGER.warning(
+                "Failed to parse the theme.%s config option: %s.",
+                config_key,
+                colors,
+                exc_info=e,
+            )
+            colors = None
+
+    if colors is not None:
+        # Check required length if specified
+        if required_length is not None and len(colors) != required_length:
+            _LOGGER.error(
+                "Config theme.%s should have %s color values, "
+                "but got %s. Defaulting to Streamlit's default colors.",
+                config_key,
+                required_length,
+                len(colors),
+            )
+            return  # Don't populate invalid data; let frontend use defaults
+        for color in colors:
+            try:
+                msg_field.append(color)
+            except Exception as e:  # noqa: PERF203
+                _LOGGER.warning(
+                    "Failed to parse the theme.%s config option: %s.",
+                    config_key,
+                    color,
+                    exc_info=e,
+                )
+
+
 def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
     theme_opts = config.get_options_for_section(section)
     if all(val is None for val in theme_opts.values()):
@@ -1036,6 +1097,7 @@ def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
                 "headingFontWeights",
                 "chartCategoricalColors",
                 "chartSequentialColors",
+                "chartDivergingColors",
             }
             and option_val is not None
         ):
@@ -1180,64 +1242,22 @@ def _populate_theme_msg(msg: CustomThemeConfig, section: str = "theme") -> None:
                     exc_info=e,
                 )
 
-    chart_categorical_colors = theme_opts.get("chartCategoricalColors", None)
-    # If chartCategoricalColors was configured via config.toml, it's already a list of
-    # strings. However, if it was provided via env variable or via CLI arg,
-    # it's a json string that needs to be parsed.
-    if isinstance(chart_categorical_colors, str):
-        try:
-            chart_categorical_colors = json.loads(chart_categorical_colors)
-        except json.JSONDecodeError as e:
-            _LOGGER.warning(
-                "Failed to parse the theme.chartCategoricalColors config option: %s.",
-                chart_categorical_colors,
-                exc_info=e,
-            )
-            chart_categorical_colors = None
-
-    if chart_categorical_colors is not None:
-        for color in chart_categorical_colors:
-            try:
-                msg.chart_categorical_colors.append(color)
-            except Exception as e:  # noqa: PERF203
-                _LOGGER.warning(
-                    "Failed to parse the theme.chartCategoricalColors config option: %s.",
-                    color,
-                    exc_info=e,
-                )
-
-    chart_sequential_colors = theme_opts.get("chartSequentialColors", None)
-    # If chartSequentialColors was configured via config.toml, it's already a list of
-    # strings. However, if it was provided via env variable or via CLI arg,
-    # it's a json string that needs to be parsed.
-    if isinstance(chart_sequential_colors, str):
-        try:
-            chart_sequential_colors = json.loads(chart_sequential_colors)
-        except json.JSONDecodeError as e:
-            _LOGGER.warning(
-                "Failed to parse the theme.chartSequentialColors config option: %s.",
-                chart_sequential_colors,
-                exc_info=e,
-            )
-            chart_sequential_colors = None
-
-    if chart_sequential_colors is not None:
-        # Check that the list has 10 color values
-        if len(chart_sequential_colors) != 10:
-            _LOGGER.error(
-                "Config theme.chartSequentialColors should have 10 color values, "
-                "but got %s. Defaulting to Streamlit's default colors.",
-                len(chart_sequential_colors),
-            )
-        for color in chart_sequential_colors:
-            try:
-                msg.chart_sequential_colors.append(color)
-            except Exception as e:  # noqa: PERF203
-                _LOGGER.warning(
-                    "Failed to parse the theme.chartSequentialColors config option: %s.",
-                    color,
-                    exc_info=e,
-                )
+    # Handle chart color configurations
+    _parse_and_populate_chart_colors(
+        theme_opts, "chartCategoricalColors", msg.chart_categorical_colors
+    )
+    _parse_and_populate_chart_colors(
+        theme_opts,
+        "chartSequentialColors",
+        msg.chart_sequential_colors,
+        required_length=10,
+    )
+    _parse_and_populate_chart_colors(
+        theme_opts,
+        "chartDivergingColors",
+        msg.chart_diverging_colors,
+        required_length=10,
+    )
 
 
 def _populate_user_info_msg(msg: UserInfo) -> None:

streamlit/runtime/caching/cache_data_api.py

@@ -465,6 +465,11 @@ class CacheDataAPI:
     ) -> 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).
 
+        Cached objects can be global or session-scoped. Global cached data is
+        available across all users, sessions, and reruns. Session-scoped cached
+        data is only available in the current session and removed when the
+        session disconnects.
+
         Cached objects are stored in "pickled" form, which means that the return
         value of a cached function must be pickleable. Each caller of the cached
         function gets its own copy of the cached data.
@@ -472,20 +477,17 @@ class CacheDataAPI:
         You can clear a function's cache with ``func.clear()`` or clear the entire
         cache with ``st.cache_data.clear()``.
 
-        A function's arguments must be hashable to cache it. If you have an
-        unhashable argument (like a database connection) or an argument you
-        want to exclude from caching, use an underscore prefix in the argument
-        name. In this case, Streamlit will return a cached value when all other
-        arguments match a previous function call. Alternatively, you can
-        declare custom hashing functions with ``hash_funcs``.
-
-        Cached values are available to all users of your app. If you need to
-        save results that should only be accessible within a session, use
-        `Session State
-        <https://docs.streamlit.io/develop/concepts/architecture/session-state>`_
-        instead. Within each user session, an ``@st.cache_data``-decorated
-        function returns a *copy* of the cached return value (if the value is
-        already cached). To cache shared global resources (singletons), use
+        A function's arguments must be hashable to cache it. Streamlit makes a
+        best effort to hash a variety of objects, but the fallback hashing method
+        requires that the argument be pickleable, also. If you have an unhashable
+        argument (like a database connection) or an argument you want to exclude
+        from caching, use an underscore prefix in the argument name. In this case,
+        Streamlit will return a cached value when all other arguments match a
+        previous function call. Alternatively, you can declare custom hashing
+        functions with ``hash_funcs``.
+
+        Objects cached by ``st.cache_data`` are returned as copies. To cache a
+        shared resource or something you want to mutate in place, use
         ``st.cache_resource`` instead. To learn more about caching, see
         `Caching overview
         <https://docs.streamlit.io/develop/concepts/architecture/caching>`_.
@@ -544,13 +546,15 @@ class CacheDataAPI:
             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.
+            The scope for the data cache. If this is ``"global"`` (default),
+            the data is cached globally. If this is ``"session"``, the data is
+            removed from the cache when the session disconnects.
+
+            Because a session-scoped cache is cleared when a session disconnects,
+            an unstable network connection can cause the cache to populate
+            multiple times in a single session. If this is a problem, you might
+            consider adjusting the ``server.websocketPingInterval``
+            configuration option.
 
         Example
         -------

streamlit/runtime/caching/cache_resource_api.py

@@ -362,33 +362,30 @@ class CacheResourceAPI:
         on_release: OnRelease | None = None,
         scope: CacheScope = "global",
     ) -> CachedFunc[P, R] | Callable[[Callable[P, R]], CachedFunc[P, R]]:
-        """Decorator to cache functions that return global resources (e.g. database connections, ML models).
+        """Decorator to cache functions that return resource objects (e.g. database connections, ML models).
 
-        Cached objects are shared across all users, sessions, and reruns. They
-        must be thread-safe because they can be accessed from multiple threads
-        concurrently. If thread safety is an issue, consider using ``st.session_state``
-        to store resources per session instead.
+        Cached objects can be global or session-scoped. Global resources are
+        shared across all users, sessions, and reruns. Session-scoped resources are
+        scoped to the current session and are removed when the session disconnects.
+        Global resources must be thread-safe. If thread safety is an issue,
+        consider using a session-scoped cache or storing the resource in
+        ``st.session_state`` instead.
 
         You can clear a function's cache with ``func.clear()`` or clear the entire
         cache with ``st.cache_resource.clear()``.
 
-        A function's arguments must be hashable to cache it. If you have an
-        unhashable argument (like a database connection) or an argument you
-        want to exclude from caching, use an underscore prefix in the argument
-        name. In this case, Streamlit will return a cached value when all other
-        arguments match a previous function call. Alternatively, you can
-        declare custom hashing functions with ``hash_funcs``.
-
-        Cached values are available to all users of your app. If you need to
-        save results that should only be accessible within a session, use
-        `Session State
-        <https://docs.streamlit.io/develop/concepts/architecture/session-state>`_
-        instead. Within each user session, an ``@st.cache_resource``-decorated
-        function returns the cached instance of the return value (if the value
-        is already cached). Therefore, objects cached by ``st.cache_resource``
-        act like singletons and can mutate. To cache data and return copies,
-        use ``st.cache_data`` instead. To learn more about caching, see
-        `Caching overview
+        A function's arguments must be hashable to cache it. Streamlit makes a
+        best effort to hash a variety of objects, but the fallback hashing method
+        requires that the argument be pickleable, also. If you have an unhashable
+        argument (like a database connection) or an argument you want to exclude
+        from caching, use an underscore prefix in the argument name. In this case,
+        Streamlit will return a cached value when all other arguments match a
+        previous function call. Alternatively, you can declare custom hashing
+        functions with ``hash_funcs``.
+
+        Objects cached by ``st.cache_resource`` act like singletons and can
+        mutate. To cache data and return copies, use ``st.cache_data`` instead.
+        To learn more about caching, see `Caching overview
         <https://docs.streamlit.io/develop/concepts/architecture/caching>`_.
 
         .. warning::
@@ -410,7 +407,8 @@ class CacheResourceAPI:
             function's source code.
 
         ttl : float, timedelta, str, or None
-            The maximum time to keep an entry in the cache. Can be one of:
+            The maximum age of a returned entry from the cache. This can be one
+            of the following values:
 
             - ``None`` if cache entries should never expire (default).
             - A number specifying the time in seconds.
@@ -459,30 +457,40 @@ class CacheResourceAPI:
             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.
+            A function to call when an 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 is only useful for caches that remove entries normally.
+            Most commonly, this is used session-scoped caches to release
+            per-session resources. This can also be used with ``max_entries``
+            or ``ttl`` settings.
 
-            This will NOT be called when an app is shut down.
+            TTL expiration only happens when expired resources are accessed.
+            Therefore, don't rely on TTL expiration to guarantee timely cleanup.
+            Also, expiration can happen on any script run. Ensure that
+            ``on_release`` functions are thread-safe and don't rely on session
+            state.
+
+            The ``on_release`` function isn't guaranteed to be called when an
+            app is shut down.
 
         scope : "global" or "session"
-            The scope for the resource. If "global", cache globally. If "session",
-            cache in the session.
+            The scope for the resource cache. If this is ``"global"`` (default),
+            the resource is cached globally. If this is ``"session"``, the
+            resource is removed from the cache when the session disconnects.
 
-            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.
+            Because a session-scoped cache is cleared when a session disconnects,
+            an unstable network connection can cause the cache to populate
+            multiple times in a single session. If this is a problem, you might
+            consider adjusting the ``server.websocketPingInterval``
+            configuration option.
 
         Example
         -------
+        **Example 1: Global cache**
+
+        By default, an ``@st.cache_resource``-decorated function uses a global cache.
+
         >>> import streamlit as st
         >>>
         >>> @st.cache_resource
@@ -501,7 +509,22 @@ class CacheResourceAPI:
         >>> s3 = get_database_session(SESSION_URL_2)
         >>> # This is a different URL, so the function executes.
 
-        By default, all parameters to a cache_resource function must be hashable.
+        **Example 2: Session-scoped cache**
+
+        By passing ``scope="session"``, an ``@st.cache_resource``-decorated function
+        uses a session-scoped cache. You can also use ``on_release`` to clean up
+        resources when they are no longer needed.
+
+        >>> import streamlit as st
+        >>>
+        >>> @st.cache_resource(scope="session", on_release=lambda sess: sess.close())
+        ... def get_database_session(url):
+        ...     # Create a database session object that points to the URL.
+        ...     return session
+
+        **Example 3: Unhashable arguments**
+
+        By default, all parameters to a cached function must be hashable.
         Any parameter whose name begins with ``_`` will not be hashed. You can use
         this as an "escape hatch" for parameters that are not hashable:
 
@@ -521,7 +544,9 @@ class CacheResourceAPI:
         >>> # value - even though the _sessionmaker parameter was different
         >>> # in both calls.
 
-        A cache_resource function's cache can be procedurally cleared:
+        **Example 4: Clearing a cache**
+
+        A cached function's cache can be procedurally cleared:
 
         >>> import streamlit as st
         >>>
@@ -530,12 +555,14 @@ class CacheResourceAPI:
         ...     # Create a database connection object that points to the URL.
         ...     return connection
         >>>
-        >>> fetch_and_clean_data.clear(_sessionmaker, "https://streamlit.io/")
+        >>> get_database_session.clear(_sessionmaker, "https://streamlit.io/")
         >>> # Clear the cached entry for the arguments provided.
         >>>
         >>> get_database_session.clear()
         >>> # Clear all cached entries for this function.
 
+        **Example 5: Custom hashing**
+
         To override the default hashing behavior, pass a custom hash function.
         You can do that by mapping a type (e.g. ``Person``) to a hash
         function (``str``) like this:
@@ -562,6 +589,7 @@ class CacheResourceAPI:
         >>> @st.cache_resource(hash_funcs={"__main__.Person": str})
         ... def get_person_name(person: Person):
         ...     return person.name
+
         """
 
         if scope not in ("global", "session"):

streamlit/runtime/connection_factory.py

@@ -277,6 +277,10 @@ def connection_factory(  # type: ignore
           be specified in ``secrets.toml`` instead.
         - ``"snowflake"``: Streamlit will initialize a connection with
           |SnowflakeConnection|_.
+        - ``"snowflake-callers-rights"``: Streamlit will initialize a
+          ``"snowflake"``-type connection, except the connection uses the
+          current viewer's identity tokens instead of the app's connection
+          configuration.
         - ``"snowpark"``: Streamlit will initialize a connection with
           |SnowparkConnection|_. This is deprecated.
         - ``"sql"``: Streamlit will initialize a connection with
@@ -289,6 +293,16 @@ def connection_factory(  # type: ignore
           with the referenced class, which must extend
           ``st.connections.BaseConnection``.
 
+        .. Important::
+           Connections of type ``"snowflake-callers-rights"`` only work when
+           they run in a Snowflake Snowpark Container Services environment. If
+           they are used in a local environment, they will raise exceptions.
+
+           For local development, use an environment variable or secret to
+           logically switch between a ``"snowflake"`` and
+           ``"snowflake-callers-rights"`` connection depending on the runtime
+           environment.
+
         .. |SnowflakeConnection| replace:: ``SnowflakeConnection``
         .. _SnowflakeConnection: https://docs.streamlit.io/develop/api-reference/connections/st.connections.snowflakeconnection
         .. |SnowparkConnection| replace:: ``SnowparkConnection``
@@ -324,18 +338,21 @@ def connection_factory(  # type: ignore
     to use their default names and define corresponding sections in your ``secrets.toml``
     file. The following example creates a ``"sql"``-type connection.
 
-    ``.streamlit/secrets.toml``:
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
 
-    >>> [connections.sql]
-    >>> dialect = "xxx"
-    >>> host = "xxx"
-    >>> username = "xxx"
-    >>> password = "xxx"
+        [connections.sql]
+        dialect = "xxx"
+        host = "xxx"
+        username = "xxx"
+        password = "xxx"
 
-    Your app code:
+    .. code-block:: python
+        :filename: streamlit_app.py
 
-    >>> import streamlit as st
-    >>> conn = st.connection("sql")
+        import streamlit as st
+
+        conn = st.connection("sql")
 
     **Example 2: Named connections**
 
@@ -346,26 +363,29 @@ def connection_factory(  # type: ignore
     custom name. The first defines ``type`` in the ``st.connection`` command;
     the second defines ``type`` in ``secrets.toml``.
 
-    ``.streamlit/secrets.toml``:
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
+
+        [connections.first_connection]
+        dialect = "xxx"
+        host = "xxx"
+        username = "xxx"
+        password = "xxx"
 
-    >>> [connections.first_connection]
-    >>> dialect = "xxx"
-    >>> host = "xxx"
-    >>> username = "xxx"
-    >>> password = "xxx"
-    >>>
-    >>> [connections.second_connection]
-    >>> type = "sql"
-    >>> dialect = "yyy"
-    >>> host = "yyy"
-    >>> username = "yyy"
-    >>> password = "yyy"
+        [connections.second_connection]
+        type = "sql"
+        dialect = "yyy"
+        host = "yyy"
+        username = "yyy"
+        password = "yyy"
 
-    Your app code:
+    .. code-block:: python
+        :filename: streamlit_app.py
 
-    >>> import streamlit as st
-    >>> conn1 = st.connection("first_connection", type="sql")
-    >>> conn2 = st.connection("second_connection")
+        import streamlit as st
+
+        conn1 = st.connection("first_connection", type="sql")
+        conn2 = st.connection("second_connection")
 
     **Example 3: Using a path to the connection class**
 
@@ -375,17 +395,20 @@ def connection_factory(  # type: ignore
     creates the same type of connection as one with ``type="sql"``. Note that
     ``type`` is a string path.
 
-    ``.streamlit/secrets.toml``:
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
+
+        [connections.my_sql_connection]
+        url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx"
 
-    >>> [connections.my_sql_connection]
-    >>> url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx"
+    .. code-block:: python
+        :filename: streamlit_app.py
 
-    Your app code:
+        import streamlit as st
 
-    >>> import streamlit as st
-    >>> conn = st.connection(
-    ...     "my_sql_connection", type="streamlit.connections.SQLConnection"
-    ... )
+        conn = st.connection(
+            "my_sql_connection", type="streamlit.connections.SQLConnection"
+        )
 
     **Example 4: Importing the connection class**
 
@@ -394,16 +417,19 @@ def connection_factory(  # type: ignore
     infer the exact return type of ``st.connection``. The following example
     creates the same connection as in Example 3.
 
-    ``.streamlit/secrets.toml``:
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
+
+        [connections.my_sql_connection]
+        url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx"
 
-    >>> [connections.my_sql_connection]
-    >>> url = "xxx+xxx://xxx:xxx@xxx:xxx/xxx"
+    .. code-block:: python
+        :filename: streamlit_app.py
 
-    Your app code:
+        import streamlit as st
+        from streamlit.connections import SQLConnection
 
-    >>> import streamlit as st
-    >>> from streamlit.connections import SQLConnection
-    >>> conn = st.connection("my_sql_connection", type=SQLConnection)
+        conn = st.connection("my_sql_connection", type=SQLConnection)
 
     """
 

streamlit/runtime/scriptrunner_utils/script_run_context.py

@@ -28,7 +28,6 @@ from urllib import parse
 
 from streamlit.errors import (
     NoSessionContext,
-    StreamlitAPIException,
 )
 from streamlit.logger import get_logger
 from streamlit.runtime.forward_msg_cache import (
@@ -109,10 +108,6 @@ class ScriptRunContext:
     # we allow only one dialog to be open at the same time
     has_dialog_opened: bool = False
 
-    # TODO(willhuang1997): Remove this variable when experimental query params are removed
-    _experimental_query_params_used = False
-    _production_query_params_used = False
-
     @property
     def page_script_hash(self) -> str:
         return self.pages_manager.current_page_script_hash
@@ -202,22 +197,6 @@ class ScriptRunContext:
         # Pass the message up to our associated ScriptRunner.
         self._enqueue(msg_to_send)
 
-    def ensure_single_query_api_used(self) -> None:
-        if self._experimental_query_params_used and self._production_query_params_used:
-            raise StreamlitAPIException(
-                "Using `st.query_params` together with either `st.experimental_get_query_params` "
-                "or `st.experimental_set_query_params` is not supported. Please "
-                " convert your app to only use `st.query_params`"
-            )
-
-    def mark_experimental_query_params_used(self) -> None:
-        self._experimental_query_params_used = True
-        self.ensure_single_query_api_used()
-
-    def mark_production_query_params_used(self) -> None:
-        self._production_query_params_used = True
-        self.ensure_single_query_api_used()
-
 
 SCRIPT_RUN_CONTEXT_ATTR_NAME: Final = "streamlit_script_run_ctx"