Update app.py

app.py

@@ -175,11 +175,9 @@ 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},
@@ -187,10 +185,7 @@ def search_pexels_videos(query: str, count: int = 3) -> list[dict]:
             timeout=20
         )
         response.raise_for_status()
-        data = response.json()
-        videos = data.get("videos", [])
-        logger.info(f"Se encontraron {len(videos)} videos para '{query}'")
-        return videos
+        return response.json().get("videos", [])
     except Exception as e:
         logger.error(f"Error buscando videos en Pexels: {e}")
         return []
@@ -200,7 +195,6 @@ 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:
@@ -208,7 +202,6 @@ 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}")
@@ -298,48 +291,6 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             logger.error(f"Error normalizando clip: {e}")
             return None
     
-    def validate_clip(clip, path="unknown"):
-        """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
-        
-        try:
-            # Verificar duración
-            if clip.duration <= 0:
-                logger.error(f"Clip con duración inválida: {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:
-            logger.error(f"Error validando clip {path}: {e}")
-            return False
-    
-    def create_fallback_video(duration):
-        """Crea un video de respaldo"""
-        try:
-            fallback = ColorClip(
-                size=TARGET_RESOLUTION, 
-                color=(0, 0, 0), 
-                duration=duration
-            )
-            fallback.fps = TARGET_FPS
-            return fallback
-        except Exception as e:
-            logger.error(f"Error creando video de respaldo: {e}")
-            return None
-    
     try:
         # Paso 1: Generar o usar guión
         update_task_progress(task_id, "Paso 1/7: Preparando guión...")
@@ -372,239 +323,87 @@ 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...")
-            base_video = create_fallback_video(video_duration)
-            if base_video is None:
-                raise RuntimeError("No se pudo crear video de respaldo")
-        else:
-            # Paso 4: Procesar videos
-            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:
-                    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}")
-                        continue
-                    
-                    # 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: {path} - Duración: {clip.duration}s - Tamaño: {clip.size}")
-                    
-                    # Validar el clip original - MENOS ESTRICTO
-                    if not validate_clip(clip, path):
-                        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)
-                    processed_clip = clip.subclip(0, duration)
-                    
-                    if processed_clip is None:
-                        logger.error(f"Error al recortar video: {path}")
-                        clip.close()
-                        continue
-                    
-                    # Validar el clip recortado - MENOS ESTRICTO
-                    if not validate_clip(processed_clip, f"{path} (recortado)"):
-                        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 - MENOS ESTRICTO
-                        if validate_clip(processed_clip, f"{path} (normalizado)"):
-                            video_clips.append(processed_clip)
-                            logger.info(f"Video procesado exitosamente: {path}")
-                        else:
-                            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()
-                        
-                except Exception as e:
-                    logger.error(f"Error procesando video {path}: {e}")
-                finally:
-                    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...")
-                base_video = create_fallback_video(video_duration)
-                if base_video is None:
-                    raise RuntimeError("No se pudo crear video de respaldo")
-            else:
-                # Verificar que todos los clips sean válidos antes de concatenar
-                valid_clips = []
-                for i, clip in enumerate(video_clips):
-                    try:
-                        # Verificación final de cada clip - MENOS ESTRICTA
-                        if validate_clip(clip, f"clip_{i}"):
-                            valid_clips.append(clip)
-                        else:
-                            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:
-                            clip.close()
-                
-                if not valid_clips:
-                    logger.warning("Todos los clips son inválidos, creando video de respaldo...")
-                    base_video = create_fallback_video(video_duration)
-                    if base_video is None:
-                        raise RuntimeError("No se pudo crear video de respaldo")
-                else:
-                    # Concatenar solo clips válidos
-                    update_task_progress(task_id, "Paso 4/7: Concatenando videos válidos...")
-                    try:
-                        base_video = concatenate_videoclips(valid_clips, method="chain")
-                        
-                        # Verificar que la concatenación funcionó
-                        if base_video is None:
-                            raise RuntimeError("La concatenación devolvió None")
-                        
-                        # Validar el video concatenado - MENOS ESTRICTO
-                        if not validate_clip(base_video, "video_concatenado"):
-                            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}")
-                        # Liberar clips
-                        for clip in valid_clips:
-                            if clip is not None:
-                                clip.close()
-                        # Crear video de respaldo
-                        base_video = create_fallback_video(video_duration)
-                        if base_video is None:
-                            raise RuntimeError("No se pudo crear video de respaldo")
+            raise RuntimeError("No se pudieron descargar videos de Pexels")
         
-        # Extender video si es más corto que el audio
-        if base_video.duration < video_duration:
-            update_task_progress(task_id, "Paso 4/7: Extendiendo video...")
+        # Paso 4: Procesar videos - VERSIÓN SIMPLIFICADA
+        update_task_progress(task_id, f"Paso 4/7: Procesando {len(video_paths)} videos...")
+        video_clips = []
+        
+        for path in video_paths:
+            clip = None
             try:
-                fade_duration = 0.5
-                loops_needed = math.ceil(video_duration / base_video.duration)
+                # Cargar el video
+                clip = VideoFileClip(path)
+                if clip is None:
+                    continue
                 
-                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)
+                # Tomar máximo 8 segundos de cada clip
+                duration = min(8, clip.duration)
+                processed_clip = clip.subclip(0, duration)
                 
-                # Guardar referencia al video original para liberarlo después
-                original_video = base_video
-                base_video = concatenate_videoclips(looped_clips)
-                
-                # Verificar el video extendido
-                if base_video is None or not validate_clip(base_video, "video_extendido"):
-                    logger.error("Error al extender video, usando original")
-                    base_video = original_video
-                else:
-                    # Liberar el video original
-                    original_video.close()
+                # Normalizar el clip
+                processed_clip = normalize_clip(processed_clip)
                 
+                if processed_clip is not None:
+                    video_clips.append(processed_clip)
+                    
             except Exception as e:
-                logger.error(f"Error extendiendo video: {e}")
-                # No hacemos nada, seguimos con el video original
+                logger.error(f"Error procesando video {path}: {e}")
+            finally:
+                if clip is not None:
+                    clip.close()
+        
+        if not video_clips:
+            raise RuntimeError("No se pudieron procesar los videos")
+        
+        # Concatenar videos
+        base_video = concatenate_videoclips(video_clips, method="chain")
+        
+        # Extender video si es más corto que el audio
+        if base_video.duration < video_duration:
+            loops_needed = math.ceil(video_duration / base_video.duration)
+            base_video = concatenate_videoclips([base_video] * loops_needed)
         
         # Asegurar duración exacta
-        try:
-            original_video = base_video
-            base_video = base_video.subclip(0, video_duration)
-            
-            if base_video is None or not validate_clip(base_video, "video_recortado"):
-                logger.error("Error al recortar video final, usando original")
-                base_video = original_video
-            else:
-                original_video.close()
-                
-        except Exception as e:
-            logger.error(f"Error al recortar video final: {e}")
-            # No hacemos nada, seguimos con el video original
+        base_video = base_video.subclip(0, video_duration)
         
         # Paso 5: Componer audio final
         update_task_progress(task_id, "Paso 5/7: Componiendo audio...")
-        final_audio = voice_clip
-        
         if music_path and os.path.exists(music_path):
-            music_clip = None
             try:
                 music_clip = AudioFileClip(music_path)
-                if music_clip is not None:
-                    music_clip = loop_audio_to_duration(music_clip, video_duration)
-                    if music_clip is not None:
-                        music_clip = music_clip.volumex(0.2)
-                        final_audio = CompositeAudioClip([music_clip, voice_clip])
+                music_clip = loop_audio_to_duration(music_clip, video_duration).volumex(0.2)
+                final_audio = CompositeAudioClip([music_clip, voice_clip])
             except Exception as e:
                 logger.error(f"Error con música: {e}")
-            finally:
-                if music_clip is not None:
-                    music_clip.close()
+                final_audio = voice_clip
+        else:
+            final_audio = voice_clip
         
         # Paso 6: Agregar subtítulos
         update_task_progress(task_id, "Paso 6/7: Agregando subtítulos...")
         subtitle_clips = create_subtitle_clips(script, base_video.w, base_video.h, video_duration)
         if subtitle_clips:
-            try:
-                original_video = base_video
-                base_video = CompositeVideoClip([base_video] + subtitle_clips)
-                
-                if base_video is None or not validate_clip(base_video, "video_con_subtitulos"):
-                    logger.error("Error al agregar subtítulos, usando video original")
-                    base_video = original_video
-                else:
-                    original_video.close()
-                    
-            except Exception as e:
-                logger.error(f"Error creando video con subtítulos: {e}")
+            base_video = CompositeVideoClip([base_video] + subtitle_clips)
         
         # Paso 7: Renderizar video final
         update_task_progress(task_id, "Paso 7/7: Renderizando video final...")
@@ -625,11 +424,12 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         
         # Limpiar clips
         voice_clip.close()
+        if 'music_clip' in locals():
+            music_clip.close()
         base_video.close()
         final_video.close()
         for clip in video_clips:
-            if clip is not None:
-                clip.close()
+            clip.close()
         
         return output_path