Update gui.py

gui.py

@@ -15,9 +15,10 @@ from processing import process_audio, auto_ensemble_process, ensemble_audio_fn,
 from assets.i18n.i18n import I18nAuto
 from config_manager import load_config, save_config, update_favorites, save_preset, delete_preset
 import logging
+
 logging.basicConfig(filename='sesa_gui.log', level=logging.DEBUG)
 
-# BASE_DIR tanımı
+# BASE_DIR definition
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 CONFIG_DIR = os.path.join(BASE_DIR, "assets")
 CONFIG_FILE = os.path.join(CONFIG_DIR, "config.json")
@@ -33,56 +34,54 @@ initial_presets = user_config["presets"]
 if "auto_category" not in initial_settings or initial_settings["auto_category"] not in MODEL_CONFIGS:
     initial_settings["auto_category"] = "Vocal Models"
 
-# Config dosyası yoksa oluştur
+# Create config file if it doesn't exist
 if not os.path.exists(CONFIG_FILE):
     default_config = {
         "lang": {"override": False, "selected_lang": "auto"},
         "sharing": {
             "method": "gradio",
             "ngrok_token": "",
-            "port": random.randint(1000, 9000)  # Random port instead of fixed
+            "port": random.randint(1000, 9000)
         }
     }
     os.makedirs(CONFIG_DIR, exist_ok=True)
     with open(CONFIG_FILE, "w", encoding="utf-8") as f:
         json.dump(default_config, f, indent=2)
-else:  # If the file exists, load and update if necessary
+else:
     try:
         with open(CONFIG_FILE, "r", encoding="utf-8") as f:
             config = json.load(f)
-        # Ensure 'lang' key exists
         if "lang" not in config:
             config["lang"] = {"override": False, "selected_lang": "auto"}
-        # Add 'sharing' key if it doesn't exist
         if "sharing" not in config:
             config["sharing"] = {
                 "method": "gradio",
                 "ngrok_token": "",
-                "port": random.randint(1000, 9000)  # Random port instead of fixed
+                "port": random.randint(1000, 9000)
             }
-        # Save the updated configuration
+        with off
         with open(CONFIG_FILE, "w", encoding="utf-8") as f:
             json.dump(config, f, indent=2)
-    except json.JSONDecodeError:  # Handle corrupted JSON
+    except json.JSONDecodeError:
         print("Warning: config.json is corrupted. Creating a new one.")
         default_config = {
             "lang": {"override": False, "selected_lang": "auto"},
             "sharing": {
                 "method": "gradio",
                 "ngrok_token": "",
-                "port": random.randint(1000, 9000)  # Random port instead of fixed
+                "port": random.randint(1000, 9000)
             }
         }
         with open(CONFIG_FILE, "w", encoding="utf-8") as f:
             json.dump(default_config, f, indent=2)
 
-# I18nAuto örneği (arayüz başlamadan önce dil yüklenir)
+# Initialize I18nAuto
 i18n = I18nAuto()
 
-# Çıktı formatları
+# Output formats
 OUTPUT_FORMATS = ['wav', 'flac', 'mp3', 'ogg', 'opus', 'm4a', 'aiff', 'ac3']
 
-# Arayüz oluşturma fonksiyonu
+# Interface creation function
 def create_interface():
     css = """
     body {
@@ -198,16 +197,18 @@ def create_interface():
     }
     """
 
-    # Load user config at startup
+    # Load user config
     user_config = load_config()
     initial_settings = user_config["settings"]
     initial_favorites = user_config["favorites"]
     initial_presets = user_config["presets"]
 
     with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
-        current_lang = gr.State(value=i18n.language)
-        favorites_state = gr.State(value=initial_favorites)
-        presets_state = gr.State(value=initial_presets)
+        # Removed gr.State components to avoid schema issues
+        # Use hidden Textbox components to store state instead
+        current_lang = gr.Textbox(value=i18n.language, visible=False)
+        favorites_state = gr.Textbox(value=json.dumps(initial_favorites), visible=False)
+        presets_state = gr.Textbox(value=json.dumps(initial_presets), visible=False)
 
         header_html = gr.HTML(
             value=f"""
@@ -220,16 +221,16 @@ def create_interface():
             with gr.Tab(i18n("audio_separation_tab"), id="separation_tab"):
                 with gr.Row(equal_height=True):
                     with gr.Column(scale=1, min_width=380):
-                        with gr.Accordion(i18n("input_model"), open=True) as input_model_accordion:
+                        with gr.Accordion(i18n("input_model"), open=True):
                             with gr.Tabs():
-                                with gr.Tab(i18n("upload")) as upload_tab:
+                                with gr.Tab(i18n("upload")):
                                     input_audio_file = gr.File(
                                         file_types=[".wav", ".mp3", ".m4a", ".mp4", ".mkv", ".flac"],
-                                        elem_classes=["compact-upload", "horizontal", "x-narrow"],
-                                        label=""
+                                        elem_classes=["compact-upload", "horizontal"],
+                                        label=i18n("upload_file")
                                     )
-                                with gr.Tab(i18n("path")) as path_tab:
-                                    file_path_input = gr.Textbox(placeholder=i18n("path_placeholder"))
+                                with gr.Tab(i18n("path")):
+                                    file_path_input = gr.Textbox(placeholder=i18n("path_placeholder"), label=i18n("file_path"))
 
                             with gr.Row():
                                 model_category = gr.Dropdown(
@@ -245,225 +246,151 @@ def create_interface():
                                 value=initial_settings["selected_model"]
                             )
 
-                        with gr.Accordion(i18n("settings"), open=False) as settings_accordion:
+                        with gr.Accordion(i18n("settings"), open=False):
                             with gr.Row():
-                                with gr.Column(scale=1):
-                                    export_format = gr.Dropdown(
-                                        label=i18n("format"),
-                                        choices=['wav FLOAT', 'flac PCM_16', 'flac PCM_24'],
-                                        value=initial_settings["export_format"]
-                                    )
-                                with gr.Column(scale=1):
-                                    chunk_size = gr.Dropdown(
-                                        label=i18n("chunk_size"),
-                                        choices=[352800, 485100],
-                                        value=initial_settings["chunk_size"],
-                                        info=i18n("chunk_size_info")
-                                    )
+                                export_format = gr.Dropdown(
+                                    label=i18n("format"),
+                                    choices=['wav FLOAT', 'flac PCM_16', 'flac PCM_24'],
+                                    value=initial_settings["export_format"]
+                                )
+                                chunk_size = gr.Dropdown(
+                                    label=i18n("chunk_size"),
+                                    choices=[352800, 485100],
+                                    value=initial_settings["chunk_size"],
+                                    info=i18n("chunk_size_info")
+                                )
 
-                            with gr.Row():
-                                with gr.Column(scale=2):
-                                    overlap = gr.Slider(
-                                        minimum=2,
-                                        maximum=50,
-                                        step=1,
-                                        label=i18n("overlap"),
-                                        value=initial_settings["overlap"],
-                                        info=i18n("overlap_info")
-                                    )
+                            overlap = gr.Slider(
+                                minimum=2,
+                                maximum=50,
+                                step=1,
+                                label=i18n("overlap"),
+                                value=initial_settings["overlap"],
+                                info=i18n("overlap_info")
+                            )
 
-                            with gr.Row():
-                                with gr.Column(scale=1):
-                                    use_tta = gr.Checkbox(
-                                        label=i18n("tta_boost"),
-                                        info=i18n("tta_info"),
-                                        value=initial_settings["use_tta"]
-                                    )
+                            use_tta = gr.Checkbox(
+                                label=i18n("tta_boost"),
+                                info=i18n("tta_info"),
+                                value=initial_settings["use_tta"]
+                            )
 
-                            with gr.Row():
-                                with gr.Column(scale=1):
-                                    use_demud_phaseremix_inst = gr.Checkbox(
-                                        label=i18n("phase_fix"),
-                                        info=i18n("phase_fix_info"),
-                                        value=initial_settings["use_demud_phaseremix_inst"]
-                                    )
+                            use_demud_phaseremix_inst = gr.Checkbox(
+                                label=i18n("phase_fix"),
+                                info=i18n("phase_fix_info"),
+                                value=initial_settings["use_demud_phaseremix_inst"]
+                            )
 
-                                with gr.Column(scale=1):
-                                    extract_instrumental = gr.Checkbox(
-                                        label=i18n("instrumental"),
-                                        info=i18n("instrumental_info"),
-                                        value=initial_settings["extract_instrumental"]
-                                    )
+                            extract_instrumental = gr.Checkbox(
+                                label=i18n("instrumental"),
+                                info=i18n("instrumental_info"),
+                                value=initial_settings["extract_instrumental"]
+                            )
 
-                            with gr.Row():
-                                use_apollo = gr.Checkbox(
-                                    label=i18n("enhance_with_apollo"),
-                                    value=initial_settings["use_apollo"],
-                                    info=i18n("apollo_enhancement_info")
-                                )
+                            use_apollo = gr.Checkbox(
+                                label=i18n("enhance_with_apollo"),
+                                value=initial_settings["use_apollo"],
+                                info=i18n("apollo_enhancement_info")
+                            )
 
                             with gr.Group(visible=initial_settings["use_apollo"]) as apollo_settings_group:
                                 with gr.Row():
-                                    with gr.Column(scale=1):
-                                        apollo_chunk_size = gr.Slider(
-                                            label=i18n("apollo_chunk_size"),
-                                            minimum=3,
-                                            maximum=25,
-                                            step=1,
-                                            value=initial_settings["apollo_chunk_size"],
-                                            info=i18n("apollo_chunk_size_info"),
-                                            interactive=True
-                                        )
-                                    with gr.Column(scale=1):
-                                        apollo_overlap = gr.Slider(
-                                            label=i18n("apollo_overlap"),
-                                            minimum=2,
-                                            maximum=10,
-                                            step=1,
-                                            value=initial_settings["apollo_overlap"],
-                                            info=i18n("apollo_overlap_info"),
-                                            interactive=True
-                                        )
-
-                                with gr.Row():
-                                    apollo_method = gr.Dropdown(
-                                        label=i18n("apollo_processing_method"),
-                                        choices=[i18n("normal_method"), i18n("mid_side_method")],
-                                        value=i18n(initial_settings["apollo_method"]),
-                                        interactive=True
+                                    apollo_chunk_size = gr.Slider(
+                                        label=i18n("apollo_chunk_size"),
+                                        minimum=3,
+                                        maximum=25,
+                                        step=1,
+                                        value=initial_settings["apollo_chunk_size"],
+                                        info=i18n("apollo_chunk_size_info")
                                     )
-
-                                with gr.Row(visible=initial_settings["apollo_method"] != "mid_side_method") as apollo_normal_model_row:
-                                    apollo_normal_model = gr.Dropdown(
-                                        label=i18n("apollo_normal_model"),
-                                        choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
-                                        value=initial_settings["apollo_normal_model"],
-                                        interactive=True
+                                    apollo_overlap = gr.Slider(
+                                        label=i18n("apollo_overlap"),
+                                        minimum=2,
+                                        maximum=10,
+                                        step=1,
+                                        value=initial_settings["apollo_overlap"],
+                                        info=i18n("apollo_overlap_info")
                                     )
 
-                                with gr.Row(visible=initial_settings["apollo_method"] == "mid_side_method") as apollo_midside_model_row:
-                                    apollo_midside_model = gr.Dropdown(
-                                        label=i18n("apollo_mid_side_model"),
-                                        choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
-                                        value=initial_settings["apollo_midside_model"],
-                                        interactive=True
-                                    )
+                                apollo_method = gr.Dropdown(
+                                    label=i18n("apollo_processing_method"),
+                                    choices=[i18n("normal_method"), i18n("mid_side_method")],
+                                    value=i18n(initial_settings["apollo_method"])
+                                )
 
-                            with gr.Row():
-                                use_matchering = gr.Checkbox(
-                                    label=i18n("apply_matchering"),
-                                    value=initial_settings.get("use_matchering", False),
-                                    info=i18n("matchering_info")
+                                apollo_normal_model_row = gr.Row(visible=initial_settings["apollo_method"] != "mid_side_method")
+                                apollo_normal_model = gr.Dropdown(
+                                    label=i18n("apollo_normal_model"),
+                                    choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
+                                    value=initial_settings["apollo_normal_model"],
+                                    container=apollo_normal_model_row
                                 )
 
-                            with gr.Group(visible=initial_settings.get("use_matchering", True)) as matchering_settings_group:
-                                matchering_passes = gr.Slider(
-                                    label=i18n("matchering_passes"),
-                                    minimum=1,
-                                    maximum=5,
-                                    step=1,
-                                    value=initial_settings.get("matchering_passes", 1),
-                                    info=i18n("matchering_passes_info"),
-                                    interactive=True
+                                apollo_midside_model_row = gr.Row(visible=initial_settings["apollo_method"] == "mid_side_method")
+                                apollo_midside_model = gr.Dropdown(
+                                    label=i18n("apollo_mid_side_model"),
+                                    choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
+                                    value=initial_settings["apollo_midside_model"],
+                                    container=apollo_midside_model_row
                                 )
 
+                            use_matchering = gr.Checkbox(
+                                label=i18n("apply_matchering"),
+                                value=initial_settings.get("use_matchering", False),
+                                info=i18n("matchering_info")
+                            )
+
+                            with gr0
+                            matchering_settings_group = gr.Group(visible=initial_settings.get("use_matchering", True))
+                            matchering_passes = gr.Slider(
+                                label=i18n("matchering_passes"),
+                                minimum=1,
+                                maximum=5,
+                                step=1,
+                                value=initial_settings.get("matchering_passes", 1),
+                                info=i18n("matchering_passes_info")
+                            )
+
                         with gr.Row():
                             process_btn = gr.Button(i18n("process"), variant="primary")
                             clear_old_output_btn = gr.Button(i18n("reset"), variant="secondary")
                         clear_old_output_status = gr.Textbox(label=i18n("status"), interactive=False)
 
-                        # Favorite handler
-                        def update_favorite_button(model, favorites):
-                            cleaned_model = clean_model(model) if model else None
-                            is_favorited = cleaned_model in favorites if cleaned_model else False
-                            return gr.update(value=i18n("remove_favorite") if is_favorited else i18n("add_favorite"))
-
-                        def toggle_favorite(model, favorites):
-                            if not model:
-                                return favorites, gr.update(), gr.update()
-                            cleaned_model = clean_model(model)
-                            is_favorited = cleaned_model in favorites
-                            new_favorites = update_favorites(favorites, cleaned_model, add=not is_favorited)
-                            save_config(new_favorites, load_config()["settings"], load_config()["presets"])
-                            category = model_category.value
-                            return (
-                                new_favorites,
-                                gr.update(choices=update_model_dropdown(category, favorites=new_favorites)["choices"]),
-                                gr.update(value=i18n("add_favorite") if is_favorited else i18n("remove_favorite"))
-                            )
-
-                        model_dropdown.change(
-                            fn=update_favorite_button,
-                            inputs=[model_dropdown, favorites_state],
-                            outputs=favorite_button
-                        )
-
-                        favorite_button.click(
-                            fn=toggle_favorite,
-                            inputs=[model_dropdown, favorites_state],
-                            outputs=[favorites_state, model_dropdown, favorite_button]
-                        )
-
-                        use_apollo.change(
-                            fn=lambda x: gr.update(visible=x),
-                            inputs=use_apollo,
-                            outputs=apollo_settings_group
-                        )
-
-                        use_matchering.change(
-                            fn=lambda x: gr.update(visible=x),
-                            inputs=use_matchering,
-                            outputs=matchering_settings_group
-                        )
-
-                        apollo_method.change(
-                            fn=lambda x: [
-                                gr.update(visible=x != i18n("mid_side_method")),
-                                gr.update(visible=x == i18n("mid_side_method")),
-                                "Apollo Universal Model" if x == i18n("mid_side_method") else None
-                            ],
-                            inputs=apollo_method,
-                            outputs=[apollo_normal_model_row, apollo_midside_model_row, apollo_normal_model]
-                        )
-
                     with gr.Column(scale=2, min_width=800):
                         with gr.Tabs():
-                            with gr.Tab(i18n("main_tab")) as main_tab:
-                                with gr.Column():
-                                    original_audio = gr.Audio(label=i18n("original"), interactive=False)
-                                    with gr.Row():
-                                        vocals_audio = gr.Audio(label=i18n("vocals"), show_download_button=True)
-                                        instrumental_audio = gr.Audio(label=i18n("instrumental_output"), show_download_button=True)
-                                        other_audio = gr.Audio(label=i18n("other"), show_download_button=True)
-
-                            with gr.Tab(i18n("details_tab")) as details_tab:
-                                with gr.Column():
-                                    with gr.Row():
-                                        male_audio = gr.Audio(label=i18n("male"))
-                                        female_audio = gr.Audio(label=i18n("female"))
-                                        speech_audio = gr.Audio(label=i18n("speech"))
-                                    with gr.Row():
-                                        drum_audio = gr.Audio(label=i18n("drums"))
-                                        bass_audio = gr.Audio(label=i18n("bass"))
-                                    with gr.Row():
-                                        effects_audio = gr.Audio(label=i18n("effects"))
-
-                            with gr.Tab(i18n("advanced_tab")) as advanced_tab:
-                                with gr.Column():
-                                    with gr.Row():
-                                        phaseremix_audio = gr.Audio(label=i18n("phase_remix"))
-                                        dry_audio = gr.Audio(label=i18n("dry"))
-                                    with gr.Row():
-                                        music_audio = gr.Audio(label=i18n("music"))
-                                        karaoke_audio = gr.Audio(label=i18n("karaoke"))
-                                        bleed_audio = gr.Audio(label=i18n("bleed"))
+                            with gr.Tab(i18n("main_tab")):
+                                original_audio = gr.Audio(label=i18n("original"), interactive=True)
+                                with gr.Row():
+                                    vocals_audio = gr.Audio(label=i18n("vocals"), show_download_button=True)
+                                    instrumental_audio = gr.Audio(label=i18n("instrumental_output"), show_download_button=True)
+                                    other_audio = gr.Audio(label=i18n("other"), show_download_button=True)
+
+                            with gr.Tab(i18n("details_tab")):
+                                with gr.Row():
+                                    male_audio = gr.Audio(label=i18n("male"))
+                                    female_audio = gr.Audio(label=i18n("female"))
+                                    speech_audio = gr.Audio(label=i18n("speech"))
+                                with gr.Row():
+                                    drum_audio = gr.Audio(label=i18n("drums"))
+                                    bass_audio = gr.Audio(label=i18n("bass"))
+                                with gr.Row():
+                                    effects_audio = gr.Audio(label=i18n("effects"))
+
+                            with gr.Tab(i18n("advanced_tab")):
+                                with gr.Row():
+                                    phaseremix_audio = gr.Audio(label=i18n("phase_remix"))
+                                    dry_audio = gr.Audio(label=i18n("dry"))
+                                with gr.Row():
+                                    music_audio = gr.Audio(label=i18n("music"))
+                                    karaoke_audio = gr.Audio(label=i18n("karaoke"))
+                                    bleed_audio = gr.Audio(label=i18n("bleed"))
 
                         separation_progress_html = gr.HTML(
                             value=f"""
-                            <div id="custom-progress" style="margin-top: 10px;">
-                                <div style="font-size: 1rem; color: #C0C0C0; margin-bottom: 5px;" id="progress-label">{i18n("waiting_for_processing")}</div>
-                                <div style="width: 100%; background-color: #444; border-radius: 5px; overflow: hidden;">
-                                    <div id="progress-bar" style="width: 0%; height: 20px; background-color: #6e8efb; transition: width 0.3s;"></div>
+                            <div id="custom-progress">
+                                <div id="progress-label">{i18n("waiting_for_processing")}</div>
+                                <div style="width: 100%; background-color: #444; border-radius: 5px;">
+                                    <div id="progress-bar" style="width: 0%;"></div>
                                 </div>
                             </div>
                             """
@@ -486,11 +413,10 @@ def create_interface():
                             )
                             auto_file_path_input = gr.Textbox(
                                 label=i18n("enter_file_path"),
-                                placeholder=i18n("file_path_placeholder"),
-                                interactive=True
+                                placeholder=i18n("file_path_placeholder")
                             )
 
-                        with gr.Accordion(i18n("advanced_settings"), open=False) as auto_settings_accordion:
+                        with gr.Accordion(i18n("advanced_settings"), open=False):
                             with gr.Row():
                                 auto_use_tta = gr.Checkbox(label=i18n("use_tta"), value=False)
                                 auto_extract_instrumental = gr.Checkbox(label=i18n("instrumental_only"))
@@ -514,76 +440,67 @@ def create_interface():
                                     value='wav FLOAT'
                                 )
 
-                            with gr.Row():
-                                auto_use_apollo = gr.Checkbox(
-                                    label=i18n("enhance_with_apollo"),
-                                    value=False,
-                                    info=i18n("apollo_enhancement_info")
-                                )
+                            auto_use_apollo = gr.Checkbox(
+                                label=i18n("enhance_with_apollo"),
+                                value=False,
+                                info=i18n("apollo_enhancement_info")
+                            )
 
                             with gr.Group(visible=False) as auto_apollo_settings_group:
                                 with gr.Row():
-                                    with gr.Column(scale=1):
-                                        auto_apollo_chunk_size = gr.Slider(
-                                            label=i18n("apollo_chunk_size"),
-                                            minimum=3,
-                                            maximum=25,
-                                            step=1,
-                                            value=19,
-                                            info=i18n("apollo_chunk_size_info"),
-                                            interactive=True
-                                        )
-                                    with gr.Column(scale=1):
-                                        auto_apollo_overlap = gr.Slider(
-                                            label=i18n("apollo_overlap"),
-                                            minimum=2,
-                                            maximum=10,
-                                            step=1,
-                                            value=2,
-                                            info=i18n("apollo_overlap_info"),
-                                            interactive=True
-                                        )
-
-                                with gr.Row():
-                                    auto_apollo_method = gr.Dropdown(
-                                        label=i18n("apollo_processing_method"),
-                                        choices=[i18n("normal_method"), i18n("mid_side_method")],
-                                        value=i18n("normal_method"),
-                                        interactive=True
+                                    auto_apollo_chunk_size = gr.Slider(
+                                        label=i18n("apollo_chunk_size"),
+                                        minimum=3,
+                                        maximum=25,
+                                        step=1,
+                                        value=19,
+                                        info=i18n("apollo_chunk_size_info")
                                     )
-
-                                with gr.Row(visible=True) as auto_apollo_normal_model_row:
-                                    auto_apollo_normal_model = gr.Dropdown(
-                                        label=i18n("apollo_normal_model"),
-                                        choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
-                                        value="Apollo Universal Model",
-                                        interactive=True
+                                    auto_apollo_overlap = gr.Slider(
+                                        label=i18n("apollo_overlap"),
+                                        minimum=2,
+                                        maximum=10,
+                                        step=1,
+                                        value=2,
+                                        info=i18n("apollo_overlap_info")
                                     )
 
-                                with gr.Row(visible=False) as auto_apollo_midside_model_row:
-                                    auto_apollo_midside_model = gr.Dropdown(
-                                        label=i18n("apollo_mid_side_model"),
-                                        choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
-                                        value="Apollo Universal Model",
-                                        interactive=True
-                                    )
+                                auto_apollo_method = gr.Dropdown(
+                                    label=i18n("apollo_processing_method"),
+                                    choices=[i18n("normal_method"), i18n("mid_side_method")],
+                                    value=i18n("normal_method")
+                                )
 
-                            with gr.Row():
-                                auto_use_matchering = gr.Checkbox(
-                                    label=i18n("apply_matchering"),
-                                    value=False,
-                                    info=i18n("matchering_info")
+                                auto_apollo_normal_model_row = gr.Row(visible=True)
+                                auto_apollo_normal_model = gr.Dropdown(
+                                    label=i18n("apollo_normal_model"),
+                                    choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
+                                    value="Apollo Universal Model",
+                                    container=auto_apollo_normal_model_row
                                 )
 
-                            with gr.Group(visible=True) as auto_matchering_settings_group:
+                                auto_apollo_midside_model_row = gr.Row(visible=False)
+                                auto_apollo_midside_model = gr.Dropdown(
+                                    label=i18n("apollo_mid_side_model"),
+                                    choices=["MP3 Enhancer", "Lew Vocal Enhancer", "Lew Vocal Enhancer v2 (beta)", "Apollo Universal Model"],
+                                    value="Apollo Universal Model",
+                                    container=auto_apollo_midside_model_row
+                                )
+
+                            auto_use_matchering = gr.Checkbox(
+                                label=i18n("apply_matchering"),
+                                value=False,
+                                info=i18n("matchering_info")
+                            )
+
+                            with gr.Group(visible=False) as auto_matchering_settings_group:
                                 auto_matchering_passes = gr.Slider(
                                     label=i18n("matchering_passes"),
                                     minimum=1,
                                     maximum=5,
                                     step=1,
                                     value=1,
-                                    info=i18n("matchering_passes_info"),
-                                    interactive=True
+                                    info=i18n("matchering_passes_info")
                                 )
 
                         with gr.Group():
@@ -601,19 +518,16 @@ def create_interface():
                                     multiselect=True
                                 )
 
-                            with gr.Row():
-                                preset_dropdown = gr.Dropdown(
-                                    label=i18n("select_preset"),
-                                    choices=list(initial_presets.keys()),
-                                    value=None,
-                                    allow_custom_value=False,
-                                    interactive=True
-                                )
+                            preset_dropdown = gr.Dropdown(
+                                label=i18n("select_preset"),
+                                choices=list(initial_presets.keys()),
+                                value=None,
+                                allow_custom_value=False
+                            )
                             with gr.Row():
                                 preset_name_input = gr.Textbox(
                                     label=i18n("preset_name"),
-                                    placeholder=i18n("enter_preset_name"),
-                                    interactive=True
+                                    placeholder=i18n("enter_preset_name")
                                 )
                                 save_preset_btn = gr.Button(i18n("save_preset"), variant="secondary", scale=0)
                                 delete_preset_btn = gr.Button(i18n("delete_preset"), variant="secondary", scale=0)
@@ -621,133 +535,39 @@ def create_interface():
 
                         with gr.Group():
                             ensemble_settings_header = gr.Markdown(f"### {i18n('ensemble_settings')}")
-                            with gr.Row():
-                                auto_ensemble_type = gr.Dropdown(
-                                    label=i18n("method"),
-                                    choices=['avg_wave', 'median_wave', 'min_wave', 'max_wave',
-                                             'avg_fft', 'median_fft', 'min_fft', 'max_fft'],
-                                    value=initial_settings["auto_ensemble_type"]
-                                )
+                            auto_ensemble_type = gr.Dropdown(
+                                label=i18n("method"),
+                                choices=['avg_wave', 'median_wave', 'min_wave', 'max_wave',
+                                         'avg_fft', 'median_fft', 'min_fft', 'max_fft'],
+                                value=initial_settings["auto_ensemble_type"]
+                            )
 
                             ensemble_recommendation = gr.Markdown(i18n("recommendation"))
 
                         auto_process_btn = gr.Button(i18n("start_processing"), variant="primary")
 
-                        def load_preset(preset_name, presets, category, favorites):
-                            if preset_name and preset_name in presets:
-                                preset = presets[preset_name]
-                                # Mark starred models with ⭐
-                                favorite_models = [f"{model} ⭐" if model in favorites else model for model in preset["models"]]
-                                # Get the category from the preset, default to current category if not specified
-                                preset_category = preset.get("auto_category_dropdown", category)
-                                # Update model choices based on the preset's category
-                                model_choices = update_model_dropdown(preset_category, favorites=favorites)["choices"]
-                                print(f"Preset '{preset_name}' loaded with models: {favorite_models}, category: {preset_category}")
-                                return (
-                                    gr.update(value=preset_category),  # Update auto_category_dropdown
-                                    gr.update(choices=model_choices, value=favorite_models),  # Update selected_models
-                                    gr.update(value=preset["ensemble_method"])  # Update auto_ensemble_type
-                                )
-                            print(f"Preset '{preset_name}' not found.")
-                            return gr.update(), gr.update(), gr.update()
-
-                        def sync_presets():
-                            """Reload presets from config and update dropdown."""
-                            config = load_config()
-                            return config["presets"], gr.update(choices=list(config["presets"].keys()), value=None)
-
-                        preset_dropdown.change(
-                            fn=load_preset,
-                            inputs=[preset_dropdown, presets_state, auto_category_dropdown, favorites_state],
-                            outputs=[auto_category_dropdown, selected_models, auto_ensemble_type]
-                        )
-
-                        def handle_save_preset(preset_name, models, ensemble_method, presets, favorites, auto_category_dropdown):
-                            if not preset_name:
-                                return gr.update(), presets, i18n("no_preset_name_provided")
-                            if not models and not favorites:
-                                return gr.update(), presets, i18n("no_models_selected_for_preset")
-                            new_presets = save_preset(
-                                presets, 
-                                preset_name, 
-                                models, 
-                                ensemble_method,
-                                auto_category_dropdown=auto_category_dropdown  # Pass the category explicitly
-                            )
-                            save_config(favorites, load_config()["settings"], new_presets)
-                            print(f"Preset dropdown updated with choices: {list(new_presets.keys())}")
-                            return gr.update(choices=list(new_presets.keys()), value=None), new_presets, i18n("preset_saved").format(preset_name)
-
-                        save_preset_btn.click(
-                            fn=handle_save_preset,
-                            inputs=[preset_name_input, selected_models, auto_ensemble_type, presets_state, favorites_state, auto_category_dropdown],
-                            outputs=[preset_dropdown, presets_state]
-                        )
-
-                        def handle_delete_preset(preset_name, presets):
-                            if not preset_name or preset_name not in presets:
-                                return gr.update(), presets
-                            new_presets = delete_preset(presets, preset_name)
-                            save_config(load_config()["favorites"], load_config()["settings"], new_presets)
-                            return gr.update(choices=list(new_presets.keys()), value=None), new_presets
-
-                        delete_preset_btn.click(
-                            fn=handle_delete_preset,
-                            inputs=[preset_dropdown, presets_state],
-                            outputs=[preset_dropdown, presets_state]
-                        )
-
-                        refresh_presets_btn.click(
-                            fn=sync_presets,
-                            inputs=[],
-                            outputs=[presets_state, preset_dropdown]
-                        )
-
-                        auto_use_apollo.change(
-                            fn=lambda x: gr.update(visible=x),
-                            inputs=auto_use_apollo,
-                            outputs=auto_apollo_settings_group
-                        )
-
-                        auto_use_matchering.change(
-                            fn=lambda x: gr.update(visible=x),
-                            inputs=auto_use_matchering,
-                            outputs=auto_matchering_settings_group
-                        )
-
-                        auto_apollo_method.change(
-                            fn=lambda x: [
-                                gr.update(visible=x != i18n("mid_side_method")),
-                                gr.update(visible=x == i18n("mid_side_method")),
-                                "Apollo Universal Model" if x == i18n("mid_side_method") else None
-                            ],
-                            inputs=auto_apollo_method,
-                            outputs=[auto_apollo_normal_model_row, auto_apollo_midside_model_row, auto_apollo_normal_model]
-                        )
-
                     with gr.Column():
                         with gr.Tabs():
-                            with gr.Tab(i18n("original_audio_tab")) as original_audio_tab:
+                            with gr.Tab(i18n("original_audio_tab")):
                                 original_audio2 = gr.Audio(
                                     label=i18n("original_audio"),
-                                    interactive=False,
-                                    every=1,
+                                    interactive=True,
                                     elem_id="original_audio_player"
                                 )
-                            with gr.Tab(i18n("ensemble_result_tab")) as ensemble_result_tab:
+                            with gr.Tab(i18n("ensemble_result_tab")):
                                 auto_output_audio = gr.Audio(
                                     label=i18n("output_preview"),
                                     show_download_button=True,
-                                    interactive=False
+                                    interactive=True
                                 )
                                 refresh_output_btn = gr.Button(i18n("refresh_output"), variant="secondary")
 
                         ensemble_progress_html = gr.HTML(
                             value=f"""
-                            <div id="custom-progress" style="margin-top: 10px;">
-                                <div style="font-size: 1rem; color: #C0C0C0; margin-bottom: 5px;" id="progress-label">{i18n("waiting_for_processing")}</div>
-                                <div style="width: 100%; background-color: #444; border-radius: 5px; overflow: hidden;">
-                                    <div id="progress-bar" style="width: 0%; height: 20px; background-color: #6e8efb; transition: width 0.3s;"></div>
+                            <div id="custom-progress">
+                                <div id="progress-label">{i18n("waiting_for_processing")}</div>
+                                <div style="width: 100%; background-color: #444; border-radius: 5px;">
+                                    <div id="progress-bar" style="width: 0%;"></div>
                                 </div>
                             </div>
                             """
@@ -758,7 +578,7 @@ def create_interface():
                             placeholder=i18n("waiting_for_processing"),
                             visible=False
                         )
-                        
+
             with gr.Tab(i18n("download_sources_tab"), id="download_tab"):
                 with gr.Row():
                     with gr.Column():
@@ -781,7 +601,7 @@ def create_interface():
             with gr.Tab(i18n("manual_ensemble_tab"), id="manual_ensemble_tab"):
                 with gr.Row(equal_height=True):
                     with gr.Column(scale=1, min_width=400):
-                        with gr.Accordion(i18n("input_sources"), open=True) as input_sources_accordion:
+                        with gr.Accordion(i18n("input_sources"), open=True):
                             with gr.Row():
                                 refresh_btn = gr.Button(i18n("refresh"), variant="secondary", size="sm")
                                 ensemble_type = gr.Dropdown(
@@ -809,14 +629,14 @@ def create_interface():
 
                     with gr.Column(scale=2, min_width=800):
                         with gr.Tabs():
-                            with gr.Tab(i18n("result_preview_tab")) as result_preview_tab:
+                            with gr.Tab(i18n("result_preview_tab")):
                                 ensemble_output_audio = gr.Audio(
                                     label=i18n("ensembled_output"),
-                                    interactive=False,
+                                    interactive=True,
                                     show_download_button=True,
                                     elem_id="output-audio"
                                 )
-                            with gr.Tab(i18n("processing_log_tab")) as processing_log_tab:
+                            with gr.Tab(i18n("processing_log_tab")):
                                 with gr.Accordion(i18n("processing_details"), open=True, elem_id="log-accordion"):
                                     ensemble_status = gr.Textbox(
                                         label="",
@@ -826,13 +646,161 @@ def create_interface():
                                         max_lines=20,
                                         elem_id="log-box"
                                     )
-                        with gr.Row():
-                            ensemble_process_btn = gr.Button(
-                                i18n("process_ensemble"),
-                                variant="primary",
-                                size="sm",
-                                elem_id="process-btn"
-                            )
+                        ensemble_process_btn = gr.Button(
+                            i18n("process_ensemble"),
+                            variant="primary",
+                            size="sm",
+                            elem_id="process-btn"
+                        )
+
+        # Event handlers
+        def update_favorite_button(model, favorites_json):
+            favorites = json.loads(favorites_json)
+            cleaned_model = clean_model(model) if model else None
+            is_favorited = cleaned_model in favorites if cleaned_model else False
+            return gr.update(value=i18n("remove_favorite") if is_favorited else i18n("add_favorite"))
+
+        def toggle_favorite(model, favorites_json):
+            favorites = json.loads(favorites_json)
+            if not model:
+                return json.dumps(favorites), gr.update(), gr.update()
+            cleaned_model = clean_model(model)
+            is_favorited = cleaned_model in favorites
+            new_favorites = update_favorites(favorites, cleaned_model, add=not is_favorited)
+            save_config(new_favorites, load_config()["settings"], load_config()["presets"])
+            category = model_category.value
+            return (
+                json.dumps(new_favorites),
+                gr.update(choices=update_model_dropdown(category, favorites=new_favorites)["choices"]),
+                gr.update(value=i18n("add_favorite") if is_favorited else i18n("remove_favorite"))
+            )
+
+        model_dropdown.change(
+            fn=update_favorite_button,
+            inputs=[model_dropdown, favorites_state],
+            outputs=favorite_button
+        )
+
+        favorite_button.click(
+            fn=toggle_favorite,
+            inputs=[model_dropdown, favorites_state],
+            outputs=[favorites_state, model_dropdown, favorite_button]
+        )
+
+        use_apollo.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=use_apollo,
+            outputs=apollo_settings_group
+        )
+
+        use_matchering.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=use_matchering,
+            outputs=matchering_settings_group
+        )
+
+        apollo_method.change(
+            fn=lambda x: [
+                gr.update(visible=x != i18n("mid_side_method")),
+                gr.update(visible=x == i18n("mid_side_method")),
+                "Apollo Universal Model" if x == i18n("mid_side_method") else None
+            ],
+            inputs=apollo_method,
+            outputs=[apollo_normal_model_row, apollo_midside_model_row, apollo_normal_model]
+        )
+
+        def load_preset(preset_name, presets_json, category, favorites_json):
+            presets = json.loads(presets_json)
+            favorites = json.loads(favorites_json)
+            if preset_name and preset_name in presets:
+                preset = presets[preset_name]
+                favorite_models = [f"{model} ⭐" if model in favorites else model for model in preset["models"]]
+                preset_category = preset.get("auto_category_dropdown", category)
+                model_choices = update_model_dropdown(preset_category, favorites=favorites)["choices"]
+                logging.debug(f"Preset '{preset_name}' loaded with models: {favorite_models}, category: {preset_category}")
+                return (
+                    gr.update(value=preset_category),
+                    gr.update(choices=model_choices, value=favorite_models),
+                    gr.update(value=preset["ensemble_method"])
+                )
+            logging.debug(f"Preset '{preset_name}' not found.")
+            return gr.update(), gr.update(), gr.update()
+
+        def sync_presets():
+            config = load_config()
+            return json.dumps(config["presets"]), gr.update(choices=list(config["presets"].keys()), value=None)
+
+        preset_dropdown.change(
+            fn=load_preset,
+            inputs=[preset_dropdown, presets_state, auto_category_dropdown, favorites_state],
+            outputs=[auto_category_dropdown, selected_models, auto_ensemble_type]
+        )
+
+        def handle_save_preset(preset_name, models, ensemble_method, presets_json, favorites_json, auto_category_dropdown):
+            presets = json.loads(presets_json)
+            favorites = json.loads(favorites_json)
+            if not preset_name:
+                return gr.update(), json.dumps(presets), i18n("no_preset_name_provided")
+            if not models and not favorites:
+                return gr.update(), json.dumps(presets), i18n("no_models_selected_for_preset")
+            new_presets = save_preset(
+                presets,
+                preset_name,
+                models,
+                ensemble_method,
+                auto_category_dropdown=auto_category_dropdown
+            )
+            save_config(favorites, load_config()["settings"], new_presets)
+            logging.debug(f"Preset dropdown updated with choices: {list(new_presets.keys())}")
+            return gr.update(choices=list(new_presets.keys()), value=None), json.dumps(new_presets), i18n("preset_saved").format(preset_name)
+
+        save_preset_btn.click(
+            fn=handle_save_preset,
+            inputs=[preset_name_input, selected_models, auto_ensemble_type, presets_state, favorites_state, auto_category_dropdown],
+            outputs=[preset_dropdown, presets_state]
+        )
+
+        def handle_delete_preset(preset_name, presets_json):
+            presets = json.loads(presets_json)
+            if not preset_name or preset_name not in presets:
+                return gr.update(), json.dumps(presets)
+            new_presets = delete_preset(presets, preset_name)
+            save_config(load_config()["favorites"], load_config()["settings"], new_presets)
+            return gr.update(choices=list(new_presets.keys()), value=None), json.dumps(new_presets)
+
+        delete_preset_btn.click(
+            fn=handle_delete_preset,
+            inputs=[preset_dropdown, presets_state],
+            outputs=[preset_dropdown, presets_state]
+        )
+
+        refresh_presets_btn.click(
+            fn=sync_presets,
+            inputs=[],
+            outputs=[presets_state, preset_dropdown]
+        )
+
+        auto_use_apollo.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=auto_use_apollo,
+            outputs=auto_apollo_settings_group
+        )
+
+        auto_use_matchering.change(
+            fn=lambda x: gr.update(visible=x),
+            inputs=auto_use_matchering,
+            outputs=auto_matchering_settings_group
+        )
+
+        auto_apollo_method.change(
+            fn=lambda x: [
+                gr.update(visible=x != i18n("mid_side_method")),
+                gr.update(visible=x == i18n("mid_side_method")),
+                "Apollo Universal Model" if x == i18n("mid_side_method") else None
+            ],
+            inputs=auto_apollo_method,
+            outputs=[auto_apollo_normal_model_row, auto_apollo_midside_model_row, auto_apollo_normal_model]
+        )
 
         def save_settings_on_process(*args):
             apollo_method_value = args[11]
@@ -865,11 +833,10 @@ def create_interface():
 
         def save_auto_ensemble_settings(*args):
             settings = load_config()["settings"]
-            settings["auto_ensemble_type"] = args[7]
+            settings["auto_Ensemble_type"] = args[7]
             settings["use_matchering"] = args[14]
             settings["matchering_passes"] = args[15]
             save_config(load_config()["favorites"], settings, load_config()["presets"])
-            # Handle generator output from auto_ensemble_process
             output_audio, status, progress_html = None, i18n("waiting_for_processing"), ensemble_progress_html.value
             for update in auto_ensemble_process(*args):
                 if isinstance(update, tuple) and len(update) == 3:
@@ -932,7 +899,7 @@ def create_interface():
             cleaned_args[1] = clean_model(cleaned_args[1]) if cleaned_args[1] else None
             cleaned_args[17] = clean_model(cleaned_args[17]) if cleaned_args[17] else None
             for name, value in zip(input_names, cleaned_args):
-                print(f"UI Input - {name}: {value}")
+                logging.debug(f"UI Input - {name}: {value}")
             return args
 
         process_btn.click(
@@ -991,4 +958,4 @@ def create_interface():
         refresh_btn.click(fn=update_file_list, outputs=file_dropdown)
         ensemble_process_btn.click(fn=ensemble_audio_fn, inputs=[file_dropdown, ensemble_type, weights_input], outputs=[ensemble_output_audio, ensemble_status])
 
-        return demo
+        return demo