Update app.py

app.py

@@ -338,16 +338,16 @@ def download_audio(url, cookie_file=None):
             temp_output_path = 'ytdl/gdrive_temp_audio'
             gdown.download(download_url, temp_output_path, quiet=False)
             if not os.path.exists(temp_output_path):
-                return None, "İndirilen dosya bulunamadı", None
+                return None, "Downloaded file not found", None
             from mimetypes import guess_type
             mime_type, _ = guess_type(temp_output_path)
             if not mime_type or not mime_type.startswith('audio'):
-                return None, "İndirilen dosya bir ses dosyası değil", None
+                return None, "Downloaded file is not an audio file", None
             output_path = 'ytdl/gdrive_audio.wav'
             audio = AudioSegment.from_file(temp_output_path)
             audio.export(output_path, format="wav")
             sample_rate, data = wavfile.read(output_path)
-            return output_path, "İndirme başarılı", (sample_rate, data)
+            return output_path, "Download successful", (sample_rate, data)
         else:
             os.makedirs('ytdl', exist_ok=True)
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
@@ -357,24 +357,24 @@ def download_audio(url, cookie_file=None):
                 for ext in ['.webm', '.m4a', '.opus', '.aac']:
                     file_path = file_path.replace(ext, '.wav')
                 if not os.path.exists(file_path):
-                    return None, "İndirilen dosya bulunamadı", None
+                    return None, "Downloaded file not found", None
                 sample_rate, data = wavfile.read(file_path)
-                return file_path, "İndirme başarılı", (sample_rate, data)
+                return file_path, "Download successful", (sample_rate, data)
     except yt_dlp.utils.ExtractorError as e:
         if "Sign in to confirm you’re not a bot" in str(e):
-            return None, "Kimlik doğrulama hatası. Lütfen geçerli YouTube çerezleri yükleyin: https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies", None
-        return None, f"İndirme hatası: {str(e)}", None
+            return None, "Authentication error. Please upload valid YouTube cookies: https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies", None
+        return None, f"Download error: {str(e)}", None
     except Exception as e:
-        return None, f"Beklenmeyen hata: {str(e)}", None
+        return None, f"Unexpected error: {str(e)}", None
     finally:
         if temp_output_path and os.path.exists(temp_output_path):
             os.remove(temp_output_path)
-            logger.info(f"Geçici dosya silindi: {temp_output_path}")
+            logger.info(f"Temporary file deleted: {temp_output_path}")
 
 @spaces.GPU
 def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, pitch_shift, model_dir, output_dir, out_format, norm_thresh, amp_thresh, batch_size, exclude_stems="", progress=gr.Progress(track_tqdm=True)):
     if not audio:
-        raise ValueError("Ses dosyası sağlanmadı.")
+        raise ValueError("No audio file provided.")
     temp_audio_path = None
     try:
         if isinstance(audio, tuple):
@@ -383,7 +383,7 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
             scipy.io.wavfile.write(temp_audio_path, sample_rate, data)
             audio = temp_audio_path
         if seg_size > 512:
-            logger.warning(f"Segment boyutu {seg_size} büyük, bu ZeroGPU'da çökmelere neden olabilir.")
+            logger.warning(f"Segment size {seg_size} is large, this may cause crashes on ZeroGPU.")
         override_seg_size = override_seg_size == "True"
         if os.path.exists(output_dir):
             shutil.rmtree(output_dir)
@@ -394,8 +394,8 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
                 model = models[model_key]
                 break
         else:
-            raise ValueError(f"Model '{model_key}' bulunamadı.")
-        logger.info(f"{base_name} ayrıştırılıyor, model: {model_key}, cihaz: {device}")
+            raise ValueError(f"Model '{model_key}' not found.")
+        logger.info(f"Separating {base_name} with {model_key} on {device}")
         separator = Separator(
             log_level=logging.INFO,
             model_file_dir=model_dir,
@@ -406,9 +406,9 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
             use_autocast=use_autocast,
             mdxc_params={"segment_size": seg_size, "override_model_segment_size": override_seg_size, "batch_size": batch_size, "overlap": overlap, "pitch_shift": pitch_shift}
         )
-        progress(0.2, desc="Model yükleniyor...")
+        progress(0.2, desc="Loading model...")
         separator.load_model(model_filename=model)
