Update app.py

app.py

@@ -1,87 +1,134 @@
-import gradio as gr
-import edge_tts
-import asyncio
 import os
+import asyncio
 import logging
-import torch
-from transformers import pipeline, set_seed
-from moviepy.editor import *
-from dotenv import load_dotenv
-
-# Configurar logs visibles en Hugging Face
-logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+import tempfile
+import requests
+from datetime import datetime
+from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip, afx
+import edge_tts
+import gradio as gr
 
-# Cargar variables de entorno si hay .env
-load_dotenv()
+from transformers import GPT2Tokenizer, GPT2LMHeadModel
+import torch
 
-# Verificar si CUDA está disponible
-device = 0 if torch.cuda.is_available() else -1
+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"
+    ]
+    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
 
-# Inicializar generador de texto
-generator = pipeline("text-generation", model="gpt2", device=device)
-set_seed(42)
+    # 7. Asignar audio al video
+    video_final = video_final.set_audio(mezcla).subclip(0, audio_tts.duration)
 
-# Asíncrono: convertir texto a voz con edge-tts
-async def text_to_speech(text, output_path, voice="es-MX-DaliaNeural"):
-    tts = edge_tts.Communicate(text=text, voice=voice)
-    await tts.save(output_path)
+    # 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)
 
-def generate_video(prompt, background_music_path="musica.mp3"):
-    logging.info("🚀 Generando guion con IA...")
-    result = generator(prompt, max_length=500, do_sample=True, truncation=True)
-    script = result[0]['generated_text']
-    logging.info("🗣 Guion generado.")
+    # 9. Limpiar archivos temporales
+    os.remove(voz_archivo)
+    for clip in clips:
+        clip.close()
 
-    # Guardar guion a texto plano
-    with open("guion.txt", "w") as f:
-        f.write(script)
+    return output_path
 
-    # Convertir texto a voz (bloqueo controlado)
-    output_audio = "voz.mp3"
+def run_app(prompt, musica_url):
+    logger.info(f"Entrada recibida: {prompt}")
     try:
-        asyncio.run(text_to_speech(script, output_audio))
-        logging.info("🎤 Voz generada.")
+        video_path = crear_video(prompt, musica_url if musica_url.strip() else None)
+        logger.info(f"Video generado en: {video_path}")
+        return video_path
     except Exception as e:
-        logging.error(f"❌ Error generando voz: {e}")
-        return None, script
-
-    # Cargar clip de voz
-    voice_clip = AudioFileClip(output_audio)
-    duration = voice_clip.duration
-
-    # Video negro (fondo) + voz
-    video = ColorClip(size=(1280, 720), color=(0, 0, 0), duration=duration)
-
-    # Música en loop si es más corta que la voz
-    if os.path.exists(background_music_path):
-        music = AudioFileClip(background_music_path)
-        if music.duration < duration:
-            loops = int(duration // music.duration) + 1
-            music = concatenate_audioclips([music] * loops)
-        music = music.subclip(0, duration)
-        final_audio = CompositeAudioClip([music.volumex(0.2), voice_clip])
-    else:
-        final_audio = voice_clip
+        logger.error(f"Error durante la generación: {e}")
+        return None
 
-    video = video.set_audio(final_audio)
-    output_path = "video_generado.mp4"
-    video.write_videofile(output_path, fps=24, codec="libx264", audio_codec="aac")
-
-    return output_path, script
-
-# Interfaz de Gradio
 with gr.Blocks() as app:
-    gr.Markdown("# 🎬 Generador de video IA + Voz + Música")
-    prompt = gr.Textbox(label="Prompt del guion")
+    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_video = gr.Video()
-    salida_texto = gr.Textbox(label="Guion generado")
-
-    def ejecutar(prompt):
-        video, script = generate_video(prompt)
-        return video, script
+    salida = gr.Video(label="Video generado")
 
-    boton.click(ejecutar, inputs=prompt, outputs=[salida_video, salida_texto])
+    boton.click(run_app, inputs=[prompt_input, musica_input], outputs=salida)
 
-# Lanzar app
-app.launch(debug=True)
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860)