Update app_vince.py

app_vince.py

@@ -1,194 +1,181 @@
 #!/usr/bin/env python3
 """
-VINCIE Service UI (Gradio) - Versão Final com Suporte a Multi-GPU
-
-- Interface com 3 abas: Edição Multi-Turno, Texto-para-Vídeo e Composição Multi-Conceito.
-- Controles avançados na UI, incluindo seleção de número de GPUs e tamanho do lote (batch size).
-- Configuração automática no carregamento da aplicação.
-- Projetado para hardware de ponta como 8x L40S.
-- Modelo funcional de referência: ByteDance-Seed/VINCIE.
-- Interface desenvolvida por Carlex ([email protected]).
+VINCIE Service UI (Gradio)
+- Automatic setup runs on app load (no manual setup button).
+- Multi-turn editing and multi-concept composition front-end.
+- Designed for NVIDIA L40S (SM 8.9) environments aligned with CUDA 12.x.
+- Functional reference: ByteDance-Seed/VINCIE.
+- Space and Docker developed by Carlex (contact below).
 """
 
 import os
 from pathlib import Path
 from typing import List, Tuple, Optional
+
 import gradio as gr
 
-# Adapte este import para o layout do seu projeto, se necessário.
-from services.vincie import VincieService
+# Adapt this import to the project layout.
+# Provide a VincieService with:
+#  - ensure_repo(): clones/updates upstream repo if missing
+#  - ensure_model(): downloads/validates checkpoints to /app/ckpt/VINCIE-3B
+#  - multi_turn_edit(image_path: str, turns: List[str]) -> str (output dir)
+#  - multi_concept_compose(files: List[str], descs: List[str], final_prompt: str) -> str (output dir)
+from services.vincie import VincieService  # change path if needed
 
-# --- Instanciação do Serviço e Constantes ---
+# Instantiate the service (defaults to /app/VINCIE and /app/ckpt/VINCIE-3B)
 svc = VincieService()
-DEFAULT_NEGATIVE_PROMPT = "Worst quality, Normal quality, Low quality, Low res, Blurry, Jpeg artifacts, Grainy, text, logo, watermark, banner, extra digits, signature, subtitling, Bad anatomy, Bad proportions, Deformed, Disconnected limbs, Disfigured, Extra arms, Extra limbs, Extra hands, Fused fingers, Gross proportions, Long neck, Malformed limbs, Mutated, Mutated hands, Mutated limbs, Missing arms, Missing fingers, Poorly drawn hands, Poorly drawn face, Nsfw, Uncensored, Cleavage, Nude, Nipples, Overexposed, Plain background, Grainy, Underexposed, Deformed structures"
 
-# --- Funções Helper ---
+
 def setup_auto() -> str:
     """
-    Executa uma configuração idempotente no carregamento da interface.
-    Retorna uma string de status para a UI.
+    Run an idempotent setup on interface load:
+    - Ensure the upstream repository is present and ready.
+    - Ensure the model checkpoint is downloaded and ready.
+    Returns an English status string for the UI. 
     """
     try:
         svc.ensure_repo()
         svc.ensure_model()
-        return "Configuração concluída com sucesso: repositório e checkpoint estão prontos."
+        return (
+            "Setup completed successfully: repository and checkpoint are ready "
+            "for inference on an NVIDIA L40S environment."
+        )
     except Exception as e:
-        # Fornece um feedback de erro mais detalhado para depuração
-        import traceback
-        print(traceback.format_exc())
-        return f"A configuração encontrou um erro: {e}"
+        return f"Setup encountered an error: {e}"
+
 
 def _list_media(out_dir: Path, max_images: int = 24) -> Tuple[List[str], Optional[str]]:
     """
-    Enumera as imagens resultantes e o vídeo mais recente de um diretório de saída.
+    Enumerate resulting images and the most recent video from an output directory.
+
+    Args:
+        out_dir: Path to the directory where the service wrote its results.
+        max_images: Upper bound on how many images to surface in the gallery.
+
+    Returns:
+        A tuple (images, video) where:
+          - images is a list of file paths to images sorted by modified time,
+          - video is the path to the latest .mp4 if found, otherwise None.
     """
     img_globs = ("*.png", "*.jpg", "*.jpeg", "*.webp")
-    # Usa rglob para encontrar imagens em subdiretórios e ordena por tempo de modificação
-    images = sorted(
-        [p for pat in img_globs for p in out_dir.rglob(pat)],
-        key=lambda p: p.stat().st_mtime
-    )
-    image_paths = [str(p) for p in images[-max_images:]]
+    images: List[Path] = []
+    for pat in img_globs:
+        images += list(out_dir.rglob(pat))
+    images = sorted(images, key=lambda p: p.stat().st_mtime)
+    image_paths = [str(p) for p in images[-max_images:]] if images else []
     videos = sorted(out_dir.rglob("*.mp4"), key=lambda p: p.stat().st_mtime)
     video_path = str(videos[-1]) if videos else None
     return image_paths, video_path
 
-# --- Funções Handler da UI (com todos os parâmetros) ---
-def ui_multi_turn(input_image, turns_text, negative_prompt, seed, steps, cfg_scale, resolution, use_vae_slicing, num_gpus, batch_size):
-    """Handler para a aba de Edição Multi-Turno."""
-    if not input_image:
-        return [], None, "Por favor, forneça uma imagem de entrada."
+
+def ui_multi_turn(input_image: Optional[str], turns_text: Optional[str]):
+    """
+    Multi-turn image editing entrypoint for the UI.
+
+    Args:
+        input_image: Path to a single input image on disk.
+        turns_text: User-provided editing turns, one instruction per line.
+
+    Returns:
+        (gallery, video, status) for Gradio components.
+    """
+    if not input_image or not str(input_image).strip():
+        return [], None, "Please provide an input image."
     if not turns_text or not turns_text.strip():
-        return [], None, "Por favor, forneça as instruções de edição (uma por linha)."
+        return [], None, "Please provide edit turns (one per line)."
 
     turns = [ln.strip() for ln in turns_text.splitlines() if ln.strip()]
     try:
-        out_dir = svc.multi_turn_edit(
-            input_image, turns,
-            negative_prompt=negative_prompt, seed=int(seed), steps=int(steps), 
-            cfg_scale=float(cfg_scale), resolution=int(resolution), use_vae_slicing=use_vae_slicing,
-            num_gpus=int(num_gpus), batch_size=int(batch_size)
-        )
-        imgs, vid = _list_media(Path(out_dir))
-        return imgs, vid, f"Saídas salvas em: {out_dir}"
+        out_dir = svc.multi_turn_edit(input_image, turns)
     except Exception as e:
-        import traceback
-        print(traceback.format_exc())
-        return [], None, f"Erro na geração: {e}"
+        return [], None, f"Generation error: {e}"
 
-def ui_text_to_video(input_image, prompt, negative_prompt, seed, steps, cfg_scale, resolution, fps, use_vae_slicing, num_gpus, batch_size):
-    """Handler para a aba de Texto-para-Vídeo."""
-    if not input_image:
-        return None, "Por favor, forneça uma imagem de entrada (frame inicial)."
-    if not prompt or not prompt.strip():
-        return None, "Por favor, forneça um prompt para o vídeo."
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Outputs saved to: {out_dir}"
+    return imgs, vid, status
+
+
+def ui_multi_concept(files: Optional[List[str]], descs_text: Optional[str], final_prompt: Optional[str]):
+    """
+    Multi-concept composition entrypoint for the UI.
+
+    Args:
+        files: List of paths to concept images on disk.
+        descs_text: Per-image descriptions (one line per image, in the same order).
+        final_prompt: A final composition prompt that aggregates the concepts.
+
+    Returns:
+        (gallery, video, status) for Gradio components.
+    """
+    if not files:
+        return [], None, "Please upload concept images."
+    if not descs_text or not descs_text.strip():
+        return [], None, "Please provide descriptions (one per line)."
+    if not final_prompt or not final_prompt.strip():
+        return [], None, "Please provide a final prompt."
 
-    try:
-        out_dir = svc.text_to_video(
-            input_image, prompt,
-            negative_prompt=negative_prompt, seed=int(seed), steps=int(steps), 
-            cfg_scale=float(cfg_scale), resolution=int(resolution), fps=int(fps), use_vae_slicing=use_vae_slicing,
-            num_gpus=int(num_gpus), batch_size=int(batch_size)
-        )
-        _, vid = _list_media(Path(out_dir))
-        return vid, f"Vídeo salvo em: {out_dir}"
-    except Exception as e:
-        import traceback
-        print(traceback.format_exc())
-        return None, f"Erro na geração: {e}"
-
-def ui_multi_concept(files, descs_text, final_prompt):
-    """Handler para a aba de Composição Multi-Conceito."""
-    if not files: return [], None, "Por favor, faça o upload das imagens de conceito."
-    if not descs_text: return [], None, "Por favor, forneça as descrições (uma por linha)."
-    if not final_prompt: return [], None, "Por favor, forneça um prompt final."
-    
     descs = [ln.strip() for ln in descs_text.splitlines() if ln.strip()]
-    if len(descs) != len(files): return [], None, f"O número de descrições ({len(descs)}) deve ser igual ao de imagens ({len(files)})."
+    if len(descs) != len(files):
+        return [], None, f"Descriptions count ({len(descs)}) must match images count ({len(files)})."
 
     try:
         out_dir = svc.multi_concept_compose(files, descs, final_prompt)
-        imgs, vid = _list_media(Path(out_dir))
-        return imgs, vid, f"Saídas salvas em: {out_dir}"
     except Exception as e:
-        import traceback
-        print(traceback.format_exc())
-        return [], None, f"Erro na geração: {e}"
-
-# --- Definição da Interface Gradio Completa ---
-with gr.Blocks(title="VINCIE Service", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# VINCIE Service — Geração Distribuída com Controles Avançados")
-    gr.Markdown("- **Interface por:** Carlex ([email protected] | GitHub: carlex22)")
+        return [], None, f"Generation error: {e}"
+
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Outputs saved to: {out_dir}"
+    return imgs, vid, status
+
+
+with gr.Blocks(title="VINCIE Service") as demo:
+    # Header and credits
+    gr.Markdown(
+        "\n".join(
+            [
+                "# VINCIE Service — Multi-turn Editing and Multi-concept Composition",
+                "- Automatic setup runs at startup; setup status appears below.",
+                "- Hardware requirement: NVIDIA L40S (SM 8.9) is recommended for this build.",
+                "- Functional upstream model: ByteDance-Seed/VINCIE (see project repository).",
+                "- Space and Docker were developed by Carlex.",
+                "- Contact: Email: [email protected] | GitHub: carlex22",
+            ]
+        )
+    )
+
     with gr.Row():
-        setup_out = gr.Textbox(label="Status da Configuração", interactive=False)
+        setup_out = gr.Textbox(label="Setup Status", interactive=False)
 
-    with gr.Tab("Edição Multi-Turno"):
-        with gr.Row():
-            img_mt = gr.Image(type="filepath", label="Imagem de Entrada")
-            with gr.Column():
-                turns_mt = gr.Textbox(lines=5, label="Instruções de Edição (uma por linha)", placeholder="Ex: adicione um chapéu azul\nagora, mude o fundo para uma praia")
-                with gr.Accordion("Configurações Avançadas e de Desempenho", open=True):
-                    with gr.Row():
-                        num_gpus_mt = gr.Slider(label="Número de GPUs", minimum=1, maximum=8, step=1, value=8, info="Use >1 para acelerar a geração com torchrun.")
-                        batch_size_mt = gr.Number(label="Batch Size por GPU", value=1, precision=0, info="Para Multi-GPU, o lote total será (GPUs x Batch Size).")
-                    resolution_mt = gr.Slider(label="Resolução", minimum=256, maximum=1024, step=128, value=512, info="Maior resolução exige mais VRAM e tempo.")
-                    use_vae_slicing_mt = gr.Checkbox(label="Usar VAE Slicing (Economiza VRAM)", value=True)
-                    neg_prompt_mt = gr.Textbox(lines=3, label="Prompt Negativo", value=DEFAULT_NEGATIVE_PROMPT)
-                    seed_mt = gr.Number(label="Seed (Semente)", value=1, precision=0)
-                    steps_mt = gr.Slider(label="Passos de Inferência", minimum=10, maximum=100, step=1, value=50, info="Menos passos = mais rápido.")
-                    cfg_mt = gr.Slider(label="Escala de Orientação (CFG)", minimum=1.0, maximum=20.0, step=0.5, value=7.5, info="Quão forte o modelo segue o prompt.")
-        run_mt = gr.Button("Executar Edição Multi-Turno", variant="primary")
-        gallery_mt = gr.Gallery(label="Imagens Geradas", columns=4, height="auto")
-        video_mt = gr.Video(label="Vídeo da Sequência (se disponível)")
-        status_mt = gr.Textbox(label="Status da Saída", interactive=False)
-        run_mt.click(ui_multi_turn,
-                     inputs=[img_mt, turns_mt, neg_prompt_mt, seed_mt, steps_mt, cfg_mt, resolution_mt, use_vae_slicing_mt, num_gpus_mt, batch_size_mt],
-                     outputs=[gallery_mt, video_mt, status_mt])
-
-    with gr.Tab("Texto-para-Vídeo"):
-        with gr.Row():
-            img_vid = gr.Image(type="filepath", label="Frame Inicial")
-            with gr.Column():
-                prompt_vid = gr.Textbox(lines=2, label="Prompt do Vídeo", placeholder="Ex: um gato andando pela sala")
-                with gr.Accordion("Configurações Avançadas e de Desempenho", open=True):
-                    with gr.Row():
-                        num_gpus_vid = gr.Slider(label="Número de GPUs", minimum=1, maximum=8, step=1, value=8, info="Use >1 para acelerar a geração com torchrun.")
-                        batch_size_vid = gr.Number(label="Batch Size por GPU", value=1, precision=0, info="Para Multi-GPU, o lote total será (GPUs x Batch Size).")
-                    resolution_vid = gr.Slider(label="Resolução", minimum=256, maximum=1024, step=128, value=512)
-                    fps_vid = gr.Slider(label="Frames por Segundo (FPS)", minimum=1, maximum=24, step=1, value=2)
-                    use_vae_slicing_vid = gr.Checkbox(label="Usar VAE Slicing (Economiza VRAM)", value=True)
-                    neg_prompt_vid = gr.Textbox(lines=3, label="Prompt Negativo", value=DEFAULT_NEGATIVE_PROMPT)
-                    seed_vid = gr.Number(label="Seed (Semente)", value=1, precision=0)
-                    steps_vid = gr.Slider(label="Passos de Inferência", minimum=10, maximum=100, step=1, value=50)
-                    cfg_vid = gr.Slider(label="Escala de Orientação (CFG)", minimum=1.0, maximum=20.0, step=0.5, value=7.5)
-        run_vid = gr.Button("Gerar Vídeo", variant="primary")
-        video_vid = gr.Video(label="Vídeo Gerado")
-        status_vid = gr.Textbox(label="Status da Saída", interactive=False)
-        run_vid.click(ui_text_to_video,
-                      inputs=[img_vid, prompt_vid, neg_prompt_vid, seed_vid, steps_vid, cfg_vid, resolution_vid, fps_vid, use_vae_slicing_vid, num_gpus_vid, batch_size_vid],
-                      outputs=[video_vid, status_vid])
-
-    with gr.Tab("Composição Multi-Conceito"):
-        gr.Markdown("Nota: A composição multi-conceito está atualmente configurada para rodar em uma única GPU para garantir estabilidade.")
+    with gr.Tab("Multi-turn Editing"):
         with gr.Row():
-            with gr.Column(scale=1):
-                files_mc = gr.File(file_count="multiple", type="filepath", label="1. Imagens de Conceito")
-            with gr.Column(scale=2):
-                descs_mc = gr.Textbox(lines=5, label="2. Descrições (uma por linha, na mesma ordem)", placeholder="Ex: <IMG1>: uma foto de um pai\n<IMG2>: uma foto de uma mãe...")
-                final_prompt_mc = gr.Textbox(lines=3, label="3. Prompt Final de Composição", placeholder="Ex: Baseado em <IMG0>, <IMG1>..., uma família sorrindo em um retrato...")
-        run_mc = gr.Button("Executar Composição", variant="primary")
-        gallery_mc = gr.Gallery(label="Imagens Geradas", columns=4, height="auto")
-        video_mc = gr.Video(label="Vídeo da Sequência (se disponível)")
-        status_mc = gr.Textbox(label="Status da Saída", interactive=False)
-        run_mc.click(ui_multi_concept,
-                     inputs=[files_mc, descs_mc, final_prompt_mc],
-                     outputs=[gallery_mc, video_mc, status_mc])
-
-    # Gatilho de configuração automática no carregamento
+            img = gr.Image(type="filepath", label="Input image")
+            turns = gr.Textbox(lines=8, label="Turns (one per line)")
+        run1 = gr.Button("Run")
+        out_gallery = gr.Gallery(label="Images", columns=4, height="auto")
+        out_video = gr.Video(label="Video (if available)")
+        out_status = gr.Textbox(label="Output", interactive=False)
+        run1.click(ui_multi_turn, inputs=[img, turns], outputs=[out_gallery, out_video, out_status])
+
+    with gr.Tab("Multi-concept Composition"):
+        files = gr.File(file_count="multiple", type="filepath", label="Concept images")
+        descs = gr.Textbox(lines=8, label="Descriptions (one per line, same order as images)")
+        final_prompt = gr.Textbox(lines=2, label="Final prompt")
+        run2 = gr.Button("Run")
+        out_gallery2 = gr.Gallery(label="Images", columns=4, height="auto")
+        out_video2 = gr.Video(label="Video (if available)")
+        out_status2 = gr.Textbox(label="Output", interactive=False)
+        run2.click(
+            ui_multi_concept,
+            inputs=[files, descs, final_prompt],
+            outputs=[out_gallery2, out_video2, out_status2],
+        )
+
+    # Auto-setup on load (no manual button)
     demo.load(fn=setup_auto, outputs=setup_out)
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=int(os.getenv("PORT", "7860")),
-    )
+        allowed_paths=["/app/outputs", "/app/ckpt"],
+    )