Update app.py

app.py

@@ -206,7 +206,13 @@ def loop_audio_to_length(audio_clip, target_duration):
     logger.debug(f"Adjusting audio | Current duration: {audio_clip.duration:.2f}s | Target: {target_duration:.2f}s")
     if audio_clip.duration is None or audio_clip.duration <= 0:
         logger.warning("Audio clip has zero or negative duration, cannot loop.")
-        return AudioFileClip(filename="")
+        # Return a small silent clip or similar if duration is invalid
+        try:
+            from moviepy.editor import AudioClip
+            return AudioClip(lambda t: 0, duration=target_duration, sr=44100)
+        except Exception as e:
+             logger.error(f"Could not create silence clip: {e}")
+             return AudioFileClip(filename="")
 
     if audio_clip.duration >= target_duration:
         logger.debug("Audio clip already longer or equal to target.")
@@ -216,17 +222,21 @@ def loop_audio_to_length(audio_clip, target_duration):
     logger.debug(f"Creating {loops} audio loops")
     
     audio_segments = [audio_clip] * loops
+    looped_audio = None # Initialize for finally block
     try:
        looped_audio = concatenate_audioclips(audio_segments)
        final_looped_audio = looped_audio.subclip(0, target_duration)
-       # Close the temporary concatenated clip to free resources
-       try: looped_audio.close()
-       except: pass
        return final_looped_audio
     except Exception as e:
         logger.error(f"Error concatenating audio clips for looping: {str(e)}", exc_info=True)
         # Fallback: return original clip if looping fails
         return audio_clip.subclip(0, min(audio_clip.duration, target_duration))
+    finally:
+        # Clean up the temporary concatenated clip
+        if looped_audio is not None:
+            try: looped_audio.close()
+            except: pass
+
 
 def extract_visual_keywords_from_script(script_text):
     logger.info("Extracting keywords from script")
@@ -293,9 +303,10 @@ def crear_video(prompt_type, input_text, musica_file=None):
     # Initialize clips and audio objects to None for cleanup in finally
     audio_tts = None
     musica_audio = None
-    video_base = None
-    video_final = None
-    concatenated_clips = [] # Keep track of main video clips for closing
+    video_base = None # This will hold the final video base clip before adding audio
+    video_final = None # This will hold the final clip with video and audio
+    source_clips = [] # Clips loaded from downloaded files for proper closing
+    clips_to_concatenate = [] # Segments extracted from source_clips
 
     try:
         # 1. Generate or use script
@@ -326,7 +337,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
         audio_duration = audio_tts.duration
         logger.info(f"Voice audio duration: {audio_duration:.2f} seconds")
 
-        if audio_duration < 1.0: # Require at least 1 second of audio
+        if audio_duration < 1.0:
              logger.error(f"Voice audio duration ({audio_duration:.2f}s) is too short.")
              raise ValueError("Generated voice audio is too short (min 1 second required).")
 
@@ -368,7 +379,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
                     videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2)
                     if videos:
                         videos_data.extend(videos)
-                        logger.extend(videos)
                         logger.info(f"Found {len(videos)} videos for '{keyword}' (generic). Total data: {len(videos_data)}")
                  except Exception as e:
                     logger.warning(f"Error searching generic videos for '{keyword}': {str(e)}")
@@ -413,27 +423,28 @@ def crear_video(prompt_type, input_text, musica_file=None):
         
         # 5. Process and concatenate video clips
         logger.info("Processing and concatenating downloaded videos...")
-        source_clips = [] # Clips loaded from downloaded files
-        clips_to_concatenate = [] # Segments extracted from source_clips
         current_duration = 0
         min_clip_duration = 0.5
-        max_clip_segment = 10.0
+        max_clip_segment = 10.0 # Max segment length from one source clip
 
         for i, path in enumerate(video_paths):
+            # Stop if we have enough duration plus a buffer
             if current_duration >= audio_duration + max_clip_segment:
                 logger.debug(f"Video base sufficient ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Stopping processing remaining source clips.")
                 break
 
-            clip = None
+            clip = None # Initialize for finally block
             try:
                 logger.debug(f"[{i+1}/{len(video_paths)}] Opening clip: {path}")
                 clip = VideoFileClip(path)
                 source_clips.append(clip) # Add to list for later cleanup
 
+                # Verify the source clip is valid
                 if clip.reader is None or clip.duration is None or clip.duration <= 0:
-                    logger.warning(f"[{i+1}/{len(video_paths)}] Clip {path} seems invalid (reader is None or duration <= 0). Skipping.")
+                    logger.warning(f"[{i+1}/{len(video_paths)}] Source clip {path} seems invalid (reader is None or duration <= 0). Skipping.")
                     continue
 
+                # Calculate how much to take from this clip
                 remaining_needed = audio_duration - current_duration
                 potential_use_duration = min(clip.duration, max_clip_segment)
 
@@ -446,7 +457,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
                           try:
                                # Create a subclip. This creates a *new* clip object.
                                sub = clip.subclip(0, segment_duration)
-                               # Verify the subclip is valid
+                               # Verify the subclip is valid (it should be a VideoFileClip still)
                                if sub.reader is None or sub.duration is None or sub.duration <= 0:
                                     logger.warning(f"[{i+1}/{len(video_paths)}] Generated subclip from {path} is invalid. Skipping.")
                                     try: sub.close() # Close the invalid subclip
@@ -468,8 +479,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             except Exception as e:
                 logger.warning(f"[{i+1}/{len(video_paths)}] Error processing video {path}: {str(e)}", exc_info=True)
                 continue
-            # No 'finally' here to close 'clip' explicitly, because we add valid clips to source_clips
-            # and close them all together later.
+            # Source clips are closed in the main finally block
 
         logger.info(f"Source clip processing finished. Obtained {len(clips_to_concatenate)} valid segments.")
 
@@ -478,26 +488,29 @@ def crear_video(prompt_type, input_text, musica_file=None):
             raise ValueError("No valid video segments available to create the video.")
         
         logger.info(f"Concatenating {len(clips_to_concatenate)} video segments.")
+        concatenated_base = None # Hold the result temporarily
         try:
             # Concatenate the collected valid segments
-            video_base = concatenate_videoclips(clips_to_concatenate, method="chain") # Explicitly use "chain"
-            logger.info(f"Base video duration after initial concatenation: {video_base.duration:.2f}s")
-
-            # IMPORTANT: Close all the individual segments that were concatenated
-            for clip_segment in clips_to_concatenate:
-                 try: clip_segment.close()
-                 except: pass
-            clips_to_concatenate = [] # Clear the list
+            concatenated_base = concatenate_videoclips(clips_to_concatenate, method="chain")
+            logger.info(f"Base video duration after initial concatenation: {concatenated_base.duration:.2f}s")
 
             # Verify the resulting concatenated clip is valid
-            if video_base.reader is None or video_base.duration is None or video_base.duration <= 0:
-                 logger.critical("Concatenated video base clip is invalid after first concatenation.")
+            # CORRECTED CHECK for CompositeVideoClip: Check existence and duration
+            if concatenated_base is None or concatenated_base.duration is None or concatenated_base.duration <= 0:
+                 logger.critical("Concatenated video base clip is invalid after first concatenation (None or zero duration).")
                  raise ValueError("Failed to create valid video base from segments.")
 
         except Exception as e:
              logger.critical(f"Error during initial concatenation: {str(e)}", exc_info=True)
              raise ValueError("Failed during initial video concatenation.")
+        finally:
+             # IMPORTANT: Close all the individual segments that were concatenated *regardless of success*
+             for clip_segment in clips_to_concatenate:
+                  try: clip_segment.close()
+                  except: pass
+             clips_to_concatenate = [] # Clear the list
 
+        video_base = concatenated_base # Assign the valid concatenated clip
 
         # --- REVISED REPETITION AND TRIMMING LOGIC ---
         final_video_base = video_base # Start with the concatenated base
@@ -513,20 +526,29 @@ def crear_video(prompt_type, input_text, musica_file=None):
             if remaining_duration > 0:
                 try:
                     remaining_clip = final_video_base.subclip(0, remaining_duration)
-                    repeated_clips_list.append(remaining_clip)
-                    logger.debug(f"Adding remaining segment: {remaining_duration:.2f}s")
+                    # Verify remaining clip is valid (should be a CompositeVideoClip from subclip)
+                    if remaining_clip is None or remaining_clip.duration is None or remaining_clip.duration <= 0:
+                        logger.warning(f"Generated subclip for remaining duration {remaining_duration:.2f}s is invalid. Skipping.")
+                        try: remaining_clip.close()
+                        except: pass
+                    else:
+                         repeated_clips_list.append(remaining_clip)
+                         logger.debug(f"Adding remaining segment: {remaining_duration:.2f}s")
+
                 except Exception as e:
                      logger.warning(f"Error creating subclip for remaining duration {remaining_duration:.2f}s: {str(e)}")
 
             if repeated_clips_list:
                  logger.info(f"Concatenating {len(repeated_clips_list)} parts for repetition.")
+                 video_base_repeated = None # Hold result temporarily
                  try:
                     # Concatenate the repeated parts
                     video_base_repeated = concatenate_videoclips(repeated_clips_list, method="chain")
                     logger.info(f"Duration of repeated video base: {video_base_repeated.duration:.2f}s")
                     
                     # Verify the repeated clip is valid
-                    if video_base_repeated.reader is None or video_base_repeated.duration is None or video_base_repeated.duration <= 0:
+                    # CORRECTED CHECK: Check existence and duration
+                    if video_base_repeated is None or video_base_repeated.duration is None or video_base_repeated.duration <= 0:
                          logger.critical("Concatenated repeated video base clip is invalid.")
                          raise ValueError("Failed to create valid repeated video base.")
 
@@ -538,21 +560,24 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
                  except Exception as e:
                     logger.critical(f"Error during repetition concatenation: {str(e)}", exc_info=True)
-                    # If repetition fails, maybe just use the original base and accept it's too short
-                    logger.warning("Repetition failed. Using original video base (may be too short).")
-                    # No need to change final_video_base if concatenation failed
+                    raise ValueError("Failed during video repetition.")
+                 finally:
+                     # Close the clips in the repeated list, EXCEPT the one assigned to final_video_base
+                     for clip in repeated_clips_list:
+                          if clip is not final_video_base:
+                               try: clip.close()
+                               except: pass
 
-            else:
-                 logger.error("Failed to create repeated video clips list.")
-                 # Use original video_base if repetition list is empty
 
         # After repetition (or if no repetition happened), ensure duration matches audio exactly
         if final_video_base.duration > audio_duration:
              logger.info(f"Trimming video base ({final_video_base.duration:.2f}s) to match audio duration ({audio_duration:.2f}s).")
+             trimmed_video_base = None # Hold result temporarily
              try:
                 trimmed_video_base = final_video_base.subclip(0, audio_duration)
                 # Verify the trimmed clip is valid
-                if trimmed_video_base.reader is None or trimmed_video_base.duration is None or trimmed_video_base.duration <= 0:
+                # CORRECTED CHECK: Check existence and duration
+                if trimmed_video_base is None or trimmed_video_base.duration is None or trimmed_video_base.duration <= 0:
                      logger.critical("Trimmed video base clip is invalid.")
                      raise ValueError("Failed to create valid trimmed video base.")
 
@@ -564,16 +589,15 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
              except Exception as e:
                 logger.critical(f"Error during trimming: {str(e)}", exc_info=True)
-                # If trimming fails, use the original longer clip (might cause audio/video sync issues)
-                logger.warning("Trimming failed. Using potentially longer video base.")
-                pass # final_video_base remains the longer one
+                raise ValueError("Failed during video trimming.")
+
 
         # Final check on video_base before setting audio/writing
-        if final_video_base.reader is None or final_video_base.duration is None or final_video_base.duration <= 0:
+        # CORRECTED CHECK: Check existence and duration
+        if final_video_base is None or final_video_base.duration is None or final_video_base.duration <= 0:
              logger.critical("Final video base clip is invalid before audio/writing.")
              raise ValueError("Final video base clip is invalid.")
 
-
         video_base = final_video_base # Use the final adjusted video_base for subsequent steps
 
         # 6. Handle background music
@@ -582,6 +606,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
         final_audio = audio_tts
         
         if musica_file:
+            musica_audio = None # Initialize for finally block
             try:
                 music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
                 shutil.copyfile(musica_file, music_path)
@@ -589,32 +614,47 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 logger.info(f"Background music copied to: {music_path}")
                 
                 musica_audio = AudioFileClip(music_path)
-                logger.debug(f"Original music duration: {musica_audio.duration:.2f}s")
                 
-                musica_audio_looped = loop_audio_to_length(musica_audio, video_base.duration)
-                logger.debug(f"Music adjusted to video duration: {musica_audio_looped.duration:.2f}s")
-
-                try: musica_audio.close()
-                except: pass
-                musica_audio = musica_audio_looped
+                if musica_audio.duration is None or musica_audio.duration <= 0:
+                     logger.warning("Background music clip seems invalid or has zero duration. Skipping music.")
+                     musica_audio = None # Invalidate the clip
 
+                if musica_audio:
+                    musica_audio_looped = loop_audio_to_length(musica_audio, video_base.duration)
+                    logger.debug(f"Music adjusted to video duration: {musica_audio_looped.duration:.2f}s")
 
-                final_audio = CompositeAudioClip([
-                    musica_audio.volumex(0.2),
-                    audio_tts.volumex(1.0)
-                ])
-                logger.info("Audio mix completed (voice + music).")
+                    # Close the original music audio clip
+                    try: musica_audio.close()
+                    except: pass
+                    musica_audio = musica_audio_looped # Assign the looped/trimmed clip
+
+                    final_audio = CompositeAudioClip([
+                        musica_audio.volumex(0.2),
+                        audio_tts.volumex(1.0)
+                    ])
+                    # Verify the resulting composite audio
+                    if final_audio.duration is None or final_audio.duration <= 0:
+                        logger.warning("Composite audio clip is invalid (None or zero duration). Using voice audio only.")
+                        final_audio = audio_tts # Fallback
+                    else:
+                         logger.info("Audio mix completed (voice + music).")
 
             except Exception as e:
                 logger.warning(f"Error processing background music: {str(e)}", exc_info=True)
                 final_audio = audio_tts
                 logger.warning("Using voice audio only due to music processing error.")
+            # No finally here for musica_audio, it's handled in the main finally block
 
-        if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.1: # Check for significant duration mismatch
-            logger.warning(f"Final audio duration ({final_audio.duration:.2f}s) differs from video base ({video_base.duration:.2f}s). This might cause sync issues.")
-            # MoviePy write_videofile often handles slight differences, but large ones can fail or sync poorly.
-            # We could try to adjust audio length here, but loop_audio_to_length should have handled it.
-            # Let's just log the warning for now.
+        # Ensure final_audio duration matches video_base duration if possible (MoviePy is lenient but best to match)
+        if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2: # Allow small floating point differences
+            logger.warning(f"Final audio duration ({final_audio.duration:.2f}s) differs significantly from video base ({video_base.duration:.2f}s). Attempting trim/extend.")
+            try:
+                 if final_audio.duration > video_base.duration:
+                      final_audio = final_audio.subclip(0, video_base.duration)
+                      logger.warning("Trimmed final audio to match video duration.")
+                 # MoviePy often extends audio automatically if it's too short, so we don't explicitly extend here.
+            except Exception as e:
+                 logger.warning(f"Error adjusting final audio duration: {str(e)}")
 
 
         # 7. Create final video
@@ -622,7 +662,8 @@ def crear_video(prompt_type, input_text, musica_file=None):
         video_final = video_base.set_audio(final_audio)
 
         # Final check on the combined video+audio clip
-        if video_final.reader is None or video_final.duration is None or video_final.duration <= 0:
+        # CORRECTED CHECK: Check existence and duration
+        if video_final is None or video_final.duration is None or video_final.duration <= 0:
              logger.critical("Final video clip (with audio) is invalid before writing.")
              raise ValueError("Final video clip is invalid before writing.")
 
@@ -630,6 +671,12 @@ def crear_video(prompt_type, input_text, musica_file=None):
         output_path = os.path.join(temp_dir_intermediate, output_filename)
         logger.info(f"Writing final video to: {output_path}")
 
+        # Check if video_base has a valid size before writing
+        if video_base.size is None or video_base.size[0] <= 0 or video_base.size[1] <= 0:
+             logger.critical(f"Video base has invalid size: {video_base.size}. Cannot write video.")
+             raise ValueError("Video base has invalid size before writing.")
+
+
         video_final.write_videofile(
             output_path,
             fps=24,
@@ -668,13 +715,12 @@ def crear_video(prompt_type, input_text, musica_file=None):
         try:
             if audio_tts is not None: audio_tts.close()
             if musica_audio is not None: musica_audio.close()
-            # The video_base and video_final clips are often intertwined or subclips of each other.
-            # Closing video_final should ideally close everything it's composed of.
-            # Explicitly closing video_base if it's different might help, but be careful not to double close.
+            # Close video_final first, which should cascade to components like video_base
             if video_final is not None:
                 try: video_final.close()
                 except Exception as e: logger.warning(f"Error closing video_final in finally: {str(e)}")
-            elif video_base is not None: # If video_final wasn't created, close video_base
+            # If video_final wasn't created but video_base was (due to error before set_audio), close video_base
+            elif video_base is not None:
                  try: video_base.close()
                  except Exception as e: logger.warning(f"Error closing video_base in finally: {str(e)}")
 
@@ -827,10 +873,23 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
 if __name__ == "__main__":
     logger.info("Verifying critical dependencies...")
     try:
-        from moviepy.editor import VideoFileClip
-        logger.info("MoviePy imported correctly. FFmpeg seems accessible.")
+        # Try importing something that requires FFmpeg/ImageMagick backend
+        from moviepy.editor import ColorClip
+        # Check if basic clip creation works
+        try:
+            temp_clip = ColorClip((100,100), color=(255,0,0), duration=1)
+            temp_clip.close()
+            logger.info("MoviePy base clips (like ColorClip) created successfully. FFmpeg seems accessible.")
+        except Exception as e:
+            logger.critical(f"Failed to create basic MoviePy clip. Often indicates FFmpeg/ImageMagick issues. Error: {e}")
+            # Decide whether to raise or just log
+            # raise RuntimeError(f"MoviePy/FFmpeg dependency issue: {e}") # Uncomment to force exit
+
     except Exception as e:
-         logger.critical(f"Failed to import MoviePy, often indicates FFmpeg issues. Ensure it is installed and in PATH. Error: {e}")
+         logger.critical(f"Failed to import MoviePy. Ensure it is installed. Error: {e}", exc_info=True)
+         # Decide whether to raise or just log
+         # raise RuntimeError(f"MoviePy import failed: {e}") # Uncomment to force exit
+
 
     logger.info("Starting Gradio app...")
     try: