Update app.py

app.py

@@ -34,7 +34,6 @@ 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.")
-    # Uncomment to force fail if not set:
     # raise ValueError("Pexels API key not configured")
 
 # Model Initialization
@@ -55,7 +54,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)
@@ -205,22 +204,18 @@ 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")
     
-    # 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:
-            # Ensure sampling rate is set, default is 44100
-            sr = getattr(audio_clip, 'fps', 44100) if audio_clip else 44100 # Use fps for audio clips
+            sr = getattr(audio_clip, 'fps', 44100) if audio_clip else 44100
             return AudioClip(lambda t: 0, duration=target_duration, sr=sr)
         except Exception as e:
              logger.error(f"Could not create silence clip: {e}", exc_info=True)
-             return AudioFileClip(filename="") # Return empty clip on failure
+             return AudioFileClip(filename="")
 
     if audio_clip.duration >= 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()
@@ -232,19 +227,17 @@ 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
-    final_looped_audio = None # Initialize for return value
+    looped_audio = None
+    final_looped_audio = None
     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.")
@@ -253,18 +246,16 @@ def loop_audio_to_length(audio_clip, target_duration):
 
     except Exception as e:
         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
+             pass
         logger.error("Fallback to original audio clip failed.")
-        return AudioFileClip(filename="") # Return empty clip if fallback fails
+        return AudioFileClip(filename="")
 
     finally:
-        # 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
@@ -332,15 +323,14 @@ 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_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
-    clips_to_concatenate = [] # Segments extracted from source_clips
+    audio_tts_original = None
+    musica_audio_original = None
+    audio_tts = None
+    musica_audio = None
+    video_base = None
+    video_final = None
+    source_clips = []
+    clips_to_concatenate = []
 
     try:
         # 1. Generate or use script
@@ -369,16 +359,14 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
         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
+            audio_tts_original = None
             raise ValueError("Generated voice audio is invalid.")
 
-        audio_tts = audio_tts_original # Use the original valid TTS clip
+        audio_tts = audio_tts_original
         audio_duration = audio_tts.duration
         logger.info(f"Voice audio duration: {audio_duration:.2f} seconds")
 
@@ -386,7 +374,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
              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).")
 
-
         # 3. Extract keywords
         logger.info("Extracting keywords...")
         try:
@@ -428,7 +415,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
                  except Exception as e:
                     logger.warning(f"Error searching generic videos for '{keyword}': {str(e)}")
 
-
         if not videos_data:
             logger.error("No videos found on Pexels for any keyword.")
             raise ValueError("No suitable videos found on Pexels.")
@@ -470,26 +456,23 @@ def crear_video(prompt_type, input_text, musica_file=None):
         logger.info("Processing and concatenating downloaded videos...")
         current_duration = 0
         min_clip_duration = 0.5
-        max_clip_segment = 10.0 # Max segment length from one source clip
+        max_clip_segment = 10.0
 
         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 # Initialize for finally block
+            clip = 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
+                source_clips.append(clip)
 
-                # 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)}] 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)
 
@@ -500,12 +483,10 @@ 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)
-                               # 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
+                                    try: sub.close()
                                     except: pass
                                     continue
                                
@@ -524,7 +505,6 @@ 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
-            # Source clips are closed in the main finally block
 
         logger.info(f"Source clip processing finished. Obtained {len(clips_to_concatenate)} valid segments.")
 
@@ -533,13 +513,11 @@ 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
+        concatenated_base = None
         try:
-            # Concatenate the collected valid segments
             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 (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.")
@@ -548,16 +526,14 @@ def crear_video(prompt_type, input_text, musica_file=None):
              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
+             clips_to_concatenate = []
 
-        video_base = concatenated_base # Assign the valid concatenated clip
+        video_base = concatenated_base
 
-        # --- REVISED REPETITION AND TRIMMING LOGIC ---
-        final_video_base = video_base # Start with the concatenated base
+        final_video_base = video_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...")
@@ -565,12 +541,11 @@ 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 # List contains the *same* clip object repeated
+            repeated_clips_list = [final_video_base] * num_full_repeats
             
             if remaining_duration > 0:
                 try:
                     remaining_clip = final_video_base.subclip(0, remaining_duration)
-                    # 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()
@@ -584,58 +559,45 @@ 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 = None # Hold result temporarily
+                 video_base_repeated = None
                  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
                     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 *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
-                     # 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
         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
+             trimmed_video_base = None
              try:
                 trimmed_video_base = final_video_base.subclip(0, audio_duration)
-                # Verify the trimmed clip is valid
                 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
                 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
 
              except Exception as e:
@@ -643,27 +605,25 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 raise ValueError("Failed during video trimming.")
 
 
-        # Final check on video_base before setting audio/writing
         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 (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
+        video_base = final_video_base
 
         # 6. Handle background music
         logger.info("Processing audio...")
         
-        final_audio = audio_tts # Start with TTS audio
+        final_audio = audio_tts_original # Start with the original valid TTS audio
 
-        musica_audio_looped = None # Initialize for cleanup
+        musica_audio_looped = None
 
         if musica_file:
-            musica_audio_original = None # Initialize for cleanup
+            musica_audio_original = None
             try:
                 music_path = os.path.join(temp_dir_intermediate, "musica_bg.mp3")
                 shutil.copyfile(musica_file, music_path)
@@ -672,101 +632,77 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 
                 musica_audio_original = AudioFileClip(music_path)
                 
-                # 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.")
-                     # Close the invalid clip before skipping
                      try: musica_audio_original.close()
                      except: pass
-                     musica_audio_original = None # Ensure it's None
+                     musica_audio_original = 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")
 
-                     # 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
+                          musica_audio_looped = None
 
 
-                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_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)
+                if musica_audio_looped:
+                    # Use the looped music and the current audio_tts (which is the original)
+                    composite_audio = CompositeAudioClip([
+                        musica_audio_looped.volumex(0.2),
+                        audio_tts_original.volumex(1.0)
                     ])
-                    # Verify the resulting composite audio
-                    if final_audio.duration is None or final_audio.duration <= 0:
+                    
+                    if composite_audio.duration is None or composite_audio.duration <= 0:
                         logger.warning("Composite audio clip is invalid (None or zero duration). Using voice audio only.")
-                        # 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
-
+                        try: composite_audio.close()
+                        except: pass
+                        # Components were likely closed by composite_audio.close() or will be in main finally
+                        final_audio = audio_tts_original # Fallback
                     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
-
+                         final_audio = composite_audio # Use the valid composite audio
+                         musica_audio = musica_audio_looped # Assign for cleanup
 
             except Exception as e:
                 logger.warning(f"Error processing background music: {str(e)}", exc_info=True)
-                # 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
+                musica_audio = None
                 logger.warning("Using voice audio only due to music processing error.")
 
 
-        # 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.")
+            logger.warning(f"Final audio duration ({final_audio.duration:.2f}s) differs significantly from video base ({video_base.duration:.2f}s). Attempting trim.")
             try:
-                 # Need to create a *new* clip if trimming, and handle closing the old one
                  if final_audio.duration > video_base.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
+                           except: pass
                       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
+                           final_audio = trimmed_final_audio
                            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)}")
 
 
         # 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)
 
         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 (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}")
 
-
         video_final.write_videofile(
             output_path,
             fps=24,
@@ -791,51 +727,34 @@ 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 *video* clips
         for clip in source_clips:
             try: clip.close()
             except Exception as e: logger.warning(f"Error closing source video clip in finally: {str(e)}")
             
-        # 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 video segment clip in finally: {str(e)}")
 
-        # Close the main MoviePy objects if they were successfully created
         try:
-            # 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)
+            # Close audio clips: looped music, original music, then final audio (which might close its components)
+            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)}")
+            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 TTS clips: potentially modified/trimmed TTS, then original TTS
+            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)}")
+            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 clips: final video (should cascade), then video base if it wasn't the final
             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)}")
-            # 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)}")
 
-
         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")
              
@@ -856,9 +775,15 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
     
     input_text = prompt_ia if prompt_type == "Generar Guion con IA" else prompt_manual
     
+    # Initialize outputs to None and default status
+    output_video = None
+    output_file = None
+    status_msg = gr.update(value="⏳ Procesando...", interactive=False)
+
     if not input_text or not input_text.strip():
         logger.warning("Empty input text.")
-        return None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.")
+        # Return None for video and file, update status
+        return None, None, gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
 
     logger.info(f"Input Type: {prompt_type}")
     logger.debug(f"Input Text: '{input_text[:100]}...'")
@@ -874,19 +799,26 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video returned path: {video_path}")
             logger.info(f"Size of returned video file: {os.path.getsize(video_path)} bytes")
-            return video_path, gr.update(value="✅ Video generado exitosamente.", interactive=False)
+            output_video = video_path # Set video component value
+            output_file = video_path   # Set file component value for download
+            status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
         else:
             logger.error(f"crear_video did not return a valid path or file does not exist: {video_path}")
-            return None, gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
+            # Leave video and file outputs as None
+            status_msg = gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
 
     except ValueError as ve:
         logger.warning(f"Validation error during video creation: {str(ve)}")
-        return None, gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
+        # Leave video and file outputs as None
+        status_msg = gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
     except Exception as e:
         logger.critical(f"Critical error during video creation: {str(e)}", exc_info=True)
-        return None, gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
+        # Leave video and file outputs as None
+        status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
     finally:
         logger.info("End of run_app handler.")
+        # Return all three outputs
+        return output_video, output_file, status_msg
 
 
 # Gradio Interface
@@ -935,10 +867,16 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         
         with gr.Column():
             video_output = gr.Video(
-                label="Generated Video", 
+                label="Generated Video Preview", # Changed label
                 interactive=False,
                 height=400
             )
+            # Add the File component for download
+            file_output = gr.File(
+                label="Download Video",
+                interactive=False, # Not interactive for user upload
+                visible=False # Hide initially
+            )
             status_output = gr.Textbox(
                 label="Status", 
                 interactive=False,
@@ -954,16 +892,25 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         outputs=[ia_guion_column, manual_guion_column]
     )
 
+    # Modify the click event to return 3 outputs
     generate_btn.click(
-        lambda: (None, gr.update(value="⏳ Processing... This can take 2-5 minutes depending on length and resources.", interactive=False)),
-        outputs=[video_output, status_output],
+        # Action 1: Reset outputs and set status to processing
+        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar 2-5 minutos.", interactive=False)),
+        outputs=[video_output, file_output, status_output],
         queue=True,
     ).then(
+        # Action 2: Call the main processing function
         run_app,
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
-        outputs=[video_output, status_output]
+        outputs=[video_output, file_output, status_output] # Match the 3 outputs
+    ).then(
+        # Action 3: Make the download link visible if a file was returned
+        lambda video_path: gr.update(visible=video_path is not None), # Check if video_output has a value
+        inputs=[video_output], # Use video_output as input to check if generation was successful
+        outputs=[file_output] # Update visibility of file_output
     )
 
+
     gr.Markdown("### Instructions:")
     gr.Markdown("""
     1.  **Pexels API Key:** Ensure you have set the `PEXELS_API_KEY` environment variable.
@@ -973,17 +920,18 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
     3.  **Upload Music** (optional): Select an audio file (MP3, WAV, etc.) for background music.
     4.  **Click "✨ Generate Video"**.
     5.  Wait for the video to process. Processing time may vary. Check the status box.
-    6.  If there are errors, check the `video_generator_full.log` file for details.
+    6.  The generated video will appear above, and a download link will show if successful.
+    7.  If there are errors, check the `video_generator_full.log` file for details.
     """)
     gr.Markdown("---")
-    gr.Markdown("Developed by [Your Name/Company/Alias - Optional]")
+    gr.Markdown("Developed by [Your Name/Company/Alias - Opcional]")
 
 if __name__ == "__main__":
     logger.info("Verifying critical dependencies...")
     try:
         from moviepy.editor import ColorClip
         try:
-            temp_clip = ColorClip((100,100), color=(255,0,0), duration=0.1) # Use a very short duration
+            temp_clip = ColorClip((100,100), color=(255,0,0), duration=0.1)
             temp_clip.close()
             logger.info("MoviePy base clips (like ColorClip) created and closed successfully. FFmpeg seems accessible.")
         except Exception as e: