Update app.py

app.py

@@ -3,79 +3,42 @@ import asyncio
 import logging
 import tempfile
 import requests
-from datetime import datetime
+import re
+import math
 import edge_tts
 import gradio as gr
-import torch
-import re
-from keybert import KeyBERT
+from pydub import AudioSegment
+import subprocess
 
 # Configuración básica de logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
 # Clave API de Pexels (configurar en Secrets de Hugging Face)
-PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "YOUR_DEFAULT_API_KEY")
-
-# Inicialización del modelo KeyBERT
-try:
-    kw_model = KeyBERT('distilbert-base-nli-mean-tokens')
-    logger.info("Modelo KeyBERT cargado exitosamente.")
-except Exception as e:
-    logger.error(f"Error al cargar KeyBERT: {e}")
-    kw_model = None
-
-# --- Funciones principales optimizadas para Spaces ---
-
-async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
-    """Genera audio TTS usando edge-tts"""
-    try:
-        communicate = edge_tts.Communicate(text, voice)
-        await communicate.save(output_path)
-        return True
-    except Exception as e:
-        logger.error(f"Error en TTS: {e}")
-        return False
+PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY", "YOUR_API_KEY")
 
-def download_video(url, temp_dir):
-    """Descarga un video desde una URL a un directorio temporal"""
-    try:
-        response = requests.get(url, stream=True, timeout=30)
-        response.raise_for_status()
-        
-        filename = f"video_{datetime.now().strftime('%H%M%S%f')}.mp4"
-        filepath = os.path.join(temp_dir, filename)
-        
-        with open(filepath, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
-                f.write(chunk)
-                
-        return filepath
-    except Exception as e:
-        logger.error(f"Error descargando video: {e}")
-        return None
+# --- Funciones optimizadas para Spaces ---
 
 def extract_keywords(text, max_keywords=3):
-    """Extrae palabras clave usando KeyBERT o método simple como fallback"""
-    if kw_model:
-        try:
-            keywords = kw_model.extract_keywords(
-                text,
-                keyphrase_ngram_range=(1, 2),
-                top_n=max_keywords,
-                use_mmr=True,
-                diversity=0.7
-            )
-            return [kw[0].replace(" ", "+") for kw in keywords]
-        except Exception as e:
-            logger.warning(f"Error KeyBERT: {e}")
+    """Extrae palabras clave usando un método simple pero efectivo"""
+    # Limpieza de texto
+    text = re.sub(r'[^\w\s]', '', text.lower())
+    words = text.split()
     
-    # Fallback: método simple
-    words = re.findall(r'\b\w+\b', text.lower())
-    stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "por"}
-    return list(set([w for w in words if len(w) > 3 and w not in stop_words][:max_keywords]))
+    # Palabras comunes a excluir
+    stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "por", "un", "una", "con"}
+    
+    # Frecuencia de palabras
+    word_freq = {}
+    for word in words:
+        if len(word) > 3 and word not in stop_words:
+            word_freq[word] = word_freq.get(word, 0) + 1
+    
+    # Ordenar por frecuencia
+    sorted_words = sorted(word_freq.items(), key=lambda x: x[1], reverse=True)
+    return [word for word, _ in sorted_words[:max_keywords]]
 
-def search_pexels_videos(query_list, per_query=2):
+def search_pexels_videos(keywords, per_query=2):
     """Busca videos en Pexels usando su API oficial"""
     if not PEXELS_API_KEY:
         logger.error("API_KEY de Pexels no configurada")
@@ -84,7 +47,7 @@ def search_pexels_videos(query_list, per_query=2):
     headers = {"Authorization": PEXELS_API_KEY}
     video_urls = []
     
-    for query in query_list:
+    for query in keywords:
         try:
             params = {
                 "query": query,
@@ -101,11 +64,13 @@ def search_pexels_videos(query_list, per_query=2):
             )
             
             if response.status_code == 200:
-                videos = response.json().get("videos", [])
+                data = response.json()
+                videos = data.get("videos", [])
+                
                 for video in videos:
                     video_files = video.get("video_files", [])
                     if video_files:
-                        # Seleccionar el video con la mejor resolución
+                        # Seleccionar el video con la mejor resolución disponible
                         best_quality = max(
                             video_files, 
                             key=lambda x: x.get("width", 0) * x.get("height", 0)
@@ -116,49 +81,116 @@ def search_pexels_videos(query_list, per_query=2):
     
     return video_urls
 
+async def generate_tts(text, output_path, voice="es-ES-ElviraNeural"):
+    """Genera audio TTS usando edge-tts"""
+    try:
+        communicate = edge_tts.Communicate(text, voice)
+        await communicate.save(output_path)
+        return True
+    except Exception as e:
+        logger.error(f"Error en TTS: {e}")
+        return False
+
+def download_video(url, temp_dir):
+    """Descarga un video desde una URL a un directorio temporal"""
+    try:
+        response = requests.get(url, stream=True, timeout=30)
+        response.raise_for_status()
+        
+        filename = f"video_{os.getpid()}.mp4"
+        filepath = os.path.join(temp_dir, filename)
+        
+        with open(filepath, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+                
+        return filepath
+    except Exception as e:
+        logger.error(f"Error descargando video: {e}")
+        return None
+
 def create_video(audio_path, video_paths, output_path):
-    """Crea el video final usando FFmpeg"""
+    """Crea el video final usando FFmpeg (más eficiente que moviepy)"""
     try:
         # Crear archivo de lista para concatenación
-        with open("input_list.txt", "w") as f:
+        list_file = "input.txt"
+        with open(list_file, "w") as f:
             for path in video_paths:
-                f.write(f"file '{path}'\n")
+                f.write(f"file '{os.path.basename(path)}'\n")
+        
+        # Mover al directorio temporal para procesamiento
+        os.chdir(os.path.dirname(video_paths[0]))
         
         # Comando FFmpeg para concatenar videos y añadir audio
         cmd = [
             "ffmpeg", "-y",
             "-f", "concat",
             "-safe", "0",
-            "-i", "input_list.txt",
+            "-i", list_file,
             "-i", audio_path,
-            "-c", "copy",
+            "-c:v", "copy",
+            "-c:a", "aac",
             "-shortest",
             output_path
         ]
         
-        subprocess.run(cmd, check=True)
+        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         return True
     except Exception as e:
         logger.error(f"Error creando video: {e}")
         return False
+    finally:
+        if os.path.exists(list_file):
+            os.remove(list_file)
 
-async def generate_video(text, music_url=None):
+def add_background_music(audio_path, music_path):
+    """Añade música de fondo al audio principal"""
+    try:
+        speech = AudioSegment.from_file(audio_path)
+        background = AudioSegment.from_file(music_path) - 20  # Reducir volumen
+        
+        # Extender música si es necesario
+        if len(background) < len(speech):
+            loops = math.ceil(len(speech) / len(background))
+            background = background * loops
+        
+        combined = speech.overlay(background[:len(speech)])
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            combined.export(tmp_file.name, format="mp3")
+            return tmp_file.name
+    except Exception as e:
+        logger.error(f"Error mezclando audio: {e}")
+        return audio_path
+
+async def generate_video(text, music_file=None):
     """Función principal para generar el video"""
     temp_dir = tempfile.mkdtemp()
-    all_files = []
+    output_files = []
     
     try:
         # 1. Generar audio TTS
         tts_path = os.path.join(temp_dir, "audio.mp3")
-        if not await text_to_speech(text, tts_path):
+        if not await generate_tts(text, tts_path):
             return None, "Error generando voz"
-        all_files.append(tts_path)
+        output_files.append(tts_path)
+        
+        # 2. Añadir música de fondo si está disponible
+        final_audio = tts_path
+        if music_file:
+            mixed_audio = add_background_music(tts_path, music_file)
+            if mixed_audio != tts_path:
+                final_audio = mixed_audio
+                output_files.append(mixed_audio)
         
-        # 2. Extraer palabras clave
+        # 3. Extraer palabras clave
         keywords = extract_keywords(text)
         logger.info(f"Palabras clave identificadas: {keywords}")
         
-        # 3. Buscar y descargar videos
+        if not keywords:
+            return None, "No se pudieron extraer palabras clave del texto"
+        
+        # 4. Buscar y descargar videos
         video_urls = search_pexels_videos(keywords)
         if not video_urls:
             return None, "No se encontraron videos para las palabras clave"
@@ -168,14 +200,14 @@ async def generate_video(text, music_url=None):
             path = download_video(url, temp_dir)
             if path:
                 video_paths.append(path)
-                all_files.append(path)
+                output_files.append(path)
         
         if not video_paths:
             return None, "Error descargando videos"
         
-        # 4. Crear video final
+        # 5. Crear video final
         output_path = os.path.join(temp_dir, "final_video.mp4")
-        if create_video(tts_path, video_paths, output_path):
+        if create_video(final_audio, video_paths, output_path):
             return output_path, "Video creado exitosamente"
         else:
             return None, "Error en la creación del video"
@@ -184,10 +216,10 @@ async def generate_video(text, music_url=None):
         logger.exception("Error inesperado")
         return None, f"Error: {str(e)}"
     finally:
-        # Limpieza opcional (Hugging Face limpia automáticamente)
+        # No eliminamos archivos temporales - Hugging Face los maneja
         pass
 
-# --- Interfaz de Gradio ---
+# --- Interfaz de Gradio optimizada ---
 with gr.Blocks(title="Generador Automático de Videos con IA", theme="soft") as demo:
     gr.Markdown("# 🎬 Generador Automático de Videos con IA")
     gr.Markdown("Transforma texto en videos usando contenido de Pexels y voz sintetizada")
@@ -199,25 +231,33 @@ with gr.Blocks(title="Generador Automático de Videos con IA", theme="soft") as
                 placeholder="Describe el contenido que quieres en el video...",
                 lines=5
             )
+            music_input = gr.Audio(
+                label="Música de fondo (opcional)",
+                type="filepath"
+            )
             generate_btn = gr.Button("Generar Video", variant="primary")
         
         with gr.Column():
-            video_output = gr.Video(label="Video Generado")
-            status_output = gr.Textbox(label="Estado")
+            video_output = gr.Video(label="Video Generado", interactive=False)
+            status_output = gr.Textbox(label="Estado", interactive=False)
     
     generate_btn.click(
+        fn=lambda: (None, "Procesando... (esto puede tomar 1-2 minutos)"),
+        outputs=[video_output, status_output],
+        queue=False
+    ).then(
         fn=generate_video,
-        inputs=[text_input],
+        inputs=[text_input, music_input],
         outputs=[video_output, status_output]
     )
     
-    gr.Markdown("### Cómo funciona:")
+    gr.Markdown("### Características:")
     gr.Markdown("""
-    1. Ingresa un texto descriptivo
-    2. Nuestra IA extrae palabras clave
-    3. Buscamos videos relacionados en Pexels
-    4. Generamos voz con Edge TTS
-    5. Combinamos todo en un video final
+    - **Extracción inteligente de palabras clave** del texto
+    - **Búsqueda automática de videos** en Pexels
+    - **Generación de voz** con Edge TTS
+    - **Música de fondo opcional**
+    - **Procesamiento eficiente** con FFmpeg
     """)
 
 # Para Hugging Face Spaces