Update app.py

app.py

@@ -9,7 +9,7 @@ import gradio as gr
 import torch
 from transformers import GPT2Tokenizer, GPT2LMHeadModel
 from keybert import KeyBERT
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, concatenate_audioclips, AudioClip
 import re
 import math
 import shutil
@@ -55,7 +55,7 @@ except Exception as e:
 logger.info("Loading KeyBERT model...")
 kw_model = None
 try:
-    kw_model = KeyBERT('distilbert-base-multilingual-cased')
+    kw_model = KeyBert('distilbert-base-multilingual-cased')
     logger.info("KeyBERT initialized successfully")
 except Exception as e:
     logger.error(f"FAILURE loading KeyBERT: {str(e)}", exc_info=True)
@@ -204,36 +204,68 @@ def download_video_file(url, temp_dir):
 
 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 a small silent clip or similar if duration is invalid
+    
+    # Handle cases where the input audio clip is invalid
+    if audio_clip is None or audio_clip.duration is None or audio_clip.duration <= 0:
+        logger.warning("Input audio clip is invalid (None or zero duration), cannot loop.")
+        # Return a silent clip of target duration as fallback
         try:
-            from moviepy.editor import AudioClip
-            return AudioClip(lambda t: 0, duration=target_duration, sr=44100)
+            # Ensure sampling rate is set, default is 44100
+            sr = getattr(audio_clip, 'fps', 44100) if audio_clip else 44100 # Use fps for audio clips
+            return AudioClip(lambda t: 0, duration=target_duration, sr=sr)
         except Exception as e:
-             logger.error(f"Could not create silence clip: {e}")
-             return AudioFileClip(filename="")
+             logger.error(f"Could not create silence clip: {e}", exc_info=True)
+             return AudioFileClip(filename="") # Return empty clip on failure
 
     if audio_clip.duration >= target_duration:
-        logger.debug("Audio clip already longer or equal to target.")
-        return audio_clip.subclip(0, target_duration)
+        logger.debug("Audio clip already longer or equal to target. Trimming.")
+        trimmed_clip = audio_clip.subclip(0, target_duration)
+        # Check trimmed clip validity (should be ok, but good practice)
+        if trimmed_clip.duration is None or trimmed_clip.duration <= 0:
+             logger.error("Trimmed audio clip is invalid.")
+             try: trimmed_clip.close()
+             except: pass
+             return AudioFileClip(filename="")
+        return trimmed_clip
     
     loops = math.ceil(target_duration / audio_clip.duration)
     logger.debug(f"Creating {loops} audio loops")
     
     audio_segments = [audio_clip] * loops
     looped_audio = None # Initialize for finally block
+    final_looped_audio = None # Initialize for return value
     try:
        looped_audio = concatenate_audioclips(audio_segments)
+       
+       # Verify the concatenated audio clip is valid
+       if looped_audio.duration is None or looped_audio.duration <= 0:
+            logger.error("Concatenated audio clip is invalid (None or zero duration).")
+            raise ValueError("Invalid concatenated audio.")
+
        final_looped_audio = looped_audio.subclip(0, target_duration)
+
+       # Verify the final subclipped audio clip is valid
+       if final_looped_audio.duration is None or final_looped_audio.duration <= 0:
+            logger.error("Final subclipped audio clip is invalid (None or zero duration).")
+            raise ValueError("Invalid final subclipped audio.")
+
        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))
+        logger.error(f"Error concatenating/subclipping audio clips for looping: {str(e)}", exc_info=True)
+        # Fallback: try returning the original clip trimmed if possible
+        try:
+             if audio_clip.duration is not None and audio_clip.duration > 0:
+                  logger.warning("Returning original audio clip (may be too short).")
+                  return audio_clip.subclip(0, min(audio_clip.duration, target_duration))
+        except:
+             pass # Ignore errors during fallback
+        logger.error("Fallback to original audio clip failed.")
+        return AudioFileClip(filename="") # Return empty clip if fallback fails
+
     finally:
-        # Clean up the temporary concatenated clip
-        if looped_audio is not None:
+        # Clean up the temporary concatenated clip if it was created but not returned
+        if looped_audio is not None and looped_audio is not final_looped_audio:
             try: looped_audio.close()
             except: pass
 
@@ -301,8 +333,10 @@ def crear_video(prompt_type, input_text, musica_file=None):
     temp_dir_intermediate = None
     
     # Initialize clips and audio objects to None for cleanup in finally
-    audio_tts = None
-    musica_audio = None
+    audio_tts_original = None # Keep original TTS clip for cleanup
+    musica_audio_original = None # Keep original music clip for cleanup
+    audio_tts = None # This will be the potentially modified/validated TTS clip
+    musica_audio = None # This will be the potentially modified/validated music clip
     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
@@ -333,7 +367,18 @@ def crear_video(prompt_type, input_text, musica_file=None):
             raise ValueError("Error generating voice audio.")
         temp_intermediate_files.append(voz_path)
 
-        audio_tts = AudioFileClip(voz_path)
+        audio_tts_original = AudioFileClip(voz_path)
+        
+        # Verify initial TTS audio clip
+        if audio_tts_original.reader is None or audio_tts_original.duration is None or audio_tts_original.duration <= 0:
+            logger.critical("Initial TTS audio clip is invalid (reader is None or duration <= 0).")
+            # Try to close the invalid clip before raising
+            try: audio_tts_original.close()
+            except: pass
+            audio_tts_original = None # Ensure it's None
+            raise ValueError("Generated voice audio is invalid.")
+
+        audio_tts = audio_tts_original # Use the original valid TTS clip
         audio_duration = audio_tts.duration
         logger.info(f"Voice audio duration: {audio_duration:.2f} seconds")
 
@@ -494,8 +539,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             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
-            # CORRECTED CHECK for CompositeVideoClip: Check existence and duration
+            # Verify the resulting concatenated clip is valid (CompositeVideoClip)
             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.")
@@ -521,7 +565,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             num_full_repeats = int(audio_duration // final_video_base.duration)
             remaining_duration = audio_duration % final_video_base.duration
             
-            repeated_clips_list = [final_video_base] * num_full_repeats
+            repeated_clips_list = [final_video_base] * num_full_repeats # List contains the *same* clip object repeated
             
             if remaining_duration > 0:
                 try:
@@ -543,30 +587,36 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  video_base_repeated = None # Hold result temporarily
                  try:
                     # Concatenate the repeated parts
+                    # If repeated_clips_list contains duplicates of the same object, this is fine for concatenate_videoclips
                     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
-                    # 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.")
 
-                    # Close the old base clip
-                    try: final_video_base.close()
-                    except: pass
+                    # Close the old base clip *only if it's different from the new one*
+                    if final_video_base is not video_base_repeated:
+                        try: final_video_base.close()
+                        except: pass
+                    
                     # Assign the new valid repeated clip
                     final_video_base = video_base_repeated
 
                  except Exception as e:
                     logger.critical(f"Error during repetition concatenation: {str(e)}", exc_info=True)
+                    # If repetition fails, the error is raised. The original final_video_base will be closed in main finally.
                     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
+                     # This needs care as list items might be the same object
+                     if 'repeated_clips_list' in locals():
+                         for clip in repeated_clips_list:
+                              # Only close if it's not the final clip and not already closed (MoviePy tracks this)
+                              if clip is not final_video_base:
+                                   try: clip.close()
+                                   except: pass
 
 
         # After repetition (or if no repetition happened), ensure duration matches audio exactly
@@ -576,14 +626,15 @@ def crear_video(prompt_type, input_text, musica_file=None):
              try:
                 trimmed_video_base = final_video_base.subclip(0, audio_duration)
                 # Verify the trimmed clip is valid
-                # 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.")
 
                 # Close the old clip
-                try: final_video_base.close()
-                except: pass
+                if final_video_base is not trimmed_video_base:
+                     try: final_video_base.close()
+                     except: pass
+
                 # Assign the new valid trimmed clip
                 final_video_base = trimmed_video_base
 
@@ -593,89 +644,128 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
 
         # Final check on video_base before setting audio/writing
-        # 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.")
+             logger.critical("Final video base clip is invalid before audio/writing (None or zero duration).")
              raise ValueError("Final video base clip is invalid.")
 
+        # Also check size, as MoviePy needs it for writing
+        if final_video_base.size is None or final_video_base.size[0] <= 0 or final_video_base.size[1] <= 0:
+             logger.critical(f"Final video base has invalid size: {final_video_base.size}. Cannot write video.")
+             raise ValueError("Final video base has invalid size before writing.")
+
         video_base = final_video_base # Use the final adjusted video_base for subsequent steps
 
         # 6. Handle background music
         logger.info("Processing audio...")
         
-        final_audio = audio_tts
-        
+        final_audio = audio_tts # Start with TTS audio
+
+        musica_audio_looped = None # Initialize for cleanup
+
         if musica_file:
-            musica_audio = None # Initialize for finally block
+            musica_audio_original = None # Initialize for cleanup
             try:
                 music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
                 shutil.copyfile(musica_file, music_path)
                 temp_intermediate_files.append(music_path)
                 logger.info(f"Background music copied to: {music_path}")
                 
-                musica_audio = AudioFileClip(music_path)
+                musica_audio_original = AudioFileClip(music_path)
                 
-                if musica_audio.duration is None or musica_audio.duration <= 0:
+                # Verify initial music audio clip
+                if musica_audio_original.reader is None or musica_audio_original.duration is None or musica_audio_original.duration <= 0:
                      logger.warning("Background music clip seems invalid or has zero duration. Skipping music.")
-                     musica_audio = None # Invalidate the clip
+                     # Close the invalid clip before skipping
+                     try: musica_audio_original.close()
+                     except: pass
+                     musica_audio_original = None # Ensure it's None
+                else:
+                     musica_audio_looped = loop_audio_to_length(musica_audio_original, video_base.duration)
+                     logger.debug(f"Music adjusted to video duration: {musica_audio_looped.duration:.2f}s")
 
-                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")
+                     # Verify the looped music clip is valid
+                     if musica_audio_looped is None or musica_audio_looped.duration is None or musica_audio_looped.duration <= 0:
+                          logger.warning("Looped background music clip is invalid. Skipping music.")
+                          # Close the invalid looped clip
+                          try: musica_audio_looped.close()
+                          except: pass
+                          musica_audio_looped = None # Ensure it's None
 
-                    # Close the original music audio clip
-                    try: musica_audio.close()
-                    except: pass
-                    musica_audio = musica_audio_looped # Assign the looped/trimmed clip
 
+                if musica_audio_looped: # Only proceed if looped music is valid
+                    # CompositeAudioClip uses the *current* audio_tts and musica_audio_looped clips
                     final_audio = CompositeAudioClip([
-                        musica_audio.volumex(0.2),
-                        audio_tts.volumex(1.0)
+                        musica_audio_looped.volumex(0.2), # Apply effect to the looped clip
+                        audio_tts.volumex(1.0)     # Apply effect to the TTS clip (safer than assuming no effects needed)
                     ])
                     # 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
+                        # If CompositeAudioClip fails, need to close its components if they are not the originals
+                        try:
+                             if musica_audio_looped is not musica_audio_original: musica_audio_looped.close()
+                             if audio_tts is not audio_tts_original: audio_tts.close()
+                             # Close the invalid composite audio
+                             try: final_audio.close()
+                             except: pass
+                        except: pass # Ignore errors during cleanup
+                        final_audio = audio_tts_original # Fallback to the original valid TTS
+                        musica_audio = None # Ensure musica_audio variable is None
+                        audio_tts = audio_tts_original # Ensure audio_tts variable points to the original valid TTS
+
                     else:
                          logger.info("Audio mix completed (voice + music).")
+                         # composite audio is valid, set musica_audio variable for later cleanup
+                         musica_audio = musica_audio_looped
+                         # audio_tts variable already points to original which is handled in main finally
+
 
             except Exception as e:
                 logger.warning(f"Error processing background music: {str(e)}", exc_info=True)
-                final_audio = audio_tts
+                # Fallback to just TTS audio
+                final_audio = audio_tts_original
+                musica_audio = None # Ensure variable is None
+                audio_tts = audio_tts_original # Ensure variable is original
                 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
 
-        # 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
+
+        # Ensure final_audio duration matches video_base duration if possible
+        # Check for significant duration mismatch allowing small floating point differences
+        if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2:
             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:
+                 # Need to create a *new* clip if trimming, and handle closing the old one
                  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.")
+                      trimmed_final_audio = final_audio.subclip(0, video_base.duration)
+                      if trimmed_final_audio.duration is None or trimmed_final_audio.duration <= 0:
+                           logger.warning("Trimmed final audio is invalid. Using original final_audio.")
+                           try: trimmed_final_audio.close()
+                           except: pass # Close the invalid trimmed clip
+                      else:
+                           # Safely close the old final_audio if it's different
+                           if final_audio is not trimmed_final_audio:
+                               try: final_audio.close()
+                               except: pass
+                           final_audio = trimmed_final_audio # Use the valid trimmed clip
+                           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
-        logger.info("Rendering final video...")
+        # Final check on video_final before writing
+        # video_final is a composite of video_base and final_audio
         video_final = video_base.set_audio(final_audio)
 
-        # Final check on the combined video+audio clip
-        # 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.")
+             logger.critical("Final video clip (with audio) is invalid before writing (None or zero duration).")
              raise ValueError("Final video clip is invalid before writing.")
 
+
         output_filename = "final_video.mp4"
         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,
@@ -701,21 +791,38 @@ def crear_video(prompt_type, input_text, musica_file=None):
     finally:
         logger.info("Starting cleanup of clips and intermediate temporary files...")
         
-        # Close all initially opened source clips
+        # Close all initially opened source *video* clips
         for clip in source_clips:
             try: clip.close()
-            except Exception as e: logger.warning(f"Error closing source clip in finally: {str(e)}")
+            except Exception as e: logger.warning(f"Error closing source video clip in finally: {str(e)}")
             
-        # Close any segments left in the list (should be empty if successful)
+        # Close any video segments left in the list (should be empty if successful)
         for clip_segment in clips_to_concatenate:
              try: clip_segment.close()
-             except Exception as e: logger.warning(f"Error closing segment clip in finally: {str(e)}")
+             except Exception as e: logger.warning(f"Error closing video segment clip in finally: {str(e)}")
 
         # Close the main MoviePy objects if they were successfully created
         try:
-            if audio_tts is not None: audio_tts.close()
-            if musica_audio is not None: musica_audio.close()
-            # Close video_final first, which should cascade to components like video_base
+            # Close the audio clips
+            # Start with the potentially looped/trimmed music clip if it exists
+            if musica_audio is not None:
+                 try: musica_audio.close()
+                 except Exception as e: logger.warning(f"Error closing musica_audio in finally: {str(e)}")
+            # Then close the original music audio clip if it exists and is different
+            if musica_audio_original is not None and musica_audio_original is not musica_audio:
+                 try: musica_audio_original.close()
+                 except Exception as e: logger.warning(f"Error closing musica_audio_original in finally: {str(e)}")
+
+            # Close the potentially modified/trimmed TTS clip if it exists and is different from original
+            if audio_tts is not None and audio_tts is not audio_tts_original:
+                 try: audio_tts.close()
+                 except Exception as e: logger.warning(f"Error closing audio_tts (modified) in finally: {str(e)}")
+            # Close the original TTS clip if it exists (it's the base)
+            if audio_tts_original is not None:
+                 try: audio_tts_original.close()
+                 except Exception as e: logger.warning(f"Error closing audio_tts_original in finally: {str(e)}")
+
+            # Close video_final first, which should cascade to video_base and final_audio (and their components)
             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)}")
@@ -724,6 +831,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  try: video_base.close()
                  except Exception as e: logger.warning(f"Error closing video_base in finally: {str(e)}")
 
+
         except Exception as e:
             logger.warning(f"Error during final clip closing in finally: {str(e)}")
 
@@ -873,23 +981,16 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
 if __name__ == "__main__":
     logger.info("Verifying critical dependencies...")
     try:
-        # 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 = ColorClip((100,100), color=(255,0,0), duration=0.1) # Use a very short duration
             temp_clip.close()
-            logger.info("MoviePy base clips (like ColorClip) created successfully. FFmpeg seems accessible.")
+            logger.info("MoviePy base clips (like ColorClip) created and closed 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
+            logger.critical(f"Failed to create basic MoviePy clip. Often indicates FFmpeg/ImageMagick issues. Error: {e}", exc_info=True)
 
     except Exception as 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: