Update app.py

app.py

@@ -23,16 +23,20 @@ for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, GLITCH_SOUND, EJEMPLO_VIDEO]:
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
-def eliminar_archivo_tiempo(ruta):
-    try:
-        if os.path.exists(ruta):
-            os.remove(ruta)
-            logging.info(f"Archivo eliminado: {ruta}")
-    except Exception as e:
-        logging.error(f"Error al eliminar {ruta}: {e}")
-    finally:
-        import gc
-        gc.collect()  # Forzar liberación de memoria
+def eliminar_archivo_tiempo(ruta, delay=1800):
+    """Elimina el archivo después de 'delay' segundos (30 minutos por defecto)"""
+    def eliminar():
+        try:
+            if os.path.exists(ruta):
+                os.remove(ruta)
+                logging.info(f"Archivo eliminado: {ruta}")
+        except Exception as e:
+            logging.error(f"Error al eliminar {ruta}: {e}")
+        finally:
+            import gc
+            gc.collect()
+    from threading import Timer
+    Timer(delay, eliminar).start()  # ← Timer restaurado con 30 minutos de espera
 
 async def procesar_audio(texto, voz, duracion_video, audio_original):
     temp_files = []
@@ -92,7 +96,7 @@ def aplicar_glitch(video_clip):
     """Versión corregida del efecto glitch"""
     def glitch_effect(frame):
         import numpy as np
-        frame = frame.copy()  # ¡Clave para evitar el error de asignación!
+        frame = frame.copy()
         height, width, _ = frame.shape
         offset = np.random.randint(-5, 5)
         
@@ -112,13 +116,11 @@ def aplicar_glitch(video_clip):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada):
     try:
-        # Carga optimizada con control de memoria
         intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
         outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
         video_original = VideoFileClip(video_input, target_resolution=(1080, 1920))
         audio_original = video_original.audio
         
-        # Liberar recursos inmediatamente
         intro.reader.close()
         outro.reader.close()
         video_original.reader.close()
@@ -147,7 +149,6 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
 
             segment = video_original.subclip(start_time, end_time)
 
-            # Aplicar glitch solo en segmentos válidos
             if i % 2 == 0 and i > 0 and (end_time - start_time) > 0.5:
                 glitch_segment = aplicar_glitch(segment.subclip(0, 0.3))
                 glitch_sound_clip = glitch_sound.set_start(start_time)
@@ -161,18 +162,16 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
         audio_final = CompositeAudioClip([audio_final] + glitch_clips).set_duration(video_final.duration)
         video_con_audio = video_final.set_audio(audio_final)
         
-        # Recargar intro/outro para evitar conflictos de memoria
         intro = VideoFileClip(INTRO_VIDEO, target_resolution=(1080, 1920))
         outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(1080, 1920))
         video_final = concatenate_videoclips([intro, video_con_audio, outro], method="compose")
         
-        # Renderizado optimizado
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.write_videofile(
                 tmp.name,
                 codec="libx264",
                 audio_codec="aac",
-                fps=24,  # FPS fijo para estabilidad
+                fps=24,
                 threads=4,
                 bitrate="5M",
                 ffmpeg_params=[
@@ -183,14 +182,13 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                 ],
                 verbose=False
             )
-            eliminar_archivo_tiempo(tmp.name)
+            eliminar_archivo_tiempo(tmp.name, 1800)  # ← Ahora se eliminan a los 30 minutos
             return tmp.name
             
     except Exception as e:
         logging.error(f" fallo general: {str(e)}")
         raise
     finally:
-        # Forzar cierre de recursos
         try:
             intro.close()
             outro.close()