motion-intelligence 0.2.0__py3-none-any.whl

motion/__init__.py

@@ -0,0 +1,10 @@
+"""motion — package & deploy models to the Motion inference platform.
+
+Authors import from here in their predict.py:
+
+    from motion import BasePredictor, Input, Path
+"""
+from .predictor import BasePredictor, Input, Path
+
+__all__ = ["BasePredictor", "Input", "Path"]
+__version__ = "0.1.0"

motion/batch.py

@@ -0,0 +1,153 @@
+"""Batch job runner — invoked when the container runs inside AWS Batch.
+
+Environment variables (set by the Lambda dispatcher):
+  JOB_ID          — unique job identifier
+  S3_BUCKET       — bucket for input/output files
+  INPUT_KEY       — S3 key of the input file (video/image)
+  CALLBACK_URL    — backend URL to POST result to
+  CALLBACK_SECRET — shared secret for the callback
+
+The container exits 0 on success, non-zero on failure.
+The backend marks the job completed/failed via the callback.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+import boto3
+
+
+def _env(name: str, required: bool = True, default: str = "") -> str:
+    val = os.environ.get(name, default).strip()
+    if required and not val:
+        raise RuntimeError(f"Missing required env var: {name}")
+    return val
+
+
+def _download_s3(bucket: str, key: str, dest: Path) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    print(f"[batch] download s3://{bucket}/{key} → {dest}")
+    boto3.client("s3").download_file(bucket, key, str(dest))
+
+
+def _upload_s3(bucket: str, key: str, path: Path, content_type: str) -> None:
+    print(f"[batch] upload {path} → s3://{bucket}/{key}")
+    boto3.client("s3").upload_file(
+        str(path), bucket, key,
+        ExtraArgs={"ContentType": content_type},
+    )
+
+
+def _callback(callback_url: str, job_id: str, secret: str, *,
+              status: str, output_key: str | None = None,
+              error: str | None = None) -> None:
+    url = f"{callback_url.rstrip('/')}/api/v1/motion/jobs/{job_id}/callback"
+    payload: dict = {"status": status, "callback_secret": secret}
+    if output_key:
+        payload["output_video_key"] = output_key
+    if error:
+        payload["error_message"] = error
+    req = urllib.request.Request(
+        url, data=json.dumps(payload).encode(),
+        headers={"Content-Type": "application/json"}, method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=120) as r:
+            print(f"[batch] callback HTTP {r.status}")
+    except Exception as e:
+        print(f"[batch] callback failed: {e}")
+
+
+def _ext_for(path_str: str) -> str:
+    ext = Path(path_str).suffix
+    return ext if ext else ".mp4"
+
+
+def _content_type(ext: str) -> str:
+    return {
+        ".mp4": "video/mp4",
+        ".glb": "model/gltf-binary",
+        ".obj": "text/plain",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".json": "application/json",
+    }.get(ext.lower(), "application/octet-stream")
+
+
+def main() -> int:
+    job_id          = _env("JOB_ID")
+    bucket          = _env("S3_BUCKET")
+    input_key       = _env("INPUT_KEY")
+    callback_url    = _env("CALLBACK_URL")
+    callback_secret = _env("CALLBACK_SECRET")
+
+    print(f"[batch] job={job_id}  model={os.environ.get('MOTION_NAME','?')}  input={input_key}")
+
+    work = Path(tempfile.mkdtemp(prefix=f"motion-{job_id[:8]}-"))
+    input_ext  = _ext_for(input_key)
+    input_path = work / f"input{input_ext}"
+
+    try:
+        # 1. Pull weights declared in motion.yml (skipped if already present)
+        from .server import _fetch_weights, _load_predictor
+        _fetch_weights()
+
+        # 2. Load predictor and call setup() once
+        predictor = _load_predictor()
+        predictor.setup()
+
+        # 3. Download input from S3
+        _download_s3(bucket, input_key, input_path)
+
+        # 4. Run predict() — pass input as a Path
+        import inspect
+        sig = inspect.signature(predictor.predict)
+        first_param = next(iter(sig.parameters.values()))
+
+        # Coerce input to the annotated type (Path or str)
+        annotation = first_param.annotation
+        if annotation is Path or str(annotation) == "<class 'pathlib.Path'>":
+            input_arg = input_path
+        else:
+            input_arg = str(input_path)
+
+        print(f"[batch] running predict({first_param.name}={input_path})")
+        result = predictor.predict(**{first_param.name: input_arg})
+
+        # 5. Upload output to S3
+        output_path = Path(str(result))
+        if not output_path.exists():
+            raise FileNotFoundError(f"predict() did not produce output: {output_path}")
+
+        output_ext = output_path.suffix or ".mp4"
+        output_key = f"outputs/{job_id}/output{output_ext}"
+        _upload_s3(bucket, output_key, output_path, _content_type(output_ext))
+
+        # 6. Callback → backend marks job completed
+        _callback(callback_url, job_id, callback_secret,
+                  status="completed", output_key=output_key)
+        print(f"[batch] done  output=s3://{bucket}/{output_key}")
+        return 0
+
+    except Exception as exc:
+        print(f"[batch] FAILED: {exc}", file=sys.stderr)
+        import traceback; traceback.print_exc()
+        _callback(callback_url, job_id, callback_secret,
+                  status="failed", error=str(exc))
+        return 1
+
+    finally:
+        for p in work.glob("*"):
+            try: p.unlink()
+            except OSError: pass
+        try: work.rmdir()
+        except OSError: pass
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

motion/categories.py

@@ -0,0 +1,46 @@
+"""Static category_code → category_id map (prod catalog).
+
+Used by `motion deploy` until the platform exposes a category lookup API.
+Refresh when categories are added in meta.model_category.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+# From GET /api/v1/motion/models (2026-06)
+CATEGORY_CODE_TO_ID: dict[str, int] = {
+    "skeleton": 1,
+    "capsule": 2,
+    "mesh": 3,
+    "hand-tracking": 4,
+    "3d-object": 5,
+    "vlm": 6,
+    "vla": 7,
+    "world": 8,
+    "annotation": 9,
+    "reconstruction": 10,
+    "spatial-perception": 11,
+}
+
+
+def resolve_category_id(
+    *,
+    category_id: Optional[int],
+    category_code: str,
+) -> Optional[int]:
+    """Return category_id from motion.yml `category_id` or mapped `category` code."""
+    if category_id is not None:
+        return int(category_id)
+    code = (category_code or "").strip().lower()
+    if not code:
+        return None
+    if code.isdigit():
+        return int(code)
+    mapped = CATEGORY_CODE_TO_ID.get(code)
+    if mapped is None:
+        known = ", ".join(sorted(CATEGORY_CODE_TO_ID))
+        raise ValueError(
+            f"Unknown category '{category_code}'. "
+            f"Use category_id or one of: {known}"
+        )
+    return mapped