Update app.py

app.py

@@ -10,12 +10,12 @@ import torch
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
 from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
-import subprocess
 import re
 import math
 from pydub import AudioSegment
 from collections import Counter
 import shutil
+import json
 
 # Configuración de logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -24,24 +24,42 @@ logger = logging.getLogger(__name__)
 # Clave API de Pexels
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
 
-# Buscar videos en Pexels usando API REST
+# Buscar videos en Pexels usando API REST - Versión mejorada
 def buscar_videos_pexels(query, api_key, per_page=5):
     headers = {"Authorization": api_key}
     try:
+        params = {
+            "query": query,
+            "per_page": per_page,
+            "orientation": "landscape",
+            "size": "medium"
+        }
+        
         response = requests.get(
             "https://api.pexels.com/videos/search",
             headers=headers,
-            params={"query": query, "per_page": per_page, "orientation": "landscape"},
-            timeout=15
+            params=params,
+            timeout=20
         )
         response.raise_for_status()
-        return response.json().get("videos", [])
+        
+        # Intentar parsear la respuesta
+        try:
+            data = response.json()
+            return data.get('videos', [])
+        except json.JSONDecodeError:
+            logger.error("Respuesta JSON inválida de Pexels")
+            return []
+            
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error de conexión con Pexels: {e}")
     except Exception as e:
-        logger.error(f"Error buscando videos en Pexels: {e}")
-        return []
+        logger.error(f"Error inesperado: {e}")
+    
+    return []
 
 # Inicialización de modelos
-MODEL_NAME = "datificate/gpt2-small-spanish"  # Modelo en español
+MODEL_NAME = "datificate/gpt2-small-spanish"
 try:
     tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
     model = GPT2LMHeadModel.from_pretrained(MODEL_NAME).eval()
@@ -53,7 +71,7 @@ except Exception as e:
     tokenizer = model = None
 
 try:
-    kw_model = KeyBERT('distilbert-base-multilingual-cased')  # Modelo multilingüe
+    kw_model = KeyBERT('distilbert-base-multilingual-cased')
     logger.info("KeyBERT cargado")
 except Exception as e:
     logger.error(f"Error al cargar KeyBERT: {e}")
@@ -86,7 +104,9 @@ def generate_script(prompt, max_length=150):
         
         # Limpiar texto generado
         text = re.sub(r'<[^>]+>', '', text)  # Eliminar tokens especiales
-        text = text.split(".")[0] + "."  # Tomar la primera oración coherente
+        sentences = text.split('.')
+        if sentences:
+            text = sentences[0] + '.'  # Tomar la primera oración coherente
         return text
     except Exception as e:
         logger.error(f"Error generando guion: {e}")
@@ -102,13 +122,15 @@ async def text_to_speech(text, output_path, voice="es-ES-ElviraNeural"):
         logger.error(f"Error en TTS: {e}")
         return False
 
-# Descarga de videos
+# Descarga de videos - Versión más robusta
 def download_video_file(url, temp_dir): 
     if not url:
         return None
     
     try:
         response = requests.get(url, stream=True, timeout=30)
+        response.raise_for_status()
+        
         file_name = f"video_{datetime.now().strftime('%H%M%S%f')}.mp4"
         output_path = os.path.join(temp_dir, file_name)
         
@@ -129,7 +151,7 @@ def loop_audio_to_length(audio_clip, target_duration):
     audios = [audio_clip] * loops
     return concatenate_videoclips(audios).subclip(0, target_duration)
 
-# Extracción de palabras clave robusta
+# Extracción de palabras clave robusta - Versión mejorada
 def extract_visual_keywords_from_script(script_text):
     # Limpiar texto
     clean_text = re.sub(r'[^\w\sáéíóúñ]', '', script_text.lower())
@@ -143,23 +165,26 @@ def extract_visual_keywords_from_script(script_text):
                 stop_words='spanish',
                 top_n=3
             )
-            return [kw[0].replace(" ", "+") for kw in keywords]
-        except:
-            pass  # Fallback al método simple
+            if keywords:
+                return [kw[0].replace(" ", "+") for kw in keywords]
+        except Exception as e:
+            logger.warning(f"KeyBERT falló: {e}")
     
     # Método 2: Frecuencia de palabras (fallback)
     words = clean_text.split()
     stop_words = {"el", "la", "los", "las", "de", "en", "y", "a", "que", "es", "un", "una", "con"}
     keywords = [word for word in words if len(word) > 3 and word not in stop_words]
     
+    # Si aún no hay palabras clave, usar palabras predeterminadas
     if not keywords:
-        return ["naturaleza"]  # Palabra clave por defecto
+        logger.warning("Usando palabras clave predeterminadas")
+        return ["naturaleza", "ciudad", "paisaje"]
     
     # Contar frecuencia y seleccionar las 3 más comunes
     word_counts = Counter(keywords)
     return [word.replace(" ", "+") for word, _ in word_counts.most_common(3)]
 
-# Función principal para crear video
+# Función principal para crear video - Versión mejorada
 def crear_video(prompt_type, input_text, musica_file=None):
     logger.info(f"Iniciando creación de video: {prompt_type}")
     
@@ -189,25 +214,60 @@ def crear_video(prompt_type, input_text, musica_file=None):
         audio_tts = AudioFileClip(voz_path)
         audio_duration = audio_tts.duration
         
-        # 3. Extraer palabras clave
-        keywords = extract_visual_keywords_from_script(guion)
+        # 3. Extraer palabras clave con respaldo
+        try:
+            keywords = extract_visual_keywords_from_script(guion)
+        except Exception as e:
+            logger.error(f"Error extrayendo palabras clave: {e}")
+            keywords = ["naturaleza", "paisaje"]  # Palabras clave de respaldo
+        
         logger.info(f"Palabras clave: {keywords}")
         
-        # 4. Buscar y descargar videos
+        # 4. Buscar y descargar videos con múltiples intentos
         videos_data = []
         for keyword in keywords:
-            videos_data.extend(buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2))
+            try:
+                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=3)
+                if videos:
+                    videos_data.extend(videos)
+                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'")
+            except Exception as e:
+                logger.warning(f"Error buscando videos para '{keyword}': {e}")
+        
+        # Si no encontramos videos, intentar con palabras clave genéricas
+        if not videos_data:
+            logger.warning("Usando palabras clave genéricas como respaldo")
+            for keyword in ["naturaleza", "ciudad", "paisaje"]:
+                videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=3)
+                if videos:
+                    videos_data.extend(videos)
+        
+        if not videos_data:
+            raise ValueError("No se encontraron videos en Pexels para ninguna palabra clave")
         
         video_paths = []
         for video in videos_data:
-            best_quality = max(video['video_files'], key=lambda x: x['width'] * x['height'])
-            path = download_video_file(best_quality['link'], temp_dir)
-            if path:
-                video_paths.append(path)
-                temp_files.append(path)
+            if 'video_files' not in video or not video['video_files']:
+                continue
+                
+            try:
+                # Seleccionar la mejor calidad de video
+                best_quality = max(
+                    video['video_files'], 
+                    key=lambda x: x.get('width', 0) * x.get('height', 0)
+                )
+                
+                if 'link' in best_quality:
+                    path = download_video_file(best_quality['link'], temp_dir)
+                    if path:
+                        video_paths.append(path)
+                        temp_files.append(path)
+                        logger.info(f"Video descargado: {best_quality['link']}")
+            except Exception as e:
+                logger.warning(f"Error procesando video: {e}")
         
         if not video_paths:
-            raise ValueError("No se encontraron videos adecuados")
+            raise ValueError("No se pudo descargar ningún video")
         
         # 5. Procesar videos
         clips = []
@@ -220,38 +280,53 @@ def crear_video(prompt_type, input_text, musica_file=None):
             try:
                 clip = VideoFileClip(path)
                 usable_duration = min(clip.duration, 10)
-                clips.append(clip.subclip(0, usable_duration))
-                current_duration += usable_duration
+                
+                if usable_duration > 1:  # Ignorar clips muy cortos
+                    clips.append(clip.subclip(0, usable_duration))
+                    current_duration += usable_duration
+                    logger.info(f"Añadido clip de {usable_duration:.1f}s (total: {current_duration:.1f}/{audio_duration:.1f}s)")
             except Exception as e:
-                logger.warning(f"Error procesando video: {e}")
+                logger.warning(f"Error procesando video {path}: {e}")
         
         if not clips:
-            raise ValueError("No hay clips válidos")
+            raise ValueError("No hay clips válidos para crear el video")
         
         video_base = concatenate_videoclips(clips, method="compose")
         
+        # Ajustar duración del video si es necesario
+        if video_base.duration < audio_duration:
+            num_repeats = int(audio_duration / video_base.duration) + 1
+            repeated_clips = [video_base] * num_repeats
+            video_base = concatenate_videoclips(repeated_clips).subclip(0, audio_duration)
+        
         # 6. Manejar música de fondo
         final_audio = audio_tts
         
         if musica_file:
             try:
-                # Convertir el archivo de música a formato utilizable
+                # Copiar archivo de música
                 music_path = os.path.join(temp_dir, "musica.mp3")
                 shutil.copyfile(musica_file, music_path)
                 temp_files.append(music_path)
                 
+                # Procesar música
                 musica_audio = AudioFileClip(music_path)
-                musica_loop = loop_audio_to_length(musica_audio, audio_duration)
                 
+                # Crear loop si es necesario
+                if musica_audio.duration < audio_duration:
+                    musica_audio = loop_audio_to_length(musica_audio, audio_duration)
+                
+                # Mezclar con el audio de voz
                 final_audio = CompositeAudioClip([
-                    musica_loop.volumex(0.3),
-                    audio_tts.volumex(1.0)
+                    musica_audio.volumex(0.3),  # 30% volumen
+                    audio_tts.volumex(1.0)      # 100% volumen voz
                 ])
+                logger.info("Música de fondo añadida")
             except Exception as e:
                 logger.warning(f"Error procesando música: {e}")
         
         # 7. Crear video final
-        video_final = video_base.set_audio(final_audio).subclip(0, audio_duration)
+        video_final = video_base.set_audio(final_audio)
         
         output_path = os.path.join(temp_dir, "final_video.mp4")
         video_final.write_videofile(
@@ -264,6 +339,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             logger=None
         )
         
+        logger.info(f"Video creado: {output_path}")
         return output_path
         
     except Exception as e:
@@ -291,46 +367,62 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         video_path = crear_video(prompt_type, input_text, musica_file)
         return video_path, "✅ Video generado exitosamente"
     except ValueError as ve:
-        return None, f"⚠️ Error: {ve}"
+        return None, f"⚠️ {ve}"
     except Exception as e:
-        return None, f"❌ Error crítico: {str(e)}"
+        return None, f"❌ Error: {str(e)}"
 
 # Interfaz de Gradio
-with gr.Blocks(title="Generador de Videos con IA", theme="soft") as app:
-    gr.Markdown("## 🎬 Generador Automático de Videos con IA")
+with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="""
+    .gradio-container {max-width: 800px; margin: auto;}
+    h1 {text-align: center;}
+    """) as app:
+    
+    gr.Markdown("# 🎬 Generador Automático de Videos con IA")
     
-    with gr.Tab("Generador de Video"):
-        with gr.Row():
+    with gr.Row():
+        with gr.Column():
             prompt_type = gr.Radio(
                 ["Generar Guion con IA", "Usar Mi Guion"], 
-                label="Método",
+                label="Método de Entrada",
                 value="Generar Guion con IA"
             )
-        
-        with gr.Column(visible=True) as ia_guion_column:
-            prompt_ia = gr.Textbox(
-                label="Tema para IA", 
-                lines=2,
-                placeholder="Ej: Un paisaje natural con montañas y ríos..."
-            )
-        
-        with gr.Column(visible=False) as manual_guion_column:
-            prompt_manual = gr.Textbox(
-                label="Tu Guion Completo", 
-                lines=5,
-                placeholder="Ej: En este video exploraremos los misterios del océano..."
+            
+            with gr.Column(visible=True) as ia_guion_column:
+                prompt_ia = gr.Textbox(
+                    label="Tema para IA", 
+                    lines=2,
+                    placeholder="Ej: Un paisaje natural con montañas y ríos...",
+                    max_lines=4
+                )
+            
+            with gr.Column(visible=False) as manual_guion_column:
+                prompt_manual = gr.Textbox(
+                    label="Tu Guion Completo", 
+                    lines=5,
+                    placeholder="Ej: En este video exploraremos los misterios del océano...",
+                    max_lines=10
+                )
+            
+            musica_input = gr.Audio(
+                label="Música de fondo (opcional)",
+                type="filepath",
+                interactive=True
             )
-        
-        musica_input = gr.Audio(
-            label="Música de fondo (opcional)",
-            type="filepath"
-        )
-        
-        boton = gr.Button("✨ Generar Video", variant="primary")
+            
+            generate_btn = gr.Button("✨ Generar Video", variant="primary")
         
         with gr.Column():
-            salida_video = gr.Video(label="Video Generado", interactive=False)
-            estado_mensaje = gr.Textbox(label="Estado", interactive=False)
+            video_output = gr.Video(
+                label="Video Generado", 
+                interactive=False,
+                height=400
+            )
+            status_output = gr.Textbox(
+                label="Estado", 
+                interactive=False,
+                show_label=False,
+                placeholder="Esperando acción..."
+            )
 
     # Manejar visibilidad de columnas
     prompt_type.change(
@@ -341,15 +433,25 @@ with gr.Blocks(title="Generador de Videos con IA", theme="soft") as app:
     )
 
     # Lógica de generación
-    boton.click(
-        lambda: (None, "⏳ Procesando... (puede tardar varios minutos)"),
-        outputs=[salida_video, estado_mensaje],
+    generate_btn.click(
+        lambda: (None, "⏳ Procesando... (esto puede tomar 2-5 minutos)"),
+        outputs=[video_output, status_output],
         queue=False
     ).then(
         run_app,
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
-        outputs=[salida_video, estado_mensaje]
+        outputs=[video_output, status_output]
     )
 
+    gr.Markdown("### Instrucciones:")
+    gr.Markdown("""
+    1. **Selecciona el tipo de entrada**: 
+        - "Generar Guion con IA": Describe un tema
+        - "Usar Mi Guion": Escribe tu guion completo
+    2. **Sube música** (opcional): Selecciona un archivo de audio
+    3. **Haz clic en Generar Video**
+    4. Espera a que se procese el video (puede tomar varios minutos)
+    """)
+
 if __name__ == "__main__":
     app.launch(server_name="0.0.0.0", server_port=7860)