Release V3.5.1 conditioning bridge and reference audio

This commit is contained in:
ukr8b3g-cmyk
2026-08-25 00:04:59 +09:00
parent ee7b9937dc
commit b555579a17
36 changed files with 5024 additions and 138 deletions
+1 -1
View File
@@ -6,7 +6,7 @@ import tomllib
ROOT = Path(__file__).resolve().parents[1]
EXPECTED_VERSION = "3.5.0"
EXPECTED_VERSION = "3.5.1"
def test_v35_release_metadata_is_consistent():
+1 -1
View File
@@ -145,4 +145,4 @@ def test_v217_result_pack_expands_legacy_outputs():
def test_v217_has_no_frontend_display_controller():
assert not (ROOT / "web" / "h3_continuum_v2.js").exists()
version_source = (ROOT / "version.py").read_text(encoding="utf-8")
assert 'PACKAGE_VERSION = "3.5.0"' in version_source
assert 'PACKAGE_VERSION = "3.5.1"' in version_source
+65
View File
@@ -277,6 +277,15 @@ class _VideoVAE:
self.upscale_ratio = 16
class _AudioVAE:
def __init__(self):
self.first_stage_model = torch.nn.Linear(2, 2)
self.patcher = _Patcher(self.first_stage_model)
self.vae_dtype = torch.float32
self.audio_sample_rate = 32000
self.latent_channels = 32
def _sampling_contract(
*, model=None, clip=None, video_vae=None, sampler=None, reroll_nonce=0,
conditioning_mode="i2va", first_frame_hash="a" * 64,
@@ -284,6 +293,8 @@ def _sampling_contract(
upstream_graph_contract=None, upstream_graph_safe=None,
upstream_graph_reasons=None,
execution_semantics=None,
reference_audio_contract=None,
reference_audio_vae=None,
):
return build_sampling_contract(
model=model or _Model(),
@@ -314,9 +325,63 @@ def _sampling_contract(
upstream_graph_safe=upstream_graph_safe,
upstream_graph_reasons=upstream_graph_reasons,
execution_semantics=execution_semantics,
reference_audio_contract=reference_audio_contract,
reference_audio_vae=reference_audio_vae,
)
def test_reference_audio_revision_separates_changes_and_restores_on_disconnect():
model = _Model()
clip = _Clip()
sampler = _Sampler()
audio_vae = _AudioVAE()
common = {
"model": model,
"clip": clip,
"sampler": sampler,
"conditioning_mode": "t2va",
"first_frame_hash": "",
}
disconnected, safe, reasons = _sampling_contract(
**common,
reference_audio_vae=audio_vae,
)
assert safe, reasons
assert "reference_audio" not in disconnected["global"]
assert "reference_audio_vae" not in disconnected["global"]
first_contract = {
"reference_audio_contract_version": 1,
"source_sha256": "a" * 64,
"resolved_vae_sample_rate": 32000,
}
first, safe, reasons = _sampling_contract(
**common,
reference_audio_contract=first_contract,
reference_audio_vae=audio_vae,
)
assert safe, reasons
assert first["global"]["reference_audio"] == first_contract
assert "reference_audio_vae" in first["global"]
changed_contract = dict(first_contract, source_sha256="b" * 64)
changed, safe, reasons = _sampling_contract(
**common,
reference_audio_contract=changed_contract,
reference_audio_vae=audio_vae,
)
assert safe, reasons
restored, safe, reasons = _sampling_contract(
**common,
reference_audio_vae=audio_vae,
)
assert safe, reasons
assert revision_identity(disconnected) != revision_identity(first)
assert revision_identity(first) != revision_identity(changed)
assert revision_identity(restored) == revision_identity(disconnected)
def test_terminal_seed_v2_revision_is_scoped_and_distinct():
old_contract, old_safe, old_reasons = _sampling_contract(
conditioning_mode="fl2va",
+8
View File
@@ -138,6 +138,14 @@ def test_v34_public_schema_replaces_reference_audio_with_driving_audio():
schema = H3ContinuumSamplerV34.INPUT_TYPES()
assert "driving_audio" in schema["optional"]
assert "audio_vae" in schema["optional"]
assert schema["optional"]["reference_video_1"][1]["display_name"] == (
"Video Guide Frames"
)
assert schema["optional"]["driving_audio"][1]["display_name"] == "Driving Audio"
assert schema["optional"]["audio_vae"][1]["display_name"] == "Driving Audio VAE"
assert schema["required"]["video_reference_size"][1]["display_name"] == (
"Video Guide Size"
)
assert "reference_audio_1" not in schema["optional"]
assert "reference_audio_vae" not in schema["optional"]
@@ -0,0 +1,159 @@
from __future__ import annotations
import shutil
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PROJECT_ID_JS = ROOT / "web" / "project_id.js"
SEED_REUSE_JS = ROOT / "web" / "last_queued_seed.js"
def test_v35_only_wires_last_queued_seed_reuse_into_prompt_capture():
source = PROJECT_ID_JS.read_text(encoding="utf-8")
assert 'const V35_NODE_CLASS = "H3ContinuumSamplerV35";' in source
assert "if (isV35)" in source
assert "configureLastQueuedSeedReuse(node);" in source
assert "if (node.comfyClass === V35_NODE_CLASS)" in source
assert "captureLastQueuedSeed(node, apiNode?.inputs?.base_seed);" in source
def test_last_queued_seed_state_is_session_only_and_uses_required_fields():
source = SEED_REUSE_JS.read_text(encoding="utf-8")
for field in (
"last_queued_seed",
"auto_updated_seed",
"previous_control_mode",
"auto_update_pending",
):
assert field in source
assert "localStorage" not in source
assert "sessionStorage" not in source
assert "widgets_values" not in source
def test_last_queued_seed_behavior_with_real_javascript_module(tmp_path):
node = shutil.which("node")
assert node is not None, "Node.js is required for frontend behavior validation"
module_path = tmp_path / "last_queued_seed.mjs"
module_path.write_text(SEED_REUSE_JS.read_text(encoding="utf-8"), encoding="utf-8")
harness_path = tmp_path / "seed_reuse_harness.mjs"
harness_path.write_text(
r'''
import assert from "node:assert/strict";
import {
captureLastQueuedSeed,
configureLastQueuedSeedReuse,
} from "./last_queued_seed.mjs";
function makeNode({ seed = 101, mode = "randomize", nextSeeds = [], runAfter = true } = {}) {
const remaining = [...nextSeeds];
const seedWidget = {
name: "base_seed",
value: seed,
callback(value) {
this.value = value;
},
};
const controlWidget = {
name: "control_after_generate",
value: mode,
callback(value) {
this.value = value;
},
afterQueued() {
if (runAfter && this.value === "randomize" && remaining.length) {
const next = remaining.shift();
seedWidget.value = next;
seedWidget.callback(next);
}
},
};
seedWidget.linkedWidgets = [controlWidget];
const node = { widgets: [seedWidget, controlWidget] };
assert.equal(configureLastQueuedSeedReuse(node), true);
return { node, seedWidget, controlWidget };
}
function setSeed(seedWidget, value) {
seedWidget.value = value;
seedWidget.callback(value);
}
function setMode(controlWidget, value) {
controlWidget.value = value;
controlWidget.callback(value);
}
{
const { node, seedWidget, controlWidget } = makeNode({ nextSeeds: [202] });
assert.equal(captureLastQueuedSeed(node, 101), true);
controlWidget.afterQueued();
assert.equal(seedWidget.value, 202);
setMode(controlWidget, "fixed");
assert.equal(seedWidget.value, 101);
}
{
const { node, seedWidget, controlWidget } = makeNode({ nextSeeds: [202] });
captureLastQueuedSeed(node, 101);
controlWidget.afterQueued();
setSeed(seedWidget, 303);
setMode(controlWidget, "fixed");
assert.equal(seedWidget.value, 303);
}
{
const { node, seedWidget, controlWidget } = makeNode({ nextSeeds: [202, 303] });
captureLastQueuedSeed(node, 101);
controlWidget.afterQueued();
assert.equal(seedWidget.value, 202);
captureLastQueuedSeed(node, 202);
controlWidget.afterQueued();
assert.equal(seedWidget.value, 303);
setMode(controlWidget, "fixed");
assert.equal(seedWidget.value, 202);
}
{
const { node, seedWidget, controlWidget } = makeNode({ runAfter: false });
captureLastQueuedSeed(node, 101);
controlWidget.afterQueued();
setMode(controlWidget, "fixed");
assert.equal(seedWidget.value, 101);
}
{
const { node, seedWidget, controlWidget } = makeNode({ mode: "fixed", nextSeeds: [202] });
captureLastQueuedSeed(node, 101);
controlWidget.afterQueued();
assert.equal(seedWidget.value, 101);
setSeed(seedWidget, 404);
assert.equal(seedWidget.value, 404);
}
{
const { node, seedWidget, controlWidget } = makeNode({ nextSeeds: [202] });
captureLastQueuedSeed(node, 101);
controlWidget.afterQueued();
assert.equal(seedWidget.value, 202);
assert.equal(captureLastQueuedSeed(node, ["12", 0]), false);
setMode(controlWidget, "fixed");
assert.equal(seedWidget.value, 202);
}
''',
encoding="utf-8",
)
result = subprocess.run(
[node, str(harness_path)],
cwd=tmp_path,
capture_output=True,
text=True,
check=False,
)
assert result.returncode == 0, result.stdout + result.stderr
+154
View File
@@ -0,0 +1,154 @@
from __future__ import annotations
import inspect
import json
from pathlib import Path
import pytest
import torch
from ComfyUI_H3_Continuum_Join.reference_audio import (
ReferenceAudioError,
prepare_reference_audio_source,
)
from ComfyUI_H3_Continuum_Join.run_storage import automatic_project_key
from ComfyUI_H3_Continuum_Join.v3 import driving_nodes
from ComfyUI_H3_Continuum_Join.v3.driving_nodes import (
H3ContinuumSamplerV34,
H3ContinuumSamplerV35,
)
from ComfyUI_H3_Continuum_Join.v3.nodes import H3ContinuumSamplerProduction
ROOT = Path(__file__).resolve().parents[1]
def test_v35_appends_reference_audio_sockets_without_changing_v34_schema():
v34_optional = H3ContinuumSamplerV34.INPUT_TYPES()["optional"]
v35_optional = H3ContinuumSamplerV35.INPUT_TYPES()["optional"]
assert "reference_audio_1" not in v34_optional
assert "reference_audio_vae" not in v34_optional
assert list(v35_optional)[:-2] == list(v34_optional)
assert list(v35_optional)[-2:] == ["reference_audio_1", "reference_audio_vae"]
assert v35_optional["reference_audio_1"][0] == "AUDIO"
assert v35_optional["reference_audio_1"][1]["display_name"] == (
"Reference Audio (Optional)"
)
assert v35_optional["reference_audio_vae"][0] == "VAE"
assert v35_optional["reference_audio_vae"][1]["display_name"] == (
"Reference Audio VAE (Optional)"
)
assert "Driving Audio" in v35_optional["reference_audio_1"][1]["tooltip"]
def test_v34_internal_reference_audio_parameters_are_appended_and_forwarded(
monkeypatch,
):
parameters = list(inspect.signature(H3ContinuumSamplerV34.run).parameters)
assert parameters[-4:] == [
"capture_refine_context",
"reference_audio_1",
"reference_audio_vae",
"kwargs",
]
captured = {}
reference_audio = object()
reference_audio_vae = object()
monkeypatch.setattr(
driving_nodes,
"prepare_driving_audio_source",
lambda *_args, **_kwargs: None,
)
monkeypatch.setattr(
"ComfyUI_H3_Continuum_Join.reference_video.prepare_reference_video_source",
lambda *_args, **_kwargs: None,
)
def production_run(_self, **kwargs):
captured.update(kwargs)
return [], [], {}, "status"
monkeypatch.setattr(H3ContinuumSamplerProduction, "run", production_run)
outputs = H3ContinuumSamplerV34().run(
reference_audio_1=reference_audio,
reference_audio_vae=reference_audio_vae,
chunks=1,
chunk_seconds=5.0,
width=640,
height=640,
)
assert captured["reference_audio_1"] is reference_audio
assert captured["reference_audio_vae"] is reference_audio_vae
assert outputs[-1] is None
def test_v35_run_forwards_reference_audio_without_duplicate_preparation(monkeypatch):
captured = {}
reference_audio = object()
reference_audio_vae = object()
def v34_run(_self, *args, **kwargs):
captured.update(kwargs)
return [], [], {}, "status", None, {"groups": ()}
monkeypatch.setattr(H3ContinuumSamplerV34, "run", v34_run)
H3ContinuumSamplerV35().run(
reference_audio_1=reference_audio,
reference_audio_vae=reference_audio_vae,
)
assert captured["reference_audio_1"] is reference_audio
assert captured["reference_audio_vae"] is reference_audio_vae
assert captured["capture_refine_context"] is True
assert captured["memory_attribution"] is True
def test_reference_audio_vae_is_ignored_without_audio_and_required_with_audio():
vae = object()
assert prepare_reference_audio_source(None, vae) is None
audio = {
"waveform": torch.zeros((1, 2, 32000), dtype=torch.float32),
"sample_rate": 32000,
}
with pytest.raises(ReferenceAudioError, match="reference_audio_vae is required"):
prepare_reference_audio_source(audio, None)
def test_unused_reference_audio_vae_does_not_change_automatic_project_key():
base = {
"1": {"class_type": "H3ContinuumSamplerV35", "inputs": {}},
"2": {"class_type": "VAELoader", "inputs": {}},
}
vae_only = {
**base,
"1": {
"class_type": "H3ContinuumSamplerV35",
"inputs": {"reference_audio_vae": ["2", 0]},
},
}
assert automatic_project_key(base, "1") == automatic_project_key(vae_only, "1")
def test_published_v35_template_keeps_existing_sampler_socket_routes():
template = ROOT / "examples/workflows/MiniMax_H3_Continuum_V35.json"
if not template.exists():
pytest.skip("published workflow template is not installed in this runtime copy")
workflow = json.loads(
template.read_text(encoding="utf-8")
)
sampler = next(
node for node in workflow["nodes"] if node["type"] == "H3ContinuumSamplerV35"
)
routes = {item["name"]: item.get("link") for item in sampler["inputs"]}
assert routes["reference_image_1"] == 321
assert routes["reference_image_2"] == 320
assert routes["reference_image_3"] == 318
assert routes["reference_video_1"] == 322
assert routes["driving_audio"] == 294
assert routes["audio_vae"] == 295
assert "reference_audio_1" not in routes
assert "reference_audio_vae" not in routes
+165
View File
@@ -0,0 +1,165 @@
from __future__ import annotations
import shutil
import subprocess
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
PROJECT_ID_JS = ROOT / "web" / "project_id.js"
REFERENCE_AUDIO_UI_JS = ROOT / "web" / "reference_audio_ui.js"
def test_v35_wires_reference_audio_visibility_after_node_setup():
source = PROJECT_ID_JS.read_text(encoding="utf-8")
assert 'from "./reference_audio_ui.js";' in source
assert "if (node.comfyClass === V35_NODE_CLASS)" in source
assert "configureReferenceAudioInputs(node);" in source
assert "setTimeout(configureDeferred, 0);" in source
assert "node.__h3ContinuumLoadedGraphNode = true;" in source
assert "node.__h3ContinuumAfterConfigureGraph = true;" in source
def test_reference_audio_visibility_with_real_javascript_module(tmp_path):
node = shutil.which("node")
assert node is not None, "Node.js is required for frontend behavior validation"
module_path = tmp_path / "reference_audio_ui.mjs"
module_path.write_text(REFERENCE_AUDIO_UI_JS.read_text(encoding="utf-8"), encoding="utf-8")
harness_path = tmp_path / "reference_audio_ui_harness.mjs"
harness_path.write_text(
r'''
import assert from "node:assert/strict";
import { configureReferenceAudioInputs } from "./reference_audio_ui.mjs";
function makeNode({ referenceLink = null, vaeLink = null, includeReferenceInputs = true } = {}) {
const widgets = [];
const inputs = [
{ name: "reference_video_1", type: "IMAGE", label: "Video Reference", link: null },
{ name: "driving_audio", type: "AUDIO", link: null },
{ name: "audio_vae", type: "VAE", link: null },
];
if (includeReferenceInputs) {
inputs.push(
{ name: "reference_audio_1", type: "AUDIO", label: "Reference Audio", shape: 7, link: referenceLink },
{ name: "reference_audio_vae", type: "VAE", label: "Reference Audio VAE", shape: 7, link: vaeLink },
);
}
inputs.push(
{ name: "prompt_mode", type: "COMBO", link: null },
{ name: "chunks", type: "INT", link: null },
);
let previousConnectionCalls = 0;
const node = {
inputs,
widgets,
size: [320, 600],
addWidget(type, name, value, callback, options) {
const widget = { type, name, value, callback, options };
this.widgets.push(widget);
return widget;
},
addInput(name, type, options = {}) {
const input = { name, type, link: null, ...options };
this.inputs.push(input);
return input;
},
removeInput(index) {
assert.ok(this.inputs[index].link === null || this.inputs[index].link === -1);
this.inputs.splice(index, 1);
},
computeSize() {
return [320, 400 + this.inputs.length * 10];
},
setSize(size) {
this.size = size;
},
setDirtyCanvas() {},
onConnectionsChange() {
previousConnectionCalls += 1;
},
};
return { node, previousConnectionCalls: () => previousConnectionCalls };
}
function widget(node) {
return node.widgets.find((item) => item.name === "Reference Audio Inputs");
}
function input(node, name) {
return node.inputs.find((item) => item.name === name);
}
{
const { node } = makeNode();
assert.equal(configureReferenceAudioInputs(node), true);
assert.equal(widget(node).value, "Hidden");
assert.equal(widget(node).options.serialize, false);
assert.equal(widget(node).serializeValue(), undefined);
assert.equal(input(node, "reference_audio_1"), undefined);
assert.equal(input(node, "reference_audio_vae"), undefined);
assert.equal(input(node, "reference_video_1").label, "Video Guide Frames");
assert.equal(input(node, "audio_vae").label, "Driving Audio VAE");
const serialized = { widgets_values: node.widgets.map((item) => item.value) };
node.onSerialize(serialized);
assert.deepEqual(serialized.widgets_values, []);
widget(node).value = "Show";
widget(node).callback("Show");
assert.deepEqual(
node.inputs.slice(3, 5).map((item) => [item.name, item.label]),
[
["reference_audio_1", "Reference Audio (Optional)"],
["reference_audio_vae", "Reference Audio VAE (Optional)"],
],
);
input(node, "reference_audio_1").link = 42;
widget(node).value = "Hidden";
widget(node).callback("Hidden");
assert.equal(widget(node).value, "Show");
assert.equal(input(node, "reference_audio_1").link, 42);
}
{
const { node, previousConnectionCalls } = makeNode({ referenceLink: 7, vaeLink: 8 });
assert.equal(configureReferenceAudioInputs(node), true);
assert.equal(widget(node).value, "Show");
assert.equal(input(node, "reference_audio_1").link, 7);
assert.equal(input(node, "reference_audio_vae").link, 8);
node.onConnectionsChange();
await new Promise((resolve) => setTimeout(resolve, 1));
assert.equal(previousConnectionCalls(), 1);
assert.equal(widget(node).value, "Show");
}
{
const { node } = makeNode({ referenceLink: -1, vaeLink: -1 });
assert.equal(configureReferenceAudioInputs(node), true);
assert.equal(widget(node).value, "Hidden");
assert.equal(input(node, "reference_audio_1"), undefined);
assert.equal(input(node, "reference_audio_vae"), undefined);
}
{
const { node } = makeNode({ includeReferenceInputs: false });
assert.equal(configureReferenceAudioInputs(node), true);
assert.equal(widget(node).value, "Hidden");
widget(node).value = "Show";
widget(node).callback("Show");
assert.equal(input(node, "reference_audio_1").type, "AUDIO");
assert.equal(input(node, "reference_audio_vae").type, "VAE");
}
''',
encoding="utf-8",
)
result = subprocess.run(
[node, str(harness_path)],
cwd=tmp_path,
capture_output=True,
text=True,
check=False,
)
assert result.returncode == 0, result.stdout + result.stderr
+249
View File
@@ -0,0 +1,249 @@
from __future__ import annotations
import torch
from ComfyUI_H3_Continuum_Join.nodes import (
NODE_CLASS_MAPPINGS,
NODE_DISPLAY_NAME_MAPPINGS,
)
from ComfyUI_H3_Continuum_Join.v3 import conditioning_bridge_nodes
from ComfyUI_H3_Continuum_Join.v3.conditioning_bridge_nodes import (
H3ContinuumConditioningBridgeV35,
)
from ComfyUI_H3_Continuum_Join.v3.refine_context import (
MAGIC as REFINE_CONTEXT_MAGIC,
)
from ComfyUI_H3_Continuum_Join.v3.second_pass import (
prepare_physical_refine_groups,
)
def _group(
group_id: int,
*,
logical_chunks: list[int],
temporal: int,
terminal: bool,
) -> dict:
return {
"group_id": group_id,
"logical_chunks": logical_chunks,
"physical_prompt": f"physical prompt {group_id}",
"prompt_policy": "paired_timeline_v1" if terminal else "single",
"physical_frames": 260 if terminal else 124,
"trim_prefix_frames": 22 if terminal else 0,
"terminal_merged": terminal,
"source_width": 640,
"source_height": 640,
"source_batch": 1,
"latent_channels": 24,
"source_latent_t": temporal,
"source_latent_h": 40,
"source_latent_w": 40,
"source_audio_shape": [1, 8, temporal * 4],
}
def _fixture():
groups = [
_group(0, logical_chunks=[1], temporal=37, terminal=False),
_group(1, logical_chunks=[2, 3], temporal=77, terminal=True),
]
plan = {
"width": 640,
"height": 640,
"second_pass_contract": {
"version": 1,
"physical_groups": groups,
},
}
videos = [
{"samples": torch.zeros((1, 24, group["source_latent_t"], 48, 48))}
for group in groups
]
context_groups = (
{
"group_id": 0,
"logical_chunks": (1,),
"physical_clip_index": 1,
"context_frames": 0,
},
{
"group_id": 1,
"logical_chunks": (2, 3),
"physical_clip_index": 2,
"context_frames": 22,
},
)
context = {
"magic": REFINE_CONTEXT_MAGIC,
"complete": True,
"groups": context_groups,
}
return groups, plan, videos, context
def test_conditioning_bridge_public_schema_and_registration():
node_id = "H3ContinuumConditioningBridgeV35"
node_class = NODE_CLASS_MAPPINGS[node_id]
assert node_class is H3ContinuumConditioningBridgeV35
assert NODE_DISPLAY_NAME_MAPPINGS[node_id] == (
"H3 Continuum Conditioning Bridge V3.5"
)
assert node_class.CATEGORY == "MiniMax H3/Continuum/Advanced"
assert node_class.DEPRECATED is False
assert node_class.INPUT_IS_LIST is True
assert node_class.OUTPUT_IS_LIST == (True, True, False, False)
assert node_class.RETURN_TYPES == (
"MODEL",
"CONDITIONING",
"H3_CONTINUUM_ASSEMBLY_PLAN",
"STRING",
)
assert node_class.RETURN_NAMES == (
"group_models",
"conditioning",
"updated_assembly_plan",
"status",
)
schema = node_class.INPUT_TYPES()
assert list(schema["required"]) == [
"model",
"clip",
"video_latents",
"assembly_plan",
"refine_context",
]
assert list(schema["optional"]) == ["video_vae"]
def test_prepare_keeps_one_complete_conditioning_per_physical_group():
groups, plan, videos, context = _fixture()
conditioning_objects = [
[["group-0-entry-a", {"slot": 0}], ["group-0-entry-b", {"slot": 1}]],
[["group-1-entry-a", {"slot": 0}], ["group-1-entry-b", {"slot": 1}]],
]
clone_calls = []
def validate_context(value, *, assembly_plan):
assert value is context
assert assembly_plan is plan
return context
def adapt(group, **kwargs):
assert kwargs["target_latent_h"] == 48
assert kwargs["target_latent_w"] == 48
return conditioning_objects[group["group_id"]], {"adapted": True}
def clone(model, **kwargs):
clone_calls.append(kwargs)
return f"model-{kwargs['chunk_index']}"
prepared = prepare_physical_refine_groups(
model="base-model",
clip="clip",
video_latents=videos,
assembly_plan=plan,
refine_context=context,
validate_refine_context_fn=validate_context,
adapt_group_conditioning_fn=adapt,
clone_model_fn=clone,
)
assert prepared["physical_group_count"] == 2
assert len(prepared["group_models"]) == len(prepared["conditioning"]) == 2
assert prepared["group_models"] == ["model-1", "model-2"]
assert prepared["conditioning"] == conditioning_objects
assert prepared["conditioning"][0] is conditioning_objects[0]
assert prepared["conditioning"][1] is conditioning_objects[1]
assert [len(item) for item in prepared["conditioning"]] == [2, 2]
assert [detail["group"]["logical_chunks"] for detail in prepared["details"]] == [
[1],
[2, 3],
]
assert [detail["context_frames"] for detail in prepared["details"]] == [0, 22]
assert clone_calls == [
{
"strict": False,
"debug": False,
"chunk_index": 1,
"context_frames": None,
},
{
"strict": False,
"debug": False,
"chunk_index": 2,
"context_frames": 22,
},
]
assert prepared["updated_assembly_plan"]["width"] == 768
assert prepared["updated_assembly_plan"]["height"] == 768
assert plan["width"] == 640
assert groups[1]["logical_chunks"] == [2, 3]
def test_node_preserves_outer_physical_group_list_without_flattening(monkeypatch):
_groups, plan, videos, context = _fixture()
complete_conditioning = [
[["first-entry", {"group": 0}], ["second-entry", {"group": 0}]],
[["terminal-entry-a", {"group": 1}], ["terminal-entry-b", {"group": 1}]],
]
prepared = {
"group_models": ["model-0", "model-1"],
"conditioning": complete_conditioning,
"updated_assembly_plan": {"width": 768, "height": 768},
"physical_group_count": 2,
"warnings": [],
"details": [
{
"group_index": 0,
"group": {"logical_chunks": [1], "prompt_policy": "single"},
"conditioning_source": "refine_context",
"physical_clip_index": 1,
"context_frames": 0,
},
{
"group_index": 1,
"group": {
"logical_chunks": [2, 3],
"prompt_policy": "paired_timeline_v1",
},
"conditioning_source": "refine_context",
"physical_clip_index": 2,
"context_frames": 22,
},
],
}
captured = {}
def fake_prepare(**kwargs):
captured.update(kwargs)
return prepared
monkeypatch.setattr(
conditioning_bridge_nodes,
"prepare_physical_refine_groups",
fake_prepare,
)
result = H3ContinuumConditioningBridgeV35().prepare(
model=["base-model"],
clip=["clip"],
video_latents=videos,
assembly_plan=[plan],
refine_context=[context],
video_vae=["vae"],
)
assert captured["model"] == "base-model"
assert captured["clip"] == "clip"
assert captured["video_latents"] is videos
assert captured["assembly_plan"] is plan
assert captured["refine_context"] is context
assert captured["video_vae"] == "vae"
assert result[0] == ["model-0", "model-1"]
assert result[1] is complete_conditioning
assert len(result[1]) == 2
assert [len(item) for item in result[1]] == [2, 2]
assert result[2] is prepared["updated_assembly_plan"]
assert "logical_chunks=[2, 3]" in result[3]
assert "AV LATENT, Noise, and Audio Lock" in result[3]
+51
View File
@@ -69,6 +69,7 @@ def _capture_sequence(
monkeypatch,
*,
terminal: bool,
reference_audio: bool = False,
session=None,
diagnostics=DIAGNOSTICS_BASIC,
memory_attribution=False,
@@ -101,6 +102,27 @@ def _capture_sequence(
"clone_model_for_chunk",
lambda model, **_kwargs: model,
)
reference_audio_source = None
reference_audio_vae = None
if reference_audio:
from ComfyUI_H3_Continuum_Join import reference_audio as reference_audio_module
reference_audio_source = SimpleNamespace(
combined_hash="reference-audio-hash",
contract={
"reference_audio_contract_version": 1,
"source_sha256": "a" * 64,
},
)
reference_audio_vae = object()
reference_audio_assets = SimpleNamespace(
audio_latent=torch.arange(64, dtype=torch.float32).reshape(1, 32, 2, 1)
)
monkeypatch.setattr(
reference_audio_module,
"encode_reference_audio",
lambda _vae, _source: reference_audio_assets,
)
chunks = 3 if terminal else 2
mode = PROMPT_MODE_LIST if terminal else PROMPT_MODE_FIXED
script = "first\n---\nmiddle\n---\nlast" if terminal else "same prompt"
@@ -133,6 +155,8 @@ def _capture_sequence(
debug=False,
session=session,
latent_only=True,
reference_audio_source=reference_audio_source,
reference_audio_vae=reference_audio_vae,
capture_refine_context=True,
memory_attribution=memory_attribution,
)
@@ -275,6 +299,33 @@ def test_capture_records_terminal_pair_as_one_physical_group(monkeypatch):
assert validate_refine_context(context, assembly_plan) is context
def test_reference_audio_is_captured_in_every_normal_physical_group(monkeypatch):
outputs = _capture_sequence(
monkeypatch,
terminal=False,
reference_audio=True,
)
groups = outputs[4]["groups"]
assert [group["logical_chunks"] for group in groups] == [(1,), (2,)]
for group in groups:
refs = group["conditioning"][0][1]["minimax_refs"]
assert [ref["kind"] for ref in refs].count("audio") == 1
def test_reference_audio_is_captured_in_terminal_physical_group(monkeypatch):
outputs = _capture_sequence(
monkeypatch,
terminal=True,
reference_audio=True,
)
groups = outputs[4]["groups"]
assert [group["logical_chunks"] for group in groups] == [(1,), (2, 3)]
assert groups[1]["prompt_policy"] == "paired_timeline_v1"
for group in groups:
refs = group["conditioning"][0][1]["minimax_refs"]
assert [ref["kind"] for ref in refs].count("audio") == 1
def test_reused_session_returns_incomplete_context_without_stopping(monkeypatch):
first_outputs = _capture_sequence(monkeypatch, terminal=False)
reused_outputs = _capture_sequence(
+97
View File
@@ -9,6 +9,7 @@ from ComfyUI_H3_Continuum_Join.nodes import (
)
from ComfyUI_H3_Continuum_Join.v3.hires_fix_nodes import (
H3ContinuumHiResFixV35,
align_h3_manual_canvas,
resolve_h3_native_latent_target,
)
from ComfyUI_H3_Continuum_Join.v3.second_pass import SecondPassContractError
@@ -173,6 +174,102 @@ def test_enabled_pixel_vae_roundtrip_then_reuses_second_pass_contract(monkeypatc
assert second_pass["conditioning_upscale_method"] == "bilinear"
@pytest.mark.parametrize(
("latent_width", "latent_height", "expected_width", "expected_height"),
(
(36, 36, 704, 704),
(64, 36, 1216, 704),
),
)
def test_manual_scale_1_2_aligns_to_core_h3_canvas(
latent_width,
latent_height,
expected_width,
expected_height,
):
target = align_h3_manual_canvas(
latent_width,
latent_height,
1.2,
pixel_scale_width=16,
pixel_scale_height=16,
canvas_multiple=32,
)
assert target == {
"target_width": expected_width,
"target_height": expected_height,
"target_latent_width": expected_width // 16,
"target_latent_height": expected_height // 16,
}
assert target["target_latent_width"] % 2 == 0
assert target["target_latent_height"] % 2 == 0
def test_manual_scale_1_2_passes_core_aligned_target_to_pixel_vae(monkeypatch):
videos = [_video("first-pass", height=36, width=36)]
resized = [_video("reencoded", height=44, width=44)]
audios = [_audio("first-pass")]
plan = _plan(width=576, height=576, latent_width=36, latent_height=36)
calls = []
def fake_roundtrip(video_latents, assembly_plan, **kwargs):
calls.append(("roundtrip", video_latents, assembly_plan, kwargs))
return resized
def fake_second_pass(**kwargs):
calls.append(("second_pass", kwargs))
return (
[_video("refined", height=44, width=44)],
audios,
{"width": 704, "height": 704},
"sampled",
)
monkeypatch.setattr(
"ComfyUI_H3_Continuum_Join.v3.hires_fix_nodes.h3_core_native_canvas",
lambda *_args, **_kwargs: (768, 768),
)
monkeypatch.setattr(
"ComfyUI_H3_Continuum_Join.v3.hires_fix_nodes.resize_video_latents_via_vae",
fake_roundtrip,
)
monkeypatch.setattr(
"ComfyUI_H3_Continuum_Join.v3.hires_fix_nodes.run_second_pass_groups",
fake_second_pass,
)
result = H3ContinuumHiResFixV35().apply(
["model"],
["clip"],
["sampler"],
[torch.tensor([0.3, 0.0])],
videos,
audios,
[plan],
[True],
["lanczos"],
[1.2],
[17],
[{"context": True}],
["video-vae"],
)
assert calls[0] == (
"roundtrip",
videos,
plan,
{
"video_vae": "video-vae",
"target_width": 704,
"target_height": 704,
"upscale_method": "lanczos",
},
)
assert calls[1][1]["video_latents"] is resized
assert "target=704x704" in result[3]
def test_native_auto_resizes_to_exact_core_target_then_samples(monkeypatch):
videos = [_video("first-pass")]
resized = [_video("native", height=6, width=6)]