motion-intelligence 0.2.0__tar.gz → 0.5.0__tar.gz

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: motion-intelligence
-Version: 0.2.0
+Version: 0.5.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

motion_intelligence-0.5.0/motion/__init__.py

@@ -0,0 +1,22 @@
+"""motion — build, deploy, and call models on the Motion inference platform.
+
+Authors import from here in their predict.py:
+
+    from motion import BasePredictor, Input, Path
+
+Callers use the client to run a deployed model:
+
+    from motion import MotionClient
+"""
+from .client import (
+    MotionClient, MotionJobFailedError, MotionTimeoutError,
+    MotionWorkflowRunFailedError, MotionWorkflowRunTimeoutError,
+)
+from .predictor import BasePredictor, Input, Path
+
+__all__ = [
+    "BasePredictor", "Input", "Path",
+    "MotionClient", "MotionJobFailedError", "MotionTimeoutError",
+    "MotionWorkflowRunFailedError", "MotionWorkflowRunTimeoutError",
+]
+__version__ = "0.5.0"

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion/batch.py

@@ -6,12 +6,14 @@ Environment variables (set by the Lambda dispatcher):
   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
+  MOTION_PARAMS   — optional JSON object of predict() kwargs beyond the input file
 
 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 inspect
 import json
 import os
 import sys
@@ -21,6 +23,8 @@ from pathlib import Path
 
 import boto3
 
+from .predictor import Input
+
 
 def _env(name: str, required: bool = True, default: str = "") -> str:
     val = os.environ.get(name, default).strip()
@@ -79,6 +83,98 @@ def _content_type(ext: str) -> str:
     }.get(ext.lower(), "application/octet-stream")
 
 
+def _submitted_params() -> dict:
+    """Parse MOTION_PARAMS into a dict, tolerating absence and malformed JSON.
+
+    A bad value must not fail the job on its own — the signature defaults are still
+    a valid way to run — so this warns and falls back to {}.
+    """
+    raw = os.environ.get("MOTION_PARAMS", "").strip()
+    if not raw:
+        return {}
+    try:
+        parsed = json.loads(raw)
+    except ValueError as e:
+        print(f"[batch] WARN: MOTION_PARAMS is not valid JSON ({e}); using defaults")
+        return {}
+    if not isinstance(parsed, dict):
+        print(f"[batch] WARN: MOTION_PARAMS is {type(parsed).__name__}, expected object; using defaults")
+        return {}
+    return parsed
+
+
+def _coerce_to_annotation(name: str, value, annotation):
+    """Cast a JSON-decoded value to the parameter's annotated type.
+
+    MOTION_PARAMS can carry strings for numeric fields (form-encoded UIs commonly
+    do), and Input.validate compares with < / >, which raises TypeError on a str.
+    Coercing first means range checks work and predict() sees the type it declared.
+    """
+    if annotation is inspect.Parameter.empty or value is None:
+        return value
+    if annotation is bool:
+        if isinstance(value, str):
+            return value.strip().lower() in ("1", "true", "yes", "on")
+        return bool(value)
+    if annotation is int:
+        try:
+            return int(float(value))
+        except (TypeError, ValueError):
+            raise TypeError(f"{name}={value!r} is not a valid int")
+    if annotation is float:
+        try:
+            return float(value)
+        except (TypeError, ValueError):
+            raise TypeError(f"{name}={value!r} is not a valid float")
+    if annotation is str:
+        return str(value)
+    return value
+
+
+def _build_kwargs(predict, input_path: Path) -> dict:
+    """Assemble the full predict() call: the input file plus the caller's params.
+
+    The first parameter always receives the downloaded input, coerced to the
+    annotated type. Every other parameter is filled from MOTION_PARAMS, falling
+    back to its Input(...) default. Values are cast to the annotated type and then
+    validated through the Input descriptor, so a bad number is rejected here naming
+    the param rather than deep inside user code.
+
+    Params the signature does not declare are dropped — passing them through would
+    raise TypeError and fail the job.
+    """
+    sig = inspect.signature(predict)
+    params = list(sig.parameters.values())
+    if not params:
+        raise TypeError("predict() must accept at least one argument (the input file)")
+
+    first, rest = params[0], params[1:]
+    annotation = first.annotation
+    if annotation is Path or str(annotation) == "<class 'pathlib.Path'>":
+        kwargs: dict = {first.name: input_path}
+    else:
+        kwargs = {first.name: str(input_path)}
+
+    given = _submitted_params()
+    for p in rest:
+        meta = p.default if isinstance(p.default, Input) else None
+        if p.name in given:
+            value = _coerce_to_annotation(p.name, given[p.name], p.annotation)
+            if meta is not None:
+                value = meta.validate(p.name, value)
+            kwargs[p.name] = value
+        elif meta is not None and not meta.required:
+            kwargs[p.name] = meta.default
+        elif meta is not None and meta.required:
+            raise TypeError(f"predict() requires '{p.name}' but no value was supplied")
+        # else: a plain Python default — let the signature apply it.
+
+    unknown = set(given) - {p.name for p in rest}
+    if unknown:
+        print(f"[batch] WARN: ignoring params not in predict() signature: {sorted(unknown)}")
+    return kwargs
+
+
 def main() -> int:
     job_id          = _env("JOB_ID")
     bucket          = _env("S3_BUCKET")