-        progress(0.7, desc="Ses ayrıştırılıyor...")
+        progress(0.7, desc="Separating audio...")
         separation = separator.separate(audio)
         stems = [os.path.join(output_dir, file_name) for file_name in separation]
         if exclude_stems.strip():
@@ -417,15 +417,15 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
             return filtered_stems[0] if filtered_stems else None, filtered_stems[1] if len(filtered_stems) > 1 else None
         return stems[0], stems[1] if len(stems) > 1 else None
     except Exception as e:
-        logger.error(f"Ayrıştırma hatası: {e}")
-        raise RuntimeError(f"Ayrıştırma hatası: {e}")
+        logger.error(f"Separation error: {e}")
+        raise RuntimeError(f"Separation error: {e}")
     finally:
         if temp_audio_path and os.path.exists(temp_audio_path):
             os.remove(temp_audio_path)
-            logger.info(f"Geçici dosya silindi: {temp_audio_path}")
+            logger.info(f"Temporary file deleted: {temp_audio_path}")
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-            logger.info("GPU belleği temizlendi")
+            logger.info("GPU memory cleared")
 
 @spaces.GPU
 def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_format="wav", use_tta="False", model_dir="/tmp/audio-separator-models/", output_dir="output", norm_thresh=0.9, amp_thresh=0.9, batch_size=1, ensemble_method="avg_wave", exclude_stems="", weights_str=""):
@@ -433,9 +433,9 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
     chunk_paths = []
     try:
         if not audio:
-            raise ValueError("Ses dosyası sağlanmadı.")
+            raise ValueError("No audio file provided.")
         if not model_keys:
-            raise ValueError("Model seçilmedi.")
+            raise ValueError("No models selected.")
         if isinstance(audio, tuple):
             sample_rate, data = audio
             temp_audio_path = os.path.join("/tmp", "temp_audio.wav")
@@ -443,11 +443,11 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
             audio = temp_audio_path
         audio_data, sr = librosa.load(audio, sr=None, mono=False)
         duration = librosa.get_duration(y=audio_data, sr=sr)
-        logger.info(f"Ses süresi: {duration:.2f} saniye")
+        logger.info(f"Audio duration: {duration:.2f} seconds")
         chunk_duration = 300
         chunks = []
         if duration > 900:
-            logger.info(f"Ses 15 dakikadan uzun, {chunk_duration}-saniyelik parçalara bölünüyor")
+            logger.info(f"Audio exceeds 15 minutes, splitting into {chunk_duration}-second chunks")
             num_chunks = int(np.ceil(duration / chunk_duration))
             for i in range(num_chunks):
                 start = i * chunk_duration * sr
@@ -457,7 +457,7 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
                 sf.write(chunk_path, chunk_data.T if audio_data.ndim == 2 else chunk_data, sr)
                 chunks.append(chunk_path)
                 chunk_paths.append(chunk_path)
-                logger.info(f"Parça {i} oluşturuldu: {chunk_path}")
+                logger.info(f"Created chunk {i}: {chunk_path}")
         else:
             chunks = [audio]
         use_tta = use_tta == "True"
@@ -465,7 +465,7 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
             shutil.rmtree(output_dir)
         os.makedirs(output_dir, exist_ok=True)
         base_name = os.path.splitext(os.path.basename(audio))[0]
-        logger.info(f"{base_name} için birleştirme, modeller: {model_keys}, cihaz: {device}")
+        logger.info(f"Ensemble for {base_name} with {model_keys} on {device}")
         all_stems = []
         model_stems = {}
         for model_key in model_keys:
@@ -475,7 +475,7 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
                     model = models[model_key]
                     break
             else:
-                logger.warning(f"Model {model_key} bulunamadı, atlanıyor")
+                logger.warning(f"Model {model_key} not found, skipping")
                 continue
             for chunk_idx, chunk_path in enumerate(chunks):
                 separator = Separator(
@@ -488,9 +488,9 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
                     use_autocast=use_autocast,
                     mdxc_params={"segment_size": seg_size, "overlap": overlap, "use_tta": use_tta, "batch_size": batch_size}
                 )
-                logger.info(f"Chunk {chunk_idx} için {model_key} yükleniyor")
+                logger.info(f"Loading {model_key} for chunk {chunk_idx}")
                 separator.load_model(model_filename=model)
-                logger.info(f"Chunk {chunk_idx} {model_key} ile ayrıştırılıyor")
+                logger.info(f"Separating chunk {chunk_idx} with {model_key}")
                 separation = separator.separate(chunk_path)
                 stems = [os.path.join(output_dir, file_name) for file_name in separation]
                 for stem in stems:
@@ -502,7 +502,7 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
                 gc.collect()
                 if torch.cuda.is_available():
                     torch.cuda.empty_cache()
-                    logger.info(f"{model_key} chunk {chunk_idx} sonrası CUDA belleği temizlendi")
+                    logger.info(f"Cleared CUDA cache after {model_key} chunk {chunk_idx}")
         for model_key, stems_dict in model_stems.items():
             for stem_type in ["vocals", "other"]:
                 if stems_dict[stem_type]:
@@ -511,18 +511,18 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
                         for stem_path in stems_dict[stem_type]:
                             data, _ = librosa.load(stem_path, sr=sr, mono=False)
                             f.write(data.T if data.ndim == 2 else data)
-                    logger.info(f"{model_key} için {stem_type} birleştirildi: {combined_path}")
+                    logger.info(f"Combined {stem_type} for {model_key}: {combined_path}")
                     if exclude_stems.strip() and stem_type.lower() in [s.strip().lower() for s in exclude_stems.split(',')]:
-                        logger.info(f"{model_key} için {stem_type} hariç tutuldu")
+                        logger.info(f"Excluding {stem_type} for {model_key}")
                         continue
                     all_stems.append(combined_path)
         all_stems = [stem for stem in all_stems if os.path.exists(stem)]
         if not all_stems:
-            raise ValueError("Birleştirme için geçerli stem dosyası bulunamadı.")
+            raise ValueError("No valid stems found for ensemble.")
         weights = [float(w.strip()) for w in weights_str.split(',')] if weights_str.strip() else [1.0] * len(all_stems)
         if len(weights) != len(all_stems):
             weights = [1.0] * len(all_stems)
