Files

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, require_comfy_core):
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, require_comfy_core):
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()