| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796 |
- #!/usr/bin/env python3
- """
- run_workflow.py — Inject parameters into a ComfyUI workflow, submit it, monitor
- execution, and download outputs.
- Improvements over v1:
- - Cloud-aware URL routing (handles /api prefix and /history_v2 / /experiment/models renames)
- - API key from CLI flag OR $COMFY_CLOUD_API_KEY env var
- - WebSocket progress monitoring (--ws), with HTTP polling fallback
- - Streaming download (no whole-file buffering — handles GB-size video outputs)
- - Path-traversal-safe output writes
- - Subfolder-aware download paths (no silent overwrites)
- - Retry with exponential backoff on transient errors
- - Status-error correctly classified before "completed: true"
- - Image upload helper (--input-image NAME=PATH)
- - Auto-randomize seed when value is -1 or omitted on a randomize-seed flag
- - Auto-extends timeout heuristically for video workflows
- - Editor-format detection with helpful error
- - Doesn't pollute extra_data.api_key_comfy_org with the cloud auth key
- unless --partner-key is provided (correct semantic per cloud docs)
- Usage:
- # Local server
- python3 run_workflow.py --workflow workflow_api.json \
- --args '{"prompt": "a cat", "seed": 42}' \
- --output-dir ./outputs
- # Cloud server (API key from env var)
- export COMFY_CLOUD_API_KEY="comfyui-xxxxxxx"
- python3 run_workflow.py --workflow workflow_api.json \
- --args '{"prompt": "a cat"}' \
- --host https://cloud.comfy.org \
- --output-dir ./outputs
- # With image input (auto-uploads, then references)
- python3 run_workflow.py --workflow img2img.json \
- --input-image image=./photo.png \
- --args '{"prompt": "make it cyberpunk"}'
- # WebSocket real-time progress
- python3 run_workflow.py --workflow flux_dev.json \
- --args '{"prompt": "..."}' \
- --ws
- Stdlib-only by default (Python 3.10+). Will use `requests`/`websocket-client`
- if installed for nicer behavior.
- """
- from __future__ import annotations
- import argparse
- import copy
- import json
- import sys
- import time
- from pathlib import Path
- from typing import Any
- from urllib.parse import urlencode, urlparse
- # Local import — _common.py sits next to this script.
- sys.path.insert(0, str(Path(__file__).resolve().parent))
- from _common import (
- DEFAULT_LOCAL_HOST, ENV_API_KEY,
- coerce_seed, emit_json, http_get, http_post, http_request,
- is_cloud_host, is_link, log, looks_like_video_workflow,
- media_type_from_filename, new_client_id, resolve_api_key, resolve_url,
- safe_path_join, unwrap_workflow,
- )
- # =============================================================================
- # Runner
- # =============================================================================
- class WorkflowRunError(Exception):
- """Raised when a workflow run fails (validation, execution, timeout)."""
- def __init__(self, status: str, message: str, **details: Any):
- super().__init__(message)
- self.status = status
- self.message = message
- self.details = details
- def to_dict(self) -> dict:
- d = {"status": self.status, "error": self.message}
- d.update(self.details)
- return d
- class ComfyRunner:
- def __init__(
- self,
- host: str = DEFAULT_LOCAL_HOST,
- api_key: str | None = None,
- client_id: str | None = None,
- partner_key: str | None = None,
- ):
- self.host = host.rstrip("/")
- self.api_key = api_key
- self.partner_key = partner_key
- self.is_cloud = is_cloud_host(self.host)
- self.client_id = client_id or new_client_id()
- @property
- def headers(self) -> dict[str, str]:
- h: dict[str, str] = {}
- if self.api_key:
- h["X-API-Key"] = self.api_key
- return h
- def _url(self, path: str) -> str:
- return resolve_url(self.host, path, is_cloud=self.is_cloud)
- # ---------- server health ----------
- def check_server(self) -> tuple[bool, dict | None]:
- try:
- r = http_get(self._url("/system_stats"), headers=self.headers, retries=2)
- if r.status == 200:
- try:
- return True, r.json()
- except Exception:
- return True, None
- return False, {"http_status": r.status, "body": r.text()[:500]}
- except Exception as e:
- return False, {"error": str(e)}
- # ---------- upload ----------
- def upload_image(self, path: Path, *, image_type: str = "input", overwrite: bool = True,
- endpoint: str = "/upload/image", extra_form: dict | None = None) -> dict:
- """Upload an image file via multipart. Returns server-side ref dict."""
- if not path.exists():
- raise FileNotFoundError(f"input image not found: {path}")
- # Stream the file via a handle to avoid OOM on huge inputs (16MP+ photos).
- with path.open("rb") as fh:
- files = {"image": (path.name, fh)}
- form = {"type": image_type}
- if overwrite:
- form["overwrite"] = "true"
- if extra_form:
- form.update({k: str(v) for k, v in extra_form.items()})
- r = http_request(
- "POST", self._url(endpoint),
- headers=self.headers, files=files, form=form,
- timeout=300, retries=2,
- )
- if r.status != 200:
- raise WorkflowRunError(
- "upload_failed",
- f"Upload of {path.name} failed: HTTP {r.status}",
- body=r.text()[:500],
- )
- try:
- return r.json()
- except Exception:
- return {"name": path.name}
- def upload_mask(self, path: Path, original_ref: dict) -> dict:
- """Upload an inpaint mask, linked to a previously uploaded source image.
- `original_ref` should be the dict returned by `upload_image()` for the
- source image (or `{"filename": ..., "subfolder": ..., "type": "input"}`).
- """
- return self.upload_image(
- path,
- endpoint="/upload/mask",
- extra_form={
- "subfolder": "clipspace",
- "original_ref": json.dumps(original_ref),
- },
- )
- # ---------- submit ----------
- def submit(self, workflow: dict) -> dict:
- payload: dict[str, Any] = {"prompt": workflow, "client_id": self.client_id}
- if self.partner_key:
- payload["extra_data"] = {"api_key_comfy_org": self.partner_key}
- r = http_post(self._url("/prompt"), headers=self.headers, json_body=payload, timeout=120)
- try:
- body = r.json()
- except Exception:
- body = {"raw": r.text()[:500]}
- if r.status != 200:
- return {"_http_error": r.status, "body": body}
- return body
- # ---------- HTTP polling ----------
- def poll_status(self, prompt_id: str, *, timeout: float = 300.0,
- initial_interval: float = 1.5, max_interval: float = 8.0) -> dict:
- start = time.time()
- interval = initial_interval
- while time.time() - start < timeout:
- if self.is_cloud:
- r = http_get(
- self._url(f"/job/{prompt_id}/status"),
- headers=self.headers, retries=2, timeout=30,
- )
- if r.status == 200:
- try:
- data = r.json()
- except Exception:
- data = {}
- s = data.get("status")
- if s == "completed":
- return {"status": "success", "data": data}
- if s in {"failed",}:
- return {"status": "error", "data": data}
- if s == "cancelled":
- return {"status": "cancelled", "data": data}
- # pending / in_progress → continue
- elif r.status == 404:
- # Cloud sometimes 404s briefly between submit and dispatcher pickup
- pass
- else:
- # transient error — retry loop covers it
- pass
- else:
- # Local: /history/{id} grows once execution completes
- r = http_get(
- self._url(f"/history/{prompt_id}"),
- headers=self.headers, retries=2, timeout=30,
- )
- if r.status == 200:
- try:
- data = r.json() or {}
- except Exception:
- data = {}
- entry = data.get(prompt_id)
- if isinstance(entry, dict):
- st = entry.get("status") or {}
- # IMPORTANT: check error first — `completed: true` can coexist with errors
- status_str = st.get("status_str")
- if status_str == "error":
- return {"status": "error", "data": entry}
- if st.get("completed", False):
- return {"status": "success", "outputs": entry.get("outputs", {})}
- # not in history yet → continue polling
- time.sleep(interval)
- interval = min(max_interval, interval * 1.4)
- return {"status": "timeout", "elapsed": time.time() - start}
- # ---------- WebSocket monitoring ----------
- def monitor_ws(self, prompt_id: str, *, timeout: float = 300.0,
- on_progress: Any = None) -> dict:
- """Connect to /ws and listen until execution_success / execution_error.
- Falls back to HTTP polling if `websocket-client` is not installed.
- Returns same shape as poll_status.
- """
- try:
- import websocket # type: ignore[import-not-found]
- except ImportError:
- log("websocket-client not installed; falling back to HTTP polling")
- return self.poll_status(prompt_id, timeout=timeout)
- # Build WS URL. Preserve any base-path components the user gave us
- # (e.g. http://example.com/comfyui → ws://example.com/comfyui/ws).
- parsed = urlparse(self.host)
- scheme = "wss" if parsed.scheme == "https" else "ws"
- netloc = parsed.netloc
- base_path = parsed.path.rstrip("/")
- ws_url = f"{scheme}://{netloc}{base_path}/ws?clientId={self.client_id}"
- if self.is_cloud and self.api_key:
- ws_url += f"&token={self.api_key}"
- outputs: dict[str, Any] = {}
- error_payload: dict[str, Any] | None = None
- success = False
- seen_executed = False
- ws = websocket.create_connection(ws_url, timeout=timeout)
- try:
- ws.settimeout(timeout)
- deadline = time.time() + timeout
- while time.time() < deadline:
- msg = ws.recv()
- if isinstance(msg, bytes):
- # Binary preview frame — ignore for now; ws_monitor.py prints them
- continue
- try:
- payload = json.loads(msg)
- except Exception:
- continue
- mtype = payload.get("type", "")
- mdata = payload.get("data", {}) or {}
- # Filter to our job (cloud broadcasts; local filters via client_id)
- pid = mdata.get("prompt_id")
- if pid is not None and pid != prompt_id:
- continue
- if mtype == "progress":
- if callable(on_progress):
- on_progress({
- "type": "progress",
- "value": mdata.get("value"),
- "max": mdata.get("max"),
- "node": mdata.get("node"),
- })
- elif mtype == "progress_state":
- if callable(on_progress):
- on_progress({"type": "progress_state", "nodes": mdata.get("nodes", {})})
- elif mtype == "executing":
- node = mdata.get("node")
- if callable(on_progress):
- on_progress({"type": "executing", "node": node})
- # When `node` is None on a local server, that signals end-of-run
- if node is None and not self.is_cloud and seen_executed:
- success = True
- break
- elif mtype == "executed":
- seen_executed = True
- nid = mdata.get("node")
- out = mdata.get("output") or {}
- if nid:
- outputs[nid] = out
- elif mtype == "notification":
- if callable(on_progress):
- on_progress({"type": "notification", "message": mdata.get("value", "")})
- elif mtype == "execution_success":
- success = True
- break
- elif mtype == "execution_error":
- error_payload = mdata
- break
- elif mtype == "execution_interrupted":
- error_payload = {"interrupted": True, **mdata}
- break
- finally:
- try:
- ws.close()
- except Exception:
- pass
- if error_payload is not None:
- return {"status": "error", "data": error_payload}
- if success:
- return {"status": "success", "outputs": outputs}
- return {"status": "timeout", "elapsed": timeout}
- # ---------- outputs ----------
- def get_outputs(self, prompt_id: str) -> dict:
- if self.is_cloud:
- # Try /jobs/{id} first (returns full job with outputs); fall back to /history_v2
- r = http_get(self._url(f"/jobs/{prompt_id}"), headers=self.headers, retries=2)
- if r.status == 200:
- try:
- return (r.json() or {}).get("outputs", {}) or {}
- except Exception:
- pass
- # Fallback
- r = http_get(self._url(f"/history/{prompt_id}"), headers=self.headers, retries=2)
- if r.status == 200:
- try:
- body = r.json() or {}
- except Exception:
- body = {}
- if isinstance(body, dict) and prompt_id in body:
- return body[prompt_id].get("outputs", {}) or {}
- if isinstance(body, dict) and "outputs" in body:
- return body["outputs"] or {}
- return {}
- # Local
- r = http_get(self._url(f"/history/{prompt_id}"), headers=self.headers, retries=2)
- if r.status != 200:
- return {}
- try:
- body = r.json() or {}
- except Exception:
- return {}
- entry = body.get(prompt_id) or {}
- return entry.get("outputs", {}) or {}
- def download_output(
- self, *, filename: str, subfolder: str, file_type: str,
- output_dir: Path, preserve_subfolder: bool = True, overwrite: bool = False,
- ) -> Path:
- """Stream a single output to disk. Path-traversal-safe."""
- params = {"filename": filename, "subfolder": subfolder, "type": file_type}
- url = self._url("/view") + "?" + urlencode(params)
- # Compute target path safely. If preserve_subfolder, include subfolder in the
- # local path; otherwise put the file in output_dir flat.
- target_parts: list[str] = []
- if preserve_subfolder and subfolder:
- target_parts.extend(p for p in subfolder.split("/") if p and p not in {".", ".."})
- target_parts.append(filename)
- out_path = safe_path_join(output_dir, *target_parts)
- if out_path.exists() and not overwrite:
- stem, suffix = out_path.stem, out_path.suffix
- i = 1
- while True:
- candidate = out_path.with_name(f"{stem}_{i}{suffix}")
- if not candidate.exists():
- out_path = candidate
- break
- i += 1
- out_path.parent.mkdir(parents=True, exist_ok=True)
- # Stream download. Two-step for cloud: get the 302, then fetch signed URL
- # so we don't accidentally send X-API-Key to the storage backend.
- # The HTTP transport already strips X-API-Key on cross-host redirect
- # via _strip_api_key_on_redirect, so a single follow_redirects=True call
- # is safe AND simpler.
- r = http_request(
- "GET", url, headers=self.headers,
- timeout=600, retries=3, follow_redirects=True,
- stream=True, sink=out_path,
- )
- if r.status != 200:
- try:
- if out_path.exists():
- out_path.unlink()
- except Exception:
- pass
- raise WorkflowRunError(
- "download_failed",
- f"Download of {filename} failed: HTTP {r.status}",
- url=url,
- )
- return out_path
- # ---------- queue / cancel ----------
- def cancel(self, prompt_id: str | None = None) -> bool:
- if prompt_id:
- r = http_post(
- self._url("/queue"), headers=self.headers,
- json_body={"delete": [prompt_id]}, retries=1,
- )
- return r.status == 200
- # Interrupt currently running
- r = http_post(self._url("/interrupt"), headers=self.headers, retries=1)
- return r.status == 200
- # =============================================================================
- # Schema / parameter injection
- # =============================================================================
- def _inline_schema(workflow: dict) -> dict:
- """Generate schema using the sibling extract_schema module."""
- from extract_schema import extract_schema # noqa: WPS433
- return extract_schema(workflow)
- def load_schema(schema_path: str | None, workflow: dict) -> dict:
- if schema_path:
- with open(schema_path, encoding="utf-8-sig") as f:
- return json.load(f)
- return _inline_schema(workflow)
- def inject_params(
- workflow: dict, schema: dict, args: dict,
- *, randomize_seed_if_unset: bool = False,
- ) -> tuple[dict, list[str]]:
- """Inject user args into the workflow. Returns (new_workflow, warnings)."""
- wf = copy.deepcopy(workflow)
- params = schema.get("parameters", {}) or {}
- warnings: list[str] = []
- # Auto-randomize seed when it's -1 in args, or when randomize_seed_if_unset
- # and user didn't pass a seed.
- if "seed" in params:
- if "seed" in args and args["seed"] in {None, -1, "-1"}:
- args = dict(args)
- args["seed"] = coerce_seed(args["seed"])
- warnings.append(f"seed=-1 expanded to {args['seed']}")
- elif randomize_seed_if_unset and "seed" not in args:
- args = dict(args)
- args["seed"] = coerce_seed(None)
- warnings.append(f"seed auto-randomized to {args['seed']}")
- for name, value in args.items():
- if name not in params:
- warnings.append(f"unknown parameter '{name}' (not in schema), skipping")
- continue
- m = params[name]
- nid, field = m["node_id"], m["field"]
- node = wf.get(nid)
- if not isinstance(node, dict) or "inputs" not in node:
- warnings.append(f"node '{nid}' for parameter '{name}' missing in workflow")
- continue
- # Refuse to overwrite a link with a literal — would silently break wiring
- cur = node["inputs"].get(field)
- if is_link(cur):
- warnings.append(
- f"parameter '{name}' targets {nid}.{field} which is currently a link; "
- f"refusing to overwrite (set the schema to point at the source node instead)"
- )
- continue
- node["inputs"][field] = value
- return wf, warnings
- # =============================================================================
- # Output download helper
- # =============================================================================
- def download_outputs(
- runner: ComfyRunner, outputs: dict, output_dir: Path,
- *, preserve_subfolder: bool = True, overwrite: bool = False,
- ) -> list[dict]:
- """Walk the outputs dict and download every file. Cloud uses `video` (singular);
- local uses `videos` (plural). We accept both."""
- output_dir.mkdir(parents=True, exist_ok=True)
- downloaded: list[dict] = []
- OUTPUT_KEYS = ("images", "gifs", "videos", "video", "audio", "files", "models", "3d")
- for node_id, node_output in (outputs or {}).items():
- if not isinstance(node_output, dict):
- continue
- for key in OUTPUT_KEYS:
- entries = node_output.get(key)
- if not entries:
- continue
- if not isinstance(entries, list):
- entries = [entries]
- for fi in entries:
- if not isinstance(fi, dict):
- continue
- filename = fi.get("filename") or ""
- if not filename:
- continue
- subfolder = fi.get("subfolder") or ""
- file_type = fi.get("type") or "output"
- try:
- out_path = runner.download_output(
- filename=filename, subfolder=subfolder, file_type=file_type,
- output_dir=output_dir, preserve_subfolder=preserve_subfolder,
- overwrite=overwrite,
- )
- downloaded.append({
- "file": str(out_path),
- "node_id": node_id,
- "type": media_type_from_filename(filename),
- "filename": filename,
- "subfolder": subfolder,
- "source_type": file_type,
- })
- except Exception as e:
- log(f"WARN: failed to download {filename}: {e}")
- return downloaded
- # =============================================================================
- # CLI
- # =============================================================================
- def parse_input_image_arg(spec: str) -> tuple[str, Path]:
- """Parse `name=path` (or `path` alone, defaulting to name='image')."""
- if "=" in spec:
- name, path = spec.split("=", 1)
- return name.strip(), Path(path).expanduser()
- return "image", Path(spec).expanduser()
- def main(argv: list[str] | None = None) -> int:
- p = argparse.ArgumentParser(
- description="Run a ComfyUI workflow with parameter injection.",
- formatter_class=argparse.RawDescriptionHelpFormatter,
- )
- p.add_argument("--workflow", required=True, help="Path to workflow API JSON file")
- p.add_argument("--args", default="{}",
- help="JSON parameters to inject (or `@/path/to/args.json`)")
- p.add_argument("--schema", help="Path to schema JSON (auto-generated if omitted)")
- p.add_argument("--host", default=DEFAULT_LOCAL_HOST, help="ComfyUI server URL")
- p.add_argument("--api-key",
- help=f"API key for cloud (or set ${ENV_API_KEY} env var)")
- p.add_argument("--partner-key",
- help="Partner-node API key (extra_data.api_key_comfy_org). "
- "Required for Flux Pro / Ideogram / etc. Defaults to --api-key if not set.")
- p.add_argument("--output-dir", default="./outputs", help="Directory to save outputs")
- p.add_argument("--timeout", type=int, default=0,
- help="Max seconds to wait (0=auto: 300 / 900 for video workflows)")
- p.add_argument("--input-image", action="append", default=[],
- help="Upload local image before running. Format: `name=path` or `path`. "
- "The `name` becomes the value injected into the matching schema parameter.")
- p.add_argument("--randomize-seed", action="store_true",
- help="If schema has a 'seed' parameter and --args didn't set one, randomize it")
- p.add_argument("--ws", action="store_true",
- help="Use WebSocket for real-time progress (requires `websocket-client`)")
- p.add_argument("--no-download", action="store_true", help="Skip downloading outputs")
- p.add_argument("--flat-output", action="store_true",
- help="Don't preserve server-side subfolder structure when saving outputs")
- p.add_argument("--overwrite", action="store_true",
- help="Overwrite existing files instead of appending _1, _2, ...")
- p.add_argument("--submit-only", action="store_true",
- help="Submit and return prompt_id without waiting")
- p.add_argument("--client-id", help="Override generated client_id (UUID)")
- p.add_argument("--use-partner-key-as-auth", action="store_true",
- help="(Compat) Use --partner-key value as cloud X-API-Key. Don't use unless you know why.")
- args = p.parse_args(argv)
- # ---- Load workflow ----
- wf_path = Path(args.workflow).expanduser()
- if not wf_path.exists():
- emit_json({"error": f"Workflow file not found: {args.workflow}"})
- return 1
- try:
- with wf_path.open(encoding="utf-8-sig") as f:
- workflow_raw = json.load(f)
- workflow = unwrap_workflow(workflow_raw)
- except ValueError as e:
- emit_json({"error": str(e)})
- return 1
- except json.JSONDecodeError as e:
- emit_json({"error": f"Invalid JSON in workflow file: {e}"})
- return 1
- # ---- Parse user args ----
- args_str = args.args
- if args_str.startswith("@"):
- try:
- args_str = Path(args_str[1:]).read_text(encoding="utf-8")
- except OSError as e:
- emit_json({"error": f"Cannot read args file: {e}"})
- return 1
- try:
- user_args = json.loads(args_str) if args_str.strip() else {}
- except json.JSONDecodeError as e:
- emit_json({"error": f"Invalid --args JSON: {e}"})
- return 1
- if not isinstance(user_args, dict):
- emit_json({"error": "--args must be a JSON object"})
- return 1
- # ---- Resolve API key ----
- api_key = resolve_api_key(args.api_key)
- partner_key = args.partner_key or None
- if args.use_partner_key_as_auth and not api_key and partner_key:
- api_key = partner_key
- # ---- Connect ----
- runner = ComfyRunner(
- host=args.host, api_key=api_key, partner_key=partner_key,
- client_id=args.client_id,
- )
- # Server reachability
- ok, info = runner.check_server()
- if not ok:
- emit_json({
- "error": f"Cannot reach server at {args.host}",
- "details": info,
- "hint": (
- "Check `comfy launch --background` is running for local, "
- f"or set ${ENV_API_KEY} for cloud."
- ),
- })
- return 1
- # ---- Upload input images ----
- upload_warnings: list[str] = []
- for spec in args.input_image:
- try:
- param_name, path = parse_input_image_arg(spec)
- except Exception as e:
- emit_json({"error": f"Bad --input-image spec '{spec}': {e}"})
- return 1
- try:
- ref = runner.upload_image(path)
- except Exception as e:
- emit_json({"error": f"Upload failed for {path}: {e}"})
- return 1
- # Register as a user arg so inject_params consumes it through the schema
- uploaded_name = ref.get("name") or path.name
- if param_name not in user_args:
- user_args[param_name] = uploaded_name
- # ---- Inject params ----
- schema = load_schema(args.schema, workflow)
- workflow, inj_warnings = inject_params(
- workflow, schema, user_args, randomize_seed_if_unset=args.randomize_seed,
- )
- warnings = upload_warnings + inj_warnings
- for w in warnings:
- log(f"WARN: {w}")
- # ---- Submit ----
- submit_resp = runner.submit(workflow)
- if "_http_error" in submit_resp:
- emit_json({
- "error": "Submission HTTP error",
- "http_status": submit_resp["_http_error"],
- "body": submit_resp.get("body"),
- })
- return 1
- if isinstance(submit_resp.get("error"), dict):
- emit_json({
- "error": "Workflow validation failed",
- "details": submit_resp["error"],
- "node_errors": submit_resp.get("node_errors"),
- })
- return 1
- prompt_id = submit_resp.get("prompt_id")
- if not prompt_id:
- emit_json({"error": "No prompt_id in submit response", "response": submit_resp})
- return 1
- node_errors = submit_resp.get("node_errors") or {}
- if node_errors:
- emit_json({"error": "Workflow validation failed", "node_errors": node_errors})
- return 1
- if args.submit_only:
- emit_json({"status": "submitted", "prompt_id": prompt_id, "warnings": warnings})
- return 0
- # ---- Wait ----
- timeout = args.timeout
- if timeout <= 0:
- timeout = 900 if looks_like_video_workflow(workflow) else 300
- log(f"Submitted: prompt_id={prompt_id}, waiting (timeout={timeout}s)…")
- def _on_progress(evt: dict) -> None:
- t = evt.get("type")
- if t == "progress":
- log(f" step {evt.get('value')}/{evt.get('max')} on node {evt.get('node')}")
- elif t == "executing":
- node = evt.get("node")
- if node:
- log(f" executing node {node}")
- try:
- if args.ws:
- wait_result = runner.monitor_ws(prompt_id, timeout=timeout, on_progress=_on_progress)
- else:
- wait_result = runner.poll_status(prompt_id, timeout=timeout)
- except KeyboardInterrupt:
- log(f"Interrupted — cancelling job {prompt_id} on server…")
- try:
- runner.cancel(prompt_id)
- except Exception as e:
- log(f" (cancel request failed: {e})")
- emit_json({
- "status": "interrupted",
- "prompt_id": prompt_id,
- "note": "Ctrl+C received; sent cancellation to server.",
- })
- return 130
- if wait_result["status"] == "timeout":
- emit_json({
- "status": "timeout",
- "prompt_id": prompt_id,
- "elapsed": wait_result.get("elapsed"),
- "hint": "Re-run with larger --timeout, or use --submit-only and check later.",
- })
- return 1
- if wait_result["status"] == "error":
- emit_json({"status": "error", "prompt_id": prompt_id, "details": wait_result.get("data")})
- return 1
- if wait_result["status"] == "cancelled":
- emit_json({"status": "cancelled", "prompt_id": prompt_id})
- return 1
- # ---- Outputs ----
- outputs = wait_result.get("outputs")
- if not outputs:
- outputs = runner.get_outputs(prompt_id)
- if args.no_download:
- emit_json({
- "status": "success", "prompt_id": prompt_id,
- "outputs": outputs, "warnings": warnings,
- })
- return 0
- downloaded = download_outputs(
- runner, outputs, Path(args.output_dir).expanduser(),
- preserve_subfolder=not args.flat_output, overwrite=args.overwrite,
- )
- emit_json({
- "status": "success",
- "prompt_id": prompt_id,
- "outputs": downloaded,
- "warnings": warnings,
- })
- return 0
- if __name__ == "__main__":
- sys.exit(main())
|