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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.17.1
+Version: 0.19.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.19.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.19.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.19.0/scripts/prepare_release.py

@@ -0,0 +1,216 @@
+"""Prepare a release by updating the package version and release notes."""
+
+import re
+from datetime import date
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+VERSION_PATTERN = re.compile(r'(?m)^__version__ = "(\d+\.\d+\.\d+)"$')
+VERSION_HEADING_PATTERN = re.compile(r"(?m)^## (\d+\.\d+\.\d+)(?: \([^)]+\))?$")
+RELEASE_NOTES_HEADER = "# Release Notes\n\n"
+LATEST_CHANGES_HEADER = "## Latest Changes"
+
+
+class BumpType(str, Enum):
+    major = "major"
+    minor = "minor"
+    patch = "patch"
+
+
+app = typer.Typer()
+
+
+def parse_version(version: str) -> tuple[int, int, int]:
+    match = re.fullmatch(r"\d+\.\d+\.\d+", version)
+    if not match:
+        raise ValueError(f"Invalid version: {version!r}. Expected format: X.Y.Z")
+    major, minor, patch = version.split(".")
+    return int(major), int(minor), int(patch)
+
+
+def get_current_version(content: str, version_file: Path) -> str:
+    matches = list(VERSION_PATTERN.finditer(content))
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"Expected exactly one __version__ assignment in {version_file}, "
+            f"found {len(matches)}"
+        )
+    return matches[0].group(1)
+
+
+def bump_version(version: str, bump: BumpType) -> str:
+    major, minor, patch = parse_version(version)
+    if bump == BumpType.major:
+        return f"{major + 1}.0.0"
+    if bump == BumpType.minor:
+        return f"{major}.{minor + 1}.0"
+    return f"{major}.{minor}.{patch + 1}"
+
+
+def update_version_file(content: str, version: str, version_file: Path) -> str:
+    current_version = get_current_version(content, version_file)
+    if parse_version(version) <= parse_version(current_version):
+        raise RuntimeError(
+            f"New version {version} must be greater than current version {current_version}"
+        )
+    return VERSION_PATTERN.sub(f'__version__ = "{version}"', content, count=1)
+
+
+def update_release_notes(
+    content: str, version: str, release_date: date, release_notes_file: Path
+) -> str:
+    if not content.startswith(RELEASE_NOTES_HEADER):
+        raise RuntimeError(
+            f"{release_notes_file} must start with {RELEASE_NOTES_HEADER!r}"
+        )
+    if re.search(rf"^## {re.escape(version)}(?: \([^)]+\))?$", content, re.M):
+        raise RuntimeError(f"Release notes already contain a section for {version}")
+
+    latest_header = f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n"
+    if not content.startswith(latest_header):
+        raise RuntimeError(f"{release_notes_file} must start with {latest_header!r}")
+
+    release_header = f"## {version} ({release_date.isoformat()})"
+    return content.replace(
+        latest_header,
+        f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n\n{release_header}\n",
+        1,
+    )
+
+
+def get_release_notes_body(content: str, version: str, release_notes_file: Path) -> str:
+    version_heading = re.compile(rf"(?m)^## {re.escape(version)}(?: \([^)]+\))?$")
+    match = version_heading.search(content)
+    if not match:
+        raise RuntimeError(
+            f"Could not find release notes section for {version} in {release_notes_file}"
+        )
+
+    next_match = VERSION_HEADING_PATTERN.search(content, match.end())
+    end = next_match.start() if next_match else len(content)
+    body = content[match.end() : end].strip()
+    if not body:
+        raise RuntimeError(
+            f"Release notes section for {version} in {release_notes_file} is empty"
+        )
+    return f"{body}\n"
+
+
+@app.command()
+def prepare(
+    bump: Annotated[
+        BumpType,
+        typer.Argument(
+            envvar="PREPARE_RELEASE_BUMP",
+            help="The release bump to make: major, minor, or patch.",
+        ),
+    ],
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+    release_date: Annotated[
+        str,
+        typer.Option(
+            "--date",
+            envvar="PREPARE_RELEASE_DATE",
+            help="Release date in YYYY-MM-DD format. Defaults to today.",
+        ),
+    ] = date.today().isoformat(),
+) -> None:
+    parsed_release_date = date.fromisoformat(release_date or date.today().isoformat())
+
+    version_file_content = version_file.read_text()
+    release_notes_content = release_notes_file.read_text()
+    version = bump_version(
+        get_current_version(version_file_content, version_file), bump
+    )
+
+    version_file.write_text(
+        update_version_file(version_file_content, version, version_file)
+    )
+    release_notes_file.write_text(
+        update_release_notes(
+            release_notes_content, version, parsed_release_date, release_notes_file
+        )
+    )
+
+    typer.echo(f"Prepared release {version} ({parsed_release_date.isoformat()})")
+
+
+@app.command()
+def current_version(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+) -> None:
+    typer.echo(get_current_version(version_file.read_text(), version_file))
+
+
+@app.command()
+def release_notes(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+) -> None:
+    version = get_current_version(version_file.read_text(), version_file)
+    typer.echo(
+        get_release_notes_body(
+            release_notes_file.read_text(), version, release_notes_file
+        ),
+        nl=False,
+    )
+
+
+if __name__ == "__main__":
+    app()

