Update app.py

app.py

@@ -14,17 +14,19 @@ from googleapiclient.http import MediaFileUpload
 import tempfile
 import re
 import random
+from google_drive_upload import upload_to_google_drive  # Importa la nueva función
 
+# Define la carpeta de salida temporal
 output_folder = "outputs"
 os.makedirs(output_folder, exist_ok=True)
 
 def clean_text_for_search(text):
+    """Limpia el texto para hacer búsquedas válidas en Pixabay"""
     text = re.sub(r'[^\w\s]', '', text).strip()
     return text
 
-from PIL import Image
-
 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."""
     try:
         w, h = clip.size
         current_aspect_ratio = w / h
@@ -36,27 +38,27 @@ def resize_and_blur_video(clip, target_aspect_ratio=16/9):
             target_w = int(h * target_aspect_ratio)
             target_h = h
 
-            # Redimensionar el video original para que ocupe el alto completo
-            foreground = clip.resize(height=target_h, resample=Image.Resampling.LANCZOS)
-
-            # Crear un fondo difuminado
-            background = clip.resize(width=target_w, height=target_h, resample=Image.Resampling.LANCZOS)
-            background = background.fx(vfx.blur, sigma=50)  # Aplicar desenfoque
+            background = clip.resize(width=target_w)
+            try:
+                background = background.fx(vfx.blur, sigma=50)
+            except Exception as e:
+                print(f"Error al aplicar blur: {e}")
 
-            # Centrar el video original sobre el fondo difuminado
-            x_center = (target_w - foreground.w) // 2
+            foreground = clip.resize(height=target_h)
+            x_center = (target_w - foreground.w) / 2
             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, resample=Image.Resampling.LANCZOS)
+            return clip.resize(width=int(h * target_aspect_ratio), height=h)
 
     except Exception as e:
         print(f"Error en resize_and_blur_video: {e}")
         return clip
 
 def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
+    """Concatena videos de Pixabay basados en palabras clave."""
     keyword_list = [keyword.strip() for keyword in keywords.split(",") if keyword.strip()]
     if not keyword_list:
         raise Exception("No se proporcionaron palabras clave válidas.")
@@ -65,12 +67,15 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
 
     for keyword in keyword_list:
         try:
+            print(f"Buscando videos para la palabra clave '{keyword}'...")
             links = search_pixabay(keyword, num_results=num_videos_per_keyword)
             if not links:
-                print(f"No se encontraron videos para la palabra clave '{keyword}'.")
-                continue
+                print(f"No se encontraron videos para la palabra clave '{keyword}'. Usando palabra clave predeterminada 'nature'.")
+                links = search_pixabay("nature", num_results=num_videos_per_keyword)  # Palabra clave predeterminada
+                if not links:
+                    continue
 
-            link = links[0]
+            link = links[0]  # Usamos solo el primer video encontrado
             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}")
@@ -93,6 +98,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
     return concatenate_videoclips(video_clips, method="compose")
 
 def adjust_background_music(video_duration, music_file):
+    """Ajusta la música de fondo para que coincida con la duración del video."""
     try:
         music = AudioFileClip(music_file)
         if music.duration < video_duration:
@@ -108,6 +114,7 @@ def adjust_background_music(video_duration, music_file):
         return None
 
 def combine_audio_video(audio_file, video_clip, music_clip=None):
+    """Combina el audio y el video en un archivo final."""
     try:
         audio_clip = AudioFileClip(audio_file)
         total_duration = audio_clip.duration + 5
@@ -136,27 +143,28 @@ def combine_audio_video(audio_file, video_clip, music_clip=None):
         return None
 
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
+    """Procesa la entrada del usuario y genera el video final."""
     try:
         if text.strip():
             final_text = text
         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())}"
 
         try:
             audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
         except Exception as e:
-            return None
+            return f"Error generando audio: {e}"
 
         try:
             video_clip = concatenate_pixabay_videos(keywords, num_videos_per_keyword=1)
         except Exception as e:
-            return None
+            return f"Error concatenando videos: {e}"
 
         if mp3_file is not None:
             music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
@@ -164,29 +172,13 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keyword
             music_clip = None
 
         final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
-        upload_to_google_drive(final_video_path)
+        upload_to_google_drive(final_video_path)  # Sube a Google Drive usando OAuth2
         return final_video_path
 
     except Exception as e:
-        return None
-
-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
+        return f"Error durante el procesamiento: {e}"
 
+# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator")
     with gr.Row():
@@ -209,5 +201,8 @@ with gr.Blocks() as demo:
         outputs=output_video
     )
 
+# Leer el puerto asignado por Hugging Face
 port = int(os.getenv("PORT", 7860))
+
+# Lanzar la aplicación
 demo.launch(server_name="0.0.0.0", server_port=port, share=True)