Update app_vince.py

app_vince.py

@@ -1,201 +1,181 @@
 #!/usr/bin/env python3
+"""
+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
 
-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
 
+# Instantiate the service (defaults to /app/VINCIE and /app/ckpt/VINCIE-3B)
 svc = VincieService()
-svc.repo_dir = Path(svc.repo_dir)
-svc.ckpt_dir = Path(svc.ckpt_dir)
-
-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"
-)
+
 
 def setup_auto() -> str:
+    """
+    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:
-        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]]:
+    """
+    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")
-    try:
-        images = sorted(
-            [p for pat in img_globs for p in out_dir.rglob(pat)],
-            key=lambda p: p.stat().st_mtime
-        )
-    except FileNotFoundError:
-        images = []
-    image_paths = [str(p) for p in images[-max_images:]]
-    try:
-        videos = sorted(out_dir.rglob("*.mp4"), key=lambda p: p.stat().st_mtime)
-    except FileNotFoundError:
-        videos = []
+    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
 
-def ui_multi_turn(input_image, turns_text, negative_prompt, seed, steps, cfg_scale, resolution, use_vae_slicing, num_gpus, batch_size):
-    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}"
-    except Exception as e:
-        import traceback
-        print(traceback.format_exc())
-        return [], None, f"Erro na geração: {e}"
-
-def ui_text_to_video(input_image, prompt, negative_prompt, seed, steps, cfg_scale, resolution, fps, use_vae_slicing, num_gpus, batch_size):
-    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."
-    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}"
+        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}"
+
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Outputs saved to: {out_dir}"
+    return imgs, vid, status
 
-def ui_multi_concept(files, descs_text, final_prompt):
+
+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, "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."
+        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."
+
     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)})."
+        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}"
+        return [], None, f"Generation error: {e}"
 
-with gr.Blocks(title="VINCIE Service", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# VINCIE Service — Geração Distribuída com Controles Avançados")
+    imgs, vid = _list_media(Path(out_dir))
+    status = f"Outputs saved to: {out_dir}"
+    return imgs, vid, status
 
-    with gr.Row():
-        setup_out = gr.Textbox(label="Status da Configuração", 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)
-                batch_size_mt = gr.Number(label="Batch Size por GPU", value=1, precision=0)
-                resolution_mt = gr.Slider(label="Resolução", minimum=256, maximum=1024, step=128, value=512)
-                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)
-                cfg_mt = gr.Slider(label="Escala de Orientação (CFG)", minimum=1.0, maximum=20.0, step=0.5, value=7.5)
-            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.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: Carlex22@gmail.com | GitHub: carlex22",
+            ]
         )
+    )
 
-    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)
-                batch_size_vid = gr.Number(label="Batch Size por GPU", value=1, precision=0)
-                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.Row():
+        setup_out = gr.Textbox(label="Setup Status", interactive=False)
 
-    with gr.Tab("Composição Multi-Conceito"):
+    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)")
-                final_prompt_mc = gr.Textbox(lines=3, label="3. Prompt Final de Composição")
-        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(
+            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_mc, descs_mc, final_prompt_mc],
-            outputs=[gallery_mc, video_mc, status_mc]
+            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")))
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", "7860")),
+        allowed_paths=["/app/outputs", "/app/ckpt"],
+    )