streamlit-nightly 1.43.2.dev20250307__py3-none-any.whl

streamlit/runtime/context.py

@@ -0,0 +1,280 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+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, cast
+
+from streamlit import runtime
+from streamlit.runtime.metrics_util import gather_metrics
+from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+
+if TYPE_CHECKING:
+    from http.cookies import Morsel
+
+    from tornado.httputil import HTTPHeaders, HTTPServerRequest
+    from tornado.web import RequestHandler
+
+
+def _get_request() -> HTTPServerRequest | None:
+    ctx = get_script_run_ctx()
+    if ctx is None:
+        return None
+
+    session_client = runtime.get_instance().get_client(ctx.session_id)
+    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
+
+
+@lru_cache
+def _normalize_header(name: str) -> str:
+    """Map a header name to Http-Header-Case.
+
+    >>> _normalize_header("coNtent-TYPE")
+    'Content-Type'
+    """
+    return "-".join(w.capitalize() for w in name.split("-"))
+
+
+class StreamlitHeaders(Mapping[str, str]):
+    def __init__(self, headers: Iterable[tuple[str, str]]):
+        dict_like_headers: dict[str, list[str]] = {}
+
+        for key, value in headers:
+            header_value = dict_like_headers.setdefault(_normalize_header(key), [])
+            header_value.append(value)
+
+        self._headers = dict_like_headers
+
+    @classmethod
+    def from_tornado_headers(cls, tornado_headers: HTTPHeaders) -> StreamlitHeaders:
+        return cls(tornado_headers.get_all())
+
+    def get_all(self, key: str) -> list[str]:
+        return list(self._headers.get(_normalize_header(key), []))
+
+    def __getitem__(self, key: str) -> str:
+        try:
+            return self._headers[_normalize_header(key)][0]
+        except LookupError:
+            raise KeyError(key) from None
+
+    def __len__(self) -> int:
+        """Number of unique headers present in request."""
+        return len(self._headers)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._headers)
+
+    def to_dict(self) -> dict[str, str]:
+        return {key: self[key] for key in self}
+
+
+class StreamlitCookies(Mapping[str, str]):
+    def __init__(self, cookies: Mapping[str, str]):
+        self._cookies = MappingProxyType(cookies)
+
+    @classmethod
+    def from_tornado_cookies(
+        cls, tornado_cookies: dict[str, Morsel[Any]]
+    ) -> StreamlitCookies:
+        dict_like_cookies = {}
+        for key, morsel in tornado_cookies.items():
+            dict_like_cookies[key] = morsel.value
+        return cls(dict_like_cookies)
+
+    def __getitem__(self, key: str) -> str:
+        return self._cookies[key]
+
+    def __len__(self) -> int:
+        """Number of unique headers present in request."""
+        return len(self._cookies)
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._cookies)
+
+    def to_dict(self) -> dict[str, str]:
+        return dict(self._cookies)
+
+
+class ContextProxy:
+    """An interface to access user session context.
+
+    ``st.context`` provides a read-only interface to access headers and cookies
+    for the current user session.
+
+    Each property (``st.context.headers`` and ``st.context.cookies``) returns
+    a dictionary of named values.
+
+    """
+
+    @property
+    @gather_metrics("context.headers")
+    def headers(self) -> StreamlitHeaders:
+        """A read-only, dict-like object containing headers sent in the initial request.
+
+        Keys are case-insensitive and may be repeated. When keys are repeated,
+        dict-like methods will only return the last instance of each key. Use
+        ``.get_all(key="your_repeated_key")`` to see all values if the same
+        header is set multiple times.
+
+        Examples
+        --------
+        **Example 1: Access all available headers**
+
+        Show a dictionary of headers (with only the last instance of any
+        repeated key):
+
+        >>> import streamlit as st
+        >>>
+        >>> st.context.headers
+
+        **Example 2: Access a specific header**
+
+        Show the value of a specific header (or the last instance if it's
+        repeated):
+
+        >>> import streamlit as st
+        >>>
+        >>> st.context.headers["host"]
+
+        Show of list of all headers for a given key:
+
+        >>> import streamlit as st
+        >>>
+        >>> st.context.headers.get_all("pragma")
+
+        """
+        # 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()
+
+        if session_client_request is None:
+            return StreamlitHeaders({})
+
+        return StreamlitHeaders.from_tornado_headers(session_client_request.headers)
+
+    @property
+    @gather_metrics("context.cookies")
+    def cookies(self) -> StreamlitCookies:
+        """A read-only, dict-like object containing cookies sent in the initial request.
+
+        Examples
+        --------
+        **Example 1: Access all available cookies**
+
+        Show a dictionary of cookies:
+
+        >>> import streamlit as st
+        >>>
+        >>> st.context.cookies
+
+        **Example 2: Access a specific cookie**
+
+        Show the value of a specific cookie:
+
+        >>> import streamlit as st
+        >>>
+        >>> st.context.cookies["_ga"]
+
+        """
+        # 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()
+
+        if session_client_request is None:
+            return StreamlitCookies({})
+
+        cookies = session_client_request.cookies
+        return StreamlitCookies.from_tornado_cookies(cookies)
+
+    @property
+    @gather_metrics("context.timezone")
+    def timezone(self) -> str | None:
+        """The read-only timezone of the user's browser.
+
+        Example
+        -------
+        Access the user's timezone, and format a datetime to display locally:
+
+        >>> import streamlit as st
+        >>> from datetime import datetime, timezone
+        >>> import pytz
+        >>>
+        >>> tz = st.context.timezone
+        >>> tz_obj = pytz.timezone(tz)
+        >>>
+        >>> now = datetime.now(timezone.utc)
+        >>>
+        >>> f"The user's timezone is {tz}."
+        >>> f"The UTC time is {now}."
+        >>> f"The user's local time is {now.astimezone(tz_obj)}"
+
+        """
+        ctx = get_script_run_ctx()
+
+        if ctx is None or ctx.context_info is None:
+            return None
+        return ctx.context_info.timezone
+
+    @property
+    @gather_metrics("context.timezone_offset")
+    def timezone_offset(self) -> int | None:
+        """The read-only timezone offset of the user's browser.
+
+        Example
+        -------
+        Access the user's timezone offset, and format a datetime to display locally:
+
+        >>> import streamlit as st
+        >>> from datetime import datetime, timezone, timedelta
+        >>>
+        >>> tzoff = st.context.timezone_offset
+        >>> tz_obj = timezone(-timedelta(minutes=tzoff))
+        >>>
+        >>> now = datetime.now(timezone.utc)
+        >>>
+        >>> f"The user's timezone is {tz}."
+        >>> f"The UTC time is {now}."
+        >>> f"The user's local time is {now.astimezone(tz_obj)}"
+
+        """
+        ctx = get_script_run_ctx()
+        if ctx is None or ctx.context_info is None:
+            return None
+        return ctx.context_info.timezone_offset
+
+    @property
+    @gather_metrics("context.locale")
+    def locale(self) -> str | None:
+        """The locale of the user browser, read-only"""
+        ctx = get_script_run_ctx()
+        if ctx is None or ctx.context_info is None:
+            return None
+        return ctx.context_info.locale

