feat(modes): T2V + I2V parameterize_fn with stage maps

modes.py

@@ -41,3 +41,108 @@ class Mode:
 
 # Filled in by tasks 11–12.
 MODE_REGISTRY: dict[str, Mode] = {}
+
+
+# ---------------------------------------------------------------------------
+# Node-id constants — captured from workflows/{t2v,i2v}.json on 2026-04-30.
+#
+# The master workflow uses rgthree's GetNode/SetNode for indirection. SetNodes
+# named "pos"/"neg" expose the *outputs* of CLIPTextEncode, not the prompt
+# strings. So the canonical place to set the prompt text is the CLIPTextEncode
+# node itself.
+#
+# Width/Height/FPS are INTConstant nodes whose values feed downstream Set_*
+# variables.  Clip length comes from a mxSlider (in seconds, then multiplied by
+# FPS via a MathExpression to compute frames).  No SetNode for "noise"/seed
+# survived the extraction, so seed is intentionally NOT patched here — the
+# template's hard-coded value is used until we wire RandomNoise injection in
+# Task 12+.
+#
+# LoRA rows live inside a single Power Lora Loader (rgthree) node whose
+# widgets_values is a list of dicts. Patching a specific row requires knowing
+# the index, and the canonical mapping (camera_lora value -> row index) belongs
+# in models.py once camera-LoRA selection lands. Deferred for now.
+# ---------------------------------------------------------------------------
+
+T2V_NODE_PROMPT = 5536            # CLIPTextEncode positive — wv[0] = prompt
+T2V_NODE_NEG_PROMPT = 5537        # CLIPTextEncode negative — wv[0] = negative prompt
+T2V_NODE_WIDTH = 5383             # INTConstant "Width" — wv[0]
+T2V_NODE_HEIGHT = 5382            # INTConstant "Height" — wv[0]
+T2V_NODE_FPS = 5445               # INTConstant "FPS" — wv[0]
+T2V_NODE_CLIP_LENGTH = 196        # mxSlider "Clip Length ( in seconds )" — wv[0]
+
+I2V_NODE_PROMPT = 5536
+I2V_NODE_NEG_PROMPT = 5537
+I2V_NODE_WIDTH = 5383
+I2V_NODE_HEIGHT = 5382
+I2V_NODE_FPS = 5445
+I2V_NODE_CLIP_LENGTH = 196
+I2V_NODE_IMAGE = 149              # LoadImage "Load Image1" — wv[0] = filename
+
+
+def _frames_to_seconds(frames: int, fps: int) -> int:
+    """Convert (frames, fps) to integer seconds for the mxSlider clip-length widget.
+
+    The downstream MathExpression is `a*b+1` (a=seconds, b=fps -> total frames),
+    so for a target frame count F at fps R we need seconds = ceil((F - 1) / R).
+    Round up so the slider is never short of the requested frames.
+    """
+    if fps <= 0:
+        return 1
+    return max(1, -(-(frames - 1) // fps))
+
+
+def _t2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (T2V_NODE_PROMPT, 0, inp["prompt"]),
+        (T2V_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (T2V_NODE_WIDTH, 0, int(inp["width"])),
+        (T2V_NODE_HEIGHT, 0, int(inp["height"])),
+        (T2V_NODE_FPS, 0, int(inp["fps"])),
+        (T2V_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
+def _i2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (I2V_NODE_PROMPT, 0, inp["prompt"]),
+        (I2V_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (I2V_NODE_IMAGE, 0, inp["image"]),
+        (I2V_NODE_WIDTH, 0, int(inp["width"])),
+        (I2V_NODE_HEIGHT, 0, int(inp["height"])),
+        (I2V_NODE_FPS, 0, int(inp["fps"])),
+        (I2V_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
+_T2V_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Diffusion (Stage 1)", 60),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 18),
+    Stage("Decode video", 10),
+]
+
+_I2V_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Encode image", 3),
+    Stage("Diffusion (Stage 1)", 55),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 20),
+    Stage("Decode video", 10),
+]
+
+MODE_REGISTRY["t2v"] = Mode(
+    name="t2v",
+    label="Text → Video",
+    icon="📝",
+    parameterize_fn=_t2v_parameterize,
+    stage_map=_T2V_STAGES,
+)
+MODE_REGISTRY["i2v"] = Mode(
+    name="i2v",
+    label="Image → Video",
+    icon="🖼",
+    parameterize_fn=_i2v_parameterize,
+    stage_map=_I2V_STAGES,
+)

tests/test_modes.py

@@ -2,6 +2,7 @@
 import pytest
 
 import modes
+import workflow
 
 
 def test_mode_dataclass_has_expected_fields():
@@ -14,3 +15,34 @@ def test_mode_dataclass_has_expected_fields():
 def test_mode_registry_is_a_dict():
     """MODE_REGISTRY exists and is a dict (entries added in Tasks 11–12)."""
     assert isinstance(modes.MODE_REGISTRY, dict)
+
+
+def test_t2v_parameterize_produces_valid_patches(canonical_inputs):
+    inputs = canonical_inputs["t2v"]
+    mode = modes.MODE_REGISTRY["t2v"]
+    patches = mode.parameterize_fn(inputs)
+
+    # All patches must be (node_id: int, widget_index: int, value: Any)
+    for node_id, widget_index, value in patches:
+        assert isinstance(node_id, int)
+        assert isinstance(widget_index, int)
+
+    # Apply patches to a real template; result must validate.
+    wf = workflow.load_template("t2v")
+    for patch in patches:
+        workflow.set_input(wf, *patch)
+    workflow.validate(wf)
+
+
+def test_i2v_parameterize_uses_image_path(canonical_inputs):
+    inputs = canonical_inputs["i2v"]
+    mode = modes.MODE_REGISTRY["i2v"]
+    patches = mode.parameterize_fn(inputs)
+    values = [p[2] for p in patches]
+    assert inputs["image"] in values
+
+
+def test_t2v_and_i2v_in_registry():
+    """T2V and I2V exist in MODE_REGISTRY (full completeness in Task 12)."""
+    assert "t2v" in modes.MODE_REGISTRY
+    assert "i2v" in modes.MODE_REGISTRY