ultimatevocalremovergui/UVR.py

# GUI modules
import os
import glob
from re import T
import pyperclip
import natsort
from gc import freeze
import tkinter as tk
from tkinter import *
from tkinter.tix import *
import webbrowser
from tracemalloc import stop
import lib_v5.sv_ttk
import tkinter.ttk as ttk
import tkinter.messagebox
import tkinter.filedialog
import tkinter.font
from tkinterdnd2 import TkinterDnD, DND_FILES  # Enable Drag & Drop
import pyglet,tkinter
from datetime import datetime
# Images
from PIL import Image
from PIL import ImageTk
import pickle  # Save Data
from pathlib import Path
import hashlib
import wget
import time
import ctypes
import trace
import zipfile
import traceback
import torch
# Pathfinding
import pathlib
import sys
import subprocess
from collections import defaultdict
# Used for live text displaying
import queue
import threading  # Run the algorithm inside a thread
from subprocess import call
from pathlib import Path
import ctypes as ct
import subprocess  # Run python file
import inference_MDX
import inference_v5
import inference_v5_ensemble
import inference_demucs
import lib_v5.filelist
import shutil
import importlib
import urllib.request
import pyAesCrypt
from __version__ import VERSION
from win32api import GetSystemMetrics

try:
    with open(os.path.join(os.getcwd(), 'tmp', 'splash.txt'), 'w') as f:
        f.write('1')
except:
    pass

class KThread(threading.Thread):
  def __init__(self, *args, **keywords):
    threading.Thread.__init__(self, *args, **keywords)
    self.killed = False
  def start(self):
    self.__run_backup = self.run
    self.run = self.__run     
    threading.Thread.start(self)
  def __run(self):
    sys.settrace(self.globaltrace)
    self.__run_backup()
    self.run = self.__run_backup
  def globaltrace(self, frame, why, arg):
    if why == 'call':
      return self.localtrace
    else:
      return None
  def localtrace(self, frame, why, arg):
    if self.killed:
      if why == 'line':
        raise SystemExit()
    return self.localtrace
  def kill(self):
    self.killed = True

# 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

demucs_v3_repo_folder_path = 'models/Demucs_Models'
demucs_v3_repo_folder_path_b = 'models/Demucs_Models/v3_repo'

if not os.path.isdir(demucs_v3_repo_folder_path):
    os.mkdir(demucs_v3_repo_folder_path)
    
if not os.path.isdir(demucs_v3_repo_folder_path_b):
    os.mkdir(demucs_v3_repo_folder_path_b)

try:
    shutil.move("models/Demucs_Models/5d2d6c55-db83574e.th", "models/Demucs_Models/v3_repo/5d2d6c55-db83574e.th")
    shutil.move("models/Demucs_Models/7fd6ef75-a905dd85.th", "models/Demucs_Models/v3_repo/7fd6ef75-a905dd85.th")
    shutil.move("models/Demucs_Models/14fc6a69-a89dd0ee.th", "models/Demucs_Models/v3_repo/14fc6a69-a89dd0ee.th")
    shutil.move("models/Demucs_Models/83fc094f-4a16d450.th", "models/Demucs_Models/v3_repo/83fc094f-4a16d450.th")
    shutil.move("models/Demucs_Models/464b36d7-e5a9386e.th", "models/Demucs_Models/v3_repo/464b36d7-e5a9386e.th")
    shutil.move("models/Demucs_Models/a1d90b5c-ae9d2452.th", "models/Demucs_Models/v3_repo/a1d90b5c-ae9d2452.th")
    shutil.move("models/Demucs_Models/cfa93e08-61801ae1.th", "models/Demucs_Models/v3_repo/cfa93e08-61801ae1.th")
    shutil.move("models/Demucs_Models/e51eebcc-c1b80bdd.th", "models/Demucs_Models/v3_repo/e51eebcc-c1b80bdd.th")
    shutil.move("models/Demucs_Models/ebf34a2d.th", "models/Demucs_Models/v3_repo/ebf34a2d.th")
    shutil.move("models/Demucs_Models/ebf34a2db.th", "models/Demucs_Models/v3_repo/ebf34a2db.th")
    print('Demucs v3 models have been moved to the correct directory.')
except:
    pass

try:
    srcdir = "models/Demucs_Models/v3_repo"
    dstdir = "models/Demucs_Models"

    for basename in os.listdir(srcdir):
        if basename.endswith('.yaml'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                shutil.copy2(pathname, dstdir)
except:
    pass

try:
    srcdir = "models/Demucs_Models"
    dstdir = "models/Demucs_Models/v3_repo"

    for basename in os.listdir(srcdir):
        if basename.endswith('.yaml'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                shutil.copy2(pathname, dstdir)
except:
    pass     

try:
    srcdir = "models/Demucs_Models"

    for basename in os.listdir(srcdir):
        if basename.endswith('.tmp'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                os.remove(pathname)
except:
    pass   

try:
    srcdir = "models/Main_Models"

    for basename in os.listdir(srcdir):
        if basename.endswith('.tmp'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                os.remove(pathname)
except:
    pass  

try:
    srcdir = "models/MDX_Net_Models"

    for basename in os.listdir(srcdir):
        if basename.endswith('.tmp'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                os.remove(pathname)
except:
    pass  

try:
    with open('lib_v5/filelists/ensemble_list/mdx_demuc_en_list.txt', 'w') as f:
        f.write('No Model\nNo Model\n')
except:
    pass

try:
    srcdir = "models/Demucs_Models/v3_repo"

    for basename in os.listdir(srcdir):
        if basename.endswith('.tmp'):
            pathname = os.path.join(srcdir, basename)
            if os.path.isfile(pathname):
                os.remove(pathname)
except:
    pass   

try:
    os.rename("models/Main_Models/MGM_HIGHEND_v4_sr44100_hl1024_nf2048.pth", "models/Main_Models/MGM_HIGHEND_v4.pth")
    os.rename("models/Main_Models/MGM_LOWEND_A_v4_sr32000_hl512_nf2048.pth", "models/Main_Models/MGM_LOWEND_A_v4.pth")
    os.rename("models/Main_Models/MGM_LOWEND_B_v4_sr33075_hl384_nf2048.pth", "models/Main_Models/MGM_LOWEND_B_v4.pth")
    os.rename("models/Main_Models/MGM_MAIN_v4_sr44100_hl512_nf2048.pth", "models/Main_Models/MGM_MAIN_v4.pth")

except:
    pass

try:
    os.rename("models/MDX_Net_Models/UVR_MDXNET_9703.onnx", "models/MDX_Net_Models/UVR_MDXNET_1_9703.onnx")
    os.rename("models/MDX_Net_Models/UVR_MDXNET_9682.onnx", "models/MDX_Net_Models/UVR_MDXNET_2_9682.onnx")
    os.rename("models/MDX_Net_Models/UVR_MDXNET_9662.onnx", "models/MDX_Net_Models/UVR_MDXNET_3_9662.onnx")
except:
    pass

#Images
banner_path = os.path.join(base_path, 'img', 'UVR-banner.png')
credits_path = os.path.join(base_path, 'img', 'credits.png')
demucs_opt_path = os.path.join(base_path, 'img', 'demucs_opt.png')
donate_path = os.path.join(base_path, 'img', 'donate.png')
download_path = os.path.join(base_path, 'img', 'download.png')
efile_path = os.path.join(base_path, 'img', 'file.png')
ense_opt_path = os.path.join(base_path, 'img', 'ense_opt.png')
gen_opt_path = os.path.join(base_path, 'img', 'gen_opt.png')
help_path = os.path.join(base_path, 'img', 'help.png')
instrumentalModels_dir = os.path.join(base_path, 'models')
key_path = os.path.join(base_path, 'img', 'key.png')
mdx_opt_path = os.path.join(base_path, 'img', 'mdx_opt.png')
stop_path = os.path.join(base_path, 'img', 'stop.png')
user_ens_opt_path = os.path.join(base_path, 'img', 'user_ens_opt.png')
vr_opt_path = os.path.join(base_path, 'img', 'vr_opt.png')

try:
    with open('uvr_patch_version.txt', 'r') as file :
        patch_version = file.read()
    os.remove(f'{patch_version}.exe')
except:
    pass

DEFAULT_DATA = {
    'agg': 10,
    'aiModel': 'MDX-Net',
    'algo': 'Instrumentals (Min Spec)',
    'appendensem': False,
    'audfile': True,
    'aud_mdx': True,
    'autocompensate': True,
    'break': False,
    'channel': 64,
    'chunks': 'Auto',
    'chunks_d': 'Auto',
    'compensate': 1.03597672895,
    'demucs_only': False,
    'demucs_stems': 'All Stems',
    'DemucsModel': 'mdx_extra',
    'demucsmodel': False,
    'DemucsModel_MDX': 'UVR_Demucs_Model_1',
    'demucsmodel_sel_VR': 'UVR_Demucs_Model_1',
    'demucsmodelVR': False,
    'dim_f': 2048,
    'ensChoose': 'Multi-AI Ensemble',
    'exportPath': '',
    'flactype': 'PCM_16',
    'gpu': False,
    'inputPaths': [],
    'inst_only': False,
    'inst_only_b': False,
    'lastDir': None,
    'margin': 44100,
    'mdx_ensem': 'MDX-Net: UVR-MDX-NET Main',
    'mdx_ensem_b': 'No Model',
    'mdx_only_ensem_a': 'MDX-Net: UVR-MDX-NET Main',
    'mdx_only_ensem_b': 'MDX-Net: UVR-MDX-NET 1',
    'mdx_only_ensem_c': 'No Model',
    'mdx_only_ensem_d': 'No Model',
    'mdx_only_ensem_e': 'No Model',
    'mdxnetModel': 'UVR-MDX-NET Main',
    'mdxnetModeltype': 'Vocals (Custom)',
    'mixing': 'Default',
    'modeldownload': 'No Model Selected',
    'modeldownload_mdx': 'No Model Selected',
    'modeldownload_demucs': 'No Model Selected',
    'modeldownload_type': 'VR Arc',
    'modelFolder': False,
    'modelInstrumentalLabel': '',
    'ModelParams': 'Auto',
    'mp3bit': '320k',
    'n_fft_scale': 6144,
    'noise_pro_select': 'Auto Select',
    'noise_reduc': True,
    'noisereduc_s': '3',
    'non_red': False,
    'nophaseinst': False,
    'normalize': False,
    'output_image': False,
    'overlap': 0.25,
    'overlap_b': 0.25,
    'postprocess': False,
    'save': True,
    'saveFormat': 'Wav',
    'selectdownload': 'VR Arc',
    'segment': 'None',
    'settest': False,
    'shifts': 2,
    'shifts_b': 2,
    'split_mode': True,
    'tta': False,
    'useModel': 'instrumental',
    'voc_only': False,
    'voc_only_b': False,
    'vr_ensem': '2_HP-UVR',
    'vr_ensem_a': '1_HP-UVR',
    'vr_ensem_b': '2_HP-UVR',
    'vr_ensem_c': 'No Model',
    'vr_ensem_d': 'No Model',
    'vr_ensem_e': 'No Model',
    'vr_ensem_mdx_a': 'No Model',
    'vr_ensem_mdx_b': 'No Model',
    'vr_ensem_mdx_c': 'No Model',
    
    'vr_multi_USER_model_param_1': 'Auto',
    'vr_multi_USER_model_param_2': 'Auto',
    'vr_multi_USER_model_param_3': 'Auto',
    'vr_multi_USER_model_param_4': 'Auto',
    'vr_basic_USER_model_param_1': 'Auto',
    'vr_basic_USER_model_param_2': 'Auto',
    'vr_basic_USER_model_param_3': 'Auto',
    'vr_basic_USER_model_param_4': 'Auto',
    'vr_basic_USER_model_param_5': 'Auto',

    'wavtype': 'PCM_16',
    'window_size': '512',
}

def open_image(path: str, size: tuple = None, keep_aspect: bool = True, rotate: int = 0) -> ImageTk.PhotoImage:
    """
    Open the image on the path and apply given settings\n
    Paramaters:
        path(str):
            Absolute path of the image
        size(tuple):
            first value - width
            second value - height
        keep_aspect(bool):
            keep aspect ratio of image and resize
            to maximum possible width and height
            (maxima are given by size)
        rotate(int):
            clockwise rotation of image
    Returns(ImageTk.PhotoImage):
        Image of path
    """
    img = Image.open(path).convert(mode='RGBA')
    ratio = img.height/img.width
    img = img.rotate(angle=-rotate)
    if size is not None:
        size = (int(size[0]), int(size[1]))
        if keep_aspect:
            img = img.resize((size[0], int(size[0] * ratio)), Image.ANTIALIAS)
        else:
            img = img.resize(size, Image.ANTIALIAS)
    return ImageTk.PhotoImage(img)

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_alt():
    
    save_data(data=DEFAULT_DATA)

    return load_data()
    

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 drop(event, accept_mode: str = 'files'):
    """
    Drag & Drop verification process
    """
    global dnd
    global dnddir
    
    path = event.data

    if accept_mode == 'folder':
        path = path.replace('{', '').replace('}', '')
        if not os.path.isdir(path):
            tk.messagebox.showerror(title='Invalid Folder',
                                    message='Your given export path is not a valid folder!')
            return
        # Set Variables
        root.exportPath_var.set(path)
    elif accept_mode == 'files':
        # Clean path text and set path to the list of paths
        path = path.replace('{', '')
        path = path.split('} ')
        path[-1] = path[-1].replace('}', '')
        # Set Variables
        dnd = 'yes'
        root.inputPaths = path
        root.update_inputPaths()
        dnddir = os.path.dirname(path[0])
    else:
        # Invalid accept mode
        return

class ThreadSafeConsole(tk.Text):
    """
    Text Widget which is thread safe for tkinter
    """
    def __init__(self, master, **options):
        tk.Text.__init__(self, master, **options)
        self.queue = queue.Queue()
        self.update_me()

    def write(self, line):
        self.queue.put(line)

    def clear(self):
        self.queue.put(None)

    def update_me(self):
        self.configure(state=tk.NORMAL)
        try:
            while 1:
                line = self.queue.get_nowait()
                if line is None:
                    self.delete(1.0, tk.END)
                else:
                    self.insert(tk.END, str(line))
                self.see(tk.END)
                self.update_idletasks()
        except queue.Empty:
            pass
        self.configure(state=tk.DISABLED)
        self.after(100, self.update_me)

class MainWindow(TkinterDnD.Tk):
    # --Constants--
    # Layout
    
    if GetSystemMetrics(1) >= 900:
        IMAGE_HEIGHT = 140
        FILEPATHS_HEIGHT = 85
        OPTIONS_HEIGHT = 275
        CONVERSIONBUTTON_HEIGHT = 35
        COMMAND_HEIGHT = 200
        PROGRESS_HEIGHT = 30
        PADDING = 10
    elif GetSystemMetrics(1) <= 720:
        IMAGE_HEIGHT = 135
        FILEPATHS_HEIGHT = 85
        OPTIONS_HEIGHT = 274
        CONVERSIONBUTTON_HEIGHT = 35
        COMMAND_HEIGHT = 80
        PROGRESS_HEIGHT = 6
        PADDING = 5
    else:
        IMAGE_HEIGHT = 135
        FILEPATHS_HEIGHT = 85
        OPTIONS_HEIGHT = 274
        CONVERSIONBUTTON_HEIGHT = 35
        COMMAND_HEIGHT = 115
        PROGRESS_HEIGHT = 6
        PADDING = 7
    
    COL1_ROWS = 11
    COL2_ROWS = 11

    def __init__(self):
        # Run the __init__ method on the tk.Tk class
        super().__init__()
        
        # Calculate window height
        height = self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT
        height += self.CONVERSIONBUTTON_HEIGHT + self.COMMAND_HEIGHT + self.PROGRESS_HEIGHT
        height += self.PADDING * 5  # Padding

        # --Window Settings--
        self.title('Ultimate Vocal Remover')
        # Set Geometry and Center Window
        self.geometry('{width}x{height}+{xpad}+{ypad}'.format(
            width=620,
            height=height,
            xpad=int(self.winfo_screenwidth()/2 - 635/2),
            ypad=int(self.winfo_screenheight()/2 - height/2 - 30)))
        if GetSystemMetrics(1) >= 900:
            pass
        else:
            self.tk.call('tk', 'scaling', 1.1)
        self.configure(bg='#0e0e0f')  # Set background color to #0c0c0d
        self.protocol("WM_DELETE_WINDOW", self.save_values)
        self.resizable(False, False)
        self.update()

        # --Variables--
        self.logo_img = open_image(path=banner_path,
                                   size=(self.winfo_width(), 9999))
        self.efile_img = open_image(path=efile_path,
                                      size=(20, 20))
        self.stop_img = open_image(path=stop_path,
                                      size=(20, 20))
        self.help_img = open_image(path=help_path,
                                      size=(20, 20))
        self.download_img = open_image(path=download_path,
                                size=(30, 30))       
        self.donate_img = open_image(path=donate_path,
                                size=(30, 30))    
        self.key_img = open_image(path=key_path,
                                size=(30, 30))     
        if GetSystemMetrics(1) >= 900:
            self.gen_opt_img = open_image(path=gen_opt_path,
                                        size=(900, 826))
            self.mdx_opt_img = open_image(path=mdx_opt_path,
                                        size=(900, 826))
            self.vr_opt_img = open_image(path=vr_opt_path,
                                        size=(900, 826))
            self.demucs_opt_img = open_image(path=demucs_opt_path,
                                        size=(900, 826))
            self.ense_opt_img = open_image(path=ense_opt_path,
                                        size=(900, 826))
            self.user_ens_opt_img = open_image(path=user_ens_opt_path,
                                        size=(900, 826))
            self.credits_img = open_image(path=credits_path,
                                        size=(100, 100))
        elif GetSystemMetrics(1) <= 720:
            self.gen_opt_img = open_image(path=gen_opt_path,
                                        size=(740, 826))
            self.mdx_opt_img = open_image(path=mdx_opt_path,
                                        size=(740, 826))
            self.vr_opt_img = open_image(path=vr_opt_path,
                                        size=(695, 826))
            self.demucs_opt_img = open_image(path=demucs_opt_path,
                                        size=(695, 826))
            self.ense_opt_img = open_image(path=ense_opt_path,
                                        size=(740, 826))
            self.user_ens_opt_img = open_image(path=user_ens_opt_path,
                                        size=(740, 826))
            self.credits_img = open_image(path=credits_path,
                                        size=(50, 50))
        else:
            self.gen_opt_img = open_image(path=gen_opt_path,
                                        size=(740, 826))
            self.mdx_opt_img = open_image(path=mdx_opt_path,
                                        size=(740, 826))
            self.vr_opt_img = open_image(path=vr_opt_path,
                                        size=(730, 826))
            self.demucs_opt_img = open_image(path=vr_opt_path,
                                        size=(730, 826))
            self.ense_opt_img = open_image(path=demucs_opt_path,
                                        size=(740, 826))
            self.user_ens_opt_img = open_image(path=user_ens_opt_path,
                                        size=(740, 826))
            self.credits_img = open_image(path=credits_path,
                                        size=(50, 50))
        
        self.instrumentalLabel_to_path = defaultdict(lambda: '')
        self.lastInstrumentalModels = []
        self.lastInstrumentalModels_ensem = []
        self.lastmdx_demuc_ensem = []
        self.MDXLabel_to_path = defaultdict(lambda: '')
        self.lastMDXModels = []
        self.ModelParamsLabel_to_path = defaultdict(lambda: '')
        self.lastModelParams = []
        self.DemucsLabel_to_path = defaultdict(lambda: '')
        self.lastDemucsModels = []
        self.ModelParamsLabel_ens_to_path = defaultdict(lambda: '')
        self.lastModelParams_ens = []

        # -Tkinter Value Holders-
        data = load_data()
        data_alt = load_data_alt()

        try:
            self.agg_var = tk.StringVar(value=data['agg'])
        except:
            self.agg_var = tk.StringVar(value=data_alt['agg'])
        try:
            self.aiModel_var = tk.StringVar(value=data['aiModel'])
        except:
            self.aiModel_var = tk.StringVar(value=data_alt['aiModel'])
        try:
            self.algo_var = tk.StringVar(value=data['algo'])
        except:
            self.algo_var = tk.StringVar(value=data_alt['algo'])
        try:
            self.appendensem_var = tk.BooleanVar(value=data['appendensem'])
        except:
            self.appendensem_var = tk.BooleanVar(value=data_alt['appendensem'])
        try:
            self.audfile_var = tk.BooleanVar(value=data['audfile'])
        except:
            self.audfile_var = tk.BooleanVar(value=data_alt['audfile'])
        try:
            self.aud_mdx_var = tk.BooleanVar(value=data['aud_mdx'])
        except:
            self.aud_mdx_var = tk.BooleanVar(value=data_alt['aud_mdx'])
        try:
            self.autocompensate_var = tk.BooleanVar(value=data['autocompensate'])
        except:
            self.autocompensate_var = tk.BooleanVar(value=data_alt['autocompensate'])
        try:
            self.channel_var = tk.StringVar(value=data['channel'])
        except:
            self.channel_var = tk.StringVar(value=data_alt['channel'])
        try:
            self.chunks_d_var = tk.StringVar(value=data['chunks_d'])
        except:
            self.chunks_d_var = tk.StringVar(value=data_alt['chunks_d'])
        try:
            self.chunks_var = tk.StringVar(value=data['chunks'])
        except:
            self.chunks_var = tk.StringVar(value=data_alt['chunks'])
        try:
            self.compensate_var = tk.StringVar(value=data['compensate'])
        except:
            self.compensate_var = tk.StringVar(value=data_alt['compensate'])
        try:
            self.demucs_only_var = tk.BooleanVar(value=data['demucs_only'])
        except:
            self.demucs_only_var = tk.BooleanVar(value=data_alt['demucs_only'])
        try:
            self.demucs_stems_var = tk.StringVar(value=data['demucs_stems'])
        except:
            self.demucs_stems_var = tk.StringVar(value=data_alt['demucs_stems'])
        try:
            self.DemucsModel_MDX_var = tk.StringVar(value=data['DemucsModel_MDX'])
        except:
            self.DemucsModel_MDX_var = tk.StringVar(value=data_alt['DemucsModel_MDX'])
        try:
            self.demucsmodel_sel_VR_var = tk.StringVar(value=data['demucsmodel_sel_VR'])
        except:
            self.demucsmodel_sel_VR_var = tk.StringVar(value=data_alt['demucsmodel_sel_VR'])
        try:
            self.demucsmodel_var = tk.BooleanVar(value=data['demucsmodel'])
        except:
            self.demucsmodel_var = tk.BooleanVar(value=data_alt['demucsmodel'])
        try:
            self.DemucsModel_var = tk.StringVar(value=data['DemucsModel'])
        except:
            self.DemucsModel_var = tk.StringVar(value=data_alt['DemucsModel'])
        try:
            self.demucsmodelVR_var = tk.BooleanVar(value=data['demucsmodelVR'])
        except:
            self.demucsmodelVR_var = tk.BooleanVar(value=data_alt['demucsmodelVR'])
        try:
            self.dim_f_var = tk.StringVar(value=data['dim_f'])    
        except:
            self.dim_f_var = tk.StringVar(value=data_alt['dim_f'])    
        try:
            self.ensChoose_var = tk.StringVar(value=data['ensChoose'])
        except:
            self.ensChoose_var = tk.StringVar(value=data_alt['ensChoose'])
        try:
            self.exportPath_var = tk.StringVar(value=data['exportPath'])
        except:
            self.exportPath_var = tk.StringVar(value=data_alt['exportPath'])
        try:
            self.flactype_var = tk.StringVar(value=data['flactype'])
        except:
            self.flactype_var = tk.StringVar(value=data_alt['flactype'])
        try:
            self.gpuConversion_var = tk.BooleanVar(value=data['gpu'])
        except:
            self.gpuConversion_var = tk.BooleanVar(value=data_alt['gpu'])
        try:
            self.inputPathop_var = tk.StringVar(value=data['inputPaths'])
        except:
            self.inputPathop_var = tk.StringVar(value=data_alt['inputPaths'])
        try:
            self.inputPaths = data['inputPaths']
        except:
            self.inputPaths = data_alt['inputPaths']
        try:
            self.inst_only_b_var = tk.BooleanVar(value=data['inst_only_b'])
        except:
            self.inst_only_b_var = tk.BooleanVar(value=data_alt['inst_only_b'])
        try:
            self.inst_only_var = tk.BooleanVar(value=data['inst_only'])
        except:
            self.inst_only_var = tk.BooleanVar(value=data_alt['inst_only'])
        try:
            self.instrumentalModel_var = tk.StringVar(value=data['modelInstrumentalLabel'])
        except:
            self.instrumentalModel_var = tk.StringVar(value=data_alt['modelInstrumentalLabel'])
        try:
            self.margin_var = tk.StringVar(value=data['margin'])
        except:
            self.margin_var = tk.StringVar(value=data_alt['margin'])
        try:
            self.mdx_only_ensem_a_var = tk.StringVar(value=data['mdx_only_ensem_a'])
        except:
            self.mdx_only_ensem_a_var = tk.StringVar(value=data_alt['mdx_only_ensem_a'])
        try:
            self.mdx_only_ensem_b_var = tk.StringVar(value=data['mdx_only_ensem_b'])
        except:
            self.mdx_only_ensem_b_var = tk.StringVar(value=data_alt['mdx_only_ensem_b'])
        try:
            self.mdx_only_ensem_c_var = tk.StringVar(value=data['mdx_only_ensem_c'])
        except:
            self.mdx_only_ensem_c_var = tk.StringVar(value=data_alt['mdx_only_ensem_c'])
        try:
            self.mdx_only_ensem_d_var = tk.StringVar(value=data['mdx_only_ensem_d'])
        except:
            self.mdx_only_ensem_d_var = tk.StringVar(value=data_alt['mdx_only_ensem_d'])
        try:
            self.mdx_only_ensem_e_var = tk.StringVar(value=data['mdx_only_ensem_e'])
        except:
            self.mdx_only_ensem_e_var = tk.StringVar(value=data_alt['mdx_only_ensem_e'])
        try:
            self.mdxensemchoose_b_var = tk.StringVar(value=data['mdx_ensem_b'])
        except:
            self.mdxensemchoose_b_var = tk.StringVar(value=data_alt['mdx_ensem_b'])
        try:
            self.mdxensemchoose_var = tk.StringVar(value=data['mdx_ensem'])
        except:
            self.mdxensemchoose_var = tk.StringVar(value=data_alt['mdx_ensem'])
        try:
            self.mdxnetModel_var = tk.StringVar(value=data['mdxnetModel'])
        except:
            self.mdxnetModel_var = tk.StringVar(value=data_alt['mdxnetModel'])
        try:
            self.mdxnetModeltype_var = tk.StringVar(value=data['mdxnetModeltype'])
        except:
            self.mdxnetModeltype_var = tk.StringVar(value=data_alt['mdxnetModeltype'])
        try:
            self.mixing_var = tk.StringVar(value=data['mixing'])
        except:
            self.mixing_var = tk.StringVar(value=data_alt['mixing'])
        try:
            self.modeldownload_type_var = tk.StringVar(value=data['modeldownload_type'])
        except:
            self.modeldownload_type_var = tk.StringVar(value=data_alt['modeldownload_type'])
        try:
            self.modeldownload_var = tk.StringVar(value=data['modeldownload'])
        except:
            self.modeldownload_var = tk.StringVar(value=data_alt['modeldownload'])
        try:
            self.modeldownload_mdx_var = tk.StringVar(value=data['modeldownload_mdx'])
        except:
            self.modeldownload_mdx_var = tk.StringVar(value=data_alt['modeldownload_mdx'])
        try:
            self.modeldownload_demucs_var = tk.StringVar(value=data['modeldownload_demucs'])
        except:
            self.modeldownload_demucs_var = tk.StringVar(value=data_alt['modeldownload_demucs'])
        try:
            self.modelFolder_var = tk.BooleanVar(value=data['modelFolder'])
        except:
            self.modelFolder_var = tk.BooleanVar(value=data_alt['modelFolder'])
        try:
            self.ModelParams_var = tk.StringVar(value=data['ModelParams'])
        except:
            self.ModelParams_var = tk.StringVar(value=data_alt['ModelParams'])
        try:
            self.mp3bit_var = tk.StringVar(value=data['mp3bit'])
        except:
            self.mp3bit_var = tk.StringVar(value=data_alt['mp3bit'])
        try:
            self.n_fft_scale_var = tk.StringVar(value=data['n_fft_scale'])
        except:
            self.n_fft_scale_var = tk.StringVar(value=data_alt['n_fft_scale'])
        try:
            self.noise_pro_select_var = tk.StringVar(value=data['noise_pro_select'])
        except:
            self.noise_pro_select_var = tk.StringVar(value=data_alt['noise_pro_select'])
        try:
            self.noisereduc_s_var = tk.StringVar(value=data['noisereduc_s'])
        except:
            self.noisereduc_s_var = tk.StringVar(value=data_alt['noisereduc_s'])
        try:
            self.noisereduc_var = tk.BooleanVar(value=data['noise_reduc'])
        except:
            self.noisereduc_var = tk.BooleanVar(value=data_alt['noise_reduc'])
        try:
            self.non_red_var = tk.BooleanVar(value=data['non_red'])
        except:
            self.non_red_var = tk.BooleanVar(value=data_alt['non_red'])
        try:
            self.nophaseinst_var = tk.BooleanVar(value=data['nophaseinst'])
        except:
            self.nophaseinst_var = tk.BooleanVar(value=data_alt['nophaseinst'])
        try:
            self.normalize_var = tk.BooleanVar(value=data['normalize'])
        except:
            self.normalize_var = tk.BooleanVar(value=data_alt['normalize'])
        try:
            self.outputImage_var = tk.BooleanVar(value=data['output_image'])
        except:
            self.outputImage_var = tk.BooleanVar(value=data_alt['output_image'])
        try:
            self.overlap_b_var = tk.StringVar(value=data['overlap_b'])
        except:
            self.overlap_b_var = tk.StringVar(value=data_alt['overlap_b'])
        try:
            self.overlap_var = tk.StringVar(value=data['overlap'])
        except:
            self.overlap_var = tk.StringVar(value=data_alt['overlap'])
        try:
            self.postprocessing_var = tk.BooleanVar(value=data['postprocess'])
        except:
            self.postprocessing_var = tk.BooleanVar(value=data_alt['postprocess'])
        try:
            self.save_var = tk.BooleanVar(value=data['save'])
        except:
            self.save_var = tk.BooleanVar(value=data_alt['save'])
        try:
            self.saveFormat_var = tk.StringVar(value=data['saveFormat'])
        except:
            self.saveFormat_var = tk.StringVar(value=data_alt['saveFormat'])
        try:
            self.selectdownload_var = tk.StringVar(value=data['selectdownload'])
        except:
            self.selectdownload_var = tk.StringVar(value=data_alt['selectdownload'])
        try:
            self.segment_var = tk.StringVar(value=data['segment'])
        except:
            self.segment_var = tk.StringVar(value=data_alt['segment'])
        try:
            self.settest_var = tk.BooleanVar(value=data['settest'])
        except:
            self.settest_var = tk.BooleanVar(value=data_alt['settest'])
        try:
            self.shifts_b_var = tk.StringVar(value=data['shifts_b'])
        except:
            self.shifts_b_var = tk.StringVar(value=data_alt['shifts_b'])
        try:
            self.shifts_var = tk.StringVar(value=data['shifts'])
        except:
            self.shifts_var = tk.StringVar(value=data_alt['shifts'])
        try:
            self.split_mode_var = tk.BooleanVar(value=data['split_mode'])
        except:
            self.split_mode_var = tk.BooleanVar(value=data_alt['split_mode'])
        try:
            self.tta_var = tk.BooleanVar(value=data['tta'])
        except:
            self.tta_var = tk.BooleanVar(value=data_alt['tta'])
        try:
            self.voc_only_b_var = tk.BooleanVar(value=data['voc_only_b'])
        except:
            self.voc_only_b_var = tk.BooleanVar(value=data_alt['voc_only_b'])
        try:
            self.voc_only_var = tk.BooleanVar(value=data['voc_only'])
        except:
            self.voc_only_var = tk.BooleanVar(value=data_alt['voc_only'])
        try:
            self.vrensemchoose_a_var = tk.StringVar(value=data['vr_ensem_a'])
        except:
            self.vrensemchoose_a_var = tk.StringVar(value=data_alt['vr_ensem_a'])
        try:
            self.vrensemchoose_b_var = tk.StringVar(value=data['vr_ensem_b'])
        except:
            self.vrensemchoose_b_var = tk.StringVar(value=data_alt['vr_ensem_b'])
        try:
            self.vrensemchoose_c_var = tk.StringVar(value=data['vr_ensem_c'])
        except:
            self.vrensemchoose_c_var = tk.StringVar(value=data_alt['vr_ensem_c'])
        try:
            self.vrensemchoose_d_var = tk.StringVar(value=data['vr_ensem_d'])
        except:
            self.vrensemchoose_d_var = tk.StringVar(value=data_alt['vr_ensem_d'])
        try:
            self.vrensemchoose_e_var = tk.StringVar(value=data['vr_ensem_e'])
        except:
            self.vrensemchoose_e_var = tk.StringVar(value=data_alt['vr_ensem_e'])
        try:
            self.vr_multi_USER_model_param_1 = tk.StringVar(value=data['vr_multi_USER_model_param_1'])
        except:
            self.vr_multi_USER_model_param_1 = tk.StringVar(value=data_alt['vr_multi_USER_model_param_1'])
        try:
            self.vr_multi_USER_model_param_2 = tk.StringVar(value=data['vr_multi_USER_model_param_2'])
        except:
            self.vr_multi_USER_model_param_2 = tk.StringVar(value=data_alt['vr_multi_USER_model_param_2'])
        try:
            self.vr_multi_USER_model_param_3 = tk.StringVar(value=data['vr_multi_USER_model_param_3'])
        except:
            self.vr_multi_USER_model_param_3 = tk.StringVar(value=data_alt['vr_multi_USER_model_param_3'])
        try:
            self.vr_multi_USER_model_param_4 = tk.StringVar(value=data['vr_multi_USER_model_param_4'])
        except:
            self.vr_multi_USER_model_param_4 = tk.StringVar(value=data_alt['vr_multi_USER_model_param_4'])
        try:
            self.vr_basic_USER_model_param_1 = tk.StringVar(value=data['vr_basic_USER_model_param_1'])
        except:
            self.vr_basic_USER_model_param_1 = tk.StringVar(value=data_alt['vr_basic_USER_model_param_1'])
        try:
            self.vr_basic_USER_model_param_2 = tk.StringVar(value=data['vr_basic_USER_model_param_2'])
        except:
            self.vr_basic_USER_model_param_2 = tk.StringVar(value=data_alt['vr_basic_USER_model_param_2'])
        try:
            self.vr_basic_USER_model_param_3 = tk.StringVar(value=data['vr_basic_USER_model_param_3'])
        except:
            self.vr_basic_USER_model_param_3 = tk.StringVar(value=data_alt['vr_basic_USER_model_param_3'])
        try:
            self.vr_basic_USER_model_param_4 = tk.StringVar(value=data['vr_basic_USER_model_param_4'])
        except:
            self.vr_basic_USER_model_param_4 = tk.StringVar(value=data_alt['vr_basic_USER_model_param_4'])
        try:
            self.vr_basic_USER_model_param_5 = tk.StringVar(value=data['vr_basic_USER_model_param_5'])
        except:
            self.vr_basic_USER_model_param_5 = tk.StringVar(value=data_alt['vr_basic_USER_model_param_5'])
        try:
            self.vrensemchoose_mdx_a_var = tk.StringVar(value=data['vr_ensem_mdx_a'])
        except:
            self.vrensemchoose_mdx_a_var = tk.StringVar(value=data_alt['vr_ensem_mdx_a'])
        try:
            self.vrensemchoose_mdx_b_var = tk.StringVar(value=data['vr_ensem_mdx_b'])
        except:
            self.vrensemchoose_mdx_b_var = tk.StringVar(value=data_alt['vr_ensem_mdx_b'])
        try:
            self.vrensemchoose_mdx_c_var = tk.StringVar(value=data['vr_ensem_mdx_c'])
        except:
            self.vrensemchoose_mdx_c_var = tk.StringVar(value=data_alt['vr_ensem_mdx_c'])
        try:
            self.vrensemchoose_var = tk.StringVar(value=data['vr_ensem'])
        except:
            self.vrensemchoose_var = tk.StringVar(value=data_alt['vr_ensem'])
        try:
            self.wavtype_var = tk.StringVar(value=data['wavtype'])
        except:
            self.wavtype_var = tk.StringVar(value=data_alt['wavtype'])
        try:
            self.winSize_var = tk.StringVar(value=data['window_size'])
        except:
            self.winSize_var = tk.StringVar(value=data_alt['window_size'])
        try:
            self.lastDir = data['lastDir']
        except:
            self.lastDir = data_alt['lastDir']

        self.last_aiModel = self.aiModel_var.get()
        self.last_algo = self.aiModel_var.get()
        self.last_ensChoose = self.ensChoose_var.get()
        self.download_progress_var = tk.StringVar(value='')
        self.download_progress_bar_var = tk.StringVar(value='')
        self.download_progress_bar_zip_var = tk.IntVar(value=0)
        self.download_stop_var = tk.StringVar(value='') 
        self.progress_var = tk.IntVar(value=0)
        
        self.last_mdxnetModel = self.mdxnetModel_var.get()
        self.inputPathsEntry_var = tk.StringVar(value='')
        
        # Font
        pyglet.font.add_file('lib_v5/fonts/centurygothic/GOTHIC.TTF')
        self.font = tk.font.Font(family='Century Gothic', size=10)
        self.fontRadio = tk.font.Font(family='Century Gothic', size=8) 
        # --Widgets--
        self.create_widgets()
        self.bind_widgets()
        self.place_widgets()
        
        self.update_available_models()
        self.update_states()
        self.update_loop()
   
        global space_fill_wide
        global space_medium_l
        global space_medium
        global space_small
        global space_tiny
        global download_code_file
        global user_code_file
        global download_code_temp_dir

        download_code_file = 'lib_v5/filelists/download_codes/user_code_download.txt'
        user_code_file = 'lib_v5/filelists/download_codes/user_code.txt'
        download_code_temp_dir = 'lib_v5/filelists/download_codes/temp'

        space_fill_wide = '  '*32
        space_medium_l = '  '*20
        space_medium = '  '*17
        space_small = '  '*10
        space_tiny = '  '*5
   
    # -Widget Methods-
    
    def create_widgets(self):
        """Create window widgets"""
        self.title_Label = tk.Label(master=self,
                                    image=self.logo_img, compound=tk.TOP)
        self.filePaths_Frame = ttk.Frame(master=self)
        self.fill_filePaths_Frame()

        self.options_Frame = ttk.Frame(master=self)
        self.fill_options_Frame()

        self.conversion_Button = ttk.Button(master=self,
                                            text='Start Processing',
                                            command=self.start_conversion)
        self.stop_Button = ttk.Button(master=self,
                                         image=self.stop_img,
                                         command=self.stop_inf)
        self.settings_Button = ttk.Button(master=self,
                                         image=self.help_img,
                                         command=self.settings)

        #ttk.Button(win, text= "Open", command= open_popup).pack()
        
        self.efile_e_Button = ttk.Button(master=self,
                                         image=self.efile_img,
                                         command=self.open_exportPath_filedialog)
        
        self.efile_i_Button = ttk.Button(master=self,
                                         image=self.efile_img,
                                         command=self.open_inputPath_filedialog)
        
        self.progressbar = ttk.Progressbar(master=self, variable=self.progress_var)

        self.command_Text = ThreadSafeConsole(master=self,
                                              background='#0e0e0f',fg='#898b8e', font=('Century Gothic', 11),borderwidth=0)

        #self.command_Text.write(f'Ultimate Vocal Remover [{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}]\n')
        
        global current_version

        with open('uvr_patch_version.txt', 'r') as file :
            current_version = file.read()

        def start_target_update():
            
            def target_update():
                update_signal_url = "https://raw.githubusercontent.com/TRvlvr/application_data/main/update_patches.txt"
                url = update_signal_url
                label_set = " "
                try:
                    file = urllib.request.urlopen(url)
                    for line in file:
                        patch_name = line.decode("utf-8")
                        if patch_name == current_version:
                            self.command_Text.write(f'Ultimate Vocal Remover v5.4.0 [{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}]')
                        else:
                            label_set = f"New Update Found: {patch_name}\n\nClick the update button in the \"Settings\" menu to download and install!"
                
                            self.command_Text.write(f'Ultimate Vocal Remover v5.4.0 [{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}]\n\n{label_set}')
                except:
                        self.command_Text.write(f'Ultimate Vocal Remover v5.4.0 [{datetime.now().strftime("%Y-%m-%d %H:%M:%S")}]')
                        
            rlg = KThread(target=target_update)
            rlg.start()

        start_target_update()


    def bind_widgets(self):
        """Bind widgets to the drag & drop mechanic"""
        self.filePaths_musicFile_Button.drop_target_register(DND_FILES)
        self.filePaths_musicFile_Entry.drop_target_register(DND_FILES)
        self.filePaths_saveTo_Button.drop_target_register(DND_FILES)
        self.filePaths_saveTo_Entry.drop_target_register(DND_FILES)        
        self.filePaths_musicFile_Button.dnd_bind('<<Drop>>',
                                                lambda e: drop(e, accept_mode='files'))
        self.filePaths_musicFile_Entry.dnd_bind('<<Drop>>',
                                                lambda e: drop(e, accept_mode='files'))
        self.filePaths_saveTo_Button.dnd_bind('<<Drop>>',
                                                lambda e: drop(e, accept_mode='folder'))
        self.filePaths_saveTo_Entry.dnd_bind('<<Drop>>',
                                                lambda e: drop(e, accept_mode='folder'))

    def place_widgets(self):
        """Place main widgets"""
        self.title_Label.place(x=-2, y=-2)
        self.filePaths_Frame.place(x=10, y=155, width=-20, height=self.FILEPATHS_HEIGHT,
                                   relx=0, rely=0, relwidth=1, relheight=0)
        self.options_Frame.place(x=10, y=250, width=-50, height=self.OPTIONS_HEIGHT,
                                 relx=0, rely=0, relwidth=1, relheight=0)
        self.conversion_Button.place(x=50, y=self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT + self.PADDING*2, width=-60 - 40, height=self.CONVERSIONBUTTON_HEIGHT,
                                     relx=0, rely=0, relwidth=1, relheight=0)
        self.efile_e_Button.place(x=-45, y=200, width=35, height=30,
                                  relx=1, rely=0, relwidth=0, relheight=0)
        self.efile_i_Button.place(x=-45, y=160, width=35, height=30,
                                  relx=1, rely=0, relwidth=0, relheight=0)
        
        self.stop_Button.place(x=-10 - 35, y=self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT + self.PADDING*2, width=35, height=self.CONVERSIONBUTTON_HEIGHT,
                                  relx=1, rely=0, relwidth=0, relheight=0)
        self.settings_Button.place(x=-10 - 600, y=self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT + self.PADDING*2, width=35, height=self.CONVERSIONBUTTON_HEIGHT,
                                  relx=1, rely=0, relwidth=0, relheight=0)
        self.command_Text.place(x=25, y=self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT + self.CONVERSIONBUTTON_HEIGHT + self.PADDING*3, width=-30, height=self.COMMAND_HEIGHT,
                                relx=0, rely=0, relwidth=1, relheight=0)
        self.progressbar.place(x=25, y=self.IMAGE_HEIGHT + self.FILEPATHS_HEIGHT + self.OPTIONS_HEIGHT + self.CONVERSIONBUTTON_HEIGHT + self.COMMAND_HEIGHT + self.PADDING*4, width=-50, height=self.PROGRESS_HEIGHT,
                               relx=0, rely=0, relwidth=1, relheight=0)

    def fill_filePaths_Frame(self):
        """Fill Frame with neccessary widgets"""
        # -Create Widgets-
        # Save To Option
         # Select Music Files Option

        # Save To Option
        self.filePaths_saveTo_Button = ttk.Button(master=self.filePaths_Frame,
                                                  text='Select output',
                                                  command=self.open_export_filedialog)
        self.filePaths_saveTo_Entry = ttk.Entry(master=self.filePaths_Frame,

                                                textvariable=self.exportPath_var,
                                                state=tk.DISABLED
                                                )
        # Select Music Files Option
        self.filePaths_musicFile_Button = ttk.Button(master=self.filePaths_Frame,
                                                     text='Select input',
                                                     command=self.open_file_filedialog)
        self.filePaths_musicFile_Entry = ttk.Entry(master=self.filePaths_Frame,
                                                   textvariable=self.inputPathsEntry_var,
                                                   state=tk.DISABLED
                                                   )
       
       
        # -Place Widgets-
        
        # Select Music Files Option
        self.filePaths_musicFile_Button.place(x=0, y=5, width=0, height=-10,
                                              relx=0, rely=0, relwidth=0.3, relheight=0.5)                                              
        self.filePaths_musicFile_Entry.place(x=10, y=2.5, width=-50, height=-5,
                                              relx=0.3, rely=0, relwidth=0.7, relheight=0.5)                                             

        # Save To Option
        self.filePaths_saveTo_Button.place(x=0, y=5, width=0, height=-10,
                                           relx=0, rely=0.5, relwidth=0.3, relheight=0.5)
        self.filePaths_saveTo_Entry.place(x=10, y=2.5, width=-50, height=-5,
                                          relx=0.3, rely=0.5, relwidth=0.7, relheight=0.5)


    def fill_options_Frame(self):
        """Fill Frame with neccessary widgets"""
        # -Create Widgets-
      

        # Save as wav
        self.options_wav_Radiobutton = ttk.Radiobutton(master=self.options_Frame,                                                
                                                text='WAV',
                                                variable=self.saveFormat_var,
                                                value='Wav'
                                                )
        
        # Save as flac 
        self.options_flac_Radiobutton = ttk.Radiobutton(master=self.options_Frame,                                                
                                                text='FLAC',                                                
                                                variable=self.saveFormat_var, 
                                                value='Flac'
                                                )
        
        # Save as mp3 
        self.options_mpThree_Radiobutton = ttk.Radiobutton(master=self.options_Frame,                                                
                                                text='MP3',                                                                                              
                                                variable=self.saveFormat_var, 
                                                value='Mp3', 
                                                )
        
        # -Column 1-
        
        # Choose Conversion Method
        self.options_aiModel_Label = tk.Button(master=self.options_Frame,
                                               text='Choose Process Method', anchor=tk.CENTER,
                                               background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.open_appdir_filedialog)
        self.options_aiModel_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                          self.aiModel_var, 
                                                          None, 'VR Architecture', 'MDX-Net', 'Demucs v3', 'Ensemble Mode')
        
        #  Choose Instrumental Model
        self.options_instrumentalModel_Label = tk.Button(master=self.options_Frame,
                                                        text='Choose Main Model',
                                                        background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.open_Modelfolder_vr)
        self.options_instrumentalModel_Optionmenu = ttk.OptionMenu(self.options_Frame,
                                                                   self.instrumentalModel_var)
        
        #  Choose Demucs Model
        self.options_DemucsModel_Label = tk.Button(master=self.options_Frame,
                                                        text='Choose Demucs Model',
                                                        background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.open_Modelfolder_de)
        self.options_DemucsModel_Optionmenu = ttk.OptionMenu(self.options_Frame,
                                                                   self.DemucsModel_var)
        
        #  Choose MDX-Net Model
        self.options_mdxnetModel_Label = tk.Button(master=self.options_Frame,
                                                        text='Choose MDX-Net Model', anchor=tk.CENTER,
                                                        background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.open_newModel_filedialog)
        
        self.options_mdxnetModel_Optionmenu = ttk.OptionMenu(self.options_Frame,
                                                             self.mdxnetModel_var)
        
        # Ensemble Mode
        self.options_ensChoose_Label = tk.Button(master=self.options_Frame,
                                               text='Choose Ensemble', anchor=tk.CENTER,
                                               background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.custom_ensemble)
        self.options_ensChoose_Optionmenu = ttk.OptionMenu(self.options_Frame,
                                                          self.ensChoose_var,
                                                          None, 'Multi-AI Ensemble', 'Basic VR Ensemble', 'Basic MD Ensemble', 'Manual Ensemble')
        
        # Choose Agorithim
        self.options_algo_Label = tk.Label(master=self.options_Frame,
                                               text='Choose Algorithm', anchor=tk.CENTER,
                                               background='#0e0e0f', font=self.font, foreground='#13a4c9')
        self.options_algo_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                          self.algo_var, 
                                                          None, 'Vocals (Max Spec)', 'Instrumentals (Min Spec)')#, 'Invert (Normal)', 'Invert (Spectral)')
        
        # Choose Demucs Stems
        self.options_demucs_stems_Label = tk.Button(master=self.options_Frame,
                                               text='Choose Stem(s)', anchor=tk.CENTER,
                                               background='#0e0e0f', font=self.font, foreground='#13a4c9', borderwidth=0, command=self.advanced_demucs_options)
        self.options_demucs_stems_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                          self.demucs_stems_var, 
                                                          None, 'All Stems', 'Vocals', 'Other', 'Bass', 'Drums')

        
        # -Column 2-
        
        # WINDOW SIZE
        self.options_winSize_Label = tk.Button(master=self.options_Frame,
                                              text='Window Size', anchor=tk.CENTER,
                                              background='#0e0e0f', font=self.font, foreground='#13a4c9', 
                                              borderwidth=0, command=self.advanced_vr_options)
        self.options_winSize_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.winSize_var,
                                                         None, '320', '512','1024')
        # MDX-chunks
        self.options_chunks_Label = tk.Label(master=self.options_Frame,
                                           text='Chunks',
                                           background='#0e0e0f', font=self.font, foreground='#13a4c9')
        self.options_chunks_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.chunks_var,
                                                         None, 'Auto', '1', '5', '10', '15', '20', 
                                                         '25', '30', '35', '40', '45', '50', 
                                                         '55', '60', '65', '70', '75', '80', 
                                                         '85', '90', '95', 'Full')
        
        # Demucs-Segment
        self.options_segment_Label = tk.Label(master=self.options_Frame,
                                           text='Segment',
                                           background='#0e0e0f', font=self.font, foreground='#13a4c9')
        self.options_segment_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.segment_var,
                                                         None, 'None', '1', '5', '10', '15', '20', 
                                                         '25', '30', '35', '40', '45', '50', 
                                                         '55', '60', '65', '70', '75', '80', 
                                                         '85', '90', '95', '100')
        
        
        # Overlap
        self.options_overlap_b_Label = tk.Label(master=self.options_Frame,
                                              text='Overlap', anchor=tk.CENTER,
                                              background='#0e0e0f', font=self.font, foreground='#13a4c9')
        self.options_overlap_b_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.overlap_b_var,
                                                         0, 0.25, 0.50, 0.75, 0.99)
        
        # Shifts
        self.options_shifts_b_Label = tk.Label(master=self.options_Frame,
                                              text='Shifts', anchor=tk.CENTER,
                                              background='#0e0e0f', font=self.font, foreground='#13a4c9')
        self.options_shifts_b_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.shifts_b_var,
                                                         0, 0, 1, 2, 3, 4, 5, 
                                                         6, 7, 8, 9, 10, 11, 
                                                         12, 13, 14, 15, 16, 17, 
                                                         18, 19, 20)

        #Checkboxes
        # GPU Selection
        self.options_gpu_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                       text='GPU Conversion',
                                                       variable=self.gpuConversion_var,
                                                       )
        
        # Vocal Only
        self.options_voc_only_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Save Vocals Only',
                                                variable=self.voc_only_var,
                                                )
        # Instrumental Only 
        self.options_inst_only_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Save Instrumental Only',
                                                variable=self.inst_only_var,
                                                )
        
        # Vocal Only
        self.options_voc_only_b_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Stem Only',
                                                variable=self.voc_only_b_var,
                                                )
        # Instrumental Only 
        self.options_inst_only_b_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Mix Without Stem Only',
                                                variable=self.inst_only_b_var,
                                                )
        
        # TTA
        self.options_tta_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                       text='TTA',
                                                       variable=self.tta_var,
                                                       )

        # MDX-Auto-Chunk
        self.options_non_red_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Save Noisey Output',
                                                variable=self.non_red_var,
                                                )

        # Demucs Model VR
        self.options_postpro_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                        text='Post-Process',
                                                        variable=self.postprocessing_var,
                                                        )
        
        # Split Mode
        self.options_split_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                        text='Split Mode',
                                                        variable=self.split_mode_var,
                                                        )

        # -Column 3-

        # AGG
        self.options_agg_Label = tk.Button(master=self.options_Frame,
                                           text='Aggression Setting',
                                           background='#0e0e0f', font=self.font, foreground='#13a4c9', 
                                           borderwidth=0, command=self.advanced_vr_options)
        self.options_agg_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.agg_var,
                                                         None, '1', '2', '3', '4', '5', 
                                                         '6', '7', '8', '9', '10', '11', 
                                                         '12', '13', '14', '15', '16', '17', 
                                                         '18', '19', '20')

        # MDX-noisereduc_s
        self.options_noisereduc_s_Label = tk.Button(master=self.options_Frame,
                                           text='Noise Reduction',
                                           background='#0e0e0f', font=self.font, foreground='#13a4c9', 
                                           borderwidth=0, command=self.advanced_mdx_options)
        self.options_noisereduc_s_Optionmenu = ttk.OptionMenu(self.options_Frame, 
                                                         self.noisereduc_s_var,
                                                         None, 'None', '0', '1', '2', '3', '4', '5', 
                                                         '6', '7', '8', '9', '10')
        

        # Save Image
        self.options_image_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                         text='Output Image',
                                                         variable=self.outputImage_var,
                                                         )

        # MDX-Enable Demucs Model
        self.options_demucsmodel_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                               text='Demucs Model',
                                                               variable=self.demucsmodel_var,
                                                               )

        # MDX-Noise Reduction
        self.options_noisereduc_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                text='Noise Reduction',
                                                variable=self.noisereduc_var,
                                                )
        
        # Ensemble Save Ensemble Outputs
        self.options_save_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                       text='Save All Outputs',
                                                       variable=self.save_var,
                                                       )
        
        # Model Test Mode
        self.options_modelFolder_Checkbutton = ttk.Checkbutton(master=self.options_Frame,
                                                               text='Model Test Mode',
                                                               variable=self.modelFolder_var,
                                                               )

        # -Place Widgets-

        # -Column 0-

        # Save as
        self.options_wav_Radiobutton.place(x=400, y=-5, width=0, height=6,
                                             relx=0, rely=0/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_flac_Radiobutton.place(x=271, y=-5, width=0, height=6,
                                             relx=1/3, rely=0/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_mpThree_Radiobutton.place(x=143, y=-5, width=0, height=6,
                                             relx=2/3, rely=0/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

        # -Column 1-
        
        # Choose Conversion Method
        self.options_aiModel_Label.place(x=0, y=0, width=0, height=-10,
                                    relx=0, rely=2/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_aiModel_Optionmenu.place(x=0, y=-2, width=0, height=7,
                                    relx=0, rely=3/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        # Choose Main Model
        self.options_instrumentalModel_Label.place(x=0, y=19, width=0, height=-10,
                                    relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_instrumentalModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                    relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        
        # Choose Demucs Model
        self.options_DemucsModel_Label.place(x=0, y=19, width=0, height=-10,
                                    relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_DemucsModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                    relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        
        # Choose MDX-Net Model
        self.options_mdxnetModel_Label.place(x=0, y=19, width=0, height=-10,
                                    relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_mdxnetModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                    relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        # Choose Ensemble 
        self.options_ensChoose_Label.place(x=0, y=19, width=0, height=-10,
                                relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_ensChoose_Optionmenu.place(x=0, y=19, width=0, height=7,
                                relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        
        # Choose Algorithm
        self.options_algo_Label.place(x=20, y=0, width=0, height=-10,
                                relx=1/3, rely=2/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        self.options_algo_Optionmenu.place(x=12, y=-2, width=0, height=7,
                                relx=1/3, rely=3/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
        
        # Choose Demucs Stems
        self.options_demucs_stems_Label.place(x=13, y=0, width=0, height=-10,
                                    relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_demucs_stems_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

        # -Column 2-
    
        # WINDOW
        self.options_winSize_Label.place(x=13, y=0, width=0, height=-10,
                                    relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_winSize_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #---MDX-Net Specific---
        # MDX-chunks
        self.options_chunks_Label.place(x=12, y=0, width=0, height=-10,
                                    relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_chunks_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        # Demucs-Segment
        self.options_segment_Label.place(x=12, y=0, width=0, height=-10,
                                    relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_segment_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        # Overlap
        self.options_overlap_b_Label.place(x=13, y=0, width=0, height=-10,
                                    relx=2/3, rely=4/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_overlap_b_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

        # Shifts
        self.options_shifts_b_Label.place(x=12, y=0, width=0, height=-10,
                                    relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_shifts_b_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        
        #Checkboxes
        
        #GPU Conversion
        self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Vocals Only
        self.options_voc_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Instrumental Only
        self.options_inst_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        #Vocals Only
        self.options_voc_only_b_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Instrumental Only
        self.options_inst_only_b_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Split Mode
        self.options_split_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        # TTA
        self.options_tta_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        # MDX-Keep Non_Reduced Vocal
        self.options_non_red_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

        # -Column 3-
        
        # AGG
        self.options_agg_Label.place(x=15, y=0, width=0, height=-10,
                                    relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_agg_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        # MDX-noisereduc_s
        self.options_noisereduc_s_Label.place(x=15, y=0, width=0, height=-10,
                                    relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        self.options_noisereduc_s_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                    relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Checkboxes
        #---MDX-Net Specific---
        # MDX-demucs Model
        self.options_demucsmodel_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

        #---VR Architecture Specific---
        #Post-Process
        self.options_postpro_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #Save Image
        # self.options_image_Checkbutton.place(x=35, y=21, width=0, height=5,
        #                                     relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #---Ensemble Specific---
        #Ensemble Save Outputs
        self.options_save_Checkbutton.place(x=35, y=21, width=0, height=5,
                                    relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        #---MDX-Net & VR Architecture Specific---
        #Model Test Mode
        self.options_modelFolder_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
        
        # Change States
        self.aiModel_var.trace_add('write',
                                    lambda *args: self.deselect_models())
        self.ensChoose_var.trace_add('write',
                            lambda *args: self.update_states())
        
        self.inst_only_var.trace_add('write',
                    lambda *args: self.update_states())

        self.voc_only_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.inst_only_b_var.trace_add('write',
                    lambda *args: self.update_states())

        self.voc_only_b_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.demucs_stems_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.noisereduc_s_var.trace_add('write',
                    lambda *args: self.update_states())
        self.non_red_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.mdxnetModeltype_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.n_fft_scale_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.dim_f_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.demucsmodel_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.demucs_only_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.split_mode_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.chunks_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.autocompensate_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.compensate_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.selectdownload_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.modeldownload_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.modeldownload_mdx_var.trace_add('write',
                    lambda *args: self.update_states())
        
        self.modeldownload_demucs_var.trace_add('write',
                    lambda *args: self.update_states())
        
    # Opening filedialogs
    def open_file_filedialog(self):
        """Make user select music files"""
        global dnd
        global nondnd
        
        if self.lastDir is not None:
            if not os.path.isdir(self.lastDir):
                self.lastDir = None

        paths = tk.filedialog.askopenfilenames(
            parent=self,
            title=f'Select Music Files',
            initialfile='',
            initialdir=self.lastDir,
        )
        if paths:  # Path selected
            self.inputPaths = paths
            dnd = 'no'
            self.update_inputPaths()
            nondnd = os.path.dirname(paths[0])

    def open_export_filedialog(self):
        """Make user select a folder to export the converted files in"""
        path = tk.filedialog.askdirectory(
            parent=self,
            title=f'Select Folder',)
        if path:  # Path selected
            self.exportPath_var.set(path)

    def open_exportPath_filedialog(self):
        filename = self.exportPath_var.get()

        if sys.platform == "win32":
            os.startfile(filename)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
            
    def open_inputPath_filedialog(self):
        """Open Input Directory"""
         
        try: 
            if dnd == 'yes':  
                self.lastDir = str(dnddir)  
                filename = str(self.lastDir)
                if sys.platform == "win32":
                    os.startfile(filename)
            if dnd == 'no':
                self.lastDir = str(nondnd)
                filename = str(self.lastDir)
                
                if sys.platform == "win32":
                    os.startfile(filename)
        except:
            tbs = str(self.inputPathsEntry_var.get())
            head, sep, tail = tbs.partition(';')
            in_path=os.path.dirname(head)
            filename = str(in_path)
                
            if sys.platform == "win32":
                os.startfile(filename)

    def start_conversion(self):
        """
        Start the conversion for all the given mp3 and wav files
        """

        # -Get all variables-
        export_path = self.exportPath_var.get()
        input_paths = self.inputPaths
        instrumentalModel_path = self.instrumentalLabel_to_path[self.instrumentalModel_var.get()]  # nopep8
        # mdxnetModel_path = self.mdxnetLabel_to_path[self.mdxnetModel_var.get()]
        # Get constants
        instrumental = self.instrumentalModel_var.get()
        try:
            if [bool(instrumental)].count(True) == 2: #CHECKTHIS
                window_size = DEFAULT_DATA['window_size']
                agg = DEFAULT_DATA['agg']
                chunks = DEFAULT_DATA['chunks']
                noisereduc_s = DEFAULT_DATA['noisereduc_s']
                mixing = DEFAULT_DATA['mixing']
            else:
                window_size = int(self.winSize_var.get())
                agg = int(self.agg_var.get())
                chunks = str(self.chunks_var.get())
                noisereduc_s = str(self.noisereduc_s_var.get())
                mixing = str(self.mixing_var.get())
                ensChoose = str(self.ensChoose_var.get())
                mdxnetModel = str(self.mdxnetModel_var.get())

        except SyntaxError:  # Non integer was put in entry box
            tk.messagebox.showwarning(master=self,
                                    title='Invalid Music File',
                                    message='You have selected an invalid music file!\nPlease make sure that your files still exist and ends with either ".mp3", ".mp4", ".m4a", ".flac", ".wav"')
            return

        # -Check for invalid inputs-
        
        for path in input_paths:
            if not os.path.isfile(path):
                    tk.messagebox.showwarning(master=self,
                                            title='Drag and Drop Feature Failed or Invalid Input',
                                            message='The input is invalid, or the drag and drop feature failed to select your files properly.\n\nPlease try the following:\n\n1. Select your inputs using the \"Select Input\" button\n2. Verify the input is valid.\n3. Then try again.')
                    return 


        if self.aiModel_var.get() == 'VR Architecture':
            if not os.path.isfile(instrumentalModel_path):
                    tk.messagebox.showwarning(master=self,
                                                title='Invalid Main Model File',
                                                message='You have selected an invalid main model file!\nPlease make sure that your model file still exists!')
                    return

        if not os.path.isdir(export_path):
            tk.messagebox.showwarning(master=self,
                                    title='Invalid Export Directory',
                                    message='You have selected an invalid export directory!\nPlease make sure that your directory still exists!')
            return

        if self.aiModel_var.get() == 'VR Architecture':
            inference = inference_v5
        elif self.aiModel_var.get() == 'Ensemble Mode':
            inference = inference_v5_ensemble
        elif self.aiModel_var.get() == 'MDX-Net':
            inference = inference_MDX
        elif self.aiModel_var.get() == 'Demucs v3':
            inference = inference_demucs
        else:
            raise TypeError('This error should not occur.')

        # -Run the algorithm-
        
        global inf
        inf = KThread(target=inference.main,
                        kwargs={
                            # Paths
                            'agg': agg,
                            'algo': self.algo_var.get(),
                            'appendensem': self.appendensem_var.get(),
                            'audfile': self.audfile_var.get(),
                            'aud_mdx': self.aud_mdx_var.get(),
                            'autocompensate': self.autocompensate_var.get(),
                            'break': False,
                            'button_widget_mdx_model_set': self.conversion_Button,
                            'button_widget': self.conversion_Button,
                            'channel': self.channel_var.get(),
                            'chunks': chunks,
                            'chunks_d': self.chunks_d_var.get(),
                            'compensate': self.compensate_var.get(),
                            'demucs_only': self.demucs_only_var.get(),
                            'demucs_stems': self.demucs_stems_var.get(),
                            'DemucsModel': self.DemucsModel_var.get(),
                            'demucsmodel': self.demucsmodel_var.get(),
                            'DemucsModel_MDX': self.DemucsModel_MDX_var.get(),
                            'demucsmodel_sel_VR': self.demucsmodel_sel_VR_var.get(),
                            'demucsmodelVR': self.demucsmodelVR_var.get(),
                            'dim_f': self.dim_f_var.get(),
                            'ensChoose': ensChoose,
                            'export_path': export_path,
                            'flactype': self.flactype_var.get(),
                            'gpu': 0 if self.gpuConversion_var.get() else -1,
                            'input_paths': input_paths,
                            'inst_menu': self.options_instrumentalModel_Optionmenu,
                            'inst_only': self.inst_only_var.get(),
                            'inst_only_b': self.inst_only_b_var.get(),
                            'instrumentalModel': instrumentalModel_path,
                            'margin': self.margin_var.get(),
                            'mdx_ensem': self.mdxensemchoose_var.get(),
                            'mdx_ensem_b': self.mdxensemchoose_b_var.get(),
                            'mdx_only_ensem_a': self.mdx_only_ensem_a_var.get(),
                            'mdx_only_ensem_b': self.mdx_only_ensem_b_var.get(),
                            'mdx_only_ensem_c': self.mdx_only_ensem_c_var.get(),
                            'mdx_only_ensem_d': self.mdx_only_ensem_d_var.get(),
                            'mdx_only_ensem_e': self.mdx_only_ensem_e_var.get(),
                            'mdxnetModel': mdxnetModel,
                            'mdxnetModeltype': self.mdxnetModeltype_var.get(),
                            'mixing': mixing,
                            'modelFolder': self.modelFolder_var.get(),
                            'ModelParams': self.ModelParams_var.get(),
                            'mp3bit': self.mp3bit_var.get(),
                            'n_fft_scale': self.n_fft_scale_var.get(),
                            'noise_pro_select': self.noise_pro_select_var.get(),
                            'noise_reduc': self.noisereduc_var.get(),
                            'noisereduc_s': noisereduc_s,
                            'non_red': self.non_red_var.get(),
                            'nophaseinst': self.nophaseinst_var.get(),
                            'normalize': self.normalize_var.get(),
                            'output_image': self.outputImage_var.get(),
                            'overlap': self.overlap_var.get(),
                            'overlap_b': self.overlap_b_var.get(),
                            'postprocess': self.postprocessing_var.get(),
                            'progress_var': self.progress_var,
                            'save': self.save_var.get(),
                            'saveFormat': self.saveFormat_var.get(),
                            'selectdownload': self.selectdownload_var.get(),
                            'segment': self.segment_var.get(),
                            'settest': self.settest_var.get(),
                            'shifts': self.shifts_var.get(),
                            'shifts_b': self.shifts_b_var.get(),
                            'split_mode': self.split_mode_var.get(),
                            'text_widget': self.command_Text,
                            'tta': self.tta_var.get(),
                            'useModel': 'instrumental',  # Always instrumental
                            'voc_only': self.voc_only_var.get(),
                            'voc_only_b': self.voc_only_b_var.get(),
                            'vocalModel': '',  # Always not needed
                            'vr_ensem': self.vrensemchoose_var.get(),
                            'vr_ensem_a': self.vrensemchoose_a_var.get(),
                            'vr_ensem_b': self.vrensemchoose_b_var.get(),
                            'vr_ensem_c': self.vrensemchoose_c_var.get(),
                            'vr_ensem_d': self.vrensemchoose_d_var.get(),
                            'vr_ensem_e': self.vrensemchoose_e_var.get(),
                            'vr_ensem_mdx_a': self.vrensemchoose_mdx_a_var.get(),
                            'vr_ensem_mdx_b': self.vrensemchoose_mdx_b_var.get(),
                            'vr_ensem_mdx_c': self.vrensemchoose_mdx_c_var.get(),
                            'vr_multi_USER_model_param_1': self.vr_multi_USER_model_param_1.get(),
                            'vr_multi_USER_model_param_2': self.vr_multi_USER_model_param_2.get(),
                            'vr_multi_USER_model_param_3': self.vr_multi_USER_model_param_3.get(),
                            'vr_multi_USER_model_param_4': self.vr_multi_USER_model_param_4.get(),
                            'vr_basic_USER_model_param_1': self.vr_basic_USER_model_param_1.get(),
                            'vr_basic_USER_model_param_2': self.vr_basic_USER_model_param_2.get(),
                            'vr_basic_USER_model_param_3': self.vr_basic_USER_model_param_3.get(),
                            'vr_basic_USER_model_param_4': self.vr_basic_USER_model_param_4.get(),
                            'vr_basic_USER_model_param_5': self.vr_basic_USER_model_param_5.get(),
                            'wavtype': self.wavtype_var.get(),
                            'window': self,
                            'window_size': window_size,
                        },
                        daemon=True
                        )
        
        inf.start()
        
    def stop_inf(self):
        
        confirm = tk.messagebox.askyesno(title='Confirmation',
                message='You are about to stop all active processes.\n\nAre you sure you wish to continue?')
        
        # if self.aiModel_var.get() == 'VR Architecture':
        #     inference = inference_v5
        # elif self.aiModel_var.get() == 'Ensemble Mode':
        #     inference = inference_v5_ensemble
        # elif self.aiModel_var.get() == 'MDX-Net':
        #     inference = inference_MDX
        # elif self.aiModel_var.get() == 'Demucs v3':
        #     inference = inference_demucs
        
        if confirm:
            inf.kill()
            button_widget = self.conversion_Button
            button_widget.configure(state=tk.NORMAL)
            text = self.command_Text
            text.write('\n\nProcess stopped by user.')
            torch.cuda.empty_cache()
            importlib.reload(inference_v5)
            importlib.reload(inference_v5_ensemble)
            importlib.reload(inference_MDX)
            importlib.reload(inference_demucs)
            self.progress_var.set(0)
        else:
            pass
        
    # Models
    def update_inputPaths(self):
        """Update the music file entry"""
        if self.inputPaths:
            # Non-empty Selection
            text = '; '.join(self.inputPaths)
        else:
            # Empty Selection
            text = ''
        self.inputPathsEntry_var.set(text)


    def update_loop(self):
        """Update the dropdown menu"""
        self.update_available_models()

        self.after(1000, self.update_loop)

    def update_available_models(self):
        """
        Loop through every VR model (.pth) in the models directory
        and add to the select your model list
        """
        temp_DemucsModels_dir = os.path.join(instrumentalModels_dir, 'Demucs_Models')
        new_DemucsModels = os.listdir(temp_DemucsModels_dir)
  
        temp_MDXModels_dir = os.path.join(instrumentalModels_dir, 'MDX_Net_Models')  # nopep8
        new_MDXModels = os.listdir(temp_MDXModels_dir)
        
        newmodels = [new_DemucsModels, new_MDXModels]

        temp_instrumentalModels_dir = os.path.join(instrumentalModels_dir, 'Main_Models')  # nopep8
        new_InstrumentalModels = os.listdir(temp_instrumentalModels_dir)
        
        if new_InstrumentalModels != self.lastInstrumentalModels_ensem:
            
            with open('lib_v5/filelists/ensemble_list/vr_en_list.txt', 'w') as f:
                f.write('No Model\nNo Model\n')
        
        if new_InstrumentalModels != self.lastInstrumentalModels:
            self.instrumentalLabel_to_path.clear()
            self.options_instrumentalModel_Optionmenu['menu'].delete(0, 'end')
            for file_name in natsort.natsorted(new_InstrumentalModels):
                if file_name.endswith('.pth'):
                    # Add Radiobutton to the Options Menu
                    self.options_instrumentalModel_Optionmenu['menu'].add_radiobutton(label=file_name,
                                                                                      command=tk._setit(self.instrumentalModel_var, file_name))
                    # Link the files name to its absolute path
                    self.instrumentalLabel_to_path[file_name] = os.path.join(temp_instrumentalModels_dir, file_name)  # nopep8
            self.lastInstrumentalModels = new_InstrumentalModels
            #print(self.instrumentalLabel_to_path)
            
        if new_InstrumentalModels != self.lastInstrumentalModels_ensem:
            
            for file_name_vr in natsort.natsorted(new_InstrumentalModels):
                if file_name_vr.endswith(".pth"):
                    b = [".pth"]
                    for char in b:
                        file_name_vr = file_name_vr.replace(char, "")

                    vr_list_en = file_name_vr
                    
                    with open('lib_v5/filelists/ensemble_list/vr_en_list.txt', 'a') as f:
                        f.write("{}\n".format(vr_list_en))
                    
            self.lastInstrumentalModels_ensem = new_InstrumentalModels

        """
        Loop through every MDX-Net model (.onnx) in the models directory
        and add to the select your model list
        """
        
        if newmodels != self.lastmdx_demuc_ensem:
            with open('lib_v5/filelists/ensemble_list/mdx_demuc_en_list.txt', 'w') as f:
                f.write('No Model\nNo Model\n')
        
        if new_MDXModels != self.lastMDXModels or newmodels != self.lastmdx_demuc_ensem:
            self.MDXLabel_to_path.clear()
            self.options_mdxnetModel_Optionmenu['menu'].delete(0, 'end')
            for file_name_1 in natsort.natsorted(new_MDXModels):
                if file_name_1.endswith(('.onnx')):
                    b = [".onnx"]
                    for char in b:
                        file_name_1 = file_name_1.replace(char, "")
                        
                    c = ["UVR_MDXNET_3_9662"]
                    for char in c:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 3") 
                        
                    d = ["UVR_MDXNET_2_9682"]
                    for char in d:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 2") 
                        
                    e = ["UVR_MDXNET_1_9703"]
                    for char in e:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 1") 
                        
                    f = ["UVR_MDXNET_9662"]
                    for char in f:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 3") 
                        
                    g = ["UVR_MDXNET_9682"]
                    for char in g:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 2") 
                        
                    h = ["UVR_MDXNET_9703"]
                    for char in h:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET 1") 
                        
                    i = ["UVR_MDXNET_KARA"]
                    for char in i:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET Karaoke") 
                        
                    j = ["UVR_MDXNET_Main"]
                    for char in j:
                        file_name_1 = file_name_1.replace(char, "UVR-MDX-NET Main") 
                    
                    self.options_mdxnetModel_Optionmenu['menu'].add_radiobutton(label=file_name_1,
                                                                        command=tk._setit(self.mdxnetModel_var, file_name_1))
                    
                    mdx_list_en = file_name_1
                    
                    self.ensemfiles = mdx_list_en
                    
                    with open('lib_v5/filelists/ensemble_list/mdx_demuc_en_list.txt', 'a') as f:
                        f.write("MDX-Net: {}\n".format(mdx_list_en))
                    
                    
            self.lastMDXModels = new_MDXModels
            
        """
        Loop through every Demucs model (.th, .pth) in the models directory
        and add to the select your model list
        """

        try:
            if new_DemucsModels != self.lastDemucsModels or newmodels != self.lastmdx_demuc_ensem:
                self.DemucsLabel_to_path.clear()
                self.options_DemucsModel_Optionmenu['menu'].delete(0, 'end')
                for file_name_2 in natsort.natsorted(new_DemucsModels):
                    if file_name_2.endswith(('.yaml', '.ckpt', '.gz', 'tasnet-beb46fac.th', 'tasnet_extra-df3777b2.th', 
                                             'demucs48_hq-28a1282c.th', 'demucs-e07c671f.th', 'demucs_extra-3646af93.th', 'demucs_unittest-09ebc15f.th', 
                                             'tasnet.th', 'tasnet_extra.th', 'demucs.th', 'demucs_extra.th', 'light.th', 'light_extra.th')):
                        #Demucs v3 Models
                        b = [".yaml"]
                        for char in b:
                            file_name_2 = file_name_2.replace(char, "") 
                        #Demucs v2 Models 
                        c = ["tasnet-beb46fac.th"]
                        for char in c:
                            file_name_2 = file_name_2.replace(char, "Tasnet v2")
                        d = ["tasnet_extra-df3777b2.th"]
                        for char in d:
                            file_name_2 = file_name_2.replace(char, "Tasnet_extra v2")
                        e = ["demucs48_hq-28a1282c.th"]
                        for char in e:
                            file_name_2 = file_name_2.replace(char, "Demucs48_hq v2")
                        f = ["demucs-e07c671f.th"]
                        for char in f:
                            file_name_2 = file_name_2.replace(char, "Demucs v2")
                        g = ["demucs_extra-3646af93.th"]
                        for char in g:
                            file_name_2 = file_name_2.replace(char, "Demucs_extra v2")
                        n = ["demucs_unittest-09ebc15f.th"]
                        for char in n:
                            file_name_2 = file_name_2.replace(char, "Demucs_unittest v2")
                        #Demucs v1 Models
                        h = ["tasnet.th"]
                        for char in h:
                            file_name_2 = file_name_2.replace(char, "Tasnet v1")
                        i = ["tasnet_extra.th"]
                        for char in i:
                            file_name_2 = file_name_2.replace(char, "Tasnet_extra v1")
                        j = ["demucs.th"]
                        for char in j:
                            file_name_2 = file_name_2.replace(char, "Demucs v1")
                        k = ["demucs_extra.th"]
                        for char in k:
                            file_name_2 = file_name_2.replace(char, "Demucs_extra v1")
                        l = ["light.th"]
                        for char in l:
                            file_name_2 = file_name_2.replace(char, "Light v1")
                        m = ["light_extra.th"]
                        for char in m:
                            file_name_2 = file_name_2.replace(char, "Light_extra v1")

                        
                        self.options_DemucsModel_Optionmenu['menu'].add_radiobutton(label=file_name_2,
                                                                            command=tk._setit(self.DemucsModel_var, file_name_2))
                        
                        demucs_list_en = file_name_2
                        
                        with open('lib_v5/filelists/ensemble_list/mdx_demuc_en_list.txt', 'a') as f:
                            f.writelines("Demucs: {}\n".format(demucs_list_en))
                        
                self.lastDemucsModels = new_DemucsModels
                
        except:
            pass
        
        try:
            if new_DemucsModels != self.lastDemucsModels or newmodels != self.lastmdx_demuc_ensem:
                #print(new_MDXModels)
                self.DemucsLabel_to_path.clear()
                self.options_DemucsModel_MDX_Optionmenu['menu'].delete(0, 'end')
                for file_name_3 in natsort.natsorted(new_DemucsModels):
                    if file_name_3.endswith(('.yaml', '.ckpt', '.gz', 'tasnet-beb46fac.th', 'tasnet_extra-df3777b2.th', 
                                             'demucs48_hq-28a1282c.th', 'demucs-e07c671f.th', 'demucs_extra-3646af93.th', 'demucs_unittest-09ebc15f.th', 
                                             'tasnet.th', 'tasnet_extra.th', 'demucs.th', 'demucs_extra.th', 'light.th', 'light_extra.th')):
                        #Demucs v3 Models
                        b = [".yaml"]
                        for char in b:
                            file_name_3 = file_name_3.replace(char, "") 
                        #Demucs v2 Models 
                        c = ["tasnet-beb46fac.th"]
                        for char in c:
                            file_name_3 = file_name_3.replace(char, "Tasnet v2")
                        d = ["tasnet_extra-df3777b2.th"]
                        for char in d:
                            file_name_3 = file_name_3.replace(char, "Tasnet_extra v2")
                        e = ["demucs48_hq-28a1282c.th"]
                        for char in e:
                            file_name_3 = file_name_3.replace(char, "Demucs48_hq v2")
                        f = ["demucs-e07c671f.th"]
                        for char in f:
                            file_name_3 = file_name_3.replace(char, "Demucs v2")
                        g = ["demucs_extra-3646af93.th"]
                        for char in g:
                            file_name_3 = file_name_3.replace(char, "Demucs_extra v2")
                        n = ["demucs_unittest-09ebc15f.th"]
                        for char in n:
                            file_name_3 = file_name_3.replace(char, "Demucs_unittest v2")
                        #Demucs v1 Models
                        h = ["tasnet.th"]
                        for char in h:
                            file_name_3 = file_name_3.replace(char, "Tasnet v1")
                        i = ["tasnet_extra.th"]
                        for char in i:
                            file_name_3 = file_name_3.replace(char, "Tasnet_extra v1")
                        j = ["demucs.th"]
                        for char in j:
                            file_name_3 = file_name_3.replace(char, "Demucs v1")
                        k = ["demucs_extra.th"]
                        for char in k:
                            file_name_3 = file_name_3.replace(char, "Demucs_extra v1")
                        l = ["light.th"]
                        for char in l:
                            file_name_3 = file_name_3.replace(char, "Light v1")
                        m = ["light_extra.th"]
                        for char in m:
                            file_name_3 = file_name_3.replace(char, "Light_extra v1")

                        
                        self.options_DemucsModel_MDX_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.DemucsModel_MDX_var, file_name_3))
                        
                self.lastDemucsModels = new_DemucsModels
                
        except:
            pass
        
        """
        Loop through every model param (.json) in the models directory
        and add to the select your model list
        """

        try:
            temp_ModelParams_dir = 'lib_v5\modelparams'  # nopep8
            new_ModelParams = os.listdir(temp_ModelParams_dir)
            
            if new_ModelParams != self.lastModelParams:
                self.ModelParamsLabel_to_path.clear()
                self.options_ModelParams_Optionmenu['menu'].delete(0, 'end')
                for file_name_3 in natsort.natsorted(new_ModelParams):
                    if file_name_3.endswith(('.json', 'Auto')):
                        
                        self.options_ModelParams_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.ModelParams_var, file_name_3))
                self.lastModelParams = new_ModelParams
        except:
            pass
        
        
        
        try:
            temp_ModelParams_dir = 'lib_v5\modelparams'  # nopep8
            new_ModelParams = os.listdir(temp_ModelParams_dir)
            
            if new_ModelParams != self.lastModelParams_ens:
                self.ModelParamsLabel_ens_to_path.clear()
                self.options_ModelParams_a_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_b_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_c_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_d_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_1_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_2_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_3_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_4_Optionmenu['menu'].delete(0, 'end')
                self.options_ModelParams_5_Optionmenu['menu'].delete(0, 'end')
                for file_name_3 in natsort.natsorted(new_ModelParams):
                    if file_name_3.endswith(('.json', 'Auto')):
                        
                        self.options_ModelParams_a_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_multi_USER_model_param_1, file_name_3))
                        self.options_ModelParams_b_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_multi_USER_model_param_2, file_name_3))
                        self.options_ModelParams_c_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_multi_USER_model_param_3, file_name_3))
                        self.options_ModelParams_d_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_multi_USER_model_param_4, file_name_3))
                        self.options_ModelParams_1_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_basic_USER_model_param_1, file_name_3))
                        self.options_ModelParams_2_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_basic_USER_model_param_2, file_name_3))
                        self.options_ModelParams_3_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_basic_USER_model_param_3, file_name_3))
                        self.options_ModelParams_4_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_basic_USER_model_param_4, file_name_3))
                        self.options_ModelParams_5_Optionmenu['menu'].add_radiobutton(label=file_name_3,
                                                                            command=tk._setit(self.vr_basic_USER_model_param_5, file_name_3))
                self.lastModelParams_ens = new_ModelParams
        except:
            pass
        
        self.lastmdx_demuc_ensem = [new_DemucsModels, new_MDXModels]
            
    def update_states(self):
        """
        Vary the states for all widgets based
        on certain selections
        """

        if self.aiModel_var.get() == 'MDX-Net':
            # Place Widgets

            # Choose MDX-Net Model
            self.options_mdxnetModel_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            self.options_mdxnetModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            # MDX-chunks
            self.options_chunks_Label.place(x=12, y=0, width=0, height=-10,
                                        relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_chunks_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                        relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            # MDX-noisereduc_s
            self.options_noisereduc_s_Label.place(x=15, y=0, width=0, height=-10,
                                        relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_noisereduc_s_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                        relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #GPU Conversion
            self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
            self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Vocals Only
            self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
            self.options_voc_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Instrumental Only
            self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
            self.options_inst_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            # MDX-demucs Model
            self.options_demucsmodel_Checkbutton.configure(state=tk.NORMAL)
            self.options_demucsmodel_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            # MDX-Keep Non_Reduced Vocal
            self.options_non_red_Checkbutton.configure(state=tk.NORMAL)
            self.options_non_red_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Model Test Mode
            self.options_modelFolder_Checkbutton.configure(state=tk.NORMAL)
            self.options_modelFolder_Checkbutton.place(x=35, y=21, width=0, height=5,
                                                relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            # Forget widgets
            self.options_agg_Label.place_forget()
            self.options_agg_Optionmenu.place_forget()
            self.options_algo_Label.place_forget()
            self.options_algo_Optionmenu.place_forget()
            self.options_demucs_stems_Label.place_forget()
            self.options_demucs_stems_Optionmenu.place_forget()
            self.options_DemucsModel_Label.place_forget()
            self.options_DemucsModel_Optionmenu.place_forget()
            self.options_ensChoose_Label.place_forget()
            self.options_ensChoose_Optionmenu.place_forget()
            self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
            self.options_inst_only_b_Checkbutton.place_forget()
            self.options_inst_only_b_Checkbutton.place_forget()
            self.options_instrumentalModel_Label.place_forget()
            self.options_instrumentalModel_Optionmenu.place_forget()
            self.options_overlap_b_Label.place_forget()
            self.options_overlap_b_Optionmenu.place_forget()
            self.options_postpro_Checkbutton.configure(state=tk.DISABLED)
            self.options_postpro_Checkbutton.place_forget()
            self.options_save_Checkbutton.configure(state=tk.DISABLED)
            self.options_save_Checkbutton.place_forget()
            self.options_segment_Label.place_forget()
            self.options_segment_Optionmenu.place_forget()
            self.options_shifts_b_Label.place_forget()
            self.options_shifts_b_Optionmenu.place_forget()
            self.options_split_Checkbutton.configure(state=tk.DISABLED)
            self.options_split_Checkbutton.place_forget()
            self.options_tta_Checkbutton.configure(state=tk.DISABLED)
            self.options_tta_Checkbutton.place_forget()
            self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
            self.options_voc_only_b_Checkbutton.place_forget()
            self.options_winSize_Label.place_forget()
            self.options_winSize_Optionmenu.place_forget()
            
            
        elif self.aiModel_var.get() == 'VR Architecture':
            #Keep for Ensemble & VR Architecture Mode
            # Choose Main Model
            self.options_instrumentalModel_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            self.options_instrumentalModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            # WINDOW
            self.options_winSize_Label.place(x=13, y=0, width=0, height=-10,
                                        relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_winSize_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                        relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            # AGG
            self.options_agg_Label.place(x=15, y=0, width=0, height=-10,
                                        relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_agg_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                        relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #GPU Conversion
            self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
            self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Vocals Only
            self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
            self.options_voc_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Instrumental Only
            self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
            self.options_inst_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            # TTA
            self.options_tta_Checkbutton.configure(state=tk.NORMAL)
            self.options_tta_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Post-Process
            self.options_postpro_Checkbutton.configure(state=tk.NORMAL)
            self.options_postpro_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Save Image
            # self.options_image_Checkbutton.configure(state=tk.NORMAL)
            # self.options_image_Checkbutton.place(x=35, y=21, width=0, height=5,
            #                                     relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Model Test Mode
            self.options_modelFolder_Checkbutton.configure(state=tk.NORMAL)
            self.options_modelFolder_Checkbutton.place(x=35, y=21, width=0, height=5,
                                                relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Forget Widgets
            self.options_algo_Label.place_forget()
            self.options_algo_Optionmenu.place_forget()
            self.options_chunks_Label.place_forget()
            self.options_chunks_Optionmenu.place_forget()
            self.options_demucs_stems_Label.place_forget()
            self.options_demucs_stems_Optionmenu.place_forget()
            self.options_demucsmodel_Checkbutton.configure(state=tk.DISABLED)
            self.options_demucsmodel_Checkbutton.place_forget()
            self.options_DemucsModel_Label.place_forget()
            self.options_DemucsModel_Optionmenu.place_forget()
            self.options_ensChoose_Label.place_forget()
            self.options_ensChoose_Optionmenu.place_forget()
            self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
            self.options_inst_only_b_Checkbutton.place_forget()
            self.options_mdxnetModel_Label.place_forget()
            self.options_mdxnetModel_Optionmenu.place_forget()
            self.options_noisereduc_Checkbutton.configure(state=tk.DISABLED)
            self.options_noisereduc_Checkbutton.place_forget()
            self.options_noisereduc_s_Label.place_forget()
            self.options_noisereduc_s_Optionmenu.place_forget()
            self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
            self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
            self.options_non_red_Checkbutton.place_forget()
            self.options_non_red_Checkbutton.place_forget()
            self.options_overlap_b_Label.place_forget()
            self.options_overlap_b_Optionmenu.place_forget()
            self.options_save_Checkbutton.configure(state=tk.DISABLED)
            self.options_save_Checkbutton.place_forget()
            self.options_segment_Label.place_forget()
            self.options_segment_Optionmenu.place_forget()
            self.options_shifts_b_Label.place_forget()
            self.options_shifts_b_Optionmenu.place_forget()
            self.options_split_Checkbutton.configure(state=tk.DISABLED)
            self.options_split_Checkbutton.place_forget()
            self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
            self.options_voc_only_b_Checkbutton.place_forget()
            
        elif self.aiModel_var.get() == 'Demucs v3':
            #Keep for Ensemble & VR Architecture Mode
            # Choose Main Model
            self.options_DemucsModel_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            self.options_DemucsModel_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
            
            # Choose Stems
            self.options_demucs_stems_Label.place(x=13, y=0, width=0, height=-10,
                                        relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_demucs_stems_Optionmenu.place(x=55, y=-2, width=-85, height=7,
                                        relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            # Segment
            self.options_segment_Label.place(x=12, y=0, width=0, height=-10,
                                        relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_segment_Optionmenu.place(x=55, y=-2, width=-85, height=7,
                                        relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            # Shifts
            self.options_shifts_b_Label.place(x=12, y=0, width=0, height=-10,
                                        relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_shifts_b_Optionmenu.place(x=55, y=-2, width=-85, height=7,
                                        relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            # Overlap
            self.options_overlap_b_Label.place(x=13, y=0, width=0, height=-10,
                                        relx=2/3, rely=8/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            self.options_overlap_b_Optionmenu.place(x=55, y=-2, width=-85, height=7,
                                        relx=2/3, rely=9/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            #GPU Conversion
            self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
            self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Vocals Only
            self.options_voc_only_b_Checkbutton.configure(state=tk.NORMAL)
            self.options_voc_only_b_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            #Instrumental Only
            self.options_inst_only_b_Checkbutton.configure(state=tk.NORMAL)
            self.options_inst_only_b_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
            
            #Split Mode
            self.options_split_Checkbutton.configure(state=tk.NORMAL)
            self.options_split_Checkbutton.place(x=35, y=21, width=0, height=5,
                                        relx=1/3, rely=8/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)

            # Forget Widgets
            # self.options_image_Checkbutton.configure(state=tk.DISABLED)
            # self.options_image_Checkbutton.place_forget()
            self.options_agg_Label.place_forget()
            self.options_agg_Optionmenu.place_forget()
            self.options_algo_Label.place_forget()
            self.options_algo_Optionmenu.place_forget()
            self.options_chunks_Label.place_forget()
            self.options_chunks_Optionmenu.place_forget()
            self.options_demucsmodel_Checkbutton.configure(state=tk.DISABLED)
            self.options_demucsmodel_Checkbutton.place_forget()
            self.options_ensChoose_Label.place_forget()
            self.options_ensChoose_Optionmenu.place_forget()
            self.options_inst_only_Checkbutton.configure(state=tk.DISABLED)
            self.options_inst_only_Checkbutton.place_forget()
            self.options_instrumentalModel_Label.place_forget()
            self.options_instrumentalModel_Optionmenu.place_forget()
            self.options_mdxnetModel_Label.place_forget()
            self.options_mdxnetModel_Optionmenu.place_forget()
            self.options_modelFolder_Checkbutton.place_forget()
            self.options_noisereduc_Checkbutton.configure(state=tk.DISABLED)
            self.options_noisereduc_Checkbutton.place_forget()
            self.options_noisereduc_s_Label.place_forget()
            self.options_noisereduc_s_Optionmenu.place_forget()
            self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
            self.options_non_red_Checkbutton.place_forget()
            self.options_postpro_Checkbutton.configure(state=tk.DISABLED)
            self.options_postpro_Checkbutton.place_forget()
            self.options_save_Checkbutton.configure(state=tk.DISABLED)
            self.options_save_Checkbutton.place_forget()
            self.options_tta_Checkbutton.configure(state=tk.DISABLED)
            self.options_tta_Checkbutton.place_forget()
            self.options_voc_only_Checkbutton.configure(state=tk.DISABLED)
            self.options_voc_only_Checkbutton.place_forget()
            self.options_winSize_Label.place_forget()
            self.options_winSize_Optionmenu.place_forget()
            
        elif self.aiModel_var.get() == 'Ensemble Mode':
            if self.ensChoose_var.get() == 'Manual Ensemble':
                # Choose Algorithm
                self.options_algo_Label.place(x=20, y=0, width=0, height=-10,
                                        relx=1/3, rely=2/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                self.options_algo_Optionmenu.place(x=12, y=-2, width=0, height=7,
                                        relx=1/3, rely=3/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                # Choose Ensemble 
                self.options_ensChoose_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                self.options_ensChoose_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                # Forget Widgets
                # self.options_image_Checkbutton.configure(state=tk.DISABLED)
                # self.options_image_Checkbutton.place_forget()
                self.options_agg_Label.place_forget()
                self.options_agg_Optionmenu.place_forget()
                self.options_chunks_Label.place_forget()
                self.options_chunks_Optionmenu.place_forget()
                self.options_demucs_stems_Label.place_forget()
                self.options_demucs_stems_Optionmenu.place_forget()
                self.options_demucsmodel_Checkbutton.configure(state=tk.DISABLED)
                self.options_demucsmodel_Checkbutton.place_forget()
                self.options_DemucsModel_Label.place_forget()
                self.options_DemucsModel_Optionmenu.place_forget()
                self.options_gpu_Checkbutton.configure(state=tk.DISABLED)
                self.options_gpu_Checkbutton.place_forget()
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_inst_only_Checkbutton.configure(state=tk.DISABLED)
                self.options_inst_only_Checkbutton.place_forget()
                self.options_mdxnetModel_Label.place_forget()
                self.options_mdxnetModel_Optionmenu.place_forget()
                self.options_modelFolder_Checkbutton.configure(state=tk.DISABLED)
                self.options_modelFolder_Checkbutton.place_forget()
                self.options_noisereduc_Checkbutton.configure(state=tk.DISABLED)
                self.options_noisereduc_Checkbutton.place_forget()
                self.options_noisereduc_s_Label.place_forget()
                self.options_noisereduc_s_Optionmenu.place_forget()
                self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
                self.options_non_red_Checkbutton.place_forget()
                self.options_overlap_b_Label.place_forget()
                self.options_overlap_b_Optionmenu.place_forget()
                self.options_postpro_Checkbutton.configure(state=tk.DISABLED)
                self.options_postpro_Checkbutton.place_forget()
                self.options_save_Checkbutton.configure(state=tk.DISABLED)
                self.options_save_Checkbutton.place_forget()
                self.options_segment_Label.place_forget()
                self.options_segment_Optionmenu.place_forget()
                self.options_shifts_b_Label.place_forget()
                self.options_shifts_b_Optionmenu.place_forget()
                self.options_split_Checkbutton.configure(state=tk.DISABLED)
                self.options_split_Checkbutton.place_forget()
                self.options_tta_Checkbutton.configure(state=tk.DISABLED)
                self.options_tta_Checkbutton.place_forget()
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_voc_only_b_Checkbutton.place_forget()
                self.options_voc_only_Checkbutton.configure(state=tk.DISABLED)
                self.options_voc_only_Checkbutton.place_forget()
                self.options_winSize_Label.place_forget()
                self.options_winSize_Optionmenu.place_forget()
                

            elif self.ensChoose_var.get() == 'Multi-AI Ensemble':
                # Choose Ensemble 
                self.options_ensChoose_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                self.options_ensChoose_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                # MDX-chunks
                self.options_chunks_Label.place(x=12, y=0, width=0, height=-10,
                                            relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_chunks_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # MDX-noisereduc_s
                self.options_noisereduc_s_Label.place(x=15, y=0, width=0, height=-10,
                                            relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_noisereduc_s_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # WINDOW
                self.options_winSize_Label.place(x=13, y=-7, width=0, height=-10,
                                            relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_winSize_Optionmenu.place(x=71, y=-5, width=-118, height=7,
                                            relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # AGG
                self.options_agg_Label.place(x=15, y=-7, width=0, height=-10,
                                            relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_agg_Optionmenu.place(x=71, y=-5, width=-118, height=7,
                                            relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #GPU Conversion
                self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
                self.options_gpu_Checkbutton.place(x=35, y=3, width=0, height=5,
                                                relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Vocals Only
                self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_voc_only_Checkbutton.place(x=35, y=3, width=0, height=5,
                                            relx=1/3, rely=8/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Instrumental Only
                self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_inst_only_Checkbutton.place(x=35, y=3, width=0, height=5,
                                            relx=1/3, rely=9/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # MDX-demucs Model
                self.options_demucsmodel_Checkbutton.configure(state=tk.NORMAL)
                self.options_demucsmodel_Checkbutton.place(x=35, y=3, width=0, height=5,
                                            relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # TTA
                self.options_tta_Checkbutton.configure(state=tk.NORMAL)
                self.options_tta_Checkbutton.place(x=35, y=3, width=0, height=5,
                                                relx=2/3, rely=8/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Ensemble Save Outputs
                self.options_save_Checkbutton.configure(state=tk.NORMAL)
                self.options_save_Checkbutton.place(x=35, y=3, width=0, height=5,
                                            relx=2/3, rely=9/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # Forget Widgets
                # self.options_image_Checkbutton.configure(state=tk.DISABLED)
                # self.options_image_Checkbutton.place_forget()
                self.options_algo_Label.place_forget()
                self.options_algo_Optionmenu.place_forget()
                self.options_demucs_stems_Label.place_forget()
                self.options_demucs_stems_Optionmenu.place_forget()
                self.options_DemucsModel_Label.place_forget()
                self.options_DemucsModel_Optionmenu.place_forget()
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_modelFolder_Checkbutton.configure(state=tk.DISABLED)
                self.options_modelFolder_Checkbutton.place_forget()
                self.options_noisereduc_Checkbutton.configure(state=tk.DISABLED)
                self.options_noisereduc_Checkbutton.place_forget()
                self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
                self.options_non_red_Checkbutton.place_forget()
                self.options_overlap_b_Label.place_forget()
                self.options_overlap_b_Optionmenu.place_forget()
                self.options_postpro_Checkbutton.configure(state=tk.DISABLED)
                self.options_postpro_Checkbutton.place_forget()
                self.options_segment_Label.place_forget()
                self.options_segment_Optionmenu.place_forget()
                self.options_shifts_b_Label.place_forget()
                self.options_shifts_b_Optionmenu.place_forget()
                self.options_split_Checkbutton.configure(state=tk.DISABLED)
                self.options_split_Checkbutton.place_forget()
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_voc_only_b_Checkbutton.place_forget()
            elif self.ensChoose_var.get() == 'Basic MD Ensemble':
                # Choose Ensemble 
                self.options_ensChoose_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                self.options_ensChoose_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                # MDX-chunks
                self.options_chunks_Label.place(x=12, y=0, width=0, height=-10,
                                            relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_chunks_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # MDX-noisereduc_s
                self.options_noisereduc_s_Label.place(x=15, y=0, width=0, height=-10,
                                            relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_noisereduc_s_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #GPU Conversion
                self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
                self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                                relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Vocals Only
                self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_voc_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Instrumental Only
                self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_inst_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # MDX-demucs Model
                self.options_demucsmodel_Checkbutton.configure(state=tk.NORMAL)
                self.options_demucsmodel_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                
                # Split Mode
                self.options_split_Checkbutton.configure(state=tk.NORMAL)
                self.options_split_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                
                #Ensemble Save Outputs
                self.options_save_Checkbutton.configure(state=tk.NORMAL)
                self.options_save_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                
                # Forget widgets
                # self.options_image_Checkbutton.configure(state=tk.DISABLED)
                # self.options_image_Checkbutton.place_forget()
                self.options_agg_Label.place_forget()
                self.options_agg_Optionmenu.place_forget()
                self.options_algo_Label.place_forget()
                self.options_algo_Optionmenu.place_forget()
                self.options_demucs_stems_Label.place_forget()
                self.options_demucs_stems_Optionmenu.place_forget()
                self.options_DemucsModel_Label.place_forget()
                self.options_DemucsModel_Optionmenu.place_forget()
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_instrumentalModel_Label.place_forget()
                self.options_instrumentalModel_Optionmenu.place_forget()
                self.options_mdxnetModel_Label.place_forget()
                self.options_mdxnetModel_Optionmenu.place_forget()
                self.options_modelFolder_Checkbutton.configure(state=tk.DISABLED)
                self.options_modelFolder_Checkbutton.place_forget() 
                self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
                self.options_non_red_Checkbutton.place_forget()
                self.options_overlap_b_Label.place_forget()
                self.options_overlap_b_Optionmenu.place_forget()
                self.options_postpro_Checkbutton.configure(state=tk.DISABLED)
                self.options_postpro_Checkbutton.place_forget()
                self.options_segment_Label.place_forget()
                self.options_segment_Optionmenu.place_forget()
                self.options_shifts_b_Label.place_forget()
                self.options_shifts_b_Optionmenu.place_forget()
                self.options_tta_Checkbutton.configure(state=tk.DISABLED)
                self.options_tta_Checkbutton.place_forget()
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_voc_only_b_Checkbutton.place_forget()
                self.options_winSize_Label.place_forget()
                self.options_winSize_Optionmenu.place_forget()
            else:
                # Choose Ensemble 
                self.options_ensChoose_Label.place(x=0, y=19, width=0, height=-10,
                                        relx=0, rely=6/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                self.options_ensChoose_Optionmenu.place(x=0, y=19, width=0, height=7,
                                        relx=0, rely=7/self.COL1_ROWS, relwidth=1/3, relheight=1/self.COL1_ROWS)
                # WINDOW
                self.options_winSize_Label.place(x=13, y=0, width=0, height=-10,
                                            relx=1/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_winSize_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=1/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # AGG
                self.options_agg_Label.place(x=15, y=0, width=0, height=-10,
                                            relx=2/3, rely=2/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                self.options_agg_Optionmenu.place(x=71, y=-2, width=-118, height=7,
                                            relx=2/3, rely=3/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #GPU Conversion
                self.options_gpu_Checkbutton.configure(state=tk.NORMAL)
                self.options_gpu_Checkbutton.place(x=35, y=21, width=0, height=5,
                                                relx=1/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Vocals Only
                self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_voc_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Instrumental Only
                self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
                self.options_inst_only_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=1/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                # TTA
                self.options_tta_Checkbutton.configure(state=tk.NORMAL)
                self.options_tta_Checkbutton.place(x=35, y=21, width=0, height=5,
                                                relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Post-Process
                self.options_postpro_Checkbutton.configure(state=tk.NORMAL)
                self.options_postpro_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=6/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Save Image
                # self.options_image_Checkbutton.configure(state=tk.NORMAL)
                # self.options_image_Checkbutton.place(x=35, y=21, width=0, height=5,
                #                                     relx=2/3, rely=5/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Ensemble Save Outputs
                self.options_save_Checkbutton.configure(state=tk.NORMAL)
                self.options_save_Checkbutton.place(x=35, y=21, width=0, height=5,
                                            relx=2/3, rely=7/self.COL2_ROWS, relwidth=1/3, relheight=1/self.COL2_ROWS)
                #Forget Widgets
                self.options_algo_Label.place_forget()
                self.options_algo_Optionmenu.place_forget()
                self.options_chunks_Label.place_forget()
                self.options_chunks_Optionmenu.place_forget()
                self.options_demucs_stems_Label.place_forget()
                self.options_demucs_stems_Optionmenu.place_forget()
                self.options_demucsmodel_Checkbutton.configure(state=tk.DISABLED)
                self.options_demucsmodel_Checkbutton.place_forget()
                self.options_DemucsModel_Label.place_forget()
                self.options_DemucsModel_Optionmenu.place_forget()
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_inst_only_b_Checkbutton.place_forget()
                self.options_instrumentalModel_Label.place_forget()
                self.options_mdxnetModel_Label.place_forget()
                self.options_mdxnetModel_Optionmenu.place_forget()
                self.options_modelFolder_Checkbutton.configure(state=tk.DISABLED)
                self.options_modelFolder_Checkbutton.place_forget()
                self.options_noisereduc_Checkbutton.configure(state=tk.DISABLED)
                self.options_noisereduc_Checkbutton.place_forget()
                self.options_noisereduc_s_Label.place_forget()
                self.options_noisereduc_s_Optionmenu.place_forget()
                self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
                self.options_non_red_Checkbutton.place_forget()
                self.options_overlap_b_Label.place_forget()
                self.options_overlap_b_Optionmenu.place_forget()
                self.options_segment_Label.place_forget()
                self.options_segment_Optionmenu.place_forget()
                self.options_shifts_b_Label.place_forget()
                self.options_shifts_b_Optionmenu.place_forget()
                self.options_split_Checkbutton.configure(state=tk.DISABLED)
                self.options_split_Checkbutton.place_forget()
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.options_voc_only_b_Checkbutton.place_forget()
                
                
        if self.inst_only_var.get() == True:
            self.options_voc_only_Checkbutton.configure(state=tk.DISABLED)
            self.voc_only_var.set(False)
            #self.non_red_var.set(False)
        elif self.inst_only_var.get() == False:
            self.options_non_red_Checkbutton.configure(state=tk.NORMAL)
            self.options_voc_only_Checkbutton.configure(state=tk.NORMAL)
            
        if self.voc_only_var.get() == True:
            self.options_inst_only_Checkbutton.configure(state=tk.DISABLED)
            self.inst_only_var.set(False)
        elif self.voc_only_var.get() == False:
            self.options_inst_only_Checkbutton.configure(state=tk.NORMAL)
            
        if self.demucs_stems_var.get() == 'All Stems':
            self.voc_only_b_var.set(False)
            self.inst_only_b_var.set(False)
            self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
            self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
        elif self.demucs_stems_var.get() == 'Vocals':
            if self.inst_only_b_var.get() == True:
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.voc_only_b_var.set(False)
            elif self.inst_only_b_var.get() == False:
                self.options_voc_only_b_Checkbutton.configure(state=tk.NORMAL)
                
            if self.voc_only_b_var.get() == True:
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.inst_only_b_var.set(False)
            elif self.voc_only_b_var.get() == False:
                self.options_inst_only_b_Checkbutton.configure(state=tk.NORMAL)
        elif self.demucs_stems_var.get() == 'Other':
            if self.inst_only_b_var.get() == True:
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.voc_only_b_var.set(False)
            elif self.inst_only_b_var.get() == False:
                self.options_voc_only_b_Checkbutton.configure(state=tk.NORMAL)
                
            if self.voc_only_b_var.get() == True:
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.inst_only_b_var.set(False)
            elif self.voc_only_b_var.get() == False:
                self.options_inst_only_b_Checkbutton.configure(state=tk.NORMAL)
        elif self.demucs_stems_var.get() == 'Drums':
            if self.inst_only_b_var.get() == True:
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.voc_only_b_var.set(False)
            elif self.inst_only_b_var.get() == False:
                self.options_voc_only_b_Checkbutton.configure(state=tk.NORMAL)
            if self.voc_only_b_var.get() == True:
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.inst_only_b_var.set(False)
            elif self.voc_only_b_var.get() == False:
                self.options_inst_only_b_Checkbutton.configure(state=tk.NORMAL)
        elif self.demucs_stems_var.get() == 'Bass':
            if self.inst_only_b_var.get() == True:
                self.options_voc_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.voc_only_b_var.set(False)
            elif self.inst_only_b_var.get() == False:
                self.options_voc_only_b_Checkbutton.configure(state=tk.NORMAL)
                
            if self.voc_only_b_var.get() == True:
                self.options_inst_only_b_Checkbutton.configure(state=tk.DISABLED)
                self.inst_only_b_var.set(False)
            elif self.voc_only_b_var.get() == False:
                self.options_inst_only_b_Checkbutton.configure(state=tk.NORMAL)
            
            
        if self.noisereduc_s_var.get() == 'None':
            self.options_non_red_Checkbutton.configure(state=tk.DISABLED)
            self.non_red_var.set(False)
        if not self.noisereduc_s_var.get() == 'None':
            self.options_non_red_Checkbutton.configure(state=tk.NORMAL)


        if self.autocompensate_var.get() == True:
            try:
                self.options_compensate.configure(state=tk.DISABLED)
            except:
                pass
            
        if self.autocompensate_var.get() == False:
            #self.compensate_var.set()
            try:
                self.options_compensate.configure(state=tk.NORMAL)
            except:
                pass

        if self.mdxnetModeltype_var.get() == 'Vocals (Default)':
            self.n_fft_scale_var.set('6144')
            self.dim_f_var.set('2048')
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.DISABLED)
                self.options_dim_f_Entry.configure(state=tk.DISABLED)
                self.options_n_fft_scale_Opt.configure(state=tk.DISABLED)
                self.options_dim_f_Opt.configure(state=tk.DISABLED)
            except:
                pass
            
        if self.mdxnetModeltype_var.get() == 'Other (Default)':
            self.n_fft_scale_var.set('8192')
            self.dim_f_var.set('2048')
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.DISABLED)
                self.options_dim_f_Entry.configure(state=tk.DISABLED)
                self.options_n_fft_scale_Opt.configure(state=tk.DISABLED)
                self.options_dim_f_Opt.configure(state=tk.DISABLED)
            except:
                pass

        if self.mdxnetModeltype_var.get() == 'Drums (Default)':
            self.n_fft_scale_var.set('4096')
            self.dim_f_var.set('2048')
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.DISABLED)
                self.options_dim_f_Entry.configure(state=tk.DISABLED)
                self.options_n_fft_scale_Opt.configure(state=tk.DISABLED)
                self.options_dim_f_Opt.configure(state=tk.DISABLED)
            except:
                pass
            
        if self.mdxnetModeltype_var.get() == 'Bass (Default)':
            self.n_fft_scale_var.set('16384')
            self.dim_f_var.set('2048')
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.DISABLED)
                self.options_dim_f_Entry.configure(state=tk.DISABLED)
                self.options_n_fft_scale_Opt.configure(state=tk.DISABLED)
                self.options_dim_f_Opt.configure(state=tk.DISABLED)
            except:
                pass
            
        if self.mdxnetModeltype_var.get() == 'Vocals (Custom)':
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.NORMAL)
                self.options_dim_f_Entry.configure(state=tk.NORMAL)
                self.options_n_fft_scale_Opt.configure(state=tk.NORMAL)
                self.options_dim_f_Opt.configure(state=tk.NORMAL)
            except:
                pass

        if self.mdxnetModeltype_var.get() == 'Other (Custom)':
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.NORMAL)
                self.options_dim_f_Entry.configure(state=tk.NORMAL)
                self.options_n_fft_scale_Opt.configure(state=tk.NORMAL)
                self.options_dim_f_Opt.configure(state=tk.NORMAL)
            except:
                pass

        if self.mdxnetModeltype_var.get() == 'Drums (Custom)':
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.NORMAL)
                self.options_dim_f_Entry.configure(state=tk.NORMAL)
                self.options_n_fft_scale_Opt.configure(state=tk.NORMAL)
                self.options_dim_f_Opt.configure(state=tk.NORMAL)
            except:
                pass
            
        if self.mdxnetModeltype_var.get() == 'Bass (Custom)':
            try:
                self.options_n_fft_scale_Entry.configure(state=tk.NORMAL)
                self.options_dim_f_Entry.configure(state=tk.NORMAL)
                self.options_n_fft_scale_Opt.configure(state=tk.NORMAL)
                self.options_dim_f_Opt.configure(state=tk.NORMAL)
            except:
                pass

        if self.selectdownload_var.get() == 'VR Arc':
            #self.modeldownload_var.clear()
            self.modeldownload_mdx_var.set('No Model Selected')
            self.modeldownload_demucs_var.set('No Model Selected')
            try:
                self.downloadmodelOptions.configure(state=tk.NORMAL)
                self.downloadmodelOptions_mdx.configure(state=tk.DISABLED)
                self.downloadmodelOptions_demucs.configure(state=tk.DISABLED)
            except:
                pass
        if self.selectdownload_var.get() == 'MDX-Net':
            #self.modeldownload_mdx_var.set('Full Model Pack')
            self.modeldownload_var.set('No Model Selected')
            self.modeldownload_demucs_var.set('No Model Selected')
            try:
                self.downloadmodelOptions.configure(state=tk.DISABLED)
                self.downloadmodelOptions_demucs.configure(state=tk.DISABLED)
                self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            except:
                pass
        if self.selectdownload_var.get() == 'Demucs':
            #self.modeldownload_demucs_var.set('Demucs v3: mdx')
            self.modeldownload_var.set('No Model Selected')
            self.modeldownload_mdx_var.set('No Model Selected')
            try:
                self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
                self.downloadmodelOptions.configure(state=tk.DISABLED)
                self.downloadmodelOptions_mdx.configure(state=tk.DISABLED)
            except:
                pass

        if self.demucs_only_var.get() == True:
            self.demucsmodel_var.set(True)
            self.options_demucsmodel_Checkbutton.configure(state=tk.DISABLED)
        elif self.demucs_only_var.get() == False:
            self.options_demucsmodel_Checkbutton.configure(state=tk.NORMAL)

        self.update_inputPaths()

    def deselect_models(self):
        """
        Run this method on version change
        """
        if self.aiModel_var.get() == self.last_aiModel:
            return
        else:
            self.last_aiModel = self.aiModel_var.get()

        self.instrumentalModel_var.set('')
        self.ensChoose_var.set('Multi-AI Ensemble')
        self.mdxnetModel_var.set('UVR-MDX-NET 1')

        self.winSize_var.set(DEFAULT_DATA['window_size'])
        self.agg_var.set(DEFAULT_DATA['agg'])
        self.modelFolder_var.set(DEFAULT_DATA['modelFolder'])


        self.update_available_models()
        self.update_states()

    def restart(self):
        """
        Restart the application after asking for confirmation
        """
        confirm = tk.messagebox.askyesno(title='Restart Confirmation',
                message='This will restart the application and halt any running processes. Your current settings will be saved. \n\n Are you sure you wish to continue?')
        
        if confirm:
            self.save_values()
            try:
                subprocess.Popen(f'UVR_Launcher.exe')
            except:
                subprocess.Popen(f'python "{__file__}"', shell=True)
            exit()
        else:
            self.settings()
            pass
        
    def shutdown(self):
        """
        Shuts down the application after asking for confirmation
        """
        exit()

    def open_newModel_filedialog(self):
        """Let user paste an MDX-Net model to use for the vocal Separation"""
        
        filename = 'models\MDX_Net_Models'

        if sys.platform == "win32":
            os.startfile(filename)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
            
            
    def delete_temps(self):  
        try:
            for basename in os.listdir(download_code_temp_dir):
                if basename.endswith('.aes'):
                    pathname = os.path.join(download_code_temp_dir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
                        
        except:
            pass
        
        try:
                        
            for basename in os.listdir(download_code_temp_dir):
                if basename.endswith('.txt'):
                    pathname = os.path.join(download_code_temp_dir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass
        
        try:
            srcdir = "models/Demucs_Models"

            for basename in os.listdir(srcdir):
                if basename.endswith('.tmp'):
                    pathname = os.path.join(srcdir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass   
        
        try:
            srcdir = "models/Demucs_Models/v3_repo"

            for basename in os.listdir(srcdir):
                if basename.endswith('.tmp'):
                    pathname = os.path.join(srcdir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass   

        try:
            srcdir = "models/Main_Models"

            for basename in os.listdir(srcdir):
                if basename.endswith('.tmp'):
                    pathname = os.path.join(srcdir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass  

        try:
            srcdir = "models/MDX_Net_Models"

            for basename in os.listdir(srcdir):
                if basename.endswith('.tmp'):
                    pathname = os.path.join(srcdir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass  
        
        try:
            srcdir = os.path.dirname(os.path.realpath(__file__))

            for basename in os.listdir(srcdir):
                if basename.endswith('.tmp'):
                    pathname = os.path.join(srcdir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        except:
            pass  
            
    def reset_to_defaults(self):
        self.agg_var.set(10)
        self.algo_var.set('Instrumentals (Min Spec)')
        self.appendensem_var.set(False)
        self.audfile_var.set(True)
        self.aud_mdx_var.set(True),
        self.autocompensate_var.set(True)
        self.channel_var.set(64)
        self.chunks_var.set('Auto')
        self.chunks_d_var.set('Full')
        self.compensate_var.set(1.03597672895)
        self.demucs_only_var.set(False)
        self.demucs_stems_var.set('All Stems')
        self.DemucsModel_var.set('mdx_extra')
        self.demucsmodel_var.set(False)
        self.DemucsModel_MDX_var.set('UVR_Demucs_Model_1')
        self.demucsmodel_sel_VR_var.set('UVR_Demucs_Model_1')
        self.demucsmodelVR_var.set(False)
        self.dim_f_var.set(2048)
        self.flactype_var.set('PCM_16')
        self.gpuConversion_var.set(False)
        self.inst_only_var.set(False)
        self.inst_only_b_var.set(False)
        self.margin_var.set(44100)
        self.mdxensemchoose_var.set('MDX-Net: UVR-MDX-NET Main')
        self.mdxensemchoose_b_var.set('No Model')
        self.mdx_only_ensem_a_var.set('MDX-Net: UVR-MDX-NET Main')
        self.mdx_only_ensem_b_var.set('MDX-Net: UVR-MDX-NET 1')
        self.mdx_only_ensem_c_var.set('No Model')
        self.mdx_only_ensem_d_var.set('No Model')
        self.mdx_only_ensem_e_var.set('No Model')  
        self.mdxnetModel_var.set('UVR-MDX-NET Main')        
        self.mdxnetModeltype_var.set('Vocals (Custom)')
        self.mixing_var.set('Default')
        self.modelFolder_var.set(False)
        self.instrumentalModel_var.set('')
        self.ModelParams_var.set('Auto')           
        self.mp3bit_var.set('320k')
        self.n_fft_scale_var.set(6144)
        self.noise_pro_select_var.set('Auto Select')
        self.noisereduc_var.set(True)
        self.noisereduc_s_var.set(3)
        self.non_red_var.set(False)
        self.nophaseinst_var.set(False)
        self.normalize_var.set(False)
        self.outputImage_var.set(False)
        self.overlap_var.set(0.25)
        self.overlap_b_var.set(0.25)
        self.postprocessing_var.set(False)
        self.save_var.set(True)
        self.saveFormat_var.set('Wav')
        self.segment_var.set(None)
        self.settest_var.set(False)
        self.shifts_var.set(2)
        self.shifts_b_var.set(2)
        self.split_mode_var.set(True)
        self.tta_var.set(False)
        self.voc_only_var.set(False)
        self.voc_only_b_var.set(False)
        self.vrensemchoose_var.set('2_HP-UVR')
        self.vrensemchoose_a_var.set('1_HP-UVR')
        self.vrensemchoose_b_var.set('2_HP-UVR')
        self.vrensemchoose_c_var.set('No Model')
        self.vrensemchoose_d_var.set('No Model')
        self.vrensemchoose_e_var.set('No Model')    
        self.vrensemchoose_mdx_a_var.set('No Model')
        self.vrensemchoose_mdx_b_var.set('No Model')
        self.vrensemchoose_mdx_c_var.set('No Model')
        self.vr_multi_USER_model_param_1.set('Auto')
        self.vr_multi_USER_model_param_2.set('Auto')
        self.vr_multi_USER_model_param_3.set('Auto')
        self.vr_multi_USER_model_param_4.set('Auto')
        self.vr_basic_USER_model_param_1.set('Auto')
        self.vr_basic_USER_model_param_2.set('Auto')
        self.vr_basic_USER_model_param_3.set('Auto')
        self.vr_basic_USER_model_param_4.set('Auto')
        self.vr_basic_USER_model_param_5.set('Auto')
        self.wavtype_var.set('PCM_16')
        self.winSize_var.set('512')
        
    
            
    def advanced_vr_options(self):
        """
        Open Advanced VR Options
        """     
           
        top=Toplevel(self)

        window_height = 630
        window_width = 500
        
        top.title("Advanced VR Options")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))
        
        top.attributes("-topmost", True)

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')

        def close_win():
            top.destroy()
            self.settings()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)
        tab2 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Advanced Settings')
        tabControl.add(tab2, text ='Demucs Settings')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)
        tab2.grid_rowconfigure(0, weight=1)
        tab2.grid_columnconfigure(0, weight=1)

        frame0=Frame(tab1, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0,text="Advanced VR Options",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=0,pady=10)
        
        l0=tk.Label(frame0, text='Window Size (Set Manually)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.winSize_var, justify="center")
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Aggression Setting (Set Manually)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.agg_var, justify="center")
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Select Model Param\n(Can\'t change Model Params in Ensemble Mode)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=10)
        
        self.options_ModelParams_Optionmenu = l0=ttk.OptionMenu(frame0, self.ModelParams_var)  
        
        self.options_ModelParams_Optionmenu
        l0.grid(row=7,column=0,padx=0,pady=0) 
        
        l0=ttk.Checkbutton(frame0, text='Save Output Image(s) of Spectrogram(s)', variable=self.outputImage_var) 
        l0.grid(row=8,column=0,padx=0,pady=0)

        l0=ttk.Checkbutton(frame0, text='Demucs Model', variable=self.demucsmodelVR_var) 
        l0.grid(row=9,column=0,padx=0,pady=0)
        
        def clear_cache():
            cachedir = "lib_v5/filelists/model_cache/vr_param_cache"

            for basename in os.listdir(cachedir):
                if basename.endswith('.txt'):
                    pathname = os.path.join(cachedir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        
        l0=ttk.Button(frame0,text='Clear Auto-Set Cache', command=clear_cache)
        l0.grid(row=10,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Open VR Models Folder', command=self.open_Modelfolder_vr)
        l0.grid(row=11,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Back to Main Menu', command=close_win)
        l0.grid(row=12,column=0,padx=0,pady=5)
        
        def close_win_self():
            top.destroy()
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win_self)
        l0.grid(row=13,column=0,padx=0,pady=5)
        
        self.ModelParamsLabel_to_path = defaultdict(lambda: '')
        self.lastModelParams = []
        
        frame0=Frame(tab2, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0,text='Demucs Model',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=5)
        
        l0=ttk.OptionMenu(frame0, self.demucsmodel_sel_VR_var, None, 'UVR_Demucs_Model_1', 'UVR_Demucs_Model_2', 'UVR_Demucs_Model_Bag')
        l0.grid(row=2,column=0,padx=0,pady=5) 
        
        l0=tk.Label(frame0, text='Shifts\n(Higher values use more resources and increase processing times)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=5)
        
        l0=ttk.Entry(frame0, textvariable=self.shifts_var, justify='center')
        l0.grid(row=4,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0, text='Overlap', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=5)
        
        l0=ttk.Entry(frame0, textvariable=self.overlap_var, justify='center')
        l0.grid(row=6,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0, text='Segment', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=7,column=0,padx=0,pady=5)
        
        l0=ttk.Entry(frame0, textvariable=self.segment_var, justify='center')
        l0.grid(row=8,column=0,padx=0,pady=5)
        
        l0=ttk.Checkbutton(frame0, text='Split Mode', variable=self.split_mode_var) 
        l0.grid(row=9,column=0,padx=0,pady=5)
        
        self.update_states()
          
    def advanced_demucs_options(self):
        """
        Open Advanced Demucs Options
        """
        top= Toplevel(self)

        window_height = 750
        window_width = 500
        
        top.title("Advanced Demucs Options")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))
        
        top.attributes("-topmost", True)

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')
        
        def close_win():
            top.destroy()
            self.settings()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Advanced Settings')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)

        frame0=Frame(tab1, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0,text="Advanced Demucs Options",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=0,pady=10)
        
        l0=tk.Label(frame0, text='Chunks (Set Manually)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.chunks_d_var, justify='center')
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Chunk Margin', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.margin_var, justify='center')
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Shifts\n(Higher values use more resources and increase processing times)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.shifts_b_var, justify='center')
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Overlap', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.overlap_b_var, justify='center')
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Segment', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=9,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.segment_var, justify='center')
        l0.grid(row=10,column=0,padx=0,pady=0)
        
        l0=ttk.Checkbutton(frame0, text='Save Stems to Model & Track Name Directory', variable=self.audfile_var) 
        l0.grid(row=11,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Open Demucs Model Folder', command=self.open_Modelfolder_de)
        l0.grid(row=12,column=0,padx=0,pady=0)
        
        l0=ttk.Button(frame0,text='Back to Main Menu', command=close_win)
        l0.grid(row=13,column=0,padx=0,pady=10)
        
        def close_win_self():
            top.destroy()
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win_self)
        l0.grid(row=14,column=0,padx=0,pady=0)
        
    def advanced_mdx_options(self):
        """
        Open Advanced MDX Options
        """
        top= Toplevel(self)

        window_height = 740
        window_width = 550
        
        top.title("Advanced MDX-Net Options")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))
        
        top.attributes("-topmost", True)

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')
        
        def close_win():
            top.destroy()
            self.settings()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)
        tab2 = ttk.Frame(tabControl)
        tab3 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Advanced Settings')
        tabControl.add(tab2, text ='Demucs Settings')
        tabControl.add(tab3, text ='Advanced ONNX Model Settings')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)
        tab2.grid_rowconfigure(0, weight=1)
        tab2.grid_columnconfigure(0, weight=1)
        tab3.grid_rowconfigure(0, weight=1)
        tab3.grid_columnconfigure(0, weight=1)

        frame0=Frame(tab1, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0,text="Advanced MDX-Net Options",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=0,pady=10)
        
        l0=tk.Label(frame0, text='Chunks (Set Manually)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.chunks_var, justify='center')
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Noise Reduction (Set Manually)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.noisereduc_s_var, justify='center')
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Chunk Margin', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.margin_var, justify='center')
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Volume Compensation', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        self.options_compensate = l0=ttk.Entry(frame0, textvariable=self.compensate_var, justify='center')
        
        self.options_compensate
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        l0=ttk.Checkbutton(frame0, text='Autoset Volume Compensation', variable=self.autocompensate_var) 
        l0.grid(row=9,column=0,padx=0,pady=5)
        
        l0=ttk.Checkbutton(frame0, text='Reduce Instrumental Noise Separately', variable=self.nophaseinst_var) 
        l0.grid(row=10,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Noise Profile', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=11,column=0,padx=0,pady=5)
        
        l0=ttk.OptionMenu(frame0, self.noise_pro_select_var, None, 'Auto Select', 'MDX-NET_Noise_Profile_14_kHz', 'MDX-NET_Noise_Profile_17_kHz', 'MDX-NET_Noise_Profile_Full_Band')
        l0.grid(row=12,column=0,padx=0,pady=0)
        
        l0=ttk.Button(frame0,text='Open MDX-Net Models Folder', command=self.open_newModel_filedialog)
        l0.grid(row=13,column=0,padx=0,pady=10)
        
        l0=ttk.Button(frame0,text='Back to Main Menu', command=close_win)
        l0.grid(row=14,column=0,padx=0,pady=0)
        
        def close_win_self():
            top.destroy()
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win_self)
        l0.grid(row=15,column=0,padx=0,pady=10)
        
        frame0=Frame(tab2, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0, text='Choose Demucs Model', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=0,column=0,padx=0,pady=0)
        
        l0=tk.Button(frame0, text='(Click here to add more Demucs models)', font=("Century Gothic", "8"), foreground='#13a4c9', borderwidth=0, command=self.open_Modelfolder_de)
        l0.grid(row=1,column=0,padx=0,pady=0)
        
        self.options_DemucsModel_MDX_Optionmenu = l0=ttk.OptionMenu(frame0, self.DemucsModel_MDX_var)  
        
        self.options_DemucsModel_MDX_Optionmenu
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Mixing Algorithm', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=10)
        
        l0=ttk.OptionMenu(frame0, self.mixing_var, None, 'Default', 'Min_Mag', 'Max_Mag', 'Invert_p')   
        l0.grid(row=4,column=0,padx=0,pady=0) 
        
        l0=tk.Label(frame0, text='Shifts\n(Higher values use more resources and increase processing times)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.shifts_var, justify='center')
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='Overlap', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        l0=ttk.Entry(frame0, textvariable=self.overlap_var, justify='center')
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        l0=ttk.Checkbutton(frame0, text='Split Mode', variable=self.split_mode_var) 
        l0.grid(row=9,column=0,padx=0,pady=10)
        
        self.update_states()
        
        frame0=Frame(tab3, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0, text=f'{space_small}Stem Type{space_small}', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdxnetModeltype_var, None, 'Vocals (Custom)', 'Instrumental (Custom)', 'Other (Custom)', 'Bass (Custom)', 'Drums (Custom)')
        l0.grid(row=2,column=0,padx=0,pady=10)

        l0=tk.Label(frame0, text='N_FFT Scale', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='(Manual Set)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=3,column=1,padx=0,pady=0)
        
        self.options_n_fft_scale_Opt = l0=ttk.OptionMenu(frame0, self.n_fft_scale_var, None, '4096', '6144', '7680', '8192', '16384')
        
        self.options_n_fft_scale_Opt
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        self.options_n_fft_scale_Entry = l0=ttk.Entry(frame0, textvariable=self.n_fft_scale_var, justify='center')
        
        self.options_n_fft_scale_Entry
        l0.grid(row=4,column=1,padx=0,pady=0)

        l0=tk.Label(frame0, text='Dim_f', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0, text='(Manual Set)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=1,padx=0,pady=0)
        
        self.options_dim_f_Opt = l0=ttk.OptionMenu(frame0, self.dim_f_var, None, '2048', '3072', '4096')
        
        self.options_dim_f_Opt
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        self.options_dim_f_Entry = l0=ttk.Entry(frame0, textvariable=self.dim_f_var, justify='center')
        
        self.options_dim_f_Entry
        l0.grid(row=6,column=1,padx=0,pady=0)
        
        l0=ttk.Checkbutton(frame0, text='Auto-Set', variable=self.aud_mdx_var) 
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        
        def clear_cache():
            cachedir = "lib_v5/filelists/hashes/mdx_model_cache"

            for basename in os.listdir(cachedir):
                if basename.endswith('.json'):
                    pathname = os.path.join(cachedir, basename)
                    if os.path.isfile(pathname):
                        os.remove(pathname)
        
        l0=ttk.Button(frame0, text='Clear Auto-Set Cache', command=clear_cache)
        
        l0.grid(row=8,column=0,padx=0,pady=10)
        
        self.DemucsLabel_to_path = defaultdict(lambda: '')
        self.lastmdx_demuc_ensem = []
        
        self.update_states()
        
    def custom_ensemble(self):
        """
        Open Ensemble Custom
        """
        top= Toplevel(self)

        window_height = 680
        window_width = 900
        
        top.title("Customize Ensemble")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        top.attributes("-topmost", True)
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')
        
        def close_win():
            top.destroy()
            self.settings()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)
        tab2 = ttk.Frame(tabControl)
        tab3 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Ensemble Options')
        tabControl.add(tab2, text ='More Options')
        tabControl.add(tab3, text ='VR Model Param Settings')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)
        
        tab2.grid_rowconfigure(0, weight=1)
        tab2.grid_columnconfigure(0, weight=1)
        
        tab3.grid_rowconfigure(0, weight=1)
        tab3.grid_columnconfigure(0, weight=1)
        
        mdx_demuc_en = ''
        mdx_demuc_en = lib_v5.filelist.get_mdx_demucs_en_list(mdx_demuc_en)
        mdx_demuc_en_list = mdx_demuc_en
        
        vr_en = ''
        vr_en = lib_v5.filelist.get_vr_en_list(vr_en)
        vr_en_list = vr_en

        frame0=Frame(tab1, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  

        mdx_only_ensem_a = self.mdx_only_ensem_a_var.get()
        mdx_only_ensem_b = self.mdx_only_ensem_b_var.get()
        mdx_only_ensem_c = self.mdx_only_ensem_c_var.get()
        mdx_only_ensem_d = self.mdx_only_ensem_d_var.get()
        mdx_only_ensem_e = self.mdx_only_ensem_e_var.get()
        mdxensemchoose_b = self.mdxensemchoose_b_var.get()
        mdxensemchoose = self.mdxensemchoose_var.get()
        vrensemchoose_a = self.vrensemchoose_a_var.get()
        vrensemchoose_b = self.vrensemchoose_b_var.get()
        vrensemchoose_c = self.vrensemchoose_c_var.get()
        vrensemchoose_d = self.vrensemchoose_d_var.get()
        vrensemchoose_e = self.vrensemchoose_e_var.get()
        vrensemchoose_mdx_a = self.vrensemchoose_mdx_a_var.get()
        vrensemchoose_mdx_b = self.vrensemchoose_mdx_b_var.get()
        vrensemchoose_mdx_c = self.vrensemchoose_mdx_c_var.get()
        vrensemchoose = self.vrensemchoose_var.get()

        l0=tk.Label(frame0,text="Multi-AI Ensemble Options",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=0,padx=20,pady=10)
        
        l0=tk.Label(frame0,text=f"{space_small}MDX-Net or Demucs Model 1{space_small}\n",font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdxensemchoose_var, *mdx_demuc_en_list)
        l0.grid(row=3,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nMDX-Net or Demucs Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdxensemchoose_b_var, *mdx_demuc_en_list)
        l0.grid(row=5,column=0,padx=0,pady=0)

        l0=tk.Label(frame0,text='\nVR Model 1\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_var, *vr_en_list)
        l0.grid(row=7,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_mdx_a_var, *vr_en_list)
        l0.grid(row=9,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 3\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=10,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_mdx_b_var, *vr_en_list)
        l0.grid(row=11,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 4\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=12,column=0,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_mdx_c_var, *vr_en_list)
        l0.grid(row=13,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text="Basic VR Ensemble Options",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=1,padx=20,pady=10)
        
        l0=tk.Label(frame0,text=f'{space_medium}VR Model 1{space_medium}\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=2,column=1,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_a_var, *vr_en_list)
        l0.grid(row=3,column=1,padx=0,pady=0)

        l0=tk.Label(frame0,text='\nVR Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=4,column=1,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_b_var, *vr_en_list)
        l0.grid(row=5,column=1,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 3\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=6,column=1,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_c_var, *vr_en_list)
        l0.grid(row=7,column=1,padx=0,pady=0) 
        
        l0=tk.Label(frame0,text='\nVR Model 4\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=8,column=1,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_d_var, *vr_en_list)
        l0.grid(row=9,column=1,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 5\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=10,column=1,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.vrensemchoose_e_var, *vr_en_list)
        l0.grid(row=11,column=1,padx=0,pady=0)
        
        l0=tk.Label(frame0,text="Basic MD Ensemble Options",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=2,padx=20,pady=10)
        
        l0=tk.Label(frame0,text=f'{space_small}MDX-Net or Demucs Model 1{space_small}\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=2,column=2,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdx_only_ensem_a_var, *mdx_demuc_en_list)
        l0.grid(row=3,column=2,padx=0,pady=0)

        l0=tk.Label(frame0,text='\nMDX-Net or Demucs Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=4,column=2,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdx_only_ensem_b_var, *mdx_demuc_en_list)
        l0.grid(row=5,column=2,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nMDX-Net or Demucs Model 3\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=6,column=2,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdx_only_ensem_c_var, *mdx_demuc_en_list)
        l0.grid(row=7,column=2,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nMDX-Net or Demucs Model 4\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=8,column=2,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdx_only_ensem_d_var, *mdx_demuc_en_list)
        l0.grid(row=9,column=2,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nMDX-Net or Demucs Model 5\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=10,column=2,padx=0,pady=0)
        
        l0=ttk.OptionMenu(frame0, self.mdx_only_ensem_e_var, *mdx_demuc_en_list)
        l0.grid(row=11,column=2,padx=0,pady=0)
        
        def close_win_self():
            top.destroy()
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win_self)
        l0.grid(row=13,column=1,padx=20,pady=0)
        
        l0=ttk.Button(frame0,text='Back to Main Menu', command=close_win)
        l0.grid(row=13,column=2,padx=20,pady=0)
        
        self.mdx_only_ensem_a_var.set(mdx_only_ensem_a)
        self.mdx_only_ensem_b_var.set(mdx_only_ensem_b)
        self.mdx_only_ensem_c_var.set(mdx_only_ensem_c)
        self.mdx_only_ensem_d_var.set(mdx_only_ensem_d)
        self.mdx_only_ensem_e_var.set(mdx_only_ensem_e)
        self.mdxensemchoose_b_var.set(mdxensemchoose_b)
        self.mdxensemchoose_var.set(mdxensemchoose)
        self.vrensemchoose_a_var.set(vrensemchoose_a)
        self.vrensemchoose_b_var.set(vrensemchoose_b)
        self.vrensemchoose_c_var.set(vrensemchoose_c)
        self.vrensemchoose_d_var.set(vrensemchoose_d)
        self.vrensemchoose_e_var.set(vrensemchoose_e)
        self.vrensemchoose_mdx_a_var.set(vrensemchoose_mdx_a)
        self.vrensemchoose_mdx_b_var.set(vrensemchoose_mdx_b)
        self.vrensemchoose_mdx_c_var.set(vrensemchoose_mdx_c)
        self.vrensemchoose_var.set(vrensemchoose)
        
        frame0=Frame(tab2, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  
        
        l0=tk.Label(frame0,text="Additional Options",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=1,padx=0,pady=10)
        
        l0=ttk.Checkbutton(frame0, text='Append Ensemble Name to Final Output', variable=self.appendensem_var) 
        l0.grid(row=2,column=1,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Open Models Directory', command=self.open_Modelfolder_filedialog)
        l0.grid(row=3,column=1,padx=0,pady=5)
        
        l0=tk.Label(frame0,text='Additional VR Architecture Options',font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=5,column=1,padx=0,pady=5)
        
        l0=ttk.Checkbutton(frame0, text='Post-Process', variable=self.postprocessing_var) 
        l0.grid(row=6,column=1,padx=0,pady=5)
        
        l0=ttk.Checkbutton(frame0, text='Save Output Image(s) of Spectrogram(s)', variable=self.outputImage_var) 
        l0.grid(row=7,column=1,padx=0,pady=5)
        
        l0=tk.Label(frame0,text='Additional Demucs Options',font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=8,column=1,padx=0,pady=5)
        
        l0=tk.Label(frame0, text='Shifts\n(Higher values use more resources)', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=9,column=1,padx=0,pady=5)
        
        l0=ttk.Entry(frame0, textvariable=self.shifts_var, justify='center')
        l0.grid(row=10,column=1,padx=0,pady=5)
        
        l0=tk.Label(frame0, text='Overlap', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=11,column=1,padx=0,pady=5)
        
        l0=ttk.Entry(frame0, textvariable=self.overlap_var, justify='center')
        l0.grid(row=12,column=1,padx=0,pady=5)
        
        l0=ttk.Checkbutton(frame0, text='Split Mode', variable=self.split_mode_var) 
        l0.grid(row=13,column=1,padx=0,pady=0)
        
        frame0=Frame(tab3, highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  

        def set_auto():
            self.vr_multi_USER_model_param_1.set('Auto')
            self.vr_multi_USER_model_param_2.set('Auto')
            self.vr_multi_USER_model_param_3.set('Auto')
            self.vr_multi_USER_model_param_4.set('Auto')
            self.vr_basic_USER_model_param_1.set('Auto')
            self.vr_basic_USER_model_param_2.set('Auto')
            self.vr_basic_USER_model_param_3.set('Auto')
            self.vr_basic_USER_model_param_4.set('Auto')
            self.vr_basic_USER_model_param_5.set('Auto')

        l0=tk.Label(frame0,text="Multi-AI Ensemble VR Model Params",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=0,padx=20,pady=10)

        l0=tk.Label(frame0,text='\nVR Model 1\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        self.options_ModelParams_a_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_multi_USER_model_param_1)
        
        self.options_ModelParams_a_Optionmenu
        l0.grid(row=3,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=4,column=0,padx=0,pady=0)
        
        self.options_ModelParams_b_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_multi_USER_model_param_2)
        
        self.options_ModelParams_b_Optionmenu
        l0.grid(row=5,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 3\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=6,column=0,padx=0,pady=0)
        
        self.options_ModelParams_c_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_multi_USER_model_param_3)
        
        self.options_ModelParams_c_Optionmenu
        l0.grid(row=7,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 4\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        self.options_ModelParams_d_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_multi_USER_model_param_4)
        
        self.options_ModelParams_d_Optionmenu
        l0.grid(row=9,column=0,padx=0,pady=0)
        
        l0=ttk.Button(frame0,text='Set All to Auto', command=set_auto)
        l0.grid(row=11,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text="Basic VR Ensemble Model Params",font=("Century Gothic", "11", "underline"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=1,padx=20,pady=10)
        
        l0=tk.Label(frame0,text=f'{space_medium}VR Model 1{space_medium}\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=2,column=1,padx=0,pady=0)
        
        self.options_ModelParams_1_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_basic_USER_model_param_1)
        
        self.options_ModelParams_1_Optionmenu
        l0.grid(row=3,column=1,padx=0,pady=0)

        l0=tk.Label(frame0,text='\nVR Model 2\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=4,column=1,padx=0,pady=0)
        
        self.options_ModelParams_2_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_basic_USER_model_param_2)
        
        self.options_ModelParams_2_Optionmenu
        l0.grid(row=5,column=1,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 3\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=6,column=1,padx=0,pady=0)
        
        self.options_ModelParams_3_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_basic_USER_model_param_3)
        
        self.options_ModelParams_3_Optionmenu
        l0.grid(row=7,column=1,padx=0,pady=0) 
        
        l0=tk.Label(frame0,text='\nVR Model 4\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=8,column=1,padx=0,pady=0)
        
        self.options_ModelParams_4_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_basic_USER_model_param_4)
        
        self.options_ModelParams_4_Optionmenu
        l0.grid(row=9,column=1,padx=0,pady=0)
        
        l0=tk.Label(frame0,text='\nVR Model 5\n',font=("Century Gothic", "9"), justify="center", foreground='#13a4c9')
        l0.grid(row=10,column=1,padx=0,pady=0)
        
        self.options_ModelParams_5_Optionmenu = l0=ttk.OptionMenu(frame0, self.vr_basic_USER_model_param_5)
        
        self.options_ModelParams_5_Optionmenu
        l0.grid(row=11,column=1,padx=0,pady=0)
        
        self.ModelParamsLabel_ens_to_path = defaultdict(lambda: '')
        self.lastModelParams_ens = []
        
        self.update_states()

    def help(self):
        """
        Open Help Guide
        """
        top= Toplevel(self)
        if GetSystemMetrics(1) >= 900:
            window_height = 810
            window_width = 1080
        elif GetSystemMetrics(1) <= 720:
            window_height = 640
            window_width = 930
        else:
            window_height = 670
            window_width = 930
        top.title("UVR Help Guide")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        top.attributes("-topmost", True)
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')
        
        def close_win():
            top.destroy()
            self.settings()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)
        tab2 = ttk.Frame(tabControl)
        tab3 = ttk.Frame(tabControl)
        tab4 = ttk.Frame(tabControl)
        tab5 = ttk.Frame(tabControl)
        tab6 = ttk.Frame(tabControl)
        tab7 = ttk.Frame(tabControl)
        tab8 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='General')
        tabControl.add(tab2, text ='VR Architecture')
        tabControl.add(tab3, text ='MDX-Net')
        tabControl.add(tab4, text ='Demucs v3')
        tabControl.add(tab5, text ='Ensemble Mode')
        tabControl.add(tab6, text ='Manual Ensemble')
        tabControl.add(tab7, text ='More Info')
        tabControl.add(tab8, text ='Credits')

        tabControl.pack(expand = 1, fill ="both")

        #Configure the row/col of our frame and root window to be resizable and fill all available space
        
        tab7.grid_rowconfigure(0, weight=1)
        tab7.grid_columnconfigure(0, weight=1)
        
        tab8.grid_rowconfigure(0, weight=1)
        tab8.grid_columnconfigure(0, weight=1)
        
        tk.Button(tab1, image=self.gen_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)

        tk.Button(tab2, image=self.vr_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)

        tk.Button(tab3, image=self.mdx_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)
        
        tk.Button(tab4, image=self.demucs_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)

        tk.Button(tab5, image=self.ense_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)

        tk.Button(tab6, image=self.user_ens_opt_img, borderwidth=0, command=close_win).grid(column = 0,
                                    row = 0, 
                                    padx = 87,
                                    pady = 30)

        #frame0
        frame0=Frame(tab7,highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=30)  

        if GetSystemMetrics(1) >= 900:
            l0=tk.Label(frame0,text="Notes",font=("Century Gothic", "16", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=1,column=0,padx=20,pady=10)

            l0=tk.Label(frame0,text="UVR is 100% free and open-source but MIT licensed.\nAll the models provided as part of UVR were trained by its core developers.\nPlease credit the core UVR developers if you choose to use any of our models or code for projects unrelated to UVR.",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=2,column=0,padx=10,pady=7)
            
            l0=tk.Label(frame0,text="Resources",font=("Century Gothic", "16", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=3,column=0,padx=20,pady=7, sticky=N)
            
            link = Label(frame0, text="Ultimate Vocal Remover (Official GitHub)",font=("Century Gothic", "14", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=4,column=0,padx=10,pady=7)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/Anjok07/ultimatevocalremovergui"))
            
            l0=tk.Label(frame0,text="You can find updates, report issues, and give us a shout via our official GitHub.",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=5,column=0,padx=10,pady=7)
            
            link = Label(frame0, text="SoX - Sound eXchange",font=("Century Gothic", "14", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=6,column=0,padx=10,pady=7)
            link.bind("<Button-1>", lambda e:
            callback("https://sourceforge.net/projects/sox/files/sox/14.4.2/sox-14.4.2-win32.zip/download"))
            
            l0=tk.Label(frame0,text="UVR relies on SoX for Noise Reduction. It's automatically included via the UVR installer but not the developer build.\nIf you are missing SoX, please download it via the link and extract the SoX archive to the following directory - lib_v5/sox",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=7,column=0,padx=10,pady=7)
            
            link = Label(frame0, text="FFmpeg",font=("Century Gothic", "14", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=8,column=0,padx=10,pady=7)
            link.bind("<Button-1>", lambda e:
            callback("https://www.wikihow.com/Install-FFmpeg-on-Windows"))
            
            l0=tk.Label(frame0,text="UVR relies on FFmpeg for processing non-wav audio files.\nIt's automatically included via the UVR installer but not the developer build.\nIf you are missing FFmpeg, please see the installation guide via the link provided.",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=9,column=0,padx=10,pady=7)

            link = Label(frame0, text="X-Minus AI",font=("Century Gothic", "14", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=10,column=0,padx=10,pady=7)
            link.bind("<Button-1>", lambda e:
            callback("https://x-minus.pro/ai"))

            l0=tk.Label(frame0,text="Many of the models provided are also on X-Minus.\nThis resource primarily benefits users without the computing resources to run the GUI or models locally.",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=11,column=0,padx=10,pady=7)
            
            link = Label(frame0, text="Official UVR Patreon",font=("Century Gothic", "14", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=12,column=0,padx=10,pady=7)
            link.bind("<Button-1>", lambda e:
            callback("https://www.patreon.com/uvr"))
            
            l0=tk.Label(frame0,text="If you wish to support and donate to this project, click the link above and become a Patreon!\nOfficial UVR Patreons will receive VIP access to additional models as well as pre-releases.",font=("Century Gothic", "13"), justify="center", fg="#F6F6F7")
            l0.grid(row=13,column=0,padx=10,pady=7)
            
            frame0=Frame(tab8,highlightbackground='red',highlightthicknes=0)
            frame0.grid(row=0,column=0,padx=0,pady=30)

            #inside frame0    
            
            l0=tk.Label(frame0,text="Core UVR Developers",font=("Century Gothic", "16", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=0,column=0,padx=20,pady=5, sticky=N)
            
            l0=tk.Label(frame0,image=self.credits_img,font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=1,column=0,padx=10,pady=5)

            l0=tk.Label(frame0,text="Anjok07\nAufr33",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=2,column=0,padx=10,pady=5)

            l0=tk.Label(frame0,text="Special Thanks",font=("Century Gothic", "16", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=4,column=0,padx=20,pady=10)

            l0=tk.Label(frame0,text="DilanBoskan",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=5,column=0,padx=10,pady=5)

            l0=tk.Label(frame0,text="Your contributions at the start of this project were essential to the success of UVR. Thank you!",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=6,column=0,padx=0,pady=0)

            link = Label(frame0, text="Tsurumeso",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=7,column=0,padx=10,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/tsurumeso/vocal-remover"))
            
            l0=tk.Label(frame0,text="Developed the original VR Architecture AI code.",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=8,column=0,padx=0,pady=0)
            
            link = Label(frame0, text="Kuielab & Woosung Choi",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=9,column=0,padx=10,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/kuielab"))
            
            l0=tk.Label(frame0,text="Developed the original MDX-Net AI code.",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=10,column=0,padx=0,pady=0)
            
            l0=tk.Label(frame0,text="Bas Curtiz",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=11,column=0,padx=10,pady=5)
            
            l0=tk.Label(frame0,text="Designed the official UVR logo, icon, banner, splash screen, and interface.",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=12,column=0,padx=0,pady=0)
            
            link = Label(frame0, text="Adefossez & Demucs",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=13,column=0,padx=10,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/facebookresearch/demucs"))
            
            l0=tk.Label(frame0,text="Core developer of Facebook's Demucs Music Source Separation.",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=14,column=0,padx=0,pady=0)
            
            l0=tk.Label(frame0,text="Audio Separation Discord Community",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=15,column=0,padx=10,pady=5)
            
            l0=tk.Label(frame0,text="Thank you for the support!",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=16,column=0,padx=0,pady=0)
            
            l0=tk.Label(frame0,text="CC Karokee & Friends Discord Community",font=("Century Gothic", "13", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=17,column=0,padx=10,pady=5)
            
            l0=tk.Label(frame0,text="Thank you for the support!",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
            l0.grid(row=18,column=0,padx=0,pady=0)
            
        else:
            l0=tk.Label(frame0,text="Notes",font=("Century Gothic", "11", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=1,column=0,padx=5,pady=5)

            l0=tk.Label(frame0,text="UVR is 100% free and open-source but MIT licensed.\nPlease credit the core UVR developers if you choose to use any of our models or code for projects unrelated to UVR.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=2,column=0,padx=5,pady=5)
            
            l0=tk.Label(frame0,text="Resources",font=("Century Gothic", "11", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=3,column=0,padx=5,pady=5, sticky=N)
            
            link = Label(frame0, text="Ultimate Vocal Remover (Official GitHub)",font=("Century Gothic", "11", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=4,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/Anjok07/ultimatevocalremovergui"))
            
            l0=tk.Label(frame0,text="You can find updates, report issues, and give us a shout via our official GitHub.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=5,column=0,padx=5,pady=5)
            
            link = Label(frame0, text="SoX - Sound eXchange",font=("Century Gothic", "11", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=6,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://sourceforge.net/projects/sox/files/sox/14.4.2/sox-14.4.2-win32.zip/download"))
            
            l0=tk.Label(frame0,text="UVR relies on SoX for Noise Reduction. It's automatically included via the UVR installer but not the developer build.\nIf you are missing SoX, please download it via the link and extract the SoX archive to the following directory - lib_v5/sox",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=7,column=0,padx=5,pady=5)
            
            link = Label(frame0, text="FFmpeg",font=("Century Gothic", "11", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=8,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://www.wikihow.com/Install-FFmpeg-on-Windows"))
            
            l0=tk.Label(frame0,text="UVR relies on FFmpeg for processing non-wav audio files.\nIf you are missing FFmpeg, please see the installation guide via the link provided.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=9,column=0,padx=5,pady=5)

            link = Label(frame0, text="X-Minus AI",font=("Century Gothic", "11", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=10,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://x-minus.pro/ai"))

            l0=tk.Label(frame0,text="Many of the models provided are also on X-Minus.\nThis resource primarily benefits users without the computing resources to run the GUI or models locally.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=11,column=0,padx=5,pady=5)
            
            link = Label(frame0, text="Official UVR Patreon",font=("Century Gothic", "11", "underline"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=12,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://www.patreon.com/uvr"))
            
            l0=tk.Label(frame0,text="If you wish to support and donate to this project, click the link above and become a Patreon!",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=13,column=0,padx=5,pady=5)
            
            frame0=Frame(tab8,highlightbackground='red',highlightthicknes=0)
            frame0.grid(row=0,column=0,padx=0,pady=30)

            #inside frame0    
            
            l0=tk.Label(frame0,text="Core UVR Developers",font=("Century Gothic", "12", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=0,column=0,padx=20,pady=5, sticky=N)
            
            l0=tk.Label(frame0,image=self.credits_img,font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=1,column=0,padx=5,pady=5)

            l0=tk.Label(frame0,text="Anjok07\nAufr33",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=2,column=0,padx=5,pady=5)

            l0=tk.Label(frame0,text="Special Thanks",font=("Century Gothic", "10", "bold"), justify="center", fg="#f4f4f4")
            l0.grid(row=4,column=0,padx=20,pady=10)

            l0=tk.Label(frame0,text="DilanBoskan",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=5,column=0,padx=5,pady=5)

            l0=tk.Label(frame0,text="Your contributions at the start of this project were essential to the success of UVR. Thank you!",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=6,column=0,padx=0,pady=0)

            link = Label(frame0, text="Tsurumeso",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=7,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/tsurumeso/vocal-remover"))
            
            l0=tk.Label(frame0,text="Developed the original VR Architecture AI code.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=8,column=0,padx=0,pady=0)
            
            link = Label(frame0, text="Kuielab & Woosung Choi",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=9,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/kuielab"))
            
            l0=tk.Label(frame0,text="Developed the original MDX-Net AI code.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=10,column=0,padx=0,pady=0)
            
            l0=tk.Label(frame0,text="Bas Curtiz",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=11,column=0,padx=5,pady=5)
            
            l0=tk.Label(frame0,text="Designed the official UVR logo, icon, banner, splash screen, and interface.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=12,column=0,padx=0,pady=0)
            
            link = Label(frame0, text="Adefossez & Demucs",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9", cursor="hand2")
            link.grid(row=13,column=0,padx=5,pady=5)
            link.bind("<Button-1>", lambda e:
            callback("https://github.com/facebookresearch/demucs"))
            
            l0=tk.Label(frame0,text="Core developer of Facebook's Demucs Music Source Separation.",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=14,column=0,padx=0,pady=0)
            
            l0=tk.Label(frame0,text="Audio Separation and CC Karokee & Friends Discord Communities",font=("Century Gothic", "11", "bold"), justify="center", fg="#13a4c9")
            l0.grid(row=15,column=0,padx=5,pady=5)
            
            l0=tk.Label(frame0,text="Thank you for the support!",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
            l0.grid(row=16,column=0,padx=0,pady=0)   
            
    def settings(self, choose=False):
        """
        Open Settings
        """
        
        self.delete_temps()

        update_var = tk.StringVar(value='')
        update_button_var = tk.StringVar(value='Check for Updates')
        update_set_var = tk.StringVar(value='UVR Version Current')

        top= Toplevel(self)

        window_height = 780
        window_width = 500
        
        top.title("Settings Guide")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        top.attributes("-topmost", True)
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')

        def askyesorno():
            """
            Ask to Update
            """
            
            top_dialoge= Toplevel()

            window_height = 250
            window_width = 370
            
            top_dialoge.title("Update Found")
            
            top_dialoge.resizable(False, False)  # This code helps to disable windows from resizing
            
            top_dialoge.lift()
            
            top_dialoge.attributes("-topmost", True)
            
            top.attributes("-topmost", False)
            
            screen_width = top_dialoge.winfo_screenwidth()
            screen_height = top_dialoge.winfo_screenheight()

            x_cordinate = int((screen_width/2) - (window_width/2))
            y_cordinate = int((screen_height/2) - (window_height/2))

            top_dialoge.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

            # change title bar icon
            top_dialoge.iconbitmap('img\\UVR-Icon-v2.ico')
            
            tabControl = ttk.Notebook(top_dialoge)
            
            tabControl.pack(expand = 1, fill ="both")
            
            tabControl.grid_rowconfigure(0, weight=1)
            tabControl.grid_columnconfigure(0, weight=1)
            
            def no():
                top.attributes("-topmost", True)
                top_dialoge.destroy()
                
            def yes():
                download_update()
                top.attributes("-topmost", True)
                top_dialoge.destroy()
            
            frame0=Frame(tabControl,highlightbackground='red',highlightthicknes=0)
            frame0.grid(row=0,column=0,padx=0,pady=0)  
            
            l0=tk.Label(frame0, text='Update Found', font=("Century Gothic", "13", "underline"), foreground='#13a4c9')
            l0.grid(row=0,column=0,padx=0,pady=10)
            
            l0=tk.Label(frame0, text='Are you sure you want to continue?\n\nThe application will need to be restarted.\n', font=("Century Gothic", "11"), foreground='#13a4c9')
            l0.grid(row=1,column=0,padx=0,pady=5)
                    
            l0=ttk.Button(frame0, text='Yes', command=yes)

            l0.grid(row=2,column=0,padx=0,pady=5)

            l0=ttk.Button(frame0, text='No', command=no)

            l0.grid(row=3,column=0,padx=0,pady=5)

        def change_event():
            self.delete_temps()
            try:
                stop_thread()
            except:
                pass
            try:
                top_code.destroy()
            except:
                pass
            top.destroy()
        
        def close_win_custom_ensemble():
            change_event()
            self.custom_ensemble()
            
        def close_win_advanced_mdx_options():
            change_event()
            self.advanced_mdx_options()
            
        def close_win_advanced_demucs_options():
            change_event()
            self.advanced_demucs_options()
            
        def close_win_advanced_vr_options():
            change_event()
            self.advanced_vr_options()
            
        def close_win_error_log():
            change_event()
            self.error_log()
            
        def close_win_help():
            change_event()
            self.help()
            
        def close_win():
            change_event()

        def restart():
            top.destroy()
            self.restart()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)
        tab2 = ttk.Frame(tabControl)
        tab3 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Settings Guide')
        tabControl.add(tab2, text ='Audio Format Settings')
        tabControl.add(tab3, text ='Download Center')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)
        
        tab2.grid_rowconfigure(0, weight=1)
        tab2.grid_columnconfigure(0, weight=1)
        
        tab3.grid_rowconfigure(0, weight=1)
        tab3.grid_columnconfigure(0, weight=1)

        if choose:
            tabControl.select(tab3)

        frame0=Frame(tab1,highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=0)  
        
        l0=tk.Label(frame0,text="Main Menu",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=0,pady=10)
        
        l0=ttk.Button(frame0,text="Ensemble Customization Options", command=close_win_custom_ensemble)
        l0.grid(row=1,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text="Advanced MDX-Net Options", command=close_win_advanced_mdx_options)
        l0.grid(row=2,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text="Advanced Demucs Options", command=close_win_advanced_demucs_options)
        l0.grid(row=3,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text="Advanced VR Options", command=close_win_advanced_vr_options)
        l0.grid(row=4,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text="Open Help Guide", command=close_win_help)
        l0.grid(row=5,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Open Error Log', command=close_win_error_log)
        l0.grid(row=6,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0,text=f"Additional Options",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        l0=ttk.Checkbutton(frame0, text='Settings Test Mode', variable=self.settest_var) 
        l0.grid(row=8,column=0,padx=0,pady=0)
        
        l0=ttk.Button(frame0,text='Reset All Settings to Default', command=self.reset_to_defaults)
        l0.grid(row=9,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Open Application Directory', command=self.open_appdir_filedialog)
        l0.grid(row=10,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Restart Application', command=restart)
        l0.grid(row=11,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win)
        l0.grid(row=12,column=0,padx=0,pady=5)
        
        def start_target_update():
            def target_update():
                update_var.set(' Loading version information... ')
                update_signal_url = "https://raw.githubusercontent.com/TRvlvr/application_data/main/update_patches.txt"
                url = update_signal_url
                try:
                    file = urllib.request.urlopen(url)
                    for line in file:
                        patch_name = line.decode("utf-8")
                        if patch_name == current_version:
                            update_var.set(' UVR Version Current ')
                            update_button_var.set('Check for Updates')
                        else:
                            label_set_a = f" Update Found: {patch_name} "
                            update_var.set(str(label_set_a))
                            update_button_var.set('Click Here to Update')
                except:
                        update_var.set(' Version Status: No Internet Connection ') 
            rlg = KThread(target=target_update)
            rlg.start()

        start_target_update()

        l0=tk.Label(frame0,text="Application Updates",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=13,column=0,padx=0,pady=10)
        
        def start_check_updates():
            def check_updates():
                try:
                    url = "https://raw.githubusercontent.com/TRvlvr/application_data/main/update_patches.txt"
                    file = urllib.request.urlopen(url)
                    for line in file:
                        patch_name = line.decode("utf-8")
                        if patch_name == current_version:
                            update_var.set(' UVR Version Current ')
                            update_button_var.set('Check for Updates')
                        else:
                            label_set = f"Update Found: {patch_name}"
                            update_button_var.set('Click Here to Update')
                            update_var.set(str(label_set))
                            update_set_var.set(str(label_set))
                            askyesorno()
                except:
                        update_var.set(' Version Status: No Internet Connection ') 

            rlg = KThread(target=check_updates)
            rlg.start()
        
        def open_bmac_m():
            top.attributes("-topmost", False)
            callback("https://www.buymeacoffee.com/uvr5")  
        
        l0=ttk.Button(frame0,text=update_button_var.get(), command=start_check_updates)
        l0.grid(row=14,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0,textvariable=update_var,font=("Century Gothic", "12"), justify="center", relief="ridge", fg="#13a4c9")
        l0.grid(row=15,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0, image=self.donate_img, command=open_bmac_m)
        l0.grid(row=16,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0,text=f"{space_small}{space_small}{space_small}{space_small}",font=("Century Gothic", "13"), justify="center", relief="flat", fg="#13a4c9")
        l0.grid(row=17,column=0,padx=0,pady=0)
        
        frame0=Frame(tab2,highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=0)  
        
        l0=tk.Label(frame0,text="Audio Format Settings",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=0,pady=10)
        
        l0=tk.Label(frame0, text='Wav Type', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=10)
        
        l0=ttk.OptionMenu(frame0, self.wavtype_var, None, 'PCM_U8', 'PCM_16', 'PCM_24', 'PCM_32', '32-bit Float', '64-bit Float')
        l0.grid(row=2,column=0,padx=20,pady=0)
        
        l0=tk.Label(frame0, text='Mp3 Bitrate', font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=5,column=0,padx=0,pady=10)
        
        l0=ttk.OptionMenu(frame0, self.mp3bit_var, None, '96k', '128k', '160k', '224k', '256k', '320k')
        l0.grid(row=6,column=0,padx=20,pady=0)
        
        l0=ttk.Checkbutton(frame0, text='Normalize Outputs\n(Prevents clipping)', variable=self.normalize_var) 
        l0.grid(row=7,column=0,padx=0,pady=10)
        
        frame0=Frame(tab3,highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=0)  
        
        l0=tk.Label(frame0,text="Application Download Center",font=("Century Gothic", "13", "underline"), justify="center", fg="#13a4c9")
        l0.grid(row=0,column=0,padx=20,pady=10)
        
        def user_code():
            """
            Input Code
            """
            
            okVar = tk.IntVar()
            
            try:
                with open(user_code_file, "r") as f:
                    code_read = f.read()
                user_code_var = tk.StringVar(value=code_read)
            except:
                user_code_var = tk.StringVar(value='')
                
            try:
                with open(download_code_file, "r") as f:
                    code_download_read = f.read()
                user_code_download_var = tk.StringVar(value=code_download_read)
            except:
                user_code_download_var = tk.StringVar(value='')
            
            global top_code
            
            top_code= Toplevel()

            window_height = 480
            window_width = 320
            
            top_code.title("User Download Codes")
            
            top_code.resizable(False, False)  # This code helps to disable windows from resizing
            
            top_code.attributes("-topmost", True)
            
            top.attributes("-topmost", False)
            
            screen_width = top_code.winfo_screenwidth()
            screen_height = top_code.winfo_screenheight()

            x_cordinate = int((screen_width/2) - (window_width/2))
            y_cordinate = int((screen_height/2) - (window_height/2))

            top_code.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

            # change title bar icon
            top_code.iconbitmap('img\\UVR-Icon-v2.ico')
            
            tabControl = ttk.Notebook(top_code)
            
            tabControl.pack(expand = 1, fill ="both")
            
            tabControl.grid_rowconfigure(0, weight=1)
            tabControl.grid_columnconfigure(0, weight=1)
            
            frame0=Frame(tabControl,highlightbackground='red',highlightthicknes=0)
            frame0.grid(row=0,column=0,padx=0,pady=0)  
            
            def write_code():
                with open(user_code_file, 'w') as f:
                    user_type_code = user_code_var.get()
                    f.write(str(user_type_code))
                with open(download_code_file, 'w') as f:
                    user_download_code = user_code_download_var.get()
                    f.write(str(user_download_code))
                    top_code.destroy()
                    if user_type_code == 'VIP':
                        refresh_list_vip()
                    elif user_type_code == 'Developer':
                        refresh_list_dev()
                    else:
                        refresh_list()
            
            def open_patreon():
                top_code.attributes("-topmost", False)
                callback("https://www.patreon.com/uvr") 
                
            def open_bmac():
                top_code.attributes("-topmost", False)
                callback("https://www.buymeacoffee.com/uvr5")  
                         
            def quit():
                top.attributes("-topmost", True)
                top_code.destroy()
            
            l0=tk.Label(frame0, text=f'User Download Codes', font=("Century Gothic", "11", "underline"), foreground='#13a4c9')
            l0.grid(row=0,column=0,padx=0,pady=5)    
            
            l0=tk.Label(frame0, text=f'{space_medium}User Code{space_medium}', font=("Century Gothic", "9"), foreground='#13a4c9')
            l0.grid(row=1,column=0,padx=0,pady=5)       
                    
            l0=ttk.Entry(frame0, textvariable=user_code_var, justify='center')

            l0.grid(row=2,column=0,padx=0,pady=5)
            
            l0=tk.Label(frame0, text=f'Download Code', font=("Century Gothic", "9"), foreground='#13a4c9')
            l0.grid(row=3,column=0,padx=0,pady=5)       
                    
            l0=ttk.Entry(frame0, textvariable=user_code_download_var, justify='center')

            l0.grid(row=4,column=0,padx=0,pady=5)

            l0=ttk.Button(frame0, text='Confirm', command=write_code)

            l0.grid(row=5,column=0,padx=0,pady=5)
            
            l0=ttk.Button(frame0, text='Cancel', command=quit)

            l0.grid(row=6,column=0,padx=0,pady=5)
            
            l0=tk.Label(frame0, text=f'Support UVR', font=("Century Gothic", "11", "underline"), foreground='#13a4c9')
            l0.grid(row=7,column=0,padx=0,pady=5)    
            
            l0=tk.Label(frame0, text=f'Obtain codes by making a one-time donation\n via \"Buy Me a Coffee\" or by becoming a Patreon.\nClick one of the buttons below to donate or pledge!', font=("Century Gothic", "8"), foreground='#13a4c9')
            l0.grid(row=8,column=0,padx=0,pady=5)
            
            l0=ttk.Button(frame0, text='UVR Patreon Link', command=open_patreon)

            l0.grid(row=9,column=0,padx=0,pady=5)
            
            l0=ttk.Button(frame0, text='UVR \"Buy Me a Coffee\" Link', command=open_bmac)

            l0.grid(row=10,column=0,padx=0,pady=5)
            
        def download_code():
            """
            Input Download Code
            """
                
            try:
                with open(download_code_file, "r") as f:
                    code_download_read = f.read()
                user_code_download_var = tk.StringVar(value=code_download_read)
            except:
                user_code_download_var = tk.StringVar(value='')
            
            top_code= Toplevel()

            window_height = 300
            window_width = 410
            
            top_code.title("Invalid Download Code")
            
            top_code.resizable(False, False)  # This code helps to disable windows from resizing
            
            top_code.attributes("-topmost", True)
            
            top.attributes("-topmost", False)
            
            screen_width = top_code.winfo_screenwidth()
            screen_height = top_code.winfo_screenheight()

            x_cordinate = int((screen_width/2) - (window_width/2))
            y_cordinate = int((screen_height/2) - (window_height/2))

            top_code.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

            # change title bar icon
            top_code.iconbitmap('img\\UVR-Icon-v2.ico')
            
            tabControl = ttk.Notebook(top_code)
            
            tabControl.pack(expand = 1, fill ="both")
            
            tabControl.grid_rowconfigure(0, weight=1)
            tabControl.grid_columnconfigure(0, weight=1)
            
            frame0=Frame(tabControl,highlightbackground='red',highlightthicknes=0)
            frame0.grid(row=0,column=0,padx=0,pady=0)  
            
            def write_code_p():
                with open(download_code_file, 'w') as f:
                    user_download_code = user_code_download_var.get()
                    f.write(str(user_download_code))
                    download_model()
                    top_code.destroy()
                    
            def quit():
                top.attributes("-topmost", True)
                top_code.destroy()
            
            l0=tk.Label(frame0, text=f'Invalid Download Code', font=("Century Gothic", "11", "underline"), foreground='#13a4c9')
            l0.grid(row=0,column=0,padx=0,pady=10)    
            
            l0=tk.Label(frame0, text=f'Provide the correct code below or make another selection.\n', font=("Century Gothic", "10"), foreground='#13a4c9')
            l0.grid(row=1,column=0,padx=0,pady=0)    
            
            l0=tk.Label(frame0, text=f'Download Code', font=("Century Gothic", "9"), foreground='#13a4c9')
            l0.grid(row=2,column=0,padx=0,pady=5)       
                    
            l0=ttk.Entry(frame0, textvariable=user_code_download_var, justify='center')

            l0.grid(row=3,column=0,padx=0,pady=5)

            l0=ttk.Button(frame0, text='Confirm', command=write_code_p)

            l0.grid(row=4,column=0,padx=0,pady=5)
            
            l0=ttk.Button(frame0, text='Cancel', command=quit)

            l0.grid(row=5,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0, text=f"{space_fill_wide}Select Download{space_fill_wide}", font=("Century Gothic", "9"), foreground='#13a4c9')
        l0.grid(row=1,column=0,padx=0,pady=10)
        
        def download_progress_bar(current, total, width=80):

            progress = ('%s' % (100 * current // total))

            self.download_progress_bar_zip_var.set(int(progress))

            self.download_progress_var.set(progress + ' %')

        def change_state_complete():
            download_button.configure(state=tk.NORMAL)
            self.downloadmodelOptions.configure(state=tk.NORMAL)
            self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
            stop_button.configure(state=tk.DISABLED)
            self.download_stop_var.set(space_small)
            self.download_progress_bar_var.set('Download Complete') 
            self.delete_temps()
            
        def change_state_locked():
            download_button.configure(state=tk.NORMAL)
            self.downloadmodelOptions.configure(state=tk.NORMAL)
            self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
            stop_button.configure(state=tk.DISABLED)
            self.download_stop_var.set(space_small)
            self.download_progress_bar_var.set('Invalid Download Code')
            self.delete_temps()

            
        def change_state_already_found():
            download_button.configure(state=tk.NORMAL)
            self.downloadmodelOptions.configure(state=tk.NORMAL)
            self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
            stop_button.configure(state=tk.DISABLED)
            self.download_stop_var.set(space_small)
            self.download_progress_bar_var.set('Download Stopped') 
            self.delete_temps()
            
        def change_state_failed():
            download_button.configure(state=tk.NORMAL)
            self.downloadmodelOptions.configure(state=tk.NORMAL)
            self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
            stop_button.configure(state=tk.DISABLED)
            self.download_stop_var.set(space_small)
            self.download_progress_bar_var.set('Download Failed')
            self.delete_temps()

        def download_model():
            self.delete_temps()
            
            def begin_download_model():
                
                if not self.modeldownload_var.get() == 'No Model Selected':
                    model = self.modeldownload_var.get()
                    self.download_progress_bar_var.set('Downloading...')
                elif not self.modeldownload_mdx_var.get() == 'No Model Selected':
                    model = self.modeldownload_mdx_var.get()
                    self.download_progress_bar_var.set('Downloading...')
                elif not self.modeldownload_demucs_var.get() == 'No Model Selected':
                    model = self.modeldownload_demucs_var.get()
                    self.download_progress_bar_var.set('Downloading...')
                elif not update_set_var.get() == 'UVR Version Current':
                    model = update_set_var.get()
                    self.download_progress_bar_var.set('Downloading Update...')
                else:
                    self.download_progress_bar_var.set('No Model Selected')
                    
                    return
                   
                self.downloadmodelOptions.configure(state=tk.DISABLED)
                self.downloadmodelOptions_mdx.configure(state=tk.DISABLED)
                self.downloadmodelOptions_demucs.configure(state=tk.DISABLED)
                download_button.configure(state=tk.DISABLED)
                stop_button.configure(state=tk.NORMAL)
                self.download_stop_var.set('Stop Download')
                
                if model == 'Demucs v3: mdx':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v3: mdx')
                        
                        url_1 = links[0]
                        url_2 = links[1]
                        url_3 = links[2]
                        url_4 = links[3]
                        url_5 = links[4]
                        self.download_progress_bar_var.set('Downloading Model 1/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/0d19c1c6-0f06f20e.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_1, 'models/Demucs_Models/v3_repo/0d19c1c6-0f06f20e.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 2/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/7ecf8ec1-70f50cc9.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_2, 'models/Demucs_Models/v3_repo/7ecf8ec1-70f50cc9.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 3/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/c511e2ab-fe698775.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/v3_repo/c511e2ab-fe698775.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 4/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/7d865c68-3d5dd56b.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/v3_repo/7d865c68-3d5dd56b.th', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/v3_repo/mdx.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/v3_repo/mdx.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/mdx.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/mdx.yaml', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                if model == 'Demucs v3: mdx_q':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v3: mdx_q')
                        
                        url_1 = links[0]
                        url_2 = links[1]
                        url_3 = links[2]
                        url_4 = links[3]
                        url_5 = links[4]
                        self.download_progress_bar_var.set('Downloading Model 1/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/6b9c2ca1-3fd82607.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_1, 'models/Demucs_Models/v3_repo/6b9c2ca1-3fd82607.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 2/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/b72baf4e-8778635e.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_2, 'models/Demucs_Models/v3_repo/b72baf4e-8778635e.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 3/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/42e558d4-196e0e1b.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/v3_repo/42e558d4-196e0e1b.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 4/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/305bc58f-18378783.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/v3_repo/305bc58f-18378783.th', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/v3_repo/mdx_q.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/v3_repo/mdx_q.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/mdx_q.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/mdx_q.yaml', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                            
                            
                if model == 'Demucs v3: mdx_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v3: mdx_extra')
                        
                        url_1 = links[0]
                        url_2 = links[1]
                        url_3 = links[2]
                        url_4 = links[3]
                        url_5 = links[4]
                        self.download_progress_bar_var.set('Downloading Model 1/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/e51eebcc-c1b80bdd.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_1, 'models/Demucs_Models/v3_repo/e51eebcc-c1b80bdd.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 2/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/a1d90b5c-ae9d2452.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_2, 'models/Demucs_Models/v3_repo/a1d90b5c-ae9d2452.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 3/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/5d2d6c55-db83574e.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/v3_repo/5d2d6c55-db83574e.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 4/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/cfa93e08-61801ae1.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/v3_repo/cfa93e08-61801ae1.th', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/v3_repo/mdx_extra.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/v3_repo/mdx_extra.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/mdx_extra.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/mdx_extra.yaml', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v3: mdx_extra_q':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v3: mdx_extra_q')
                        
                        url_1 = links[0]
                        url_2 = links[1]
                        url_3 = links[2]
                        url_4 = links[3]
                        url_5 = links[4]
                        self.download_progress_bar_var.set('Downloading Model 1/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/83fc094f-4a16d450.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_1, 'models/Demucs_Models/v3_repo/83fc094f-4a16d450.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 2/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/464b36d7-e5a9386e.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_2, 'models/Demucs_Models/v3_repo/464b36d7-e5a9386e.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 3/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/14fc6a69-a89dd0ee.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/v3_repo/14fc6a69-a89dd0ee.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 4/4...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/7fd6ef75-a905dd85.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/v3_repo/7fd6ef75-a905dd85.th', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/v3_repo/mdx_extra_q.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/v3_repo/mdx_extra_q.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/mdx_extra_q.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/mdx_extra_q.yaml', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                
                if model == 'Demucs v3: UVR Models':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v3: UVR Models')
                        
                        url_1 = links[0]
                        url_2 = links[1]
                        url_3 = links[2]
                        url_4 = links[3]
                        url_5 = links[4]
                        self.download_progress_bar_var.set('Downloading Model 1/2...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/ebf34a2d.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_1, 'models/Demucs_Models/v3_repo/ebf34a2d.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model 2/2...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/ebf34a2db.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_2, 'models/Demucs_Models/v3_repo/ebf34a2db.th', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/UVR_Demucs_Model_1.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/v3_repo/UVR_Demucs_Model_1.yaml', bar=download_progress_bar)
                        self.download_progress_bar_var.set('Downloading Model...')
                        if os.path.isfile('models/Demucs_Models/v3_repo/UVR_Demucs_Model_2.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/v3_repo/UVR_Demucs_Model_2.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/v3_repo/UVR_Demucs_Model_Bag.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/v3_repo/UVR_Demucs_Model_Bag.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/UVR_Demucs_Model_1.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_3, 'models/Demucs_Models/UVR_Demucs_Model_1.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/UVR_Demucs_Model_2.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_4, 'models/Demucs_Models/UVR_Demucs_Model_2.yaml', bar=download_progress_bar)
                        if os.path.isfile('models/Demucs_Models/UVR_Demucs_Model_Bag.yaml'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url_5, 'models/Demucs_Models/UVR_Demucs_Model_Bag.yaml', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v2: demucs':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: demucs')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs-e07c671f.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs-e07c671f.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                if model == 'Demucs v2: demucs_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: demucs_extra')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs_extra-3646af93.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs_extra-3646af93.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v2: demucs48_hq':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: demucs48_hq')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs48_hq-28a1282c.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs48_hq-28a1282c.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v2: tasnet':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: tasnet')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/tasnet-beb46fac.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/tasnet-beb46fac.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v2: tasnet_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: tasnet_extra')
                        
                        url = links    
                                            
                        if os.path.isfile('models/Demucs_Models/tasnet_extra-df3777b2.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/tasnet_extra-df3777b2.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v2: demucs_unittest':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v2: demucs_unittest')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs_unittest-09ebc15f.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs_unittest-09ebc15f.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: demucs':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: demucs')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: demucs_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: demucs_extra')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/demucs_extra.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/demucs_extra.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: light':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: light')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/light.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/light.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: light_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: light_extra')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/light_extra.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/light_extra.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: tasnet':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: tasnet')
                        
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/tasnet.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/tasnet.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'Demucs v1: tasnet_extra':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='Demucs v1: tasnet_extra')
                        url = links                        
                        if os.path.isfile('models/Demucs_Models/tasnet_extra.th'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Demucs_Models/tasnet_extra.th', bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
         
                if model == 'VR Arch Model Pack v5: HP2 Models':
                    try:
                        links = []
                        links = lib_v5.filelist.get_download_links(links, downloads='model_repo')
                        url = f"{links}uvr_v5_hp2_models.zip"
                        if os.path.isfile('models/Main_Models/uvr_v5_hp2_models.zip'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Main_Models/uvr_v5_hp2_models.zip', bar=download_progress_bar)
                        with zipfile.ZipFile('models/Main_Models/uvr_v5_hp2_models.zip', 'r') as zip_ref:
                            zip_ref.extractall('models/Main_Models')
                        os.remove('models/Main_Models/uvr_v5_hp2_models.zip')
                        change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if model == 'VR Arch Model Pack v4: Main Models':
                    links = []
                    links = lib_v5.filelist.get_download_links(links, downloads='model_repo')
                    url = f"{links}uvr_v4_models.zip"
                    try:
                        if os.path.isfile('models/Main_Models/4_models.zip'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Main_Models/4_models.zip', bar=download_progress_bar)
                        with zipfile.ZipFile('models/Main_Models/4_models.zip', 'r') as zip_ref:
                            zip_ref.extractall('models/Main_Models')
                        os.remove('models/Main_Models/4_models.zip')
                        change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                if model == 'VR Arch Model Pack v5: SP Models':
                    links = []
                    links = lib_v5.filelist.get_download_links(links, downloads='model_repo')
                    url = f"{links}uvr_v5_sp_models.zip"
                    try:
                        if os.path.isfile('models/Main_Models/uvr_v5_sp_models.zip'):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, 'models/Main_Models/uvr_v5_sp_models.zip', bar=download_progress_bar)
                        with zipfile.ZipFile('models/Main_Models/uvr_v5_sp_models.zip', 'r') as zip_ref:
                            zip_ref.extractall('models/Main_Models')
                        os.remove('models/Main_Models/uvr_v5_sp_models.zip')
                        change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                if 'VR Arch Single Model v5:' in model or 'VR Arch Single Model v4:' in model:
                    
                    if 'VR Arch Single Model v5:' in model:
                        model_name = model
                        head, sep, tail = model_name.partition('VR Arch Single Model v5: ')
                        model_name = tail
                    if 'VR Arch Single Model v4:' in model:
                        model_name = model
                        head, sep, tail = model_name.partition('VR Arch Single Model v4: ')
                        model_name = tail
                    if 'VR Arch Single Model v4:' in model:
                        model_name = model
                        head, sep, tail = model_name.partition('VR Arch Single Model v4: ')
                        model_name = tail
                        
                    links = []
                    links = lib_v5.filelist.get_download_links(links, downloads='single_model_repo')
                    m_url = f"{links}{model_name}.pth"
                    url = m_url
                    
                    try:
                        if os.path.isfile(f"models/Main_Models/{model_name}.pth"):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, f"models/Main_Models/{model_name}.pth", bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                
                if 'MDX-Net Model: ' in model:
                    
                    model_name = model
                    head, sep, tail = model_name.partition('MDX-Net Model: ')
                    model_name = tail
                    links = []
                    links = lib_v5.filelist.get_download_links(links, downloads='single_model_repo')
                    m_url = f"{links}{model_name}.onnx"
                    
                    #print(m_url)
                    url = m_url
                    
                    try:
                        if os.path.isfile(f"models/MDX_Net_Models/{model_name}.onnx"):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(url, f"models/MDX_Net_Models/{model_name}.onnx", bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                            
                if 'MDX-Net Model VIP:' in model:
                    
                    model_name = model
                    head, sep, tail = model_name.partition('MDX-Net Model VIP: ')
                    model_name = tail
    
                    url_code = f"https://github.com/TRvlvr/application_data/raw/main/filelists/aes_vip/{model_name}.txt.aes"
                    
                    encrypted_file_code_vip = f"lib_v5/filelists/download_codes/temp/{model_name}.aes"
                    file_code_vip = f"lib_v5/filelists/download_codes/temp/{model_name}.txt"
                    
                    try:
                        wget.download(url_code, encrypted_file_code_vip, bar=download_progress_bar)
                        with open(download_code_file, "r") as f:
                            user_download_code_read = f.read()
                        
                        bufferSize = 128 * 1024
                        password = user_download_code_read
                        
                        try:
                            pyAesCrypt.decryptFile(encrypted_file_code_vip, file_code_vip, password, bufferSize)
                        except:
                            try:
                                url_v_key = f"https://github.com/TRvlvr/application_data/raw/main/filelists/aes_dev/vip_key.txt.aes"
                                wget.download(url_v_key, 'lib_v5/filelists/download_codes/temp/vip_key.aes', bar=download_progress_bar)
                                pyAesCrypt.decryptFile('lib_v5/filelists/download_codes/temp/vip_key.aes', 
                                                    'lib_v5/filelists/download_codes/temp/vip_key.txt', password, bufferSize)
                                
                                with open('lib_v5/filelists/download_codes/temp/vip_key.txt', "r") as f:
                                    vip_code_read = f.read()
                                
                                password = vip_code_read

                                pyAesCrypt.decryptFile(encrypted_file_code_vip, file_code_vip, password, bufferSize)
                            except:
                                download_code()
                                change_state_locked()
                                return
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                    
                    with open(file_code_vip, "r") as f:
                        link=f.read()  
                    
                    m_url = link
                    
                    try:
                        if os.path.isfile(f"models/MDX_Net_Models/{model_name}.onnx"):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(m_url, f"models/MDX_Net_Models/{model_name}.onnx", bar=download_progress_bar)
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                            
                            
                if 'Developer Pack:' in model:
                        
                    pack_name = model
                    head, sep, tail = pack_name.partition('Developer Pack: ')
                    pack_name = tail
                    
                    url_code = f"https://github.com/TRvlvr/application_data/raw/main/filelists/aes_dev/{pack_name}.txt.aes"
                    
                    #print(url_code)
                    
                    encrypted_file_code = f"lib_v5/filelists/download_codes/temp/{pack_name}.aes"
                    file_code = f"lib_v5/filelists/download_codes/temp/{pack_name}.txt"
                    
                    try:
                        wget.download(url_code, encrypted_file_code, bar=download_progress_bar)
                        with open(download_code_file, "r") as f:
                            user_download_code_read = f.read()
                        
                        bufferSize = 128 * 1024
                        password = user_download_code_read
                        # encrypt
                        
                        try:
                            pyAesCrypt.decryptFile(encrypted_file_code, file_code, password, bufferSize)
                        except:
                            download_code()
                            change_state_locked()
                            return
                        
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error) 
                    
                    with open(file_code, "r") as f:
                        link=f.read()
                        
                    m_url = link
                        
                    try:
                        if os.path.isfile(f"models/MDX_Net_Models/{pack_name}.zip"):
                                self.download_progress_var.set('File already exists')
                                change_state_already_found()
                                pass
                        else:
                                wget.download(m_url, f"models/MDX_Net_Models/{pack_name}.zip", bar=download_progress_bar)
                                with zipfile.ZipFile(f'models/MDX_Net_Models/{pack_name}.zip', 'r') as zip_ref:
                                    zip_ref.extractall('models/MDX_Net_Models')
                                try:
                                    os.remove(f'models/MDX_Net_Models/{pack_name}.zip')
                                except:
                                    pass
                                change_state_complete()
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error)            
                            
                if 'Update Found:' in model:
                    pack_name = model
                    head, sep, tail = pack_name.partition('Update Found: ')
                    pack_name = tail
                    cwd_path = os.path.dirname(os.path.realpath(__file__))
                    #print('cwd_path ', cwd_path)
                    
                    links = []
                    links = lib_v5.filelist.get_download_links(links, downloads='app_patch')
                    url_link = f"{links}{pack_name}.exe"
                    #print(url_link)
                    top.attributes("-topmost", False)
                    try:
                        if os.path.isfile(f"{cwd_path}/{pack_name}.exe"):
                                self.download_progress_var.set('File already exists')
                                subprocess.Popen(f"{cwd_path}/{pack_name}.exe")
                        else:
                            wget.download(url_link, f"{cwd_path}/{pack_name}.exe", bar=download_progress_bar)
                            subprocess.Popen(f"{cwd_path}/{pack_name}.exe")
                    except Exception as e:
                        short_error = f'{e}'
                        change_state_failed()
                        if '[Errno 11001] getaddrinfo failed' in short_error:
                            self.download_progress_var.set('No Internet Connection Detected')
                        else: 
                            self.download_progress_var.set(short_error)

                self.update_states()           
        
            global th
            
            th = KThread(target=begin_download_model)
            th.start()
    
        def stop_thread():
            th.kill()
            download_button.configure(state=tk.NORMAL)
            self.downloadmodelOptions.configure(state=tk.NORMAL)
            self.downloadmodelOptions_mdx.configure(state=tk.NORMAL)
            self.downloadmodelOptions_demucs.configure(state=tk.NORMAL)
            stop_button.configure(state=tk.DISABLED)
            self.download_stop_var.set(space_small)
            self.update_states()
            self.download_progress_bar_var.set('Download Stopped')
            self.delete_temps()
            
            
        def download_update():
            self.modeldownload_var.set('No Model Selected')
            self.modeldownload_mdx_var.set('No Model Selected')
            self.modeldownload_demucs_var.set('No Model Selected')
            tabControl.select(tab3)
            download_model()
            
        vr_download_list_file = "lib_v5/filelists/download_lists/vr_download_list.txt"
        mdx_download_list_file = "lib_v5/filelists/download_lists/mdx_download_list.txt"
        demucs_download_list_file = "lib_v5/filelists/download_lists/demucs_download_list.txt"
        
        vr_download_list_temp_file = "lib_v5/filelists/download_lists/temp/vr_download_list.txt"
        mdx_download_list_temp_file = "lib_v5/filelists/download_lists/temp/mdx_download_list.txt"
        demucs_download_list_temp_file = "lib_v5/filelists/download_lists/temp/demucs_download_list.txt"
        
        mdx_new_hashes = "lib_v5/filelists/hashes/mdx_new_hashes.txt"
        mdx_new_inst_hashes = "lib_v5/filelists/hashes/mdx_new_inst_hashes.txt"
        mdx_original_hashes = "lib_v5/filelists/hashes/mdx_original_hashes.txt"
        download_links_file = "lib_v5/filelists/download_lists/download_links.json"
        
        mdx_new_hashes_temp = "lib_v5/filelists/hashes/temp/mdx_new_hashes.txt"
        mdx_new_inst_hashes_temp = "lib_v5/filelists/hashes/temp/mdx_new_inst_hashes.txt"
        mdx_original_hashes_temp = "lib_v5/filelists/hashes/temp/mdx_original_hashes.txt"
        download_links_file_temp = "lib_v5/filelists/download_lists/temp/download_links.json"
            
        def move_lists_from_temp():
            try:
                shutil.move(vr_download_list_temp_file, vr_download_list_file)
                shutil.move(mdx_download_list_temp_file, mdx_download_list_file)
                shutil.move(demucs_download_list_temp_file, demucs_download_list_file)
                shutil.move(mdx_new_hashes_temp, mdx_new_hashes)
                shutil.move(mdx_new_inst_hashes_temp, mdx_new_inst_hashes)
                shutil.move(mdx_original_hashes_temp, mdx_original_hashes)
                shutil.move(download_links_file_temp, download_links_file)
            except:
                pass
            
        def remove_lists_temp():
            try:
                os.remove(vr_download_list_temp_file)
                os.remove(mdx_download_list_temp_file)
                os.remove(demucs_download_list_temp_file)
                os.remove(mdx_new_hashes_temp)
                os.remove(mdx_new_inst_hashes_temp)
                os.remove(mdx_original_hashes_temp)
                os.remove(download_links_file_temp)
            except:
                pass
            
        def refresh_download_list_only():
            download_links = "https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/download_links.json"
            def begin_refresh_list():
                try:
                    url_1 = download_links
                    shutil.move(download_links_file, download_links_file_temp)
                    wget.download(url_1, download_links_file, bar=download_progress_bar)
                    os.remove(download_links_file_temp)
                except Exception as e:
                    try:
                        shutil.move(download_links_file_temp, download_links_file)
                    except:
                        pass
            
            rlg = KThread(target=begin_refresh_list)
            rlg.start()
            
        def refresh_list():
            download_links = "https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/download_links.json"
            def begin_refresh_list():
                try:
                    url_1 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/gen_vr_download_list.txt'
                    url_2 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/gen_mdx_download_list.txt'
                    url_3 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/gen_demucs_download_list.txt'
                    url_4 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_hashes.txt'
                    url_5 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_inst_hashes.txt'
                    url_6 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_original_hashes.txt'
                    url_7 = download_links
                    wget.download(url_1, vr_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_2, mdx_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_3, demucs_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_4, mdx_new_hashes_temp, bar=download_progress_bar)
                    wget.download(url_5, mdx_new_inst_hashes_temp, bar=download_progress_bar)
                    wget.download(url_6, mdx_original_hashes_temp, bar=download_progress_bar)
                    wget.download(url_7, download_links_file_temp, bar=download_progress_bar)
                    move_lists_from_temp()
                    self.download_progress_bar_var.set('Download list\'s refreshed!')
                    top.destroy()
                    self.settings(choose=True)
                except Exception as e:
                    short_error = f'{e}'
                    self.download_progress_bar_var.set('Refresh failed')
                    if '[Errno 11001] getaddrinfo failed' in short_error:
                        self.download_progress_var.set('No Internet Connection Detected')
                    else: 
                        self.download_progress_var.set(short_error)
                    try:
                        remove_lists_temp()
                    except:
                        pass
            
            rlg = KThread(target=begin_refresh_list)
            rlg.start()
                
        def refresh_list_vip():
            download_links = "https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/download_links.json"
            def begin_refresh_list_vip():
                try:
                    url_1 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/vip_vr_download_list.txt'
                    url_2 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/vip_mdx_download_list.txt'
                    url_3 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/vip_demucs_download_list.txt'
                    url_4 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_hashes.txt'
                    url_5 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_inst_hashes.txt'
                    url_6 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_original_hashes.txt'
                    url_7 = download_links
                    wget.download(url_1, vr_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_2, mdx_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_3, demucs_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_4, mdx_new_hashes_temp, bar=download_progress_bar)
                    wget.download(url_5, mdx_new_inst_hashes_temp, bar=download_progress_bar)
                    wget.download(url_6, mdx_original_hashes_temp, bar=download_progress_bar)
                    wget.download(url_7, download_links_file_temp, bar=download_progress_bar)
                    move_lists_from_temp()
                    self.download_progress_bar_var.set('VIP: Download list\'s refreshed!')
                    top.destroy()
                    self.settings(choose=True)
                except Exception as e:
                    short_error = f'{e}'
                    self.download_progress_bar_var.set('Refresh failed')
                    if '[Errno 11001] getaddrinfo failed' in short_error:
                        self.download_progress_var.set('No Internet Connection Detected')
                    else: 
                        self.download_progress_var.set(short_error)
                    try:
                        remove_lists_temp()
                    except:
                        pass
            
            rlv = KThread(target=begin_refresh_list_vip)
            rlv.start()

        vr_download_list_dev = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/dev_vr_download_list.txt'
        mdx_download_list_dev = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/dev_mdx_download_list.txt'
        demucs_download_list_dev = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/dev_demucs_download_list.txt'

        def refresh_list_dev():
            download_links = "https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/download_lists/download_links.json"
            def begin_refresh_list_dev():
                try:
                    url_1 = vr_download_list_dev
                    url_2 = mdx_download_list_dev
                    url_3 = demucs_download_list_dev
                    url_4 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_hashes.txt'
                    url_5 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_new_inst_hashes.txt'
                    url_6 = 'https://raw.githubusercontent.com/TRvlvr/application_data/main/filelists/hashes/mdx_original_hashes.txt'
                    url_7 = download_links
                    wget.download(url_1, vr_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_2, mdx_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_3, demucs_download_list_temp_file, bar=download_progress_bar)
                    wget.download(url_4, mdx_new_hashes_temp, bar=download_progress_bar)
                    wget.download(url_5, mdx_new_inst_hashes_temp, bar=download_progress_bar)
                    wget.download(url_6, mdx_original_hashes_temp, bar=download_progress_bar)
                    wget.download(url_7, download_links_file_temp, bar=download_progress_bar)
                    move_lists_from_temp()
                    self.download_progress_bar_var.set('Developer: Download list\'s refreshed!')
                    top.destroy()
                    self.settings(choose=True)
                except Exception as e:
                    short_error = f'{e}'
                    self.download_progress_bar_var.set('Refresh failed')
                    if '[Errno 11001] getaddrinfo failed' in short_error:
                        self.download_progress_var.set('No Internet Connection Detected')
                    else: 
                        self.download_progress_var.set(short_error)
                    try:
                        remove_lists_temp()
                    except:
                        pass
            
            rld = KThread(target=begin_refresh_list_dev)
            rld.start()
            
        vr_list = ''
        vr_list = lib_v5.filelist.get_vr_download_list(vr_list)
        vr_download_list = vr_list
        
        mdx_list = ''
        mdx_list = lib_v5.filelist.get_mdx_download_list(mdx_list)
        mdx_download_list = mdx_list
        
        demucs_list = ''
        demucs_list = lib_v5.filelist.get_demucs_download_list(demucs_list)
        demucs_download_list = demucs_list
        
        ach_radio = l0=ttk.Radiobutton(frame0, text='VR Arch', variable=self.selectdownload_var, value='VR Arc')
        l0.grid(row=3,column=0,padx=0,pady=5)
        
        self.downloadmodelOptions = l0=ttk.OptionMenu(frame0, self.modeldownload_var, *vr_download_list)
        l0.grid(row=4,column=0,padx=0,pady=5)
        
        mdx_radio = l0=ttk.Radiobutton(frame0, text='MDX-Net', variable=self.selectdownload_var, value='MDX-Net')
        l0.grid(row=5,column=0,padx=0,pady=5)
        
        self.downloadmodelOptions_mdx = l0=ttk.OptionMenu(frame0, self.modeldownload_mdx_var, *mdx_download_list)
        l0.grid(row=6,column=0,padx=0,pady=5)
        
        demucs_radio = l0=ttk.Radiobutton(frame0, text='Demucs', variable=self.selectdownload_var, value='Demucs')
        l0.grid(row=7,column=0,padx=0,pady=5)
        
        self.downloadmodelOptions_demucs = l0=ttk.OptionMenu(frame0, self.modeldownload_demucs_var, *demucs_download_list)
        l0.grid(row=8,column=0,padx=0,pady=5)
        
        download_button = l0=ttk.Button(frame0, image=self.download_img, command=download_model)
        l0.grid(row=9,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0, textvariable=self.download_progress_bar_var, font=("Century Gothic", "9"), foreground='#13a4c9', borderwidth=0)
        l0.grid(row=10,column=0,padx=0,pady=5)
        
        l0=tk.Label(frame0, textvariable=self.download_progress_var, font=("Century Gothic", "9"), wraplength=350, foreground='#13a4c9')
        l0.grid(row=11,column=0,padx=0,pady=5)
        
        l0=ttk.Progressbar(frame0, variable=self.download_progress_bar_zip_var)
        l0.grid(row=12,column=0,padx=0,pady=5)
        
        stop_button = l0=ttk.Button(frame0, textvariable=self.download_stop_var, command=stop_thread)
        l0.grid(row=13,column=0,padx=0,pady=5)
        
        try:
            with open(user_code_file, "r") as f:
                code_read = f.read()
                if code_read == 'VIP':
                    l0=ttk.Button(frame0, text='Refresh List', command=refresh_list_vip)
                elif code_read == 'Developer':
                    l0=ttk.Button(frame0, text='Refresh List', command=refresh_list_dev)
                else:
                    code_read = 'None'
                    l0=ttk.Button(frame0, text='Refresh List', command=refresh_list)
        except:
            code_read = 'None'
            l0=ttk.Button(frame0, text='Refresh List', command=refresh_list)
            
        l0.grid(row=14,column=0,padx=0,pady=5)
        
        l0=ttk.Button(frame0, image=self.key_img, command=user_code)
        l0.grid(row=15,column=0,padx=0,pady=5)
        
        stop_button.configure(state=tk.DISABLED)
        
        if choose:
            pass
        else:
            self.download_progress_bar_var.set('')
            
        self.download_progress_var.set('')
        self.download_stop_var.set(space_small)
        
        top.protocol("WM_DELETE_WINDOW", change_event)
        
        self.update_states()      

    def error_log(self):
        """
        Open Error Log
        """
        top= Toplevel(self)
        if GetSystemMetrics(1) >= 900:
            window_height = 810
            window_width = 1080
        elif GetSystemMetrics(1) <= 720:
            window_height = 640
            window_width = 930
        else:
            window_height = 670
            window_width = 930
            
        top.title("UVR Help Guide")
        
        top.resizable(False, False)  # This code helps to disable windows from resizing
        
        top.attributes("-topmost", True)
        
        screen_width = top.winfo_screenwidth()
        screen_height = top.winfo_screenheight()

        x_cordinate = int((screen_width/2) - (window_width/2))
        y_cordinate = int((screen_height/2) - (window_height/2))

        top.geometry("{}x{}+{}+{}".format(window_width, window_height, x_cordinate, y_cordinate))

        # change title bar icon
        top.iconbitmap('img\\UVR-Icon-v2.ico')
        
        def close_win():
            top.destroy()
            self.settings()
            
        def close_win_self():
            top.destroy()

        tabControl = ttk.Notebook(top)
  
        tab1 = ttk.Frame(tabControl)

        tabControl.add(tab1, text ='Error Log')

        tabControl.pack(expand = 1, fill ="both")
        
        tab1.grid_rowconfigure(0, weight=1)
        tab1.grid_columnconfigure(0, weight=1)

        frame0=Frame(tab1,highlightbackground='red',highlightthicknes=0)
        frame0.grid(row=0,column=0,padx=0,pady=0)  
        
        l0=tk.Label(frame0,text="Error Details",font=("Century Gothic", "16", "bold"), justify="center", fg="#f4f4f4")
        l0.grid(row=1,column=0,padx=20,pady=10)
        
        l0=tk.Label(frame0,text="This tab will show the raw details of the last error received.",font=("Century Gothic", "12"), justify="center", fg="#F6F6F7")
        l0.grid(row=2,column=0,padx=0,pady=0)
        
        l0=tk.Label(frame0,text="(Click the error console below to copy the error)\n",font=("Century Gothic", "10"), justify="center", fg="#F6F6F7")
        l0.grid(row=3,column=0,padx=0,pady=0)
        
        with open("errorlog.txt", "r") as f:
            l0=Button(frame0,text=f.read(),font=("Century Gothic", "7"), command=self.copy_clip, justify="left", wraplength=1000, fg="#FF0000", bg="black", relief="sunken")
            l0.grid(row=4,column=0,padx=0,pady=0)
        
        l0=ttk.Button(frame0,text="Back to Main Menu", command=close_win)
        l0.grid(row=5,column=0,padx=20,pady=10)
        
        l0=ttk.Button(frame0,text='Close Window', command=close_win_self)
        l0.grid(row=6,column=0,padx=20,pady=0)


    def copy_clip(self):
            copy_t = open("errorlog.txt", "r").read()
            pyperclip.copy(copy_t)
            
    def copy_vr_list(self):
            copy_t = open("lib_v5/vr_download_list.txt", "r").read()
            pyperclip.copy(copy_t)
            
    def open_Modelfolder_filedialog(self):
        """Let user paste a ".pth" model to use for the vocal Separation"""
        filename = 'models'

        if sys.platform == "win32":
            os.startfile(filename)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
            
    def open_Modelfolder_vr(self):
        """Let user paste a ".pth" model to use for the vocal Separation"""
        filename = 'models\Main_Models'

        if sys.platform == "win32":
            os.startfile(filename)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
            
    def open_Modelfolder_de(self):
        """Let user paste a ".pth" model to use for the vocal Separation"""
        filename = 'models\Demucs_Models'

        if sys.platform == "win32":
            os.startfile(filename)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
            
    def open_appdir_filedialog(self):
        
        pathname = '.'
        
        if sys.platform == "win32":
            os.startfile(pathname)
        else:
            opener = "open" if sys.platform == "darwin" else "xdg-open"
            subprocess.call([opener, filename])
        
    def save_values(self):
        """
        Save the data of the application
        """
        # Get constants
        instrumental = self.instrumentalModel_var.get()
        if [bool(instrumental)].count(True) == 2: #Checkthis
            window_size = DEFAULT_DATA['window_size']
            agg = DEFAULT_DATA['agg']
            chunks = DEFAULT_DATA['chunks']
            noisereduc_s = DEFAULT_DATA['noisereduc_s']
            mixing = DEFAULT_DATA['mixing']
        else:
            window_size = self.winSize_var.get()
            agg = self.agg_var.get()
            chunks = self.chunks_var.get()
            noisereduc_s = self.noisereduc_s_var.get()
            mixing = self.mixing_var.get()

        # -Save Data-
        save_data(data={
            'agg': agg,
            'aiModel': self.aiModel_var.get(),
            'algo': self.algo_var.get(),
            'appendensem': self.appendensem_var.get(),
            'audfile': self.audfile_var.get(),
            'aud_mdx': self.aud_mdx_var.get(),
            'autocompensate': self.autocompensate_var.get(),
            'channel': self.channel_var.get(),
            'chunks': chunks,
            'chunks_d': self.chunks_d_var.get(),
            'compensate': self.compensate_var.get(),
            'demucs_only': self.demucs_only_var.get(),
            'demucs_stems': self.demucs_stems_var.get(),
            'DemucsModel': self.DemucsModel_var.get(),
            'demucsmodel': self.demucsmodel_var.get(),
            'DemucsModel_MDX': self.DemucsModel_MDX_var.get(),
            'demucsmodel_sel_VR': self.demucsmodel_sel_VR_var.get(),
            'demucsmodelVR': self.demucsmodelVR_var.get(),
            'dim_f': self.dim_f_var.get(),
            'ensChoose': self.ensChoose_var.get(),
            'exportPath': self.exportPath_var.get(),
            'flactype': self.flactype_var.get(),
            'gpu': self.gpuConversion_var.get(),
            'inputPaths': self.inputPaths,
            'inst_only': self.inst_only_var.get(),
            'inst_only_b': self.inst_only_b_var.get(),
            'lastDir': self.lastDir,
            'margin': self.margin_var.get(),
            'mdx_ensem': self.mdxensemchoose_var.get(),
            'mdx_ensem_b': self.mdxensemchoose_b_var.get(),
            'mdx_only_ensem_a': self.mdx_only_ensem_a_var.get(),
            'mdx_only_ensem_b': self.mdx_only_ensem_b_var.get(),
            'mdx_only_ensem_c': self.mdx_only_ensem_c_var.get(),
            'mdx_only_ensem_d': self.mdx_only_ensem_d_var.get(),
            'mdx_only_ensem_e': self.mdx_only_ensem_e_var.get(),
            'mdxnetModel': self.mdxnetModel_var.get(),
            'mdxnetModeltype': self.mdxnetModeltype_var.get(),
            'mixing': mixing,
            'modeldownload': 'No Model Selected',
            'modeldownload_mdx': 'No Model Selected',
            'modeldownload_demucs': 'No Model Selected',
            'modeldownload_type': 'VR Arc',
            'modelFolder': self.modelFolder_var.get(),
            'modelInstrumentalLabel': self.instrumentalModel_var.get(),
            'ModelParams': self.ModelParams_var.get(),
            'mp3bit': self.mp3bit_var.get(),
            'n_fft_scale': self.n_fft_scale_var.get(),
            'noise_pro_select': self.noise_pro_select_var.get(),
            'noise_reduc': self.noisereduc_var.get(),
            'noisereduc_s': noisereduc_s,
            'non_red': self.non_red_var.get(),
            'nophaseinst': self.nophaseinst_var.get(),
            'normalize': self.normalize_var.get(),
            'output_image': self.outputImage_var.get(),
            'overlap': self.overlap_var.get(),
            'overlap_b': self.overlap_b_var.get(),
            'postprocess': self.postprocessing_var.get(),
            'save': self.save_var.get(),
            'saveFormat': self.saveFormat_var.get(),
            'selectdownload': self.selectdownload_var.get(),
            'segment': self.segment_var.get(),
            'settest': self.settest_var.get(),
            'shifts': self.shifts_var.get(),
            'shifts_b': self.shifts_b_var.get(),
            'split_mode': self.split_mode_var.get(),
            'tta': self.tta_var.get(),
            'useModel': 'instrumental',
            'voc_only': self.voc_only_var.get(),
            'voc_only_b': self.voc_only_b_var.get(),
            'vr_ensem': self.vrensemchoose_var.get(),
            'vr_ensem_a': self.vrensemchoose_a_var.get(),
            'vr_ensem_b': self.vrensemchoose_b_var.get(),
            'vr_ensem_c': self.vrensemchoose_c_var.get(),
            'vr_ensem_d': self.vrensemchoose_d_var.get(),
            'vr_ensem_e': self.vrensemchoose_e_var.get(),
            'vr_ensem_mdx_a': self.vrensemchoose_mdx_a_var.get(),
            'vr_ensem_mdx_b': self.vrensemchoose_mdx_b_var.get(),
            'vr_ensem_mdx_c': self.vrensemchoose_mdx_c_var.get(),
            'vr_multi_USER_model_param_1': self.vr_multi_USER_model_param_1.get(),
            'vr_multi_USER_model_param_2': self.vr_multi_USER_model_param_2.get(),
            'vr_multi_USER_model_param_3': self.vr_multi_USER_model_param_3.get(),
            'vr_multi_USER_model_param_4': self.vr_multi_USER_model_param_4.get(),
            'vr_basic_USER_model_param_1': self.vr_basic_USER_model_param_1.get(),
            'vr_basic_USER_model_param_2': self.vr_basic_USER_model_param_2.get(),
            'vr_basic_USER_model_param_3': self.vr_basic_USER_model_param_3.get(),
            'vr_basic_USER_model_param_4': self.vr_basic_USER_model_param_4.get(),
            'vr_basic_USER_model_param_5': self.vr_basic_USER_model_param_5.get(),
            'wavtype': self.wavtype_var.get(),
            'window_size': window_size,
        }, 
        )
        
        self.destroy()

if __name__ == "__main__":

    root = MainWindow()

    root.tk.call(
    'wm', 
    'iconphoto', 
    root._w, 
    tk.PhotoImage(file='img\\GUI-icon.png')
    )

    lib_v5.sv_ttk.set_theme("dark")
    lib_v5.sv_ttk.use_dark_theme()  # Set dark theme

    #Define a callback function
    def callback(url):
        webbrowser.open_new_tab(url)
        
    root.mainloop()