streamlit/runtime/credentials.py

@@ -0,0 +1,364 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Manage the user's Streamlit credentials."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import textwrap
+from typing import Final, NamedTuple, NoReturn
+from uuid import uuid4
+
+from streamlit import cli_util, env_util, file_util, util
+from streamlit.logger import get_logger
+
+_LOGGER: Final = get_logger(__name__)
+
+
+if env_util.IS_WINDOWS:
+    _CONFIG_FILE_PATH = r"%userprofile%/.streamlit/config.toml"
+else:
+    _CONFIG_FILE_PATH = "~/.streamlit/config.toml"
+
+
+class _Activation(NamedTuple):
+    email: str | None  # the user's email.
+    is_valid: bool  # whether the email is valid.
+
+
+def email_prompt() -> str:
+    # Emoji can cause encoding errors on non-UTF-8 terminals
+    # (See https://github.com/streamlit/streamlit/issues/2284.)
+    # WT_SESSION is a Windows Terminal specific environment variable. If it exists,
+    # we are on the latest Windows Terminal that supports emojis
+    show_emoji = sys.stdout.encoding == "utf-8" and (
+        not env_util.IS_WINDOWS or os.environ.get("WT_SESSION")
+    )
+
+    # IMPORTANT: Break the text below at 80 chars.
+    return f"""
+      {"👋 " if show_emoji else ""}{cli_util.style_for_cli("Welcome to Streamlit!", bold=True)}
+
+      If you’d like to receive helpful onboarding emails, news, offers, promotions,
+      and the occasional swag, please enter your email address below. Otherwise,
+      leave this field blank.
+
+      {cli_util.style_for_cli("Email: ", fg="blue")}"""
+
+
+_TELEMETRY_HEADLESS_TEXT = """
+Collecting usage statistics. To deactivate, set browser.gatherUsageStats to false.
+"""
+
+
+def _send_email(email: str) -> None:
+    """Send the user's email for metrics, if submitted"""
+    import requests
+
+    if email is None or "@" not in email:
+        return
+
+    metrics_url = ""
+    try:
+        response_json = requests.get(
+            "https://data.streamlit.io/metrics.json", timeout=2
+        ).json()
+        metrics_url = response_json.get("url", "")
+    except Exception:
+        _LOGGER.error("Failed to fetch metrics URL")
+        return
+
+    headers = {
+        "accept": "*/*",
+        "accept-language": "en-US,en;q=0.9",
+        "content-type": "application/json",
+        "origin": "localhost:8501",
+        "referer": "localhost:8501/",
+    }
+
+    data = {
+        "anonymous_id": None,
+        "messageId": str(uuid4()),
+        "event": "submittedEmail",
+        "author_email": email,
+        "source": "provided_email",
+        "type": "track",
+        "userId": email,
+    }
+
+    response = requests.post(
+        metrics_url,
+        headers=headers,
+        data=json.dumps(data).encode(),
+    )
+
+    response.raise_for_status()
+
+
+class Credentials:
+    """Credentials class."""
+
+    _singleton: Credentials | None = None
+
+    @classmethod
+    def get_current(cls):
+        """Return the singleton instance."""
+        if cls._singleton is None:
+            Credentials()
+
+        return Credentials._singleton
+
+    def __init__(self):
+        """Initialize class."""
+        if Credentials._singleton is not None:
+            raise RuntimeError(
+                "Credentials already initialized. Use .get_current() instead"
+            )
+
+        self.activation = None
+        self._conf_file = _get_credential_file_path()
+
+        Credentials._singleton = self
+
+    def __repr__(self) -> str:
+        return util.repr_(self)
+
+    def load(self, auto_resolve: bool = False) -> None:
+        """Load from toml file."""
+        if self.activation is not None:
+            _LOGGER.error("Credentials already loaded. Not rereading file.")
+            return
+
+        import toml
+
+        try:
+            with open(self._conf_file) as f:
+                data = toml.load(f).get("general")
+            if data is None:
+                raise Exception
+            self.activation = _verify_email(data.get("email"))
+        except FileNotFoundError:
+            if auto_resolve:
+                self.activate(show_instructions=not auto_resolve)
+                return
+            raise RuntimeError(
+                'Credentials not found. Please run "streamlit activate".'
+            )
+        except Exception:
+            if auto_resolve:
+                self.reset()
+                self.activate(show_instructions=not auto_resolve)
+                return
+            raise Exception(
+                textwrap.dedent(
+                    """
+                Unable to load credentials from %s.
+                Run "streamlit reset" and try again.
+                """
+                )
+                % (self._conf_file)
+            )
+
+    def _check_activated(self, auto_resolve: bool = True) -> None:
+        """Check if streamlit is activated.
+
+        Used by `streamlit run script.py`
+        """
+        try:
+            self.load(auto_resolve)
+        except (Exception, RuntimeError) as e:
+            _exit(str(e))
+
+        if self.activation is None or not self.activation.is_valid:
+            _exit("Activation email not valid.")
+
+    @classmethod
+    def reset(cls) -> None:
+        """Reset credentials by removing file.
+
+        This is used by `streamlit activate reset` in case a user wants
+        to start over.
+        """
+        c = Credentials.get_current()
+        c.activation = None
+
+        try:
+            os.remove(c._conf_file)
+        except OSError:
+            _LOGGER.exception("Error removing credentials file.")
+
+    def save(self) -> None:
+        """Save to toml file and send email."""
+        from requests.exceptions import RequestException
+
+        if self.activation is None:
+            return
+
+        # Create intermediate directories if necessary
+        os.makedirs(os.path.dirname(self._conf_file), exist_ok=True)
+
+        # Write the file
+        data = {"email": self.activation.email}
+
+        import toml
+
+        with open(self._conf_file, "w") as f:
+            toml.dump({"general": data}, f)
+
+        try:
+            _send_email(self.activation.email)
+        except RequestException:
+            _LOGGER.exception("Error saving email:")
+
+    def activate(self, show_instructions: bool = True) -> None:
+        """Activate Streamlit.
+
+        Used by `streamlit activate`.
+        """
+        try:
+            self.load()
+        except RuntimeError:
+            # Runtime Error is raised if credentials file is not found. In that case,
+            # `self.activation` is None and we will show the activation prompt below.
+            pass
+
+        if self.activation:
+            if self.activation.is_valid:
+                _exit("Already activated")
+            else:
+                _exit(
+                    "Activation not valid. Please run "
+                    "`streamlit activate reset` then `streamlit activate`"
+                )
+        else:
+            activated = False
+
+            while not activated:
+                import click
+
+                email = click.prompt(
+                    text=email_prompt(),
+                    prompt_suffix="",
+                    default="",
+                    show_default=False,
+                )
+
+                self.activation = _verify_email(email)
+                if self.activation.is_valid:
+                    self.save()
+                    # IMPORTANT: Break the text below at 80 chars.
+                    TELEMETRY_TEXT = """
+  You can find our privacy policy at %(link)s
+
+  Summary:
+  - This open source library collects usage statistics.
+  - We cannot see and do not store information contained inside Streamlit apps,
+    such as text, charts, images, etc.
+  - Telemetry data is stored in servers in the United States.
+  - If you'd like to opt out, add the following to %(config)s,
+    creating that file if necessary:
+
+    [browser]
+    gatherUsageStats = false
+""" % {
+                        "link": cli_util.style_for_cli(
+                            "https://streamlit.io/privacy-policy", underline=True
+                        ),
+                        "config": cli_util.style_for_cli(_CONFIG_FILE_PATH),
+                    }
+
+                    cli_util.print_to_cli(TELEMETRY_TEXT)
+                    if show_instructions:
+                        # IMPORTANT: Break the text below at 80 chars.
+                        INSTRUCTIONS_TEXT = """
+  %(start)s
+  %(prompt)s %(hello)s
+""" % {
+                            "start": cli_util.style_for_cli(
+                                "Get started by typing:", fg="blue", bold=True
+                            ),
+                            "prompt": cli_util.style_for_cli("$", fg="blue"),
+                            "hello": cli_util.style_for_cli(
+                                "streamlit hello", bold=True
+                            ),
+                        }
+
+                        cli_util.print_to_cli(INSTRUCTIONS_TEXT)
+                    activated = True
+                else:  # pragma: nocover
+                    _LOGGER.error("Please try again.")
+
+
+def _verify_email(email: str) -> _Activation:
+    """Verify the user's email address.
+
+    The email can either be an empty string (if the user chooses not to enter
+    it), or a string with a single '@' somewhere in it.
+
+    Parameters
+    ----------
+    email : str
+
+    Returns
+    -------
+    _Activation
+        An _Activation object. Its 'is_valid' property will be True only if
+        the email was validated.
+
+    """
+    email = email.strip()
+
+    # We deliberately use simple email validation here
+    # since we do not use email address anywhere to send emails.
+    if len(email) > 0 and email.count("@") != 1:
+        _LOGGER.error("That doesn't look like an email :(")
+        return _Activation(None, False)
+
+    return _Activation(email, True)
+
+
+def _exit(message: str) -> NoReturn:
+    """Exit program with error."""
+    _LOGGER.error(message)
+    sys.exit(-1)
+
+
+def _get_credential_file_path() -> str:
+    return file_util.get_streamlit_file_path("credentials.toml")
+
+
+def _check_credential_file_exists() -> bool:
+    return os.path.exists(_get_credential_file_path())
+
+
+def check_credentials() -> None:
+    """Check credentials and potentially activate.
+
+    Note
+    ----
+    If there is no credential file and we are in headless mode, we should not
+    check, since credential would be automatically set to an empty string.
+
+    """
+    from streamlit import config
+
+    if not _check_credential_file_exists() and config.get_option("server.headless"):
+        if not config.is_manually_set("browser.gatherUsageStats"):
+            # If not manually defined, show short message about usage stats gathering.
+            cli_util.print_to_cli(_TELEMETRY_HEADLESS_TEXT)
+        return
+    Credentials.get_current()._check_activated()