powertech-cli 0.1.0__tar.gz

powertech_cli-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,94 @@
+# 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/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "powertech-cli"
+version = "0.1.0"
+description = "PowerTech CLI for batch video upload and result download."
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+  { name = "PowerTech" }
+]
+dependencies = [
+  "alibabacloud-oss-v2>=1.3.2,<2",
+  "httpx>=0.27,<1",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2,<2",
+  "ruff>=0.9,<1",
+]
+
+[project.scripts]
+powertech = "powertech_cli.main:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

powertech_cli-0.1.0/setup.cfg

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

powertech_cli-0.1.0/src/powertech_cli/__init__.py

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

powertech_cli-0.1.0/src/powertech_cli/__main__.py

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

powertech_cli-0.1.0/src/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-0.1.0/src/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()