Update app.py

app.py

@@ -14,9 +14,11 @@ import math
 import shutil
 import json
 from collections import Counter
+import threading
+import time
 
 # Variable global para TTS
-tts_model = None  
+tts_model = None
 
 # Configuración de logging
 logging.basicConfig(
@@ -61,6 +63,19 @@ except Exception as e:
     logger.error(f"FALLA al cargar KeyBERT: {str(e)}", exc_info=True)
     kw_model = None
 
+def schedule_deletion(directory_path, delay_seconds):
+    """Programa la eliminación de un directorio después de un cierto tiempo."""
+    logger.info(f"PROGRAMADA eliminación del directorio '{directory_path}' en {delay_seconds / 3600:.1f} horas.")
+    time.sleep(delay_seconds)
+    try:
+        if os.path.isdir(directory_path):
+            shutil.rmtree(directory_path)
+            logger.info(f"Directorio temporal '{directory_path}' eliminado exitosamente.")
+        else:
+            logger.warning(f"No se pudo eliminar: '{directory_path}' no es un directorio válido o ya fue eliminado.")
+    except Exception as e:
+        logger.error(f"Error durante la eliminación programada de '{directory_path}': {str(e)}")
+
 def buscar_videos_pexels(query, api_key, per_page=5):
     if not api_key:
         logger.warning("No se puede buscar en Pexels: API Key no configurada.")
@@ -182,20 +197,16 @@ def text_to_speech(text, output_path, voice=None):
         return False
     
     try:
-        # Usar modelo específico para español, sin GPU
         tts = TTS(model_name="tts_models/es/css10/vits", progress_bar=False, gpu=False)
         
-        # Limpiar y truncar texto
         text = text.replace("na hora", "A la hora")
         text = re.sub(r'[^\w\s.,!?áéíóúñÁÉÍÓÚÑ]', '', text)
         if len(text) > 500:
             logger.warning("Texto demasiado largo, truncando a 500 caracteres")
             text = text[:500]
         
-        # Generar audio sin especificar idioma
         tts.tts_to_file(text=text, file_path=output_path)
         
-        # Verificar archivo generado
         if os.path.exists(output_path) and os.path.getsize(output_path) > 1000:
             logger.info(f"Audio creado: {output_path} | Tamaño: {os.path.getsize(output_path)} bytes")
             return True
@@ -362,6 +373,7 @@ def crear_video(prompt_type, input_text, musica_file=None):
 
     start_time = datetime.now()
     temp_dir_intermediate = None
+    TARGET_RESOLUTION = (1280, 720) # *** MODIFICACIÓN: Resolución 720p ***
 
     audio_tts_original = None
     musica_audio_original = None
@@ -384,8 +396,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
         if not guion.strip():
             logger.error("El guion resultante está vacío o solo contiene espacios.")
             raise ValueError("El guion está vacío.")
-
-        # Corregir error tipográfico en el guion
         guion = guion.replace("na hora", "A la hora")
 
         temp_dir_intermediate = tempfile.mkdtemp(prefix="video_gen_intermediate_")
@@ -395,25 +405,22 @@ def crear_video(prompt_type, input_text, musica_file=None):
         # 2. Generar audio de voz
         logger.info("Generando audio de voz...")
         voz_path = os.path.join(temp_dir_intermediate, "voz.mp3")
-
-        # Llamar a text_to_speech directamente
         tts_success = text_to_speech(guion, voz_path)
 
         if not tts_success or not os.path.exists(voz_path) or os.path.getsize(voz_path) <= 1000:
             logger.error(f"Fallo en la generación de voz. Archivo de audio no creado o es muy pequeño: {voz_path}")
             raise ValueError("Error generando voz a partir del guion (fallo de TTS).")
-
         temp_intermediate_files.append(voz_path)
 
         audio_tts_original = AudioFileClip(voz_path)
 
         if audio_tts_original.reader is None or audio_tts_original.duration is None or audio_tts_original.duration <= 0:
-            logger.critical("Clip de audio TTS inicial es inválido (reader is None o duración <= 0) *después* de crear AudioFileClip.")
+            logger.critical("Clip de audio TTS inicial es inválido (reader is None o duración <= 0).")
             try: audio_tts_original.close()
             except: pass
             audio_tts_original = None
             raise ValueError("Audio de voz generado es inválido después de procesamiento inicial.")
-
+        
         audio_tts = audio_tts_original
         audio_duration = audio_tts_original.duration
         logger.info(f"Duración audio voz: {audio_duration:.2f} segundos")
@@ -430,7 +437,6 @@ def crear_video(prompt_type, input_text, musica_file=None):
         except Exception as e:
             logger.error(f"Error extrayendo keywords: {str(e)}", exc_info=True)
             keywords = ["naturaleza", "paisaje"]
-
         if not keywords:
              keywords = ["video", "background"]
 
@@ -446,20 +452,17 @@ def crear_video(prompt_type, input_text, musica_file=None):
                 videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=per_page_per_keyword)
                 if videos:
                     videos_data.extend(videos)
