Update app.py

app.py

@@ -6,6 +6,7 @@ from moviepy.editor import (
     concatenate_audioclips, concatenate_videoclips, vfx, CompositeVideoClip,
     ColorClip
 )
+from scipy.ndimage import gaussian_filter
 import asyncio
 import os
 import json
@@ -30,6 +31,7 @@ os.makedirs(temp_dir, exist_ok=True)
 FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"
 
 def cleanup_temp_files():
+    """Elimina todos los archivos temporales de la carpeta temp_files."""
     for filename in os.listdir(temp_dir):
         file_path = os.path.join(temp_dir, filename)
         try:
@@ -39,37 +41,44 @@ def cleanup_temp_files():
             print(f"Error deleting {file_path}: {e}")
 
 def resize_and_blur_video(clip, target_width=1920, target_height=1080):
+    """Redimensiona el video al tamaño 1080p (16:9) y aplica desenfoque si es necesario."""
     try:
         w, h = clip.size
         current_aspect_ratio = w / h
         target_aspect_ratio = target_width / target_height
 
         if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+            # Si la relación de aspecto ya es cercana a 16:9, solo redimensionamos
             return clip.resize((target_width, target_height))
 
+        # Crear un fondo borroso con las dimensiones objetivo
         background = ColorClip(size=(target_width, target_height), color=[0, 0, 0]).set_duration(clip.duration)
         try:
-            background = background.fx(vfx.blur, sigma=50)
+            # Aplicar filtro gaussiano como alternativa al blur
+            background = background.fx(vfx, lambda gf: gaussian_filter(gf, sigma=5))
         except Exception as e:
-            print(f"Error al aplicar blur: {e}")
+            print(f"Error al aplicar filtro gaussiano: {e}")
 
-        if current_aspect_ratio < target_aspect_ratio:
+        # Redimensionar el video original para mantener su proporción
+        if current_aspect_ratio < target_aspect_ratio:  # Video vertical
             new_height = target_height
             new_width = int(new_height * current_aspect_ratio)
             x_center = (target_width - new_width) / 2
             resized_clip = clip.resize(width=new_width).set_position((x_center, 0))
-        else:
+        else:  # Video horizontal
             new_width = target_width
             new_height = int(new_width / current_aspect_ratio)
             y_center = (target_height - new_height) / 2
             resized_clip = clip.resize(height=new_height).set_position((0, y_center))
 
+        # Combinar el fondo borroso con el video redimensionado
         return CompositeVideoClip([background, resized_clip], size=(target_width, target_height))
     except Exception as e:
         print(f"Error en resize_and_blur_video: {e}")
         return clip
 
 def download_video(link):
+    """Descarga un video desde un enlace y lo guarda en la carpeta temporal."""
     try:
         video_response = requests.get(link)
         if video_response.status_code != 200:
@@ -83,12 +92,14 @@ def download_video(link):
         return None
 
 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:
-        keyword_list = ["nature"]
+        keyword_list = ["nature"]  # Palabra clave por defecto
     video_clips = []
     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 '{keyword}', probando con 'nature'")
@@ -100,16 +111,18 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
                 clip = VideoFileClip(temp_video_path)
                 processed_clip = resize_and_blur_video(clip)
                 video_clips.append(processed_clip)
-                os.remove(temp_video_path)
+                os.remove(temp_video_path)  # Eliminar archivo temporal después de usarlo
         except Exception as e:
             print(f"Error procesando palabra clave '{keyword}': {e}")
             continue
     if not video_clips:
+        # Si no hay videos, creamos un clip negro de 5 segundos
         return ColorClip(size=(1920, 1080), color=[0, 0, 0], duration=5)
     random.shuffle(video_clips)
     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:
@@ -122,57 +135,63 @@ def adjust_background_music(video_duration, music_file):
         print(f"Error ajustando música: {e}")
         return None
 
-def calculate_real_duration(video):
-    frame_time = 1 / video.fps
-    total_frames = int(video.duration * video.fps)
-    real_duration = total_frames * frame_time
-    return real_duration
-
 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 + 2
+        total_duration = audio_clip.duration + 2  # Añadimos 2 segundos extra
 
-        # Ajustar la duración del video al último fotograma válido
-        real_duration = calculate_real_duration(video_clip)
-        video_clip = video_clip.subclip(0, min(real_duration, total_duration)).loop(duration=total_duration)
+        # Aseguramos que el video tenga la duración correcta
+        video_clip = video_clip.loop(duration=total_duration)
         video_clip = video_clip.set_duration(total_duration).fadeout(2)
 
+        # Combinamos el audio principal
         final_clip = video_clip.set_audio(audio_clip)
+        # Añadimos la música de fondo si existe
         if music_clip:
             music_clip = music_clip.set_duration(total_duration).audio_fadeout(2)
             final_clip = final_clip.set_audio(CompositeAudioClip([audio_clip, music_clip]))
 
+        # Generamos el nombre del archivo y la ruta
         output_filename = f"final_video_{int(time.time())}.mp4"
         output_path = os.path.join(output_folder, output_filename)
+
+        # Guardamos el video
         final_clip.write_videofile(output_path, codec="libx264", audio_codec="aac", fps=24)
+
+        # Limpiamos los clips
         final_clip.close()
         video_clip.close()
         audio_clip.close()
         if music_clip:
             music_clip.close()
+
         return output_path
     except Exception as e:
         print(f"Error combinando audio y video: {e}")
         return None
 
 def upload_to_google_drive(file_path, folder_id):
+    """Sube un archivo a Google Drive y devuelve el enlace público."""
     try:
         creds = service_account.Credentials.from_service_account_file(
             'service-account.json', scopes=['https://www.googleapis.com/auth/drive']
         )
         service = build('drive', 'v3', credentials=creds)
+
         file_metadata = {
             'name': os.path.basename(file_path),
             'parents': [folder_id]
         }
         media = MediaFileUpload(file_path, resumable=True)
         file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
+
         permission = {
             'type': 'anyone',
             'role': 'reader'
         }
         service.permissions().create(fileId=file['id'], body=permission).execute()
+
         file_id = file['id']
         download_link = f"https://drive.google.com/uc?export=download&id={file_id}"
         return download_link
@@ -181,6 +200,7 @@ def upload_to_google_drive(file_path, folder_id):
         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