streamlit-nightly 1.52.3.dev20260106__tar.gz → 1.52.3.dev20260108__tar.gz

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/PKG-INFO

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

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/setup.py

@@ -23,7 +23,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.52.3.dev20260106"  # PEP-440
+VERSION = "1.52.3.dev20260108"  # 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.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/components/v2/__init__.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from streamlit import deprecation_util
 from streamlit.components.v2.component_definition_resolver import (
     build_definition_with_validation,
 )
@@ -106,6 +107,7 @@ def _create_component_callable(
     html: str | None = None,
     css: str | None = None,
     js: str | None = None,
+    isolate_styles: bool = True,
 ) -> Callable[..., Any]:
     """Create a component callable, handling both lookup and registration cases.
 
@@ -121,6 +123,9 @@ def _create_component_callable(
     js : str | None
         Inline JavaScript (string) or a string path/glob to a file under
         ``asset_dir``; see :func:`_register_component` for path validation semantics.
+    isolate_styles : bool
+        Whether to sandbox the component's styles in a shadow root.
+        Defaults to True.
 
     Returns
     -------
@@ -143,7 +148,6 @@ def _create_component_callable(
         default: dict[str, Any] | None = None,
         width: Width = "stretch",
         height: Height = "content",
-        isolate_styles: bool = True,
         **on_callbacks: WidgetCallback | None,
     ) -> BidiComponentResult:
         """Mount the component.
@@ -161,9 +165,6 @@ def _create_component_callable(
             The width of the component.
         height : Height
             The height of the component.
-        isolate_styles : bool
-            Whether to sandbox the component styles in a shadow-root. Defaults to
-            True.
         **on_callbacks : WidgetCallback
             Callback functions for handling component events. Use pattern
             on_{state_name}_change (e.g., on_click_change, on_value_change).
@@ -175,6 +176,20 @@ def _create_component_callable(
         """
         import streamlit as st
 
+        # Backwards-tolerant: old code may still pass isolate_styles at mount
+        # time. Since isolate_styles is now configured on component(), ignore it
+        # here to prevent a runtime error.
+        if "isolate_styles" in on_callbacks:
+            on_callbacks.pop("isolate_styles", None)
+
+            deprecation_util.show_deprecation_warning(
+                "Passing `isolate_styles` when mounting a component created via "
+                "`st.components.v2.component` is deprecated and will be ignored. "
+                "Set `isolate_styles` when creating the component instead "
+                "(`st.components.v2.component(..., isolate_styles=...)`).",
+                show_in_browser=False,
+            )
+
         return st._bidi_component(
             component_key,
             key=key,
@@ -186,10 +201,6 @@ def _create_component_callable(
             **on_callbacks,
         )
 
-    # Ensure the function remains compatible with the shared public callable type.
-    # Static type assertion to ensure the callable matches the shared signature
-    _typed_check_mount_component: BidiComponentCallable = _mount_component
-
     return _mount_component
 
 
@@ -199,11 +210,13 @@ def component(
     html: str | None = None,
     css: str | None = None,
     js: str | None = None,
+    isolate_styles: bool = True,
 ) -> BidiComponentCallable:
     '''Register an ``st.components.v2`` component and return a callable to mount it.
 
-    A component must have HTML, JavaScript, or both. If you want a component
-    with only CSS, use ``st.html`` instead.
+    Components may provide any combination of HTML, CSS, and JavaScript. If none
+    are provided, the component will render as an empty element without raising
+    an error.
 
     If your component is defined in an installed package, you can declare an
     asset directory (``asset_dir``) through ``pyproject.toml`` files in the
@@ -250,9 +263,6 @@ def component(
         element and populate it via JavaScript. Alternatively, you can append
         a new element to the parent. For more information, see Example 2.
 
-        ``html`` and ``js`` can't both be ``None``. At least one of them must
-        be provided.
-
     css : str or None
         Inline CSS. This can be one of the following strings:
 
@@ -267,8 +277,13 @@ def component(
         - A path or glob to a JS file, relative to the component's
           asset directory.
 
-        ``html`` and ``js`` can't both be ``None``. At least one of them must
-        be provided.
+    isolate_styles : bool
+        Whether to sandbox the component styles in a shadow root. If this is
+        ``True`` (default), the component's HTML is mounted inside a shadow DOM
+        and, in your component's JavaScript, ``parentElement`` returns a
+        ``ShadowRoot``. If this is ``False``, the component's HTML is mounted
+        directly into the app's DOM tree, and ``parentElement`` returns a
+        regular ``HTMLElement``.
 
     Returns
     -------
@@ -506,7 +521,9 @@ def component(
         height: 250px
 
     '''
-    return _create_component_callable(name, html=html, css=css, js=js)
+    return _create_component_callable(
+        name, html=html, css=css, js=js, isolate_styles=isolate_styles
+    )
 
 
 __all__ = [

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/components/v2/bidi_component/main.py

@@ -50,7 +50,6 @@ from streamlit.errors import (
     BidiComponentInvalidCallbackNameError,
     BidiComponentInvalidDefaultKeyError,
     BidiComponentInvalidIdError,
-    BidiComponentMissingContentError,
     BidiComponentUnserializableDataError,
 )
 from streamlit.proto.ArrowData_pb2 import ArrowData as ArrowDataProto
@@ -349,13 +348,6 @@ class BidiComponentMixin:
         if component_def is None:
             raise ValueError(f"Component '{component_name}' is not registered")
 
-        # Validate that the component has the required content
-        has_js = bool(component_def.js_content or component_def.js_url)
-        has_html = bool(component_def.html_content)
-
-        if not has_js and not has_html:
-            raise BidiComponentMissingContentError(component_name)
-
         # ------------------------------------------------------------------
         # 1. Parse user-supplied callbacks
         # ------------------------------------------------------------------

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/components/v2/types.py

@@ -22,6 +22,10 @@ authoring wrappers/utilities around `st.components.v2.component`.
 The goal is to keep the public argument surface documented in one place and
 reusable across both the user-facing factory in `components/v2/__init__.py`
 and the internal implementation in `components/v2/bidi_component/main.py`.
+
+Component definitions may provide any combination of HTML, CSS, and
+JavaScript. If none are supplied, the component renders as an empty
+placeholder without raising an error.
 """
 
 from __future__ import annotations
@@ -137,14 +141,6 @@ class BidiComponentCallable(Protocol):
         You are responsible for ensuring the component's inner HTML content is
         responsive to the ``<div>`` wrapper.
 
-    isolate_styles : bool
-        Whether to sandbox the component styles in a shadow root. If this is
-        ``True`` (default), the component's HTML is mounted inside a shadow DOM
-        and, in your component's JavaScript, ``parentElement`` returns a
-        ``ShadowRoot``. If this is ``False``, the component's HTML is mounted
-        directly into the app's DOM tree, and ``parentElement`` returns a
-        regular ``HTMLElement``.
-
     **callbacks : Callable or None
         Callbacks with the naming pattern ``on_<key>_change`` for each state and
         trigger key. For example, if your component has a state key of
@@ -251,11 +247,12 @@ class BidiComponentCallable(Protocol):
 
     **Example 2: Add Tailwind CSS to a component**
 
-    You can use the ``isolate_styles`` parameter to disable shadow DOM
-    isolation and apply global styles like Tailwind CSS to your component. The
-    following example creates a simple button styled with Tailwind CSS. This
-    example also demonstrates using different keys to mount multiple instances
-    of the same component in one app.
+    You can use the ``isolate_styles`` parameter in
+    ``st.components.v2.component`` to disable shadow DOM isolation and apply
+    global styles like Tailwind CSS to your component. The following example
+    creates a simple button styled with Tailwind CSS. This example also
+    demonstrates using different keys to mount multiple instances of the same
+    component in one app.
 
     .. code-block:: python
 
@@ -285,15 +282,12 @@ class BidiComponentCallable(Protocol):
             "my_tailwind_button",
             html=HTML,
             js=JS,
+            isolate_styles=False,
         )
-        result_1 = my_component(
-            isolate_styles=False, on_clicked_change=lambda: None, key="one"
-        )
+        result_1 = my_component(on_clicked_change=lambda: None, key="one")
         result_1
 
-        result_2 = my_component(
-            isolate_styles=False, on_clicked_change=lambda: None, key="two"
-        )
+        result_2 = my_component(on_clicked_change=lambda: None, key="two")
         result_2
 
     .. output::
@@ -310,7 +304,6 @@ class BidiComponentCallable(Protocol):
         default: BidiComponentDefaults = None,
         width: Width = "stretch",
         height: Height = "content",
-        isolate_styles: ComponentIsolateStyles = True,
         **on_callbacks: WidgetCallback | None,
     ) -> BidiComponentResult: ...
 

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/config.py

@@ -1003,6 +1003,16 @@ _create_option(
     visibility="hidden",
 )
 
+_create_option(
+    "server.useStarlette",
+    description="""
+        Enable the experimental Starlette-based server implementation instead of
+        Tornado. This is an experimental feature and may be removed in the future.
+    """,
+    default_val=False,
+    type_=bool,
+)
+
 # Config Section: Browser #
 
 _create_section("browser", "Configuration of non-UI browser options.")

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/connections/__init__.py

@@ -13,7 +13,10 @@
 # limitations under the License.
 
 from streamlit.connections.base_connection import BaseConnection
-from streamlit.connections.snowflake_connection import SnowflakeConnection
+from streamlit.connections.snowflake_connection import (
+    SnowflakeCallersRightsConnection,
+    SnowflakeConnection,
+)
 from streamlit.connections.snowpark_connection import SnowparkConnection
 from streamlit.connections.sql_connection import SQLConnection
 
@@ -23,6 +26,7 @@ __all__ = [
     "BaseConnection",
     "ExperimentalBaseConnection",
     "SQLConnection",
+    "SnowflakeCallersRightsConnection",
     "SnowflakeConnection",
     "SnowparkConnection",
 ]

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/connections/snowflake_connection.py

@@ -20,7 +20,8 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Final, cast
+import os
+from typing import TYPE_CHECKING, Any, Final, Literal, cast
 
 from streamlit import logger
 from streamlit.connections import BaseConnection
@@ -45,11 +46,18 @@ if TYPE_CHECKING:
 # (see docs: https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-api#id6)
 SQLSTATE_CONNECTION_WAS_NOT_ESTABLISHED: Final = "08001"
 
+# The location on disk where Snowpark Container Services will mount service connection tokens.
+SNOWPARK_CONNECTION_TOKEN_FILE = "/snowflake/session/token"  # noqa: S105 (not a password)
 
-class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
+# The header where Snowpark Container Services will put per-user connection tokens.
+SNOWPARK_USER_TOKEN_HEADER_NAME = "Sf-Context-Current-User-Token"  # noqa: S105 (not a password)
+
+
+class BaseSnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     """A connection to Snowflake using the Snowflake Connector for Python.
 
-    Initialize this connection object using ``st.connection("snowflake")`` or
+    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
@@ -61,7 +69,14 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     case. Use ``secrets.toml`` and ``**kwargs`` to configure your connection
     for local development.
 
-    SnowflakeConnection includes several convenience methods. For example, you
+    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``.
 
@@ -85,6 +100,12 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         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**
@@ -222,64 +243,23 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
     >>> conn = st.connection("snowflake")
     >>> df = conn.query("SELECT * FROM my_table")
 
-    """
+    **Example 7: Caller's rights connection when running in Snowpark Container Services**
 
-    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
-        import snowflake.connector  # type:ignore[import]
-        from snowflake.connector import Error as SnowflakeError  # type:ignore[import]
+    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.
 
-        # If we're running in SiS, just call get_active_session() and retrieve the
-        # lower-level connection from it.
-        if running_in_sis():
-            from snowflake.snowpark.context import (  # type:ignore[import]  # isort: skip
-                get_active_session,
-            )
-
-            session = get_active_session()
+    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``.
 
-            if hasattr(session, "connection"):
-                return session.connection
-            # session.connection is only a valid attr in more recent versions of
-            # snowflake-connector-python, so we fall back to grabbing
-            # session._conn._conn if `.connection` is unavailable.
-            return session._conn._conn
-
-        # We require qmark-style parameters everywhere for consistency across different
-        # environments where SnowflakeConnections may be used.
-        snowflake.connector.paramstyle = "qmark"
-
-        # Otherwise, attempt to create a new connection from whatever credentials we
-        # have available.
-        st_secrets = self._secrets.to_dict()
-        try:
-            if len(st_secrets):
-                _LOGGER.info(
-                    "Connect to Snowflake using the Streamlit secret defined under "
-                    "[connections.snowflake]."
-                )
-                conn_kwargs = {**st_secrets, **kwargs}
-                return snowflake.connector.connect(**conn_kwargs)
+    Your app code:
 
-            # Use the default configuration as defined in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection
-            if self._connection_name == "snowflake":
-                _LOGGER.info(
-                    "Connect to Snowflake using the default configuration as defined "
-                    "in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection"
-                )
-                return snowflake.connector.connect()
+    >>> import streamlit as st
+    >>> conn = st.connection("snowflake-callers-rights")
+    >>> df = conn.query("SELECT * FROM my_table")
 
-            return snowflake.connector.connect(**kwargs)
-        except SnowflakeError:
-            if not len(st_secrets) and not kwargs:
-                raise StreamlitAPIException(
-                    "Missing Snowflake connection configuration. "
-                    "Did you forget to set this in `secrets.toml`, a Snowflake configuration file, "
-                    "or as kwargs to `st.connection`? "
-                    "See the [SnowflakeConnection configuration documentation]"
-                    "(https://docs.streamlit.io/st.connections.snowflakeconnection-configuration) "
-                    "for more details and examples."
-                )
-            raise
+    """
 
     def query(
         self,
@@ -563,3 +543,169 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         return cast(
             "Session", Session.builder.configs({"connection": self._instance}).create()
         )
+
+    def close(self) -> None:
+        """Closes the underlying Snowflake connection."""
+        if self._raw_instance is not None:
+            self._raw_instance.close()
+
+
+class SnowflakeConnection(BaseSnowflakeConnection):
+    """A connection to Snowflake using the Snowflake Connector for Python.
+
+    See ``BaseSnowflakeConnection`` for complete docs.
+    """
+
+    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
+        import snowflake.connector  # type:ignore[import]
+        from snowflake.connector import Error as SnowflakeError  # type:ignore[import]
+
+        # If we're running in SiS-on-warehouses, just call get_active_session() and
+        # retrieve the lower-level connection from it.
+        if running_in_sis():
+            from snowflake.snowpark.context import (  # type:ignore[import]  # isort: skip
+                get_active_session,
+            )
+
+            session = get_active_session()
+
+            if hasattr(session, "connection"):
+                return session.connection
+            # session.connection is only a valid attr in more recent versions of
+            # snowflake-connector-python, so we fall back to grabbing
+            # session._conn._conn if `.connection` is unavailable.
+            return session._conn._conn
+
+        # We require qmark-style parameters everywhere for consistency across different
+        # environments where SnowflakeConnections may be used.
+        snowflake.connector.paramstyle = "qmark"
+
+        # Otherwise, attempt to create a new connection from whatever credentials we
+        # have available.
+        st_secrets = self._secrets.to_dict()
+        try:
+            if len(st_secrets):
+                _LOGGER.info(
+                    "Connect to Snowflake using the Streamlit secret defined under "
+                    "[connections.snowflake]."
+                )
+                conn_kwargs = {**st_secrets, **kwargs}
+                return snowflake.connector.connect(**conn_kwargs)
+
+            # Use the default configuration as defined in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection
+            if self._connection_name == "snowflake":
+                _LOGGER.info(
+                    "Connect to Snowflake using the default configuration as defined "
+                    "in https://docs.snowflake.com/en/developer-guide/python-connector/python-connector-connect#setting-a-default-connection"
+                )
+                return snowflake.connector.connect()
+
+            return snowflake.connector.connect(**kwargs)
+        except SnowflakeError:
+            if not len(st_secrets) and not kwargs:
+                raise StreamlitAPIException(
+                    "Missing Snowflake connection configuration. "
+                    "Did you forget to set this in `secrets.toml`, a Snowflake configuration file, "
+                    "or as kwargs to `st.connection`? "
+                    "See the [SnowflakeConnection configuration documentation]"
+                    "(https://docs.streamlit.io/st.connections.snowflakeconnection-configuration) "
+                    "for more details and examples."
+                )
+            raise
+
+
+class SnowflakeCallersRightsConnection(SnowflakeConnection):
+    """A caller's rights connection to Snowflake using the Snowflake Connector for Python.
+
+    This will only work when running on Snowpark Container Services or another
+    compatible platform.
+
+    See ``BaseSnowflakeConnection`` for complete docs.
+    """
+
+    @classmethod
+    def scope(cls) -> Literal["session"]:
+        """Returns ``"session"``.
+
+        Caller's rights Snowflake connections rely on per-session connection tokens and
+        therefore must be session-scoped.
+        """
+        return "session"
+
+    @classmethod
+    def _read_token_file(cls) -> str:
+        """Returns the contents of the Snowpark token file on disk."""
+        with open(SNOWPARK_CONNECTION_TOKEN_FILE) as token_file:
+            return token_file.read()
+
+    @classmethod
+    def _get_connection_params(cls) -> dict[str, str | bool]:
+        """Returns caller's rights connection parameters for the current session.
+
+        Raises
+        ------
+            StreamlitAPIException: if any Snowpark environment variables or connection
+            tokens are missing; or if this is called outside of a session context.
+        """
+        # Local import needed to avoid cycles.
+        from streamlit import context as st_context
+
+        # See Snowflake docs:
+        # https://docs.snowflake.com/en/developer-guide/snowpark-container-services/additional-considerations-services-jobs#configuring-caller-s-rights-for-your-service
+
+        # Base parameters, common to all connections.
+        params: dict[str, str | bool] = {
+            "authenticator": "oauth",
+            # OCSP checks do not work in Snowflake containers.
+            "ocsp_fail_open": True,
+            # We want to keep this alive, as the user token will expire fairly quickly
+            # - so we can't create a new session on expiration.
+            "client_session_keep_alive": True,
+        }
+        for param_name, env_var_name in (
+            ("account", "SNOWFLAKE_ACCOUNT"),
+            ("host", "SNOWFLAKE_HOST"),
+            ("database", "SNOWFLAKE_DATABASE"),
+            ("schema", "SNOWFLAKE_SCHEMA"),
+        ):
+            value = os.getenv(env_var_name)
+            if value is None:
+                raise StreamlitAPIException(
+                    f"Environment variable `{env_var_name}` not found. Is this app "
+                    "running in a Snowflake container environment?"
+                )
+            params[param_name] = value
+
+        # Validate the token file exists, and read it.
+        if not os.path.exists(SNOWPARK_CONNECTION_TOKEN_FILE):
+            raise StreamlitAPIException(
+                f"Token file `{SNOWPARK_CONNECTION_TOKEN_FILE}` not found. Is this app "
+                "running in a Snowflake container environment?"
+            )
+        login_token = cls._read_token_file()
+
+        # Validate the token header exists, and read it.
+        if SNOWPARK_USER_TOKEN_HEADER_NAME not in st_context.headers:
+            raise StreamlitAPIException(
+                "Token header not found. Is this app running with caller's "
+                "rights enabled, and is this connection being created in an app "
+                "execution thread?"
+            )
+        user_token = st_context.headers[SNOWPARK_USER_TOKEN_HEADER_NAME]
+
+        # Build the actual caller's rights token.
+        params["token"] = f"{login_token}.{user_token}"
+
+        return params
+
+    def _connect(self, **kwargs: Any) -> InternalSnowflakeConnection:
+        import snowflake.connector  # type:ignore[import]
+
+        # We require qmark-style parameters everywhere for consistency across different
+        # environments where SnowflakeConnections may be used.
+        snowflake.connector.paramstyle = "qmark"
+
+        params = self._get_connection_params()
+
+        # Connect with the params we generated, overriding with user-specified params.
+        return snowflake.connector.connect(**{**params, **kwargs})

{streamlit_nightly-1.52.3.dev20260106 → streamlit_nightly-1.52.3.dev20260108}/streamlit/elements/widgets/number_input.py

@@ -452,9 +452,7 @@ class NumberInputMixin:
         element_id = compute_and_register_element_id(
             "number_input",
             user_key=key,
-            # Ensure stable ID when key is provided; explicitly whitelist parameters
-            # that might invalidate the current widget state.
-            key_as_main_identity={"min_value", "max_value", "step"},
+            key_as_main_identity=True,
             dg=self.dg,
             label=label,
             min_value=min_value,
@@ -630,26 +628,31 @@ class NumberInputMixin:
             value_type="double_value",
         )
 
-        if widget_state.value_changed:
-            if widget_state.value is not None:
-                # Min/Max bounds checks when the value is updated.
-                if (
-                    number_input_proto.has_min
-                    and widget_state.value < number_input_proto.min
-                ):
-                    raise StreamlitValueBelowMinError(
-                        value=widget_state.value, min_value=number_input_proto.min
-                    )
-
-                if (
-                    number_input_proto.has_max
-                    and widget_state.value > number_input_proto.max
-                ):
-                    raise StreamlitValueAboveMaxError(
-                        value=widget_state.value, max_value=number_input_proto.max
-                    )
-
-                number_input_proto.value = widget_state.value
+        # Validate the current value against the new min/max bounds.
+        # If the value is no longer valid (outside bounds), reset to default.
+        # This handles the case where min_value/max_value change dynamically and the
+        # previously entered value is no longer within bounds.
+        current_value = widget_state.value
+        value_needs_reset = False
+
+        # Check if the current value is outside the new bounds.
+        if current_value is not None and (
+            (number_input_proto.has_min and current_value < number_input_proto.min)
+            or (number_input_proto.has_max and current_value > number_input_proto.max)
+        ):
+            # Value is outside new bounds - reset to default.
+            value_needs_reset = True
+            current_value = value
+
+            # Update session_state so subsequent accesses in this run
+            # return the corrected value. Use reset_state_value to avoid
+            # the "cannot be modified after widget instantiated" error.
+            if key is not None:
+                get_session_state().reset_state_value(key, current_value)
+
+        if value_needs_reset or widget_state.value_changed:
+            if current_value is not None:
+                number_input_proto.value = current_value
             number_input_proto.set_value = True
 
         validate_width(width)
@@ -658,7 +661,7 @@ class NumberInputMixin:
         self.dg._enqueue(
             "number_input", number_input_proto, layout_config=layout_config
         )
-        return widget_state.value
+        return current_value
 
     @property
     def dg(self) -> DeltaGenerator: