powertech-cli 0.1.0__py3-none-any.whl

powertech_cli/__init__.py

@@ -0,0 +1,3 @@
+"""PowerTech CLI upload tool."""
+
+__version__ = "0.1.0"

powertech_cli/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

powertech_cli/api.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from pathlib import Path, PurePosixPath
+
+import httpx
+
+from . import __version__
+from .config import CliConfig, get_home
+from .errors import CliError
+from .utils import content_type_for_path, utc_now
+
+
+class HttpBackendClient:
+    def __init__(self, config: CliConfig) -> None:
+        self.config = config
+        self.base_url = f"{config.api_url.rstrip('/')}/cli/v1"
+
+    def ensure_authenticated(self) -> None:
+        if not self.config.is_logged_in:
+            raise CliError("Not logged in. Run: powertech login --token <cli_token>")
+
+    def create_upload_batch(self) -> dict:
+        return self._request("POST", "/upload-batches", {"client_version": __version__})
+
+    def get_current_context(self) -> dict:
+        return self._request("GET", "/me")
+
+    def get_upload_batch(self, upload_batch_id: str) -> dict:
+        return self._request("GET", f"/upload-batches/{upload_batch_id}")
+
+    def create_upload_credential(
+        self, *, upload_batch_id: str, file_path: Path, relative_path: str
+    ) -> dict:
+        return self._request(
+            "POST",
+            "/upload-credentials",
+            {
+                "upload_batch_id": upload_batch_id,
+                "file_name": file_path.name,
+                "file_size_bytes": file_path.stat().st_size,
+                "content_type": content_type_for_path(file_path),
+                "relative_path": relative_path,
+                "client_version": __version__,
+            },
+        )
+
+    def complete_upload(
+        self,
+        *,
+        upload_batch_id: str,
+        relative_path: str,
+        file_path: Path,
+        object_info: dict,
+        duration_ms: int | None,
+    ) -> dict:
+        return self._request(
+            "POST",
+            "/uploads/complete",
+            {
+                "upload_batch_id": upload_batch_id,
+                "object_key": object_info["object_key"],
+                "relative_path": relative_path,
+                "file_size_bytes": file_path.stat().st_size,
+                "content_type": content_type_for_path(file_path),
+                "duration_ms": duration_ms,
+                "etag": object_info.get("etag"),
+                "checksum_sha256": object_info.get("checksum_sha256"),
+            },
+        )
+
+    def finish_upload_batch(self, upload_batch_id: str) -> dict:
+        return self._request("POST", f"/upload-batches/{upload_batch_id}/finish")
+
+    def get_results(self, upload_batch_id: str) -> dict:
+        return self._request("GET", f"/upload-batches/{upload_batch_id}/results")
+
+    def list_uploaded_files(self) -> list[dict]:
+        raise CliError("The files command is only available in mock mode. Use the Web video data page.")
+
+    def _request(self, method: str, path: str, payload: dict | None = None) -> dict:
+        self.ensure_authenticated()
+        try:
+            with httpx.Client(timeout=30, trust_env=False) as client:
+                response = client.request(
+                    method,
+                    f"{self.base_url}{path}",
+                    headers={"Authorization": f"Bearer {self.config.token}"},
+                    json=payload,
+                )
+        except httpx.HTTPError as exc:
+            raise CliError(f"Could not reach PowerTech API at {self.config.api_url}: {exc}") from exc
+
+        if response.is_error:
+            raise CliError(_api_error_message(response))
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise CliError("PowerTech API returned an invalid JSON response.") from exc
+
+
+class LocalBackendClient:
+    """Local JSON-backed API simulator retained for isolated CLI tests."""
+
+    def __init__(self, config: CliConfig) -> None:
+        self.config = config
+        self.state_path = get_home() / "backend-state.json"
+
+    def ensure_authenticated(self) -> None:
+        if not self.config.is_logged_in:
+            raise CliError("Not logged in. Run: powertech login --token <cli_token>")
+
+    def create_upload_batch(self) -> dict:
+        self.ensure_authenticated()
+        state = self._load_state()
+        batch_id = f"ub_{uuid.uuid4().hex[:12]}"
+        batch = {
+            "id": batch_id,
+            "upload_source": "cli",
+            "status": "created",
+            "client_version": __version__,
+            "created_at": utc_now(),
+            "completed_at": None,
+        }
+        state["upload_batches"][batch_id] = batch
+        self._save_state(state)
+        return batch
+
+    def get_current_context(self) -> dict:
+        self.ensure_authenticated()
+        return {
+            "user_id": self.config.user_id,
+            "organization_id": self.config.org_id,
+            "role": "owner",
+            "organization_name": self.config.org_id,
+            "user_name": self.config.user_id,
+        }
+
+    def get_upload_batch(self, upload_batch_id: str) -> dict:
+        state = self._load_state()
+        batch = _require_batch(state, upload_batch_id)
+        files = [item for item in state["uploaded_files"].values() if item["upload_batch_id"] == upload_batch_id]
+        return {
+            "upload_batch": batch,
+            "file_count": len(files),
+            "total_size_bytes": sum(item["file_size_bytes"] for item in files),
+        }
+
+    def create_upload_credential(
+        self, *, upload_batch_id: str, file_path: Path, relative_path: str
+    ) -> dict:
+        state = self._load_state()
+        batch = _require_batch(state, upload_batch_id)
+        safe_path = _safe_object_name(relative_path)
+        object_key = f"uploads/{self.config.org_id}/{batch['id']}/{safe_path}"
+        batch["status"] = "uploading"
+        self._save_state(state)
+        return {
+            "upload_batch_id": batch["id"],
+            "object_key": object_key,
+            "storage_provider": "mock",
+            "upload_method": "mock_multipart",
+            "credential": {"type": "mock", "file_size_bytes": file_path.stat().st_size},
+        }
+
+    def complete_upload(
+        self,
+        *,
+        upload_batch_id: str,
+        relative_path: str,
+        file_path: Path,
+        object_info: dict,
+        duration_ms: int | None,
+    ) -> dict:
+        state = self._load_state()
+        batch = _require_batch(state, upload_batch_id)
+        existing = next(
+            (
+                item
+                for item in state["uploaded_files"].values()
+                if item["upload_batch_id"] == upload_batch_id and item["object_key"] == object_info["object_key"]
+            ),
+            None,
+        )
+        if existing:
+            return {"upload_batch_id": upload_batch_id, "uploaded_file": existing}
+
+        uploaded_file_id = f"uf_{uuid.uuid4().hex[:12]}"
+        uploaded_file = {
+            "id": uploaded_file_id,
+            "upload_batch_id": upload_batch_id,
+            "original_file_name": file_path.name,
+            "relative_path": relative_path,
+            "file_size_bytes": file_path.stat().st_size,
+            "duration_ms": duration_ms,
+            "content_type": content_type_for_path(file_path),
+            "object_key": object_info["object_key"],
+            "storage_provider": "mock",
+            "status": "uploaded",
+            "upload_source": "cli",
+            "created_at": utc_now(),
+        }
+        batch["status"] = "uploading"
+        state["uploaded_files"][uploaded_file_id] = uploaded_file
+        self._save_state(state)
+        return {"upload_batch_id": upload_batch_id, "uploaded_file": uploaded_file}
+
+    def finish_upload_batch(self, upload_batch_id: str) -> dict:
+        state = self._load_state()
+        batch = _require_batch(state, upload_batch_id)
+        batch["status"] = "completed"
+        batch["completed_at"] = utc_now()
+        self._save_state(state)
+        return {"upload_batch": batch}
+
+    def get_results(self, upload_batch_id: str) -> dict:
+        status = self.get_upload_batch(upload_batch_id)
+        items = [
+            {
+                "upload_batch_id": upload_batch_id,
+                "uploaded_file_id": item["id"],
+                "task_id": None,
+                "service_sku": None,
+                "original_file_name": item["original_file_name"],
+                "relative_path": item["relative_path"],
+                "task_status": "not_created",
+                "result_files": [],
+                "skipped_reason": "no_task_created",
+            }
+            for item in self.list_uploaded_files()
+            if item["upload_batch_id"] == upload_batch_id
+        ]
+        return {
+            "upload_batch_id": upload_batch_id,
+            "status": "ready",
+            "manifest": {
+                "schema_version": "result-manifest-v1",
+                "generated_at": utc_now(),
+                "download_scope": "upload_batch",
+                "upload_batch_id": upload_batch_id,
+                "items": items,
+            },
+            "downloads": [],
+            "file_count": status["file_count"],
+        }
+
+    def list_uploaded_files(self) -> list[dict]:
+        state = self._load_state()
+        return sorted(state["uploaded_files"].values(), key=lambda item: item["created_at"], reverse=True)
+
+    def _load_state(self) -> dict:
+        if not self.state_path.exists():
+            return {"upload_batches": {}, "uploaded_files": {}}
+        state = json.loads(self.state_path.read_text(encoding="utf-8"))
+        state.setdefault("upload_batches", {})
+        state.setdefault("uploaded_files", {})
+        return state
+
+    def _save_state(self, state: dict) -> None:
+        self.state_path.parent.mkdir(parents=True, exist_ok=True)
+        tmp_path = self.state_path.with_suffix(".json.tmp")
+        tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        tmp_path.replace(self.state_path)
+
+
+def build_backend_client(config: CliConfig) -> HttpBackendClient | LocalBackendClient:
+    if config.is_mock_mode:
+        return LocalBackendClient(config)
+    return HttpBackendClient(config)
+
+
+def download_file(
+    url: str,
+    destination: Path,
+    *,
+    expected_size: int | None = None,
+    expected_sha256: str | None = None,
+    client: httpx.Client | None = None,
+) -> bool:
+    if destination.exists() and _download_matches(
+        destination,
+        expected_size=expected_size,
+        expected_sha256=expected_sha256,
+    ):
+        return False
+
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    partial = destination.with_name(f"{destination.name}.part")
+    if expected_size is not None and partial.exists() and partial.stat().st_size > expected_size:
+        partial.unlink()
+
+    own_client = client is None
+    http_client = client or httpx.Client(timeout=120, follow_redirects=True, trust_env=False)
+    try:
+        downloaded_bytes = partial.stat().st_size if partial.exists() else 0
+        headers = {"Range": f"bytes={downloaded_bytes}-"} if downloaded_bytes else {}
+        with http_client.stream("GET", url, headers=headers) as response:
+            if response.status_code == 416 and expected_size == downloaded_bytes:
+                pass
+            elif response.is_error:
+                raise CliError(f"Result download failed with HTTP {response.status_code}.")
+            else:
+                append = downloaded_bytes > 0 and response.status_code == 206
+                with partial.open("ab" if append else "wb") as handle:
+                    for chunk in response.iter_bytes():
+                        handle.write(chunk)
+    except httpx.HTTPError as exc:
+        raise CliError(f"Result download failed: {exc}") from exc
+    finally:
+        if own_client:
+            http_client.close()
+
+    has_validation = expected_size is not None or expected_sha256 is not None
+    if has_validation and not _download_matches(
+        partial,
+        expected_size=expected_size,
+        expected_sha256=expected_sha256,
+    ):
+        raise CliError(f"Downloaded result failed validation: {destination.name}")
+    partial.replace(destination)
+    return True
+
+
+def _download_matches(
+    path: Path,
+    *,
+    expected_size: int | None,
+    expected_sha256: str | None,
+) -> bool:
+    if not path.exists():
+        return False
+    if expected_size is not None and path.stat().st_size != expected_size:
+        return False
+    if expected_sha256:
+        digest = hashlib.sha256()
+        with path.open("rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                digest.update(chunk)
+        if digest.hexdigest().lower() != expected_sha256.lower():
+            return False
+    return expected_size is not None or expected_sha256 is not None
+
+
+def _api_error_message(response: httpx.Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        return f"PowerTech API request failed with HTTP {response.status_code}."
+    error = payload.get("error", {}) if isinstance(payload, dict) else {}
+    message = error.get("message")
+    code = error.get("code")
+    if message and code:
+        return f"{message} ({code})"
+    return message or f"PowerTech API request failed with HTTP {response.status_code}."
+
+
+def _require_batch(state: dict, upload_batch_id: str) -> dict:
+    batch = state["upload_batches"].get(upload_batch_id)
+    if not batch:
+        raise CliError(f"Upload batch not found: {upload_batch_id}")
+    return batch
+
+
+def _safe_object_name(relative_name: str) -> str:
+    parts = [part for part in PurePosixPath(relative_name).parts if part not in {"", ".", "..", "/"}]
+    if not parts:
+        raise CliError("Invalid upload file name.")
+    return "/".join(parts)

powertech_cli/checkpoint.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+from .config import get_home
+from .utils import utc_now
+
+
+def compute_upload_fingerprint(path: Path, org_id: str) -> str:
+    stat = path.stat()
+    source = f"{org_id}|{path.resolve()}|{stat.st_size}|{stat.st_mtime_ns}"
+    return hashlib.sha256(source.encode("utf-8")).hexdigest()[:32]
+
+
+@dataclass
+class UploadCheckpoint:
+    fingerprint: str
+    source_path: str
+    file_size_bytes: int
+    upload_batch_id: str
+    object_key: str
+    uploaded_bytes: int
+    chunk_size_bytes: int
+    updated_at: str
+    completed: bool = False
+    oss_upload_id: str | None = None
+    completed_parts: dict[str, str] = field(default_factory=dict)
+    oss_completed: bool = False
+    oss_etag: str | None = None
+
+
+class CheckpointStore:
+    def __init__(self, root: Path | None = None) -> None:
+        self.root = root or get_home() / "checkpoints"
+
+    def _path(self, fingerprint: str) -> Path:
+        return self.root / f"{fingerprint}.json"
+
+    def load(self, fingerprint: str) -> UploadCheckpoint | None:
+        path = self._path(fingerprint)
+        if not path.exists():
+            return None
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+            return UploadCheckpoint(**data)
+        except (json.JSONDecodeError, OSError, TypeError):
+            return None
+
+    def save(self, checkpoint: UploadCheckpoint) -> None:
+        checkpoint.updated_at = utc_now()
+        self.root.mkdir(parents=True, exist_ok=True)
+        path = self._path(checkpoint.fingerprint)
+        tmp_path = path.with_suffix(".json.tmp")
+        tmp_path.write_text(json.dumps(asdict(checkpoint), indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+        tmp_path.replace(path)
+
+    def delete(self, fingerprint: str) -> None:
+        path = self._path(fingerprint)
+        if path.exists():
+            path.unlink()

powertech_cli/config.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+APP_HOME_ENV = "POWERTECH_CLI_HOME"
+CONFIG_FILENAME = "config.json"
+DEFAULT_API_URL = os.environ.get("POWERTECH_API_URL", "https://api.powertech-ai.com")
+DEFAULT_ORG_ID = "org_demo"
+DEFAULT_USER_ID = "user_demo"
+DEFAULT_STORAGE = "local"
+DEFAULT_CHUNK_SIZE_BYTES = 8 * 1024 * 1024
+
+
+def get_home() -> Path:
+    raw_home = os.environ.get(APP_HOME_ENV)
+    if raw_home:
+        return Path(raw_home).expanduser()
+    return Path.home() / ".powertech"
+
+
+@dataclass
+class CliConfig:
+    token: str | None = None
+    api_url: str = DEFAULT_API_URL
+    org_id: str = DEFAULT_ORG_ID
+    user_id: str = DEFAULT_USER_ID
+    storage: str = DEFAULT_STORAGE
+    chunk_size_bytes: int = DEFAULT_CHUNK_SIZE_BYTES
+    local_store_dir: str | None = None
+
+    @property
+    def is_logged_in(self) -> bool:
+        return bool(self.token)
+
+    @property
+    def is_mock_mode(self) -> bool:
+        return self.api_url in {"local", "mock"}
+
+    def resolve_local_store_dir(self) -> Path:
+        if self.local_store_dir:
+            return Path(self.local_store_dir).expanduser()
+        return get_home() / "local-oss"
+
+
+def config_path() -> Path:
+    return get_home() / CONFIG_FILENAME
+
+
+def load_config() -> CliConfig:
+    path = config_path()
+    if not path.exists():
+        return CliConfig()
+    data = json.loads(path.read_text(encoding="utf-8"))
+    allowed = CliConfig.__dataclass_fields__.keys()
+    filtered = {key: value for key, value in data.items() if key in allowed}
+    return CliConfig(**filtered)
+
+
+def save_config(config: CliConfig) -> Path:
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.parent.chmod(0o700)
+    path.write_text(json.dumps(asdict(config), indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    path.chmod(0o600)
+    return path

powertech_cli/errors.py

@@ -0,0 +1,2 @@
+class CliError(Exception):
+    """Expected command-line error that should be shown without a traceback."""

powertech_cli/main.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path, PurePosixPath
+
+from . import __version__
+from .api import build_backend_client, download_file
+from .checkpoint import CheckpointStore, UploadCheckpoint, compute_upload_fingerprint
+from .config import DEFAULT_API_URL, DEFAULT_ORG_ID, DEFAULT_STORAGE, CliConfig, load_config, save_config
+from .errors import CliError
+from .storage import build_storage_client
+from .utils import collect_video_files, format_bytes, read_video_duration_ms, utc_now
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not hasattr(args, "handler"):
+        parser.print_help()
+        return 0
+
+    try:
+        return args.handler(args)
+    except CliError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        return 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="powertech", description="PowerTech CLI upload and result download tool")
+    parser.add_argument("--version", action="version", version=f"powertech-cli {__version__}")
+    subparsers = parser.add_subparsers(dest="command")
+
+    login = subparsers.add_parser("login", help="Save a CLI token")
+    login.add_argument("--token", required=True, help="CLI token generated by the SaaS web app")
+    login.add_argument("--api-url", default=DEFAULT_API_URL, help="PowerTech API URL")
+    login.add_argument("--org-id", default=DEFAULT_ORG_ID, help=argparse.SUPPRESS)
+    login.add_argument("--user-id", default="user_demo", help=argparse.SUPPRESS)
+    login.add_argument("--storage", choices=["local", "oss"], default=DEFAULT_STORAGE, help=argparse.SUPPRESS)
+    login.add_argument("--chunk-size-mb", type=float, default=8, help="Upload chunk size in MiB")
+    login.set_defaults(handler=handle_login)
+
+    upload = subparsers.add_parser("upload", help="Upload a video file or directory")
+    upload.add_argument("paths", nargs="+", help="Video file or directory paths")
+    upload.add_argument("--recursive", action="store_true", help="Upload supported videos in nested directories")
+    upload.add_argument("--resume", action="store_true", help="Reuse checkpoint for interrupted uploads")
+    upload.add_argument("--dry-run", action="store_true", help="Print matched files without uploading")
+    upload.add_argument("--chunk-size-mb", type=float, default=None, help="Override upload chunk size in MiB")
+    upload.set_defaults(handler=handle_upload)
+
+    status = subparsers.add_parser("status", help="Show upload batch status")
+    status.add_argument("upload_batch_id", help="Upload batch id, for example ub_...")
+    status.add_argument("--json", action="store_true", help="Print raw JSON status")
+    status.set_defaults(handler=handle_status)
+
+    files = subparsers.add_parser("files", help="List locally recorded uploaded files")
+    files.add_argument("--json", action="store_true", help="Print raw JSON list")
+    files.set_defaults(handler=handle_files)
+
+    download = subparsers.add_parser("download", help="Download results for an upload batch")
+    download.add_argument("--upload-batch", required=True, dest="upload_batch_id", help="Upload batch id")
+    download.add_argument("--output", "-o", default="./results", help="Output directory")
+    download.set_defaults(handler=handle_download)
+
+    return parser
+
+
+def handle_login(args: argparse.Namespace) -> int:
+    config = load_config()
+    config.token = args.token
+    config.api_url = args.api_url
+    config.org_id = args.org_id
+    config.user_id = args.user_id
+    config.storage = args.storage
+    config.chunk_size_bytes = _chunk_size_bytes(args.chunk_size_mb)
+    if not config.is_mock_mode:
+        context = build_backend_client(config).get_current_context()
+        config.org_id = context["organization_id"]
+        config.user_id = context["user_id"]
+    path = save_config(config)
+    print(f"Logged in to organization {config.org_id}. Config saved to {path}")
+    return 0
+
+
+def handle_upload(args: argparse.Namespace) -> int:
+    config = load_config()
+    if args.chunk_size_mb is not None:
+        config.chunk_size_bytes = _chunk_size_bytes(args.chunk_size_mb)
+
+    backend = build_backend_client(config)
+    checkpoint_store = CheckpointStore()
+
+    upload_items: list[tuple[Path, str]] = []
+    for raw_path in args.paths:
+        upload_items.extend(collect_video_files(Path(raw_path), recursive=args.recursive))
+
+    if not upload_items:
+        raise CliError("No supported MP4 or MOV files were found.")
+
+    if args.dry_run:
+        print(f"Matched {len(upload_items)} video file(s):")
+        for source_path, relative_name in upload_items:
+            print(f"- {source_path} -> {relative_name} ({format_bytes(source_path.stat().st_size)})")
+        return 0
+
+    checkpoint_identity = _checkpoint_identity(config)
+    checkpoints = {
+        fingerprint: checkpoint_store.load(fingerprint) if args.resume else None
+        for fingerprint in [compute_upload_fingerprint(path, checkpoint_identity) for path, _ in upload_items]
+    }
+    resumable_batch_ids = {item.upload_batch_id for item in checkpoints.values() if item is not None}
+    if len(resumable_batch_ids) > 1:
+        raise CliError("Matched files belong to multiple interrupted upload batches. Resume them separately.")
+
+    if resumable_batch_ids:
+        upload_batch_id = resumable_batch_ids.pop()
+        backend.get_upload_batch(upload_batch_id)
+        print(f"Resuming upload batch {upload_batch_id}")
+    else:
+        upload_batch_id = backend.create_upload_batch()["id"]
+        print(f"Created upload batch {upload_batch_id}")
+
+    print(f"Uploading {len(upload_items)} video file(s) to {config.api_url}")
+    for source_path, relative_name in upload_items:
+        _upload_one(
+            config=config,
+            backend=backend,
+            checkpoint_store=checkpoint_store,
+            upload_batch_id=upload_batch_id,
+            source_path=source_path,
+            relative_name=relative_name,
+            resume=args.resume,
+        )
+    backend.finish_upload_batch(upload_batch_id)
+    for source_path, _ in upload_items:
+        checkpoint_store.delete(compute_upload_fingerprint(source_path, checkpoint_identity))
+    print(f"Upload batch completed: {upload_batch_id}")
+    return 0
+
+
+def handle_status(args: argparse.Namespace) -> int:
+    config = load_config()
+    backend = build_backend_client(config)
+    status = backend.get_upload_batch(args.upload_batch_id)
+    if args.json:
+        print(json.dumps(status, indent=2, ensure_ascii=False))
+        return 0
+
+    batch = status["upload_batch"]
+    print(f"Upload batch: {batch['id']}")
+    print(f"Status: {batch['status']}")
+    print(f"Files: {status['file_count']}")
+    print(f"Total size: {format_bytes(status['total_size_bytes'])}")
+    return 0
+
+
+def handle_download(args: argparse.Namespace) -> int:
+    config = load_config()
+    backend = build_backend_client(config)
+    result = backend.get_results(args.upload_batch_id)
+    output_dir = Path(args.output).expanduser()
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "manifest.json").write_text(
+        json.dumps(result["manifest"], indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+    result_metadata = {
+        result_file["path"]: result_file
+        for item in result["manifest"]["items"]
+        for result_file in item["result_files"]
+    }
+    downloaded = 0
+    existing = 0
+    for entry in result["downloads"]:
+        url = entry["download_url"]
+        if url.startswith("mock://"):
+            continue
+        destination = _safe_download_destination(output_dir, entry["path"])
+        metadata = result_metadata.get(entry["path"], {})
+        did_download = download_file(
+            url,
+            destination,
+            expected_size=metadata.get("size_bytes"),
+            expected_sha256=metadata.get("sha256"),
+        )
+        if did_download:
+            downloaded += 1
+            print(f"Downloaded: {entry['path']}")
+        else:
+            existing += 1
+            print(f"Already complete: {entry['path']}")
+
+    print(f"Manifest: {output_dir / 'manifest.json'}")
+    print(f"Downloaded {downloaded} result file(s).")
+    if existing:
+        print(f"Reused {existing} verified local file(s).")
+    return 0
+
+
+def handle_files(args: argparse.Namespace) -> int:
+    config = load_config()
+    backend = build_backend_client(config)
+    files = backend.list_uploaded_files()
+    if args.json:
+        print(json.dumps(files, indent=2, ensure_ascii=False))
+        return 0
+
+    if not files:
+        print("No uploaded files.")
+        return 0
+
+    for item in files:
+        print(
+            f"{item['id']}  {item['original_file_name']}  "
+            f"{format_bytes(item['file_size_bytes'])}  {item['created_at']}"
+        )
+    return 0
+
+
+def _upload_one(
+    *,
+    config: CliConfig,
+    backend,
+    checkpoint_store: CheckpointStore,
+    upload_batch_id: str,
+    source_path: Path,
+    relative_name: str,
+    resume: bool,
+) -> None:
+    fingerprint = compute_upload_fingerprint(source_path, _checkpoint_identity(config))
+    checkpoint = checkpoint_store.load(fingerprint) if resume else None
+    if checkpoint:
+        if checkpoint.completed:
+            print(f"Already uploaded in this batch: {source_path}")
+            return
+        if checkpoint.upload_batch_id != upload_batch_id:
+            checkpoint = None
+
+    if not checkpoint:
+        authorization = backend.create_upload_credential(
+            upload_batch_id=upload_batch_id,
+            file_path=source_path,
+            relative_path=relative_name,
+        )
+        checkpoint = UploadCheckpoint(
+            fingerprint=fingerprint,
+            source_path=str(source_path.resolve()),
+            file_size_bytes=source_path.stat().st_size,
+            upload_batch_id=upload_batch_id,
+            object_key=authorization["object_key"],
+            uploaded_bytes=0,
+            chunk_size_bytes=config.chunk_size_bytes,
+            updated_at=utc_now(),
+        )
+        checkpoint_store.save(checkpoint)
+    else:
+        authorization = backend.create_upload_credential(
+            upload_batch_id=upload_batch_id,
+            file_path=source_path,
+            relative_path=relative_name,
+        )
+        if authorization["object_key"] != checkpoint.object_key:
+            raise CliError("The resumed upload object key no longer matches the API authorization.")
+
+    storage = build_storage_client(config, authorization)
+    duration_ms = read_video_duration_ms(source_path)
+    duration_text = f", duration={duration_ms / 1000:g}s" if duration_ms is not None else ""
+    print(f"- {relative_name}: size={format_bytes(source_path.stat().st_size)}{duration_text}")
+    object_info = storage.upload_file(
+        source_path=source_path,
+        object_key=checkpoint.object_key,
+        checkpoint=checkpoint,
+        checkpoint_store=checkpoint_store,
+        resume=resume,
+    )
+    completed = backend.complete_upload(
+        upload_batch_id=upload_batch_id,
+        relative_path=relative_name,
+        file_path=source_path,
+        object_info=object_info,
+        duration_ms=duration_ms,
+    )
+    checkpoint.completed = True
+    checkpoint_store.save(checkpoint)
+    uploaded_file = completed["uploaded_file"]
+    print(f"  UploadedFile={uploaded_file['id']} relative_path={uploaded_file['relative_path']}")
+
+
+def _safe_download_destination(output_dir: Path, relative_path: str) -> Path:
+    parts = PurePosixPath(relative_path).parts
+    if not parts or any(part in {"", ".", "..", "/"} for part in parts):
+        raise CliError(f"Unsafe result path returned by API: {relative_path}")
+    return output_dir.joinpath(*parts)
+
+
+def _checkpoint_identity(config: CliConfig) -> str:
+    return f"{config.api_url}|{config.org_id}"
+
+
+def _chunk_size_bytes(value_mb: float) -> int:
+    if value_mb <= 0:
+        raise CliError("--chunk-size-mb must be greater than 0")
+    return max(1, int(value_mb * 1024 * 1024))

powertech_cli/storage/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from powertech_cli.config import CliConfig
+from powertech_cli.errors import CliError
+
+from .local import LocalStorageClient
+from .oss import OssStorageClient
+
+
+def build_storage_client(config: CliConfig, authorization: dict):
+    upload_method = authorization.get("upload_method")
+    if upload_method == "mock_multipart" and config.storage == "local":
+        return LocalStorageClient(config)
+    if upload_method == "oss_multipart":
+        return OssStorageClient(authorization)
+    raise CliError(f"Unsupported upload method: {upload_method or 'unknown'}")

powertech_cli/storage/local.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path, PurePosixPath
+
+from powertech_cli.checkpoint import CheckpointStore, UploadCheckpoint
+from powertech_cli.config import CliConfig
+from powertech_cli.errors import CliError
+
+
+class LocalStorageClient:
+    """Local filesystem storage that simulates object storage multipart upload."""
+
+    def __init__(self, config: CliConfig) -> None:
+        self.root = config.resolve_local_store_dir()
+
+    def upload_file(
+        self,
+        *,
+        source_path: Path,
+        object_key: str,
+        checkpoint: UploadCheckpoint,
+        checkpoint_store: CheckpointStore,
+        resume: bool,
+    ) -> dict:
+        destination = self._destination_for_key(object_key)
+        destination.parent.mkdir(parents=True, exist_ok=True)
+
+        source_size = source_path.stat().st_size
+        start_offset = 0
+        if resume and destination.exists():
+            existing_size = destination.stat().st_size
+            if existing_size <= source_size:
+                start_offset = existing_size
+            else:
+                destination.unlink()
+        elif destination.exists():
+            destination.unlink()
+
+        mode = "ab" if start_offset else "wb"
+        checkpoint.uploaded_bytes = start_offset
+        checkpoint_store.save(checkpoint)
+
+        with source_path.open("rb") as source, destination.open(mode) as target:
+            source.seek(start_offset)
+            uploaded = start_offset
+            while True:
+                chunk = source.read(checkpoint.chunk_size_bytes)
+                if not chunk:
+                    break
+                target.write(chunk)
+                uploaded += len(chunk)
+                checkpoint.uploaded_bytes = uploaded
+                checkpoint_store.save(checkpoint)
+
+        if destination.stat().st_size != source_size:
+            raise CliError(f"Local upload failed for {source_path.name}: incomplete destination file.")
+
+        checksum = _sha256_file(destination)
+        return {
+            "object_key": object_key,
+            "size": destination.stat().st_size,
+            "etag": checksum[:32],
+            "checksum_sha256": checksum,
+            "local_path": str(destination),
+        }
+
+    def _destination_for_key(self, object_key: str) -> Path:
+        parts = [part for part in PurePosixPath(object_key).parts if part not in {"", ".", "..", "/"}]
+        if not parts:
+            raise CliError("Invalid object key.")
+        return self.root.joinpath(*parts)
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()

powertech_cli/storage/oss.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import alibabacloud_oss_v2 as oss
+
+from powertech_cli.checkpoint import CheckpointStore, UploadCheckpoint
+from powertech_cli.errors import CliError
+
+
+class OssStorageClient:
+    def __init__(self, authorization: dict) -> None:
+        credential = authorization.get("credential", {})
+        required = {
+            "access_key_id",
+            "access_key_secret",
+            "security_token",
+            "region",
+            "bucket",
+            "object_key",
+        }
+        missing = sorted(required.difference(credential))
+        if authorization.get("upload_method") != "oss_multipart" or missing:
+            raise CliError(f"Invalid OSS upload authorization. Missing: {', '.join(missing)}")
+
+        provider = oss.credentials.StaticCredentialsProvider(
+            credential["access_key_id"],
+            credential["access_key_secret"],
+            credential["security_token"],
+        )
+        config = oss.config.Config(
+            region=credential["region"],
+            endpoint=credential.get("endpoint"),
+            credentials_provider=provider,
+        )
+        self.client = oss.Client(config)
+        self.bucket = credential["bucket"]
+        self.authorized_object_key = credential["object_key"]
+
+    def upload_file(
+        self,
+        *,
+        source_path: Path,
+        object_key: str,
+        checkpoint: UploadCheckpoint,
+        checkpoint_store: CheckpointStore,
+        resume: bool,
+    ) -> dict:
+        if object_key != self.authorized_object_key:
+            raise CliError("OSS credential does not authorize the requested object key.")
+
+        if checkpoint.oss_completed:
+            return {
+                "object_key": object_key,
+                "size": source_path.stat().st_size,
+                "etag": checkpoint.oss_etag,
+                "checksum_sha256": None,
+            }
+
+        upload_id = checkpoint.oss_upload_id
+        if not upload_id:
+            try:
+                initiated = self.client.initiate_multipart_upload(
+                    oss.InitiateMultipartUploadRequest(bucket=self.bucket, key=object_key)
+                )
+            except Exception as exc:
+                raise CliError(f"Could not initiate OSS upload for {source_path.name}: {exc}") from exc
+            upload_id = initiated.upload_id
+            checkpoint.oss_upload_id = upload_id
+            checkpoint.completed_parts = {}
+            checkpoint_store.save(checkpoint)
+
+        try:
+            self._upload_parts(source_path, object_key, upload_id, checkpoint, checkpoint_store)
+            parts = [
+                oss.UploadPart(part_number=int(number), etag=etag)
+                for number, etag in sorted(checkpoint.completed_parts.items(), key=lambda item: int(item[0]))
+            ]
+            completed = self.client.complete_multipart_upload(
+                oss.CompleteMultipartUploadRequest(
+                    bucket=self.bucket,
+                    key=object_key,
+                    upload_id=upload_id,
+                    complete_multipart_upload=oss.CompleteMultipartUpload(parts=parts),
+                )
+            )
+        except Exception as exc:
+            if not resume:
+                self._abort_quietly(object_key, upload_id)
+                checkpoint.oss_upload_id = None
+                checkpoint.completed_parts = {}
+                checkpoint_store.save(checkpoint)
+            raise CliError(f"OSS upload failed for {source_path.name}: {exc}") from exc
+
+        checkpoint.uploaded_bytes = source_path.stat().st_size
+        checkpoint.oss_completed = True
+        checkpoint.oss_etag = _normalize_etag(completed.etag)
+        checkpoint_store.save(checkpoint)
+        return {
+            "object_key": object_key,
+            "size": source_path.stat().st_size,
+            "etag": checkpoint.oss_etag,
+            "checksum_sha256": None,
+        }
+
+    def _upload_parts(
+        self,
+        source_path: Path,
+        object_key: str,
+        upload_id: str,
+        checkpoint: UploadCheckpoint,
+        checkpoint_store: CheckpointStore,
+    ) -> None:
+        part_size = max(checkpoint.chunk_size_bytes, 100 * 1024)
+        uploaded_bytes = 0
+        with source_path.open("rb") as source:
+            part_number = 1
+            while True:
+                body = source.read(part_size)
+                if not body:
+                    break
+                part_key = str(part_number)
+                if part_key not in checkpoint.completed_parts:
+                    result = self.client.upload_part(
+                        oss.UploadPartRequest(
+                            bucket=self.bucket,
+                            key=object_key,
+                            upload_id=upload_id,
+                            part_number=part_number,
+                            content_length=len(body),
+                            body=body,
+                        )
+                    )
+                    if not result.etag:
+                        raise CliError(f"OSS did not return an ETag for part {part_number}.")
+                    checkpoint.completed_parts[part_key] = result.etag
+                uploaded_bytes += len(body)
+                checkpoint.uploaded_bytes = uploaded_bytes
+                checkpoint_store.save(checkpoint)
+                part_number += 1
+
+    def _abort_quietly(self, object_key: str, upload_id: str) -> None:
+        try:
+            self.client.abort_multipart_upload(
+                oss.AbortMultipartUploadRequest(bucket=self.bucket, key=object_key, upload_id=upload_id)
+            )
+        except Exception:
+            pass
+
+
+def _normalize_etag(etag: str | None) -> str | None:
+    return etag.strip('"') if etag else None

powertech_cli/utils.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import mimetypes
+import struct
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import BinaryIO
+
+from .errors import CliError
+
+SUPPORTED_VIDEO_EXTENSIONS = {".mp4", ".mov"}
+
+
+def utc_now() -> str:
+    return datetime.now(UTC).isoformat(timespec="seconds")
+
+
+def content_type_for_path(path: Path) -> str:
+    guessed, _ = mimetypes.guess_type(path.name)
+    return guessed or "application/octet-stream"
+
+
+def read_video_duration_ms(path: Path) -> int | None:
+    try:
+        with path.open("rb") as handle:
+            moov = _find_iso_bmff_box(handle, 0, path.stat().st_size, b"moov")
+            if moov is None:
+                return None
+            mvhd = _find_iso_bmff_box(handle, moov[0], moov[1], b"mvhd")
+            if mvhd is None:
+                return None
+            handle.seek(mvhd[0])
+            version_and_flags = handle.read(4)
+            if len(version_and_flags) != 4:
+                return None
+            version = version_and_flags[0]
+            if version == 0:
+                payload = handle.read(16)
+                if len(payload) != 16:
+                    return None
+                timescale, duration = struct.unpack(">II", payload[8:])
+            elif version == 1:
+                payload = handle.read(28)
+                if len(payload) != 28:
+                    return None
+                timescale = struct.unpack(">I", payload[16:20])[0]
+                duration = struct.unpack(">Q", payload[20:28])[0]
+            else:
+                return None
+    except (OSError, ValueError, struct.error):
+        return None
+    if timescale <= 0 or duration <= 0:
+        return None
+    return round(duration * 1000 / timescale)
+
+
+def _find_iso_bmff_box(handle: BinaryIO, start: int, end: int, target: bytes) -> tuple[int, int] | None:
+    position = start
+    while position + 8 <= end:
+        handle.seek(position)
+        header = handle.read(8)
+        if len(header) != 8:
+            return None
+        size, box_type = struct.unpack(">I4s", header)
+        header_size = 8
+        if size == 1:
+            extended_size = handle.read(8)
+            if len(extended_size) != 8:
+                return None
+            size = struct.unpack(">Q", extended_size)[0]
+            header_size = 16
+        elif size == 0:
+            size = end - position
+        if size < header_size or position + size > end:
+            return None
+        data_start = position + header_size
+        box_end = position + size
+        if box_type == target:
+            return data_start, box_end
+        position = box_end
+    return None
+
+
+def ensure_supported_video(path: Path) -> None:
+    if path.suffix.lower() not in SUPPORTED_VIDEO_EXTENSIONS:
+        supported = ", ".join(sorted(SUPPORTED_VIDEO_EXTENSIONS))
+        raise CliError(f"Unsupported file type: {path.name}. Supported video types: {supported}")
+
+
+def collect_video_files(input_path: Path, recursive: bool) -> list[tuple[Path, str]]:
+    path = input_path.expanduser()
+    if not path.exists():
+        raise CliError(f"Path does not exist: {path}")
+
+    if path.is_file():
+        ensure_supported_video(path)
+        return [(path, path.name)]
+
+    if not path.is_dir():
+        raise CliError(f"Path is not a regular file or directory: {path}")
+
+    candidates = path.rglob("*") if recursive else path.iterdir()
+    files: list[tuple[Path, str]] = []
+    for candidate in sorted(candidates):
+        if not candidate.is_file():
+            continue
+        if candidate.suffix.lower() not in SUPPORTED_VIDEO_EXTENSIONS:
+            continue
+        relative_name = candidate.relative_to(path).as_posix()
+        files.append((candidate, relative_name))
+
+    if not files:
+        scope = "recursively " if recursive else ""
+        raise CliError(f"No supported video files found {scope}under: {path}")
+
+    return files
+
+
+def format_bytes(size: int) -> str:
+    units = ["B", "KB", "MB", "GB", "TB"]
+    value = float(size)
+    for unit in units:
+        if value < 1024 or unit == units[-1]:
+            if unit == "B":
+                return f"{int(value)} {unit}"
+            return f"{value:.1f} {unit}"
+        value /= 1024
+
+    return f"{size} B"

powertech_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: powertech-cli
+Version: 0.1.0
+Summary: PowerTech CLI for batch video upload and result download.
+Author: PowerTech
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: alibabacloud-oss-v2<2,>=1.3.2
+Requires-Dist: httpx<1,>=0.27
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: ruff<1,>=0.9; extra == "dev"
+
+# PowerTech CLI
+
+Command-line client for uploading video batches and downloading processing results.
+
+## Development install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+The same package is used in every environment. Production is the default;
+development and staging select another API URL during login and keep their local
+CLI state in separate directories.
+
+## Environments
+
+### Development
+
+Start `powertech-api` at `http://127.0.0.1:8000`, then create a CLI token in the
+development SaaS web app:
+
+```bash
+POWERTECH_CLI_HOME=~/.powertech/dev \
+powertech login --token <development_token> --api-url http://127.0.0.1:8000
+```
+
+### Staging
+
+Use the same editable installation and save staging credentials separately:
+
+```bash
+POWERTECH_CLI_HOME=~/.powertech/staging \
+powertech login \
+  --token <staging_token> \
+  --api-url https://api-staging.powertech-ai.com
+```
+
+Set the same `POWERTECH_CLI_HOME` when running later commands. The saved
+configuration is private to the current operating-system user.
+
+### Production
+
+PyPI releases default to the production API:
+
+```bash
+powertech login --token <production_token>
+```
+
+Use `--api-url` only for development, staging, or a private deployment. The URL
+is saved with the token, so later upload and download commands do not repeat it.
+
+## Upload
+
+Each command creates one upload batch. Directory uploads preserve relative paths,
+and `--resume` retains the batch and completed OSS parts after interruption.
+
+```bash
+POWERTECH_CLI_HOME=~/.powertech/staging powertech upload ./video.mp4 --resume
+POWERTECH_CLI_HOME=~/.powertech/staging powertech upload ./videos --recursive --resume
+POWERTECH_CLI_HOME=~/.powertech/staging powertech status <upload_batch_id>
+```
+
+Supported input formats: MP4 and MOV.
+
+## Download
+
+```bash
+POWERTECH_CLI_HOME=~/.powertech/staging \
+powertech download --upload-batch <upload_batch_id> --output ./results
+```
+
+The output always contains `manifest.json`. Result files are downloaded into the
+paths returned by the API.
+
+## Local Test Mode
+
+The isolated mock adapter does not use RDS or OSS:
+
+```bash
+powertech login --token dev_token --api-url local
+powertech upload ./videos --recursive --resume
+```
+
+CLI state is stored under `~/.powertech/`. Set `POWERTECH_CLI_HOME` to use another
+directory during tests.
+
+## Continuous integration
+
+Pull requests and pushes to `main` run Ruff, the unit tests, and a packaging smoke
+test. The packaging check is release preparation; staging does not deploy or
+require a separate CLI package. PyPI publication is a separate, manually
+triggered GitHub Actions workflow.

powertech_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+powertech_cli/__init__.py,sha256=GfxO8tiBXgwvyfTdTDJaoYiLsUUeBYN-khv6Q-eRahM,56
+powertech_cli/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
+powertech_cli/api.py,sha256=HCFa0SgZVLQy3MQ7CCPruDQjSWvpOLzidhbWWw_dsr8,13674
+powertech_cli/checkpoint.py,sha256=agUMKS-X8eCLv_MPsaBejuX70AQJxdyNAsz8ftiHXZI,1977
+powertech_cli/config.py,sha256=evij4EoRbTx89FtMca-iPjkZ7doTKdke24ewsGkUdlA,1918
+powertech_cli/errors.py,sha256=jFz6TgbLjuEZHRN-iE_gtCeGFkgYn8NALVBrzUPalTU,107
+powertech_cli/main.py,sha256=dinx_VOtVIawj2t72EAqJ9D8U1i1BrbwoAsBoxnUvik,12073
+powertech_cli/utils.py,sha256=BuXtI3X-8VfZAP4RWW4dRow7BukMgW4j1gf5HMh1bfw,4227
+powertech_cli/storage/__init__.py,sha256=JYwQEgIPauDRVscUiP_iZxpYr5H7qpMgKMJ_Ta8cRYM,598
+powertech_cli/storage/local.py,sha256=Jrx0AUCbBJ5Nq0TakzFcr0Np6lGeOq837nPIw9LOEmc,2758
+powertech_cli/storage/oss.py,sha256=r0onQEzuCyIHKNlPoRb6Fnca7MoEcZmF7r5AYfhudwU,5756
+powertech_cli-0.1.0.dist-info/METADATA,sha256=M50wKJOVVhQ-tlhx0MbMR19FwTtKGXFjuxeyqXg9Qx0,3008
+powertech_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+powertech_cli-0.1.0.dist-info/entry_points.txt,sha256=Kg6mhZXY-Jc-ZwIh-UmA2nP5zq1oNSeR2P4o8X9Th8U,54
+powertech_cli-0.1.0.dist-info/top_level.txt,sha256=nXGg3NMin97FoWvr3mGlxrRBypUbRh640XBc2J8AkoE,14
+powertech_cli-0.1.0.dist-info/RECORD,,

powertech_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

powertech_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+powertech = powertech_cli.main:main

powertech_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+powertech_cli