@@ -104,20 +200,11 @@ def main() -> int:
         # 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})
+        # 4. Run predict() — input file as the first arg, MOTION_PARAMS for the rest
+        kwargs = _build_kwargs(predictor.predict, input_path)
+        shown = {k: v for k, v in kwargs.items() if not isinstance(v, Path)}
+        print(f"[batch] running predict(input={input_path}, {shown})")
+        result = predictor.predict(**kwargs)
 
         # 5. Upload output to S3
         output_path = Path(str(result))

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion/cli.py

@@ -20,14 +20,13 @@ import subprocess
 import sys
 
 from .categories import resolve_category_id
-from .config import MotionConfig
+from .config import MotionConfig, resolve_api_url
 from .dockerfile import generate_dockerfile
 from .profile import resolve_compute_profile
 from .weight_upload import upload_weight_via_backend
 
 _PKG_DIR = os.path.dirname(os.path.abspath(__file__))
-_RUNTIME_FILES = ("__init__.py", "predictor.py", "server.py", "batch.py")
-_DEFAULT_API_URL = "https://adwrzdrdes.us-east-1.awsapprunner.com"
+_RUNTIME_FILES = ("__init__.py", "predictor.py", "server.py", "batch.py", "client.py", "config.py")
 
 
 def _c(msg, code="36"):
@@ -35,7 +34,7 @@ def _c(msg, code="36"):
 
 
 def _api_url():
-    return os.environ.get("MOTION_API_URL", _DEFAULT_API_URL).rstrip("/")
+    return resolve_api_url()
 
 
 def cmd_build(args):
@@ -146,6 +145,7 @@ def cmd_deploy(args):
     import requests
 
     project_dir = os.path.abspath(args.path)
+    org_id = (getattr(args, "organization_id", None) or os.environ.get("MOTION_ORGANIZATION_ID") or "").strip()
     print(_c(f"▶ motion deploy  ({project_dir})"))
 
     # 1. Parse motion.yml
@@ -306,6 +306,9 @@ def cmd_deploy(args):
         register_payload["category_code"] = cfg.category
     if getattr(args, "service_type", None):
         register_payload["service_type"] = args.service_type
