Update app.py

app.py

@@ -1,33 +1,42 @@
-import os
-import time
-import random
-import logging
-import traceback
-import numpy as np
-import torch
+import spaces
 import gradio as gr
+import torch
 from PIL import Image
+from diffusers import DiffusionPipeline, AutoencoderTiny, AutoencoderKL
+import random
+import os
+import json
 import io
+import time
 from datetime import datetime
-from huggingface_hub import HfApi, HfFileSystem, snapshot_download, login
+from huggingface_hub import HfFileSystem, ModelCard
 
-# Configurar logging para facilitar debug
+# Configuração de Logging
+import logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# Autenticar com o Hugging Face (necessário para alguns modelos)
-hf_token = os.environ.get("HF_TOKEN")
-if hf_token:
-    login(token=hf_token)
-    logger.info("Autenticado no Hugging Face")
+# Supabase (opcional)
+try:
+    from supabase import create_client, Client
+    url: str = os.getenv('SUPABASE_URL')
+    key: str = os.getenv('SUPABASE_KEY')
+    supabase: Client = create_client(url, key) if url and key else None
+    supabase_enabled = True if supabase else False
+    logger.info("Supabase inicializado" if supabase_enabled else "Supabase não configurado")
+except Exception as e:
+    logger.warning(f"Erro ao inicializar Supabase: {e}")
+    supabase_enabled = False
+    supabase = None
 
-# Define o modelo base que vamos usar
-BASE_MODEL = "black-forest-labs/FLUX.1-dev"
-MAX_SEED = 2**32-1
+# Obtém token da Hugging Face
+hf_token = os.getenv("HF_TOKEN")
 
