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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.18.0
+Version: 0.20.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT
@@ -33,7 +33,7 @@ Requires-Dist: typer>=0.16.0
 Requires-Dist: uvicorn[standard]>=0.17.6
 Requires-Dist: rignore>=0.5.1
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: rich-toolkit>=0.19.7
+Requires-Dist: rich-toolkit>=0.20.1
 Requires-Dist: pydantic[email]>=2.7.4; python_version < "3.13"
 Requires-Dist: pydantic[email]>=2.8.0; python_version == "3.13"
 Requires-Dist: pydantic[email]>=2.12.0; python_version >= "3.14"

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

@@ -33,7 +33,7 @@ dependencies = [
     "uvicorn[standard] >= 0.17.6",
     "rignore >= 0.5.1",
     "httpx >= 0.27.0",
-    "rich-toolkit >= 0.19.7",
+    "rich-toolkit>=0.20.1",
     "pydantic[email] >= 2.7.4; python_version < '3.13'",
     "pydantic[email] >= 2.8.0; python_version == '3.13'",
     "pydantic[email] >= 2.12.0; python_version >= '3.14'",
@@ -41,7 +41,7 @@ dependencies = [
     "fastar >= 0.10.0",
     "detect-installer>=0.1.0",
 ]
-version = "0.18.0"
+version = "0.20.0"
 
 [project.license]
 text = "MIT"
@@ -61,12 +61,12 @@ Changelog = "https://github.com/fastapilabs/fastapi-cloud-cli/blob/main/release-
 [dependency-groups]
 dev = [
     "prek>=0.2.24,<1.0.0",
-    "pytest>=7.0.0,<9.0.0",
+    "pytest>=7.0.0,<10.0.0",
     "coverage[toml]>=7.2,<8.0",
-    "mypy==1.14.1",
-    "ruff==0.13.0",
-    "respx==0.22.0",
-    "time-machine==2.15.0",
+    "mypy==2.1.0",
+    "ruff==0.15.15",
+    "respx==0.23.1",
+    "time-machine==2.19.0",
     "ty>=0.0.25",
     "zizmor>=1.24.1",
 ]
@@ -167,3 +167,14 @@ known-third-party = [
 
 [tool.ruff.lint.pyupgrade]
 keep-runtime-typing = true
+
+[tool.typos.files]
+extend-exclude = [
+    "release-notes.md",
+    "uv.lock",
+    "coverage/",
+    "htmlcov/",
+]
+
+[tool.typos.default.extend-identifiers]
+alls = "alls"

fastapi_cloud_cli-0.20.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.20.0/src/fastapi_cloud_cli/__init__.py

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

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.20.0}/src/fastapi_cloud_cli/cli.py

@@ -4,14 +4,18 @@ import typer
 from rich import print
 
 from . import __version__
+from .commands.apps import apps_app
+from .commands.apps.link import link_app
+from .commands.apps.unlink import unlink_app
+from .commands.auth import auth_app
 from .commands.deploy import deploy
+from .commands.deployments import deployments_app
 from .commands.env import env_app
-from .commands.link import link
 from .commands.login import login
 from .commands.logout import logout
 from .commands.logs import logs
 from .commands.setup_ci import setup_ci
-from .commands.unlink import unlink
+from .commands.teams import teams_app
 from .commands.whoami import whoami
 from .logging import setup_logging
 from .utils.sentry import init_sentry
@@ -29,7 +33,7 @@ def version_callback(value: bool) -> None:
 
 cloud_app = typer.Typer(
     rich_markup_mode="rich",
-    help="Manage [bold]FastAPI[/bold] Cloud deployments. 🚀",
+    help="Manage [bold]FastAPI[/bold] Cloud deployments.",
     no_args_is_help=True,
 )
 
@@ -54,15 +58,19 @@ def cloud_main(
 
 # fastapi cloud [command]
 cloud_app.command()(deploy)
-cloud_app.command()(link)
+cloud_app.command("link")(link_app)
 cloud_app.command()(login)
 cloud_app.command()(logs)
 cloud_app.command()(logout)
 cloud_app.command()(whoami)
-cloud_app.command()(unlink)
+cloud_app.command("unlink")(unlink_app)
 cloud_app.command()(setup_ci)
 
 cloud_app.add_typer(env_app, name="env")
+cloud_app.add_typer(auth_app, name="auth")
+cloud_app.add_typer(apps_app, name="apps")
+cloud_app.add_typer(deployments_app, name="deployments")
+cloud_app.add_typer(teams_app, name="teams")
 
 # fastapi [command]
 app.command()(deploy)

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/_flow.py

@@ -0,0 +1,159 @@
+import logging
+import time
+
+import httpx
+from pydantic import BaseModel
+from rich_toolkit import RichToolkit
+from rich_toolkit.progress import Progress
+
+from fastapi_cloud_cli.config import Settings
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.auth import AuthConfig, AuthMode, write_auth_config
+from fastapi_cloud_cli.utils.cli import FastAPIRichToolkit
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_LOGIN_TIMEOUT_SECONDS = 300
+
+
+class AuthorizationData(BaseModel):
+    user_code: str
+    device_code: str
+    verification_uri: str
+    verification_uri_complete: str
+    interval: int = 5
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+
+
+class LoginOutput(BaseModel):
+    authenticated: bool
+    auth_mode: AuthMode
+
+
+class DeviceAuthorizationOutput(BaseModel):
+    verification_uri: str
+    verification_uri_complete: str
+    user_code: str
+    device_code: str
+    interval: int
+
+
+class LoginTimeoutError(Exception):
+    pass
+
+
+def render_login_output(data: LoginOutput, toolkit: RichToolkit) -> None:
+    toolkit.print("Now you are logged in! 🚀")
+
+
+def device_authorization_output(
+    authorization_data: AuthorizationData,
+) -> DeviceAuthorizationOutput:
+    return DeviceAuthorizationOutput(
+        verification_uri=authorization_data.verification_uri,
+        verification_uri_complete=authorization_data.verification_uri_complete,
+        user_code=authorization_data.user_code,
+        device_code=authorization_data.device_code,
+        interval=authorization_data.interval,
+    )
+
+
+def start_device_authorization(
+    client: httpx.Client,
+) -> AuthorizationData:
+    settings = Settings.get()
+
+    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()
+
+    return AuthorizationData.model_validate_json(response.text)
+
+
+def fetch_access_token(
+    client: httpx.Client,
+    device_code: str,
+    interval: int,
+    timeout: int = DEFAULT_LOGIN_TIMEOUT_SECONDS,
+) -> str:
+    settings = Settings.get()
+    start = time.monotonic()
+
+    logger.debug("Starting to poll for access token")
+    while True:
+        response = client.post(
+            "/login/device/token",
+            data={
+                "device_code": device_code,
+                "client_id": settings.client_id,
+                "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 error != "authorization_pending":
+                response.raise_for_status()
+
+        if response.status_code == 200:
+            break
+
+        remaining = timeout - (time.monotonic() - start)
+        if remaining <= 0:
+            raise LoginTimeoutError
+
+        sleep_for = min(interval, remaining)
+
+        logger.debug(f"Sleeping for {sleep_for} seconds before retrying...")
+        time.sleep(sleep_for)
+
+    response_data = TokenResponse.model_validate_json(response.text)
+    logger.debug("Access token received successfully.")
+
+    return response_data.access_token
+
+
+def complete_device_login(
+    *,
+    client: APIClient,
+    progress: Progress,
+    toolkit: FastAPIRichToolkit,
+    device_code: str,
+    interval: int,
+    timeout: int,
+    cancel_hint: str,
+) -> LoginOutput:
+    try:
+        with client.handle_http_errors(progress, toolkit=toolkit):
+            access_token = fetch_access_token(client, device_code, interval, timeout)
+    except LoginTimeoutError:
+        message = "Login timed out before authorization completed."
+        toolkit.fail(
+            "timeout",
+            message,
+            hint="Try again with a longer --timeout value.",
+        )
+    except KeyboardInterrupt:
+        message = "Login cancelled before authorization completed."
+        toolkit.fail(
+            "cancelled",
+            message,
+            hint=cancel_hint,
+        )
+
+    write_auth_config(AuthConfig(access_token=access_token))
+
+    return LoginOutput(authenticated=True, auth_mode="user")

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/apps/__init__.py

@@ -0,0 +1,21 @@
+import typer
+
+from fastapi_cloud_cli.commands.apps.create import create_app
+from fastapi_cloud_cli.commands.apps.get import get_app
+from fastapi_cloud_cli.commands.apps.link import link_app
+from fastapi_cloud_cli.commands.apps.list import list_apps
+from fastapi_cloud_cli.commands.apps.unlink import unlink_app
+from fastapi_cloud_cli.commands.logs import logs
+
+apps_app = typer.Typer(
+    no_args_is_help=True,
+    help="Manage your FastAPI Cloud apps.",
+)
+apps_app.command("create")(create_app)
+apps_app.command("get")(get_app)
+apps_app.command("link")(link_app)
+apps_app.command("list")(list_apps)
+apps_app.command("logs")(logs)
+apps_app.command("unlink")(unlink_app)
+
+__all__ = ["apps_app"]

fastapi_cloud_cli-0.20.0/src/fastapi_cloud_cli/commands/apps/create.py

@@ -0,0 +1,179 @@
+import logging
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from pydantic import BaseModel, Field
+from rich_toolkit import RichToolkit
+
+from fastapi_cloud_cli.commands.apps.list import _prompt_for_team
+from fastapi_cloud_cli.commands.deploy.archive import (
+    _get_app_name,
+    validate_app_directory,
+)
+from fastapi_cloud_cli.utils.api import APIClient
+from fastapi_cloud_cli.utils.apps import AppConfig, write_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.execution import JsonOutputOption
+
+logger = logging.getLogger(__name__)
+
+
+class CreatedApp(BaseModel):
+    id: str
+    team_id: str
+    slug: str
+    name: str
+    directory: str | None
+
+
+class AppsCreateOutput(BaseModel):
+    app: CreatedApp
+    linked: bool
+    path_to_link: Annotated[Path | None, Field(exclude=True)] = None
+
+
+def _create_app(
+    client: APIClient, *, team_id: str, name: str, directory: str | None
+) -> CreatedApp:
+    response = client.post(
+        "/apps/",
+        json={"team_id": team_id, "name": name, "directory": directory},
+    )
+    response.raise_for_status()
+
+    return CreatedApp.model_validate(response.json())
+
+
+def _render_apps_create_output(data: AppsCreateOutput, toolkit: RichToolkit) -> None:
+    toolkit.print(f"Created app [bold]{data.app.name}[/bold]", bullet=False)
+
+    if data.linked and data.path_to_link is not None:
+        toolkit.print(
+            f"Linked [bold]{data.path_to_link}[/bold] to [bold]{data.app.name}[/bold]",
+            bullet=False,
+        )
+
+
+def create_app(
+    team_id: Annotated[
+        str | None,
+        typer.Option(
+            "--team-id",
+            help="ID of the team where the app should be created.",
+        ),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option(
+            "--name",
+            help="Name of the app to create.",
+        ),
+    ] = None,
+    directory: Annotated[
+        str | None,
+        typer.Option(
+            "--directory",
+            help="Directory containing the app's pyproject.toml.",
+        ),
+    ] = None,
+    link: Annotated[
+        bool | None,
+        typer.Option(
+            "--link/--no-link",
+            help="Link the local directory to the created app.",
+        ),
+    ] = None,
+    path: Annotated[
+        Path | None,
+        typer.Option(
+            "--path",
+            help="Directory to link when --link is enabled.",
+        ),
+    ] = None,
+    json_output: JsonOutputOption = False,
+) -> Any:
+    """
+    Create a FastAPI Cloud app.
+    """
+    identity = Identity()
+    path_to_link = path or Path.cwd()
+
+    # JSON output is non-interactive, so it defaults to create-only unless --link is explicit.
+    link_app = link if link is not None else not json_output
+
+    with get_rich_toolkit(json_output=json_output) as toolkit:
+        if not identity.is_logged_in():
+            toolkit.fail(
+                "not_logged_in",
+                "No credentials found.",
+                hint="Run `fastapi cloud login` or set FASTAPI_CLOUD_TOKEN.",
+            )
+
+        if not link_app and path is not None:
+            toolkit.fail(
+                "invalid_input",
+                "Path can only be used when linking.",
+                hint="Pass --link or omit --path.",
+            )
+
+        with APIClient() as client:
+            if team_id is None:
+                if json_output:
+                    toolkit.fail(
+                        "missing_required_input",
+                        "Team ID is required.",
+                        hint="Pass --team-id to choose a team.",
+                    )
+
+                team = _prompt_for_team(toolkit, client)
+                team_id = team.id
+                toolkit.print_line()
+
+            if name is None:
+                if json_output:
+                    toolkit.fail(
+                        "missing_required_input",
+                        "App name is required.",
+                        hint="Pass --name to choose an app name.",
+                    )
+
+                name = toolkit.input(
+                    title="What's your app name?",
+                    default=_get_app_name(path_to_link),
+                    bullet=False,
+                )
+                toolkit.print_line()
+
+            directory = validate_app_directory(directory)
+
+            with toolkit.progress(
+                title="Creating app",
+                transient=True,
+            ) as progress:
+                with client.handle_http_errors(
+                    progress,
+                    default_message="Error creating app. Please try again later.",
+                    toolkit=toolkit,
+                ):
+                    app = _create_app(
+                        client,
+                        team_id=team_id,
+                        name=name,
+                        directory=directory,
+                    )
+
+        if link_app:
+            write_app_config(
+                path_to_link,
+                AppConfig(app_id=app.id, team_id=app.team_id),
+            )
+
+        result = AppsCreateOutput(
+            app=app,
+            linked=link_app,
+            path_to_link=path_to_link if link_app else None,
+        )
+
+        toolkit.success(result, render_output=_render_apps_create_output)