Update app.py

app.py

@@ -10,8 +10,10 @@ import edge_tts
 import gradio as gr
 from pydub import AudioSegment
 
+# Configuración de Logs
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
+# CONSTANTES DE ARCHIVOS
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
@@ -19,12 +21,14 @@ FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
 EJEMPLO_VIDEO = "ejemplo.mp4"
 
+# Validar existencia de archivos
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK, EJEMPLO_VIDEO]:
     if not os.path.exists(file):
         logging.error(f"Falta archivo necesario: {file}")
         raise FileNotFoundError(f"Falta: {file}")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
+    """Elimina archivos temporales después de 30 minutos"""
     def eliminar():
         try:
             if os.path.exists(ruta):
@@ -35,42 +39,49 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
     Timer(delay, eliminar).start()
 
 def validar_texto(texto):
+    """Valida el texto para evitar errores en TTS"""
     texto_limpio = texto.strip()
     if len(texto_limpio) < 3:
         raise gr.Error("⚠️ El texto debe tener al menos 3 caracteres")
     if any(c in texto_limpio for c in ["|", "\n", "\r"]):
         raise gr.Error("⚠️ Caracteres no permitidos detectados")
 
-async def procesar_audio(texto, voz, duracion_total, duracion_intro):
+async def procesar_audio(texto, voz, duracion_total, duracion_intro, max_tts_time):
+    """Genera y mezcla audio con protección de duración"""
     temp_files = []
     try:
         validar_texto(texto)
-        communicate = edge_tts.Communicate(texto, voz)
         
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            await communicate.save(tmp.name)
-            tts_audio = AudioFileClip(tmp.name)
-            temp_files.append(tmp.name)
+        # Generar TTS
+        communicate = edge_tts.Communicate(texto, voz)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
+            await communicate.save(tmp_tts.name)
+            tts_audio = AudioFileClip(tmp_tts.name)
+            temp_files.append(tmp_tts.name)
             
-            if tts_audio.duration < 0.5:
-                raise RuntimeError(f"Audio TTS inválido ({tts_audio.duration}s)")
+            # Asegurar TTS no exceda el tiempo disponible
+            if tts_audio.duration > max_tts_time:
+                tts_audio = tts_audio.subclip(0, max_tts_time)
 
+        # Procesar música de fondo
         bg_music = AudioSegment.from_mp3(MUSIC_BG)
         needed_ms = int(duracion_total * 1000)
         repeticiones = needed_ms // len(bg_music) + 1
         bg_music = bg_music * repeticiones
         bg_music = bg_music[:needed_ms].fade_out(5000)
         
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
-            bg_music.export(tmp.name, format="mp3")
-            bg_audio = AudioFileClip(tmp.name).volumex(0.15)
-            temp_files.append(tmp.name)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_bg:
+            bg_music.export(tmp_bg.name, format="mp3")
+            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
+            temp_files.append(tmp_bg.name)
 
+        # Combinar audios con duraciones exactas
         audio_final = CompositeAudioClip([
             bg_audio.set_duration(duracion_total),
-            tts_audio.volumex(0.85).set_start(duracion_intro)
-                      .set_duration(duracion_total - duracion_intro)
-        ])
+            tts_audio.volumex(0.85)
+                   .set_start(duracion_intro)
+                   .set_duration(max_tts_time)
+        ]).set_duration(duracion_total)
         
         return audio_final
     
@@ -85,6 +96,7 @@ async def procesar_audio(texto, voz, duracion_total, duracion_intro):
                 logging.warning(f"Error limpiando {file}: {e}")
 
 def agregar_transiciones(clips):
+    """Agrega transiciones visuales cada 40 segundos"""
     try:
         fx_audio = AudioFileClip(FX_SOUND).subclip(0, 0.5)
         watermark = (ImageClip(WATERMARK)
@@ -109,9 +121,11 @@ def agregar_transiciones(clips):
 
 async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
     try:
+        # Cargar video original
         video_original = VideoFileClip(video_input)
         audio_original = video_original.audio.volumex(0.7) if video_original.audio else None
         
+        # Cortar video según método
         clips = []
         if metodo_corte == "manual":
             for i in range(math.ceil(video_original.duration / duracion_corte)):
@@ -120,22 +134,37 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte,
             clips = [video_original.subclip(i, min(i+40, video_original.duration)) 
                     for i in range(0, math.ceil(video_original.duration), 40)]
         
+        # Procesar transiciones visuales
         video_editado = agregar_transiciones(clips)
+        video_editado_duration = video_editado.duration
+        
+        # Combinar con intro/outro
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
         video_final = concatenate_videoclips([intro, video_editado, outro])
-        
         duracion_total = video_final.duration
-        duracion_intro = intro.duration
         
-        audio_tts_bg = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, duracion_intro)
+        # Procesar audio (recibe duración exacta para TTS)
+        audio_tts_bg = await procesar_audio(
+            texto_tts,
+            voz_seleccionada,
+            duracion_total,
+            intro.duration,
+            video_editado_duration
+        )
         
+        # Combinar todos los audios
         audios = [audio_tts_bg]
         if audio_original:
-            audios.append(audio_original.set_duration(video_final.duration))
+            audios.append(
+                audio_original
+                .set_duration(video_editado_duration)
+                .set_start(intro.duration)
+            )
         
-        audio_final = CompositeAudioClip(audios).set_duration(video_final.duration)
+        audio_final = CompositeAudioClip(audios).set_duration(duracion_total)
         
+        # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
             video_final.set_audio(audio_final).write_videofile(
                 tmp.name,
@@ -151,6 +180,7 @@ async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte,
         logging.error(f" fallo general: {str(e)}")
         raise
 
+# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Editor de Video con IA")