#!/usr/bin/env python3 """ orchestrator.py — drives ComfyUI's REST API to generate a storyboard. WHAT THIS DOES: 1. Reads shots.yaml (your storyboard, one block per shot) 2. Loads single_shot_template.json (the reusable ~43-node pipeline) 3. For each shot: overrides prompt text + character/location refs, submits to ComfyUI's /prompt endpoint, waits for completion, moves to next shot 4. No canvas editing, no manual node clicking — fully automated REQUIREMENTS: pip install requests pyyaml --break-system-packages USAGE: # 1. Make sure ComfyUI is running (python main.py --listen 0.0.0.0 --port 8188) # 2. Edit shots.yaml to add/change shots # 3. Run: python orchestrator.py # Run only specific shots (comma-separated IDs): python orchestrator.py --only B1_Jim_Seated_Table,B2_Jim_BarCounter_Facing # Point at a different ComfyUI instance: python orchestrator.py --host http://localhost:8188 """ import argparse import copy import json import sys import time from pathlib import Path import requests import yaml # ============================================================================ # NODE ID MAP — which node in the template each field maps to # (These IDs come from single_shot_template.json — don't change unless you # re-extract the template from a different pipeline) # ============================================================================ NODE = { "pos": 20, # CLIPTextEncodeFlux POS (widgets: [clip_l, t5, guidance]) "neg": 21, # CLIPTextEncodeFlux NEG "ipa": 23, # ApplyFluxIPAdapter (widgets: [weight]) "pulid_s1": 24, # ApplyPulidFlux Stage 1 (widgets: [weight, ...]) "cn_apply": 25, # ControlNetApplyAdvanced (widgets: [strength, start%, end%]) "face_pos": 35, # CLIPTextEncodeFlux face POS "face_neg": 36, # CLIPTextEncodeFlux face NEG "pulid_s2": 34, # ApplyPulidFlux Stage 2 "save_final": 39, # SaveImage FINAL (widgets: [filename_prefix]) "save_s1": 28, # SaveImage Stage1 (widgets: [filename_prefix]) } # Reference image LoadImage nodes — keyed by character/location name REF_NODE = { "jim_body": 16, "jim_face": 17, "barbara_body": 18, "barbara_face": 19, } # Which LoadImage node the ControlNetApplyAdvanced (id 25) should pull its # depth image from, depending on shot['location']. The template has TWO # depth preprocessors already wired (12=LOC1, 13=LOC2); we just need the # CN Apply node's "image" INPUT to point at the correct one at submit time. DEPTH_NODE = {"loc1": "12", "loc2": "13"} DEFAULT_NEG = ( "low quality, bad anatomy, extra limbs, missing limbs, watermark, " "blurry, deformed face, extra fingers, duplicate, ugly" ) DEFAULT_FACE_NEG = "low quality, bad anatomy, blurry, deformed face" def load_template(path: str) -> dict: with open(path) as f: return json.load(f) def workflow_to_api_format(wf: dict) -> dict: """ Convert the UI-style workflow (nodes/links arrays, used for canvas display) into the API prompt format ComfyUI's /prompt endpoint expects (a flat dict of node_id -> {class_type, inputs}). """ link_map = {l[0]: l for l in wf["links"]} api = {} for n in wf["nodes"]: node_id = str(n["id"]) inputs = {} # Wire up input links for i, inp in enumerate(n.get("inputs", [])): lid = inp.get("link") if lid is not None: l = link_map[lid] src_node, src_slot = l[1], l[2] inputs[inp["name"]] = [str(src_node), src_slot] # Wire up widget values (order matters — matches node's widget order) widget_names = [i["name"] for i in n.get("inputs", []) if i.get("link") is None] # Simpler: ComfyUI API expects widget values merged into inputs by name. # We rely on the fact that widgets_values order matches the node's # default widget schema — this works for all nodes used in this template. wv = n.get("widgets_values", []) # Map widget index -> input name using the node's *own* declared widget slots. # ComfyUI stores this implicitly; for our known node types we hardcode below. api[node_id] = {"class_type": n["type"], "inputs": inputs, "_widgets": wv} return api def apply_shot_overrides(wf: dict, shot: dict, char_registry: dict) -> dict: """Return a deep-copied workflow with this shot's values patched in.""" wf = copy.deepcopy(wf) by_id = {n["id"]: n for n in wf["nodes"]} char = shot["character"] guidance = shot.get("guidance", 4.5) neg_guidance = shot.get("neg_guidance", 3.5) # ---- Prompts ---- by_id[NODE["pos"]]["widgets_values"] = [ shot["clip_l"].strip(), shot["t5"].strip(), guidance ] by_id[NODE["neg"]]["widgets_values"] = [ "", shot.get("neg", DEFAULT_NEG), neg_guidance ] by_id[NODE["face_pos"]]["widgets_values"] = [ shot["face_clip_l"].strip(), shot["face_t5"].strip(), guidance ] by_id[NODE["face_neg"]]["widgets_values"] = [ "", shot.get("face_neg", DEFAULT_FACE_NEG), neg_guidance ] # ---- Character reference images (IPA body ref + PuLID face ref) ---- body_ref_id = REF_NODE[f"{char}_body"] face_ref_id = REF_NODE[f"{char}_face"] body_fname = char_registry[char]["body_image"] face_fname = char_registry[char]["face_image"] by_id[body_ref_id]["widgets_values"] = [body_fname, "image"] by_id[face_ref_id]["widgets_values"] = [face_fname, "image"] # ---- IPA / PuLID weights (allow per-shot override, else registry default) ---- ipa_weight = shot.get("ipa_weight", char_registry[char].get("ipa_weight", 0.43)) by_id[NODE["ipa"]]["widgets_values"] = [ipa_weight] pulid_s1_weight = shot.get("pulid_s1_weight", 0.85) by_id[NODE["pulid_s1"]]["widgets_values"][0] = pulid_s1_weight pulid_s2_weight = shot.get("pulid_s2_weight", 0.95) by_id[NODE["pulid_s2"]]["widgets_values"][0] = pulid_s2_weight # ---- ControlNet strength (allow per-shot override) ---- cn_strength = shot.get("cn_strength", 0.45) cn_end = shot.get("cn_end", 0.65) by_id[NODE["cn_apply"]]["widgets_values"] = [cn_strength, 0.0, cn_end] # ---- Location routing: rewire ControlNetApplyAdvanced's image input ---- depth_node_id = int(DEPTH_NODE[shot["location"]]) cn_node = by_id[NODE["cn_apply"]] # input[3] is "image" on ControlNetApplyAdvanced for link in wf["links"]: if link[3] == NODE["cn_apply"] and link[4] == 3: link[1] = depth_node_id # rewire source node link[2] = 0 # output slot 0 (IMAGE) # ---- Output filenames ---- by_id[NODE["save_final"]]["widgets_values"] = [f"{shot['id']}_FINAL"] by_id[NODE["save_s1"]]["widgets_values"] = [f"{shot['id']}_Stage1"] return wf def fetch_widget_schemas(host: str) -> dict: """ Fetch real widget name schemas from ComfyUI's /object_info endpoint. This replaces the old hardcoded WIDGET_SCHEMA — it works regardless of which version of custom nodes is installed, and handles ComfyUI's own typos in node input names (e.g. 'ipadatper' in LoadFluxIPAdapter). Widget inputs are those whose type is a primitive (STRING, INT, FLOAT, BOOLEAN) or a combo list — as opposed to node connection types like MODEL, CLIP, LATENT which are satisfied by links, not widget values. """ resp = requests.get(f"{host}/object_info", timeout=10) resp.raise_for_status() info = resp.json() PRIMITIVE_TYPES = {"STRING", "INT", "FLOAT", "BOOLEAN"} schemas = {} for node_type, node_info in info.items(): widget_names = [] all_inputs = {} all_inputs.update(node_info.get("input", {}).get("required", {})) all_inputs.update(node_info.get("input", {}).get("optional", {})) for name, spec in all_inputs.items(): if not spec: continue input_type = spec[0] # Lists = combo boxes (widget); uppercase strings = node connections if isinstance(input_type, list) or input_type in PRIMITIVE_TYPES: widget_names.append(name) schemas[node_type] = widget_names return schemas # Module-level schema cache — populated at startup by fetch_widget_schemas() WIDGET_SCHEMA: dict = {} # UI-only widget indices to skip when building the API payload. # These values exist in the canvas widgets_values array but are NOT real # node inputs — they're inserted by the ComfyUI frontend and absent from # object_info. Keyed by node type, values are sets of indices to skip. SKIP_WIDGET_INDICES: dict = { "KSampler": {1}, # index 1 = "control_after_generate" (randomize/fixed) "KSamplerAdvanced": {1, 4}, # same concept, two occurrences } def ui_workflow_to_prompt_payload(wf: dict) -> dict: """ Convert UI graph format to ComfyUI's API prompt dict format. ComfyUI needs: {node_id: {"class_type": ..., "inputs": {name: value_or_link}}} WIDGET_SCHEMA must be populated before calling this (done in main()). """ link_map = {l[0]: l for l in wf["links"]} prompt = {} for n in wf["nodes"]: node_id = str(n["id"]) class_type = n["type"] inputs = {} # Linked inputs — satisfied by connections from other nodes linked_names = set() for inp in n.get("inputs", []): lid = inp.get("link") if lid is not None: l = link_map[lid] inputs[inp["name"]] = [str(l[1]), l[2]] linked_names.add(inp["name"]) # Widget inputs — map widgets_values positionally onto widget names. # SKIP_WIDGET_INDICES lists widgets_values positions that are UI-only # (they exist in the canvas JSON but are NOT sent to the API). # KSampler index 1 = "control_after_generate" (randomize/fixed) is a # frontend-only widget absent from object_info — must be skipped here. wv = n.get("widgets_values", []) schema = WIDGET_SCHEMA.get(class_type, []) skip = SKIP_WIDGET_INDICES.get(class_type, set()) wi = 0 # position in schema for vi, val in enumerate(wv): if vi in skip: continue # skip UI-only value at this index if wi >= len(schema): break name = schema[wi] wi += 1 if name in linked_names: continue # input satisfied by a link, not a widget inputs[name] = val prompt[node_id] = {"class_type": class_type, "inputs": inputs} return prompt def submit_and_wait(host: str, prompt_payload: dict, shot_id: str, timeout: int = 600): """Submit to ComfyUI /prompt and poll /history until this prompt completes.""" resp = requests.post(f"{host}/prompt", json={"prompt": prompt_payload}) resp.raise_for_status() data = resp.json() prompt_id = data["prompt_id"] print(f" [{shot_id}] submitted, prompt_id={prompt_id}") start = time.time() while time.time() - start < timeout: h = requests.get(f"{host}/history/{prompt_id}").json() if prompt_id in h: status = h[prompt_id].get("status", {}) if status.get("completed"): print(f" [{shot_id}] done in {time.time()-start:.1f}s") return h[prompt_id] if status.get("status_str") == "error": print(f" [{shot_id}] FAILED: {status}") return None time.sleep(3) print(f" [{shot_id}] TIMEOUT after {timeout}s") return None def main(): ap = argparse.ArgumentParser() ap.add_argument("--host", default="http://localhost:8188") ap.add_argument("--shots", default="shots.yaml") ap.add_argument("--template", default="single_shot_template.json") ap.add_argument("--characters", default="characters.yaml") ap.add_argument("--only", default=None, help="Comma-separated shot IDs to run (default: all)") args = ap.parse_args() with open(args.characters) as f: char_registry = yaml.safe_load(f) with open(args.shots) as f: shots = yaml.safe_load(f) template = load_template(args.template) if args.only: wanted = set(args.only.split(",")) shots = [s for s in shots if s["id"] in wanted] # Fetch real widget schemas from the live ComfyUI instance global WIDGET_SCHEMA print(f"Fetching node schemas from {args.host} ...") WIDGET_SCHEMA = fetch_widget_schemas(args.host) print(f" got schemas for {len(WIDGET_SCHEMA)} node types\n") print(f"Running {len(shots)} shot(s) against {args.host}\n") for shot in shots: wf = apply_shot_overrides(template, shot, char_registry) prompt_payload = ui_workflow_to_prompt_payload(wf) submit_and_wait(args.host, prompt_payload, shot["id"]) print("\nAll shots submitted.") if __name__ == "__main__": main()