-# Carrega a lista de modelos LoRA disponíveis
+# Seed máxima
+MAX_SEED = 2**32 - 1
+
+# Carregar modelos LoRA
 loras = [
-    # Super-Realism
     {
         "image": "https://huggingface.co/vcollos/VitorCollos/resolve/main/images/IMG_0047.WEBP",
         "title": "Vitor",
@@ -39,7 +48,7 @@ loras = [
         "image": "https://huggingface.co/vcollos/camila/resolve/main/images/1732936378531__000003000_1.jpg",
         "title": "Camila",
         "repo": "vcollos/camila",
-        "weights": "Camila.safetensors",  # Corrigido
+        "weights": "Camila.safetensors",
         "trigger_word": "A photo of Camila"
     },
     {
@@ -86,59 +95,10 @@ loras = [
     }
 ]
 
-# Função para inicializar os modelos - carregada apenas quando necessário para economizar memória
-def load_models():
-    try:
-        logger.info("Iniciando carregamento dos modelos...")
-        import torch
-        from diffusers import DiffusionPipeline, AutoencoderTiny, AutoencoderKL, AutoPipelineForImage2Image
-        
-        # Configurar dispositivo e tipo de dados
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        dtype = torch.bfloat16 if device == "cuda" else torch.float32
-        
-        logger.info(f"Usando dispositivo: {device} com dtype: {dtype}")
-        
-        # Carregar o autoencoder tiny para previsualização
-        taef1 = AutoencoderTiny.from_pretrained("madebyollin/taef1", torch_dtype=dtype).to(device)
-        
-        # Carregar o VAE completo para a imagem final
-        good_vae = AutoencoderKL.from_pretrained(BASE_MODEL, subfolder="vae", torch_dtype=dtype).to(device)
-        
-        # Carregar o pipeline principal
-        pipe = DiffusionPipeline.from_pretrained(
-            BASE_MODEL,
-            torch_dtype=dtype,
-            vae=taef1
-        ).to(device)
-        
-        # Criar pipeline de image-to-image
-        pipe_i2i = AutoPipelineForImage2Image.from_pretrained(
-            BASE_MODEL,
-            vae=good_vae,
-            transformer=pipe.transformer,
-            text_encoder=pipe.text_encoder,
-            tokenizer=pipe.tokenizer,
-            text_encoder_2=pipe.text_encoder_2,
-            tokenizer_2=pipe.tokenizer_2,
-            torch_dtype=dtype
-        ).to(device)
-        
-        logger.info("Modelos carregados com sucesso")
-        
-        return {
-            "pipe": pipe,
-            "pipe_i2i": pipe_i2i,
-            "good_vae": good_vae,
-            "device": device,
-            "dtype": dtype
-        }
-    except Exception as e:
-        logger.error(f"Erro ao carregar modelos: {e}")
-        logger.error(traceback.format_exc())
-        raise e
+# Inicializar modelo
+base_model = "black-forest-labs/FLUX.1-dev"
+logger.info(f"Inicializando modelo base: {base_model}")
 
-# Classe para medir duração de operações
 class TimeMeasure:
     def __init__(self, name=""):
         self.name = name
@@ -151,156 +111,46 @@ class TimeMeasure:
         self.duration = time.time() - self.start
         logger.info(f"🕒 {self.name}: {self.duration:.2f} segundos")
 
+# Upload de imagem para o Supabase (se configurado)
+def upload_image_to_supabase(image, filename):
+    if not supabase_enabled:
+        return None
+        
+    img_bytes = io.BytesIO()
+    image.save(img_bytes, format="PNG")
+    img_bytes.seek(0)
+
+    storage_path = f"images/{filename}"
+
+    try:
+        supabase.storage.from_("images").upload(storage_path, img_bytes.getvalue(), {"content-type": "image/png"})
+        base_url = f"{url}/storage/v1/object/public/images"
+        return f"{base_url}/{storage_path}"
+    except Exception as e:
+        logger.error(f"Erro no upload da imagem: {e}")
+        return None
+
 # Função para processar a seleção de modelos na interface
-def update_selection(evt: gr.SelectData, width, height):
+def update_selection(evt: gr.SelectData):
     selected_lora = loras[evt.index]
     new_placeholder = f"Digite o prompt para {selected_lora['title']}, de preferência em inglês."
     lora_repo = selected_lora["repo"]
     updated_text = f"### Selecionado: [{lora_repo}](https://huggingface.co/{lora_repo}) ✅"
-    
-    # Ajustar dimensões conforme especificações do modelo
-    if "aspect" in selected_lora:
-        if selected_lora["aspect"] == "retrato":
-            width = 768
-            height = 1024
-        elif selected_lora["aspect"] == "paisagem":
-            width = 1024
-            height = 768
-        else:
-            width = 1024
-            height = 1024
             
     return (
         gr.update(placeholder=new_placeholder),
         updated_text,
         evt.index,
-        width,
-        height,
     )
 
-# Função principal de geração de imagens
-def generate_image(prompt, steps, cfg_scale, width, height, selected_index, randomize_seed, seed, lora_scale, input_image=None, image_strength=0.75, progress=gr.Progress()):
-    try:
-        if selected_index is None:
-            raise gr.Error("Por favor, selecione um modelo LoRA primeiro")
-        
-        # Carregar modelos (apenas quando necessário)
-        models = load_models()
-        pipe = models["pipe"]
-        pipe_i2i = models["pipe_i2i"] 
-        good_vae = models["good_vae"]
-        device = models["device"]
-        
-        # Preparar prompt com trigger words
-        selected_lora = loras[selected_index]
-        lora_path = selected_lora["repo"]
-        trigger_word = selected_lora.get("trigger_word", "")
-        qualidade = "<flux.1-dev>"
-        
-        if trigger_word:
-            trigger_position = selected_lora.get("trigger_position", "prepend")
-            if trigger_position == "prepend":
-                prompt_full = f"{trigger_word} {prompt} {qualidade}"
-            else:
-                prompt_full = f"{prompt} {trigger_word} {qualidade}"
-        else:
-            prompt_full = f"{prompt} {qualidade}"
-            
-        logger.info(f"Prompt completo: {prompt_full}")
-        
-        # Randomizar seed se necessário
-        if randomize_seed:
-            seed = random.randint(0, MAX_SEED)
-            
-        # Configurar gerador
-        generator = torch.Generator(device=device).manual_seed(seed)
-        progress(0, desc="Preparando modelo...")
-            
-        # Descarregar pesos LoRA anteriores e limpar cache
-        with TimeMeasure("Descarregando modelos anteriores"):
-            pipe.unload_lora_weights() if hasattr(pipe, 'unload_lora_weights') else None
-            pipe_i2i.unload_lora_weights() if hasattr(pipe_i2i, 'unload_lora_weights') else None
-            torch.cuda.empty_cache()
-
-        # Carregar pesos LoRA
-        with TimeMeasure(f"Carregando LoRA {selected_lora['title']}"):
-            pipeline_to_use = pipe_i2i if input_image is not None else pipe
-            weight_name = selected_lora.get("weights", None)
-            
-            try:
-                pipeline_to_use.load_lora_weights(
-                    lora_path,
-                    weight_name=weight_name,
-                    low_cpu_mem_usage=True
-                )
-                logger.info(f"LoRA carregado: {weight_name}")
-            except Exception as e:
-                logger.error(f"Erro ao carregar LoRA: {e}")
-                raise gr.Error(f"Erro ao carregar LoRA: {str(e)}")
-        
-        # Gerar imagem
-        with TimeMeasure("Gerando imagem"):
-            progress(0.2, desc=f"Gerando imagem com {steps} passos...")
-            
-            if input_image is not None:
-                # Modo image-to-image
-                from diffusers.utils import load_image
-                image_input = load_image(input_image)
-                
-                result = pipe_i2i(
-                    prompt=prompt_full,
-                    image=image_input,
-                    strength=image_strength,
-                    num_inference_steps=steps,
-                    guidance_scale=cfg_scale,
-                    width=width,
-                    height=height,
-                    generator=generator,
-                    joint_attention_kwargs={"scale": lora_scale},
-                )
-                final_image = result.images[0]
-            else:
-                # Modo text-to-image com visualização progressiva
-                final_image = None
-                
-                # Definir função de callback para atualizar o progresso
-                def callback_fn(i, t, latents):
-                    progress((i + 1) / steps, desc=f"Passo {i+1}/{steps}")
-                    return True
-                
-                # Generate image
-                result = pipe(
-                    prompt=prompt_full,
-                    num_inference_steps=steps,
-                    guidance_scale=cfg_scale,
-                    width=width,
-                    height=height,
-                    generator=generator,
-                    joint_attention_kwargs={"scale": lora_scale},
-                    callback=callback_fn,
-                    callback_steps=1
-                )
-                final_image = result.images[0]
-        
-        # Limpar cache após geração
-        torch.cuda.empty_cache()
-            
-        return final_image, seed
-        
-    except Exception as e:
-        logger.error(f"Erro ao gerar imagem: {e}")
-        logger.error(traceback.format_exc())
-        raise gr.Error(f"Erro: {str(e)}")
-
-# Verifica modelo personalizado
+# Carrega modelo personalizado
 def add_custom_lora(custom_lora):
     global loras
     
     if not custom_lora:
-        return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
+        return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None
     
     try:
-        # Processar o link ou ID do modelo
         model_id = custom_lora
         if model_id.startswith("https://huggingface.co/"):
             model_id = model_id.replace("https://huggingface.co/", "")
@@ -312,7 +162,6 @@ def add_custom_lora(custom_lora):
         
         # Verificar card do modelo
         try:
-            from huggingface_hub import ModelCard
             model_card = ModelCard.load(model_id)
             base_model = model_card.data.get("base_model")
             
@@ -395,7 +244,6 @@ def add_custom_lora(custom_lora):
             gr.Gallery(value=[(item["image"], item["title"]) for item in loras]),
             f"Modelo: {title}",
             existing_item_index,
-            trigger_word if trigger_word else "",
         )
         
     except Exception as e:
@@ -407,189 +255,239 @@ def add_custom_lora(custom_lora):
             gr.update(),
             "",
             None,
-            "",
         )
 
 def remove_custom_lora():
