streamlit-nightly 1.52.3.dev20260106__py3-none-any.whl → 1.52.3.dev20260107__py3-none-any.whl

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/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/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/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/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:

streamlit/errors.py

@@ -476,18 +476,6 @@ class BidiComponentInvalidIdError(LocalizableStreamlitException):
         )
 
 
-class BidiComponentMissingContentError(LocalizableStreamlitException):
-    """Exception raised when a component is missing required content."""
-
-    def __init__(self, component_name: str) -> None:
-        super().__init__(
-            "Component `{component_name}` must have either JavaScript content "
-            "(`js_content` or `js_url`) or HTML content (`html_content`), or both. "
-            "Please ensure the component definition includes at least one of these.",
-            component_name=component_name,
-        )
-
-
 class BidiComponentInvalidCallbackNameError(LocalizableStreamlitException):
     """Exception raised when a callback with an invalid name is provided."""
 

streamlit/runtime/context.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 from collections.abc import Iterable, Iterator, Mapping
 from functools import lru_cache
 from types import MappingProxyType
-from typing import TYPE_CHECKING, Any, Literal, cast
+from typing import TYPE_CHECKING, Any, Literal
 
 from streamlit import runtime
 from streamlit.runtime.context_util import maybe_add_page_path, maybe_trim_page_path
@@ -28,11 +28,18 @@ from streamlit.util import AttributeDictionary
 if TYPE_CHECKING:
     from http.cookies import Morsel
 
-    from tornado.httputil import HTTPHeaders, HTTPServerRequest
-    from tornado.web import RequestHandler
+    from tornado.httputil import HTTPHeaders
 
+    from streamlit.runtime.session_manager import ClientContext
 
-def _get_request() -> HTTPServerRequest | None:
+
+def _get_client_context() -> ClientContext | None:
+    """Get the ClientContext for the current session.
+
+    Returns the client context from the session client if available,
+    or None if not available (e.g., no active session or the session
+    client doesn't provide a client context).
+    """
     ctx = get_script_run_ctx()
     if ctx is None:
         return None
@@ -41,17 +48,7 @@ def _get_request() -> HTTPServerRequest | None:
     if session_client is None:
         return None
 
-    # We return websocket request only if session_client is an instance of
-    # BrowserWebSocketHandler (which is True for the Streamlit open-source
-    # implementation). For any other implementation, we return None.
-    # We are not using `type_util.is_type` here to avoid circular import.
-    if (
-        f"{type(session_client).__module__}.{type(session_client).__qualname__}"
-        != "streamlit.web.server.browser_websocket_handler.BrowserWebSocketHandler"
-    ):
-        return None
-
-    return cast("RequestHandler", session_client).request
+    return session_client.client_context
 
 
 @lru_cache
@@ -195,12 +192,12 @@ class ContextProxy:
         """
         # We have a docstring in line above as one-liner, to have a correct docstring
         # in the st.write(st,context) call.
-        session_client_request = _get_request()
+        client_context = _get_client_context()
 
-        if session_client_request is None:
+        if client_context is None:
             return StreamlitHeaders({})
 
-        return StreamlitHeaders.from_tornado_headers(session_client_request.headers)
+        return StreamlitHeaders(client_context.headers)
 
     @property
     @gather_metrics("context.cookies")
@@ -228,13 +225,12 @@ class ContextProxy:
         """
         # We have a docstring in line above as one-liner, to have a correct docstring
         # in the st.write(st,context) call.
-        session_client_request = _get_request()
+        client_context = _get_client_context()
 
-        if session_client_request is None:
+        if client_context is None:
             return StreamlitCookies({})
 
-        cookies = session_client_request.cookies
-        return StreamlitCookies.from_tornado_cookies(cookies)
+        return StreamlitCookies(client_context.cookies)
 
     @property
     @gather_metrics("context.theme")
@@ -399,11 +395,7 @@ class ContextProxy:
         This should not be used for security measures because it can easily be
         spoofed. When a user accesses the app through ``localhost``, the IP
         address is ``None``. Otherwise, the IP address is determined from the
-        |remote_ip|_ attribute of the Tornado request object and may be an
-        IPv4 or IPv6 address.
-
-        .. |remote_ip| replace:: ``remote_ip``
-        .. _remote_ip: https://www.tornadoweb.org/en/stable/httputil.html#tornado.httputil.HTTPServerRequest.remote_ip
+        WebSocket connection and may be an IPv4 or IPv6 address.
 
         Example
         -------
