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

streamlit/commands/logo.py

@@ -56,6 +56,8 @@ def logo(
     `configuration option <https://docs.streamlit.io/develop/api-reference/configuration/config.toml>`_
     ``client.toolbarMode="minimal"``.
 
+    If a user clicks the logo, they are redirected to your app's home page.
+
     Parameters
     ----------
     image: Anything supported by st.image (except list)

streamlit/commands/page_config.py

@@ -170,28 +170,28 @@ def set_page_config(
         .. _st.image: https://docs.streamlit.io/develop/api-reference/media/st.image
 
     layout: "centered", "wide", or None
-        How the page content should be laid out. If this is ``None`` (default),
-        the page layout is inherited from the previous call of
-        ``st.set_page_config``. If this is ``None`` and no previous call
-        exists, the page layout is ``"centered"``.
+        Layout of the page content. The following layouts are supported:
 
-        ``"centered"`` constrains the elements into a centered column of fixed
-        width. ``"wide"`` uses the entire screen.
+        - ``None`` (default): The page layout is inherited from the previous
+          call of ``st.set_page_config``. If no previous call exists, the page
+          layout is ``"centered"``.
+        - ``"centered"``: Page elements are constrained to a centered column of
+          fixed width.
+        - ``"wide"``: Page elements use the entire screen width.
 
     initial_sidebar_state: "auto", "expanded", "collapsed", int, or None
-        How the sidebar should start out. If this is ``None`` (default), the
-        sidebar state is inherited from the previous call of
-        ``st.set_page_config``. If no previous call exists, the sidebar state
-        is ``"auto"``.
-
-        The following states are supported:
+        Initial state of the sidebar. The following states are supported:
 
-        - ``"auto"``: The sidebar is hidden on small devices and shown otherwise.
+        - ``None`` (default): The sidebar state is inherited from the previous
+          call of ``st.set_page_config``. If no previous call exists, the
+          sidebar state is ``"auto"``.
+        - ``"auto"``: The sidebar is hidden on small devices and shown
+          otherwise.
         - ``"expanded"``: The sidebar is shown initially.
         - ``"collapsed"``: The sidebar is hidden initially.
-        - ``int``: Set the initial sidebar width in pixels. The sidebar will use
-          "auto" behavior but start with the specified width. Must be a positive integer.
-          The width is limited to a minimum of 200px and a maximum of 600px.
+        - ``int``: The sidebar will use ``"auto"`` behavior but start with the
+          specified width in pixels. The width must be between 200 and 600
+          pixels, inclusive.
 
         In most cases, ``"auto"`` provides the best user experience across
         devices of different sizes.

streamlit/components/v2/__init__.py

@@ -214,8 +214,8 @@ def component(
 ) -> ComponentRenderer:
     '''Register an ``st.components.v2`` component and return a callable to mount it.
 
-    Components may provide any combination of HTML, CSS, and JavaScript. If none
-    are provided, the component will render as an empty element without raising
+    Components can have any combination of HTML, CSS, and JavaScript. If none
+    are provided, the component renders as an empty element without raising
     an error.
 
     If your component is defined in an installed package, you can declare an

streamlit/connections/base_connection.py

@@ -35,6 +35,13 @@ class BaseConnection(ABC, Generic[RawConnectionT]):
     implementation of connections more convenient. See the docstrings for each of the
     methods of this class for more information
 
+    By default, ``BaseConnection`` is a global-scoped connection. It has a class
+    method |BaseConnection.scope()|_ that returns ``"global"``. To implement a session-scoped
+    connection, override this method to return ``"session"`` in your subclass.
+
+    .. |BaseConnection.scope()| replace:: ``BaseConnection.scope()``
+    .. _BaseConnection.scope(): #baseconnectionscope
+
     .. note::
         While providing an implementation of ``_connect`` is technically all that's
         required to define a valid connection, connections should also provide the user
@@ -179,14 +186,19 @@ class BaseConnection(ABC, Generic[RawConnectionT]):
     def scope(cls) -> Literal["global", "session"]:
         """Returns the scope of this connection type.
 
-        "global" connection instances will be cached globally, and typically created
-        once during the lifetime of an application. "session" connection instances will
-        be cached per session, and typically will be created once per user session.
+        This is a class method. ``"global"`` connection instances will be cached
+        globally and are typically created once during the lifetime of an
+        application. ``"session"`` connection instances will be cached per
+        session and are typically created once per user session.
+
+        A connection's scope can't be changed for different instances of the
+        same connection type. If you want to switch between global and
+        session-scoped connections, you should create two different connection
+        types.
 
         Returns
         -------
         "global" or "session"
-            The scope of this connection type.
         """
         return "global"
 

streamlit/connections/snowflake_connection.py

@@ -54,211 +54,12 @@ SNOWPARK_USER_TOKEN_HEADER_NAME = "Sf-Context-Current-User-Token"  # noqa: S105
 
 
 class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
-    """A connection to Snowflake using the Snowflake Connector for Python.
-
-    For standard connections, create an instance of this using
-    ``st.connection("snowflake")`` or
-    ``st.connection("<name>", type="snowflake")``. Connection parameters for a
-    SnowflakeConnection can be specified using ``secrets.toml`` and/or
-    ``**kwargs``. Connection parameters are passed to
-    |snowflake.connector.connect()|.
-
-    When an app is running in Streamlit in Snowflake,
-    ``st.connection("snowflake")`` connects automatically using the app owner's
-    role without further configuration. ``**kwargs`` will be ignored in this
-    case. Use ``secrets.toml`` and ``**kwargs`` to configure your connection
-    for local development.
-
-    When an app is running in Snowpark Container Services and has caller's rights
-    enabled, ``st.connection("snowflake-callers-rights")`` connects automatically
-    using the current user's identity tokens. This will be a session-scoped connection
-    to ensure that the identity stays tied to the active user. Unlike with
-    ``"snowflake"`` connections, it will use the Snowpark Container Services connection
-    settings even when other ``**kwargs`` are provided.
-
-    BaseSnowflakeConnection includes several convenience methods. For example, you
-    can directly execute a SQL query with ``.query()`` or access the underlying
-    Snowflake Connector object with ``.raw_connection``.
-
-    .. |snowflake.connector.connect()| replace:: ``snowflake.connector.connect()``
-    .. _snowflake.connector.connect(): https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api#label-snowflake-connector-methods-connect
-
-    .. Important::
-        `snowflake-snowpark-python <https://pypi.org/project/snowflake-snowpark-python/>`_
-        must be installed in your environment to use this connection. You can
-        install it as an extra with Streamlit:
-
-        .. code-block:: shell
-
-           pip install streamlit[snowflake]
-
-    .. Important::
-        Account identifiers must be of the form ``<orgname>-<account_name>``
-        where ``<orgname>`` is the name of your Snowflake organization and
-        ``<account_name>`` is the unique name of your account within your
-        organization. This is dash-separated, not dot-separated like when used
-        in SQL queries. For more information, see `Account identifiers
-        <https://docs.snowflake.com/en/user-guide/admin-account-identifier>`_.
-
-    .. Important::
-        Caller's rights connections rely on credentials provided when a user first
-        connects to a Streamlit app. These credentials are only valid for a short period
-        of time - so caller's rights connections must be created at the top of an app
-        or else the connection may fail.
-
-    Examples
-    --------
-    **Example 1: Configuration with Streamlit secrets**
-
-    You can configure your Snowflake connection using Streamlit's
-    `Secrets management <https://docs.streamlit.io/develop/concepts/connections/secrets-management>`_.
-    For example, if you have MFA enabled on your account, you can connect using
-    `key-pair authentication <https://docs.snowflake.com/en/user-guide/key-pair-auth>`_.
-
-    ``.streamlit/secrets.toml``:
-
-    >>> [connections.snowflake]
-    >>> account = "xxx-xxx"
-    >>> user = "xxx"
-    >>> private_key_file = "/xxx/xxx/xxx.p8"
-    >>> role = "xxx"
-    >>> warehouse = "xxx"
-    >>> database = "xxx"
-    >>> schema = "xxx"
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("snowflake")
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 2: Configuration with keyword arguments and external authentication**
-
-    You can configure your Snowflake connection with keyword arguments. The
-    keyword arguments are merged with (and take precedence over) the values in
-    ``secrets.toml``. However, if you name your connection ``"snowflake"`` and
-    don't have a ``[connections.snowflake]`` dictionary in your
-    ``secrets.toml`` file, Streamlit will ignore any keyword arguments and use
-    the default Snowflake connection as described in Example 5 and Example 6.
-    To configure your connection using only keyword arguments, declare a name
-    for the connection other than ``"snowflake"``.
-
-    For example, if your Snowflake account supports SSO, you can set up a quick
-    local connection for development using `browser-based SSO
-    <https://docs.snowflake.com/en/user-guide/admin-security-fed-auth-use#how-browser-based-sso-works>`_.
-    Because there is nothing configured in ``secrets.toml``, the name is an
-    empty string and the type is set to ``"snowflake"``. This prevents
-    Streamlit from ignoring the keyword arguments and using a default
-    Snowflake connection.
-
-    >>> import streamlit as st
-    >>> conn = st.connection(
-    ...     "",
-    ...     type="snowflake",
-    ...     account="xxx-xxx",
-    ...     user="xxx",
-    ...     authenticator="externalbrowser",
-    ... )
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 3: Named connection with Snowflake's connection configuration file**
-
-    Snowflake's Python Connector supports a `connection configuration file
-    <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#connecting-using-the-connections-toml-file>`_,
-    which is well integrated with Streamlit's ``SnowflakeConnection``. If you
-    already have one or more connections configured, all you need to do is pass
-    the name of the connection to use.
-
-    ``~/.snowflake/connections.toml``:
-
-    >>> [my_connection]
-    >>> account = "xxx-xxx"
-    >>> user = "xxx"
-    >>> password = "xxx"
-    >>> warehouse = "xxx"
-    >>> database = "xxx"
-    >>> schema = "xxx"
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("my_connection", type="snowflake")
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 4: Named connection with Streamlit secrets and Snowflake's connection configuration file**
-
-    If you have a Snowflake configuration file with a connection named
-    ``my_connection`` as in Example 3, you can pass the connection name through
-    ``secrets.toml``.
-
-    ``.streamlit/secrets.toml``:
-
-    >>> [connections.snowflake]
-    >>> connection_name = "my_connection"
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("snowflake")
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 5: Default connection with an environment variable**
-
-    If you don't have a ``[connections.snowflake]`` dictionary in your
-    ``secrets.toml`` file and use ``st.connection("snowflake")``, Streamlit
-    will use the default connection for the `Snowflake Python Connector
-    <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection>`_.
-
-    If you have a Snowflake configuration file with a connection named
-    ``my_connection`` as in Example 3, you can set an environment variable to
-    declare it as the default Snowflake connection.
-
-    >>> SNOWFLAKE_DEFAULT_CONNECTION_NAME = "my_connection"
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("snowflake")
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 6: Default connection in Snowflake's connection configuration file**
-
-    If you have a Snowflake configuration file that defines your ``default``
-    connection, Streamlit will automatically use it if no other connection is
-    declared.
-
-    ``~/.snowflake/connections.toml``:
-
-    >>> [default]
-    >>> account = "xxx-xxx"
-    >>> user = "xxx"
-    >>> password = "xxx"
-    >>> warehouse = "xxx"
-    >>> database = "xxx"
-    >>> schema = "xxx"
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("snowflake")
-    >>> df = conn.query("SELECT * FROM my_table")
-
-    **Example 7: Caller's rights connection when running in Snowpark Container Services**
-
-    This connection will work for any Streamlit-in-Snowflake app using a container
-    runtime, as well as any self-managed caller's rights Service in Snowpark Container
-    Services that is hosting Streamlit.
-
-    This will use the Snowpark-provided account, host, database, and schema to connect.
-    Additionally, it will set ``client_session_keep_alive`` to ``True``. These values
-    may be overridden with ``**kwargs``.
-
-    Your app code:
-
-    >>> import streamlit as st
-    >>> conn = st.connection("snowflake-callers-rights")
-    >>> df = conn.query("SELECT * FROM my_table")
+    """Base class for Snowflake connections.
 
+    This base class provides the common methods and properties for Snowflake
+    connections. See the docstrings for each of these methods for more
+    information. The docstring for ``SnowflakeConnection`` provides an overall
+    description of the Snowflake connection types.
     """
 
     def query(
@@ -553,7 +354,255 @@ class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
 class SnowflakeConnection(BaseSnowflakeConnection):
     """A connection to Snowflake using the Snowflake Connector for Python.
 
-    See ``BaseSnowflakeConnection`` for complete docs.
+    For standard connections, create an instance of this using
+    ``st.connection("snowflake")`` or
+    ``st.connection("<name>", type="snowflake")``. Connection parameters for a
+    SnowflakeConnection can be specified using ``secrets.toml`` and/or
+    ``**kwargs``. Connection parameters are passed to
+    |snowflake.connector.connect()|_.
+
+    When an app is running in Streamlit in Snowflake,
+    ``st.connection("snowflake")`` connects automatically using the app owner's
+    role without further configuration. ``**kwargs`` are ignored in this
+    case. Use ``secrets.toml`` and ``**kwargs`` to configure your connection
+    for local development.
+
+    When an app is running in Snowpark Container Services and has caller's rights
+    enabled, ``st.connection("snowflake-callers-rights")`` connects automatically
+    using the current user's identity tokens. This is a session-scoped connection
+    to ensure that the identity stays tied to the active user. Unlike with
+    ``"snowflake"`` connections, it will use the Snowpark Container Services
+    connection settings even when other ``**kwargs`` are provided.
+
+    The Snowflake connection includes several convenience methods. For example, you
+    can directly execute a SQL query with ``.query()`` or access the underlying
+    Snowflake Connector object with ``.raw_connection``.
+
+    .. |snowflake.connector.connect()| replace:: ``snowflake.connector.connect()``
+    .. _snowflake.connector.connect(): https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api#label-snowflake-connector-methods-connect
+
+    .. Important::
+        - `snowflake-snowpark-python <https://pypi.org/project/snowflake-snowpark-python/>`_
+          must be installed in your environment to use this connection. You can
+          install it as an extra with Streamlit:
+
+          .. code-block:: shell
+
+             pip install streamlit[snowflake]
+
+        - Account identifiers must be of the form ``<orgname>-<account_name>``
+          where ``<orgname>`` is the name of your Snowflake organization and
+          ``<account_name>`` is the unique name of your account within your
+          organization. This is dash-separated, not dot-separated like when used
+          in SQL queries. For more information, see `Account identifiers
+          <https://docs.snowflake.com/en/user-guide/admin-account-identifier>`_.
+
+        - Caller's rights connections rely on credentials provided when a user first
+          connects to a Streamlit app. These credentials are only valid for about
+          two minutes. Therefore, caller's rights connections must be created at
+          the top of an app or else the connection may fail.
+
+        - To develop locally with a caller's rights connection, use an
+          environment variable to logically switch between a ``"snowflake"``
+          connection locally and a ``"snowflake-callers-rights"`` connection in
+          Snowpark Container Services.
+
+    Examples
+    --------
+    **Example 1: Configuration with Streamlit secrets**
+
+    You can configure your Snowflake connection using Streamlit's
+    `Secrets management <https://docs.streamlit.io/develop/concepts/connections/secrets-management>`_.
+    For example, if you have MFA enabled on your account, you can connect using
+    `key-pair authentication <https://docs.snowflake.com/en/user-guide/key-pair-auth>`_.
+
+    .. code-block:: toml
+        :filename: ~/.snowflake/connections.toml
+
+        [connections.snowflake]
+        account = "xxx-xxx"
+        user = "xxx"
+        private_key_file = "/xxx/xxx/xxx.p8"
+        role = "xxx"
+        warehouse = "xxx"
+        database = "xxx"
+        schema = "xxx"
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("snowflake")
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 2: Configuration with keyword arguments and external authentication**
+
+    You can configure your Snowflake connection with keyword arguments. The
+    keyword arguments are merged with (and take precedence over) the values in
+    ``secrets.toml``. However, if you name your connection ``"snowflake"`` and
+    don't have a ``[connections.snowflake]`` dictionary in your
+    ``secrets.toml`` file, Streamlit will ignore any keyword arguments and use
+    the default Snowflake connection as described in Example 5 and Example 6.
+    To configure your connection using only keyword arguments, declare a name
+    for the connection other than ``"snowflake"``.
+
+    For example, if your Snowflake account supports SSO, you can set up a quick
+    local connection for development using `browser-based SSO
+    <https://docs.snowflake.com/en/user-guide/admin-security-fed-auth-use#how-browser-based-sso-works>`_.
+    Because there is nothing configured in ``secrets.toml``, the name is an
+    empty string and the type is set to ``"snowflake"``. This prevents
+    Streamlit from ignoring the keyword arguments and using a default
+    Snowflake connection.
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection(
+            "",
+            type="snowflake",
+            account="xxx-xxx",
+            user="xxx",
+            authenticator="externalbrowser",
+        )
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 3: Named connection with Snowflake's connection configuration file**
+
+    Snowflake's Python Connector supports a `connection configuration file
+    <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#connecting-using-the-connections-toml-file>`_,
+    which is well integrated with Streamlit's ``SnowflakeConnection``. If you
+    already have one or more connections configured, all you need to do is pass
+    the name of the connection to use.
+
+    .. code-block:: toml
+        :filename: ~/.snowflake/connections.toml
+
+        [my_connection]
+        account = "xxx-xxx"
+        user = "xxx"
+        password = "xxx"
+        warehouse = "xxx"
+        database = "xxx"
+        schema = "xxx"
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("my_connection", type="snowflake")
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 4: Named connection with Streamlit secrets and Snowflake's connection configuration file**
+
+    If you have a Snowflake configuration file with a connection named
+    ``my_connection`` as in Example 3, you can pass the connection name through
+    ``secrets.toml``.
+
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
+
+        [connections.snowflake]
+        connection_name = "my_connection"
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("snowflake")
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 5: Default connection with an environment variable**
+
+    If you don't have a ``[connections.snowflake]`` dictionary in your
+    ``secrets.toml`` file and use ``st.connection("snowflake")``, Streamlit
+    will use the default connection for the `Snowflake Python Connector
+    <https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection>`_.
+
+    If you have a Snowflake configuration file with a connection named
+    ``my_connection`` as in Example 3, you can set an environment variable to
+    declare it as the default Snowflake connection.
+
+    .. code-block:: toml
+        :filename: .streamlit/secrets.toml
+
+        SNOWFLAKE_DEFAULT_CONNECTION_NAME = "my_connection"
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("snowflake")
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 6: Default connection in Snowflake's connection configuration file**
+
+    If you have a Snowflake configuration file that defines your ``default``
+    connection, Streamlit will automatically use it if no other connection is
+    declared.
+
+    .. code-block:: toml
+        :filename: ~/.snowflake/connections.toml
+
+        [default]
+        account = "xxx-xxx"
+        user = "xxx"
+        password = "xxx"
+        warehouse = "xxx"
+        database = "xxx"
+        schema = "xxx"
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("snowflake")
+        df = conn.query("SELECT * FROM my_table")
+
+    **Example 7: Caller's rights connection when running in Snowpark Container Services**
+
+    You can use ``"snowflake-callers-rights"`` type connections in any
+    environment running on Snowpark Container Services, including Streamlit in
+    Snowflake on containers and any self-managed caller's rights Service.
+
+    This will use the Snowpark-provided account, host, database, and schema to connect.
+    Additionally, it will set ``client_session_keep_alive`` to ``True``. These values
+    may be overridden with ``**kwargs`` in ``st.connection``. For a complete list
+    of keyword arguments, see the documentation for |snowflake.connector.connect()|_.
+
+    .. |snowflake.connector.connect()| replace:: ``snowflake.connector.connect()``
+    .. _snowflake.connector.connect(): https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api#label-snowflake-connector-methods-connect
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = st.connection("snowflake-callers-rights")
+        df = conn.query("SELECT * FROM my_table")
+
+    If you want to develop locally with a caller's rights connection, use an
+    environment variable to logically switch between a ``"snowflake"``
+    connection locally and a ``"snowflake-callers-rights"`` connection in
+    Snowpark Container Services.
+
+    .. code-block:: python
+        :filename: streamlit_app.py
+
+        import streamlit as st
+
+        conn = (
+            st.connection("snowflake")
+            if "LOCAL_DEVELOPMENT" in st.secrets and st.secrets["LOCAL_DEVELOPMENT"]
+            else st.connection("snowflake-callers-rights")
+        )
+        df = conn.query("SELECT * FROM my_table")
     """
 
     def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:

streamlit/elements/form.py

@@ -341,8 +341,8 @@ class FormMixin:
             - ``"spinner"``: Displays a spinner as an icon.
 
         icon_position : "left" or "right"
-            The position of the icon relative to the button label. Defaults to
-            ``"left"``.
+            The position of the icon relative to the button label. This
+            defaults to ``"left"``.
 
         disabled : bool
             Whether to disable the button. If this is ``False`` (default), the