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

streamlit/__init__.py

@@ -0,0 +1,306 @@
+# 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.
+
+# isort: skip_file
+
+"""Streamlit.
+
+How to use Streamlit in 3 seconds:
+
+    1. Write an app
+    >>> import streamlit as st
+    >>> st.write(anything_you_want)
+
+    2. Run your app
+    $ streamlit run my_script.py
+
+    3. Use your app
+    A new tab will open on your browser. That's your Streamlit app!
+
+    4. Modify your code, save it, and watch changes live on your browser.
+
+Take a look at the other commands in this module to find out what else
+Streamlit can do:
+
+    >>> dir(streamlit)
+
+Or try running our "Hello World":
+
+    $ streamlit hello
+
+For more detailed info, see https://docs.streamlit.io.
+"""
+
+# IMPORTANT: Prefix with an underscore anything that the user shouldn't see.
+
+import os as _os
+
+# Set Matplotlib backend to avoid a crash.
+# The default Matplotlib backend crashes Python on OSX when run on a thread
+# that's not the main thread, so here we set a safer backend as a fix.
+# This fix is OS-independent. We didn't see a good reason to make this
+# Mac-only. Consistency within Streamlit seemed more important.
+# IMPORTANT: This needs to run on top of all imports before any other
+# import of matplotlib could happen.
+_os.environ["MPLBACKEND"] = "Agg"
+
+
+# Must be at the top, to avoid circular dependency.
+from streamlit import logger as _logger
+from streamlit import config as _config
+from streamlit.deprecation_util import deprecate_func_name as _deprecate_func_name
+from streamlit.version import STREAMLIT_VERSION_STRING as _STREAMLIT_VERSION_STRING
+
+# Give the package a version.
+__version__ = _STREAMLIT_VERSION_STRING
+
+# DeltaGenerator methods:
+# We initialize them here so that it is clear where they are instantiated.
+# Further, it helps us to break circular imports because the DeltaGenerator
+# imports the different elements but some elements also require DeltaGenerator
+# functions such as the dg_stack. Now, elements that require DeltaGenerator functions
+# can import the singleton module.
+from streamlit.delta_generator_singletons import (
+    DeltaGeneratorSingleton as _DeltaGeneratorSingleton,
+)
+from streamlit.delta_generator import DeltaGenerator as _DeltaGenerator
+from streamlit.elements.lib.mutable_status_container import (
+    StatusContainer as _StatusContainer,
+)
+from streamlit.elements.lib.dialog import Dialog as _Dialog
+
+# instantiate the DeltaGeneratorSingleton
+_dg_singleton = _DeltaGeneratorSingleton(
+    delta_generator_cls=_DeltaGenerator,
+    status_container_cls=_StatusContainer,
+    dialog_container_cls=_Dialog,
+)
+_main = _dg_singleton._main_dg
+sidebar = _dg_singleton._sidebar_dg
+_event = _dg_singleton._event_dg
+_bottom = _dg_singleton._bottom_dg
+
+
+from streamlit.elements.dialog_decorator import (
+    dialog_decorator as _dialog_decorator,
+    experimental_dialog_decorator as _experimental_dialog_decorator,
+)
+from streamlit.runtime.caching import (
+    cache_resource as _cache_resource,
+    cache_data as _cache_data,
+    cache as _cache,
+)
+from streamlit.runtime.connection_factory import (
+    connection_factory as _connection,
+)
+from streamlit.runtime.fragment import (
+    experimental_fragment as _experimental_fragment,
+    fragment as _fragment,
+)
+from streamlit.runtime.metrics_util import gather_metrics as _gather_metrics
+from streamlit.runtime.secrets import secrets_singleton as _secrets_singleton
+from streamlit.runtime.context import ContextProxy as _ContextProxy
+from streamlit.runtime.state import (
+    SessionStateProxy as _SessionStateProxy,
+    QueryParamsProxy as _QueryParamsProxy,
+)
+from streamlit.user_info import (
+    UserInfoProxy as _UserInfoProxy,
+    login as _login,
+    logout as _logout,
+)
+from streamlit.commands.experimental_query_params import (
+    get_query_params as _get_query_params,
+    set_query_params as _set_query_params,
+)
+
+import streamlit.column_config as _column_config
+
+# Modules that the user should have access to. These are imported with the "as" syntax
+# and the same name; note that renaming the import with "as" does not make it an
+# explicit export. In this case, you should import it with an underscore to make clear
+# that it is internal and then assign it to a variable with the new intended name.
+# You can check the export behavior by running 'mypy --strict example_app.py', which
+# disables implicit_reexport, where you use the respective command in the example_app.py
+# Streamlit app.
+
+from streamlit.commands.echo import echo as echo
+from streamlit.commands.logo import logo as logo
+from streamlit.commands.navigation import navigation as navigation
+from streamlit.navigation.page import Page as Page
+from streamlit.elements.spinner import spinner as spinner
+
+from streamlit.commands.page_config import set_page_config as set_page_config
+from streamlit.commands.execution_control import (
+    stop as stop,
+    rerun as rerun,
+    switch_page as switch_page,
+)
+
+
+def _update_logger() -> None:
+    _logger.set_log_level(_config.get_option("logger.level").upper())
+    _logger.update_formatter()
+    _logger.init_tornado_logs()
+
+
+# Make this file only depend on config option in an asynchronous manner. This
+# avoids a race condition when another file (such as a test file) tries to pass
+# in an alternative config.
+_config.on_config_parsed(_update_logger, True)
+
+secrets = _secrets_singleton
+
+altair_chart = _main.altair_chart
+area_chart = _main.area_chart
+audio = _main.audio
+audio_input = _main.audio_input
+balloons = _main.balloons
+bar_chart = _main.bar_chart
+bokeh_chart = _main.bokeh_chart
+button = _main.button
+caption = _main.caption
+camera_input = _main.camera_input
+chat_message = _main.chat_message
+chat_input = _main.chat_input
+checkbox = _main.checkbox
+code = _main.code
+columns = _main.columns
+tabs = _main.tabs
+container = _main.container
+dataframe = _main.dataframe
+data_editor = _main.data_editor
+date_input = _main.date_input
+divider = _main.divider
+download_button = _main.download_button
+expander = _main.expander
+feedback = _main.feedback
+pydeck_chart = _main.pydeck_chart
+empty = _main.empty
+error = _main.error
+exception = _main.exception
+file_uploader = _main.file_uploader
+form = _main.form
+form_submit_button = _main.form_submit_button
+graphviz_chart = _main.graphviz_chart
+header = _main.header
+help = _main.help
+html = _main.html
+image = _main.image
+info = _main.info
+json = _main.json
+latex = _main.latex
+line_chart = _main.line_chart
+link_button = _main.link_button
+map = _main.map
+markdown = _main.markdown
+metric = _main.metric
+multiselect = _main.multiselect
+number_input = _main.number_input
+page_link = _main.page_link
+pills = _main.pills
+plotly_chart = _main.plotly_chart
+popover = _main.popover
+progress = _main.progress
+pyplot = _main.pyplot
+radio = _main.radio
+scatter_chart = _main.scatter_chart
+selectbox = _main.selectbox
+select_slider = _main.select_slider
+segmented_control = _main.segmented_control
+slider = _main.slider
+snow = _main.snow
+subheader = _main.subheader
+success = _main.success
+table = _main.table
+text = _main.text
+text_area = _main.text_area
+text_input = _main.text_input
+toggle = _main.toggle
+time_input = _main.time_input
+title = _main.title
+vega_lite_chart = _main.vega_lite_chart
+video = _main.video
+warning = _main.warning
+write = _main.write
+write_stream = _main.write_stream
+color_picker = _main.color_picker
+status = _main.status
+
+# Events - Note: these methods cannot be called directly on sidebar
+# (ex: st.sidebar.toast)
+toast = _event.toast
+
+# Config
+# We add the metrics tracking here, since importing
+# gather_metrics in config causes a circular dependency
+get_option = _gather_metrics("get_option", _config.get_option)
+set_option = _gather_metrics("set_option", _config.set_user_option)
+
+# Session State
+session_state = _SessionStateProxy()
+
+query_params = _QueryParamsProxy()
+
+context = _ContextProxy()
+
+# Caching
+cache_data = _cache_data
+cache_resource = _cache_resource
+# `st.cache` is deprecated and should be removed soon
+cache = _cache
+
+# Namespaces
+column_config = _column_config
+
+# Connection
+connection = _connection
+
+# Fragment and dialog
+dialog = _dialog_decorator
+fragment = _fragment
+
+
+# Auth
+login = _login
+logout = _logout
+
+# Experimental APIs
+experimental_audio_input = _main.experimental_audio_input
+experimental_dialog = _experimental_dialog_decorator
+experimental_fragment = _experimental_fragment
+experimental_user = _UserInfoProxy()
+
+_EXPERIMENTAL_QUERY_PARAMS_DEPRECATE_MSG = "Refer to our [docs page](https://docs.streamlit.io/develop/api-reference/caching-and-state/st.query_params) for more information."
+
+experimental_get_query_params = _deprecate_func_name(
+    _get_query_params,
+    "experimental_get_query_params",
+    "2024-04-11",
+    _EXPERIMENTAL_QUERY_PARAMS_DEPRECATE_MSG,
+    name_override="query_params",
+)
+experimental_set_query_params = _deprecate_func_name(
+    _set_query_params,
+    "experimental_set_query_params",
+    "2024-04-11",
+    _EXPERIMENTAL_QUERY_PARAMS_DEPRECATE_MSG,
+    name_override="query_params",
+)
+
+
+# make it possible to call streamlit.components.v1.html etc. by importing it here
+# import in the very end to avoid partially-initialized module import errors, because
+# streamlit.components.v1 also uses some streamlit imports
+import streamlit.components.v1  # noqa: F401

