Update app.py

app.py

@@ -8,735 +8,407 @@ import time
 import soundfile as sf
 from infer_rvc_python.main import download_manager
 import zipfile
-import edge_tts
 import asyncio
 import librosa
 import traceback
-import soundfile as sf
-from pedalboard import Pedalboard, Reverb, Compressor, HighpassFilter
-from pedalboard.io import AudioFile
-from pydub import AudioSegment
-import noisereduce as nr
 import numpy as np
 import urllib.request
 import shutil
 import threading
+from pedalboard import Pedalboard, Reverb, Compressor, HighpassFilter
+from pedalboard.io import AudioFile
+from pydub import AudioSegment
+import noisereduce as nr
+import edge_tts
 
+# Suppress logging
 logging.getLogger("infer_rvc_python").setLevel(logging.ERROR)
 
+# Initialize converter
 converter = BaseLoader(only_cpu=False, hubert_path=None, rmvpe_path=None)
 
-title = "<center><strong><font size='7'>RVC⚡ZERO</font></strong></center>"
-description = "This demo is provided for educational and research purposes only. The authors and contributors of this project do not endorse or encourage any misuse or unethical use of this software. Any use of this software for purposes other than those intended is solely at the user's own risk. The authors and contributors shall not be held responsible for any damages or liabilities arising from the use of this demo inappropriately."
-theme = "aliabid94/new-theme"
-
-PITCH_ALGO_OPT = [
-    "pm",
-    "harvest",
-    "crepe",
-    "rmvpe",
-    "rmvpe+",
-]
+# Theme & Title
+title = "<center><strong><font size='7'>🔊 RVC+</font></strong></center>"
+description = """
+<div style="text-align: center; font-size: 1.1em; color: #aaa;">
+This demo is for educational and research purposes only.<br>
+Misuse of voice conversion technology is unethical. Use responsibly.<br>
+Authors are not liable for inappropriate usage.
+</div>
+"""
+theme = gr.themes.Soft(primary_hue="indigo", secondary_hue="blue").set(
+    body_background_fill="*neutral_50"
+)
 
+# Global constants
+PITCH_ALGO_OPT = ["pm", "harvest", "crepe", "rmvpe", "rmvpe+"]
+MAX_FILE_SIZE = 500 * 1024 * 1024  # 500 MB
+DOWNLOAD_DIR = "downloads"
+OUTPUT_DIR = "output"
 
-def find_files(directory):
-    file_paths = []
-    for filename in os.listdir(directory):
-        # Check if the file has the desired extension
-        if filename.endswith('.pth') or filename.endswith('.zip') or filename.endswith('.index'):
-            # If yes, add the file path to the list
-            file_paths.append(os.path.join(directory, filename))
+os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+os.makedirs(OUTPUT_DIR, exist_ok=True)
 
-    return file_paths
 
+# --- Utility Functions ---
+def find_files(directory, exts=(".pth", ".index", ".zip")):
+    return [os.path.join(directory, f) for f in os.listdir(directory)
+            if f.endswith(exts)]
 
-def unzip_in_folder(my_zip, my_dir):
-    with zipfile.ZipFile(my_zip) as zip:
-        for zip_info in zip.infolist():
-            if zip_info.is_dir():
-                continue
-            zip_info.filename = os.path.basename(zip_info.filename)
-            zip.extract(zip_info, my_dir)
-
-
-def find_my_model(a_, b_):
-
-    if a_ is None or a_.endswith(".pth"):
-        return a_, b_
-
-    txt_files = []
-    for base_file in [a_, b_]:
-        if base_file is not None and base_file.endswith(".txt"):
-            txt_files.append(base_file)
-
-    directory = os.path.dirname(a_)
-
-    for txt in txt_files:
-        with open(txt, 'r') as file:
-            first_line = file.readline()
-
-        download_manager(
-            url=first_line.strip(),
-            path=directory,
-            extension="",
-        )
-
-    for f in find_files(directory):
-        if f.endswith(".zip"):
-            unzip_in_folder(f, directory)
-
-    model = None
-    index = None
-    end_files = find_files(directory)
 
-    for ff in end_files:
-        if ff.endswith(".pth"):
-            model = os.path.join(directory, ff)
-            gr.Info(f"Model found: {ff}")
-        if ff.endswith(".index"):
-            index = os.path.join(directory, ff)
-            gr.Info(f"Index found: {ff}")
-
-    if not model:
-        gr.Error(f"Model not found in: {end_files}")
-
-    if not index:
-        gr.Warning("Index not found")
-
-    return model, index
+def unzip_in_folder(zip_path, extract_to):
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        for member in zip_ref.infolist():
+            if not member.is_dir():
+                member.filename = os.path.basename(member.filename)
+                zip_ref.extract(member, extract_to)
 
 
 def get_file_size(url):
-
-    if "huggingface" not in url:
-        raise ValueError("Only downloads from Hugging Face are allowed")
-
+    if "huggingface" not in url.lower():
+        raise ValueError("❌ Only Hugging Face links are allowed.")
     try:
         with urllib.request.urlopen(url) as response:
-            info = response.info()
-            content_length = info.get("Content-Length")
+            file_size = int(response.headers.get("Content-Length", 0))
+        if file_size > MAX_FILE_SIZE:
+            raise ValueError(f"⚠️ File too large: {file_size / 1e6:.1f} MB (>500MB)")
+        return file_size
+    except Exception as e:
+        raise RuntimeError(f"❌ Failed to fetch file info: {str(e)}")
 
-        file_size = int(content_length)
-        if file_size > 500000000:
-            raise ValueError("The file is too large. You can only download files up to 500 MB in size.")
 
-    except Exception as e:
-        raise e
+def clear_directory_later(directory, delay=15):
+    """Clear temp directory after delay in a background thread."""
+    def _clear():
+        time.sleep(delay)
+        if os.path.exists(directory):
+            shutil.rmtree(directory, ignore_errors=True)
+            print(f"🧹 Cleaned up: {directory}")
+    threading.Thread(target=_clear, daemon=True).start()
 
 
-def clear_files(directory):
-    time.sleep(15)
-    print(f"Clearing files: {directory}.")
-    shutil.rmtree(directory)
+def find_model_and_index(directory):
+    files = find_files(directory)
+    model = next((f for f in files if f.endswith(".pth")), None)
+    index = next((f for f in files if f.endswith(".index")), None)
+    return model, index
 
 
-def get_my_model(url_data):
+# --- Model Download Handler ---
+@spaces.GPU(duration=60)
+def download_model(url_data):
+    if not url_data.strip():
+        raise ValueError("❌ No URL provided.")
 
-    if not url_data:
-        return None, None
+    urls = [u.strip().replace("/blob/", "/resolve/") for u in url_data.split(",") if u.strip()]
+    if len(urls) > 2:
+        raise ValueError("❌ Provide up to two URLs (model.pth, index.index).")
 
-    if "," in url_data:
-        a_, b_ = url_data.split(",")
-        a_, b_ = a_.strip().replace("/blob/", "/resolve/"), b_.strip().replace("/blob/", "/resolve/")
-    else:
-        a_, b_ = url_data.strip().replace("/blob/", "/resolve/"), None
+    # Validate size first
+    for url in urls:
+        get_file_size(url)
 
-    out_dir = "downloads"
-    folder_download = str(random.randint(1000, 9999))
-    directory = os.path.join(out_dir, folder_download)
+    folder_name = f"model_{random.randint(1000, 9999)}"
+    directory = os.path.join(DOWNLOAD_DIR, folder_name)
     os.makedirs(directory, exist_ok=True)
 
     try:
-        get_file_size(a_)
-        if b_:
-            get_file_size(b_)
-
-        valid_url = [a_] if not b_ else [a_, b_]
-        for link in valid_url:
-            download_manager(
-                url=link,
-                path=directory,
-                extension="",
-            )
-
-        for f in find_files(directory):
-            if f.endswith(".zip"):
-                unzip_in_folder(f, directory)
+        for url in urls:
+            download_manager(url=url, path=directory, extension="")
 
-        model = None
-        index = None
-        end_files = find_files(directory)
+        # Unzip if needed
+        for f in find_files(directory, (".zip",)):
+            unzip_in_folder(f, directory)
 
-        for ff in end_files:
-            if ff.endswith(".pth"):
-                model = ff
-                gr.Info(f"Model found: {ff}")
-            if ff.endswith(".index"):
-                index = ff
-                gr.Info(f"Index found: {ff}")
+        model, index = find_model_and_index(directory)
 
         if not model:
-            raise ValueError(f"Model not found in: {end_files}")
-
-        if not index:
-            gr.Warning("Index not found")
+            raise ValueError("❌ .pth model file not found in downloaded content.")
+        gr.Info(f"✅ Model loaded: {os.path.basename(model)}")
+        if index:
+            gr.Info(f"📌 Index loaded: {os.path.basename(index)}")
         else:
-            index = os.path.abspath(index)
+            gr.Warning("⚠️ Index file not found – conversion may be less accurate.")
 
-        return os.path.abspath(model), index
+        # Schedule cleanup
+        clear_directory_later(directory, delay=30)
 
-    except Exception as e:
-        raise e
-    finally:
-        # time.sleep(10)
-        # shutil.rmtree(directory)
-        t = threading.Thread(target=clear_files, args=(directory,))
-        t.start()
+        return os.path.abspath(model), os.path.abspath(index) if index else None
 
+    except Exception as e:
+        shutil.rmtree(directory, ignore_errors=True)
+        raise gr.Error(f"❌ Download failed: {str(e)}")
 
-def add_audio_effects(audio_list):
-    print("Audio effects")
 
-    result = []
-    for audio_path in audio_list:
+# --- Audio Processing ---
+def apply_noisereduce(audio_paths):
+    results = []
+    for path in audio_paths:
+        out_path = f"{os.path.splitext(path)[0]}_denoised.wav"
         try:
