Update app.py

app.py

@@ -3,7 +3,7 @@ import re
 import random
 import time
 import logging
-from typing import Optional, List
+from typing import Optional, List, Dict
 from datetime import datetime
 from pathlib import Path
 
@@ -25,15 +25,28 @@ try:
     import numpy as np
     from transformers import pipeline
     import backoff
+    from pydub import AudioSegment
 except ImportError as e:
     logger.error(f"Error importing dependencies: {e}")
     raise
 
 # Constantes configurables
-MAX_VIDEOS = 3  # Reducir para evitar rate limiting
-VIDEO_SEGMENT_DURATION = 5  # Duración de cada segmento en segundos
-MAX_RETRIES = 3  # Máximo de reintentos para descargas
-REQUEST_TIMEOUT = 15  # Timeout para requests
+MAX_VIDEOS = 3
+VIDEO_SEGMENT_DURATION = 5
+MAX_RETRIES = 3
+REQUEST_TIMEOUT = 15
+
+# Voces disponibles en Edge TTS (español)
+VOICES = {
+    "Femenino MX": "es-MX-DaliaNeural",
+    "Masculino MX": "es-MX-JorgeNeural",
+    "Femenino ES": "es-ES-ElviraNeural",
+    "Masculino ES": "es-ES-AlvaroNeural",
+    "Femenino CO": "es-CO-SalomeNeural",
+    "Masculino CO": "es-CO-GonzaloNeural",
+    "Femenino AR": "es-AR-ElenaNeural",
+    "Masculino AR": "es-AR-TomasNeural"
+}
 
 # Configuración de modelos
 MODEL_NAME = "facebook/mbart-large-50"
@@ -45,7 +58,7 @@ PEXELS_API_KEY = os.getenv("PEXELS_API_KEY", "")
                     max_tries=MAX_RETRIES,
                     max_time=30)
 def safe_download(url: str, timeout: int = REQUEST_TIMEOUT) -> Optional[str]:
-    """Descarga segura con reintentos y manejo de rate limiting"""
+    """Descarga segura con reintentos"""
     try:
         response = requests.get(url, stream=True, timeout=timeout)
         response.raise_for_status()
@@ -69,6 +82,25 @@ def safe_download(url: str, timeout: int = REQUEST_TIMEOUT) -> Optional[str]:
         logger.error(f"Unexpected download error: {str(e)}")
         return None
 
+def process_music(music_path: str, target_duration: float) -> str:
+    """Procesa música para loop y duración correcta"""
+    processed_path = "processed_music.mp3"
+    try:
+        audio = AudioSegment.from_file(music_path)
+        
+        # Crear loop si es más corto que el video
+        if len(audio) < target_duration * 1000:
+            loops_needed = int(target_duration * 1000 / len(audio)) + 1
+            audio = audio * loops_needed
+            
+        # Recortar a la duración exacta
+        audio = audio[:int(target_duration * 1000)]
+        audio.export(processed_path, format="mp3")
+        return processed_path
+    except Exception as e:
+        logger.error(f"Error processing music: {str(e)}")
+        return music_path  # Fallback al original
+
 def download_video_segment(url: str, duration: float, output_path: str) -> bool:
     """Descarga y procesa un segmento de video"""
     temp_path = None
@@ -85,7 +117,6 @@ def download_video_segment(url: str, duration: float, output_path: str) -> bool:
             end_time = min(duration, clip.duration - 0.1)
             subclip = clip.subclip(0, end_time)
             
-            # Configuración optimizada para HF Spaces
             subclip.write_videofile(
                 output_path,
                 codec="libx264",
@@ -93,10 +124,7 @@ def download_video_segment(url: str, duration: float, output_path: str) -> bool:
                 threads=2,
                 preset='ultrafast',
                 verbose=False,
-                ffmpeg_params=[
-                    '-max_muxing_queue_size', '1024',
-                    '-movflags', '+faststart'
-                ]
+                ffmpeg_params=['-max_muxing_queue_size', '1024']
             )
         return True
         
@@ -108,7 +136,7 @@ def download_video_segment(url: str, duration: float, output_path: str) -> bool:
             os.remove(temp_path)
 
 def fetch_pexels_videos(query: str) -> List[str]:
-    """Busca videos en Pexels con manejo de errores"""
+    """Busca videos en Pexels"""
     if not PEXELS_API_KEY:
         logger.error("PEXELS_API_KEY no configurada")
         return []
@@ -123,7 +151,7 @@ def fetch_pexels_videos(query: str) -> List[str]:
         videos = []
         for video in response.json().get("videos", [])[:MAX_VIDEOS]:
             video_files = [vf for vf in video.get("video_files", []) 
-                         if vf.get("width", 0) >= 720]  # Calidad mínima
+                         if vf.get("width", 0) >= 720]
             if video_files:
                 best_file = max(video_files, key=lambda x: x.get("width", 0))
                 videos.append(best_file["link"])
@@ -134,8 +162,11 @@ def fetch_pexels_videos(query: str) -> List[str]:
         logger.error(f"Error fetching Pexels videos: {str(e)}")
         return []
 
-def generate_script(prompt: str) -> str:
-    """Genera un script usando IA local con fallback"""
+def generate_script(prompt: str, custom_script: Optional[str] = None) -> str:
+    """Genera un script usando IA o custom text"""
+    if custom_script and custom_script.strip():
+        return custom_script.strip()
+        
     try:
         generator = pipeline("text-generation", model=MODEL_NAME)
         result = generator(
@@ -148,10 +179,10 @@ def generate_script(prompt: str) -> str:
         logger.error(f"Error generating script: {str(e)}")
         return f"1. Punto uno sobre {prompt}\n2. Punto dos\n3. Punto tres"
 
-async def generate_voice(text: str, output_file: str = "voice.mp3") -> bool:
-    """Genera narración de voz con manejo de errores"""
+async def generate_voice(text: str, voice_id: str, output_file: str = "voice.mp3") -> bool:
+    """Genera narración de voz"""
     try:
-        communicate = edge_tts.Communicate(text, voice="es-MX-DaliaNeural")
+        communicate = edge_tts.Communicate(text, voice=voice_id)
         await communicate.save(output_file)
         return True
     except Exception as e:
@@ -159,7 +190,7 @@ async def generate_voice(text: str, output_file: str = "voice.mp3") -> bool:
         return False
 
 def run_async(coro):
-    """Ejecuta corrutinas asíncronas desde código síncrono"""
+    """Ejecuta corrutinas asíncronas"""
     import asyncio
     loop = asyncio.new_event_loop()
     asyncio.set_event_loop(loop)
@@ -168,11 +199,16 @@ def run_async(coro):
     finally:
         loop.close()
 
-def create_video(prompt: str) -> Optional[str]:
+def create_video(
+    prompt: str,
+    custom_script: Optional[str] = None,
+    voice_choice: str = "es-MX-DaliaNeural",
+    music_file: Optional[str] = None
+) -> Optional[str]:
     """Función principal para crear el video"""
     try:
         # 1. Generar contenido
-        script = generate_script(prompt)
+        script = generate_script(prompt, custom_script)
         logger.info(f"Script generado: {script[:100]}...")
         
         # 2. Buscar videos
@@ -183,11 +219,20 @@ def create_video(prompt: str) -> Optional[str]:
             
         # 3. Generar voz
         voice_file = "voice.mp3"
-        if not run_async(generate_voice(script, voice_file)):
+        if not run_async(generate_voice(script, voice_choice, voice_file)):
             logger.error("No se pudo generar voz")
             return None
             
-        # 4. Procesar videos
+        # 4. Procesar música si existe
+        music_path = None
+        if music_file:
+            audio_clip = AudioFileClip(voice_file)
+            target_duration = audio_clip.duration
+            audio_clip.close()
+            
+            music_path = process_music(music_file.name, target_duration)
+            
+        # 5. Procesar videos
         output_dir = "output"
         os.makedirs(output_dir, exist_ok=True)
         output_path = os.path.join(output_dir, f"video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4")
@@ -204,10 +249,17 @@ def create_video(prompt: str) -> Optional[str]:
             logger.error("No se pudieron procesar los videos")
             return None
             
-        # 5. Ensamblar video final
+        # 6. Ensamblar video final
         final_video = concatenate_videoclips(clips, method="compose")
-        audio_clip = AudioFileClip(voice_file)
-        final_video = final_video.set_audio(audio_clip)
+        voice_audio = AudioFileClip(voice_file)
+        
+        if music_path:
+            music_audio = AudioFileClip(music_path)
+            final_audio = CompositeAudioClip([voice_audio, music_audio.volumex(0.3)])
+        else:
+            final_audio = voice_audio
+            
+        final_video = final_video.set_audio(final_audio)
         
         final_video.write_videofile(
             output_path,
@@ -229,31 +281,68 @@ def create_video(prompt: str) -> Optional[str]:
             clip.close()
         if os.path.exists(voice_file):
             os.remove(voice_file)
+        if music_path and os.path.exists(music_path):
+            os.remove(music_path)
         for i in range(len(video_urls)):
             if os.path.exists(f"segment_{i}.mp4"):
                 os.remove(f"segment_{i}.mp4")
 
-# Interfaz Gradio optimizada
-with gr.Blocks(title="Generador de Videos HF", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🎥 Generador Automático de Videos")
+# Interfaz Gradio completa
+with gr.Blocks(title="Generador de Videos Avanzado", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎬 Generador de Videos con IA")
     
     with gr.Row():
         with gr.Column():
             prompt_input = gr.Textbox(
                 label="Tema del video",
-                placeholder="Ej: Paisajes naturales de Chile",
+                placeholder="Ej: Lugares turísticos de Argentina",
                 max_lines=2
             )
+            
+            custom_script_input = gr.TextArea(
+                label="Guion personalizado (opcional)",
+                placeholder="Pega aquí tu propio guion si lo tienes...",
+                lines=5
+            )
+            
+            voice_dropdown = gr.Dropdown(
+                label="Selecciona una voz",
+                choices=list(VOICES.keys()),
+                value="Femenino MX"
+            )
+            
+            music_input = gr.File(
+                label="Música de fondo (opcional)",
+                type="file",
+                file_types=["audio"]
+            )
+            
             generate_btn = gr.Button("Generar Video", variant="primary")
             
         with gr.Column():
-            output_video = gr.Video(label="Resultado", interactive=False)
+            output_video = gr.Video(
+                label="Video Resultante",
+                interactive=False,
+                format="mp4"
+            )
     
     generate_btn.click(
         fn=create_video,
-        inputs=prompt_input,
+        inputs=[
+            prompt_input,
+            custom_script_input,
+            gr.Dropdown(value="es-MX-DaliaNeural", visible=False),  # Valor real de voz
+            music_input
+        ],
         outputs=output_video
     )
+    
+    # Actualizar el valor de voz real cuando cambia el dropdown
+    voice_dropdown.change(
+        lambda x: VOICES[x],
+        inputs=voice_dropdown,
+        outputs=gr.Dropdown(visible=False)
+    )
 
 # Para Hugging Face Spaces
 if __name__ == "__main__":