streamlit/__main__.py

@@ -0,0 +1,20 @@
+# 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 streamlit.web.cli import main
+
+if __name__ == "__main__":
+    # Set prog_name so that the Streamlit server sees the same command line
+    # string whether streamlit is called directly or via `python -m streamlit`.
+    main(prog_name="streamlit")

streamlit/auth_util.py

@@ -0,0 +1,218 @@
+# 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 Mapping
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any, TypedDict, cast
+
+from streamlit import config
+from streamlit.errors import StreamlitAuthError
+from streamlit.runtime.secrets import AttrDict, secrets_singleton
+
+if TYPE_CHECKING:
+
+    class ProviderTokenPayload(TypedDict):
+        provider: str
+        exp: int
+
+
+class AuthCache:
+    """Simple cache implementation for storing info required for Authlib."""
+
+    def __init__(self):
+        self.cache = {}
+
+    def get(self, key):
+        return self.cache.get(key)
+
+    # for set method, we are follow the same signature used in Authlib
+    # the expires_in is not used in our case
+    def set(self, key, value, expires_in):
+        self.cache[key] = value
+
+    def get_dict(self):
+        return self.cache
+
+    def delete(self, key):
+        self.cache.pop(key, None)
+
+
+def is_authlib_installed() -> bool:
+    """Check if Authlib is installed."""
+    try:
+        import authlib  # type: ignore[import-untyped]
+
+        authlib_version = authlib.__version__
+        authlib_version_tuple = tuple(map(int, authlib_version.split(".")))
+
+        if authlib_version_tuple < (1, 3, 2):
+            return False
+    except (ImportError, ModuleNotFoundError):
+        return False
+    return True
+
+
+def get_signing_secret() -> str:
+    """Get the cookie signing secret from the configuration or secrets.toml."""
+    signing_secret: str = config.get_option("server.cookieSecret")
+    if secrets_singleton.load_if_toml_exists():
+        auth_section = secrets_singleton.get("auth")
+        if auth_section:
+            signing_secret = auth_section.get("cookie_secret", signing_secret)
+    return signing_secret
+
+
+def get_secrets_auth_section() -> AttrDict:
+    auth_section = AttrDict({})
+    """Get the 'auth' section of the secrets.toml."""
+    if secrets_singleton.load_if_toml_exists():
+        auth_section = cast(AttrDict, secrets_singleton.get("auth"))
+
+    return auth_section
+
+
+def encode_provider_token(provider: str) -> str:
+    """Returns a signed JWT token with the provider and expiration time."""
+    try:
+        from authlib.jose import jwt  # type: ignore[import-untyped]
+    except ImportError:
+        raise StreamlitAuthError(
+            """To use authentication features, you need to install Authlib>=1.3.2, e.g. via `pip install Authlib`."""
+        ) from None
+
+    header = {"alg": "HS256"}
+    payload = {
+        "provider": provider,
+        "exp": datetime.now(timezone.utc) + timedelta(minutes=2),
+    }
+    provider_token: bytes = jwt.encode(header, payload, get_signing_secret())
+    # JWT token is a byte string, so we need to decode it to a URL compatible string
+    return provider_token.decode("latin-1")
+
+
+def decode_provider_token(provider_token: str) -> ProviderTokenPayload:
+    """Decode the JWT token and validate the claims."""
+    try:
+        from authlib.jose import JoseError, JWTClaims, jwt
+    except ImportError:
+        raise StreamlitAuthError(
+            """To use authentication features, you need to install Authlib>=1.3.2, e.g. via `pip install Authlib`."""
+        ) from None
+
+    # Our JWT token is short-lived (2 minutes), so we check here that it contains
+    # the 'exp' (and it is not expired), and 'provider' field exists.
+    claim_options = {"exp": {"essential": True}, "provider": {"essential": True}}
+    try:
+        payload: JWTClaims = jwt.decode(
+            provider_token, get_signing_secret(), claims_options=claim_options
+        )
+        payload.validate()
+    except JoseError as e:
+        raise StreamlitAuthError(f"Error decoding provider token: {e}") from None
+
+    return cast("ProviderTokenPayload", payload)
+
+
+def generate_default_provider_section(auth_section) -> dict[str, Any]:
+    """Generate a default provider section for the 'auth' section of secrets.toml."""
+    default_provider_section = {}
+    if auth_section.get("client_id"):
+        default_provider_section["client_id"] = auth_section.get("client_id")
+    if auth_section.get("client_secret"):
+        default_provider_section["client_secret"] = auth_section.get("client_secret")
+    if auth_section.get("server_metadata_url"):
+        default_provider_section["server_metadata_url"] = auth_section.get(
+            "server_metadata_url"
+        )
+    if auth_section.get("client_kwargs"):
+        default_provider_section["client_kwargs"] = auth_section.get(
+            "client_kwargs"
+        ).to_dict()
+    return default_provider_section
+
+
+def validate_auth_credentials(provider: str) -> None:
+    """Validate the general auth credentials and auth credentials for the given
+    provider."""
+    if not secrets_singleton.load_if_toml_exists():
+        raise StreamlitAuthError(
+            """To use authentication features you need to configure credentials for at
+            least one authentication provider in `.streamlit/secrets.toml`."""
+        )
+
+    auth_section = secrets_singleton.get("auth")
+    if auth_section is None:
+        raise StreamlitAuthError(
+            """To use authentication features you need to configure credentials for at
+            least one authentication provider in `.streamlit/secrets.toml`."""
+        )
+    if "redirect_uri" not in auth_section:
+        raise StreamlitAuthError(
+            """Authentication credentials in `.streamlit/secrets.toml` are missing the
+            "redirect_uri" key. Please check your configuration."""
+        )
+    if "cookie_secret" not in auth_section:
+        raise StreamlitAuthError(
+            """Authentication credentials in `.streamlit/secrets.toml` are missing the
+            "cookie_secret" key. Please check your configuration."""
+        )
+
+    provider_section = auth_section.get(provider)
+
+    # TODO(kajarenc): Revisit this check later when investigating the ability
+    # TODO(kajarenc): to add "_" to the provider name.
+    if "_" in provider:
+        raise StreamlitAuthError(
+            f'Auth provider name "{provider}" contains an underscore. '
+            f"Please use a provider name without underscores."
+        )
+
+    if provider_section is None and provider == "default":
+        provider_section = generate_default_provider_section(auth_section)
+
+    if provider_section is None:
+        if provider == "default":
+            raise StreamlitAuthError(
+                """Authentication credentials in `.streamlit/secrets.toml` are missing for
+                the default authentication provider. Please check your configuration."""
+            )
+        raise StreamlitAuthError(
+            f"Authentication credentials in `.streamlit/secrets.toml` are missing for "
+            f'the authentication provider "{provider}". Please check your '
+            f"configuration."
+        )
+
+    if not isinstance(provider_section, Mapping):
+        raise StreamlitAuthError(
+            f"Authentication credentials in `.streamlit/secrets.toml` for the "
+            f'authentication provider "{provider}" must be valid TOML. Please check '
+            f"your configuration."
+        )
+
+    required_keys = ["client_id", "client_secret", "server_metadata_url"]
+    missing_keys = [key for key in required_keys if key not in provider_section]
+    if missing_keys:
+        if provider == "default":
+            raise StreamlitAuthError(
+                "Authentication credentials in `.streamlit/secrets.toml` for the "
+                f"default authentication provider are missing the following keys: "
+                f"{missing_keys}. Please check your configuration."
+            )
+        raise StreamlitAuthError(
+            "Authentication credentials in `.streamlit/secrets.toml` for the "
+            f'authentication provider "{provider}" are missing the following keys: '
+            f"{missing_keys}. Please check your configuration."
+        )

streamlit/cli_util.py

@@ -0,0 +1,105 @@
+# 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.
+
+"""Utilities related to the CLI."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+from streamlit import env_util, errors
+
+
+def print_to_cli(message: str, **kwargs) -> None:
+    """Print a message to the terminal using click if available, else print
+    using the built-in print function.
+
+    You can provide any keyword arguments that click.secho supports.
+    """
+    try:
+        import click
+
+        click.secho(message, **kwargs)
+    except ImportError:
+        print(message, flush=True)  # noqa: T201
+
+
+def style_for_cli(message: str, **kwargs) -> str:
+    """Style a message using click if available, else return the message
+    unchanged.
+
+    You can provide any keyword arguments that click.style supports.
+    """
+
+    try:
+        import click
+
+        return click.style(message, **kwargs)
+    except ImportError:
+        return message
+
+
+def _open_browser_with_webbrowser(url: str) -> None:
+    import webbrowser
+
+    webbrowser.open(url)
+
+
+def _open_browser_with_command(command: str, url: str) -> None:
+    cmd_line = [command, url]
+    with open(os.devnull, "w") as devnull:
+        subprocess.Popen(cmd_line, stdout=devnull, stderr=subprocess.STDOUT)
+
+
+def open_browser(url: str) -> None:
+    """Open a web browser pointing to a given URL.
+
+    We use this function instead of Python's `webbrowser` module because this
+    way we can capture stdout/stderr to avoid polluting the terminal with the
+    browser's messages. For example, Chrome always prints things like "Created
+    new window in existing browser session", and those get on the user's way.
+
+    url : str
+        The URL. Must include the protocol.
+
+    """
+    # Treat Windows separately because:
+    # 1. /dev/null doesn't exist.
+    # 2. subprocess.Popen(['start', url]) doesn't actually pop up the
+    #    browser even though 'start url' works from the command prompt.
+    # Fun!
+    # Also, use webbrowser if we are on Linux and xdg-open is not installed.
+    #
+    # We don't use the webbrowser module on Linux and Mac because some browsers
+    # (ahem... Chrome) always print "Opening in existing browser session" to
+    # the terminal, which is spammy and annoying. So instead we start the
+    # browser ourselves and send all its output to /dev/null.
+
+    if env_util.IS_WINDOWS:
+        _open_browser_with_webbrowser(url)
+        return
+    if env_util.IS_LINUX_OR_BSD:
+        if env_util.is_executable_in_path("xdg-open"):
+            _open_browser_with_command("xdg-open", url)
+            return
+        _open_browser_with_webbrowser(url)
+        return
+    if env_util.IS_DARWIN:
+        _open_browser_with_command("open", url)
+        return
+
+    import platform
+
+    raise errors.Error(f'Cannot open browser in platform "{platform.system()}"')