-            output_path = f'{os.path.splitext(audio_path)[0]}_effects.wav'
-
-            # Initialize audio effects plugins
-            board = Pedalboard(
-                [
-                    HighpassFilter(),
-                    Compressor(ratio=4, threshold_db=-15),
-                    Reverb(room_size=0.10, dry_level=0.8, wet_level=0.2, damping=0.7)
-                 ]
+            audio = AudioSegment.from_file(path)
+            samples = np.array(audio.get_array_of_samples())
+            sr = audio.frame_rate
+            reduced = nr.reduce_noise(y=samples.astype(np.float32), sr=sr, prop_decrease=0.6)
+            reduced_audio = AudioSegment(
+                reduced.tobytes(),
+                frame_rate=sr,
+                sample_width=audio.sample_width,
+                channels=audio.channels
             )
-
-            with AudioFile(audio_path) as f:
-                with AudioFile(output_path, 'w', f.samplerate, f.num_channels) as o:
-                    # Read one second of audio at a time, until the file is empty:
+            reduced_audio.export(out_path, format="wav")
+            results.append(out_path)
+            gr.Info("🔊 Noise reduction applied.")
+        except Exception as e:
+            print(f"Noise reduction failed: {e}")
+            results.append(path)
+    return results
+
+
+def apply_audio_effects(audio_paths):
+    results = []
+    board = Pedalboard([
+        HighpassFilter(cutoff_frequency_hz=80),
+        Compressor(ratio=4, threshold_db=-15),
+        Reverb(room_size=0.15, damping=0.7, wet_level=0.15, dry_level=0.85)
+    ])
+    for path in audio_paths:
+        out_path = f"{os.path.splitext(path)[0]}_reverb.wav"
+        try:
+            with AudioFile(path) as f:
+                with AudioFile(out_path, 'w', f.samplerate, f.num_channels) as o:
                     while f.tell() < f.frames:
                         chunk = f.read(int(f.samplerate))
-                        effected = board(chunk, f.samplerate, reset=False)
+                        effected = board(chunk, f.samplerate)
                         o.write(effected)
-            result.append(output_path)
+            results.append(out_path)
+            gr.Info("🎛️ Audio effects applied.")
         except Exception as e:
-            traceback.print_exc()
-            print(f"Error noisereduce: {str(e)}")
-            result.append(audio_path)
-
-    return result
-
-
-def apply_noisereduce(audio_list):
-    # https://github.com/sa-if/Audio-Denoiser
-    print("Noice reduce")
-
-    result = []
-    for audio_path in audio_list:
-        out_path = f'{os.path.splitext(audio_path)[0]}_noisereduce.wav'
-
-        try:
-            # Load audio file
-            audio = AudioSegment.from_file(audio_path)
+            print(f"Effects failed: {e}")
+            results.append(path)
+    return results
 
-            # Convert audio to numpy array
-            samples = np.array(audio.get_array_of_samples())
 
-            # Reduce noise
-            reduced_noise = nr.reduce_noise(samples, sr=audio.frame_rate, prop_decrease=0.6)
+# --- TTS Handler ---
+async def generate_tts(text, voice, output_path):
+    communicate = edge_tts.Communicate(text, voice.split("-")[0])
+    await communicate.save(output_path)
 
-            # Convert reduced noise signal back to audio
-            reduced_audio = AudioSegment(
-                reduced_noise.tobytes(), 
-                frame_rate=audio.frame_rate, 
-                sample_width=audio.sample_width,
-                channels=audio.channels
-            )
 
-            # Save reduced audio to file
-            reduced_audio.export(out_path, format="wav")
-            result.append(out_path)
-
-        except Exception as e:
-            traceback.print_exc()
-            print(f"Error noisereduce: {str(e)}")
-            result.append(audio_path)
+def infer_tts(tts_voice, tts_text, play_tts):
+    if not tts_text.strip():
+        raise ValueError("❌ Text is empty.")
+    folder = f"tts_{random.randint(10000, 99999)}"
+    out_dir = os.path.join(OUTPUT_DIR, folder)
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, "tts_output.mp3")
 
-    return result
+    try:
+        asyncio.run(generate_tts(tts_text, tts_voice, out_path))
+        if play_tts:
+            return [out_path], out_path
+        return [out_path], None
+    except Exception as e:
+        raise gr.Error(f"TTS generation failed: {str(e)}")
 
 
+# --- Main Conversion Function ---
 @spaces.GPU()
