Update app.py

app.py

@@ -1,9 +1,7 @@
-import math
 import tempfile
 import logging
 import os
 import asyncio
-from threading import Timer  # Importación faltante
 from moviepy.editor import *
 import edge_tts
 import gradio as gr
@@ -16,18 +14,15 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
-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]:
+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}")
 
 def eliminar_archivo_tiempo(ruta, delay=1800):
-    """Elimina archivos temporales después de 30 minutos"""
     def eliminar():
         try:
             if os.path.exists(ruta):
@@ -35,34 +30,50 @@ def eliminar_archivo_tiempo(ruta, delay=1800):
                 logging.info(f"Archivo eliminado: {ruta}")
         except Exception as e:
             logging.error(f"Error al eliminar {ruta}: {e}")
+    from threading import Timer
     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_maxima):
-    """Genera TTS y lo limita a la duración máxima disponible"""
+async def procesar_audio(texto, voz, duracion_video_editado, duracion_intro):
     temp_files = []
     try:
         validar_texto(texto)
-        
-        # 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)
             
-            # Limitar TTS a la duración máxima
-            if tts_audio.duration > duracion_maxima:
-                tts_audio = tts_audio.subclip(0, duracion_maxima)
+            # Limitar TTS al tiempo disponible después de la intro
+            if tts_audio.duration > duracion_video_editado:
+                tts_audio = tts_audio.subclip(0, duracion_video_editado)
+
+        # Preparar música de fondo en loop
+        bg_music = AudioSegment.from_mp3(MUSIC_BG)
+        needed_ms = int(duracion_video_editado * 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:
+            bg_music.export(tmp_bg.name, format="mp3")
+            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
+            temp_files.append(tmp_bg.name)
 
-        return tts_audio
+        # Combinar audios
+        audio_final = CompositeAudioClip([
+            bg_audio.set_duration(duracion_video_editado),
+            tts_audio.volumex(0.85).set_start(0)  # Comienza al inicio del video editado
+        ]).set_duration(duracion_video_editado)
+        
+        return audio_final
     
     except Exception as e:
         logging.error(f" fallo en audio: {str(e)}")
@@ -74,82 +85,33 @@ async def procesar_audio(texto, voz, duracion_maxima):
             except Exception as e:
                 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)
-                    .set_duration(0.5)
-                    .resize(height=50)
-                    .set_pos(("right", "bottom")))
-        
-        clips_finales = []
-        for i, clip in enumerate(clips):
-            clip_watermarked = CompositeVideoClip([clip, watermark])
-            
-            if i > 0 and i % 40 == 0:
-                transicion = CompositeVideoClip([watermark.set_duration(0.5)]).set_audio(fx_audio)
-                clips_finales.append(transicion)
-            
-            clips_finales.append(clip_watermarked)
-        
-        return concatenate_videoclips(clips_finales, method="compose")
-    except Exception as e:
-        logging.error(f"Error en transiciones: {e}")
-        return concatenate_videoclips(clips)
-
-async def procesar_video(video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte):
+async def procesar_video(video_input, texto_tts, voz_seleccionada):
     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)):
-                clips.append(video_original.subclip(i*duracion_corte, (i+1)*duracion_corte))
-        else:
-            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
+        # Cargar componentes
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
+        video_original = VideoFileClip(video_input)
         
-        # Música de fondo solo para el video editado
-        bg_music = AudioSegment.from_mp3(MUSIC_BG)
-        needed_ms = int(video_editado_duration * 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:
-            bg_music.export(tmp_bg.name, format="mp3")
-            bg_audio = AudioFileClip(tmp_bg.name).volumex(0.15)
-        
-        # Duración máxima para el TTS (después de la intro)
-        max_tts_time = video_editado_duration
-        
-        # Procesar TTS
-        tts_audio = await procesar_audio(texto_tts, voz_seleccionada, max_tts_time)
+        # Duraciones
+        duracion_intro = intro.duration
+        duracion_video_editado = video_original.duration
         
-        # Combinar audios para el video editado
-        audios_editado = [bg_audio]
-        if audio_original:
-            audios_editado.append(audio_original.set_duration(video_editado_duration))
-        audios_editado.append(tts_audio.set_start(0))
+        # Procesar audio
+        audio_final = await procesar_audio(
+            texto_tts,
+            voz_seleccionada,
+            duracion_video_editado,
+            duracion_intro
+        )
         
-        audio_editado = CompositeAudioClip(audios_editado).set_duration(video_editado_duration)
-        video_editado = video_editado.set_audio(audio_editado)
+        # Combinar video original con audio
+        video_con_audio = video_original.set_audio(audio_final)
         
-        # Concatenar intro, video editado y outro
-        video_final = concatenate_videoclips([intro, video_editado, outro])
-        duracion_total = video_final.duration
+        # Concatenar intro + video + outro
+        video_final = concatenate_videoclips(
+            [intro, video_con_audio, outro],
+            method="chain"  # Evita el efecto grid
+        )
         
         # Renderizar video final
         with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmp:
@@ -186,27 +148,16 @@ with gr.Blocks() as demo:
         procesar_btn = gr.Button("Generar Video")
         video_output = gr.Video(label="Video Procesado")
     
-    with gr.Tab("Ajustes"):
-        metodo_corte = gr.Radio(
-            ["inteligente", "manual"],
-            label="Método de corte",
-            value="inteligente"
-        )
-        duracion_corte = gr.Slider(
-            1, 60, 10,
-            label="Segundos por corte (manual)"
-        )
-
     with gr.Accordion("Ejemplos de Uso", open=False):
         gr.Examples(
-            examples=[[EJEMPLO_VIDEO, "¡Hola! Esto es una prueba. Suscríbete al canal y activa la campanita."]],
+            examples=[[EJEMPLO_VIDEO, "¡Hola! Esto es una prueba. Suscríbete al canal."]],
             inputs=[video_input, texto_tts],
             label="Ejemplos"
         )
 
     procesar_btn.click(
         procesar_video,
-        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
+        inputs=[video_input, texto_tts, voz_seleccionada],
         outputs=video_output
     )