Update app.py

app.py

@@ -15,7 +15,8 @@ from moviepy.editor import (
     TextClip,
     CompositeVideoClip,
     VideoClip,
-    ColorClip
+    ColorClip,
+    ImageClip
 )
 import numpy as np
 import json
@@ -291,6 +292,72 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             logger.error(f"Error normalizando clip: {e}")
             return None
     
+    def create_visual_video(script: str, duration: float):
+        """Crea un video visual con texto cuando no hay videos de Pexels"""
+        try:
+            logger.info("Creando video visual con texto...")
+            
+            # Crear clips de texto para cada frase
+            sentences = [s.strip() for s in re.split(r"[.!?¿¡]", script) if s.strip()]
+            if not sentences:
+                sentences = [script]
+            
+            clips = []
+            sentence_duration = duration / len(sentences)
+            
+            for i, sentence in enumerate(sentences):
+                try:
+                    # Crear fondo con color cambiante
+                    color_intensity = int(255 * (i / len(sentences)))
+                    bg_color = (color_intensity, 50, 150 - color_intensity//2)
+                    
+                    bg_clip = ColorClip(
+                        size=TARGET_RESOLUTION,
+                        color=bg_color,
+                        duration=sentence_duration
+                    )
+                    bg_clip.fps = TARGET_FPS
+                    
+                    # Crear texto
+                    txt_clip = TextClip(
+                        sentence,
+                        fontsize=60,
+                        color="white",
+                        stroke_color="black",
+                        stroke_width=3,
+                        method="caption",
+                        size=(int(TARGET_RESOLUTION[0] * 0.9), None),
+                        font="Arial-Bold",
+                        align="center"
+                    ).set_position("center")
+                    
+                    # Combinar fondo y texto
+                    composite = CompositeVideoClip([bg_clip, txt_clip])
+                    clips.append(composite)
+                    
+                except Exception as e:
+                    logger.error(f"Error creando clip visual para '{sentence}': {e}")
+                    continue
+            
+            if clips:
+                return concatenate_videoclips(clips)
+            else:
+                # Si falla, crear un video simple con color
+                return ColorClip(
+                    size=TARGET_RESOLUTION,
+                    color=(50, 50, 150),
+                    duration=duration
+                )
+                
+        except Exception as e:
+            logger.error(f"Error creando video visual: {e}")
+            # Último recurso: video de color sólido
+            return ColorClip(
+                size=TARGET_RESOLUTION,
+                color=(50, 50, 150),
+                duration=duration
+            )
+    
     try:
         # Paso 1: Generar o usar guión
         update_task_progress(task_id, "Paso 1/7: Preparando guión...")
@@ -323,10 +390,14 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         video_paths = []
         keywords = extract_keywords(script)
         
+        logger.info(f"Palabras clave: {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)
+            logger.info(f"Encontrados {len(videos)} videos para '{keyword}'")
+            
             for video_data in videos:
                 if len(video_paths) >= 6:
                     break
@@ -335,95 +406,93 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                 if video_files:
                     best_file = max(video_files, key=lambda f: f.get("width", 0))
                     video_url = best_file.get("link")
+                    video_quality = f"{best_file.get('width', 0)}x{best_file.get('height', 0)}"
+                    
+                    logger.info(f"Intentando descargar video {video_quality}: {video_url}")
                     
                     if video_url:
                         downloaded_path = download_video(video_url, temp_dir)
                         if downloaded_path:
                             video_paths.append(downloaded_path)
+                            logger.info(f"Video descargado: {downloaded_path}")
         
-        if not video_paths:
-            raise RuntimeError("No se pudieron descargar videos de Pexels")
+        logger.info(f"Total videos descargados: {len(video_paths)}")
         
-        # Paso 4: Procesar videos - MANEJO CORRECTO DE CLIPS NULOS
+        # Paso 4: Procesar videos o crear video visual
         update_task_progress(task_id, f"Paso 4/7: Procesando {len(video_paths)} videos...")
         video_clips = []
         
-        for i, path in enumerate(video_paths):
-            clip = None
-            try:
-                # Cargar el video - SI FALLA, CONTINUAR CON EL SIGUIENTE
-                clip = VideoFileClip(path)
-                if clip is None:
-                    logger.error(f"Video {i+1} no se pudo cargar: {path}")
-                    continue
-                
-                # Verificar que el clip tenga duración
-                if clip.duration <= 0:
-                    logger.error(f"Video {i+1} tiene duración inválida: {path}")
-                    clip.close()
-                    continue
-                
-                # Tomar máximo 8 segundos - SI FALLA, CONTINUAR
-                duration = min(8, clip.duration)
-                processed_clip = clip.subclip(0, duration)
-                
-                if processed_clip is None:
-                    logger.error(f"No se pudo recortar el video {i+1}: {path}")
-                    clip.close()
-                    continue
-                
-                # Normalizar el clip - SI FALLA, CONTINUAR
-                processed_clip = normalize_clip(processed_clip)
-                
-                if processed_clip is not None:
-                    video_clips.append(processed_clip)
-                    logger.info(f"Video {i+1} procesado exitosamente: {path}")
-                else:
-                    logger.error(f"No se pudo normalizar el video {i+1}: {path}")
-                    processed_clip.close()
-                    clip.close()
+        if video_paths:
+            for i, path in enumerate(video_paths):
+                clip = None
+                try:
+                    logger.info(f"Procesando video {i+1}/{len(video_paths)}: {path}")
                     
-            except Exception as e:
-                logger.error(f"Error procesando video {i+1} {path}: {e}")
-            finally:
-                # Asegurarse de cerrar el clip original si existe
-                if clip is not None:
-                    clip.close()
+                    # Verificar archivo
+                    if not os.path.exists(path):
+                        logger.error(f"Archivo no existe: {path}")
+                        continue
+                    
+                    file_size = os.path.getsize(path)
+                    logger.info(f"Tamaño del archivo: {file_size} bytes")
+                    
+                    if file_size < 1000:
+                        logger.error(f"Archivo demasiado pequeño: {path}")
+                        continue
+                    
+                    # Intentar cargar el video
+                    clip = VideoFileClip(path)
+                    if clip is None:
+                        logger.error(f"No se pudo cargar el video: {path}")
+                        continue
+                    
+                    logger.info(f"Video cargado: duración={clip.duration}s, tamaño={clip.size}")
+                    
+                    # Tomar máximo 8 segundos
+                    duration = min(8, clip.duration)
+                    processed_clip = clip.subclip(0, duration)
+                    
+                    if processed_clip is None:
+                        logger.error(f"No se pudo recortar el video: {path}")
+                        clip.close()
+                        continue
+                    
+                    # Normalizar
+                    processed_clip = normalize_clip(processed_clip)
+                    
+                    if processed_clip is not None:
+                        video_clips.append(processed_clip)
+                        logger.info(f"Video {i+1} procesado exitosamente")
+                    else:
+                        logger.error(f"No se pudo normalizar el video {i+1}")
+                        processed_clip.close()
+                        clip.close()
+                        
+                except Exception as e:
+                    logger.error(f"Error procesando video {i+1}: {str(e)}")
+                finally:
+                    if clip is not None:
+                        clip.close()
         
         logger.info(f"Videos procesados exitosamente: {len(video_clips)} de {len(video_paths)}")
         
-        # Si no hay videos válidos, crear video de respaldo
-        if not video_clips:
-            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 - MANEJO DE ERROR
+        # Decidir qué video usar
+        if video_clips:
+            # Usar videos de Pexels
             try:
                 base_video = concatenate_videoclips(video_clips, method="chain")
-                if base_video is None:
-                    raise RuntimeError("La concatenación devolvió None")
-                logger.info(f"Videos concatenados exitosamente. Duración: {base_video.duration}s")
+                logger.info(f"Videos de Pexels concatenados. Duración: {base_video.duration}s")
             except Exception as e:
-                logger.error(f"Error concatenando videos: {e}")
-                # Cerrar todos los clips antes de crear respaldo
-                for clip in video_clips:
-                    if clip is not None:
-                        clip.close()
-                # Crear video de respaldo
-                base_video = ColorClip(
-                    size=TARGET_RESOLUTION, 
-                    color=(0, 0, 0), 
-                    duration=video_duration
-                )
-                base_video.fps = TARGET_FPS
+                logger.error(f"Error concatenando videos de Pexels: {e}")
+                base_video = create_visual_video(script, video_duration)
+        else:
+            # Crear video visual si no hay videos de Pexels
+            logger.warning("No hay videos válidos de Pexels, creando video visual...")
+            base_video = create_visual_video(script, video_duration)
         
         # Extender video si es más corto que el audio
         if base_video.duration < video_duration:
+            logger.info(f"Extendiendo video de {base_video.duration}s a {video_duration}s")
             loops_needed = math.ceil(video_duration / base_video.duration)
             base_video = concatenate_videoclips([base_video] * loops_needed)