Update app.py

app.py

@@ -4,15 +4,11 @@ import subprocess
 import traceback
 from pathlib import Path
 
-# --- 1. INSTALACIÓN DE LIBRERÍAS ---
 def install_dependencies():
-    print("Instalando librerías necesarias...")
-    # Se eliminó 'spaces' de la lista
     commands = [
         "pip install spaces-0.1.0-py3-none-any.whl"
     ]
     for cmd in commands:
-        print(f"Ejecutando: {cmd}")
         os.system(cmd)
 
 install_dependencies()
@@ -24,7 +20,6 @@ import torch
 import gradio as gr
 from huggingface_hub import snapshot_download
 
-# Verificación de librerías críticas
 try:
     import diffusers
     import accelerate
@@ -35,41 +30,31 @@ except ImportError:
 
 import spaces
 
-# --- 2. Descarga del Modelo ---
 MODEL_ID = "tolgacangoz/Wan2.2-S2V-14B-Diffusers"
-print(f"Verificando modelo {MODEL_ID}...")
 try:
     LOCAL_DIR = snapshot_download(repo_id=MODEL_ID, repo_type="model")
-except Exception as e:
-    print(f"Error descargando modelo, usando ID remoto: {e}")
+except Exception:
     LOCAL_DIR = MODEL_ID
 
-# Variable global para el pipeline
 pipe = None
 
-# --- 3. Funciones Auxiliares ---
 def load_audio_for_model(audio_filepath):
-    """Carga el audio y lo prepara para el pipeline"""
     try:
         wav, sr = sf.read(audio_filepath)
-        # Convertir a float32 si es necesario
         if wav.dtype != np.float32:
             if np.issubdtype(wav.dtype, np.integer):
                 wav = wav.astype("float32") / 32768.0
             else:
                 wav = wav.astype("float32")
         
-        # Mezclar a mono si es estéreo
         if wav.ndim > 1:
             wav = wav.mean(axis=1)
             
         return wav, sr
-    except Exception as e:
-        print(f"Error cargando audio: {e}")
+    except Exception:
         return None, None
 
 def to_pil(image):
-    """Convierte cualquier entrada a PIL Image RGB"""
     if image is None: return None
     if isinstance(image, Image.Image): return image.convert("RGB")
     if isinstance(image, str): return Image.open(image).convert("RGB")
@@ -77,86 +62,68 @@ def to_pil(image):
     return Image.fromarray(arr).convert("RGB")
 
 def merge_audio_video(video_path, audio_path, output_path):
-    """Combina el video generado con el audio original usando FFmpeg"""
-    print("Combinando audio y video...")
     cmd = [
         "ffmpeg", "-y",
-        "-i", video_path,       # Video input
-        "-i", audio_path,       # Audio input
-        "-c:v", "copy",         # Copiar stream de video (no re-codificar)
-        "-c:a", "aac",          # Codificar audio a AAC
-        "-map", "0:v:0",        "-map", "1:a:0",
-        "-shortest",            # Cortar al más corto
+        "-i", video_path,
+        "-i", audio_path,
+        "-c:v", "copy",
+        "-c:a", "aac",
+        "-map", "0:v:0", "-map", "1:a:0",
+        "-shortest",
         output_path
     ]
     subprocess.run(cmd, check=True)
     return output_path
 
-# --- 4. Generación ---
-# Se eliminó el decorador @spaces.GPU
 @spaces.GPU(duration=120)
-def generate_video(image_input, audio_filepath):
+def generate_video(image_input, audio_filepath, prompt):
     global pipe
     
-    # 1. Validaciones
     if image_input is None or audio_filepath is None:
-        raise gr.Error("Por favor sube una imagen y un audio.")
+        raise gr.Error("Error inputs")
 
-    print(f"Procesando audio: {audio_filepath}")
-    
     try:
-        # 2. Carga del Modelo (Lazy Loading)
         if pipe is None:
-            print("Cargando pipeline en memoria...")
             from diffusers import WanSpeechToVideoPipeline
             
-            # Se eliminaron las comprobaciones explícitas de CUDA/CPU/Device map
-            # El pipeline usará la configuración por defecto de torch/accelerate
             pipe = WanSpeechToVideoPipeline.from_pretrained(
                 LOCAL_DIR,
                 use_safetensors=True
             )
 
-        # 3. Preparar inputs
         audio_values, sample_rate = load_audio_for_model(audio_filepath)
         init_image = to_pil(image_input)
         
-        # Redimensionar imagen (múltiplos de 16)
         w, h = init_image.size
         w = (w // 16) * 16
         h = (h // 16) * 16
         init_image = init_image.resize((w, h), Image.LANCZOS)
 
-        print("Iniciando inferencia...")
-        
-        # 4. Inferencia
         out = pipe(
             image=init_image,
             audio=audio_values,
             num_inference_steps=25,
-            guidance_scale=4.0
+            guidance_scale=4.0,
+            sampling_rate=sample_rate,
+            prompt=prompt
         )
         
         frames = out.frames[0]
 
-        # 5. Exportar Video Mudo Temporal
         temp_mute_video = "temp_mute.mp4"
         final_video = "output_s2v.mp4"
         
         from diffusers.utils import export_to_video
         export_to_video(frames, temp_mute_video, fps=16)
         
-        # 6. Añadir Audio
         final_output = merge_audio_video(temp_mute_video, audio_filepath, final_video)
         
         return final_output
 
     except Exception as e:
-        print("ERROR CRÍTICO DURANTE LA GENERACIÓN:")
         traceback.print_exc()
-        raise gr.Error(f"Error generando video: {str(e)}")
+        raise gr.Error(str(e))
 
-# --- 5. Interfaz Gradio ---
 with gr.Blocks(title="Wan2.1 Speech to Video") as demo:
     gr.Markdown("# Wan2.2-S2V Generador de Video")
     
@@ -164,6 +131,7 @@ with gr.Blocks(title="Wan2.1 Speech to Video") as demo:
         with gr.Column():
             img_input = gr.Image(label="Imagen de referencia", type="pil")
             audio_input = gr.Audio(label="Audio (.wav)", type="filepath")
+            prompt_input = gr.Textbox(label="Prompt")
             btn = gr.Button("Generar Video", variant="primary")
         
         with gr.Column():
@@ -171,7 +139,7 @@ with gr.Blocks(title="Wan2.1 Speech to Video") as demo:
 
     btn.click(
         fn=generate_video, 
-        inputs=[img_input, audio_input], 
+        inputs=[img_input, audio_input, prompt_input], 
         outputs=video_output
     )