+    org_for_register = org_id or (cfg.organization_id or "").strip()
+    if org_for_register:
+        register_payload["organization_id"] = org_for_register
 
     try:
         reg = requests.post(
@@ -331,6 +334,12 @@ def cmd_deploy(args):
     print(_c(f"\n✓ model {action}: {model_code}  (id={reg_data['model_type_id']})", "32"))
     print(f"  ECR image:  {reg_data['ecr_image']}")
     print(f"  model_code: {reg_data['model_code']}")
+    if reg_data.get("organization_id"):
+        print(f"  organization: {reg_data['organization_id']}")
+    elif org_for_register:
+        print(f"  organization: {org_for_register}")
+    else:
+        print("  scope:        personal")
     if resolved_category_id is not None:
         print(f"  category:   id={resolved_category_id}")
     elif cfg.category:
@@ -380,9 +389,16 @@ def _parse_predict_inputs(project_dir: str, cfg: "MotionConfig") -> list:
         for item in node.body:
             if not isinstance(item, ast.FunctionDef) or item.name != "predict":
                 continue
+            seen_file_arg = False
             for i, arg in enumerate(item.args.args):
                 if arg.arg == "self":
                     continue
+                # predict()'s first non-self arg is always the input file (see
+                # BasePredictor / motion.batch._build_kwargs) — it's already
+                # represented by input_type, not a caller-supplied "param".
+                if not seen_file_arg:
+                    seen_file_arg = True
+                    continue
                 # Determine type annotation
                 annotation = item.args.annotations.get(arg.arg) if hasattr(item.args, "annotations") else None
                 type_name = ""
@@ -455,6 +471,170 @@ def _extract_input_default(func_node, arg_name: str) -> dict:
     return {}
 
 
+def _parse_kv_list(pairs):
+    """['fps=24', 'steps=20'] -> {'fps': '24', 'steps': '20'}."""
+    out = {}
+    for item in pairs or []:
+        if "=" not in item:
+            print(_c(f"  ✗ invalid '{item}' — expected KEY=VALUE", "31"))
+            raise SystemExit(1)
+        key, _, value = item.partition("=")
+        out[key] = value
+    return out
+
+
+def _print_result(result):
+    for artifact in result.get("artifacts") or []:
+        url = artifact.get("url") if isinstance(artifact, dict) else artifact
+        if url:
+            print(f"  artifact:   {url}")
+    if result.get("output_url"):
+        print(f"  output:     {result['output_url']}")
+
+
+def cmd_run_model(args):
+    from .client import MotionClient
+
+    print(_c(f"▶ motion run model  ({args.model_code})"))
+    try:
+        client = MotionClient()
+    except ValueError as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    outputs = args.outputs.split(",") if args.outputs else None
+    try:
+        submitted = client.submit_job(
+            args.model_code, args.file, task=args.task or "",
+            outputs=outputs, params=_parse_kv_list(args.param),
+        )
+    except Exception as e:
+        print(_c(f"  ✗ submit failed: {e}", "31"))
+        return 1
+    print(f"  ✓ submitted   job_id={submitted['job_id']}")
+
+    if args.no_wait:
+        print(f"  poll:         GET /api/v1/motion/jobs/{submitted['job_id']}")
+        return 0
+
+    print("  → waiting for the job to finish …")
+    try:
+        result = client.wait_for_job(
+            submitted["job_id"], on_poll=lambda j: print(f"    {j.get('status')}…"),
+        )
+    except Exception as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    print(_c("\n✓ job completed", "32"))
+    _print_result(result)
+    return 0
+
+
+def cmd_run_workflow(args):
+    from .client import MotionClient
+
+    print(_c(f"▶ motion run workflow  ({args.workflow_id})"))
+    try:
+        client = MotionClient()
+    except ValueError as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    try:
+        started = client.run_workflow(
+            args.workflow_id, file=args.file, texts=_parse_kv_list(args.text),
+        )
+    except Exception as e:
+        print(_c(f"  ✗ run failed: {e}", "31"))
+        return 1
+
+    run_id = started.get("run_id")
+    job_id = started.get("job_id")
+    print(f"  ✓ started     {'run_id=' + run_id if run_id else 'job_id=' + job_id}")
+
+    if args.no_wait:
+        return 0
+
+    print("  → waiting for the workflow to finish …")
+    try:
+        if run_id:
+            result = client.wait_for_workflow_run(
+                run_id,
+                on_poll=lambda r: print(
+                    f"    step {r.get('current_step', 0) + 1}/{r.get('step_count', 1)} ({r.get('status')})…"
+                ),
+            )
+        else:
+            result = client.wait_for_job(job_id, on_poll=lambda j: print(f"    {j.get('status')}…"))
+    except Exception as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    print(_c("\n✓ workflow completed", "32"))
+    _print_result(result)
+    return 0
+
+
+def cmd_workflow_deploy(args):
+    from .client import MotionClient
+
+    print(_c(f"▶ motion workflow deploy  ({args.workflow_id})"))
+    try:
+        client = MotionClient()
+        result = client.deploy_workflow(args.workflow_id, notes=args.notes)
+    except Exception as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    print(_c(f"\n✓ deployed  v{result['version']}", "32"))
+    if result.get("notes"):
+        print(f"  notes:      {result['notes']}")
+    print(f"  deployed_at: {result['deployed_at']}")
+    print("  API-key calls to this workflow's /run now use this version.")
+    return 0
+
+
+def cmd_workflow_deployments(args):
+    from .client import MotionClient
+
+    try:
+        client = MotionClient()
+        result = client.list_workflow_deployments(args.workflow_id)
+    except Exception as e:
+        print(_c(f"✗ {e}", "31"))
+        return 1
+
+    deployments = result.get("deployments", [])
+    if not deployments:
+        print("No deployments yet — run `motion workflow deploy <workflow_id>` first.")
+        return 0
+
+    print(_c(f"▶ deploy history  ({args.workflow_id})"))
+    for d in deployments:
+        marker = _c(" (current)", "32") if d.get("is_current") else ""
+        rollback_note = f"  [rollback of v{d['rollback_of_version']}]" if d.get("rollback_of_version") else ""
+        print(f"  v{d['version']}{marker}  {d['deployed_at']}{rollback_note}")
+        if d.get("notes"):
+            print(f"      {d['notes']}")
+    return 0
+
+
+def cmd_workflow_rollback(args):
+    from .client import MotionClient
+
+    print(_c(f"▶ motion workflow rollback  ({args.workflow_id} → v{args.version})"))
+    try:
+        client = MotionClient()
+        result = client.rollback_workflow(args.workflow_id, args.version)
+    except Exception as e:
+        print(_c(f"  ✗ {e}", "31"))
+        return 1
+
+    print(_c(f"\n✓ rolled back — now live as v{result['version']}", "32"))
+    return 0
+
+
 def main(argv=None):
     p = argparse.ArgumentParser(prog="motion", description="Build & deploy models for Motion inference")
     sub = p.add_subparsers(dest="command", required=True)
@@ -493,8 +673,50 @@ def main(argv=None):
              "(warm host), or dedicated_instance (disabled for now). "
              "Omit to keep the default/existing value.",
     )
