powertech-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: powertech-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: PowerTech CLI for batch video upload and result download.
 Author: PowerTech
 Requires-Python: >=3.11
@@ -35,13 +35,13 @@ 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_CLI_HOME=~/.powertech/development \
 powertech login --token <development_token> --api-url http://127.0.0.1:8000
 ```
 
 ### Staging
 
-Use the same editable installation and save staging credentials separately:
+Use the same package and save staging credentials separately:
 
 ```bash
 POWERTECH_CLI_HOME=~/.powertech/staging \
@@ -66,17 +66,30 @@ 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.
+Every upload command requires one camera intrinsics JSON. It is validated locally,
+then applied to every video selected by that command. Directory inputs recursively
+find MP4 and MOV files and preserve relative paths. Interrupted uploads resume from
+local checkpoints automatically.
 
 ```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 upload ./video.mp4 --intrinsics ./camera-a.json
+
+POWERTECH_CLI_HOME=~/.powertech/staging \
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+
 POWERTECH_CLI_HOME=~/.powertech/staging powertech status <upload_batch_id>
 ```
 
 Supported input formats: MP4 and MOV.
 
+Run separate commands when videos use different cameras or intrinsics:
+
+```bash
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+powertech upload ./camera-b-videos --intrinsics ./camera-b.json
+```
+
 ## Download
 
 ```bash
@@ -93,7 +106,7 @@ The isolated mock adapter does not use RDS or OSS:
 
 ```bash
 powertech login --token dev_token --api-url local
-powertech upload ./videos --recursive --resume
+powertech upload ./videos --intrinsics ./camera-a.json
 ```
 
 CLI state is stored under `~/.powertech/`. Set `POWERTECH_CLI_HOME` to use another
@@ -102,6 +115,6 @@ 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.
+test. Staging does not deploy or require a separate CLI package. A `vX.Y.Z` tag
+whose commit belongs to `main` and whose value matches the package version publishes
+to PyPI through its trusted publisher; manual dispatch remains a recovery path.

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/README.md

@@ -22,13 +22,13 @@ 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_CLI_HOME=~/.powertech/development \
 powertech login --token <development_token> --api-url http://127.0.0.1:8000
 ```
 
 ### Staging
 
-Use the same editable installation and save staging credentials separately:
+Use the same package and save staging credentials separately:
 
 ```bash
 POWERTECH_CLI_HOME=~/.powertech/staging \
@@ -53,17 +53,30 @@ 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.
+Every upload command requires one camera intrinsics JSON. It is validated locally,
+then applied to every video selected by that command. Directory inputs recursively
+find MP4 and MOV files and preserve relative paths. Interrupted uploads resume from
+local checkpoints automatically.
 
 ```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 upload ./video.mp4 --intrinsics ./camera-a.json
+
+POWERTECH_CLI_HOME=~/.powertech/staging \
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+
 POWERTECH_CLI_HOME=~/.powertech/staging powertech status <upload_batch_id>
 ```
 
 Supported input formats: MP4 and MOV.
 
+Run separate commands when videos use different cameras or intrinsics:
+
+```bash
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+powertech upload ./camera-b-videos --intrinsics ./camera-b.json
+```
+
 ## Download
 
 ```bash
@@ -80,7 +93,7 @@ The isolated mock adapter does not use RDS or OSS:
 
 ```bash
 powertech login --token dev_token --api-url local
-powertech upload ./videos --recursive --resume
+powertech upload ./videos --intrinsics ./camera-a.json
 ```
 
 CLI state is stored under `~/.powertech/`. Set `POWERTECH_CLI_HOME` to use another
@@ -89,6 +102,6 @@ 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.
+test. Staging does not deploy or require a separate CLI package. A `vX.Y.Z` tag
+whose commit belongs to `main` and whose value matches the package version publishes
+to PyPI through its trusted publisher; manual dispatch remains a recovery path.

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "powertech-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "PowerTech CLI for batch video upload and result download."
 readme = "README.md"
 requires-python = ">=3.11"

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli/__init__.py

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

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli/api.py

@@ -74,6 +74,19 @@ class HttpBackendClient:
     def finish_upload_batch(self, upload_batch_id: str) -> dict:
         return self._request("POST", f"/upload-batches/{upload_batch_id}/finish")
 
+    def attach_upload_batch_materials(
+        self,
+        *,
+        upload_batch_id: str,
+        relative_paths: list[str],
+        intrinsics: dict,
+    ) -> list[dict]:
+        return self._request(
+            "PUT",
+            f"/upload-batches/{upload_batch_id}/materials",
+            {"relative_paths": relative_paths, "intrinsics": intrinsics},
+        )
+
     def get_results(self, upload_batch_id: str) -> dict:
         return self._request("GET", f"/upload-batches/{upload_batch_id}/results")
 
@@ -200,6 +213,9 @@ class LocalBackendClient:
             "storage_provider": "mock",
             "status": "uploaded",
             "upload_source": "cli",
+            "camera_intrinsics": None,
+            "camera_intrinsics_revision": 0,
+            "material_submitted_at": None,
             "created_at": utc_now(),
         }
         batch["status"] = "uploading"
@@ -207,6 +223,42 @@ class LocalBackendClient:
         self._save_state(state)
         return {"upload_batch_id": upload_batch_id, "uploaded_file": uploaded_file}
 
+    def attach_upload_batch_materials(
+        self,
+        *,
+        upload_batch_id: str,
+        relative_paths: list[str],
+        intrinsics: dict,
+    ) -> list[dict]:
+        state = self._load_state()
+        _require_batch(state, upload_batch_id)
+        files = [
+            item for item in state["uploaded_files"].values() if item["upload_batch_id"] == upload_batch_id
+        ]
+        actual_paths = {item["relative_path"] for item in files}
+        if actual_paths != set(relative_paths):
+            raise CliError("The upload batch files do not match this command. Resume with the same video paths.")
+
+        candidate = {
+            "schema_version": "camera-intrinsics.v1",
+            "source": "user_provided",
+            **intrinsics,
+        }
+        submitted_at = utc_now()
+        for item in files:
+            existing = item.get("camera_intrinsics")
+            if existing is not None and existing != candidate:
+                raise CliError(
+                    "This upload batch already has different camera intrinsics. "
+                    "Use the Web app to replace them explicitly."
+                )
+            if existing is None:
+                item["camera_intrinsics"] = candidate
+                item["camera_intrinsics_revision"] = item.get("camera_intrinsics_revision", 0) + 1
+            item["material_submitted_at"] = item.get("material_submitted_at") or submitted_at
+        self._save_state(state)
+        return files
+
     def finish_upload_batch(self, upload_batch_id: str) -> dict:
         state = self._load_state()
         batch = _require_batch(state, upload_batch_id)