-    return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None, ""
+    return gr.update(visible=False), gr.update(visible=False), gr.update(), "", None
 
-# Interface Gradio
-def create_interface():
-    # Tema personalizado
-    collos = gr.themes.Soft(
-        primary_hue="gray",
-        secondary_hue="stone",
-        neutral_hue="slate",
-        radius_size=gr.themes.Size(lg="15px", md="8px", sm="6px", xl="16px", xs="4px", xxl="24px", xxs="2px")
-    ).set(
-        body_background_fill='*primary_100',
-        embed_radius='*radius_lg',
-        shadow_drop='0 1px 2px rgba(0, 0, 0, 0.1)',
-        shadow_drop_lg='0 1px 2px rgba(0, 0, 0, 0.1)',
-        shadow_inset='0 1px 2px rgba(0, 0, 0, 0.1)',
-        shadow_spread='0 1px 2px rgba(0, 0, 0, 0.1)',
-        shadow_spread_dark='0 1px 2px rgba(0, 0, 0, 0.1)',
-        block_radius='*radius_lg',
-        block_shadow='*shadow_drop',
-        container_radius='*radius_lg'
-    )
-
-    # CSS personalizado
-    css = """
-    #group_with_padding {
-        padding: 20px;
-        background-color: #f5f5f5;
-        border: 1px solid #ccc;
-    }
-
-    #padded_text {
-        padding: 10px;
-        background-color: #eef;
-        border-radius: 5px;
-        font-size: 16px;
-    }
-    
-    .custom_lora_card {
-        padding: 10px;
-        background-color: #f5f5f5;
-        border-radius: 10px;
-        margin-top: 10px;
-    }
-    
-    .card_internal {
-        display: flex;
-        align-items: center;
-        margin-top: 10px;
-    }
-    
-    .card_internal img {
-        margin-right: 15px;
-        border-radius: 5px;
-    }
-    """
-
-    # Interface principal
-    with gr.Blocks(theme=collos, css=css) as interface:
-        # Logo
-        title = gr.HTML(
-            """<img src="https://huggingface.co/spaces/vcollos/Uniodonto/resolve/main/logo/logo_collos_3.png" alt="Logo" style="display: block; margin: 0 auto; padding: 5px 0px 20px 0px; width: 200px;" />""",
-            elem_id="title",
-        )
+# Função principal para gerar imagem
+@spaces.GPU(duration=60)
+def run_lora(prompt, cfg_scale, steps, selected_index, randomize_seed, seed, width, height, lora_scale, progress=gr.Progress(track_tqdm=True)):
+    try:
+        if selected_index is None:
+            raise gr.Error("Selecione um modelo para continuar.")
+            
+        # Inicializa o timestamp
+        start_time = time.time()
+        logger.info(f"Iniciando geração com modelo: {loras[selected_index]['title']}")
         
