Update app.py

app.py

@@ -1,1474 +1,108 @@
 import os
-# os.system("pip install ./ort_nightly_gpu-1.17.0.dev20240118002-cp310-cp310-manylinux_2_28_x86_64.whl")
-os.system("pip install ort-nightly-gpu --index-url=https://aiinfra.pkgs.visualstudio.com/PublicPackages/_packaging/ort-cuda-12-nightly/pypi/simple/")
-import gc
-import hashlib
-import queue
-import threading
-import json
-import shlex
-import sys
+import tempfile
 import subprocess
-import librosa
-import numpy as np
-import soundfile as sf
-import torch
-from tqdm import tqdm
-from utils import (
-    remove_directory_contents,
-    create_directories,
-    download_manager,
-)
-import random
-import spaces
-from utils import logger
-import onnxruntime as ort
-import warnings
-import spaces
 import gradio as gr
 import logging
-import time
-import traceback
-from pedalboard import Pedalboard, Reverb, Delay, Chorus, Compressor, Gain, HighpassFilter, LowpassFilter
-from pedalboard.io import AudioFile
-import numpy as np
-import yt_dlp
+from pathlib import Path
 
-warnings.filterwarnings("ignore")
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("demucs")
 
-title = "<center><strong><font size='7'>Audio🔹separator</font></strong></center>"
-description = "This demo uses the MDX-Net models for vocal and background sound separation."
-theme = "NoCrypt/miku"
+DEFAULT_MODEL = "htdemucs"
 
-stem_naming = {
-    "Vocals": "Instrumental",
-    "Other": "Instruments",
-    "Instrumental": "Vocals",
-    "Drums": "Drumless",
-    "Bass": "Bassless",
-}
-
-
-class MDXModel:
-    def __init__(
-        self,
-        device,
-        dim_f,
-        dim_t,
-        n_fft,
-        hop=1024,
-        stem_name=None,
-        compensation=1.000,
-    ):
-        self.dim_f = dim_f
-        self.dim_t = dim_t
-        self.dim_c = 4
-        self.n_fft = n_fft
-        self.hop = hop
-        self.stem_name = stem_name
-        self.compensation = compensation
-
-        self.n_bins = self.n_fft // 2 + 1
-        self.chunk_size = hop * (self.dim_t - 1)
-        self.window = torch.hann_window(
-            window_length=self.n_fft, periodic=True
-        ).to(device)
-
-        out_c = self.dim_c
-
-        self.freq_pad = torch.zeros(
-            [1, out_c, self.n_bins - self.dim_f, self.dim_t]
-        ).to(device)
-
-    def stft(self, x):
-        x = x.reshape([-1, self.chunk_size])
-        x = torch.stft(
-            x,
-            n_fft=self.n_fft,
-            hop_length=self.hop,
-            window=self.window,
-            center=True,
-            return_complex=True,
-        )
-        x = torch.view_as_real(x)
-        x = x.permute([0, 3, 1, 2])
-        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape(
-            [-1, 4, self.n_bins, self.dim_t]
-        )
-        return x[:, :, : self.dim_f]
-
-    def istft(self, x, freq_pad=None):
-        freq_pad = (
-            self.freq_pad.repeat([x.shape[0], 1, 1, 1])
-            if freq_pad is None
-            else freq_pad
-        )
-        x = torch.cat([x, freq_pad], -2)
-        # c = 4*2 if self.target_name=='*' else 2
-        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape(
-            [-1, 2, self.n_bins, self.dim_t]
-        )
-        x = x.permute([0, 2, 3, 1])
-        x = x.contiguous()
-        x = torch.view_as_complex(x)
-        x = torch.istft(
-            x,
-            n_fft=self.n_fft,
-            hop_length=self.hop,
-            window=self.window,
-            center=True,
-        )
-        return x.reshape([-1, 2, self.chunk_size])
-
-
-class MDX:
-    DEFAULT_SR = 44100
-    # Unit: seconds
-    DEFAULT_CHUNK_SIZE = 0 * DEFAULT_SR
-    DEFAULT_MARGIN_SIZE = 1 * DEFAULT_SR
-
-    def __init__(
-        self, model_path: str, params: MDXModel, processor=0
-    ):
-        # Set the device and the provider (CPU or CUDA)
-        self.device = (
-            torch.device(f"cuda:{processor}")
-            if processor >= 0
-            else torch.device("cpu")
-        )
-        self.provider = (
-            ["CUDAExecutionProvider"]
-            if processor >= 0
-            else ["CPUExecutionProvider"]
-        )
-
-        self.model = params
-
-        # Load the ONNX model using ONNX Runtime
-        self.ort = ort.InferenceSession(model_path, providers=self.provider)
-        # Preload the model for faster performance
-        self.ort.run(
-            None,
-            {"input": torch.rand(1, 4, params.dim_f, params.dim_t).numpy()},
-        )
-        self.process = lambda spec: self.ort.run(
-            None, {"input": spec.cpu().numpy()}
-        )[0]
-
-        self.prog = None
-
-    @staticmethod
-    def get_hash(model_path):
-        try:
-            with open(model_path, "rb") as f:
-                f.seek(-10000 * 1024, 2)
-                model_hash = hashlib.md5(f.read()).hexdigest()
-        except: # noqa
-            model_hash = hashlib.md5(open(model_path, "rb").read()).hexdigest()
-
-        return model_hash
-
-    @staticmethod
-    def segment(
-        wave,
-        combine=True,
-        chunk_size=DEFAULT_CHUNK_SIZE,
-        margin_size=DEFAULT_MARGIN_SIZE,
-    ):
-        """
-        Segment or join segmented wave array
-        Args:
-            wave: (np.array) Wave array to be segmented or joined
-            combine: (bool) If True, combines segmented wave array.
-                If False, segments wave array.
-            chunk_size: (int) Size of each segment (in samples)
-            margin_size: (int) Size of margin between segments (in samples)
-        Returns:
-            numpy array: Segmented or joined wave array
-        """
-
-        if combine:
-            # Initializing as None instead of [] for later numpy array concatenation
-            processed_wave = None
-            for segment_count, segment in enumerate(wave):
-                start = 0 if segment_count == 0 else margin_size
-                end = None if segment_count == len(wave) - 1 else -margin_size
-                if margin_size == 0:
-                    end = None
-                if processed_wave is None:  # Create array for first segment
-                    processed_wave = segment[:, start:end]
-                else:  # Concatenate to existing array for subsequent segments
-                    processed_wave = np.concatenate(
-                        (processed_wave, segment[:, start:end]), axis=-1
-                    )
-
-        else:
-            processed_wave = []
-            sample_count = wave.shape[-1]
-
-            if chunk_size <= 0 or chunk_size > sample_count:
-                chunk_size = sample_count
-
-            if margin_size > chunk_size:
-                margin_size = chunk_size
-
-            for segment_count, skip in enumerate(
-                range(0, sample_count, chunk_size)
-            ):
-                margin = 0 if segment_count == 0 else margin_size
-                end = min(skip + chunk_size + margin_size, sample_count)
-                start = skip - margin
-
-                cut = wave[:, start:end].copy()
-                processed_wave.append(cut)
-
-                if end == sample_count:
-                    break
-
-        return processed_wave
-
-    def pad_wave(self, wave):
-        """
-        Pad the wave array to match the required chunk size
-        Args:
-            wave: (np.array) Wave array to be padded
-        Returns:
-            tuple: (padded_wave, pad, trim)
-                - padded_wave: Padded wave array
-                - pad: Number of samples that were padded
-                - trim: Number of samples that were trimmed
-        """
-        n_sample = wave.shape[1]
-        trim = self.model.n_fft // 2
-        gen_size = self.model.chunk_size - 2 * trim
-        pad = gen_size - n_sample % gen_size
-
-        # Padded wave
-        wave_p = np.concatenate(
-            (
-                np.zeros((2, trim)),
-                wave,
-                np.zeros((2, pad)),
-                np.zeros((2, trim)),
-            ),
-            1,
-        )
-
-        mix_waves = []
-        for i in range(0, n_sample + pad, gen_size):
-            waves = np.array(wave_p[:, i:i + self.model.chunk_size])
-            mix_waves.append(waves)
-
-        mix_waves = torch.tensor(mix_waves, dtype=torch.float32).to(
-            self.device
-        )
-
-        return mix_waves, pad, trim
-
-    def _process_wave(self, mix_waves, trim, pad, q: queue.Queue, _id: int):
-        """
-        Process each wave segment in a multi-threaded environment
-        Args:
-            mix_waves: (torch.Tensor) Wave segments to be processed
-            trim: (int) Number of samples trimmed during padding
-            pad: (int) Number of samples padded during padding
-            q: (queue.Queue) Queue to hold the processed wave segments
-            _id: (int) Identifier of the processed wave segment
-        Returns:
-            numpy array: Processed wave segment
-        """
-        mix_waves = mix_waves.split(1)
-        with torch.no_grad():
-            pw = []
-            for mix_wave in mix_waves:
-                self.prog.update()
-                spec = self.model.stft(mix_wave)
-                processed_spec = torch.tensor(self.process(spec))
-                processed_wav = self.model.istft(
-                    processed_spec.to(self.device)
-                )
-                processed_wav = (
-                    processed_wav[:, :, trim:-trim]
-                    .transpose(0, 1)
-                    .reshape(2, -1)
-                    .cpu()
-                    .numpy()
-                )
-                pw.append(processed_wav)
-        processed_signal = np.concatenate(pw, axis=-1)[:, :-pad]
-        q.put({_id: processed_signal})
-        return processed_signal
-
-    def process_wave(self, wave: np.array, mt_threads=1):
-        """
-        Process the wave array in a multi-threaded environment
-        Args:
-            wave: (np.array) Wave array to be processed
-            mt_threads: (int) Number of threads to be used for processing
-        Returns:
-            numpy array: Processed wave array
-        """
-        self.prog = tqdm(total=0)
-        chunk = wave.shape[-1] // mt_threads
-        waves = self.segment(wave, False, chunk)
-
-        # Create a queue to hold the processed wave segments
-        q = queue.Queue()
-        threads = []
-        for c, batch in enumerate(waves):
-            mix_waves, pad, trim = self.pad_wave(batch)
-            self.prog.total = len(mix_waves) * mt_threads
-            thread = threading.Thread(
-                target=self._process_wave, args=(mix_waves, trim, pad, q, c)
-            )
-            thread.start()
-            threads.append(thread)
-        for thread in threads:
-            thread.join()
-        self.prog.close()
-
-        processed_batches = []
-        while not q.empty():
-            processed_batches.append(q.get())
-        processed_batches = [
-            list(wave.values())[0]
-            for wave in sorted(
-                processed_batches, key=lambda d: list(d.keys())[0]
-            )
-        ]
-        assert len(processed_batches) == len(
-            waves
-        ), "Incomplete processed batches, please reduce batch size!"
-        return self.segment(processed_batches, True, chunk)
-
-
-@spaces.GPU()
-def run_mdx(
-    model_params,
-    output_dir,
-    model_path,
-    filename,
-    exclude_main=False,
-    exclude_inversion=False,
-    suffix=None,
-    invert_suffix=None,
-    denoise=False,
-    keep_orig=True,
-    m_threads=2,
-    device_base="cuda",
-):
-
-    if device_base == "cuda":
-        device = torch.device("cuda:0")
-        processor_num = 0
-        device_properties = torch.cuda.get_device_properties(device)
-        vram_gb = device_properties.total_memory / 1024**3
-        m_threads = 1 if vram_gb < 8 else (8 if vram_gb > 32 else 2)
-        logger.info(f"threads: {m_threads} vram: {vram_gb}")
-    else:
-        device = torch.device("cpu")
-        processor_num = -1
-        m_threads = 1
-
-    model_hash = MDX.get_hash(model_path)
-    mp = model_params.get(model_hash)
-    model = MDXModel(
-        device,
-        dim_f=mp["mdx_dim_f_set"],
-        dim_t=2 ** mp["mdx_dim_t_set"],
-        n_fft=mp["mdx_n_fft_scale_set"],
-        stem_name=mp["primary_stem"],
-        compensation=mp["compensate"],
-    )
-
-    mdx_sess = MDX(model_path, model, processor=processor_num)
-    wave, sr = librosa.load(filename, mono=False, sr=44100)
-    # normalizing input wave gives better output
-    peak = max(np.max(wave), abs(np.min(wave)))
-    wave /= peak
-    if denoise:
-        wave_processed = -(mdx_sess.process_wave(-wave, m_threads)) + (
-            mdx_sess.process_wave(wave, m_threads)
-        )
-        wave_processed *= 0.5
-    else:
-        wave_processed = mdx_sess.process_wave(wave, m_threads)
-    # return to previous peak
-    wave_processed *= peak
-    stem_name = model.stem_name if suffix is None else suffix
-
-    main_filepath = None
-    if not exclude_main:
-        main_filepath = os.path.join(
-            output_dir,
-            f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav",
-        )
-        sf.write(main_filepath, wave_processed.T, sr)
-
-    invert_filepath = None
-    if not exclude_inversion:
-        diff_stem_name = (
-            stem_naming.get(stem_name)
-            if invert_suffix is None
-            else invert_suffix
-        )
-        stem_name = (
-            f"{stem_name}_diff" if diff_stem_name is None else diff_stem_name
-        )
-        invert_filepath = os.path.join(
-            output_dir,
-            f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav",
-        )
-        sf.write(
-            invert_filepath,
-            (-wave_processed.T * model.compensation) + wave.T,
-            sr,
-        )
-
-    if not keep_orig:
-        os.remove(filename)
-
-    del mdx_sess, wave_processed, wave
-    gc.collect()
-    torch.cuda.empty_cache()
-    return main_filepath, invert_filepath
-
-
-def run_mdx_beta(
-    model_params,
-    output_dir,
-    model_path,
-    filename,
-    exclude_main=False,
-    exclude_inversion=False,
-    suffix=None,
-    invert_suffix=None,
-    denoise=False,
-    keep_orig=True,
-    m_threads=2,
-    device_base="",
-):
-
-    m_threads = 1
-    duration = librosa.get_duration(filename=filename)
-    if duration >= 60 and duration <= 120:
-        m_threads = 8
-    elif duration > 120:
-        m_threads = 16
-
-    logger.info(f"threads: {m_threads}")
-
-    model_hash = MDX.get_hash(model_path)
-    device = torch.device("cpu")
-    processor_num = -1
-    mp = model_params.get(model_hash)
-    model = MDXModel(
-        device,
-        dim_f=mp["mdx_dim_f_set"],
-        dim_t=2 ** mp["mdx_dim_t_set"],
-        n_fft=mp["mdx_n_fft_scale_set"],
-        stem_name=mp["primary_stem"],
-        compensation=mp["compensate"],
-    )
-
-    mdx_sess = MDX(model_path, model, processor=processor_num)
-    wave, sr = librosa.load(filename, mono=False, sr=44100)
-    # normalizing input wave gives better output
-    peak = max(np.max(wave), abs(np.min(wave)))
-    wave /= peak
-    if denoise:
-        wave_processed = -(mdx_sess.process_wave(-wave, m_threads)) + (
-            mdx_sess.process_wave(wave, m_threads)
-        )
-        wave_processed *= 0.5
-    else:
-        wave_processed = mdx_sess.process_wave(wave, m_threads)
-    # return to previous peak
-    wave_processed *= peak
-    stem_name = model.stem_name if suffix is None else suffix
-
-    main_filepath = None
-    if not exclude_main:
-        main_filepath = os.path.join(
-            output_dir,
-            f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav",
-        )
-        sf.write(main_filepath, wave_processed.T, sr)
-
-    invert_filepath = None
-    if not exclude_inversion:
-        diff_stem_name = (
-            stem_naming.get(stem_name)
-            if invert_suffix is None
-            else invert_suffix
-        )
-        stem_name = (
-            f"{stem_name}_diff" if diff_stem_name is None else diff_stem_name
-        )
-        invert_filepath = os.path.join(
-            output_dir,
-            f"{os.path.basename(os.path.splitext(filename)[0])}_{stem_name}.wav",
-        )
-        sf.write(
-            invert_filepath,
-            (-wave_processed.T * model.compensation) + wave.T,
-            sr,
-        )
-
-    if not keep_orig:
-        os.remove(filename)
-
-    del mdx_sess, wave_processed, wave
-    gc.collect()
-    torch.cuda.empty_cache()
-    return main_filepath, invert_filepath
-
-
-MDX_DOWNLOAD_LINK = "https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/"
-UVR_MODELS = [
-    "UVR-MDX-NET-Voc_FT.onnx",
-    "UVR_MDXNET_KARA_2.onnx",
-    "Reverb_HQ_By_FoxJoy.onnx",
-    "UVR-MDX-NET-Inst_HQ_4.onnx",
-]
-BASE_DIR = "."  # os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-mdxnet_models_dir = os.path.join(BASE_DIR, "mdx_models")
-output_dir = os.path.join(BASE_DIR, "clean_song_output")
-
-
-def convert_to_stereo_and_wav(audio_path):
-    wave, sr = librosa.load(audio_path, mono=False, sr=44100)
-
-    # check if mono
-    if type(wave[0]) != np.ndarray or audio_path[-4:].lower() != ".wav": # noqa
-        stereo_path = f"{os.path.splitext(audio_path)[0]}_stereo.wav"
-        stereo_path = os.path.join(output_dir, stereo_path)
-
-        command = shlex.split(
-            f'ffmpeg -y -loglevel error -i "{audio_path}" -ac 2 -f wav "{stereo_path}"'
-        )
-        sub_params = {
-            "stdout": subprocess.PIPE,
-            "stderr": subprocess.PIPE,
-            "creationflags": subprocess.CREATE_NO_WINDOW
-            if sys.platform == "win32"
-            else 0,
-        }
-        process_wav = subprocess.Popen(command, **sub_params)
-        output, errors = process_wav.communicate()
-        if process_wav.returncode != 0 or not os.path.exists(stereo_path):
-            raise Exception("Error processing audio to stereo wav")
-
-        return stereo_path
-    else:
-        return audio_path
-
-
-def get_hash(filepath):
-    with open(filepath, 'rb') as f:
-        file_hash = hashlib.blake2b()
-        while chunk := f.read(8192):
-            file_hash.update(chunk)
-
-    return file_hash.hexdigest()[:18]
-
-def random_sleep():
-    sleep_time = round(random.uniform(5.2, 7.9), 1)
-    time.sleep(sleep_time)
-
-def process_uvr_task(
-    orig_song_path: str = "aud_test.mp3",
-    main_vocals: bool = False,
-    dereverb: bool = True,
-    song_id: str = "mdx",  # folder output name
-    only_voiceless: bool = False,
-    remove_files_output_dir: bool = False,
-):
-
-    device_base = "cuda" if torch.cuda.is_available() else "cpu"
-    logger.info(f"Device: {device_base}")
-
-    if remove_files_output_dir:
-        remove_directory_contents(output_dir)
-
-    with open(os.path.join(mdxnet_models_dir, "data.json")) as infile:
-        mdx_model_params = json.load(infile)
-
-    song_output_dir = os.path.join(output_dir, song_id)
-    create_directories(song_output_dir)
-    orig_song_path = convert_to_stereo_and_wav(orig_song_path)
-
-    logger.info(f"onnxruntime device >> {ort.get_device()}")
-
-    if only_voiceless:
-        logger.info("Voiceless Track Separation...")
-
-        process = run_mdx(
-            mdx_model_params,
-            song_output_dir,
-            os.path.join(mdxnet_models_dir, "UVR-MDX-NET-Inst_HQ_4.onnx"),
-            orig_song_path,
-            suffix="Voiceless",
-            denoise=False,
-            keep_orig=True,
-            exclude_inversion=True,
-            device_base=device_base,
-        )
-
-        return process
-
-    logger.info("Vocal Track Isolation...")
-    vocals_path, instrumentals_path = run_mdx(
-        mdx_model_params,
-        song_output_dir,
-        os.path.join(mdxnet_models_dir, "UVR-MDX-NET-Voc_FT.onnx"),
-        orig_song_path,
-        denoise=True,
-        keep_orig=True,
-        device_base=device_base,
-    )
-
-    if main_vocals:
-        random_sleep()
-        msg_main = "Main Voice Separation from Supporting Vocals..."
-        logger.info(msg_main)
-        gr.Info(msg_main)
-        try:
-            backup_vocals_path, main_vocals_path = run_mdx(
-                mdx_model_params,
-                song_output_dir,
-                os.path.join(mdxnet_models_dir, "UVR_MDXNET_KARA_2.onnx"),
-                vocals_path,
-                suffix="Backup",
-                invert_suffix="Main",
-                denoise=True,
-                device_base=device_base,
-            )
-        except Exception as e:
-                backup_vocals_path, main_vocals_path = run_mdx_beta(
-                    mdx_model_params,
-                    song_output_dir,
-                    os.path.join(mdxnet_models_dir, "UVR_MDXNET_KARA_2.onnx"),
-                    vocals_path,
-                    suffix="Backup",
-                    invert_suffix="Main",
-                    denoise=True,
-                    device_base=device_base,
-                )
-    else:
-        backup_vocals_path, main_vocals_path = None, vocals_path
-
-    if dereverb:
-        random_sleep()
-        msg_dereverb = "Vocal Clarity Enhancement through De-Reverberation..."
-        logger.info(msg_dereverb)
-        gr.Info(msg_dereverb)
-        try:
-            _, vocals_dereverb_path = run_mdx(
-                mdx_model_params,
-                song_output_dir,
-                os.path.join(mdxnet_models_dir, "Reverb_HQ_By_FoxJoy.onnx"),
-                main_vocals_path,
-                invert_suffix="DeReverb",
-                exclude_main=True,
-                denoise=True,
-                device_base=device_base,
-            )
-        except Exception as e:
-                _, vocals_dereverb_path = run_mdx_beta(
-                    mdx_model_params,
-                    song_output_dir,
-                    os.path.join(mdxnet_models_dir, "Reverb_HQ_By_FoxJoy.onnx"),
-                    main_vocals_path,
-                    invert_suffix="DeReverb",
-                    exclude_main=True,
-                    denoise=True,
-                    device_base=device_base,
-                )
-    else:
-        vocals_dereverb_path = main_vocals_path
-
-    return (
-        vocals_path,
-        instrumentals_path,
-        backup_vocals_path,
-        main_vocals_path,
-        vocals_dereverb_path,
-    )
-
-
-def add_vocal_effects(input_file, output_file, reverb_room_size=0.6, vocal_reverb_dryness=0.8, reverb_damping=0.6, reverb_wet_level=0.35,
-                      delay_seconds=0.4, delay_mix=0.25,
-                      compressor_threshold_db=-25, compressor_ratio=3.5, compressor_attack_ms=10, compressor_release_ms=60,
-                      gain_db=3):
-
-    effects = [HighpassFilter()]
-
-    effects.append(Reverb(room_size=reverb_room_size, damping=reverb_damping, wet_level=reverb_wet_level, dry_level=vocal_reverb_dryness))
-
-    effects.append(Compressor(threshold_db=compressor_threshold_db, ratio=compressor_ratio,
-                              attack_ms=compressor_attack_ms, release_ms=compressor_release_ms))
-
-    if delay_seconds > 0 or delay_mix > 0:
-        effects.append(Delay(delay_seconds=delay_seconds, mix=delay_mix))
-        print("delay applied")
-    # effects.append(Chorus())
-
-    if gain_db:
-        effects.append(Gain(gain_db=gain_db))
-        print("added gain db")
-
-    board = Pedalboard(effects)
-
-    with AudioFile(input_file) as f:
-        with AudioFile(output_file, 'w', f.samplerate, f.num_channels) as o:
-            # Read one second of audio at a time, until the file is empty:
-            while f.tell() < f.frames:
-                chunk = f.read(int(f.samplerate))
-                effected = board(chunk, f.samplerate, reset=False)
-                o.write(effected)
-
-
-def add_instrumental_effects(input_file, output_file, highpass_freq=100, lowpass_freq=12000,
-                             reverb_room_size=0.5, reverb_damping=0.5, reverb_wet_level=0.25,
-                             compressor_threshold_db=-20, compressor_ratio=2.5, compressor_attack_ms=15, compressor_release_ms=80,
-                             gain_db=2):
-
-    effects = [
-        HighpassFilter(cutoff_frequency_hz=highpass_freq),
-        LowpassFilter(cutoff_frequency_hz=lowpass_freq),
-    ]
-    if reverb_room_size > 0 or reverb_damping > 0 or reverb_wet_level > 0:
-        effects.append(Reverb(room_size=reverb_room_size, damping=reverb_damping, wet_level=reverb_wet_level))
-
-    effects.append(Compressor(threshold_db=compressor_threshold_db, ratio=compressor_ratio,
-                              attack_ms=compressor_attack_ms, release_ms=compressor_release_ms))
-
-    if gain_db:
-        effects.append(Gain(gain_db=gain_db))
-
-    board = Pedalboard(effects)
-
-    with AudioFile(input_file) as f:
-        with AudioFile(output_file, 'w', f.samplerate, f.num_channels) as o:
-            # Read one second of audio at a time, until the file is empty:
-            while f.tell() < f.frames:
-                chunk = f.read(int(f.samplerate))
-                effected = board(chunk, f.samplerate, reset=False)
-                o.write(effected)
-
-    
-def sound_separate(media_file, stem, main, dereverb, vocal_effects=True, background_effects=True,
-                   vocal_reverb_room_size=0.6, vocal_reverb_damping=0.6, vocal_reverb_wet_level=0.35,
-                   vocal_delay_seconds=0.4, vocal_delay_mix=0.25,
-                   vocal_compressor_threshold_db=-25, vocal_compressor_ratio=3.5, vocal_compressor_attack_ms=10, vocal_compressor_release_ms=60,
-                   vocal_gain_db=4,
-                   background_highpass_freq=120, background_lowpass_freq=11000,
-                   background_reverb_room_size=0.5, background_reverb_damping=0.5, background_reverb_wet_level=0.25,
-                   background_compressor_threshold_db=-20, background_compressor_ratio=2.5, background_compressor_attack_ms=15, background_compressor_release_ms=80,
-                   background_gain_db=3):
-    if not media_file:
-        raise ValueError("The audio path is missing.")
-
-    if not stem:
-        raise ValueError("Please select 'vocal' or 'background' stem.")
-
-    hash_audio = str(get_hash(media_file))
-    media_dir = os.path.dirname(media_file)
-
-    outputs = []
-
-    start_time = time.time()
-
-    if stem == "vocal":
-        try:
-            _, _, _, _, vocal_audio = process_uvr_task(
-                orig_song_path=media_file,
-                song_id=hash_audio + "mdx",
-                main_vocals=main,
-                dereverb=dereverb,
-                remove_files_output_dir=False,
-            )
-
-            if vocal_effects:
-                suffix = '_effects'
-                file_name, file_extension = os.path.splitext(vocal_audio)
-                out_effects = file_name + suffix + file_extension
-                out_effects_path = os.path.join(media_dir, out_effects)
-                add_vocal_effects(vocal_audio, out_effects_path,
-                                  reverb_room_size=vocal_reverb_room_size, reverb_damping=vocal_reverb_damping, reverb_wet_level=vocal_reverb_wet_level,
-                                  delay_seconds=vocal_delay_seconds, delay_mix=vocal_delay_mix,
-                                  compressor_threshold_db=vocal_compressor_threshold_db, compressor_ratio=vocal_compressor_ratio, compressor_attack_ms=vocal_compressor_attack_ms, compressor_release_ms=vocal_compressor_release_ms,
-                                  gain_db=vocal_gain_db
-                                  )
-                vocal_audio = out_effects_path
-
-            outputs.append(vocal_audio)
-        except Exception as error:
-            logger.error(str(error))
-            traceback.print_exc()
-
-    if stem == "background":
-        background_audio, _ = process_uvr_task(
-            orig_song_path=media_file,
-            song_id=hash_audio + "voiceless",
-            only_voiceless=True,
-            remove_files_output_dir=False,
-        )
-
-        if background_effects:
-            suffix = '_effects'
-            file_name, file_extension = os.path.splitext(background_audio)
-            out_effects = file_name + suffix + file_extension
-            out_effects_path = os.path.join(media_dir, out_effects)
-            add_instrumental_effects(background_audio, out_effects_path,
-                                     highpass_freq=background_highpass_freq, lowpass_freq=background_lowpass_freq,
-                                     reverb_room_size=background_reverb_room_size, reverb_damping=background_reverb_damping, reverb_wet_level=background_reverb_wet_level,
-                                     compressor_threshold_db=background_compressor_threshold_db, compressor_ratio=background_compressor_ratio, compressor_attack_ms=background_compressor_attack_ms, compressor_release_ms=background_compressor_release_ms,
-                                     gain_db=background_gain_db
-                                     )
-            background_audio = out_effects_path
-
-        outputs.append(background_audio)
-
-    end_time = time.time()
-    execution_time = end_time - start_time
-    logger.info(f"Execution time: {execution_time} seconds")
-
-    if not outputs:
-        raise Exception("Error in sound separation.")
-
-    return outputs
-
-
-def sound_separate(media_file, stem, main, dereverb, vocal_effects=True, background_effects=True,
-                   vocal_reverb_room_size=0.6, vocal_reverb_damping=0.6, vocal_reverb_dryness=0.8 ,vocal_reverb_wet_level=0.35,
-                   vocal_delay_seconds=0.4, vocal_delay_mix=0.25,
-                   vocal_compressor_threshold_db=-25, vocal_compressor_ratio=3.5, vocal_compressor_attack_ms=10, vocal_compressor_release_ms=60,
-                   vocal_gain_db=4,
-                   background_highpass_freq=120, background_lowpass_freq=11000,
-                   background_reverb_room_size=0.5, background_reverb_damping=0.5, background_reverb_wet_level=0.25,
-                   background_compressor_threshold_db=-20, background_compressor_ratio=2.5, background_compressor_attack_ms=15, background_compressor_release_ms=80,
-                   background_gain_db=3,
-):
-    if not media_file:
-        raise ValueError("The audio path is missing.")
-
-    if not stem:
-        raise ValueError("Please select 'vocal' or 'background' stem.")
-
-    hash_audio = str(get_hash(media_file))
-    media_dir = os.path.dirname(media_file)
-
-    outputs = []
 
+def run_demucs(audio_path, selected_stems, model_name=DEFAULT_MODEL):
     try:
-        duration_base_ = librosa.get_duration(filename=media_file)
-        print("Duration audio:", duration_base_)
-    except Exception as e:
-        print(e)
-    
-    start_time = time.time()
+        logger.info(f"Running Demucs on {audio_path}")
+        output_dir = tempfile.mkdtemp()
 
-    if stem == "vocal":
-        try:
-            _, _, _, _, vocal_audio = process_uvr_task(
-                orig_song_path=media_file,
-                song_id=hash_audio + "mdx",
-                main_vocals=main,
-                dereverb=dereverb,
-                remove_files_output_dir=False,
-            )
-
-            if vocal_effects:
-                suffix = '_effects'
-                file_name, file_extension = os.path.splitext(os.path.abspath(vocal_audio))
-                out_effects = file_name + suffix + file_extension
-                out_effects_path = os.path.join(media_dir, out_effects)
-                add_vocal_effects(vocal_audio, out_effects_path,
-                                  reverb_room_size=vocal_reverb_room_size, reverb_damping=vocal_reverb_damping, vocal_reverb_dryness=vocal_reverb_dryness, reverb_wet_level=vocal_reverb_wet_level,
-                                  delay_seconds=vocal_delay_seconds, delay_mix=vocal_delay_mix,
-                                  compressor_threshold_db=vocal_compressor_threshold_db, compressor_ratio=vocal_compressor_ratio, compressor_attack_ms=vocal_compressor_attack_ms, compressor_release_ms=vocal_compressor_release_ms,
-                                  gain_db=vocal_gain_db
-                                  )
-                vocal_audio = out_effects_path
+        cmd = f"python -m demucs -n {model_name} -o {output_dir} \"{audio_path}\""
+        logger.info(f"Executing command: {cmd}")
 
-            outputs.append(vocal_audio)
-        except Exception as error:
-            gr.Info(str(error))
-            logger.error(str(error))
-
-    if stem == "background":
-        background_audio, _ = process_uvr_task(
-            orig_song_path=media_file,
-            song_id=hash_audio + "voiceless",
-            only_voiceless=True,
-            remove_files_output_dir=False,
+        process = subprocess.Popen(
+            cmd,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
         )
 
-        if background_effects:
-            suffix = '_effects'
-            file_name, file_extension = os.path.splitext(os.path.abspath(background_audio))
-            out_effects = file_name + suffix + file_extension
-            out_effects_path = os.path.join(media_dir, out_effects)
-            print(file_name, file_extension, out_effects, out_effects_path)
-            add_instrumental_effects(background_audio, out_effects_path,
-                                     highpass_freq=background_highpass_freq, lowpass_freq=background_lowpass_freq,
-                                     reverb_room_size=background_reverb_room_size, reverb_damping=background_reverb_damping, reverb_wet_level=background_reverb_wet_level,
-                                     compressor_threshold_db=background_compressor_threshold_db, compressor_ratio=background_compressor_ratio, compressor_attack_ms=background_compressor_attack_ms, compressor_release_ms=background_compressor_release_ms,
-                                     gain_db=background_gain_db
-                                     )
-            background_audio = out_effects_path
-
-        outputs.append(background_audio)
-
-    end_time = time.time()
-    execution_time = end_time - start_time
-    logger.info(f"Execution time: {execution_time} seconds")
-
-    if not outputs:
-        raise Exception("Error in sound separation.")
-
-    return outputs
-
-
-def audio_downloader(
-    url_media,
-):
-
-    url_media = url_media.strip()
-
-    if not url_media:
-        return None
-
-    print(url_media[:10])
-
-    dir_output_downloads = "downloads"
-    os.makedirs(dir_output_downloads, exist_ok=True)
-
-    media_info = yt_dlp.YoutubeDL(
-        {"quiet": True, "no_warnings": True, "noplaylist": True}
-    ).extract_info(url_media, download=False)
-    download_path = f"{os.path.join(dir_output_downloads, media_info['title'])}.m4a"
-
-    ydl_opts = {
-        'format': 'm4a/bestaudio/best',
-        'postprocessors': [{  # Extract audio using ffmpeg
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'm4a',
-        }],
-        'force_overwrites': True,
-        'noplaylist': True,
-        'no_warnings': True,
-        'quiet': True,
-        'ignore_no_formats_error': True,
-        'restrictfilenames': True,
-        'outtmpl': download_path,
-    }
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl_download:
-        ydl_download.download([url_media])
-
-    return download_path
-
-
-def downloader_conf():
-    return gr.Checkbox(
-        False,
-        label="URL-to-Audio",
-        # info="",
-        container=False,
-    )
-
-
-def url_media_conf():
-    return gr.Textbox(
-        value="",
-        label="Enter URL",
-        placeholder="www.youtube.com/watch?v=g_9rPvbENUw",
-        visible=False,
-        lines=1,
-    )
-
-
-def url_button_conf():
-    return gr.Button(
-        "Go",
-        variant="secondary",
-        visible=False,
-    )
-
-
-def show_components_downloader(value_active):
-    return gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    )
-
-
-def audio_conf():
-    return gr.File(
-        label="Audio file",
-        # file_count="multiple",
-        type="filepath",
-        container=True,
-    )
-
-
-def stem_conf():
-    return gr.Radio(
-        choices=["vocal", "background"],
-        value="vocal",
-        label="Stem",
-        # info="",
-    )
-
-
-def main_conf():
-    return gr.Checkbox(
-        False,
-        label="Main",
-        # info="",
-    )
-
-
-def dereverb_conf():
-    return gr.Checkbox(
-        False,
-        label="Dereverb",
-        # info="",
-        visible=True,
-    )
-
-
-def vocal_effects_conf():
-    return gr.Checkbox(
-        False,
-        label="Vocal Effects",
-        # info="",
-        visible=True,
-    )
-
-
-def background_effects_conf():
-    return gr.Checkbox(
-        False,
-        label="Background Effects",
-        # info="",
-        visible=False,
-    )
-
+        stdout, stderr = process.communicate()
 