+    d.add_argument(
+        "--organization-id",
+        dest="organization_id",
+        default="",
+        help="org UUID for org-scoped deploy (or MOTION_ORGANIZATION_ID / motion.yml organization_id)",
+    )
     d.set_defaults(func=cmd_deploy)
 
+    r = sub.add_parser("run", help="run a deployed model or workflow and wait for the result")
+    run_sub = r.add_subparsers(dest="run_target", required=True)
+
+    rm = run_sub.add_parser("model", help="run a deployed model")
+    rm.add_argument("model_code", help="e.g. jay/pose-estimation")
+    rm.add_argument("file", help="local path to the input file")
+    rm.add_argument("--task", default="", help="task/prompt text, if the model takes one")
+    rm.add_argument("--param", action="append", metavar="KEY=VALUE", help="extra predict() param (repeatable)")
+    rm.add_argument("--outputs", help="comma-separated output names to request")
+    rm.add_argument("--no-wait", action="store_true", help="submit and exit, don't wait for completion")
+    rm.set_defaults(func=cmd_run_model)
+
+    rw = run_sub.add_parser("workflow", help="run a deployed workflow (see `motion workflow deploy` first)")
+    rw.add_argument("workflow_id")
+    rw.add_argument("file", nargs="?", default=None, help="local path to the input file, if the workflow needs one")
+    rw.add_argument("--text", action="append", metavar="KEY=VALUE", help="named text input (repeatable)")
+    rw.add_argument("--no-wait", action="store_true", help="start and exit, don't wait for completion")
+    rw.set_defaults(func=cmd_run_workflow)
+
+    w = sub.add_parser("workflow", help="deploy, version, and roll back a workflow")
+    workflow_sub = w.add_subparsers(dest="workflow_action", required=True)
+
+    wd = workflow_sub.add_parser("deploy", help="deploy the current draft as a new live version")
+    wd.add_argument("workflow_id")
+    wd.add_argument("--notes", help="optional changelog note for this deploy")
+    wd.set_defaults(func=cmd_workflow_deploy)
+
+    wl = workflow_sub.add_parser("deployments", help="list a workflow's deploy/version history")
+    wl.add_argument("workflow_id")
+    wl.set_defaults(func=cmd_workflow_deployments)
+
+    wb = workflow_sub.add_parser("rollback", help="roll back to an earlier deployed version")
+    wb.add_argument("workflow_id")
+    wb.add_argument("version", type=int)
+    wb.set_defaults(func=cmd_workflow_rollback)
+
     args = p.parse_args(argv)
     return args.func(args)
 

motion_intelligence-0.5.0/motion/client.py

@@ -0,0 +1,336 @@
+"""MotionClient — call a deployed model or workflow from Python, the consumer
+side of `motion`.
+
+    from motion import MotionClient
+
+    client = MotionClient(api_key="motion_live_...")
+    job = client.submit_job("jay/pose-estimation", "video.mp4", params={"fps": 24})
+    result = client.wait_for_job(job["job_id"])
+    print(result["artifacts"])
+
+    # A workflow built in the dashboard, once deployed there (or via
+    # client.deploy_workflow(...)):
+    result = client.process_workflow(workflow_id, "video.mp4")
+
+`motion build` / `motion deploy` (cli.py) and `BasePredictor` (predictor.py) are for
+authoring and shipping a model; this module is for running one that's already
+deployed — same package, the other side of the counter.
+"""
+from __future__ import annotations
+
+import mimetypes
+import os
+import time
+from typing import Any, BinaryIO
+
+import requests
+
+from .config import resolve_api_url
+
+API_PREFIX = "/api/v1"
+_DEFAULT_POLL_INTERVAL = 3.0
+_DEFAULT_WAIT_TIMEOUT = 600.0
+
+
+class MotionJobFailedError(RuntimeError):
+    def __init__(self, job_id: str, error_message: str | None):
+        self.job_id = job_id
+        self.error_message = error_message
+        super().__init__(f"job {job_id} failed: {error_message or 'no error message'}")
+
+
+class MotionTimeoutError(TimeoutError):
+    def __init__(self, job_id: str, timeout: float):
+        self.job_id = job_id
+        super().__init__(f"job {job_id} did not finish within {timeout}s")
+
+
+class MotionWorkflowRunFailedError(RuntimeError):
+    def __init__(self, run_id: str, error_message: str | None):
+        self.run_id = run_id
+        self.error_message = error_message
+        super().__init__(f"workflow run {run_id} failed: {error_message or 'no error message'}")
+
+
+class MotionWorkflowRunTimeoutError(TimeoutError):
+    def __init__(self, run_id: str, timeout: float):
+        self.run_id = run_id
+        super().__init__(f"workflow run {run_id} did not finish within {timeout}s")
+
+
+class MotionClient:
+    """Thin wrapper over the Motion inference API.
+
+    `api_key` falls back to the `MOTION_API_KEY` env var; `base_url` falls back to
+    `MOTION_API_URL` env var, then the platform default (same resolution `motion`
+    CLI uses for `build`/`deploy`).
+    """
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None,
+                 timeout: float = 120.0):
+        self.api_key = (api_key or os.environ.get("MOTION_API_KEY", "")).strip()
+        if not self.api_key:
+            raise ValueError(
+                "MotionClient: `api_key` is required (or set MOTION_API_KEY). "
+                "Get your key from the Motion dashboard."
+            )
+        self.base_url = resolve_api_url(base_url)
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers["X-API-Key"] = self.api_key
+
+    # ─── Models ──────────────────────────────────────────────────────────────
+
+    def list_models(self) -> list[dict]:
+        """Public catalog — every active platform and deployed model."""
+        return self._get(f"{API_PREFIX}/motion/models")
+
+    def get_model_params(self, model_code: str) -> dict:
+        """Input params (name/type/default/constraints) for one model_code."""
+        return self._get(f"{API_PREFIX}/motion/models/{model_code}/params")
+
+    # ─── Jobs ────────────────────────────────────────────────────────────────
+
+    def submit_job(
+        self,
+        model_name: str,
+        file: str | bytes | BinaryIO,
+        task: str = "",
+        outputs: list[str] | None = None,
+        params: dict[str, Any] | None = None,
+        filename: str | None = None,
+    ) -> dict:
+        """Submit a job. `file` is a local path, raw bytes, or an open file object.
+
+        `params` fills any extra fields the model's predict() declares (e.g.
+        `{"fps": 24}`) beyond the input file — see GET /motion/models/{code}/params
+        for what a given model accepts.
+        """
+        if not model_name or not model_name.strip():
+            raise ValueError("`model_name` must be a non-empty string")
+
+        data = {"model_name": model_name.strip(), "task": task}
+        if outputs:
+            data["outputs"] = ",".join(outputs)
+        for key, value in (params or {}).items():
+            data[key] = str(value)
+
+        opened = None
+        try:
+            if isinstance(file, (str, os.PathLike)):
+                opened = open(file, "rb")
+                upload_name = filename or os.path.basename(str(file))
+                upload_obj: Any = opened
+            elif isinstance(file, (bytes, bytearray)):
+                upload_name = filename or "input"
+                upload_obj = file
+            else:
+                upload_name = filename or getattr(file, "name", "input")
+                upload_obj = file
+
+            mime = mimetypes.guess_type(upload_name)[0] or "application/octet-stream"
+            files = {"video": (upload_name, upload_obj, mime)}
+            return self._post(f"{API_PREFIX}/motion/submit", data=data, files=files)
+        finally:
+            if opened is not None:
+                opened.close()
+
+    def get_job(self, job_id: str) -> dict:
+        return self._get(f"{API_PREFIX}/motion/jobs/{job_id}")
+
+    def list_jobs(self, limit: int = 20, offset: int = 0) -> dict:
+        return self._get(f"{API_PREFIX}/motion/jobs", params={"limit": limit, "offset": offset})
+
+    def wait_for_job(
+        self,
+        job_id: str,
+        poll_interval: float = _DEFAULT_POLL_INTERVAL,
+        timeout: float = _DEFAULT_WAIT_TIMEOUT,
+        on_poll=None,
+    ) -> dict:
+        """Poll `get_job` until the job reaches `completed` or `failed`."""
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get_job(job_id)
+            if on_poll is not None:
+                on_poll(job)
+            if job.get("status") == "completed":
+                return job
+            if job.get("status") == "failed":
+                raise MotionJobFailedError(job_id, job.get("error_message"))
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise MotionTimeoutError(job_id, timeout)
+            time.sleep(min(poll_interval, remaining))
+
+    def process(
+        self,
+        model_name: str,
+        file: str | bytes | BinaryIO,
+        task: str = "",
+        outputs: list[str] | None = None,
+        params: dict[str, Any] | None = None,
+        wait: bool = True,
+        poll_interval: float = _DEFAULT_POLL_INTERVAL,
+        timeout: float = _DEFAULT_WAIT_TIMEOUT,
+    ) -> dict:
+        """`submit_job` + `wait_for_job` in one call — the fire-and-get-result path."""
+        submitted = self.submit_job(model_name, file, task=task, outputs=outputs, params=params)
+        if not wait:
+            return submitted
+        return self.wait_for_job(submitted["job_id"], poll_interval=poll_interval, timeout=timeout)
+
+    # ─── Workflows ───────────────────────────────────────────────────────────
+    # A workflow is built visually in the dashboard, then deployed (see
+    # deploy_workflow below) — running it here always executes that deployed
+    # snapshot, never a draft still being edited.
+
+    def run_workflow(
+        self,
+        workflow_id: str,
+        file: str | bytes | BinaryIO | None = None,
+        files: dict[str, str | bytes | BinaryIO] | None = None,
+        text: str | None = None,
+        texts: dict[str, str] | None = None,
+    ) -> dict:
+        """Run a deployed workflow. Returns `{"job_id": ...}` for a single-model
+        workflow — poll with `wait_for_job` — or `{"run_id": ...}` for a
+        multi-model pipeline — poll with `wait_for_workflow_run`. See
+        `process_workflow` for the version that waits for you either way.
+
+        `file`/`text` cover the common single-input case; `files`/`texts` (each
+        a dict keyed by the workflow's input name) cover workflows with more
+        than one named input — one file per name.
+        """
+        if not workflow_id or not workflow_id.strip():
+            raise ValueError("`workflow_id` must be a non-empty string")
+
+        data: dict[str, str] = dict(texts or {})
+        if text is not None and "text" not in data:
+            data["text"] = text
+
+        opened: list[Any] = []
+        try:
+            multipart_files = {}
+            for key, f in (files or {}).items():
+                multipart_files[key] = self._prepare_file(f, opened)
+            if file is not None and "file" not in multipart_files:
+                multipart_files["file"] = self._prepare_file(file, opened)
+
+            if not multipart_files and not data:
+                raise ValueError("Provide at least one input file (file/files) or text (text/texts).")
+
+            return self._post(
+                f"{API_PREFIX}/workflow/{workflow_id.strip()}/run", data=data, files=multipart_files,
+            )
+        finally:
+            for f in opened:
+                f.close()
+
+    def get_workflow_run(self, run_id: str) -> dict:
+        return self._get(f"{API_PREFIX}/workflow/runs/{run_id}")
+
+    def wait_for_workflow_run(
+        self,
+        run_id: str,
+        poll_interval: float = _DEFAULT_POLL_INTERVAL,
+        timeout: float = _DEFAULT_WAIT_TIMEOUT,
+        on_poll=None,
+    ) -> dict:
+        """Poll `get_workflow_run` until the run reaches `completed` or `failed`."""
+        deadline = time.monotonic() + timeout
+        while True:
+            run = self.get_workflow_run(run_id)
+            if on_poll is not None:
+                on_poll(run)
+            if run.get("status") == "completed":
+                return run
+            if run.get("status") == "failed":
+                raise MotionWorkflowRunFailedError(run_id, run.get("error_message"))
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise MotionWorkflowRunTimeoutError(run_id, timeout)
+            time.sleep(min(poll_interval, remaining))
+
+    def process_workflow(
+        self,
+        workflow_id: str,
+        file: str | bytes | BinaryIO | None = None,
+        files: dict[str, str | bytes | BinaryIO] | None = None,
+        text: str | None = None,
+        texts: dict[str, str] | None = None,
+        wait: bool = True,
+        poll_interval: float = _DEFAULT_POLL_INTERVAL,
+        timeout: float = _DEFAULT_WAIT_TIMEOUT,
+    ) -> dict:
+        """`run_workflow` + wait for it in one call — the fire-and-get-result path.
+
+        Waits on whichever the run started — `run_id` for a multi-model
+        pipeline, `job_id` for a single model — so callers don't need to know
+        which ahead of time.
+        """
+        started = self.run_workflow(workflow_id, file=file, files=files, text=text, texts=texts)
+        if not wait:
+            return started
+        if started.get("run_id"):
+            return self.wait_for_workflow_run(started["run_id"], poll_interval=poll_interval, timeout=timeout)
+        return self.wait_for_job(started["job_id"], poll_interval=poll_interval, timeout=timeout)
+
+    # ─── Workflow deployments ────────────────────────────────────────────────
+
+    def deploy_workflow(self, workflow_id: str, notes: str | None = None) -> dict:
+        """Snapshot the workflow's current draft (as last saved in the dashboard)
+        as a new live version. `run_workflow`/`process_workflow` execute this
+        snapshot until the workflow is redeployed or rolled back."""
+        body = {"notes": notes} if notes is not None else {}
+        return self._post_json(f"{API_PREFIX}/workflow/{workflow_id}/deploy", json=body)
+
+    def list_workflow_deployments(self, workflow_id: str) -> dict:
+        """Version history: `{"deployments": [...]}`, newest first."""
+        return self._get(f"{API_PREFIX}/workflow/{workflow_id}/deployments")
+
+    def rollback_workflow(self, workflow_id: str, version: int) -> dict:
+        """Restore an earlier deployed version as a brand-new version (history
+        is never rewritten)."""
+        return self._post_json(f"{API_PREFIX}/workflow/{workflow_id}/deployments/{version}/rollback")
+
+    # ─── HTTP layer ──────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _prepare_file(file: str | bytes | BinaryIO, opened: list[Any]) -> tuple[str, Any, str]:
+        """Normalize a path/bytes/file-object into a `requests`-style file tuple.
+        Any opened file handle is appended to `opened` so the caller can close it."""
+        if isinstance(file, (str, os.PathLike)):
+            obj: Any = open(file, "rb")
+            opened.append(obj)
+            name = os.path.basename(str(file))
+        elif isinstance(file, (bytes, bytearray)):
+            obj = file
+            name = "input"
+        else:
+            obj = file
+            name = getattr(file, "name", "input")
+        mime = mimetypes.guess_type(name)[0] or "application/octet-stream"
+        return name, obj, mime
+
+    def _get(self, path: str, params: dict | None = None) -> Any:
+        res = self._session.get(f"{self.base_url}{path}", params=params, timeout=self.timeout)
+        return self._handle(res)
+
+    def _post(self, path: str, data: dict | None = None, files: dict | None = None) -> Any:
+        res = self._session.post(f"{self.base_url}{path}", data=data, files=files, timeout=self.timeout)
+        return self._handle(res)
+
+    def _post_json(self, path: str, json: dict | None = None) -> Any:
+        res = self._session.post(f"{self.base_url}{path}", json=json, timeout=self.timeout)
+        return self._handle(res)
+
+    @staticmethod
+    def _handle(res: requests.Response) -> Any:
+        if not res.ok:
+            try:
+                detail = res.json().get("detail", res.text)
+            except Exception:
+                detail = res.text
+            raise requests.HTTPError(f"{res.status_code} {res.reason}: {detail}", response=res)
+        return res.json()

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion/config.py

@@ -8,6 +8,16 @@ try:
 except ImportError:  # pragma: no cover
     raise SystemExit("PyYAML is required: pip install pyyaml")
 
+# Shared by the build/deploy CLI (cli.py) and the consumer client (client.py) so
+# there is exactly one place that knows the platform's default API host.
+DEFAULT_API_URL = "https://adwrzdrdes.us-east-1.awsapprunner.com"
+
+
+def resolve_api_url(explicit: Optional[str] = None) -> str:
+    """`explicit` arg > MOTION_API_URL env var > DEFAULT_API_URL, trailing slash stripped."""
+    url = explicit or os.environ.get("MOTION_API_URL", DEFAULT_API_URL)
+    return url.rstrip("/")
+
 
 @dataclass
 class BuildSpec:
@@ -48,6 +58,7 @@ class MotionConfig:
     category_id: Optional[int] = None  # explicit id; wins over category code
     inference_model: str = ""          # inference_model slug; defaults to `name`
     sample: str = ""                   # sample input used by deploy profiling
+    organization_id: str = ""          # omit = personal deploy; set = org-scoped model
     input_type: str = "video"          # video | image | text
     output_type: str = "mp4"           # mp4 | glb | ...
     build: BuildSpec = field(default_factory=BuildSpec)
@@ -132,6 +143,7 @@ class MotionConfig:
         category_id=int(raw["category_id"]) if raw.get("category_id") is not None else None,
             inference_model=str(raw.get("inference_model", "") or "").strip(),
             sample=str(raw.get("sample", "") or "").strip(),
+            organization_id=str(raw.get("organization_id", "") or os.environ.get("MOTION_ORGANIZATION_ID", "") or "").strip(),
             input_type=str(raw.get("input_type", "video") or "video"),
             output_type=str(raw.get("output_type", "mp4") or "mp4"),
             build=build,

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion/dockerfile.py

@@ -10,12 +10,23 @@ def generate_dockerfile(cfg: MotionConfig) -> str:
         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.
+        # `distutils` was removed from the stdlib in 3.12 (PEP 632) and deadsnakes
+        # does not publish a `python3.12+-distutils` package at all — requesting
+        # it 404s the whole apt-get install. Only pull it for <3.12 interpreters,
+        # where it's still a separate package pip's bootstrap can depend on.
+        try:
+            needs_distutils = tuple(int(p) for p in py.split(".")[:2]) < (3, 12)
+        except ValueError:
+            needs_distutils = True
+        py_pkgs_line = f"        python{py} python{py}-dev" + (
+            f" python{py}-distutils \\\n" if needs_distutils else " \\\n"
+        )
         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"{py_pkgs_line}"
             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/*"

motion_intelligence-0.5.0/motion/server.py

@@ -0,0 +1,238 @@
+"""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
+import threading
+import time
+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 _materialize_file(raw_value, suffix_hint: str = "") -> Path:
+    """Turn a JSON-encodable value into a local file path.
+
+    Accepts, in order of preference for a live control loop:
+      - "data:<mime>;base64,<...>"  inline bytes, no extra round trip
+      - {"b64": "...", "ext": ".png"}   explicit inline bytes
+      - "/local/path"               already on disk (bind mount / baked asset)
+      - "http(s)://..."             downloaded (the original behaviour)
+
+    Inline forms matter because a per-timestep loop cannot afford to upload each
+    frame somewhere just to hand back a URL.
+    """
+    import base64
+
+    # {"b64": ..., "ext": ...}
+    if isinstance(raw_value, dict) and "b64" in raw_value:
+        ext = raw_value.get("ext") or suffix_hint or ""
+        fd, local = tempfile.mkstemp(suffix=ext)
+        with os.fdopen(fd, "wb") as f:
+            f.write(base64.b64decode(raw_value["b64"]))
+        return Path(local)
+
+    value = str(raw_value)
+
+    # data: URI
+    if value.startswith("data:"):
+        header, _, b64 = value.partition(",")
+        mime = header[5:].split(";")[0]
+        ext = suffix_hint or {
+            "image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp",
+            "video/mp4": ".mp4", "application/json": ".json",
+        }.get(mime, "")
+        fd, local = tempfile.mkstemp(suffix=ext)
+        with os.fdopen(fd, "wb") as f:
+            f.write(base64.b64decode(b64))
+        return Path(local)
+
+    # already a local file
+    if not value.startswith(("http://", "https://")) and os.path.exists(value):
+        return Path(value)
+
+    # remote URL
+    import requests
+    suffix = os.path.splitext(value.split("?")[0])[1] or suffix_hint or ""
+    fd, local = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    with requests.get(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)
+    return Path(local)
+
+
+def _coerce(param, raw_value):
+    """Materialize Path inputs; validate via the Input descriptor."""
+    meta = param.default if isinstance(param.default, Input) else None
+    value = raw_value
+    is_path = param.annotation is Path or (
+        meta and meta.description and "path" in str(param.annotation)
+    )
+    # An optional Path sent explicitly as null (or the string a text-column default
+    # round-trips to) means "not supplied". Without this the URL branch below tried
+    # to GET "None" and predict() failed with a confusing MissingSchema.
+    if is_path and (
+        raw_value is None
+        or (isinstance(raw_value, str) and raw_value.strip().lower() in ("", "none", "null"))
+    ):
+        if meta and not meta.required:
+            return meta.default
+        raise ValueError(f"'{param.name}' is required but was sent as null")
+    if is_path:
+        value = _materialize_file(raw_value)
+    if meta:
+        value = meta.validate(param.name, value)
+    return value
+
+
+def _jsonify(result):
+    """Represent predict()'s return value for an HTTP response.
+
+    A Path pointing at JSON is inlined so a caller does not need a second fetch
+    to read an action chunk — the whole point of a low-latency serving path.
+    Anything already JSON-encodable is passed through untouched; previously this
+    was `str(result)`, which turned a dict into a Python repr.
+    """
+    import json as _json
+
+    if isinstance(result, Path) or (
+        isinstance(result, str) and os.path.exists(str(result))
+    ):
+        path = Path(str(result))
+        if path.suffix.lower() == ".json":
+            try:
+                with open(path) as f:
+                    return {"output": _json.load(f), "output_path": str(path)}
+            except (ValueError, OSError):
+                pass  # fall through to the path form
+        return {"output": str(path), "output_path": str(path)}
+
+    if isinstance(result, (dict, list, int, float, bool)) or result is None:
+        return {"output": result}
+    return {"output": str(result)}
+
+
+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)
+    # Most predictors hold non-reentrant state (a CUDA context, an ACT action
+    # queue). FastAPI runs sync handlers in a threadpool, so without this two
+    # concurrent calls would interleave inside one predictor.
+    predict_lock = threading.Lock()
+
+    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:
+                try:
+                    kwargs[name] = _coerce(p, given[name])
+                except ValueError as e:
+                    # A bad input is the caller's fault; 400 says so instead of
+                    # surfacing as an opaque "prediction failed".
+                    raise HTTPException(400, str(e))
+            elif m and not m.required:
+                kwargs[name] = m.default
+            elif m and m.required:
+                raise HTTPException(400, f"missing required input '{name}'")
+        started = time.time()
+        try:
+            with predict_lock:
+                result = predictor.predict(**kwargs)
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(500, f"prediction failed: {e}")
+        body = _jsonify(result)
+        body["inference_ms"] = round((time.time() - started) * 1000, 1)
+        return body
+
+    return app
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(build_app(), host="0.0.0.0", port=8000)

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion_intelligence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: motion-intelligence
-Version: 0.2.0
+Version: 0.5.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

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/motion_intelligence.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ motion/__init__.py
 motion/batch.py
 motion/categories.py
 motion/cli.py
+motion/client.py
 motion/config.py
 motion/dockerfile.py
 motion/predictor.py

{motion_intelligence-0.2.0 → motion_intelligence-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "motion-intelligence"
-version = "0.2.0"
+version = "0.5.0"
 description = "Author, build & deploy Python models for the Motion inference platform"
 readme = "README.md"
 requires-python = ">=3.9"

motion_intelligence-0.2.0/motion/__init__.py

@@ -1,10 +0,0 @@
-"""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/server.py

@@ -1,138 +0,0 @@
-"""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)