Update app.py

app.py

@@ -1,92 +1,104 @@
-import os
 import math
 import tempfile
 import logging
 from PIL import Image
-from pydub import AudioSegment
+import os
+import asyncio
 from moviepy.editor import (
     VideoFileClip, AudioFileClip, ImageClip,
     concatenate_videoclips, CompositeVideoClip, CompositeAudioClip
 )
 import edge_tts
 import gradio as gr
-import asyncio
+from pydub import AudioSegment
+
+# PATCH PARA PILLOW 10+ (crítico)
+Image.ANTIALIAS = Image.Resampling.LANCZOS  # Parche antes de importar MoviePy
 
-# PATCH PARA PILLOW 10+
-Image.ANTIALIAS = Image.Resampling.LANCZOS
+# Configuración de Logs
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 
-# CONFIGURACIÓN
+# CONSTANTES DE ARCHIVOS (sin cambios en los nombres)
 INTRO_VIDEO = "introvideo.mp4"
 OUTRO_VIDEO = "outrovideo.mp4"
 MUSIC_BG = "musicafondo.mp3"
 FX_SOUND = "fxsound.mp3"
 WATERMARK = "watermark.png"
 
-# Validar archivos
+# Validar existencia de archivos obligatorios
 for file in [INTRO_VIDEO, OUTRO_VIDEO, MUSIC_BG, FX_SOUND, WATERMARK]:
     if not os.path.exists(file):
-        raise FileNotFoundError(f"Falta: {file}")
-
-async def procesar_audio(texto, voz, duracion_total):
-    try:
-        communicate = edge_tts.Communicate(texto, voz)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_tts:
-            await communicate.save(tmp_tts.name)
-            tts_path = tmp_tts.name
-        
-        # Verificar que el archivo TTS es válido
-        if not os.path.exists(tts_path) or os.path.getsize(tts_path) == 0:
-            raise ValueError("El archivo TTS generado está vacío o corrupto.")
-        
-        tts_audio = AudioSegment.from_mp3(tts_path)
-        
-        # Preparar música de fondo en loop
-        bg_music = AudioSegment.from_mp3(MUSIC_BG) - 10  # 10% volumen
-        repeticiones = math.ceil(duracion_total * 1000 / len(bg_music))
-        bg_music_loop = bg_music * repeticiones
-        bg_music_final = bg_music_loop[:duracion_total*1000].fade_out(3000)
-        
-        # Combinar TTS (después de la intro) con música
-        intro_duration = VideoFileClip(INTRO_VIDEO).duration * 1000  # Duración en ms
-        audio_final = bg_music_final.overlay(tts_audio, position=intro_duration)
-        
-        # Guardar como WAV primero (para evitar problemas de formato)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_wav:
-            audio_final.export(tmp_wav.name, format="wav")
-        
-        # Convertir a MP3 (si es necesario)
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_mp3:
-            AudioSegment.from_wav(tmp_wav.name).export(tmp_mp3.name, format="mp3")
-            return tmp_mp3.name
-    except Exception as e:
-        logging.error(f"Error procesando audio: {e}")
-        raise
+        logging.error(f"Falta archivo necesario: {file}")
+        raise FileNotFoundError(f"Falta archivo necesario: {file}")
 
 def cortar_video(video_path, metodo="inteligente", duracion=10):
     try:
+        logging.info("Iniciando corte de video...")
         video = VideoFileClip(video_path)
         if metodo == "manual":
-            return [
-                video.subclip(i*duracion, (i+1)*duracion)
-                for i in range(math.ceil(video.duration/duracion))
-            ]
+            clips = [video.subclip(i * duracion, (i + 1) * duracion)
+                     for i in range(math.ceil(video.duration / duracion))]
+            logging.info(f"Video cortado en {len(clips)} clips manuales.")
+            return clips
         
-        # Simulación de cortes automáticos
+        # Simulación básica de cortes automáticos (puedes mejorar esto con VAD)
         clips = []
         ultimo_corte = 0
         for i in range(1, math.ceil(video.duration)):
             if i % 5 == 0:  # Simulación de pausas
                 clips.append(video.subclip(ultimo_corte, i))
                 ultimo_corte = i
-        return clips if clips else [video]
+        logging.info(f"Video cortado en {len(clips)} clips automáticos.")
+        return clips
     except Exception as e:
-        logging.error(f"Error cortando video: {e}")
+        logging.error(f"Error al cortar video: {e}")
+        raise
+
+async def procesar_audio(texto, voz, duracion_total, duracion_intro, duracion_video_editado):
+    try:
+        logging.info("Generando TTS y mezclando audio...")
+        communicate = edge_tts.Communicate(texto, voz)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            await communicate.save(tmp.name)  # Usar await en lugar de asyncio.run()
+            tts_audio = AudioFileClip(tmp.name)
+        
+        # Duración natural del TTS
+        tts_duration = tts_audio.duration
+        
+        # Ajustar TTS para que dure solo lo que dura el video editado
+        if tts_duration > duracion_video_editado:
+            tts_audio = tts_audio.subclip(0, duracion_video_editado)
+        
+        # Mezclar con música de fondo
+        bg_music = AudioSegment.from_mp3(MUSIC_BG)
+        if len(bg_music) < duracion_total * 1000:
+            bg_music = bg_music * math.ceil(duracion_total * 1000 / len(bg_music))
+        bg_music = bg_music[:duracion_total * 1000].fade_out(3000)
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp:
+            bg_music.export(tmp.name, format="mp3")
+            bg_audio = AudioFileClip(tmp.name).volumex(0.10)
+        
+        # Combinar audios: bg_audio en toda la duración, tts_audio después del intro
+        audio_final = CompositeAudioClip([
+            bg_audio,
+            tts_audio.volumex(0.9).set_start(duracion_intro)
+        ])
+        
+        logging.info("Audio procesado correctamente.")
+        return audio_final
+    except Exception as e:
+        logging.error(f"Error al procesar audio: {e}")
         raise
 
 def agregar_transiciones(clips):
     try:
+        logging.info("Agregando transiciones...")
         fx_audio = AudioFileClip(FX_SOUND).set_duration(2.5)
-        transicion = ImageClip(WATERMARK).set_duration(2.5).resize(height=clips[0].h).set_position(("center", 0.1))
+        transicion = ImageClip(WATERMARK).set_duration(2.5)
+        
+        # Redimensionar la transición
+        transicion = transicion.resize(height=clips[0].h).set_position(("center", 0.1))
         
         clips_con_fx = []
         for i, clip in enumerate(clips):
@@ -94,19 +106,19 @@ def agregar_transiciones(clips):
             clip_watermarked = CompositeVideoClip([clip, transicion])
             clips_con_fx.append(clip_watermarked)
             
-            # Agregar transición entre clips
-            if i < len(clips)-1:
+            if i < len(clips) - 1:
                 clips_con_fx.append(
                     CompositeVideoClip([transicion.set_position("center")])
                     .set_audio(fx_audio)
                 )
+        logging.info("Transiciones agregadas correctamente.")
         return concatenate_videoclips(clips_con_fx)
     except Exception as e:
-        logging.error(f"Error en transiciones: {e}")
+        logging.error(f"Error al agregar transiciones: {e}")
         raise
 
 async def procesar_video(
-    video_input,
+    video_input, 
     texto_tts,
     voz_seleccionada,
     metodo_corte,
@@ -114,31 +126,36 @@ async def procesar_video(
 ):
     temp_files = []
     try:
+        logging.info("Iniciando procesamiento de video...")
         # Procesar video principal
         clips = cortar_video(video_input, metodo_corte, duracion_corte)
         video_editado = agregar_transiciones(clips)
         
-        # Agregar intro/outro
+        # Cargar intro y outro
         intro = VideoFileClip(INTRO_VIDEO)
         outro = VideoFileClip(OUTRO_VIDEO)
-        video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Calcular duración total para la música
-        duracion_total = video_final.duration
+        # Calcular duraciones
+        duracion_intro = intro.duration
+        duracion_video_editado = video_editado.duration
+        duracion_total = duracion_intro + duracion_video_editado + outro.duration
+        
+        # Concatenar intro, video editado y outro
+        video_final = concatenate_videoclips([intro, video_editado, outro])
         
-        # Generar audio (música en loop + TTS después de intro)
-        audio_mix_path = await procesar_audio(texto_tts, voz_seleccionada, duracion_total)
+        # Procesar audio
+        audio_final = await procesar_audio(texto_tts, voz_seleccionada, duracion_total, duracion_intro, duracion_video_editado)
         
-        # Combinar video y audio
-        video_final = video_final.set_audio(AudioFileClip(audio_mix_path))
+        # Combinar y renderizar
+        video_final = video_final.set_audio(audio_final)
         
-        # Renderizar
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_out:
-            video_final.write_videofile(tmp_out.name, codec="libx264", fps=24)
-            temp_files.append(tmp_out.name)
-            return tmp_out.name
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp:
+            video_final.write_videofile(tmp.name, codec="libx264", fps=24)
+            logging.info("Video procesado y guardado temporalmente.")
+            temp_files.append(tmp.name)
+            return tmp.name
     except Exception as e:
-        logging.error(f"Error general: {e}")
+        logging.error(f"Error durante el procesamiento: {e}")
         raise
     finally:
         # Eliminar archivos temporales
@@ -146,18 +163,19 @@ async def procesar_video(
             try:
                 if os.path.exists(file):
                     os.remove(file)
+                    logging.info(f"Archivo temporal eliminado: {file}")
             except Exception as e:
-                logging.warning(f"Error eliminando {file}: {e}")
+                logging.warning(f"No se pudo eliminar el archivo temporal {file}: {e}")
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Video Editor IA")
     
     with gr.Tab("Principal"):
-        video_input = gr.Video(label="Subir video")  # Solo un video
+        video_input = gr.Video(label="Subir video")
         texto_tts = gr.Textbox(label="Texto para TTS", lines=3)
         voz_seleccionada = gr.Dropdown(
-            label="Voz",
+            label="Seleccionar voz",
             choices=["es-ES-AlvaroNeural", "es-MX-BeatrizNeural"]
         )
         procesar_btn = gr.Button("Generar Video")
@@ -166,16 +184,26 @@ with gr.Blocks() as demo:
     with gr.Tab("Ajustes"):
         metodo_corte = gr.Radio(
             ["inteligente", "manual"],
-            label="Método de corte",
+            label="Método de cortes",
             value="inteligente"
         )
-        duracion_corte = gr.Slider(1, 60, 10, label="Duración por corte (solo manual)")
+        duracion_corte = gr.Slider(
+            1, 60, 10,
+            label="Segundos por corte (solo manual)"
+        )
 
     procesar_btn.click(
         procesar_video,
-        inputs=[video_input, texto_tts, voz_seleccionada, metodo_corte, duracion_corte],
+        inputs=[
+            video_input,
+            texto_tts,
+            voz_seleccionada,
+            metodo_corte,
+            duracion_corte
+        ],
         outputs=video_output
     )
 
 if __name__ == "__main__":
+    logging.info("Iniciando aplicación Gradio...")
     demo.queue().launch()