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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: motion-intelligence
-Version: 0.4.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.4.0 → motion_intelligence-0.5.0}/motion/__init__.py

@@ -8,11 +8,15 @@ Callers use the client to run a deployed model:
 
     from motion import MotionClient
 """
-from .client import MotionClient, MotionJobFailedError, MotionTimeoutError
+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.4.0"
+__version__ = "0.5.0"

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

@@ -471,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)
@@ -517,6 +681,42 @@ def main(argv=None):
     )
     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.4.0 → motion_intelligence-0.5.0}/motion/client.py

@@ -1,4 +1,5 @@
-"""MotionClient — call a deployed model from Python, the consumer side of `motion`.
+"""MotionClient — call a deployed model or workflow from Python, the consumer
+side of `motion`.
 
     from motion import MotionClient
 
@@ -7,6 +8,10 @@
     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.
@@ -40,6 +45,19 @@ class MotionTimeoutError(TimeoutError):
         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.
 
@@ -162,8 +180,139 @@ class MotionClient:
             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)
@@ -172,6 +321,10 @@ class MotionClient:
         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:

{motion_intelligence-0.4.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.4.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.4.0 → motion_intelligence-0.5.0}/pyproject.toml

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