powertech_cli-0.2.0/src/powertech_cli/intrinsics.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import json
+import math
+from pathlib import Path
+from typing import Any
+
+from .errors import CliError
+
+MAX_INTRINSICS_FILE_BYTES = 64 * 1024
+REQUIRED_KEYS = {
+    "image_width",
+    "image_height",
+    "fx",
+    "fy",
+    "cx",
+    "cy",
+    "k1",
+    "k2",
+    "k3",
+    "k4",
+    "camera_model",
+    "p1",
+    "p2",
+}
+FLOAT_KEYS = {"fx", "fy", "cx", "cy", "k1", "k2", "k3", "k4", "p1", "p2"}
+
+
+def load_camera_intrinsics(raw_path: str | Path) -> dict[str, Any]:
+    path = Path(raw_path).expanduser()
+    if not path.is_file():
+        raise CliError(f"Camera intrinsics file does not exist: {path}")
+    if path.suffix.lower() != ".json":
+        raise CliError("Camera intrinsics must be provided as a JSON file.")
+    if path.stat().st_size > MAX_INTRINSICS_FILE_BYTES:
+        raise CliError("Camera intrinsics JSON must not exceed 64 KiB.")
+
+    try:
+        parameters = json.loads(
+            path.read_text(encoding="utf-8"),
+            parse_constant=lambda value: _reject_non_finite(value),
+        )
+    except (OSError, UnicodeError, ValueError) as exc:
+        raise CliError(f"Could not read camera intrinsics JSON: {exc}") from exc
+
+    if not isinstance(parameters, dict):
+        raise CliError("Camera intrinsics JSON must contain one object.")
+    missing = sorted(REQUIRED_KEYS - parameters.keys())
+    extra = sorted(parameters.keys() - REQUIRED_KEYS)
+    if missing or extra:
+        details: list[str] = []
+        if missing:
+            details.append(f"missing: {', '.join(missing)}")
+        if extra:
+            details.append(f"unexpected: {', '.join(extra)}")
+        raise CliError(f"Invalid camera intrinsics fields ({'; '.join(details)}).")
+
+    for key in ("image_width", "image_height"):
+        value = parameters[key]
+        if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+            raise CliError(f"Camera intrinsics field {key} must be a positive integer.")
+    for key in FLOAT_KEYS:
+        value = parameters[key]
+        if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
+            raise CliError(f"Camera intrinsics field {key} must be a finite number.")
+        parameters[key] = float(value)
+    for key in ("fx", "fy"):
+        if parameters[key] <= 0:
+            raise CliError(f"Camera intrinsics field {key} must be greater than 0.")
+    if parameters["camera_model"] != "PinHole":
+        raise CliError("Camera intrinsics field camera_model must be PinHole.")
+    if not 0 <= parameters["cx"] <= parameters["image_width"]:
+        raise CliError("Camera intrinsics field cx must be within the image width.")
+    if not 0 <= parameters["cy"] <= parameters["image_height"]:
+        raise CliError("Camera intrinsics field cy must be within the image height.")
+
+    return {"file_name": path.name, "parameters": parameters}
+
+
+def _reject_non_finite(value: str) -> None:
+    raise ValueError(f"non-finite number: {value}")

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli/main.py

@@ -10,6 +10,7 @@ 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 .intrinsics import load_camera_intrinsics
 from .storage import build_storage_client
 from .utils import collect_video_files, format_bytes, read_video_duration_ms, utc_now
 
@@ -44,8 +45,11 @@ def build_parser() -> argparse.ArgumentParser:
 
     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(
+        "--intrinsics",
+        required=True,
+        help="Camera intrinsics JSON applied to every video in this command",
+    )
     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)
@@ -85,29 +89,38 @@ def handle_login(args: argparse.Namespace) -> int:
 
 
 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()
-
+    intrinsics = load_camera_intrinsics(args.intrinsics)
     upload_items: list[tuple[Path, str]] = []
     for raw_path in args.paths:
-        upload_items.extend(collect_video_files(Path(raw_path), recursive=args.recursive))
+        upload_items.extend(collect_video_files(Path(raw_path)))
 
     if not upload_items:
         raise CliError("No supported MP4 or MOV files were found.")
+    relative_names = [relative_name for _, relative_name in upload_items]
+    duplicate_names = sorted({name for name in relative_names if relative_names.count(name) > 1})
+    if duplicate_names:
+        raise CliError(
+            "Selected paths produce duplicate upload names: "
+            f"{', '.join(duplicate_names)}. Upload those inputs separately."
+        )
 
     if args.dry_run:
         print(f"Matched {len(upload_items)} video file(s):")
+        print(f"Camera intrinsics: {args.intrinsics} (applies to every matched video)")
         for source_path, relative_name in upload_items:
             print(f"- {source_path} -> {relative_name} ({format_bytes(source_path.stat().st_size)})")
         return 0
 
