Update app.py

app.py

@@ -1,57 +1,218 @@
-def process_input_with_resume(text, txt_file, mp3_file, selected_voice, rate, pitch, keywords):
+import gradio as gr
+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,
+    ColorClip
+)
+import asyncio
+import os
+import json
+import time
+import requests
+import tempfile
+import re
+import random
+from google_drive_upload import authenticate_google_drive, upload_to_google_drive
+
+# Crear el archivo de credenciales de servicio desde los secretos
+service_account_info = json.loads(os.getenv('GOOGLE_SERVICE_ACCOUNT', '{}'))
+if service_account_info:
+    with open('service-account.json', 'w') as f:
+        json.dump(service_account_info, f)
+
+# Define la carpeta de salida
+output_folder = "outputs"
+os.makedirs(output_folder, exist_ok=True)
+
+# ID de la carpeta de destino en Google Drive (ajusta esto con tu ID real)
+FOLDER_ID = "TU_ID_DE_CARPETA"  # Reemplaza con tu ID de carpeta de Google Drive
+
+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:
-        # 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")
+        w, h = clip.size
+        current_aspect_ratio = w / h
+        if abs(current_aspect_ratio - target_aspect_ratio) < 0.1:
+            return clip
+        if current_aspect_ratio < target_aspect_ratio:  # Video vertical
+            target_w = int(h * target_aspect_ratio)
+            target_h = h
+            background = clip.resize(width=target_w)
+            try:
+                background = background.fx(vfx.blur, sigma=50)
+            except Exception as e:
+                print(f"Error al aplicar blur: {e}")
+            foreground = clip.resize(height=target_h)
+            x_center = (target_w - foreground.w) / 2
+            return CompositeVideoClip(
+                [background, foreground.set_position((x_center, 0))],
+                size=(target_w, target_h)
+            )
+        else:  # Video horizontal
+            return clip.resize(width=int(h * target_aspect_ratio), height=h)
+    except Exception as e:
+        print(f"Error en resize_and_blur_video: {e}")
+        return clip
 
-        # Dividimos el texto en segmentos
-        segments = split_text_into_segments(final_text, max_segment_length=30)
-        video_clips = []
 
-        for i, segment in enumerate(segments):
-            segment_file = os.path.join(output_folder, f"segment_{i}.mp4")
-            if os.path.exists(segment_file):  # Verifica si el segmento ya existe
-                print(f"Segmento {i} ya procesado, saltando...")
-                video_clips.append(VideoFileClip(segment_file))
+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
+            link = links[0]
+            video_response = requests.get(link)
+            if video_response.status_code != 200:
+                print(f"Error al descargar video desde {link}")
                 continue
+            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_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 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")
 
-            print(f"Procesando segmento {i + 1}/{len(segments)}...")
-            audio_segment = asyncio.run(text_to_speech(segment, selected_voice, rate, pitch))
-            if not audio_segment:
-                raise ValueError(f"Failed to generate audio for segment {i + 1}")
 
-            video_clip = concatenate_pixabay_videos(keywords, num_videos_per_keyword=1)
-            if not video_clip:
-                raise ValueError(f"Failed to generate video for segment {i + 1}")
-
-            music_clip = adjust_background_music(video_clip.duration, mp3_file.name) if mp3_file else None
-            video_segment_path = combine_audio_video(audio_segment, video_clip, music_clip)
+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
 
-            # Guardamos el segmento
-            os.rename(video_segment_path, segment_file)
-            video_clips.append(VideoFileClip(segment_file))
 
-            # Subimos el segmento a Google Drive (opcional)
-            upload_to_google_drive(segment_file, folder_id=FOLDER_ID)
+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  # 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:
+            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}")
+        if 'final_clip' in locals():
+            final_clip.close()
+        return None
 
-        # Combinamos todos los segmentos en un solo video
-        final_video_clip = concatenate_videoclips(video_clips, method="compose")
-        final_video_path = os.path.join(output_folder, f"final_video_{int(time.time())}.mp4")
-        final_video_clip.write_videofile(final_video_path, codec="libx264", audio_codec="aac", fps=24)
 
-        # Subimos el video final a Google Drive
+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
         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}")
         else:
             print("Error subiendo el video a Google Drive")
-
+        
         return final_video_path
-
     except Exception as e:
         print(f"Error durante el procesamiento: {e}")
-        return None
+        return None
+
+
+# Interfaz Gradio
+with gr.Blocks() as demo:
+    gr.Markdown("# Text-to-Video Generator")
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(label="Write your text here", lines=5)
+            txt_file_input = gr.File(label="Or upload a .txt file", file_types=[".txt"])
+            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"
+            )
+            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="Generated Video")  # Usamos gr.File en lugar de gr.Video
+
+    btn = gr.Button("Generate Video")
+    btn.click(
+        process_input,
+        inputs=[text_input, txt_file_input, mp3_file_input, voice_dropdown, rate_slider, pitch_slider, keyword_input],
+        outputs=output_video
+    )
+
+# 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, enable_queue=True)