streamlit 1.49.1__py3-none-any.whl → 1.51.0__py3-none-any.whl

streamlit/errors.py

@@ -41,6 +41,17 @@ class CustomComponentError(Error):
     pass
 
 
+class StreamlitComponentRegistryError(Error):
+    """Exceptions raised while discovering or registering Streamlit components.
+
+    These errors occur during Streamlit startup when scanning installed
+    distributions for component metadata and registering them with the component
+    registry.
+    """
+
+    pass
+
+
 class DeprecationError(Error):
     pass
 
@@ -428,6 +439,67 @@ class StreamlitPageNotFoundError(LocalizableStreamlitException):
         )
 
 
+# Bidirectional Components
+class BidiComponentInvalidIdError(LocalizableStreamlitException):
+    """Exception raised when an invalid ID component is provided."""
+
+    def __init__(self, part: str, delimiter: str) -> None:
+        super().__init__(
+            "The `{part}` of a bidirectional component's ID must not contain "
+            "the delimiter sequence `{delimiter}`.",
+            part=part,
+            delimiter=delimiter,
+        )
+
+
+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."""
+
+    def __init__(self, callback_name: str) -> None:
+        super().__init__(
+            "The callback name `'{callback_name}'` is not allowed. "
+            "Callback names must follow the pattern `on_{{event_name}}_change` "
+            "where `event_name` is not empty.",
+            callback_name=callback_name,
+        )
+
+
+class BidiComponentInvalidDefaultKeyError(LocalizableStreamlitException):
+    """Exception raised when an invalid key is provided in the default dict."""
+
+    def __init__(self, state_key: str, available_keys: list[str]) -> None:
+        super().__init__(
+            "Key `'{state_key}'` in `default` is not a valid state name. "
+            "Valid state names are those with corresponding `on_{{state_name}}_change` "
+            "callbacks. Available state names: `{available_keys}`",
+            state_key=state_key,
+            available_keys=available_keys or "none",
+        )
+
+
+class BidiComponentUnserializableDataError(LocalizableStreamlitException):
+    """Exception raised when data provided to a bidirectional component cannot be serialized."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The `data` provided to the bidirectional component could not be serialized. "
+            "Please ensure the data is JSON-serializable, or is a supported data structure "
+            "like a pandas DataFrame."
+        )
+
+
 # policies
 class StreamlitFragmentWidgetsNotAllowedOutsideError(LocalizableStreamlitException):
     """Exception raised when the fragment attempts to write to an element outside of its container."""
@@ -519,6 +591,17 @@ class StreamlitInvalidHeightError(LocalizableStreamlitException):
         )
 
 
+class StreamlitInvalidSizeError(LocalizableStreamlitException):
+    """Exception raised when an invalid size value is provided."""
+
+    def __init__(self, size: Any) -> None:
+        super().__init__(
+            "Invalid size value: {size}. Size must be either an integer (pixels), "
+            "'stretch', 'small', 'medium', or 'large'.",
+            size=repr(size),
+        )
+
+
 class StreamlitValueError(LocalizableStreamlitException):
     """Exception raised when a value is not valid for a parameter."""
 
@@ -528,3 +611,35 @@ class StreamlitValueError(LocalizableStreamlitException):
             parameter=parameter,
             valid_values=", ".join(valid_values),
         )
+
+
+# config
+class StreamlitInvalidThemeError(LocalizableStreamlitException):
+    """Exception raised for general theme errors."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message,
+        )
+
+
+class StreamlitInvalidThemeOptionError(LocalizableStreamlitException):
+    """Exception raised when an invalid theme config option is provided."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(
+            message,
+        )
+
+
+class StreamlitInvalidThemeSectionError(LocalizableStreamlitException):
+    """Exception raised when an invalid theme section is provided."""
+
+    def __init__(self, option_name: str, file_path_or_url: str = "config.toml") -> None:
+        super().__init__(
+            "Invalid theme section: `{option_name}` found in {file_path_or_url}. "
+            "Valid sections are: `theme`, `theme.light`, `theme.dark`, `theme.sidebar`, `theme.light.sidebar`, "
+            "and `theme.dark.sidebar`.",
+            option_name=option_name,
+            file_path_or_url=file_path_or_url,
+        )

streamlit/git_util.py

@@ -16,21 +16,50 @@ from __future__ import annotations
 
 import os
 import re
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Final, cast
 
 from streamlit import util
+from streamlit.logger import get_logger
 
 if TYPE_CHECKING:
     from git import Commit, Remote, RemoteReference, Repo
 
-# Github has two URLs, one that is https and one that is ssh
-GITHUB_HTTP_URL = r"^https://(www\.)?github.com/(.+)/(.+)(?:.git)?$"
-GITHUB_SSH_URL = r"^git@github.com:(.+)/(.+)(?:.git)?$"
+_LOGGER: Final = get_logger(__name__)
+
+# Github repo extractor: match owner/repo for https/ssh/scp forms, with optional
+# userinfo/port/trailing slash. This is just to extract the repo name, not validate the URL.
+_GITHUB_URL_PATTERN: Final = re.compile(
+    r"github\.com(?::\d+)?[/:]([^/]+)/([^/]+?)(?:\.git)?/?$"
+)
 
 # We don't support git < 2.7, because we can't get repo info without
 # talking to the remote server, which results in the user being prompted
 # for credentials.
