Update app.py

app.py

@@ -4,7 +4,7 @@ from pixabay_api import search_pixabay
 from moviepy.editor import (
     AudioFileClip, VideoFileClip, CompositeAudioClip,
     concatenate_audioclips, concatenate_videoclips, vfx, CompositeVideoClip,
-    ColorClip, ImageClip
+    ColorClip
 )
 import asyncio
 import os
@@ -16,8 +16,6 @@ import re
 import random
 from google_drive_upload import authenticate_google_drive, upload_to_google_drive
 from io import BytesIO
-from PIL import Image
-import numpy as np
 
 # Crear el archivo de credenciales de servicio desde los secretos
 service_account_info = json.loads(os.getenv('GOOGLE_SERVICE_ACCOUNT', '{}'))
@@ -30,62 +28,44 @@ output_folder = "outputs"
 os.makedirs(output_folder, exist_ok=True)
 
 # ID de la carpeta de destino en Google Drive
-FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"  # Reemplaza con tu ID real
+FOLDER_ID = "12S6adpanAXjf71pKKGRRPqpzbJa5XEh3"  # Reemplaza con tu ID de carpeta
 
-
-def resize_and_add_background(clip, target_width=1920, target_height=1080, background_url="https://wallpaperaccess.com/full/231401.jpg"):
-    """
-    Redimensiona el video al tamaño 1080p (16:9) y añade una imagen de fondo descargada desde una URL.
-    """
+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
 
-        # Descargar la imagen de fondo desde la URL
-        response = requests.get(background_url)
-        if response.status_code != 200:
-            print("Error al descargar la imagen de fondo, usando un fondo negro.")
-            background = (
-                ImageClip(
-                    np.zeros((target_height, target_width, 3), dtype=np.uint8),
-                    duration=clip.duration,
-                )
-                .set_duration(clip.duration)
-                .resize((target_width, target_height))
-            )
-        else:
-            image_data = Image.open(BytesIO(response.content))
-            image_array = np.array(image_data)
-            background = (
-                ImageClip(image_array)
-                .set_duration(clip.duration)
-                .resize((target_width, target_height))
-            )
-
-        # Si el video ya tiene una relación de aspecto cercana a 16:9, solo redimensionarlo
         if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
-            resized_clip = clip.resize((target_width, target_height))
-        else:
-            # Redimensionar el video manteniendo su proporción y centrarlo sobre el fondo
-            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:  # 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))
+            # Si la relación de aspecto ya es cercana a 16:9, solo redimensionamos
+            return clip.resize((target_width, target_height))
 
-        # Combinar el fondo con el video redimensionado
+        # 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)
+        except Exception as e:
+            print(f"Error al aplicar blur: {e}")
+
+        # 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:  # 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_add_background: {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()]
@@ -109,7 +89,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
             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_add_background(clip)
+                processed_clip = resize_and_blur_video(clip)
                 video_clips.append(processed_clip)
                 os.unlink(tmp_video.name)  # Limpiamos el archivo temporal
         except Exception as e:
@@ -121,7 +101,6 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
     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:
@@ -136,7 +115,6 @@ def adjust_background_music(video_duration, music_file):
         print(f"Error ajustando música: {e}")
         return None
 
-
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     """Combina el audio y el video en un archivo final."""
     try:
@@ -174,7 +152,6 @@ def combine_audio_video(audio_file, video_clip, music_clip=None):
             final_clip.close()
         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:
@@ -185,41 +162,33 @@ def process_input(text, txt_file, mp3_file, selected_voice, rate, pitch, keyword
             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
         video_id = upload_to_google_drive(final_video_path, folder_id=FOLDER_ID)
         if video_id:
             print(f"Video subido a Google Drive con ID: {video_id}")
-            download_link = f"https://drive.google.com/file/d/{video_id}/view?usp=sharing"
-            return download_link  # Devuelve el enlace compartido
         else:
             print("Error subiendo el video a Google Drive")
-            return "Error al subir el video"
-
+        
+        return final_video_path
     except Exception as e:
         print(f"Error durante el procesamiento: {e}")
-        return f"Error durante el procesamiento: {e}"
-
+        return None
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -231,15 +200,14 @@ with gr.Blocks() as demo:
             mp3_file_input = gr.File(label="Upload background music (.mp3)", file_types=[".mp3"])
             keyword_input = gr.Textbox(
                 label="Enter keywords separated by commas (e.g., universe, galaxy, forest, cat)",
-                value="space, espacio,galaxy,moon,fear,astral,god,evil,mistery,cosmos,stars"
+                value="space, espacio,galaxy,moon,fear,astral,god, evil, mistery, cosmos, stars"
             )
             voices = asyncio.run(get_voices())
             voice_dropdown = gr.Dropdown(choices=list(voices.keys()), label="Select Voice")
             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_video = gr.HTML(value="<p></p>")  # Usamos HTML para mostrar el botón
+           output_video = gr.File(label="Generated Video")  # En lugar de gr.Video
 
     btn = gr.Button("Generate Video")
     btn.click(
@@ -248,16 +216,6 @@ with gr.Blocks() as demo:
         outputs=output_video
     )
 
-    # Función para actualizar el HTML con el botón de descarga
-    def update_html(download_link):
-        if "Error" in download_link:
-            return gr.HTML.update(value=f"<p>{download_link}</p>")
-        return gr.HTML.update(value=f'<a href="{download_link}" target="_blank"><button>Descargar</button></a>')
-
-    btn.click(process_input, inputs=[text_input, txt_file_input, mp3_file_input, voice_dropdown, rate_slider, pitch_slider, keyword_input], outputs=output_video).then(
-        update_html, inputs=output_video, outputs=output_video
-    )
-
 # Leer el puerto asignado por Hugging Face
 port = int(os.getenv("PORT", 7860))