fastapi-cloud-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.3.0
+Version: 0.4.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: httpx>=0.27.0
 Requires-Dist: rich-toolkit>=0.14.5
 Requires-Dist: pydantic[email]>=1.6.1
 Requires-Dist: sentry-sdk>=2.20.0
+Requires-Dist: fastar>=0.5.0
 Provides-Extra: standard
 Requires-Dist: uvicorn[standard]>=0.15.0; extra == "standard"
 Description-Content-Type: text/markdown

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/pyproject.toml

@@ -39,8 +39,9 @@ dependencies = [
     "rich-toolkit >= 0.14.5",
     "pydantic[email] >= 1.6.1",
     "sentry-sdk >= 2.20.0",
+    "fastar >= 0.5.0",
 ]
-version = "0.3.0"
+version = "0.4.0"
 
 [project.license]
 text = "MIT"

fastapi_cloud_cli-0.4.0/src/fastapi_cloud_cli/__init__.py

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

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/src/fastapi_cloud_cli/cli.py

@@ -13,17 +13,29 @@ setup_logging()
 
 app = typer.Typer(rich_markup_mode="rich")
 
+cloud_app = typer.Typer(
+    rich_markup_mode="rich",
+    help="Manage [bold]FastAPI[/bold] Cloud deployments. 🚀",
+)
 
 # TODO: use the app structure
 
 # Additional commands
+
+# fastapi cloud [command]
+cloud_app.command()(deploy)
+cloud_app.command()(login)
+cloud_app.command()(logout)
+cloud_app.command()(whoami)
+cloud_app.command()(unlink)
+
+cloud_app.add_typer(env_app, name="env")
+
+# fastapi [command]
 app.command()(deploy)
 app.command()(login)
-app.command()(logout)
-app.command()(whoami)
-app.command()(unlink)
 
-app.add_typer(env_app, name="env")
+app.add_typer(cloud_app, name="cloud")
 
 
 def main() -> None:

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/src/fastapi_cloud_cli/commands/deploy.py

@@ -2,15 +2,14 @@ import contextlib
 import json
 import logging
 import subprocess
-import tarfile
 import tempfile
 import time
-import uuid
 from enum import Enum
 from itertools import cycle
 from pathlib import Path
 from typing import Any, Dict, Generator, List, Optional, Union
 
+import fastar
 import rignore
 import typer
 from httpx import Client
@@ -25,7 +24,6 @@ from fastapi_cloud_cli.utils.api import APIClient
 from fastapi_cloud_cli.utils.apps import AppConfig, get_app_config, write_app_config
 from fastapi_cloud_cli.utils.auth import is_logged_in
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit, handle_http_errors
-from fastapi_cloud_cli.utils.env import validate_environment_variable_name
 
 logger = logging.getLogger(__name__)
 
@@ -36,7 +34,14 @@ def _get_app_name(path: Path) -> str:
 
 
 def _should_exclude_entry(path: Path) -> bool:
-    parts_to_exclude = [".venv", "__pycache__", ".mypy_cache", ".pytest_cache"]
+    parts_to_exclude = [
+        ".venv",
+        "__pycache__",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".gitignore",
+        ".fastapicloudignore",
+    ]
 
     if any(part in path.parts for part in parts_to_exclude):
         return True
@@ -47,28 +52,26 @@ def _should_exclude_entry(path: Path) -> bool:
     return False
 
 
-def archive(path: Path) -> Path:
+def archive(path: Path, tar_path: Path) -> Path:
     logger.debug("Starting archive creation for path: %s", path)
     files = rignore.walk(
         path,
         should_exclude_entry=_should_exclude_entry,
         additional_ignore_paths=[".fastapicloudignore"],
+        ignore_hidden=False,
     )
 
-    temp_dir = tempfile.mkdtemp()
-    logger.debug("Created temp directory: %s", temp_dir)
-
-    name = f"fastapi-cloud-deploy-{uuid.uuid4()}"
-    tar_path = Path(temp_dir) / f"{name}.tar"
     logger.debug("Archive will be created at: %s", tar_path)
 
     file_count = 0
-    with tarfile.open(tar_path, "w") as tar:
+    with fastar.open(tar_path, "w") as tar:
         for filename in files:
             if filename.is_dir():
                 continue
 
-            tar.add(filename, arcname=filename.relative_to(path))
+            arcname = filename.relative_to(path)
+            logger.debug("Adding %s to archive", arcname)
+            tar.append(filename, arcname=arcname)
             file_count += 1
 
     logger.debug("Archive created successfully with %s files", file_count)
@@ -120,6 +123,7 @@ class DeploymentStatus(str, Enum):
     deploying_failed = "deploying_failed"
     verifying = "verifying"
     verifying_failed = "verifying_failed"
+    verifying_skipped = "verifying_skipped"
     success = "success"
     failed = "failed"
 
@@ -137,6 +141,7 @@ class DeploymentStatus(str, Enum):
             cls.deploying_failed: "Deploying failed",
             cls.verifying: "Verifying",
             cls.verifying_failed: "Verifying failed",
+            cls.verifying_skipped: "Verification skipped",
             cls.success: "Success",
             cls.failed: "Failed",
         }[status]
@@ -229,12 +234,6 @@ def _get_apps(team_id: str) -> List[AppResponse]:
     return [AppResponse.model_validate(app) for app in data]
 
 
-def _create_environment_variables(app_id: str, env_vars: Dict[str, str]) -> None:
-    with APIClient() as client:
-        response = client.patch(f"/apps/{app_id}/environment-variables/", json=env_vars)
-        response.raise_for_status()
-
-
 def _stream_build_logs(deployment_id: str) -> Generator[str, None, None]:
     with APIClient() as client:
         with client.stream(
@@ -399,45 +398,6 @@ def _wait_for_deployment(
                     last_message_changed_at = time.monotonic()  # pragma: no cover
 
 
-def _setup_environment_variables(toolkit: RichToolkit, app_id: str) -> None:
-    if not toolkit.confirm("Do you want to setup environment variables?", tag="env"):
-        return
-
-    toolkit.print_line()
-
-    env_vars = {}
-
-    while True:
-        key = toolkit.input(
-            "Enter the environment variable name: [ENTER to skip]", required=False
-        )
-
-        if key.strip() == "":
-            break
-
-        if not validate_environment_variable_name(key):
-            toolkit.print(
-                "[error]Invalid environment variable name.",
-            )
-
-        else:
-            value = toolkit.input(
-                "Enter the environment variable value:", password=True
-            )
-
-            env_vars[key] = value
-
-        toolkit.print_line()
-
-    toolkit.print_line()
-
-    with toolkit.progress("Setting up environment variables...") as progress:
-        with handle_http_errors(progress):
-            _create_environment_variables(app_id, env_vars)
-
-        progress.log("Environment variables set up successfully!")
-
-
 class SignupToWaitingList(BaseModel):
     email: EmailStr
     name: Optional[str] = None
@@ -539,7 +499,7 @@ def _waitlist_form(toolkit: RichToolkit) -> None:
 
         with contextlib.suppress(Exception):
             subprocess.run(
-                ["open", "raycast://confetti"],
+                ["open", "raycast://confetti?emojis=🐔⚡"],
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.DEVNULL,
                 check=False,
@@ -605,9 +565,6 @@ def deploy(
             logger.debug("No app config found, configuring new app")
             app_config = _configure_app(toolkit, path_to_deploy=path_to_deploy)
             toolkit.print_line()
-
-            _setup_environment_variables(toolkit, app_config.app_id)
-            toolkit.print_line()
         else:
             logger.debug("Existing app config found, proceeding with deployment")
             toolkit.print("Deploying app...")
@@ -627,16 +584,19 @@ def deploy(
         if not app:
             toolkit.print_line()
             toolkit.print(
-                "If you deleted this app, you can run [bold]fastapi unlink[/] to unlink the local configuration.",
+                "If you deleted this app, you can run [bold]fastapi cloud unlink[/] to unlink the local configuration.",
                 tag="tip",
             )
             raise typer.Exit(1)
 
-        logger.debug("Creating archive for deployment")
-        archive_path = archive(path or Path.cwd())  # noqa: F841
+        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)
 
-        with toolkit.progress(title="Creating deployment") as progress:
-            with handle_http_errors(progress):
+            with toolkit.progress(
+                title="Creating deployment"
+            ) as progress, handle_http_errors(progress):
                 logger.debug("Creating deployment for app: %s", app.id)
                 deployment = _create_deployment(app.id)
 
@@ -648,7 +608,7 @@ def deploy(
 
                 _upload_deployment(deployment.id, archive_path)
 
-            progress.log("Deployment uploaded successfully!")
+                progress.log("Deployment uploaded successfully!")
 
         toolkit.print_line()
 

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/src/fastapi_cloud_cli/commands/env.py

@@ -44,11 +44,13 @@ def _delete_environment_variable(app_id: str, name: str) -> bool:
     return True
 
 
-def _set_environment_variable(app_id: str, name: str, value: str) -> None:
+def _set_environment_variable(
+    app_id: str, name: str, value: str, is_secret: bool = False
+) -> None:
     with APIClient() as client:
-        response = client.patch(
+        response = client.post(
             f"/apps/{app_id}/environment-variables/",
-            json={name: value},
+            json={"name": name, "value": value, "is_secret": is_secret},
         )
         response.raise_for_status()
 

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/src/fastapi_cloud_cli/commands/login.py

@@ -8,7 +8,13 @@ from pydantic import BaseModel
 
 from fastapi_cloud_cli.config import Settings
 from fastapi_cloud_cli.utils.api import APIClient
-from fastapi_cloud_cli.utils.auth import AuthConfig, write_auth_config
+from fastapi_cloud_cli.utils.auth import (
+    AuthConfig,
+    get_auth_token,
+    is_logged_in,
+    is_token_expired,
+    write_auth_config,
+)
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit, handle_http_errors
 
 logger = logging.getLogger(__name__)
@@ -76,6 +82,20 @@ def login() -> Any:
     """
     Login to FastAPI Cloud. 🚀
     """
+    token = get_auth_token()
+    if token is not None and is_token_expired(token):
+        with get_rich_toolkit(minimal=True) as toolkit:
+            toolkit.print("Your session has expired. Logging in again...")
+            toolkit.print_line()
+
+    if is_logged_in():
+        with get_rich_toolkit(minimal=True) as toolkit:
+            toolkit.print("You are already logged in.")
+            toolkit.print(
+                "Run [bold]fastapi logout[/bold] first if you want to switch accounts."
+            )
+        return
+
     with get_rich_toolkit() as toolkit, APIClient() as client:
         toolkit.print_title("Login to FastAPI Cloud", tag="FastAPI")
 
@@ -87,7 +107,7 @@ def login() -> Any:
 
             url = authorization_data.verification_uri_complete
 
-            progress.log(f"Opening {url}")
+            progress.log(f"Opening [link={url}]{url}[/link]")
 
         toolkit.print_line()
 

fastapi_cloud_cli-0.4.0/src/fastapi_cloud_cli/utils/auth.py

@@ -0,0 +1,122 @@
+import base64
+import binascii
+import json
+import logging
+import time
+from typing import Optional
+
+from pydantic import BaseModel
+
+from .config import get_auth_path
+
+logger = logging.getLogger("fastapi_cli")
+
+
+class AuthConfig(BaseModel):
+    access_token: str
+
+
+def write_auth_config(auth_data: AuthConfig) -> None:
+    auth_path = get_auth_path()
+    logger.debug("Writing auth config to: %s", auth_path)
+
+    auth_path.write_text(auth_data.model_dump_json(), encoding="utf-8")
+    logger.debug("Auth config written successfully")
+
+
+def delete_auth_config() -> None:
+    auth_path = get_auth_path()
+    logger.debug("Deleting auth config at: %s", auth_path)
+
+    if auth_path.exists():
+        auth_path.unlink()
+        logger.debug("Auth config deleted successfully")
+    else:
+        logger.debug("Auth config file doesn't exist, nothing to delete")
+
+
+def read_auth_config() -> Optional[AuthConfig]:
+    auth_path = get_auth_path()
+    logger.debug("Reading auth config from: %s", auth_path)
+
+    if not auth_path.exists():
+        logger.debug("Auth config file doesn't exist")
+        return None
+
+    logger.debug("Auth config loaded successfully")
+    return AuthConfig.model_validate_json(auth_path.read_text(encoding="utf-8"))
+
+
+def get_auth_token() -> Optional[str]:
+    logger.debug("Getting auth token")
+    auth_data = read_auth_config()
+
+    if auth_data is None:
+        logger.debug("No auth data found")
+        return None
+
+    logger.debug("Auth token retrieved successfully")
+    return auth_data.access_token
+
+
+def is_token_expired(token: str) -> bool:
+    try:
+        parts = token.split(".")
+
+        if len(parts) != 3:
+            logger.debug("Invalid JWT format: expected 3 parts, got %d", len(parts))
+            return True
+
+        payload = parts[1]
+
+        # Add padding if needed (JWT uses base64url encoding without padding)
+        if padding := len(payload) % 4:
+            payload += "=" * (4 - padding)
+
+        payload = payload.replace("-", "+").replace("_", "/")
+        decoded_bytes = base64.b64decode(payload)
+        payload_data = json.loads(decoded_bytes)
+
+        exp = payload_data.get("exp")
+
+        if exp is None:
+            logger.debug("No 'exp' claim found in token")
+
+            return False
+
+        if not isinstance(exp, int):  # pragma: no cover
+            logger.debug("Invalid 'exp' claim: expected int, got %s", type(exp))
+
+            return True
+
+        current_time = time.time()
+
+        is_expired = current_time >= exp
+
+        logger.debug(
+            "Token expiration check: current=%d, exp=%d, expired=%s",
+            current_time,
+            exp,
+            is_expired,
+        )
+
+        return is_expired
+    except (binascii.Error, json.JSONDecodeError) as e:
+        logger.debug("Error parsing JWT token: %s", e)
+
+        return True
+
+
+def is_logged_in() -> bool:
+    token = get_auth_token()
+
+    if token is None:
+        logger.debug("Login status: False (no token)")
+        return False
+
+    if is_token_expired(token):
+        logger.debug("Login status: False (token expired)")
+        return False
+
+    logger.debug("Login status: True")
+    return True

{fastapi_cloud_cli-0.3.0 → fastapi_cloud_cli-0.4.0}/tests/conftest.py

@@ -7,6 +7,8 @@ from unittest.mock import patch
 import pytest
 from typer import rich_utils
 
+from .utils import create_jwt_token
+
 
 @pytest.fixture(autouse=True)
 def reset_syspath() -> Generator[None, None, None]:
@@ -26,7 +28,9 @@ def setup_terminal() -> None:
 
 @pytest.fixture
 def logged_in_cli(temp_auth_config: Path) -> Generator[None, None, None]:
-    temp_auth_config.write_text('{"access_token": "test_token_12345"}')
+    valid_token = create_jwt_token({"sub": "test_user_12345"})
+
+    temp_auth_config.write_text(f'{{"access_token": "{valid_token}"}}')
 
     yield
 

fastapi_cloud_cli-0.4.0/tests/test_archive.py

@@ -0,0 +1,132 @@
+import tarfile
+from pathlib import Path
+
+import pytest
+
+from fastapi_cloud_cli.commands.deploy import archive
+
+
+@pytest.fixture
+def src_path(tmp_path: Path) -> Path:
+    path = tmp_path / "source"
+    path.mkdir()
+    return path
+
+
+@pytest.fixture
+def tar_path(tmp_path: Path) -> Path:
+    return tmp_path / "archive.tar"
+
+
+def test_archive_creates_tar_file(src_path: Path, tar_path: Path) -> None:
+    (src_path / "main.py").write_text("print('hello')")
+    (src_path / "config.json").write_text('{"key": "value"}')
+    (src_path / "subdir").mkdir()
+    (src_path / "subdir" / "utils.py").write_text("def helper(): pass")
+
+    archive(src_path, tar_path)
+    assert tar_path.exists()
+
+
+def test_archive_excludes_venv_and_similar_folders(
+    src_path: Path, tar_path: Path
+) -> None:
+    """Should exclude .venv directory from archive."""
+    # the only files we want to include
+    (src_path / "main.py").write_text("print('hello')")
+    (src_path / "static").mkdir()
+    (src_path / "static" / "index.html").write_text("<html></html>")
+    # virtualenv
+    (src_path / ".venv").mkdir()
+    (src_path / ".venv" / "lib").mkdir()
+    (src_path / ".venv" / "lib" / "package.py").write_text("# package")
+    # pycache
+    (src_path / "__pycache__").mkdir()
+    (src_path / "__pycache__" / "main.cpython-311.pyc").write_text("bytecode")
+    # pyc files
+    (src_path / "main.pyc").write_text("bytecode")
+    # mypy/pytest
+    (src_path / ".mypy_cache").mkdir()
+    (src_path / ".mypy_cache" / "file.json").write_text("{}")
+    (src_path / ".pytest_cache").mkdir()
+    (src_path / ".pytest_cache" / "cache.db").write_text("data")
+
+    archive(src_path, tar_path)
+
+    with tarfile.open(tar_path, "r") as tar:
+        names = tar.getnames()
+        assert set(names) == {"main.py", "static/index.html"}
+
+
+def test_archive_preserves_relative_paths(src_path: Path, tar_path: Path) -> None:
+    (src_path / "src").mkdir()
+    (src_path / "src" / "app").mkdir()
+    (src_path / "src" / "app" / "main.py").write_text("print('hello')")
+
+    archive(src_path, tar_path)
+
+    with tarfile.open(tar_path, "r") as tar:
+        names = tar.getnames()
+        assert names == ["src/app/main.py"]
+
+
+def test_archive_respects_fastapicloudignore(src_path: Path, tar_path: Path) -> None:
+    """Should exclude files specified in .fastapicloudignore."""
+    (src_path / "main.py").write_text("print('hello')")
+    (src_path / "config.py").write_text("CONFIG = 'value'")
+    (src_path / "secrets.env").write_text("SECRET_KEY=xyz")
+    (src_path / "data").mkdir()
+    (src_path / "data" / "file.txt").write_text("data")
+
+    (src_path / ".fastapicloudignore").write_text("secrets.env\ndata/\n")
+
+    archive(src_path, tar_path)
+
+    with tarfile.open(tar_path, "r") as tar:
+        names = tar.getnames()
+        assert set(names) == {
+            "main.py",
+            "config.py",
+        }
+
+
+def test_archive_respects_fastapicloudignore_unignore(
+    src_path: Path, tar_path: Path
+) -> None:
+    """Test we can use .fastapicloudignore to unignore files inside .gitignore"""
+    (src_path / "main.py").write_text("print('hello')")
+
+    (src_path / "ignore_me.txt").write_text("You should ignore me")
+
+    (src_path / "static/build").mkdir(exist_ok=True, parents=True)
+    (src_path / "static/build/style.css").write_text("body { background: #bada55 }")
+
+    # Rignore needs a .git folder to make .gitignore work
+    (src_path / ".git").mkdir(exist_ok=True, parents=True)
+    (src_path / ".gitignore").write_text("ignore_me.txt\nbuild/")
+
+    (src_path / ".fastapicloudignore").write_text("!static/build")
+
+    archive(src_path, tar_path)
+
+    with tarfile.open(tar_path, "r") as tar:
+        names = tar.getnames()
+        assert set(names) == {"main.py", "static/build/style.css"}
+
+
+def test_archive_includes_hidden_files(src_path: Path, tar_path: Path) -> None:
+    """Should include hidden files in the archive by default."""
+    (src_path / "main.py").write_text("print('hello')")
+    (src_path / ".env").write_text("SECRET_KEY=xyz")
+    (src_path / ".config").mkdir()
+    (src_path / ".config" / "settings.json").write_text('{"setting": "value"}')
+
+    archive(src_path, tar_path)
+
+    with tarfile.open(tar_path, "r") as tar:
+        names = tar.getnames()
+        assert set(names) == {
+            "main.py",
+            ".env",
+            ".config/settings.json",
+        }