git-subtree-dir: vendor/dumas_minimax_h3_refmod git-subtree-split: 517e8c419a8584fbf69fceb487bc39d83e6a6ec8
85 lines
3.8 KiB
Python
85 lines
3.8 KiB
Python
"""Audio backend regressions without loading codec weights."""
|
|
import builtins
|
|
import contextlib
|
|
import importlib
|
|
import math
|
|
import sys
|
|
import types
|
|
import unittest
|
|
from unittest.mock import Mock, patch
|
|
|
|
import test_loaders as loaders
|
|
|
|
torch = loaders.torch
|
|
AUDIO = importlib.import_module(loaders.N.__package__ + ".audio")
|
|
|
|
|
|
class AudioResampleTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.pieces = []
|
|
pieces = self.pieces
|
|
|
|
class Codec:
|
|
def encode(self, waveform):
|
|
pieces.append(waveform.clone())
|
|
return torch.zeros(1, 32, 2, math.ceil(waveform.shape[-1] / 800))
|
|
|
|
self.vae = types.SimpleNamespace(first_stage_model=Codec(), patcher=object(),
|
|
device="cpu", vae_dtype=torch.float32)
|
|
for mocked in (patch.object(AUDIO, "MiniMaxH3AudioVAE", Codec),
|
|
patch.object(AUDIO.model_management, "load_models_gpu"),
|
|
patch.object(AUDIO.model_management, "cuda_device_context",
|
|
side_effect=lambda device: contextlib.nullcontext())):
|
|
mocked.start()
|
|
self.addCleanup(mocked.stop)
|
|
|
|
def backend(self):
|
|
def resample(waveform, orig_freq, new_freq):
|
|
length = math.ceil(waveform.shape[-1] * new_freq / orig_freq)
|
|
return torch.ones(*waveform.shape[:-1], length)
|
|
return types.SimpleNamespace(resample=Mock(side_effect=resample))
|
|
|
|
def test_native_backend_without_torchaudio_clips_before_resampling(self):
|
|
for rate, channels in ((44100, 1), (48000, 2)):
|
|
with self.subTest(rate=rate, channels=channels):
|
|
native = self.backend()
|
|
self.pieces.clear()
|
|
with patch.dict(sys.modules, {"comfy.audio": native, "torchaudio": None,
|
|
"torchaudio.functional": None}):
|
|
z = AUDIO.encode_audio(self.vae, {
|
|
"waveform": torch.zeros(1,channels,rate*2), "sample_rate": rate},
|
|
max_seconds=1.25, chunk_seconds=1)
|
|
wave, orig, new = native.resample.call_args.args
|
|
self.assertEqual(tuple(wave.shape), (1,2,round(rate*1.25)))
|
|
self.assertEqual((orig,new), (rate,32000))
|
|
self.assertEqual([p.shape[-1] for p in self.pieces], [32000,8000])
|
|
self.assertEqual(tuple(z.shape), (1,32,2,50))
|
|
|
|
def test_older_comfyui_uses_torchaudio(self):
|
|
legacy = self.backend()
|
|
with patch.dict(sys.modules, {"comfy.audio": None, "torchaudio.functional": legacy}):
|
|
AUDIO.encode_audio(self.vae, {"waveform": torch.zeros(1,2,4800), "sample_rate": 48000})
|
|
legacy.resample.assert_called_once()
|
|
self.assertEqual(self.pieces[0].shape[-1], 3200)
|
|
|
|
def test_32000_needs_neither_resampler(self):
|
|
with patch.dict(sys.modules, {"comfy.audio": None, "torchaudio": None,
|
|
"torchaudio.functional": None}):
|
|
AUDIO.encode_audio(self.vae, {"waveform": torch.ones(1,1,3200), "sample_rate": 32000})
|
|
torch.testing.assert_close(self.pieces[0], torch.ones(1,2,3200))
|
|
|
|
def test_native_dependency_error_is_not_hidden_by_fallback(self):
|
|
original_import = builtins.__import__
|
|
def failing_import(name, *args, **kwargs):
|
|
if name == "comfy.audio":
|
|
raise ModuleNotFoundError("Missing native dependency", name="scipy")
|
|
return original_import(name, *args, **kwargs)
|
|
with patch.object(builtins, "__import__", side_effect=failing_import):
|
|
with self.assertRaises(ModuleNotFoundError) as error:
|
|
AUDIO.encode_audio(self.vae, {"waveform": torch.zeros(1,2,4800), "sample_rate": 48000})
|
|
self.assertEqual(error.exception.name, "scipy")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|