Files

221 lines
7.4 KiB
Python

from copy import deepcopy
import importlib.util
from pathlib import Path
from types import SimpleNamespace
import pytest
import torch
_SPEC = importlib.util.spec_from_file_location(
"h3_continuum_v3_hardening",
Path(__file__).parents[1] / "hardening.py",
)
hardening = importlib.util.module_from_spec(_SPEC)
assert _SPEC.loader is not None
_SPEC.loader.exec_module(hardening)
def _plan():
plan = {
"schema_version": 1,
"fps": 24,
"width": 448,
"height": 672,
"chunk_seconds": 5.0,
"target_frames": 240,
"preserve_final_frame": True,
"chunks": [
{
"sequence_index": 0,
"chunk_index": 7,
"total_frames": 124,
"trim_frames": 0,
"net_frames": 124,
"context_frames": 5,
"expected_video_latent_t": 32,
"expected_audio_latent_t": 207,
},
{
"sequence_index": 1,
"chunk_index": 8,
"total_frames": 141,
"trim_frames": 22,
"net_frames": 119,
"context_frames": 22,
"expected_video_latent_t": 36,
"expected_audio_latent_t": 235,
},
],
}
return hardening.enrich_assembly_plan(plan)
def _decoded():
images = [
torch.zeros((124, 8, 8, 3), dtype=torch.float32),
torch.zeros((141, 8, 8, 3), dtype=torch.float32),
]
audio = [
{"waveform": torch.zeros((1, 2, 160000)), "sample_rate": 32000},
{"waveform": torch.zeros((1, 2, 188000)), "sample_rate": 32000},
]
return images, audio
def test_plan_records_natural_boundaries_without_equating_target():
plan = _plan()
assert plan["chunk_count"] == 2
assert plan["natural_frames"] == 243
assert plan["target_frames"] == 240
assert plan["chunks"][0]["frame_start"] == 0
assert plan["chunks"][0]["frame_stop"] == 124
assert plan["chunks"][1]["frame_start"] == 124
assert plan["chunks"][1]["frame_stop"] == 243
hardening.validate_assembly_plan_contract(plan)
def test_plan_uses_canonical_latent_length_fields():
plan = _plan()
chunk = plan["chunks"][0]
assert chunk["expected_video_latent_t"] == 32
assert chunk["expected_audio_latent_t"] == 207
chunk["expected_video_t"] = chunk.pop("expected_video_latent_t")
with pytest.raises(ValueError, match="expected_video_latent_t"):
hardening.validate_assembly_plan_contract(plan)
def test_plan_builder_reads_audio_time_from_last_axis():
source = (Path(__file__).parents[1] / "v3" / "plan.py").read_text(
encoding="utf-8"
)
assert '"expected_video_latent_t": int(video.shape[2])' in source
assert '"expected_audio_latent_t": int(audio.shape[-1])' in source
def test_plan_accepts_resumed_indices_but_rejects_discontinuity():
plan = _plan()
hardening.validate_assembly_plan_contract(plan)
plan["chunks"][1]["chunk_index"] = 9
with pytest.raises(ValueError, match="chunk_index"):
hardening.validate_assembly_plan_contract(plan)
def test_plan_rejects_invalid_h3_grid_and_arithmetic():
plan = _plan()
plan["chunks"][1]["total_frames"] = 140
with pytest.raises(ValueError, match=r"17k\+5"):
hardening.validate_assembly_plan_contract(plan)
plan = _plan()
plan["chunks"][1]["net_frames"] = 118
with pytest.raises(ValueError, match="total_frames - trim_frames"):
hardening.validate_assembly_plan_contract(plan)
def test_legacy_schema_one_plan_without_redundant_fields_is_accepted():
plan = _plan()
plan.pop("chunk_count")
plan.pop("natural_frames")
for chunk in plan["chunks"]:
chunk.pop("frame_start")
chunk.pop("frame_stop")
hardening.validate_assembly_plan_contract(plan)
def test_decoded_preflight_rejects_geometry_before_assembly():
plan = _plan()
images, audio = _decoded()
images[1] = torch.zeros((141, 9, 8, 3), dtype=torch.float32)
with pytest.raises(ValueError, match="geometry"):
hardening.preflight_decoded_chunks(images, audio, plan)
def test_decoded_preflight_rejects_sample_rate_change():
plan = _plan()
images, audio = _decoded()
audio[1]["sample_rate"] = 44100
with pytest.raises(ValueError, match="sample_rate"):
hardening.preflight_decoded_chunks(images, audio, plan)
def test_decoded_preflight_accepts_current_two_chunk_contract():
plan = _plan()
images, audio = _decoded()
hardening.preflight_decoded_chunks(images, audio, plan)
def test_storage_stats_deduplicate_shared_storage():
tensor = torch.zeros((2, 3))
stats = hardening.tensor_storage_stats(tensor, tensor)
assert stats["references"] == 2
assert stats["unique_storages"] == 1
def test_memory_snapshot_does_not_probe_uninitialized_cuda(monkeypatch):
def forbidden(*args, **kwargs):
raise BaseException("CPU diagnostics must not query CUDA counters")
monkeypatch.setattr(torch.cuda, "is_initialized", lambda: False)
for name in ("is_available", "memory_allocated", "memory_reserved", "mem_get_info"):
monkeypatch.setattr(torch.cuda, name, forbidden)
tensor = torch.zeros((2, 3))
original = tensor.clone()
rng = torch.random.get_rng_state().clone()
text = hardening.format_memory_snapshot("CPU", tensor)
assert "CUDA_allocated=n/a, CUDA_reserved=n/a, CUDA_free=n/a" in text
assert "CPU_storage=" in text
assert torch.equal(tensor, original)
assert torch.equal(torch.random.get_rng_state(), rng)
def test_memory_snapshot_preserves_initialized_cuda_counters(monkeypatch):
monkeypatch.setattr(torch.cuda, "is_initialized", lambda: True)
monkeypatch.setattr(torch.cuda, "memory_allocated", lambda: 2 * 1024**2)
monkeypatch.setattr(torch.cuda, "memory_reserved", lambda: 3 * 1024**2)
monkeypatch.setattr(torch.cuda, "mem_get_info", lambda: (4 * 1024**2, 8 * 1024**2))
text = hardening.format_memory_snapshot("mock initialized CUDA")
assert "CUDA_allocated=2.0 MiB, CUDA_reserved=3.0 MiB, CUDA_free=4.0 MiB" in text
def test_memory_snapshot_counter_failure_is_diagnostic_only(monkeypatch):
def unavailable():
raise RuntimeError("counter unavailable")
monkeypatch.setattr(torch.cuda, "is_initialized", lambda: True)
monkeypatch.setattr(torch.cuda, "memory_allocated", unavailable)
text = hardening.format_memory_snapshot("counter failure", torch.zeros(1))
assert "CUDA_allocated=n/a, CUDA_reserved=n/a, CUDA_free=n/a" in text
assert "tensor_refs=1" in text
def test_session_storage_audit_reports_shared_cpu_storage():
video = torch.zeros((1, 2, 3))
audio = torch.zeros((1, 2, 4))
entry = {"video": video, "audio": audio}
text = hardening.format_latent_storage_audit([entry], {"chunks": [dict(entry)]})
assert "session_shared=yes" in text
assert "all_cpu=yes" in text
def test_core_chunked_io_capability_is_optional():
supported_model = SimpleNamespace(
comfy_has_chunked_io=True,
decode_output_shape=lambda *args: None,
)
unsupported_model = SimpleNamespace()
assert (
hardening.core_video_vae_chunked_io_status(
SimpleNamespace(first_stage_model=supported_model)
)
== "Supported"
)
assert (
hardening.core_video_vae_chunked_io_status(
SimpleNamespace(first_stage_model=unsupported_model)
)
== "Unsupported"
)
assert hardening.core_video_vae_chunked_io_status(object()) == "Unknown"