Update app.py

app.py

@@ -3,140 +3,123 @@ import requests
 import edge_tts
 import gradio as gr
 from moviepy.editor import *
-from moviepy.video.fx.all import resize, scroll
 from PIL import Image
 import io
 import asyncio
 import json
+from openai import OpenAI
 
-# 1. Descargar imágenes/videos de stock (Pexels)
-def get_stock_media(query, is_video=False):
-    API_KEY = os.getenv("PEXELS_API_KEY")  # Configurar en HF Secrets
-    if not API_KEY:
-        raise ValueError("¡Falta la API Key de Pexels! Añádela en los Secrets de Hugging Face.")
-    
-    url = f"https://api.pexels.com/v1/{'videos' if is_video else 'photos'}/search?query={query}&per_page=1"
-    headers = {"Authorization": API_KEY}
-    response = requests.get(url, headers=headers).json()
-    
-    if is_video:
-        video_url = response["videos"][0]["video_files"][0]["link"]
-        return requests.get(video_url).content
-    else:
-        image_url = response["photos"][0]["src"]["large"]
-        return Image.open(io.BytesIO(requests.get(image_url).content))
+# Configura APIs (gratis)
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))  # Para GPT-3.5-turbo
+PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
 
-# 2. Generar voz con Edge TTS
-async def generate_voice(text, voice="es-ES-AlvaroNeural", output_path="voice.mp3"):
-    communicate = edge_tts.Communicate(text=text, voice=voice)
-    await communicate.save(output_path)
-
-# 3. Añadir música de fondo (20% volumen, loop automático)
-def add_background_music(audio_clip, music_path=None, volume=0.2):
-    if not music_path:
-        return audio_clip
-    music = AudioFileClip(music_path).volumex(volume)
-    if music.duration < audio_clip.duration:
-        music = music.loop(duration=audio_clip.duration)
-    return CompositeAudioClip([audio_clip, music.set_start(0)])
+# 1. Generar guion automático con IA (si el usuario no proporciona uno)
+async def generate_script(topic):
+    prompt = f"""
+    Genera un guion para un video de YouTube sobre '{topic}'. 
+    Formato JSON ejemplo:
+    [
+        {{"prompt": "imagen de ejemplo", "text": "narración correspondiente"}},
+        ...
+    ]
+    """
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": prompt}],
+        temperature=0.7
+    )
+    return response.choices[0].message.content
 
-# 4. Efectos de movimiento/zoom para imágenes
-def apply_effects(clip, zoom_factor=1.05, effect_duration=2):
-    return clip.resize(zoom_factor).set_position('center').fx(scroll, h=50, w=50)
+# 2. Descargar imágenes de Pexels/Unsplash
+def get_stock_media(query):
+    url = f"https://api.pexels.com/v1/photos/search?query={query}&per_page=1"
+    headers = {"Authorization": PEXELS_API_KEY}
+    response = requests.get(url, headers=headers).json()
+    image_url = response["photos"][0]["src"]["large"]
+    return Image.open(io.BytesIO(requests.get(image_url).content))
 
-# 5. Subtítulos dinámicos (aparecen progresivamente)
-def generate_subtitles(text, duration, fontsize=30, color="white", stroke_color="black"):
-    words = text.split()
-    word_duration = duration / max(len(words), 1)  # Evitar división por cero
-    clips = []
-    for i, word in enumerate(words):
-        txt_clip = TextClip(
-            " ".join(words[:i+1]),
-            fontsize=fontsize,
-            color=color,
-            stroke_color=stroke_color,
-            font="Arial-Bold",
-            size=(None, None),
-            method="caption"
-        ).set_start(i * word_duration).set_duration(word_duration)
-        clips.append(txt_clip.set_position(("center", "bottom")))
-    return concatenate_videoclips(clips)
+# 3. Generar voz con Edge TTS
+async def generate_voice(text, voice="es-ES-AlvaroNeural"):
+    communicate = edge_tts.Communicate(text=text, voice=voice)
+    await communicate.save("voice.mp3")
+    return AudioFileClip("voice.mp3")
 
-# 6. Función principal
-async def generate_video(script_json, voice_model, music_file=None):
+# 4. Crear video final
+async def create_video(script_json, voice_model, music_file=None):
     try:
         script = json.loads(script_json)
     except json.JSONDecodeError:
-        raise gr.Error("¡Formato de script inválido! Usa JSON como en el ejemplo.")
-    
+        raise gr.Error("¡Error en el formato del guion! Usa JSON válido.")
+
     clips = []
     for i, scene in enumerate(script):
         img = get_stock_media(scene["prompt"])
-        img_path = f"scene_{i}.jpg"
-        img.save(img_path)
+        img.save(f"scene_{i}.jpg")
         
-        voice_path = f"voice_{i}.mp3"
-        await generate_voice(scene["text"], voice_model, voice_path)
+        audio = await generate_voice(scene["text"], voice_model)
+        clip = ImageClip(f"scene_{i}.jpg").set_duration(audio.duration)
         
-        audio = AudioFileClip(voice_path)
-        clip = ImageClip(img_path).set_duration(audio.duration)
-        clip = apply_effects(clip)
+        # Subtítulos dinámicos
+        text_clip = TextClip(
+            scene["text"],
+            fontsize=30,
+            color="white",
+            stroke_color="black",
+            size=(clip.w * 0.9, None),
+            method="caption"
+        ).set_position(("center", "bottom")).set_duration(audio.duration)
         
-        subtitles = generate_subtitles(scene["text"], audio.duration)
-        final_clip = CompositeVideoClip([clip, subtitles]).set_audio(audio)
-        clips.append(final_clip)
+        clips.append(CompositeVideoClip([clip, text_clip]).set_audio(audio))
     
     final_video = concatenate_videoclips(clips)
     if music_file:
-        final_video.audio = add_background_music(final_video.audio, music_file)
+        music = AudioFileClip(music_file).volumex(0.2)
+        final_video.audio = CompositeAudioClip([final_video.audio, music.set_start(0)])
     
     output_path = "final_video.mp4"
-    final_video.write_videofile(output_path, fps=24, codec="libx264", threads=4)
+    final_video.write_videofile(output_path, fps=24, codec="libx264")
     return output_path
 
-# 7. Interfaz Gradio
-def ui(script_json, voice_model, music_file=None):
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    try:
-        output_video = loop.run_until_complete(generate_video(script_json, voice_model, music_file))
-    except Exception as e:
-        raise gr.Error(f"Error: {str(e)}")
-    finally:
-        loop.close()
-    return output_video
-
-# Voces Edge TTS (puedes añadir más)
-voices = list(edge_tts.list_voices())
-
-with gr.Blocks(title="Generador de Videos con IA") as demo:
-    gr.Markdown("## 🎥 Generador de Videos con IA (Gratis)")
-    with gr.Row():
+# 5. Interfaz Gradio (2 modos: automático o manual)
+with gr.Blocks() as demo:
+    gr.Markdown("## 🎥 Generador de Videos con IA (Modo Automático o Manual)")
+    
+    with gr.Tab("Modo Automático"):
+        topic_input = gr.Textbox(label="Tema del video (ej: 'Top 10 misterios del mundo')")
+        auto_voice = gr.Dropdown(label="Voz", choices=["es-ES-AlvaroNeural", "en-US-JennyNeural"])
+        generate_auto_btn = gr.Button("Generar Guion y Video")
+    
+    with gr.Tab("Modo Manual"):
         script_input = gr.Textbox(
-            label="Script (JSON)",
-            placeholder='[{"prompt": "paisaje", "text": "Texto aquí..."}]',
-            lines=5
+            label="Pega tu guion (JSON)",
+            placeholder='[{"prompt": "ciudad futurista", "text": "Bienvenidos al futuro..."}]',
+            lines=10
         )
-    with gr.Row():
-        voice_dropdown = gr.Dropdown(choices=voices, label="Voz", value="es-ES-AlvaroNeural")
+        manual_voice = gr.Dropdown(label="Voz", choices=["es-ES-AlvaroNeural", "en-US-JennyNeural"])
         music_upload = gr.File(label="Música de fondo (opcional)", type="filepath")
-    generate_btn = gr.Button("Generar Video")
-    output_video = gr.Video(label="Resultado", format="mp4")
+        generate_manual_btn = gr.Button("Generar Video")
+    
+    output_video = gr.Video(label="Video Generado", format="mp4")
+    
+    # Modo Automático: Generar guion + video
+    async def auto_mode(topic, voice):
+        script = await generate_script(topic)
+        return await create_video(script, voice)
     
-    gr.Examples(
-        examples=[[
-            '[{"prompt": "ciudad futurista", "text": "Bienvenidos al futuro."}]',
-            "es-ES-AlvaroNeural",
-            None
-        ]],
-        inputs=[script_input, voice_dropdown, music_upload],
+    # Modo Manual: Usar guion existente
+    async def manual_mode(script, voice, music):
+        return await create_video(script, voice, music)
+    
+    generate_auto_btn.click(
+        fn=auto_mode,
+        inputs=[topic_input, auto_voice],
         outputs=output_video
     )
     
-    generate_btn.click(
-        fn=ui,
-        inputs=[script_input, voice_dropdown, music_upload],
-        outputs=output_video,
+    generate_manual_btn.click(
+        fn=manual_mode,
+        inputs=[script_input, manual_voice, music_upload],
+        outputs=output_video
     )
 
-demo.launch(debug=True)
+demo.launch()