motion-intelligence 0.2.0__py3-none-any.whl

motion/dockerfile.py

@@ -0,0 +1,110 @@
+"""Turn a MotionConfig into a Dockerfile string."""
+from .config import MotionConfig
+
+
+def generate_dockerfile(cfg: MotionConfig) -> str:
+    b = cfg.build
+    py = b.python_version
+
+    if b.gpu:
+        base = f"nvidia/cuda:{b.cuda}.0-cudnn8-runtime-ubuntu22.04"
+        # Ubuntu 22.04 ships only python3.10; the deadsnakes PPA provides any
+        # other version, then we bootstrap pip for that interpreter via get-pip.
+        python_setup = (
+            "RUN apt-get update && apt-get install -y --no-install-recommends \\\n"
+            "        software-properties-common gnupg2 curl ca-certificates \\\n"
+            "    && add-apt-repository -y ppa:deadsnakes/ppa \\\n"
+            "    && apt-get update && apt-get install -y --no-install-recommends \\\n"
+            f"        python{py} python{py}-dev python{py}-distutils \\\n"
+            f"    && ln -sf /usr/bin/python{py} /usr/bin/python \\\n"
+            f"    && curl -sS https://bootstrap.pypa.io/get-pip.py | python{py} \\\n"
+            "    && rm -rf /var/lib/apt/lists/*"
+        )
+    else:
+        base = f"python:{py}-slim"
+        python_setup = "# python provided by base image"
+
+    sys_pkgs = "# (none)"
+    if b.system_packages:
+        pkgs = " ".join(b.system_packages)
+        sys_pkgs = (
+            "RUN apt-get update && apt-get install -y --no-install-recommends \\\n"
+            f"        {pkgs} \\\n"
+            "    && rm -rf /var/lib/apt/lists/*"
+        )
+
+    find_links = " ".join(f"-f {url}" for url in b.python_find_links)
+    index_url = f"--index-url {b.python_index_url}" if b.python_index_url else ""
+    py_pkgs = "# (none in motion.yml)"
+    if b.python_packages:
+        pkgs_str = " ".join(f'"{p}"' for p in b.python_packages)
+        if b.python_index_url:
+            # Three-pass install when a custom index (e.g. PyTorch CPU) is given:
+            #  1. Install torch & torchvision from the custom index (CPU-only wheels).
+            #  2. Install everything else from PyPI with --upgrade-strategy only-if-needed
+            #     so pip won't upgrade the already-pinned torch to the GPU variant.
+            #  3. Re-pin torch from the custom index again to undo any accidental upgrade
+            #     that transitive deps might have triggered in step 2.
+            torch_pkgs = [p for p in b.python_packages if "torch" in p.lower()]
+            other_pkgs = [p for p in b.python_packages if "torch" not in p.lower()]
+            lines = []
+            if torch_pkgs:
+                tp = " ".join(f'"{p}"' for p in torch_pkgs)
+                lines.append(f"RUN pip install --no-cache-dir {tp} {index_url}")
+            if other_pkgs:
+                op = " ".join(f'"{p}"' for p in other_pkgs)
+                fl = f" {find_links}" if find_links else ""
+                lines.append(
+                    f"RUN pip install --no-cache-dir --upgrade-strategy only-if-needed {op}{fl}"
+                )
+            # Re-pin torch so nothing in step 2 silently upgraded it to a GPU wheel
+            if torch_pkgs:
+                tp = " ".join(f'"{p}"' for p in torch_pkgs)
+                lines.append(f"RUN pip install --no-cache-dir --force-reinstall --no-deps {tp} {index_url}")
+            py_pkgs = "\n".join(lines)
+        else:
+            extras = f" {find_links}" if find_links else ""
+            py_pkgs = f"RUN pip install --no-cache-dir {pkgs_str}{extras}"
+
+    # weights are pulled at startup, not baked — only the small manifest is copied
+    weights_copy = "# (no weights: section — nothing pulled at startup)"
+    if cfg.weights:
+        weights_copy = "COPY .motion/weights.json /opt/motion-runtime/weights.json"
+
+    return f"""# ─── generated by `motion build` — do not edit ───
+FROM {base}
+
+ENV PYTHONUNBUFFERED=1 PIP_NO_CACHE_DIR=1 DEBIAN_FRONTEND=noninteractive TZ=UTC
+{python_setup}
+
+# --- system packages from motion.yml ---
+{sys_pkgs}
+
+# --- the motion runtime (server + contract), vendored into the image ---
+COPY .motion/runtime /opt/motion-runtime
+ENV PYTHONPATH=/opt/motion-runtime
+RUN pip install --no-cache-dir fastapi "uvicorn[standard]" pyyaml python-multipart requests boto3
+
+# --- weights manifest (files fetched at startup, see motion.yml `weights:`) ---
+{weights_copy}
+
+# --- model python deps from motion.yml ---
+{py_pkgs}
+
+WORKDIR /src
+# install requirements.txt first (better layer caching) if present
+COPY requirements.tx[t] /src/
+RUN if [ -f requirements.txt ]; then pip install --no-cache-dir -r requirements.txt; fi
+
+# --- the model code ---
+COPY . /src
+
+# entrypoint metadata read by motion.server / motion.batch at boot
+ENV MOTION_PREDICT="{cfg.predict}"
+ENV MOTION_NAME="{cfg.name}"
+EXPOSE 8000
+
+# Batch mode  : JOB_ID is set by the Lambda dispatcher → runs motion.batch (one-shot)
+# HTTP mode   : no JOB_ID                              → runs motion.server (uvicorn)
+CMD ["python", "-c", "import os, runpy; runpy.run_module(\\"motion.batch\\" if os.environ.get(\\"JOB_ID\\") else \\"motion.server\\", run_name=\\"__main__\\")"]
+"""

