Update app.py

app.py

@@ -1,186 +1,57 @@
-# app.py (Versão com UI para Upscaler)
-
+#!/usr/bin/env python3
 import gradio as gr
-from PIL import Image
-import os
-import imageio
-
-# --- FUNÇÕES DE AJUDA PARA A UI ---
-TARGET_FIXED_SIDE = 768
-MIN_DIM_SLIDER = 256
-MAX_IMAGE_SIZE = 1280
+from pathlib import Path
+from typing import List
+from vincie_service import VincieService
 
-def calculate_new_dimensions(orig_w, orig_h):
-    if orig_w == 0 or orig_h == 0: return int(TARGET_FIXED_SIDE), int(TARGET_FIXED_SIDE)
-    if orig_w >= orig_h:
-        new_h, aspect_ratio = TARGET_FIXED_SIDE, orig_w / orig_h
-        new_w = round((new_h * aspect_ratio) / 32) * 32
-        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE)) 
-    else:
-        new_w, aspect_ratio = TARGET_FIXED_SIDE, orig_h / orig_w
-        new_h = round((new_w * aspect_ratio) / 32) * 32
-        new_h = max(MIN_DIM_SLIDER, min(new_h, MAX_IMAGE_SIZE))
-        new_w = max(MIN_DIM_SLIDER, min(new_w, MAX_IMAGE_SIZE))
-    return int(new_h), int(new_w)
+svc = VincieService()
 
-def handle_media_upload_for_dims(filepath, current_h, current_w):
-    if not filepath or not os.path.exists(str(filepath)): return gr.update(value=current_h), gr.update(value=current_w)
+def setup():
+    # opcional: preparar ambiente na primeira execução
     try:
-        if str(filepath).lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
-            with Image.open(filepath) as img:
-                orig_w, orig_h = img.size
-        else: # Assumir que é um vídeo
-            with imageio.get_reader(filepath) as reader:
-                meta = reader.get_meta_data()
-                orig_w, orig_h = meta.get('size', (current_w, current_h))
-        new_h, new_w = calculate_new_dimensions(orig_w, orig_h)
-        return gr.update(value=new_h), gr.update(value=new_w)
+        svc.ensure_repo()
+        svc.ensure_model()
     except Exception as e:
-        print(f"Erro ao processar mídia para dimensões: {e}")
-        return gr.update(value=current_h), gr.update(value=current_w)
-
-def update_frame_slider(duration):
-    fps = 24.0
-    max_frames = int(duration * fps)
-    new_value = 48 if max_frames >= 48 else max_frames // 2
-    return gr.update(maximum=max_frames, value=new_value)
-
-
-# --- FUNÇÃO WRAPPER PARA CHAMAR O SERVIÇO ---
-def gradio_generate_wrapper(
-    prompt, negative_prompt, mode,
-    start_image, middle_image, middle_frame, middle_weight, end_image, end_weight,
-    input_video, height, width, duration,
-    frames_to_use, seed, randomize_seed,
-    guidance_scale, enable_upscaler, adain_factor,
-    progress=gr.Progress(track_tqdm=True)
-):
-    try:
-        #output_path, used_seed = video_generation_service.generate(
-        #    prompt=prompt, negative_prompt=negative_prompt, mode=mode,
-        #    start_image_filepath=start_image,
-        #    middle_image_filepath=middle_image,
-        #    middle_frame_number=middle_frame,
-        #    middle_image_weight=middle_weight,
-        #    end_image_filepath=end_image,
-        #    end_image_weight=end_weight,
-        #    input_video_filepath=input_video,
-        #    height=int(height), width=int(width), duration=float(duration),
-        #    frames_to_use=int(frames_to_use), seed=int(seed),
-        #    randomize_seed=bool(randomize_seed), guidance_scale=float(guidance_scale),
-        #    enable_upscaler=bool(enable_upscaler),
-        #    adain_factor=float(adain_factor),
-        #    progress_callback=progress
-        #)
-        return None, None
-    except ValueError as e:
-        raise gr.Error(str(e))
-    except Exception as e:
-        print(f"Erro inesperado na geração: {e}")
-        raise gr.Error("Ocorreu um erro inesperado. Verifique os logs.")
-
-# --- DEFINIÇÃO DA INTERFACE GRADIO ---
-css = "#col-container { margin: 0 auto; max-width: 900px; }"
-with gr.Blocks(css=css) as demo:
-    gr.Markdown("# LTX Video com Keyframes e Latent Upscaler")
-    gr.Markdown("Gere vídeos em baixa resolução e opcionalmente duplique a resolução com um Upscaler.")
-
-    with gr.Row():
-        with gr.Column():
-            with gr.Tab("image-to-video (Keyframes)") as image_tab:
-                i2v_prompt = gr.Textbox(label="Prompt", value="Uma bela transição entre as imagens", lines=2)
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        gr.Markdown("#### Keyframe de Início (Obrigatório)")
-                        start_image_i2v = gr.Image(label="Imagem de Início", type="filepath", sources=["upload", "clipboard"])
-                    with gr.Column(scale=1):
-                        with gr.Accordion("Keyframe do Meio (Opcional)", open=False):
-                            middle_image_i2v = gr.Image(label="Imagem do Meio", type="filepath", sources=["upload", "clipboard"]); middle_frame_i2v = gr.Slider(label="Frame Alvo", minimum=0, maximum=200, step=1, value=48); middle_weight_i2v = gr.Slider(label="Peso/Força", minimum=0.0, maximum=1.0, step=0.05, value=1.0)
-                    with gr.Column(scale=1):
-                        with gr.Accordion("Keyframe de Fim (Opcional)", open=False):
-                            end_image_i2v = gr.Image(label="Imagem de Fim", type="filepath", sources=["upload", "clipboard"]); end_weight_i2v = gr.Slider(label="Peso/Força", minimum=0.0, maximum=1.0, step=0.05, value=1.0)
-                i2v_button = gr.Button("Generate Image-to-Video", variant="primary")
+        return f"Setup falhou: {e}"
+    return "Setup OK"
+
+def ui_multi_turn(input_image, turns_text):
+    if not input_image or not turns_text.strip():
+        return "Forneça imagem e turns (um por linha)."
+    turns = [ln.strip() for ln in turns_text.splitlines() if ln.strip()]
+    out_dir = svc.multi_turn_edit(input_image, turns)
+    return f"Gerado em: {str(out_dir)}"
+
+def ui_multi_concept(files, descs_text, final_prompt):
+    if not files or not descs_text.strip() or not final_prompt.strip():
+        return "Envie imagens, descrições (uma por linha) e o prompt final."
+    descs = [ln.strip() for ln in descs_text.splitlines() if ln.strip()]
+    if len(descs) != len(files):
+        return f"Número de descrições ({len(descs)}) difere do número de imagens ({len(files)})."
+    out_dir = svc.multi_concept_compose([f.name if hasattr(f, 'name') else str(f) for f in files],
+                                        descs, final_prompt)
+    return f"Gerado em: {str(out_dir)}"
+
+with gr.Blocks(title="VINCIE Service") as demo:
+    gr.Markdown("# 🎨 VINCIE Service")
+    setup_btn = gr.Button("Preparar repositório e modelo (uma vez)")
+    setup_out = gr.Textbox(label="Status")
+    setup_btn.click(fn=setup, outputs=setup_out)
+
+    with gr.Tab("🔄 Multi-turn Editing"):
+        img = gr.Image(type="filepath", label="Imagem inicial")
+        turns = gr.Textbox(lines=6, label="Turns (um por linha)")
+        run1 = gr.Button("Executar")
+        out1 = gr.Textbox(label="Saída")
+        run1.click(ui_multi_turn, inputs=[img, turns], outputs=out1)
+
+    with gr.Tab("🎭 Multi-concept Composition"):
+        files = gr.File(file_count="multiple", file_types=["image"], label="Imagens conceito")
+        descs = gr.Textbox(lines=6, label="Descrições p/ <IMG0>, <IMG1>, ... (uma por linha)")
+        finalp = gr.Textbox(lines=3, label="Prompt final")
+        run2 = gr.Button("Executar")
+        out2 = gr.Textbox(label="Saída")
+        run2.click(ui_multi_concept, inputs=[files, descs, finalp], outputs=out2)
 
-            with gr.Tab("text-to-video") as text_tab:
-                t2v_prompt = gr.Textbox(label="Prompt", value="A majestic dragon flying over a medieval castle", lines=3); t2v_button = gr.Button("Generate Text-to-Video", variant="primary")
-
-            with gr.Tab("video-to-video") as video_tab:
-                video_v2v = gr.Video(label="Input Video", sources=["upload", "webcam"]); frames_to_use = gr.Slider(label="Frames to use from input video", minimum=9, maximum=257, value=9, step=8, info="Must be N*8+1."); v2v_prompt = gr.Textbox(label="Prompt", value="Change the style to cinematic anime", lines=3); v2v_button = gr.Button("Generate Video-to-Video", variant="primary")
-            
-            duration_input = gr.Slider(label="Video Duration (seconds)", minimum=0.3, maximum=8.5, value=4, step=0.1)
-
-        with gr.Column():
-            output_video = gr.Video(label="Generated Video", interactive=False)
-
-    with gr.Accordion("Opções Avançadas", open=False):
-        mode = gr.Dropdown(["text-to-video", "image-to-video", "video-to-video"], label="task", value="image-to-video", visible=False)
-        
-        with gr.Accordion("Ajustes de Geração (Sampling)", open=True):
-            negative_prompt_input = gr.Textbox(label="Negative Prompt", value="worst quality, blurry, jittery", lines=2)
-            with gr.Row():
-                seed_input = gr.Number(label="Seed", value=42, precision=0)
-                randomize_seed_input = gr.Checkbox(label="Randomize Seed", value=True)
-            guidance_scale_input = gr.Slider(label="Guidance Scale (CFG)", minimum=1.0, maximum=10.0, value=3.0, step=0.1)
-        
-        with gr.Accordion("Dimensões do Vídeo (Base)", open=False):
-            with gr.Row():
-                height_input = gr.Slider(label="Height", value=512, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
-                width_input = gr.Slider(label="Width", value=704, step=32, minimum=MIN_DIM_SLIDER, maximum=MAX_IMAGE_SIZE)
-
-        with gr.Accordion("Configurações do Upscaler 2x (Etapa 2)", open=False):
-            with gr.Row():
-                enable_upscaler_input = gr.Checkbox(label="Enable Upscaler", value=True, info="Gera o vídeo final com o dobro da resolução base.")
-                adain_factor_input = gr.Slider(label="AdaIN Factor", minimum=0.0, maximum=2.0, value=1.0, step=0.05, info="Controla a transferência de estilo/cor para o vídeo ampliado.")
-
-    # --- LÓGICA DE EVENTOS DA UI ---
-    start_image_i2v.upload(fn=handle_media_upload_for_dims, inputs=[start_image_i2v, height_input, width_input], outputs=[height_input, width_input])
-    video_v2v.upload(fn=handle_media_upload_for_dims, inputs=[video_v2v, height_input, width_input], outputs=[height_input, width_input])
-    duration_input.change(fn=update_frame_slider, inputs=duration_input, outputs=middle_frame_i2v)
-    
-    image_tab.select(fn=lambda: "image-to-video", outputs=[mode])
-    text_tab.select(fn=lambda: "text-to-video", outputs=[mode])
-    video_tab.select(fn=lambda: "video-to-video", outputs=[mode])
-    
-    none_image = gr.Textbox(visible=False, value=None)
-    none_video = gr.Textbox(visible=False, value=None)
-    
-    shared_params = [
-        height_input, width_input, duration_input, frames_to_use, 
-        seed_input, randomize_seed_input, guidance_scale_input,
-        enable_upscaler_input, adain_factor_input
-    ]
-    
-    i2v_inputs = [i2v_prompt, negative_prompt_input, mode, start_image_i2v, middle_image_i2v, middle_frame_i2v, middle_weight_i2v, end_image_i2v, end_weight_i2v, none_video, *shared_params]
-    t2v_inputs = [t2v_prompt, negative_prompt_input, mode, none_image, none_image, gr.Number(value=-1, visible=False), gr.Slider(value=0, visible=False), none_image, gr.Slider(value=0, visible=False), none_video, *shared_params]
-    v2v_inputs = [v2v_prompt, negative_prompt_input, mode, none_image, none_image, gr.Number(value=-1, visible=False), gr.Slider(value=0, visible=False), none_image, gr.Slider(value=0, visible=False), video_v2v, *shared_params]
-    
-    common_outputs = [output_video, seed_input]
-    
-    i2v_button.click(fn=gradio_generate_wrapper, inputs=i2v_inputs, outputs=common_outputs, api_name="image_to_video_keyframes")
-    t2v_button.click(fn=gradio_generate_wrapper, inputs=t2v_inputs, outputs=common_outputs, api_name="text_to_video")
-    v2v_button.click(fn=gradio_generate_wrapper, inputs=v2v_inputs, outputs=common_outputs, api_name="video_to_video")
-
-# --- <INÍCIO DA ATUALIZAÇÃO> ---
 if __name__ == "__main__":
-    import sys
-    
-    # Define os padrões de inicialização
-    share_option = False
-    server_name = "127.0.0.1"
-
-    # Verifica se argumentos foram passados na linha de comando
-    if '--share' in sys.argv:
-        share_option = True
-        print("Iniciando com a opção de compartilhamento público (share=True)")
-
-    if '--listen' in sys.argv:
-        server_name = "0.0.0.0"
-        print("Iniciando para ser acessível na rede local (listen)")
-
-    # Inicia a aplicação com as opções definidas
-    demo.queue().launch(
-        debug=True, 
-        share=share_option,
-        server_name=server_name
-    )
+    demo.launch(server_name="0.0.0.0", server_port=7861)