fastapi-cloud-cli 0.17.1__tar.gz → 0.18.0__tar.gz

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.17.1
+Version: 0.18.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT
@@ -39,6 +39,7 @@ Requires-Dist: pydantic[email]>=2.8.0; python_version == "3.13"
 Requires-Dist: pydantic[email]>=2.12.0; python_version >= "3.14"
 Requires-Dist: sentry-sdk>=2.20.0
 Requires-Dist: fastar>=0.10.0
+Requires-Dist: detect-installer>=0.1.0
 Provides-Extra: standard
 Requires-Dist: uvicorn[standard]>=0.15.0; extra == "standard"
 Description-Content-Type: text/markdown

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/pyproject.toml

@@ -39,8 +39,9 @@ dependencies = [
     "pydantic[email] >= 2.12.0; python_version >= '3.14'",
     "sentry-sdk >= 2.20.0",
     "fastar >= 0.10.0",
+    "detect-installer>=0.1.0",
 ]
-version = "0.17.1"
+version = "0.18.0"
 
 [project.license]
 text = "MIT"
@@ -66,7 +67,11 @@ dev = [
     "ruff==0.13.0",
     "respx==0.22.0",
     "time-machine==2.15.0",
-    "ty>=0.0.9",
+    "ty>=0.0.25",
+    "zizmor>=1.24.1",
+]
+github-actions = [
+    "smokeshow>=0.5.0",
 ]
 
 [build-system]
@@ -134,6 +139,9 @@ exclude = [
     "tests/assets/**",
 ]
 
