Update app.py

app.py

@@ -13,24 +13,12 @@ import requests
 import tempfile
 import re
 import random
-import numpy as np
 from google_drive_upload import upload_to_google_drive
 
 # Define la carpeta de salida
 output_folder = "outputs"
 os.makedirs(output_folder, exist_ok=True)
 
-# Crear un video predeterminado si no existe
-if not os.path.exists(os.path.join(output_folder, "blank.mp4")):
-    # Create a black frame
-    color_clip = ColorClip(size=(1920, 1080), color=[0, 0, 0], duration=1)
-    color_clip.write_videofile(os.path.join(output_folder, "blank.mp4"), fps=24)
-
-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
-
 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:
@@ -67,9 +55,7 @@ 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:
-        # Si no hay palabras clave, crear un video negro
-        color_clip = ColorClip(size=(1920, 1080), color=[0, 0, 0], duration=5)
-        return color_clip
+        keyword_list = ["nature"]  # Palabra clave por defecto
 
     video_clips = []
 
@@ -78,7 +64,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
             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}'. Usando palabra clave predeterminada 'nature'.")
+                print(f"No se encontraron videos para '{keyword}', probando con 'nature'")
                 links = search_pixabay("nature", num_results=num_videos_per_keyword)
                 if not links:
                     continue
@@ -86,7 +72,7 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
             link = links[0]
             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}")
+                print(f"Error al descargar video desde {link}")
                 continue
 
             with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video:
@@ -94,15 +80,15 @@ def concatenate_pixabay_videos(keywords, num_videos_per_keyword=1):
                 clip = VideoFileClip(tmp_video.name)
                 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:
             print(f"Error procesando palabra clave '{keyword}': {e}")
             continue
 
     if not video_clips:
-        # Si no se encontraron videos, crear un video negro
-        color_clip = ColorClip(size=(1920, 1080), color=[0, 0, 0], duration=5)
-        return color_clip
+        # 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")
@@ -115,10 +101,8 @@ def adjust_background_music(video_duration, music_file):
             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
+        music = music.subclip(0, video_duration)
+        return music.volumex(0.2)
     except Exception as e:
         print(f"Error ajustando música: {e}")
         return None
@@ -127,69 +111,81 @@ 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
-        if video_clip.duration < total_duration:
-            video_clip = video_clip.loop(duration=total_duration)
-        video_clip = video_clip.set_duration(total_duration).fadeout(5)
+        total_duration = audio_clip.duration + 2  # Añadimos 2 segundos extra
+        
+        # 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:
-            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)
+            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 os.path.join(output_folder, "blank.mp4")
+        if 'final_clip' in locals():
+            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:
+        # 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:
-            return os.path.join(output_folder, "blank.mp4")
-
-        voices = asyncio.run(get_voices())
-        if selected_voice not in voices:
-            return os.path.join(output_folder, "blank.mp4")
+            raise ValueError("No text input provided")
 
-        try:
-            audio_file = asyncio.run(text_to_speech(final_text, selected_voice, rate, pitch))
-        except Exception as e:
-            print(f"Error generando audio: {e}")
-            return os.path.join(output_folder, "blank.mp4")
+        # 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")
 
-        try:
-            video_clip = concatenate_pixabay_videos(keywords, num_videos_per_keyword=1)
-        except Exception as e:
-            print(f"Error concatenando videos: {e}")
-            return os.path.join(output_folder, "blank.mp4")
+        # 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)
-        else:
-            music_clip = None
 
+        # 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
         upload_to_google_drive(final_video_path)
+        
         return final_video_path
 
     except Exception as e:
         print(f"Error durante el procesamiento: {e}")
-        return os.path.join(output_folder, "blank.mp4")
+        return None
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -201,14 +197,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="nature"  # Valor predeterminado
+                value="nature"
             )
             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.File(label="Download Generated Video")
+            output_video = gr.Video(label="Generated Video")
 
     btn = gr.Button("Generate Video")
     btn.click(
@@ -217,8 +213,5 @@ with gr.Blocks() as demo:
         outputs=output_video
     )
 
-if __name__ == "__main__":
-    # Leer el puerto asignado por Hugging Face
-    port = int(os.getenv("PORT", 7860))
-    # Lanzar la aplicación
+# Lanzar la aplicación
     demo.launch(server_name="0.0.0.0", server_port=port, share=True)