Upload 10 files

README.md

@@ -4,7 +4,7 @@ emoji: ⚡
 colorFrom: indigo
 colorTo: purple
 sdk: gradio
-sdk_version: 4.1.2
+sdk_version: 3.44.2
 app_file: app.py
 pinned: false
 license: openrail

UVR_interface.py

@@ -0,0 +1,852 @@
+import audioread
+import librosa
+
+import os
+import sys
+import json
+import time
+from tqdm import tqdm
+import pickle
+import hashlib
+import logging
+import traceback
+import shutil
+import soundfile as sf
+
+import torch
+
+from gui_data.constants import *
+from gui_data.old_data_check import file_check, remove_unneeded_yamls, remove_temps
+from lib_v5.vr_network.model_param_init import ModelParameters
+from lib_v5 import spec_utils
+from pathlib  import Path
+from separate import SeperateAttributes, SeperateDemucs, SeperateMDX, SeperateVR, save_format
+from typing import List
+
+
+logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)
+logging.info('UVR BEGIN')
+
+PREVIOUS_PATCH_WIN = 'UVR_Patch_1_12_23_14_54'
+
+is_dnd_compatible = True
+banner_placement = -2
+
+def save_data(data):
+    """
+    Saves given data as a .pkl (pickle) file
+
+    Paramters:
+        data(dict):
+            Dictionary containing all the necessary data to save
+    """
+    # Open data file, create it if it does not exist
+    with open('data.pkl', 'wb') as data_file:
+        pickle.dump(data, data_file)
+
+def load_data() -> dict:
+    """
+    Loads saved pkl file and returns the stored data
+
+    Returns(dict):
+        Dictionary containing all the saved data
+    """
+    try:
+        with open('data.pkl', 'rb') as data_file:  # Open data file
+            data = pickle.load(data_file)
+
+        return data
+    except (ValueError, FileNotFoundError):
+        # Data File is corrupted or not found so recreate it
+
+        save_data(data=DEFAULT_DATA)
+
+        return load_data()
+
+def load_model_hash_data(dictionary):
+    '''Get the model hash dictionary'''
+
+    with open(dictionary) as d:
+        data = d.read()
+
+    return json.loads(data)
+
+# Change the current working directory to the directory
+# this file sits in
+if getattr(sys, 'frozen', False):
+    # If the application is run as a bundle, the PyInstaller bootloader
+    # extends the sys module by a flag frozen=True and sets the app
+    # path into variable _MEIPASS'.
+    BASE_PATH = sys._MEIPASS
+else:
+    BASE_PATH = os.path.dirname(os.path.abspath(__file__))
+
+os.chdir(BASE_PATH)  # Change the current working directory to the base path
+
+debugger = []
+
+#--Constants--
+#Models
+MODELS_DIR = os.path.join(BASE_PATH, 'models')
+VR_MODELS_DIR = os.path.join(MODELS_DIR, 'VR_Models')
+MDX_MODELS_DIR = os.path.join(MODELS_DIR, 'MDX_Net_Models')
+DEMUCS_MODELS_DIR = os.path.join(MODELS_DIR, 'Demucs_Models')
+DEMUCS_NEWER_REPO_DIR = os.path.join(DEMUCS_MODELS_DIR, 'v3_v4_repo')
+MDX_MIXER_PATH = os.path.join(BASE_PATH, 'lib_v5', 'mixer.ckpt')
+
+#Cache & Parameters
+VR_HASH_DIR = os.path.join(VR_MODELS_DIR, 'model_data')
+VR_HASH_JSON = os.path.join(VR_MODELS_DIR, 'model_data', 'model_data.json')
+MDX_HASH_DIR = os.path.join(MDX_MODELS_DIR, 'model_data')
+MDX_HASH_JSON = os.path.join(MDX_MODELS_DIR, 'model_data', 'model_data.json')
+DEMUCS_MODEL_NAME_SELECT = os.path.join(DEMUCS_MODELS_DIR, 'model_data', 'model_name_mapper.json')
+MDX_MODEL_NAME_SELECT = os.path.join(MDX_MODELS_DIR, 'model_data', 'model_name_mapper.json')
+ENSEMBLE_CACHE_DIR = os.path.join(BASE_PATH, 'gui_data', 'saved_ensembles')
+SETTINGS_CACHE_DIR = os.path.join(BASE_PATH, 'gui_data', 'saved_settings')
+VR_PARAM_DIR = os.path.join(BASE_PATH, 'lib_v5', 'vr_network', 'modelparams')
+SAMPLE_CLIP_PATH = os.path.join(BASE_PATH, 'temp_sample_clips')
+ENSEMBLE_TEMP_PATH = os.path.join(BASE_PATH, 'ensemble_temps')
+
+#Style
+ICON_IMG_PATH = os.path.join(BASE_PATH, 'gui_data', 'img', 'GUI-Icon.ico')
+FONT_PATH = os.path.join(BASE_PATH, 'gui_data', 'fonts', 'centurygothic', 'GOTHIC.TTF')#ensemble_temps
+
+#Other
+COMPLETE_CHIME = os.path.join(BASE_PATH, 'gui_data', 'complete_chime.wav')
+FAIL_CHIME = os.path.join(BASE_PATH, 'gui_data', 'fail_chime.wav')
+CHANGE_LOG = os.path.join(BASE_PATH, 'gui_data', 'change_log.txt')
+SPLASH_DOC = os.path.join(BASE_PATH, 'tmp', 'splash.txt')
+
+file_check(os.path.join(MODELS_DIR, 'Main_Models'), VR_MODELS_DIR)
+file_check(os.path.join(DEMUCS_MODELS_DIR, 'v3_repo'), DEMUCS_NEWER_REPO_DIR)
+remove_unneeded_yamls(DEMUCS_MODELS_DIR)
+
+remove_temps(ENSEMBLE_TEMP_PATH)
+remove_temps(SAMPLE_CLIP_PATH)
+remove_temps(os.path.join(BASE_PATH, 'img'))
+
+if not os.path.isdir(ENSEMBLE_TEMP_PATH):
+    os.mkdir(ENSEMBLE_TEMP_PATH)
+    
+if not os.path.isdir(SAMPLE_CLIP_PATH):
+    os.mkdir(SAMPLE_CLIP_PATH)
+
+model_hash_table = {}
+data = load_data()
+    
+class ModelData():
+    def __init__(self, model_name: str, 
+                 selected_process_method=ENSEMBLE_MODE, 
+                 is_secondary_model=False, 
+                 primary_model_primary_stem=None, 
+                 is_primary_model_primary_stem_only=False, 
+                 is_primary_model_secondary_stem_only=False, 
+                 is_pre_proc_model=False,
+                 is_dry_check=False):
+
+        self.is_gpu_conversion = 0 if root.is_gpu_conversion_var.get() else -1
+        self.is_normalization = root.is_normalization_var.get()
+        self.is_primary_stem_only = root.is_primary_stem_only_var.get()
+        self.is_secondary_stem_only = root.is_secondary_stem_only_var.get()
+        self.is_denoise = root.is_denoise_var.get()
+        self.mdx_batch_size = 1 if root.mdx_batch_size_var.get() == DEF_OPT else int(root.mdx_batch_size_var.get())
+        self.is_mdx_ckpt = False
+        self.wav_type_set = root.wav_type_set
+        self.mp3_bit_set = root.mp3_bit_set_var.get()
+        self.save_format = root.save_format_var.get()
+        self.is_invert_spec = root.is_invert_spec_var.get()
+        self.is_mixer_mode = root.is_mixer_mode_var.get()
+        self.demucs_stems = root.demucs_stems_var.get()
+        self.demucs_source_list = []
+        self.demucs_stem_count = 0
+        self.mixer_path = MDX_MIXER_PATH
+        self.model_name = model_name
+        self.process_method = selected_process_method
+        self.model_status = False if self.model_name == CHOOSE_MODEL or self.model_name == NO_MODEL else True
+        self.primary_stem = None
+        self.secondary_stem = None
+        self.is_ensemble_mode = False
+        self.ensemble_primary_stem = None
+        self.ensemble_secondary_stem = None
+        self.primary_model_primary_stem = primary_model_primary_stem
+        self.is_secondary_model = is_secondary_model
+        self.secondary_model = None
+        self.secondary_model_scale = None
+        self.demucs_4_stem_added_count = 0
+        self.is_demucs_4_stem_secondaries = False
+        self.is_4_stem_ensemble = False
+        self.pre_proc_model = None
+        self.pre_proc_model_activated = False
+        self.is_pre_proc_model = is_pre_proc_model
+        self.is_dry_check = is_dry_check
+        self.model_samplerate = 44100
+        self.model_capacity = 32, 128
+        self.is_vr_51_model = False
+        self.is_demucs_pre_proc_model_inst_mix = False
+        self.manual_download_Button = None
+        self.secondary_model_4_stem = []
+        self.secondary_model_4_stem_scale = []
+        self.secondary_model_4_stem_names = []
+        self.secondary_model_4_stem_model_names_list = []
+        self.all_models = []
+        self.secondary_model_other = None
+        self.secondary_model_scale_other = None
+        self.secondary_model_bass = None
+        self.secondary_model_scale_bass = None
+        self.secondary_model_drums = None
+        self.secondary_model_scale_drums = None
+
+        if selected_process_method == ENSEMBLE_MODE:
+            partitioned_name = model_name.partition(ENSEMBLE_PARTITION)
+            self.process_method = partitioned_name[0]
+            self.model_name = partitioned_name[2]
+            self.model_and_process_tag = model_name
+            self.ensemble_primary_stem, self.ensemble_secondary_stem = root.return_ensemble_stems()
+            self.is_ensemble_mode = True if not is_secondary_model and not is_pre_proc_model else False
+            self.is_4_stem_ensemble = True if root.ensemble_main_stem_var.get() == FOUR_STEM_ENSEMBLE and self.is_ensemble_mode else False
+            self.pre_proc_model_activated = root.is_demucs_pre_proc_model_activate_var.get() if not self.ensemble_primary_stem == VOCAL_STEM else False
+
+        if self.process_method == VR_ARCH_TYPE:
+            self.is_secondary_model_activated = root.vr_is_secondary_model_activate_var.get() if not self.is_secondary_model else False
+            self.aggression_setting = float(int(root.aggression_setting_var.get())/100)
+            self.is_tta = root.is_tta_var.get()
+            self.is_post_process = root.is_post_process_var.get()
+            self.window_size = int(root.window_size_var.get())
+            self.batch_size = 1 if root.batch_size_var.get() == DEF_OPT else int(root.batch_size_var.get())
+            self.crop_size = int(root.crop_size_var.get())
+            self.is_high_end_process = 'mirroring' if root.is_high_end_process_var.get() else 'None'
+            self.post_process_threshold = float(root.post_process_threshold_var.get())
+            self.model_capacity = 32, 128
+            self.model_path = os.path.join(VR_MODELS_DIR, f"{self.model_name}.pth")
+            self.get_model_hash()
+            if self.model_hash:
+                self.model_data = self.get_model_data(VR_HASH_DIR, root.vr_hash_MAPPER) if not self.model_hash == WOOD_INST_MODEL_HASH else WOOD_INST_PARAMS
+                if self.model_data:
+                    vr_model_param = os.path.join(VR_PARAM_DIR, "{}.json".format(self.model_data["vr_model_param"]))
+                    self.primary_stem = self.model_data["primary_stem"]
+                    self.secondary_stem = STEM_PAIR_MAPPER[self.primary_stem]
+                    self.vr_model_param = ModelParameters(vr_model_param)
+                    self.model_samplerate = self.vr_model_param.param['sr']
+                    if "nout" in self.model_data.keys() and "nout_lstm" in self.model_data.keys():
+                        self.model_capacity = self.model_data["nout"], self.model_data["nout_lstm"]
+                        self.is_vr_51_model = True
+                else:
+                    self.model_status = False
+                
+        if self.process_method == MDX_ARCH_TYPE:
+            self.is_secondary_model_activated = root.mdx_is_secondary_model_activate_var.get() if not is_secondary_model else False
+            self.margin = int(root.margin_var.get())
+            self.chunks = root.determine_auto_chunks(root.chunks_var.get(), self.is_gpu_conversion) if root.is_chunk_mdxnet_var.get() else 0
+            self.get_mdx_model_path()
+            self.get_model_hash()
+            if self.model_hash:
+                self.model_data = self.get_model_data(MDX_HASH_DIR, root.mdx_hash_MAPPER)
+                if self.model_data:
+                    self.compensate = self.model_data["compensate"] if root.compensate_var.get() == AUTO_SELECT else float(root.compensate_var.get())
+                    self.mdx_dim_f_set = self.model_data["mdx_dim_f_set"]
+                    self.mdx_dim_t_set = self.model_data["mdx_dim_t_set"]
+                    self.mdx_n_fft_scale_set = self.model_data["mdx_n_fft_scale_set"]
+                    self.primary_stem = self.model_data["primary_stem"]
+                    self.secondary_stem = STEM_PAIR_MAPPER[self.primary_stem]
+                else:
+                    self.model_status = False
+
+        if self.process_method == DEMUCS_ARCH_TYPE:
+            self.is_secondary_model_activated = root.demucs_is_secondary_model_activate_var.get() if not is_secondary_model else False
+            if not self.is_ensemble_mode:
+                self.pre_proc_model_activated = root.is_demucs_pre_proc_model_activate_var.get() if not root.demucs_stems_var.get() in [VOCAL_STEM, INST_STEM] else False
+            self.overlap = float(root.overlap_var.get())
+            self.margin_demucs = int(root.margin_demucs_var.get())
+            self.chunks_demucs = root.determine_auto_chunks(root.chunks_demucs_var.get(), self.is_gpu_conversion)
+            self.shifts = int(root.shifts_var.get())
+            self.is_split_mode = root.is_split_mode_var.get()
+            self.segment = root.segment_var.get()
+            self.is_chunk_demucs = root.is_chunk_demucs_var.get()
+            self.is_demucs_combine_stems = root.is_demucs_combine_stems_var.get()
+            self.is_primary_stem_only = root.is_primary_stem_only_var.get() if self.is_ensemble_mode else root.is_primary_stem_only_Demucs_var.get() 
+            self.is_secondary_stem_only = root.is_secondary_stem_only_var.get() if self.is_ensemble_mode else root.is_secondary_stem_only_Demucs_var.get()
+            self.get_demucs_model_path()
+            self.get_demucs_model_data()
+
+        self.model_basename = os.path.splitext(os.path.basename(self.model_path))[0] if self.model_status else None
+        self.pre_proc_model_activated = self.pre_proc_model_activated if not self.is_secondary_model else False
+        
+        self.is_primary_model_primary_stem_only = is_primary_model_primary_stem_only
+        self.is_primary_model_secondary_stem_only = is_primary_model_secondary_stem_only
+
+        if self.is_secondary_model_activated and self.model_status:
+            if (not self.is_ensemble_mode and root.demucs_stems_var.get() == ALL_STEMS and self.process_method == DEMUCS_ARCH_TYPE) or self.is_4_stem_ensemble:
+                for key in DEMUCS_4_SOURCE_LIST:
+                    self.secondary_model_data(key)
+                    self.secondary_model_4_stem.append(self.secondary_model)
+                    self.secondary_model_4_stem_scale.append(self.secondary_model_scale)
+                    self.secondary_model_4_stem_names.append(key)
+                self.demucs_4_stem_added_count = sum(i is not None for i in self.secondary_model_4_stem)
+                self.is_secondary_model_activated = False if all(i is None for i in self.secondary_model_4_stem) else True
+                self.demucs_4_stem_added_count = self.demucs_4_stem_added_count - 1 if self.is_secondary_model_activated else self.demucs_4_stem_added_count
+                if self.is_secondary_model_activated:
+                    self.secondary_model_4_stem_model_names_list = [None if i is None else i.model_basename for i in self.secondary_model_4_stem]
+                    self.is_demucs_4_stem_secondaries = True 
+            else:
+                primary_stem = self.ensemble_primary_stem if self.is_ensemble_mode and self.process_method == DEMUCS_ARCH_TYPE else self.primary_stem
+                self.secondary_model_data(primary_stem)
+                
+        if self.process_method == DEMUCS_ARCH_TYPE and not is_secondary_model:
+            if self.demucs_stem_count >= 3 and self.pre_proc_model_activated:
+                self.pre_proc_model_activated = True
+                self.pre_proc_model = root.process_determine_demucs_pre_proc_model(self.primary_stem)
+                self.is_demucs_pre_proc_model_inst_mix = root.is_demucs_pre_proc_model_inst_mix_var.get() if self.pre_proc_model else False
+
+    def secondary_model_data(self, primary_stem):
+        secondary_model_data = root.process_determine_secondary_model(self.process_method, primary_stem, self.is_primary_stem_only, self.is_secondary_stem_only)
+        self.secondary_model = secondary_model_data[0]
+        self.secondary_model_scale = secondary_model_data[1]
+        self.is_secondary_model_activated = False if not self.secondary_model else True
+        if self.secondary_model:
+            self.is_secondary_model_activated = False if self.secondary_model.model_basename == self.model_basename else True
+              
+    def get_mdx_model_path(self):
+        
+        if self.model_name.endswith(CKPT):
+            # self.chunks = 0
+            # self.is_mdx_batch_mode = True
+            self.is_mdx_ckpt = True
+            
+        ext = '' if self.is_mdx_ckpt else ONNX
+        
+        for file_name, chosen_mdx_model in root.mdx_name_select_MAPPER.items():
+            if self.model_name in chosen_mdx_model:
+                self.model_path = os.path.join(MDX_MODELS_DIR, f"{file_name}{ext}")
+                break
+        else:
+            self.model_path = os.path.join(MDX_MODELS_DIR, f"{self.model_name}{ext}")
+            
+        self.mixer_path = os.path.join(MDX_MODELS_DIR, f"mixer_val.ckpt")
+    
+    def get_demucs_model_path(self):
+        
+        demucs_newer = [True for x in DEMUCS_NEWER_TAGS if x in self.model_name]
+        demucs_model_dir = DEMUCS_NEWER_REPO_DIR if demucs_newer else DEMUCS_MODELS_DIR
+        
+        for file_name, chosen_model in root.demucs_name_select_MAPPER.items():
+            if self.model_name in chosen_model:
+                self.model_path = os.path.join(demucs_model_dir, file_name)
+                break
+        else:
+            self.model_path = os.path.join(DEMUCS_NEWER_REPO_DIR, f'{self.model_name}.yaml')
+
+    def get_demucs_model_data(self):
+
+        self.demucs_version = DEMUCS_V4
+
+        for key, value in DEMUCS_VERSION_MAPPER.items():
+            if value in self.model_name:
+                self.demucs_version = key
+
+        self.demucs_source_list = DEMUCS_2_SOURCE if DEMUCS_UVR_MODEL in self.model_name else DEMUCS_4_SOURCE
+        self.demucs_source_map = DEMUCS_2_SOURCE_MAPPER if DEMUCS_UVR_MODEL in self.model_name else DEMUCS_4_SOURCE_MAPPER
+        self.demucs_stem_count = 2 if DEMUCS_UVR_MODEL in self.model_name else 4
+        
+        if not self.is_ensemble_mode:
+            self.primary_stem = PRIMARY_STEM if self.demucs_stems == ALL_STEMS else self.demucs_stems
+            self.secondary_stem = STEM_PAIR_MAPPER[self.primary_stem]
+
+    def get_model_data(self, model_hash_dir, hash_mapper):
+        model_settings_json = os.path.join(model_hash_dir, "{}.json".format(self.model_hash))
+
+        if os.path.isfile(model_settings_json):
+            return json.load(open(model_settings_json))
+        else:
+            for hash, settings in hash_mapper.items():
+                if self.model_hash in hash:
+                    return settings
+            else:
+                return self.get_model_data_from_popup()
+
+    def get_model_data_from_popup(self):
+        return None
+
+    def get_model_hash(self):
+        self.model_hash = None
+        
+        if not os.path.isfile(self.model_path):
+            self.model_status = False
+            self.model_hash is None
+        else:
+            if model_hash_table:
+                for (key, value) in model_hash_table.items():
+                    if self.model_path == key:
+                        self.model_hash = value
+                        break
+                    
+            if not self.model_hash:
+                try:
+                    with open(self.model_path, 'rb') as f:
+                        f.seek(- 10000 * 1024, 2)
+                        self.model_hash = hashlib.md5(f.read()).hexdigest()
+                except:
+                    self.model_hash = hashlib.md5(open(self.model_path,'rb').read()).hexdigest()
+                    
+                table_entry = {self.model_path: self.model_hash}
+                model_hash_table.update(table_entry)
+
+
+class Ensembler():
+    def __init__(self, is_manual_ensemble=False):
+        self.is_save_all_outputs_ensemble = root.is_save_all_outputs_ensemble_var.get()
+        chosen_ensemble_name = '{}'.format(root.chosen_ensemble_var.get().replace(" ", "_")) if not root.chosen_ensemble_var.get() == CHOOSE_ENSEMBLE_OPTION else 'Ensembled'
+        ensemble_algorithm = root.ensemble_type_var.get().partition("/")
+        ensemble_main_stem_pair = root.ensemble_main_stem_var.get().partition("/")
+        time_stamp = round(time.time())
+        self.audio_tool = MANUAL_ENSEMBLE
+        self.main_export_path = Path(root.export_path_var.get())
+        self.chosen_ensemble = f"_{chosen_ensemble_name}" if root.is_append_ensemble_name_var.get() else ''
+        ensemble_folder_name = self.main_export_path if self.is_save_all_outputs_ensemble else ENSEMBLE_TEMP_PATH
+        self.ensemble_folder_name = os.path.join(ensemble_folder_name, '{}_Outputs_{}'.format(chosen_ensemble_name, time_stamp))
+        self.is_testing_audio = f"{time_stamp}_" if root.is_testing_audio_var.get() else ''
+        self.primary_algorithm = ensemble_algorithm[0]
+        self.secondary_algorithm = ensemble_algorithm[2]
+        self.ensemble_primary_stem = ensemble_main_stem_pair[0]
+        self.ensemble_secondary_stem = ensemble_main_stem_pair[2]
+        self.is_normalization = root.is_normalization_var.get()
+        self.wav_type_set = root.wav_type_set
+        self.mp3_bit_set = root.mp3_bit_set_var.get()
+        self.save_format = root.save_format_var.get()
+        if not is_manual_ensemble:
+            os.mkdir(self.ensemble_folder_name)
+
+    def ensemble_outputs(self, audio_file_base, export_path, stem, is_4_stem=False, is_inst_mix=False):
+        """Processes the given outputs and ensembles them with the chosen algorithm"""
+        
+        if is_4_stem:
+            algorithm = root.ensemble_type_var.get()
+            stem_tag = stem
+        else:
+            if is_inst_mix:
+                algorithm = self.secondary_algorithm
+                stem_tag = f"{self.ensemble_secondary_stem} {INST_STEM}"
+            else:
+                algorithm = self.primary_algorithm if stem == PRIMARY_STEM else self.secondary_algorithm
+                stem_tag = self.ensemble_primary_stem if stem == PRIMARY_STEM else self.ensemble_secondary_stem
+
+        stem_outputs = self.get_files_to_ensemble(folder=export_path, prefix=audio_file_base, suffix=f"_({stem_tag}).wav")
+        audio_file_output = f"{self.is_testing_audio}{audio_file_base}{self.chosen_ensemble}_({stem_tag})"
+        stem_save_path = os.path.join('{}'.format(self.main_export_path),'{}.wav'.format(audio_file_output))
+        
+        if stem_outputs:
+            spec_utils.ensemble_inputs(stem_outputs, algorithm, self.is_normalization, self.wav_type_set, stem_save_path)
+            save_format(stem_save_path, self.save_format, self.mp3_bit_set)
+        
+        if self.is_save_all_outputs_ensemble:
+            for i in stem_outputs:
+                save_format(i, self.save_format, self.mp3_bit_set)
+        else:
+            for i in stem_outputs:
+                try:
+                    os.remove(i)
+                except Exception as e:
+                    print(e)
+
+    def ensemble_manual(self, audio_inputs, audio_file_base, is_bulk=False):
+        """Processes the given outputs and ensembles them with the chosen algorithm"""
+        
+        is_mv_sep = True
+        
+        if is_bulk:
+            number_list = list(set([os.path.basename(i).split("_")[0] for i in audio_inputs]))
+            for n in number_list:
+                current_list = [i for i in audio_inputs if os.path.basename(i).startswith(n)]
+                audio_file_base = os.path.basename(current_list[0]).split('.wav')[0]
+                stem_testing = "instrum" if "Instrumental" in audio_file_base else "vocals"
+                if is_mv_sep:
+                    audio_file_base = audio_file_base.split("_")
+                    audio_file_base = f"{audio_file_base[1]}_{audio_file_base[2]}_{stem_testing}"
+                self.ensemble_manual_process(current_list, audio_file_base, is_bulk)
+        else:
+            self.ensemble_manual_process(audio_inputs, audio_file_base, is_bulk)
+            
+    def ensemble_manual_process(self, audio_inputs, audio_file_base, is_bulk):
+        
+        algorithm = root.choose_algorithm_var.get()
+        algorithm_text = "" if is_bulk else f"_({root.choose_algorithm_var.get()})"
+        stem_save_path = os.path.join('{}'.format(self.main_export_path),'{}{}{}.wav'.format(self.is_testing_audio, audio_file_base, algorithm_text))
+        spec_utils.ensemble_inputs(audio_inputs, algorithm, self.is_normalization, self.wav_type_set, stem_save_path)
+        save_format(stem_save_path, self.save_format, self.mp3_bit_set)
+
+    def get_files_to_ensemble(self, folder="", prefix="", suffix=""):
+        """Grab all the files to be ensembled"""
+        
+        return [os.path.join(folder, i) for i in os.listdir(folder) if i.startswith(prefix) and i.endswith(suffix)]
+
+
+def secondary_stem(stem):
+    """Determines secondary stem"""
+    
+    for key, value in STEM_PAIR_MAPPER.items():
+        if stem in key:
+            secondary_stem = value
+    
+    return secondary_stem
+
+
+class UVRInterface:
+    def __init__(self) -> None:
+        pass
+
+    def assemble_model_data(self, model=None, arch_type=ENSEMBLE_MODE, is_dry_check=False) -> List[ModelData]:
+        if arch_type == ENSEMBLE_STEM_CHECK:
+            model_data = self.model_data_table
+            missing_models = [model.model_status for model in model_data if not model.model_status]
+            
+            if missing_models or not model_data:
+                model_data: List[ModelData] = [ModelData(model_name, is_dry_check=is_dry_check) for model_name in self.ensemble_model_list]
+                self.model_data_table = model_data
+
+        if arch_type == ENSEMBLE_MODE:
+            model_data: List[ModelData] = [ModelData(model_name) for model_name in self.ensemble_listbox_get_all_selected_models()]
+        if arch_type == ENSEMBLE_CHECK:
+            model_data: List[ModelData] = [ModelData(model)]
+        if arch_type == VR_ARCH_TYPE or arch_type == VR_ARCH_PM:
+            model_data: List[ModelData] = [ModelData(model, VR_ARCH_TYPE)]
+        if arch_type == MDX_ARCH_TYPE:
+            model_data: List[ModelData] = [ModelData(model, MDX_ARCH_TYPE)]
+        if arch_type == DEMUCS_ARCH_TYPE:
+            model_data: List[ModelData] = [ModelData(model, DEMUCS_ARCH_TYPE)]#
+
+        return model_data
+
+    def create_sample(self, audio_file, sample_path=SAMPLE_CLIP_PATH):
+        try:
+            with audioread.audio_open(audio_file) as f:
+                track_length = int(f.duration)
+        except Exception as e:
+            print('Audioread failed to get duration. Trying Librosa...')
+            y, sr = librosa.load(audio_file, mono=False, sr=44100)
+            track_length = int(librosa.get_duration(y=y, sr=sr))
+        
+        clip_duration = int(root.model_sample_mode_duration_var.get())
+        
+        if track_length >= clip_duration:
+            offset_cut = track_length//3
+            off_cut = offset_cut + track_length
+            if not off_cut >= clip_duration:
+                offset_cut = 0
+            name_apped = f'{clip_duration}_second_'
+        else:
+            offset_cut, clip_duration = 0, track_length
+            name_apped = ''
+
+        sample = librosa.load(audio_file, offset=offset_cut, duration=clip_duration, mono=False, sr=44100)[0].T
+        audio_sample = os.path.join(sample_path, f'{os.path.splitext(os.path.basename(audio_file))[0]}_{name_apped}sample.wav')
+        sf.write(audio_sample, sample, 44100)
+        
+        return audio_sample
+    
+    def verify_audio(self, audio_file, is_process=True, sample_path=None):
+        is_good = False
+        error_data = ''
+        
+        if os.path.isfile(audio_file):
+            try:
+                librosa.load(audio_file, duration=3, mono=False, sr=44100) if not type(sample_path) is str else self.create_sample(audio_file, sample_path)
+                is_good = True
+            except Exception as e:
+                error_name = f'{type(e).__name__}'
+                traceback_text = ''.join(traceback.format_tb(e.__traceback__))
+                message = f'{error_name}: "{e}"\n{traceback_text}"'
+                if is_process:
+                    audio_base_name = os.path.basename(audio_file)
+                    self.error_log_var.set(f'Error Loading the Following File:\n\n\"{audio_base_name}\"\n\nRaw Error Details:\n\n{message}')
+                else:
+                    error_data = AUDIO_VERIFICATION_CHECK(audio_file, message)
+
+        if is_process:
+            return is_good
+        else:
+            return is_good, error_data
+
+    def cached_sources_clear(self):
+        self.vr_cache_source_mapper = {}
+        self.mdx_cache_source_mapper = {}
+        self.demucs_cache_source_mapper = {}
+      
+    def cached_model_source_holder(self, process_method, sources, model_name=None):
+        if process_method == VR_ARCH_TYPE:
+            self.vr_cache_source_mapper = {**self.vr_cache_source_mapper, **{model_name: sources}}
+        if process_method == MDX_ARCH_TYPE:
+            self.mdx_cache_source_mapper = {**self.mdx_cache_source_mapper, **{model_name: sources}}
+        if process_method == DEMUCS_ARCH_TYPE:
+            self.demucs_cache_source_mapper = {**self.demucs_cache_source_mapper, **{model_name: sources}}
+                             
+    def cached_source_callback(self, process_method, model_name=None):
+        model, sources = None, None
+        
+        if process_method == VR_ARCH_TYPE:
+            mapper = self.vr_cache_source_mapper
+        if process_method == MDX_ARCH_TYPE:
+            mapper = self.mdx_cache_source_mapper
+        if process_method == DEMUCS_ARCH_TYPE:
+            mapper = self.demucs_cache_source_mapper
+        
+        for key, value in mapper.items():
+            if model_name in key:
+                model = key
+                sources = value
+        
+        return model, sources
+
+    def cached_source_model_list_check(self, model_list: List[ModelData]):
+        model: ModelData
+        primary_model_names = lambda process_method:[model.model_basename if model.process_method == process_method else None for model in model_list]
+        secondary_model_names = lambda process_method:[model.secondary_model.model_basename if model.is_secondary_model_activated and model.process_method == process_method else None for model in model_list]
+
+        self.vr_primary_model_names = primary_model_names(VR_ARCH_TYPE)
+        self.mdx_primary_model_names = primary_model_names(MDX_ARCH_TYPE)
+        self.demucs_primary_model_names = primary_model_names(DEMUCS_ARCH_TYPE)
+        self.vr_secondary_model_names = secondary_model_names(VR_ARCH_TYPE)
+        self.mdx_secondary_model_names = secondary_model_names(MDX_ARCH_TYPE)
+        self.demucs_secondary_model_names = [model.secondary_model.model_basename if model.is_secondary_model_activated and model.process_method == DEMUCS_ARCH_TYPE and not model.secondary_model is None else None for model in model_list]
+        self.demucs_pre_proc_model_name = [model.pre_proc_model.model_basename if model.pre_proc_model else None for model in model_list]#list(dict.fromkeys())
+        
+        for model in model_list:
+            if model.process_method == DEMUCS_ARCH_TYPE and model.is_demucs_4_stem_secondaries:
+                if not model.is_4_stem_ensemble:
+                    self.demucs_secondary_model_names = model.secondary_model_4_stem_model_names_list
+                    break
+                else:
+                    for i in model.secondary_model_4_stem_model_names_list:
+                        self.demucs_secondary_model_names.append(i)
+        
+        self.all_models = self.vr_primary_model_names + self.mdx_primary_model_names + self.demucs_primary_model_names + self.vr_secondary_model_names + self.mdx_secondary_model_names + self.demucs_secondary_model_names + self.demucs_pre_proc_model_name
+
+    def process(self, model_name, arch_type, audio_file, export_path, is_model_sample_mode=False, is_4_stem_ensemble=False, set_progress_func=None, console_write=print) -> SeperateAttributes:
+        stime = time.perf_counter()
+        time_elapsed = lambda:f'Time Elapsed: {time.strftime("%H:%M:%S", time.gmtime(int(time.perf_counter() - stime)))}'
+
+        if arch_type==ENSEMBLE_MODE:
+            model_list, ensemble = self.assemble_model_data(), Ensembler()
+            export_path = ensemble.ensemble_folder_name
+            is_ensemble = True
+        else:
+            model_list = self.assemble_model_data(model_name, arch_type)
+            is_ensemble = False
+        self.cached_source_model_list_check(model_list)
+        model = model_list[0]
+
+        if self.verify_audio(audio_file):
+            audio_file = self.create_sample(audio_file) if is_model_sample_mode else audio_file
+        else:
+            print(f'"{os.path.basename(audio_file)}\" is missing or currupted.\n')
+            exit()
+
+        audio_file_base = f"{os.path.splitext(os.path.basename(audio_file))[0]}"
+        audio_file_base = audio_file_base if is_ensemble else f"{round(time.time())}_{audio_file_base}"
+        audio_file_base = audio_file_base if not is_ensemble else f"{audio_file_base}_{model.model_basename}"
+        if not is_ensemble:
+            audio_file_base = f"{audio_file_base}_{model.model_basename}"
+
+        if not is_ensemble:
+            export_path = os.path.join(Path(export_path), model.model_basename, os.path.splitext(os.path.basename(audio_file))[0])
+            if not os.path.isdir(export_path):
+                os.makedirs(export_path) 
+
+        if set_progress_func is None:
+            pbar = tqdm(total=1)
+            self._progress = 0
+            def set_progress_func(step, inference_iterations=0):
+                progress_curr = step + inference_iterations
+                pbar.update(progress_curr-self._progress)
+                self._progress = progress_curr
+
+            def postprocess():
+                pbar.close()
+        else:
+            def postprocess():
+                pass
+
+        process_data = {
+            'model_data': model,
+            'export_path': export_path,
+            'audio_file_base': audio_file_base,
+            'audio_file': audio_file,
+            'set_progress_bar': set_progress_func,
+            'write_to_console': lambda progress_text, base_text='': console_write(base_text + progress_text),
+            'process_iteration': lambda:None,
+            'cached_source_callback': self.cached_source_callback,
+            'cached_model_source_holder': self.cached_model_source_holder,
+            'list_all_models': self.all_models,
+            'is_ensemble_master': is_ensemble,
+            'is_4_stem_ensemble': is_ensemble and is_4_stem_ensemble
+        }
+        if model.process_method == VR_ARCH_TYPE:
+            seperator = SeperateVR(model, process_data)
+        if model.process_method == MDX_ARCH_TYPE:
+            seperator = SeperateMDX(model, process_data)
+        if model.process_method == DEMUCS_ARCH_TYPE:
+            seperator = SeperateDemucs(model, process_data)
+
+        seperator.seperate()
+        postprocess()
+
+        if is_ensemble:
+            audio_file_base = audio_file_base.replace(f"_{model.model_basename}", "")
+            console_write(ENSEMBLING_OUTPUTS)
+            
+            if is_4_stem_ensemble:
+                for output_stem in DEMUCS_4_SOURCE_LIST:
+                    ensemble.ensemble_outputs(audio_file_base, export_path, output_stem, is_4_stem=True)
+            else:
+                if not root.is_secondary_stem_only_var.get():
+                    ensemble.ensemble_outputs(audio_file_base, export_path, PRIMARY_STEM)
+                if not root.is_primary_stem_only_var.get():
+                    ensemble.ensemble_outputs(audio_file_base, export_path, SECONDARY_STEM)
+                    ensemble.ensemble_outputs(audio_file_base, export_path, SECONDARY_STEM, is_inst_mix=True)
+
+            console_write(DONE)
+
+        if is_model_sample_mode:
+            if os.path.isfile(audio_file):
+                os.remove(audio_file)
+
+        torch.cuda.empty_cache()
+        
+        if is_ensemble and len(os.listdir(export_path)) == 0:
+            shutil.rmtree(export_path)
+        console_write(f'Process Complete, using time: {time_elapsed()}\nOutput path: {export_path}')
+        self.cached_sources_clear()
+        return seperator
+
+
+class RootWrapper:
+    def __init__(self, var) -> None:
+        self.var=var
+    
+    def set(self, val):
+        self.var=val
+    
+    def get(self):
+        return self.var
+
+class FakeRoot:
+    def __init__(self) -> None:
+        self.wav_type_set = 'PCM_16'
+        self.vr_hash_MAPPER = load_model_hash_data(VR_HASH_JSON)
+        self.mdx_hash_MAPPER = load_model_hash_data(MDX_HASH_JSON)
+        self.mdx_name_select_MAPPER = load_model_hash_data(MDX_MODEL_NAME_SELECT)
+        self.demucs_name_select_MAPPER = load_model_hash_data(DEMUCS_MODEL_NAME_SELECT)
+    
+    def __getattribute__(self, __name: str):
+        try:
+            return super().__getattribute__(__name)
+        except AttributeError:
+            wrapped=RootWrapper(None)
+            super().__setattr__(__name, wrapped)
+            return wrapped
+
+    def load_saved_settings(self, loaded_setting: dict, process_method=None):
+        """Loads user saved application settings or resets to default"""
+        
+        for key, value in DEFAULT_DATA.items():
+            if not key in loaded_setting.keys():
+                loaded_setting = {**loaded_setting, **{key:value}}
+                loaded_setting['batch_size'] = DEF_OPT
+        
+        is_ensemble = True if process_method == ENSEMBLE_MODE else False
+        
+        if not process_method or process_method == VR_ARCH_PM or is_ensemble:
+            self.vr_model_var.set(loaded_setting['vr_model'])
+            self.aggression_setting_var.set(loaded_setting['aggression_setting'])
+            self.window_size_var.set(loaded_setting['window_size'])
+            self.batch_size_var.set(loaded_setting['batch_size'])
+            self.crop_size_var.set(loaded_setting['crop_size'])
+            self.is_tta_var.set(loaded_setting['is_tta'])
+            self.is_output_image_var.set(loaded_setting['is_output_image'])
+            self.is_post_process_var.set(loaded_setting['is_post_process'])
+            self.is_high_end_process_var.set(loaded_setting['is_high_end_process'])
+            self.post_process_threshold_var.set(loaded_setting['post_process_threshold'])
+            self.vr_voc_inst_secondary_model_var.set(loaded_setting['vr_voc_inst_secondary_model'])
+            self.vr_other_secondary_model_var.set(loaded_setting['vr_other_secondary_model'])
+            self.vr_bass_secondary_model_var.set(loaded_setting['vr_bass_secondary_model'])
+            self.vr_drums_secondary_model_var.set(loaded_setting['vr_drums_secondary_model'])
+            self.vr_is_secondary_model_activate_var.set(loaded_setting['vr_is_secondary_model_activate'])
+            self.vr_voc_inst_secondary_model_scale_var.set(loaded_setting['vr_voc_inst_secondary_model_scale'])
+            self.vr_other_secondary_model_scale_var.set(loaded_setting['vr_other_secondary_model_scale'])
+            self.vr_bass_secondary_model_scale_var.set(loaded_setting['vr_bass_secondary_model_scale'])
+            self.vr_drums_secondary_model_scale_var.set(loaded_setting['vr_drums_secondary_model_scale'])
+        
+        if not process_method or process_method == DEMUCS_ARCH_TYPE or is_ensemble:
+            self.demucs_model_var.set(loaded_setting['demucs_model'])
+            self.segment_var.set(loaded_setting['segment'])
+            self.overlap_var.set(loaded_setting['overlap'])
+            self.shifts_var.set(loaded_setting['shifts'])
+            self.chunks_demucs_var.set(loaded_setting['chunks_demucs'])
+            self.margin_demucs_var.set(loaded_setting['margin_demucs'])
+            self.is_chunk_demucs_var.set(loaded_setting['is_chunk_demucs'])
+            self.is_chunk_mdxnet_var.set(loaded_setting['is_chunk_mdxnet'])
+            self.is_primary_stem_only_Demucs_var.set(loaded_setting['is_primary_stem_only_Demucs'])
+            self.is_secondary_stem_only_Demucs_var.set(loaded_setting['is_secondary_stem_only_Demucs'])
+            self.is_split_mode_var.set(loaded_setting['is_split_mode'])
+            self.is_demucs_combine_stems_var.set(loaded_setting['is_demucs_combine_stems'])
+            self.demucs_voc_inst_secondary_model_var.set(loaded_setting['demucs_voc_inst_secondary_model'])
+            self.demucs_other_secondary_model_var.set(loaded_setting['demucs_other_secondary_model'])
+            self.demucs_bass_secondary_model_var.set(loaded_setting['demucs_bass_secondary_model'])
+            self.demucs_drums_secondary_model_var.set(loaded_setting['demucs_drums_secondary_model'])
+            self.demucs_is_secondary_model_activate_var.set(loaded_setting['demucs_is_secondary_model_activate'])
+            self.demucs_voc_inst_secondary_model_scale_var.set(loaded_setting['demucs_voc_inst_secondary_model_scale'])
+            self.demucs_other_secondary_model_scale_var.set(loaded_setting['demucs_other_secondary_model_scale'])
+            self.demucs_bass_secondary_model_scale_var.set(loaded_setting['demucs_bass_secondary_model_scale'])
+            self.demucs_drums_secondary_model_scale_var.set(loaded_setting['demucs_drums_secondary_model_scale'])
+            self.demucs_stems_var.set(loaded_setting['demucs_stems'])
+            # self.update_stem_checkbox_labels(self.demucs_stems_var.get(), demucs=True)
+            self.demucs_pre_proc_model_var.set(data['demucs_pre_proc_model'])
+            self.is_demucs_pre_proc_model_activate_var.set(data['is_demucs_pre_proc_model_activate'])
+            self.is_demucs_pre_proc_model_inst_mix_var.set(data['is_demucs_pre_proc_model_inst_mix'])
+        
+        if not process_method or process_method == MDX_ARCH_TYPE or is_ensemble:
+            self.mdx_net_model_var.set(loaded_setting['mdx_net_model'])
+            self.chunks_var.set(loaded_setting['chunks'])
+            self.margin_var.set(loaded_setting['margin'])
+            self.compensate_var.set(loaded_setting['compensate'])
+            self.is_denoise_var.set(loaded_setting['is_denoise'])
+            self.is_invert_spec_var.set(loaded_setting['is_invert_spec'])
+            self.is_mixer_mode_var.set(loaded_setting['is_mixer_mode'])
+            self.mdx_batch_size_var.set(loaded_setting['mdx_batch_size'])
+            self.mdx_voc_inst_secondary_model_var.set(loaded_setting['mdx_voc_inst_secondary_model'])
+            self.mdx_other_secondary_model_var.set(loaded_setting['mdx_other_secondary_model'])
+            self.mdx_bass_secondary_model_var.set(loaded_setting['mdx_bass_secondary_model'])
+            self.mdx_drums_secondary_model_var.set(loaded_setting['mdx_drums_secondary_model'])
+            self.mdx_is_secondary_model_activate_var.set(loaded_setting['mdx_is_secondary_model_activate'])
+            self.mdx_voc_inst_secondary_model_scale_var.set(loaded_setting['mdx_voc_inst_secondary_model_scale'])
+            self.mdx_other_secondary_model_scale_var.set(loaded_setting['mdx_other_secondary_model_scale'])
+            self.mdx_bass_secondary_model_scale_var.set(loaded_setting['mdx_bass_secondary_model_scale'])
+            self.mdx_drums_secondary_model_scale_var.set(loaded_setting['mdx_drums_secondary_model_scale'])
+        
+        if not process_method or is_ensemble:
+            self.is_save_all_outputs_ensemble_var.set(loaded_setting['is_save_all_outputs_ensemble'])
+            self.is_append_ensemble_name_var.set(loaded_setting['is_append_ensemble_name'])
+            self.chosen_audio_tool_var.set(loaded_setting['chosen_audio_tool'])
+            self.choose_algorithm_var.set(loaded_setting['choose_algorithm'])
+            self.time_stretch_rate_var.set(loaded_setting['time_stretch_rate'])
+            self.pitch_rate_var.set(loaded_setting['pitch_rate'])
+            self.is_primary_stem_only_var.set(loaded_setting['is_primary_stem_only'])
+            self.is_secondary_stem_only_var.set(loaded_setting['is_secondary_stem_only'])
+            self.is_testing_audio_var.set(loaded_setting['is_testing_audio'])
+            self.is_add_model_name_var.set(loaded_setting['is_add_model_name'])
+            self.is_accept_any_input_var.set(loaded_setting["is_accept_any_input"])
+            self.is_task_complete_var.set(loaded_setting['is_task_complete'])
+            self.is_create_model_folder_var.set(loaded_setting['is_create_model_folder'])
+            self.mp3_bit_set_var.set(loaded_setting['mp3_bit_set'])
+            self.save_format_var.set(loaded_setting['save_format'])
+            self.wav_type_set_var.set(loaded_setting['wav_type_set'])
+            self.user_code_var.set(loaded_setting['user_code'])
+            
+        self.is_gpu_conversion_var.set(loaded_setting['is_gpu_conversion'])
+        self.is_normalization_var.set(loaded_setting['is_normalization'])
+        self.help_hints_var.set(loaded_setting['help_hints_var'])
+        
+        self.model_sample_mode_var.set(loaded_setting['model_sample_mode'])
+        self.model_sample_mode_duration_var.set(loaded_setting['model_sample_mode_duration'])
+
+
+root = FakeRoot()
+root.load_saved_settings(DEFAULT_DATA)

__version__.py

@@ -0,0 +1,4 @@
+VERSION = 'v5.5.1'
+PATCH = 'UVR_Patch_3_31_23_5_5'
+PATCH_MAC = 'UVR_Patch_01_10_12_6_50'
+PATCH_LINUX = 'UVR_Patch_01_01_23_6_50'

app.py

@@ -0,0 +1,3 @@
+import os
+
+os.system("python webUI.py")

packages.txt

@@ -0,0 +1,3 @@
+git-lfs
+aria2 -y
+ffmpeg

requirements.txt

@@ -0,0 +1,43 @@
+altgraph==0.17.3
+audioread==3.0.0
+certifi==2022.12.7
+cffi==1.15.1
+cryptography==3.4.6
+diffq==0.2.3
+Dora==0.0.3
+einops==0.6.0
+future==0.18.2
+julius==0.2.7
+kthread==0.2.3
+librosa==0.9.2
+llvmlite==0.39.1
+natsort==8.2.0
+numba==0.56.4
+numpy==1.23.4
+omegaconf==2.2.3
+opencv-python==4.6.0.66
+onnx
+onnxruntime==1.13.1
+Pillow==9.3.0
+playsound==1.3.0
+psutil==5.9.4
+pydub==0.25.1
+pyglet==1.5.23
+pyperclip==1.8.2
+pyrubberband==0.3.0
+pytorch_lightning==2.0.0
+PyYAML==6.0
+resampy==0.2.2
+scipy==1.9.3
+soundfile==0.11.0
+soundstretch==1.2
+torch==1.13.1
+tqdm
+urllib3==1.26.12
+wget==3.2
+samplerate==0.1.0
+screeninfo==0.8.1
+PySoundFile==0.9.0.post1; sys_platform != 'windows'
+SoundFile==0.9.0; sys_platform == 'windows'
+
+gradio >= 3.19