-def vocal_reverb_room_size_conf():
-    return gr.Number(
-        0.15,
-        label="Vocal Reverb Room Size",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        visible=True,
-    )
+        if process.returncode != 0:
+            logger.error(f"Demucs error: {stderr}")
+            raise gr.Error(f"Demucs failed: {stderr}")
 
+        track_name = Path(audio_path).stem
+        stem_dir = Path(output_dir) / model_name / track_name
 
-def vocal_reverb_damping_conf():
-    return gr.Number(
-        0.7,
-        label="Vocal Reverb Damping",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.01,
-        visible=True,
-    )
+        output_files = []
+        for stem in selected_stems:
+            stem_path = stem_dir / f"{stem}.wav"
+            if stem_path.exists():
+                output_files.append(str(stem_path))
 
+        if not output_files:
+            raise gr.Error("No stems were generated")
 
-def vocal_reverb_wet_level_conf():
-    return gr.Number(
-        0.2,
-        label="Vocal Reverb Wet Level",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        visible=True,
-    )
+        return output_files
 
-
-def vocal_reverb_dryness_level_conf():
-    return gr.Number(
-        0.8,
-        label="Vocal Reverb Dryness Level",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        visible=True,
-    )
-
-
-def vocal_delay_seconds_conf():
-    return gr.Number(
-        0.,
-        label="Vocal Delay Seconds",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.01,
-        visible=True,
-    )
-
-
-def vocal_delay_mix_conf():
-    return gr.Number(
-        0.,
-        label="Vocal Delay Mix",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.01,
-        visible=True,
-    )
-
-
-def vocal_compressor_threshold_db_conf():
-    return gr.Number(
-        -15,
-        label="Vocal Compressor Threshold (dB)",
-        minimum=-60,
-        maximum=0,
-        step=1,
-        visible=True,
-    )
-
-
-def vocal_compressor_ratio_conf():
-    return gr.Number(
-        4.,
-        label="Vocal Compressor Ratio",
-        minimum=0,
-        maximum=20,
-        step=0.1,
-        visible=True,
-    )
-
-
-def vocal_compressor_attack_ms_conf():
-    return gr.Number(
-        1.0,
-        label="Vocal Compressor Attack (ms)",
-        minimum=0,
-        maximum=1000,
-        step=1,
-        visible=True,
-    )
-
-
-def vocal_compressor_release_ms_conf():
-    return gr.Number(
-        100,
-        label="Vocal Compressor Release (ms)",
-        minimum=0,
-        maximum=3000,
-        step=1,
-        visible=True,
-    )
-
-
-def vocal_gain_db_conf():
-    return gr.Number(
-        0,
-        label="Vocal Gain (dB)",
-        minimum=-40,
-        maximum=40,
-        step=1,
-        visible=True,
-    )
-
-
-def background_highpass_freq_conf():
-    return gr.Number(
-        120,
-        label="Background Highpass Frequency (Hz)",
-        minimum=0,
-        maximum=1000,
-        step=1,
-        visible=True,
-    )
-
-
-def background_lowpass_freq_conf():
-    return gr.Number(
-        11000,
-        label="Background Lowpass Frequency (Hz)",
-        minimum=0,
-        maximum=20000,
-        step=1,
-        visible=True,
-    )
-
-
-def background_reverb_room_size_conf():
-    return gr.Number(
-        0.1,
-        label="Background Reverb Room Size",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.1,
-        visible=True,
-    )
-
-
-def background_reverb_damping_conf():
-    return gr.Number(
-        0.5,
-        label="Background Reverb Damping",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.1,
-        visible=True,
-    )
-
-
-def background_reverb_wet_level_conf():
-    return gr.Number(
-        0.25,
-        label="Background Reverb Wet Level",
-        minimum=0.0,
-        maximum=1.0,
-        step=0.05,
-        visible=True,
-    )
-
-
-def background_compressor_threshold_db_conf():
-    return gr.Number(
-        -15,
-        label="Background Compressor Threshold (dB)",
-        minimum=-60,
-        maximum=0,
-        step=1,
-        visible=True,
-    )
-
-
-def background_compressor_ratio_conf():
-    return gr.Number(
-        4.,
-        label="Background Compressor Ratio",
-        minimum=0,
-        maximum=20,
-        step=0.1,
-        visible=True,
-    )
-
-
-def background_compressor_attack_ms_conf():
-    return gr.Number(
-        15,
-        label="Background Compressor Attack (ms)",
-        minimum=0,
-        maximum=1000,
-        step=1,
-        visible=True,
-    )
-
-
-def background_compressor_release_ms_conf():
-    return gr.Number(
-        60,
-        label="Background Compressor Release (ms)",
-        minimum=0,
-        maximum=3000,
-        step=1,
-        visible=True,
-    )
-
-
-def background_gain_db_conf():
-    return gr.Number(
-        0,
-        label="Background Gain (dB)",
-        minimum=-40,
-        maximum=40,
-        step=1,
-        visible=True,
-    )
-
-
-def button_conf():
-    return gr.Button(
-        "Inference",
-        variant="primary",
-    )
-
-
-def output_conf():
-    return gr.File(
-        label="Result",
-        file_count="multiple",
-        interactive=False,
-    )
-
-
-def show_vocal_components(value_name):
-
-    if value_name == "vocal":
-        return gr.update(visible=True), gr.update(
-            visible=True
-        ), gr.update(visible=True), gr.update(
-            visible=False
-        )
-    else:
-        return gr.update(visible=False), gr.update(
-            visible=False
-        ), gr.update(visible=False), gr.update(
-            visible=True
-        )
+    except Exception as e:
+        logger.error(f"Error: {str(e)}")
+        raise gr.Error(f"Process failed: {str(e)}")
 
 
-def get_gui(theme):
-    with gr.Blocks(theme=theme) as app:
-        gr.Markdown(title)
-        gr.Markdown(description)
+def create_interface():
+    with gr.Blocks() as interface:
+        gr.Markdown("# 🎚️ Demucs Stem Splitter")
 
-        downloader_gui = downloader_conf()
         with gr.Row():
-            with gr.Column(scale=2):
-                url_media_gui = url_media_conf()
-            with gr.Column(scale=1):
-                url_button_gui = url_button_conf()
+            audio_input = gr.Audio(type="filepath", label="Upload Audio File")
 
-        downloader_gui.change(
-            show_components_downloader,
-            [downloader_gui],
-            [url_media_gui, url_button_gui]
-        )
-
-        aud = audio_conf()
-
-        url_button_gui.click(
-            audio_downloader,
-            [url_media_gui],
-            [aud]
-        )
-
-        with gr.Column():
-            with gr.Row():
-                stem_gui = stem_conf()
+        with gr.Row():
+            vocals = gr.Checkbox(label="Vocals", value=True)
+            drums = gr.Checkbox(label="Drums", value=True)
+            bass = gr.Checkbox(label="Bass", value=True)
+            other = gr.Checkbox(label="Other", value=True)
 
-        with gr.Column():
-            with gr.Row():
-                main_gui = main_conf()
-                dereverb_gui = dereverb_conf()
-                vocal_effects_gui = vocal_effects_conf()
-                background_effects_gui = background_effects_conf()
+        with gr.Row():
+            model_selector = gr.Dropdown(
+                label="Model",
+                choices=["htdemucs", "mdx_extra", "mdx_extra_q"],
+                value="htdemucs"
+            )
 
