Update app.py

app.py

@@ -1,325 +1,314 @@
 import gradio as gr
-import os
+import torch
+import torchaudio
 import tempfile
+import os
 import subprocess
 import sys
-import librosa
-import soundfile as sf
 import numpy as np
 from pathlib import Path
 import warnings
 warnings.filterwarnings("ignore")
 
-def install_spleeter():
-    """Instala Spleeter de forma segura"""
+def install_demucs_properly():
+    """Instala demucs de la forma correcta para HF"""
     try:
-        # Instalar tensorflow primero
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "tensorflow==2.13.0", "--quiet"])
-        # Instalar spleeter
-        subprocess.check_call([sys.executable, "-m", "pip", "install", "spleeter==2.3.0", "--quiet"])
+        # Instalar dependencias una por una
+        print("📦 Instalando PyTorch...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "torch", "torchaudio", "--quiet"])
+        
+        print("📦 Instalando dependencias de audio...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "julius", "--quiet"])
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "openunmix", "--quiet"])
+        
+        print("📦 Instalando Demucs...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "demucs", "--quiet", "--no-deps"])
+        
+        # Instalar dependencias restantes
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "hydra-core", "omegaconf", "--quiet"])
+        
         return True
     except Exception as e:
-        print(f"Error instalando: {e}")
+        print(f"Error en instalación: {e}")
         return False
 
-# Intentar importar spleeter
-try:
-    from spleeter.separator import Separator
-    from spleeter.audio.adapter import AudioAdapter
-    SPLEETER_AVAILABLE = True
-    print("✅ Spleeter ya disponible")
-except ImportError:
-    print("⚠️ Instalando Spleeter...")
-    if install_spleeter():
-        try:
-            from spleeter.separator import Separator
-            from spleeter.audio.adapter import AudioAdapter
-            SPLEETER_AVAILABLE = True
-            print("✅ Spleeter instalado correctamente")
-        except Exception as e:
-            print(f"❌ Error importando Spleeter: {e}")
-            SPLEETER_AVAILABLE = False
-    else:
-        SPLEETER_AVAILABLE = False
-
-class SimpleAudioSeparator:
+# Intentar usar demucs directamente con subprocess
+class DemucsWrapper:
     def __init__(self):
-        self.separator_4stems = None
-        self.separator_2stems = None
-        self.audio_adapter = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.models_available = ["htdemucs", "htdemucs_ft", "mdx_extra"]
+        print(f"🔧 Dispositivo: {self.device}")
         
-        if SPLEETER_AVAILABLE:
-            try:
-                print("🤖 Inicializando separadores...")
-                self.audio_adapter = AudioAdapter.default()
-                print("✅ Audio adapter listo")
-            except Exception as e:
-                print(f"❌ Error inicializando: {e}")
-    
-    def load_separator(self, stems_count):
-        """Carga el separador según el número de stems"""
-        if not SPLEETER_AVAILABLE:
-            return False
-            
+    def separate_with_subprocess(self, audio_path, model="htdemucs"):
+        """Usa demucs vía subprocess (método más estable)"""
         try:
-            if stems_count == 4 and self.separator_4stems is None:
-                print("🔄 Cargando modelo 4-stems...")
-                self.separator_4stems = Separator('spleeter:4stems-wq')
-                print("✅ Modelo 4-stems cargado")
+            # Crear directorio temporal
+            output_dir = tempfile.mkdtemp()
+            print(f"📁 Directorio de salida: {output_dir}")
+            
+            # Comando demucs
+            cmd = [
+                sys.executable, "-m", "demucs.separate",
+                audio_path,
+                "-n", model,
+                "-o", output_dir,
+                "--device", self.device
+            ]
+            
+            print(f"🚀 Ejecutando: {' '.join(cmd)}")
+            
+            # Ejecutar comando
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+            
+            if result.returncode == 0:
+                print("✅ Demucs ejecutado exitosamente")
                 
-            elif stems_count == 2 and self.separator_2stems is None:
-                print("🔄 Cargando modelo 2-stems...")
-                self.separator_2stems = Separator('spleeter:2stems-wq')
-                print("✅ Modelo 2-stems cargado")
+                # Buscar archivos de salida
+                model_dir = os.path.join(output_dir, model)
+                if os.path.exists(model_dir):
+                    song_dirs = [d for d in os.listdir(model_dir) if os.path.isdir(os.path.join(model_dir, d))]
+                    if song_dirs:
+                        song_dir = os.path.join(model_dir, song_dirs[0])
+                        output_files = []
+                        
+                        for file in os.listdir(song_dir):
+                            if file.endswith('.wav'):
+                                file_path = os.path.join(song_dir, file)
+                                output_files.append(file_path)
+                                print(f"✅ Encontrado: {file}")
+                        
+                        return output_files, f"✅ Separación completada: {len(output_files)} stems"
                 
-            return True
+                return [], "❌ No se encontraron archivos de salida"
+            else:
+                error_msg = result.stderr if result.stderr else "Error desconocido"
+                print(f"❌ Error en demucs: {error_msg}")
+                return [], f"❌ Error: {error_msg[:100]}..."
+                
+        except subprocess.TimeoutExpired:
+            return [], "❌ Timeout: El procesamiento tomó demasiado tiempo"
         except Exception as e:
-            print(f"❌ Error cargando separador: {e}")
-            return False
+            return [], f"❌ Error inesperado: {str(e)}"
     
-    def separate_audio(self, audio_path, separation_type="4stems"):
-        """Separa audio usando Spleeter"""
-        if not SPLEETER_AVAILABLE:
-            return [], "❌ Spleeter no está disponible"
-            
+    def separate_manual(self, audio_path, model="htdemucs"):
+        """Método manual si subprocess falla"""
         try:
-            print(f"🎵 Procesando: {audio_path}")
-            
-            # Verificar archivo
-            if not os.path.exists(audio_path):
-                return [], "❌ Archivo no encontrado"
-            
-            # Cargar separador
-            stems_count = 4 if separation_type == "4stems" else 2
-            if not self.load_separator(stems_count):
-                return [], "❌ Error cargando el modelo"
-            
-            # Seleccionar separador
-            separator = self.separator_4stems if stems_count == 4 else self.separator_2stems
-            
-            # Cargar audio
-            print("📂 Cargando audio...")
-            waveform, sample_rate = self.audio_adapter.load(audio_path, sample_rate=44100)
-            
-            # Separar
-            print(f"⚙️ Separando en {stems_count} stems...")
-            prediction = separator.separate(waveform)
-            
-            # Guardar stems
-            output_files = []
-            temp_dir = tempfile.mkdtemp()
-            print(f"📁 Guardando en: {temp_dir}")
-            
-            for stem_name, stem_data in prediction.items():
-                output_path = os.path.join(temp_dir, f"{stem_name}.wav")
+            # Intentar importar demucs directamente
+            try:
+                from demucs.api import Separator
+                separator = Separator(model=model, device=self.device)
                 
-                # Guardar usando soundfile
-                sf.write(output_path, stem_data, sample_rate)
+                print("🎵 Separando con API directa...")
+                waveform, sources = separator.separate_audio_file(audio_path)
+                
+                # Guardar archivos
+                output_files = []
+                temp_dir = tempfile.mkdtemp()
+                stem_names = ["drums", "bass", "other", "vocals"]
+                
+                for i, stem_name in enumerate(stem_names):
+                    if i < len(sources):
+                        output_path = os.path.join(temp_dir, f"{stem_name}.wav")
+                        torchaudio.save(output_path, sources[i], separator.samplerate)
+                        output_files.append(output_path)
+                        print(f"✅ {stem_name}.wav guardado")
+                
+                return output_files, f"✅ Separación completada: {len(output_files)} stems"
+                
+            except ImportError:
+                return [], "❌ Demucs no está instalado correctamente"
                 
-                if os.path.exists(output_path):
-                    output_files.append(output_path)
-                    print(f"✅ {stem_name}.wav guardado")
-            
-            success_msg = f"✅ Separación completada: {len(output_files)} stems generados"
-            print(success_msg)
-            
-            return output_files, success_msg
-            
         except Exception as e:
-            error_msg = f"❌ Error durante la separación: {str(e)}"
-            print(error_msg)
-            return [], error_msg
+            return [], f"❌ Error en separación manual: {str(e)}"
 
-# Inicializar separador
-print("🚀 Inicializando Audio Separator...")
-separator = SimpleAudioSeparator()
+# Inicializar wrapper
+print("🚀 Inicializando Demucs Wrapper...")
+demucs = DemucsWrapper()
 
-def process_audio(audio_file, separation_type, progress=gr.Progress()):
-    """Función principal para procesar audio"""
+def process_audio_demucs(audio_file, model_choice, use_subprocess, progress=gr.Progress()):
+    """Función principal para procesar con Demucs"""
     if audio_file is None:
-        return [], "⚠️ Por favor, sube un archivo de audio", "Ningún archivo seleccionado"
+        return [], "⚠️ Por favor, sube un archivo de audio", ""
     
     # Verificar tamaño
     try:
-        file_size = os.path.getsize(audio_file) / 1024 / 1024  # MB
-        if file_size > 20:
-            return [], "❌ Archivo muy grande. Máximo 20MB", f"Archivo: {file_size:.1f}MB"
+        file_size = os.path.getsize(audio_file) / 1024 / 1024
+        if file_size > 25:
+            return [], f"❌ Archivo muy grande: {file_size:.1f}MB. Máximo 25MB", ""
     except:
-        return [], "❌ Error leyendo el archivo", "Error de archivo"
+        return [], "❌ Error leyendo archivo", ""
+    
+    progress(0.1, desc="Iniciando Demucs...")
     
-    # Información del tipo de separación
-    separation_info = {
-        "4stems": "🎵 4 Stems: Separa en Voces, Batería, Bajo, Otros",
-        "2stems": "🎤 2 Stems: Separa en Voces e Instrumental"
+    # Información del modelo
+    model_info = {
+        "htdemucs": "🏆 Hybrid Transformer: Mejor calidad general",
+        "htdemucs_ft": "🥇 Fine-tuned: Estado del arte", 
+        "mdx_extra": "🎤 MDX Extra: Especializado en voces"
     }
     
-    info_text = separation_info.get(separation_type, "Separación desconocida")
+    info = model_info.get(model_choice, "Modelo desconocido")
     
-    # Mostrar progreso
-    progress(0.1, desc="Iniciando separación...")
-    progress(0.3, desc="Cargando modelo IA...")
+    progress(0.3, desc=f"Cargando modelo {model_choice}...")
     
-    # Separar audio
-    output_files, status = separator.separate_audio(audio_file, separation_type)
+    # Intentar separación
+    if use_subprocess:
+        print("🔄 Usando método subprocess...")
+        output_files, status = demucs.separate_with_subprocess(audio_file, model_choice)
+    else:
+        print("🔄 Usando método directo...")
+        output_files, status = demucs.separate_manual(audio_file, model_choice)
     
     progress(1.0, desc="¡Completado!")
     
-    return output_files, status, info_text
+    return output_files, status, info
 
-def get_audio_info(audio_file):
-    """Obtiene información básica del audio"""
-    if audio_file is None:
-        return "Ningún archivo seleccionado"
-    
+def check_demucs_installation():
+    """Verifica si demucs está instalado"""
     try:
-        # Cargar solo para obtener info
-        y, sr = librosa.load(audio_file, duration=1)  # Solo 1 segundo para info
-        duration = librosa.get_duration(path=audio_file)
-        
-        file_size = os.path.getsize(audio_file) / 1024 / 1024
-        
-        return f"""
-📊 **Info del archivo:**
-⏱️ Duración: {duration/60:.1f} minutos
-📏 Tamaño: {file_size:.1f} MB
-🎵 Sample Rate: {sr} Hz
-        """
+        result = subprocess.run([sys.executable, "-m", "demucs.separate", "--help"], 
+                              capture_output=True, timeout=10)
+        return result.returncode == 0
     except:
-        return "No se pudo analizar el archivo"
+        return False
 
 # Crear interfaz
-def create_interface():
+def create_demucs_interface():
+    # Verificar instalación
+    demucs_installed = check_demucs_installation()
+    
     with gr.Blocks(
-        title="🎵 Audio Separator - Spleeter",
+        title="🎵 Demucs Audio Separator",
         theme=gr.themes.Soft(),
         css="""
         .gradio-container { max-width: 1200px !important; }
-        .info-box { 
+        .model-info { 
             background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
-            color: white; padding: 15px; border-radius: 10px; margin: 10px 0;
-        }
-        .success-box {
-            background: linear-gradient(45deg, #56ab2f 0%, #a8e6cf 100%);
-            padding: 15px; border-radius: 10px;
+            color: white; padding: 15px; border-radius: 10px;
         }
+        .status-error { background-color: #ff6b6b; color: white; }
+        .status-success { background-color: #51cf66; color: white; }
         """
     ) as demo:
         
+        if not demucs_installed:
+            gr.Markdown("""
+            # ⚠️ Demucs Installation Required
+            
+            Demucs is not installed. The Space will attempt to install it on first use.
+            This may take several minutes.
+            """)
+        
         gr.Markdown("""
-        # 🎵 Audio Separator Pro (Spleeter)
+        # 🎵 Demucs Audio Separator
         
-        **Separa canciones como Moises - 100% GRATIS**
+        **El separador más avanzado - Tecnología de Facebook/Meta**
         
-        🚀 **Tecnología**: Spleeter (Deezer AI) - El mismo que usa Moises
+        🧠 **Demucs v4**: Estado del arte en separación de audio
+        - 🥁 **Batería** - Elementos percusivos limpios
+        - 🎸 **Bajo** - Líneas de bajo precisas
+        - 🎵 **Otros** - Melodías e instrumentos
+        - 🎤 **Voces** - Voces cristalinas
         
-        🎯 **Opciones de separación:**
-        - 🎵 **4 Stems**: Voces, Batería, Bajo, Otros instrumentos
-        - 🎤 **2 Stems**: Voces e Instrumental (karaoke)
+        ⚡ **Superior a Moises**: Mejor tecnología, 100% gratis
         """)
         
         with gr.Row():
             with gr.Column(scale=2):
                 audio_input = gr.Audio(
-                    label="🎵 Sube tu archivo de audio (máx 20MB)",
+                    label="🎵 Sube tu archivo (máx 25MB)",
                     type="filepath",
                     sources=["upload"]
                 )
                 
-                separation_type = gr.Radio(
-                    label="🎛️ Tipo de Separación",
-                    choices=[
-                        ("🎵 4 Stems (Voces, Batería, Bajo, Otros)", "4stems"),
-                        ("🎤 2 Stems (Voces, Instrumental)", "2stems")
-                    ],
-                    value="4stems"
-                )
+                with gr.Row():
+                    model_choice = gr.Dropdown(
+                        label="🤖 Modelo Demucs",
+                        choices=[
+                            ("🏆 Hybrid Transformer (Recomendado)", "htdemucs"),
+                            ("🥇 Fine-tuned (Mejor calidad)", "htdemucs_ft"),
+                            ("🎤 MDX Extra (Voces)", "mdx_extra")
+                        ],
+                        value="htdemucs"
+                    )
+                    
+                    use_subprocess = gr.Checkbox(
+                        label="🔧 Usar método subprocess (más estable)",
+                        value=True
+                    )
                 
                 process_btn = gr.Button(
-                    "🚀 Separar Audio",
+                    "🚀 Separar con Demucs",
                     variant="primary",
                     size="lg"
                 )
                 
-            with gr.Column(scale=1):
-                audio_info = gr.Markdown(
-                    "📊 Sube un archivo para ver información",
-                    elem_classes=["info-box"]
-                )
+                if not demucs_installed:
+                    install_btn = gr.Button(
+                        "📦 Instalar Demucs",
+                        variant="secondary"
+                    )
                 
-                separation_info = gr.Markdown(
-                    "🎵 4 Stems: Separa en Voces, Batería, Bajo, Otros",
-                    elem_classes=["info-box"]
+            with gr.Column(scale=1):
+                model_info = gr.Markdown(
+                    "🏆 Hybrid Transformer: Mejor calidad general",
+                    elem_classes=["model-info"]
                 )
                 
                 status_output = gr.Textbox(
                     label="📊 Estado",
                     interactive=False,
-                    lines=3
+                    lines=4
                 )
         
         download_files = gr.File(
-            label="📥 Descargar Stems Separados",
-            file_count="multiple",
-            interactive=False
+            label="📥 Descargar Stems de Demucs",
+            file_count="multiple"
         )
         
-        # Comparación y consejos
         gr.Markdown("""
-        ### 🆚 **vs Moises:**
+        ### 🏆 **¿Por qué Demucs es superior?**
         
-        | Característica | **Nuestro Separador** | **Moises Gratuito** | **Moises Premium** |
-        |----------------|----------------------|---------------------|-------------------|
-        | **4 Stems** | ✅ Ilimitado | ✅ 5/mes | ✅ Ilimitado |
-        | **Calidad** | ✅ Profesional | ✅ Buena | ✅ Profesional |
-        | **Velocidad** | ✅ 2-5 min | ✅ 2-5 min | ✅ 1-3 min |
-        | **Límites** | ✅ Solo tamaño archivo | ❌ 5 canciones/mes | ✅ Sin límites |
-        | **Costo** | 🆓 **GRATIS** | 🆓 Muy limitado | 💰 **$24.99/mes** |
+        | Característica | **Demucs v4** | **Spleeter** | **Moises** |
+        |----------------|---------------|---------------|------------|
+        | **Tecnología** | 🧠 Transformer Híbrido | 🤖 U-Net básico | 🤖 Spleeter |
+        | **Calidad SDR** | 🥇 9.0+ dB | 🥉 6.5 dB | 🥈 7.5 dB |
+        | **Desarrollador** | 🏢 Facebook/Meta | 🎵 Deezer | 🎵 Moises |
+        | **Costo** | 🆓 **GRATIS** | 🆓 Gratis | 💰 $24.99/mes |
         
-        ### 💡 **Consejos:**
-        - 🎵 **Formatos**: MP3, WAV, FLAC, M4A, OGG
-        - ⚡ **Velocidad**: 2-5 minutos por canción en CPU
-        - 🎧 **Mejor calidad**: Archivos WAV o FLAC de alta calidad
-        - 📱 **Tamaño máximo**: 20MB por archivo
-        - 🎯 **Uso**: Karaoke, remixes, aprendizaje musical
-        
-        ### 🎼 **Resultados esperados:**
-        - **Voces**: Limpias para karaoke o acapella
-        - **Batería**: Perfecta para beats y loops  
-        - **Bajo**: Ideal para líneas de bajo aisladas
-        - **Otros**: Melodías e instrumentos restantes
+        ### 💡 **Consejos Demucs:**
+        - 🎵 **Mejor con**: Música moderna, bien producida
+        - ⚡ **Tiempo**: 3-8 minutos en CPU, 1-2 min en GPU
+        - 🎧 **Calidad óptima**: WAV o FLAC de alta calidad
+        - 🔧 **Si falla**: Prueba modo subprocess
         """)
         
         # Event handlers
-        audio_input.change(
-            fn=get_audio_info,
-            inputs=[audio_input],
-            outputs=[audio_info]
-        )
-        
-        separation_type.change(
-            fn=lambda sep_type: {
-                "4stems": "🎵 4 Stems: Separa en Voces, Batería, Bajo, Otros",
-                "2stems": "🎤 2 Stems: Separa en Voces e Instrumental"
-            }.get(sep_type),
-            inputs=[separation_type],
-            outputs=[separation_info]
+        model_choice.change(
+            fn=lambda model: {
+                "htdemucs": "🏆 Hybrid Transformer: Mejor calidad general",
+                "htdemucs_ft": "🥇 Fine-tuned: Estado del arte", 
+                "mdx_extra": "🎤 MDX Extra: Especializado en voces"
+            }.get(model, ""),
+            inputs=[model_choice],
+            outputs=[model_info]
         )
         
         process_btn.click(
-            fn=process_audio,
-            inputs=[audio_input, separation_type],
-            outputs=[download_files, status_output, separation_info],
+            fn=process_audio_demucs,
+            inputs=[audio_input, model_choice, use_subprocess],
+            outputs=[download_files, status_output, model_info],
             show_progress=True
         )
+        
+        if not demucs_installed:
+            install_btn.click(
+                fn=lambda: ("Instalando Demucs..." if install_demucs_properly() else "Error en instalación"),
+                outputs=[status_output]
+            )
     
     return demo
 
-# Estado del sistema
-if SPLEETER_AVAILABLE:
-    print("✅ Sistema listo para separar audio!")
-else:
-    print("❌ Spleeter no disponible. Reinicia el Space.")
-
 if __name__ == "__main__":
-    demo = create_interface()
+    demo = create_demucs_interface()
     demo.launch()