fastapi-cloud-cli 0.15.1__tar.gz → 0.16.0__tar.gz

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.15.1
+Version: 0.16.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "sentry-sdk >= 2.20.0",
     "fastar >= 0.8.0",
 ]
-version = "0.15.1"
+version = "0.16.0"
 
 [project.license]
 text = "MIT"

fastapi_cloud_cli-0.16.0/scripts/add_latest_release_date.py

@@ -0,0 +1,40 @@
+"""Check release-notes.md and add today's date to the latest release header if missing."""
+
+import re
+import sys
+from datetime import date
+
+RELEASE_NOTES_FILE = "release-notes.md"
+RELEASE_HEADER_PATTERN = re.compile(r"^## (\d+\.\d+\.\d+)\s*(\(.*\))?\s*$")
+
+
+def main() -> None:
+    with open(RELEASE_NOTES_FILE) as f:
+        lines = f.readlines()
+
+    for i, line in enumerate(lines):
+        match = RELEASE_HEADER_PATTERN.match(line)
+        if not match:
+            continue
+
+        version = match.group(1)
+        date_part = match.group(2)
+
+        if date_part:
+            print(f"Latest release {version} already has a date: {date_part}")
+            sys.exit(0)
+
+        today = date.today().isoformat()
+        lines[i] = f"## {version} ({today})\n"
+        print(f"Added date: {version} ({today})")
+
+        with open(RELEASE_NOTES_FILE, "w") as f:
+            f.writelines(lines)
+        sys.exit(0)
+
+    print("No release header found")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

fastapi_cloud_cli-0.16.0/src/fastapi_cloud_cli/__init__.py

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

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/src/fastapi_cloud_cli/commands/deploy.py

@@ -7,7 +7,7 @@ import time
 from itertools import cycle
 from pathlib import Path, PurePosixPath
 from textwrap import dedent
-from typing import Annotated, Any
+from typing import Annotated, Any, BinaryIO, cast
 
 import fastar
 import rignore
@@ -17,6 +17,7 @@ from pydantic import AfterValidator, BaseModel, EmailStr, TypeAdapter, Validatio
 from rich.text import Text
 from rich_toolkit import RichToolkit
 from rich_toolkit.menu import Option
+from rich_toolkit.progress import Progress
 
 from fastapi_cloud_cli.commands.login import login
 from fastapi_cloud_cli.utils.api import (
@@ -29,6 +30,7 @@ from fastapi_cloud_cli.utils.api import (
 from fastapi_cloud_cli.utils.apps import AppConfig, get_app_config, write_app_config
 from fastapi_cloud_cli.utils.auth import Identity
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit, handle_http_errors
+from fastapi_cloud_cli.utils.progress_file import ProgressFile
 
 logger = logging.getLogger(__name__)
 
@@ -201,16 +203,32 @@ class RequestUploadResponse(BaseModel):
     fields: dict[str, str]
 
 
-def _upload_deployment(deployment_id: str, archive_path: Path) -> None:
+def _format_size(size_in_bytes: int) -> str:
+    if size_in_bytes >= 1024 * 1024:
+        return f"{size_in_bytes / (1024 * 1024):.2f} MB"
+    elif size_in_bytes >= 1024:
+        return f"{size_in_bytes / 1024:.2f} KB"
+    else:
+        return f"{size_in_bytes} bytes"
+
+
+def _upload_deployment(
+    deployment_id: str, archive_path: Path, progress: Progress
+) -> None:
+    archive_size = archive_path.stat().st_size
+    archive_size_str = _format_size(archive_size)
+
+    progress.log(f"Uploading deployment ({archive_size_str})...")
     logger.debug(
         "Starting deployment upload for deployment: %s",
         deployment_id,
     )
-    logger.debug(
-        "Archive path: %s, size: %s bytes",
-        archive_path,
-        archive_path.stat().st_size,
-    )
+    logger.debug("Archive path: %s, size: %s bytes", archive_path, archive_size)
+
+    def progress_callback(bytes_read: int) -> None:
+        progress.log(
+            f"Uploading deployment ({_format_size(bytes_read)} of {archive_size_str})..."
+        )
 
     with APIClient() as fastapi_client, Client() as client:
         # Get the upload URL
@@ -223,10 +241,13 @@ def _upload_deployment(deployment_id: str, archive_path: Path) -> None:
 
         logger.debug("Starting file upload to S3")
         with open(archive_path, "rb") as archive_file:
+            archive_file_with_progress = ProgressFile(
+                archive_file, progress_callback=progress_callback
+            )
             upload_response = client.post(
                 upload_data.url,
                 data=upload_data.fields,
-                files={"file": archive_file},
+                files={"file": cast(BinaryIO, archive_file_with_progress)},
             )
 
         upload_response.raise_for_status()
@@ -769,9 +790,7 @@ def deploy(
                         f"Deployment created successfully! Deployment slug: {deployment.slug}"
                     )
 
-                    progress.log("Uploading deployment...")
-
-                    _upload_deployment(deployment.id, archive_path)
+                    _upload_deployment(deployment.id, archive_path, progress=progress)
 
                     progress.log("Deployment uploaded successfully!")
                 except KeyboardInterrupt:

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/src/fastapi_cloud_cli/utils/api.py

@@ -141,6 +141,7 @@ def attempts(
 
 class DeploymentStatus(str, Enum):
     waiting_upload = "waiting_upload"
+    upload_cancelled = "upload_cancelled"
     ready_for_build = "ready_for_build"
     building = "building"
     extracting = "extracting"
@@ -153,24 +154,27 @@ class DeploymentStatus(str, Enum):
     verifying_failed = "verifying_failed"
     verifying_skipped = "verifying_skipped"
     success = "success"
+    expired = "expired"
     failed = "failed"
 
     @classmethod
     def to_human_readable(cls, status: "DeploymentStatus") -> str:
         return {
-            cls.waiting_upload: "Waiting for upload",
-            cls.ready_for_build: "Ready for build",
+            cls.waiting_upload: "Awaiting Upload",
+            cls.upload_cancelled: "Upload Cancelled",
+            cls.ready_for_build: "Build Queued",
             cls.building: "Building",
-            cls.extracting: "Extracting",
-            cls.extracting_failed: "Extracting failed",
-            cls.building_image: "Building image",
-            cls.building_image_failed: "Build failed",
-            cls.deploying: "Deploying",
-            cls.deploying_failed: "Deploying failed",
-            cls.verifying: "Verifying",
-            cls.verifying_failed: "Verifying failed",
-            cls.verifying_skipped: "Verification skipped",
-            cls.success: "Success",
+            cls.extracting: "Extracting Upload",
+            cls.extracting_failed: "Extraction Failed",
+            cls.building_image: "Building Image",
+            cls.building_image_failed: "Build Failed",
+            cls.deploying: "Deploying Image",
+            cls.deploying_failed: "Deployment Failed",
+            cls.verifying: "Verifying Readiness",
+            cls.verifying_failed: "Verification Failed",
+            cls.verifying_skipped: "Verification Skipped",
+            cls.success: "Ready",
+            cls.expired: "Expired",
             cls.failed: "Failed",
         }[status]
 

fastapi_cloud_cli-0.16.0/src/fastapi_cloud_cli/utils/progress_file.py

@@ -0,0 +1,30 @@
+from collections.abc import Callable
+from datetime import datetime
+from typing import Any, BinaryIO
+
+
+class ProgressFile:
+    """Wrap a binary file object and report upload progress as it is read."""
+
+    def __init__(
+        self,
+        file: BinaryIO,
+        progress_callback: Callable[[int], None],
+        update_interval: float = 0.5,
+    ) -> None:
+        self._file = file
+        self._progress_callback = progress_callback
+        self._update_interval = update_interval
+        self._last_update_time = 0.0
+
+    def read(self, n: int = -1) -> bytes:
+        data = self._file.read(n)
+        now_ = datetime.now().timestamp()
+        is_eof = (len(data) == 0) or (n > 0 and len(data) < n)
+        if (now_ - self._last_update_time >= self._update_interval) or is_eof:
+            self._progress_callback(self._file.tell())
+            self._last_update_time = now_
+        return data
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._file, name)

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/tests/test_cli_deploy.py

@@ -1,4 +1,5 @@
 import random
+import re
 import string
 from datetime import timedelta
 from pathlib import Path
@@ -10,6 +11,7 @@ import pytest
 import respx
 from click.testing import Result
 from httpx import Response
+from rich_toolkit.progress import Progress
 from time_machine import TimeMachineFixture
 from typer.testing import CliRunner
 
@@ -1656,6 +1658,101 @@ def test_deploy_with_token_fails(
         )
 
 
+@pytest.mark.parametrize(
+    ("size", "expected_msgs"),
+    [
+        (
+            100,
+            [
+                r"\(\d+ bytes\)",  # e.g. "(123 bytes)"
+                r"\(\d+ bytes of \d+ bytes\)",  # e.g. "(123 bytes of 456 bytes)"
+            ],
+        ),
+        (
+            10 * 1024,
+            [
+                r"\(\d+\.\d+ KB\)",  # e.g. "(1.23 KB)"
+                r"\(\d+\.\d+ KB of \d+\.\d+ KB\)",  # e.g. "(1.23 KB of 4.56 KB)"
+            ],
+        ),
+        (
+            10 * 1024 * 1024,
+            [
+                r"\(\d+\.\d+ MB\)",  # e.g. "(1.23 MB)"
+                r"\(\d+\.\d+ KB of \d+\.\d+ MB\)",  # e.g. "(1.23 KB of 4.56 MB)"
+                r"\(\d+\.\d+ MB of \d+\.\d+ MB\)",  # e.g. "(1.23 MB of 4.56 MB)"
+            ],
+        ),
+    ],
+)
+@pytest.mark.respx
+def test_upload_deployment_progress(
+    logged_in_cli: None,
+    tmp_path: Path,
+    respx_mock: respx.MockRouter,
+    size: int,
+    expected_msgs: list[str],
+) -> None:
+    app_data = _get_random_app()
+    team_data = _get_random_team()
+    app_id = app_data["id"]
+    team_id = team_data["id"]
+    deployment_data = _get_random_deployment(app_id=app_id)
+    deployment_id = deployment_data["id"]
+
+    config_path = tmp_path / ".fastapicloud" / "cloud.json"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(f'{{"app_id": "{app_id}", "team_id": "{team_id}"}}')
+
+    (tmp_path / "file.bin").write_bytes(random.randbytes(size))
+
+    respx_mock.get(f"/apps/{app_id}").mock(return_value=Response(200, json=app_data))
+    respx_mock.post(f"/apps/{app_id}/deployments/").mock(
+        return_value=Response(201, json=deployment_data)
+    )
+    respx_mock.post(f"/deployments/{deployment_id}/upload").mock(
+        return_value=Response(
+            200,
+            json={"url": "http://test.com", "fields": {"key": "value"}},
+        )
+    )
+    respx_mock.post("http://test.com", data={"key": "value"}).mock(
+        return_value=Response(200)
+    )
+    respx_mock.post(f"/deployments/{deployment_id}/upload-complete").mock(
+        return_value=Response(200)
+    )
+    respx_mock.get(f"/deployments/{deployment_id}/build-logs").mock(
+        return_value=Response(
+            200,
+            content=build_logs_response(
+                {"type": "message", "message": "Building...", "id": "1"},
+                {"type": "complete"},
+            ),
+        )
+    )
+    respx_mock.get(f"/apps/{app_id}/deployments/{deployment_id}").mock(
+        return_value=Response(200, json={**deployment_data, "status": "success"})
+    )
+
+    with (
+        changing_dir(tmp_path),
+        patch.object(Progress, "log") as mock_progress,
+    ):
+        result = runner.invoke(app, ["deploy"])
+        assert result.exit_code == 0
+
+    call_args = [
+        c.args[0] for c in mock_progress.call_args_list if isinstance(c.args[0], str)
+    ]
+
+    for expected_msg in expected_msgs:
+        pattern = re.compile(f"Uploading deployment {expected_msg}\\.\\.\\.")
+        assert any(pattern.match(arg) for arg in call_args), (
+            f"Expected message '{pattern.pattern}' not found in {call_args}"
+        )
+
+
 @pytest.mark.respx
 def test_deploy_with_app_id_arg(
     logged_in_cli: None, tmp_path: Path, respx_mock: respx.MockRouter
@@ -1916,7 +2013,7 @@ def test_verification_failure_after_build_complete(
 
         assert result.exit_code == 1
         assert "Deployment failed" in result.output
-        assert "Verifying failed" in result.output
+        assert "Verification Failed" in result.output
         assert deployment_data["dashboard_url"] in result.output
 
 

{fastapi_cloud_cli-0.15.1 → fastapi_cloud_cli-0.16.0}/tests/test_deploy_utils.py

@@ -58,19 +58,20 @@ def test_includes_paths(path: Path) -> None:
 @pytest.mark.parametrize(
     "status,expected",
     [
-        (DeploymentStatus.waiting_upload, "Waiting for upload"),
-        (DeploymentStatus.ready_for_build, "Ready for build"),
+        (DeploymentStatus.waiting_upload, "Awaiting Upload"),
+        (DeploymentStatus.ready_for_build, "Build Queued"),
         (DeploymentStatus.building, "Building"),
-        (DeploymentStatus.extracting, "Extracting"),
-        (DeploymentStatus.extracting_failed, "Extracting failed"),
-        (DeploymentStatus.building_image, "Building image"),
-        (DeploymentStatus.building_image_failed, "Build failed"),
-        (DeploymentStatus.deploying, "Deploying"),
-        (DeploymentStatus.deploying_failed, "Deploying failed"),
-        (DeploymentStatus.verifying, "Verifying"),
-        (DeploymentStatus.verifying_failed, "Verifying failed"),
-        (DeploymentStatus.verifying_skipped, "Verification skipped"),
-        (DeploymentStatus.success, "Success"),
+        (DeploymentStatus.extracting, "Extracting Upload"),
+        (DeploymentStatus.extracting_failed, "Extraction Failed"),
+        (DeploymentStatus.building_image, "Building Image"),
+        (DeploymentStatus.building_image_failed, "Build Failed"),
+        (DeploymentStatus.deploying, "Deploying Image"),
+        (DeploymentStatus.deploying_failed, "Deployment Failed"),
+        (DeploymentStatus.verifying, "Verifying Readiness"),
+        (DeploymentStatus.verifying_failed, "Verification Failed"),
+        (DeploymentStatus.verifying_skipped, "Verification Skipped"),
+        (DeploymentStatus.success, "Ready"),
+        (DeploymentStatus.expired, "Expired"),
         (DeploymentStatus.failed, "Failed"),
     ],
 )

fastapi_cloud_cli-0.16.0/tests/test_progress_file.py

@@ -0,0 +1,104 @@
+import io
+from datetime import datetime, timezone
+from unittest.mock import Mock, call
+
+import time_machine
+
+from fastapi_cloud_cli.utils.progress_file import ProgressFile
+
+
+def _make_file(
+    content: bytes = b"hello world", name: str = "test.tar.gz"
+) -> io.BytesIO:
+    f = io.BytesIO(content)
+    f.name = name
+    return f
+
+
+def test_read_with_size() -> None:
+    file = _make_file(b"abcdef")
+    pf = ProgressFile(file, progress_callback=lambda _: None)
+
+    assert pf.read(3) == b"abc"
+    assert pf.read(3) == b"def"
+
+
+def test_callback_not_called_within_interval() -> None:
+    file = _make_file(b"abcdef")
+    mock_callback = Mock()
+    pf = ProgressFile(file, progress_callback=mock_callback)
+
+    pf.read(3)  # Should trigger callback
+    pf.read(3)  # Should NOT trigger
+
+    mock_callback.assert_called_once_with(3)
+
+
+def test_callback_called_after_interval_elapses() -> None:
+    file = _make_file(b"abcdef")
+    mock_callback = Mock()
+
+    with time_machine.travel(
+        datetime(2026, 1, 1, tzinfo=timezone.utc), tick=False
+    ) as traveller:
+        pf = ProgressFile(file, progress_callback=mock_callback)
+
+        pf.read(3)
+        traveller.shift(0.6)
+        pf.read(3)
+
+    mock_callback.assert_has_calls([call(3), call(6)])
+
+
+def test_callback_tracks_cumulative_bytes() -> None:
+    file = _make_file(b"a" * 100)
+    mock_callback = Mock()
+
+    with time_machine.travel(
+        datetime(2026, 1, 1, tzinfo=timezone.utc), tick=False
+    ) as traveller:
+        pf = ProgressFile(file, progress_callback=mock_callback)
+
+        pf.read(10)  # Should trigger callback with 10 bytes read
+        traveller.shift(0.1)
+        pf.read(10)
+        traveller.shift(0.5)
+        pf.read(10)  # Should trigger callback with 10 + 10 + 10 = 30 bytes read
+        traveller.shift(0.6)
+        pf.read(10)  # Should trigger callback with 30 + 10 = 40 bytes read
+
+    mock_callback.assert_has_calls([call(10), call(30), call(40)])
+
+
+def test_callback_called_on_eof() -> None:
+    file = _make_file(b"abcd")
+    mock_callback = Mock()
+
+    pf = ProgressFile(file, progress_callback=mock_callback)
+    pf.read(3)
+    pf.read(3)
+    mock_callback.assert_has_calls([call(3), call(4)])
+
+
+def test_name_property() -> None:
+    file = _make_file(name="test.tar.gz")
+    pf = ProgressFile(file, progress_callback=lambda _: None)
+
+    assert pf.name == "test.tar.gz"
+
+
+def test_callback_uses_current_file_position_after_seek() -> None:
+    file = _make_file(b"abcde")
+    mock_callback = Mock()
+
+    pf = ProgressFile(file, progress_callback=mock_callback)
+
+    pf.read(3)
+
+    # Imitate retrying
+    pf.seek(0)
+    pf.read(3)
+
+    pf.read(3)
+
+    mock_callback.assert_has_calls([call(3), call(5)])

fastapi_cloud_cli-0.15.1/src/fastapi_cloud_cli/__init__.py

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