Update app.py

app.py

@@ -1,113 +1,115 @@
-import gradio as gr
-import asyncio
-import edge_tts
+import os
 import requests
+import asyncio
 import tempfile
-import os
+import logging
 from datetime import datetime
+
+import gradio as gr
 from moviepy.editor import VideoFileClip, concatenate_videoclips, AudioFileClip, CompositeAudioClip
+import edge_tts
 
-# Voz predeterminada (puedes cambiarla o cargar lista)
-VOCES = [{'ShortName': 'es-ES-ElviraNeural', 'Name': 'Elvira', 'Gender': 'Female'}]
-VOICE_NAMES = [f"{v['Name']} ({v['Gender']})" for v in VOCES]
+from transformers import pipeline
+import torch
 
-# Simula función para generar texto según prompt
-def generar_texto(prompt):
-    # Aquí deberías integrar tu generador real, por ahora solo repetimos prompt
-    return f"Este es un texto generado para el tema: {prompt}"
-
-# Simula función para buscar videos (debes conectar con Pexels u otra API)
-def buscar_videos(prompt):
-    # Retorna lista simulada con links a videos (debes poner tu API real)
-    return [
-        {
-            "video_files": [{"link": "https://filesamples.com/samples/video/mp4/sample_640x360.mp4"}],
-            "duration": 10
-        },
-        {
-            "video_files": [{"link": "https://filesamples.com/samples/video/mp4/sample_640x360.mp4"}],
-            "duration": 10
-        }
-    ]
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-async def crear_video(prompt, voz_index, musica_path=None):
-    try:
-        texto = generar_texto(prompt)
-        voz_shortname = VOCES[voz_index]['ShortName']
-
-        # Generar audio TTS
-        archivo_audio = "audio.mp3"
-        await edge_tts.Communicate(texto, voz_shortname).save(archivo_audio)
-        audio_clip = AudioFileClip(archivo_audio)
-        duracion_audio = audio_clip.duration
-
-        # Cargar música si se pasa
-        if musica_path:
-            musica_clip = AudioFileClip(musica_path).volumex(0.2)  # Volumen bajo para música
-            musica_clip = musica_clip.subclip(0, duracion_audio)
-            audio_final = CompositeAudioClip([musica_clip, audio_clip])
-        else:
-            audio_final = audio_clip
-
-        # Descargar y preparar videos
-        videos = buscar_videos(prompt)
-        if not videos:
-            return None
-
-        clips = []
-        for v in videos[:3]:
-            video_url = v['video_files'][0]['link']
-            response = requests.get(video_url, stream=True)
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
-            for chunk in response.iter_content(chunk_size=1024*1024):
-                temp_file.write(chunk)
-            temp_file.close()
-
-            clip = VideoFileClip(temp_file.name).subclip(0, min(duracion_audio/len(videos), v['duration']))
-            clips.append(clip)
-
-        video_final = concatenate_videoclips(clips)
-        video_final = video_final.set_audio(audio_final)
-
-        output_filename = f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
-        video_final.write_videofile(output_filename, codec="libx264", audio_codec="aac", fps=24)
-
-        # Limpieza
-        audio_clip.close()
-        if musica_path:
-            musica_clip.close()
-        for c in clips:
-            c.close()
-            os.remove(c.filename)
-        os.remove(archivo_audio)
-
-        return output_filename
+# --- CONFIG ---
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+# Modelo de texto en español
+MODEL_NAME = "DeepESP/gpt2-spanish"
 
-    except Exception as e:
-        return f"Error: {e}"
+# Inicializar generador de texto
+device = 0 if torch.cuda.is_available() else -1
+generator = pipeline("text-generation", model=MODEL_NAME, device=device)
 
-def run_crear_video(prompt, voz_nombre, musica_file):
+async def listar_voces():
     try:
-        voz_index = VOICE_NAMES.index(voz_nombre)
-    except ValueError:
-        voz_index = 0
+        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'}]
 
-    musica_path = musica_file.name if musica_file else None
-    return asyncio.run(crear_video(prompt, voz_index, musica_path))
+VOCES = asyncio.run(listar_voces())
+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}"
 
-with gr.Blocks(title="Generador de Video con TTS y Música de Fondo") as demo:
-    with gr.Row():
-        with gr.Column():
-            prompt = gr.Textbox(label="Tema del video", lines=2)
-            voz = gr.Dropdown(VOICE_NAMES, label="Voz", value=VOICE_NAMES[0])
-            musica = gr.File(label="Sube música de fondo (opcional, mp3/wav)", file_types=[".mp3", ".wav"])
-            btn = gr.Button("Generar Video")
-        with gr.Column():
-            salida = gr.Video(label="Video generado")
+def buscar_videos(prompt, max_videos=3):
+    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
+
+    videos = buscar_videos(prompt)
+    if not videos:
+        return None
+
+    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)]
+        tmp.close()
+        clip = VideoFileClip(tmp.name).subclip(0, min(dur/len(videos), v['duration']))
+        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)
+
+    return out_name
+
+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))
 
-    btn.click(run_crear_video, inputs=[prompt, voz, musica], outputs=salida)
+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")
 
+    btn.click(fn=run_crear, inputs=[tema, voz, muz], outputs=vid_out)
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch()