Update app.py

app.py

@@ -34,8 +34,8 @@ logger.info("="*80)
 PEXELS_API_KEY = os.environ.get("PEXELS_API_KEY")
 if not PEXELS_API_KEY:
     logger.critical("PEXELS_API_KEY environment variable not found.")
-    # logger.warning("Continuing without PEXELS_API_KEY. Video search will fail.")
-    # raise ValueError("Pexels API key not configured") # Uncomment to force fail if not set
+    # Uncomment to force fail if not set:
+    # raise ValueError("Pexels API key not configured")
 
 # Model Initialization
 MODEL_NAME = "datificate/gpt2-small-spanish"
@@ -99,7 +99,7 @@ def buscar_videos_pexels(query, api_key, per_page=5):
     return []
 
 def generate_script(prompt, max_length=150):
-    logger.info(f"Generating script | Prompt: '{prompt[:50]}...' | Max length: {max_length}")
+    logger.info(f"Generando guión | Prompt: '{prompt[:50]}...' | Max length: {max_length}")
     if not tokenizer or not model:
         logger.warning("GPT-2 models not available - Using original prompt as script.")
         return prompt
@@ -137,10 +137,10 @@ def generate_script(prompt, max_length=150):
                  final_text += " " + sentences[1].strip() + "."
                  final_text = final_text.replace("..", ".")
 
-            logger.info(f"Generated script (Truncated): '{final_text[:100]}...'")
+            logger.info(f"Guion generado (Truncado): '{final_text[:100]}...'")
             return final_text.strip()
         
-        logger.info(f"Generated script (no full sentences detected): '{text[:100]}...'")
+        logger.info(f"Guion generado (sin oraciones completas): '{text[:100]}...'")
         return text.strip()
 
     except Exception as e:
@@ -182,12 +182,9 @@ def download_video_file(url, temp_dir):
         
         with requests.get(url, stream=True, timeout=60) as r: 
             r.raise_for_status()
-            # total_size = int(r.headers.get('content-length', 0)) # Uncomment for progress logging
-            # downloaded_size = 0
             with open(output_path, 'wb') as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)
-                    # downloaded_size += len(chunk) # Uncomment for progress logging
 
         if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
              logger.info(f"Video downloaded successfully: {output_path} | Size: {os.path.getsize(output_path)} bytes")
@@ -207,7 +204,7 @@ 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 <= 0:
+    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="")
 
@@ -219,9 +216,16 @@ def loop_audio_to_length(audio_clip, target_duration):
     logger.debug(f"Creating {loops} audio loops")
     
     audio_segments = [audio_clip] * loops
-    looped_audio = concatenate_audioclips(audio_segments)
-    
-    return looped_audio.subclip(0, target_duration)
+    try:
+       looped_audio = concatenate_audioclips(audio_segments)
+       final_looped_audio = looped_audio.subclip(0, target_duration)
+       # Close the temporary concatenated clip
+       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)
+        return audio_clip.subclip(0, min(audio_clip.duration, target_duration))
 
 def extract_visual_keywords_from_script(script_text):
     logger.info("Extracting keywords from script")
@@ -244,7 +248,7 @@ def extract_visual_keywords_from_script(script_text):
             seen_keywords = set()
             for keyword, score in all_keywords:
                 formatted_keyword = keyword.lower().replace(" ", "+")
-                if formatted_keyword and formatted_keyword not in seen_keywords: # Ensure keyword is not empty
+                if formatted_keyword and formatted_keyword not in seen_keywords:
                     keywords_list.append(formatted_keyword)
                     seen_keywords.add(formatted_keyword)
                 if len(keywords_list) >= 5:
@@ -285,6 +289,11 @@ def crear_video(prompt_type, input_text, musica_file=None):
     start_time = datetime.now()
     temp_dir_intermediate = None
     
+    audio_tts = None
+    musica_audio = None
+    video_base = None
+    video_final = None
+
     try:
         # 1. Generate or use script
         if prompt_type == "Generar Guion con IA":
@@ -314,8 +323,10 @@ 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:
-             logger.warning(f"Voice audio duration ({audio_duration:.2f}s) is very short.")
+        if audio_duration < 0.5:
+             logger.error(f"Voice audio duration ({audio_duration:.2f}s) is too short.")
+             raise ValueError("Generated voice audio is too short.")
+
 
         # 3. Extract keywords
         logger.info("Extracting keywords...")
@@ -400,8 +411,8 @@ def crear_video(prompt_type, input_text, musica_file=None):
         logger.info("Processing and concatenating downloaded videos...")
         clips = []
         current_duration = 0
-        min_clip_duration = 1.0
-        max_clip_segment = 8.0
+        min_clip_duration = 0.5
+        max_clip_segment = 10.0
 
         for i, path in enumerate(video_paths):
             if current_duration >= audio_duration + max_clip_segment:
@@ -413,12 +424,10 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 logger.debug(f"[{i+1}/{len(video_paths)}] Opening clip: {path}")
                 clip = VideoFileClip(path)
 
-                # Check clip validity after opening
                 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.")
                     continue
 
-                # Calculate how much to take from this clip
                 remaining_needed = audio_duration - current_duration
                 potential_use_duration = min(clip.duration, max_clip_segment)
 
@@ -433,6 +442,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
                                clips.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
@@ -461,24 +471,53 @@ def crear_video(prompt_type, input_text, musica_file=None):
             raise ValueError("No valid video clips available to create the video.")
         
         logger.info(f"Concatenating {len(clips)} video clips.")
-        video_base = concatenate_videoclips(clips, method="compose")
-        logger.info(f"Base video duration: {video_base.duration:.2f}s")
+        # 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:
-            num_repeats = math.ceil(audio_duration / video_base.duration)
-            logger.info(f"Repeating base video ({video_base.duration:.2f}s) {num_repeats} times to reach {audio_duration:.2f}s.")
-            repeated_clips = [video_base] * num_repeats
-            video_base = concatenate_videoclips(repeated_clips, method="compose").subclip(0, audio_duration)
-            logger.info(f"Adjusted base video duration: {video_base.duration:.2f}s")
+            logger.info(f"Base video ({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
+            
+            repeated_clips_list = [video_base] * num_full_repeats
+            
+            if remaining_duration > 0:
+                try:
+                    remaining_clip = 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:
+                     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 = 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
+                 
+            else:
+                 logger.error("Failed to create repeated video clips list.")
+                 pass
 
         if video_base.duration > audio_duration:
-             logger.info(f"Trimming base video ({video_base.duration:.2f}s) to match audio duration ({audio_duration:.2f}s).")
-             video_base = video_base.subclip(0, 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")
 
 
         # 6. Handle background music
         logger.info("Processing audio...")
+        
         final_audio = audio_tts
         
         if musica_file:
@@ -491,21 +530,29 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 musica_audio = AudioFileClip(music_path)
                 logger.debug(f"Original music duration: {musica_audio.duration:.2f}s")
                 
-                musica_audio = loop_audio_to_length(musica_audio, video_base.duration)
-                logger.debug(f"Music adjusted to video 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
+
+
                 final_audio = CompositeAudioClip([
                     musica_audio.volumex(0.2),
                     audio_tts.volumex(1.0)
                 ])
                 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.")
 
-        if final_audio.duration > video_base.duration:
+        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).")
 
 
         # 7. Create final video
@@ -523,22 +570,12 @@ def crear_video(prompt_type, input_text, musica_file=None):
             codec="libx264",
             audio_codec="aac",
             preset="medium",
-            logger='bar' # Show MoviePy progress bar
+            logger='bar'
         )
         
         total_time = (datetime.now() - start_time).total_seconds()
         logger.info(f"VIDEO PROCESS FINISHED | Output: {output_path} | Total time: {total_time:.2f}s")
         
-        # Close main clips
-        try:
-            video_base.close()
-            audio_tts.close()
-            if 'musica_audio' in locals() and musica_audio is not None: musica_audio.close()
-            video_final.close()
-        except Exception as e:
-            logger.warning(f"Error closing final clips: {str(e)}")
-
-
         return output_path
         
     except ValueError as ve:
@@ -549,6 +586,22 @@ def crear_video(prompt_type, input_text, musica_file=None):
         raise e
     finally:
         logger.info("Starting cleanup of intermediate temporary files...")
+        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 video_final is not None:
+                try: video_final.close()
+                except: pass
+        except Exception as e:
+            logger.warning(f"Error during final clip closing in finally: {str(e)}")
+
         if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
              final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")
              
@@ -560,8 +613,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  except Exception as e:
                      logger.warning(f"Could not delete temporary file {path}: {str(e)}")
             
-             # IMPORTANT: DO NOT remove the temp_dir_intermediate itself.
-             # It contains the final video file needed by Gradio.
              logger.info(f"Intermediate temporary directory {temp_dir_intermediate} will persist for Gradio to read the final video.")