Files

593 lines
19 KiB
Python

from __future__ import annotations
import json
from pathlib import Path
import shutil
import subprocess
import sys
from types import ModuleType
import pytest
import torch
from ComfyUI_H3_Continuum_Join import nodes as root_nodes
from ComfyUI_H3_Continuum_Join.reference import (
REFERENCE_SIZE_MATCH_OUTPUT,
prepare_reference_assets,
validate_reference_prompts,
)
from ComfyUI_H3_Continuum_Join.v2.sequence import _terminal_flf_merge_enabled
from ComfyUI_H3_Continuum_Join.v3.driving_nodes import H3ContinuumSamplerV37
from ComfyUI_H3_Continuum_Join.v3.easy_nodes import (
EASY_ASPECT_AUTO,
EASY_ASPECT_LANDSCAPE,
EASY_ASPECT_PORTRAIT,
EASY_ASPECT_SQUARE,
EASY_PRESET_BALANCED,
EASY_PRESET_CUSTOM,
EASY_PRESET_DRAFT,
EASY_PRESET_NATIVE,
EASY_REFERENCES_TYPE,
EASY_SEED_MODE_RANDOMIZE,
H3ContinuumEasyReferences,
H3ContinuumEasyV38,
NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS,
make_easy_references,
resolve_easy_duration,
resolve_easy_references,
resolve_easy_resolution,
)
ROOT = Path(__file__).resolve().parents[1]
EASY_JS = ROOT / "web" / "easy_v38.js"
class _Image:
def __init__(self, height: int, width: int):
self.shape = (1, height, width, 3)
@pytest.mark.parametrize(
("duration", "chunks", "chunk_seconds"),
(
(4, 1, 4.0),
(10, 1, 10.0),
(15, 2, 7.5),
(20, 2, 10.0),
(30, 3, 10.0),
(160, 16, 10.0),
(480, 16, 30.0),
),
)
def test_duration_resolver_uses_approved_ten_second_policy(
duration,
chunks,
chunk_seconds,
):
plan = resolve_easy_duration(duration)
assert plan.duration_seconds == duration
assert plan.chunks == chunks
assert plan.chunk_seconds == chunk_seconds
assert plan.chunks * plan.chunk_seconds == duration
@pytest.mark.parametrize("duration", (3, 481, True, 10.5))
def test_duration_resolver_rejects_values_outside_integer_production_contract(duration):
with pytest.raises((TypeError, ValueError)):
resolve_easy_duration(duration)
def test_decimal_mp_presets_follow_first_image_aspect_and_32_pixel_grid():
first = _Image(1200, 900)
draft = resolve_easy_resolution(
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_DRAFT,
first_frame=first,
)
balanced = resolve_easy_resolution(
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_BALANCED,
first_frame=first,
)
assert (draft.width, draft.height) == (480, 640)
assert (balanced.width, balanced.height) == (672, 896)
assert draft.aspect_source == "First Image"
assert draft.width % 32 == draft.height % 32 == 0
assert balanced.width % 32 == balanced.height % 32 == 0
@pytest.mark.parametrize(
("aspect", "expected"),
(
(EASY_ASPECT_SQUARE, (768, 768)),
(EASY_ASPECT_LANDSCAPE, (1344, 768)),
(EASY_ASPECT_PORTRAIT, (768, 1344)),
),
)
def test_native_768_representative_dimensions(aspect, expected):
plan = resolve_easy_resolution(aspect=aspect, preset=EASY_PRESET_NATIVE)
assert (plan.width, plan.height) == expected
def test_native_768_preserves_extreme_aspect_by_prioritizing_long_edge_cap():
landscape = resolve_easy_resolution(
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_NATIVE,
first_frame=_Image(900, 2100),
)
portrait = resolve_easy_resolution(
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_NATIVE,
first_frame=_Image(2100, 900),
)
assert (landscape.width, landscape.height) == (1344, 576)
assert (portrait.width, portrait.height) == (576, 1344)
def test_auto_without_first_image_falls_back_to_landscape():
auto = resolve_easy_resolution(
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_DRAFT,
)
explicit = resolve_easy_resolution(
aspect=EASY_ASPECT_LANDSCAPE,
preset=EASY_PRESET_DRAFT,
)
assert (auto.width, auto.height) == (explicit.width, explicit.height)
assert auto.aspect_source == "Landscape 16:9 fallback"
def test_custom_mp_is_not_clamped_to_native_and_reports_diagnostics():
plan = resolve_easy_resolution(
aspect=EASY_ASPECT_SQUARE,
preset=EASY_PRESET_CUSTOM,
custom_mp=3.0,
)
assert plan.width > 768
assert plan.height > 768
assert len(plan.warnings) == 2
assert "Above Native 768" in plan.warnings[0]
assert "High Custom MP" in plan.warnings[1]
def test_easy_schema_keeps_driving_audio_optional_and_scheduler_out():
schema = H3ContinuumEasyV38.INPUT_TYPES()
required = schema["required"]
optional = schema["optional"]
assert tuple(required)[:5] == ("model", "clip", "video_vae", "sampler", "sigmas")
assert "scheduler" not in required
assert "audio_vae" not in required
assert optional["driving_audio"][0] == "AUDIO"
assert optional["driving_audio"][1]["display_name"] == "Driving Audio"
assert optional["audio_vae"][0] == "VAE"
assert optional["audio_vae"][1]["display_name"] == "Driving Audio VAE"
assert "first_frame" in optional
assert "last_frame" in optional
assert optional["references"][0] == EASY_REFERENCES_TYPE
assert not {
"driving_audio_vae",
"reference_audio_1",
"reference_audio_vae",
"reference_video_1",
"still_image_guide",
"timeline_video",
} & set(optional)
assert required["duration"][1]["default"] == 10
assert required["seed_mode"][1]["default"] == EASY_SEED_MODE_RANDOMIZE
assert required["run_storage"][1]["default"] == "Off"
assert required["prompt_text"][1]["multiline"] is True
def test_easy_node_is_registered_without_replacing_v37():
assert NODE_CLASS_MAPPINGS["H3ContinuumEasyReferences"] is (
H3ContinuumEasyReferences
)
assert NODE_DISPLAY_NAME_MAPPINGS["H3ContinuumEasyReferences"] == (
"H3 Continuum Easy References"
)
assert NODE_CLASS_MAPPINGS["H3ContinuumEasyV38"] is H3ContinuumEasyV38
assert NODE_DISPLAY_NAME_MAPPINGS["H3ContinuumEasyV38"] == (
"H3 Continuum Easy V3.8"
)
assert "H3ContinuumEasyV38" not in root_nodes.NODE_CLASS_MAPPINGS
assert "H3ContinuumSamplerV37" not in root_nodes.NODE_CLASS_MAPPINGS
assert "H3ContinuumEasyReferences" not in root_nodes.NODE_CLASS_MAPPINGS
assert H3ContinuumEasyReferences.DEPRECATED is False
assert H3ContinuumEasyV38.DEPRECATED is False
def test_easy_references_schema_has_three_fixed_optional_image_sockets_only():
schema = H3ContinuumEasyReferences.INPUT_TYPES()
assert "required" not in schema
assert tuple(schema["optional"]) == (
"reference_image_1",
"reference_image_2",
"reference_image_3",
)
assert all(value[0] == "IMAGE" for value in schema["optional"].values())
assert H3ContinuumEasyReferences.RETURN_TYPES == (EASY_REFERENCES_TYPE,)
@pytest.mark.parametrize(
"active_slots",
((), (1,), (1, 2), (1, 2, 3), (2,)),
)
def test_easy_references_preserve_fixed_slots_for_v37_mapping(active_slots):
images = {index: object() for index in range(1, 4)}
kwargs = {
f"reference_image_{index}": images[index]
for index in active_slots
}
bundle = H3ContinuumEasyReferences().pack(**kwargs)[0]
resolved = resolve_easy_references(bundle)
assert resolved == tuple(
images[index] if index in active_slots else None
for index in range(1, 4)
)
def test_easy_references_none_and_invalid_payload_contract():
assert resolve_easy_references(None) == (None, None, None)
with pytest.raises(TypeError, match="H3 Continuum Easy References"):
resolve_easy_references("not-a-reference-bundle")
with pytest.raises(ValueError, match="schema version"):
resolve_easy_references({"schema_version": 999})
@pytest.mark.parametrize(
("duration", "expected_chunks", "expected_seconds"),
((10, 1, 10.0), (15, 2, 7.5), (20, 2, 10.0), (30, 3, 10.0)),
)
def test_easy_facade_maps_to_v37_without_copying_sampling(
monkeypatch,
duration,
expected_chunks,
expected_seconds,
):
captured = {}
def fake_v37_run(_self, **kwargs):
captured.update(kwargs)
return "video", "audio", {"plan": True}, "V3.7 status", None, "refine"
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
outputs = H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="<|caption|> literal embedding:example",
duration=duration,
seed=42,
aspect=EASY_ASPECT_AUTO,
preset=EASY_PRESET_DRAFT,
first_frame=_Image(1200, 900),
last_frame=_Image(1200, 900),
)
assert captured["chunks"] == expected_chunks
assert captured["chunk_seconds"] == expected_seconds
assert captured["sequence_prompt"] == "<|caption|> literal embedding:example"
assert captured["prompt_mode"] == "Auto"
assert (captured["width"], captured["height"]) == (480, 640)
assert captured["first_frame"] is not None
assert captured["last_frame"] is not None
assert captured["base_seed"] == 42
assert captured["run_storage"] == "Off"
assert captured["driving_audio"] is None
assert captured["audio_vae"] is None
assert len(outputs) == 5
assert "FL2VA + Continuation" in outputs[3]
assert "V3.7 status" in outputs[3]
def test_easy_driving_audio_and_vae_map_directly_to_v37(monkeypatch):
captured = {}
driving_audio = {"waveform": object(), "sample_rate": 32000}
audio_vae = object()
def fake_v37_run(_self, **kwargs):
captured.update(kwargs)
return "video", "audio", {"plan": True}, "V3.7 status", driving_audio
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
outputs = H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="prompt",
duration=10,
seed=42,
driving_audio=driving_audio,
audio_vae=audio_vae,
)
assert captured["driving_audio"] is driving_audio
assert captured["audio_vae"] is audio_vae
assert outputs[4] is driving_audio
def test_easy_audio_vae_only_remains_normal_generation(monkeypatch):
captured = {}
audio_vae = object()
def fake_v37_run(_self, **kwargs):
captured.update(kwargs)
return "video", "generated-audio", {"plan": True}, "V3.7 status", None
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
outputs = H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="prompt",
duration=10,
seed=42,
audio_vae=audio_vae,
)
assert captured["driving_audio"] is None
assert captured["audio_vae"] is audio_vae
assert outputs[1] == "generated-audio"
assert outputs[4] is None
def test_easy_audio_without_vae_keeps_v37_validation(monkeypatch):
def fake_v37_run(_self, **kwargs):
if kwargs["driving_audio"] is not None and kwargs["audio_vae"] is None:
raise ValueError("anchoring guide audio needs the audio_vae input")
raise AssertionError("expected the existing V3.7 validation path")
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
with pytest.raises(ValueError, match="audio_vae input"):
H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="prompt",
duration=10,
seed=42,
driving_audio={"waveform": object(), "sample_rate": 32000},
)
def test_easy_reference_mapping_matches_direct_v37_slots_and_output_geometry(
monkeypatch,
):
captured = {}
first_ref, second_ref, third_ref = object(), object(), object()
def fake_v37_run(_self, **kwargs):
captured.update(kwargs)
return "video", "audio", {"plan": True}, "V3.7 status", None, "refine"
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
references = make_easy_references(first_ref, second_ref, third_ref)
H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="Use <Picture 1>, <Picture 2>, and <Picture 3>.",
duration=10,
seed=42,
aspect=EASY_ASPECT_PORTRAIT,
preset=EASY_PRESET_DRAFT,
references=references,
)
direct_v37_reference_kwargs = {
"reference_image_1": first_ref,
"reference_image_2": second_ref,
"reference_image_3": third_ref,
}
assert {
key: captured[key] for key in direct_v37_reference_kwargs
} == direct_v37_reference_kwargs
assert captured["reference_size"] == REFERENCE_SIZE_MATCH_OUTPUT
assert (captured["width"], captured["height"]) == (416, 736)
@pytest.mark.parametrize(
("first_frame", "last_frame", "expected_mode"),
(
(_Image(640, 480), None, "Hybrid I2VA + Reference + Continuation"),
(
_Image(640, 480),
_Image(640, 480),
"Hybrid FL2VA + Reference + Continuation",
),
),
)
def test_easy_status_reports_first_last_with_reference(
monkeypatch,
first_frame,
last_frame,
expected_mode,
):
def fake_v37_run(_self, **_kwargs):
return "video", "audio", {"plan": True}, "V3.7 status", None, "refine"
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
outputs = H3ContinuumEasyV38().run(
model="model",
clip="clip",
video_vae="video-vae",
sampler="sampler",
sigmas="sigmas",
prompt_text="Use <Picture 1>.",
duration=10,
seed=42,
first_frame=first_frame,
last_frame=last_frame,
references=make_easy_references(object()),
)
assert expected_mode in outputs[3]
def test_easy_reference_gap_compacts_to_picture_one_in_existing_v37_preprocessing():
second = torch.ones((1, 32, 32, 3))
refs = resolve_easy_references(
make_easy_references(reference_image_2=second)
)
assets = prepare_reference_assets(
reference_image_1=refs[0],
reference_image_2=refs[1],
reference_image_3=refs[2],
output_width=480,
output_height=640,
size_mode=REFERENCE_SIZE_MATCH_OUTPUT,
)
assert assets is not None
assert assets.count == 1
assert torch.equal(assets.images[0], second)
assert validate_reference_prompts(["Use <Picture 1>."], assets.count) == ""
assert "unavailable <Picture 2>" in validate_reference_prompts(
["Use <Picture 2>."], assets.count
)
def test_easy_reference_size_uses_existing_v37_output_geometry_policy(monkeypatch):
comfy_module = ModuleType("comfy")
comfy_utils_module = ModuleType("comfy.utils")
def common_upscale(image, width, height, _method, _crop):
return torch.nn.functional.interpolate(
image,
size=(height, width),
mode="bilinear",
align_corners=False,
)
comfy_utils_module.common_upscale = common_upscale
comfy_module.utils = comfy_utils_module
monkeypatch.setitem(sys.modules, "comfy", comfy_module)
monkeypatch.setitem(sys.modules, "comfy.utils", comfy_utils_module)
source = torch.zeros((1, 512, 1024, 3))
refs = resolve_easy_references(make_easy_references(source))
assets = prepare_reference_assets(
reference_image_1=refs[0],
reference_image_2=refs[1],
reference_image_3=refs[2],
output_width=320,
output_height=320,
size_mode=REFERENCE_SIZE_MATCH_OUTPUT,
)
assert assets is not None
height, width = assets.images[0].shape[1:3]
assert width * height <= 320 * 320
assert width % 32 == height % 32 == 0
assert width == 2 * height
@pytest.mark.parametrize("duration", (10, 15, 20, 30))
def test_approved_easy_fl2va_durations_do_not_enter_five_second_terminal_merge(
duration,
):
plan = resolve_easy_duration(duration)
enabled = _terminal_flf_merge_enabled(
multi_chunk_flf=plan.chunks >= 2,
chunks=plan.chunks,
chunk_seconds=plan.chunk_seconds,
prompt_hashes=["p"] * plan.chunks,
timeline_video_source=None,
)
assert enabled is False
def _function_source(source: str, name: str, next_name: str) -> str:
start = source.index(f"function {name}")
end = source.index(f"function {next_name}", start)
return source[start:end]
def test_easy_frontend_maps_only_randomize_fixed_and_hides_conditional_widgets(tmp_path):
node_executable = shutil.which("node")
if node_executable is None:
pytest.skip("Node.js is required for the frontend behavior regression")
source = EASY_JS.read_text(encoding="utf-8")
functions = "\n".join(
(
_function_source(source, "findWidget", "setWidgetVisible"),
_function_source(source, "setWidgetVisible", "attachRefresh"),
_function_source(source, "attachRefresh", "createProjectId"),
_function_source(source, "createProjectId", "seedControlWidget"),
_function_source(source, "seedControlWidget", "configureEasyNode"),
_function_source(source, "configureEasyNode", "configureEasyNodeAfterSetup"),
)
)
script = f"""
const EASY_NODE_CLASS = "H3ContinuumEasyV38";
const CUSTOM_PRESET = "Custom";
const STORAGE_ENABLED = "Save + Auto Resume";
{functions}
function widget(name, value) {{
return {{ name, value, type: "combo", options: {{}}, computeSize: () => [120, 20] }};
}}
const node = {{
comfyClass: EASY_NODE_CLASS,
widgets: [
widget("preset", "Draft — 0.30 MP"),
widget("custom_mp", 0.3),
widget("run_storage", "Off"),
widget("run_name", ""),
widget("seed_mode", "Randomize"),
widget("control_after_generate", "fixed"),
widget("project_id", "test-project"),
],
setDirtyCanvas() {{}},
}};
configureEasyNode(node);
const observed = {{
initialControl: findWidget(node, "control_after_generate").value,
controlHidden: findWidget(node, "control_after_generate").hidden,
customHidden: findWidget(node, "custom_mp").hidden,
runNameHidden: findWidget(node, "run_name").hidden,
projectHidden: findWidget(node, "project_id").hidden,
}};
findWidget(node, "seed_mode").value = "Fixed";
findWidget(node, "seed_mode").callback("Fixed");
findWidget(node, "preset").value = "Custom";
findWidget(node, "preset").callback("Custom");
findWidget(node, "run_storage").value = "Save + Auto Resume";
findWidget(node, "run_storage").callback("Save + Auto Resume");
observed.fixedControl = findWidget(node, "control_after_generate").value;
observed.customVisible = !findWidget(node, "custom_mp").hidden;
observed.runNameVisible = !findWidget(node, "run_name").hidden;
console.log(JSON.stringify(observed));
"""
script_path = tmp_path / "easy-v38-frontend.js"
script_path.write_text(script, encoding="utf-8")
result = subprocess.run(
[node_executable, str(script_path)],
check=True,
capture_output=True,
text=True,
)
observed = json.loads(result.stdout)
assert observed == {
"initialControl": "randomize",
"controlHidden": True,
"customHidden": True,
"runNameHidden": True,
"projectHidden": True,
"fixedControl": "fixed",
"customVisible": True,
"runNameVisible": True,
}