Update app.py

app.py

@@ -3,10 +3,9 @@ from tts_module import get_voices, text_to_speech
 from pixabay_api import search_pixabay
 from moviepy.editor import (
     AudioFileClip, VideoFileClip, CompositeAudioClip,
-    concatenate_audioclips, concatenate_videoclips, vfx, CompositeVideoClip,
+    concatenate_audioclips, concatenate_videoclips, CompositeVideoClip,
     ColorClip
 )
-from scipy.ndimage import gaussian_filter
 import asyncio
 import os
 import json
@@ -23,12 +22,14 @@ if service_account_info:
     with open('service-account.json', 'w') as f:
         json.dump(service_account_info, f)
 
+# Define la carpeta de salida y la carpeta temporal
 output_folder = "outputs"
 temp_dir = "temp_files"
 os.makedirs(output_folder, exist_ok=True)
 os.makedirs(temp_dir, exist_ok=True)
 
-FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"
+# ID de la carpeta de destino en Google Drive
+FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"  # Reemplaza con tu ID de carpeta
 
 def cleanup_temp_files():
     """Elimina todos los archivos temporales de la carpeta temp_files."""
@@ -40,25 +41,16 @@ def cleanup_temp_files():
         except Exception as e:
             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."""
+def resize_video(clip, target_width=1920, target_height=1080):
+    """Redimensiona el video al tamaño 1080p (16:9) sin aplicar desenfoque."""
     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:
-            # 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 filtro gaussiano: {e}")
-
         # Redimensionar el video original para mantener su proporción
         if current_aspect_ratio < target_aspect_ratio:  # Video vertical
             new_height = target_height
@@ -71,10 +63,11 @@ def resize_and_blur_video(clip, target_width=1920, target_height=1080):
             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
+        # Crear un fondo negro y combinar con el video redimensionado
+        background = ColorClip(size=(target_width, target_height), color=[0, 0, 0]).set_duration(clip.duration)
         return CompositeVideoClip([background, resized_clip], size=(target_width, target_height))
     except Exception as e:
-        print(f"Error en resize_and_blur_video: {e}")
+        print(f"Error en resize_video: {e}")
         return clip
 
 def download_video(link):
@@ -109,7 +102,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
             temp_video_path = download_video(links[0])
             if temp_video_path:
                 clip = VideoFileClip(temp_video_path)
-                processed_clip = resize_and_blur_video(clip)
+                processed_clip = resize_video(clip)
                 video_clips.append(processed_clip)
                 os.remove(temp_video_path)  # Eliminar archivo temporal después de usarlo
         except Exception as e:
@@ -202,24 +195,30 @@ def upload_to_google_drive(file_path, folder_id):
 def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
     """Procesa la entrada del usuario y genera el video final."""
     try:
+        # Determinamos el texto a usar
         if text.strip():
             final_text = text
         elif txt_file is not None:
             final_text = txt_file.decode("utf-8")
         else:
             raise ValueError("No text input provided")
+        # Generamos el audio
         audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
         if not audio_file:
             raise ValueError("Failed to generate audio")
+        # Generamos el video
         video_clip = concatenate_pixabay_videos(keywords, num_videos_per_keyword=1)
         if not video_clip:
             raise ValueError("Failed to generate video")
+        # Procesamos la música de fondo si existe
         music_clip = None
         if mp3_file is not None:
             music_clip = adjust_background_music(video_clip.duration, mp3_file.name)
+        # Combinamos todo
         final_video_path = combine_audio_video(audio_file, video_clip, music_clip)
         if not final_video_path:
             raise ValueError("Failed to combine audio and video")
+        # Subimos a Google Drive y obtenemos el enlace
         download_link = upload_to_google_drive(final_video_path, folder_id=FOLDER_ID)
         if download_link:
             return f"[Descargar video]({download_link})"
@@ -229,8 +228,9 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keyword
         print(f"Error durante el procesamiento: {e}")
         return None
     finally:
-        cleanup_temp_files()
+        cleanup_temp_files()  # Limpiar archivos temporales al finalizar
 
+# Interfaz Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Text-to-Video Generator")
     with gr.Row():
@@ -247,7 +247,8 @@ with gr.Blocks() as demo:
             rate_slider = gr.Slider(minimum=-50, maximum=50, value=0, label="Speech Rate Adjustment (%)", step=1)
             pitch_slider = gr.Slider(minimum=-20, maximum=20, value=0, label="Pitch Adjustment (Hz)", step=1)
         with gr.Column():
-            output_link = gr.Markdown("")
+            output_link = gr.Markdown("")  # Mostrar el enlace de descarga
+
     btn = gr.Button("Generate Video")
     btn.click(
         process_input,
@@ -255,5 +256,8 @@ with gr.Blocks() as demo:
         outputs=output_link
     )
 
+# 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, show_error=True)