evercoast-cli 0.1.0__tar.gz

evercoast_cli-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: evercoast-cli
+Version: 0.1.0
+Summary: Evercoast CLI — upload files to your company's S3 bucket
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: boto3>=1.28
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.10; extra == "dev"

evercoast_cli-0.1.0/README.md

@@ -0,0 +1,166 @@
+# Evercoast CLI
+
+Upload files to your company's S3 bucket with resumable uploads, checksum validation, and automatic credential management.
+
+## Requirements
+
+- Python 3.9+
+- An active Evercoast account with S3 direct upload enabled by Evercoast support
+
+## Install
+
+```bash
+pip install evercoast-cli
+```
+
+## Quick Start
+
+### 1. Login (one-time setup)
+
+```bash
+evercoast login
+```
+
+You'll be prompted for your Evercoast email and password. You only need to do this once — credentials are saved and refresh automatically.
+
+### 2. Upload
+
+```bash
+evercoast upload ./session-42/ --type takes
+```
+
+That's it. The CLI handles credentials, checksums, progress, and retries automatically.
+
+---
+
+## Upload Guide
+
+### Data types
+
+Choose a data type to route files to the right location:
+
+```bash
+evercoast upload ./session-42/ --type takes      # Raw capture data
+evercoast upload ./meshes/ --type renders         # PLY or OBJ sequences
+evercoast upload notes.zip --type other           # Anything else
+```
+
+If you don't pass `--type`, the CLI prompts you:
+
+```
+What type of data are you uploading?
+
+  1) Raw take data (images, videos, calibration, 2D data)
+  2) PLY or OBJ sequences
+  3) Other data
+
+Select [1-3] (default: 1):
+```
+
+Your last choice is remembered for next time.
+
+| Type | Destination |
+|------|-------------|
+| `takes` | `client-uploads/takes/<folder-name>/` |
+| `renders` | `client-uploads/renders/<folder-name>/` |
+| `other` | `client-uploads/<folder-name>/` |
+
+Use `--to` to specify a custom destination:
+
+```bash
+evercoast upload ./data/ --to my/custom/path
+# → uploads to client-uploads/my/custom/path/
+```
+
+### Resumable uploads
+
+Directories are synced. If an upload is interrupted (Ctrl+C, network drop, laptop sleep), re-run the same command and only the remaining files are uploaded:
+
+```bash
+# First run: uploads 847 files
+evercoast upload ./session-42/ --type takes
+
+# Second run: skips everything
+evercoast upload ./session-42/ --type takes
+# → "Nothing to upload — all 847 files already exist at destination."
+```
+
+### Checksum validation
+
+SHA256 checksums are enabled by default. The CLI calculates a checksum locally and the server validates it — if data is corrupted in transit, the upload is rejected and retried.
+
+Disable with `--no-checksum` if needed (not recommended).
+
+### Network resilience
+
+If the network drops during an upload, the CLI:
+
+1. Detects the failure
+2. Waits for connectivity to return
+3. Retries with increasing delays (up to 5 minutes between attempts)
+
+Retries continue indefinitely until the upload succeeds or you cancel with Ctrl+C. If you cancel, re-run the same command to resume where you left off.
+
+### Dry run
+
+Preview what would be uploaded without actually uploading:
+
+```bash
+evercoast upload ./session-42/ --type takes --dry-run
+```
+
+### Exclude files
+
+Skip files matching glob patterns:
+
+```bash
+evercoast upload ./data/ --type takes --exclude "*.tmp" --exclude ".DS_Store"
+```
+
+### Skip confirmation
+
+Uploads over 1 GB prompt for confirmation. Skip with `--yes`:
+
+```bash
+evercoast upload ./large-dataset/ --type takes --yes
+```
+
+---
+
+## All Options
+
+```
+evercoast login
+  Authenticate and save credentials (one-time setup)
+
+evercoast upload <path> [options]
+  --type [takes|renders|other]   Data type (prompted if omitted)
+  --to TEXT                      Custom destination path
+  --dry-run                      Preview without uploading
+  --no-checksum                  Disable SHA256 checksum validation
+  --exclude TEXT                 Exclude glob pattern (repeatable)
+  -y, --yes                      Skip confirmation prompt
+  --help                         Show help
+```
+
+## Troubleshooting
+
+### "Not configured. Run 'evercoast login' first."
+
+You haven't logged in yet. Run `evercoast login` and enter your Evercoast credentials.
+
+### "Authentication expired."
+
+Your saved credentials are no longer valid. Run `evercoast login` again.
+
+### "S3 direct upload is not enabled for your company."
+
+Contact Evercoast support to enable this feature for your company.
+
+### Upload seems stuck
+
+Large files use multipart upload — the progress bar may pause between parts. This is normal. If the upload truly stalls, Ctrl+C and re-run the same command to resume.
+
+## Support
+
+Contact Evercoast support or your account representative for help.

