Update app.py

app.py

@@ -2,7 +2,7 @@ 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, 
+    AudioFileClip, VideoFileClip, CompositeAudioClip,
     concatenate_audioclips, concatenate_videoclips,
     vfx, CompositeVideoClip
 )
@@ -13,128 +13,137 @@ import requests
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaFileUpload
 import tempfile
-import numpy as np
+import re
 
 # Define la carpeta de salida temporal
 output_folder = "outputs"
 os.makedirs(output_folder, exist_ok=True)
 
-def upload_to_google_drive(file_path):
-    try:
-        api_key = os.getenv("GOOGLE_API_KEY")
-        if not api_key:
-            print("Error: GOOGLE_API_KEY no está definida en las variables de entorno.")
-            return None
-
-        service = build("drive", "v3", developerKey=api_key)
-        file_metadata = {"name": os.path.basename(file_path)}
-        media = MediaFileUpload(file_path, resumable=True)
-        file = service.files().create(body=file_metadata, media_body=media, fields="id").execute()
-        print(f"Archivo subido exitosamente con ID: {file.get('id')}")
-        return file.get("id")
-    except Exception as e:
-        print(f"Error al subir archivo a Google Drive: {e}")
-        return None
-
-def adjust_background_music(video_duration, music_file):
-    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 clean_text_for_search(text):
+    """Limpia el texto para hacer búsquedas válidas en Pexels"""
+    # Eliminar caracteres especiales y limitar longitud
+    text = re.sub(r'[^\w\s]', ' ', text)
+    words = text.split()
+    # Tomar solo las primeras 3-4 palabras significativas
+    return ' '.join(words[:4])
 
 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
+    try:
+        # Obtener dimensiones originales
+        w, h = clip.size
+        current_aspect_ratio = w / h
         
-        # Combinar las capas
-        final = CompositeVideoClip(
-            [background,
-             foreground.set_position((x_center, 0))],
-            size=(target_w, target_h)
-        )
+        print(f"Procesando video: {w}x{h}, ratio: {current_aspect_ratio}")
+        if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+            return clip
         
-        return final
-    else:  # Video horizontal
-        return clip.resize(width=target_w, height=target_h)
+        # Calcular nuevas dimensiones
+        if current_aspect_ratio < target_aspect_ratio:  # Video vertical
+            target_w = int(h * target_aspect_ratio)
+            target_h = h
+            
+            # Crear versión desenfocada para el fondo
+            background = clip.resize(width=target_w)
+            try:
+                # Intentar con blur más intenso
+                background = background.fx(vfx.blur, sigma=50)
+            except Exception as e:
+                print(f"Error al aplicar blur: {e}")
+                # Si falla el blur, usar solo resize
+                background = background.resize(width=target_w)
+            
+            # Escalar video original
+            foreground = clip.resize(height=target_h)
+            x_center = (target_w - foreground.w) / 2
+            
+            # Combinar capas
+            return CompositeVideoClip(
+                [background, foreground.set_position((x_center, 0))],
+                size=(target_w, target_h)
+            )
+        else:  # Video horizontal
+            return clip.resize(width=int(h * target_aspect_ratio), height=h)
+            
+    except Exception as e:
+        print(f"Error en resize_and_blur_video: {e}")
+        # En caso de error, devolver el clip original
+        return clip
 
 def concatenate_pexels_videos(text, num_videos=5):
     sentences = [sentence.strip() for sentence in text.split(".") if sentence.strip()]
-    video_links = []
-    for sentence in sentences:
+    video_clips = []
+    
+    for sentence in sentences[:num_videos]:  # Limitar número de videos
         try:
-            links = search_pexels(sentence, num_results=num_videos)
-            if links:
-                video_links.append(links[0])
+            # Limpiar y preparar el texto para la búsqueda
+            search_text = clean_text_for_search(sentence)
+            print(f"Buscando videos para: {search_text}")
+            
+            links = search_pexels(search_text, num_results=1)
+            if not links:
+                continue
+                
+            video_response = requests.get(links[0])
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
+                tmp_video.write(video_response.content)
+                clip = VideoFileClip(tmp_video.name)
+                processed_clip = resize_and_blur_video(clip)
+                video_clips.append(processed_clip)
+                
         except Exception as e:
-            print(f"Error al buscar video para la frase '{sentence}': {e}")
+            print(f"Error procesando sentencia '{sentence}': {e}")
             continue
     
-    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)
+    if not video_clips:
+        raise Exception("No se pudieron obtener videos válidos")
     
-    final_clip = concatenate_videoclips(video_clips, method="compose")
-    return final_clip
+    return concatenate_videoclips(video_clips, method="compose")
+
+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 ajustando música: {e}")
+        return None
 
 def combine_audio_video(audio_file, video_clip, music_clip=None):
-    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
+    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
+    except Exception as e:
+        print(f"Error combinando audio y video: {e}")
+        return None
 
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch):
     try:
@@ -144,33 +153,49 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch):
             final_text = txt_file.decode("utf-8")
         else:
             return "No input provided"
-
+        
         voices = asyncio.run(get_voices())
         if selected_voice not in voices:
             return f"La voz '{selected_voice}' no es válida. Por favor, seleccione una de las siguientes voces: {', '.join(voices.keys())}"
-
+        
         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}"
-
+            return f"Error generando audio: {e}"
+        
         try:
             video_clip = concatenate_pexels_videos(final_text, num_videos=5)
         except Exception as e:
-            return f"Error al buscar videos en Pexels: {e}"
-
+            return f"Error concatenando videos: {e}"
+        
         if mp3_file is not None:
             music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
         else:
             music_clip = None
-
+        
         final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
         upload_to_google_drive(final_video_path)
         return final_video_path
-
     except Exception as e:
         return f"Error durante el procesamiento: {e}"
 
+def upload_to_google_drive(file_path):
+    try:
+        api_key = os.getenv("GOOGLE_API_KEY")
+        if not api_key:
+            print("Error: GOOGLE_API_KEY no está definida en las variables de entorno.")
+            return None
+        
+        service = build("drive", "v3", developerKey=api_key)
+        file_metadata = {"name": os.path.basename(file_path)}
+        media = MediaFileUpload(file_path, resumable=True)
+        file = service.files().create(body=file_metadata, media_body=media, fields="id").execute()
+        print(f"Archivo subido exitosamente con ID: {file.get('id')}")
+        return file.get("id")
+    except Exception as e:
+        print(f"Error subiendo a Google Drive: {e}")
+        return None
+
 # Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator")
@@ -185,7 +210,7 @@ with gr.Blocks() as demo:
             pitch_slider = gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch Adjustment (Hz)", step=1)
         with gr.Column():
             output_video = gr.File(label="Download Generated Video")
-
+    
     btn = gr.Button("Generate Video")
     btn.click(
         process_input,