Update app.py

app.py

@@ -219,12 +219,13 @@ def loop_audio_to_length(audio_clip, target_duration):
     try:
        looped_audio = concatenate_audioclips(audio_segments)
        final_looped_audio = looped_audio.subclip(0, target_duration)
-       # Close the temporary concatenated clip
+       # 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))
 
 def extract_visual_keywords_from_script(script_text):
@@ -289,10 +290,12 @@ def crear_video(prompt_type, input_text, musica_file=None):
     start_time = datetime.now()
     temp_dir_intermediate = 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
 
     try:
         # 1. Generate or use script
@@ -323,9 +326,9 @@ 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 < 0.5:
+        if audio_duration < 1.0: # Require at least 1 second of audio
              logger.error(f"Voice audio duration ({audio_duration:.2f}s) is too short.")
-             raise ValueError("Generated voice audio is too short.")
+             raise ValueError("Generated voice audio is too short (min 1 second required).")
 
 
         # 3. Extract keywords
@@ -365,6 +368,7 @@ 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)}")
@@ -409,7 +413,8 @@ def crear_video(prompt_type, input_text, musica_file=None):
         
         # 5. Process and concatenate video clips
         logger.info("Processing and concatenating downloaded videos...")
-        clips = []
+        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
@@ -423,6 +428,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
             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
 
                 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.")
@@ -438,11 +444,19 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
                      if segment_duration >= min_clip_duration:
                           try:
+                               # Create a subclip. This creates a *new* clip object.
                                sub = clip.subclip(0, segment_duration)
-                               clips.append(sub)
+                               # Verify the subclip is valid
+                               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
+                                    except: pass
+                                    continue
+                               
+                               clips_to_concatenate.append(sub)
                                current_duration += sub.duration 
                                logger.debug(f"[{i+1}/{len(video_paths)}] Segment added: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
-                               # sub.close() # Decided against closing subclips explicitly here
+                               
                           except Exception as sub_e:
                                logger.warning(f"[{i+1}/{len(video_paths)}] Error creating subclip from {path} ({segment_duration:.1f}s): {str(sub_e)}")
                                continue
@@ -454,39 +468,51 @@ 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.
 
-            finally:
-                if clip is not None:
-                    try:
-                        clip.close()
-                        logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} closed.")
-                    except Exception as close_e:
-                        logger.warning(f"[{i+1}/{len(video_paths)}] Error closing clip {path}: {str(close_e)}")
+        logger.info(f"Source clip processing finished. Obtained {len(clips_to_concatenate)} valid segments.")
 
+        if not clips_to_concatenate:
+            logger.error("No valid video segments available to create the sequence.")
+            raise ValueError("No valid video segments available to create the video.")
+        
+        logger.info(f"Concatenating {len(clips_to_concatenate)} video segments.")
+        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")
 
-        logger.info(f"Source clip processing finished. Obtained {len(clips)} valid clips.")
+            # 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
 
-        if not clips:
-            logger.error("No valid video clips available to create the sequence.")
-            raise ValueError("No valid video clips available to create the video.")
-        
-        logger.info(f"Concatenating {len(clips)} video clips.")
-        # Use the default "chain" method for simple concatenation
-        video_base = concatenate_videoclips(clips) # Removed method="compose"
-        logger.info(f"Base video duration after initial concatenation: {video_base.duration:.2f}s")
-        
-        # --- REVISED REPETITION LOGIC ---
-        if video_base.duration < audio_duration:
-            logger.info(f"Base video ({video_base.duration:.2f}s) is shorter than audio ({audio_duration:.2f}s). Repeating...")
+            # 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.")
+                 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.")
+
+
+        # --- REVISED REPETITION AND TRIMMING LOGIC ---
+        final_video_base = video_base # Start with the concatenated base
+
+        if final_video_base.duration < audio_duration:
+            logger.info(f"Base video ({final_video_base.duration:.2f}s) is shorter than audio ({audio_duration:.2f}s). Repeating...")
             
-            num_full_repeats = int(audio_duration // video_base.duration)
-            remaining_duration = audio_duration % video_base.duration
+            num_full_repeats = int(audio_duration // final_video_base.duration)
+            remaining_duration = audio_duration % final_video_base.duration
             
-            repeated_clips_list = [video_base] * num_full_repeats
+            repeated_clips_list = [final_video_base] * num_full_repeats
             
             if remaining_duration > 0:
                 try:
-                    remaining_clip = video_base.subclip(0, remaining_duration)
+                    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")
                 except Exception as e:
@@ -494,27 +520,62 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
             if repeated_clips_list:
                  logger.info(f"Concatenating {len(repeated_clips_list)} parts for repetition.")
-                 video_base_repeated = concatenate_videoclips(repeated_clips_list)
-                 logger.info(f"Duration of repeated video base: {video_base_repeated.duration:.2f}s")
-                 
-                 try: video_base.close()
-                 except: pass
-                 
-                 video_base = video_base_repeated
-                 
+                 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:
+                         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
+                    # 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, 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
+
             else:
                  logger.error("Failed to create repeated video clips list.")
-                 pass
+                 # 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).")
+             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:
+                     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
+                # Assign the new valid trimmed clip
+                final_video_base = trimmed_video_base
+
+             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
 
-        if video_base.duration > audio_duration:
-             logger.info(f"Trimming video base ({video_base.duration:.2f}s) to match audio duration ({audio_duration:.2f}s).")
-             trimmed_video_base = video_base.subclip(0, audio_duration)
-             try: video_base.close()
-             except: pass
-             video_base = trimmed_video_base
-             logger.info(f"Final base video duration: {video_base.duration:.2f}s")
+        # 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:
+             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
         logger.info("Processing audio...")
         
@@ -549,16 +610,22 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 final_audio = audio_tts
                 logger.warning("Using voice audio only due to music processing error.")
 
-        if final_audio.duration is not None and final_audio.duration > video_base.duration:
-             final_audio = final_audio.subclip(0, video_base.duration)
-        elif final_audio.duration is not None and final_audio.duration < video_base.duration:
-            logger.warning(f"Final audio duration ({final_audio.duration:.2f}s) is less than video base ({video_base.duration:.2f}s).")
+        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.
 
 
         # 7. Create final video
         logger.info("Rendering final video...")
         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:
+             logger.critical("Final video clip (with audio) is invalid before writing.")
+             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}")
@@ -585,23 +652,36 @@ def crear_video(prompt_type, input_text, musica_file=None):
         logger.critical(f"CRITICAL UNHANDLED ERROR in crear_video: {str(e)}", exc_info=True)
         raise e
     finally:
-        logger.info("Starting cleanup of intermediate temporary files...")
+        logger.info("Starting cleanup of clips and intermediate temporary files...")
+        
+        # Close all initially opened source clips
+        for clip in source_clips:
+            try: clip.close()
+            except Exception as e: logger.warning(f"Error closing source clip in finally: {str(e)}")
+            
+        # Close any 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)}")
+
+        # Close the main MoviePy objects if they were successfully created
         try:
-            if audio_tts is not None:
-                try: audio_tts.close()
-                except: pass
-            if musica_audio is not None:
-                 try: musica_audio.close()
-                 except: pass
-            if video_base is not None:
-                try: video_base.close()
-                except: pass
+            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.
             if video_final is not None:
                 try: video_final.close()
-                except: pass
+                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
+                 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)}")
 
+        # Clean up intermediate files, but NOT the final video file
         if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
              final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")