@@ -421,9 +413,9 @@ class ContextProxy:
         >>> else:
         >>>     st.error("This should not happen.")
         """
-        session_client_request = _get_request()
-        if session_client_request is not None:
-            remote_ip = session_client_request.remote_ip
+        client_context = _get_client_context()
+        if client_context is not None:
+            remote_ip = client_context.remote_ip
             if remote_ip in {"::1", "127.0.0.1"}:
                 return None
             return remote_ip

streamlit/runtime/session_manager.py

@@ -16,10 +16,10 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Protocol, cast
+from typing import TYPE_CHECKING, Protocol, cast, runtime_checkable
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
+    from collections.abc import Callable, Iterable, Mapping
 
     from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
     from streamlit.runtime.app_session import AppSession
@@ -33,6 +33,31 @@ class SessionClientDisconnectedError(Exception):
     """Raised by operations on a disconnected SessionClient."""
 
 
+@runtime_checkable
+class ClientContext(Protocol):
+    """Framework-agnostic context for the client WebSocket connection.
+
+    This protocol abstracts away framework-specific request types (Tornado/Starlette)
+    to provide a consistent interface for accessing headers, cookies, and client info
+    from the initial WebSocket handshake.
+    """
+
+    @property
+    def headers(self) -> Iterable[tuple[str, str]]:
+        """All headers as (name, value) tuples. Headers may be repeated."""
+        ...
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        """Cookies as a name-to-value mapping."""
+        ...
+
+    @property
+    def remote_ip(self) -> str | None:
+        """The remote IP address of the client, or None if unavailable."""
+        ...
+
+
 class SessionClient(Protocol):
     """Interface for sending data to a session's client."""
 
@@ -45,6 +70,14 @@ class SessionClient(Protocol):
         """
         raise NotImplementedError
 
+    @property
+    def client_context(self) -> ClientContext | None:
+        """The client's connection context (headers, cookies, IP).
+
+        Returns None if request context information is not available.
+        """
+        return None
+
 
 @dataclass
 class ActiveSessionInfo:

streamlit/web/server/browser_websocket_handler.py

@@ -19,10 +19,6 @@ import json
 from typing import TYPE_CHECKING, Any, Final
 from urllib.parse import urlparse
 
-import tornado.concurrent
-import tornado.locks
-import tornado.netutil
-import tornado.web
 import tornado.websocket
 from tornado.escape import utf8
 from tornado.websocket import WebSocketHandler
@@ -33,6 +29,7 @@ from streamlit.logger import get_logger
 from streamlit.proto.BackMsg_pb2 import BackMsg
 from streamlit.runtime import Runtime, SessionClient, SessionClientDisconnectedError
 from streamlit.runtime.runtime_util import serialize_forward_msg
+from streamlit.runtime.session_manager import ClientContext
 from streamlit.web.server.server_util import (
     AUTH_COOKIE_NAME,
     TOKENS_COOKIE_NAME,
@@ -41,13 +38,46 @@ from streamlit.web.server.server_util import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable
+    from collections.abc import Awaitable, Iterable, Mapping
+
+    from tornado.httputil import HTTPServerRequest
 
     from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 
 _LOGGER: Final = get_logger(__name__)
 
 
+class TornadoClientContext(ClientContext):
+    """Tornado-specific implementation of ClientContext.
+
+    Captures headers, cookies, and client info from the initial WebSocket handshake.
+    Values are cached at construction time since they represent the initial request
+    context and should not change during the connection lifetime.
+    """
+
+    def __init__(self, tornado_request: HTTPServerRequest) -> None:
+        self._headers: list[tuple[str, str]] = list(tornado_request.headers.get_all())
+        self._cookies: dict[str, str] = {
+            k: m.value for k, m in tornado_request.cookies.items()
+        }
+        self._remote_ip: str | None = tornado_request.remote_ip
+
+    @property
+    def headers(self) -> Iterable[tuple[str, str]]:
+        """All headers as (name, value) tuples."""
+        return self._headers
+
+    @property
+    def cookies(self) -> Mapping[str, str]:
+        """Cookies as a name-to-value mapping."""
+        return self._cookies
+
+    @property
+    def remote_ip(self) -> str | None:
+        """The client's remote IP address."""
+        return self._remote_ip
+
+
 class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
     """Handles a WebSocket connection from the browser."""
 
@@ -143,6 +173,19 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
         except tornado.websocket.WebSocketClosedError as e:
             raise SessionClientDisconnectedError from e
 
+    @property
+    def client_context(self) -> ClientContext:
+        """Return the client's connection context.
+
+        The context is cached on first access to avoid repeatedly
+        constructing a new TornadoClientContext instance.
+        """
+        context = getattr(self, "_client_context", None)
+        if context is None:
+            context = TornadoClientContext(self.request)
+            self._client_context = context
+        return context
+
     def select_subprotocol(self, subprotocols: list[str]) -> str | None:
         """Return the first subprotocol in the given list.