Update app.py

app.py

@@ -2,6 +2,8 @@ import tempfile
 import logging
 import os
 import asyncio
+import gc
+import psutil
 from moviepy.editor import *
 import edge_tts
 import gradio as gr
@@ -16,15 +18,25 @@ OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
+# CONSTANTES DE LIMITACIONES
+MAX_VIDEO_DURATION = 300  # Máxima duración en segundos (5 minutos)
+MAX_VIDEO_SIZE = 100 * 1024 * 1024  # Tamaño máximo en bytes (100MB)
+MAX_RESOLUTION = (1280, 720)  # Resolución máxima (720p)
+
+# Configuración de chunks
+SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
+TRANSITION_DURATION = 1.5  # Duración del efecto slide
+
 # Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
-# Configuración de chunks
-SEGMENT_DURATION = 30  # Duración exacta entre transiciones (sin overlap)
-TRANSITION_DURATION = 1.5  # Duración del efecto slide
+def mostrar_uso_memoria():
+    proceso = psutil.Process(os.getpid())
+    memoria_uso = proceso.memory_info().rss / 1024 / 1024
+    logging.info(f"Uso de memoria: {memoria_uso:.2f} MB")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
     def eliminar():
@@ -39,8 +51,22 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
 
 def validar_video(video_path):
     try:
+        # Comprobar tamaño del archivo
+        file_size = os.path.getsize(video_path)
+        if file_size > MAX_VIDEO_SIZE:
+            logging.warning(f"El video excede el tamaño máximo: {file_size/1024/1024:.2f}MB > {MAX_VIDEO_SIZE/1024/1024}MB")
+            return False
+        
+        # Validar que es un video
         clip = VideoFileClip(video_path)
+        duracion = clip.duration
         clip.close()
+        
+        # Comprobar duración
+        if duracion > MAX_VIDEO_DURATION:
+            logging.warning(f"El video excede la duración máxima: {duracion}s > {MAX_VIDEO_DURATION}s")
+            return False
+            
         return True
     except Exception as e:
         logging.error(f"El video no es válido: {e}")
@@ -50,30 +76,39 @@ def convertir_video(video_path):
     try:
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_converted:
             output_path = tmp_converted.name
-        os.system(f'ffmpeg -i "{video_path}" -vcodec libx264 -acodec aac "{output_path}" -y')
+        
+        # Primero convertir a un formato más eficiente y con menor resolución
+        os.system(f'ffmpeg -i "{video_path}" -vf "scale=640:360" -c:v libx264 -crf 28 -preset ultrafast -c:a aac -b:a 96k "{output_path}" -y')
+        
+        # Comprobar si ahora cumple las limitaciones
+        if not validar_video(output_path):
+            # Si sigue sin cumplir, recortar duración
+            nuevo_clip = VideoFileClip(output_path)
+            duracion_maxima = min(nuevo_clip.duration, MAX_VIDEO_DURATION)
+            nuevo_clip = nuevo_clip.subclip(0, duracion_maxima)
+            
+            temp_recortado = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
+            nuevo_clip.write_videofile(temp_recortado, codec="libx264", audio_codec="aac", 
+                                      preset="ultrafast", bitrate="1M")
+            nuevo_clip.close()
+            
+            os.remove(output_path)
+            return temp_recortado
+        
         return output_path
     except Exception as e:
         logging.error(f"Error al convertir el video: {e}")
         raise
 
-def ajustar_resolucion(video_path):
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_resized:
-            output_path = tmp_resized.name
-        os.system(f'ffmpeg -i "{video_path}" -vf "scale=1280:720" -vcodec libx264 -acodec aac "{output_path}" -y')
-        return output_path
-    except Exception as e:
-        logging.error(f"Error al ajustar la resolución del video: {e}")
-        raise
-
 async def generar_tts(texto, voz, duracion_total):
     try:
         if not texto.strip():
             raise ValueError("El texto para TTS no puede estar vacío.")
-        if len(texto) > 1000:
-            texto = texto[:1000]
+        # Limitar el texto a 500 caracteres para procesar más rápido
+        if len(texto) > 500:
+            texto = texto[:500]
+            logging.info("Texto para TTS truncado a 500 caracteres para optimizar rendimiento")
         
-        # Eliminado la validación restrictiva de voces para permitir todas las que están en el dropdown
         logging.info(f"Generando TTS con voz: {voz}")
         communicate = edge_tts.Communicate(texto, voz)
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
@@ -104,44 +139,85 @@ def create_slide_transition(clip1, clip2, duration=TRANSITION_DURATION):
         part2.fx(vfx.fadein, duration).set_position(
             lambda t: ('center', 720 - (720 * (t/duration)))
         )
-    ], size=(1280, 720)).set_duration(duration)
+    ], size=(640, 360)).set_duration(duration)  # Reducido a 640x360 para optimizar
     return transition
 
-async def procesar_video(video_input, texto_tts, voz_seleccionada):
+def liberar_memoria(objetos_cerrar=None):
+    """Forzar liberación de memoria cerrando objetos y llamando al recolector de basura"""
+    if objetos_cerrar:
+        for obj in objetos_cerrar:
+            if obj is not None:
+                try:
+                    obj.close()
+                except:
+                    pass
+    
+    # Forzar recolección de basura
+    gc.collect()
+    mostrar_uso_memoria()
+
+async def procesar_video(video_input, texto_tts, voz_seleccionada, progress=gr.Progress()):
     temp_files = []
     intro, outro, video_original = None, None, None
+    segmentos_temp = []
+    
     try:
+        mostrar_uso_memoria()
         logging.info("Iniciando procesamiento")
+        progress(0, desc="Validando video")
         
         if not validar_video(video_input):
+            progress(0.05, desc="Convirtiendo formato de video")
             video_input = convertir_video(video_input)
             temp_files.append(video_input)
-        
-        video_original = VideoFileClip(video_input, target_resolution=(720, 1280))
+            
+        progress(0.1, desc="Preparando video")
+        # Reducir resolución para optimizar procesamiento
+        video_original = VideoFileClip(video_input)
         duracion_video = video_original.duration
         
+        # Limitar duración si es necesario
+        if duracion_video > MAX_VIDEO_DURATION:
+            duracion_video = MAX_VIDEO_DURATION
+            video_original = video_original.subclip(0, duracion_video)
+            
         if duracion_video <= 0:
             raise ValueError("El video debe tener una duración mayor que cero.")
         
+        progress(0.2, desc="Generando narración (TTS)")
         tts_audio, tts_path = await generar_tts(texto_tts, voz_seleccionada, duracion_video)
+        temp_files.append(tts_path)
+        
+        progress(0.3, desc="Preparando música de fondo")
         bg_audio, bg_path = crear_musica_fondo(duracion_video)
-        temp_files.extend([tts_path, bg_path])
+        temp_files.append(bg_path)
         
-        audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
+        progress(0.35, desc="Mezclando audio")
+        audio_original = video_original.audio.volumex(0.5) if video_original.audio else None
         audios = [bg_audio.set_duration(duracion_video)]
         if audio_original:
             audios.append(audio_original)
         audios.append(tts_audio.set_start(0).volumex(0.85))
         audio_final = CompositeAudioClip(audios).set_duration(duracion_video)
         
-        video_final = video_original.copy()
+        # Procesar por segmentos para optimizar memoria
         if duracion_video > SEGMENT_DURATION:
+            progress(0.4, desc="Procesando segmentos de video")
             clips = []
             num_segments = int(duracion_video // SEGMENT_DURATION) + (1 if duracion_video % SEGMENT_DURATION > 0 else 0)
+            
             for i in range(num_segments):
+                progress_val = 0.4 + (0.3 * (i / num_segments))
+                progress(progress_val, desc=f"Procesando segmento {i+1}/{num_segments}")
+                
                 start_time = i * SEGMENT_DURATION
                 end_time = min(start_time + SEGMENT_DURATION, duracion_video)
                 segment = video_original.subclip(start_time, end_time)
+                
+                # Reducir resolución si es necesario
+                if segment.size[0] > MAX_RESOLUTION[0] or segment.size[1] > MAX_RESOLUTION[1]:
+                    segment = segment.resize(height=MAX_RESOLUTION[1])
+                
                 if i == 0:
                     clips.append(segment)
                 else:
@@ -152,48 +228,88 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada):
                         clips[-1] = prev_segment.subclip(0, prev_end)
                     clips.append(transition)
                     clips.append(segment)
+                
+                # Liberar memoria después de cada 2 segmentos
+                if i % 2 == 1:
+                    liberar_memoria()
+                    
             video_final = concatenate_videoclips(clips, method="compose")
-        
+        else:
+            video_final = video_original.copy()
+            
+        # Asignar audio final
+        progress(0.7, desc="Asignando audio")
         video_final = video_final.set_audio(audio_final)
-        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(720, 1280))
-        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(720, 1280))
-        video_final = concatenate_videoclips([intro, video_final, outro], method="compose")
         
