Update app.py

app.py

@@ -22,7 +22,6 @@ import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from threading import Lock
 import scipy.io.wavfile
-import spaces
 import subprocess
 
 # Logging setup
@@ -156,7 +155,7 @@ ROFORMER_MODELS = {
 
 OUTPUT_FORMATS = ['wav', 'flac', 'mp3', 'ogg', 'opus', 'm4a', 'aiff', 'ac3']
 
-# CSS (değişmedi)
+# CSS (orijinal CSS korundu)
 CSS = """
 body {
     background: linear-gradient(to bottom, rgba(45, 11, 11, 0.9), rgba(0, 0, 0, 0.8)), url('/content/logo.jpg') no-repeat center center fixed;
@@ -382,18 +381,17 @@ def download_audio(url, cookie_file=None):
 @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("No audio file provided.")
+        raise ValueError("No audio or video file provided.")
     temp_audio_path = None
     extracted_audio_path = None
     try:
-        # Giriş dosyasının uzantısını kontrol et
         file_extension = os.path.splitext(audio)[1].lower().lstrip('.')
-        supported_video_formats = ['mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg']
-        is_video = file_extension in supported_video_formats
+        supported_formats = ['wav', 'mp3', 'flac', 'ogg', 'opus', 'm4a', 'aiff', 'ac3', 'mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg', 'ts', 'vob']
+        if file_extension not in supported_formats:
+            raise ValueError(f"Unsupported file format: {file_extension}. Supported formats: {', '.join(supported_formats)}")
 
-        # Eğer giriş bir video dosyasıysa, sesi çıkar
         audio_to_process = audio
-        if is_video:
+        if file_extension in ['mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg', 'ts', 'vob']:
             extracted_audio_path = os.path.join("/tmp", f"extracted_audio_{os.path.basename(audio)}.wav")
             logger.info(f"Extracting audio from video file: {audio}")
             ffmpeg_command = [
@@ -405,8 +403,13 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
                 logger.info(f"Audio extracted to: {extracted_audio_path}")
                 audio_to_process = extracted_audio_path
             except subprocess.CalledProcessError as e:
-                logger.error(f"FFmpeg error: {e.stderr}")
-                raise RuntimeError(f"Failed to extract audio from video: {e.stderr}")
+                error_message = e.stderr.decode() if e.stderr else str(e)
+                if "No audio stream" in error_message:
+                    raise RuntimeError("The provided video file does not contain an audio track.")
+                elif "Invalid data" in error_message:
+                    raise RuntimeError("The video file is corrupted or not supported.")
+                else:
+                    raise RuntimeError(f"Failed to extract audio from video: {error_message}")
 
         if isinstance(audio_to_process, tuple):
             sample_rate, data = audio_to_process
@@ -454,17 +457,25 @@ def roformer_separator(audio, model_key, seg_size, override_seg_size, overlap, p
             file_list = stems
             stem1 = stems[0]
             stem2 = stems[1] if len(stems) > 1 else None
+
         return stem1, stem2, file_list
+
     except Exception as 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"Temporary file deleted: {temp_audio_path}")
+            try:
+                os.remove(temp_audio_path)
+                logger.info(f"Temporary file deleted: {temp_audio_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete temporary file {temp_audio_path}: {e}")
         if extracted_audio_path and os.path.exists(extracted_audio_path):
-            os.remove(extracted_audio_path)
-            logger.info(f"Extracted audio file deleted: {extracted_audio_path}")
+            try:
+                os.remove(extracted_audio_path)
+                logger.info(f"Extracted audio file deleted: {extracted_audio_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete extracted audio file {extracted_audio_path}: {e}")
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
             logger.info("GPU memory cleared")
@@ -476,21 +487,20 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
     start_time = time.time()
     try:
         if not audio:
-            raise ValueError("No audio file provided.")
+            raise ValueError("No audio or video file provided.")
         if not model_keys:
             raise ValueError("No models selected.")
         if len(model_keys) > max_models:
             logger.warning(f"Selected {len(model_keys)} models, limiting to {max_models}.")
             model_keys = model_keys[:max_models]
 
-        # Giriş dosyasının uzantısını kontrol et
         file_extension = os.path.splitext(audio)[1].lower().lstrip('.')
-        supported_video_formats = ['mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg']
-        is_video = file_extension in supported_video_formats
+        supported_formats = ['wav', 'mp3', 'flac', 'ogg', 'opus', 'm4a', 'aiff', 'ac3', 'mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg', 'ts', 'vob']
+        if file_extension not in supported_formats:
+            raise ValueError(f"Unsupported file format: {file_extension}. Supported formats: {', '.join(supported_formats)}")
 
-        # Eğer giriş bir video dosyasıysa, sesi çıkar
         audio_to_process = audio
-        if is_video:
+        if file_extension in ['mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'webm', 'mpeg', 'mpg', 'ts', 'vob']:
             extracted_audio_path = os.path.join("/tmp", f"extracted_audio_{os.path.basename(audio)}.wav")
             logger.info(f"Extracting audio from video file: {audio}")
             ffmpeg_command = [
@@ -502,10 +512,14 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                 logger.info(f"Audio extracted to: {extracted_audio_path}")
                 audio_to_process = extracted_audio_path
             except subprocess.CalledProcessError as e:
-                logger.error(f"FFmpeg error: {e.stderr}")
-                raise RuntimeError(f"Failed to extract audio from video: {e.stderr}")
+                error_message = e.stderr.decode() if e.stderr else str(e)
+                if "No audio stream" in error_message:
+                    raise RuntimeError("The provided video file does not contain an audio track.")
+                elif "Invalid data" in error_message:
+                    raise RuntimeError("The video file is corrupted or not supported.")
+                else:
+                    raise RuntimeError(f"Failed to extract audio from video: {error_message}")
 
-        # Audio süresine göre dinamik batch size
         audio_data, sr = librosa.load(audio_to_process, sr=None, mono=False)
         duration = librosa.get_duration(y=audio_data, sr=sr)
         logger.info(f"Audio duration: {duration:.2f} seconds")
@@ -518,7 +532,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
             scipy.io.wavfile.write(temp_audio_path, sample_rate, data)
             audio_to_process = temp_audio_path
 
-        # State kontrolü
         if not state:
             state = {
                 "current_audio": None,
@@ -527,7 +540,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                 "model_outputs": {}
             }
 
-        # Yeni audio dosyası kontrolü - yalnızca audio değiştiğinde sıfırlıyoruz
         if state["current_audio"] != audio:
             state["current_audio"] = audio
             state["current_model_idx"] = 0
@@ -539,28 +551,20 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
         base_name = os.path.splitext(os.path.basename(audio))[0]
         logger.info(f"Ensemble for {base_name} with {model_keys} on {device}")
 
-        # Kalıcı bir klasör oluştur
         permanent_output_dir = os.path.join(output_dir, "permanent_stems")
         os.makedirs(permanent_output_dir, exist_ok=True)
 
-        # Model cache
         model_cache = {}
         all_stems = []
         total_tasks = len(model_keys)
-
-        # Şu anki modeli işle
         current_idx = state["current_model_idx"]
         logger.info(f"Current model index: {current_idx}, total models: {len(model_keys)}")
 
-        # Tüm modeller işlendiyse ensemble işlemini yap
         if current_idx >= len(model_keys):
             logger.info("All models processed, running ensemble...")
             progress(0.9, desc="Running ensemble...")
 
-            # "Exclude Stems" listesindeki stem'leri belirle
             excluded_stems_list = [s.strip().lower() for s in exclude_stems.split(',')] if exclude_stems.strip() else []
-
-            # Tüm stem’leri topla, ama "Exclude Stems" ile belirtilenleri hariç tut
             for model_key, stems_dict in state["model_outputs"].items():
                 for stem_type in ["vocals", "other"]:
                     if stems_dict[stem_type]:
@@ -573,7 +577,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
             if not all_stems:
                 raise ValueError("No valid stems found for ensemble after excluding specified stems.")
 
-            # Ensemble işlemi
             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)
@@ -590,7 +593,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
             if result is None or not os.path.exists(output_file):
                 raise RuntimeError(f"Ensemble failed, output file not created: {output_file}")
 
-            # Durumu sıfırla
             state["current_model_idx"] = 0
             state["current_audio"] = None
             state["processed_stems"] = []
@@ -607,7 +609,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
             status += "</ul>"
             return output_file, status, file_list, state
 
-        # Şu anki modeli işle
         model_key = model_keys[current_idx]
         logger.info(f"Processing model {current_idx + 1}/{len(model_keys)}: {model_key}")
         progress(0.1, desc=f"Processing model {model_key}...")
@@ -615,7 +616,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
         with torch.no_grad():
             for attempt in range(max_retries + 1):
                 try:
-                    # Modeli bul
                     for category, models in ROFORMER_MODELS.items():
                         if model_key in models:
                             model = models[model_key]
@@ -625,13 +625,11 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                         state["current_model_idx"] += 1
                         return None, f"Model {model_key} not found, proceeding to next model.", [], state
 
-                    # Zaman kontrolü
                     elapsed = time.time() - start_time
                     if elapsed > time_budget:
                         logger.error(f"Time budget ({time_budget}s) exceeded")
                         raise TimeoutError("Processing took too long")
 
-                    # Separator oluştur
                     if model_key not in model_cache:
                         logger.info(f"Loading {model_key} into cache")
                         separator = Separator(
@@ -654,15 +652,12 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                     else:
                         separator = model_cache[model_key]
 
-                    # GPU ile işlem
                     with gpu_lock:
                         progress(0.3, desc=f"Separating with {model_key}")
                         logger.info(f"Separating with {model_key}")
                         separation = separator.separate(audio_to_process)
                         stems = [os.path.join(output_dir, file_name) for file_name in separation]
                         result = []
-
-                        # Stem’leri kalıcı klasöre taşı
                         for stem in stems:
                             stem_type = "vocals" if "vocals" in os.path.basename(stem).lower() else "other"
                             permanent_stem_path = os.path.join(permanent_output_dir, f"{base_name}_{stem_type}_{model_key.replace(' | ', '_').replace(' ', '_')}.{out_format}")
@@ -670,7 +665,6 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                             state["model_outputs"][model_key][stem_type].append(permanent_stem_path)
                             if stem_type not in exclude_stems.lower():
                                 result.append(permanent_stem_path)
-
                         state["processed_stems"].extend(result)
                         break
 
@@ -687,24 +681,20 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
                         torch.cuda.empty_cache()
                         logger.info(f"Cleared CUDA cache after {model_key}")
 
-        # Model cache temizliği
         model_cache.clear()
         gc.collect()
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
             logger.info("Cleared model cache and GPU memory")
 
-        # Bir sonraki modele geç
         state["current_model_idx"] += 1
         elapsed = time.time() - start_time
         logger.info(f"Model {model_key} completed in {elapsed:.2f}s")
 
-        # Eğer bu son modelse, ensemble işlemini hemen başlat
         if state["current_model_idx"] >= len(model_keys):
             logger.info("Last model processed, running ensemble immediately...")
             return auto_ensemble_process(audio, model_keys, state, seg_size, overlap, out_format, use_tta, model_dir, output_dir, norm_thresh, amp_thresh, batch_size, ensemble_method, exclude_stems, weights_str, progress)
 
-        # Çıktılar
         file_list = state["processed_stems"]
         status = f"Model {model_key} (Model {current_idx + 1}/{len(model_keys)}) completed in {elapsed:.2f}s<br>Click 'Run Ensemble!' to process the next model.<br>Processed stems:<ul>"
         for file in file_list:
@@ -715,7 +705,7 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
 
     except Exception as e:
         logger.error(f"Ensemble error: {e}")
-        error_msg = f"Processing failed: {e}. Try fewer models (max {max_models}) or uploading a local WAV file."
+        error_msg = f"Processing failed: {e}. Try fewer models (max {max_models}) or uploading a local WAV or video file."
         raise RuntimeError(error_msg)
 
     finally:
@@ -736,13 +726,11 @@ def auto_ensemble_process(audio, model_keys, state, seg_size=64, overlap=0.1, ou
             logger.info("GPU memory cleared")
 
 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=[])
@@ -756,7 +744,6 @@ def create_interface():
         gr.Markdown("<h1 class='header-text'>🎵 SESA Fast Separation 🎵</h1>")
         gr.Markdown("**Note**: If YouTube downloads fail, upload a valid cookies file or a local WAV/MP4/MOV file. [Cookie Instructions](https://github.com/yt-dlp/yt-dlp/wiki/Extractors#exporting-youtube-cookies)")
         gr.Markdown("**Tip**: For best results, use audio/video shorter than 15 minutes or fewer models (up to 6) to ensure smooth processing.")
-        # Gradio State bileşeni
         ensemble_state = gr.State(value={
             "current_audio": None,
             "current_model_idx": 0,
@@ -777,7 +764,7 @@ def create_interface():
                 with gr.Group(elem_classes="dubbing-theme"):
                     gr.Markdown("### Audio Separation")
                     with gr.Row():
-                        roformer_audio = gr.Audio(label="🎧 Upload Audio/Video", type="filepath", interactive=True)
+                        roformer_audio = gr.File(label="🎧 Upload Audio or Video (WAV, MP3, MP4, MOV, etc.)", file_types=['.wav', '.mp3', '.flac', '.ogg', '.opus', '.m4a', '.aiff', '.ac3', '.mp4', '.mov', '.avi', '.mkv', '.flv', '.wmv', '.webm', '.mpeg', '.mpg', '.ts', '.vob'], interactive=True)
                         url_ro = gr.Textbox(label="🔗 Or Paste URL", placeholder="YouTube or audio/video URL", interactive=True)
                         cookies_ro = gr.File(label="🍪 Cookies File", file_types=[".txt"], interactive=True)
                         download_roformer = gr.Button("⬇️ Download", variant="secondary")
@@ -802,7 +789,7 @@ def create_interface():
                     gr.Markdown("### Ensemble Processing")
                     gr.Markdown("Note: If weights are not specified, equal weights (1.0) are applied. Use up to 6 models for best results.")
                     with gr.Row():
-                        ensemble_audio = gr.Audio(label="🎧 Upload Audio/Video", type="filepath", interactive=True)
+                        ensemble_audio = gr.File(label="🎧 Upload Audio or Video (WAV, MP3, MP4, MOV, etc.)", file_types=['.wav', '.mp3', '.flac', '.ogg', '.opus', '.m4a', '.aiff', '.ac3', '.mp4', '.mov', '.avi', '.mkv', '.flv', '.wmv', '.webm', '.mpeg', '.mpg', '.ts', '.vob'], interactive=True)
                         url_ensemble = gr.Textbox(label="🔗 Or Paste URL", placeholder="YouTube or audio/video URL", interactive=True)
                         cookies_ensemble = gr.File(label="🍪 Cookies File", file_types=[".txt"], interactive=True)
                         download_ensemble = gr.Button("⬇️ Download", variant="secondary")