Download nodes/ComfyUI-H3-Multishot/rift_engine_script.py from Russ1on/MiniMax-H3-Multishot-Workflow: direct link, hf CLI and curl.
- Browser
- Download file 7.53 kB
-
https://huggingface.co/Russ1on/MiniMax-H3-Multishot-Workflow/resolve/main/nodes/ComfyUI-H3-Multishot/rift_engine_script.py
- Command line
-
hf download hf://Russ1on/MiniMax-H3-Multishot-Workflow/nodes/ComfyUI-H3-Multishot/rift_engine_script.py
-
curl -L -o rift_engine_script.py https://huggingface.co/Russ1on/MiniMax-H3-Multishot-Workflow/resolve/main/nodes/ComfyUI-H3-Multishot/rift_engine_script.py
7.53 kB
| """One script, two engines. | |
| H3 and LTX-2.5 want opposite things from a multi-shot script. | |
| H3 chains N separate generations. Each block is one generation, and the scene | |
| description has to be restated WORD FOR WORD in every block or the room drifts | |
| - continuity comes from the text agreeing with itself plus the latent pin. | |
| LTX-2.5 generates all the shots in ONE pass and finds the cuts itself, holding | |
| character, environment, lighting and voice across them natively. Feeding it ten | |
| verbatim repetitions of the same paragraph does not help it and buries the part | |
| that changes. | |
| This node takes the H3 form - the one a writer actually maintains - and emits | |
| both. The scene block is found as the longest common prefix across the blocks, | |
| which is exactly what "restate it verbatim" produces, and is stated once for | |
| LTX with the per-shot remainder following as a beat list. | |
| """ | |
| import re | |
| # Match the SAMPLER's rule verbatim (h3_multishot_utils._parse_script, and | |
| # h3_episode_tools._BLOCK_SPLIT). A literal "\n---\n" split was stricter than | |
| # every other splitter in the pack, and its failure mode is silent: it returns | |
| # ONE block, so an 8-shot script becomes a 1-shot render with no diagnostic. | |
| # Measured on this box 2026-08-17: | |
| # unix 3 dashes literal -> 2 blocks sampler regex -> 2 | |
| # CRLF literal -> 1 block sampler regex -> 2 <- collapse | |
| # trailing space literal -> 1 block sampler regex -> 2 <- collapse | |
| # CRLF is the default for anything edited in Notepad on Windows, so this was | |
| # live, not theoretical. | |
| _SEP_RE = re.compile(r"(?m)^---\s*$") | |
| def _blocks(script): | |
| # The prompt writer emits {"prompts": [...]} - accept that directly so | |
| # the writer can feed this node without a format hop (Joy-LTX 2.5 canvas). | |
| s = (script or "").strip() | |
| if s.startswith("{"): | |
| try: | |
| import json as _json | |
| d = _json.loads(s) | |
| arr = d.get("prompts") if isinstance(d, dict) else None | |
| if isinstance(arr, list) and arr: | |
| return [str(x).strip() for x in arr if str(x).strip()] | |
| except ValueError: | |
| pass | |
| parts = [b.strip() for b in _SEP_RE.split(script or "")] | |
| return [b for b in parts if b] | |
| def _common_prefix(blocks, sentence_boundary=True): | |
| """Longest text shared by the start of every block. | |
| sentence_boundary=True cuts back to the end of a sentence, which is what | |
| the SCENE block wants - otherwise the LTX prompt opens with half a sentence | |
| and the per-shot beats start with the other half. | |
| It is wrong for the per-shot HOLD preamble, which by design ends mid | |
| sentence on "... says," - cutting back to a full stop finds none and | |
| silently returns nothing, leaving the preamble to repeat once per shot. | |
| """ | |
| if len(blocks) < 2: | |
| return "" | |
| pre = blocks[0] | |
| for b in blocks[1:]: | |
| n = min(len(pre), len(b)) | |
| i = 0 | |
| while i < n and pre[i] == b[i]: | |
| i += 1 | |
| pre = pre[:i] | |
| if not pre: | |
| return "" | |
| if not sentence_boundary: | |
| return pre.strip() | |
| cut = max(pre.rfind(". "), pre.rfind('." '), pre.rfind("? "), pre.rfind("! ")) | |
| return pre[:cut + 1].strip() if cut > 40 else "" | |
| class RiftEngineScript: | |
| def INPUT_TYPES(cls): | |
| return { | |
| "required": { | |
| "script": ("STRING", { | |
| "multiline": True, "default": "", | |
| "tooltip": "The H3 form: shots separated by --- on its own " | |
| "line, with the scene block restated verbatim in " | |
| "each. Write it once, here, for either engine."}), | |
| }, | |
| "optional": { | |
| "ltx_shot_label": ("STRING", { | |
| "default": "Then, without moving the camera,", | |
| "tooltip": "Joins the per-shot beats in the LTX prompt. " | |
| "LTX-2.5 decides its own cut points, so this is " | |
| "how you tell it whether the shots are one " | |
| "continuous take or separate setups. For hard " | |
| "cuts try 'Cut to:'."}), | |
| }, | |
| } | |
| RETURN_TYPES = ("STRING", "STRING", "INT") | |
| RETURN_NAMES = ("h3_script", "ltx_prompt", "shot_count") | |
| FUNCTION = "split" | |
| CATEGORY = "H3/script" | |
| def split(self, script, ltx_shot_label="Then, without moving the camera,"): | |
| blocks = _blocks(script) | |
| if not blocks: | |
| return ("", "", 0) | |
| scene = _common_prefix(blocks) | |
| if scene: | |
| tails = [b[len(scene):].strip() if b.startswith(scene) else b | |
| for b in blocks] | |
| # Second pass: shots 2..N usually share a "hold" preamble too - | |
| # "She sits exactly as she was, ... and the woman says," - which is | |
| # not a prefix of ALL blocks because shot 1 opens differently. Left | |
| # in, it repeats once per shot and buries the beats. | |
| hold = (_common_prefix(tails[1:], sentence_boundary=False) | |
| if len(tails) > 2 else "") | |
| # The shared preamble runs right up to the opening quote of the | |
| # line - every block has one there, so the raw prefix swallows it | |
| # and each beat loses the quote that opens its dialogue. | |
| hold = hold.rstrip("“‘\"' \t") | |
| if len(hold) < 25: # too short to be a real preamble | |
| hold = "" | |
| if hold: | |
| tails = [tails[0]] + [ | |
| (t[len(hold):].strip() if t.startswith(hold) else t) | |
| for t in tails[1:]] | |
| label = ltx_shot_label.strip() | |
| joined = tails[0] | |
| for t in tails[1:]: | |
| if label: | |
| # The beat continues the joining clause, so it must not | |
| # arrive capitalised mid-sentence - UNLESS it opens with | |
| # dialogue, where the capital belongs to the line and | |
| # lowercasing it corrupts what the character says. | |
| if (t[:1].isupper() and not t[:2].isupper() | |
| and not t.startswith(("“", '"', "‘", "'"))): | |
| t = t[0].lower() + t[1:] | |
| joined += " " + label + " " + t | |
| else: | |
| joined += " " + t | |
| ltx = scene + (" " + hold if hold else "") + " " + joined | |
| else: | |
| # no verbatim scene block - the writer is not using the H3 | |
| # convention, so pass the blocks through in order rather than | |
| # inventing structure that is not there | |
| label = ltx_shot_label.strip() | |
| ltx = (" " + label + " ").join(blocks) if label else " ".join(blocks) | |
| print("[H3 Multishot] EngineScript: %d shot(s); scene block %s; " | |
| "H3 %d chars, LTX %d chars" | |
| % (len(blocks), | |
| "%d chars, stated once for LTX" % len(scene) if scene | |
| else "not detected (blocks passed through)", | |
| len(script), len(ltx)), flush=True) | |
| return (script, ltx, len(blocks)) | |
| NODE_CLASS_MAPPINGS = {"RiftEngineScript": RiftEngineScript} | |
| NODE_DISPLAY_NAME_MAPPINGS = { | |
| "RiftEngineScript": "Script for Two Engines (H3 + LTX-2.5)"} | |