serverless: client scripts (sync/async) + README; timings from live endpoint tests

serverless/README.md

@@ -27,9 +27,13 @@ serverless/
 │       ├── endpoint.json           # models + custom nodes + default workflow
 │       ├── workflows/<name>.json   # API-format workflow(s) baked into the image
 │       └── params/<name>.json      # friendly-param -> node.input mapping
-└── tests/
-    ├── local_test.py     # drive handler against a locally running ComfyUI
-    └── endpoint_test.py  # drive a deployed RunPod endpoint
+├── tests/
+│   ├── local_test.py     # drive handler against a locally running ComfyUI
+│   └── endpoint_test.py  # drive a deployed RunPod endpoint
+└── client/               # standalone caller scripts (stdlib-only) + usage README
+    ├── qwen_edit_sync.py     # /runsync: block until done
+    ├── qwen_edit_async.py    # /run: submit, poll, fire-and-forget, collect, cancel
+    └── qwen-edit-turbo-v4.json
 ```
 
 ## Calling the endpoint

serverless/client/README.md

@@ -0,0 +1,81 @@
+# qwen-edit-turbo — client scripts
+
+Call the deployed RunPod serverless endpoint (`dom5lwr0o5wq6u`, image
+`plx1029/comfyui-serverless:qwen-edit-turbo-v1`) from anywhere. Both scripts
+are standalone (Python 3.8+, stdlib only — no pip installs).
+
+| file | what it does |
+|---|---|
+| `qwen_edit_sync.py`  | `/runsync` — blocks until done, saves image(s) |
+| `qwen_edit_async.py` | `/run` — submit, poll, or fire-and-forget + collect later |
+| `qwen-edit-turbo-v4.json` | the API-format workflow baked into the endpoint (reference; also usable with `--workflow-json` after editing) |
+
+## Quick start
+
+```bash
+export RUNPOD_API_KEY=...      # or pass --api-key
+
+# synchronous: person + outfit -> edited image in ./results
+python qwen_edit_sync.py \
+    --image person.jpg --ref-image outfit.png \
+    --prompt "replace the outfit of the person in the first image with the outfit in the second image" \
+    --mode turbo-8 --out ./results
+
+# async fire-and-forget
+job=$(python qwen_edit_async.py --image person.jpg --prompt "remove the background people" --no-wait)
+python qwen_edit_async.py --job-id "$job" --out ./results     # collect later
+```
+
+Single-image edits: just omit `--ref-image` (the workflow's reference branch
+switches off automatically).
+
+## Arguments (both scripts)
+
+| arg | default | meaning |
+|---|---|---|
+| `--api-key` | `$RUNPOD_API_KEY` | RunPod API key |
+| `--endpoint-id` | `dom5lwr0o5wq6u` | endpoint to call |
+| `--image` | required | main input image |
+| `--ref-image` | none | reference image (outfit/style/person source) |
+| `--prompt` | required | edit instruction |
+| `--mode` | `turbo-8` | `turbo-4` (fastest) / `turbo-8` / `quality` (12-step, cfg 3) |
+| `--seed` | random | reproducibility; the used seed is always printed |
+| `--input-max-dim` | 2048 | main image is resized to fit this before editing |
+| `--ref-max-dim` | 1024 | same for the reference image |
+| `--output-max-dim` | 2560 | result upscale target |
+| `--lora-skin-fix [--lora-skin-fix-strength]` | off / 1.0 | optional Skin-Fix lora |
+| `--lora-amateur [--lora-amateur-strength]` | off / 1.0 | optional Amateur-Photo lora |
+| `--workflow` | `qwen-edit-turbo-v4` | which baked workflow to run |
+| `--set NODE.INPUT=VALUE` | — | raw graph override, repeatable (e.g. `--set 43.cfg=1.5`) |
+| `--workflow-json FILE` | — | run a full custom API-format graph instead |
+| `--out` | `.` | where to save result images |
+| `--timeout` | 600 / 1800 | max seconds to wait |
+
+`qwen_edit_async.py` extras: `--no-wait` (print job id and exit), `--job-id ID`
+(poll/collect an existing job), `--poll SECONDS`, `--cancel JOB_ID`.
+
+## What to expect (measured 2026-07-23)
+
+| situation | delay | execution |
+|---|---|---|
+| warm worker | ~0.1–0.5 s | turbo-4 ≈ 42 s, turbo-8 ≈ 60 s (2048px, 2 input images, 2560px output) |
+| FlashBoot resume (idle worker) | ~0.5 s | same as warm — models stay in VRAM |
+| brand-new host (first ever pull) | ~15 min once | ~78 s (model load from NVMe + inference) |
+
+Payload limits: ~10 MB on `/run`, ~20 MB on `/runsync`; base64 adds ~33 % to
+image bytes. Keep the two inputs under ~7 MB combined for sync calls, or use
+async. (URL inputs / S3 outputs are the planned upgrade if this becomes a
+bottleneck.)
+
+## Raw HTTP (no script)
+
+```bash
+curl -s -X POST "https://api.runpod.ai/v2/dom5lwr0o5wq6u/runsync" \
+  -H "Authorization: Bearer $RUNPOD_API_KEY" -H "Content-Type: application/json" \
+  -d '{"input": {"images": [{"name": "a.jpg", "image": "'"$(base64 -w0 a.jpg)"'"}],
+       "params": {"prompt": "make it night time", "mode": "turbo-8"}}}'
+```
+
+Response: `output.images[].data` is a base64 PNG; `output.seed`,
+`output.timings` included. See `../README.md` for the full API schema and how
+the endpoint image is built.

serverless/client/qwen-edit-turbo-v4.json

@@ -0,0 +1,758 @@
+{
+  "1": {
+    "class_type": "UNETLoader",
+    "inputs": {
+      "unet_name": "qwen_image_edit_2511_bf16.safetensors",
+      "weight_dtype": "default"
+    }
+  },
+  "13": {
+    "class_type": "ModelSamplingAuraFlow",
+    "inputs": {
+      "model": [
+        "53:6",
+        0
+      ],
+      "shift": 3.1
+    }
+  },
+  "14": {
+    "class_type": "CFGNorm",
+    "inputs": {
+      "model": [
+        "13",
+        0
+      ],
+      "pre_cfg": false,
+      "strength": 1
+    }
+  },
+  "15": {
+    "_meta": {
+      "title": "upscale_input_to_max_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "16": {
+    "_meta": {
+      "title": "downscale_input_to_max_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": false
+    }
+  },
+  "20": {
+    "_meta": {
+      "title": "Main Image"
+    },
+    "class_type": "LoadImage",
+    "inputs": {
+      "image": "733427737_18059858666742129_6215894921112236726_n.jpg"
+    }
+  },
+  "21": {
+    "_meta": {
+      "title": "Input max size (main)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 2048
+    }
+  },
+  "27": {
+    "_meta": {
+      "title": "Main image config"
+    },
+    "class_type": "QwenEditConfigPreparer",
+    "inputs": {
+      "image": [
+        "20",
+        0
+      ],
+      "ref_crop": "pad",
+      "ref_longest_edge": [
+        "54:5",
+        0
+      ],
+      "ref_main_image": true,
+      "ref_upscale": "lanczos",
+      "to_ref": true,
+      "to_vl": true,
+      "vl_crop": "center",
+      "vl_resize": true,
+      "vl_target_size": 384,
+      "vl_upscale": "bicubic"
+    }
+  },
+  "3": {
+    "class_type": "CLIPLoader",
+    "inputs": {
+      "clip_name": "qwen_2.5_vl_7b.safetensors",
+      "device": "default",
+      "type": "qwen_image"
+    }
+  },
+  "30": {
+    "_meta": {
+      "title": "Reference Image 2 (optional)"
+    },
+    "class_type": "LoadImage",
+    "inputs": {
+      "image": "b.png"
+    }
+  },
+  "31": {
+    "_meta": {
+      "title": "Input max size (ref 2)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 1024
+    }
+  },
+  "37": {
+    "_meta": {
+      "title": "Reference image 2 config"
+    },
+    "class_type": "QwenEditConfigPreparer",
+    "inputs": {
+      "configs": [
+        "27",
+        0
+      ],
+      "image": [
+        "30",
+        0
+      ],
+      "ref_crop": "center",
+      "ref_longest_edge": [
+        "55:5",
+        0
+      ],
+      "ref_main_image": false,
+      "ref_upscale": "lanczos",
+      "to_ref": true,
+      "to_vl": true,
+      "vl_crop": "center",
+      "vl_resize": true,
+      "vl_target_size": 384,
+      "vl_upscale": "bicubic"
+    }
+  },
+  "4": {
+    "class_type": "VAELoader",
+    "inputs": {
+      "vae_name": "qwen_image_vae.safetensors"
+    }
+  },
+  "40": {
+    "_meta": {
+      "title": "Qwen Edit Encode (prompt here)"
+    },
+    "class_type": "TextEncodeQwenImageEditPlusCustom_lrzjason",
+    "inputs": {
+      "clip": [
+        "3",
+        0
+      ],
+      "configs": [
+        "57",
+        0
+      ],
+      "instruction": "",
+      "prompt": "replace the outfit of the subject in the first image with the outfit in the second image, don't change anything else. do not change the body's anatomy or shape or skin tone. only put the outfit onto the person in the first image. ",
+      "return_full_refs_cond": true,
+      "vae": [
+        "4",
+        0
+      ]
+    }
+  },
+  "41": {
+    "class_type": "QwenEditOutputExtractor",
+    "inputs": {
+      "custom_output": [
+        "40",
+        2
+      ]
+    }
+  },
+  "42": {
+    "_meta": {
+      "title": "Negative (zeroed)"
+    },
+    "class_type": "ConditioningZeroOut",
+    "inputs": {
+      "conditioning": [
+        "40",
+        0
+      ]
+    }
+  },
+  "43": {
+    "class_type": "KSampler",
+    "inputs": {
+      "cfg": [
+        "53:14",
+        0
+      ],
+      "denoise": 1,
+      "latent_image": [
+        "40",
+        1
+      ],
+      "model": [
+        "14",
+        0
+      ],
+      "negative": [
+        "42",
+        0
+      ],
+      "positive": [
+        "40",
+        0
+      ],
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "seed": 440984114065874,
+      "steps": [
+        "53:11",
+        0
+      ]
+    }
+  },
+  "44": {
+    "class_type": "VAEDecode",
+    "inputs": {
+      "samples": [
+        "43",
+        0
+      ],
+      "vae": [
+        "4",
+        0
+      ]
+    }
+  },
+  "45": {
+    "_meta": {
+      "title": "Remove padding"
+    },
+    "class_type": "CropWithPadInfo",
+    "inputs": {
+      "image": [
+        "44",
+        0
+      ],
+      "pad_info": [
+        "41",
+        0
+      ]
+    }
+  },
+  "46": {
+    "_meta": {
+      "title": "upscale_output_to_selected_size"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "47": {
+    "_meta": {
+      "title": "Selected output size"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 2560
+    }
+  },
+  "48": {
+    "_meta": {
+      "title": "Scale output"
+    },
+    "class_type": "ImageScaleToMaxDimension",
+    "inputs": {
+      "image": [
+        "45",
+        0
+      ],
+      "largest_size": [
+        "47",
+        0
+      ],
+      "upscale_method": "lanczos"
+    }
+  },
+  "49": {
+    "_meta": {
+      "title": "Output size switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "45",
+        0
+      ],
+      "on_true": [
+        "48",
+        0
+      ],
+      "switch": [
+        "46",
+        0
+      ]
+    }
+  },
+  "5": {
+    "_meta": {
+      "title": "Sampling mode: 1=4-step / 2=8-step / 3=quality"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 1
+    }
+  },
+  "50": {
+    "class_type": "SaveImage",
+    "inputs": {
+      "filename_prefix": "qwen-edit-turbo-v4",
+      "images": [
+        "49",
+        0
+      ]
+    }
+  },
+  "52": {
+    "_meta": {
+      "title": "User LoRAs"
+    },
+    "class_type": "Power Lora Loader (rgthree)",
+    "inputs": {
+      "lora_1": {
+        "lora": "Qwen_LoRA_Skin_Fix_v2.safetensors",
+        "on": false,
+        "strength": 1,
+        "strengthTwo": null
+      },
+      "lora_2": {
+        "lora": "Qwen_LoRA_Amateur_Photo_v1.safetensors",
+        "on": false,
+        "strength": 1,
+        "strengthTwo": null
+      },
+      "model": [
+        "1",
+        0
+      ]
+    }
+  },
+  "53:1": {
+    "_meta": {
+      "title": "LoRA: Lightning 4 steps"
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "inputs": {
+      "lora_name": "Qwen-Image-Edit-2511-Lightning-4steps-V1.0-bf16.safetensors",
+      "model": [
+        "52",
+        0
+      ],
+      "strength_model": 1
+    }
+  },
+  "53:10": {
+    "_meta": {
+      "title": "Steps switch 4/8"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:7",
+        0
+      ],
+      "on_true": [
+        "53:8",
+        0
+      ],
+      "switch": [
+        "53:3",
+        2
+      ]
+    }
+  },
+  "53:11": {
+    "_meta": {
+      "title": "Steps switch quality"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:10",
+        0
+      ],
+      "on_true": [
+        "53:9",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:12": {
+    "_meta": {
+      "title": "CFG (lightning)"
+    },
+    "class_type": "PrimitiveFloat",
+    "inputs": {
+      "value": 1.0
+    }
+  },
+  "53:13": {
+    "_meta": {
+      "title": "CFG (quality)"
+    },
+    "class_type": "PrimitiveFloat",
+    "inputs": {
+      "value": 3.0
+    }
+  },
+  "53:14": {
+    "_meta": {
+      "title": "CFG switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:12",
+        0
+      ],
+      "on_true": [
+        "53:13",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:2": {
+    "_meta": {
+      "title": "LoRA: Lightning 8 steps"
+    },
+    "class_type": "LoraLoaderModelOnly",
+    "inputs": {
+      "lora_name": "Qwen-Image-Edit-2511-Lightning-8steps-V1.0-bf16.safetensors",
+      "model": [
+        "52",
+        0
+      ],
+      "strength_model": 1
+    }
+  },
+  "53:3": {
+    "_meta": {
+      "title": "is 8-step (mode == 2)"
+    },
+    "class_type": "ComfyMathExpression",
+    "inputs": {
+      "expression": "a == 2",
+      "values.a": [
+        "5",
+        0
+      ]
+    }
+  },
+  "53:4": {
+    "_meta": {
+      "title": "is quality (mode == 3)"
+    },
+    "class_type": "ComfyMathExpression",
+    "inputs": {
+      "expression": "a == 3",
+      "values.a": [
+        "5",
+        0
+      ]
+    }
+  },
+  "53:5": {
+    "_meta": {
+      "title": "Model switch 4/8"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:1",
+        0
+      ],
+      "on_true": [
+        "53:2",
+        0
+      ],
+      "switch": [
+        "53:3",
+        2
+      ]
+    }
+  },
+  "53:6": {
+    "_meta": {
+      "title": "Model switch quality"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "53:5",
+        0
+      ],
+      "on_true": [
+        "52",
+        0
+      ],
+      "switch": [
+        "53:4",
+        2
+      ]
+    }
+  },
+  "53:7": {
+    "_meta": {
+      "title": "Steps (4-step)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 4
+    }
+  },
+  "53:8": {
+    "_meta": {
+      "title": "Steps (8-step)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 8
+    }
+  },
+  "53:9": {
+    "_meta": {
+      "title": "Steps (quality)"
+    },
+    "class_type": "PrimitiveInt",
+    "inputs": {
+      "value": 12
+    }
+  },
+  "54:1": {
+    "_meta": {
+      "title": "native edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "20",
+        0
+      ],
+      "expression": "max(a.width, a.height)"
+    }
+  },
+  "54:2": {
+    "_meta": {
+      "title": "upscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "20",
+        0
+      ],
+      "c": [
+        "21",
+        0
+      ],
+      "expression": "max(a.width, a.height, c)"
+    }
+  },
+  "54:3": {
+    "_meta": {
+      "title": "apply upscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "54:1",
+        0
+      ],
+      "on_true": [
+        "54:2",
+        0
+      ],
+      "switch": [
+        "15",
+        0
+      ]
+    }
+  },
+  "54:4": {
+    "_meta": {
+      "title": "downscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "54:3",
+        0
+      ],
+      "c": [
+        "21",
+        0
+      ],
+      "expression": "min(a, c)"
+    }
+  },
+  "54:5": {
+    "_meta": {
+      "title": "apply downscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "54:3",
+        0
+      ],
+      "on_true": [
+        "54:4",
+        0
+      ],
+      "switch": [
+        "16",
+        0
+      ]
+    }
+  },
+  "55:1": {
+    "_meta": {
+      "title": "native edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "30",
+        0
+      ],
+      "expression": "max(a.width, a.height)"
+    }
+  },
+  "55:2": {
+    "_meta": {
+      "title": "upscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "30",
+        0
+      ],
+      "c": [
+        "31",
+        0
+      ],
+      "expression": "max(a.width, a.height, c)"
+    }
+  },
+  "55:3": {
+    "_meta": {
+      "title": "apply upscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "55:1",
+        0
+      ],
+      "on_true": [
+        "55:2",
+        0
+      ],
+      "switch": [
+        "15",
+        0
+      ]
+    }
+  },
+  "55:4": {
+    "_meta": {
+      "title": "downscaled edge"
+    },
+    "class_type": "MathExpression|pysssss",
+    "inputs": {
+      "a": [
+        "55:3",
+        0
+      ],
+      "c": [
+        "31",
+        0
+      ],
+      "expression": "min(a, c)"
+    }
+  },
+  "55:5": {
+    "_meta": {
+      "title": "apply downscale"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "55:3",
+        0
+      ],
+      "on_true": [
+        "55:4",
+        0
+      ],
+      "switch": [
+        "16",
+        0
+      ]
+    }
+  },
+  "56": {
+    "_meta": {
+      "title": "Use Reference Image 2"
+    },
+    "class_type": "PrimitiveBoolean",
+    "inputs": {
+      "value": true
+    }
+  },
+  "57": {
+    "_meta": {
+      "title": "Ref 2 on/off switch"
+    },
+    "class_type": "ComfySwitchNode",
+    "inputs": {
+      "on_false": [
+        "27",
+        0
+      ],
+      "on_true": [
+        "37",
+        0
+      ],
+      "switch": [
+        "56",
+        0
+      ]
+    }
+  }
+}

serverless/client/qwen_edit_async.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""Call the qwen-edit-turbo RunPod serverless endpoint ASYNCHRONOUSLY (/run).
+
+Standalone: python 3.8+, stdlib only. Submits the job, then either polls until
+done (default) or exits immediately with the job id (--no-wait) so you can
+collect later with --job-id.
+
+    # submit and wait
+    python qwen_edit_async.py --api-key $RUNPOD_API_KEY \
+        --image person.jpg --ref-image outfit.png \
+        --prompt "put the outfit from the second image on the person"
+
+    # fire-and-forget, collect later
+    python qwen_edit_async.py ... --no-wait          # prints JOB_ID
+    python qwen_edit_async.py --api-key $RUNPOD_API_KEY --job-id JOB_ID
+
+Arguments are identical to qwen_edit_sync.py, plus:
+    --no-wait        submit only; print the job id and exit
+    --job-id ID      skip submission; poll/collect an existing job
+    --poll SECONDS   poll interval (default 3)
+    --cancel ID      cancel a queued/running job and exit
+"""
+import argparse
+import base64
+import json
+import os
+import pathlib
+import sys
+import time
+import urllib.error
+import urllib.request
+
+DEFAULT_ENDPOINT = "dom5lwr0o5wq6u"
+TERMINAL = ("COMPLETED", "FAILED", "CANCELLED", "TIMED_OUT")
+
+
+def api(args, method, path, payload=None, timeout=90):
+    req = urllib.request.Request(
+        f"https://api.runpod.ai/v2/{args.endpoint_id}/{path}", method=method,
+        data=json.dumps(payload).encode() if payload is not None else None,
+        headers={"Content-Type": "application/json",
+                 "Authorization": f"Bearer {args.api_key}"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            return json.load(r)
+    except urllib.error.HTTPError as e:
+        sys.exit(f"ERROR: HTTP {e.code} on /{path}: {e.read().decode(errors='replace')[:2000]}")
+
+
+def build_input(args):
+    images, params = [], {"prompt": args.prompt, "mode": args.mode}
+    images.append({"name": os.path.basename(args.image),
+                   "image": base64.b64encode(open(args.image, "rb").read()).decode()})
+    if args.ref_image:
+        images.append({"name": os.path.basename(args.ref_image),
+                       "image": base64.b64encode(open(args.ref_image, "rb").read()).decode()})
+    if args.seed is not None:
+        params["seed"] = args.seed
+    for name in ("input_max_dim", "ref_max_dim", "output_max_dim"):
+        v = getattr(args, name)
+        if v is not None:
+            params[name] = v
+    if args.lora_skin_fix:
+        params["lora_skin_fix"] = True
+        params["lora_skin_fix_strength"] = args.lora_skin_fix_strength
+    if args.lora_amateur:
+        params["lora_amateur"] = True
+        params["lora_amateur_strength"] = args.lora_amateur_strength
+
+    payload = {"images": images, "params": params}
+    if args.workflow:
+        payload["workflow"] = args.workflow
+    if args.workflow_json:
+        payload["workflow_json"] = json.load(open(args.workflow_json))
+    overrides = {}
+    for s in args.set or []:
+        k, v = s.split("=", 1)
+        try:
+            overrides[k] = json.loads(v)
+        except json.JSONDecodeError:
+            overrides[k] = v
+    if overrides:
+        payload["set"] = overrides
+    return payload
+
+
+def save_outputs(output, out_dir):
+    out_dir = pathlib.Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    saved = []
+    for i, img in enumerate(output.get("images", [])):
+        p = out_dir / f"{int(time.time())}-{i}-{img['filename']}"
+        p.write_bytes(base64.b64decode(img["data"]))
+        saved.append(str(p))
+    return saved
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--api-key", default=os.environ.get("RUNPOD_API_KEY"))
+    ap.add_argument("--endpoint-id", default=DEFAULT_ENDPOINT)
+    ap.add_argument("--image")
+    ap.add_argument("--ref-image")
+    ap.add_argument("--prompt")
+    ap.add_argument("--mode", default="turbo-8", choices=["turbo-4", "turbo-8", "quality"])
+    ap.add_argument("--seed", type=int)
+    ap.add_argument("--input-max-dim", type=int)
+    ap.add_argument("--ref-max-dim", type=int)
+    ap.add_argument("--output-max-dim", type=int)
+    ap.add_argument("--lora-skin-fix", action="store_true")
+    ap.add_argument("--lora-skin-fix-strength", type=float, default=1.0)
+    ap.add_argument("--lora-amateur", action="store_true")
+    ap.add_argument("--lora-amateur-strength", type=float, default=1.0)
+    ap.add_argument("--workflow")
+    ap.add_argument("--set", action="append", metavar="NODE.INPUT=VALUE")
+    ap.add_argument("--workflow-json")
+    ap.add_argument("--out", default=".")
+    ap.add_argument("--timeout", type=float, default=1800)
+    ap.add_argument("--poll", type=float, default=3.0)
+    ap.add_argument("--no-wait", action="store_true")
+    ap.add_argument("--job-id")
+    ap.add_argument("--cancel", metavar="JOB_ID")
+    args = ap.parse_args()
+    if not args.api_key:
+        sys.exit("ERROR: pass --api-key or set RUNPOD_API_KEY")
+
+    if args.cancel:
+        print(json.dumps(api(args, "POST", f"cancel/{args.cancel}"), indent=2))
+        return
+
+    if args.job_id:
+        job_id = args.job_id
+    else:
+        if not args.image or not args.prompt:
+            sys.exit("ERROR: --image and --prompt are required to submit a job")
+        job = api(args, "POST", "run", {"input": build_input(args)})
+        job_id = job["id"]
+        print(f"# submitted job {job_id}", file=sys.stderr)
+        if args.no_wait:
+            print(job_id)
+            return
+
+    t0 = time.monotonic()
+    while True:
+        result = api(args, "GET", f"status/{job_id}")
+        status = result.get("status")
+        if status in TERMINAL:
+            break
+        if time.monotonic() - t0 > args.timeout:
+            sys.exit(f"ERROR: timed out after {args.timeout}s (last status {status}); "
+                     f"job {job_id} is still yours to collect with --job-id")
+        print(f"# {status} ... {time.monotonic()-t0:.0f}s", file=sys.stderr)
+        time.sleep(args.poll)
+
+    if status != "COMPLETED":
+        sys.exit(f"ERROR: {json.dumps(result, indent=2)[:3000]}")
+    output = result["output"]
+    if "error" in output:
+        sys.exit(f"ERROR from handler: {output['error']}")
+    for p in save_outputs(output, args.out):
+        print(p)
+    print(f"# seed={output.get('seed')} delay={result.get('delayTime')}ms "
+          f"exec={result.get('executionTime')}ms", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()

serverless/client/qwen_edit_sync.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Call the qwen-edit-turbo RunPod serverless endpoint SYNCHRONOUSLY (/runsync).
+
+Standalone: python 3.8+, stdlib only. Blocks until the edit is done (typically
+40-65 s warm), saves the returned image(s), prints their paths.
+
+    python qwen_edit_sync.py \
+        --api-key $RUNPOD_API_KEY \
+        --image person.jpg --ref-image outfit.png \
+        --prompt "put the outfit from the second image on the person" \
+        --mode turbo-8 --out ./results
+
+All arguments:
+    --api-key        RunPod API key (or set RUNPOD_API_KEY env var)
+    --endpoint-id    RunPod endpoint id       (default: dom5lwr0o5wq6u)
+    --image          main input image (required)
+    --ref-image      optional reference image (outfit/style source)
+    --prompt         edit instruction (required)
+    --mode           turbo-4 | turbo-8 | quality        (default turbo-8)
+    --seed           integer seed (default: random; used seed is printed)
+    --input-max-dim  max size of the main image fed to the model (default 2048)
+    --ref-max-dim    max size of the reference image (default 1024)
+    --output-max-dim upscale target for the result (default 2560)
+    --lora-skin-fix / --lora-amateur      enable the optional loras
+    --lora-skin-fix-strength / --lora-amateur-strength   (default 1.0)
+    --workflow       which baked workflow to run (default qwen-edit-turbo-v4)
+    --set NODE.INPUT=VALUE   raw graph override, repeatable (advanced)
+    --workflow-json FILE     full API-format graph passthrough (advanced)
+    --out            output directory (default .)
+    --timeout        max seconds to wait (default 600)
+"""
+import argparse
+import base64
+import json
+import os
+import pathlib
+import sys
+import time
+import urllib.error
+import urllib.request
+
+DEFAULT_ENDPOINT = "dom5lwr0o5wq6u"
+
+
+def build_input(args):
+    images, params = [], {"prompt": args.prompt, "mode": args.mode}
+    images.append({"name": os.path.basename(args.image),
+                   "image": base64.b64encode(open(args.image, "rb").read()).decode()})
+    if args.ref_image:
+        images.append({"name": os.path.basename(args.ref_image),
+                       "image": base64.b64encode(open(args.ref_image, "rb").read()).decode()})
+    if args.seed is not None:
+        params["seed"] = args.seed
+    for cli, param in [("input_max_dim", "input_max_dim"), ("ref_max_dim", "ref_max_dim"),
+                       ("output_max_dim", "output_max_dim")]:
+        v = getattr(args, cli)
+        if v is not None:
+            params[param] = v
+    if args.lora_skin_fix:
+        params["lora_skin_fix"] = True
+        params["lora_skin_fix_strength"] = args.lora_skin_fix_strength
+    if args.lora_amateur:
+        params["lora_amateur"] = True
+        params["lora_amateur_strength"] = args.lora_amateur_strength
+
+    payload = {"images": images, "params": params}
+    if args.workflow:
+        payload["workflow"] = args.workflow
+    if args.workflow_json:
+        payload["workflow_json"] = json.load(open(args.workflow_json))
+    overrides = {}
+    for s in args.set or []:
+        k, v = s.split("=", 1)
+        try:
+            overrides[k] = json.loads(v)
+        except json.JSONDecodeError:
+            overrides[k] = v
+    if overrides:
+        payload["set"] = overrides
+    return payload
+
+
+def save_outputs(output, out_dir):
+    out_dir = pathlib.Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    saved = []
+    for i, img in enumerate(output.get("images", [])):
+        p = out_dir / f"{int(time.time())}-{i}-{img['filename']}"
+        p.write_bytes(base64.b64decode(img["data"]))
+        saved.append(str(p))
+    return saved
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--api-key", default=os.environ.get("RUNPOD_API_KEY"))
+    ap.add_argument("--endpoint-id", default=DEFAULT_ENDPOINT)
+    ap.add_argument("--image", required=True)
+    ap.add_argument("--ref-image")
+    ap.add_argument("--prompt", required=True)
+    ap.add_argument("--mode", default="turbo-8", choices=["turbo-4", "turbo-8", "quality"])
+    ap.add_argument("--seed", type=int)
+    ap.add_argument("--input-max-dim", type=int)
+    ap.add_argument("--ref-max-dim", type=int)
+    ap.add_argument("--output-max-dim", type=int)
+    ap.add_argument("--lora-skin-fix", action="store_true")
+    ap.add_argument("--lora-skin-fix-strength", type=float, default=1.0)
+    ap.add_argument("--lora-amateur", action="store_true")
+    ap.add_argument("--lora-amateur-strength", type=float, default=1.0)
+    ap.add_argument("--workflow")
+    ap.add_argument("--set", action="append", metavar="NODE.INPUT=VALUE")
+    ap.add_argument("--workflow-json")
+    ap.add_argument("--out", default=".")
+    ap.add_argument("--timeout", type=float, default=600)
+    args = ap.parse_args()
+    if not args.api_key:
+        sys.exit("ERROR: pass --api-key or set RUNPOD_API_KEY")
+
+    req = urllib.request.Request(
+        f"https://api.runpod.ai/v2/{args.endpoint_id}/runsync",
+        data=json.dumps({"input": build_input(args)}).encode(),
+        headers={"Content-Type": "application/json",
+                 "Authorization": f"Bearer {args.api_key}"})
+    t0 = time.monotonic()
+    try:
+        with urllib.request.urlopen(req, timeout=args.timeout) as r:
+            result = json.load(r)
+    except urllib.error.HTTPError as e:
+        sys.exit(f"ERROR: HTTP {e.code}: {e.read().decode(errors='replace')[:2000]}")
+
+    if result.get("status") != "COMPLETED":
+        sys.exit(f"ERROR: {json.dumps(result, indent=2)[:3000]}")
+    output = result["output"]
+    if "error" in output:
+        sys.exit(f"ERROR from handler: {output['error']}")
+    for p in save_outputs(output, args.out):
+        print(p)
+    print(f"# seed={output.get('seed')} wall={time.monotonic()-t0:.1f}s "
+          f"delay={result.get('delayTime')}ms exec={result.get('executionTime')}ms",
+          file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()