Update app.py

app.py

@@ -1,7 +1,11 @@
 import gradio as gr
 from tts_module import get_voices, text_to_speech
 from pexels_api import search_pexels
-from moviepy.editor import AudioFileClip, VideoFileClip, CompositeAudioClip, concatenate_audioclips, concatenate_videoclips
+from moviepy.editor import (
+    AudioFileClip, VideoFileClip, CompositeAudioClip, 
+    concatenate_audioclips, concatenate_videoclips,
+    vfx, CompositeVideoClip
+)
 import asyncio
 import os
 import time
@@ -9,17 +13,12 @@ import requests
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaFileUpload
 import tempfile
-import PIL
-
-# Parche para compatibilidad con Pillow >= 9.0.0
-if not hasattr(PIL.Image, "ANTIALIAS"):
-    PIL.Image.ANTIALIAS = PIL.Image.Resampling.LANCZOS
+import numpy as np
 
 # Define la carpeta de salida temporal
 output_folder = "outputs"
 os.makedirs(output_folder, exist_ok=True)
 
-# Sube el archivo al Google Drive usando una variable de entorno para la API Key
 def upload_to_google_drive(file_path):
     try:
         api_key = os.getenv("GOOGLE_API_KEY")
@@ -37,103 +36,106 @@ def upload_to_google_drive(file_path):
         print(f"Error al subir archivo a Google Drive: {e}")
         return None
 
-# Ajustar música de fondo
 def adjust_background_music(video_duration, music_file):
-    try:
-        music = AudioFileClip(music_file)
-        if music.duration < video_duration:
-            repetitions = int(video_duration / music.duration) + 1
-            music_clips = [music] * repetitions
-            music = concatenate_audioclips(music_clips)
-        if music.duration > video_duration:
-            music = music.subclip(0, video_duration)
-        music = music.volumex(0.2)
-        return music
-    except Exception as e:
-        print(f"Error al ajustar música de fondo: {e}")
-        return None
-
-# Concatenar múltiples videos de Pexels (manteniendo funcionalidad original)
-def concatenate_pexels_videos(text, num_videos=5, target_width=1920, target_height=1080):
+    music = AudioFileClip(music_file)
+    if music.duration < video_duration:
+        repetitions = int(video_duration / music.duration) + 1
+        music_clips = [music] * repetitions
+        music = concatenate_audioclips(music_clips)
+    if music.duration > video_duration:
+        music = music.subclip(0, video_duration)
+    music = music.volumex(0.2)
+    return music
+
+def resize_and_blur_video(clip, target_aspect_ratio=16/9):
+    """
+    Redimensiona y aplica desenfoque al fondo del video para mantener el aspecto 16:9
+    mientras preserva la calidad del contenido original.
+    """
+    # Obtener dimensiones originales
+    w, h = clip.size
+    current_aspect_ratio = w / h
+
+    if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+        return clip
+
+    # Calcular nuevas dimensiones manteniendo la altura
+    target_w = int(h * target_aspect_ratio)
+    target_h = h
+
+    if current_aspect_ratio < target_aspect_ratio:  # Video vertical
+        # Crear versión desenfocada y escalada para el fondo
+        background = (clip
+            .resize(width=target_w)  # Escalar al ancho objetivo
+            .fx(vfx.blur, sigma=15)  # Aplicar desenfoque gaussiano
+        )
+        
+        # Escalar el video original manteniendo su aspecto
+        foreground = clip.resize(height=target_h)
+        
+        # Centrar el video original sobre el fondo desenfocado
+        x_center = (target_w - foreground.w) / 2
+        
+        # Combinar las capas
+        final = CompositeVideoClip(
+            [background,
+             foreground.set_position((x_center, 0))],
+            size=(target_w, target_h)
+        )
+        
+        return final
+    else:  # Video horizontal
+        return clip.resize(width=target_w, height=target_h)
+
+def concatenate_pexels_videos(text, num_videos=5):
     sentences = [sentence.strip() for sentence in text.split(".") if sentence.strip()]
-    video_clips = []
-
+    video_links = []
     for sentence in sentences:
         try:
-            # Buscar videos en Pexels (funcionalidad original)
             links = search_pexels(sentence, num_results=num_videos)
-            if not links:
-                print(f"No se encontraron videos para la frase '{sentence}'.")
-                continue
-
-            link = links[0]  # Usamos solo el primer video encontrado
-            print(f"Enlace encontrado para '{sentence}': {link}")
-
-            # Descargar el video desde Pexels (funcionalidad original)
-            video_response = requests.get(link)
-            if video_response.status_code != 200:
-                print(f"Error al descargar video desde {link}: Código de estado {video_response.status_code}")
-                continue
-
-            # Crear un archivo temporal para guardar el video (funcionalidad original)
-            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
-                tmp_video.write(video_response.content)
-                tmp_path = tmp_video.name
-
-            # Procesar el video descargado (mejoras aquí)
-            clip = VideoFileClip(tmp_path)
-
-            # Redimensionar manteniendo la proporción original
-            if clip.size[0] != target_width or clip.size[1] != target_height:
-                clip_resized = clip.resize(width=target_width)
-                canvas = ColorClip(size=(target_width, target_height), color=(0, 0, 0), duration=clip_resized.duration)
-                clip_centered = CompositeVideoClip([clip_resized.set_position("center")], size=(target_width, target_height))
-                video_clips.append(clip_centered)
-            else:
-                video_clips.append(clip)
-
-            # Eliminar el archivo temporal después de procesarlo
-            os.remove(tmp_path)
-
+            if links:
+                video_links.append(links[0])
         except Exception as e:
-            print(f"Error al procesar video para la frase '{sentence}': {e}")
+            print(f"Error al buscar video para la frase '{sentence}': {e}")
             continue
-
-    if not video_clips:
-        raise Exception("No se pudieron procesar videos para el texto proporcionado.")
+    
+    if not video_links:
+        raise Exception("No se encontraron videos relevantes para el texto proporcionado.")
+    
+    video_clips = []
+    for link in video_links:
+        video_response = requests.get(link)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
+            tmp_video.write(video_response.content)
+            # Cargar y procesar cada clip
+            clip = VideoFileClip(tmp_video.name)
+            processed_clip = resize_and_blur_video(clip)
+            video_clips.append(processed_clip)
+    
     final_clip = concatenate_videoclips(video_clips, method="compose")
     return final_clip
 
-# Combinar audio, video y música
 def combine_audio_video(audio_file, video_clip, music_clip=None):
-    try:
-        audio_clip = AudioFileClip(audio_file)
-        total_duration = audio_clip.duration + 5
-        if video_clip.duration < total_duration:
-            video_clip = video_clip.loop(duration=total_duration)
-        video_clip = video_clip.set_duration(total_duration).fadeout(5)
-        final_clip = video_clip.set_audio(audio_clip)
-
-        if music_clip:
-            if music_clip.duration < total_duration:
-                repetitions = int(total_duration / music_clip.duration) + 1
-                music_clips = [music_clip] * repetitions
-                music_clip = concatenate_audioclips(music_clips)
-            if music_clip.duration > total_duration:
-                music_clip = music_clip.subclip(0, total_duration)
-            music_clip = music_clip.audio_fadeout(5)
-            final_clip = final_clip.set_audio(CompositeAudioClip([audio_clip, music_clip]))
-
-        output_filename = f"final_video_{int(time.time())}.mp4"
-        output_path = os.path.join(output_folder, output_filename)
-        final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", fps=24)
-        return output_path
+    audio_clip = AudioFileClip(audio_file)
+    total_duration = audio_clip.duration + 5
+    if video_clip.duration < total_duration:
+        video_clip = video_clip.loop(duration=total_duration)
+    video_clip = video_clip.set_duration(total_duration).fadeout(5)
+    final_clip = video_clip.set_audio(audio_clip)
+    if music_clip:
+        if music_clip.duration < total_duration:
+            repetitions = int(total_duration / music_clip.duration) + 1
+            music_clips = [music_clip] * repetitions
+            music_clip = concatenate_audioclips(music_clips)
+        if music_clip.duration > total_duration:
+            music_clip = music_clip.subclip(0, total_duration)
+        music_clip = music_clip.audio_fadeout(5)
+        final_clip = final_clip.set_audio(CompositeAudioClip([audio_clip, music_clip]))
+    output_filename = f"final_video_{int(time.time())}.mp4"
+    output_path = os.path.join(output_folder, output_filename)
+    final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", fps=24)
+    return output_path
 
-    except Exception as e:
-        print(f"Error al combinar audio, video y música: {e}")
-        return None
-
-# Función principal
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch):
     try:
         if text.strip():
@@ -141,35 +143,33 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch):
         elif txt_file is not None:
             final_text = txt_file.decode("utf-8")
         else:
-            return None
+            return "No input provided"
 
         voices = asyncio.run(get_voices())
         if selected_voice not in voices:
-            return None
+            return f"La voz '{selected_voice}' no es válida. Por favor, seleccione una de las siguientes voces: {', '.join(voices.keys())}"
 
-        # Generar audio con TTS
-        audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
+        try:
+            audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
+        except Exception as e:
+            return f"Error con la voz seleccionada: {e}"
 
-        # Concatenar videos de Pexels
-        video_clip = concatenate_pexels_videos(final_text, num_videos=5)
+        try:
+            video_clip = concatenate_pexels_videos(final_text, num_videos=5)
+        except Exception as e:
+            return f"Error al buscar videos en Pexels: {e}"
 
-        # Ajustar música de fondo
         if mp3_file is not None:
             music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
         else:
             music_clip = None
 
-        # Combinar audio, video y música
         final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
-
-        # Subir el video final a Google Drive
         upload_to_google_drive(final_video_path)
-
         return final_video_path
 
     except Exception as e:
-        print(f"Error durante el procesamiento: {e}")
-        return None
+        return f"Error durante el procesamiento: {e}"
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -193,7 +193,7 @@ with gr.Blocks() as demo:
         outputs=output_video
     )
 
-# Leer el puerto asignado por Hugging Face
+# Leer el puerto asignado por Hugging Face o usar 7860 como valor predeterminado
 port = int(os.getenv("PORT", 7860))
 
 # Lanzar la aplicación