Update app.py

app.py

@@ -1,3 +1,4 @@
+# Mevcut imports
 import os
 import sys
 import torch
@@ -12,65 +13,41 @@ import soundfile as sf
 from ensemble import ensemble_files
 import shutil
 import gradio_client.utils as client_utils
-import validators
 import matchering as mg
-from typing import Any, Optional
-import spaces  # Added for @spaces.GPU
-import gdown 
-
-# Add this import if not already present
-import yt_dlp
-import scipy.io.wavfile  # For audio processing
+import spaces
+import gdown
+import scipy.io.wavfile
+from pydub import AudioSegment
+import gc
 
 # Logging setup
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration directory
-CONFIG_DIR = "/tmp/SESA-Config"
-
-def ensure_config_dir():
-    """Ensure the configuration directory exists and is writable."""
-    try:
-        os.makedirs(CONFIG_DIR, exist_ok=True)
-        logger.info(f"Configuration directory ensured: {CONFIG_DIR}")
-    except PermissionError as e:
-        logger.error(f"Failed to create config directory {CONFIG_DIR}: {e}")
-        raise RuntimeError(f"Cannot create config directory: {e}")
-    except Exception as e:
-        logger.error(f"Unexpected error creating config directory {CONFIG_DIR}: {e}")
-        raise
-
-# Call early in the script
-ensure_config_dir()
+# Mevcut CONFIG_DIR ve ensure_config_dir kaldırıldı (kullanılmıyor)
 
-# Patch gradio_client.utils._json_schema_to_python_type
+# Mevcut JSON schema yaması (gerekirse korunabilir)
 original_json_schema_to_python_type = client_utils._json_schema_to_python_type
-
 def patched_json_schema_to_python_type(schema: Any, defs: Optional[dict] = None) -> str:
     logger.debug(f"Parsing schema: {schema}")
     if isinstance(schema, bool):
-        logger.info("Found boolean schema, returning 'boolean'")
         return "boolean"
     if not isinstance(schema, dict):
-        logger.warning(f"Unexpected schema type: {type(schema)}, returning 'Any'")
         return "Any"
     if "enum" in schema and schema.get("type") == "string":
-        logger.info(f"Handling enum schema: {schema['enum']}")
         return f"Literal[{', '.join(repr(e) for e in schema['enum'])}]"
     try:
         return original_json_schema_to_python_type(schema, defs)
-    except client_utils.APIInfoParseError as e:
-        logger.error(f"Failed to parse schema {schema}: {e}")
+    except client_utils.APIInfoParseError:
         return "str"
-
 client_utils._json_schema_to_python_type = patched_json_schema_to_python_type
 
-# Device and autocast setup
+# Device setup
 device = "cuda" if torch.cuda.is_available() else "cpu"
 use_autocast = device == "cuda"
 logger.info(f"Using device: {device}")
 
+
 # ROFORMER_MODELS and OUTPUT_FORMATS
 ROFORMER_MODELS = {
     "Vocals": {
@@ -327,12 +304,6 @@ button:hover {
 }
 """
 
-import os
-import yt_dlp
-import gdown
-from scipy.io import wavfile
-from pydub import AudioSegment
-
 def download_audio(url, cookie_file=None):
     ydl_opts = {
         'format': 'bestaudio[ext=webm]/bestaudio[ext=m4a]/bestaudio[ext=opus]/bestaudio[ext=aac]/bestaudio -video',
@@ -353,92 +324,73 @@ def download_audio(url, cookie_file=None):
         'no_check_certificate': True,
         'verbose': True,
     }
-
-    # Check if it's a Google Drive link
-    if 'drive.google.com' in url or 'https://drive.google.com' in url:
-        try:
-            # Create the 'ytdl' directory if it doesn't exist
+    temp_output_path = None
+    try:
+        if 'drive.google.com' in url:
             os.makedirs('ytdl', exist_ok=True)
-
-            # Extract file ID from the URL
             file_id = url.split('/d/')[1].split('/')[0]
             download_url = f'https://drive.google.com/uc?id={file_id}'
-            temp_output_path = 'ytdl/gdrive_temp_audio'  # Temporary file for raw download
+            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, "Downloaded file not found", None
-
-            # Convert the downloaded file to WAV using pydub
+                return None, "İndirilen dosya bulunamadı", 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
             output_path = 'ytdl/gdrive_audio.wav'
             audio = AudioSegment.from_file(temp_output_path)
             audio.export(output_path, format="wav")
-
-            # Read the converted WAV file
             sample_rate, data = wavfile.read(output_path)
-            audio_data = (sample_rate, data)
-            
-            # Clean up the temporary file
-            os.remove(temp_output_path)
-            
-            return output_path, "Download successful", audio_data
-        except Exception as e:
-            return None, f"Google Drive download failed: {str(e)}", None
-
-    # Handle YouTube link
-    else:
-        os.makedirs('ytdl', exist_ok=True)
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            try:
+            return output_path, "İndirme başarılı", (sample_rate, data)
+        else:
+            os.makedirs('ytdl', exist_ok=True)
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 info_dict = ydl.extract_info(url, download=True)
                 base_file_path = ydl.prepare_filename(info_dict)
                 file_path = base_file_path
                 for ext in ['.webm', '.m4a', '.opus', '.aac']:
                     file_path = file_path.replace(ext, '.wav')
                 if not os.path.exists(file_path):
-                    return None, "Downloaded file not found", None
+                    return None, "İndirilen dosya bulunamadı", None
                 sample_rate, data = wavfile.read(file_path)
-                audio_data = (sample_rate, data)
-                return file_path, "Download successful", audio_data
-            except yt_dlp.utils.ExtractorError as e:
-                if "Sign in to confirm you’re not a bot" in str(e) or "The provided YouTube account cookies are no longer valid" in str(e):
-                    return None, "Authentication failed. Please upload updated cookies from a logged-in browser session in the respective tab. See https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies for instructions.", None
-                elif "HTTP Error 403: Forbidden" in str(e):
-                    return None, "Download failed: HTTP Error 403. This format requires a GVS PO Token, or the cookies are invalid. Please upload fresh cookies. See https://github.com/yt-dlp/yt-dlp/wiki/PO-Token-Guide for advanced troubleshooting.", None
-                return None, f"Download failed: {str(e)}", None
-            except Exception as e:
-                return None, f"Unexpected error: {str(e)}", None 
-                
+                return file_path, "İndirme başarılı", (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
+    except Exception as e:
+        return None, f"Beklenmeyen hata: {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}")
+
 @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)):
-    """Separate audio into stems using a Roformer model."""
     if not audio:
-        raise ValueError("No audio file provided.")
-    
-    temp_audio_path = None  # Initialize to None to avoid undefined variable in finally
+        raise ValueError("Ses dosyası sağlanmadı.")
+    temp_audio_path = None
     try:
-        # If audio is a tuple (sample_rate, data), save it as a temporary file
         if isinstance(audio, tuple):
             sample_rate, data = audio
             temp_audio_path = os.path.join("/tmp", "temp_audio.wav")
             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.")
         override_seg_size = override_seg_size == "True"
-        
         if os.path.exists(output_dir):
             shutil.rmtree(output_dir)
         os.makedirs(output_dir, exist_ok=True)
-        
         base_name = os.path.splitext(os.path.basename(audio))[0]
         for category, models in ROFORMER_MODELS.items():
             if model_key in models:
                 model = models[model_key]
                 break
         else:
-            raise ValueError(f"Model '{model_key}' not found.")
-        
-        logger.info(f"Separating {base_name} with {model_key} on {device}")
+            raise ValueError(f"Model '{model_key}' bulunamadı.")
+        logger.info(f"{base_name} ayrıştırılıyor, model: {model_key}, cihaz: {device}")
         separator = Separator(
             log_level=logging.INFO,
             model_file_dir=model_dir,
@@ -449,54 +401,48 @@ 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="Loading model...")
+        progress(0.2, desc="Model yükleniyor...")
         separator.load_model(model_filename=model)
-        progress(0.7, desc="Separating audio...")
+        progress(0.7, desc="Ses ayrıştırılıyor...")
         separation = separator.separate(audio)
         stems = [os.path.join(output_dir, file_name) for file_name in separation]
-        
         if exclude_stems.strip():
             excluded = [s.strip().lower() for s in exclude_stems.split(',')]
             filtered_stems = [stem for stem in stems if not any(ex in os.path.basename(stem).lower() for ex in excluded)]
             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"Separation failed: {e}")
-        raise RuntimeError(f"Separation failed: {e}")
+        logger.error(f"Ayrıştırma hatası: {e}")
+        raise RuntimeError(f"Ayrıştırma hatası: {e}")
     finally:
-        # Clean up temporary file if it was created
         if temp_audio_path and os.path.exists(temp_audio_path):
-            try:
-                os.remove(temp_audio_path)
-                logger.info(f"Cleaned up temporary file: {temp_audio_path}")
-            except Exception as e:
-                logger.warning(f"Failed to clean up temporary file {temp_audio_path}: {e}")
+            os.remove(temp_audio_path)
+            logger.info(f"Geçici dosya silindi: {temp_audio_path}")
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            logger.info("GPU belleği temizlendi")
 
 @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=""):
     temp_audio_path = None
     chunk_paths = []
     try:
-        if not audio or not model_keys:
-            raise ValueError("Audio or models missing.")
-        
-        # Handle tuple input (sample_rate, data)
+        if not audio:
+            raise ValueError("Ses dosyası sağlanmadı.")
+        if not model_keys:
+            raise ValueError("Model seçilmedi.")
         if isinstance(audio, tuple):
             sample_rate, data = audio
             temp_audio_path = os.path.join("/tmp", "temp_audio.wav")
             scipy.io.wavfile.write(temp_audio_path, sample_rate, data)
             audio = temp_audio_path
-        
-        # Load audio to check duration
         audio_data, sr = librosa.load(audio, sr=None, mono=False)
         duration = librosa.get_duration(y=audio_data, sr=sr)
-        logger.info(f"Audio duration: {duration:.2f} seconds")
-        
-        # Split audio if longer than 15 minutes (900 seconds)
-        chunk_duration = 300  # 5 minutes in seconds
+        logger.info(f"Ses süresi: {duration:.2f} saniye")
+        chunk_duration = 300
         chunks = []
         if duration > 900:
-            logger.info(f"Audio exceeds 15 minutes, splitting into {chunk_duration}-second chunks")
+            logger.info(f"Ses 15 dakikadan uzun, {chunk_duration}-saniyelik parçalara bölünüyor")
             num_chunks = int(np.ceil(duration / chunk_duration))
             for i in range(num_chunks):
                 start = i * chunk_duration * sr
@@ -506,23 +452,17 @@ 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"Created chunk {i}: {chunk_path}")
+                logger.info(f"Parça {i} oluşturuldu: {chunk_path}")
         else:
             chunks = [audio]
-        
         use_tta = use_tta == "True"
-        
-        # Create output directory
         if os.path.exists(output_dir):
             shutil.rmtree(output_dir)
         os.makedirs(output_dir, exist_ok=True)
-        
         base_name = os.path.splitext(os.path.basename(audio))[0]
-        logger.info(f"Ensemble for {base_name} with {model_keys} on {device}")
-        
+        logger.info(f"{base_name} için birleştirme, modeller: {model_keys}, cihaz: {device}")
         all_stems = []
-        model_stems = {}  # Store stems per model for concatenation
-        
+        model_stems = {}
         for model_key in model_keys:
             model_stems[model_key] = {"vocals": [], "other": []}
             for category, models in ROFORMER_MODELS.items():
@@ -530,9 +470,8 @@ 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} not found, skipping")
+                logger.warning(f"Model {model_key} bulunamadı, atlanıyor")
                 continue
-            
             for chunk_idx, chunk_path in enumerate(chunks):
                 separator = Separator(
                     log_level=logging.INFO,
@@ -544,51 +483,41 @@ 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"Loading {model_key} for chunk {chunk_idx}")
+                logger.info(f"Chunk {chunk_idx} için {model_key} yükleniyor")
                 separator.load_model(model_filename=model)
-                logger.info(f"Separating chunk {chunk_idx} with {model_key}")
+                logger.info(f"Chunk {chunk_idx} {model_key} ile ayrıştırılıyor")
                 separation = separator.separate(chunk_path)
                 stems = [os.path.join(output_dir, file_name) for file_name in separation]
-                
-                # Store stems for this chunk
                 for stem in stems:
                     if "vocals" in os.path.basename(stem).lower():
                         model_stems[model_key]["vocals"].append(stem)
                     elif "other" in os.path.basename(stem).lower():
                         model_stems[model_key]["other"].append(stem)
-                
-                # Clean up memory
                 separator = None
                 gc.collect()
                 if torch.cuda.is_available():
                     torch.cuda.empty_cache()
-                    logger.info(f"Cleared CUDA cache after {model_key} chunk {chunk_idx}")
-        
-        # Combine stems for each model
+                    logger.info(f"{model_key} chunk {chunk_idx} sonrası CUDA belleği temizlendi")
         for model_key, stems_dict in model_stems.items():
             for stem_type in ["vocals", "other"]:
                 if stems_dict[stem_type]:
                     combined_path = os.path.join(output_dir, f"{base_name}_{stem_type}_{model_key.replace(' | ', '_').replace(' ', '_')}.wav")
-                    combined_data = []
-                    for stem_path in stems_dict[stem_type]:
-                        data, _ = librosa.load(stem_path, sr=sr, mono=False)
-                        combined_data.append(data)
-                    combined_data = np.concatenate(combined_data, axis=-1) if combined_data[0].ndim == 2 else np.concatenate(combined_data)
-                    sf.write(combined_path, combined_data.T if combined_data.ndim == 2 else combined_data, sr)
-                    logger.info(f"Combined {stem_type} for {model_key}: {combined_path}")
+                    with sf.SoundFile(combined_path, 'w', sr, channels=2 if audio_data.ndim == 2 else 1) as f:
+                        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}")
                     if exclude_stems.strip() and stem_type.lower() in [s.strip().lower() for s in exclude_stems.split(',')]:
-                        logger.info(f"Excluding {stem_type} for {model_key}")
+                        logger.info(f"{model_key} için {stem_type} hariç tutuldu")
                         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("No valid stems for ensemble after exclusion.")
-        
-        # Ensemble the combined stems
+            raise ValueError("Birleştirme için geçerli stem dosyası bulunamadı.")
         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ı")
         output_file = os.path.join(output_dir, f"{base_name}_ensemble_{ensemble_method}.{out_format}")
         ensemble_args = [
             "--files", *all_stems,
@@ -596,114 +525,98 @@ 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"Running ensemble with args: {ensemble_args}")
+        logger.info(f"Birleştirme argümanları: {ensemble_args}")
         ensemble_files(ensemble_args)
-        
-        logger.info("Ensemble complete")
-        return output_file, f"Ensemble completed with {ensemble_method}, excluded: {exclude_stems if exclude_stems else 'None'}"
+        logger.info("Birleştirme tamamlandı")
+        return output_file, f"Birleştirme {ensemble_method} ile tamamlandı, hariç tutulan: {exclude_stems if exclude_stems else 'Yok'}"
     except Exception as e:
-        logger.error(f"Ensemble failed: {e}")
-        raise RuntimeError(f"Ensemble failed: {e}")
+        logger.error(f"Birleştirme hatası: {e}")
+        raise RuntimeError(f"Birleştirme hatası: {e}")
     finally:
-        # Clean up temporary files
         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"Successfully cleaned up {path}")
+                    logger.info(f"Geçici dosya silindi: {path}")
             except Exception as e:
-                logger.error(f"Failed to clean up {path}: {e}")
-                
-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)
+                logger.warning(f"Geçici dosya silinemedi {path}: {e}")
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            logger.info("GPU belleği temizlendi")
 
-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=[])
+# Mevcut update_roformer_models ve update_ensemble_models (değişmedi)
 
 def download_audio_wrapper(url, cookie_file):
     file_path, status, audio_data = download_audio(url, cookie_file)
-    return audio_data, status  # Return audio_data for gr.Audio, status for gr.Textbox    
+    return audio_data, status
 
 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("**Note**: If YouTube downloads fail, try uploading an audio file directly or use a valid cookies file.")
-        
+        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.")
         with gr.Tabs():
-            # Settings Tab
             with gr.Tab("⚙️ Settings"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    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)
-
-            # Roformer Tab
+                    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)
             with gr.Tab("🎤 Roformer"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    gr.Markdown("### Audio Separation")
+                    gr.Markdown("### Ses Ayrıştırma")
                     with gr.Row():
-                        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)  # Added status output
-                    roformer_exclude_stems = gr.Textbox(label="🚫 Exclude Stems", placeholder="e.g., vocals, drums (comma-separated)", interactive=True)
+                        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)
                     with gr.Row():
-                        roformer_category = gr.Dropdown(label="📚 Category", choices=list(ROFORMER_MODELS.keys()), value="General Purpose", interactive=True)
+                        roformer_category = gr.Dropdown(label="📚 Kategori", 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 Size", interactive=True)
-                        roformer_overlap = gr.Slider(2, 10, value=8, step=1, label="🔄 Overlap", interactive=True)
+                        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)
                     with gr.Row():
-                        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")
+                        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")
                     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)
-
-            # Auto Ensemble Tab
             with gr.Tab("🎚️ Auto Ensemble"):
                 with gr.Group(elem_classes="dubbing-theme"):
-                    gr.Markdown("### Ensemble Processing")
+                    gr.Markdown("### Birleştirme İşlemi")
+                    gr.Markdown("Not: Ağırlıklar belirtilmezse, tüm modellere eşit ağırlık (1.0) uygulanır.")
                     with gr.Row():
-                        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)  # Added status output
-                    ensemble_exclude_stems = gr.Textbox(label="🚫 Exclude Stems", placeholder="e.g., vocals, drums (comma-separated)", interactive=True)
+                        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)
                     with gr.Row():
-                        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)
+                        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)
                     with gr.Row():
-                        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>")
-
-        # Event Handlers
+                        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>")
         roformer_category.change(update_roformer_models, inputs=[roformer_category], outputs=[roformer_model])
         download_roformer.click(
             fn=download_audio_wrapper,
             inputs=[url_ro, cookies_ro],
-            outputs=[roformer_audio, roformer_download_status]  # Updated to use wrapper and output status
+            outputs=[roformer_audio, roformer_download_status]
         )
         roformer_button.click(
             fn=roformer_separator,
@@ -718,7 +631,7 @@ def create_interface():
         download_ensemble.click(
             fn=download_audio_wrapper,
             inputs=[url_ensemble, cookies_ensemble],
-            outputs=[ensemble_audio, ensemble_download_status]  # Updated to use wrapper and output status
+            outputs=[ensemble_audio, ensemble_download_status]
         )
         ensemble_button.click(
             fn=auto_ensemble_process,
@@ -730,19 +643,17 @@ def create_interface():
             ],
             outputs=[ensemble_output, ensemble_status]
         )
-    
     return app
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Music Source Separation Web UI")
-    parser.add_argument("--port", type=int, default=7860, help="Port to run the UI on")
+    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")
     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"Failed to launch app: {e}")
+        logger.error(f"Arayüz başlatılamadı: {e}")
         raise
     finally:
         app.close()