Update app.py

app.py

@@ -2,163 +2,180 @@ import gradio as gr
 import subprocess
 import os
 import sys
-import threading
-from huggingface_hub import snapshot_download
-
-# --- 1. CONFIGURAÇÃO INICIAL (Executa apenas uma vez) ---
-
-# Diretório base para o projeto SeedVR
-SEEDVR_DIR = "SeedVR"
-
-def setup():
+import time
+from threading import Thread
+from queue import Queue, Empty
+
+# --- 1. CONFIGURAÇÃO E INSTALAÇÃO AUTOMÁTICA ---
+# Esta parte do código é executada apenas uma vez quando o Space inicia.
+
+INSTALLATION_FLAG = ".installation_complete"
+SEEDVR_REPO_DIR = "SeedVR"
+
+def run_subprocess(command, cwd=None):
+    """Executa um comando de subprocesso e imprime a saída em tempo real."""
+    print(f"Executando comando: {' '.join(command)}")
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, cwd=cwd)
+    while True:
+        output = process.stdout.readline()
+        if output == '' and process.poll() is not None:
+            break
+        if output:
+            print(output.strip())
+    rc = process.poll()
+    if rc != 0:
+        raise RuntimeError(f"Comando falhou com código de saída {rc}: {' '.join(command)}")
+
+def setup_environment():
     """
-    Clona o repositório, instala dependências especiais e baixa o modelo.
-    Esta função é executada uma vez quando o Space é iniciado.
+    Traduz os comandos do manual do SeedVR para o ambiente do Hugging Face Spaces.
+    1. Clona o repositório.
+    2. Instala dependências especiais.
+    3. Cria um "flag" para não repetir a instalação.
     """
-    print("--- Iniciando configuração do ambiente ---")
+    print("--- Verificando o ambiente de instalação ---")
     
-    # Etapa 1: Clonar o repositório SeedVR se ainda não existir
-    if not os.path.exists(SEEDVR_DIR):
-        print(f"Clonando o repositório SeedVR de https://github.com/bytedance-seed/SeedVR.git...")
-        subprocess.run(["git", "clone", "https://github.com/bytedance-seed/SeedVR.git"], check=True)
+    # Se a instalação já foi feita, não faz nada.
+    if os.path.exists(INSTALLATION_FLAG):
+        print("Ambiente já configurado. Pulando a instalação.")
+        return
+
+    print("--- Iniciando configuração pela primeira vez ---")
+
+    # Comando 1: git clone ...
+    if not os.path.exists(SEEDVR_REPO_DIR):
+        run_subprocess(["git", "clone", "https://github.com/bytedance-seed/SeedVR.git"])
     else:
         print("Repositório SeedVR já existe.")
-        
-    # Mudando para o diretório do projeto para os próximos comandos
-    os.chdir(SEEDVR_DIR)
 
-    # Etapa 2: Instalar dependências que exigem comandos específicos
-    print("Instalando flash_attn...")
-    subprocess.run([sys.executable, "-m", "pip", "install", "flash_attn==2.5.9.post1", "--no-build-isolation"], check=True)
+    # Comandos 2 e 3: conda create/activate (substituído pelo `python_version: 3.10` no README.md)
+    print("Versão do Python já definida pelo Hugging Face Spaces.")
     
-    # Nota sobre o Apex: O arquivo .whl precisa estar no seu repositório Hugging Face
-    apex_whl_path = "apex-0.1-cp310-cp310-linux_x86_64.whl"
-    if os.path.exists(apex_whl_path):
-        print(f"Instalando {apex_whl_path}...")
-        subprocess.run([sys.executable, "-m", "pip", "install", apex_whl_path], check=True)
-    else:
-        print(f"AVISO: Arquivo '{apex_whl_path}' não encontrado. A instalação do Apex foi pulada. Por favor, adicione este arquivo ao seu repositório.")
-
-    # Etapa 3: Baixar o modelo do Hugging Face Hub
-    save_dir = "ckpts/"
-    repo_id = "ByteDance-Seed/SeedVR2-3B"
-    cache_dir = os.path.join(save_dir, "cache")
-
-    if not os.path.exists(os.path.join(save_dir, "README.md")): # Checa se o download já foi feito
-        print(f"Baixando o modelo '{repo_id}' para '{save_dir}'...")
-        snapshot_download(
-            cache_dir=cache_dir,
-            local_dir=save_dir,
-            repo_id=repo_id,
-            local_dir_use_symlinks=False,
-            resume_download=True,
-            allow_patterns=["*.json", "*.safetensors", "*.pth", "*.bin", "*.py", "*.md", "*.txt"],
-        )
-    else:
-        print("Modelo já foi baixado.")
+    # Comando 4: pip install -r requirements.txt (já foi executado pelo Hugging Face)
+    print("Dependências do requirements.txt já instaladas.")
+
+    # Comando 5: pip install flash_attn... (instalação especial)
+    print("Instalando flash_attn com flags especiais...")
+    # Usamos sys.executable para garantir que estamos usando o pip do ambiente correto
+    flash_attn_command = [
+        sys.executable, "-m", "pip", "install", 
+        "flash_attn==2.5.9.post1", "--no-build-isolation"
+    ]
+    run_subprocess(flash_attn_command)
 
-    print("--- Configuração do ambiente concluída ---")
-    # Retornar ao diretório raiz original
-    os.chdir("..")
+    print("--- Configuração do ambiente concluída com sucesso! ---")
 
-# Executa a configuração
-setup()
+    # Cria o arquivo de flag para indicar que a instalação foi concluída
+    with open(INSTALLATION_FLAG, "w") as f:
+        f.write("OK")
 
-# --- 2. LÓGICA DA INFERÊNCIA ---
+# Executa a função de configuração
+setup_environment()
 
-def run_inference(video_path, seed, res_h, res_w, sp_size, progress=gr.Progress(track_tqdm=True)):
-    """
-    Executa o script de inferência do SeedVR usando torchrun.
-    """
-    if video_path is None:
-        return None, "Por favor, faça o upload de um arquivo de vídeo de entrada."
+# O restante do código do app (interface Gradio, download do modelo, inferência)
+# continuaria aqui, como na resposta anterior.
+from huggingface_hub import snapshot_download
+
+# --- 2. LÓGICA DA APLICAÇÃO (DOWNLOAD DO MODELO E INFERÊNCIA) ---
+
+# Baixar o modelo (fora da função de inferência para não baixar toda vez)
+CKPTS_DIR = os.path.join(SEEDVR_REPO_DIR, "ckpts")
+if not os.path.exists(os.path.join(CKPTS_DIR, "README.md")):
+    print("Baixando o modelo SeedVR2-3B...")
+    snapshot_download(
+        repo_id="ByteDance-Seed/SeedVR2-3B",
+        local_dir=CKPTS_DIR,
+        local_dir_use_symlinks=False,
+        resume_download=True,
+        allow_patterns=["*.json", "*.safetensors", "*.pth", "*.bin", "*.py", "*.md", "*.txt"],
+    )
+else:
+    print("Modelo já foi baixado.")
+
+def run_inference_app(video_file, seed_num):
+    if video_file is None:
+        return None, "Por favor, envie um arquivo de vídeo."
+    
+    # Salva o arquivo de entrada em uma pasta temporária
+    input_folder = "inputs"
+    os.makedirs(input_folder, exist_ok=True)
+    input_video_path = os.path.join(input_folder, os.path.basename(video_file.name))
+    with open(input_video_path, "wb") as f_out, open(video_file.name, "rb") as f_in:
+        f_out.write(f_in.read())
         
-    input_folder = os.path.dirname(video_path.name)
     output_folder = "outputs"
     os.makedirs(output_folder, exist_ok=True)
     
-    # Determinar o número de GPUs disponíveis. Para 4xL40s, será 4.
-    num_gpus = 4
-
+    # Comando de inferência do SeedVR
+    # Usando 4 GPUs, como especificado no hardware 4xL40s
     command = [
-        "torchrun",
-        f"--nproc-per-node={num_gpus}",
+        "torchrun", "--nproc-per-node=4",
         "projects/inference_seedvr2_3b.py",
-        "--video_path", input_folder,
-        "--output_dir", f"../{output_folder}", # Navega para fora do dir SeedVR
-        "--seed", str(seed),
-        "--res_h", str(res_h),
-        "--res_w", str(res_w),
-        "--sp_size", str(sp_size),
+        "--video_path", f"../{input_folder}",
+        "--output_dir", f"../{output_folder}",
+        "--seed", str(seed_num),
+        "--res_h", "320",
+        "--res_w", "512",
+        "--sp_size", "1"
     ]
 