evercoast_cli-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "evercoast-cli"
+version = "0.1.0"
+description = "Evercoast CLI — upload files to your company's S3 bucket"
+requires-python = ">=3.9"
+dependencies = [
+    "click>=8.0",
+    "boto3>=1.28",
+    "requests>=2.28",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-mock>=3.10",
+]
+
+[project.scripts]
+evercoast = "evercoast_cli.main:cli"
+
+[tool.setuptools.packages.find]
+where = ["src"]

evercoast_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

evercoast_cli-0.1.0/src/evercoast_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Evercoast CLI — upload files to your company's S3 bucket."""
+
+__version__ = "0.1.0"

evercoast_cli-0.1.0/src/evercoast_cli/api.py

@@ -0,0 +1,264 @@
+"""API client for Evercoast backend.
+
+Handles login, S3 credential fetching, and auto-refreshing boto3 sessions.
+"""
+
+import platform
+import subprocess
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+
+import boto3
+import requests
+from botocore.credentials import RefreshableCredentials
+from botocore.session import get_session
+
+from . import __version__
+
+EC_AGENT_HEADER = "CB"
+USER_AGENT = f"evercoast-cli/{__version__} ({platform.system()})"
+
+# Common headers for all API calls
+BASE_HEADERS = {
+    "EC-Agent": EC_AGENT_HEADER,
+    "Content-Type": "application/json",
+    "User-Agent": USER_AGENT,
+}
+
+
+class APIError(Exception):
+    """Raised when an API call fails."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None):
+        self.status_code = status_code
+        super().__init__(message)
+
+
+def login(api_url: str, email: str, password: str) -> str:
+    """Authenticate with the Evercoast API and return an auth token.
+
+    Uses EC-Agent: CB to create a Cloudbreak token that persists
+    indefinitely and won't conflict with Mavericks sessions.
+
+    Returns:
+        Auth token string
+
+    Raises:
+        APIError: If login fails
+    """
+    try:
+        resp = requests.post(
+            f"{api_url}/login/",
+            headers=BASE_HEADERS,
+            json={"email": email, "password": password},
+            timeout=30,
+        )
+    except requests.ConnectionError:
+        raise APIError("Could not connect to Evercoast API. Check your internet connection.")
+    except requests.Timeout:
+        raise APIError("Connection to Evercoast API timed out.")
+
+    if resp.status_code != 200:
+        data = {}
+        try:
+            data = resp.json()
+        except ValueError:
+            pass
+        msg = (
+            data.get("detail")
+            or data.get("error")
+            or (data.get("non_field_errors") or [""])[0]
+            or "Invalid credentials"
+        )
+        raise APIError(f"Login failed: {msg}", status_code=resp.status_code)
+
+    data = resp.json()
+    token = data.get("token")
+    if not token:
+        raise APIError("Login failed: no token received")
+
+    return token
+
+
+def fetch_s3_credentials(api_url: str, token: str) -> Dict:
+    """Fetch S3 upload credentials from the API.
+
+    Returns:
+        Dict with keys: access_key_id, secret_access_key, session_token,
+        expiration, bucket, region, upload_path
+
+    Raises:
+        APIError: If credential fetch fails
+    """
+    headers = {
+        **BASE_HEADERS,
+        "Authorization": f"Token {token}",
+    }
+
+    try:
+        resp = requests.post(
+            f"{api_url}/s3-credentials/",
+            headers=headers,
+            timeout=30,
+        )
+    except requests.ConnectionError:
+        raise APIError("Could not connect to Evercoast API. Check your internet connection.")
+    except requests.Timeout:
+        raise APIError("Connection to Evercoast API timed out.")
+
+    if resp.status_code == 401:
+        raise APIError(
+            "Authentication expired. Run 'evercoast login' to re-authenticate.",
+            status_code=401,
+        )
+
+    if resp.status_code != 200:
+        data = {}
+        try:
+            data = resp.json()
+        except ValueError:
+            pass
+        msg = data.get("error") or data.get("detail") or "Unknown error"
+        raise APIError(f"Failed to get S3 credentials: {msg}", status_code=resp.status_code)
+
+    return resp.json()
+
+
+def _make_refreshable_metadata(api_url: str, token: str) -> Dict[str, str]:
+    """Fetch credentials and return in botocore RefreshableCredentials format."""
+    data = fetch_s3_credentials(api_url, token)
+    return {
+        "access_key": data["access_key_id"],
+        "secret_key": data["secret_access_key"],
+        "token": data["session_token"],
+        "expiry_time": data["expiration"],
+    }
+
+
+def get_s3_client(api_url: str, token: str, region: str):
+    """Create an S3 client with auto-refreshing credentials.
+
+    Uses botocore's RefreshableCredentials so credentials are automatically
+    refreshed before expiration during long uploads.
+    """
+    credentials = RefreshableCredentials.create_from_metadata(
+        metadata=_make_refreshable_metadata(api_url, token),
+        refresh_using=lambda: _make_refreshable_metadata(api_url, token),
+        method="sts-assume-role",
+    )
+
+    botocore_session = get_session()
+    botocore_session._credentials = credentials
+    boto3_session = boto3.Session(botocore_session=botocore_session)
+    return boto3_session.client("s3", region_name=region)
+
+
+def setup_aws_cli_profile(
+    api_url: str,
+    token: str,
+    region: str,
+    profile_name: str,
+):
+    """Set up an AWS CLI credential_process profile as a bonus.
+
+    Creates a credential helper script and configures AWS CLI to use it.
+    If AWS CLI is not installed, this is silently skipped.
+    """
+    # Check if AWS CLI is available
+    try:
+        subprocess.run(
+            ["aws", "--version"],
+            capture_output=True,
+            check=True,
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return False
+
+    config_dir = Path.home() / ".evercoast"
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    if platform.system() == "Windows":
+        helper_path = config_dir / f"{profile_name}-credential-helper.ps1"
+        helper_content = _generate_powershell_helper(api_url, token)
+        helper_path.write_text(helper_content, encoding="utf-8")
+        credential_process = f'powershell.exe -NoProfile -File "{helper_path}"'
+    else:
+        helper_path = config_dir / f"{profile_name}-credential-helper.sh"
+        helper_content = _generate_bash_helper(api_url, token)
+        helper_path.write_text(helper_content, encoding="utf-8")
+        helper_path.chmod(0o700)
+        credential_process = str(helper_path)
+
+    subprocess.run(
+        ["aws", "configure", "set", "credential_process", credential_process,
+         "--profile", profile_name],
+        capture_output=True,
+    )
+    subprocess.run(
+        ["aws", "configure", "set", "region", region,
+         "--profile", profile_name],
+        capture_output=True,
+    )
+    return True
+
+
+def _generate_bash_helper(api_url: str, token: str) -> str:
+    """Generate a bash credential helper script."""
+    return f"""#!/usr/bin/env bash
+# Auto-generated by evercoast CLI
+# Called automatically by AWS CLI to get fresh credentials.
+RESPONSE=$(curl -s -X POST "{api_url}/s3-credentials/" \\
+    -H "Authorization: Token {token}" \\
+    -H "EC-Agent: CB" \\
+    -H "Content-Type: application/json")
+
+ERROR=$(echo "$RESPONSE" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('error',''))" 2>/dev/null)
+if [ -n "$ERROR" ]; then
+    echo "Error: $ERROR" >&2
+    echo "Run 'evercoast login' to re-authenticate." >&2
+    exit 1
+fi
+
+echo "$RESPONSE" | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+print(json.dumps({{
+    'Version': 1,
+    'AccessKeyId': d['access_key_id'],
+    'SecretAccessKey': d['secret_access_key'],
+    'SessionToken': d['session_token'],
+    'Expiration': d['expiration']
+}}))
+"
+"""
+
+
+def _generate_powershell_helper(api_url: str, token: str) -> str:
+    """Generate a PowerShell credential helper script."""
+    return f"""# Auto-generated by evercoast CLI
+$ErrorActionPreference = "Stop"
+try {{
+    $Headers = @{{
+        "Authorization" = "Token {token}"
+        "EC-Agent" = "CB"
+        "Content-Type" = "application/json"
+    }}
+    $Response = Invoke-RestMethod -Uri "{api_url}/s3-credentials/" `
+        -Method Post `
+        -ContentType "application/json" `
+        -Headers $Headers `
+        -ErrorAction Stop
+    @{{
+        Version = 1
+        AccessKeyId = $Response.access_key_id
+        SecretAccessKey = $Response.secret_access_key
+        SessionToken = $Response.session_token
+        Expiration = $Response.expiration
+    }} | ConvertTo-Json
+}}
+catch {{
+    Write-Error "Error refreshing credentials. Run 'evercoast login' to re-authenticate."
+    exit 1
+}}
+"""

evercoast_cli-0.1.0/src/evercoast_cli/config.py

@@ -0,0 +1,151 @@
+"""Config file management for Evercoast CLI.
+
+Stores authentication tokens, bucket info, and user preferences
+in ~/.evercoast/config.toml with per-profile sections.
+"""
+
+import os
+import platform
+import re
+import stat
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+# API URLs
+PRODUCTION_API_URL = "https://api.cloudbreak.evercoast.com/api/v1"
+STAGING_API_URL = "https://api.staging.cloudbreak.evercoast.com/api/v1"
+
+DEFAULT_PROFILE = "default"
+STAGING_PROFILE = "staging"
+
+
+def get_config_dir() -> Path:
+    """Return the config directory path (~/.evercoast/)."""
+    return Path.home() / ".evercoast"
+
+
+def get_config_path() -> Path:
+    """Return the config file path (~/.evercoast/config.toml)."""
+    return get_config_dir() / "config.toml"
+
+
+def _parse_toml(text: str) -> Dict[str, Dict[str, str]]:
+    """Parse a simple TOML file into nested dicts.
+
+    Only supports [section] headers and key = "value" pairs.
+    No nested tables, arrays, or complex types.
+    """
+    result: Dict[str, Dict[str, str]] = {}
+    current_section = None
+
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        # Section header
+        section_match = re.match(r"^\[([^\]]+)\]$", line)
+        if section_match:
+            current_section = section_match.group(1).strip()
+            result[current_section] = {}
+            continue
+
+        # Key = value pair
+        kv_match = re.match(r'^(\w+)\s*=\s*"((?:[^"\\]|\\.)*)"$', line)
+        if kv_match and current_section is not None:
+            key = kv_match.group(1)
+            value = kv_match.group(2).replace('\\"', '"').replace("\\\\", "\\")
+            result[current_section][key] = value
+
+    return result
+
+
+def _serialize_toml(data: Dict[str, Dict[str, str]]) -> str:
+    """Serialize nested dicts to simple TOML format."""
+    lines = []
+    for i, (section, values) in enumerate(data.items()):
+        if i > 0:
+            lines.append("")
+        lines.append(f"[{section}]")
+        for key, value in values.items():
+            escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+            lines.append(f'{key} = "{escaped}"')
+    lines.append("")  # trailing newline
+    return "\n".join(lines)
+
+
+class Config:
+    """Manages the Evercoast CLI config file."""
+
+    def __init__(self, config_path: Optional[Path] = None):
+        self.path = config_path or get_config_path()
+        self._data: Dict[str, Dict[str, str]] = {}
+        self._load()
+
+    def _load(self):
+        """Load config from disk if it exists."""
+        if self.path.exists():
+            text = self.path.read_text(encoding="utf-8")
+            self._data = _parse_toml(text)
+
+    def _save(self):
+        """Write config to disk with restricted permissions."""
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(_serialize_toml(self._data), encoding="utf-8")
+        # Restrict permissions on Unix (owner read/write only)
+        if platform.system() != "Windows":
+            self.path.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+    def save_profile(
+        self,
+        profile: str,
+        api_url: str,
+        token: str,
+        bucket: str,
+        region: str,
+        upload_path: str = "client-uploads/",
+    ):
+        """Save a profile with all connection details."""
+        self._data[profile] = {
+            "api_url": api_url,
+            "token": token,
+            "bucket": bucket,
+            "region": region,
+            "upload_path": upload_path,
+        }
+        self._save()
+
+    def get_profile(self, profile: str) -> Optional[Dict[str, str]]:
+        """Get a profile's config, or None if it doesn't exist."""
+        return self._data.get(profile)
+
+    def has_profile(self, profile: str) -> bool:
+        """Check if a profile exists."""
+        return profile in self._data
+
+    def get_value(self, profile: str, key: str) -> Optional[str]:
+        """Get a single value from a profile."""
+        p = self._data.get(profile)
+        if p is None:
+            return None
+        return p.get(key)
+
+    def set_value(self, profile: str, key: str, value: str):
+        """Set a single value in a profile (profile must exist)."""
+        if profile not in self._data:
+            self._data[profile] = {}
+        self._data[profile][key] = value
+        self._save()
+
+    def get_profile_name(self, staging: bool) -> str:
+        """Return the profile name based on staging flag."""
+        return STAGING_PROFILE if staging else DEFAULT_PROFILE
+
+    def get_api_url(self, staging: bool) -> str:
+        """Return the API URL for the given environment."""
+        profile = self.get_profile_name(staging)
+        p = self.get_profile(profile)
+        if p and "api_url" in p:
+            return p["api_url"]
+        return STAGING_API_URL if staging else PRODUCTION_API_URL