-def convert_now(audio_files, random_tag, converter):
-    return converter(
-        audio_files,
-        random_tag,
-        overwrite=False,
-        parallel_workers=8
-    )
-
-
-def run(
+def run_conversion(
     audio_files,
-    file_m,
-    pitch_alg,
-    pitch_lvl,
-    file_index,
-    index_inf,
-    r_m_f,
-    e_r,
-    c_b_p,
-    active_noise_reduce,
-    audio_effects,
+    model_path,
+    pitch_algo,
+    pitch_level,
+    index_path,
+    index_rate,
+    filter_radius,
+    rms_mix_rate,
+    protect,
+    denoise,
+    effects,
 ):
     if not audio_files:
-        raise ValueError("The audio pls")
+        raise ValueError("❌ Please upload at least one 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)
-
-    if file_m is not None and file_m.endswith(".txt"):
-        file_m, file_index = find_my_model(file_m, file_index)
-        print(file_m, file_index)
-
-    random_tag = "USER_"+str(random.randint(10000000, 99999999))
+    random_tag = f"USER_{random.randint(10000000, 99999999)}"
 
+    # Configure converter
     converter.apply_conf(
         tag=random_tag,
-        file_model=file_m,
-        pitch_algo=pitch_alg,
-        pitch_lvl=pitch_lvl,
-        file_index=file_index,
-        index_influence=index_inf,
-        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, 
-    )
-    time.sleep(0.1)
-
-    result = convert_now(audio_files, random_tag, converter)
-
-    if active_noise_reduce:
-        result = apply_noisereduce(result)
-
-    if audio_effects:
-        result = add_audio_effects(result)
-
-    return result
-
-
-def audio_conf():
-    return gr.File(
-        label="Audio files",
-        file_count="multiple",
-        type="filepath",
-        container=True,
-    )
-
-
-def model_conf():
-    return gr.File(
-        label="Model file",
-        type="filepath",
-        height=130,
-    )
-
-
-def pitch_algo_conf():
-    return gr.Dropdown(
-        PITCH_ALGO_OPT,
-        value=PITCH_ALGO_OPT[4],
-        label="Pitch algorithm",
-        visible=True,
-        interactive=True,
-    )
-
-
-def pitch_lvl_conf():
-    return gr.Slider(
-        label="Pitch level",
-        minimum=-24,
-        maximum=24,
-        step=1,
-        value=0,
-        visible=True,
-        interactive=True,
-    )
-
-
-def index_conf():
-    return gr.File(
-        label="Index file",
-        type="filepath",
-        height=130,
-    )
-
-
-def index_inf_conf():
-    return gr.Slider(
-        minimum=0,
-        maximum=1,
-        label="Index influence",
-        value=0.75,
-    )
-
-
-def respiration_filter_conf():
-    return gr.Slider(
-        minimum=0,
-        maximum=7,
-        label="Respiration median filtering",
-        value=3,
-        step=1,
-        interactive=True,
-    )
-
-
-def envelope_ratio_conf():
-    return gr.Slider(
-        minimum=0,
-        maximum=1,
-        label="Envelope ratio",
-        value=0.25,
-        interactive=True,
-    )
-
-
-def consonant_protec_conf():
-    return gr.Slider(
-        minimum=0,
-        maximum=0.5,
-        label="Consonant breath protection",
-        value=0.5,
-        interactive=True,
-    )
-
-
-def button_conf():
-    return gr.Button(
-        "Inference",
-        variant="primary",
-    )
-
-
-def output_conf():
-    return gr.File(
-        label="Result",
-        file_count="multiple",
-        interactive=False,
-    )
-
-
-def active_tts_conf():
-    return gr.Checkbox(
-        False,
-        label="TTS",
-        # info="",
-        container=False,
-    )
-
-
-def tts_voice_conf():
-    return gr.Dropdown(
-        label="tts voice",
-        choices=voices,
-        visible=False,
-        value="en-US-EmmaMultilingualNeural-Female",
-    )
-
-
-def tts_text_conf():
-    return gr.Textbox(
-        value="",
-        placeholder="Write the text here...",
-        label="Text",
-        visible=False,
-        lines=3,
-    )
-
-
-def tts_button_conf():
-    return gr.Button(
-        "Process TTS",
-        variant="secondary",
-        visible=False,
-    )
-
-
-def tts_play_conf():
-    return gr.Checkbox(
-        False,
-        label="Play",
-        # info="",
-        container=False,
-        visible=False,
-    )
-
-
-def sound_gui():
-    return gr.Audio(
-        value=None,
-        type="filepath",
-        # format="mp3",
-        autoplay=True,
-        visible=False,
-    )
-
-
-def denoise_conf():
-    return gr.Checkbox(
-        False,
-        label="Denoise",
-        # info="",
-        container=False,
-        visible=True,
-    )
-
-
-def effects_conf():
-    return gr.Checkbox(
-        False,
-        label="Reverb",
-        # info="",
-        container=False,
-        visible=True,
-    )
-
-
-def infer_tts_audio(tts_voice, tts_text, play_tts):
-    out_dir = "output"
-    folder_tts = "USER_"+str(random.randint(10000, 99999))
-
-    os.makedirs(out_dir, exist_ok=True)
-    os.makedirs(os.path.join(out_dir, folder_tts), exist_ok=True)
-    out_path = os.path.join(out_dir, folder_tts, "tts.mp3")
-
-    asyncio.run(edge_tts.Communicate(tts_text, "-".join(tts_voice.split('-')[:-1])).save(out_path))
-    if play_tts:
-        return [out_path], out_path
-    return [out_path], None
-
-
-def show_components_tts(value_active):
-    return gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    )
-
-
-def down_active_conf():
-    return gr.Checkbox(
-        False,
-        label="URL-to-Model",
-        # info="",
-        container=False,
-    )
-
-
-def down_url_conf():
-    return gr.Textbox(
-        value="",
-        placeholder="Write the url here...",
-        label="Enter URL",
-        visible=False,
-        lines=1,
+        file_model=model_path,
+        pitch_algo=pitch_algo,
+        pitch_lvl=pitch_level,
+        file_index=index_path,
+        index_influence=index_rate,
+        respiration_median_filtering=int(filter_radius),
+        envelope_ratio=rms_mix_rate,
+        consonant_breath_protection=protect,
+        resample_sr=44100 if any(f.endswith(".mp3") for f in audio_files) else 0,
     )
 
+    # Run conversion
+    try:
+        results = converter(audio_files, random_tag, overwrite=False, parallel_workers=8)
+    except Exception as e:
+        raise gr.Error(f"❌ Conversion failed: {str(e)}")
 
-def down_button_conf():
-    return gr.Button(
-        "Process",
-        variant="secondary",
-        visible=False,
-    )
+    # Post-processing
+    if denoise:
+        results = apply_noisereduce(results)
+    if effects:
+        results = apply_audio_effects(results)
 
+    return results
 
-def show_components_down(value_active):
-    return gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    ), gr.update(
-        visible=value_active
-    )
 
+# --- Gradio UI Builder ---
+def create_ui():
+    with gr.Blocks(theme=theme, title="RVC+", fill_width=True, delete_cache=(3200, 3200)) as app:
+        gr.HTML(title)
+        gr.HTML(description)
 
-def get_gui(theme):
-    with gr.Blocks(theme=theme, fill_width=True, fill_height=True, delete_cache=(3200, 3200)) as app:
-        gr.Markdown(title)
-        gr.Markdown(description)
+        with gr.Tabs():
+            # ============= TAB 1: Voice Conversion =============
+            with gr.Tab("🎤 Voice Conversion", id=0):
+                gr.Markdown("### 🔊 Upload audio and select your model.")
 
-        active_tts = active_tts_conf()
-        with gr.Row():
-            with gr.Column(scale=1):
-                tts_text = tts_text_conf()
-            with gr.Column(scale=2):
                 with gr.Row():
-                    with gr.Column():
-                        with gr.Row():
-                            tts_voice = tts_voice_conf()
-                            tts_active_play = tts_play_conf()
-
-                tts_button = tts_button_conf()
-                tts_play = sound_gui()
-
-        active_tts.change(
-            fn=show_components_tts,
-            inputs=[active_tts],
-            outputs=[tts_voice, tts_text, tts_button, tts_active_play],
-        )
-
-        aud = audio_conf()
-        # gr.HTML("<hr>")
-
-        tts_button.click(
-            fn=infer_tts_audio,
-            inputs=[tts_voice, tts_text, tts_active_play],
-            outputs=[aud, tts_play],
-        )
-
-        down_active_gui = down_active_conf()
-        down_info = gr.Markdown(
-            "Provide a link to a zip file, like this one: `https://huggingface.co/mrmocciai/Models/resolve/main/Genshin%20Impact/ayaka-v2.zip?download=true`, or separate links with a comma for the .pth and .index files, like this: `https://huggingface.co/sail-rvc/ayaka-jp/resolve/main/model.pth?download=true, https://huggingface.co/sail-rvc/ayaka-jp/resolve/main/model.index?download=true`",
-            visible=False
-        )
-        with gr.Row():
-            with gr.Column(scale=3):
-                down_url_gui = down_url_conf()
-            with gr.Column(scale=1):
-                down_button_gui = down_button_conf()
-
-        with gr.Column():
-            with gr.Row():
-                model = model_conf()
-                indx = index_conf()
-
-        down_active_gui.change(
-            show_components_down,
-            [down_active_gui],
-            [down_info, down_url_gui, down_button_gui]
-        )
-
-        down_button_gui.click(
-            get_my_model,
-            [down_url_gui],
-            [model, indx]
-        )
-
-        algo = pitch_algo_conf()
-        algo_lvl = pitch_lvl_conf()
-        indx_inf = index_inf_conf()
-        res_fc = respiration_filter_conf()
-        envel_r = envelope_ratio_conf()
-        const = consonant_protec_conf()
-        with gr.Row():
-            with gr.Column():
+                    with gr.Column(scale=2):
+                        audio_input = gr.File(
+                            label="Upload Audio (WAV, MP3, OGG)",
+                            file_count="multiple",
+                            type="filepath"
+                        )
+                    with gr.Column(scale=1):
+                        with gr.Group():
+                            model_file = gr.File(label="Upload .pth Model", type="filepath", height=100)
+                            index_file = gr.File(label="Upload .index File (Optional)", type="filepath", height=100)
+
+                # Download Model Section
+                gr.Markdown("📥 Or download model from URL:")
                 with gr.Row():
