Update app.py

app.py

@@ -2,7 +2,7 @@ import gradio as gr
 import requests
 import random
 import os
-import zipfile 
+import zipfile
 import librosa
 import time
 from infer_rvc_python import BaseLoader
@@ -12,46 +12,18 @@ import edge_tts
 import tempfile
 from audio_separator.separator import Separator
 import model_handler
-import psutil
-import cpuinfo
+import logging
+import aiohttp
+import asyncio
 
-language_dict = tts_order_voice
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
 
-async def text_to_speech_edge(text, language_code):
-    voice = language_dict[language_code]
-    communicate = edge_tts.Communicate(text, voice)
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-        tmp_path = tmp_file.name
-
-    await communicate.save(tmp_path)
-
-    return tmp_path
-
-try:
-    import spaces
-    spaces_status = True
-except ImportError:
-    spaces_status = False
-
-separator = Separator()
-converter = BaseLoader(only_cpu=False, hubert_path=None, rmvpe_path=None)
-
-global pth_file
-global index_file
-
-pth_file = "model.pth"
-index_file = "model.index"
-
-#CONFIGS
+# Constants
 TEMP_DIR = "temp"
 MODEL_PREFIX = "model"
-PITCH_ALGO_OPT = [
-    "pm",
-    "harvest",
-    "crepe",
-    "rmvpe",
-    "rmvpe+",
-]
+PITCH_ALGO_OPT = ["pm", "harvest", "crepe", "rmvpe", "rmvpe+"]
 UVR_5_MODELS = [
     {"model_name": "BS-Roformer-Viperx-1297", "checkpoint": "model_bs_roformer_ep_317_sdr_12.9755.ckpt"},
     {"model_name": "MDX23C-InstVoc HQ 2", "checkpoint": "MDX23C-8KFFT-InstVoc_HQ_2.ckpt"},
@@ -63,130 +35,78 @@ UVR_5_MODELS = [
 MODELS = [
     {"model": "model.pth", "index": "model.index", "model_name": "Test Model"},
 ]
+BAD_WORDS = ['puttana', 'whore', 'badword3', 'badword4']
+MAX_FILE_SIZE = 500_000_000  # 500 MB
 
 os.makedirs(TEMP_DIR, exist_ok=True)
 
-def unzip_file(file):
-    filename = os.path.basename(file).split(".")[0] 
-    with zipfile.ZipFile(file, 'r') as zip_ref:
-        zip_ref.extractall(os.path.join(TEMP_DIR, filename)) 
-    return True
-    
-
-def progress_bar(total, current):
-    return "[" + "=" * int(current / total * 20) + ">" + " " * (20 - int(current / total * 20)) + "] " + str(int(current / total * 100)) + "%"
-
-def contains_bad_word(text, bad_words):
-    text_lower = text.lower()
-    for word in bad_words:
-        if word.lower() in text_lower:
-            return True
-    return False
+try:
+    import spaces
+    spaces_status = True
+except ImportError:
+    spaces_status = False
+    logger.warning("Spaces module not found; running in CPU mode")
 
-bad_words = ['puttana', 'whore', 'badword3', 'badword4']
+separator = Separator()
+converter = BaseLoader(only_cpu=not spaces_status, hubert_path=None, rmvpe_path=None)
 
 class BadWordError(Exception):
-    def __init__(self, msg):
-        super().__init__(msg)
-        self.word = word
+    pass
 
-def download_from_url(url, name=None):
-    if name is None:
-        raise ValueError("The model name must be provided")
-    if "/blob/" in url:
-        url = url.replace("/blob/", "/resolve/") 
-    if "huggingface" not in url:
-        return ["The URL must be from huggingface", "Failed", "Failed"]
-    if contains_bad_word(url, bad_words):
-        return BadWordError("The file url has a bad word.")
-    if contains_bad_word(name, bad_words):
-        return BadWordError("The file name has a bad word.")
-    filename = os.path.join(TEMP_DIR, MODEL_PREFIX + str(random.randint(1, 1000)) + ".zip")
-    response = requests.get(url)
-    total = int(response.headers.get('content-length', 0)) 
-    if total > 500000000:
+async def text_to_speech_edge(text, language_code):
+    if not text.strip():
+        raise ValueError("Text input cannot be empty")
+    voice = tts_order_voice.get(language_code, tts_order_voice[list(tts_order_voice.keys())[0]])
+    communicate = edge_tts.Communicate(text, voice)
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+        tmp_path = tmp_file.name
+    await communicate.save(tmp_path)
+    return tmp_path
 
-        return ["The file is too large. You can only download files up to 500 MB in size.", "Failed", "Failed"]
-    current = 0
-    with open(filename, "wb") as f:
-        for data in response.iter_content(chunk_size=4096): 
-            f.write(data)
-            current += len(data)
-            print(progress_bar(total, current), end="\r") #
-    
+async def download_from_url(url, name, progress=gr.Progress()):
+    if not url.startswith("https://huggingface.co"):
+        raise ValueError("URL must be from Hugging Face")
+    if not name.strip():
+        raise ValueError("Model name cannot be empty")
+    if any(bad_word in url.lower() or bad_word in name.lower() for bad_word in BAD_WORDS):
+        raise BadWordError("Input contains restricted words")
+
+    filename = os.path.join(TEMP_DIR, f"{MODEL_PREFIX}{random.randint(1, 1000)}.zip")
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url.replace("/blob/", "/resolve/")) as response:
+            if response.status != 200:
+                raise ValueError("Failed to download file")
+            total = int(response.headers.get('content-length', 0))
+            if total > MAX_FILE_SIZE:
+                raise ValueError(f"File size exceeds {MAX_FILE_SIZE / 1_000_000} MB limit")
+            current = 0
+            with open(filename, "wb") as f:
+                async for data in response.content.iter_chunked(4096):
+                    f.write(data)
+                    current += len(data)
+                    progress(current / total, desc="Downloading model")
     
-
     try:
-        unzip_file(filename)
+        with zipfile.ZipFile(filename, 'r') as zip_ref:
+            zip_ref.extractall(os.path.join(TEMP_DIR, os.path.basename(filename).split(".")[0]))
     except Exception as e:
-        return ["Failed to unzip the file", "Failed", "Failed"] 
+        logger.error(f"Failed to unzip file: {e}")
+        raise ValueError("Failed to unzip file")
+
     unzipped_dir = os.path.join(TEMP_DIR, os.path.basename(filename).split(".")[0])
-    pth_files = []
-    index_files = []
-    for root, dirs, files in os.walk(unzipped_dir): 
-        for file in files:
-            if file.endswith(".pth"):
-                pth_files.append(os.path.join(root, file))
-            elif file.endswith(".index"):
-                index_files.append(os.path.join(root, file))
+    pth_files = [os.path.join(root, file) for root, _, files in os.walk(unzipped_dir) for file in files if file.endswith(".pth")]
+    index_files = [os.path.join(root, file) for root, _, files in os.walk(unzipped_dir) for file in files if file.endswith(".index")]
+    
+    if not pth_files or not index_files:
+        raise ValueError("No .pth or .index files found in the zip")
     
-    print(pth_files, index_files) 
-    global pth_file
-    global index_file
     pth_file = pth_files[0]
     index_file = index_files[0]
-
-    print(pth_file)
-    print(index_file)
-
-    if name == "":
-        name = pth_file.split(".")[0]
-
+    name = name or os.path.basename(pth_file).split(".")[0]
     MODELS.append({"model": pth_file, "index": index_file, "model_name": name})
-    return ["Downloaded as " + name, pth_files[0], index_files[0]]
-
-def inference(audio, model_name):
-        output_data = inf_handler(audio, model_name)
-        vocals = output_data[0]
-        inst = output_data[1]
-
-        return vocals, inst
-
-if spaces_status:
-    @spaces.GPU()
-    def convert_now(audio_files, random_tag, converter):
-        return converter(
-            audio_files,
-            random_tag,
-            overwrite=False,
-            parallel_workers=8
-        )
-
-        
-else:
-    def convert_now(audio_files, random_tag, converter):
-        return converter(
-            audio_files,
-            random_tag,
-            overwrite=False,
-            parallel_workers=8
-        )
-
-def calculate_remaining_time(epochs, seconds_per_epoch):
-    total_seconds = epochs * seconds_per_epoch
-
-    hours = total_seconds // 3600
-    minutes = (total_seconds % 3600) // 60
-    seconds = total_seconds % 60
+    return [f"Downloaded as {name}", pth_file, index_file]
 
-    if hours == 0:
-        return f"{int(minutes)} minutes"
-    elif hours == 1:
-        return f"{int(hours)} hour and {int(minutes)} minutes"
-    else:
-        return f"{int(hours)} hours and {int(minutes)} minutes"
-
-def inf_handler(audio, model_name): 
+def inf_handler(audio, model_name):
     model_found = False
     for model_info in UVR_5_MODELS:
         if model_info["model_name"] == model_name:
@@ -196,60 +116,27 @@ def inf_handler(audio, model_name):
     if not model_found:
         separator.load_model()
     output_files = separator.separate(audio)
-    vocals = output_files[0]
-    inst = output_files[1]
-    return vocals, inst
+    return output_files[0], output_files[1]
 
-    
-def run(
-    model,
-    audio_files,
-    pitch_alg,
-    pitch_lvl,
-    index_inf,
-    r_m_f,
-    e_r,
-    c_b_p,
-):
+def run(model, audio_files, pitch_alg, pitch_lvl, index_inf, r_m_f, e_r, c_b_p):
     if not audio_files:
-        raise ValueError("The audio pls")
-
+        raise ValueError("Please upload an audio file")
     if isinstance(audio_files, str):
         audio_files = [audio_files]
-
-    try:
-        duration_base = librosa.get_duration(filename=audio_files[0])
-        print("Duration:", duration_base)
-    except Exception as e:
-        print(e)
-
-    random_tag = "USER_"+str(random.randint(10000000, 99999999))
-
+    
+    random_tag = f"USER_{random.randint(10000000, 99999999)}"
     file_m = model
-    print("File model:", file_m)
-
-    # get from MODELS
-    for model in MODELS:
-        if model["model_name"] == file_m:
-            print(model)
-            file_m = model["model"]
-            file_index = model["index"]
+    file_index = None
+    for m in MODELS:
+        if m["model_name"] == file_m:
+            file_m = m["model"]
+            file_index = m["index"]
             break
     
     if not file_m.endswith(".pth"):
-        raise ValueError("The model file must be a .pth file")
-
-
-    print("ILARIA RVC: mod by NeoDev 💖")
-    print("Random tag:", random_tag)
-    print("File model:", file_m)
-    print("Pitch algorithm:", pitch_alg)
-    print("Pitch level:", pitch_lvl)
-    print("File index:", file_index)
-    print("Index influence:", index_inf)
-    print("Respiration median filtering:", r_m_f)
-    print("Envelope ratio:", e_r)
-
+        raise ValueError("Model file must be a .pth file")
+    
+    logger.info(f"Running inference with model: {file_m}, tag: {random_tag}")
     converter.apply_conf(
         tag=random_tag,
         file_model=file_m,
@@ -260,249 +147,109 @@ def run(
         respiration_median_filtering=r_m_f,
         envelope_ratio=e_r,
         consonant_breath_protection=c_b_p,
-        resample_sr=44100 if audio_files[0].endswith('.mp3') else 0, 
+        resample_sr=44100 if audio_files[0].endswith('.mp3') else 0,
     )
     time.sleep(0.1)
-
     result = convert_now(audio_files, random_tag, converter)
-    print("Result:", result)
-
     return result[0]
 
-def upload_model(index_file, pth_file, model_name):
-    pth_file = pth_file.name
-    index_file = index_file.name
-    MODELS.append({"model": pth_file, "index": index_file, "model_name": model_name})
-    return "Uploaded!"  
-
-
+def convert_now(audio_files, random_tag, converter):
+    return converter(
+        audio_files,
+        random_tag,
+        overwrite=False,
+        parallel_workers=8
+    )
 
-with gr.Blocks(theme=gr.themes.Base(primary_hue="pink", secondary_hue="rose"), title="Ilaria RVC 💖") as app:
+def upload_model(index_file, pth_file, model_name):
+    if not index_file or not pth_file:
+        raise ValueError("Both index and model files are required")
+    if not model_name.strip():
+        raise ValueError("Model name cannot be empty")
+    MODELS.append({"model": pth_file.name, "index": index_file.name, "model_name": model_name})
+    return "Model uploaded successfully!"
+
+def json_to_markdown_table(json_data):
+    table = "| Key | Value |\n| --- | --- |\n"
+    for key, value in json_data.items():
+        table += f"| {key} | {value} |\n"
+    return table
+
+def model_info(name):
+    for model in MODELS:
+        if model["model_name"] == name:
+            info = model_handler.model_info(model["model"])
+            info2 = {
+                "Model Name": model["model_name"],
+                "Model Config": info['config'],
+                "Epochs Trained": info['epochs'],
+                "Sample Rate": info['sr'],
+                "Pitch Guidance": info['f0'],
+                "Model Precision": info['size'],
+            }
+            return json_to_markdown_table(info2)
+    return "Model not found"
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="pink", secondary_hue="rose"), title="Ilaria RVC 💖") as app:
     gr.Markdown("# Ilaria RVC 💖")
-    gr.Markdown("**Help keeping up the GPU donating on [Ko-Fi](https://ko-fi.com/ilariaowo)**")
-    with gr.Tab("Inference"):
-        
-        def update():
-            print(MODELS)
-            return gr.Dropdown(label="Model",choices=[model["model_name"] for model in MODELS],visible=True,interactive=True, value=MODELS[0]["model_name"],)
-        with gr.Row(equal_height=True):
-            models_dropdown = gr.Dropdown(label="Model",choices=[model["model_name"] for model in MODELS],visible=True,interactive=True, value=MODELS[0]["model_name"],)
-            refresh_button = gr.Button("Refresh Models")
-        refresh_button.click(update, outputs=[models_dropdown])
+    gr.Markdown("Support the project by donating on [Ko-Fi](https://ko-fi.com/ilariaowo)")
 
-        sound_gui = gr.Audio(value=None,type="filepath",autoplay=False,visible=True,)
-        
-        with gr.Accordion("Ilaria TTS", open=False):
-            text_tts = gr.Textbox(label="Text", placeholder="Hello!", lines=3, interactive=True,)
-            dropdown_tts = gr.Dropdown(label="Language and Model",choices=list(language_dict.keys()),interactive=True, value=list(language_dict.keys())[0])
-
-            button_tts = gr.Button("Speak", variant="primary",)
-            button_tts.click(text_to_speech_edge, inputs=[text_tts, dropdown_tts], outputs=[sound_gui])
+    with gr.Tab("Inference"):
+        with gr.Group():
+            models_dropdown = gr.Dropdown(label="Select Model", choices=[m["model_name"] for m in MODELS], value=MODELS[0]["model_name"])
+            refresh_button = gr.Button("Refresh Models", variant="secondary")
+            refresh_button.click(lambda: gr.Dropdown(choices=[m["model_name"] for m in MODELS]), outputs=models_dropdown)
 
