Update app.py

app.py

@@ -44,97 +44,19 @@ def cleanup_temp_files():
 
 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)
-        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_blur_video: {e}")
-        return clip
+    # (código existente)
 
 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:
-            return None
-        temp_video_path = os.path.join(temp_dir, f"temp_video_{int(time.time())}.mp4")
-        with open(temp_video_path, "wb") as f:
-            f.write(video_response.content)
-        return temp_video_path
-    except Exception as e:
-        print(f"Error downloading video: {e}")
-        return None
+    # (código existente)
 
 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"]  # 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'")
-                links = search_pixabay("nature", num_results=num_videos_per_keyword)
-                if not links:
-                    continue
-            temp_video_path = download_video(links[0])
-            if temp_video_path:
-                clip = VideoFileClip(temp_video_path)
-                processed_clip = resize_and_blur_video(clip)
-                video_clips.append(processed_clip)
-                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")
+    # (código existente)
 
 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:
-            repetitions = int(video_duration / music.duration) + 1
-            music_clips = [music] * repetitions
-            music = concatenate_audioclips(music_clips)
-        music = music.subclip(0, video_duration)
-        return music.volumex(0.2)
-    except Exception as e:
-        print(f"Error ajustando música: {e}")
-        return None
+    # (código existente)
 
 def combine_audio_video(audio_file, video_clip, music_clip=None):
     """Combina el audio y el video en un archivo final."""
@@ -148,30 +70,33 @@ def combine_audio_video(audio_file, video_clip, music_clip=None):
         
         # 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
+        # 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}")
+    if 'final_clip' in locals():
         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}")
-        if 'final_clip' in locals():
-            final_clip.close()
-        return None
+    return None
 
 def upload_to_google_drive(file_path, folder_id):
     """Sube un archivo a Google Drive y devuelve el enlace público."""
@@ -215,34 +140,38 @@ 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 y obtenemos el enlace
-        download_link = upload_to_google_drive(final_video_path, folder_id=FOLDER_ID)
-        if download_link:
-            print(f"Video subido a Google Drive. Enlace de descarga: {download_link}")
-            return f"[Descargar video]({download_link})"
-        else:
-            raise ValueError("Error subiendo el video a Google Drive")
-    except Exception as e:
-        print(f"Error durante el procesamiento: {e}")
-        return None
-    finally:
-        cleanup_temp_files()  # Limpiar archivos temporales al finalizar
+download_link = upload_to_google_drive(final_video_path, folder_id=FOLDER_ID)
+if download_link:
+    print(f"Video subido a Google Drive. Enlace de descarga: {download_link}")
+    return f"[Descargar video]({download_link})"
+else:
+    raise ValueError("Error subiendo el video a Google Drive")
+except Exception as e:
+    print(f"Error durante el procesamiento: {e}")
+    return None
+finally:
+    cleanup_temp_files()  # Limpiar archivos temporales al finalizar
 
 # Interfaz Gradio
 with gr.Blocks() as demo:
@@ -274,4 +203,4 @@ with gr.Blocks() as demo:
 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)
+demo.launch(server_name="0.0.0.0", server_port=port, share=True, show_error=True)