Update app.py

app.py

@@ -15,8 +15,7 @@ from moviepy.editor import (
     TextClip,
     CompositeVideoClip,
     VideoClip,
-    ColorClip,
-    ImageClip
+    ColorClip
 )
 import numpy as np
 import json
@@ -292,72 +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 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...")
@@ -390,14 +323,10 @@ 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
@@ -406,93 +335,51 @@ 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}")
         
-        logger.info(f"Total videos descargados: {len(video_paths)}")
+        if not video_paths:
+            raise RuntimeError("No se pudieron descargar videos de Pexels")
         
-        # Paso 4: Procesar videos o crear video visual
+        # Paso 4: Procesar videos - SOLO CORREGIR EL ERROR DE NoneType
         update_task_progress(task_id, f"Paso 4/7: Procesando {len(video_paths)} videos...")
         video_clips = []
         
-        if video_paths:
-            for i, path in enumerate(video_paths):
-                clip = None
-                try:
-                    logger.info(f"Procesando video {i+1}/{len(video_paths)}: {path}")
-                    
-                    # 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)}")
-        
-        # Decidir qué video usar
-        if video_clips:
-            # Usar videos de Pexels
+        for path in video_paths:
+            clip = None
             try:
-                base_video = concatenate_videoclips(video_clips, method="chain")
-                logger.info(f"Videos de Pexels concatenados. Duración: {base_video.duration}s")
+                # Cargar el video
+                clip = VideoFileClip(path)
+                if clip is None:
+                    continue
+                
+                # Tomar máximo 8 segundos de cada clip
+                duration = min(8, clip.duration)
+                processed_clip = clip.subclip(0, duration)
+                
+                # 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 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)
+                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:
-            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)
         
@@ -542,8 +429,7 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         base_video.close()
         final_video.close()
         for clip in video_clips:
-            if clip is not None:
-                clip.close()
+            clip.close()
         
         return output_path