-        # Estado para armazenar o índice do modelo selecionado
-        selected_index = gr.State(None)
+        # Configuração do modelo
+        with TimeMeasure("Carregando modelo base"):
+            # Usar bfloat16 para economizar memória
+            pipe = DiffusionPipeline.from_pretrained(
+                base_model, 
+                torch_dtype=torch.float16,
+                use_safetensors=True
+            )
+            pipe.to("cuda")
+            
+        selected_lora = loras[selected_index]
+        lora_path = selected_lora["repo"]
+        lora_weights = selected_lora.get("weights")
+        trigger_word = selected_lora.get("trigger_word", "")
+        qualidade = "<flux.1-dev>"
         
-        # Seção principal
-        with gr.Row():
-            with gr.Column(scale=3):
-                prompt = gr.Textbox(label="Prompt", lines=1, placeholder="Selecione um modelo primeiro")
-            with gr.Column(scale=1):
-                generate_button = gr.Button("Gerar Imagem", variant="primary", elem_id="cta")
-                
-        # Galeria e resultados
-        with gr.Row():
-            with gr.Column():
-                selected_info = gr.Markdown("")
-                gallery = gr.Gallery(
-                    label="Modelos Disponíveis",
-                    value=[(item["image"], item["title"]) for item in loras],
-                    allow_preview=False,
-                    columns=3,
-                    show_share_button=False
+        # Adiciona trigger word ao prompt
+        if trigger_word:
+            prompt_full = f"{trigger_word} {prompt} {qualidade}"
+        else:
+            prompt_full = f"{prompt} {qualidade}"
+            
+        # Randomiza a seed se necessário
+        if randomize_seed:
+            seed = random.randint(0, MAX_SEED)
+            
+        generator = torch.Generator(device="cuda").manual_seed(seed)
+        
+        # Carrega o LoRA específico
+        with TimeMeasure(f"Carregando LoRA {selected_lora['title']}"):
+            try:
+                pipe.load_lora_weights(
+                    lora_path, 
+                    weight_name=lora_weights, 
+                    adapter_name="lora"
                 )
+                pipe.set_adapters(["lora"], adapter_weights=[lora_scale])
+            except Exception as e:
+                logger.error(f"Erro ao carregar LoRA: {e}")
+                raise gr.Error(f"Erro ao carregar LoRA: {str(e)}")
                 
-                # Seção LoRA personalizado
-                with gr.Group():
-                    custom_lora = gr.Textbox(
-                        label="Adicionar Modelo Externo", 
-                        placeholder="Nome do modelo ou URL (ex: vcollos/VitorCollos)"
-                    )
-                    gr.Markdown(
-                        "[Ver modelos FLUX no Hugging Face](https://huggingface.co/models?other=base_model:adapter:black-forest-labs/FLUX.1-dev)", 
-                        elem_id="lora_list"
-                    )
-                
-                # Informações do modelo personalizado
-                custom_lora_info = gr.HTML(visible=False)
-                custom_lora_button = gr.Button("Remover Modelo Externo", visible=False)
-                
-            # Resultado da geração
-            with gr.Column():
-                result = gr.Image(label="Imagem Gerada", type="pil")
-                seed_output = gr.Number(label="Seed", precision=0)
-                
-        # Configurações avançadas
-        with gr.Row():
-            with gr.Accordion("Configurações Avançadas", open=False):
-                with gr.Row():
-                    input_image = gr.Image(label="Imagem de Referência (opcional)", type="filepath")
-                    image_strength = gr.Slider(
-                        label="Força da Imagem Original", 
-                        info="Valores menores preservam mais da imagem original", 
-                        minimum=0.1, 
-                        maximum=1.0, 
-                        step=0.01, 
-                        value=0.75
-                    )
+        # Gera a imagem
+        with TimeMeasure("Gerando imagem"):
+            result = pipe(
+                prompt=prompt_full,
+                num_inference_steps=steps,
+                guidance_scale=cfg_scale,
+                width=width,
+                height=height,
+                generator=generator
+            )
+            image = result.images[0]
+        
+        # Salva a imagem no Supabase se configurado
+        if supabase_enabled:
+            try:
+                filename = f"image_{seed}_{datetime.utcnow().strftime('%Y%m%d%H%M%S')}.png"
+                image_url = upload_image_to_supabase(image, filename)
                 
-                with gr.Column():
-                    with gr.Row():
-                        cfg_scale = gr.Slider(label="Escala de Orientação (CFG)", minimum=1, maximum=20, step=0.5, value=3.0)
-                        steps = gr.Slider(label="Passos de Inferência", minimum=1, maximum=50, step=1, value=32)
+                if image_url:
+                    logger.info(f"Imagem salva no Supabase: {image_url}")
                     
-                    with gr.Row():
-                        width = gr.Slider(label="Largura", minimum=256, maximum=1536, step=64, value=1024)
-                        height = gr.Slider(label="Altura", minimum=256, maximum=1536, step=64, value=1024)
+                    # Salva metadados
+                    supabase.table("images").insert({
+                        "prompt": prompt_full,
+                        "cfg_scale": cfg_scale,
+                        "steps": steps,
+                        "seed": seed,
+                        "lora_scale": lora_scale,
+                        "image_url": image_url,
+                        "created_at": datetime.utcnow().isoformat()
+                    }).execute()
                     
-                    with gr.Row():
-                        randomize_seed = gr.Checkbox(True, label="Seed Aleatória")
-                        seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
-                        lora_scale = gr.Slider(label="Intensidade do LoRA", minimum=0, maximum=3, step=0.01, value=1.20)
-        
-        # Eventos
-        gallery.select(
-            update_selection,
-            inputs=[width, height],
-            outputs=[prompt, selected_info, selected_index, width, height]
-        )
-        
-        custom_lora.change(
-            add_custom_lora,
-            inputs=[custom_lora],
-            outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, prompt]
-        )
-        
-        custom_lora_button.click(
-            remove_custom_lora,
-            outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index, custom_lora]
-        )
+                    logger.info("Metadados salvos no Supabase")
+            except Exception as e:
+                logger.error(f"Erro ao salvar no Supabase: {e}")
         
-        generate_inputs = [
-            prompt, steps, cfg_scale, width, height, selected_index, 
-            randomize_seed, seed, lora_scale, input_image, image_strength
-        ]
+        elapsed_time = time.time() - start_time
+        logger.info(f"Imagem gerada em {elapsed_time:.2f} segundos")
         
-        generate_outputs = [result, seed_output]
+        # Limpa memória CUDA
+        torch.cuda.empty_cache()
         
-        generate_button.click(generate_image, inputs=generate_inputs, outputs=generate_outputs)
-        prompt.submit(generate_image, inputs=generate_inputs, outputs=generate_outputs)
+        return image, seed
         
-        # Informações iniciais
-        gr.Markdown(
-            """
-            ## Gerador de Imagens com FLUX LoRA
+    except Exception as e:
+        logger.error(f"Erro na geração: {e}")
+        raise gr.Error(str(e))
+
+# Interface Gradio
+collos = gr.themes.Soft(
+    primary_hue="gray",
+    secondary_hue="stone",
+    neutral_hue="slate",
+    radius_size=gr.themes.Size(lg="15px", md="8px", sm="6px", xl="16px", xs="4px", xxl="24px", xxs="2px")
+).set(
+    body_background_fill='*primary_100',
+    embed_radius='*radius_lg',
+    shadow_drop='0 1px 2px rgba(0, 0, 0, 0.1)',
+    shadow_drop_lg='0 1px 2px rgba(0, 0, 0, 0.1)',
+    shadow_inset='0 1px 2px rgba(0, 0, 0, 0.1)',
+    shadow_spread='0 1px 2px rgba(0, 0, 0, 0.1)',
+    shadow_spread_dark='0 1px 2px rgba(0, 0, 0, 0.1)',
+    block_radius='*radius_lg',
+    block_shadow='*shadow_drop',
+    container_radius='*radius_lg'
+)
+
+css = """
+.custom_lora_card {
+    padding: 10px;
+    background-color: #f5f5f5;
+    border-radius: 10px;
+    margin-top: 10px;
+}
+
+.card_internal {
+    display: flex;
+    align-items: center;
+    margin-top: 10px;
+}
+
+.card_internal img {
+    margin-right: 15px;
+    border-radius: 5px;
+}
+"""
+
+with gr.Blocks(theme=collos, css=css) as app:
+    # Logo
+    title = gr.HTML(
+        """<img src="https://huggingface.co/spaces/vcollos/Uniodonto/resolve/main/logo/logo_collos_3.png" alt="Logo" style="display: block; margin: 0 auto; padding: 5px 0px 20px 0px; width: 200px;" />""",
+        elem_id="title",
+    )
+    
+    selected_index = gr.State(None)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            prompt = gr.Textbox(label="Prompt", lines=2, placeholder="Selecione um modelo primeiro")
+        with gr.Column(scale=1):
+            generate_button = gr.Button("Gerar Imagem", variant="primary", elem_id="cta")
             
-            1. Selecione um modelo na galeria
-            2. Digite um prompt (preferencialmente em inglês)
-            3. Clique em "Gerar Imagem"
+    with gr.Row():
+        with gr.Column():
+            selected_info = gr.Markdown("")
+            gallery = gr.Gallery(
+                label="Modelos Disponíveis",
+                value=[(item["image"], item["title"]) for item in loras],
+                allow_preview=False,
+                columns=3,
+                show_share_button=False
+            )
             
-            Use as configurações avançadas para ajustar parâmetros como tamanho, número de passos, etc.
-            """
-        )
-        
-    return interface
+            # Seção LoRA personalizado
+            with gr.Group():
+                custom_lora = gr.Textbox(
+                    label="Adicionar Modelo Externo", 
+                    placeholder="Nome do modelo ou URL (ex: vcollos/VitorCollos)"
+                )
+                gr.Markdown(
+                    "[Ver modelos FLUX no Hugging Face](https://huggingface.co/models?other=base_model:adapter:black-forest-labs/FLUX.1-dev)", 
+                    elem_id="lora_list"
+                )
+            
+            # Informações do modelo personalizado
+            custom_lora_info = gr.HTML(visible=False)
+            custom_lora_button = gr.Button("Remover Modelo Externo", visible=False)
+            
+        with gr.Column():
+            result = gr.Image(label="Imagem Gerada")
+            seed_output = gr.Number(label="Seed", precision=0)
+            
+    with gr.Row():
+        with gr.Accordion("Configurações Avançadas", open=False):
+            with gr.Column():
+                with gr.Row():
+                    cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=20, step=0.5, value=3.5)
+                    steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=32)
+                
+                with gr.Row():
+                    width = gr.Slider(label="Largura", minimum=256, maximum=1536, step=64, value=1024)
+                    height = gr.Slider(label="Altura", minimum=256, maximum=1536, step=64, value=1024)
+                
+                with gr.Row():
+                    randomize_seed = gr.Checkbox(True, label="Seed Aleatória")
+                    seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
+                    lora_scale = gr.Slider(label="Intensidade do LoRA", minimum=0, maximum=3, step=0.01, value=1.20)
+    
+    # Eventos
+    gallery.select(
+        update_selection,
+        inputs=[],
+        outputs=[prompt, selected_info, selected_index]
+    )
+    
+    custom_lora.change(
+        add_custom_lora,
+        inputs=[custom_lora],
+        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index]
+    )
+    
+    custom_lora_button.click(
+        remove_custom_lora,
+        outputs=[custom_lora_info, custom_lora_button, gallery, selected_info, selected_index]
+    )
+    
+    generate_inputs = [
+        prompt, cfg_scale, steps, selected_index, 
+        randomize_seed, seed, width, height, lora_scale
+    ]
+    
+    generate_outputs = [result, seed_output]
+    
+    generate_button.click(run_lora, inputs=generate_inputs, outputs=generate_outputs)
+    prompt.submit(run_lora, inputs=generate_inputs, outputs=generate_outputs)
 
-# Criar interface e iniciar
-if __name__ == "__main__":
-    app = create_interface()
-    app.queue(concurrency_count=1).launch(debug=True)
+# Iniciar o app
+app.queue()
+app.launch()