+[tool.ty.terminal]
+error-on-warning = true
+
 [tool.ruff.lint]
 select = [
     "E",

fastapi_cloud_cli-0.18.0/src/fastapi_cloud_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0"

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/commands/deploy.py

@@ -108,15 +108,19 @@ def _should_exclude_entry(path: Path) -> bool:
     return False
 
 
-def archive(path: Path, tar_path: Path) -> Path:
-    logger.debug("Starting archive creation for path: %s", path)
-    files = rignore.walk(
+def _rignore_walk(path: Path) -> rignore.Walker:
+    return rignore.walk(
         path,
         should_exclude_entry=_should_exclude_entry,
         additional_ignore_paths=[".fastapicloudignore"],
         ignore_hidden=False,
     )
 
+
+def archive(path: Path, tar_path: Path) -> Path:
+    logger.debug("Starting archive creation for path: %s", path)
+    files = _rignore_walk(path)
+
     logger.debug("Archive will be created at: %s", tar_path)
 
     file_count = 0
@@ -134,6 +138,20 @@ def archive(path: Path, tar_path: Path) -> Path:
     return tar_path
 
 
+def _get_large_files(path: Path, threshold_mb: int) -> list[tuple[Path, int]]:
+    threshold_bytes = threshold_mb * 1024 * 1024
+    large_files = []
+    files = _rignore_walk(path)
+    for filename in files:
+        if filename.is_dir():
+            continue
+        file_size = filename.stat().st_size
+        if file_size > threshold_bytes:
+            large_files.append((filename.relative_to(path), file_size))
+
+    return sorted(large_files, key=lambda x: x[1], reverse=True)
+
+
 class Team(BaseModel):
     id: str
     slug: str
@@ -263,8 +281,8 @@ def _upload_deployment(
     logger.debug("Upload notification sent successfully")
 
 
-def _get_app(client: APIClient, app_slug: str) -> AppResponse | None:
-    response = client.get(f"/apps/{app_slug}")
+def _get_app(client: APIClient, app_id: str) -> AppResponse | None:
+    response = client.get(f"/apps/{app_id}")
 
     if response.status_code == 404:
         return None
@@ -378,10 +396,14 @@ def _configure_app(
     initial_directory = selected_app.directory if selected_app else ""
 
     directory_input = toolkit.input(
-        title="Path to the directory containing your app (e.g. src, backend):",
+        title=(
+            "Directory where your app's pyproject.toml file lives (e.g. src, backend):"
+        ),
         tag="dir",
         value=initial_directory or "",
-        placeholder="[italic]Leave empty if it's the current directory[/italic]",
+        placeholder=(
+            "[italic]Leave empty if pyproject.toml is in the current directory[/italic]"
+        ),
         validator=TypeAdapter(AppDirectory),
     )
 
@@ -665,7 +687,10 @@ def deploy(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="A path to the folder containing the app you want to deploy"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
     skip_wait: Annotated[
@@ -679,6 +704,14 @@ def deploy(
             envvar="FASTAPI_CLOUD_APP_ID",
         ),
     ] = None,
+    large_file_threshold: Annotated[
+        int,
+        typer.Option(
+            help="File size threshold in MB for warning about large files",
+            min=1,
+            envvar="FASTAPI_CLOUD_LARGE_FILE_THRESHOLD",
+        ),
+    ] = 10,  # 10 MB
 ) -> Any:
     """
     Deploy a [bold]FastAPI[/bold] app to FastAPI Cloud. 🚀
@@ -786,7 +819,7 @@ def deploy(
             with toolkit.progress("Checking app...", transient=True) as progress:
                 with client.handle_http_errors(progress):
                     logger.debug("Checking app with ID: %s", target_app_id)
-                    app = _get_app(client=client, app_slug=target_app_id)
+                    app = _get_app(client=client, app_id=target_app_id)
 
                 if not app:
                     logger.debug("App not found in API")
@@ -804,10 +837,32 @@ def deploy(
                     )
                 raise typer.Exit(1)
 
+            large_files = _get_large_files(
+                path_to_deploy, threshold_mb=large_file_threshold
+            )
+            if large_files:
+                toolkit.print(
+                    f"⚠️  Some uploaded files are larger than {large_file_threshold} MB ⚖️ :",
+                    tag="warning",
+                )
+                for fname, fsize in large_files[:3]:
+                    fsize_mb = fsize // (1024 * 1024)
+                    toolkit.print(f" • {fname} [yellow]({fsize_mb} MB)[/yellow]")
+                is_more = len(large_files) > 3
+                if is_more:
+                    toolkit.print(f" [dim]...and {len(large_files) - 3} more[/dim]")
+
+                large_files_docs_url = "https://fastapicloud.com/docs/fastapi-cloud-cli/deploy/#large-files-warning"
+                toolkit.print(
+                    f"Read more: [link={large_files_docs_url}]{large_files_docs_url}[/link]",
+                    tag="tip",
+                )
+                toolkit.print_line()
+
             with tempfile.TemporaryDirectory() as temp_dir:
                 logger.debug("Creating archive for deployment")
                 archive_path = Path(temp_dir) / "archive.tar"
-                archive(path or Path.cwd(), archive_path)
+                archive(path_to_deploy, archive_path)
 
                 with (
                     toolkit.progress(

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/commands/env.py

@@ -61,7 +61,10 @@ def list(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="A path to the folder containing the app you want to deploy"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
 ) -> Any:
@@ -119,7 +122,10 @@ def delete(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="A path to the folder containing the app you want to deploy"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
 ) -> Any:
@@ -208,7 +214,10 @@ def set(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="A path to the folder containing the app you want to deploy"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
     secret: Annotated[

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/commands/login.py

@@ -77,18 +77,18 @@ def login() -> Any:
     Login to FastAPI Cloud. 🚀
     """
     identity = Identity()
+    is_logged_in = identity.is_logged_in()
 
-    if identity.is_logged_in():
-        with get_rich_toolkit(minimal=True) as toolkit:
+    with get_rich_toolkit(minimal=is_logged_in) as toolkit:
+        if is_logged_in:
             toolkit.print("You are already logged in.")
             toolkit.print(
                 "Run [bold]fastapi cloud logout[/bold] first if you want to switch accounts."
             )
 
-        return
+            return
 
-    if identity.has_deploy_token():
-        with get_rich_toolkit() as toolkit:
+        if identity.has_deploy_token():
             toolkit.print(
                 "You have [bold blue]FASTAPI_CLOUD_TOKEN[/] environment variable set.\n"
                 "This token will take precedence over the user token for "
@@ -96,29 +96,31 @@ def login() -> Any:
                 tag="Warning",
             )
 
-    with get_rich_toolkit() as toolkit, APIClient() as client:
-        toolkit.print_title("Login to FastAPI Cloud", tag="FastAPI")
+        with APIClient() as client:
+            toolkit.print_title("Login to FastAPI Cloud", tag="FastAPI")
 
-        toolkit.print_line()
+            toolkit.print_line()
 
-        with toolkit.progress("Starting authorization") as progress:
-            with client.handle_http_errors(progress):
-                authorization_data = _start_device_authorization(client)
+            with toolkit.progress("Starting authorization") as progress:
+                with client.handle_http_errors(progress):
+                    authorization_data = _start_device_authorization(client)
 
-            url = authorization_data.verification_uri_complete
+                url = authorization_data.verification_uri_complete
 
-            progress.log(f"Opening [link={url}]{url}[/link]")
+                progress.log(f"Opening [link={url}]{url}[/link]")
 
-        toolkit.print_line()
+            toolkit.print_line()
 
-        with toolkit.progress("Waiting for user to authorize...") as progress:
-            typer.launch(url)
+            with toolkit.progress("Waiting for user to authorize...") as progress:
+                typer.launch(url)
 
-            with client.handle_http_errors(progress):
-                access_token = _fetch_access_token(
-                    client, authorization_data.device_code, authorization_data.interval
-                )
+                with client.handle_http_errors(progress):
+                    access_token = _fetch_access_token(
+                        client,
+                        authorization_data.device_code,
+                        authorization_data.interval,
+                    )
 
-            write_auth_config(AuthConfig(access_token=access_token))
+                write_auth_config(AuthConfig(access_token=access_token))
 
-            progress.log("Now you are logged in! 🚀")
+                progress.log("Now you are logged in! 🚀")

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/commands/logs.py

@@ -113,7 +113,10 @@ def logs(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="Path to the folder containing the app (defaults to current directory)"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
     tail: int = typer.Option(

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/commands/setup_ci.py

@@ -157,7 +157,10 @@ def setup_ci(
     path: Annotated[
         Path | None,
         typer.Argument(
-            help="Path to the folder containing the app (defaults to current directory)"
+            help=(
+                "Path to the directory with your app's pyproject.toml "
+                "(defaults to current directory)"
+            )
         ),
     ] = None,
     branch: str | None = typer.Option(

fastapi_cloud_cli-0.18.0/src/fastapi_cloud_cli/commands/whoami.py

@@ -0,0 +1,37 @@
+import logging
+from typing import Any
+
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.auth import Identity
+from fastapi_cloud_cli.utils.cli import get_rich_toolkit
+
+logger = logging.getLogger(__name__)
+
+
+def whoami() -> Any:
+    identity = Identity()
+
+    with get_rich_toolkit(minimal=True) as toolkit:
+        if not identity.is_logged_in():
+            toolkit.print(
+                "No credentials found. Use [blue]`fastapi login`[/] to login."
+            )
+        else:
+            with APIClient() as client:
+                with toolkit.progress(
+                    title="⚡ Fetching profile",
+                    transient=True,
+                ) as progress:
+                    with client.handle_http_errors(progress, default_message=""):
+                        response = client.get("/users/me")
+                        response.raise_for_status()
+
+                data = response.json()
+
+                toolkit.print(f"⚡ [bold]{data['email']}[/bold]")
+
+        if identity.has_deploy_token():
+            toolkit.print(
+                "⚡ [bold]Using API token from environment variable for "
+                "[blue]`fastapi deploy`[/blue] command.[/bold]"
+            )

fastapi_cloud_cli-0.18.0/src/fastapi_cloud_cli/utils/cli.py

@@ -0,0 +1,128 @@
+import logging
+import os
+from types import TracebackType
+from typing import Any, Literal
+
+from rich.segment import Segment
+from rich.style import Style
+from rich.text import Text
+from rich_toolkit import RichToolkit, RichToolkitTheme
+from rich_toolkit.styles import BaseStyle, MinimalStyle, TaggedStyle
+
+from fastapi_cloud_cli.utils.version_check import (
+    DISABLE_VERSION_CHECK_ENV,
+    BackgroundVersionCheck,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class FastAPIStyle(TaggedStyle):
+    def __init__(self, tag_width: int = 11):
+        super().__init__(tag_width=tag_width)
+
+    def _get_tag_segments(
+        self,
+        metadata: dict[str, Any],
+        is_animated: bool = False,
+        done: bool = False,
+        animation_status: Literal["started", "stopped", "error"] | None = None,
+    ) -> tuple[list[Segment], int]:
+        if not is_animated:
+            tag_segments, left_padding = super()._get_tag_segments(
+                metadata, is_animated, done, animation_status=animation_status
+            )
+
+            tag_style = metadata.get("tag_style")
+
+            if isinstance(tag_style, (str, Style)):
+                style = self.console.get_style(tag_style)
+                tag_segments = [
+                    Segment(segment.text, style=style) for segment in tag_segments
+                ]
+
+            return tag_segments, left_padding
+
+        emojis = [
+            "🥚",
+            "🐣",
+            "🐤",
+            "🐥",
+            "🐓",
+            "🐔",
+        ]
+
+        tag = emojis[self.animation_counter % len(emojis)]
+
+        if done:
+            tag = metadata.get("done_emoji", emojis[-1])
+
+        if animation_status == "error":
+            tag = "🟡"
+
+        left_padding = self.tag_width - 1
+        left_padding = max(0, left_padding)
+
+        return [Segment(tag)], left_padding
+
+
+class FastAPIRichToolkit(RichToolkit):
+    def __init__(
+        self,
+        style: BaseStyle | None = None,
+        theme: RichToolkitTheme | None = None,
+    ) -> None:
+        super().__init__(style=style, theme=theme)
+        self._version_check = self._get_version_check()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self._print_update_message()
+
+        return super().__exit__(
+            exc_type,
+            exc_value,
+            traceback,
+        )
+
+    def _get_version_check(self) -> BackgroundVersionCheck | None:
+        if os.environ.get(DISABLE_VERSION_CHECK_ENV) == "1":
+            return None
+
+        version_check = BackgroundVersionCheck()
+        version_check.start()
+
+        return version_check
+
+    def _print_update_message(self) -> None:
+        if self._version_check is None:
+            return
+
+        if message := self._version_check.get_update_message():
+            self.print(Text.from_markup(message), tag="update", tag_style="tag.update")
+
+
+def get_rich_toolkit(minimal: bool = False) -> RichToolkit:
+    style = MinimalStyle() if minimal else FastAPIStyle(tag_width=11)
+
+    theme = RichToolkitTheme(
+        style=style,
+        theme={
+            "tag.title": "white on #009485",
+            "tag": "white on #007166",
+            "tag.update": "black on yellow",
+            "placeholder": "grey62",
+            "text": "white",
+            "selected": "#007166",
+            "result": "grey85",
+            "progress": "on #007166",
+            "error": "red",
+            "cancelled": "indian_red italic",
+        },
+    )
+
+    return FastAPIRichToolkit(theme=theme)

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.18.0}/src/fastapi_cloud_cli/utils/config.py

@@ -25,3 +25,7 @@ def get_cli_config_path() -> Path:
     cli_config_path.parent.mkdir(parents=True, exist_ok=True)
 
     return cli_config_path
+
+
+def get_version_check_cache_path() -> Path:
+    return get_config_folder() / "version-check.json"

fastapi_cloud_cli-0.18.0/src/fastapi_cloud_cli/utils/version_check.py

@@ -0,0 +1,187 @@
+import json
+import logging
+import re
+import threading
+from contextlib import suppress
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import httpx
+from detect_installer import detect_installer
+from pydantic import AwareDatetime, BaseModel, ValidationError
+
+from fastapi_cloud_cli import __version__
+from fastapi_cloud_cli.utils.config import get_version_check_cache_path
+
+logger = logging.getLogger(__name__)
+
+PACKAGE_NAME = "fastapi-cloud-cli"
+DEFAULT_UPGRADE_COMMAND = f"pip install --upgrade {PACKAGE_NAME}"
+PYPI_JSON_URL = f"https://pypi.org/pypi/{PACKAGE_NAME}/json"
+VERSION_CHECK_TIMEOUT_SECONDS = 2.0
+VERSION_CHECK_JOIN_TIMEOUT_SECONDS = 0.2
+VERSION_CHECK_CACHE_TTL = timedelta(hours=24)
+DISABLE_VERSION_CHECK_ENV = "FASTAPI_CLOUD_DISABLE_VERSION_CHECK"
+SIMPLE_RELEASE_VERSION_RE = re.compile(r"\d+(?:\.\d+)*")
+
+
+@dataclass(frozen=True)
+class VersionUpdate:
+    current: str
+    latest: str
+
+
+class VersionCheckCache(BaseModel):
+    latest_version: str
+    checked_at: AwareDatetime
+
+
+class PyPIProjectInfo(BaseModel):
+    version: str
+
+
+class PyPIProjectResponse(BaseModel):
+    info: PyPIProjectInfo
+
+
+def _parse_simple_release_version(version: str) -> tuple[int, ...] | None:
+    if not SIMPLE_RELEASE_VERSION_RE.fullmatch(version):
+        logger.debug("Skipping non-simple version string: %r", version)
+        return None
+
+    return tuple(int(part) for part in version.split("."))
+
+
+def is_newer_version(latest: str, current: str) -> bool:
+    latest_parts = _parse_simple_release_version(latest)
+    current_parts = _parse_simple_release_version(current)
+
+    if latest_parts is None or current_parts is None:
+        return False
+
+    return latest_parts > current_parts
+
+
+def read_cached_latest_version(
+    cache_path: Path,
+    *,
+    ttl: timedelta = VERSION_CHECK_CACHE_TTL,
+) -> str | None:
+    now = datetime.now(timezone.utc)
+
+    try:
+        cache = VersionCheckCache.model_validate_json(
+            cache_path.read_text(encoding="utf-8")
+        )
+    except (OSError, ValidationError) as error:
+        logger.debug("Could not read CLI version cache: %s", error)
+        return None
+
+    if _parse_simple_release_version(cache.latest_version) is None:
+        return None
+
+    if now - cache.checked_at > ttl:
+        return None
+
+    return cache.latest_version
+
+
+def write_latest_version_cache(
+    cache_path: Path,
+    *,
+    latest_version: str,
+    now: datetime | None = None,
+) -> None:
+    now = now or datetime.now(timezone.utc)
+    data = {
+        "latest_version": latest_version,
+        "checked_at": now.isoformat(),
+    }
+
+    try:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        cache_path.write_text(json.dumps(data), encoding="utf-8")
+    except OSError as error:
+        logger.debug("Could not write CLI version cache: %s", error)
+
+
+def fetch_latest_version() -> str | None:
+    headers = {"User-Agent": f"fastapi-cloud-cli/{__version__}"}
+
+    try:
+        with httpx.Client(
+            timeout=httpx.Timeout(VERSION_CHECK_TIMEOUT_SECONDS),
+            headers=headers,
+        ) as client:
+            response = client.get(PYPI_JSON_URL)
+            response.raise_for_status()
+            data = PyPIProjectResponse.model_validate_json(response.text)
+    except (httpx.HTTPError, ValidationError) as error:
+        logger.debug("Could not check latest CLI version: %s", error)
+        return None
+
+    return data.info.version
+
+
+def check_for_update() -> VersionUpdate | None:
+    cache_path = get_version_check_cache_path()
+
+    if (latest_version := read_cached_latest_version(cache_path)) is None:
+        if (latest_version := fetch_latest_version()) is None:
+            return None
+
+        write_latest_version_cache(
+            cache_path,
+            latest_version=latest_version,
+        )
+
+    if not is_newer_version(latest_version, __version__):
+        return None
+
+    return VersionUpdate(current=__version__, latest=latest_version)
+
+
+def get_upgrade_command() -> str:
+    installer_info = detect_installer(PACKAGE_NAME)
+
+    if installer_info is None or installer_info.upgrade_cmd is None:
+        return DEFAULT_UPGRADE_COMMAND
+
+    return installer_info.upgrade_cmd
+
+
+def format_update_message(
+    update: VersionUpdate,
+) -> str:
+    return (
+        "A newer FastAPI Cloud CLI version is available: "
+        f"{update.current} → [bold]{update.latest}[/]\n\n"
+        f'Run "[blue]{get_upgrade_command()}[/]" to upgrade.'
+    )
+
+
+class BackgroundVersionCheck:
+    def __init__(self) -> None:
+        self._thread = threading.Thread(target=self._run, daemon=True)
+        self._update: VersionUpdate | None = None
+        self._message_returned = False
+
+    def start(self) -> None:
+        self._thread.start()
+
+    def _run(self) -> None:
+        with suppress(Exception):
+            self._update = check_for_update()
+
+    def get_update_message(self) -> str | None:
+        if self._message_returned:
+            return None
+
+        self._thread.join(timeout=VERSION_CHECK_JOIN_TIMEOUT_SECONDS)
+
+        if self._update:
+            self._message_returned = True
+            return format_update_message(self._update)
+
+        return None