trossen-cloud-cli 0.1.2__py3-none-any.whl

trossen_cloud_cli/__init__.py

@@ -0,0 +1,7 @@
+"""Trossen CLI - A Python CLI for Trossen Cloud."""
+
+__version__ = "0.1.0"
+
+from .cli import app
+
+__all__ = ["app", "__version__"]

trossen_cloud_cli/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running as a module: python -m trossen_cloud_cli"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

trossen_cloud_cli/api_client.py

@@ -0,0 +1,269 @@
+"""HTTP client wrapper with authentication injection."""
+
+import asyncio
+import os
+from typing import Any
+
+import httpx
+
+from .auth import get_token
+
+API_BASE_URL = os.environ.get("TROSSEN_API_URL", "https://cloud.trossen.com/api/v1")
+
+
+class ApiError(Exception):
+    """
+    API error with status code and message.
+    """
+
+    def __init__(self, status_code: int, message: str, details: dict | None = None):
+        self.status_code = status_code
+        self.message = message
+        self.details = details or {}
+        super().__init__(f"API Error {status_code}: {message}")
+
+
+class ApiClient:
+    """
+    HTTP client with authentication and retry logic.
+    """
+
+    def __init__(self, base_url: str | None = None):
+        """
+        Initialize API client.
+        """
+        self.base_url = base_url or API_BASE_URL
+        self._access_token: str | None = None
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> "ApiClient":
+        """
+        Enter async context.
+        """
+        self._access_token = get_token()
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=httpx.Timeout(30.0, connect=10.0),
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exit async context.
+        """
+        if self._client:
+            await self._client.aclose()
+
+    def _get_headers(self) -> dict[str, str]:
+        """
+        Get request headers with auth token.
+        """
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if self._access_token:
+            headers["X-API-Token"] = self._access_token
+        return headers
+
+    async def _handle_response(self, response: httpx.Response) -> Any:
+        """
+        Handle API response and raise errors if needed.
+        """
+        if response.status_code == 401:
+            raise ApiError(401, "Authentication failed. Check your token or run 'trc auth login'")
+
+        if response.status_code == 403:
+            detail = "Access denied"
+            try:
+                error_data = response.json()
+                if msg := error_data.get("message", error_data.get("detail")):
+                    detail = msg
+            except ValueError:
+                pass
+            raise ApiError(403, detail)
+
+        if response.status_code == 404:
+            raise ApiError(404, "Resource not found")
+
+        if response.status_code >= 400:
+            try:
+                error_data = response.json()
+                message = error_data.get("message", error_data.get("detail", "Unknown error"))
+                raise ApiError(response.status_code, message, error_data)
+            except ValueError:
+                raise ApiError(response.status_code, response.text)
+
+        if response.status_code == 204:
+            return {}
+
+        try:
+            return response.json()
+        except ValueError:
+            return {"data": response.text}
+
+    async def _request_with_retry(
+        self,
+        method: str,
+        path: str,
+        max_retries: int = 5,
+        **kwargs,
+    ) -> Any:
+        """
+        Make request with exponential backoff retry.
+        """
+        if not self._client:
+            raise RuntimeError("Client not initialized. Use async context manager.")
+
+        last_error: Exception | None = None
+
+        for attempt in range(max_retries):
+            try:
+                response = await self._client.request(
+                    method,
+                    path,
+                    headers=self._get_headers(),
+                    **kwargs,
+                )
+                return await self._handle_response(response)
+
+            except httpx.TimeoutException:
+                last_error = ApiError(408, "Request timeout")
+            except httpx.ConnectError:
+                last_error = ApiError(503, "Could not connect to server")
+            except ApiError as e:
+                if e.status_code >= 500 or e.status_code == 429:
+                    last_error = e
+                else:
+                    raise
+
+            # Exponential backoff
+            if attempt < max_retries - 1:
+                wait_time = (2**attempt) * 0.5
+                await asyncio.sleep(wait_time)
+
+        if last_error:
+            raise last_error
+        raise ApiError(500, "Unknown error occurred")
+
+    async def get(self, path: str, params: dict | None = None) -> Any:
+        """
+        Make GET request.
+        """
+        return await self._request_with_retry("GET", path, params=params)
+
+    async def post(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make POST request.
+        """
+        return await self._request_with_retry("POST", path, json=json)
+
+    async def put(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make PUT request.
+        """
+        return await self._request_with_retry("PUT", path, json=json)
+
+    async def delete(self, path: str) -> Any:
+        """
+        Make DELETE request.
+        """
+        return await self._request_with_retry("DELETE", path)
+
+    async def patch(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make PATCH request.
+        """
+        return await self._request_with_retry("PATCH", path, json=json)
+
+
+class SyncApiClient:
+    """
+    Synchronous wrapper around the async API client.
+    """
+
+    def __init__(self, base_url: str | None = None):
+        """
+        Initialize sync API client.
+        """
+        self.base_url = base_url
+        self._async_client: ApiClient | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    def __enter__(self) -> "SyncApiClient":
+        """
+        Enter sync context.
+        """
+        self._loop = asyncio.new_event_loop()
+        self._async_client = ApiClient(self.base_url)
+        try:
+            self._loop.run_until_complete(self._async_client.__aenter__())
+        except BaseException:
+            self._loop.close()
+            self._loop = None
+            raise
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exit sync context.
+        """
+        if self._async_client and self._loop:
+            self._loop.run_until_complete(self._async_client.__aexit__(exc_type, exc_val, exc_tb))
+        if self._loop:
+            self._loop.close()
+
+    def _run(self, coro):
+        """
+        Run coroutine synchronously.
+        """
+        if not self._loop:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._loop.run_until_complete(coro)
+
+    def get(self, path: str, params: dict | None = None) -> Any:
+        """
+        Make GET request.
+        """
+        if not self._async_client:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._run(self._async_client.get(path, params))
+
+    def post(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make POST request.
+        """
+        if not self._async_client:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._run(self._async_client.post(path, json))
+
+    def put(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make PUT request.
+        """
+        if not self._async_client:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._run(self._async_client.put(path, json))
+
+    def delete(self, path: str) -> Any:
+        """
+        Make DELETE request.
+        """
+        if not self._async_client:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._run(self._async_client.delete(path))
+
+    def patch(self, path: str, json: dict | None = None) -> Any:
+        """
+        Make PATCH request.
+        """
+        if not self._async_client:
+            raise RuntimeError("Client not initialized. Use context manager.")
+        return self._run(self._async_client.patch(path, json))
+
+
+def get_api_client() -> ApiClient:
+    """
+    Get a new API client instance.
+    """
+    return ApiClient()

trossen_cloud_cli/auth.py

@@ -0,0 +1,172 @@
+"""Authentication commands and token management."""
+
+import os
+import stat
+
+import keyring
+import typer
+from rich.prompt import Prompt
+
+from .config import get_token_file
+from .output import console
+from .types import StoredToken
+
+KEYRING_SERVICE = "trossen-cloud-cli"
+KEYRING_USERNAME = "tokens"
+
+
+def _store_token_keyring(token: str) -> bool:
+    """
+    Store token in system keyring.
+    """
+    try:
+        data = StoredToken(token=token).model_dump_json()
+        keyring.set_password(KEYRING_SERVICE, KEYRING_USERNAME, data)
+        return True
+    except Exception:
+        return False
+
+
+def _store_token_file(token: str) -> None:
+    """
+    Store token in file with restricted permissions.
+    """
+    token_file = get_token_file()
+    data = StoredToken(token=token).model_dump_json()
+
+    with open(token_file, "w") as f:
+        f.write(data)
+
+    # Set file permissions to owner-only read/write
+    os.chmod(token_file, stat.S_IRUSR | stat.S_IWUSR)
+
+
+def _load_token_keyring() -> str | None:
+    """
+    Load token from system keyring.
+    """
+    try:
+        data = keyring.get_password(KEYRING_SERVICE, KEYRING_USERNAME)
+        if data:
+            return StoredToken.model_validate_json(data).token
+    except Exception:
+        pass
+    return None
+
+
+def _load_token_file() -> str | None:
+    """
+    Load token from file.
+    """
+    token_file = get_token_file()
+    if token_file.exists():
+        try:
+            with open(token_file) as f:
+                data = f.read()
+            return StoredToken.model_validate_json(data).token
+        except Exception:
+            pass
+    return None
+
+
+def store_token(token: str) -> None:
+    """
+    Store token securely (keyring with file fallback).
+    """
+    if not _store_token_keyring(token):
+        _store_token_file(token)
+
+
+def load_token() -> str | None:
+    """
+    Load token from storage. Env var takes priority.
+    """
+    if token := os.environ.get("TROSSEN_TOKEN"):
+        return token
+
+    # Try keyring first, then file
+    token = _load_token_keyring()
+    if token is None:
+        token = _load_token_file()
+
+    return token
+
+
+def get_token() -> str | None:
+    """
+    Get the stored API token.
+    """
+    return load_token()
+
+
+def clear_token() -> None:
+    """
+    Clear stored token.
+    """
+    # Clear from keyring
+    try:
+        keyring.delete_password(KEYRING_SERVICE, KEYRING_USERNAME)
+    except Exception:
+        pass
+
+    # Clear from file
+    token_file = get_token_file()
+    if token_file.exists():
+        token_file.unlink()
+
+
+def require_auth() -> str:
+    """
+    Require authentication and return API token.
+    """
+    token = get_token()
+    if not token:
+        console.print("[error]Not authenticated. Please run 'trc auth login' first.[/error]")
+        raise typer.Exit(1)
+    return token
+
+
+# CLI Commands
+
+
+def login_command(token: str | None = None) -> None:
+    """
+    Log in to Trossen Cloud by storing an API token.
+    """
+    token = token or os.environ.get("TROSSEN_TOKEN")
+
+    if not token:
+        token = Prompt.ask("API token", password=True)
+
+    store_token(token)
+    prefix = token[:10] if len(token) >= 10 else token
+    console.print(f"[success]Token stored ({prefix}...)[/success]")
+
+
+def logout_command() -> None:
+    """
+    Log out and clear stored credentials.
+    """
+    clear_token()
+    console.print("[success]Logged out[/success]")
+
+
+def status_command() -> None:
+    """
+    Show authentication status.
+    """
+    token = get_token()
+    if not token:
+        console.print("[warning]Not authenticated.[/warning]")
+        raise typer.Exit(1)
+
+    from .api_client import ApiError, SyncApiClient
+
+    try:
+        with SyncApiClient() as client:
+            data = client.get("/users/me")
+        username = data.get("username", "unknown")
+        console.print(f"[success]Authenticated[/success] as [bold]{username}[/bold]")
+    except ApiError as e:
+        console.print(f"[error]Authentication failed: {e.message}[/error]")
+        raise typer.Exit(1)

trossen_cloud_cli/cli.py

@@ -0,0 +1,109 @@
+"""Main CLI app definition."""
+
+from typing import Annotated
+
+import typer
+import typer.rich_utils
+
+from .commands import auth, config, datasets, models, training_jobs
+from .output import console
+
+# Override Typer's default styling for better readability on light and dark terminals.
+typer.rich_utils.STYLE_ERRORS_PANEL_BORDER = "red1"
+typer.rich_utils.STYLE_ERRORS_SUGGESTION = "bold"
+typer.rich_utils.RICH_HELP = "Try [bold dodger_blue2]'{command_path} {help_option}'[/] for help."
+
+
+# Create main app
+app = typer.Typer(
+    name="trc",
+    help="CLI for interacting with Trossen Cloud datasets and models APIs.",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def main_callback(
+    quiet: Annotated[
+        bool,
+        typer.Option("--quiet", "-q", help="Suppress all output"),
+    ] = False,
+) -> None:
+    """
+    Trossen Cloud CLI.
+    """
+    if quiet:
+        console.quiet = True
+
+
+# Add subcommands
+app.add_typer(auth.app, name="auth")
+app.add_typer(config.app, name="config")
+app.add_typer(datasets.app, name="dataset")
+app.add_typer(models.app, name="model")
+app.add_typer(training_jobs.app, name="training-job")
+
+
+USAGE_TEXT = """\
+[bold]Getting started:[/bold]
+
+  trc auth login --token <your-api-token>
+  trc auth status
+
+[bold]Datasets:[/bold]
+
+  trc dataset upload ./my-data --name my-dataset --type lerobot
+  trc dataset import-hf org/dataset-name --name my-dataset
+  trc dataset download <dataset-id> ./output
+  trc dataset list --mine
+  trc dataset info <dataset-id>
+  trc dataset view <user>/<name>
+  trc dataset update <dataset-id> --name new-name --privacy public
+  trc dataset delete <dataset-id>
+
+[bold]Models:[/bold]
+
+  trc model upload ./my-model --name my-model
+  trc model download <model-id> ./output
+  trc model list --mine
+  trc model info <model-id>
+
+[bold]Training jobs:[/bold]
+
+  trc training-job create --name my-job --base-model-id <id> --dataset-id <id>
+  trc training-job list
+  trc training-job info <job-id>
+  trc training-job cancel <job-id>
+  trc training-job models <job-id>
+
+[bold]Configuration:[/bold]
+
+  trc config show
+  trc config set upload.chunk_size_mb 100
+  trc config reset
+
+[bold]Options:[/bold]
+
+  -q, --quiet       Suppress all output
+  TROSSEN_API_URL   Override the API endpoint
+  TROSSEN_TOKEN     Override the stored auth token
+"""
+
+
+@app.command()
+def usage() -> None:
+    """
+    Show usage examples.
+    """
+    console.print(USAGE_TEXT)
+
+
+def main() -> None:
+    """
+    Main entry point.
+    """
+    app()
+
+
+if __name__ == "__main__":
+    main()

trossen_cloud_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands package."""

trossen_cloud_cli/commands/auth.py

@@ -0,0 +1,41 @@
+"""Authentication commands."""
+
+from typing import Annotated
+
+import typer
+
+from .. import auth as auth_module
+
+app = typer.Typer(help="Authentication commands")
+
+
+@app.command("login")
+def login(
+    token: Annotated[
+        str | None,
+        typer.Option("--token", "-t", help="API token"),
+    ] = None,
+) -> None:
+    """
+    Log in to Trossen Cloud.
+
+    Token can also be provided via the TROSSEN_TOKEN environment variable.
+
+    """
+    auth_module.login_command(token)
+
+
+@app.command("logout")
+def logout() -> None:
+    """
+    Log out and clear stored credentials.
+    """
+    auth_module.logout_command()
+
+
+@app.command("status")
+def status() -> None:
+    """
+    Show authentication status.
+    """
+    auth_module.status_command()

trossen_cloud_cli/commands/config.py

@@ -0,0 +1,88 @@
+"""Configuration commands."""
+
+from typing import Annotated
+
+import typer
+
+from ..config import Config, get_config, load_config, reset_config, save_config
+from ..output import console, print_error, print_success
+
+app = typer.Typer(help="View and manage CLI configuration.")
+
+# Flat map of settable keys to (section, field, type)
+CONFIG_KEYS: dict[str, tuple[str, str, type]] = {
+    "upload.chunk_size_mb": ("upload", "chunk_size_mb", int),
+    "upload.parallel_parts": ("upload", "parallel_parts", int),
+    "upload.parallel_files": ("upload", "parallel_files", int),
+    "download.parallel_files": ("download", "parallel_files", int),
+    "download.stream_chunk_size": ("download", "stream_chunk_size", int),
+}
+
+
+@app.command("show")
+def show_command() -> None:
+    """
+    Show current configuration.
+    """
+    config = get_config()
+
+    console.print("\n[heading]Upload[/heading]")
+    console.print(f"  chunk_size_mb      {config.upload.chunk_size_mb}")
+    console.print(f"  parallel_parts     {config.upload.parallel_parts}")
+    console.print(f"  parallel_files     {config.upload.parallel_files}")
+
+    console.print("\n[heading]Download[/heading]")
+    console.print(f"  parallel_files     {config.download.parallel_files}")
+    console.print(f"  stream_chunk_size  {config.download.stream_chunk_size}")
+    console.print()
+
+
+@app.command("set")
+def set_command(
+    key: Annotated[str, typer.Argument(help="Config key (e.g. upload.chunk_size_mb)")],
+    value: Annotated[str, typer.Argument(help="Value to set")],
+) -> None:
+    """
+    Set a configuration value.
+    """
+    if key not in CONFIG_KEYS:
+        print_error(f"Unknown key: {key}")
+        console.print(f"[muted]Valid keys: {', '.join(sorted(CONFIG_KEYS))}[/muted]")
+        raise typer.Exit(1)
+
+    section, field, field_type = CONFIG_KEYS[key]
+
+    try:
+        parsed = field_type(value)
+    except ValueError:
+        print_error(f"Invalid value for {key}: expected {field_type.__name__}")
+        raise typer.Exit(1)
+
+    if parsed <= 0:
+        print_error("Value must be positive")
+        raise typer.Exit(1)
+
+    # Load fresh from disk, apply change, save
+    config = load_config()
+    setattr(getattr(config, section), field, parsed)
+    save_config(config)
+    reset_config()
+
+    print_success(f"{key} = {parsed}")
+
+
+@app.command("reset")
+def reset_command(
+    force: Annotated[bool, typer.Option("--force", "-f", help="Skip confirmation")] = False,
+) -> None:
+    """
+    Reset configuration to defaults.
+    """
+    if not force:
+        typer.confirm("Reset all settings to defaults?", abort=True)
+
+    config = Config()
+    save_config(config)
+    reset_config()
+
+    print_success("Configuration reset to defaults")