motion-intelligence 0.2.0__tar.gz

motion_intelligence-0.2.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: motion-intelligence
+Version: 0.2.0
+Summary: Author, build & deploy Python models for the Motion inference platform
+Project-URL: Homepage, https://github.com/devathub9/Motion-packages
+Project-URL: Repository, https://github.com/devathub9/Motion-packages
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: requests>=2.28
+Requires-Dist: boto3>=1.26
+
+# motion-cli (Python)
+
+Build and deploy Docker images for models on the Motion inference platform.
+
+```bash
+pip install -e /path/to/cli-py    # gives the `motion` command
+export MOTION_API_KEY=motion_live_<your_key>
+```
+
+## Quick start
+
+A model is a folder with `motion.yml` + `predict.py`:
+
+```python
+# predict.py
+from motion import BasePredictor, Input, Path
+
+class MyPredictor(BasePredictor):
+    def setup(self):
+        self.model = load_model(...)
+
+    def predict(self, video: Path = Input(description="Input clip")) -> Path:
+        out = "/tmp/out.mp4"
+        self.model.run(video, out)
+        return Path(out)
+```
+
+```yaml
+# motion.yml
+name: lingbot-map
+predict: predict.py:MyPredictor
+description: Streaming 3D reconstruction
+
+# Where the model appears in GET /api/v1/motion/models
+category: reconstruction          # required for catalog listing
+inference_model: lingbot-map      # optional; defaults to `name`
+input_type: video                 # video | image | text
+output_type: mp4
+
+# Used by `motion deploy` to measure CPU/RAM via docker stats
+sample: demo_files/input.mp4
+
+build:
+  gpu: true
+  cuda: "11.8"
+  python_version: "3.11"
+  system_packages: [ffmpeg]
+  python_packages: ["torch>=2.4.0"]
+
+# Optional — overrides auto-profiling
+compute:
+  cpu: 4
+  memory_mib: 16384
+  gpu: true
+
+weights:
+  - path: weights/model.pt
+    url: https://example.com/model.pt
+    dest: weights/model.pt
+```
+
+## Commands
+
+### `motion build`
+
+Uploads local weights to S3 (via `MOTION_API_KEY`, no AWS creds on your machine),
+generates `.motion/Dockerfile`, and builds `motion-<name>:latest`.
+
+```bash
+motion build .                  # build image
+motion build . --dry-run        # print Dockerfile only
+motion build . --tag myimg:dev  # custom tag
+```
+
+**Requires:** `MOTION_API_KEY` when `weights:` has local files to upload.
+
+Large weights (≥64 MiB) use multipart S3 upload automatically.
+
+### `motion deploy`
+
+Profiles the local image, pushes to ECR, and registers the model in the platform.
+
+```bash
+motion deploy .
+motion deploy . --no-profile              # skip docker stats measurement
+motion deploy . --sample tests/clip.mp4   # override profiling input
+motion deploy . --profile-timeout 300     # longer profiling window
+```
+
+**Flow:**
+1. Parse `motion.yml` (including `category`, `sample`, `compute`)
+2. **Profile** — run the container locally, poll `docker stats`, derive `cpu_vcpus` + `memory_mib`
+   - Skipped if `compute:` is set in motion.yml (`compute_source=declared`)
+   - Skipped with `--no-profile`
+   - Skipped if no sample file is found
+3. Push image to ECR (backend issues a short-lived docker login token)
+4. **Register** — `POST /api/v1/motion/models/register` with:
+   - `model_code` = `<namespace>/<name>` (e.g. `saurav/lingbot-map`)
+   - `category_code`, `inference_model_slug`, compute profile, predict params
+
+**Requires:** `MOTION_API_KEY`, local image from `motion build`.
+
+**Category codes:** list with `GET /api/v1/motion/models` — e.g. `reconstruction`, `hand-tracking`, `mesh`, `3d-object`.
+
+After deploy, submit jobs with:
+
+```bash
+POST /api/v1/motion/submit   model_name=<namespace>/<name>
+```
+
+## Environment
+
+| Variable | Purpose |
+|----------|---------|
+| `MOTION_API_KEY` | Auth for build (weight upload) and deploy (ECR + register) |
+| `MOTION_API_URL` | Backend base URL (default: Motion App Runner prod) |
+
+## Image contract
+
+Every built image exposes: `GET /health`, `GET /schema`, `POST /predict`.
+
+Weights declared in `motion.yml` are fetched from S3 at container startup — not baked into the image.

motion_intelligence-0.2.0/README.md

@@ -0,0 +1,122 @@
+# motion-cli (Python)
+
+Build and deploy Docker images for models on the Motion inference platform.
+
+```bash
+pip install -e /path/to/cli-py    # gives the `motion` command
+export MOTION_API_KEY=motion_live_<your_key>
+```
+
+## Quick start
+
+A model is a folder with `motion.yml` + `predict.py`:
+
+```python
+# predict.py
+from motion import BasePredictor, Input, Path
+
+class MyPredictor(BasePredictor):
+    def setup(self):
+        self.model = load_model(...)
+
+    def predict(self, video: Path = Input(description="Input clip")) -> Path:
+        out = "/tmp/out.mp4"
+        self.model.run(video, out)
+        return Path(out)
+```
+
+```yaml
+# motion.yml
+name: lingbot-map
+predict: predict.py:MyPredictor
+description: Streaming 3D reconstruction
+
+# Where the model appears in GET /api/v1/motion/models
+category: reconstruction          # required for catalog listing
+inference_model: lingbot-map      # optional; defaults to `name`
+input_type: video                 # video | image | text
+output_type: mp4
+
+# Used by `motion deploy` to measure CPU/RAM via docker stats
+sample: demo_files/input.mp4
+
+build:
+  gpu: true
+  cuda: "11.8"
+  python_version: "3.11"
+  system_packages: [ffmpeg]
+  python_packages: ["torch>=2.4.0"]
+
+# Optional — overrides auto-profiling
+compute:
+  cpu: 4
+  memory_mib: 16384
+  gpu: true
+
+weights:
+  - path: weights/model.pt
+    url: https://example.com/model.pt
+    dest: weights/model.pt
+```
+
+## Commands
+
+### `motion build`
+
+Uploads local weights to S3 (via `MOTION_API_KEY`, no AWS creds on your machine),
+generates `.motion/Dockerfile`, and builds `motion-<name>:latest`.
+
+```bash
+motion build .                  # build image
+motion build . --dry-run        # print Dockerfile only
+motion build . --tag myimg:dev  # custom tag
+```
+
+**Requires:** `MOTION_API_KEY` when `weights:` has local files to upload.
+
+Large weights (≥64 MiB) use multipart S3 upload automatically.
+
+### `motion deploy`
+
+Profiles the local image, pushes to ECR, and registers the model in the platform.
+
+```bash
+motion deploy .
+motion deploy . --no-profile              # skip docker stats measurement
+motion deploy . --sample tests/clip.mp4   # override profiling input
+motion deploy . --profile-timeout 300     # longer profiling window
+```
+
+**Flow:**
+1. Parse `motion.yml` (including `category`, `sample`, `compute`)
+2. **Profile** — run the container locally, poll `docker stats`, derive `cpu_vcpus` + `memory_mib`
+   - Skipped if `compute:` is set in motion.yml (`compute_source=declared`)
+   - Skipped with `--no-profile`
+   - Skipped if no sample file is found
+3. Push image to ECR (backend issues a short-lived docker login token)
+4. **Register** — `POST /api/v1/motion/models/register` with:
+   - `model_code` = `<namespace>/<name>` (e.g. `saurav/lingbot-map`)
+   - `category_code`, `inference_model_slug`, compute profile, predict params
+
+**Requires:** `MOTION_API_KEY`, local image from `motion build`.
+
+**Category codes:** list with `GET /api/v1/motion/models` — e.g. `reconstruction`, `hand-tracking`, `mesh`, `3d-object`.
+
+After deploy, submit jobs with:
+
+```bash
+POST /api/v1/motion/submit   model_name=<namespace>/<name>
+```
+
+## Environment
+
+| Variable | Purpose |
+|----------|---------|
+| `MOTION_API_KEY` | Auth for build (weight upload) and deploy (ECR + register) |
+| `MOTION_API_URL` | Backend base URL (default: Motion App Runner prod) |
+
+## Image contract
+
+Every built image exposes: `GET /health`, `GET /schema`, `POST /predict`.
+
+Weights declared in `motion.yml` are fetched from S3 at container startup — not baked into the image.

motion_intelligence-0.2.0/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_intelligence-0.2.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_intelligence-0.2.0/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