+    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()
+
     checkpoint_identity = _checkpoint_identity(config)
     checkpoints = {
-        fingerprint: checkpoint_store.load(fingerprint) if args.resume else None
+        fingerprint: checkpoint_store.load(fingerprint)
         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}
@@ -131,8 +144,13 @@ def handle_upload(args: argparse.Namespace) -> int:
             upload_batch_id=upload_batch_id,
             source_path=source_path,
             relative_name=relative_name,
-            resume=args.resume,
         )
+    backend.attach_upload_batch_materials(
+        upload_batch_id=upload_batch_id,
+        relative_paths=relative_names,
+        intrinsics=intrinsics,
+    )
+    print(f"Attached {intrinsics['file_name']} to {len(upload_items)} video file(s)")
     backend.finish_upload_batch(upload_batch_id)
     for source_path, _ in upload_items:
         checkpoint_store.delete(compute_upload_fingerprint(source_path, checkpoint_identity))
@@ -228,10 +246,9 @@ def _upload_one(
     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
+    checkpoint = checkpoint_store.load(fingerprint)
     if checkpoint:
         if checkpoint.completed:
             print(f"Already uploaded in this batch: {source_path}")
@@ -274,7 +291,7 @@ def _upload_one(
         object_key=checkpoint.object_key,
         checkpoint=checkpoint,
         checkpoint_store=checkpoint_store,
-        resume=resume,
+        resume=True,
     )
     completed = backend.complete_upload(
         upload_batch_id=upload_batch_id,

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli/utils.py

@@ -87,7 +87,7 @@ def ensure_supported_video(path: Path) -> None:
         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]]:
+def collect_video_files(input_path: Path) -> list[tuple[Path, str]]:
     path = input_path.expanduser()
     if not path.exists():
         raise CliError(f"Path does not exist: {path}")
@@ -99,7 +99,7 @@ def collect_video_files(input_path: Path, recursive: bool) -> list[tuple[Path, s
     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()
+    candidates = path.rglob("*")
     files: list[tuple[Path, str]] = []
     for candidate in sorted(candidates):
         if not candidate.is_file():
@@ -110,8 +110,7 @@ def collect_video_files(input_path: Path, recursive: bool) -> list[tuple[Path, s
         files.append((candidate, relative_name))
 
     if not files:
-        scope = "recursively " if recursive else ""
-        raise CliError(f"No supported video files found {scope}under: {path}")
+        raise CliError(f"No supported video files found under: {path}")
 
     return files
 

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: powertech-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: PowerTech CLI for batch video upload and result download.
 Author: PowerTech
 Requires-Python: >=3.11
@@ -35,13 +35,13 @@ 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_CLI_HOME=~/.powertech/development \
 powertech login --token <development_token> --api-url http://127.0.0.1:8000
 ```
 
 ### Staging
 
-Use the same editable installation and save staging credentials separately:
+Use the same package and save staging credentials separately:
 
 ```bash
 POWERTECH_CLI_HOME=~/.powertech/staging \
@@ -66,17 +66,30 @@ 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.
+Every upload command requires one camera intrinsics JSON. It is validated locally,
+then applied to every video selected by that command. Directory inputs recursively
+find MP4 and MOV files and preserve relative paths. Interrupted uploads resume from
+local checkpoints automatically.
 
 ```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 upload ./video.mp4 --intrinsics ./camera-a.json
+
+POWERTECH_CLI_HOME=~/.powertech/staging \
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+
 POWERTECH_CLI_HOME=~/.powertech/staging powertech status <upload_batch_id>
 ```
 
 Supported input formats: MP4 and MOV.
 
+Run separate commands when videos use different cameras or intrinsics:
+
+```bash
+powertech upload ./camera-a-videos --intrinsics ./camera-a.json
+powertech upload ./camera-b-videos --intrinsics ./camera-b.json
+```
+
 ## Download
 
 ```bash
@@ -93,7 +106,7 @@ The isolated mock adapter does not use RDS or OSS:
 
 ```bash
 powertech login --token dev_token --api-url local
-powertech upload ./videos --recursive --resume
+powertech upload ./videos --intrinsics ./camera-a.json
 ```
 
 CLI state is stored under `~/.powertech/`. Set `POWERTECH_CLI_HOME` to use another
@@ -102,6 +115,6 @@ 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.
+test. Staging does not deploy or require a separate CLI package. A `vX.Y.Z` tag
+whose commit belongs to `main` and whose value matches the package version publishes
+to PyPI through its trusted publisher; manual dispatch remains a recovery path.

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/src/powertech_cli.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/powertech_cli/api.py
 src/powertech_cli/checkpoint.py
 src/powertech_cli/config.py
 src/powertech_cli/errors.py
+src/powertech_cli/intrinsics.py
 src/powertech_cli/main.py
 src/powertech_cli/utils.py
 src/powertech_cli.egg-info/PKG-INFO
@@ -19,4 +20,5 @@ src/powertech_cli/storage/local.py
 src/powertech_cli/storage/oss.py
 tests/test_cli_flow.py
 tests/test_downloads.py
+tests/test_intrinsics.py
 tests/test_video_metadata.py

{powertech_cli-0.1.0 → powertech_cli-0.2.0}/tests/test_cli_flow.py

@@ -25,12 +25,33 @@ class CliFlowTest(unittest.TestCase):
             check=False,
         )
 
+    def write_intrinsics(self, path: Path, **overrides: object) -> Path:
+        parameters: dict[str, object] = {
+            "image_width": 1920,
+            "image_height": 1080,
+            "fx": 918.4,
+            "fy": 918.2,
+            "cx": 960.0,
+            "cy": 540.0,
+            "k1": 0.0003,
+            "k2": 0.0012,
+            "k3": 0.0,
+            "k4": 0.0,
+            "camera_model": "PinHole",
+            "p1": 0.0002,
+            "p2": -0.0005,
+        }
+        parameters.update(overrides)
+        path.write_text(json.dumps(parameters), encoding="utf-8")
+        return path
+
     def test_login_upload_status_and_files(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             base = Path(tmp)
             home = base / "home"
             video = base / "kitchen_grasp_0012.mp4"
             video.write_bytes(b"video-data" * 2048)
+            intrinsics = self.write_intrinsics(base / "camera-a.json")
 
             login = self.run_cli(
                 home,
@@ -46,16 +67,28 @@ class CliFlowTest(unittest.TestCase):
             )
             self.assertEqual(login.returncode, 0, login.stderr)
 
-            upload = self.run_cli(home, "upload", str(video), "--resume", "--chunk-size-mb", "0.001")
+            upload = self.run_cli(
+                home,
+                "upload",
+                str(video),
+                "--intrinsics",
+                str(intrinsics),
+                "--chunk-size-mb",
+                "0.001",
+            )
             self.assertEqual(upload.returncode, 0, upload.stderr)
             self.assertIn("UploadedFile=", upload.stdout)
             self.assertIn("relative_path=kitchen_grasp_0012.mp4", upload.stdout)
+            self.assertIn("Attached camera-a.json to 1 video file(s)", upload.stdout)
 
             state = json.loads((home / "backend-state.json").read_text(encoding="utf-8"))
             upload_batch_id = next(iter(state["upload_batches"].keys()))
             uploaded_file = next(iter(state["uploaded_files"].values()))
             self.assertTrue(uploaded_file["id"].startswith("uf_"))
             self.assertTrue((home / "local-oss" / uploaded_file["object_key"]).exists())
+            self.assertEqual(uploaded_file["camera_intrinsics"]["file_name"], "camera-a.json")
+            self.assertEqual(uploaded_file["camera_intrinsics_revision"], 1)
+            self.assertIsNotNone(uploaded_file["material_submitted_at"])
 
             status = self.run_cli(home, "status", upload_batch_id)
             self.assertEqual(status.returncode, 0, status.stderr)
@@ -83,14 +116,37 @@ class CliFlowTest(unittest.TestCase):
             (videos / "a.mp4").write_bytes(b"a")
             (nested / "b.mov").write_bytes(b"b")
             (videos / "notes.txt").write_text("ignored", encoding="utf-8")
+            intrinsics = self.write_intrinsics(base / "camera-a.json")
 
             login = self.run_cli(home, "login", "--token", "dev_token", "--api-url", "local")
             self.assertEqual(login.returncode, 0, login.stderr)
 
-            dry_run = self.run_cli(home, "upload", str(videos), "--recursive", "--dry-run")
+            dry_run = self.run_cli(
+                home,
+                "upload",
+                str(videos),
+                "--intrinsics",
+                str(intrinsics),
+                "--dry-run",
+            )
             self.assertEqual(dry_run.returncode, 0, dry_run.stderr)
             self.assertIn("Matched 2 video file(s)", dry_run.stdout)
             self.assertIn("nested/b.mov", dry_run.stdout)
+            self.assertIn("applies to every matched video", dry_run.stdout)
+
+    def test_invalid_intrinsics_fail_before_upload_state_is_created(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            home = base / "home"
+            video = base / "video.mp4"
+            video.write_bytes(b"video")
+            intrinsics = self.write_intrinsics(base / "bad.json", camera_model="Fisheye")
+
+            upload = self.run_cli(home, "upload", str(video), "--intrinsics", str(intrinsics))
+
+            self.assertEqual(upload.returncode, 1)
+            self.assertIn("camera_model must be PinHole", upload.stderr)
+            self.assertFalse((home / "backend-state.json").exists())
 
 
 if __name__ == "__main__":

powertech_cli-0.2.0/tests/test_intrinsics.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from powertech_cli.errors import CliError
+from powertech_cli.intrinsics import load_camera_intrinsics
+
+
+class CameraIntrinsicsTest(unittest.TestCase):
+    def valid_parameters(self) -> dict[str, object]:
+        return {
+            "image_width": 1920,
+            "image_height": 1080,
+            "fx": 918.4,
+            "fy": 918.2,
+            "cx": 960,
+            "cy": 540,
+            "k1": 0,
+            "k2": 0,
+            "k3": 0,
+            "k4": 0,
+            "camera_model": "PinHole",
+            "p1": 0,
+            "p2": 0,
+        }
+
+    def test_loads_and_normalizes_valid_json(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "camera.json"
+            path.write_text(json.dumps(self.valid_parameters()), encoding="utf-8")
+
+            result = load_camera_intrinsics(path)
+
+            self.assertEqual(result["file_name"], "camera.json")
+            self.assertEqual(result["parameters"]["camera_model"], "PinHole")
+            self.assertIsInstance(result["parameters"]["fx"], float)
+
+    def test_rejects_unknown_fields_and_non_finite_numbers(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            unknown = self.valid_parameters()
+            unknown["serial_number"] = "camera-a"
+            unknown_path = base / "unknown.json"
+            unknown_path.write_text(json.dumps(unknown), encoding="utf-8")
+            with self.assertRaisesRegex(CliError, "unexpected: serial_number"):
+                load_camera_intrinsics(unknown_path)
+
+            non_finite_path = base / "non-finite.json"
+            non_finite_path.write_text(json.dumps({**self.valid_parameters(), "fx": float("nan")}), encoding="utf-8")
+            with self.assertRaisesRegex(CliError, "non-finite number"):
+                load_camera_intrinsics(non_finite_path)
+
+
+if __name__ == "__main__":
+    unittest.main()