Update app.py

app.py

@@ -2,96 +2,95 @@ import gradio as gr
 import whisper
 import os
 import tempfile
-import numpy as np
 from pydub import AudioSegment
-import torch
+import subprocess
 
-# Cargar modelo (usa "base" para CPU, "small" o "medium" si tienes GPU)
+# Cargar modelo
 print("Cargando modelo Whisper...")
 model = whisper.load_model("base")
 print("Modelo cargado.")
 
 def extract_audio_from_video(video_path):
     """Extrae audio de video usando ffmpeg"""
-    import subprocess
-    audio_path = video_path.replace('.mp4', '.wav').replace('.avi', '.wav').replace('.mov', '.wav')
-    audio_path = audio_path + "_audio.wav"
+    audio_path = tempfile.mktemp(suffix='.wav')
     
     command = [
         'ffmpeg',
         '-i', video_path,
-        '-vn',  # No video
+        '-vn',
         '-acodec', 'pcm_s16le',
-        '-ar', '16000',  # Whisper necesita 16kHz
-        '-ac', '1',      # Mono
+        '-ar', '16000',
+        '-ac', '1',
+        '-y',  # Sobrescribir si existe
         audio_path
     ]
     
-    subprocess.run(command, capture_output=True)
+    result = subprocess.run(command, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise Exception(f"Error extrayendo audio: {result.stderr}")
+    
     return audio_path
 
-def split_audio(audio_path, chunk_length_ms=30000):  # 30 segundos por chunk
-    """Divide el audio en chunks para procesar largos"""
+def split_audio(audio_path, chunk_length_ms=30000):
+    """Divide el audio en chunks"""
     audio = AudioSegment.from_wav(audio_path)
     chunks = []
     
     for i in range(0, len(audio), chunk_length_ms):
         chunk = audio[i:i + chunk_length_ms]
-        chunk_path = f"{audio_path}_chunk_{i}.wav"
+        chunk_path = tempfile.mktemp(suffix=f'_chunk_{i}.wav')
         chunk.export(chunk_path, format="wav")
         chunks.append(chunk_path)
     
     return chunks
 
 def transcribir_archivo(archivo):
-    """
-    Función principal de transcripción
-    """
+    """Función principal de transcripción"""
     if archivo is None:
-        return "Por favor sube un archivo"
+        yield "Por favor sube un archivo", ""
+        return
     
-    archivo_path = archivo.name if hasattr(archivo, 'name') else archivo
     texto_completo = []
     archivos_temp = []
     
     try:
-        # Determinar si es video o audio
-        extension = os.path.splitext(archivo_path)[1].lower()
-        es_video = extension in ['.mp4', '.avi', '.mov', '.mkv', '.webm']
+        extension = os.path.splitext(archivo)[1].lower()
+        es_video = extension in ['.mp4', '.avi', '.mov', '.mkv', '.webm', '.mpg', '.mpeg']
         
         yield "Procesando archivo...", ""
         
         # Extraer audio si es video
         if es_video:
             yield "Extrayendo audio del video...", ""
-            audio_path = extract_audio_from_video(archivo_path)
+            audio_path = extract_audio_from_video(archivo)
             archivos_temp.append(audio_path)
         else:
-            # Convertir a wav si es necesario
-            audio = AudioSegment.from_file(archivo_path)
+            # Convertir a wav
+            yield "Convirtiendo audio...", ""
+            audio = AudioSegment.from_file(archivo)
             audio_path = tempfile.mktemp(suffix='.wav')
             audio.export(audio_path, format="wav", parameters=["-ar", "16000", "-ac", "1"])
             archivos_temp.append(audio_path)
         
-        # Dividir en chunks si es muy largo (>30 segundos)
+        # Verificar duración
         audio = AudioSegment.from_wav(audio_path)
-        duracion_total = len(audio) / 1000  # segundos
+        duracion_total = len(audio) / 1000
         
         if duracion_total > 30:
             yield f"Dividiendo audio en partes (duración: {duracion_total:.1f}s)...", ""
-            chunks = split_audio(audio_path, 30000)  # 30s chunks
+            chunks = split_audio(audio_path, 30000)
             archivos_temp.extend(chunks)
         else:
             chunks = [audio_path]
         
-        # Transcribir cada chunk
+        # Transcribir
         total_chunks = len(chunks)
         for i, chunk_path in enumerate(chunks):
-            yield f"Transcribiendo parte {i+1} de {total_chunks}...", "\n".join(texto_completo)
+            yield f"Transcribiendo parte {i+1} de {total_chunks}...", "\n\n".join(texto_completo)
             
             resultado = model.transcribe(
                 chunk_path,
-                language="es",  # Forzar español (quita esto para autodetectar)
+                language="es",
                 task="transcribe"
             )
             texto_completo.append(resultado["text"])
@@ -103,7 +102,7 @@ def transcribir_archivo(archivo):
         yield f"Error: {str(e)}", ""
     
     finally:
-        # Limpiar archivos temporales
+        # Limpiar
         for temp_file in archivos_temp:
             try:
                 if os.path.exists(temp_file):
@@ -111,15 +110,12 @@ def transcribir_archivo(archivo):
             except:
                 pass
 
-# Interfaz de Gradio
+# Interfaz Gradio
 with gr.Blocks(title="Transcriptor de Video/Audio") as demo:
     gr.Markdown("""
     # 🎙️ Transcriptor de Video y Audio
     
     Sube un video o archivo de audio y obtén la transcripción en texto.
-    
-    **Soporta:** MP4, AVI, MOV, MP3, WAV, M4A, etc.
-    **Idioma:** Optimizado para español (pero detecta automáticamente)
     """)
     
     with gr.Row():
@@ -143,13 +139,6 @@ with gr.Blocks(title="Transcriptor de Video/Audio") as demo:
         inputs=archivo_input,
         outputs=[estado, resultado]
     )
-    
-    gr.Markdown("""
-    ### 💡 Tips:
-    - Archivos largos se dividen automáticamente en partes
-    - El procesamiento puede tomar varios minutos dependiendo la duración
-    - Máximo recomendado: 1 hora de audio (puede variar según recursos del Space)
-    """)
 
 if __name__ == "__main__":
     demo.launch()