-        with gr.Accordion("Settings", open=False):
-            pitch_algo_conf = gr.Radio(choices=[PITCH_ALGO_OPT],value=PITCH_ALGO_OPT[4],label="Pitch algorithm",visible=True,interactive=True) # Dropdown is 🤡
-            with gr.Row(equal_height=True):
-                pitch_lvl_conf = gr.Slider(label="Pitch level (lower -> 'male' while higher -> 'female')",minimum=-24,maximum=24,step=1,value=0,visible=True,interactive=True,)
-                index_inf_conf =  gr.Slider(minimum=0,maximum=1,label="Index influence -> How much accent is applied",value=0.75,)
-            with gr.Row(equal_height=True):
-                respiration_filter_conf = gr.Slider(minimum=0,maximum=7,label="Respiration median filtering",value=3,step=1,interactive=True,)
-                envelope_ratio_conf = gr.Slider(minimum=0,maximum=1,label="Envelope ratio",value=0.25,interactive=True,)
-            consonant_protec_conf = gr.Slider(minimum=0,maximum=0.5,label="Consonant breath protection",value=0.5,interactive=True,)
+        sound_gui = gr.Audio(label="Input Audio", type="filepath")
 
-        with gr.Row(equal_height=True):
-            button_conf = gr.Button("Convert",variant="primary",)
-            output_conf = gr.Audio(type="filepath",label="Output",)
-    	
-        button_conf.click(lambda :None, None, output_conf)
-        button_conf.click(
-            run,
-            inputs=[
-                models_dropdown,
-                sound_gui,
-                pitch_algo_conf,
-                pitch_lvl_conf,
-                index_inf_conf,
-                respiration_filter_conf,
-                envelope_ratio_conf,
-                consonant_protec_conf,
-            ],
-            outputs=[output_conf],
-        )
+        with gr.Accordion("Text-to-Speech", open=False):
+            text_tts = gr.Textbox(label="Text Input", placeholder="Enter text to convert to speech", lines=3)
+            dropdown_tts = gr.Dropdown(label="Language and Voice", choices=list(tts_order_voice.keys()), value=list(tts_order_voice.keys())[0])
+            button_tts = gr.Button("Generate Speech", variant="primary")
+            button_tts.click(text_to_speech_edge, inputs=[text_tts, dropdown_tts], outputs=sound_gui)
 
