Update app.py

app.py

@@ -3,19 +3,22 @@ import requests
 import edge_tts
 import gradio as gr
 from moviepy.editor import *
-from moviepy.editor import AudioFileClip, CompositeVideoClip, concatenate_videoclips, ImageClip, TextClip
 from moviepy.video.fx.all import resize, scroll
 from PIL import Image
-import numpy as np
 import io
 import asyncio
+import json
 
 # 1. Descargar imágenes/videos de stock (Pexels)
 def get_stock_media(query, is_video=False):
-    API_KEY = os.getenv("PEXELS_API_KEY")  # Configura esto en HF Secrets
+    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
@@ -23,26 +26,28 @@ def get_stock_media(query, is_video=False):
         image_url = response["photos"][0]["src"]["large"]
         return Image.open(io.BytesIO(requests.get(image_url).content))
 
-# 2. Generar voz con Edge TTS (todos los modelos)
+# 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 (en loop si es necesario)
-def add_background_music(audio_clip, music_path="background.mp3", volume=0.2):
+# 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)])
 
 # 4. Efectos de movimiento/zoom para imágenes
-def apply_effects(clip, zoom_factor=1.1, effect_duration=2):
-    return clip.resize(zoom_factor).set_position('center').fx(vfx.scroll, h=100, w=100)
+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)
 
-# 5. Crear subtítulos dinámicos (karaoke-style)
+# 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 / len(words)
+    word_duration = duration / max(len(words), 1)  # Evitar división por cero
     clips = []
     for i, word in enumerate(words):
         txt_clip = TextClip(
@@ -51,58 +56,82 @@ def generate_subtitles(text, duration, fontsize=30, color="white", stroke_color=
             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)
-    return concatenate_videoclips(clips).set_position(("center", "bottom"))
+        clips.append(txt_clip.set_position(("center", "bottom")))
+    return concatenate_videoclips(clips)
 
-# 6. Función principal para generar el video
-async def generate_video(script, voice_model, music_file=None):
+# 6. Función principal
+async def generate_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.")
+    
     clips = []
     for i, scene in enumerate(script):
-        # Descargar imagen y generar voz
         img = get_stock_media(scene["prompt"])
-        img.save(f"scene_{i}.jpg")
-        await generate_voice(scene["text"], voice_model, f"voice_{i}.mp3")
+        img_path = f"scene_{i}.jpg"
+        img.save(img_path)
+        
+        voice_path = f"voice_{i}.mp3"
+        await generate_voice(scene["text"], voice_model, voice_path)
         
-        # Crear clip con efectos
-        audio = AudioFileClip(f"voice_{i}.mp3")
-        clip = ImageClip(f"scene_{i}.jpg").set_duration(audio.duration)
-        clip = apply_effects(clip)  # Efecto de zoom/movimiento
+        audio = AudioFileClip(voice_path)
+        clip = ImageClip(img_path).set_duration(audio.duration)
+        clip = apply_effects(clip)
         
-        # Subtítulos dinámicos
         subtitles = generate_subtitles(scene["text"], audio.duration)
         final_clip = CompositeVideoClip([clip, subtitles]).set_audio(audio)
         clips.append(final_clip)
     
-    # Unir clips y añadir música
     final_video = concatenate_videoclips(clips)
     if music_file:
-        final_video.audio = add_background_music(final_video.audio, music_file.name)
+        final_video.audio = add_background_music(final_video.audio, music_file)
     
-    # Exportar
     output_path = "final_video.mp4"
-    final_video.write_videofile(output_path, fps=24, codec="libx264")
+    final_video.write_videofile(output_path, fps=24, codec="libx264", threads=4)
     return output_path
 
 # 7. Interfaz Gradio
-def ui(script, voice_model, music_file):
+def ui(script_json, voice_model, music_file=None):
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
-    output_video = loop.run_until_complete(generate_video(script, voice_model, music_file))
+    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
 
-# Lista de voces Edge TTS (ejemplo)
-voices = ["es-ES-AlvaroNeural", "es-MX-DaliaNeural", "en-US-JennyNeural", "fr-FR-HenriNeural"]
+# Voces Edge TTS (puedes añadir más)
+voices = list(edge_tts.list_voices())
 
-# Diseño de la interfaz
-with gr.Blocks() as demo:
-    gr.Markdown("## 🎬 Generador de Videos con IA (100% Gratis)")
+with gr.Blocks(title="Generador de Videos con IA") as demo:
+    gr.Markdown("## 🎥 Generador de Videos con IA (Gratis)")
     with gr.Row():
-        script_input = gr.Textbox(label="Script (JSON)", placeholder='[{"prompt": "futuristic city", "text": "Texto aquí..."}]')
-        voice_dropdown = gr.Dropdown(choices=voices, label="Voz Edge TTS", value="es-ES-AlvaroNeural")
-        music_upload = gr.File(label="Música de fondo (opcional)", type="file")
+        script_input = gr.Textbox(
+            label="Script (JSON)",
+            placeholder='[{"prompt": "paisaje", "text": "Texto aquí..."}]',
+            lines=5
+        )
+    with gr.Row():
+        voice_dropdown = gr.Dropdown(choices=voices, label="Voz", value="es-ES-AlvaroNeural")
+        music_upload = gr.File(label="Música de fondo (opcional)", type="filepath")
     generate_btn = gr.Button("Generar Video")
-    output_video = gr.Video(label="Video Generado")
+    output_video = gr.Video(label="Resultado", format="mp4")
+    
+    gr.Examples(
+        examples=[[
+            '[{"prompt": "ciudad futurista", "text": "Bienvenidos al futuro."}]',
+            "es-ES-AlvaroNeural",
+            None
+        ]],
+        inputs=[script_input, voice_dropdown, music_upload],
+        outputs=output_video
+    )
     
     generate_btn.click(
         fn=ui,
@@ -110,4 +139,4 @@ with gr.Blocks() as demo:
         outputs=output_video,
     )
 
-demo.launch()
+demo.launch(debug=True)