Update app.py

app.py

@@ -2,133 +2,243 @@ import os
 import asyncio
 import logging
 import tempfile
-import requests
-from datetime import datetime
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, afx
+import time
+import shutil
+from datetime import datetime, timedelta
+from moviepy.editor import VideoFileClip, AudioFileClip, CompositeAudioClip, ColorClip, TextClip, CompositeVideoClip
 import edge_tts
 import gradio as gr
 
-from transformers import GPT2Tokenizer, GPT2LMHeadModel
-import torch
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Inicializa tokenizer y modelo (puedes cambiar modelo si quieres)
-tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
-model = GPT2LMHeadModel.from_pretrained("gpt2").eval()
-
-def generate_script(prompt, max_length=300):
-    logger.info("Generando guion...")
-    inputs = tokenizer(prompt, return_tensors="pt", truncation=False)
-    with torch.no_grad():
-        outputs = model.generate(
-            **inputs,
-            max_length=max_length,
-            do_sample=True,
-            top_p=0.95,
-            top_k=60,
-            temperature=0.9,
-            pad_token_id=tokenizer.eos_token_id
-        )
-    text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    logger.info(f"Guion generado, longitud: {len(text)} caracteres")
-    return text
-
-async def text_to_speech(text, voice="es-ES-ElviraNeural", output_path="voz.mp3"):
-    logger.info("Generando audio TTS...")
-    communicate = edge_tts.Communicate(text, voice)
-    await communicate.save(output_path)
-    logger.info(f"Audio guardado en {output_path}")
-
-def download_video_sample(url):
-    logger.info(f"Descargando video de ejemplo: {url}")
-    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-    response = requests.get(url, stream=True)
-    for chunk in response.iter_content(chunk_size=1024*1024):
-        tmp.write(chunk)
-    tmp.close()
-    return tmp.name
-
-def loop_audio_to_length(audio_clip, target_duration):
-    if audio_clip.duration >= target_duration:
-        return audio_clip.subclip(0, target_duration)
-    loops = int(target_duration // audio_clip.duration) + 1
-    audios = [audio_clip] * loops
-    concatenated = concatenate_videoclips(audios, method="compose")
-    return concatenated.subclip(0, target_duration)
-
-def crear_video(prompt, musica_url=None):
-    # 1. Generar guion
-    guion = generate_script(prompt, max_length=300)
-
-    # 2. TTS
-    voz_archivo = "voz.mp3"
-    asyncio.run(text_to_speech(guion, output_path=voz_archivo))
-
-    # 3. Descargar videos de ejemplo (puedes reemplazar por tu búsqueda real)
-    # Aquí pongo 3 clips de ejemplo (deberías poner tus URLs)
-    video_urls = [
-        "https://sample-videos.com/video123/mp4/240/big_buck_bunny_240p_1mb.mp4",
-        "https://sample-videos.com/video123/mp4/240/big_buck_bunny_240p_1mb.mp4",
-        "https://sample-videos.com/video123/mp4/240/big_buck_bunny_240p_1mb.mp4"
+# Configuración avanzada de logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("video_generator.log"),
+        logging.StreamHandler()
     ]
-    clips = []
-    for url in video_urls[:3]:
-        video_path = download_video_sample(url)
-        clip = VideoFileClip(video_path).subclip(0, 10)  # máximo 10 segundos
-        clips.append(clip)
-
-    # 4. Concatenar videos
-    video_final = concatenate_videoclips(clips, method="compose")
-
-    # 5. Cargar audio TTS
-    audio_tts = AudioFileClip(voz_archivo)
-
-    # 6. Música de fondo en loop si está definida
-    if musica_url:
-        musica_path = download_video_sample(musica_url)
-        musica_audio = AudioFileClip(musica_path)
-        # Loop música a duración voz
-        musica_loop = loop_audio_to_length(musica_audio, audio_tts.duration)
-        # Mezclar audio TTS y música
-        mezcla = CompositeAudioClip([musica_loop.volumex(0.3), audio_tts.volumex(1.0)])
-    else:
-        mezcla = audio_tts
-
-    # 7. Asignar audio al video
-    video_final = video_final.set_audio(mezcla).subclip(0, audio_tts.duration)
-
-    # 8. Guardar video final
-    output_path = f"video_output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-    video_final.write_videofile(output_path, fps=24, threads=2, logger=None)
-
-    # 9. Limpiar archivos temporales
-    os.remove(voz_archivo)
-    for clip in clips:
-        clip.close()
+)
+logger = logging.getLogger(__name__)
 
-    return output_path
+# Directorio temporal personalizado con limpieza automática
+TEMP_DIR = "temp_media"
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+def clean_old_files():
+    """Elimina archivos temporales con más de 24 horas"""
+    now = time.time()
+    cutoff = now - (24 * 3600)
+    
+    for filename in os.listdir(TEMP_DIR):
+        file_path = os.path.join(TEMP_DIR, filename)
+        if os.path.isfile(file_path):
+            file_time = os.path.getmtime(file_path)
+            if file_time < cutoff:
+                try:
+                    os.remove(file_path)
+                    logger.info(f"Eliminado archivo antiguo: {filename}")
+                except Exception as e:
+                    logger.error(f"Error al eliminar {filename}: {e}")
+
+async def text_to_speech(text, voice="es-ES-ElviraNeural"):
+    """Convierte texto a voz y guarda en archivo temporal"""
+    clean_old_files()
+    output_path = os.path.join(TEMP_DIR, f"tts_{datetime.now().strftime('%Y%m%d%H%M%S')}.mp3")
+    
+    try:
+        logger.info(f"Generando TTS para texto de {len(text)} caracteres")
+        communicate = edge_tts.Communicate(text, voice)
+        await communicate.save(output_path)
+        return output_path
+    except Exception as e:
+        logger.error(f"Error en TTS: {e}")
+        raise
 
-def run_app(prompt, musica_url):
-    logger.info(f"Entrada recibida: {prompt}")
+def create_audio_loop(audio_path, target_duration):
+    """Crea un loop de audio hasta alcanzar la duración objetivo"""
     try:
-        video_path = crear_video(prompt, musica_url if musica_url.strip() else None)
-        logger.info(f"Video generado en: {video_path}")
-        return video_path
+        audio = AudioFileClip(audio_path)
+        if audio.duration >= target_duration:
+            return audio.subclip(0, target_duration)
+        
+        loops_needed = int(target_duration // audio.duration) + 1
+        clips = [audio] * loops_needed
+        looped_audio = concatenate_audioclips(clips).subclip(0, target_duration)
+        return looped_audio
     except Exception as e:
-        logger.error(f"Error durante la generación: {e}")
-        return None
+        logger.error(f"Error al crear loop de audio: {e}")
+        raise
 
-with gr.Blocks() as app:
-    gr.Markdown("### Generador simple de video con texto, voz y música en loop")
-    with gr.Row():
-        prompt_input = gr.Textbox(label="Introduce el tema para generar el guion", lines=2)
-        musica_input = gr.Textbox(label="URL de música (opcional) para usar de fondo")
-    boton = gr.Button("Generar video")
-    salida = gr.Video(label="Video generado")
+def create_video_with_text(text, duration, size=(1280, 720)):
+    """Crea un video simple con texto centrado"""
+    try:
+        # Fondo del video
+        bg_clip = ColorClip(size, color=(30, 30, 30), duration=duration)
+        
+        # Texto con ajuste automático de tamaño
+        text_clip = TextClip(
+            text,
+            fontsize=28,
+            color='white',
+            font='Arial-Bold',
+            size=(size[0]-100, size[1]-100),
+            method='caption',
+            align='center'
+        ).set_position('center').set_duration(duration)
+        
+        return CompositeVideoClip([bg_clip, text_clip])
+    except Exception as e:
+        logger.error(f"Error al crear video con texto: {e}")
+        raise
 
-    boton.click(run_app, inputs=[prompt_input, musica_input], outputs=salida)
+async def generate_video_content(text, background_music=None, use_tts=True):
+    """Función principal que genera el contenido del video"""
+    try:
+        clean_old_files()
+        
+        # 1. Procesar audio principal
+        if use_tts:
+            voice_path = await text_to_speech(text)
+            main_audio = AudioFileClip(voice_path)
+        else:
+            # Si no usamos TTS, creamos un audio silencioso de la duración estimada
+            estimated_duration = max(5, len(text.split()) / 3)  # Estimación basada en palabras
+            main_audio = AudioFileClip(lambda t: 0, duration=estimated_duration)
+        
+        duration = main_audio.duration
+        
+        # 2. Procesar música de fondo
+        final_audio = main_audio
+        if background_music:
+            try:
+                bg_music_loop = create_audio_loop(background_music, duration).volumex(0.2)
+                final_audio = CompositeAudioClip([bg_music_loop, main_audio])
+            except Exception as e:
+                logger.error(f"Error al procesar música de fondo, continuando sin ella: {e}")
+        
+        # 3. Crear video
+        video_clip = create_video_with_text(text, duration)
+        video_clip = video_clip.set_audio(final_audio)
+        
+        # 4. Guardar resultado
+        output_path = os.path.join(TEMP_DIR, f"video_{datetime.now().strftime('%Y%m%d%H%M%S')}.mp4")
+        video_clip.write_videofile(
+            output_path,
+            fps=24,
+            threads=4,
+            codec='libx264',
+            audio_codec='aac',
+            preset='fast',
+            logger=None
+        )
+        
+        return output_path
+    except Exception as e:
+        logger.error(f"Error en generate_video_content: {e}")
+        raise
+    finally:
+        # Cerrar todos los clips para liberar recursos
+        if 'main_audio' in locals():
+            main_audio.close()
+        if 'bg_music_loop' in locals():
+            bg_music_loop.close()
+        if 'video_clip' in locals():
+            video_clip.close()
+
+# Interfaz Gradio mejorada
+with gr.Blocks(title="Generador de Videos Avanzado", theme="soft") as app:
+    gr.Markdown("""
+    # 🎥 Generador de Videos Automático
+    Crea videos con voz sintetizada y música de fondo
+    """)
+    
+    with gr.Tab("Configuración Principal"):
+        with gr.Row():
+            with gr.Column():
+                text_input = gr.Textbox(
+                    label="Texto del Video",
+                    placeholder="Escribe aquí el contenido de tu video...",
+                    lines=5,
+                    max_lines=20
+                )
+                
+                with gr.Accordion("Opciones Avanzadas", open=False):
+                    use_tts = gr.Checkbox(
+                        label="Usar Texto a Voz (TTS)",
+                        value=True
+                    )
+                    voice_selector = gr.Dropdown(
+                        label="Voz TTS",
+                        choices=["es-ES-ElviraNeural", "es-MX-DaliaNeural", "es-US-AlonsoNeural"],
+                        value="es-ES-ElviraNeural",
+                        visible=True
+                    )
+                    
+                    bg_music = gr.Audio(
+                        label="Música de Fondo",
+                        type="filepath",
+                        sources=["upload"],
+                        format="mp3"
+                    )
+                
+                generate_btn = gr.Button("Generar Video", variant="primary")
+            
+            with gr.Column():
+                video_output = gr.Video(
+                    label="Video Resultante",
+                    format="mp4",
+                    interactive=False
+                )
+                status_output = gr.Textbox(
+                    label="Estado",
+                    interactive=False
+                )
+    
+    # Lógica para mostrar/ocultar selector de voz
+    use_tts.change(
+        fn=lambda x: gr.Dropdown(visible=x),
+        inputs=use_tts,
+        outputs=voice_selector
+    )
+    
+    # Función principal de generación
+    def generate_video(text, use_tts, voice, bg_music):
+        try:
+            if not text.strip():
+                raise ValueError("Por favor ingresa un texto para el video")
+            
+            # Limpieza inicial
+            clean_old_files()
+            
+            # Generación del video
+            video_path = asyncio.run(
+                generate_video_content(
+                    text=text,
+                    use_tts=use_tts,
+                    background_music=bg_music
+                )
+            )
+            
+            return video_path, "✅ Video generado con éxito"
+        except Exception as e:
+            logger.error(f"Error en la generación: {str(e)}")
+            return None, f"❌ Error: {str(e)}"
+    
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[text_input, use_tts, voice_selector, bg_music],
+        outputs=[video_output, status_output]
+    )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    # Limpieza inicial de archivos antiguos
+    clean_old_files()
+    
+    # Configuración del servidor
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False,
+        favicon_path=None
+    )