+        with gr.Accordion("Conversion Settings", open=False):
+            pitch_algo_conf = gr.Dropdown(choices=PITCH_ALGO_OPT, value=PITCH_ALGO_OPT[4], label="Pitch Algorithm", info="Select the algorithm for pitch detection")
+            with gr.Row():
+                pitch_lvl_conf = gr.Slider(label="Pitch Level", minimum=-24, maximum=24, step=1, value=0, info="Adjust pitch: negative for male, positive for female")
+                index_inf_conf = gr.Slider(minimum=0, maximum=1, value=0.75, label="Index Influence", info="Controls how much accent is applied")
+            with gr.Row():
+                respiration_filter_conf = gr.Slider(minimum=0, maximum=7, value=3, step=1, label="Respiration Median Filtering")
+                envelope_ratio_conf = gr.Slider(minimum=0, maximum=1, value=0.25, label="Envelope Ratio")
+            consonant_protec_conf = gr.Slider(minimum=0, maximum=0.5, value=0.5, label="Consonant Breath Protection")
 
-    with gr.Tab("Model Loader (Download and Upload)"):
-        with gr.Accordion("Model Downloader", open=False):
-            gr.Markdown(
-                "Download the model from the following URL and upload it here. (Huggingface RVC model)"
-            )
-            model = gr.Textbox(lines=1, label="Model URL")
-            name = gr.Textbox(lines=1, label="Model Name", placeholder="Model Name")
-            download_button = gr.Button("Download Model")
-            status = gr.Textbox(lines=1, label="Status", placeholder="Waiting....", interactive=False)
-            model_pth = gr.Textbox(lines=1, label="Model pth file", placeholder="Waiting....", interactive=False)
-            index_pth = gr.Textbox(lines=1, label="Index pth file", placeholder="Waiting....", interactive=False)
-            download_button.click(download_from_url, [model, name], outputs=[status, model_pth, index_pth])
-        with gr.Accordion("Upload A Model", open=False):
+        with gr.Row():
+            button_conf = gr.Button("Convert Audio", variant="primary")
+            output_conf = gr.Audio(type="filepath", label="Converted Audio")
+        button_conf.click(run, inputs=[models_dropdown, sound_gui, pitch_algo_conf, pitch_lvl_conf, index_inf_conf, respiration_filter_conf, envelope_ratio_conf, consonant_protec_conf], outputs=output_conf)
+
+    with gr.Tab("Model Loader"):
+        with gr.Accordion("Download Model", open=False):
+            gr.Markdown("Download a model from Hugging Face (RVC model, max 500 MB)")
+            model_url = gr.Textbox(label="Hugging Face Model URL", placeholder="https://huggingface.co/username/model")
+            model_name = gr.Textbox(label="Model Name", placeholder="Enter a unique model name")
+            download_button = gr.Button("Download Model", variant="primary")
+            status = gr.Textbox(label="Status", interactive=False)
+            model_pth = gr.Textbox(label="Model .pth File", interactive=False)
+            index_pth = gr.Textbox(label="Index .index File", interactive=False)
+            download_button.click(download_from_url, [model_url, model_name], [status, model_pth, index_pth])
+
+        with gr.Accordion("Upload Model", open=False):
             index_file_upload = gr.File(label="Index File (.index)")
             pth_file_upload = gr.File(label="Model File (.pth)")