-                    denoise_gui = denoise_conf()
-                    effects_gui = effects_conf()
-        button_base = button_conf()
-        output_base = output_conf()
-
-        button_base.click(
-            run,
-            inputs=[
-                aud,
-                model,
-                algo,
-                algo_lvl,
-                indx,
-                indx_inf,
-                res_fc,
-                envel_r,
-                const,
-                denoise_gui,
-                effects_gui,
-            ],
-            outputs=[output_base],
-        )
+                    use_url = gr.Checkbox(label="🌐 Use Model URL", value=False)
+                with gr.Group(visible=False) as url_group:
+                    gr.Markdown(
+                        "🔗 Paste Hugging Face link(s):<br>"
+                        "• Single ZIP: `https://hf.co/.../model.zip`<br>"
+                        "• Two links: `https://hf.co/.../model.pth, https://hf.co/.../model.index`"
+                    )
+                    model_url = gr.Textbox(
+                        placeholder="https://huggingface.co/...",
+                        label="Model URL(s)",
+                        lines=1
+                    )
+                    download_btn = gr.Button("⬇️ Download Model", variant="secondary")
+
+                download_btn.click(
+                    download_model,
+                    inputs=[model_url],
+                    outputs=[model_file, index_file]
+                )
+                use_url.change(
+                    lambda x: gr.update(visible=x),
+                    inputs=[use_url],
+                    outputs=[url_group]
+                )
+
+                # Parameters
+                gr.Markdown("### ⚙️ Conversion Settings")
+                with gr.Row():
+                    pitch_algo = gr.Dropdown(PITCH_ALGO_OPT, value="rmvpe+", label="Pitch Algorithm")
+                    pitch_level = gr.Slider(-24, 24, value=0, step=1, label="Pitch Level")
+                with gr.Row():
+                    index_rate = gr.Slider(0, 1, value=0.75, label="Index Influence")
+                    filter_radius = gr.Slider(0, 7, value=3, step=1, label="Median Filter")
+                with gr.Row():
+                    rms_mix_rate = gr.Slider(0, 1, value=0.25, label="Volume Envelope")
+                    protect = gr.Slider(0, 0.5, value=0.5, label="Consonant Protection")
 
+                # Post-processing
+                with gr.Row():
+                    denoise = gr.Checkbox(False, label="🔇 Denoise Output")
+                    reverb = gr.Checkbox(False, label="🎛️ Add Reverb")
+
+                # Run Button
+                convert_btn = gr.Button("🚀 Convert Voice", variant="primary")
+                output_files = gr.File(label="✅ Converted Audio", file_count="multiple")
+
+                convert_btn.click(
+                    run_conversion,
+                    inputs=[
+                        audio_input,
+                        model_file,
+                        pitch_algo,
+                        pitch_level,
+                        index_file,
+                        index_rate,
+                        filter_radius,
+                        rms_mix_rate,
+                        protect,
+                        denoise,
+                        reverb,
+                    ],
+                    outputs=output_files,
+                )
+
+            # ============= TAB 2: Text-to-Speech =============
+            with gr.Tab("🗣️ Text-to-Speech", id=1):
+                gr.Markdown("### Convert text to speech using Edge TTS.")
+
+                tts_voice_list = sorted(
+                    [f"{v['ShortName']}-{v['Gender']}" for v in asyncio.run(edge_tts.list_voices())]
+                )
+                with gr.Row():
+                    with gr.Column():
+                        tts_text = gr.Textbox(
+                            placeholder="Type your message here...",
+                            label="Text Input",
+                            lines=4
+                        )
+                        tts_voice = gr.Dropdown(tts_voice_list, value=tts_voice_list[0], label="Voice")
+                        tts_play = gr.Checkbox(False, label="🎧 Auto-play audio")
+                        tts_btn = gr.Button("🔊 Generate Speech", variant="secondary")
+                    with gr.Column():
+                        tts_output_audio = gr.File(label="Generated Audio", type="filepath")
+                        tts_preview = gr.Audio(label="Preview", visible=False, autoplay=True)
+
+                tts_btn.click(
+                    infer_tts,
+                    inputs=[tts_voice, tts_text, tts_play],
+                    outputs=[tts_output_audio, tts_preview],
+                ).then(
+                    lambda x: gr.update(visible=bool(x)),
+                    inputs=[tts_preview],
+                    outputs=[tts_preview]
+                )
+
+        # Examples
+        gr.Markdown("### 📚 Examples")
         gr.Examples(
             examples=[
-                [
-                    ["./test.ogg"],
-                    "./model.pth",
-                    "rmvpe+",
-                    0,
-                    "./model.index",
-                    0.75,
-                    3,
-                    0.25,
-                    0.50,
-                ],
-                [
-                    ["./example2/test2.ogg"],
-                    "./example2/model_link.txt",
-                    "rmvpe+",
-                    0,
-                    "./example2/index_link.txt",
-                    0.75,
-                    3,
-                    0.25,
-                    0.50,
-                ],
-                [
-                    ["./example3/test3.wav"],
-                    "./example3/zip_link.txt",
-                    "rmvpe+",
-                    0,
-                    None,
-                    0.75,
-                    3,
-                    0.25,
-                    0.50,
-                ],
-
+                ["./test.ogg", "./model.pth", "rmvpe+", 0, "./model.index", 0.75, 3, 0.25, 0.5, False, False],
+                ["./example3/test3.wav", "./example3/zip_link.txt", "rmvpe+", 0, None, 0.75, 3, 0.25, 0.5, True, True],
             ],
-            fn=run,
             inputs=[
-                aud,
-                model,
-                algo,
-                algo_lvl,
-                indx,
-                indx_inf,
-                res_fc,
-                envel_r,
-                const,
+                audio_input, model_file, pitch_algo, pitch_level, index_file,
+                index_rate, filter_radius, rms_mix_rate, protect, denoise, reverb
             ],
-            outputs=[output_base],
+            outputs=output_files,
+            fn=run_conversion,
             cache_examples=False,
         )
 
     return app
 
 
+# --- Launch App ---
 if __name__ == "__main__":
-
-    tts_voice_list = asyncio.new_event_loop().run_until_complete(edge_tts.list_voices())
-    voices = sorted([f"{v['ShortName']}-{v['Gender']}" for v in tts_voice_list])
-
-    app = get_gui(theme)
-
-    app.queue(default_concurrency_limit=40)
-
+    app = create_ui()
+    app.queue(default_concurrency_limit=10)
     app.launch(
-        max_threads=40,
-        share=False,
-        show_error=True,
-        quiet=False,
+        share=True,
         debug=False,
-        ssr_mode=False,
-        allowed_paths=["./downloads/"],
-    )
+        show_api=False,
+        max_threads=40,
+        allowed_paths=[DOWNLOAD_DIR, OUTPUT_DIR],
+    )