Update app.py

app.py

@@ -14,7 +14,8 @@ from moviepy.editor import (
     AudioClip,
     TextClip,
     CompositeVideoClip,
-    VideoClip
+    VideoClip,
+    ColorClip  # Importar para video de respaldo
 )
 import numpy as np
 import json
@@ -31,19 +32,15 @@ import time
 from datetime import datetime, timedelta
 
 # ------------------- FIX PARA PILLOW -------------------
-# Solución para el error de ANTIALIAS en versiones nuevas de Pillow
 try:
     from PIL import Image
     if not hasattr(Image, 'ANTIALIAS'):
-        # Para versiones nuevas de Pillow
         Image.ANTIALIAS = Image.Resampling.LANCZOS
 except ImportError:
     pass
 
-# ------------------- Configuración de Timeout -------------------
-os.environ["GRADIO_SERVER_TIMEOUT"] = "3800"  # 30 minutos en segundos
-
 # ------------------- Configuración & Globals -------------------
+os.environ["GRADIO_SERVER_TIMEOUT"] = "3800"
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
@@ -62,7 +59,6 @@ class EdgeTTSEngine:
         logger.info(f"Inicializando Edge TTS con voz: {voice}")
     
     async def _synthesize_async(self, text, output_path):
-        """Sintetiza texto a voz usando Edge TTS de forma asíncrona"""
         try:
             communicate = edge_tts.Communicate(text, self.voice)
             await communicate.save(output_path)
@@ -72,15 +68,12 @@ class EdgeTTSEngine:
             return False
     
     def synthesize(self, text, output_path):
-        """Sintetiza texto a voz (wrapper síncrono)"""
         try:
-            # Ejecutar la función async en un nuevo loop
             return asyncio.run(self._synthesize_async(text, output_path))
         except Exception as e:
             logger.error(f"Error al sintetizar con Edge TTS: {e}")
             return False
 
-# Instancia global del motor TTS
 tts_engine = EdgeTTSEngine()
 
 # ------------------- Carga Perezosa de Modelos -------------------
@@ -114,7 +107,6 @@ def update_task_progress(task_id, message):
         logger.info(f"[{task_id}] {message}")
 
 def gpt2_script(prompt: str) -> str:
-    """Genera un guión usando GPT-2"""
     try:
         local_tokenizer = get_tokenizer()
         local_gpt2_model = get_gpt2_model()
@@ -143,7 +135,6 @@ def gpt2_script(prompt: str) -> str:
         return f"Hoy hablaremos sobre {prompt}. Este es un tema fascinante que merece nuestra atención."
 
 def generate_tts_audio(text: str, output_path: str) -> bool:
-    """Genera audio usando Edge TTS"""
     try:
         logger.info("Generando audio con Edge TTS...")
         success = tts_engine.synthesize(text, output_path)
@@ -158,7 +149,6 @@ def generate_tts_audio(text: str, output_path: str) -> bool:
         return False
 
 def extract_keywords(text: str) -> list[str]:
-    """Extrae palabras clave del texto para búsqueda de videos"""
     try:
         local_kw_model = get_kw_model()
         clean_text = re.sub(r"[^\w\sáéíóúñÁÉÍÓÚÑ]", "", text.lower())
@@ -184,7 +174,6 @@ def extract_keywords(text: str) -> list[str]:
                 "symbolism", "occult", "eerie", "haunting", "unexplained", "forbidden knowledge", "redacted", "conspiracy theorist"]
 
 def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
-    """Busca videos en Pexels"""
     if not PEXELS_API_KEY:
         return []
     
@@ -202,7 +191,6 @@ def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
         return []
 
 def download_video(url: str, folder: str) -> str | None:
-    """Descarga un video desde URL"""
     try:
         filename = f"{uuid.uuid4().hex}.mp4"
         filepath = os.path.join(folder, filename)
@@ -224,7 +212,6 @@ def download_video(url: str, folder: str) -> str | None:
         return None
 
 def create_subtitle_clips(script: str, video_width: int, video_height: int, duration: float):