-
-            model_name = gr.Textbox(label="Model Name", placeholder="Model Name")
-            upload_button = gr.Button("Upload Model")
-            upload_status = gr.Textbox(lines=1, label="Status", placeholder="Waiting....", interactive=False)
-
-            upload_button.click(upload_model, [index_file_upload, pth_file_upload, model_name], upload_status)
-    
-
-    with gr.Tab("Vocal Separator (UVR)"):
-        gr.Markdown("Separate vocals and instruments from an audio file using UVR models. - This is only on CPU due to ZeroGPU being ZeroGPU :(")
-        uvr5_audio_file = gr.Audio(label="Audio File",type="filepath")
-
+            model_name_upload = gr.Textbox(label="Model Name", placeholder="Enter a unique model name")
+            upload_button = gr.Button("Upload Model", variant="primary")
+            upload_status = gr.Textbox(label="Status", interactive=False)
+            upload_button.click(upload_model, [index_file_upload, pth_file_upload, model_name_upload], upload_status)
+
+    with gr.Tab("Vocal Separator"):
+        gr.Markdown("Separate vocals and instruments using UVR models (CPU only)")
+        uvr5_audio_file = gr.Audio(label="Input Audio", type="filepath")
         with gr.Row():
-            uvr5_model = gr.Dropdown(label="Model", choices=[model["model_name"] for model in UVR_5_MODELS])
-            uvr5_button = gr.Button("Separate Vocals", variant="primary",)
-
-        uvr5_output_voc = gr.Audio(type="filepath", label="Output 1",)
-        uvr5_output_inst = gr.Audio(type="filepath", label="Output 2",)
-
-        uvr5_button.click(inference, [uvr5_audio_file, uvr5_model], [uvr5_output_voc, uvr5_output_inst])
-    
-    with gr.Tab("Extra"):
-        with gr.Accordion("Model Information", open=False):
-            def json_to_markdown_table(json_data):
-                table = "| Key | Value |\n| --- | --- |\n"
-                for key, value in json_data.items():
-                    table += f"| {key} | {value} |\n"
-                return table
-            def model_info(name):
-                for model in MODELS:
-                    if model["model_name"] == name:
-                        print(model["model"])
-                        info = model_handler.model_info(model["model"])
-                        info2 = {
-                            "Model Name": model["model_name"],
-                            "Model Config": info['config'],
-                            "Epochs Trained": info['epochs'],
-                            "Sample Rate": info['sr'],
-                            "Pitch Guidance": info['f0'],
-                            "Model Precision": info['size'],
-                        }
-                        return gr.Markdown(json_to_markdown_table(info2))
-
-                return "Model not found"
-            def update():
-                print(MODELS)
-                return gr.Dropdown(label="Model", choices=[model["model_name"] for model in MODELS])
-            with gr.Row():
-                model_info_dropdown = gr.Dropdown(label="Model", choices=[model["model_name"] for model in MODELS])
-                refresh_button = gr.Button("Refresh Models")
-                refresh_button.click(update, outputs=[model_info_dropdown])
-            model_info_button = gr.Button("Get Model Information")
-            model_info_output = gr.Textbox(value="Waiting...",label="Output", interactive=False)
-            model_info_button.click(model_info, [model_info_dropdown], [model_info_output])
-            
-
-
-        with gr.Accordion("Training Time Calculator", open=False):
-            with gr.Column():
-                epochs_input = gr.Number(label="Number of Epochs")
-                seconds_input = gr.Number(label="Seconds per Epoch")
-                calculate_button = gr.Button("Calculate Time Remaining")
-                remaining_time_output = gr.Textbox(label="Remaining Time", interactive=False)
-                
-                calculate_button.click(calculate_remaining_time,inputs=[epochs_input, seconds_input],outputs=[remaining_time_output])
-
-        with gr.Accordion("Model Fusion", open=False): 
-                    with gr.Group():
-                        def merge(ckpt_a, ckpt_b, alpha_a, sr_, if_f0_, info__, name_to_save0, version_2):
-                            for model in MODELS:
-                                if model["model_name"] == ckpt_a:
-                                    ckpt_a = model["model"]
-                                if model["model_name"] == ckpt_b:
-                                    ckpt_b = model["model"]
-                            
-                            path = model_handler.merge(ckpt_a, ckpt_b, alpha_a, sr_, if_f0_, info__, name_to_save0, version_2)
-                            if path == "Fail to merge the models. The model architectures are not the same.":
-                                return "Fail to merge the models. The model architectures are not the same."
-                            else:
-                                MODELS.append({"model": path, "index": None, "model_name": name_to_save0})
-                                return "Merged, saved as " + name_to_save0
-
-                        gr.Markdown(value="Strongly suggested to use only very clean models.")
-                        with gr.Row():
-                            def update():
-                                print(MODELS)
-                                return gr.Dropdown(label="Model A", choices=[model["model_name"] for model in MODELS]), gr.Dropdown(label="Model B", choices=[model["model_name"] for model in MODELS])
-                            refresh_button_fusion = gr.Button("Refresh Models")
-                            ckpt_a = gr.Dropdown(label="Model A", choices=[model["model_name"] for model in MODELS])
-                            ckpt_b = gr.Dropdown(label="Model B", choices=[model["model_name"] for model in MODELS])
-                            refresh_button_fusion.click(update, outputs=[ckpt_a, ckpt_b])
-                            alpha_a = gr.Slider(
-                                minimum=0,
-                                maximum=1,
-                                label="Weight of the first model over the second",
-                                value=0.5,
-                                interactive=True,
-                            )
-                    with gr.Group():
-                        with gr.Row():
-                            sr_ = gr.Radio(
-                                label="Sample rate of both models",
-                                choices=["32k","40k", "48k"],
-                                value="32k",
-                                interactive=True,
-                            )
-                            if_f0_ = gr.Radio(
-                                label="Pitch Guidance",
-                                choices=["Yes", "Nah"],
-                                value="Yes",
-                                interactive=True,
-                            )
-                            info__ = gr.Textbox(
-                                label="Add informations to the model",
-                                value="",
-                                max_lines=8,
-                                interactive=True,
-                                visible=False
-                            )
-                            name_to_save0 = gr.Textbox(
-                                label="Final Model name",
-                                value="",
-                                max_lines=1,
-                                interactive=True,
-                            )
-                            version_2 = gr.Radio(
-                                label="Versions of the models",
-                                choices=["v1", "v2"],
-                                value="v2",
-                                interactive=True,
-                            )
-                    with gr.Group():
-                        with gr.Row():
-                            but6 = gr.Button("Fuse the two models", variant="primary")
-                            info4 = gr.Textbox(label="Output", value="", max_lines=8)
-                        but6.click(
-                            merge,
-                            [ckpt_a,ckpt_b,alpha_a,sr_,if_f0_,info__,name_to_save0,version_2,],info4,api_name="ckpt_merge",)
-
-        with gr.Accordion("Model Quantization", open=False):
-            gr.Markdown("Quantize the model to a lower precision. - soon™ or never™ 😎")
-
-        
-    with gr.Tab("Credits"):
-        gr.Markdown(
-            """
-            Ilaria RVC made by [Ilaria](https://huggingface.co/TheStinger) suport her on [ko-fi](https://ko-fi.com/ilariaowo)
-            
-            The Inference code is made by [r3gm](https://huggingface.co/r3gm) (his module helped form this space 💖)
-
-            made with ❤️ by [mikus](https://github.com/cappuch) - made the ui!
-
-            ## In loving memory of JLabDX 🕊️
-            """
-        )
-    with gr.Tab(("")):
-        gr.Markdown('''
-            ![ilaria](https://i.ytimg.com/vi/5PWqt2Wg-us/maxresdefault.jpg)
-        ''')
+            uvr5_model = gr.Dropdown(label="UVR Model", choices=[m["model_name"] for m in UVR_5_MODELS])
+            uvr5_button = gr.Button("Separate", variant="primary")
+        uvr5_output_voc = gr.Audio(label="Vocals", type="filepath")
+        uvr5_output_inst = gr.Audio(label="Instrumental", type="filepath")
+        uvr5_button.click(inf_handler, [uvr5_audio_file, uvr5_model], [uvr5_output_voc, uvr5_output_inst])
 
-app.queue(api_open=False).launch(show_api=False)
+app.queue(api_open=False).launch(show_api=False)