mirror of
https://github.com/nomadkaraoke/karaoke-gen.git
synced 2026-11-20 13:07:57 +09:00
@coderabbitai ignore ## Why BACKLOG "audio-separator 0.45–0.47 regression: mel-band RoFormer karaoke models 3–5× slower on L4". The root cause is **python-audio-separator #299 (0.47.0)**, not #298. #299 made RoFormer `overlap` a *window count* that defaults to each model YAML's `num_overlap`. Before that, `overlap` was effectively an 8-second step, which meant almost no overlap. The karaoke models' YAMLs set `num_overlap` 4/8, so a 3-minute track went from 23 forward passes to 87 (aufr33) and 124 (gabox_v2, becruily). That matches the measured 25→75s, 26→149s and 27→157s. 0.45.0 and 0.46.0 still had the old step formula. python-audio-separator #313 (released as **0.47.1**) keeps #299. It adds a per-model forward-pass budget test on every PR and a GPU per-pass timing test (T4: 1.21 s/pass), plus a README note. Andrew chose overlap=2 for gen: smoother chunk seams than 0.44's no-overlap, at about 1.5× the 0.44 compute instead of 4–6×. ## What - `karaoke_gen/audio_processor.py`: `SEPARATOR_MDXC_PARAMS` (overlap=2) goes to all four `Separator(...)` constructions (stage 1, stage 2 karaoke ensemble, single-model paths) **only when audio-separator ≥ 0.47**. On older versions `overlap=2` meant a 2-second step, which is 4× slower, so they keep their defaults. Ensembles load each model through `load_model`, so the param reaches every model in the preset. - `backend/Dockerfile.gpu-base`: `AUDIO_SEPARATOR_VERSION=0.47.1`, with the comment rewritten to explain the root cause. 0.47.1 needs `torch>=2.3` on Linux, so the pre-installed `torch==2.6.0+cu126` (required by the L4 driver) is kept. - The poetry lock stays on 0.44.1. The version-aware params keep CI and CPU images on the old semantics, and there's no torch churn. ## Expected cost per ~3-min track (forward passes) | model | 0.44.2 | 0.47 YAML default | 0.47 + overlap=2 | |---|---|---|---| | karaoke_aufr33 | 23 | 87 | 44 | | karaoke_gabox_v2 | 23 | 124 | 32 | | karaoke_becruily | 23 | 124 | 32 | | instrumental fv7z / resurrection | 23 | 32 / 21 | 32 / 21 | ## Verification plan (before /backlog-finish) After the deploy, time the separation of the daily E2E or a real job on the audio-separation-job logs. I expect roughly 1.5× the 0.44.2 karaoke-stage times (~40–50s per karaoke model rather than 75–157s). If it's worse, revert the pin to 0.44.2. That's one line. ## Testing - `tests/unit/test_audio_processor_local_gpu.py`: version gating (0.47.x/0.48/1.0 → overlap 2; 0.44/0.46 → defaults; unknown → defaults; fresh copy), and both stages' constructors receive `mdxc_params.overlap == 2`. - `make test`: the backend unit suite passes. The only failures are 8 `test_emulator_integration.py` tests, caused by my local environment: another session's emulator setup is on :8080/:4443, and they fail identically on untouched main. CI is green on main. - Local CodeRabbit: 0 findings. 🤖 Generated with [Claude Code](https://claude.com/claude-code) https://claude.ai/code/session_01Jw21syo4HizJJjYw2mg2Vp --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
534 lines
24 KiB
Python
534 lines
24 KiB
Python
import os
|
|
import logging
|
|
import pytest
|
|
from unittest.mock import patch, MagicMock, AsyncMock
|
|
|
|
from backend.workers.audio_worker import create_audio_processor, process_audio_separation
|
|
from karaoke_gen.audio_processor import AudioProcessor
|
|
|
|
|
|
class TestCreateAudioProcessorLocalGPU:
|
|
"""Tests for create_audio_processor with local GPU (model_file_dir set)."""
|
|
|
|
def test_model_file_dir_passed_through(self):
|
|
"""When model_file_dir is provided, AudioProcessor gets it for local separation."""
|
|
processor = create_audio_processor(
|
|
temp_dir="/tmp/test",
|
|
model_file_dir="/models",
|
|
)
|
|
assert processor.model_file_dir == "/models"
|
|
|
|
def test_model_file_dir_none_by_default(self):
|
|
"""When model_file_dir is not provided, AudioProcessor gets None (remote mode)."""
|
|
processor = create_audio_processor(
|
|
temp_dir="/tmp/test",
|
|
)
|
|
assert processor.model_file_dir is None
|
|
|
|
def test_presets_set_by_default(self):
|
|
"""Ensemble presets are always set on the processor."""
|
|
processor = create_audio_processor(
|
|
temp_dir="/tmp/test",
|
|
model_file_dir="/models",
|
|
)
|
|
assert processor.instrumental_preset == "instrumental_clean"
|
|
assert processor.karaoke_preset == "karaoke"
|
|
|
|
def test_custom_presets_override_defaults(self):
|
|
"""Custom presets override the defaults."""
|
|
processor = create_audio_processor(
|
|
temp_dir="/tmp/test",
|
|
model_file_dir="/models",
|
|
instrumental_preset="instrumental_full",
|
|
karaoke_preset="vocal_clean",
|
|
)
|
|
assert processor.instrumental_preset == "instrumental_full"
|
|
assert processor.karaoke_preset == "vocal_clean"
|
|
|
|
|
|
class TestProcessAudioSeparationMode:
|
|
"""Tests for separation mode selection (remote API vs local GPU)."""
|
|
|
|
@pytest.mark.asyncio
|
|
@patch("backend.workers.audio_worker.worker_registry")
|
|
@patch("backend.workers.audio_worker.setup_job_logging")
|
|
@patch("backend.workers.audio_worker.create_job_logger")
|
|
@patch("backend.workers.audio_worker.JobManager")
|
|
@patch("backend.workers.audio_worker.StorageService")
|
|
@patch("backend.workers.audio_worker.get_settings")
|
|
@patch("backend.workers.audio_worker.validate_worker_can_run", return_value=None)
|
|
@patch("backend.workers.audio_worker.download_audio")
|
|
@patch("backend.workers.audio_worker._store_audio_source_metadata")
|
|
@patch("backend.workers.audio_worker.create_audio_processor")
|
|
@patch("backend.workers.audio_worker.upload_separation_results", new_callable=AsyncMock)
|
|
async def test_model_dir_enables_local_gpu(
|
|
self,
|
|
mock_upload,
|
|
mock_create_processor,
|
|
mock_store_metadata,
|
|
mock_download,
|
|
mock_validate,
|
|
mock_settings,
|
|
mock_storage,
|
|
mock_job_manager_cls,
|
|
mock_create_logger,
|
|
mock_setup_logging,
|
|
mock_registry,
|
|
):
|
|
"""When MODEL_DIR is set and AUDIO_SEPARATOR_API_URL is not, uses local GPU."""
|
|
# Make async methods on the registry work properly
|
|
mock_registry.register = AsyncMock()
|
|
mock_registry.unregister = AsyncMock()
|
|
|
|
# Set up environment
|
|
env = {k: v for k, v in os.environ.items()}
|
|
env.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
env["MODEL_DIR"] = "/models"
|
|
|
|
with patch.dict(os.environ, env, clear=True):
|
|
# Set up mocks
|
|
mock_job = MagicMock()
|
|
mock_job.artist = "Test"
|
|
mock_job.title = "Song"
|
|
mock_job.url = None
|
|
mock_job.input_media_gcs_path = "audio/test.wav"
|
|
mock_job.clean_instrumental_model = None
|
|
mock_job.backing_vocals_models = None
|
|
mock_job.other_stems_models = None
|
|
|
|
mock_jm = MagicMock()
|
|
mock_jm.get_job.return_value = mock_job
|
|
# advance_to_screens_if_ready is an async method that the worker awaits
|
|
# after a successful separation (durable prep->screens handoff, #1002).
|
|
# It must be an AsyncMock, or `await` raises TypeError and the worker
|
|
# reports status=error / result=False.
|
|
mock_jm.advance_to_screens_if_ready = AsyncMock(return_value=True)
|
|
mock_job_manager_cls.return_value = mock_jm
|
|
|
|
mock_settings_obj = MagicMock()
|
|
mock_settings_obj.gcs_bucket_name = "test-bucket"
|
|
mock_settings.return_value = mock_settings_obj
|
|
|
|
mock_download.return_value = "/tmp/test.wav"
|
|
mock_create_logger.return_value = MagicMock()
|
|
|
|
mock_processor = MagicMock()
|
|
mock_processor.process_audio_separation.return_value = {
|
|
"clean_instrumental": {"vocals": "/tmp/v.flac", "instrumental": "/tmp/i.flac"},
|
|
"other_stems": {},
|
|
"backing_vocals": {},
|
|
"combined_instrumentals": {},
|
|
}
|
|
mock_create_processor.return_value = mock_processor
|
|
|
|
result = await process_audio_separation("test-job-id")
|
|
|
|
assert result is True
|
|
# Verify model_file_dir="/models" was passed
|
|
mock_create_processor.assert_called_once()
|
|
call_kwargs = mock_create_processor.call_args[1]
|
|
assert call_kwargs.get("model_file_dir") == "/models"
|
|
|
|
@pytest.mark.asyncio
|
|
@patch("backend.workers.audio_worker.worker_registry")
|
|
@patch("backend.workers.audio_worker.setup_job_logging")
|
|
@patch("backend.workers.audio_worker.create_job_logger")
|
|
@patch("backend.workers.audio_worker.JobManager")
|
|
@patch("backend.workers.audio_worker.StorageService")
|
|
@patch("backend.workers.audio_worker.get_settings")
|
|
@patch("backend.workers.audio_worker.validate_worker_can_run", return_value=None)
|
|
async def test_no_api_url_no_model_dir_raises(
|
|
self,
|
|
mock_validate,
|
|
mock_settings,
|
|
mock_storage,
|
|
mock_job_manager_cls,
|
|
mock_create_logger,
|
|
mock_setup_logging,
|
|
mock_registry,
|
|
):
|
|
"""When neither AUDIO_SEPARATOR_API_URL nor MODEL_DIR is set, raises error."""
|
|
# Make async methods on the registry work properly
|
|
mock_registry.register = AsyncMock()
|
|
mock_registry.unregister = AsyncMock()
|
|
|
|
env = {k: v for k, v in os.environ.items()}
|
|
env.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
env.pop("MODEL_DIR", None)
|
|
|
|
with patch.dict(os.environ, env, clear=True):
|
|
mock_job = MagicMock()
|
|
mock_job.artist = "Test"
|
|
mock_job.title = "Song"
|
|
mock_job.url = None
|
|
mock_job.input_media_gcs_path = "audio/test.wav"
|
|
mock_job.clean_instrumental_model = None
|
|
mock_job.backing_vocals_models = None
|
|
mock_job.other_stems_models = None
|
|
|
|
mock_jm = MagicMock()
|
|
mock_jm.get_job.return_value = mock_job
|
|
mock_job_manager_cls.return_value = mock_jm
|
|
|
|
mock_settings_obj = MagicMock()
|
|
mock_settings_obj.gcs_bucket_name = "test-bucket"
|
|
mock_settings.return_value = mock_settings_obj
|
|
mock_create_logger.return_value = MagicMock()
|
|
|
|
# Should fail because no separation mode is configured
|
|
result = await process_audio_separation("test-job-id")
|
|
assert result is False
|
|
|
|
|
|
class TestLocalSeparationWithPresets:
|
|
"""Tests for local audio separation using ensemble presets."""
|
|
|
|
def setup_method(self):
|
|
self.processor = AudioProcessor(
|
|
logger=logging.getLogger("test"),
|
|
log_level=logging.DEBUG,
|
|
log_formatter=None,
|
|
model_file_dir="/models",
|
|
lossless_output_format="FLAC",
|
|
clean_instrumental_model="model_bs_roformer_ep_317_sdr_12.9755.ckpt",
|
|
backing_vocals_models=["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"],
|
|
other_stems_models=[],
|
|
ffmpeg_base_command="ffmpeg",
|
|
)
|
|
self.processor.instrumental_preset = "instrumental_clean"
|
|
self.processor.karaoke_preset = "karaoke"
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_local_separation_uses_ensemble_preset_for_stage1(self, mock_separator_cls, mock_shutil):
|
|
"""Stage 1 uses instrumental_preset on the Separator constructor."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
|
|
# Disable karaoke_preset so stage 2 is skipped, isolating stage 1
|
|
self.processor.karaoke_preset = None
|
|
self.processor.backing_vocals_models = []
|
|
|
|
# Use realistic ensemble preset filenames
|
|
stems_dir = "/tmp/stems"
|
|
mock_sep = MagicMock()
|
|
mock_sep.separate.return_value = [
|
|
f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac",
|
|
f"{stems_dir}/Song_(Instrumental)_preset_instrumental_clean.flac",
|
|
]
|
|
mock_separator_cls.return_value = mock_sep
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Title", "/tmp/output"
|
|
)
|
|
|
|
# Verify Separator was constructed with ensemble_preset="instrumental_clean"
|
|
mock_separator_cls.assert_called_once()
|
|
constructor_kwargs = mock_separator_cls.call_args[1]
|
|
assert constructor_kwargs.get("ensemble_preset") == "instrumental_clean"
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_local_separation_uses_karaoke_preset_for_stage2(self, mock_separator_cls, mock_shutil):
|
|
"""Stage 2 uses karaoke_preset on a fresh Separator for BV separation."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
|
|
stems_dir = "/tmp/stems"
|
|
|
|
# Stage 1 output
|
|
s1_vocals = f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac"
|
|
s1_instrumental = f"{stems_dir}/Song_(Instrumental)_preset_instrumental_clean.flac"
|
|
# Stage 2 output (uses clean-named input)
|
|
s2_lead = f"{stems_dir}/Artist - Title (Vocals)_(Vocals)_preset_karaoke.flac"
|
|
s2_backing = f"{stems_dir}/Artist - Title (Vocals)_(No Vocal)_preset_karaoke.flac"
|
|
|
|
mock_sep1 = MagicMock()
|
|
mock_sep1.separate.return_value = [s1_vocals, s1_instrumental]
|
|
mock_sep2 = MagicMock()
|
|
mock_sep2.separate.return_value = [s2_lead, s2_backing]
|
|
mock_separator_cls.side_effect = [mock_sep1, mock_sep2]
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
mock_shutil.copy2 = MagicMock()
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Title", "/tmp/output"
|
|
)
|
|
|
|
# Separator should be instantiated twice: once for stage 1, once for stage 2
|
|
assert mock_separator_cls.call_count == 2
|
|
stage2_kwargs = mock_separator_cls.call_args_list[1][1]
|
|
assert stage2_kwargs.get("ensemble_preset") == "karaoke"
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("importlib.metadata.version", return_value="0.47.1")
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_both_stages_pass_overlap_two_on_window_overlap_separator(self, mock_separator_cls, mock_shutil, _mock_version):
|
|
"""Stage 1 and the karaoke ensemble (num_overlap 4-8 in YAML) both run with overlap=2."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
|
|
stems_dir = "/tmp/stems"
|
|
mock_sep1 = MagicMock()
|
|
mock_sep1.separate.return_value = [
|
|
f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac",
|
|
f"{stems_dir}/Song_(Instrumental)_preset_instrumental_clean.flac",
|
|
]
|
|
mock_sep2 = MagicMock()
|
|
mock_sep2.separate.return_value = [
|
|
f"{stems_dir}/Artist - Title (Vocals)_(Vocals)_preset_karaoke.flac",
|
|
f"{stems_dir}/Artist - Title (Vocals)_(No Vocal)_preset_karaoke.flac",
|
|
]
|
|
mock_separator_cls.side_effect = [mock_sep1, mock_sep2]
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
mock_shutil.copy2 = MagicMock()
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Title", "/tmp/output"
|
|
)
|
|
|
|
assert mock_separator_cls.call_count == 2
|
|
for call in mock_separator_cls.call_args_list:
|
|
assert call[1]["mdxc_params"]["overlap"] == 2
|
|
|
|
|
|
class TestEnsembleStemTagParsing:
|
|
"""Tests for stem tag extraction from ensemble preset output filenames.
|
|
|
|
Ensemble presets produce files named: {base}_(StemTag)_preset_{name}.flac
|
|
The parser must identify the StemTag (between _( and )_) and NOT be confused
|
|
by the preset name (e.g., "instrumental_clean" contains "instrumental").
|
|
"""
|
|
|
|
def setup_method(self):
|
|
self.processor = AudioProcessor(
|
|
logger=logging.getLogger("test"),
|
|
log_level=logging.DEBUG,
|
|
log_formatter=None,
|
|
model_file_dir="/models",
|
|
lossless_output_format="FLAC",
|
|
clean_instrumental_model="model_bs_roformer_ep_317_sdr_12.9755.ckpt",
|
|
backing_vocals_models=["mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt"],
|
|
other_stems_models=[],
|
|
ffmpeg_base_command="ffmpeg",
|
|
)
|
|
self.processor.instrumental_preset = "instrumental_clean"
|
|
self.processor.karaoke_preset = "karaoke"
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_stage1_instrumental_clean_preset_classifies_vocals_correctly(
|
|
self, mock_separator_cls, mock_shutil
|
|
):
|
|
"""Regression: preset name 'instrumental_clean' must not cause Vocals file
|
|
to be classified as instrumental (the old substring match bug)."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
|
|
# Disable stage 2 to isolate stage 1
|
|
self.processor.karaoke_preset = None
|
|
self.processor.backing_vocals_models = []
|
|
|
|
# Realistic filenames from instrumental_clean ensemble preset
|
|
stems_dir = "/tmp/stems"
|
|
vocals_file = f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac"
|
|
instrumental_file = f"{stems_dir}/Song_(Instrumental)_preset_instrumental_clean.flac"
|
|
|
|
mock_sep = MagicMock()
|
|
mock_sep.separate.return_value = [vocals_file, instrumental_file]
|
|
mock_separator_cls.return_value = mock_sep
|
|
|
|
# shutil.move returns the destination path
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
result = self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Song", "/tmp/output"
|
|
)
|
|
|
|
# Vocals must be set (this is what the bug prevented)
|
|
assert result["clean_instrumental"]["vocals"] == vocals_file
|
|
# Instrumental must also be set
|
|
assert result["clean_instrumental"]["instrumental"] is not None
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_stage1_vocals_path_enables_stage2(self, mock_separator_cls, mock_shutil):
|
|
"""When Stage 1 correctly identifies vocals, Stage 2 runs and produces
|
|
backing vocals + lead vocals stems."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
|
|
stems_dir = "/tmp/stems"
|
|
|
|
# Stage 1 output (instrumental_clean preset)
|
|
s1_vocals = f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac"
|
|
s1_instrumental = f"{stems_dir}/Song_(Instrumental)_preset_instrumental_clean.flac"
|
|
|
|
# Stage 2 output uses the RENAMED clean input, so filenames don't have
|
|
# nested stem tags (this is the fix for the regex collision bug)
|
|
s2_lead = f"{stems_dir}/Artist - Song (Vocals)_(Vocals)_preset_karaoke.flac"
|
|
s2_backing = f"{stems_dir}/Artist - Song (Vocals)_(No Vocal)_preset_karaoke.flac"
|
|
|
|
mock_sep1 = MagicMock()
|
|
mock_sep1.separate.return_value = [s1_vocals, s1_instrumental]
|
|
mock_sep2 = MagicMock()
|
|
mock_sep2.separate.return_value = [s2_lead, s2_backing]
|
|
mock_separator_cls.side_effect = [mock_sep1, mock_sep2]
|
|
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
mock_shutil.copy2 = MagicMock() # For the vocals rename
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
result = self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Song", "/tmp/output"
|
|
)
|
|
|
|
# Stage 2 should have run (Separator instantiated twice)
|
|
assert mock_separator_cls.call_count == 2
|
|
|
|
# Vocals file should have been copied to a clean name for Stage 2
|
|
mock_shutil.copy2.assert_called_once()
|
|
copy_dest = mock_shutil.copy2.call_args[0][1]
|
|
assert "_(Vocals)_preset_instrumental_clean" not in copy_dest
|
|
assert "Artist - Song (Vocals).flac" in copy_dest
|
|
|
|
# Stage 2 separator should receive the clean-named file
|
|
stage2_input = mock_sep2.separate.call_args[0][0]
|
|
assert "_(Vocals)_preset_instrumental_clean" not in stage2_input
|
|
|
|
# Backing vocals correctly classified
|
|
bv = result["backing_vocals"]["karaoke"]
|
|
assert bv["lead_vocals"] == s2_lead
|
|
assert bv["backing_vocals"] == s2_backing
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_stage1_no_vocal_tag_recognized(self, mock_separator_cls, mock_shutil):
|
|
"""Files with '(No Vocal)' stem tag are correctly classified as instrumental."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
self.processor.karaoke_preset = None
|
|
self.processor.backing_vocals_models = []
|
|
|
|
stems_dir = "/tmp/stems"
|
|
vocals_file = f"{stems_dir}/Song_(Vocals)_preset_instrumental_clean.flac"
|
|
no_vocal_file = f"{stems_dir}/Song_(No Vocal)_preset_instrumental_clean.flac"
|
|
|
|
mock_sep = MagicMock()
|
|
mock_sep.separate.return_value = [vocals_file, no_vocal_file]
|
|
mock_separator_cls.return_value = mock_sep
|
|
mock_shutil.move.side_effect = lambda src, dst: dst
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
result = self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Song", "/tmp/output"
|
|
)
|
|
|
|
assert result["clean_instrumental"]["vocals"] == vocals_file
|
|
assert result["clean_instrumental"]["instrumental"] is not None
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_unrecognized_stem_tag_logs_warning(self, mock_separator_cls, mock_shutil):
|
|
"""Files with unrecognized stem tags produce a warning log."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
self.processor.karaoke_preset = None
|
|
self.processor.backing_vocals_models = []
|
|
|
|
stems_dir = "/tmp/stems"
|
|
weird_file = f"{stems_dir}/Song_(Drums)_preset_instrumental_clean.flac"
|
|
|
|
mock_sep = MagicMock()
|
|
mock_sep.separate.return_value = [weird_file]
|
|
mock_separator_cls.return_value = mock_sep
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
with patch.object(self.processor.logger, 'warning') as mock_warn:
|
|
result = self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Song", "/tmp/output"
|
|
)
|
|
|
|
mock_warn.assert_called_once()
|
|
assert "drums" in mock_warn.call_args[0][0].lower()
|
|
|
|
@patch.dict(os.environ, {}, clear=False)
|
|
@patch("karaoke_gen.audio_processor.shutil")
|
|
@patch("karaoke_gen.audio_processor.Separator")
|
|
def test_filename_without_stem_tag_pattern_logs_warning(self, mock_separator_cls, mock_shutil):
|
|
"""Files missing the _(Tag)_ pattern produce a warning."""
|
|
os.environ.pop("AUDIO_SEPARATOR_API_URL", None)
|
|
self.processor.karaoke_preset = None
|
|
self.processor.backing_vocals_models = []
|
|
|
|
stems_dir = "/tmp/stems"
|
|
plain_file = f"{stems_dir}/vocals.flac"
|
|
|
|
mock_sep = MagicMock()
|
|
mock_sep.separate.return_value = [plain_file]
|
|
mock_separator_cls.return_value = mock_sep
|
|
|
|
with patch.object(self.processor, '_create_stems_directory', return_value=stems_dir):
|
|
with patch.object(self.processor, '_normalize_audio_files'):
|
|
with patch.object(self.processor, '_generate_combined_instrumentals', return_value={}):
|
|
with patch.object(self.processor.logger, 'warning') as mock_warn:
|
|
result = self.processor.process_audio_separation(
|
|
"/tmp/test.wav", "Artist - Song", "/tmp/output"
|
|
)
|
|
|
|
mock_warn.assert_called_once()
|
|
# Should not have classified anything
|
|
assert result["clean_instrumental"].get("vocals") is None
|
|
assert result["clean_instrumental"].get("instrumental") is None
|
|
|
|
|
|
class TestSeparatorOverlapParams:
|
|
"""audio-separator >= 0.47 counts RoFormer overlap in windows; gen pins 2 to keep karaoke models fast."""
|
|
|
|
def _kwargs_for_version(self, installed):
|
|
from karaoke_gen import audio_processor
|
|
|
|
with patch("importlib.metadata.version", return_value=installed):
|
|
return audio_processor._separator_kwargs()
|
|
|
|
def test_window_overlap_versions_get_overlap_two(self):
|
|
for installed in ("0.47.0", "0.47.1", "0.48.2", "1.0.0"):
|
|
kwargs = self._kwargs_for_version(installed)
|
|
assert kwargs["mdxc_params"]["overlap"] == 2, installed
|
|
assert kwargs["mdxc_params"]["batch_size"] is None
|
|
|
|
def test_seconds_overlap_versions_keep_library_defaults(self):
|
|
# Before 0.47 overlap=2 meant a 2 s step: 4x the passes of the 8 s default.
|
|
for installed in ("0.44.1", "0.44.2", "0.46.0"):
|
|
assert self._kwargs_for_version(installed) == {}, installed
|
|
|
|
def test_unknown_version_keeps_library_defaults(self):
|
|
from karaoke_gen import audio_processor
|
|
|
|
with patch("importlib.metadata.version", side_effect=Exception("not installed")):
|
|
assert audio_processor._separator_kwargs() == {}
|
|
|
|
def test_returns_a_fresh_copy(self):
|
|
kwargs = self._kwargs_for_version("0.47.1")
|
|
kwargs["mdxc_params"]["overlap"] = 8
|
|
assert self._kwargs_for_version("0.47.1")["mdxc_params"]["overlap"] == 2
|