-            # with gr.Column():
-            with gr.Accordion("Vocal Effects Parameters", open=False): # with gr.Row():
-                # gr.Label("Vocal Effects Parameters")
-                with gr.Row():
-                    vocal_reverb_room_size_gui = vocal_reverb_room_size_conf()
-                    vocal_reverb_damping_gui = vocal_reverb_damping_conf()
-                    vocal_reverb_dryness_gui = vocal_reverb_dryness_level_conf()
-                    vocal_reverb_wet_level_gui = vocal_reverb_wet_level_conf()
-                    vocal_delay_seconds_gui = vocal_delay_seconds_conf()
-                    vocal_delay_mix_gui = vocal_delay_mix_conf()
-                    vocal_compressor_threshold_db_gui = vocal_compressor_threshold_db_conf()
-                    vocal_compressor_ratio_gui = vocal_compressor_ratio_conf()
-                    vocal_compressor_attack_ms_gui = vocal_compressor_attack_ms_conf()
-                    vocal_compressor_release_ms_gui = vocal_compressor_release_ms_conf()
-                    vocal_gain_db_gui = vocal_gain_db_conf()
+        with gr.Row():
+            submit_btn = gr.Button("Split Stems")
 
-            with gr.Accordion("Background Effects Parameters", open=False): # with gr.Row():
-                # gr.Label("Background Effects Parameters")
-                with gr.Row():
-                    background_highpass_freq_gui = background_highpass_freq_conf()
-                    background_lowpass_freq_gui = background_lowpass_freq_conf()
-                    background_reverb_room_size_gui = background_reverb_room_size_conf()
-                    background_reverb_damping_gui = background_reverb_damping_conf()
-                    background_reverb_wet_level_gui = background_reverb_wet_level_conf()
-                    background_compressor_threshold_db_gui = background_compressor_threshold_db_conf()
-                    background_compressor_ratio_gui = background_compressor_ratio_conf()
-                    background_compressor_attack_ms_gui = background_compressor_attack_ms_conf()
-                    background_compressor_release_ms_gui = background_compressor_release_ms_conf()
-                    background_gain_db_gui = background_gain_db_conf()
+        output = gr.File(label="Output Stems", file_count="multiple")
 
