Update app.py

app.py

@@ -175,9 +175,11 @@ def extract_keywords(text: str) -> list[str]:
 
 def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
     if not PEXELS_API_KEY:
+        logger.warning("PEXELS_API_KEY no está definida")
         return []
     
     try:
+        logger.info(f"Buscando videos en Pexels para: {query}")
         response = requests.get(
             "https://api.pexels.com/videos/search",
             headers={"Authorization": PEXELS_API_KEY},
@@ -185,7 +187,10 @@ def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
             timeout=20
         )
         response.raise_for_status()
-        return response.json().get("videos", [])
+        data = response.json()
+        videos = data.get("videos", [])
+        logger.info(f"Se encontraron {len(videos)} videos para '{query}'")
+        return videos
     except Exception as e:
         logger.error(f"Error buscando videos en Pexels: {e}")
         return []
@@ -195,6 +200,7 @@ def download_video(url: str, folder: str) -> str | None:
         filename = f"{uuid.uuid4().hex}.mp4"
         filepath = os.path.join(folder, filename)
         
+        logger.info(f"Descargando video desde: {url}")
         with requests.get(url, stream=True, timeout=60) as response:
             response.raise_for_status()
             with open(filepath, "wb") as f:
@@ -202,6 +208,7 @@ def download_video(url: str, folder: str) -> str | None:
                     f.write(chunk)
         
         if os.path.exists(filepath) and os.path.getsize(filepath) > 1000:
+            logger.info(f"Video descargado correctamente: {filepath} ({os.path.getsize(filepath)} bytes)")
             return filepath
         else:
             logger.error(f"Archivo descargado inválido: {filepath}")
@@ -292,7 +299,7 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             return None
     
     def validate_clip(clip, path="unknown"):
-        """Función para validar que un clip sea usable"""
+        """Función para validar que un clip sea usable - versión menos estricta"""
         if clip is None:
             logger.error(f"Clip es None: {path}")
             return False
@@ -303,11 +310,16 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                 logger.error(f"Clip con duración inválida: {path}")
                 return False
             
-            # Verificar que podemos obtener un frame
-            test_frame = clip.get_frame(0)
-            if test_frame is None:
-                logger.error(f"No se pudo obtener frame del clip: {path}")
-                return False
+            # Verificar que podemos obtener un frame - MENOS ESTRICTO
+            try:
+                test_frame = clip.get_frame(0)
+                if test_frame is None:
+                    logger.error(f"No se pudo obtener frame del clip: {path}")
+                    return False
+            except Exception as frame_error:
+                logger.warning(f"Error al obtener frame de {path}: {frame_error}")
+                # En lugar de rechazar, intentamos continuar
+                return True
                 
             return True
         except Exception as e:
@@ -360,23 +372,34 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         video_paths = []
         keywords = extract_keywords(script)
         
+        logger.info(f"Palabras clave extraídas: {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"Se encontraron {len(videos)} videos para '{keyword}'")
+            
             for video_data in 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")
+                    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 exitosamente: {downloaded_path}")
+        
+        logger.info(f"Total de videos descargados: {len(video_paths)}")
         
         if not video_paths:
             logger.warning("No se pudieron descargar videos de Pexels, creando video de respaldo...")
@@ -388,9 +411,11 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             update_task_progress(task_id, f"Paso 4/7: Procesando {len(video_paths)} videos...")
             video_clips = []
             
-            for path in video_paths:
+            for i, path in enumerate(video_paths):
                 clip = None
                 try:
+                    logger.info(f"Procesando video {i+1}/{len(video_paths)}: {path}")
+                    
                     # Verificar que el archivo exista y tenga tamaño
                     if not os.path.exists(path) or os.path.getsize(path) < 1024:
                         logger.error(f"Archivo inválido: {path}")
@@ -402,10 +427,12 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                         logger.error(f"No se pudo cargar el video: {path}")
                         continue
                     
-                    # Validar el clip original
+                    logger.info(f"Video cargado: {path} - Duración: {clip.duration}s - Tamaño: {clip.size}")
+                    
+                    # Validar el clip original - MENOS ESTRICTO
                     if not validate_clip(clip, path):
-                        clip.close()
-                        continue
+                        logger.warning(f"Clip inválido, pero intentando usarlo igualmente: {path}")
+                        # No cerramos el clip, lo intentamos usar igualmente
                     
                     # Recortar el video
                     duration = min(8, clip.duration)
@@ -416,22 +443,22 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                         clip.close()
                         continue
                     
-                    # Validar el clip recortado
+                    # Validar el clip recortado - MENOS ESTRICTO
                     if not validate_clip(processed_clip, f"{path} (recortado)"):
-                        processed_clip.close()
-                        clip.close()
-                        continue
+                        logger.warning(f"Clip recortado inválido, pero intentando usarlo igualmente: {path}")
+                        # No cerramos el clip, lo intentamos usar igualmente
                     
                     # Normalizar
                     processed_clip = normalize_clip(processed_clip)
                     
                     if processed_clip is not None:
-                        # Validación final del clip procesado
+                        # Validación final del clip procesado - MENOS ESTRICTO
                         if validate_clip(processed_clip, f"{path} (normalizado)"):
                             video_clips.append(processed_clip)
+                            logger.info(f"Video procesado exitosamente: {path}")
                         else:
-                            processed_clip.close()
-                            clip.close()
+                            logger.warning(f"Clip normalizado inválido, pero intentando usarlo igualmente: {path}")
+                            video_clips.append(processed_clip)  # Lo usamos igualmente
                     else:
                         logger.error(f"Error normalizando video: {path}")
                         clip.close()
@@ -442,6 +469,8 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                     if clip is not None:
                         clip.close()
             
+            logger.info(f"Total de videos procesados exitosamente: {len(video_clips)}")
+            
             # Verificar si tenemos clips válidos
             if not video_clips:
                 logger.warning("No se procesaron videos válidos, creando video de respaldo...")
@@ -453,11 +482,12 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                 valid_clips = []
                 for i, clip in enumerate(video_clips):
                     try:
-                        # Verificación final de cada clip
+                        # Verificación final de cada clip - MENOS ESTRICTA
                         if validate_clip(clip, f"clip_{i}"):
                             valid_clips.append(clip)
                         else:
-                            clip.close()
+                            logger.warning(f"Clip inválido en posición {i}, pero intentando usarlo igualmente")
+                            valid_clips.append(clip)  # Lo usamos igualmente
                     except Exception as e:
                         logger.error(f"Clip inválido en posición {i}: {e}")
                         if clip is not None:
@@ -478,9 +508,11 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
                         if base_video is None:
                             raise RuntimeError("La concatenación devolvió None")
                         
-                        # Validar el video concatenado
+                        # Validar el video concatenado - MENOS ESTRICTO
                         if not validate_clip(base_video, "video_concatenado"):
-                            raise RuntimeError("Video concatenado inválido")
+                            logger.warning("Video concatenado inválido, pero intentando usarlo igualmente")
+                        
+                        logger.info(f"Video concatenado exitosamente. Duración: {base_video.duration}s")
                         
                     except Exception as e:
                         logger.error(f"Error concatenando videos: {e}")