Preserve Second Pass audio and scoped Review conditioning, strengthen Take compatibility, and align Review Driving Audio. Keep v5 history readable, document v6 restart requirements, and describe the fixes at the top of both READMEs. Remove workstation-specific paths and private operational records from public documentation.
140 lines
6.4 KiB
Python
140 lines
6.4 KiB
Python
from __future__ import annotations
|
|
|
|
import builtins
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
import torch
|
|
|
|
from ComfyUI_H3_Continuum_Join import audio_compat, reference, reference_audio, driving_audio
|
|
from ComfyUI_H3_Continuum_Join.v3.ref_encode_cache import clear_ref_encode_cache
|
|
from . import test_v38_ref_encode_cache as cache_cases
|
|
|
|
|
|
def test_equal_rate_returns_original_without_importing_a_resampler(monkeypatch):
|
|
monkeypatch.setattr(audio_compat.importlib, "import_module", lambda *args: pytest.fail("unneeded import"))
|
|
waveform = torch.arange(200, dtype=torch.float32)
|
|
assert audio_compat.resample_audio(waveform, 32000, 32000) is waveform
|
|
|
|
|
|
@pytest.mark.parametrize("rate", [16000, 22050, 32000, 44100, 48000, 96000])
|
|
@pytest.mark.parametrize("channels", [1, 2])
|
|
def test_resample_is_exactly_core(rate, channels):
|
|
from comfy.audio import resample
|
|
waveform = torch.sin(torch.arange(rate // 10, dtype=torch.float32) * 0.0123).view(1, 1, -1).repeat(1, channels, 1)
|
|
frozen = waveform.clone()
|
|
expected = resample(waveform, rate, 32000)
|
|
actual = audio_compat.resample_audio(waveform, rate, 32000)
|
|
assert actual.shape == expected.shape
|
|
assert actual.dtype == expected.dtype
|
|
assert torch.equal(actual, expected)
|
|
assert torch.equal(waveform, frozen)
|
|
|
|
|
|
@pytest.mark.parametrize("absence", ["module", "api"])
|
|
def test_older_core_uses_the_legacy_adapter_only_if_api_absent(monkeypatch, absence):
|
|
calls = []
|
|
def legacy(waveform, source_rate, target_rate):
|
|
calls.append((source_rate, target_rate))
|
|
return waveform + 1
|
|
def modules(name):
|
|
if name == "comfy.audio":
|
|
if absence == "module":
|
|
raise ModuleNotFoundError("old Core", name="comfy.audio")
|
|
return SimpleNamespace()
|
|
assert name == "torchaudio"
|
|
return SimpleNamespace(functional=SimpleNamespace(resample=legacy))
|
|
monkeypatch.setattr(audio_compat.importlib, "import_module", modules)
|
|
waveform = torch.zeros(1, 1, 20)
|
|
assert torch.equal(audio_compat.resample_audio(waveform, 44100, 32000), waveform + 1)
|
|
assert calls == [(44100, 32000)]
|
|
|
|
|
|
@pytest.mark.parametrize("failure", ["internal_dependency", "core_computation", "both_absent"])
|
|
def test_errors_never_switch_silently_to_a_different_resampler(monkeypatch, failure):
|
|
calls = []
|
|
def core(*args):
|
|
raise ValueError("Core computation failed")
|
|
def modules(name):
|
|
calls.append(name)
|
|
if name == "comfy.audio":
|
|
if failure == "internal_dependency":
|
|
raise ModuleNotFoundError("broken scipy", name="scipy.signal")
|
|
if failure == "core_computation":
|
|
return SimpleNamespace(resample=core)
|
|
raise ModuleNotFoundError("old Core", name="comfy.audio")
|
|
raise ModuleNotFoundError("no legacy module", name="torchaudio")
|
|
monkeypatch.setattr(audio_compat.importlib, "import_module", modules)
|
|
with pytest.raises((ModuleNotFoundError, ValueError, RuntimeError), match={
|
|
"internal_dependency": "broken scipy", "core_computation": "Core computation failed",
|
|
"both_absent": "requires comfy.audio.resample",
|
|
}[failure]):
|
|
audio_compat.resample_audio(torch.zeros(1, 1, 20), 44100, 32000)
|
|
if failure != "both_absent":
|
|
assert calls == ["comfy.audio"]
|
|
|
|
|
|
@pytest.mark.parametrize("rate", [32000, 44100, 48000])
|
|
def test_reference_bundle_and_driving_do_not_require_torchaudio(rate, monkeypatch):
|
|
original_import = builtins.__import__
|
|
def no_torchaudio(name, *args, **kwargs):
|
|
if name == "torchaudio" or name.startswith("torchaudio."):
|
|
raise ModuleNotFoundError("Torchaudio deliberately absent", name="torchaudio")
|
|
return original_import(name, *args, **kwargs)
|
|
monkeypatch.setattr(builtins, "__import__", no_torchaudio)
|
|
from comfy.audio import resample
|
|
waveform = torch.sin(torch.arange(rate, dtype=torch.float32) / 10).view(1, 1, -1)
|
|
source = {"waveform": waveform, "sample_rate": rate}
|
|
vae = cache_cases.AudioVAE()
|
|
reference_source = reference_audio.prepare_reference_audio_source(source, vae)
|
|
bundle = reference_audio.H3ContinuumReferenceAudios().pack(source, None, None, vae)[0]
|
|
assert bundle is not None
|
|
assert reference_source.source_sample_rate == rate
|
|
assert torch.equal(reference_source.waveform, resample(waveform, rate, 32000))
|
|
driving = driving_audio.prepare_driving_audio_source(source, vae, target_frames=12, fps=24)
|
|
effective = waveform[..., :round(rate / 2)]
|
|
assert torch.equal(driving.source_audio["waveform"], effective)
|
|
assert driving.source_audio["sample_rate"] == rate
|
|
assert torch.equal(driving.resampled_waveform, resample(effective, rate, 32000))
|
|
assert driving.contract["preprocess_version"] == 1
|
|
same = reference_audio.prepare_reference_audio_source(source, vae)
|
|
assert same.combined_hash == reference_source.combined_hash
|
|
assert torch.equal(source["waveform"], waveform)
|
|
|
|
|
|
@pytest.mark.parametrize("kind", ["image", "audio"])
|
|
def test_direct_same_vae_weight_mutation_requires_clear_or_reload(kind):
|
|
clear_ref_encode_cache()
|
|
class WeightedImage(cache_cases.ImageVAE):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.weight = torch.tensor(1.)
|
|
def encode(self, image):
|
|
return super().encode(image) + self.weight
|
|
class WeightedAudio(cache_cases.AudioVAE):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.weight = torch.tensor(1.)
|
|
def encode(self, waveform):
|
|
return super().encode(waveform) + self.weight
|
|
vae = WeightedImage() if kind == "image" else WeightedAudio()
|
|
source = cache_cases._image_assets("stability-r5-image") if kind == "image" else cache_cases._audio_source("stability-r5-audio")
|
|
def encode(current):
|
|
if kind == "image":
|
|
return reference.encode_reference_latents_cached(current, source).latents[0]
|
|
return reference_audio.encode_reference_audio_cached(current, source).audio_latent
|
|
cold = encode(vae)
|
|
same = encode(vae)
|
|
assert vae.calls == 1 and torch.equal(cold, same)
|
|
vae.weight.add_(1)
|
|
stale = encode(vae)
|
|
assert vae.calls == 1 and torch.equal(cold, stale)
|
|
clear_ref_encode_cache()
|
|
refreshed = encode(vae)
|
|
assert vae.calls == 2 and torch.equal(refreshed, cold + 1)
|
|
reloaded = type(vae)()
|
|
reloaded.weight.fill_(3)
|
|
assert torch.equal(encode(reloaded), cold + 2)
|
|
assert reloaded.calls == 1
|
|
clear_ref_encode_cache()
|