Squashed 'vendor/dumas_h3_continuum/' content from commit d07ed31
git-subtree-dir: vendor/dumas_h3_continuum git-subtree-split: d07ed31b442d283d6a1740f875a843b9feda4c91
This commit is contained in:
@@ -0,0 +1,529 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import inspect
|
||||
|
||||
import pytest
|
||||
import torch
|
||||
|
||||
from ComfyUI_H3_Continuum_Join import reference, reference_video
|
||||
from ComfyUI_H3_Continuum_Join.v3 import driving_nodes, reliability_v38
|
||||
from ComfyUI_H3_Continuum_Join.v3.driving_nodes import (
|
||||
H3ContinuumSamplerV37,
|
||||
H3ContinuumSamplerV38,
|
||||
)
|
||||
from ComfyUI_H3_Continuum_Join.v3.reliability_v38 import (
|
||||
V38Diagnostics,
|
||||
append_v38_status,
|
||||
build_frame_alignment_diagnostics,
|
||||
collect_core_compatibility_advisory,
|
||||
estimate_visual_conditioning_load,
|
||||
format_v38_diagnostics,
|
||||
validate_audio_latent_lengths,
|
||||
)
|
||||
|
||||
|
||||
def _group(
|
||||
frames: int,
|
||||
*,
|
||||
trim: int = 0,
|
||||
video_t: int,
|
||||
audio_t: int,
|
||||
logical=(1,),
|
||||
terminal=False,
|
||||
):
|
||||
return {
|
||||
"sequence_index": 1,
|
||||
"chunk_index": 1,
|
||||
"total_frames": frames,
|
||||
"trim_frames": trim,
|
||||
"net_frames": frames - trim,
|
||||
"context_frames": trim,
|
||||
"expected_video_latent_t": video_t,
|
||||
"expected_audio_latent_t": audio_t,
|
||||
"logical_chunk_indices": list(logical),
|
||||
"terminal_merged": terminal,
|
||||
}
|
||||
|
||||
|
||||
def _plan(*groups, terminal=False):
|
||||
if terminal:
|
||||
return {
|
||||
"chunks": [
|
||||
_group(124, video_t=37, audio_t=207),
|
||||
_group(141, trim=22, video_t=42, audio_t=235),
|
||||
],
|
||||
"decode_groups": list(groups),
|
||||
}
|
||||
return {"chunks": list(groups)}
|
||||
|
||||
|
||||
def _video_latent(t: int):
|
||||
return {"samples": torch.zeros(1, 24, t, 2, 2)}
|
||||
|
||||
|
||||
def _audio_latent(t: int, *, channels=32, stereo=2):
|
||||
return {"samples": torch.zeros(1, channels, stereo, t)}
|
||||
|
||||
|
||||
def test_current_v38_public_schema_is_preserved_exactly():
|
||||
v37 = H3ContinuumSamplerV37.INPUT_TYPES()
|
||||
v38 = H3ContinuumSamplerV38.INPUT_TYPES()
|
||||
expected_required = []
|
||||
for name in v37["required"]:
|
||||
if name == "width":
|
||||
expected_required.extend(("aspect", "preset", "custom_mp"))
|
||||
elif name != "height":
|
||||
expected_required.append(name)
|
||||
expected_required.extend(
|
||||
(
|
||||
"generation_mode",
|
||||
"review_action",
|
||||
"take_group",
|
||||
"take_revision_id",
|
||||
"take_action",
|
||||
"size_source",
|
||||
"width",
|
||||
"height",
|
||||
)
|
||||
)
|
||||
assert tuple(v38["required"]) == tuple(expected_required)
|
||||
assert list(v38["optional"])[:-3] == list(v37["optional"])
|
||||
assert list(v38["optional"])[-3:] == [
|
||||
"audio_references",
|
||||
"image_references",
|
||||
"video_reference_mode",
|
||||
]
|
||||
assert v38["optional"]["audio_references"][0] == (
|
||||
"H3_CONTINUUM_AUDIO_REFERENCES"
|
||||
)
|
||||
mode_schema = v38["optional"]["video_reference_mode"]
|
||||
assert mode_schema[0] == ("Follow Timeline", "Repeat Reference")
|
||||
assert mode_schema[1]["default"] == "Repeat Reference"
|
||||
assert v38.get("hidden") == v37.get("hidden")
|
||||
assert tuple(v38["required"])[-8:] == (
|
||||
"generation_mode",
|
||||
"review_action",
|
||||
"take_group",
|
||||
"take_revision_id",
|
||||
"take_action",
|
||||
"size_source",
|
||||
"width",
|
||||
"height",
|
||||
)
|
||||
|
||||
|
||||
def test_reference_preprocessing_uses_the_new_shared_pure_size_resolver(monkeypatch):
|
||||
calls = []
|
||||
|
||||
def fake_resolver(source_width, source_height, **kwargs):
|
||||
calls.append((source_width, source_height, kwargs))
|
||||
return source_width, source_height
|
||||
|
||||
monkeypatch.setattr(reference, "resolve_reference_image_size", fake_resolver)
|
||||
image = torch.zeros(1, 64, 96, 3)
|
||||
assets = reference.prepare_reference_assets(
|
||||
reference_image_1=image,
|
||||
reference_image_2=None,
|
||||
output_width=96,
|
||||
output_height=64,
|
||||
size_mode=reference.REFERENCE_SIZE_MATCH_OUTPUT,
|
||||
)
|
||||
assert assets is not None
|
||||
assert assets.images[0].shape == image.shape
|
||||
assert calls == [
|
||||
(
|
||||
96,
|
||||
64,
|
||||
{
|
||||
"output_width": 96,
|
||||
"output_height": 64,
|
||||
"size_mode": reference.REFERENCE_SIZE_MATCH_OUTPUT,
|
||||
},
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
def test_reference_video_preprocessing_uses_shared_frame_and_size_resolvers(
|
||||
monkeypatch,
|
||||
):
|
||||
assert reference_video._resolved_size is reference_video.resolve_reference_video_size
|
||||
assert (
|
||||
reference_video._resolve_reference_frame_count
|
||||
is reference_video.resolve_reference_video_frame_count
|
||||
)
|
||||
frame_calls = []
|
||||
size_calls = []
|
||||
|
||||
def fake_frames(source_frames, target_frames):
|
||||
frame_calls.append((source_frames, target_frames))
|
||||
return 5
|
||||
|
||||
def fake_size(source_width, source_height, **kwargs):
|
||||
size_calls.append((source_width, source_height, kwargs))
|
||||
return source_width, source_height
|
||||
|
||||
monkeypatch.setattr(
|
||||
reference_video,
|
||||
"resolve_reference_video_frame_count",
|
||||
fake_frames,
|
||||
)
|
||||
monkeypatch.setattr(
|
||||
reference_video,
|
||||
"resolve_reference_video_size",
|
||||
fake_size,
|
||||
)
|
||||
source = reference_video.prepare_reference_video_source(
|
||||
torch.zeros(5, 32, 64, 3),
|
||||
target_frames=124,
|
||||
output_width=64,
|
||||
output_height=32,
|
||||
size_mode=reference_video.REFERENCE_VIDEO_SIZE_EFFICIENT,
|
||||
)
|
||||
assert source is not None
|
||||
assert frame_calls == [(5, 124)]
|
||||
assert size_calls == [
|
||||
(
|
||||
64,
|
||||
32,
|
||||
{
|
||||
"output_width": 64,
|
||||
"output_height": 32,
|
||||
"size_mode": reference_video.REFERENCE_VIDEO_SIZE_EFFICIENT,
|
||||
},
|
||||
)
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("source_frames", "expected_action"),
|
||||
(
|
||||
(120, "120 -> 124 (final-frame pad"),
|
||||
(124, "124 -> 124 (unchanged"),
|
||||
(180, "180 -> 124 (trimmed to one-chunk H3 limit"),
|
||||
),
|
||||
)
|
||||
def test_video_guide_alignment_reports_existing_pad_unchanged_and_cap(
|
||||
source_frames,
|
||||
expected_action,
|
||||
):
|
||||
section = build_frame_alignment_diagnostics(
|
||||
video_latents=[_video_latent(37)],
|
||||
assembly_plan=_plan(_group(124, video_t=37, audio_t=207)),
|
||||
video_guide=torch.zeros(source_frames, 32, 64, 3),
|
||||
chunk_seconds=5.0,
|
||||
)
|
||||
assert expected_action in "\n".join(section.detailed)
|
||||
if source_frames == 124:
|
||||
assert not section.basic
|
||||
else:
|
||||
assert expected_action in "\n".join(section.basic)
|
||||
|
||||
|
||||
def test_frame_grid_uses_terminal_physical_group_and_advises_on_actual_t_mismatch():
|
||||
terminal = _group(
|
||||
260,
|
||||
trim=22,
|
||||
video_t=77,
|
||||
audio_t=433,
|
||||
logical=(2, 3),
|
||||
terminal=True,
|
||||
)
|
||||
passed = build_frame_alignment_diagnostics(
|
||||
video_latents=[_video_latent(77)],
|
||||
assembly_plan=_plan(terminal, terminal=True),
|
||||
chunk_seconds=5.0,
|
||||
)
|
||||
assert not passed.basic
|
||||
assert "frames=260" in passed.detailed[0]
|
||||
assert "video_t=77" in passed.detailed[0]
|
||||
assert passed.detailed[0].endswith("PASS.")
|
||||
|
||||
failed = build_frame_alignment_diagnostics(
|
||||
video_latents=[_video_latent(76)],
|
||||
assembly_plan=_plan(terminal, terminal=True),
|
||||
chunk_seconds=5.0,
|
||||
)
|
||||
assert "actual T differs" in "\n".join(failed.basic)
|
||||
assert failed.detailed[0].endswith("ADVISORY.")
|
||||
|
||||
|
||||
def test_frame_grid_advises_on_physical_output_count_mismatch():
|
||||
section = build_frame_alignment_diagnostics(
|
||||
video_latents=[],
|
||||
assembly_plan=_plan(_group(124, video_t=37, audio_t=207)),
|
||||
chunk_seconds=5.0,
|
||||
)
|
||||
assert "output count 0 does not match group count 1" in "\n".join(section.basic)
|
||||
|
||||
|
||||
def test_audio_validation_passes_normal_and_terminal_physical_groups():
|
||||
first = _group(124, video_t=37, audio_t=207)
|
||||
terminal = _group(
|
||||
260,
|
||||
trim=22,
|
||||
video_t=77,
|
||||
audio_t=433,
|
||||
logical=(2, 3),
|
||||
terminal=True,
|
||||
)
|
||||
section = validate_audio_latent_lengths(
|
||||
audio_latents=[_audio_latent(207), _audio_latent(433)],
|
||||
assembly_plan=_plan(first, terminal, terminal=True),
|
||||
)
|
||||
assert not section.basic
|
||||
assert len(section.detailed) == 2
|
||||
assert all(line.endswith("PASS.") for line in section.detailed)
|
||||
assert "phase=0.333333" in section.detailed[0]
|
||||
assert "phase=-0.333333" in section.detailed[1]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("latent", "expected"),
|
||||
(
|
||||
({}, "samples are missing"),
|
||||
({"samples": "not-a-tensor"}, "not a Tensor"),
|
||||
({"samples": torch.zeros(1, 32, 207)}, "rank is 3"),
|
||||
(_audio_latent(207, channels=31), "channels=31"),
|
||||
(_audio_latent(207, stereo=1), "stereo=1"),
|
||||
(_audio_latent(0), "T must be positive"),
|
||||
),
|
||||
)
|
||||
def test_audio_validation_reports_shape_advisories(latent, expected):
|
||||
section = validate_audio_latent_lengths(
|
||||
audio_latents=[latent],
|
||||
assembly_plan=_plan(_group(124, video_t=37, audio_t=207)),
|
||||
)
|
||||
assert expected in "\n".join(section.basic)
|
||||
|
||||
|
||||
def test_audio_validation_reports_metadata_delta_phase_and_count():
|
||||
section = validate_audio_latent_lengths(
|
||||
audio_latents=[_audio_latent(206)],
|
||||
assembly_plan=_plan(
|
||||
_group(124, video_t=37, audio_t=207),
|
||||
_group(141, trim=22, video_t=42, audio_t=235),
|
||||
),
|
||||
)
|
||||
text = "\n".join(section.basic)
|
||||
assert "output count 1 does not match group count 2" in text
|
||||
assert "metadata=207 actual=206 delta=-1" in text
|
||||
assert "phase=-0.666667" in text
|
||||
|
||||
|
||||
def test_audio_validation_does_not_copy_or_modify_tensor():
|
||||
samples = torch.arange(1 * 32 * 2 * 207, dtype=torch.float32).reshape(
|
||||
1, 32, 2, 207
|
||||
)
|
||||
before = samples.clone()
|
||||
pointer = samples.data_ptr()
|
||||
latents = [{"samples": samples}]
|
||||
section = validate_audio_latent_lengths(
|
||||
audio_latents=latents,
|
||||
assembly_plan=_plan(_group(124, video_t=37, audio_t=207)),
|
||||
)
|
||||
assert not section.basic
|
||||
assert latents[0]["samples"] is samples
|
||||
assert samples.data_ptr() == pointer
|
||||
assert torch.equal(samples, before)
|
||||
source = inspect.getsource(validate_audio_latent_lengths)
|
||||
for forbidden in (".clone(", ".cpu(", ".to(", ".numpy(", "contiguous("):
|
||||
assert forbidden not in source
|
||||
|
||||
|
||||
def test_core_advisory_basic_detailed_deduplicates_and_never_gates():
|
||||
compatible = collect_core_compatibility_advisory(lambda: [])
|
||||
assert compatible.basic == ()
|
||||
assert "native MiniMax H3 contracts detected" in compatible.detailed[0]
|
||||
|
||||
issues = collect_core_compatibility_advisory(
|
||||
lambda: ["PackedLayout changed", "PackedLayout changed", "rows missing"]
|
||||
)
|
||||
assert "2 native H3 contract difference" in issues.basic[0]
|
||||
assert len(issues.detailed) == 2
|
||||
|
||||
unavailable = collect_core_compatibility_advisory(
|
||||
lambda: (_ for _ in ()).throw(RuntimeError("probe failed"))
|
||||
)
|
||||
assert "generation result was preserved" in unavailable.basic[0]
|
||||
assert "RuntimeError: probe failed" in unavailable.detailed[0]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("value", "expected"),
|
||||
(
|
||||
(0.749999, "Low"),
|
||||
(0.75, "Medium"),
|
||||
(1.749999, "Medium"),
|
||||
(1.75, "High"),
|
||||
),
|
||||
)
|
||||
def test_visual_load_classification_boundaries(value, expected):
|
||||
assert reliability_v38._visual_load_class(value) == expected
|
||||
|
||||
|
||||
def test_visual_load_uses_existing_efficient_geometry_and_temporal_ratio():
|
||||
section = estimate_visual_conditioning_load(
|
||||
output_width=1344,
|
||||
output_height=768,
|
||||
reference_images=(),
|
||||
reference_size=reference.REFERENCE_SIZE_MATCH_OUTPUT,
|
||||
video_guide=torch.zeros(120, 1080, 1920, 3),
|
||||
video_guide_size=reference_video.REFERENCE_VIDEO_SIZE_EFFICIENT,
|
||||
chunk_seconds=5.0,
|
||||
still_guide_active=False,
|
||||
)
|
||||
assert section.basic == (
|
||||
"Visual conditioning load: Low (peak per physical group).",
|
||||
)
|
||||
assert "total=0.387 class=Low" in section.detailed[0]
|
||||
assert "Video Guide=832x480/124f=0.387" in section.detailed[0]
|
||||
|
||||
|
||||
def test_visual_load_adds_reference_images_but_excludes_still_guide():
|
||||
reference_image = torch.zeros(1, 768, 1024, 3)
|
||||
section = estimate_visual_conditioning_load(
|
||||
output_width=1024,
|
||||
output_height=768,
|
||||
reference_images=(reference_image, reference_image, reference_image),
|
||||
reference_size=reference.REFERENCE_SIZE_MATCH_OUTPUT,
|
||||
video_guide=None,
|
||||
chunk_seconds=5.0,
|
||||
still_guide_active=True,
|
||||
)
|
||||
assert "High" in section.basic[0]
|
||||
assert "Still Guide active" in section.basic[0]
|
||||
assert "total=3.000" in section.detailed[0]
|
||||
assert "Still Guide=active" in section.detailed[0]
|
||||
assert "Ref1=1024x768=1.000" in section.detailed[0]
|
||||
assert "Ref3=1024x768=1.000" in section.detailed[0]
|
||||
|
||||
|
||||
def test_still_guide_only_is_reported_without_numeric_total():
|
||||
section = estimate_visual_conditioning_load(
|
||||
output_width=1024,
|
||||
output_height=768,
|
||||
reference_images=(),
|
||||
reference_size=reference.REFERENCE_SIZE_MATCH_OUTPUT,
|
||||
video_guide=None,
|
||||
chunk_seconds=5.0,
|
||||
still_guide_active=True,
|
||||
)
|
||||
assert section.basic == ("Still Guide: active.",)
|
||||
assert "excluded from numeric visual load" in section.detailed[0]
|
||||
|
||||
|
||||
def test_visual_load_inspects_shapes_only_and_has_no_chunk_or_storage_input():
|
||||
signature = inspect.signature(estimate_visual_conditioning_load)
|
||||
assert "chunks" not in signature.parameters
|
||||
assert "run_storage" not in signature.parameters
|
||||
source = inspect.getsource(estimate_visual_conditioning_load)
|
||||
for forbidden in (
|
||||
".clone(",
|
||||
".cpu(",
|
||||
".to(",
|
||||
".numpy(",
|
||||
"encode(",
|
||||
"_tensor_hash",
|
||||
"common_upscale",
|
||||
):
|
||||
assert forbidden not in source
|
||||
|
||||
|
||||
def test_basic_detailed_and_off_status_formatting():
|
||||
diagnostics = V38Diagnostics(
|
||||
basic=("Basic issue.",),
|
||||
detailed=("Detailed PASS.",),
|
||||
)
|
||||
assert format_v38_diagnostics(diagnostics, mode="Basic") == (
|
||||
"V3.8 Reliability\nBasic issue."
|
||||
)
|
||||
assert format_v38_diagnostics(diagnostics, mode="Detailed Report") == (
|
||||
"V3.8 Reliability\nDetailed PASS."
|
||||
)
|
||||
assert format_v38_diagnostics(diagnostics, mode="Off") == ""
|
||||
assert append_v38_status("Original", diagnostics, mode="Off") == "Original"
|
||||
assert append_v38_status("Original", diagnostics, mode="Basic") == (
|
||||
"Original\nV3.8 Reliability\nBasic issue."
|
||||
)
|
||||
|
||||
|
||||
def test_v38_wrapper_preserves_every_non_status_output_identity(monkeypatch):
|
||||
video = [_video_latent(37)]
|
||||
audio = [_audio_latent(207)]
|
||||
plan = _plan(_group(124, video_t=37, audio_t=207))
|
||||
driving_audio = object()
|
||||
refine_context = object()
|
||||
|
||||
def fake_v37_run(self, **kwargs):
|
||||
return video, audio, plan, "Original status", driving_audio, refine_context
|
||||
|
||||
monkeypatch.setattr(H3ContinuumSamplerV37, "run", fake_v37_run)
|
||||
monkeypatch.setattr(
|
||||
driving_nodes,
|
||||
"build_v38_diagnostics",
|
||||
lambda **kwargs: V38Diagnostics(("Basic diagnostic.",), ("Detailed.",)),
|
||||
)
|
||||
outputs = H3ContinuumSamplerV38().run(
|
||||
chunk_seconds=5.0,
|
||||
diagnostics="Basic",
|
||||
)
|
||||
assert outputs[0] is video
|
||||
assert outputs[1] is audio
|
||||
assert outputs[2] is plan
|
||||
assert outputs[4] is driving_audio
|
||||
assert outputs[5] is refine_context
|
||||
assert outputs[3] == (
|
||||
"Original status\nV3.8 Reliability\nBasic diagnostic."
|
||||
)
|
||||
|
||||
|
||||
def test_v38_wrapper_preserves_generation_when_diagnostics_raise(monkeypatch):
|
||||
outputs = (
|
||||
[_video_latent(37)],
|
||||
[_audio_latent(207)],
|
||||
_plan(_group(124, video_t=37, audio_t=207)),
|
||||
"Original status",
|
||||
object(),
|
||||
)
|
||||
|
||||
monkeypatch.setattr(H3ContinuumSamplerV37, "run", lambda self, **kwargs: outputs)
|
||||
monkeypatch.setattr(
|
||||
driving_nodes,
|
||||
"build_v38_diagnostics",
|
||||
lambda **kwargs: (_ for _ in ()).throw(RuntimeError("diagnostic failed")),
|
||||
)
|
||||
result = H3ContinuumSamplerV38().run(
|
||||
chunk_seconds=5.0,
|
||||
diagnostics="Detailed Report",
|
||||
)
|
||||
assert result[0] is outputs[0]
|
||||
assert result[1] is outputs[1]
|
||||
assert result[2] is outputs[2]
|
||||
assert result[4] is outputs[4]
|
||||
assert "generation result was preserved" in result[3]
|
||||
assert "RuntimeError: diagnostic failed" in result[3]
|
||||
|
||||
|
||||
def test_v38_wrapper_keeps_non_tuple_test_double_unchanged(monkeypatch):
|
||||
monkeypatch.setattr(H3ContinuumSamplerV37, "run", lambda self, **kwargs: "ok")
|
||||
assert H3ContinuumSamplerV38().run() == "ok"
|
||||
|
||||
|
||||
def test_v38_wrapper_diagnostics_off_skips_all_reliability_work(monkeypatch):
|
||||
outputs = (
|
||||
[_video_latent(37)],
|
||||
[_audio_latent(207)],
|
||||
_plan(_group(124, video_t=37, audio_t=207)),
|
||||
"Original status",
|
||||
)
|
||||
monkeypatch.setattr(H3ContinuumSamplerV37, "run", lambda self, **kwargs: outputs)
|
||||
|
||||
def fail_if_called(**kwargs):
|
||||
raise AssertionError("diagnostics must not run when Report Detail is Off")
|
||||
|
||||
monkeypatch.setattr(driving_nodes, "build_v38_diagnostics", fail_if_called)
|
||||
result = H3ContinuumSamplerV38().run(
|
||||
chunk_seconds=5.0,
|
||||
diagnostics="Off",
|
||||
)
|
||||
assert result is outputs
|
||||
Reference in New Issue
Block a user