Update app.py

app.py

@@ -17,17 +17,23 @@ logger = logging.getLogger(__name__)
 
 # Pexels API key from environment variable
 PEXELS_API_KEY = os.getenv("PEXELS_API_KEY")
+if not PEXELS_API_KEY:
+    logger.error("PEXELS_API_KEY no encontrada en variables de entorno")
 logger.info("Loaded PEXELS_API_KEY from environment")
 
 # Ensure asyncio works with Gradio
 def run_async(coro):
     logger.info("Running async coroutine")
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    result = loop.run_until_complete(coro)
-    loop.close()
-    logger.info("Async coroutine completed")
-    return result
+    try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(coro)
+        loop.close()
+        logger.info("Async coroutine completed")
+        return result
+    except Exception as e:
+        logger.error(f"Error en run_async: {e}")
+        return None
 
 # Load lightweight text generation model for Spanish
 logger.info("Loading text generation model: facebook/mbart-large-50")
@@ -57,21 +63,24 @@ def fetch_pexels_videos(query, num_videos=5):
     logger.info(f"Fetching {num_videos} videos from Pexels with query: {query}")
     headers = {"Authorization": PEXELS_API_KEY}
     url = f"https://api.pexels.com/videos/search?query={query}&per_page={num_videos}"
-    response = requests.get(url, headers=headers)
-    if response.status_code == 200:
-        videos = [video["video_files"][0]["link"] for video in response.json()["videos"]]
-        logger.info(f"Fetched {len(videos)} videos from Pexels")
-        return videos
-    logger.error("Failed to fetch videos from Pexels")
+    try:
+        response = requests.get(url, headers=headers)
+        if response.status_code == 200:
+            videos = [video["video_files"][0]["link"] for video in response.json()["videos"]]
+            logger.info(f"Fetched {len(videos)} videos from Pexels")
+            return videos
+        logger.error(f"Failed to fetch videos from Pexels. Status code: {response.status_code}")
+    except Exception as e:
+        logger.error(f"Error fetching videos from Pexels: {e}")
     return []
 
 # Generate script using local model or custom text
 def generate_script(prompt, custom_text=None):
     logger.info("Generating script")
-    if custom_text:
+    if custom_text and custom_text.strip():
         logger.info("Using custom text provided by user")
         return custom_text.strip()
-    if not prompt:
+    if not prompt or not prompt.strip():
         logger.error("No prompt or custom text provided")
         return "Error: Debes proporcionar un prompt o un guion personalizado."
     
@@ -105,34 +114,68 @@ def generate_script(prompt, custom_text=None):
 
 # Generate voice using Edge TTS
 async def generate_voice(text, output_file="output.mp3"):
-    logger.info(f"Generating voice with Edge TTS using voice: es-MX-DaliaNeural")
+    if not text or len(text.strip()) < 10:
+        logger.error("Texto demasiado corto para generar voz")
+        return None
+        
+    logger.info(f"Generating voice with Edge TTS")
     try:
-        communicate = edge_tts.Communicate(text, voice="es-MX-DaliaNeural")
+        # Seleccionar una voz aleatoria
+        voice = random.choice(SPANISH_VOICES)
+        logger.info(f"Using voice: {voice}")
+        
+        communicate = edge_tts.Communicate(text, voice=voice)
         await communicate.save(output_file)
         logger.info(f"Voice generated and saved to {output_file}")
         return output_file
     except Exception as e:
         logger.error(f"Error generating voice: {e}")
+        # Intentar con otra voz si falla
+        for voice in SPANISH_VOICES:
+            try:
+                logger.info(f"Trying with voice: {voice}")
+                communicate = edge_tts.Communicate(text, voice=voice)
+                await communicate.save(output_file)
+                logger.info(f"Voice generated with backup voice {voice}")
+                return output_file
+            except:
+                continue
+        logger.error("All voice attempts failed")
         return None
 
 # Download and trim video
 def download_and_trim_video(url, duration, output_path):
     logger.info(f"Downloading video from {url}")
-    response = requests.get(url, stream=True)
-    with open("temp_video.mp4", "wb") as f:
-        for chunk in response.iter_content(chunk_size=1024):
-            f.write(chunk)
-    logger.info("Trimming video")
-    clip = VideoFileClip("temp_video.mp4").subclip(0, min(duration, VideoFileClip("temp_video.mp4").duration))
-    clip.write_videofile(output_path, codec="libx264", audio_codec="aac")
-    clip.close()
-    os.remove("temp_video.mp4")
-    logger.info(f"Video trimmed and saved to {output_path}")
-    return output_path
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        
+        with open("temp_video.mp4", "wb") as f:
+            for chunk in response.iter_content(chunk_size=1024):
+                f.write(chunk)
+                
+        logger.info("Trimming video")
+        clip = VideoFileClip("temp_video.mp4")
+        clip_duration = min(duration, clip.duration)
+        clip = clip.subclip(0, clip_duration)
+        clip.write_videofile(output_path, codec="libx264", audio_codec="aac", threads=4)
+        clip.close()
+        os.remove("temp_video.mp4")
+        logger.info(f"Video trimmed and saved to {output_path}")
+        return output_path
+    except Exception as e:
+        logger.error(f"Error downloading/trimming video: {e}")
+        return None
 
 # Main video creation function
 def create_video(prompt, custom_text, music_file):
     logger.info("Starting video creation process")
+    
+    # Validar inputs
+    if not prompt and not custom_text:
+        logger.error("No prompt or custom text provided")
+        return "Error: Debes proporcionar un prompt o un guion personalizado."
+        
     output_dir = "output_videos"
     os.makedirs(output_dir, exist_ok=True)
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
@@ -147,13 +190,19 @@ def create_video(prompt, custom_text, music_file):
 
     # Generate voice
     voice_file = "temp_audio.mp3"
-    run_async(generate_voice(script, voice_file))
-    if not os.path.exists(voice_file):
+    voice_result = run_async(generate_voice(script, voice_file))
+    
+    if not voice_result or not os.path.exists(voice_file):
         logger.error("Voice generation failed")
-        return "Error: No se pudo generar la voz."
-    audio = AudioFileClip(voice_file)
-    video_duration = audio.duration
-    logger.info(f"Audio duration: {video_duration} seconds")
+        return "Error: No se pudo generar la voz. Intenta con un texto diferente."
+        
+    try:
+        audio = AudioFileClip(voice_file)
+        video_duration = audio.duration
+        logger.info(f"Audio duration: {video_duration} seconds")
+    except Exception as e:
+        logger.error(f"Error loading audio file: {e}")
+        return "Error: El archivo de audio generado es inválido."
 
     # Fetch Pexels videos
     query = prompt.split()[0] if prompt else "generic"
@@ -166,52 +215,122 @@ def create_video(prompt, custom_text, music_file):
     clips = []
     for i, url in enumerate(video_urls):
         clip_path = f"temp_clip_{i}.mp4"
-        download_and_trim_video(url, video_duration / len(video_urls), clip_path)
-        clips.append(VideoFileClip(clip_path))
-        logger.info(f"Processed video clip {i+1}/{len(video_urls)}")
+        result = download_and_trim_video(url, video_duration / len(video_urls), clip_path)
+        if result:
+            try:
+                clip = VideoFileClip(clip_path)
+                clips.append(clip)
+                logger.info(f"Processed video clip {i+1}/{len(video_urls)}")
+            except Exception as e:
+                logger.error(f"Error loading clip {i+1}: {e}")
+                continue
+
+    if not clips:
+        logger.error("No valid video clips available")
+        return "Error: No se pudieron procesar los videos descargados."
 
     # Concatenate video clips
     logger.info("Concatenating video clips")
-    final_clip = concatenate_videoclips(clips, method="compose").set_duration(video_duration)
-
-    # Add looped music
-    if music_file:
-        logger.info("Adding user-uploaded music")
-        music = AudioFileClip(music_file.name)
-        music = audio_loop(music, duration=video_duration)
-        final_clip = final_clip.set_audio(music.set_duration(video_duration))
-    else:
-        logger.info("Using generated voice as audio")
-        final_clip = final_clip.set_audio(audio)
+    try:
+        final_clip = concatenate_videoclips(clips, method="compose")
+        final_clip = final_clip.set_duration(video_duration)
+    except Exception as e:
+        logger.error(f"Error concatenating clips: {e}")
+        return "Error: No se pudieron unir los segmentos de video."
+
+    # Add looped music or voice
+    try:
+        if music_file:
+            logger.info("Adding user-uploaded music")
+            music = AudioFileClip(music_file.name)
+            music = audio_loop(music, duration=video_duration)
+            final_audio = CompositeAudioClip([audio, music.volumex(0.3)])
+        else:
+            logger.info("Using generated voice as audio")
+            final_audio = audio
+
+        final_clip = final_clip.set_audio(final_audio)
+    except Exception as e:
+        logger.error(f"Error processing audio: {e}")
+        return "Error: Problema al procesar el audio."
 
     # Write final video
     logger.info(f"Writing final video to {output_video}")
-    final_clip.write_videofile(output_video, codec="libx264", audio_codec="aac", fps=24)
+    try:
+        final_clip.write_videofile(
+            output_video, 
+            codec="libx264", 
+            audio_codec="aac", 
+            fps=24,
+            threads=4,
+            preset='ultrafast',
+            bitrate="3000k"
+        )
+    except Exception as e:
+        logger.error(f"Error writing video file: {e}")
+        return "Error: No se pudo generar el video final."
     
     # Clean up
     logger.info("Cleaning up temporary files")
-    for clip in clips:
-        clip.close()
-    audio.close()
-    if music_file:
-        music.close()
-    final_clip.close()
-    os.remove(voice_file)
-    for i in range(len(video_urls)):
-        os.remove(f"temp_clip_{i}.mp4")
-
-    logger.info("Video creation completed")
+    try:
+        for clip in clips:
+            clip.close()
+        audio.close()
+        if music_file:
+            music.close()
+        final_clip.close()
+        os.remove(voice_file)
+        for i in range(len(video_urls)):
+            if os.path.exists(f"temp_clip_{i}.mp4"):
+                os.remove(f"temp_clip_{i}.mp4")
+    except Exception as e:
+        logger.error(f"Error during cleanup: {e}")
+
+    logger.info("Video creation completed successfully")
     return output_video
 
 # Gradio interface
 with gr.Blocks() as demo:
-    gr.Markdown("# Generador de Videos")
-    gr.Markdown("Ingresa un prompt (ej., 'Top 10 recetas más ricas') o un guion personalizado. Sube música opcional (MP3).")
-    prompt = gr.Textbox(label="Prompt", placeholder="Ejemplo: Top 10 recetas más ricas")
-    custom_text = gr.Textbox(label="Guion Personalizado", placeholder="Ingresa tu propio guion aquí (opcional)")
-    music_file = gr.File(label="Subir Música (MP3, opcional)", file_types=[".mp3"])
-    submit = gr.Button("Generar Video")
-    output = gr.Video(label="Video Generado")
-    submit.click(fn=create_video, inputs=[prompt, custom_text, music_file], outputs=output)
-
-demo.launch(share=True)
+    gr.Markdown("# Generador de Videos Automáticos")
+    gr.Markdown("""
+    Crea videos automáticos con voz en español. 
+    Ingresa un tema (ej. 'Top 10 recetas mexicanas') o escribe tu propio guion.
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            prompt = gr.Textbox(
+                label="Tema del Video", 
+                placeholder="Ejemplo: Top 10 lugares para visitar en México",
+                max_lines=2
+            )
+            custom_text = gr.Textbox(
+                label="Guion Personalizado (opcional)", 
+                placeholder="Pega aquí tu propio guion si prefieres...",
+                max_lines=10
+            )
+            music_file = gr.File(
+                label="Música de Fondo (opcional, MP3)", 
+                file_types=[".mp3"]
+            )
+            submit = gr.Button("Generar Video", variant="primary")
+            
+        with gr.Column():
+            output = gr.Video(label="Video Generado", format="mp4")
+            gr.Examples(
+                examples=[
+                    ["Top 10 ciudades de México", "", None],
+                    ["", "1. Ciudad de México - La capital vibrante\n2. Guadalajara - Cuna del mariachi\n3. Monterrey - Modernidad industrial", None]
+                ],
+                inputs=[prompt, custom_text, music_file],
+                label="Ejemplos para probar"
+            )
+    
+    submit.click(
+        fn=create_video,
+        inputs=[prompt, custom_text, music_file],
+        outputs=output,
+        api_name="generate_video"
+    )
+
+demo.launch(server_name="0.0.0.0", server_port=7860, share=True)