motion-intelligence 0.2.0__py3-none-any.whl

motion/weight_upload.py

@@ -0,0 +1,324 @@
+"""Upload model weights to S3 via Motion backend presigned URLs.
+
+Developers only need MOTION_API_KEY — never AWS credentials on their machine.
+Small files use a single presigned PUT; large files use S3 multipart upload
+(init → per-part presigned PUT → complete) so multi-GB checkpoints can resume
+per-part instead of restarting the whole file.
+"""
+from __future__ import annotations
+
+import mimetypes
+import os
+import time
+from typing import Callable, Optional
+
+# Use multipart for files >= 64 MiB (S3 minimum part size is 5 MiB).
+MULTIPART_THRESHOLD_BYTES = 64 * 1024 * 1024
+DEFAULT_PART_SIZE_BYTES = 64 * 1024 * 1024
+MAX_PART_RETRIES = 5
+API_TIMEOUT = (30, 120)
+
+
+def upload_weight_via_backend(
+    local_path: str,
+    model_name: str,
+    api_key: str,
+    *,
+    api_url: str,
+    log_ok: Callable[[str], str],
+    log_warn: Callable[[str], str],
+    log_err: Callable[[str], str],
+) -> Optional[str]:
+    """Upload a local weight file; return final s3:// URL or None on failure."""
+    size_bytes = os.path.getsize(local_path)
+    if size_bytes >= MULTIPART_THRESHOLD_BYTES:
+        return _upload_multipart(
+            local_path,
+            model_name,
+            api_key,
+            api_url=api_url,
+            log_ok=log_ok,
+            log_warn=log_warn,
+            log_err=log_err,
+        )
+    return _upload_single_put(
+        local_path,
+        model_name,
+        api_key,
+        api_url=api_url,
+        log_ok=log_ok,
+        log_warn=log_warn,
+        log_err=log_err,
+    )
+
+
+def _api_post(session, api_url: str, path: str, api_key: str, payload: dict) -> dict:
+    r = session.post(
+        f"{api_url}{path}",
+        json=payload,
+        headers={"X-API-Key": api_key},
+        timeout=API_TIMEOUT,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+def _api_post_with_retries(
+    session,
+    api_url: str,
+    path: str,
+    api_key: str,
+    payload: dict,
+    *,
+    log_warn: Callable[[str], str],
+    max_attempts: int = 5,
+) -> Optional[dict]:
+    for attempt in range(1, max_attempts + 1):
+        try:
+            return _api_post(session, api_url, path, api_key, payload)
+        except Exception as e:
+            if attempt < max_attempts:
+                wait = min(30, 2 ** attempt)
+                print(log_warn(f"  ⚠ API {path} failed (attempt {attempt}): {e}"))
+                print(f"    retrying in {wait}s …")
+                time.sleep(wait)
+            else:
+                print(log_err(f"  ✗ API {path} failed after {max_attempts} attempts: {e}"))
+                return None
+    return None
+
+
+def _upload_single_put(
+    local_path: str,
+    model_name: str,
+    api_key: str,
+    *,
+    api_url: str,
+    log_ok: Callable[[str], str],
+    log_warn: Callable[[str], str],
+    log_err: Callable[[str], str],
+) -> Optional[str]:
+    import requests
+
+    filename = os.path.basename(local_path)
+    size_bytes = os.path.getsize(local_path)
+    size_mb = size_bytes / 1e6
+    content_type = mimetypes.guess_type(local_path)[0] or "application/octet-stream"
+    read_timeout = max(3600, int(size_bytes / (512 * 1024)) + 300)
+
+    session = requests.Session()
+    print(f"  ↑ {filename} ({size_mb:.1f} MB) — single PUT upload …")
+
+    for attempt in range(1, MAX_PART_RETRIES + 1):
+        data = _api_post_with_retries(
+            session,
+            api_url,
+            "/api/v1/motion/weights/upload-url",
+            api_key,
+            {
+                "filename": filename,
+                "model_name": model_name,
+                "content_type": content_type,
+            },
+            log_warn=log_warn,
+        )
+        if data is None:
+            return None
+
+        s3_url = data["s3_url"]
+        label = "uploading" if attempt == 1 else f"retry {attempt}/{MAX_PART_RETRIES}"
+        print(f"  ↑ {label} → {s3_url}")
+
+        try:
+            with open(local_path, "rb") as f:
+                put = session.put(
+                    data["upload_url"],
+                    data=f,
+                    headers={"Content-Type": content_type},
+                    timeout=(30, read_timeout),
+                )
+                put.raise_for_status()
+            print(log_ok(f"  ✓ uploaded  {filename} → {s3_url}"))
+            return s3_url
+        except Exception as e:
+            if attempt < MAX_PART_RETRIES:
+                wait = min(30, 2 ** attempt)
+                print(log_warn(f"  ⚠ upload failed (attempt {attempt}): {e}"))
+                print(f"    retrying in {wait}s …")
+                time.sleep(wait)
+            else:
+                print(log_err(f"  ✗ upload failed after {MAX_PART_RETRIES} attempts: {e}"))
+                return None
+    return None
+
+
+def _upload_multipart(
+    local_path: str,
+    model_name: str,
+    api_key: str,
+    *,
+    api_url: str,
+    log_ok: Callable[[str], str],
+    log_warn: Callable[[str], str],
+    log_err: Callable[[str], str],
+) -> Optional[str]:
+    import math
+
+    import requests
+
+    filename = os.path.basename(local_path)
+    size_bytes = os.path.getsize(local_path)
+    size_mb = size_bytes / 1e6
+    content_type = mimetypes.guess_type(local_path)[0] or "application/octet-stream"
+    part_size = DEFAULT_PART_SIZE_BYTES
+    part_count = max(1, math.ceil(size_bytes / part_size))
+
+    session = requests.Session()
+    print(
+        f"  ↑ {filename} ({size_mb:.1f} MB) — multipart upload "
+        f"({part_count} parts × {part_size / (1024 * 1024):.0f} MiB) …"
+    )
+
+    init = _api_post_with_retries(
+        session,
+        api_url,
+        "/api/v1/motion/weights/multipart/init",
+        api_key,
+        {
+            "filename": filename,
+            "model_name": model_name,
+            "content_type": content_type,
+            "file_size": size_bytes,
+            "part_size": part_size,
+        },
+        log_warn=log_warn,
+    )
+    if init is None:
+        return None
+
+    upload_id = init["upload_id"]
+    s3_key = init["s3_key"]
+    s3_url = init["s3_url"]
+    print(f"  ↑ destination → {s3_url}")
+
+    completed_parts: list[dict] = []
+    upload_failed = False
+
+    try:
+        with open(local_path, "rb") as f:
+            for part_number in range(1, part_count + 1):
+                chunk = f.read(part_size)
+                if not chunk:
+                    break
+
+                uploaded = False
+                for attempt in range(1, MAX_PART_RETRIES + 1):
+                    part_meta = _api_post_with_retries(
+                        session,
+                        api_url,
+                        "/api/v1/motion/weights/multipart/part-url",
+                        api_key,
+                        {
+                            "s3_key": s3_key,
+                            "upload_id": upload_id,
+                            "part_number": part_number,
+                        },
+                        log_warn=log_warn,
+                        max_attempts=3,
+                    )
+                    if part_meta is None:
+                        upload_failed = True
+                        break
+
+                    try:
+                        put = session.put(
+                            part_meta["upload_url"],
+                            data=chunk,
+                            timeout=(30, 600),
+                        )
+                        put.raise_for_status()
+                        etag = put.headers.get("ETag", "").strip('"')
+                        if not etag:
+                            raise RuntimeError(f"missing ETag for part {part_number}")
+                        completed_parts.append(
+                            {"part_number": part_number, "etag": etag}
+                        )
+                        uploaded = True
+                        pct = 100.0 * part_number / part_count
+                        print(
+                            f"    part {part_number}/{part_count} "
+                            f"({pct:.0f}%, {len(chunk) / (1024 * 1024):.1f} MiB)"
+                        )
+                        break
+                    except Exception as e:
+                        if attempt < MAX_PART_RETRIES:
+                            wait = min(15, 2 ** attempt)
+                            print(
+                                log_warn(
+                                    f"  ⚠ part {part_number} failed "
+                                    f"(attempt {attempt}): {e}"
+                                )
+                            )
+                            time.sleep(wait)
+                        else:
+                            print(
+                                log_err(
+                                    f"  ✗ part {part_number} failed after "
+                                    f"{MAX_PART_RETRIES} attempts: {e}"
+                                )
+                            )
+                            upload_failed = True
+                            break
+
+                if not uploaded:
+                    upload_failed = True
+                    break
+
+        if upload_failed:
+            _abort_multipart(session, api_url, api_key, s3_key, upload_id, log_warn)
+            return None
+
+        complete = _api_post_with_retries(
+            session,
+            api_url,
+            "/api/v1/motion/weights/multipart/complete",
+            api_key,
+            {
+                "s3_key": s3_key,
+                "upload_id": upload_id,
+                "parts": completed_parts,
+            },
+            log_warn=log_warn,
+        )
+        if complete is None:
+            _abort_multipart(session, api_url, api_key, s3_key, upload_id, log_warn)
+            return None
+
+        final_url = complete.get("s3_url", s3_url)
+        print(log_ok(f"  ✓ uploaded  {filename} → {final_url}"))
+        return final_url
+
+    except Exception as e:
+        print(log_err(f"  ✗ multipart upload failed: {e}"))
+        _abort_multipart(session, api_url, api_key, s3_key, upload_id, log_warn)
+        return None
+
+
+def _abort_multipart(
+    session,
+    api_url: str,
+    api_key: str,
+    s3_key: str,
+    upload_id: str,
+    log_warn: Callable[[str], str],
+) -> None:
+    try:
+        _api_post(
+            session,
+            api_url,
+            "/api/v1/motion/weights/multipart/abort",
+            api_key,
+            {"s3_key": s3_key, "upload_id": upload_id},
+        )
+    except Exception as e:
+        print(log_warn(f"  ⚠ could not abort incomplete multipart upload: {e}"))

motion_intelligence-0.2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,15 @@
+motion/__init__.py,sha256=wntmmPl2ftB947kd3FcEtEF7uX_W5VGyye9ZLDF-JWc,292
+motion/batch.py,sha256=nI_vP5Jy-IjXKV3e1vDK_XvSrAtSuMSaft-66Dvi4P8,5152
+motion/categories.py,sha256=nfJpsBQsiTr8RvpKIR4UEh7wBmmOlt9ccKGlPKiTbUE,1235
+motion/cli.py,sha256=PRoXW3oaHBcZ9RQjiNrJAgELIixJNgZgXtAJ-4JwJ6w,19761
+motion/config.py,sha256=H093udCVsQkywVeEh5o3tYFU5NdToZ4BwdFcn0rmixA,5748
+motion/dockerfile.py,sha256=yTpxRrRAjqlE8TZNsiM20oRPfuu9Nm38sc5Gsz1sZZo,5023
+motion/predictor.py,sha256=hVGaE_0p5ohrx7QJW-fhzkl83oV9cVo42YwGtKInJ84,2211
+motion/profile.py,sha256=5nx0OYox_btGx1DNg-tiq0EOoRVl37emcUp8eZfehSA,9735
+motion/server.py,sha256=3v4I-78mEgcEjJ8Ler-miAscFi5qOCOCGshIgNjCs4g,5066
+motion/weight_upload.py,sha256=J4EZKQjFZUFQ-ZU3UWsb1QvLDcqg0WQkLxOYvfqQSdI,10416
+motion_intelligence-0.2.0.dist-info/METADATA,sha256=qsicn3hYj_WLtHrEx8ZjG7cWGXKURselGGky0kOa0OA,3991
+motion_intelligence-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+motion_intelligence-0.2.0.dist-info/entry_points.txt,sha256=VNMZnZpeWzX2w7CtKSbalOs3mkKSYkeNTudgCkxnQnE,43
+motion_intelligence-0.2.0.dist-info/top_level.txt,sha256=E9RTvbgvBIgO3RWcgGtgIHlM3v-RG0fqt-WzobhO1c0,7
+motion_intelligence-0.2.0.dist-info/RECORD,,

motion_intelligence-0.2.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
+

motion_intelligence-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+motion = motion.cli:main

motion_intelligence-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+motion