feat(modes): A2V + Lipsync + Keyframe + Style parameterize_fn

modes.py

@@ -79,6 +79,46 @@ I2V_NODE_FPS = 5445
 I2V_NODE_CLIP_LENGTH = 196
 I2V_NODE_IMAGE = 149              # LoadImage "Load Image1" — wv[0] = filename
 
+# Mode-specific media nodes — captured from workflows/{a2v,lipsync,keyframe,style}.json
+# on 2026-04-30. All four templates contain the same node ids for these inputs (the
+# Loaders group is shared across modes); only a subset is wired into each mode's
+# pipeline.
+#
+# VHS_LoadAudioUpload and VHS_LoadVideo carry dict-style widgets_values keyed by
+# "audio"/"video". The current set_input helper is list-indexed; passing
+# widget_index=0 against a dict adds a numeric "0" key without replacing the
+# canonical "audio"/"video" entry. The runtime file-path swap is therefore not
+# yet wired — Task 12 only validates the patch tuple set. Real path injection
+# lands when backend.py grows file-staging in Task 17.
+
+A2V_NODE_PROMPT = 5536
+A2V_NODE_NEG_PROMPT = 5537
+A2V_NODE_WIDTH = 5383
+A2V_NODE_HEIGHT = 5382
+A2V_NODE_FPS = 5445
+A2V_NODE_CLIP_LENGTH = 196
+A2V_NODE_AUDIO = 5400             # VHS_LoadAudioUpload — dict wv keyed by "audio"
+
+LIPSYNC_NODE_PROMPT = 5536
+LIPSYNC_NODE_NEG_PROMPT = 5537
+LIPSYNC_NODE_FPS = 5445
+LIPSYNC_NODE_CLIP_LENGTH = 196
+LIPSYNC_NODE_IMAGE = 149          # LoadImage "Load Image1" — wv[0] = filename
+LIPSYNC_NODE_AUDIO = 5400         # VHS_LoadAudioUpload — dict wv keyed by "audio"
+
+KEYFRAME_NODE_PROMPT = 5536
+KEYFRAME_NODE_NEG_PROMPT = 5537
+KEYFRAME_NODE_FPS = 5445
+KEYFRAME_NODE_CLIP_LENGTH = 196
+KEYFRAME_NODE_FIRST_FRAME = 149   # LoadImage "Load Image1" — wv[0] = filename
+KEYFRAME_NODE_LAST_FRAME = 5437   # LoadImage "Load Image2" — wv[0] = filename
+
+STYLE_NODE_PROMPT = 5536
+STYLE_NODE_NEG_PROMPT = 5537
+STYLE_NODE_FPS = 5445
+STYLE_NODE_CLIP_LENGTH = 196
+STYLE_NODE_INPUT_VIDEO = 5444     # VHS_LoadVideo — dict wv keyed by "video"
+
 
 def _frames_to_seconds(frames: int, fps: int) -> int:
     """Convert (frames, fps) to integer seconds for the mxSlider clip-length widget.
@@ -115,6 +155,50 @@ def _i2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
     ]
 
 
+def _a2v_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (A2V_NODE_PROMPT, 0, inp["prompt"]),
+        (A2V_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (A2V_NODE_AUDIO, 0, inp["audio"]),
+        (A2V_NODE_WIDTH, 0, int(inp["width"])),
+        (A2V_NODE_HEIGHT, 0, int(inp["height"])),
+        (A2V_NODE_FPS, 0, int(inp["fps"])),
+        (A2V_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
+def _lipsync_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (LIPSYNC_NODE_PROMPT, 0, inp["prompt"]),
+        (LIPSYNC_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (LIPSYNC_NODE_IMAGE, 0, inp["image"]),
+        (LIPSYNC_NODE_AUDIO, 0, inp["audio"]),
+        (LIPSYNC_NODE_FPS, 0, int(inp["fps"])),
+        (LIPSYNC_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
+def _keyframe_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (KEYFRAME_NODE_PROMPT, 0, inp["prompt"]),
+        (KEYFRAME_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (KEYFRAME_NODE_FIRST_FRAME, 0, inp["first_frame"]),
+        (KEYFRAME_NODE_LAST_FRAME, 0, inp["last_frame"]),
+        (KEYFRAME_NODE_FPS, 0, int(inp["fps"])),
+        (KEYFRAME_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
+def _style_parameterize(inp: dict[str, Any]) -> list[Patch]:
+    return [
+        (STYLE_NODE_PROMPT, 0, inp["prompt"]),
+        (STYLE_NODE_NEG_PROMPT, 0, inp.get("negative_prompt", "")),
+        (STYLE_NODE_INPUT_VIDEO, 0, inp["input_video"]),
+        (STYLE_NODE_FPS, 0, int(inp["fps"])),
+        (STYLE_NODE_CLIP_LENGTH, 0, _frames_to_seconds(int(inp["frames"]), int(inp["fps"]))),
+    ]
+
+
 _T2V_STAGES = [
     Stage("Encode prompt", 5),
     Stage("Diffusion (Stage 1)", 60),
@@ -132,6 +216,43 @@ _I2V_STAGES = [
     Stage("Decode video", 10),
 ]
 
+_A2V_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Encode audio", 5),
+    Stage("Diffusion (Stage 1)", 55),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 18),
+    Stage("Decode video", 10),
+]
+
+_LIPSYNC_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Encode image", 3),
+    Stage("Encode audio", 5),
+    Stage("Diffusion (Stage 1)", 52),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 18),
+    Stage("Decode video", 10),
+]
+
+_KEYFRAME_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Encode keyframes", 5),
+    Stage("Diffusion (Stage 1)", 55),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 18),
+    Stage("Decode video", 10),
+]
+
+_STYLE_STAGES = [
+    Stage("Encode prompt", 5),
+    Stage("Decode source video", 5),
+    Stage("Diffusion (Stage 1)", 55),
+    Stage("Spatial upscale", 7),
+    Stage("Diffusion (Stage 2)", 18),
+    Stage("Decode video", 10),
+]
+
 MODE_REGISTRY["t2v"] = Mode(
     name="t2v",
     label="Text → Video",
@@ -146,3 +267,31 @@ MODE_REGISTRY["i2v"] = Mode(
     parameterize_fn=_i2v_parameterize,
     stage_map=_I2V_STAGES,
 )
+MODE_REGISTRY["a2v"] = Mode(
+    name="a2v",
+    label="Audio → Video",
+    icon="🎵",
+    parameterize_fn=_a2v_parameterize,
+    stage_map=_A2V_STAGES,
+)
+MODE_REGISTRY["lipsync"] = Mode(
+    name="lipsync",
+    label="Lipsync",
+    icon="👄",
+    parameterize_fn=_lipsync_parameterize,
+    stage_map=_LIPSYNC_STAGES,
+)
+MODE_REGISTRY["keyframe"] = Mode(
+    name="keyframe",
+    label="Keyframe → Video",
+    icon="🎞",
+    parameterize_fn=_keyframe_parameterize,
+    stage_map=_KEYFRAME_STAGES,
+)
+MODE_REGISTRY["style"] = Mode(
+    name="style",
+    label="Style Transfer",
+    icon="🎨",
+    parameterize_fn=_style_parameterize,
+    stage_map=_STYLE_STAGES,
+)

tests/test_modes.py

@@ -46,3 +46,56 @@ 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
+
+
+@pytest.mark.parametrize("mode_name", ["a2v", "lipsync", "keyframe", "style"])
+def test_remaining_modes_parameterize_validates(mode_name, canonical_inputs):
+    inputs = canonical_inputs[mode_name]
+    mode = modes.MODE_REGISTRY[mode_name]
+    patches = mode.parameterize_fn(inputs)
+    assert len(patches) > 0
+
+    wf = workflow.load_template(mode_name)
+    for patch in patches:
+        workflow.set_input(wf, *patch)
+    workflow.validate(wf)
+
+
+def test_a2v_parameterize_passes_audio_path(canonical_inputs):
+    patches = modes.MODE_REGISTRY["a2v"].parameterize_fn(canonical_inputs["a2v"])
+    assert canonical_inputs["a2v"]["audio"] in [p[2] for p in patches]
+
+
+def test_lipsync_parameterize_passes_image_and_audio(canonical_inputs):
+    patches = modes.MODE_REGISTRY["lipsync"].parameterize_fn(canonical_inputs["lipsync"])
+    values = [p[2] for p in patches]
+    assert canonical_inputs["lipsync"]["image"] in values
+    assert canonical_inputs["lipsync"]["audio"] in values
+
+
+def test_keyframe_parameterize_passes_two_frames(canonical_inputs):
+    patches = modes.MODE_REGISTRY["keyframe"].parameterize_fn(canonical_inputs["keyframe"])
+    values = [p[2] for p in patches]
+    assert canonical_inputs["keyframe"]["first_frame"] in values
+    assert canonical_inputs["keyframe"]["last_frame"] in values
+
+
+def test_style_parameterize_passes_input_video(canonical_inputs):
+    patches = modes.MODE_REGISTRY["style"].parameterize_fn(canonical_inputs["style"])
+    assert canonical_inputs["style"]["input_video"] in [p[2] for p in patches]
+
+
+def test_mode_registry_has_all_six_keys():
+    """All six modes are in the registry now."""
+    assert set(modes.MODE_REGISTRY.keys()) == {
+        "t2v", "a2v", "i2v", "lipsync", "keyframe", "style",
+    }
+
+
+def test_each_mode_has_required_attributes():
+    for name, mode in modes.MODE_REGISTRY.items():
+        assert mode.name == name
+        assert mode.label  # non-empty
+        assert mode.icon  # non-empty
+        assert callable(mode.parameterize_fn)
+        assert isinstance(mode.stage_map, list) and len(mode.stage_map) > 0