-    """Crea clips de subtítulos"""
     try:
         sentences = [s.strip() for s in re.split(r"[.!?¿¡]", script) if s.strip()]
         if not sentences:
@@ -273,7 +260,6 @@ def create_subtitle_clips(script: str, video_width: int, video_height: int, dura
         return []
 
 def loop_audio_to_duration(audio_clip: AudioFileClip, target_duration: float) -> AudioFileClip:
-    """Hace loop del audio hasta alcanzar la duración objetivo"""
     if audio_clip is None:
         return None
     try:
@@ -289,12 +275,10 @@ def loop_audio_to_duration(audio_clip: AudioFileClip, target_duration: float) ->
 
 def create_video(script_text: str, generate_script: bool, music_path: str | None, task_id: str) -> str:
     temp_dir = tempfile.mkdtemp()
-    # Constantes para normalización
     TARGET_FPS = 24
-    TARGET_RESOLUTION = (1280, 720)  # (ancho, alto)
+    TARGET_RESOLUTION = (1280, 720)
     
     def normalize_clip(clip):
-        """Normaliza un clip de video a resolución y FPS estándar"""
         if clip is None:
             return None
         try:
@@ -345,17 +329,16 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         video_paths = []
         keywords = extract_keywords(script)
         
-        for i, keyword in enumerate(keywords[:3]):  # Límite de 3 keywords
+        for i, keyword in enumerate(keywords[:3]):
             update_task_progress(task_id, f"Paso 3/7: Buscando videos para '{keyword}' ({i+1}/{len(keywords[:3])})")
             
             videos = search_pexels_videos(keyword, 2)
             for video_data in videos:
-                if len(video_paths) >= 6:  # Límite de 6 videos
+                if len(video_paths) >= 6:
                     break
                 
                 video_files = video_data.get("video_files", [])
                 if video_files:
-                    # Tomar el video de mejor calidad
                     best_file = max(video_files, key=lambda f: f.get("width", 0))
                     video_url = best_file.get("link")
                     
@@ -374,19 +357,39 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         for path in video_paths:
             clip = None
             try:
+                # 1. Validar inmediatamente después de cargar cada video
                 clip = VideoFileClip(path)
-                if clip is None:
+                if clip is None or clip.duration <= 0:
+                    logger.error(f"Video inválido: {path}")
+                    if clip is not None:
+                        clip.close()
                     continue
-                    
+                
+                # 2. Probar cada clip antes de usarlo
+                try:
+                    test_frame = clip.get_frame(0)
+                except Exception as e:
+                    logger.error(f"Video corrupto: {path} - {e}")
+                    clip.close()
+                    continue
+                
                 # Tomar máximo 8 segundos de cada clip
                 duration = min(8, clip.duration)
+                
+                # 4. Verificar cada operación crítica
                 processed_clip = clip.subclip(0, duration)
+                if processed_clip is None:
+                    logger.error("Error al recortar video")
+                    clip.close()
+                    continue
                 
-                # Normalizar el clip (resolución y FPS)
+                # Normalizar el clip
                 processed_clip = normalize_clip(processed_clip)
-                
                 if processed_clip is not None:
                     video_clips.append(processed_clip)
+                else:
+                    logger.error(f"Error normalizando video: {path}")
+                    processed_clip.close()
                     
             except Exception as e:
                 logger.error(f"Error procesando video {path}: {e}")
@@ -394,52 +397,35 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                 if clip is not None:
                     clip.close()
         
+        # 3. Manejar explícitamente los casos donde no hay videos válidos
         if not video_clips:
-            raise RuntimeError("No se pudieron procesar los videos")
-        
-        # Concatenar videos
-        base_video = None
-        try:
+            logger.warning("No se procesaron videos válidos, creando video de respaldo...")
+            base_video = ColorClip(
+                size=TARGET_RESOLUTION, 
+                color=(0, 0, 0), 
+                duration=video_duration
+            )
+            base_video.fps = TARGET_FPS
+        else:
+            # Concatenar videos
             base_video = concatenate_videoclips(video_clips, method="chain")
-            if base_video is None:
-                raise RuntimeError("No se pudo concatenar los videos")
-        except Exception as e:
-            if base_video is not None:
-                base_video.close()
-            raise e
-        
-        # Extender video si es más corto que el audio con transiciones suaves
-        if base_video.duration < video_duration:
-            fade_duration = 0.5  # segundos de fundido
-            loops_needed = math.ceil(video_duration / base_video.duration)
-            
-            # Crear una lista de clips para el loop
-            looped_clips = [base_video]
-            for _ in range(loops_needed - 1):
-                # Crear un clip con fundido de entrada para la transición
-                fade_in_clip = base_video.crossfadein(fade_duration)
-                if fade_in_clip is not None:
-                    looped_clips.append(fade_in_clip)
-                    looped_clips.append(base_video)
             
-            try:
+            # Extender video si es más corto que el audio
+            if base_video.duration < video_duration:
+                fade_duration = 0.5
+                loops_needed = math.ceil(video_duration / base_video.duration)
+                
+                looped_clips = [base_video]
+                for _ in range(loops_needed - 1):
+                    fade_in_clip = base_video.crossfadein(fade_duration)
+                    if fade_in_clip is not None:
+                        looped_clips.append(fade_in_clip)
+                        looped_clips.append(base_video)
+                
                 base_video = concatenate_videoclips(looped_clips)
-                if base_video is None:
-                    raise RuntimeError("No se pudo extender el video")
-            except Exception as e:
-                if base_video is not None:
-                    base_video.close()
-                raise e
-        
-        # Asegurar que el video tenga la duración exacta del audio
-        try:
+            
+            # Asegurar duración exacta
             base_video = base_video.subclip(0, video_duration)
-            if base_video is None:
-                raise RuntimeError("No se pudo recortar el video")
-        except Exception as e:
-            if base_video is not None:
-                base_video.close()
-            raise e
         
         # Paso 5: Componer audio final
         update_task_progress(task_id, "Paso 5/7: Componiendo audio...")
@@ -466,60 +452,46 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         if subtitle_clips:
             try:
                 base_video = CompositeVideoClip([base_video] + subtitle_clips)
-                if base_video is None:
-                    raise RuntimeError("No se pudo agregar subtítulos")
             except Exception as e:
                 logger.error(f"Error creando video con subtítulos: {e}")
-                # Continuar sin subtítulos si falla
         
         # Paso 7: Renderizar video final
         update_task_progress(task_id, "Paso 7/7: Renderizando video final...")
-        final_video = None
-        try:
-            final_video = base_video.set_audio(final_audio)
-            if final_video is None:
-                raise RuntimeError("No se pudo combinar video y audio")
-            
-            output_path = os.path.join(RESULTS_DIR, f"video_{task_id}.mp4")
-            final_video.write_videofile(
-                output_path,
-                fps=TARGET_FPS,
-                codec="libx264",
-                audio_codec="aac",  # Mejor calidad de audio
-                bitrate="8000k",    # Controlar calidad de video
-                threads=4,          # Mejor uso de CPU
-                preset="slow",      # Mejor compresión
-                logger=None,
-                verbose=False
-            )
-            
-            return output_path
-        except Exception as e:
-            raise e
-        finally:
-            # Limpiar clips
-            if voice_clip is not None:
-                voice_clip.close()
-            if base_video is not None:
-                base_video.close()
-            if final_video is not None:
-                final_video.close()
-            for clip in video_clips:
-                if clip is not None:
-                    clip.close()
+        final_video = base_video.set_audio(final_audio)
+        
+        output_path = os.path.join(RESULTS_DIR, f"video_{task_id}.mp4")
+        final_video.write_videofile(
+            output_path,
+            fps=TARGET_FPS,
+            codec="libx264",
+            audio_codec="aac",
+            bitrate="8000k",
+            threads=4,
+            preset="slow",
+            logger=None,
+            verbose=False
+        )
+        
+        # Limpiar clips
+        voice_clip.close()
+        base_video.close()
+        final_video.close()
+        for clip in video_clips:
+            if clip is not None:
+                clip.close()
+        
+        return output_path
         
     except Exception as e:
         logger.error(f"Error creando video: {e}")
         raise
     finally:
-        # Limpiar directorio temporal
         try:
             shutil.rmtree(temp_dir)
         except:
             pass
 
 def worker_thread(task_id: str, mode: str, topic: str, user_script: str, music_path: str | None):
-    """Hilo worker para procesamiento de video"""
     try:
         generate_script = (mode == "Generar Guion con IA")
         content = topic if generate_script else user_script
@@ -541,14 +513,11 @@ def worker_thread(task_id: str, mode: str, topic: str, user_script: str, music_p
         })
 
 def generate_video_with_progress(mode, topic, user_script, music):
