Update app.py

app.py

@@ -243,22 +243,28 @@ def create_subtitle_clips(script: str, video_width: int, video_height: int, dura
             if sentence_duration < 0.5:
                 continue
                 
-            txt_clip = (
-                TextClip(
-                    sentence,
-                    fontsize=max(20, int(video_height * 0.05)),
-                    color="white",
-                    stroke_color="black",
-                    stroke_width=2,
-                    method="caption",
-                    size=(int(video_width * 0.9), None),
-                    font="Arial-Bold"
+            try:
+                txt_clip = (
+                    TextClip(
+                        sentence,
+                        fontsize=max(20, int(video_height * 0.05)),
+                        color="white",
+                        stroke_color="black",
+                        stroke_width=2,
+                        method="caption",
+                        size=(int(video_width * 0.9), None),
+                        font="Arial-Bold"
+                    )
+                    .set_start(current_time)
+                    .set_duration(sentence_duration)
+                    .set_position(("center", "bottom"))
                 )
-                .set_start(current_time)
-                .set_duration(sentence_duration)
-                .set_position(("center", "bottom"))
-            )
-            clips.append(txt_clip)
+                if txt_clip is not None:
+                    clips.append(txt_clip)
+            except Exception as e:
+                logger.error(f"Error creando subtítulo para '{sentence}': {e}")
+                continue
+            
             current_time += sentence_duration
             
         return clips
@@ -268,6 +274,8 @@ def create_subtitle_clips(script: str, video_width: int, video_height: int, dura
 
 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:
         if audio_clip.duration >= target_duration:
             return audio_clip.subclip(0, target_duration)
@@ -287,11 +295,17 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
     
     def normalize_clip(clip):
         """Normaliza un clip de video a resolución y FPS estándar"""
-        if clip.size != TARGET_RESOLUTION:
-            clip = clip.resize(TARGET_RESOLUTION)
-        if clip.fps != TARGET_FPS:
-            clip = clip.set_fps(TARGET_FPS)
-        return clip
+        if clip is None:
+            return None
+        try:
+            if clip.size != TARGET_RESOLUTION:
+                clip = clip.resize(TARGET_RESOLUTION)
+            if clip.fps != TARGET_FPS:
+                clip = clip.set_fps(TARGET_FPS)
+            return clip
+        except Exception as e:
+            logger.error(f"Error normalizando clip: {e}")
+            return None
     
     try:
         # Paso 1: Generar o usar guión
@@ -311,11 +325,20 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
         if not generate_tts_audio(script, audio_path):
             raise RuntimeError("Error generando el audio TTS")
         
-        voice_clip = AudioFileClip(audio_path)
-        video_duration = voice_clip.duration
-        
-        if video_duration < 1:
-            raise ValueError("El audio generado es demasiado corto")
+        voice_clip = None
+        try:
+            voice_clip = AudioFileClip(audio_path)
+            if voice_clip is None:
+                raise RuntimeError("No se pudo cargar el clip de audio")
+            
+            video_duration = voice_clip.duration
+            
+            if video_duration < 1:
+                raise ValueError("El audio generado es demasiado corto")
+        except Exception as e:
+            if voice_clip is not None:
+                voice_clip.close()
+            raise e
         
         # Paso 3: Buscar y descargar videos
         update_task_progress(task_id, "Paso 3/7: Buscando videos en Pexels...")
@@ -352,12 +375,19 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             clip = None
             try:
                 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 (resolución y FPS)
                 processed_clip = normalize_clip(processed_clip)
-                video_clips.append(processed_clip)
+                
+                if processed_clip is not None:
+                    video_clips.append(processed_clip)
+                    
             except Exception as e:
                 logger.error(f"Error procesando video {path}: {e}")
             finally:
@@ -368,7 +398,15 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             raise RuntimeError("No se pudieron procesar los videos")
         
         # Concatenar videos
-        base_video = concatenate_videoclips(video_clips, method="chain")
+        base_video = None
+        try:
+            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:
@@ -380,60 +418,95 @@ def create_video(script_text: str, generate_script: bool, music_path: str | None
             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)
-                looped_clips.append(fade_in_clip)
-                looped_clips.append(base_video)
+                if fade_in_clip is not None:
+                    looped_clips.append(fade_in_clip)
+                    looped_clips.append(base_video)
             
-            base_video = concatenate_videoclips(looped_clips)
+            try:
+                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
-        base_video = base_video.subclip(0, video_duration)
+        try:
+            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...")
+        final_audio = voice_clip
+        
         if music_path and os.path.exists(music_path):
+            music_clip = None
             try:
                 music_clip = AudioFileClip(music_path)
-                music_clip = loop_audio_to_duration(music_clip, video_duration).volumex(0.2)
-                final_audio = CompositeAudioClip([music_clip, voice_clip])
+                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])
             except Exception as e:
                 logger.error(f"Error con música: {e}")
-                final_audio = voice_clip
-        else:
-            final_audio = voice_clip
+            finally:
+                if music_clip is not None:
+                    music_clip.close()
         
         # 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:
-            base_video = CompositeVideoClip([base_video] + 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 = 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",  # 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
-        )
-        
-        # Limpiar clips
-        voice_clip.close()
-        if 'music_clip' in locals():
-            music_clip.close()
-        base_video.close()
-        final_video.close()
-        for clip in video_clips:
-            clip.close()
-        
-        return output_path
+        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()
         
     except Exception as e:
         logger.error(f"Error creando video: {e}")