fastapi_cloud_cli-0.19.0/src/fastapi_cloud_cli/__init__.py

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

{fastapi_cloud_cli-0.17.1 → fastapi_cloud_cli-0.19.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,12 @@ 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. 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 +685,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 +702,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 +817,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 +835,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.19.0}/src/fastapi_cloud_cli/commands/env.py

@@ -4,19 +4,27 @@ from typing import Annotated, Any
 
 import typer
 from pydantic import BaseModel
+from rich import box
+from rich.table import Table
+from rich.text import Text
 
 from fastapi_cloud_cli.utils.api import APIClient
 from fastapi_cloud_cli.utils.apps import get_app_config
 from fastapi_cloud_cli.utils.auth import Identity
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit
+from fastapi_cloud_cli.utils.dates import format_last_updated
 from fastapi_cloud_cli.utils.env import validate_environment_variable_name
 
 logger = logging.getLogger(__name__)
 
+ENV_VAR_VALUE_MAX_LENGTH = 40
+
 
 class EnvironmentVariable(BaseModel):
     name: str
     value: str | None = None
+    is_secret: bool = False
+    updated_at: str | None = None
 
 
 class EnvironmentVariableResponse(BaseModel):
@@ -53,15 +61,54 @@ def _set_environment_variable(
     response.raise_for_status()
 
 
+def _format_env_var_value(env_var: EnvironmentVariable) -> Text:
+    if env_var.value is None:
+        placeholder = "[secret]" if env_var.is_secret else "-"
+
+        return Text(placeholder, style="dim")
+
+    value = env_var.value.replace("\r", "\\r").replace("\n", "\\n")
+
+    if len(value) > ENV_VAR_VALUE_MAX_LENGTH:
+        value = f"{value[: ENV_VAR_VALUE_MAX_LENGTH - 3]}..."
+
+    return Text(value)
+
+
+def _get_environment_variables_table(
+    environment_variables: list[EnvironmentVariable],
+) -> Table:
+    table = Table(
+        box=box.SIMPLE_HEAD,
+        pad_edge=False,
+        show_edge=False,
+    )
+    table.add_column("Key", no_wrap=True)
+    table.add_column("Value", overflow="ellipsis", max_width=ENV_VAR_VALUE_MAX_LENGTH)
+    table.add_column("Last updated", style="dim", no_wrap=True)
+
+    for env_var in environment_variables:
+        table.add_row(
+            Text(env_var.name),
+            _format_env_var_value(env_var),
+            Text(format_last_updated(env_var.updated_at)),
+        )
+
+    return table
+
+
 env_app = typer.Typer()
 
 
-@env_app.command()
-def list(
+@env_app.command("list")
+def list_variables(
     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:
@@ -103,11 +150,7 @@ def list(
             toolkit.print("No environment variables found.")
             return
 
-        toolkit.print("Environment variables:")
-        toolkit.print_line()
-
-        for env_var in environment_variables.data:
-            toolkit.print(f"[bold]{env_var.name}[/]")
+        toolkit.print(_get_environment_variables_table(environment_variables.data))
 
 
 @env_app.command()
@@ -119,7 +162,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 +254,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.19.0}/src/fastapi_cloud_cli/commands/login.py

@@ -34,6 +34,7 @@ def _start_device_authorization(
     response = client.post(
         "/login/device/authorization", data={"client_id": settings.client_id}
     )
+    logger.debug(f"Device authorization response status code: {response.status_code}")
 
     response.raise_for_status()
 
@@ -43,6 +44,7 @@ def _start_device_authorization(
 def _fetch_access_token(client: httpx.Client, device_code: str, interval: int) -> str:
     settings = Settings.get()
 
+    logger.debug("Starting to poll for access token")
     while True:
         response = client.post(
             "/login/device/token",
@@ -52,22 +54,27 @@ def _fetch_access_token(client: httpx.Client, device_code: str, interval: int) -
                 "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
             },
         )
+        logger.debug(f"Token response status code: {response.status_code}")
 
         if response.status_code not in (200, 400):
             response.raise_for_status()
 
         if response.status_code == 400:
             data = response.json()
+            error = data.get("error")
+            logger.debug(f"Token response error: {error}")
 
-            if data.get("error") != "authorization_pending":
+            if error != "authorization_pending":
                 response.raise_for_status()
 
         if response.status_code == 200:
             break
 
+        logger.debug(f"Sleeping for {interval} seconds before retrying...")
         time.sleep(interval)
 
     response_data = TokenResponse.model_validate_json(response.text)
+    logger.debug("Access token received successfully.")
 
     return response_data.access_token
 
@@ -77,18 +84,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 +103,32 @@ 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:
+                launch_cmd_res = typer.launch(url)
+                logger.debug(f"Launch command result: {launch_cmd_res}")
 
-            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.19.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.19.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(