motion/predictor.py

@@ -0,0 +1,62 @@
+"""The contract every model's predict.py implements.
+
+A model author writes a class that subclasses BasePredictor:
+
+    from motion import BasePredictor, Input, Path
+
+    class MyPredictor(BasePredictor):
+        def setup(self):
+            self.model = load_weights(...)        # runs ONCE at container boot
+
+        def predict(self, video: Path = Input(description="clip"),
+                          fps: int = Input(default=10)) -> Path:
+            ...                                    # runs PER request
+            return Path("/tmp/out.mp4")
+
+`setup()` is separated from `predict()` on purpose: setup is expensive
+(load 5GB of weights into VRAM) and must happen only once, while predict is
+cheap and runs on every request. That split is what makes autoscaling cheap.
+"""
+from pathlib import Path  # re-exported so authors do `from motion import Path`
+
+# sentinel meaning "no default → this input is required"
+_REQUIRED = object()
+
+
+class Input:
+    """Describes one argument of predict(). Used as the parameter default:
+
+        fps: int = Input(default=10, description="sampling fps", ge=1, le=60)
+    """
+
+    def __init__(self, default=_REQUIRED, description=None, ge=None, le=None,
+                 choices=None):
+        self.default = default
+        self.description = description
+        self.ge = ge
+        self.le = le
+        self.choices = choices
+
+    @property
+    def required(self) -> bool:
+        return self.default is _REQUIRED
+
+    def validate(self, name, value):
+        if self.choices is not None and value not in self.choices:
+            raise ValueError(f"{name}={value!r} not in allowed {self.choices}")
+        if self.ge is not None and value < self.ge:
+            raise ValueError(f"{name}={value!r} must be >= {self.ge}")
+        if self.le is not None and value > self.le:
+            raise ValueError(f"{name}={value!r} must be <= {self.le}")
+        return value
+
+
+class BasePredictor:
+    """Subclass this in predict.py."""
+
+    def setup(self) -> None:
+        """Load weights / warm the model. Called once before serving traffic."""
+        pass
+
+    def predict(self, **kwargs):
+        raise NotImplementedError("Your predictor must implement predict()")

motion/profile.py

@@ -0,0 +1,345 @@
+"""Measure container CPU/memory with docker stats during `motion deploy`."""
+from __future__ import annotations
+
+import math
+import os
+import re
+import shlex
+import subprocess
+import tempfile
+import threading
+import time
+from pathlib import Path
+from typing import Callable, Optional
+
+MEMORY_HEADROOM = 1.30
+MIN_MEMORY_MIB = 512
+MAX_MEMORY_MIB = 122880
+MIN_CPU_VCPUS = 1
+MAX_CPU_VCPUS = 32
+DEFAULT_TIMEOUT = 120
+
+_SAMPLE_SEARCH = [
+    "sample.mp4",
+    "sample.jpg",
+    "sample.png",
+    "tests/sample.mp4",
+    "tests/sample.jpg",
+    "demo_files/input_courthouse.mp4",
+]
+
+
+def resolve_compute_profile(
+    *,
+    image: str,
+    project_dir: str,
+    is_gpu: bool,
+    declared_compute: Optional[dict],
+    sample_hint: str,
+    sample_override: Optional[str],
+    no_profile: bool,
+    timeout: int,
+    log: Callable[[str], None],
+    log_warn: Callable[[str], None],
+) -> dict:
+    """Return compute fields for model registration."""
+    if declared_compute:
+        cpu = declared_compute.get("cpu") or declared_compute.get("cpu_vcpus")
+        mem = declared_compute.get("memory") or declared_compute.get("memory_mib")
+        gpu = declared_compute.get("gpu", is_gpu)
+        log("using declared compute from motion.yml")
+        return {
+            "cpu_vcpus": int(cpu) if cpu else None,
+            "memory_mib": int(mem) if mem else None,
+            "gpu": bool(gpu),
+            "compute_source": "declared",
+        }
+
+    if no_profile:
+        log_warn("profiling skipped (--no-profile)")
+        return {
+            "cpu_vcpus": None,
+            "memory_mib": None,
+            "gpu": is_gpu,
+            "compute_source": "declared",
+        }
+
+    sample = _find_sample(project_dir, sample_hint, sample_override)
+    if not sample:
+        log_warn(
+            "no sample input for profiling — add `sample:` to motion.yml "
+            "or pass --sample. Skipping compute measurement."
+        )
+        return {
+            "cpu_vcpus": None,
+            "memory_mib": None,
+            "gpu": is_gpu,
+            "compute_source": "declared",
+        }
+
+    log(f"profiling image with sample {sample} (timeout {timeout}s) …")
+    if is_gpu:
+        log_warn("GPU model — measuring CPU/RAM only on this machine")
+
+    try:
+        raw = _profile_container(image, sample, timeout, is_gpu, log, log_warn)
+    except Exception as exc:
+        log_warn(f"profiling failed: {exc}")
+        return {
+            "cpu_vcpus": None,
+            "memory_mib": None,
+            "gpu": is_gpu,
+            "compute_source": "declared",
+        }
+
+    if raw.get("error"):
+        log_warn(f"profiling error: {raw['error']}")
+        return {
+            "cpu_vcpus": None,
+            "memory_mib": None,
+            "gpu": is_gpu,
+            "compute_source": "declared",
+        }
+
+    reqs = _derive_requirements(raw, is_gpu)
+    if reqs["cpu_vcpus"]:
+        log(f"measured cpu_vcpus={reqs['cpu_vcpus']}")
+    if reqs["memory_mib"]:
+        log(f"measured memory_mib={reqs['memory_mib']}")
+    return {**reqs, "compute_source": "measured"}
+
+
+def _find_sample(
+    project_dir: str,
+    sample_hint: str,
+    sample_override: Optional[str],
+) -> Optional[str]:
+    if sample_override:
+        path = Path(sample_override)
+        if not path.is_absolute():
+            path = Path(project_dir) / path
+        return str(path) if path.is_file() else None
+
+    if sample_hint:
+        path = Path(sample_hint)
+        if not path.is_absolute():
+            path = Path(project_dir) / path
+        if path.is_file():
+            return str(path)
+
+    for rel in _SAMPLE_SEARCH:
+        path = Path(project_dir) / rel
+        if path.is_file():
+            return str(path)
+    return None
+
+
+def _run(cmd: list[str], **kwargs) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
+
+
+def _container_running(cid: str) -> bool:
+    result = _run(["docker", "inspect", "--format", "{{.State.Running}}", cid])
+    return result.stdout.strip() == "true"
+
+
+def _read_cgroup_peak(cid: str) -> Optional[int]:
+    result = _run([
+        "docker", "exec", cid,
+        "sh", "-c",
+        "cat /sys/fs/cgroup/memory.peak 2>/dev/null "
+        "|| cat /sys/fs/cgroup/memory/memory.max_usage_in_bytes 2>/dev/null",
+    ])
+    try:
+        val = int(result.stdout.strip())
+        if val > 0:
+            return val
+    except (ValueError, TypeError):
+        pass
+    return None
+
+
+def _parse_mem_string(value: str) -> int:
+    match = re.match(r"^([\d.]+)\s*([a-zA-Z]*)$", value.strip())
+    if not match:
+        return 0
+    amount, unit = float(match.group(1)), match.group(2).lower()
+    multipliers = {
+        "b": 1,
+        "kb": 1000,
+        "kib": 1024,
+        "mb": 1_000_000,
+        "mib": 1 << 20,
+        "gb": 1_000_000_000,
+        "gib": 1 << 30,
+    }
+    return int(amount * multipliers.get(unit, 1))
+
+
+def _docker_stats_sample(cid: str) -> tuple[float, int]:
+    result = _run([
+        "docker", "stats", "--no-stream", "--format",
+        "{{.CPUPerc}}\t{{.MemUsage}}",
+        cid,
+    ])
+    cpu_pct = 0.0
+    mem_bytes = 0
+    if result.returncode != 0:
+        return cpu_pct, mem_bytes
+    for line in result.stdout.splitlines():
+        parts = line.strip().split("\t")
+        if len(parts) < 2:
+            continue
+        try:
+            cpu_pct = float(parts[0].rstrip("%"))
+        except ValueError:
+            pass
+        mem_part = parts[1].split("/")[0].strip()
+        mem_bytes = _parse_mem_string(mem_part)
+    return cpu_pct, mem_bytes
+
+
+class _StatsCollector(threading.Thread):
+    def __init__(self, cid: str, interval: float = 1.0):
+        super().__init__(daemon=True)
+        self.cid = cid
+        self.interval = interval
+        self.cpu_samples: list[float] = []
+        self.mem_samples: list[int] = []
+        self._stop = threading.Event()
+
+    def run(self) -> None:
+        while not self._stop.is_set():
+            cpu, mem = _docker_stats_sample(self.cid)
+            if cpu > 0 or mem > 0:
+                self.cpu_samples.append(cpu)
+                self.mem_samples.append(mem)
+            self._stop.wait(self.interval)
+
+    def stop(self) -> None:
+        self._stop.set()
+
+    @property
+    def avg_cpu_pct(self) -> float:
+        return sum(self.cpu_samples) / len(self.cpu_samples) if self.cpu_samples else 0.0
+
+    @property
+    def peak_mem_bytes(self) -> int:
+        return max(self.mem_samples, default=0)
+
+
+def _profile_container(
+    image: str,
+    sample_path: str,
+    timeout: int,
+    is_gpu: bool,
+    log: Callable[[str], None],
+    log_warn: Callable[[str], None],
+) -> dict:
+    result: dict = {
+        "peak_memory_bytes": 0,
+        "avg_cpu_pct": 0.0,
+        "wall_seconds": 0.0,
+        "error": None,
+    }
+
+    host_path = str(Path(sample_path).resolve())
+    filename = Path(sample_path).name
+    container_input = f"/input/{filename}"
+
+    cid_file = tempfile.NamedTemporaryFile(delete=False, suffix=".cid")
+    cid_path = cid_file.name
+    cid_file.close()
+
+    run_cmd = [
+        "docker", "run", "-d",
+        "--cidfile", cid_path,
+        "--name", f"motion-profile-{int(time.time())}",
+        "--platform", "linux/amd64",
+        "-v", f"{host_path}:{container_input}:ro",
+        image,
+    ]
+
+    log(f"docker run (detached) {' '.join(shlex.quote(part) for part in run_cmd)}")
+    start = subprocess.Popen(run_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    _, start_err = start.communicate(timeout=30)
+    if start.returncode != 0:
+        result["error"] = start_err.decode().strip() or "docker run failed"
+        return result
+
+    deadline = time.monotonic() + 10
+    cid = ""
+    while time.monotonic() < deadline:
+        try:
+            cid = Path(cid_path).read_text().strip()
+            if cid:
+                break
+        except FileNotFoundError:
+            pass
+        time.sleep(0.2)
+    if not cid:
+        result["error"] = "could not read container id"
+        return result
+
+    collector = _StatsCollector(cid, interval=1.0)
+    collector.start()
+    t0 = time.monotonic()
+    waited = 0.0
+    while waited < timeout:
+        if not _container_running(cid):
+            break
+        time.sleep(2.0)
+        waited += 2.0
+
+    if waited >= timeout:
+        log_warn(f"container exceeded {timeout}s — stopping")
+        subprocess.run(["docker", "kill", cid], capture_output=True)
+
+    cgroup_peak = _read_cgroup_peak(cid)
+    collector.stop()
+    collector.join(timeout=5)
+
+    if cgroup_peak and cgroup_peak > 0:
+        result["peak_memory_bytes"] = cgroup_peak
+    elif collector.peak_mem_bytes > 0:
+        result["peak_memory_bytes"] = collector.peak_mem_bytes
+
+    result["avg_cpu_pct"] = round(collector.avg_cpu_pct, 1)
+    result["wall_seconds"] = round(time.monotonic() - t0, 1)
+    subprocess.run(["docker", "wait", cid], capture_output=True, timeout=15)
+    try:
+        os.unlink(cid_path)
+    except OSError:
+        pass
+
+    if is_gpu:
+        # Trust motion.yml on dev machines without CUDA.
+        pass
+
+    return result
+
+
+def _derive_requirements(raw: dict, is_gpu: bool) -> dict:
+    peak_bytes = raw.get("peak_memory_bytes", 0)
+    avg_cpu_pct = raw.get("avg_cpu_pct", 0.0)
+
+    if peak_bytes > 0:
+        peak_mib = peak_bytes / (1 << 20)
+        memory_mib = math.ceil(peak_mib * MEMORY_HEADROOM)
+        memory_mib = max(MIN_MEMORY_MIB, min(MAX_MEMORY_MIB, memory_mib))
+    else:
+        memory_mib = None
+
+    if avg_cpu_pct > 0:
+        cpu_vcpus = max(
+            MIN_CPU_VCPUS,
+            min(MAX_CPU_VCPUS, math.ceil(avg_cpu_pct / 100.0)),
+        )
+    else:
+        cpu_vcpus = None
+
+    return {
+        "cpu_vcpus": cpu_vcpus,
+        "memory_mib": memory_mib,
+        "gpu": is_gpu,
+    }

motion/server.py

@@ -0,0 +1,138 @@
+"""Uniform HTTP server baked into every model image.
+
+At boot it reads MOTION_PREDICT ("predict.py:ClassName"), imports the user's
+predictor, runs setup() once, then serves /predict per request. Identical for
+every model — that's the whole point of the packaging contract.
+
+Run with: python -m motion.server   (this is the container CMD)
+"""
+import importlib.util
+import inspect
+import os
+import tempfile
+from pathlib import Path
+
+from .predictor import BasePredictor, Input
+
+
+def _load_predictor() -> BasePredictor:
+    spec_str = os.environ.get("MOTION_PREDICT")
+    if not spec_str or ":" not in spec_str:
+        raise SystemExit("MOTION_PREDICT must be set to 'file.py:ClassName'")
+    file_part, class_name = spec_str.split(":", 1)
+    file_path = os.path.join("/src", file_part)
+
+    spec = importlib.util.spec_from_file_location("motion_user_predict", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    klass = getattr(module, class_name)
+    return klass()
+
+
+def _coerce(param, raw_value):
+    """Download Path inputs; validate via the Input descriptor."""
+    meta = param.default if isinstance(param.default, Input) else None
+    value = raw_value
+    if param.annotation is Path or (meta and meta.description and "path" in str(param.annotation)):
+        # input is a file → fetch URL to a local temp path
+        import requests
+        suffix = os.path.splitext(str(raw_value).split("?")[0])[1] or ""
+        fd, local = tempfile.mkstemp(suffix=suffix)
+        os.close(fd)
+        with requests.get(raw_value, stream=True) as r:
+            r.raise_for_status()
+            with open(local, "wb") as f:
+                for chunk in r.iter_content(chunk_size=1 << 20):
+                    f.write(chunk)
+        value = Path(local)
+    if meta:
+        value = meta.validate(param.name, value)
+    return value
+
+
+def _fetch_weights():
+    """Download weights declared in motion.yml `weights:` before setup().
+
+    Kept out of the image to avoid bloat / slow cold starts; pulled here at boot
+    into /src/<dest> (skipped if already present, e.g. a mounted volume).
+    """
+    manifest = "/opt/motion-runtime/weights.json"
+    if not os.path.exists(manifest):
+        return
+    import json
+    with open(manifest) as f:
+        items = json.load(f)
+    for w in items:
+        dest = os.path.join("/src", w["dest"])
+        if os.path.exists(dest):
+            print(f"[motion] weight present, skipping: {w['dest']}")
+            continue
+        os.makedirs(os.path.dirname(dest), exist_ok=True)
+        url = w["url"]
+        print(f"[motion] fetching weight {url} -> {dest}")
+        if url.startswith("s3://"):
+            import boto3
+            bucket, key = url[5:].split("/", 1)
+            boto3.client("s3").download_file(bucket, key, dest)
+        else:
+            import requests
+            with requests.get(url, stream=True) as r:
+                r.raise_for_status()
+                with open(dest, "wb") as out:
+                    for chunk in r.iter_content(chunk_size=1 << 20):
+                        out.write(chunk)
+    print("[motion] weights ready")
+
+
+def build_app():
+    from fastapi import FastAPI, HTTPException
+
+    _fetch_weights()  # ← pull declared weights before the model loads
+    predictor = _load_predictor()
+    predictor.setup()  # ← runs exactly once, before any request
+    sig = inspect.signature(predictor.predict)
+
+    app = FastAPI(title=os.environ.get("MOTION_NAME", "motion-model"))
+
+    @app.get("/health")
+    def health():
+        return {"status": "ok", "model": os.environ.get("MOTION_NAME")}
+
+    @app.get("/schema")
+    def schema():
+        out = {}
+        for name, p in sig.parameters.items():
+            m = p.default if isinstance(p.default, Input) else None
+            out[name] = {
+                "type": getattr(p.annotation, "__name__", str(p.annotation)),
+                "required": m.required if m else p.default is inspect._empty,
+                "default": None if (m is None or m.required) else m.default,
+                "description": m.description if m else None,
+            }
+        return out
+
+    @app.post("/predict")
+    def predict(payload: dict):
+        given = payload.get("input", payload) or {}
+        kwargs = {}
+        for name, p in sig.parameters.items():
+            m = p.default if isinstance(p.default, Input) else None
+            if name in given:
+                kwargs[name] = _coerce(p, given[name])
+            elif m and not m.required:
+                kwargs[name] = m.default
+            elif m and m.required:
+                raise HTTPException(400, f"missing required input '{name}'")
+        try:
+            result = predictor.predict(**kwargs)
+        except Exception as e:
+            raise HTTPException(500, f"prediction failed: {e}")
+        # Phase 0: return local path. Phase 'deploy' will upload to S3 here.
+        return {"output": str(result)}
+
+    return app
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(build_app(), host="0.0.0.0", port=8000)