-            logger.info("Ağırlıklar eşleşmedi, varsayılan 1.0 kullanıldı")
+            logger.info("Weights mismatched, defaulting to 1.0")
         output_file = os.path.join(output_dir, f"{base_name}_ensemble_{ensemble_method}.{out_format}")
         ensemble_args = [
             "--files", *all_stems,
@@ -530,26 +530,36 @@ def auto_ensemble_process(audio, model_keys, seg_size=128, overlap=0.1, out_form
             "--weights", *[str(w) for w in weights],
             "--output", output_file
         ]
-        logger.info(f"Birleştirme argümanları: {ensemble_args}")
+        logger.info(f"Running ensemble with args: {ensemble_args}")
         ensemble_files(ensemble_args)
-        logger.info("Birleştirme tamamlandı")
-        return output_file, f"Birleştirme {ensemble_method} ile tamamlandı, hariç tutulan: {exclude_stems if exclude_stems else 'Yok'}"
+        logger.info("Ensemble completed")
+        return output_file, f"Ensemble completed with {ensemble_method}, excluded: {exclude_stems if exclude_stems else 'None'}"
     except Exception as e:
-        logger.error(f"Birleştirme hatası: {e}")
-        raise RuntimeError(f"Birleştirme hatası: {e}")
+        logger.error(f"Ensemble error: {e}")
+        raise RuntimeError(f"Ensemble error: {e}")
     finally:
         for path in chunk_paths + ([temp_audio_path] if temp_audio_path and os.path.exists(temp_audio_path) else []):
             try:
                 if os.path.exists(path):
                     os.remove(path)
-                    logger.info(f"Geçici dosya silindi: {path}")
+                    logger.info(f"Temporary file deleted: {path}")
             except Exception as e:
-                logger.warning(f"Geçici dosya silinemedi {path}: {e}")
+                logger.warning(f"Failed to delete temporary file {path}: {e}")
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
-            logger.info("GPU belleği temizlendi")
+            logger.info("GPU memory cleared")
 
-# Mevcut update_roformer_models ve update_ensemble_models (değişmedi)
+def update_roformer_models(category):
+    """Update Roformer model dropdown based on selected category."""
+    choices = list(ROFORMER_MODELS.get(category, {}).keys()) or []
+    logger.debug(f"Updating roformer models for category {category}: {choices}")
+    return gr.update(choices=choices, value=choices[0] if choices else None)
+
+def update_ensemble_models(category):
+    """Update ensemble model dropdown based on selected category."""
+    choices = list(ROFORMER_MODELS.get(category, {}).keys()) or []
+    logger.debug(f"Updating ensemble models for category {category}: {choices}")
+    return gr.update(choices=choices, value=[])
 
 def download_audio_wrapper(url, cookie_file):
     file_path, status, audio_data = download_audio(url, cookie_file)
@@ -558,65 +568,65 @@ def download_audio_wrapper(url, cookie_file):
 def create_interface():
     with gr.Blocks(title="🎵 SESA Fast Separation 🎵", css=CSS, elem_id="app-container") as app:
         gr.Markdown("<h1 class='header-text'>🎵 SESA Fast Separation 🎵</h1>")
-        gr.Markdown("**Not**: YouTube indirmeleri başarısız olursa, doğrudan bir ses dosyası yükleyin veya geçerli bir çerez dosyası kullanın. [Çerez Talimatları](https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies)")
-        gr.Markdown("**Uyarı**: 15 dakikadan uzun ses dosyaları otomatik olarak parçalara bölünür, bu işlem daha fazla zaman ve kaynak gerektirebilir.")
+        gr.Markdown("**Note**: If YouTube downloads fail, upload an audio file directly or use a valid cookies file. [Cookie Instructions](https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies)")
+        gr.Markdown("**Warning**: Audio files longer than 15 minutes are automatically split into chunks, which may require more time and resources.")
         with gr.Tabs():
             with gr.Tab("⚙️ Settings"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    gr.Markdown("### Genel Ayarlar")
-                    model_file_dir = gr.Textbox(value="/tmp/audio-separator-models/", label="📂 Model Önbelleği", placeholder="Model dizini yolu", interactive=True)
-                    output_dir = gr.Textbox(value="output", label="📤 Çıkış Dizini", placeholder="Sonuçların kaydedileceği yer", interactive=True)
-                    output_format = gr.Dropdown(value="wav", choices=OUTPUT_FORMATS, label="🎶 Çıkış Formatı", interactive=True)
-                    norm_threshold = gr.Slider(0.1, 1.0, value=0.9, step=0.1, label="🔊 Normalizasyon Eşiği", interactive=True)
-                    amp_threshold = gr.Slider(0.1, 1.0, value=0.3, step=0.1, label="📈 Amplifikasyon Eşiği", interactive=True)
-                    batch_size = gr.Slider(1, 16, value=1, step=1, label="⚡ Batch Boyutu", interactive=True)
+                    gr.Markdown("### General Settings")
+                    model_file_dir = gr.Textbox(value="/tmp/audio-separator-models/", label="📂 Model Cache", placeholder="Path to model directory", interactive=True)
+                    output_dir = gr.Textbox(value="output", label="📤 Output Directory", placeholder="Where to save results", interactive=True)
+                    output_format = gr.Dropdown(value="wav", choices=OUTPUT_FORMATS, label="🎶 Output Format", interactive=True)
+                    norm_threshold = gr.Slider(0.1, 1.0, value=0.9, step=0.1, label="🔊 Normalization Threshold", interactive=True)
+                    amp_threshold = gr.Slider(0.1, 1.0, value=0.3, step=0.1, label="📈 Amplification Threshold", interactive=True)
+                    batch_size = gr.Slider(1, 16, value=1, step=1, label="⚡ Batch Size", interactive=True)
             with gr.Tab("🎤 Roformer"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    gr.Markdown("### Ses Ayrıştırma")
+                    gr.Markdown("### Audio Separation")
                     with gr.Row():
-                        roformer_audio = gr.Audio(label="🎧 Ses Yükle", type="filepath", interactive=True)
-                        url_ro = gr.Textbox(label="🔗 Veya URL Yapıştır", placeholder="YouTube veya ses URL'si", interactive=True)
-                        cookies_ro = gr.File(label="🍪 Çerez Dosyası", file_types=[".txt"], interactive=True)
-                        download_roformer = gr.Button("⬇️ İndir", variant="secondary")
-                    roformer_download_status = gr.Textbox(label="📢 İndirme Durumu", interactive=False)
-                    roformer_exclude_stems = gr.Textbox(label="🚫 Stem'leri Hariç Tut", placeholder="örn: vocals, drums (virgülle ayrılmış)", interactive=True)
+                        roformer_audio = gr.Audio(label="🎧 Upload Audio", type="filepath", interactive=True)
+                        url_ro = gr.Textbox(label="🔗 Or Paste URL", placeholder="YouTube or audio URL", interactive=True)
+                        cookies_ro = gr.File(label="🍪 Cookies File", file_types=[".txt"], interactive=True)
+                        download_roformer = gr.Button("⬇️ Download", variant="secondary")
+                    roformer_download_status = gr.Textbox(label="📢 Download Status", interactive=False)
+                    roformer_exclude_stems = gr.Textbox(label="🚫 Exclude Stems", placeholder="e.g., vocals, drums (comma-separated)", interactive=True)
                     with gr.Row():
-                        roformer_category = gr.Dropdown(label="📚 Kategori", choices=list(ROFORMER_MODELS.keys()), value="General Purpose", interactive=True)
+                        roformer_category = gr.Dropdown(label="📚 Category", choices=list(ROFORMER_MODELS.keys()), value="General Purpose", interactive=True)
                         roformer_model = gr.Dropdown(label="🛠️ Model", choices=list(ROFORMER_MODELS["General Purpose"].keys()), interactive=True, allow_custom_value=True)
                     with gr.Row():
-                        roformer_seg_size = gr.Slider(32, 4000, value=256, step=32, label="📏 Segment Boyutu", interactive=True)
-                        roformer_overlap = gr.Slider(2, 10, value=8, step=1, label="🔄 Örtüşme", interactive=True)
+                        roformer_seg_size = gr.Slider(32, 4000, value=256, step=32, label="📏 Segment Size", interactive=True)
+                        roformer_overlap = gr.Slider(2, 10, value=8, step=1, label="🔄 Overlap", interactive=True)
                     with gr.Row():
-                        roformer_pitch_shift = gr.Slider(-12, 12, value=0, step=1, label="🎵 Perde Kaydırma", interactive=True)
-                        roformer_override_seg_size = gr.Dropdown(choices=["True", "False"], value="False", label="🔧 Segment Boyutunu Geçersiz Kıl", interactive=True)
-                    roformer_button = gr.Button("✂️ Şimdi Ayır!", variant="primary")
+                        roformer_pitch_shift = gr.Slider(-12, 12, value=0, step=1, label="🎵 Pitch Shift", interactive=True)
+                        roformer_override_seg_size = gr.Dropdown(choices=["True", "False"], value="False", label="🔧 Override Segment Size", interactive=True)
+                    roformer_button = gr.Button("✂️ Separate Now!", variant="primary")
                     with gr.Row():
                         roformer_stem1 = gr.Audio(label="🎸 Stem 1", type="filepath", interactive=False)
                         roformer_stem2 = gr.Audio(label="🥁 Stem 2", type="filepath", interactive=False)
             with gr.Tab("🎚️ Auto Ensemble"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    gr.Markdown("### Birleştirme İşlemi")
-                    gr.Markdown("Not: Ağırlıklar belirtilmezse, tüm modellere eşit ağırlık (1.0) uygulanır.")
+                    gr.Markdown("### Ensemble Processing")
+                    gr.Markdown("Note: If weights are not specified, equal weights (1.0) are applied to all models.")
                     with gr.Row():
-                        ensemble_audio = gr.Audio(label="🎧 Ses Yükle", type="filepath", interactive=True)
-                        url_ensemble = gr.Textbox(label="🔗 Veya URL Yapıştır", placeholder="YouTube veya ses URL'si", interactive=True)
-                        cookies_ensemble = gr.File(label="🍪 Çerez Dosyası", file_types=[".txt"], interactive=True)
-                        download_ensemble = gr.Button("⬇️ İndir", variant="secondary")
-                    ensemble_download_status = gr.Textbox(label="📢 İndirme Durumu", interactive=False)
-                    ensemble_exclude_stems = gr.Textbox(label="🚫 Stem'leri Hariç Tut", placeholder="örn: vocals, drums (virgülle ayrılmış)", interactive=True)
+                        ensemble_audio = gr.Audio(label="🎧 Upload Audio", type="filepath", interactive=True)
+                        url_ensemble = gr.Textbox(label="🔗 Or Paste URL", placeholder="YouTube or audio URL", interactive=True)
+                        cookies_ensemble = gr.File(label="🍪 Cookies File", file_types=[".txt"], interactive=True)
+                        download_ensemble = gr.Button("⬇️ Download", variant="secondary")
+                    ensemble_download_status = gr.Textbox(label="📢 Download Status", interactive=False)
+                    ensemble_exclude_stems = gr.Textbox(label="🚫 Exclude Stems", placeholder="e.g., vocals, drums (comma-separated)", interactive=True)
                     with gr.Row():
-                        ensemble_category = gr.Dropdown(label="📚 Kategori", choices=list(ROFORMER_MODELS.keys()), value="Instrumentals", interactive=True)
-                        ensemble_models = gr.Dropdown(label="🛠️ Modeller", choices=list(ROFORMER_MODELS["Instrumentals"].keys()), multiselect=True, interactive=True, allow_custom_value=True)
+                        ensemble_category = gr.Dropdown(label="📚 Category", choices=list(ROFORMER_MODELS.keys()), value="Instrumentals", interactive=True)
+                        ensemble_models = gr.Dropdown(label="🛠️ Models", choices=list(ROFORMER_MODELS["Instrumentals"].keys()), multiselect=True, interactive=True, allow_custom_value=True)
                     with gr.Row():
-                        ensemble_seg_size = gr.Slider(32, 4000, value=256, step=32, label="📏 Segment Boyutu", interactive=True)
-                        ensemble_overlap = gr.Slider(2, 10, value=8, step=1, label="🔄 Örtüşme", interactive=True)
-                        ensemble_use_tta = gr.Dropdown(choices=["True", "False"], value="False", label="🔍 TTA Kullan", interactive=True)
-                    ensemble_method = gr.Dropdown(label="⚙️ Birleştirme Yöntemi", choices=['avg_wave', 'median_wave', 'max_wave', 'min_wave', 'avg_fft', 'median_fft', 'max_fft', 'min_fft'], value='avg_wave', interactive=True)
-                    ensemble_weights = gr.Textbox(label="⚖️ Ağırlıklar", placeholder="örn: 1.0, 1.0 (virgülle ayrılmış)", interactive=True)
-                    ensemble_button = gr.Button("🎛️ Birleştirme Çalıştır!", variant="primary")
-                    ensemble_output = gr.Audio(label="🎶 Birleştirme Sonucu", type="filepath", interactive=False)
-                    ensemble_status = gr.Textbox(label="📢 Durum", interactive=False)
-        gr.HTML("<div class='footer'>Audio-Separator ile Güçlendirildi 🌟🎶 | ❤️ ile yapıldı</div>")
+                        ensemble_seg_size = gr.Slider(32, 4000, value=256, step=32, label="📏 Segment Size", interactive=True)
+                        ensemble_overlap = gr.Slider(2, 10, value=8, step=1, label="🔄 Overlap", interactive=True)
+                        ensemble_use_tta = gr.Dropdown(choices=["True", "False"], value="False", label="🔍 Use TTA", interactive=True)
+                    ensemble_method = gr.Dropdown(label="⚙️ Ensemble Method", choices=['avg_wave', 'median_wave', 'max_wave', 'min_wave', 'avg_fft', 'median_fft', 'max_fft', 'min_fft'], value='avg_wave', interactive=True)
+                    ensemble_weights = gr.Textbox(label="⚖️ Weights", placeholder="e.g., 1.0, 1.0 (comma-separated)", interactive=True)
+                    ensemble_button = gr.Button("🎛️ Run Ensemble!", variant="primary")
+                    ensemble_output = gr.Audio(label="🎶 Ensemble Result", type="filepath", interactive=False)
+                    ensemble_status = gr.Textbox(label="📢 Status", interactive=False)
+        gr.HTML("<div class='footer'>Powered by Audio-Separator 🌟🎶 | Made with ❤️</div>")
         roformer_category.change(update_roformer_models, inputs=[roformer_category], outputs=[roformer_model])
         download_roformer.click(
             fn=download_audio_wrapper,
@@ -651,14 +661,14 @@ def create_interface():
     return app
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Müzik Kaynak Ayrıştırma Web Arayüzü")
-    parser.add_argument("--port", type=int, default=7860, help="Arayüzün çalışacağı port")
+    parser = argparse.ArgumentParser(description="Music Source Separation Web UI")
+    parser.add_argument("--port", type=int, default=7860, help="Port to run the UI on")
     args = parser.parse_args()
     app = create_interface()
     try:
         app.launch(server_name="0.0.0.0", server_port=args.port, share=True)
     except Exception as e:
-        logger.error(f"Arayüz başlatılamadı: {e}")
+        logger.error(f"Failed to launch UI: {e}")
         raise
     finally:
         app.close()