Update app.py

app.py

@@ -1,115 +1,86 @@
 import os
+import gradio as gr
 import requests
-import asyncio
 import tempfile
 import logging
 from datetime import datetime
 
-import gradio as gr
-from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
 import edge_tts
+import nest_asyncio
+import asyncio
 
 from transformers import pipeline
-import torch
+from moviepy.editor import AudioFileClip, VideoFileClip, concatenate_videoclips
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+nest_asyncio.apply()
 
-# --- CONFIG ---
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
-# Modelo de texto en español
-MODEL_NAME = "DeepESP/gpt2-spanish"
-
-# Inicializar generador de texto
-device = 0 if torch.cuda.is_available() else -1
-generator = pipeline("text-generation", model=MODEL_NAME, device=device)
+logger = logging.getLogger(__name__)
 
-async def listar_voces():
-    try:
-        return await edge_tts.list_voices()
-    except Exception as e:
-        logger.error(f"Error obteniendo voces: {e}")
-        return [{'ShortName': 'es-ES-ElviraNeural', 'Name': 'Elvira', 'Gender': 'Female'}]
+# Carga modelo
+generator = pipeline("text-generation", model="DeepESP/gpt2-spanish")
 
-VOCES = asyncio.run(listar_voces())
+# Cargar voces
+loop = asyncio.get_event_loop()
+VOCES = loop.run_until_complete(edge_tts.list_voices())
 VOICE_NAMES = [f"{v['Name']} ({v['Gender']})" for v in VOCES]
 
 def generar_guion(prompt):
-    prompt_text = f"Escribe un guion profesional para un vídeo de YouTube sobre '{prompt}':\n"
-    try:
-        out = generator(prompt_text, max_new_tokens=300, temperature=0.7, truncate=True, num_return_sequences=1)
-        texto = out[0]['generated_text']
-        return texto
-    except Exception as e:
-        logger.error(f"Error generando guion: {e}")
-        return f"Error generando guion: {e}"
+    prompt_text = f"Escribe un guion profesional de YouTube sobre '{prompt}':\n"
+    res = generator(prompt_text, max_new_tokens=300)[0]['generated_text']
+    return res.strip()
 
 def buscar_videos(prompt, max_videos=3):
+    headers = {"Authorization": PEXELS_API_KEY}
+    r = requests.get(f"https://api.pexels.com/videos/search?query={prompt}&per_page={max_videos}", headers=headers)
+    return r.json().get("videos", [])
+
+def crear_video(prompt, voz_nombre):
     try:
-        url = f"https://api.pexels.com/videos/search?query={prompt}&per_page={max_videos}"
-        resp = requests.get(url, headers={"Authorization": PEXELS_API_KEY}, timeout=10)
-        return resp.json().get("videos", [])
-    except Exception as e:
-        logger.error(f"Error en Pexels: {e}")
-        return []
-
-async def crear_video(prompt, voz_index, musica_path=None):
-    texto = generar_guion(prompt)
-    voz_short = VOCES[voz_index]['ShortName']
-    audio_file = "tts.mp3"
-    await edge_tts.Communicate(texto, voz_short).save(audio_file)
-    tts_audio = AudioFileClip(audio_file)
-    dur = tts_audio.duration
-
-    # Música opcional
-    if musica_path:
-        music = AudioFileClip(musica_path).volumex(0.2).subclip(0, dur)
-        audio_comp = CompositeAudioClip([music, tts_audio])
-    else:
-        audio_comp = tts_audio
+        idx = VOICE_NAMES.index(voz_nombre)
+    except:
+        idx = 0
 
-    videos = buscar_videos(prompt)
-    if not videos:
-        return None
+    voz_short = VOCES[idx]['ShortName']
+    guion = generar_guion(prompt)
+
+    # Guardar voz
+    tts = edge_tts.Communicate(guion, voz_short)
+    voz_path = "voz.mp3"
+    loop.run_until_complete(tts.save(voz_path))
+
+    audio_clip = AudioFileClip(voz_path)
+    duracion = audio_clip.duration
 
+    # Descargar videos
+    videos = buscar_videos(prompt)
     clips = []
     for v in videos:
         url = v['video_files'][0]['link']
-        r = requests.get(url, stream=True, timeout=15)
         tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-        [tmp.write(c) for c in r.iter_content(1024*1024)]
+        r = requests.get(url, stream=True)
+        for c in r.iter_content(1024*1024):
+            tmp.write(c)
         tmp.close()
-        clip = VideoFileClip(tmp.name).subclip(0, min(dur/len(videos), v['duration']))
+        clip = VideoFileClip(tmp.name).subclip(0, min(v['duration'], duracion / len(videos)))
         clips.append(clip)
 
-    final = concatenate_videoclips(clips).set_audio(audio_comp)
-    out_name = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-    final.write_videofile(out_name, codec="libx264", audio_codec="aac", fps=24)
-
-    # Cleanup
-    tts_audio.close()
-    for c in clips:
-        c.close()
-        os.remove(c.filename)
-    os.remove(audio_file)
+    final = concatenate_videoclips(clips).set_audio(audio_clip)
+    salida = f"video_{datetime.now().strftime('%H%M%S')}.mp4"
+    final.write_videofile(salida, fps=24)
 
-    return out_name
+    return salida
 
-def run_crear(prompt, voz_name, muz_file):
-    try:
-        idx = VOICE_NAMES.index(voz_name)
-    except:
-        idx = 0
-    return asyncio.run(crear_video(prompt, idx, muz_file.name if muz_file else None))
+def run(prompt, voz):
+    return crear_video(prompt, voz)
 
 with gr.Blocks() as app:
-    tema = gr.Textbox(label="Tema para guion y video")
-    voz = gr.Dropdown(choices=VOICE_NAMES, value=VOICE_NAMES[0], label="Voz TTS")
-    muz = gr.File(label="Música fondo opcional (mp3/wav)", file_types=[".mp3", ".wav"])
-    btn = gr.Button("Crear video")
-    vid_out = gr.Video(label="Video generado")
+    entrada = gr.Textbox(label="Tema del video")
+    voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
+    boton = gr.Button("Generar Video")
+    salida = gr.Video(label="Resultado")
 
-    btn.click(fn=run_crear, inputs=[tema, voz, muz], outputs=vid_out)
+    boton.click(fn=run, inputs=[entrada, voz], outputs=salida)
 
 if __name__ == "__main__":
-    app.launch()
+    app.launch(server_name="0.0.0.0", server_port=7860)