-    """Función principal que maneja la generación con progreso en tiempo real"""
-    # Validar entrada
     content = topic if mode == "Generar Guion con IA" else user_script
     if not content or not content.strip():
         yield "❌ Error: Por favor, ingresa un tema o guion.", None, None
         return
     
-    # Crear tarea
     task_id = uuid.uuid4().hex[:8]
     TASKS[task_id] = {
         "status": "processing",
@@ -556,7 +525,6 @@ def generate_video_with_progress(mode, topic, user_script, music):
         "timestamp": datetime.utcnow()
     }
     
-    # Iniciar worker
     worker = threading.Thread(
         target=worker_thread,
         args=(task_id, mode, topic, user_script, music),
@@ -564,12 +532,10 @@ def generate_video_with_progress(mode, topic, user_script, music):
     )
     worker.start()
     
-    # Monitorear progreso
     while TASKS[task_id]["status"] == "processing":
         yield TASKS[task_id]['progress_log'], None, None
         time.sleep(1)
     
-    # Retornar resultado final
     if TASKS[task_id]["status"] == "error":
         yield TASKS[task_id]['progress_log'], None, None
     elif TASKS[task_id]["status"] == "done":
@@ -578,10 +544,9 @@ def generate_video_with_progress(mode, topic, user_script, music):
 
 # ------------------- Limpieza automática -------------------
 def cleanup_old_files():
-    """Limpia archivos antiguos cada hora"""
     while True:
         try:
-            time.sleep(6600)  # 1 hora
+            time.sleep(6600)
             now = datetime.utcnow()
             logger.info("Ejecutando limpieza de archivos antiguos...")
             
@@ -598,18 +563,15 @@ def cleanup_old_files():
         except Exception as e:
             logger.error(f"Error en cleanup: {e}")
 
-# Iniciar hilo de limpieza
 threading.Thread(target=cleanup_old_files, daemon=True).start()
 
 # ------------------- Interfaz Gradio -------------------
 def toggle_input_fields(mode):
-    """Alterna los campos de entrada según el modo seleccionado"""
     return (
         gr.update(visible=mode == "Generar Guion con IA"),
         gr.update(visible=mode != "Generar Guion con IA")
     )
 
-# Crear interfaz
 with gr.Blocks(title="🎬 Generador de Videos IA", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
     # 🎬 Generador de Videos con IA
@@ -676,7 +638,6 @@ with gr.Blocks(title="🎬 Generador de Videos IA", theme=gr.themes.Soft()) as d
                 label="📥 Descargar archivo"
             )
     
-    # Event handlers
     mode_radio.change(
         fn=toggle_input_fields,
         inputs=[mode_radio],
@@ -699,14 +660,9 @@ with gr.Blocks(title="🎬 Generador de Videos IA", theme=gr.themes.Soft()) as d
     ⏱️ **Tiempo estimado**: 2-5 minutos dependiendo de la duración del contenido.
     """)
 
-# Ejecutar aplicación
 if __name__ == "__main__":
     logger.info("🚀 Iniciando aplicación Generador de Videos IA...")
-    
-    # Configurar la cola (versión compatible)
     demo.queue(max_size=10)
-    
-    # Lanzar aplicación (parámetros básicos compatibles)
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,