separate.py

@@ -0,0 +1,942 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from demucs.apply import apply_model, demucs_segments
+from demucs.hdemucs import HDemucs
+from demucs.model_v2 import auto_load_demucs_model_v2
+from demucs.pretrained import get_model as _gm
+from demucs.utils import apply_model_v1
+from demucs.utils import apply_model_v2
+from lib_v5 import spec_utils
+from lib_v5.vr_network import nets
+from lib_v5.vr_network import nets_new
+#from lib_v5.vr_network.model_param_init import ModelParameters
+from pathlib import Path
+from gui_data.constants import *
+from gui_data.error_handling import *
+import audioread
+import gzip
+import librosa
+import math
+import numpy as np
+import onnxruntime as ort
+import os
+import torch
+import warnings
+import pydub
+import soundfile as sf
+import traceback
+import lib_v5.mdxnet as MdxnetSet
+
+if TYPE_CHECKING:
+    from UVR import ModelData
+
+warnings.filterwarnings("ignore")
+cpu = torch.device('cpu')
+
+class SeperateAttributes:
+    def __init__(self, model_data: ModelData, process_data: dict, main_model_primary_stem_4_stem=None, main_process_method=None):
+        
+        self.list_all_models: list
+        self.process_data = process_data
+        self.progress_value = 0
+        self.set_progress_bar = process_data['set_progress_bar']
+        self.write_to_console = process_data['write_to_console']
+        self.audio_file = process_data['audio_file']
+        self.audio_file_base = process_data['audio_file_base']
+        self.export_path = process_data['export_path']
+        self.cached_source_callback = process_data['cached_source_callback']
+        self.cached_model_source_holder = process_data['cached_model_source_holder']
+        self.is_4_stem_ensemble = process_data['is_4_stem_ensemble']
+        self.list_all_models = process_data['list_all_models']
+        self.process_iteration = process_data['process_iteration']
+        self.mixer_path = model_data.mixer_path
+        self.model_samplerate = model_data.model_samplerate
+        self.model_capacity = model_data.model_capacity
+        self.is_vr_51_model = model_data.is_vr_51_model
+        self.is_pre_proc_model = model_data.is_pre_proc_model
+        self.is_secondary_model_activated = model_data.is_secondary_model_activated if not self.is_pre_proc_model else False
+        self.is_secondary_model = model_data.is_secondary_model if not self.is_pre_proc_model else True
+        self.process_method = model_data.process_method
+        self.model_path = model_data.model_path
+        self.model_name = model_data.model_name
+        self.model_basename = model_data.model_basename
+        self.wav_type_set = model_data.wav_type_set
+        self.mp3_bit_set = model_data.mp3_bit_set
+        self.save_format = model_data.save_format
+        self.is_gpu_conversion = model_data.is_gpu_conversion
+        self.is_normalization = model_data.is_normalization
+        self.is_primary_stem_only = model_data.is_primary_stem_only if not self.is_secondary_model else model_data.is_primary_model_primary_stem_only
+        self.is_secondary_stem_only = model_data.is_secondary_stem_only if not self.is_secondary_model else model_data.is_primary_model_secondary_stem_only      
+        self.is_ensemble_mode = model_data.is_ensemble_mode
+        self.secondary_model = model_data.secondary_model #
+        self.primary_model_primary_stem = model_data.primary_model_primary_stem
+        self.primary_stem = model_data.primary_stem #
+        self.secondary_stem = model_data.secondary_stem #
+        self.is_invert_spec = model_data.is_invert_spec #
+        self.is_mixer_mode = model_data.is_mixer_mode #
+        self.secondary_model_scale = model_data.secondary_model_scale #
+        self.is_demucs_pre_proc_model_inst_mix = model_data.is_demucs_pre_proc_model_inst_mix #
+        self.primary_source_map = {}
+        self.secondary_source_map = {}
+        self.primary_source = None
+        self.secondary_source = None
+        self.secondary_source_primary = None
+        self.secondary_source_secondary = None
+
+        if not model_data.process_method == DEMUCS_ARCH_TYPE:
+            if process_data['is_ensemble_master'] and not self.is_4_stem_ensemble:
+                if not model_data.ensemble_primary_stem == self.primary_stem:
+                    self.is_primary_stem_only, self.is_secondary_stem_only = self.is_secondary_stem_only, self.is_primary_stem_only
+            
+            if self.is_secondary_model and not process_data['is_ensemble_master']:
+                if not self.primary_model_primary_stem == self.primary_stem and not main_model_primary_stem_4_stem:
+                    self.is_primary_stem_only, self.is_secondary_stem_only = self.is_secondary_stem_only, self.is_primary_stem_only
+                    
+            if main_model_primary_stem_4_stem:
+                self.is_primary_stem_only = True if main_model_primary_stem_4_stem == self.primary_stem else False
+                self.is_secondary_stem_only = True if not main_model_primary_stem_4_stem == self.primary_stem else False
+
+            if self.is_pre_proc_model:
+                self.is_primary_stem_only = True if self.primary_stem == INST_STEM else False
+                self.is_secondary_stem_only = True if self.secondary_stem == INST_STEM else False
+
+        if model_data.process_method == MDX_ARCH_TYPE:
+            self.is_mdx_ckpt = model_data.is_mdx_ckpt
+            self.primary_model_name, self.primary_sources = self.cached_source_callback(MDX_ARCH_TYPE, model_name=self.model_basename)
+            self.is_denoise = model_data.is_denoise
+            self.mdx_batch_size = model_data.mdx_batch_size
+            self.compensate = model_data.compensate
+            self.dim_f, self.dim_t = model_data.mdx_dim_f_set, 2**model_data.mdx_dim_t_set
+            self.n_fft = model_data.mdx_n_fft_scale_set
+            self.chunks = model_data.chunks
+            self.margin = model_data.margin
+            self.adjust = 1
+            self.dim_c = 4
+            self.hop = 1024
+            
+            if self.is_gpu_conversion >= 0 and torch.cuda.is_available():
+                self.device, self.run_type = torch.device('cuda:0'), ['CUDAExecutionProvider']
+            else:
+                self.device, self.run_type = torch.device('cpu'), ['CPUExecutionProvider']
+
+        if model_data.process_method == DEMUCS_ARCH_TYPE:
+            self.demucs_stems = model_data.demucs_stems if not main_process_method in [MDX_ARCH_TYPE, VR_ARCH_TYPE] else None
+            self.secondary_model_4_stem = model_data.secondary_model_4_stem
+            self.secondary_model_4_stem_scale = model_data.secondary_model_4_stem_scale
+            self.primary_stem = model_data.ensemble_primary_stem if process_data['is_ensemble_master'] else model_data.primary_stem
+            self.secondary_stem = model_data.ensemble_secondary_stem if process_data['is_ensemble_master'] else model_data.secondary_stem
+            self.is_chunk_demucs = model_data.is_chunk_demucs
+            self.segment = model_data.segment
+            self.demucs_version = model_data.demucs_version
+            self.demucs_source_list = model_data.demucs_source_list
+            self.demucs_source_map = model_data.demucs_source_map
+            self.is_demucs_combine_stems = model_data.is_demucs_combine_stems
+            self.demucs_stem_count = model_data.demucs_stem_count
+            self.pre_proc_model = model_data.pre_proc_model
+            
+            if self.is_secondary_model and not process_data['is_ensemble_master']:
+                if not self.demucs_stem_count == 2 and model_data.primary_model_primary_stem == INST_STEM:
+                    self.primary_stem = VOCAL_STEM
+                    self.secondary_stem = INST_STEM
+                else:
+                    self.primary_stem = model_data.primary_model_primary_stem
+                    self.secondary_stem = STEM_PAIR_MAPPER[self.primary_stem]
+            
+            if self.is_chunk_demucs:
+                self.chunks_demucs = model_data.chunks_demucs
+                self.margin_demucs = model_data.margin_demucs
+            else:
+                self.chunks_demucs = 0
+                self.margin_demucs = 44100
+                
+            self.shifts = model_data.shifts
+            self.is_split_mode = model_data.is_split_mode if not self.demucs_version == DEMUCS_V4 else True
+            self.overlap = model_data.overlap
+            self.primary_model_name, self.primary_sources = self.cached_source_callback(DEMUCS_ARCH_TYPE, model_name=self.model_basename)
+
+        if model_data.process_method == VR_ARCH_TYPE:
+            self.primary_model_name, self.primary_sources = self.cached_source_callback(VR_ARCH_TYPE, model_name=self.model_basename)
+            self.mp = model_data.vr_model_param
+            self.high_end_process = model_data.is_high_end_process
+            self.is_tta = model_data.is_tta
+            self.is_post_process = model_data.is_post_process
+            self.is_gpu_conversion = model_data.is_gpu_conversion
+            self.batch_size = model_data.batch_size
+            self.window_size = model_data.window_size
+            self.input_high_end_h = None
+            self.post_process_threshold = model_data.post_process_threshold
+            self.aggressiveness = {'value': model_data.aggression_setting, 
+                                   'split_bin': self.mp.param['band'][1]['crop_stop'], 
+                                   'aggr_correction': self.mp.param.get('aggr_correction')}
+            
+    def start_inference_console_write(self):
+        
+        if self.is_secondary_model and not self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_2_SEC(self.process_method, self.model_basename))
+        
+        if self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_2_PRE(self.process_method, self.model_basename))
+        
+    def running_inference_console_write(self, is_no_write=False):
+        
+        self.write_to_console(DONE, base_text='') if not is_no_write else None
+        self.set_progress_bar(0.05) if not is_no_write else None
+        
+        if self.is_secondary_model and not self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_1_SEC)
+        elif self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_1_PRE)
+        else:
+            self.write_to_console(INFERENCE_STEP_1)
+        
+    def running_inference_progress_bar(self, length, is_match_mix=False):
+        if not is_match_mix:
+            self.progress_value += 1
+
+            if (0.8/length*self.progress_value) >= 0.8:
+                length = self.progress_value + 1
+  
+            self.set_progress_bar(0.1, (0.8/length*self.progress_value))
+        
+    def load_cached_sources(self, is_4_stem_demucs=False):
+        
+        if self.is_secondary_model and not self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_2_SEC_CACHED_MODOEL(self.process_method, self.model_basename))
+        elif self.is_pre_proc_model:
+            self.write_to_console(INFERENCE_STEP_2_PRE_CACHED_MODOEL(self.process_method, self.model_basename))
+        else:
+            self.write_to_console(INFERENCE_STEP_2_PRIMARY_CACHED)
+
+        if not is_4_stem_demucs:
+            primary_stem, secondary_stem = gather_sources(self.primary_stem, self.secondary_stem, self.primary_sources)
+            
+            return primary_stem, secondary_stem
+            
+    def cache_source(self, secondary_sources):
+        
+        model_occurrences = self.list_all_models.count(self.model_basename)
+        
+        if not model_occurrences <= 1:
+            if self.process_method == MDX_ARCH_TYPE:
+                self.cached_model_source_holder(MDX_ARCH_TYPE, secondary_sources, self.model_basename)
+                
+            if self.process_method == VR_ARCH_TYPE:
+                self.cached_model_source_holder(VR_ARCH_TYPE, secondary_sources, self.model_basename)
+
+            if self.process_method == DEMUCS_ARCH_TYPE:
+                self.cached_model_source_holder(DEMUCS_ARCH_TYPE, secondary_sources, self.model_basename)
+                
+    def write_audio(self, stem_path, stem_source, samplerate, secondary_model_source=None, model_scale=None):
+                
+        if not self.is_secondary_model:
+            if self.is_secondary_model_activated:
+                if isinstance(secondary_model_source, np.ndarray):
+                    secondary_model_scale = model_scale if model_scale else self.secondary_model_scale
+                    stem_source = spec_utils.average_dual_sources(stem_source, secondary_model_source, secondary_model_scale)
+            
+            sf.write(stem_path, stem_source, samplerate, subtype=self.wav_type_set)
+            save_format(stem_path, self.save_format, self.mp3_bit_set) if not self.is_ensemble_mode else None
+            
+            self.write_to_console(DONE, base_text='')
+            self.set_progress_bar(0.95)
+
+    def run_mixer(self, mix, sources):
+        try:
+            if self.is_mixer_mode and len(sources) == 4:
+                mixer = MdxnetSet.Mixer(self.device, self.mixer_path).eval()
+                with torch.no_grad():
+                    mix = torch.tensor(mix, dtype=torch.float32)
+                    sources_ = torch.tensor(sources).detach()
+                    x = torch.cat([sources_, mix.unsqueeze(0)], 0)
+                    sources_ = mixer(x)
+                final_source = np.array(sources_)
+            else:
+                final_source = sources
+        except Exception as e:
+            error_name = f'{type(e).__name__}'
+            traceback_text = ''.join(traceback.format_tb(e.__traceback__))
+            message = f'{error_name}: "{e}"\n{traceback_text}"'
+            print('Mixer Failed: ', message)
+            final_source = sources
+            
+        return final_source
+
+class SeperateMDX(SeperateAttributes):        
+
+    def seperate(self):
+        samplerate = 44100
+          
+        if self.primary_model_name == self.model_basename and self.primary_sources:
+            self.primary_source, self.secondary_source = self.load_cached_sources()
+        else:
+            self.start_inference_console_write()
+
+            if self.is_mdx_ckpt:
+                model_params = torch.load(self.model_path, map_location=lambda storage, loc: storage)['hyper_parameters']
+                self.dim_c, self.hop = model_params['dim_c'], model_params['hop_length']
+                separator = MdxnetSet.ConvTDFNet(**model_params)
+                self.model_run = separator.load_from_checkpoint(self.model_path).to(self.device).eval()
+            else:
+                ort_ = ort.InferenceSession(self.model_path, providers=self.run_type)
+                self.model_run = lambda spek:ort_.run(None, {'input': spek.cpu().numpy()})[0]
+
+            self.initialize_model_settings()
+            self.running_inference_console_write()
+            mdx_net_cut = True if self.primary_stem in MDX_NET_FREQ_CUT else False
+            mix, raw_mix, samplerate = prepare_mix(self.audio_file, self.chunks, self.margin, mdx_net_cut=mdx_net_cut)
+            source = self.demix_base(mix, is_ckpt=self.is_mdx_ckpt)[0]
+            self.write_to_console(DONE, base_text='')            
+
+        if self.is_secondary_model_activated:
+            if self.secondary_model:
+                self.secondary_source_primary, self.secondary_source_secondary = process_secondary_model(self.secondary_model, self.process_data, main_process_method=self.process_method)
+        
+        if not self.is_secondary_stem_only:
+            self.write_to_console(f'{SAVING_STEM[0]}{self.primary_stem}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+            primary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({self.primary_stem}).wav')
+            if not isinstance(self.primary_source, np.ndarray):
+                self.primary_source = spec_utils.normalize(source, self.is_normalization).T
+            self.primary_source_map = {self.primary_stem: self.primary_source}
+            self.write_audio(primary_stem_path, self.primary_source, samplerate, self.secondary_source_primary)
+
+        if not self.is_primary_stem_only:
+            self.write_to_console(f'{SAVING_STEM[0]}{self.secondary_stem}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+            secondary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({self.secondary_stem}).wav')
+            if not isinstance(self.secondary_source, np.ndarray):
+                raw_mix = self.demix_base(raw_mix, is_match_mix=True)[0] if mdx_net_cut else raw_mix
+                self.secondary_source, raw_mix = spec_utils.normalize_two_stem(source*self.compensate, raw_mix, self.is_normalization)
+            
+                if self.is_invert_spec:
+                    self.secondary_source = spec_utils.invert_stem(raw_mix, self.secondary_source)
+                else:
+                    self.secondary_source = (-self.secondary_source.T+raw_mix.T)
+
+            self.secondary_source_map = {self.secondary_stem: self.secondary_source}
+            self.write_audio(secondary_stem_path, self.secondary_source, samplerate, self.secondary_source_secondary)
+
+        torch.cuda.empty_cache()
+        secondary_sources = {**self.primary_source_map, **self.secondary_source_map}
+
+        self.cache_source(secondary_sources)
+
+        if self.is_secondary_model:
+            return secondary_sources
+
+    def initialize_model_settings(self):
+        self.n_bins = self.n_fft//2+1
+        self.trim = self.n_fft//2
+        self.chunk_size = self.hop * (self.dim_t-1)
+        self.window = torch.hann_window(window_length=self.n_fft, periodic=False).to(self.device)
+        self.freq_pad = torch.zeros([1, self.dim_c, self.n_bins-self.dim_f, self.dim_t]).to(self.device)
+        self.gen_size = self.chunk_size-2*self.trim
+
+    def initialize_mix(self, mix, is_ckpt=False):
+        if is_ckpt:
+            pad = self.gen_size + self.trim - ((mix.shape[-1]) % self.gen_size)
+            mixture = np.concatenate((np.zeros((2, self.trim), dtype='float32'),mix, np.zeros((2, pad), dtype='float32')), 1)
+            num_chunks = mixture.shape[-1] // self.gen_size
+            mix_waves = [mixture[:, i * self.gen_size: i * self.gen_size + self.chunk_size] for i in range(num_chunks)]
+        else:
+            mix_waves = []
+            n_sample = mix.shape[1]
+            pad = self.gen_size - n_sample%self.gen_size
+            mix_p = np.concatenate((np.zeros((2,self.trim)), mix, np.zeros((2,pad)), np.zeros((2,self.trim))), 1)
+            i = 0
+            while i < n_sample + pad:
+                waves = np.array(mix_p[:, i:i+self.chunk_size])
+                mix_waves.append(waves)
+                i += self.gen_size
+                
+        mix_waves = torch.tensor(mix_waves, dtype=torch.float32).to(self.device)
+
+        return mix_waves, pad
+    
+    def demix_base(self, mix, is_ckpt=False, is_match_mix=False):
+        chunked_sources = []
+        for slice in mix:
+            sources = []
+            tar_waves_ = []
+            mix_p = mix[slice]
+            mix_waves, pad = self.initialize_mix(mix_p, is_ckpt=is_ckpt)
+            mix_waves = mix_waves.split(self.mdx_batch_size)
+            pad = mix_p.shape[-1] if is_ckpt else -pad
+            with torch.no_grad():
+                for mix_wave in mix_waves:
+                    self.running_inference_progress_bar(len(mix)*len(mix_waves), is_match_mix=is_match_mix)
+                    tar_waves = self.run_model(mix_wave, is_ckpt=is_ckpt, is_match_mix=is_match_mix)
+                    tar_waves_.append(tar_waves)
+                tar_waves_ = np.vstack(tar_waves_)[:, :, self.trim:-self.trim] if is_ckpt else tar_waves_
+                tar_waves = np.concatenate(tar_waves_, axis=-1)[:, :pad]
+                start = 0 if slice == 0 else self.margin
+                end = None if slice == list(mix.keys())[::-1][0] or self.margin == 0 else -self.margin
+                sources.append(tar_waves[:,start:end]*(1/self.adjust))
+            chunked_sources.append(sources)
+        sources = np.concatenate(chunked_sources, axis=-1)
+        
+        return sources
+
+    def run_model(self, mix, is_ckpt=False, is_match_mix=False):
+        
+        spek = self.stft(mix.to(self.device))*self.adjust
+        spek[:, :, :3, :] *= 0 
+
+        if is_match_mix:
+            spec_pred = spek.cpu().numpy()
+        else:
+            spec_pred = -self.model_run(-spek)*0.5+self.model_run(spek)*0.5 if self.is_denoise else self.model_run(spek)
+
+        if is_ckpt:
+            return self.istft(spec_pred).cpu().detach().numpy()
+        else: 
+            return self.istft(torch.tensor(spec_pred).to(self.device)).to(cpu)[:,:,self.trim:-self.trim].transpose(0,1).reshape(2, -1).numpy()
+    
+    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,self.dim_c,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)
+        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 SeperateDemucs(SeperateAttributes):        
+
+    def seperate(self):
+
+        samplerate = 44100
+        source = None
+        model_scale = None
+        stem_source = None
+        stem_source_secondary = None
+        inst_mix = None
+        inst_raw_mix = None
+        raw_mix = None
+        inst_source = None
+        is_no_write = False
+        is_no_piano_guitar = False
+
+        if self.primary_model_name == self.model_basename and type(self.primary_sources) is dict and not self.pre_proc_model:
+            self.primary_source, self.secondary_source = self.load_cached_sources()
+        elif self.primary_model_name == self.model_basename and isinstance(self.primary_sources, np.ndarray) and not self.pre_proc_model:
+            source = self.primary_sources
+            self.load_cached_sources(is_4_stem_demucs=True)
+        else:
+            self.start_inference_console_write()
+
+            if self.is_gpu_conversion >= 0:
+                self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') 
+            else:
+                self.device = torch.device('cpu')
+            
+            if self.demucs_version == DEMUCS_V1:
+                if str(self.model_path).endswith(".gz"):
+                    self.model_path = gzip.open(self.model_path, "rb")
+                klass, args, kwargs, state = torch.load(self.model_path)
+                self.demucs = klass(*args, **kwargs)
+                self.demucs.to(self.device) 
+                self.demucs.load_state_dict(state)
+            elif self.demucs_version == DEMUCS_V2:
+                self.demucs = auto_load_demucs_model_v2(self.demucs_source_list, self.model_path)
+                self.demucs.to(self.device) 
+                self.demucs.load_state_dict(torch.load(self.model_path))
+                self.demucs.eval()
+            else:  
+                self.demucs = HDemucs(sources=self.demucs_source_list)
+                self.demucs = _gm(name=os.path.splitext(os.path.basename(self.model_path))[0], 
+                                  repo=Path(os.path.dirname(self.model_path)))
+                self.demucs = demucs_segments(self.segment, self.demucs)
+                self.demucs.to(self.device)
+                self.demucs.eval()
+
+            if self.pre_proc_model:
+                if self.primary_stem not in [VOCAL_STEM, INST_STEM]:
+                    is_no_write = True
+                    self.write_to_console(DONE, base_text='')
+                    mix_no_voc = process_secondary_model(self.pre_proc_model, self.process_data, is_pre_proc_model=True)
+                    inst_mix, inst_raw_mix, inst_samplerate = prepare_mix(mix_no_voc[INST_STEM], self.chunks_demucs, self.margin_demucs)
+                    self.process_iteration()
+                    self.running_inference_console_write(is_no_write=is_no_write)
+                    inst_source = self.demix_demucs(inst_mix)
+                    inst_source = self.run_mixer(inst_raw_mix, inst_source)
+                    self.process_iteration()
+
+            self.running_inference_console_write(is_no_write=is_no_write) if not self.pre_proc_model else None
+            mix, raw_mix, samplerate = prepare_mix(self.audio_file, self.chunks_demucs, self.margin_demucs)
+            
+            if self.primary_model_name == self.model_basename and isinstance(self.primary_sources, np.ndarray) and self.pre_proc_model:
+                source = self.primary_sources
+            else:
+                source = self.demix_demucs(mix)
+                source = self.run_mixer(raw_mix, source)
+            
+            self.write_to_console(DONE, base_text='')
+            
+            del self.demucs
+            torch.cuda.empty_cache()
+            
+        if isinstance(inst_source, np.ndarray):
+            source_reshape = spec_utils.reshape_sources(inst_source[self.demucs_source_map[VOCAL_STEM]], source[self.demucs_source_map[VOCAL_STEM]])
+            inst_source[self.demucs_source_map[VOCAL_STEM]] = source_reshape
+            source = inst_source
+
+        if isinstance(source, np.ndarray):
+            if len(source) == 2:
+                self.demucs_source_map = DEMUCS_2_SOURCE_MAPPER
+            else:
+                self.demucs_source_map = DEMUCS_6_SOURCE_MAPPER if len(source) == 6 else DEMUCS_4_SOURCE_MAPPER
+
+                if len(source) == 6 and self.process_data['is_ensemble_master'] or len(source) == 6 and self.is_secondary_model:
+                    is_no_piano_guitar = True
+                    six_stem_other_source = list(source)
+                    six_stem_other_source = [i for n, i in enumerate(source) if n in [self.demucs_source_map[OTHER_STEM], self.demucs_source_map[GUITAR_STEM], self.demucs_source_map[PIANO_STEM]]]
+                    other_source = np.zeros_like(six_stem_other_source[0])
+                    for i in six_stem_other_source:
+                        other_source += i
+                    source_reshape = spec_utils.reshape_sources(source[self.demucs_source_map[OTHER_STEM]], other_source)
+                    source[self.demucs_source_map[OTHER_STEM]] = source_reshape
+
+        if (self.demucs_stems == ALL_STEMS and not self.process_data['is_ensemble_master']) or self.is_4_stem_ensemble:
+            self.cache_source(source)
+            
+            for stem_name, stem_value in self.demucs_source_map.items():
+                if self.is_secondary_model_activated and not self.is_secondary_model and not stem_value >= 4:
+                    if self.secondary_model_4_stem[stem_value]:
+                        model_scale = self.secondary_model_4_stem_scale[stem_value]
+                        stem_source_secondary = process_secondary_model(self.secondary_model_4_stem[stem_value], self.process_data, main_model_primary_stem_4_stem=stem_name, is_4_stem_demucs=True)
+                        if isinstance(stem_source_secondary, np.ndarray):
+                            stem_source_secondary = stem_source_secondary[1 if self.secondary_model_4_stem[stem_value].demucs_stem_count == 2 else stem_value]
+                            stem_source_secondary = spec_utils.normalize(stem_source_secondary, self.is_normalization).T
+                        elif type(stem_source_secondary) is dict:
+                            stem_source_secondary = stem_source_secondary[stem_name]
+                            
+                stem_source_secondary = None if stem_value >= 4 else stem_source_secondary
+                self.write_to_console(f'{SAVING_STEM[0]}{stem_name}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+                stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({stem_name}).wav')
+                stem_source = spec_utils.normalize(source[stem_value], self.is_normalization).T
+                self.write_audio(stem_path, stem_source, samplerate, secondary_model_source=stem_source_secondary, model_scale=model_scale)
+
+            if self.is_secondary_model:    
+                return source
+        else:
+            if self.is_secondary_model_activated:
+                if self.secondary_model:
+                    self.secondary_source_primary, self.secondary_source_secondary = process_secondary_model(self.secondary_model, self.process_data, main_process_method=self.process_method)
+
+            if not self.is_secondary_stem_only:
+                self.write_to_console(f'{SAVING_STEM[0]}{self.primary_stem}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+                primary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({self.primary_stem}).wav')
+                if not isinstance(self.primary_source, np.ndarray):
+                    self.primary_source = spec_utils.normalize(source[self.demucs_source_map[self.primary_stem]], self.is_normalization).T
+                self.primary_source_map = {self.primary_stem: self.primary_source}
+                self.write_audio(primary_stem_path, self.primary_source, samplerate, self.secondary_source_primary)
+
+            if not self.is_primary_stem_only:
+                def secondary_save(sec_stem_name, source, raw_mixture=None, is_inst_mixture=False):
+                    secondary_source = self.secondary_source if not is_inst_mixture else None
+                    self.write_to_console(f'{SAVING_STEM[0]}{sec_stem_name}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+                    secondary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({sec_stem_name}).wav')
+                    secondary_source_secondary = None
+                    
+                    if not isinstance(secondary_source, np.ndarray):
+                        if self.is_demucs_combine_stems:
+                            source = list(source)
+                            if is_inst_mixture:
+                                source = [i for n, i in enumerate(source) if not n in [self.demucs_source_map[self.primary_stem], self.demucs_source_map[VOCAL_STEM]]]
+                            else:
+                                source.pop(self.demucs_source_map[self.primary_stem])
+                                
+                            source = source[:len(source) - 2] if is_no_piano_guitar else source
+                            secondary_source = np.zeros_like(source[0])
+                            for i in source:
+                                secondary_source += i
+                            secondary_source = spec_utils.normalize(secondary_source, self.is_normalization).T
+                        else:
+                            if not isinstance(raw_mixture, np.ndarray):
+                                raw_mixture = prepare_mix(self.audio_file, self.chunks_demucs, self.margin_demucs, is_missing_mix=True)
+       
+                            secondary_source, raw_mixture = spec_utils.normalize_two_stem(source[self.demucs_source_map[self.primary_stem]], raw_mixture, self.is_normalization)
+                            
+                            if self.is_invert_spec:
+                                secondary_source = spec_utils.invert_stem(raw_mixture, secondary_source)
+                            else:
+                                raw_mixture = spec_utils.reshape_sources(secondary_source, raw_mixture)
+                                secondary_source = (-secondary_source.T+raw_mixture.T)
+                            
+                    if not is_inst_mixture:
+                        self.secondary_source = secondary_source
+                        secondary_source_secondary = self.secondary_source_secondary
+                        self.secondary_source_map = {self.secondary_stem: self.secondary_source}
+
+                    self.write_audio(secondary_stem_path, secondary_source, samplerate, secondary_source_secondary)
+
+                secondary_save(self.secondary_stem, source, raw_mixture=raw_mix)
+                
+                if self.is_demucs_pre_proc_model_inst_mix and self.pre_proc_model and not self.is_4_stem_ensemble:
+                    secondary_save(f"{self.secondary_stem} {INST_STEM}", source, raw_mixture=inst_raw_mix, is_inst_mixture=True)
+
+            secondary_sources = {**self.primary_source_map, **self.secondary_source_map}
+
+            self.cache_source(secondary_sources)
+            
+            if self.is_secondary_model:    
+                return secondary_sources
+    
+    def demix_demucs(self, mix):
+        processed = {}
+
+        set_progress_bar = None if self.is_chunk_demucs else self.set_progress_bar
+
+        for nmix in mix:
+            self.progress_value += 1
+            self.set_progress_bar(0.1, (0.8/len(mix)*self.progress_value)) if self.is_chunk_demucs else None
+            cmix = mix[nmix]
+            cmix = torch.tensor(cmix, dtype=torch.float32)
+            ref = cmix.mean(0)        
+            cmix = (cmix - ref.mean()) / ref.std()
+            mix_infer = cmix 
+            
+            with torch.no_grad():
+                if self.demucs_version == DEMUCS_V1:
+                    sources = apply_model_v1(self.demucs, 
+                                                mix_infer.to(self.device), 
+                                                self.shifts, 
+                                                self.is_split_mode,
+                                                set_progress_bar=set_progress_bar)
+                elif self.demucs_version == DEMUCS_V2:
+                    sources = apply_model_v2(self.demucs, 
+                                                mix_infer.to(self.device), 
+                                                self.shifts,
+                                                self.is_split_mode,
+                                                self.overlap,
+                                                set_progress_bar=set_progress_bar)
+                else:
+                    sources = apply_model(self.demucs, 
+                                            mix_infer[None], 
+                                            self.shifts,
+                                            self.is_split_mode,
+                                            self.overlap,
+                                            static_shifts=1 if self.shifts == 0 else self.shifts,
+                                            set_progress_bar=set_progress_bar,
+                                            device=self.device)[0]
+            
+            sources = (sources * ref.std() + ref.mean()).cpu().numpy()
+            sources[[0,1]] = sources[[1,0]]
+            start = 0 if nmix == 0 else self.margin_demucs
+            end = None if nmix == list(mix.keys())[::-1][0] else -self.margin_demucs
+            if self.margin_demucs == 0:
+                end = None
+            processed[nmix] = sources[:,:,start:end].copy()
+            sources = list(processed.values())
+        sources = np.concatenate(sources, axis=-1)
+                        
+        return sources
+
+class SeperateVR(SeperateAttributes):        
+
+    def seperate(self):
+        if self.primary_model_name == self.model_basename and self.primary_sources:
+            self.primary_source, self.secondary_source = self.load_cached_sources()
+        else:
+            self.start_inference_console_write()
+            if self.is_gpu_conversion >= 0:
+                if OPERATING_SYSTEM == 'Darwin':
+                    device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu')
+                else:
+                    device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') 
+            else:
+                device = torch.device('cpu')
+
+            nn_arch_sizes = [
+                31191, # default
+                33966, 56817, 123821, 123812, 129605, 218409, 537238, 537227]
+            vr_5_1_models = [56817, 218409]
+            model_size = math.ceil(os.stat(self.model_path).st_size / 1024)
+            nn_arch_size = min(nn_arch_sizes, key=lambda x:abs(x-model_size))
+
+            if nn_arch_size in vr_5_1_models or self.is_vr_51_model:
+                self.model_run = nets_new.CascadedNet(self.mp.param['bins'] * 2, nn_arch_size, nout=self.model_capacity[0], nout_lstm=self.model_capacity[1])
+            else:
+                self.model_run = nets.determine_model_capacity(self.mp.param['bins'] * 2, nn_arch_size)
+                            
+            self.model_run.load_state_dict(torch.load(self.model_path, map_location=cpu)) 
+            self.model_run.to(device) 
+
+            self.running_inference_console_write()
+                        
+            y_spec, v_spec = self.inference_vr(self.loading_mix(), device, self.aggressiveness)
+            self.write_to_console(DONE, base_text='')
+            
+        if self.is_secondary_model_activated:
+            if self.secondary_model:
+                self.secondary_source_primary, self.secondary_source_secondary = process_secondary_model(self.secondary_model, self.process_data, main_process_method=self.process_method)
+
+        if not self.is_secondary_stem_only:
+            self.write_to_console(f'{SAVING_STEM[0]}{self.primary_stem}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+            primary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({self.primary_stem}).wav')
+            if not isinstance(self.primary_source, np.ndarray):
+                self.primary_source = spec_utils.normalize(self.spec_to_wav(y_spec), self.is_normalization).T
+                if not self.model_samplerate == 44100:
+                    self.primary_source = librosa.resample(self.primary_source.T, orig_sr=self.model_samplerate, target_sr=44100).T
+                
+            self.primary_source_map = {self.primary_stem: self.primary_source}
+            
+            self.write_audio(primary_stem_path, self.primary_source, 44100, self.secondary_source_primary)
+
+        if not self.is_primary_stem_only:
+            self.write_to_console(f'{SAVING_STEM[0]}{self.secondary_stem}{SAVING_STEM[1]}') if not self.is_secondary_model else None
+            secondary_stem_path = os.path.join(self.export_path, f'{self.audio_file_base}_({self.secondary_stem}).wav')
+            if not isinstance(self.secondary_source, np.ndarray):
+                self.secondary_source = self.spec_to_wav(v_spec)
+                self.secondary_source = spec_utils.normalize(self.spec_to_wav(v_spec), self.is_normalization).T
+                if not self.model_samplerate == 44100:
+                    self.secondary_source = librosa.resample(self.secondary_source.T, orig_sr=self.model_samplerate, target_sr=44100).T
+            
+            self.secondary_source_map = {self.secondary_stem: self.secondary_source}
+            
+            self.write_audio(secondary_stem_path, self.secondary_source, 44100, self.secondary_source_secondary)
+            
+        torch.cuda.empty_cache()
+        secondary_sources = {**self.primary_source_map, **self.secondary_source_map}
+        self.cache_source(secondary_sources)
+
+        if self.is_secondary_model:
+            return secondary_sources
+            
+    def loading_mix(self):
+
+        X_wave, X_spec_s = {}, {}
+        
+        bands_n = len(self.mp.param['band'])
+        
+        for d in range(bands_n, 0, -1):        
+            bp = self.mp.param['band'][d]
+        
+            if OPERATING_SYSTEM == 'Darwin':
+                wav_resolution = 'polyphase' if SYSTEM_PROC == ARM or ARM in SYSTEM_ARCH else bp['res_type']
+            else:
+                wav_resolution = bp['res_type']
+        
+            if d == bands_n: # high-end band
+                X_wave[d], _ = librosa.load(self.audio_file, bp['sr'], False, dtype=np.float32, res_type=wav_resolution)
+                    
+                if not np.any(X_wave[d]) and self.audio_file.endswith('.mp3'):
+                    X_wave[d] = rerun_mp3(self.audio_file, bp['sr'])
+
+                if X_wave[d].ndim == 1:
+                    X_wave[d] = np.asarray([X_wave[d], X_wave[d]])
+            else: # lower bands
+                X_wave[d] = librosa.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=wav_resolution)
+                
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], 
+                                                            self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            
+            if d == bands_n and self.high_end_process != 'none':
+                self.input_high_end_h = (bp['n_fft']//2 - bp['crop_stop']) + (self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
+                self.input_high_end = X_spec_s[d][:, bp['n_fft']//2-self.input_high_end_h:bp['n_fft']//2, :]
+
+        X_spec = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+        
+        del X_wave, X_spec_s
+
+        return X_spec
+
+    def inference_vr(self, X_spec, device, aggressiveness):
+        def _execute(X_mag_pad, roi_size):
+            X_dataset = []
+            patches = (X_mag_pad.shape[2] - 2 * self.model_run.offset) // roi_size
+            total_iterations = patches//self.batch_size if not self.is_tta else (patches//self.batch_size)*2
+            for i in range(patches):
+                start = i * roi_size
+                X_mag_window = X_mag_pad[:, :, start:start + self.window_size]
+                X_dataset.append(X_mag_window)
+
+            X_dataset = np.asarray(X_dataset)
+            self.model_run.eval()
+            with torch.no_grad():
+                mask = []
+                for i in range(0, patches, self.batch_size):
+                    self.progress_value += 1
+                    if self.progress_value >= total_iterations:
+                        self.progress_value = total_iterations
+                    self.set_progress_bar(0.1, 0.8/total_iterations*self.progress_value)
+                    X_batch = X_dataset[i: i + self.batch_size]
+                    X_batch = torch.from_numpy(X_batch).to(device)
+                    pred = self.model_run.predict_mask(X_batch)
+                    if not pred.size()[3] > 0:
+                        raise Exception(ERROR_MAPPER[WINDOW_SIZE_ERROR])
+                    pred = pred.detach().cpu().numpy()
+                    pred = np.concatenate(pred, axis=2)
+                    mask.append(pred)
+                if len(mask) == 0:
+                    raise Exception(ERROR_MAPPER[WINDOW_SIZE_ERROR])
+                
+                mask = np.concatenate(mask, axis=2)
+            return mask
+
+        def postprocess(mask, X_mag, X_phase):
+            
+            is_non_accom_stem = False
+            for stem in NON_ACCOM_STEMS:
+                if stem == self.primary_stem:
+                    is_non_accom_stem = True
+                    
+            mask = spec_utils.adjust_aggr(mask, is_non_accom_stem, aggressiveness)
+
+            if self.is_post_process:
+                mask = spec_utils.merge_artifacts(mask, thres=self.post_process_threshold)
+
+            y_spec = mask * X_mag * np.exp(1.j * X_phase)
+            v_spec = (1 - mask) * X_mag * np.exp(1.j * X_phase)
+        
+            return y_spec, v_spec
+        X_mag, X_phase = spec_utils.preprocess(X_spec)
+        n_frame = X_mag.shape[2]
+        pad_l, pad_r, roi_size = spec_utils.make_padding(n_frame, self.window_size, self.model_run.offset)
+        X_mag_pad = np.pad(X_mag, ((0, 0), (0, 0), (pad_l, pad_r)), mode='constant')
+        X_mag_pad /= X_mag_pad.max()
+        mask = _execute(X_mag_pad, roi_size)
+        
+        if self.is_tta:
+            pad_l += roi_size // 2
+            pad_r += roi_size // 2
+            X_mag_pad = np.pad(X_mag, ((0, 0), (0, 0), (pad_l, pad_r)), mode='constant')
+            X_mag_pad /= X_mag_pad.max()
+            mask_tta = _execute(X_mag_pad, roi_size)
+            mask_tta = mask_tta[:, :, roi_size // 2:]
+            mask = (mask[:, :, :n_frame] + mask_tta[:, :, :n_frame]) * 0.5
+        else:
+            mask = mask[:, :, :n_frame]
+
+        y_spec, v_spec = postprocess(mask, X_mag, X_phase)
+        
+        return y_spec, v_spec
+
+    def spec_to_wav(self, spec):
+        
+        if self.high_end_process.startswith('mirroring'):        
+            input_high_end_ = spec_utils.mirroring(self.high_end_process, spec, self.input_high_end, self.mp)
+            wav = spec_utils.cmb_spectrogram_to_wave(spec, self.mp, self.input_high_end_h, input_high_end_)       
+        else:
+            wav = spec_utils.cmb_spectrogram_to_wave(spec, self.mp)
+            
+        return wav
+   
+def process_secondary_model(secondary_model: ModelData, process_data, main_model_primary_stem_4_stem=None, is_4_stem_demucs=False, main_process_method=None, is_pre_proc_model=False):
+        
+    if not is_pre_proc_model:
+        process_iteration = process_data['process_iteration']
+        process_iteration()
+    
+    if secondary_model.process_method == VR_ARCH_TYPE:
+        seperator = SeperateVR(secondary_model, process_data, main_model_primary_stem_4_stem=main_model_primary_stem_4_stem, main_process_method=main_process_method)
+    if secondary_model.process_method == MDX_ARCH_TYPE:
+        seperator = SeperateMDX(secondary_model, process_data, main_model_primary_stem_4_stem=main_model_primary_stem_4_stem, main_process_method=main_process_method)
+    if secondary_model.process_method == DEMUCS_ARCH_TYPE:
+        seperator = SeperateDemucs(secondary_model, process_data, main_model_primary_stem_4_stem=main_model_primary_stem_4_stem, main_process_method=main_process_method)
+        
+    secondary_sources = seperator.seperate()
+
+    if type(secondary_sources) is dict and not is_4_stem_demucs and not is_pre_proc_model:
+        return gather_sources(secondary_model.primary_model_primary_stem, STEM_PAIR_MAPPER[secondary_model.primary_model_primary_stem], secondary_sources)
+    else:
+        return secondary_sources
+    
+def gather_sources(primary_stem_name, secondary_stem_name, secondary_sources: dict):
+    
+    source_primary = False
+    source_secondary = False
+
+    for key, value in secondary_sources.items():
+        if key in primary_stem_name:
+            source_primary = value
+        if key in secondary_stem_name:
+            source_secondary = value
+
+    return source_primary, source_secondary
+        
+def prepare_mix(mix, chunk_set, margin_set, mdx_net_cut=False, is_missing_mix=False):
+
+    audio_path = mix
+    samplerate = 44100
+
+    if not isinstance(mix, np.ndarray):
+        mix, samplerate = librosa.load(mix, mono=False, sr=44100)
+    else:
+        mix = mix.T
+
+    if not np.any(mix) and audio_path.endswith('.mp3'):
+        mix = rerun_mp3(audio_path)
+
+    if mix.ndim == 1:
+        mix = np.asfortranarray([mix,mix])
+
+    def get_segmented_mix(chunk_set=chunk_set):
+        segmented_mix = {}
+        
+        samples = mix.shape[-1]
+        margin = margin_set
+        chunk_size = chunk_set*44100
+        assert not margin == 0, 'margin cannot be zero!'
+        
+        if margin > chunk_size:
+            margin = chunk_size
+        if chunk_set == 0 or samples < chunk_size:
+            chunk_size = samples
+        
+        counter = -1
+        for skip in range(0, samples, chunk_size):
+            counter+=1
+            s_margin = 0 if counter == 0 else margin
+            end = min(skip+chunk_size+margin, samples)
+            start = skip-s_margin
+            segmented_mix[skip] = mix[:,start:end].copy()
+            if end == samples:
+                break
+            
+        return segmented_mix
+
+    if is_missing_mix:
+        return mix
+    else:
+        segmented_mix = get_segmented_mix()
+        raw_mix = get_segmented_mix(chunk_set=0) if mdx_net_cut else mix
+        return segmented_mix, raw_mix, samplerate
+
+def rerun_mp3(audio_file, sample_rate=44100):
+
+    with audioread.audio_open(audio_file) as f:
+        track_length = int(f.duration)
+
+    return librosa.load(audio_file, duration=track_length, mono=False, sr=sample_rate)[0]
+
+def save_format(audio_path, save_format, mp3_bit_set):
+    
+    if not save_format == WAV:
+        
+        if OPERATING_SYSTEM == 'Darwin':
+            FFMPEG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'ffmpeg')
+            pydub.AudioSegment.converter = FFMPEG_PATH
+        
+        musfile = pydub.AudioSegment.from_wav(audio_path)
+        
+        if save_format == FLAC:
+            audio_path_flac = audio_path.replace(".wav", ".flac")
+            musfile.export(audio_path_flac, format="flac")  
+        
+        if save_format == MP3:
+            audio_path_mp3 = audio_path.replace(".wav", ".mp3")
+            musfile.export(audio_path_mp3, format="mp3", bitrate=mp3_bit_set)
+        
+        try:
+            os.remove(audio_path)
+        except Exception as e:
+            print(e)

webUI.py

@@ -0,0 +1,285 @@
+import os
+import json
+
+import librosa
+import soundfile
+import numpy as np
+
+import gradio as gr
+from UVR_interface import root, UVRInterface, VR_MODELS_DIR, MDX_MODELS_DIR, DEMUCS_MODELS_DIR
+from gui_data.constants import *
+from typing import List, Dict, Callable, Union
+
+
+class UVRWebUI:
+    def __init__(self, uvr: UVRInterface, online_data_path: str) -> None:
+        self.uvr = uvr
+        self.models_url = self.get_models_url(online_data_path)
+        self.define_layout()
+
+        self.input_temp_dir = "__temp"
+        self.export_path = "out"
+        if not os.path.exists(self.input_temp_dir):
+            os.mkdir(self.input_temp_dir)
+
+    def get_models_url(self, models_info_path: str) -> Dict[str, Dict]:
+        with open(models_info_path, "r") as f:
+            online_data = json.loads(f.read())
+        models_url = {}
+        for arch, download_list_key in zip([VR_ARCH_TYPE, MDX_ARCH_TYPE], ["vr_download_list", "mdx_download_list"]):
+            models_url[arch] = {model: NORMAL_REPO+model_path for model, model_path in online_data[download_list_key].items()}
+        models_url[DEMUCS_ARCH_TYPE] = online_data["demucs_download_list"]
+        return models_url
+
+    def get_local_models(self, arch: str) -> List[str]:
+        model_config = {
+            VR_ARCH_TYPE: (VR_MODELS_DIR, ".pth"),
+            MDX_ARCH_TYPE: (MDX_MODELS_DIR, ".onnx"),
+            DEMUCS_ARCH_TYPE: (DEMUCS_MODELS_DIR, ".yaml"),
+        }
+        try:
+            model_dir, suffix = model_config[arch]
+        except KeyError:
+            raise ValueError(f"Unkown arch type: {arch}")
+        return [os.path.splitext(f)[0] for f in os.listdir(model_dir) if f.endswith(suffix)]
+
+    def set_arch_setting_value(self, arch: str, setting1, setting2):
+        if arch == VR_ARCH_TYPE:
+            root.window_size_var.set(setting1)
+            root.aggression_setting_var.set(setting2)
+        elif arch == MDX_ARCH_TYPE:
+            root.mdx_batch_size_var.set(setting1)
+            root.compensate_var.set(setting2)
+        elif arch == DEMUCS_ARCH_TYPE:
+            pass
+
+    def arch_select_update(self, arch: str) -> List[Dict]:
+        choices = self.get_local_models(arch)
+        if arch == VR_ARCH_TYPE:
+            model_update = self.model_choice.update(choices=choices, value=CHOOSE_MODEL, label=SELECT_VR_MODEL_MAIN_LABEL)
+            setting1_update = self.arch_setting1.update(choices=VR_WINDOW, label=WINDOW_SIZE_MAIN_LABEL, value=root.window_size_var.get())
+            setting2_update = self.arch_setting2.update(choices=VR_AGGRESSION, label=AGGRESSION_SETTING_MAIN_LABEL, value=root.aggression_setting_var.get())
+        elif arch == MDX_ARCH_TYPE:
+            model_update = self.model_choice.update(choices=choices, value=CHOOSE_MODEL, label=CHOOSE_MDX_MODEL_MAIN_LABEL)
+            setting1_update = self.arch_setting1.update(choices=BATCH_SIZE, label=BATCHES_MDX_MAIN_LABEL, value=root.mdx_batch_size_var.get())
+            setting2_update = self.arch_setting2.update(choices=VOL_COMPENSATION, label=VOL_COMP_MDX_MAIN_LABEL, value=root.compensate_var.get())
+        elif arch == DEMUCS_ARCH_TYPE:
+            model_update = self.model_choice.update(choices=choices, value=CHOOSE_MODEL, label=CHOOSE_DEMUCS_MODEL_MAIN_LABEL)
+            raise gr.Error(f"{DEMUCS_ARCH_TYPE} not implempted")
+        else:
+            raise gr.Error(f"Unkown arch type: {arch}")
+        return [model_update, setting1_update, setting2_update]
+
+    def model_select_update(self, arch: str, model_name: str) -> List[Union[str, Dict, None]]:
+        if model_name == CHOOSE_MODEL:
+            return [None for _ in range(4)]
+        model, = self.uvr.assemble_model_data(model_name, arch)
+        if not model.model_status:
+            raise gr.Error(f"Cannot get model data, model hash = {model.model_hash}")
+
+        stem1_check_update = self.primary_stem_only.update(label=f"{model.primary_stem} Only")
+        stem2_check_update = self.secondary_stem_only.update(label=f"{model.secondary_stem} Only")
+        stem1_out_update = self.primary_stem_out.update(label=f"Output {model.primary_stem}")
+        stem2_out_update = self.secondary_stem_out.update(label=f"Output {model.secondary_stem}")
+
+        return [stem1_check_update, stem2_check_update, stem1_out_update, stem2_out_update]
+
+    def checkbox_set_root_value(self, checkbox: gr.Checkbox, root_attr: str):
+        checkbox.change(lambda value: root.__getattribute__(root_attr).set(value), inputs=checkbox)
+
+    def set_checkboxes_exclusive(self, checkboxes: List[gr.Checkbox], pure_callbacks: List[Callable], exclusive_value=True):
+        def exclusive_onchange(i, callback_i):
+            def new_onchange(*check_values):
+                if check_values[i] == exclusive_value:
+                    return_values = []
+                    for j, value_j in enumerate(check_values):
+                        if j != i and value_j == exclusive_value:
+                            return_values.append(not exclusive_value)
+                        else:
+                            return_values.append(value_j)
+                else:
+                    return_values = check_values
+                callback_i(check_values[i])
+                return return_values
+            return new_onchange
+
+        for i, (checkbox, callback) in enumerate(zip(checkboxes, pure_callbacks)):
+            checkbox.change(exclusive_onchange(i, callback), inputs=checkboxes, outputs=checkboxes)
+
+    def process(self, input_audio, input_filename, model_name, arch, setting1, setting2, progress=gr.Progress()):
+        def set_progress_func(step, inference_iterations=0):
+            progress_curr = step + inference_iterations
+            progress(progress_curr)
+
+        sampling_rate, audio = input_audio
+        audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
+        if len(audio.shape) > 1:
+            audio = librosa.to_mono(audio.transpose(1, 0))
+        input_path = os.path.join(self.input_temp_dir, input_filename)
+        soundfile.write(input_path, audio, sampling_rate, format="wav")
+
+        self.set_arch_setting_value(arch, setting1, setting2)
+
+        seperator = uvr.process(
+            model_name=model_name,
+            arch_type=arch,
+            audio_file=input_path,
+            export_path=self.export_path,
+            is_model_sample_mode=root.model_sample_mode_var.get(),
+            set_progress_func=set_progress_func,
+        )
+
+        primary_audio = None
+        secondary_audio = None
+        msg = ""
+        if not seperator.is_secondary_stem_only:
+            primary_stem_path = os.path.join(seperator.export_path, f"{seperator.audio_file_base}_({seperator.primary_stem}).wav")
+            audio, rate = soundfile.read(primary_stem_path)
+            primary_audio = (rate, audio)
+            msg += f"{seperator.primary_stem} saved at {primary_stem_path}\n"
+        if not seperator.is_primary_stem_only:
+            secondary_stem_path = os.path.join(seperator.export_path, f"{seperator.audio_file_base}_({seperator.secondary_stem}).wav")
+            audio, rate = soundfile.read(secondary_stem_path)
+            secondary_audio = (rate, audio)
+            msg += f"{seperator.secondary_stem} saved at {secondary_stem_path}\n"
+
+        os.remove(input_path)
+
+        return primary_audio, secondary_audio, msg
+
+    def define_layout(self):
+        with gr.Blocks() as app:
+            self.app = app
+            gr.HTML("<h1> 🎵 Ultimate Vocal Remover WebUI 🎵 </h1>")
+            gr.Markdown("This is an experimental demo with CPU. Duplicate the space for use in private")
+            gr.Markdown(
+                "[![Duplicate this Space](https://huggingface.co/datasets/huggingface/badges/raw/main/duplicate-this-space-sm-dark.svg)](https://huggingface.co/spaces/r3gm/Ultimate-Vocal-Remover-WebUI?duplicate=true)\n\n"
+            ) 
+            with gr.Tabs():
+                with gr.TabItem("process"):
+                    with gr.Row():
+                        self.arch_choice = gr.Dropdown(
+                            choices=[VR_ARCH_TYPE, MDX_ARCH_TYPE], value=VR_ARCH_TYPE, # choices=[VR_ARCH_TYPE, MDX_ARCH_TYPE, DEMUCS_ARCH_TYPE], value=VR_ARCH_TYPE,
+                            label=CHOOSE_PROC_METHOD_MAIN_LABEL, interactive=True)
+                        self.model_choice = gr.Dropdown(
+                            choices=self.get_local_models(VR_ARCH_TYPE), value=CHOOSE_MODEL,
+                            label=SELECT_VR_MODEL_MAIN_LABEL+' 👋Select a model', interactive=True)
+                    with gr.Row():
+                        self.arch_setting1 = gr.Dropdown(
+                            choices=VR_WINDOW, value=root.window_size_var.get(),
+                            label=WINDOW_SIZE_MAIN_LABEL+' 👋Select one', interactive=True)
+                        self.arch_setting2 = gr.Dropdown(
+                            choices=VR_AGGRESSION, value=root.aggression_setting_var.get(),
+                            label=AGGRESSION_SETTING_MAIN_LABEL, interactive=True)
+                    with gr.Row():
+                        self.use_gpu = gr.Checkbox(
+                            label='Rhythmic Transmutation Device', value=True, interactive=True) #label=GPU_CONVERSION_MAIN_LABEL, value=root.is_gpu_conversion_var.get(), interactive=True)
+                        self.primary_stem_only = gr.Checkbox(
+                            label=f"{PRIMARY_STEM} only", value=root.is_primary_stem_only_var.get(), interactive=True)
+                        self.secondary_stem_only = gr.Checkbox(
+                            label=f"{SECONDARY_STEM} only", value=root.is_secondary_stem_only_var.get(), interactive=True)
+                        self.sample_mode = gr.Checkbox(
+                            label=SAMPLE_MODE_CHECKBOX(root.model_sample_mode_duration_var.get()),
+                            value=root.model_sample_mode_var.get(), interactive=True)
+
+                    with gr.Row():
+                        self.input_filename = gr.Textbox(label="Input filename", value="temp.wav", interactive=True)
+                    with gr.Row():
+                        self.audio_in = gr.Audio(label="Input audio", interactive=True)
+                    with gr.Row():
+                        self.process_submit = gr.Button(START_PROCESSING, variant="primary")
+                    with gr.Row():
+                        self.primary_stem_out = gr.Audio(label=f"Output {PRIMARY_STEM}", interactive=False)
+                        self.secondary_stem_out = gr.Audio(label=f"Output {SECONDARY_STEM}", interactive=False)
+                    with gr.Row():
+                        self.out_message = gr.Textbox(label="Output Message", interactive=False, show_progress=False)
+
+                with gr.TabItem("settings"):
+                    with gr.Tabs():
+                        with gr.TabItem("Settings Guide"):
+                            pass
+                        with gr.TabItem("Additional Settigns"):
+                            self.wav_type = gr.Dropdown(choices=WAV_TYPE, label="Wav Type", value="PCM_16", interactive=True)
+                            self.mp3_rate = gr.Dropdown(choices=MP3_BIT_RATES, label="MP3 Bitrate", value="320k",interactive=True)
+                        with gr.TabItem("Download models"):
+
+                            def md_url(url, text=None):
+                                if text is None:
+                                    text = url
+                                return f"[{url}]({url})"
+
+                            with gr.Row():
+                                vr_models = self.models_url[VR_ARCH_TYPE]
+                                self.vr_download_choice = gr.Dropdown(choices=list(vr_models.keys()), label=f"Select {VR_ARCH_TYPE} Model", interactive=True)
+                                self.vr_download_url = gr.Markdown()
+                                self.vr_download_choice.change(lambda model: md_url(vr_models[model]), inputs=self.vr_download_choice, outputs=self.vr_download_url)
+                            with gr.Row(variant="panel"):
+                                mdx_models = self.models_url[MDX_ARCH_TYPE]
+                                self.mdx_download_choice = gr.Dropdown(choices=list(mdx_models.keys()), label=f"Select {MDX_ARCH_TYPE} Model", interactive=True)
+                                self.mdx_download_url = gr.Markdown()
+                                self.mdx_download_choice.change(lambda model: md_url(mdx_models[model]), inputs=self.mdx_download_choice, outputs=self.mdx_download_url)
+                            with gr.Row(variant="panel"):
+                                demucs_models: Dict[str, Dict] = self.models_url[DEMUCS_ARCH_TYPE]
+                                self.demucs_download_choice = gr.Dropdown(choices=list(demucs_models.keys()), label=f"Select {DEMUCS_ARCH_TYPE} Model", interactive=True)
+                                self.demucs_download_url = gr.Markdown()
+
+                                self.demucs_download_choice.change(
+                                    lambda model: "\n".join([
+                                        "- " + md_url(url, text=filename) for filename, url in demucs_models[model].items()]),
+                                    inputs=self.demucs_download_choice,
+                                    outputs=self.demucs_download_url)
+
+            self.arch_choice.change(
+                self.arch_select_update, inputs=self.arch_choice,
+                outputs=[self.model_choice, self.arch_setting1, self.arch_setting2])
+            self.model_choice.change(
+                self.model_select_update, inputs=[self.arch_choice, self.model_choice],
+                outputs=[self.primary_stem_only, self.secondary_stem_only, self.primary_stem_out, self.secondary_stem_out])
+
+            self.checkbox_set_root_value(self.use_gpu, 'is_gpu_conversion_var')
+            self.checkbox_set_root_value(self.sample_mode, 'model_sample_mode_var')
+            self.set_checkboxes_exclusive(
+                [self.primary_stem_only, self.secondary_stem_only],
+                [lambda value: root.is_primary_stem_only_var.set(value), lambda value: root.is_secondary_stem_only_var.set(value)])
+
+            self.process_submit.click(
+                self.process,
+                inputs=[self.audio_in, self.input_filename, self.model_choice, self.arch_choice, self.arch_setting1, self.arch_setting2],
+                outputs=[self.primary_stem_out, self.secondary_stem_out, self.out_message])
+
+    def launch(self, **kwargs):
+        self.app.queue().launch(**kwargs)
+
+
+uvr = UVRInterface()
+uvr.cached_sources_clear()
+
+webui = UVRWebUI(uvr, online_data_path='models/download_checks.json')
+
+
+print(webui.models_url)
+model_dict = webui.models_url
+
+import os
+import wget
+
+for category, models in model_dict.items():
+    if category in ['VR Arc', 'MDX-Net']:
+        if category == 'VR Arc':
+            model_path = 'models/VR_Models'
+        elif category == 'MDX-Net':
+            model_path = 'models/MDX_Net_Models'
+
+        for model_name, model_url in models.items():
+            cmd = f"aria2c --optimize-concurrent-downloads --console-log-level=error --summary-interval=10 -j5 -x16 -s16 -k1M -c -d {model_path} -Z {model_url}"
+            os.system(cmd)
+
+        print("Models downloaded successfully.")
+    else:
+        print(f"Ignoring category: {category}")
+
+
+
+
+webui = UVRWebUI(uvr, online_data_path='models/download_checks.json')
+webui.launch()