-                    logger.info(f"Encontrados {len(videos)} videos para '{keyword}'. Total data: {len(videos_data)}")
             except Exception as e:
                 logger.warning(f"Error buscando videos para '{keyword}': {str(e)}")
 
         if len(videos_data) < total_desired_videos / 2:
             logger.warning(f"Pocos videos encontrados ({len(videos_data)}). Intentando con palabras clave genéricas.")
-            generic_keywords = ["nature", "city", "background", "abstract"]
-            for keyword in generic_keywords:
+            for keyword in ["nature", "city", "background", "abstract"]:
                  if len(videos_data) >= total_desired_videos: break
                  try:
                     videos = buscar_videos_pexels(keyword, PEXELS_API_KEY, per_page=2)
                     if videos:
                         videos_data.extend(videos)
-                        logger.info(f"Encontrados {len(videos)} videos para '{keyword}' (genérico). Total data: {len(videos_data)}")
                  except Exception as e:
                     logger.warning(f"Error buscando videos genéricos para '{keyword}': {str(e)}")
 
@@ -470,28 +473,14 @@ def crear_video(prompt_type, input_text, musica_file=None):
         video_paths = []
         logger.info(f"Intentando descargar {len(videos_data)} videos encontrados...")
         for video in videos_data:
-            if 'video_files' not in video or not video['video_files']:
-                logger.debug(f"Saltando video sin archivos de video: {video.get('id')}")
-                continue
-
+            if 'video_files' not in video or not video['video_files']: continue
             try:
-                best_quality = None
-                for vf in sorted(video['video_files'], key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True):
-                    if 'link' in vf:
-                        best_quality = vf
-                        break
-
-                if best_quality and 'link' in best_quality:
+                best_quality = next((vf for vf in sorted(video['video_files'], key=lambda x: x.get('width', 0), reverse=True) if 'link' in vf), None)
+                if best_quality:
                     path = download_video_file(best_quality['link'], temp_dir_intermediate)
                     if path:
                         video_paths.append(path)
                         temp_intermediate_files.append(path)
-                        logger.info(f"Video descargado OK desde {best_quality['link'][:50]}...")
-                    else:
-                         logger.warning(f"No se pudo descargar video desde {best_quality['link'][:50]}...")
-                else:
-                    logger.warning(f"No se encontró enlace de descarga válido para video {video.get('id')}.")
-
             except Exception as e:
                 logger.warning(f"Error procesando/descargando video {video.get('id')}: {str(e)}")
 
@@ -507,335 +496,115 @@ def crear_video(prompt_type, input_text, musica_file=None):
         max_clip_segment = 10.0
 
         for i, path in enumerate(video_paths):
-            if current_duration >= audio_duration + max_clip_segment:
-                logger.debug(f"Video base suficiente ({current_duration:.1f}s >= {audio_duration:.1f}s + {max_clip_segment:.1f}s buffer). Dejando de procesar clips fuente restantes.")
-                break
-
+            if current_duration >= audio_duration + max_clip_segment: break
             clip = None
             try:
-                logger.debug(f"[{i+1}/{len(video_paths)}] Abriendo clip: {path}")
                 clip = VideoFileClip(path)
                 source_clips.append(clip)
-
-                if clip.reader is None or clip.duration is None or clip.duration <= 0:
-                    logger.warning(f"[{i+1}/{len(video_paths)}] Clip fuente {path} parece inválido (reader is None o duración <= 0). Saltando.")
-                    continue
-
+                if clip.reader is None or clip.duration is None or clip.duration <= 0: continue
+                
                 remaining_needed = audio_duration - current_duration
-                potential_use_duration = min(clip.duration, max_clip_segment)
-
                 if remaining_needed > 0:
-                     segment_duration = min(potential_use_duration, remaining_needed + min_clip_duration)
+                     segment_duration = min(min(clip.duration, max_clip_segment), remaining_needed + min_clip_duration)
                      segment_duration = max(min_clip_duration, segment_duration)
-                     segment_duration = min(segment_duration, clip.duration)
-
                      if segment_duration >= min_clip_duration:
-                          try:
-                               sub = clip.subclip(0, segment_duration)
-                               if sub.reader is None or sub.duration is None or sub.duration <= 0:
-                                    logger.warning(f"[{i+1}/{len(video_paths)}] Subclip generado de {path} es inválido. Saltando.")
-                                    try: sub.close()
-                                    except: pass
-                                    continue
-
-                               clips_to_concatenate.append(sub)
-                               current_duration += sub.duration
-                               logger.debug(f"[{i+1}/{len(video_paths)}] Segmento añadido: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
-
-                          except Exception as sub_e:
-                               logger.warning(f"[{i+1}/{len(video_paths)}] Error creando subclip de {path} ({segment_duration:.1f}s): {str(sub_e)}")
-                               continue
-                     else:
-                          logger.debug(f"[{i+1}/{len(video_paths)}] Clip {path} ({clip.duration:.1f}s) no contribuye un segmento suficiente ({segment_duration:.1f}s necesario). Saltando.")
-                else:
-                    logger.debug(f"[{i+1}/{len(video_paths)}] Duración de video base ya alcanzada. Saltando clip.")
-
+                        try:
+                            sub_raw = clip.subclip(0, segment_duration)
+                            # *** MODIFICACIÓN: Redimensionar y recortar cada subclip a 720p ***
+                            sub = sub_raw.resize(height=TARGET_RESOLUTION[1]).crop(x_center='center', width=TARGET_RESOLUTION[0], height=TARGET_RESOLUTION[1])
+                            sub_raw.close() # Liberar memoria del clip intermedio
+
+                            if sub.reader is None or sub.duration is None or sub.duration <= 0:
+                                try: sub.close()
+                                except: pass
+                                continue
+
+                            clips_to_concatenate.append(sub)
+                            current_duration += sub.duration
+                            logger.debug(f"Segmento añadido: {sub.duration:.1f}s (total video: {current_duration:.1f}/{audio_duration:.1f}s)")
+                        except Exception as sub_e:
+                            logger.warning(f"Error creando subclip de {path}: {str(sub_e)}")
             except Exception as e:
-                logger.warning(f"[{i+1}/{len(video_paths)}] Error procesando video {path}: {str(e)}", exc_info=True)
-                continue
-
-        logger.info(f"Procesamiento de clips fuente finalizado. Se obtuvieron {len(clips_to_concatenate)} segmentos válidos.")
+                logger.warning(f"Error procesando video {path}: {str(e)}", exc_info=True)
 
         if not clips_to_concatenate:
             logger.error("No hay segmentos de video válidos disponibles para crear la secuencia.")
             raise ValueError("No hay segmentos de video válidos disponibles para crear el video.")
 
         logger.info(f"Concatenando {len(clips_to_concatenate)} segmentos de video.")
-        concatenated_base = None
-        try:
-            concatenated_base = concatenate_videoclips(clips_to_concatenate, method="chain")
-            logger.info(f"Duración video base después de concatenación inicial: {concatenated_base.duration:.2f}s")
-
-            if concatenated_base is None or concatenated_base.duration is None or concatenated_base.duration <= 0:
-                 logger.critical("Video base concatenado es inválido después de la primera concatenación (None o duración cero).")
-                 raise ValueError("Fallo al crear video base válido a partir de segmentos.")
-
-        except Exception as e:
-             logger.critical(f"Error durante la concatenación inicial: {str(e)}", exc_info=True)
-             raise ValueError("Fallo durante la concatenación de video inicial.")
-        finally:
-             for clip_segment in clips_to_concatenate:
-                  try: clip_segment.close()
-                  except: pass
-             clips_to_concatenate = []
-
-        video_base = concatenated_base
-
-        final_video_base = video_base
-
-        if final_video_base.duration < audio_duration:
-            logger.info(f"Video base ({final_video_base.duration:.2f}s) es más corto que el audio ({audio_duration:.2f}s). Repitiendo...")
-
-            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
-            if remaining_duration > 0:
-                try:
-                    remaining_clip = final_video_base.subclip(0, remaining_duration)
-                    if remaining_clip is None or remaining_clip.duration is None or remaining_clip.duration <= 0:
-                        logger.warning(f"Subclip generado para duración restante {remaining_duration:.2f}s es inválido. Saltando.")
-                        try: remaining_clip.close()
-                        except: pass
-                    else:
-                         repeated_clips_list.append(remaining_clip)
-                         logger.debug(f"Añadiendo segmento restante: {remaining_duration:.2f}s")
-
-                except Exception as e:
-                     logger.warning(f"Error creando subclip para duración restante {remaining_duration:.2f}s: {str(e)}")
-
-            if repeated_clips_list:
-                 logger.info(f"Concatenando {len(repeated_clips_list)} partes para repetición.")
-                 video_base_repeated = None
-                 try:
-                    video_base_repeated = concatenate_videoclips(repeated_clips_list, method="chain")
-                    logger.info(f"Duración del video base repetido: {video_base_repeated.duration:.2f}s")
-
-                    if video_base_repeated is None or video_base_repeated.duration is None or video_base_repeated.duration <= 0:
-                         logger.critical("Video base repetido concatenado es inválido.")
-                         raise ValueError("Fallo al crear video base repetido válido.")
+        video_base = concatenate_videoclips(clips_to_concatenate, method="chain")
+        for seg in clips_to_concatenate:
+            try: seg.close() 
+            except: pass
+        clips_to_concatenate = []
 
-                    if final_video_base is not video_base_repeated:
-                        try: final_video_base.close()
-                        except: pass
+        if video_base.duration < audio_duration:
+            logger.info(f"Video base ({video_base.duration:.2f}s) más corto que audio ({audio_duration:.2f}s). Repitiendo...")
+            video_base = video_base.loop(duration=audio_duration)
 
-                    final_video_base = video_base_repeated
+        if video_base.duration > audio_duration:
+             logger.info(f"Recortando video base ({video_base.duration:.2f}s) para coincidir con audio ({audio_duration:.2f}s).")
+             video_base = video_base.subclip(0, audio_duration)
 
-                 except Exception as e:
-                    logger.critical(f"Error durante la concatenación de repetición: {str(e)}", exc_info=True)
-                    raise ValueError("Fallo durante la repetición de video.")
-                 finally:
-                     if 'repeated_clips_list' in locals():
-                         for clip in repeated_clips_list:
-                              if clip is not final_video_base:
-                                   try: clip.close()
-                                   except: pass
-
-        if final_video_base.duration > audio_duration:
-             logger.info(f"Recortando video base ({final_video_base.duration:.2f}s) para que coincida con la duración del audio ({audio_duration:.2f}s).")
-             trimmed_video_base = None
-             try:
-                trimmed_video_base = final_video_base.subclip(0, audio_duration)
-                if trimmed_video_base is None or trimmed_video_base.duration is None or trimmed_video_base.duration <= 0:
-                     logger.critical("Video base recortado es inválido.")
-                     raise ValueError("Fallo al crear video base recortado válido.")
-
-                if final_video_base is not trimmed_video_base:
-                     try: final_video_base.close()
-                     except: pass
-
-                final_video_base = trimmed_video_base
-
-             except Exception as e:
-                logger.critical(f"Error durante el recorte: {str(e)}", exc_info=True)
-                raise ValueError("Fallo durante el recorte de video.")
-
-        if final_video_base is None or final_video_base.duration is None or final_video_base.duration <= 0:
-             logger.critical("Video base final es inválido antes de audio/escritura (None o duración cero).")
+        if video_base is None or video_base.duration is None or video_base.duration <= 0:
              raise ValueError("Video base final es inválido.")
-
-        if final_video_base.size is None or final_video_base.size[0] <= 0 or final_video_base.size[1] <= 0:
-             logger.critical(f"Video base final tiene tamaño inválido: {final_video_base.size}. No se puede escribir video.")
-             raise ValueError("Video base final tiene tamaño inválido antes de escribir.")
-
-        video_base = final_video_base
-
+        
         # 6. Manejar música de fondo
         logger.info("Procesando audio...")
-
         final_audio = audio_tts_original
-
-        musica_audio_looped = None
-
         if musica_file:
-            musica_audio_original = None
             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"Música de fondo copiada a: {music_path}")
-
                 musica_audio_original = AudioFileClip(music_path)
-
-                if musica_audio_original.reader is None or musica_audio_original.duration is None or musica_audio_original.duration <= 0:
-                     logger.warning("Clip de música de fondo parece inválido o tiene duración cero. Saltando música.")
-                     try: musica_audio_original.close()
-                     except: pass
-                     musica_audio_original = None
-                else:
-                     musica_audio_looped = loop_audio_to_length(musica_audio_original, video_base.duration)
-                     logger.debug(f"Música ajustada a duración del video: {musica_audio_looped.duration:.2f}s")
-
-                     if musica_audio_looped is None or musica_audio_looped.duration is None or musica_audio_looped.duration <= 0:
-                          logger.warning("Clip de música de fondo loopeado es inválido. Saltando música.")
-                          try: musica_audio_looped.close()
-                          except: pass
-                          musica_audio_looped = None
-
-                if musica_audio_looped:
-                    composite_audio = CompositeAudioClip([
-                        musica_audio_looped.volumex(0.2), # Volumen 20% para música
-                        audio_tts_original.volumex(1.0) # Volumen 100% para voz
-                    ])
-
-                    if composite_audio.duration is None or composite_audio.duration <= 0:
-                        logger.warning("Clip de audio compuesto es inválido (None o duración cero). Usando solo audio de voz.")
-                        try: composite_audio.close()
-                        except: pass
-                        final_audio = audio_tts_original
-                    else:
-                         logger.info("Mezcla de audio completada (voz + música).")
-                         final_audio = composite_audio
-                         musica_audio = musica_audio_looped # Asignar para limpieza
-
+                if musica_audio_original.duration > 0:
+                    musica_audio = loop_audio_to_length(musica_audio_original, video_base.duration)
+                    if musica_audio and musica_audio.duration > 0:
+                        final_audio = CompositeAudioClip([musica_audio.volumex(0.2), audio_tts_original.volumex(1.0)])
             except Exception as e:
-                logger.warning(f"Error procesando música de fondo: {str(e)}", exc_info=True)
-                final_audio = audio_tts_original
-                musica_audio = None
-                logger.warning("Usando solo audio de voz debido a un error con la música.")
+                logger.warning(f"Error procesando música: {str(e)}", exc_info=True)
 
         if final_audio.duration is not None and abs(final_audio.duration - video_base.duration) > 0.2:
-            logger.warning(f"Duración del audio final ({final_audio.duration:.2f}s) difiere significativamente del video base ({video_base.duration:.2f}s). Intentando recorte.")
-            try:
-                 if final_audio.duration > video_base.duration:
-                      trimmed_final_audio = final_audio.subclip(0, video_base.duration)
-                      if trimmed_final_audio is None or trimmed_final_audio.duration <= 0:
-                           logger.warning("Audio final recortado es inválido. Usando audio final original.")
-                           try: trimmed_final_audio.close()
-                           except: pass
-                      else:
-                           if final_audio is not trimmed_final_audio:
-                               try: final_audio.close()
-                               except: pass
-                           final_audio = trimmed_final_audio
-                           logger.warning("Audio final recortado para que coincida con la duración del video.")
-            except Exception as e:
-                 logger.warning(f"Error ajustando duración del audio final: {str(e)}")
+            logger.warning(f"Ajustando duración de audio final ({final_audio.duration:.2f}s) a la del video ({video_base.duration:.2f}s).")
+            final_audio = final_audio.subclip(0, video_base.duration)
 
-              # 7. Crear video final
+        # 7. Crear video final
         logger.info("Renderizando video final...")
         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("Clip de video final (con audio) es inválido antes de escribir (None o duración cero).")
-             raise ValueError("Clip de video final es inválido antes de escribir.")
-
         output_filename = "final_video.mp4"
         output_path = os.path.join(temp_dir_intermediate, output_filename)
         logger.info(f"Escribiendo video final a: {output_path}")
 
-        if not output_path or not isinstance(output_path, str):
-            logger.critical(f"output_path no es válido: {output_path}")
-            raise ValueError("El nombre del archivo de salida no es válido.")
-
-        try:
-            video_final.write_videofile(
-                filename=output_path,
-                fps=24,
-                threads=4,
-                codec="libx264",
-                audio_codec="aac",
-                preset="medium",
-                logger='bar'
-            )
-        except Exception as e:
-            logger.critical(f"Error al escribir el video final: {str(e)}", exc_info=True)
-            raise ValueError(f"Fallo al escribir el video final: {str(e)}")
+        video_final.write_videofile(
+            filename=output_path, fps=24, threads=4, codec="libx264",
+            audio_codec="aac", preset="medium", logger='bar'
+        )
 
         total_time = (datetime.now() - start_time).total_seconds()
         logger.info(f"PROCESO DE VIDEO FINALIZADO | Output: {output_path} | Tiempo total: {total_time:.2f}s")
 
         return output_path
 
-    except ValueError as ve:
-         logger.error(f"ERROR CONTROLADO en crear_video: {str(ve)}")
-         raise ve
     except Exception as e:
-        logger.critical(f"ERROR CRÍTICO NO CONTROLADO en crear_video: {str(e)}", exc_info=True)
-        raise e
+        logger.critical(f"ERROR CRÍTICO en crear_video: {str(e)}", exc_info=True)
+        raise
     finally:
         logger.info("Iniciando limpieza de clips y archivos temporales intermedios...")
-
-        for clip in source_clips:
-            try:
-                clip.close()
-            except Exception as e:
-                logger.warning(f"Error cerrando clip de video fuente en finally: {str(e)}")
-
-        for clip_segment in clips_to_concatenate:
-             try:
-                 clip_segment.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando segmento de video en finally: {str(e)}")
-
-        if musica_audio is not None:
-            try:
-                musica_audio.close()
-            except Exception as e:
-                logger.warning(f"Error cerrando musica_audio (procesada) en 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 cerrando musica_audio_original en finally: {str(e)}")
-
-        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 cerrando audio_tts (procesada) en finally: {str(e)}")
-
-        if audio_tts_original is not None:
-             try:
-                 audio_tts_original.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando audio_tts_original en finally: {str(e)}")
-
-        if video_final is not None:
-            try:
-                video_final.close()
-            except Exception as e:
-                logger.warning(f"Error cerrando video_final en finally: {str(e)}")
-        elif video_base is not None and video_base is not video_final:
-             try:
-                 video_base.close()
-             except Exception as e:
-                 logger.warning(f"Error cerrando video_base en finally: {str(e)}")
-
+        clips_to_close = [video_base, video_final, audio_tts_original, musica_audio_original, musica_audio] + source_clips + clips_to_concatenate
+        for clip in clips_to_close:
+            if clip:
+                try: clip.close()
+                except Exception: pass
         if temp_dir_intermediate and os.path.exists(temp_dir_intermediate):
              final_output_in_temp = os.path.join(temp_dir_intermediate, "final_video.mp4")
-
              for path in temp_intermediate_files:
-                 try:
-                     if os.path.isfile(path) and path != final_output_in_temp:
-                         logger.debug(f"Eliminando archivo temporal intermedio: {path}")
+                 if os.path.isfile(path) and path != final_output_in_temp:
+                     try:
                          os.remove(path)
-                     elif os.path.isfile(path) and path == final_output_in_temp:
-                         logger.debug(f"Saltando eliminación del archivo de video final: {path}")
-                 except Exception as e:
-                     logger.warning(f"No se pudo eliminar archivo temporal intermedio {path}: {str(e)}")
-
+                         logger.debug(f"Eliminando archivo temporal intermedio: {path}")
+                     except Exception: pass
              logger.info(f"Directorio temporal intermedio {temp_dir_intermediate} persistirá para que Gradio lea el video final.")
 
 def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
@@ -853,30 +622,29 @@ def run_app(prompt_type, prompt_ia, prompt_manual, musica_file):
         status_msg = gr.update(value="⚠️ Por favor, ingresa texto para el guion o el tema.", interactive=False)
         return output_video, output_file, status_msg
 
-    logger.info(f"Tipo de entrada: {prompt_type}")
-    logger.debug(f"Texto de entrada: '{input_text[:100]}...'")
-    if musica_file:
-        logger.info(f"Archivo de música recibido: {musica_file}")
-    else:
-        logger.info("No se proporcionó archivo de música.")
-
     try:
         logger.info("Llamando a crear_video...")
         video_path = crear_video(prompt_type, input_text, musica_file)
 
         if video_path and os.path.exists(video_path):
             logger.info(f"crear_video retornó path: {video_path}")
-            logger.info(f"Tamaño del archivo de video retornado: {os.path.getsize(video_path)} bytes")
             output_video = video_path
             output_file = gr.update(value=video_path, visible=True)
             status_msg = gr.update(value="✅ Video generado exitosamente.", interactive=False)
+
+            # *** MODIFICACIÓN: Programar la eliminación automática del directorio del video ***
+            temp_dir_to_delete = os.path.dirname(video_path)
+            delay_hours = 3
+            deletion_thread = threading.Thread(
+                target=schedule_deletion,
+                args=(temp_dir_to_delete, delay_hours * 3600)
+            )
+            deletion_thread.daemon = True
+            deletion_thread.start()
         else:
             logger.error(f"crear_video no retornó un path válido o el archivo no existe: {video_path}")
-            status_msg = gr.update(value="❌ Error: La generación del video falló o el archivo no se creó correctamente.", interactive=False)
+            status_msg = gr.update(value="❌ Error: La generación del video falló.", interactive=False)
 
-    except ValueError as ve:
-        logger.warning(f"Error de validación durante la creación del video: {str(ve)}")
-        status_msg = gr.update(value=f"⚠️ Error de validación: {str(ve)}", interactive=False)
     except Exception as e:
         logger.critical(f"Error crítico durante la creación del video: {str(e)}", exc_info=True)
         status_msg = gr.update(value=f"❌ Error inesperado: {str(e)}", interactive=False)
@@ -904,25 +672,21 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 prompt_ia = gr.Textbox(
                     label="Tema para IA",
                     lines=2,
-                    placeholder="Ej: Un paisaje natural con montañas y ríos al amanecer, mostrando la belleza de la naturaleza...",
-                    max_lines=4,
-                    value=""
+                    placeholder="Ej: Un paisaje natural con montañas y ríos...",
+                    max_lines=4
                 )
 
             with gr.Column(visible=False) as manual_guion_column:
                 prompt_manual = gr.Textbox(
                     label="Tu Guion Completo",
                     lines=5,
-                    placeholder="Ej: En este video exploraremos los misterios del océano. Veremos la vida marina fascinante y los arrecifes de coral vibrantes. ¡Acompáñanos en esta aventura subacuática!",
-                    max_lines=10,
-                    value=""
+                    placeholder="Ej: En este video exploraremos los misterios del océano...",
+                    max_lines=10
                 )
 
             musica_input = gr.Audio(
                 label="Música de fondo (opcional)",
-                type="filepath",
-                interactive=True,
-                value=None
+                type="filepath"
             )
 
             generate_btn = gr.Button("✨ Generar Video", variant="primary")
@@ -942,8 +706,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
                 label="Estado",
                 interactive=False,
                 show_label=False,
-                placeholder="Esperando acción...",
-                value="Esperando entrada..."
+                placeholder="Esperando acción..."
             )
 
     prompt_type.change(
@@ -954,7 +717,7 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
     )
 
     generate_btn.click(
-        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.", interactive=False)),
+        lambda: (None, None, gr.update(value="⏳ Procesando... Esto puede tomar varios minutos.")),
         outputs=[video_output, file_output, status_output],
         queue=True,
     ).then(
@@ -962,36 +725,15 @@ with gr.Blocks(title="Generador de Videos con IA", theme=gr.themes.Soft(), css="
         inputs=[prompt_type, prompt_ia, prompt_manual, musica_input],
         outputs=[video_output, file_output, status_output]
     )
-
     gr.Markdown("### Instrucciones:")
-    gr.Markdown("""
-    1.  **Clave API de Pexels:** Asegúrate de haber configurado la variable de entorno `PEXELS_API_KEY` con tu clave.
-    2.  **Selecciona el tipo de entrada**:
-        -   "Generar Guion con IA": Describe brevemente un tema (ej. "La belleza de las montañas"). La IA generará un guion corto.
-        -   "Usar Mi Guion": Escribe el guion completo que quieres para el video.
-    3.  **Sube música** (opcional): Selecciona un archivo de audio (MP3, WAV, etc.) para usar como música de fondo.
-    4.  **Haz clic en "✨ Generar Video"**.
-    5.  Espera a que se procese el video. El tiempo de espera puede variar. Verás el estado en el cuadro de texto.
-    6.  La previsualización del video aparecerá arriba (puede fallar para archivos grandes), y un enlace **Descargar Archivo de Video** se mostrará si la generación fue exitosa.
-    7.  Si hay errores, revisa el log `video_generator_full.log` para más detalles.
-    """)
-    gr.Markdown("---")
-    gr.Markdown("Desarrollado por [Tu Nombre/Empresa/Alias - Opcional]")
+    gr.Markdown("1. **Clave API de Pexels:** Asegúrate de tener la variable de entorno `PEXELS_API_KEY`.\n"
+                "2. **Selecciona el método** y escribe tu tema o guion.\n"
+                "3. **Sube música** (opcional).\n"
+                "4. Haz clic en **Generar Video** y espera.\n"
+                "5. El video generado se eliminará automáticamente del servidor después de 3 horas.")
 
-if __name__ == "__main__":
-    logger.info("Verificando dependencias críticas...")
-    try:
-        from moviepy.editor import ColorClip
-        try:
-            temp_clip = ColorClip((100,100), color=(255,0,0), duration=0.1)
-            temp_clip.close()
-            logger.info("Clips base de MoviePy (como ColorClip) creados y cerrados exitosamente. FFmpeg parece accesible.")
-        except Exception as e:
-            logger.critical(f"Fallo al crear clip base de MoviePy. A menudo indica problemas con FFmpeg/ImageMagick. Error: {e}", exc_info=True)
-
-    except Exception as e:
-         logger.critical(f"Fallo al importar MoviePy. Asegúrate de que está instalado. Error: {e}", exc_info=True)
 
+if __name__ == "__main__":
     logger.info("Iniciando aplicación Gradio...")
     try:
         app.launch(server_name="0.0.0.0", server_port=7860, share=False)