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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.3.1
+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.1 → 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.1"
+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.1 → 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.1 → 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
@@ -35,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
@@ -46,29 +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
 
-            logger.debug("Adding %s to archive", filename.relative_to(path))
-            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]
@@ -494,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,
@@ -579,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)
 
@@ -600,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.1 → 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")
 

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.1 → 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",
+        }

fastapi_cloud_cli-0.4.0/tests/test_auth.py

@@ -0,0 +1,107 @@
+import base64
+import time
+from pathlib import Path
+
+import pytest
+
+from fastapi_cloud_cli.utils.auth import (
+    AuthConfig,
+    is_logged_in,
+    is_token_expired,
+    write_auth_config,
+)
+
+from .utils import create_jwt_token
+
+
+def test_is_token_expired_with_valid_token() -> None:
+    future_exp = int(time.time()) + 3600
+
+    token = create_jwt_token({"exp": future_exp, "sub": "test_user"})
+
+    assert not is_token_expired(token)
+
+
+def test_is_token_expired_with_expired_token() -> None:
+    past_exp = int(time.time()) - 3600
+    token = create_jwt_token({"exp": past_exp, "sub": "test_user"})
+
+    assert is_token_expired(token)
+
+
+def test_is_token_expired_with_no_exp_claim() -> None:
+    token = create_jwt_token({"sub": "test_user"})
+
+    # Tokens without exp claim should be considered valid
+    assert not is_token_expired(token)
+
+
+@pytest.mark.parametrize(
+    "token",
+    [
+        "not.a.valid.jwt.token",
+        "only.two",
+        "invalid",
+        "",
+        "...",
+    ],
+)
+def test_is_token_expired_with_malformed_token(token: str) -> None:
+    assert is_token_expired(token)
+
+
+def test_is_token_expired_with_invalid_base64() -> None:
+    token = "header.!!!invalid_signature!!!.signature"
+    assert is_token_expired(token)
+
+
+def test_is_token_expired_with_invalid_json() -> None:
+    header_encoded = base64.urlsafe_b64encode(b'{"alg":"HS256"}').decode().rstrip("=")
+    payload_encoded = base64.urlsafe_b64encode(b"{invalid json}").decode().rstrip("=")
+    signature = base64.urlsafe_b64encode(b"signature").decode().rstrip("=")
+    token = f"{header_encoded}.{payload_encoded}.{signature}"
+
+    assert is_token_expired(token)
+
+
+def test_is_logged_in_with_no_token(temp_auth_config: Path) -> None:
+    assert not temp_auth_config.exists()
+    assert not is_logged_in()
+
+
+def test_is_logged_in_with_valid_token(temp_auth_config: Path) -> None:
+    future_exp = int(time.time()) + 3600
+    token = create_jwt_token({"exp": future_exp, "sub": "test_user"})
+
+    write_auth_config(AuthConfig(access_token=token))
+
+    assert is_logged_in()
+
+
+def test_is_logged_in_with_expired_token(temp_auth_config: Path) -> None:
+    past_exp = int(time.time()) - 3600
+    token = create_jwt_token({"exp": past_exp, "sub": "test_user"})
+
+    write_auth_config(AuthConfig(access_token=token))
+
+    assert not is_logged_in()
+
+
+def test_is_logged_in_with_malformed_token(temp_auth_config: Path) -> None:
+    write_auth_config(AuthConfig(access_token="not.a.valid.token"))
+
+    assert not is_logged_in()
+
+
+def test_is_token_expired_edge_case_exact_expiration() -> None:
+    current_time = int(time.time())
+    token = create_jwt_token({"exp": current_time, "sub": "test_user"})
+
+    assert is_token_expired(token)
+
+
+def test_is_token_expired_edge_case_one_second_before() -> None:
+    current_time = int(time.time())
+    token = create_jwt_token({"exp": current_time + 1, "sub": "test_user"})
+
+    assert not is_token_expired(token)

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_cli_login.py

@@ -1,3 +1,4 @@
+import time
 from pathlib import Path
 from unittest.mock import patch
 
@@ -9,6 +10,7 @@ from typer.testing import CliRunner
 
 from fastapi_cloud_cli.cli import app
 from fastapi_cloud_cli.config import Settings
+from tests.utils import create_jwt_token
 
 runner = CliRunner()
 settings = Settings.get()
@@ -162,3 +164,54 @@ def test_fetch_access_token_handles_500_error(respx_mock: respx.MockRouter) -> N
     with APIClient() as client:
         with pytest.raises(httpx.HTTPStatusError):
             _fetch_access_token(client, "test_device_code", 5)
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_notify_already_logged_in_user(
+    respx_mock: respx.MockRouter, logged_in_cli: None
+) -> None:
+    result = runner.invoke(app, ["login"])
+
+    assert result.exit_code == 0
+    assert "You are already logged in." in result.output
+    assert "Run fastapi logout first if you want to switch accounts." in result.output
+
+
+@pytest.mark.respx(base_url=settings.base_api_url)
+def test_notify_expired_token_user(
+    respx_mock: respx.MockRouter, temp_auth_config: Path
+) -> None:
+    past_exp = int(time.time()) - 3600
+    expired_token = create_jwt_token({"sub": "test_user_12345", "exp": past_exp})
+
+    temp_auth_config.write_text(f'{{"access_token": "{expired_token}"}}')
+
+    with patch("fastapi_cloud_cli.commands.login.typer.launch") as mock_open:
+        respx_mock.post(
+            "/login/device/authorization", data={"client_id": settings.client_id}
+        ).mock(
+            return_value=Response(
+                200,
+                json={
+                    "verification_uri_complete": "http://test.com",
+                    "verification_uri": "http://test.com",
+                    "user_code": "1234",
+                    "device_code": "5678",
+                },
+            )
+        )
+        respx_mock.post(
+            "/login/device/token",
+            data={
+                "device_code": "5678",
+                "client_id": settings.client_id,
+                "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+            },
+        ).mock(return_value=Response(200, json={"access_token": "new_token_1234"}))
+
+        result = runner.invoke(app, ["login"])
+
+        assert result.exit_code == 0
+        assert "Your session has expired. Logging in again..." in result.output
+        assert "Now you are logged in!" in result.output
+        assert mock_open.called

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_cli_logout.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 
 runner = CliRunner()
 

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_cli_unlink.py

@@ -3,7 +3,7 @@ from unittest.mock import patch
 
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 
 runner = CliRunner()
 

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_cli_whoami.py

@@ -5,7 +5,7 @@ import respx
 from httpx import ReadTimeout, Response
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 from fastapi_cloud_cli.config import Settings
 
 runner = CliRunner()

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_deploy_utils.py

@@ -58,6 +58,7 @@ def test_includes_paths(path: Path) -> None:
         (DeploymentStatus.deploying_failed, "Deploying failed"),
         (DeploymentStatus.verifying, "Verifying"),
         (DeploymentStatus.verifying_failed, "Verifying failed"),
+        (DeploymentStatus.verifying_skipped, "Verification skipped"),
         (DeploymentStatus.success, "Success"),
         (DeploymentStatus.failed, "Failed"),
     ],

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_env_delete.py

@@ -6,7 +6,7 @@ import respx
 from httpx import Response
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 from fastapi_cloud_cli.config import Settings
 from tests.utils import Keys, changing_dir
 

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_env_list.py

@@ -5,7 +5,7 @@ import respx
 from httpx import Response
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 from fastapi_cloud_cli.config import Settings
 from tests.conftest import ConfiguredApp
 from tests.utils import changing_dir

{fastapi_cloud_cli-0.3.1 → fastapi_cloud_cli-0.4.0}/tests/test_env_set.py

@@ -6,7 +6,7 @@ import respx
 from httpx import Response
 from typer.testing import CliRunner
 
-from fastapi_cloud_cli.cli import app
+from fastapi_cloud_cli.cli import cloud_app as app
 from fastapi_cloud_cli.config import Settings
 from tests.utils import Keys, changing_dir
 

fastapi_cloud_cli-0.4.0/tests/utils.py

@@ -0,0 +1,42 @@
+import base64
+import json
+import os
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Any, Dict, Generator, Union
+
+
+@contextmanager
+def changing_dir(directory: Union[str, Path]) -> Generator[None, None, None]:
+    initial_dir = os.getcwd()
+    os.chdir(directory)
+    try:
+        yield
+    finally:
+        os.chdir(initial_dir)
+
+
+class Keys:
+    RIGHT_ARROW = "\x1b[C"
+    DOWN_ARROW = "\x1b[B"
+    ENTER = "\r"
+    CTRL_C = "\x03"
+    TAB = "\t"
+
+
+def create_jwt_token(payload: Dict[str, Any]) -> str:
+    # Note: This creates a JWT with an invalid signature, but that's OK for our tests
+    # since we only parse the payload, not verify the signature.
+
+    header = {"alg": "HS256", "typ": "JWT"}
+    header_encoded = (
+        base64.urlsafe_b64encode(json.dumps(header).encode()).decode().rstrip("=")
+    )
+
+    payload_encoded = (
+        base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=")
+    )
+
+    signature = base64.urlsafe_b64encode(b"signature").decode().rstrip("=")
+
+    return f"{header_encoded}.{payload_encoded}.{signature}"

fastapi_cloud_cli-0.3.1/src/fastapi_cloud_cli/__init__.py

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

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

@@ -1,61 +0,0 @@
-import logging
-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_logged_in() -> bool:
-    result = get_auth_token() is not None
-    logger.debug("Login status: %s", result)
-    return result

fastapi_cloud_cli-0.3.1/tests/test_archive.py

@@ -1,103 +0,0 @@
-import tarfile
-from pathlib import Path
-
-from fastapi_cloud_cli.commands.deploy import archive
-
-
-def test_archive_creates_tar_file(tmp_path: Path) -> None:
-    (tmp_path / "main.py").write_text("print('hello')")
-    (tmp_path / "config.json").write_text('{"key": "value"}')
-    (tmp_path / "subdir").mkdir()
-    (tmp_path / "subdir" / "utils.py").write_text("def helper(): pass")
-
-    tar_path = archive(tmp_path)
-
-    assert tar_path.exists()
-    assert tar_path.suffix == ".tar"
-    assert tar_path.name.startswith("fastapi-cloud-deploy-")
-
-
-def test_archive_excludes_venv_and_similar_folders(tmp_path: Path) -> None:
-    """Should exclude .venv directory from archive."""
-    # the only files we want to include
-    (tmp_path / "main.py").write_text("print('hello')")
-    (tmp_path / "static").mkdir()
-    (tmp_path / "static" / "index.html").write_text("<html></html>")
-    # virtualenv
-    (tmp_path / ".venv").mkdir()
-    (tmp_path / ".venv" / "lib").mkdir()
-    (tmp_path / ".venv" / "lib" / "package.py").write_text("# package")
-    # pycache
-    (tmp_path / "__pycache__").mkdir()
-    (tmp_path / "__pycache__" / "main.cpython-311.pyc").write_text("bytecode")
-    # pyc files
-    (tmp_path / "main.pyc").write_text("bytecode")
-    # mypy/pytest
-    (tmp_path / ".mypy_cache").mkdir()
-    (tmp_path / ".mypy_cache" / "file.json").write_text("{}")
-    (tmp_path / ".pytest_cache").mkdir()
-    (tmp_path / ".pytest_cache" / "cache.db").write_text("data")
-
-    tar_path = archive(tmp_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(tmp_path: Path) -> None:
-    (tmp_path / "src").mkdir()
-    (tmp_path / "src" / "app").mkdir()
-    (tmp_path / "src" / "app" / "main.py").write_text("print('hello')")
-
-    tar_path = archive(tmp_path)
-
-    with tarfile.open(tar_path, "r") as tar:
-        names = tar.getnames()
-        assert names == ["src/app/main.py"]
-
-
-def test_archive_respects_fastapicloudignore(tmp_path: Path) -> None:
-    """Should exclude files specified in .fastapicloudignore."""
-    # Create test files
-    (tmp_path / "main.py").write_text("print('hello')")
-    (tmp_path / "config.py").write_text("CONFIG = 'value'")
-    (tmp_path / "secrets.env").write_text("SECRET_KEY=xyz")
-    (tmp_path / "data").mkdir()
-    (tmp_path / "data" / "file.txt").write_text("data")
-
-    # Create .fastapicloudignore file
-    (tmp_path / ".fastapicloudignore").write_text("secrets.env\ndata/\n")
-
-    # Create archive
-    tar_path = archive(tmp_path)
-
-    # Verify ignored files are excluded
-    with tarfile.open(tar_path, "r") as tar:
-        names = tar.getnames()
-        assert set(names) == {
-            "main.py",
-            "config.py",
-        }
-
-
-def test_archive_respects_fastapicloudignore_unignore(tmp_path: Path) -> None:
-    """Test we can use .fastapicloudignore to unignore files inside .gitignore"""
-    # Create test files
-    (tmp_path / "main.py").write_text("print('hello')")
-    (tmp_path / "static/build").mkdir(exist_ok=True, parents=True)
-    (tmp_path / "static/build/style.css").write_text("body { background: #bada55 }")
-    # Rignore needs a .git folder to make .gitignore work
-    (tmp_path / ".git").mkdir(exist_ok=True, parents=True)
-    (tmp_path / ".gitignore").write_text("build/")
-
-    # Create .fastapicloudignore file
-    (tmp_path / ".fastapicloudignore").write_text("!static/build")
-
-    # Create archive
-    tar_path = archive(tmp_path)
-
-    # Verify ignored files are excluded
-    with tarfile.open(tar_path, "r") as tar:
-        names = tar.getnames()
-        assert set(names) == {"main.py", "static/build/style.css"}

fastapi_cloud_cli-0.3.1/tests/utils.py

@@ -1,22 +0,0 @@
-import os
-from contextlib import contextmanager
-from pathlib import Path
-from typing import Generator, Union
-
-
-@contextmanager
-def changing_dir(directory: Union[str, Path]) -> Generator[None, None, None]:
-    initial_dir = os.getcwd()
-    os.chdir(directory)
-    try:
-        yield
-    finally:
-        os.chdir(initial_dir)
-
-
-class Keys:
-    RIGHT_ARROW = "\x1b[C"
-    DOWN_ARROW = "\x1b[B"
-    ENTER = "\r"
-    CTRL_C = "\x03"
-    TAB = "\t"