Update app.py

app.py

@@ -1,105 +1,87 @@
-import os
 import gradio as gr
-import requests
-import tempfile
-import asyncio
 import edge_tts
-from datetime import datetime
-from moviepy.editor import (
-    VideoFileClip, AudioFileClip, concatenate_videoclips,
-    CompositeAudioClip, afx
-)
-from transformers import pipeline
+import asyncio
+import os
 import logging
-import nest_asyncio
+import torch
+from transformers import pipeline, set_seed
+from moviepy.editor import *
+from dotenv import load_dotenv
 
-nest_asyncio.apply()
+# Configurar logs visibles en Hugging Face
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Cargar variables de entorno si hay .env
+load_dotenv()
 
-# Generador de texto real con GPT-2
-generador = pipeline("text-generation", model="gpt2")
+# Verificar si CUDA está disponible
+device = 0 if torch.cuda.is_available() else -1
 
-# Obtener voces
-async def get_voices():
-    return await edge_tts.list_voices()
+# Inicializar generador de texto
+generator = pipeline("text-generation", model="gpt2", device=device)
+set_seed(42)
 
-VOICES = asyncio.run(get_voices())
-VOICE_OPTIONS = [f"{v['Name']} ({v['Gender']}, {v['Locale']})" for v in VOICES]
-VOICE_MAP = {v['Name']: v['ShortName'] for v in VOICES}
+# 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)
 
-# Simulación de búsqueda de videos
-def buscar_videos_mock():
-    return [
-        "https://samplelib.com/lib/preview/mp4/sample-5s.mp4",
-        "https://samplelib.com/lib/preview/mp4/sample-10s.mp4"
-    ]
+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.")
 
-# Simulación de música de fondo
-def buscar_musica_mock():
-    return "https://samplelib.com/lib/preview/mp3/sample-3s.mp3"
+    # Guardar guion a texto plano
+    with open("guion.txt", "w") as f:
+        f.write(script)
 
-# Función principal
-async def generar_video(prompt, voz_str):
+    # Convertir texto a voz (bloqueo controlado)
+    output_audio = "voz.mp3"
     try:
-        logger.info("Generando guion...")
-        texto = generador(prompt, max_length=500, do_sample=True, truncation=True)[0]['generated_text']
-
-        logger.info("Convirtiendo texto en voz...")
-        voz_id = voz_str.split(" ")[0]
-        short_name = VOICE_MAP.get(voz_id, "es-ES-ElviraNeural")
-        voz_path = "voz.mp3"
-        await edge_tts.Communicate(text=texto, voice=short_name).save(voz_path)
-        voz_clip = AudioFileClip(voz_path)
-
-        logger.info("Descargando clips de video...")
-        video_urls = buscar_videos_mock()
-        clips = []
-        for url in video_urls:
-            r = requests.get(url, stream=True)
-            with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
-                for chunk in r.iter_content(1024 * 1024):
-                    f.write(chunk)
-                f.flush()
-                clip = VideoFileClip(f.name).subclip(0, 5)
-                clips.append(clip)
-
-        video = concatenate_videoclips(clips).set_audio(voz_clip)
-
-        logger.info("Descargando música de fondo...")
-        music_url = buscar_musica_mock()
-        r = requests.get(music_url, stream=True)
-        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as f:
-            for chunk in r.iter_content(1024 * 1024):
-                f.write(chunk)
-            f.flush()
-            music_clip = AudioFileClip(f.name)
-            music_loop = afx.audio_loop(music_clip, duration=video.duration).volumex(0.3)
-
-        logger.info("Combinando audio de voz y música...")
-        audio_final = CompositeAudioClip([video.audio, music_loop])
-        video = video.set_audio(audio_final)
-
-        output_path = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        logger.info("Renderizando video final...")
-        video.write_videofile(output_path, fps=24, logger=logger)
-
-        return output_path
+        asyncio.run(text_to_speech(script, output_audio))
+        logging.info("🎤 Voz generada.")
     except Exception as e:
-        logger.error(f"Error: {e}")
-        return f"Error: {e}"
-
-# Interfaz
+        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
+
+    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:
-    prompt = gr.Textbox(label="Tema del video", placeholder="Ejemplo: Top 5 misterios sin resolver")
-    voz = gr.Dropdown(VOICE_OPTIONS, label="Voz", value=VOICE_OPTIONS[0])
-    btn = gr.Button("Generar Video")
-    output = gr.Video(label="Resultado")
+    gr.Markdown("# 🎬 Generador de video IA + Voz + Música")
+    prompt = gr.Textbox(label="Prompt del guion")
+    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
 
-    btn.click(fn=lambda p, v: asyncio.run(generar_video(p, v)),
-              inputs=[prompt, voz],
-              outputs=output)
+    boton.click(ejecutar, inputs=prompt, outputs=[salida_video, salida_texto])
 
-if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+# Lanzar app
+app.launch(debug=True)