-    log_output = ""
+    log_output = "Iniciando a inferência...\n" + ' '.join(command) + "\n\n"
+    
     try:
-        print(f"Executando comando: {' '.join(command)}")
-        # Executar o comando dentro do diretório SeedVR
         process = subprocess.Popen(
             command,
-            cwd=SEEDVR_DIR,
+            cwd=SEEDVR_REPO_DIR, # Executa o comando de dentro do diretório do repositório
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
             encoding='utf-8'
         )
 
-        # Capturar e exibir a saída em tempo real
         while True:
             line = process.stdout.readline()
             if not line:
                 break
             log_output += line
-            print(line, end='')
+            print(line.strip()) # Imprime no console do Space para debug
             yield None, log_output
 
         process.wait()
 
         if process.returncode != 0:
-            raise subprocess.CalledProcessError(process.returncode, command, output=log_output)
+            raise RuntimeError("O script de inferência falhou.")
         
-        # Encontrar os arquivos de vídeo gerados
-        result_files = [os.path.join(output_folder, f) for f in os.listdir(output_folder) if f.endswith(('.mp4', '.avi', '.mov'))]
-
+        # Encontra o vídeo gerado
+        result_files = [os.path.join(output_folder, f) for f in os.listdir(output_folder) if f.endswith('.mp4')]
         if not result_files:
-             return None, log_output + "\n\nERRO: Nenhum arquivo de vídeo foi gerado."
-
-        return result_files, log_output
+            return None, log_output + "\nERRO: Nenhum vídeo foi gerado."
+            
+        return result_files, log_output + "\n\nInferência concluída com sucesso!"
 
-    except subprocess.CalledProcessError as e:
-        error_message = f"Erro ao executar a inferência.\nOutput:\n{e.output}"
+    except Exception as e:
+        error_message = f"{log_output}\n\nOcorreu um erro: {str(e)}"
         print(error_message)
         return None, error_message
-    except Exception as e:
-        return None, f"Ocorreu um erro inesperado: {str(e)}"
 
-# --- 3. INTERFACE GRAPHEMICA (GRADIO) ---
+# --- 3. INTERFACE GRÁFICA (GRADIO) ---
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎥 Interface de Inferência para SeedVR2")
-    gr.Markdown("Faça o upload de um vídeo, ajuste os parâmetros e clique em 'Gerar Vídeo' para iniciar a inferência.")
+    gr.Markdown("# 🚀 Automação de Inferência para SeedVR2")
+    gr.Markdown("Envie um vídeo, clique em 'Gerar' e o processo de instalação e inferência será executado.")
 
     with gr.Row():
         with gr.Column(scale=1):
-            video_input = gr.File(label="Vídeo de Entrada (.mp4, .mov, etc.)")
-            seed_input = gr.Number(label="Seed", value=123)
-            res_h_input = gr.Number(label="Altura da Saída (res_h)", value=320)
-            res_w_input = gr.Number(label="Largura da Saída (res_w)", value=512)
-            sp_size_input = gr.Number(label="Tamanho do passo espacial (sp_size)", value=1)
-            
+            video_input = gr.File(label="Vídeo de Entrada")
+            seed_input = gr.Number(label="Seed", value=42)
             run_button = gr.Button("Gerar Vídeo", variant="primary")
 
         with gr.Column(scale=2):
-            gallery_output = gr.Gallery(label="Vídeo Gerado", show_label=True, elem_id="gallery")
-            log_display = gr.Textbox(label="Logs de Execução", lines=15, interactive=False)
-
+            gallery_output = gr.Gallery(label="Vídeo de Saída", show_label=True)
+            log_display = gr.Textbox(label="Logs de Execução", lines=15, interactive=False, autoscroll=True)
+            
     run_button.click(
-        fn=run_inference,
-        inputs=[video_input, seed_input, res_h_input, res_w_input, sp_size_input],
+        fn=run_inference_app,
+        inputs=[video_input, seed_input],
         outputs=[gallery_output, log_display]
     )
 
-if __name__ == "__main__":
-    demo.launch()
+demo.launch()