-        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
-            video_final.write_videofile(
-                tmp.name,
-                codec="libx264",
-                audio_codec="aac",
-                fps=24,
-                threads=2,
-                bitrate="3M",
-                ffmpeg_params=[
-                    "-preset", "ultrafast",
-                    "-crf", "28",
-                    "-movflags", "+faststart",
-                    "-vf", "scale=1280:720"
-                ],
-                verbose=False
-            )
-            eliminar_archivo_tiempo(tmp.name, 1800)
-            logging.info(f"Video final guardado: {tmp.name}")
-            return tmp.name
+        # Añadir intro y outro
+        progress(0.75, desc="Añadiendo intro y outro")
+        intro = VideoFileClip(INTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
+        outro = VideoFileClip(OUTRO_VIDEO, target_resolution=(360, 640))  # Reducido para optimizar
+        
+        # Crear el video final por partes
+        with tempfile.NamedTemporaryFile(delete=False, suffix="_intro.mp4") as tmp_intro:
+            intro.write_videofile(tmp_intro.name, codec="libx264", audio_codec="aac", 
+                                preset="ultrafast", bitrate="1M", 
+                                ffmpeg_params=["-crf", "30"])
+            segmentos_temp.append(tmp_intro.name)
+            
+        with tempfile.NamedTemporaryFile(delete=False, suffix="_main.mp4") as tmp_main:
+            video_final.write_videofile(tmp_main.name, codec="libx264", audio_codec="aac",
+                                    preset="ultrafast", bitrate="1M",
+                                    ffmpeg_params=["-crf", "30"])
+            segmentos_temp.append(tmp_main.name)
+            
+        with tempfile.NamedTemporaryFile(delete=False, suffix="_outro.mp4") as tmp_outro:
+            outro.write_videofile(tmp_outro.name, codec="libx264", audio_codec="aac",
+                                preset="ultrafast", bitrate="1M",
+                                ffmpeg_params=["-crf", "30"])
+            segmentos_temp.append(tmp_outro.name)
+        
+        # Liberar memoria antes de la unión final
+        liberar_memoria([video_original, intro, outro, video_final])
+        video_original = intro = outro = video_final = None
+        
+        # Unir los segmentos con ffmpeg directamente
+        progress(0.9, desc="Generando video final")
+        with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as concat_file:
+            # Escribir archivo de lista para concatenación
+            for segment in segmentos_temp:
+                concat_file.write(f"file '{segment}'\n".encode())
+            concat_path = concat_file.name
+            
+        with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp_final:
+            output_path = tmp_final.name
+            os.system(f'ffmpeg -f concat -safe 0 -i "{concat_path}" -c copy "{output_path}" -y')
+            
+            # Limpiar archivos temporales
+            os.remove(concat_path)
+            for segment in segmentos_temp:
+                if os.path.exists(segment):
+                    os.remove(segment)
+            
+            eliminar_archivo_tiempo(output_path, 3600)  # Extendido a 1 hora
+            progress(1.0, desc="¡Video listo!")
+            logging.info(f"Video final guardado: {output_path}")
+            mostrar_uso_memoria()
+            return output_path
     except Exception as e:
         logging.error(f"Fallo general: {str(e)}")
         raise
     finally:
         try:
-            if video_original:
-                video_original.close()
-            if intro:
-                intro.close()
-            if outro:  # Corregido: outro en lugar de otro
-                outro.close()
+            liberar_memoria([video_original, intro, outro])
             for file in temp_files:
                 try:
-                    os.remove(file)
+                    if os.path.exists(file):
+                        os.remove(file)
                 except Exception as e:
                     logging.warning(f"Error limpiando {file}: {e}")
+            for segment in segmentos_temp:
+                try:
+                    if os.path.exists(segment):
+                        os.remove(segment)
+                except Exception as e:
+                    logging.warning(f"Error limpiando segmento {segment}: {e}")
         except Exception as e:
             logging.warning(f"Error al cerrar recursos: {str(e)}")
 
@@ -203,7 +319,7 @@ with gr.Blocks() as demo:
     with gr.Tab("Principal"):
         video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(
-            label="Texto para TTS",
+            label="Texto para TTS (máx. 500 caracteres)",
             lines=3,
             placeholder="Escribe aquí tu texto..."
         )
@@ -261,7 +377,7 @@ with gr.Blocks() as demo:
             ],
             value="es-ES-AlvaroNeural"
         )
-        procesar_btn = gr.Button("Generar Video")
+        procesar_btn = gr.Button("Generar Video (Modo Optimizado)")
         video_output = gr.Video(label="Video Procesado")
     with gr.Accordion("Ejemplos de Uso", open=False):
         gr.Examples(
@@ -277,11 +393,23 @@ with gr.Blocks() as demo:
 
     gr.Markdown("""
     ### ℹ️ Notas importantes:
-    - Las transiciones ocurren solamente cada 30 segundos
+    - **Limitaciones para Hugging Face Spaces:**
+      - Máxima duración de video: 5 minutos
+      - Máximo tamaño de archivo: 100MB
+      - Resolución reducida a 640x360 para procesamiento
+      - Texto TTS limitado a 500 caracteres
+    - Las transiciones ocurren cada 30 segundos
     - El video contiene intro y outro predefinidos
-    - El archivo generado se elimina después de 30 minutos
-    - Para mejores resultados, usa videos de dimensiones 720p o 1080p
+    - El archivo generado se elimina después de 1 hora
+    - Para videos más pesados, considera usar este código localmente
     """)
 
 if __name__ == "__main__":
+    # Instalar psutil si no está disponible
+    try:
+        import psutil
+    except ImportError:
+        os.system("pip install psutil")
+        import psutil
+        
     demo.queue().launch()