-            stem_gui.change(
-                show_vocal_components,
-                [stem_gui],
-                [main_gui, dereverb_gui, vocal_effects_gui, background_effects_gui],
-            )
+        def process(audio_file, vocals_enabled, drums_enabled, bass_enabled, other_enabled, model):
+            selected = [stem for stem, enabled in [
+                ("vocals", vocals_enabled),
+                ("drums", drums_enabled),
+                ("bass", bass_enabled),
+                ("other", other_enabled),
+            ] if enabled]
 
-        button_base = button_conf()
-        output_base = output_conf()
+            if not selected:
+                raise gr.Error("Please select at least one stem")
 
-        button_base.click(
-            sound_separate,
-            inputs=[
-                aud,
-                stem_gui,
-                main_gui,
-                dereverb_gui,
-                vocal_effects_gui,
-                background_effects_gui,
-                vocal_reverb_room_size_gui, vocal_reverb_damping_gui, vocal_reverb_dryness_gui, vocal_reverb_wet_level_gui,
-                vocal_delay_seconds_gui, vocal_delay_mix_gui, vocal_compressor_threshold_db_gui, vocal_compressor_ratio_gui,
-                vocal_compressor_attack_ms_gui, vocal_compressor_release_ms_gui, vocal_gain_db_gui,
-                background_highpass_freq_gui, background_lowpass_freq_gui, background_reverb_room_size_gui,
-                background_reverb_damping_gui, background_reverb_wet_level_gui, background_compressor_threshold_db_gui,
-                background_compressor_ratio_gui, background_compressor_attack_ms_gui, background_compressor_release_ms_gui,
-                background_gain_db_gui,
-            ],
-            outputs=[output_base],
-        )
+            return run_demucs(audio_file, selected, model)
 
-        gr.Examples(
-            examples=[
-                [
-                    "./test.mp3",
-                    "vocal",
-                    False,
-                    False,
-                    False,
-                    False,
-                    0.15, 0.7, 0.8, 0.2,
-                    0., 0., -15, 4., 1, 100, 0,
-                    120, 11000, 0.5, 0.1, 0.25, -15, 4., 15, 60, 0,
-                ],
-            ],
-            fn=sound_separate,
-            inputs=[
-                aud,
-                stem_gui,
-                main_gui,
-                dereverb_gui,
-                vocal_effects_gui,
-                background_effects_gui,
-                vocal_reverb_room_size_gui, vocal_reverb_damping_gui, vocal_reverb_dryness_gui, vocal_reverb_wet_level_gui,
-                vocal_delay_seconds_gui, vocal_delay_mix_gui, vocal_compressor_threshold_db_gui, vocal_compressor_ratio_gui,
-                vocal_compressor_attack_ms_gui, vocal_compressor_release_ms_gui, vocal_gain_db_gui,
-                background_highpass_freq_gui, background_lowpass_freq_gui, background_reverb_room_size_gui,
-                background_reverb_damping_gui, background_reverb_wet_level_gui, background_compressor_threshold_db_gui,
-                background_compressor_ratio_gui, background_compressor_attack_ms_gui, background_compressor_release_ms_gui,
-                background_gain_db_gui,
-            ],
-            outputs=[output_base],
-            cache_examples=False,
+        submit_btn.click(
+            fn=process,
+            inputs=[audio_input, vocals, drums, bass, other, model_selector],
+            outputs=output
         )
 
-    return app
+    return interface
 
 
-if __name__ == "__main__":
-
-    for id_model in UVR_MODELS:
-        download_manager(
-            os.path.join(MDX_DOWNLOAD_LINK, id_model), mdxnet_models_dir
-        )
-
-    app = get_gui(theme)
+def main():
+    interface = create_interface()
+    interface.launch()
 
-    app.queue(default_concurrency_limit=40)
 
-    app.launch(
-        max_threads=40,
-        share=False,
-        show_error=True,
-        quiet=False,
-        debug=False,
-    )
+if __name__ == '__main__':
+    main()