-MIN_GIT_VERSION = (2, 7, 0)
+_MIN_GIT_VERSION: Final = (2, 7, 0)
+
+
+def _extract_github_repo_from_url(url: str) -> str | None:
+    """Extract the ``owner/repo`` from a GitHub remote URL.
+
+    This supports HTTPS and SSH URL forms including optional user info, port,
+    trailing slash, and ``.git`` suffix. Validation of the scheme is not
+    performed; we only extract if the URL contains ``github.com`` and ends with
+    a path of the shape ``owner/repo``.
+
+    Parameters
+    ----------
+    url
+        The remote URL string.
+
+    Returns
+    -------
+    str | None
+        The extracted ``owner/repo`` if found; otherwise ``None``.
+    """
+    match = _GITHUB_URL_PATTERN.search(url.strip())
+    if match is None:
+        return None
+    return f"{match.group(1)}/{match.group(2)}"
 
 
 class GitRepo:
@@ -40,6 +69,7 @@ class GitRepo:
         # If we have a valid repo, git_version will be a tuple
         # of 3+ ints: (major, minor, patch, possible_additional_patch_number)
         self.git_version: tuple[int, ...] | None = None
+        self.module: str = ""
 
         try:
             import git
@@ -47,26 +77,31 @@ class GitRepo:
             self.repo = git.Repo(path, search_parent_directories=True)
             self.git_version = self.repo.git.version_info
 
-            if self.git_version is not None and self.git_version >= MIN_GIT_VERSION:
+            if self.git_version is not None and self.git_version >= _MIN_GIT_VERSION:
                 git_root = self.repo.git.rev_parse("--show-toplevel")
                 self.module = os.path.relpath(path, git_root)
         except Exception:
-            # The git repo must be invalid for the following reasons:
-            #  * git binary or GitPython not installed
-            #  * No .git folder
-            #  * Corrupted .git folder
-            #  * Path is invalid
+            _LOGGER.debug(
+                "Did not find a git repo at %s. This is expected if this isn't a git repo, but could "
+                "also fail for other reasons: "
+                "1) git binary or GitPython not installed "
+                "2) No .git folder "
+                "3) Corrupted .git folder "
+                "4) Path is invalid.",
+                path,
+                exc_info=True,
+            )
             self.repo = None
 
     def __repr__(self) -> str:
         return util.repr_(self)
 
     def is_valid(self) -> bool:
-        """True if there's a git repo here, and git.version >= MIN_GIT_VERSION."""
+        """True if there's a git repo here, and git.version >= _MIN_GIT_VERSION."""
         return (
             self.repo is not None
             and self.git_version is not None
-            and self.git_version >= MIN_GIT_VERSION
+            and self.git_version >= _MIN_GIT_VERSION
         )
 
     @property
@@ -129,50 +164,37 @@ class GitRepo:
         remote_name, *branch = tracking_branch.name.split("/")
         branch_name = "/".join(branch)
 
-        return self.repo.remote(remote_name), branch_name
-
-    def is_github_repo(self) -> bool:
-        if not self.is_valid():
-            return False
-
-        remote_info = self.get_tracking_branch_remote()
-        if remote_info is None:
-            return False
-
-        remote, _branch = remote_info
-
-        for url in remote.urls:
-            if (
-                re.match(GITHUB_HTTP_URL, url) is not None
-                or re.match(GITHUB_SSH_URL, url) is not None
-            ):
-                return True
-
-        return False
+        try:
+            return self.repo.remote(remote_name), branch_name
+        except Exception:
+            _LOGGER.debug("Failed to resolve remote %s", remote_name, exc_info=True)
+            return None
 
     def get_repo_info(self) -> tuple[str, str, str] | None:
         if not self.is_valid():
+            _LOGGER.debug(
+                "No valid git information found. Git version: %s", self.git_version
+            )
             return None
 
         remote_info = self.get_tracking_branch_remote()
         if remote_info is None:
+            _LOGGER.debug("No tracking remote branch found for the git repo.")
             return None
 
         remote, branch = remote_info
-
+        remote_urls = list(remote.urls)
         repo = None
-        for url in remote.urls:
-            https_matches = re.match(GITHUB_HTTP_URL, url)
-            ssh_matches = re.match(GITHUB_SSH_URL, url)
-            if https_matches is not None:
-                repo = f"{https_matches.group(2)}/{https_matches.group(3)}"
-                break
-
-            if ssh_matches is not None:
-                repo = f"{ssh_matches.group(1)}/{ssh_matches.group(2)}"
+        for url in remote_urls:
+            repo = _extract_github_repo_from_url(url)
+            if repo is not None:
                 break
 
         if repo is None:
+            _LOGGER.debug(
+                "Unable to determine repo name from configured remote URLs. URLs: %s",
+                remote_urls,
+            )
             return None
 
         return repo, branch, self.module

streamlit/hello/hello.py

@@ -36,3 +36,11 @@ st.write(
     - Explore a [New York City rideshare dataset](https://github.com/streamlit/demo-uber-nyc-pickups)
     """
 )
+
+# Preload Python modules that take a while to compile in a new venv.
+# Otherwise, when users switch to another page, it seems that Streamlit
+# is slow, when in reality this is just an artifact of loading/compiling
+# large modules from zero.
+with st.spinner("Preloading Python modules for other pages..."):
+    import numpy  # noqa: ICN001 F401
+    import pandas  # noqa: ICN001 F401

streamlit/hello/utils.py

@@ -14,7 +14,8 @@
 
 import inspect
 import textwrap
-from typing import Any, Callable
+from collections.abc import Callable
+from typing import Any
 
 import streamlit as st