Upload 5 files

README.md

@@ -4,7 +4,7 @@ emoji: 🏆😻
 colorFrom: red
 colorTo: pink
 sdk: gradio
-sdk_version: 5.7.0
+sdk_version: 5.6.0
 app_file: app.py
 pinned: true
 license: mit

app.py

@@ -13,6 +13,7 @@ import random
 import time
 import requests
 import pandas as pd
+import numpy as np
 from pathlib import Path
 
 from env import models, num_loras, num_cns, HF_TOKEN, single_file_base_models
@@ -41,10 +42,16 @@ controlnet_model_union_repo = 'InstantX/FLUX.1-dev-Controlnet-Union'
 #controlnet_model_union_repo = 'Shakker-Labs/FLUX.1-dev-ControlNet-Union-Pro'
 dtype = torch.bfloat16
 #dtype = torch.float8_e4m3fn
-#device = "cuda" if torch.cuda.is_available() else "cpu"
+CACHE_MODEL = False
+device = "cuda" if torch.cuda.is_available() else "cpu"
 taef1 = AutoencoderTiny.from_pretrained("madebyollin/taef1", torch_dtype=dtype, token=HF_TOKEN)
 good_vae = AutoencoderKL.from_pretrained(base_model, subfolder="vae", torch_dtype=dtype, token=HF_TOKEN)
 pipe = DiffusionPipeline.from_pretrained(base_model, torch_dtype=dtype, vae=taef1, token=HF_TOKEN)
+if CACHE_MODEL:
+    taef1.to(device)
+    good_vae.to(device)
+    pipe.to(device)
+    pipe.transformer.to("cpu")
 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, token=HF_TOKEN)
 pipe_ip = AutoPipelineForInpainting.from_pretrained(base_model, vae=good_vae, transformer=pipe.transformer, text_encoder=pipe.text_encoder,
@@ -66,6 +73,7 @@ def unload_lora():
         pipe.unload_lora_weights()
         #pipe_i2i.unfuse_lora()
         pipe_i2i.unload_lora_weights()
+        #pipe_ip.unfuse_lora()
         pipe_ip.unload_lora_weights()
     except Exception as e:
         print(e)
@@ -104,12 +112,19 @@ def change_base_model(repo_id: str, cn_on: bool, disable_model_cache: bool, mode
             if ".safetensors" in repo_id:
                 safetensors_file = download_file_mod(repo_id)
                 transformer = FluxTransformer2DModel.from_single_file(safetensors_file, subfolder="transformer", torch_dtype=dtype, config=single_file_base_model)
-                pipe = FluxControlNetPipeline.from_pretrained(single_file_base_model, transformer=transformer, controlnet=controlnet, torch_dtype=dtype, token=HF_TOKEN)
+                if CACHE_MODEL:
+                    pipe = FluxControlNetPipeline.from_pretrained(single_file_base_model, controlnet=controlnet, vae=good_vae, transformer=transformer, text_encoder=pipe.text_encoder,
+                     tokenizer=pipe.tokenizer, text_encoder_2=pipe.text_encoder_2, tokenizer_2=pipe.tokenizer_2, torch_dtype=dtype, token=HF_TOKEN)
+                else: pipe = FluxControlNetPipeline.from_pretrained(single_file_base_model, transformer=transformer, controlnet=controlnet, torch_dtype=dtype, token=HF_TOKEN)
                 pipe_i2i = FluxControlNetImg2ImgPipeline.from_pretrained(single_file_base_model, controlnet=controlnet, 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, token=HF_TOKEN)
                 pipe_ip = FluxControlNetInpaintPipeline.from_pretrained(single_file_base_model, controlnet=controlnet, 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, token=HF_TOKEN)
             else:
+                if CACHE_MODEL:
+                    transformer = FluxTransformer2DModel.from_pretrained(repo_id, subfolder="transformer", torch_dtype=dtype, token=HF_TOKEN)
+                    pipe = FluxControlNetPipeline.from_pretrained(repo_id, controlnet=controlnet, vae=good_vae, transformer=transformer, text_encoder=pipe.text_encoder,
+                     tokenizer=pipe.tokenizer, text_encoder_2=pipe.text_encoder_2, tokenizer_2=pipe.tokenizer_2, torch_dtype=dtype, token=HF_TOKEN)
                 pipe = FluxControlNetPipeline.from_pretrained(repo_id, controlnet=controlnet, torch_dtype=dtype, token=HF_TOKEN)
                 pipe_i2i = FluxControlNetImg2ImgPipeline.from_pretrained(repo_id, controlnet=controlnet, 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, token=HF_TOKEN)
@@ -124,14 +139,21 @@ def change_base_model(repo_id: str, cn_on: bool, disable_model_cache: bool, mode
             print(f"Loading model: {repo_id}")
             if ".safetensors" in repo_id:
                 safetensors_file = download_file_mod(repo_id)
-                transformer = FluxTransformer2DModel.from_single_file(safetensors_file, subfolder="transformer", torch_dtype=dtype, config=single_file_base_model)
-                pipe = DiffusionPipeline.from_pretrained(single_file_base_model, transformer=transformer, torch_dtype=dtype, token=HF_TOKEN)
+                transformer = FluxTransformer2DModel.from_single_file(safetensors_file, subfolder="transformer", torch_dtype=dtype, config=single_file_base_model, token=HF_TOKEN)
+                if CACHE_MODEL:
+                    pipe = DiffusionPipeline.from_pretrained(single_file_base_model, vae=taef1, transformer=transformer, text_encoder=pipe.text_encoder,
+                     tokenizer=pipe.tokenizer, text_encoder_2=pipe.text_encoder_2, tokenizer_2=pipe.tokenizer_2, torch_dtype=dtype, token=HF_TOKEN)
+                else: pipe = DiffusionPipeline.from_pretrained(single_file_base_model, transformer=transformer, torch_dtype=dtype, token=HF_TOKEN)
                 pipe_i2i = AutoPipelineForImage2Image.from_pretrained(single_file_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, token=HF_TOKEN)
                 pipe_ip = AutoPipelineForInpainting.from_pretrained(single_file_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, token=HF_TOKEN)
             else:
-                pipe = DiffusionPipeline.from_pretrained(repo_id, torch_dtype=dtype, token=HF_TOKEN)
+                if CACHE_MODEL:
+                    transformer = FluxTransformer2DModel.from_pretrained(repo_id, subfolder="transformer", torch_dtype=dtype, token=HF_TOKEN)
+                    pipe = DiffusionPipeline.from_pretrained(repo_id, vae=taef1, transformer=transformer, text_encoder=pipe.text_encoder,
+                     tokenizer=pipe.tokenizer, text_encoder_2=pipe.text_encoder_2, tokenizer_2=pipe.tokenizer_2, torch_dtype=dtype, token=HF_TOKEN)
+                else: pipe = DiffusionPipeline.from_pretrained(repo_id, torch_dtype=dtype, token=HF_TOKEN)
                 pipe_i2i = AutoPipelineForImage2Image.from_pretrained(repo_id, 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, token=HF_TOKEN)
                 pipe_ip = AutoPipelineForInpainting.from_pretrained(repo_id, vae=good_vae, transformer=pipe.transformer, text_encoder=pipe.text_encoder,
@@ -158,6 +180,11 @@ def is_repo_public(repo_id: str):
         print(f"Error: Failed to connect {repo_id}. {e}")
         return False
 
+def calc_sigmas(num_inference_steps: int, sigmas_factor: float):
+    sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps)
+    sigmas = sigmas * sigmas_factor
+    return sigmas
+
 class calculateDuration:
     def __init__(self, activity_name=""):
         self.activity_name = activity_name
@@ -414,18 +441,19 @@ def remove_custom_lora(selected_indices, current_loras, gallery):
 
 @spaces.GPU(duration=70)
 @torch.inference_mode()
-def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, cn_on, progress=gr.Progress(track_tqdm=True)):
+def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, sigmas_factor, cn_on, progress=gr.Progress(track_tqdm=True)):
     global pipe, taef1, good_vae, controlnet, controlnet_union
     try:
-        good_vae.to("cuda")
-        taef1.to("cuda")
-        generator = torch.Generator(device="cuda").manual_seed(int(float(seed)))
+        good_vae.to(device)
+        taef1.to(device)
+        generator = torch.Generator(device=device).manual_seed(int(float(seed)))
+        sigmas = calc_sigmas(steps, sigmas_factor)
         
         with calculateDuration("Generating image"):
             # Generate image
             modes, images, scales = get_control_params()
             if not cn_on or len(modes) == 0:
-                pipe.to("cuda")
+                pipe.to(device)
                 pipe.vae = taef1
                 pipe.flux_pipe_call_that_returns_an_iterable_of_images = flux_pipe_call_that_returns_an_iterable_of_images.__get__(pipe)
                 progress(0, desc="Start Inference.")
@@ -439,13 +467,14 @@ def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, cn_on, pr
                     joint_attention_kwargs={"scale": 1.0},
                     output_type="pil",
                     good_vae=good_vae,
+                    sigmas=sigmas,
                 ):
                     yield img
             else:
-                pipe.to("cuda")
+                pipe.to(device)
                 pipe.vae = good_vae
-                if controlnet_union is not None: controlnet_union.to("cuda")
-                if controlnet is not None: controlnet.to("cuda")
+                if controlnet_union is not None: controlnet_union.to(device)
+                if controlnet is not None: controlnet.to(device)
                 pipe.enable_model_cpu_offload()
                 progress(0, desc="Start Inference with ControlNet.")
                 for img in pipe(
@@ -459,6 +488,7 @@ def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, cn_on, pr
                     controlnet_conditioning_scale=scales,
                     generator=generator,
                     joint_attention_kwargs={"scale": 1.0},
+                    sigmas=sigmas,
                 ).images:
                     yield img
     except Exception as e:
@@ -467,20 +497,22 @@ def generate_image(prompt_mash, steps, seed, cfg_scale, width, height, cn_on, pr
 
 @spaces.GPU(duration=70)
 @torch.inference_mode()
-def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength, is_inpaint, blur_mask, blur_factor, steps, cfg_scale, width, height, seed, cn_on, progress=gr.Progress(track_tqdm=True)):
+def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength, is_inpaint, blur_mask, blur_factor, steps, cfg_scale, width, height,
+                            sigmas_factor, seed, cn_on, progress=gr.Progress(track_tqdm=True)):
     global pipe_i2i, pipe_ip, good_vae, controlnet, controlnet_union
     try:
-        good_vae.to("cuda")
-        generator = torch.Generator(device="cuda").manual_seed(int(float(seed)))
+        good_vae.to(device)
+        generator = torch.Generator(device=device).manual_seed(int(float(seed)))
         image_input_path = image_input_path_dict['background']
         mask_path = image_input_path_dict['layers'][0]
+        sigmas = calc_sigmas(steps, sigmas_factor)
 
         with calculateDuration("Generating image"):
             # Generate image
             modes, images, scales = get_control_params()
             if not cn_on or len(modes) == 0:
                 if is_inpaint: # Inpainting
-                    pipe_ip.to("cuda")
+                    pipe_ip.to(device)
                     pipe_ip.vae = good_vae
                     image_input = load_image(image_input_path)
                     mask_input = load_image(mask_path)
@@ -498,10 +530,11 @@ def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength,
                         generator=generator,
                         joint_attention_kwargs={"scale": 1.0},
                         output_type="pil",
+                        #sigmas=sigmas,
                     ).images[0]
                     return final_image 
                 else:
-                    pipe_i2i.to("cuda")
+                    pipe_i2i.to(device)
                     pipe_i2i.vae = good_vae
                     image_input = load_image(image_input_path)
                     progress(0, desc="Start I2I Inference.")
@@ -516,17 +549,18 @@ def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength,
                         generator=generator,
                         joint_attention_kwargs={"scale": 1.0},
                         output_type="pil",
+                        #sigmas=sigmas,
                     ).images[0]
                     return final_image 
             else:
                 if is_inpaint: # Inpainting
-                    pipe_ip.to("cuda")
+                    pipe_ip.to(device)
                     pipe_ip.vae = good_vae
                     image_input = load_image(image_input_path)
                     mask_input = load_image(mask_path)
                     if blur_mask: mask_input = pipe_ip.mask_processor.blur(mask_input, blur_factor=blur_factor)
-                    if controlnet_union is not None: controlnet_union.to("cuda")
-                    if controlnet is not None: controlnet.to("cuda")
+                    if controlnet_union is not None: controlnet_union.to(device)
+                    if controlnet is not None: controlnet.to(device)
                     pipe_ip.enable_model_cpu_offload()
                     progress(0, desc="Start Inpainting Inference with ControlNet.")
                     final_image = pipe_ip(
@@ -544,14 +578,15 @@ def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength,
                         generator=generator,
                         joint_attention_kwargs={"scale": 1.0},
                         output_type="pil",
+                        #sigmas=sigmas,
                     ).images[0]
                     return final_image
                 else:
-                    pipe_i2i.to("cuda")
+                    pipe_i2i.to(device)
                     pipe_i2i.vae = good_vae
                     image_input = load_image(image_input_path['background'])
-                    if controlnet_union is not None: controlnet_union.to("cuda")
-                    if controlnet is not None: controlnet.to("cuda")
+                    if controlnet_union is not None: controlnet_union.to(device)
+                    if controlnet is not None: controlnet.to(device)
                     pipe_i2i.enable_model_cpu_offload()
                     progress(0, desc="Start I2I Inference with ControlNet.")
                     final_image = pipe_i2i(
@@ -568,6 +603,7 @@ def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength,
                         generator=generator,
                         joint_attention_kwargs={"scale": 1.0},
                         output_type="pil",
+                        #sigmas=sigmas,
                     ).images[0]
                     return final_image
     except Exception as e:
@@ -575,7 +611,7 @@ def generate_image_to_image(prompt_mash, image_input_path_dict, image_strength,
         raise gr.Error(f"I2I Inference Error: {e}") from e
 
 def run_lora(prompt, image_input, image_strength, task_type, blur_mask, blur_factor, cfg_scale, steps, selected_indices, lora_scale_1, lora_scale_2,
-             randomize_seed, seed, width, height, loras_state, lora_json, cn_on, translate_on, progress=gr.Progress(track_tqdm=True)):
+             randomize_seed, seed, width, height, sigmas_factor, loras_state, lora_json, cn_on, translate_on, progress=gr.Progress(track_tqdm=True)):
     global pipe, pipe_i2i, pipe_ip
     if not selected_indices and not is_valid_lora(lora_json):
         gr.Info("LoRA isn't selected.")
@@ -690,10 +726,11 @@ def run_lora(prompt, image_input, image_strength, task_type, blur_mask, blur_fac
     # Generate image
     progress(0, desc="Running Inference.")
     if is_i2i:
-        final_image = generate_image_to_image(prompt_mash, image_input, image_strength, is_inpaint, blur_mask, blur_factor, steps, cfg_scale, width, height, seed, cn_on)
+        final_image = generate_image_to_image(prompt_mash, image_input, image_strength, is_inpaint, blur_mask, blur_factor,
+                                              steps, cfg_scale, width, height, sigmas_factor, seed, cn_on)
         yield save_image(final_image, None, last_model, prompt_mash, height, width, steps, cfg_scale, seed), seed, gr.update(visible=False)
     else:
-        image_generator = generate_image(prompt_mash, steps, seed, cfg_scale, width, height, cn_on)
+        image_generator = generate_image(prompt_mash, steps, seed, cfg_scale, width, height, sigmas_factor, cn_on)
         # Consume the generator to get the final image
         final_image = None
         step_counter = 0
@@ -856,43 +893,47 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
                 progress_bar = gr.Markdown(elem_id="progress",visible=False)
                 result = gr.Image(label="Generated Image", format="png", type="filepath", show_share_button=False, interactive=False)
                 with gr.Accordion("History", open=False):
+                    history_files = gr.Files(interactive=False, visible=False)
                     history_gallery = gr.Gallery(label="History", columns=6, object_fit="contain", interactive=False, format="png",
                                                  show_share_button=False, show_download_button=True)
-                    history_files = gr.Files(interactive=False, visible=False)
                     history_clear_button = gr.Button(value="Clear History", variant="secondary")
                     history_clear_button.click(lambda: ([], []), None, [history_gallery, history_files], queue=False, show_api=False)
-        with gr.Group():
-            with gr.Row():
-                model_name = gr.Dropdown(label="Base Model", info="You can enter a huggingface model repo_id or path of single safetensors file to want to use.",
-                                         choices=models, value=models[0], allow_custom_value=True, min_width=320, scale=5)
-                model_type = gr.Radio(label="Model type", info="Model type of single safetensors file",
-                                      choices=list(single_file_base_models.keys()), value=list(single_file_base_models.keys())[0], scale=1)
-            model_info = gr.Markdown(elem_classes="info")
-            
+
         with gr.Row():
-            with gr.Accordion("Advanced Settings", open=False):
-                with gr.Row():
-                    with gr.Column():
-                        #input_image = gr.Image(label="Input image", type="filepath", height=256, sources=["upload", "clipboard"], show_share_button=False)
-                        input_image = gr.ImageEditor(label='Input image', type='filepath', sources=["upload", "clipboard"], image_mode='RGB', show_share_button=False, show_fullscreen_button=False,
-                                                     layers=False, brush=gr.Brush(colors=["#FFFFFF"], color_mode="fixed", default_size=32), value=None,
-                                                     canvas_size=(384, 384), width=384, height=512)
+            with gr.Accordion("Advanced Settings", open=True):
+                with gr.Tab("Generation Settings"):
                     with gr.Column():
-                        task_type = gr.Radio(label="Task", choices=["Text-to-Image", "Image-to-Image", "Inpainting"], value="Text-to-Image")
-                        image_strength = gr.Slider(label="Strength", info="Lower means more image influence in I2I, opposite in Inpaint", minimum=0.01, maximum=1.0, step=0.01, value=0.75)
-                        blur_mask = gr.Checkbox(label="Blur mask", value=False)
-                        blur_factor = gr.Slider(label="Blur factor", minimum=0, maximum=50, step=1, value=33)
-                        input_image_preprocess = gr.Checkbox(True, label="Preprocess Input image")
-                with gr.Column():
-                    with gr.Row():
-                        width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=1024)
-                        height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=1024)
-                        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=28)
+                        with gr.Group():
+                            with gr.Row():
+                                model_name = gr.Dropdown(label="Base Model", info="You can enter a huggingface model repo_id or path of single safetensors file to want to use.",
+                                                        choices=models, value=models[0], allow_custom_value=True, min_width=320, scale=5)
+                                model_type = gr.Radio(label="Model type", info="Model type of single safetensors file",
+                                                    choices=list(single_file_base_models.keys()), value=list(single_file_base_models.keys())[0], scale=1)
+                            model_info = gr.Markdown(elem_classes="info")
+                        with gr.Row():
+                            width = gr.Slider(label="Width", minimum=256, maximum=1536, step=64, value=1024)
+                            height = gr.Slider(label="Height", minimum=256, maximum=1536, step=64, value=1024)
+                            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=28)
+                        with gr.Row():
+                            randomize_seed = gr.Checkbox(True, label="Randomize seed")
+                            seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
+                            sigmas_factor = gr.Slider(label="Sigmas factor", minimum=0.01, maximum=1.00, step=0.01, value=0.95)
+                            disable_model_cache = gr.Checkbox(False, label="Disable model caching")
+                with gr.Tab("Image-to-Image"):
                     with gr.Row():
-                        randomize_seed = gr.Checkbox(True, label="Randomize seed")
-                        seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0, randomize=True)
-                        disable_model_cache = gr.Checkbox(False, label="Disable model caching")
+                        with gr.Column():
+                            #input_image = gr.Image(label="Input image", type="filepath", height=256, sources=["upload", "clipboard"], show_share_button=False)
+                            input_image = gr.ImageEditor(label='Input image', type='filepath', sources=["upload", "clipboard"], image_mode='RGB', show_share_button=False, show_fullscreen_button=False,
+                                                        layers=False, brush=gr.Brush(colors=["white"], color_mode="fixed", default_size=32), eraser=gr.Eraser(default_size="32"), value=None,
+                                                        canvas_size=(384, 384), width=384, height=512)
+                        with gr.Column():
+                            task_type = gr.Radio(label="Task", choices=["Text-to-Image", "Image-to-Image", "Inpainting"], value="Text-to-Image")
+                            image_strength = gr.Slider(label="Strength", info="Lower means more image influence in I2I, opposite in Inpaint", minimum=0.01, maximum=1.0, step=0.01, value=0.75)
+                            blur_mask = gr.Checkbox(label="Blur mask", value=False)
+                            blur_factor = gr.Slider(label="Blur factor", minimum=0, maximum=50, step=1, value=33)
+                            input_image_preprocess = gr.Checkbox(True, label="Preprocess Input image")
+                with gr.Tab("More LoRA"):
                     with gr.Accordion("External LoRA", open=True):
                         with gr.Column():
                             deselect_lora_button = gr.Button("Remove External LoRAs", variant="secondary")
@@ -939,27 +980,27 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
                                     lora_download = [None] * num_loras
                                     for i in range(num_loras):
                                         lora_download[i] = gr.Button(f"Get and set LoRA to {int(i+1)}")
-                    with gr.Accordion("ControlNet (extremely slow)", open=True, visible=False):
-                        with gr.Column():
-                            cn_on = gr.Checkbox(False, label="Use ControlNet")
-                            cn_mode = [None] * num_cns
-                            cn_scale = [None] * num_cns
-                            cn_image = [None] * num_cns
-                            cn_image_ref = [None] * num_cns
-                            cn_res = [None] * num_cns
-                            cn_num = [None] * num_cns
-                            with gr.Row():
-                                for i in range(num_cns):
-                                    with gr.Column():
-                                        cn_mode[i] = gr.Radio(label=f"ControlNet {int(i+1)} Mode", choices=get_control_union_mode(), value=get_control_union_mode()[0])
-                                        with gr.Row():
-                                            cn_scale[i] = gr.Slider(label=f"ControlNet {int(i+1)} Weight", minimum=0.0, maximum=1.0, step=0.01, value=0.75)
-                                            cn_res[i] = gr.Slider(label=f"ControlNet {int(i+1)} Preprocess resolution", minimum=128, maximum=512, value=384, step=1)
-                                            cn_num[i] = gr.Number(i, visible=False)
-                                        with gr.Row():
-                                            cn_image_ref[i] = gr.Image(label="Image Reference", type="pil", format="png", height=256, sources=["upload", "clipboard"], show_share_button=False)
-                                            cn_image[i] = gr.Image(label="Control Image", type="pil", format="png", height=256, show_share_button=False, interactive=False)
-    
+                with gr.Tab("ControlNet", visible=False):
+                    with gr.Column():
+                        cn_on = gr.Checkbox(False, label="Use ControlNet")
+                        cn_mode = [None] * num_cns
+                        cn_scale = [None] * num_cns
+                        cn_image = [None] * num_cns
+                        cn_image_ref = [None] * num_cns
+                        cn_res = [None] * num_cns
+                        cn_num = [None] * num_cns
+                        with gr.Row():
+                            for i in range(num_cns):
+                                with gr.Column():
+                                    cn_mode[i] = gr.Radio(label=f"ControlNet {int(i+1)} Mode", choices=get_control_union_mode(), value=get_control_union_mode()[0])
+                                    with gr.Row():
+                                        cn_scale[i] = gr.Slider(label=f"ControlNet {int(i+1)} Weight", minimum=0.0, maximum=1.0, step=0.01, value=0.75)
+                                        cn_res[i] = gr.Slider(label=f"ControlNet {int(i+1)} Preprocess resolution", minimum=128, maximum=512, value=384, step=1)
+                                        cn_num[i] = gr.Number(i, visible=False)
+                                    with gr.Row():
+                                        cn_image_ref[i] = gr.Image(label="Image Reference", type="pil", format="png", height=256, sources=["upload", "clipboard"], show_share_button=False)
+                                        cn_image[i] = gr.Image(label="Control Image", type="pil", format="png", height=256, show_share_button=False, interactive=False)
+
     gallery.select(
         update_selection,
         inputs=[selected_indices, loras_state, width, height],
@@ -1000,7 +1041,7 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
     ).success(
         fn=run_lora,
         inputs=[prompt, input_image, image_strength, task_type, blur_mask, blur_factor, cfg_scale, steps, selected_indices, lora_scale_1, lora_scale_2,
-                randomize_seed, seed, width, height, loras_state, lora_repo_json, cn_on, auto_trans], 
+                randomize_seed, seed, width, height, sigmas_factor, loras_state, lora_repo_json, cn_on, auto_trans], 
         outputs=[result, seed, progress_bar],
         queue=True,
         show_api=True,

live_preview_helpers.py

@@ -60,6 +60,7 @@ def flux_pipe_call_that_returns_an_iterable_of_images(
     joint_attention_kwargs: Optional[Dict[str, Any]] = None,
     max_sequence_length: int = 512,
     good_vae: Optional[Any] = None,
+    sigmas: Optional[List[float]] = None, # MOD
 ):
     height = height or self.default_sample_size * self.vae_scale_factor
     width = width or self.default_sample_size * self.vae_scale_factor
@@ -108,7 +109,7 @@ def flux_pipe_call_that_returns_an_iterable_of_images(
         latents,
     )
     # 5. Prepare timesteps
-    sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps)
+    sigmas = np.linspace(1.0, 1 / num_inference_steps, num_inference_steps) if sigmas is None else sigmas # MOD
     image_seq_len = latents.shape[1]
     mu = calculate_shift(
         image_seq_len,

modutils.py

@@ -172,7 +172,7 @@ class ModelInformation:
         self.download_url = json_data.get("downloadUrl", "")
         self.model_url = f"https://civitai.com/models/{self.model_id}?modelVersionId={self.model_version_id}"
         self.filename_url = next(
-            (v.get("name", "") for v in json_data.get("files", []) if str(self.model_version_id) in v.get("downloadUrl", "")), ""
+            (v.get("name", "") for v in reversed(json_data.get("files", [])) if str(self.model_version_id) in v.get("downloadUrl", "")), ""
         )
         self.filename_url = self.filename_url if self.filename_url else ""
         self.description = json_data.get("description", "")
@@ -302,6 +302,10 @@ def safe_float(input):
     return output
 
 
+def valid_model_name(model_name: str):
+    return model_name.split(" ")[0]
+
+
 def save_images(images: list[Image.Image], metadatas: list[str]):
     from PIL import PngImagePlugin
     import uuid
@@ -566,7 +570,8 @@ private_lora_model_list = get_private_lora_model_lists()
 
 def get_civitai_info(path):
     global civitai_not_exists_list
-    if path in set(civitai_not_exists_list): return ["", "", "", "", ""]
+    default = ["", "", "", "", ""]
+    if path in set(civitai_not_exists_list): return default
     if not Path(path).exists(): return None
     user_agent = get_user_agent()
     headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
@@ -584,12 +589,12 @@ def get_civitai_info(path):
         r = session.get(url, params=params, headers=headers, stream=True, timeout=(3.0, 15))
     except Exception as e:
         print(e)
-        return ["", "", "", "", ""]
+        return default
     if not r.ok: return None
     json = r.json()
     if not 'baseModel' in json:
         civitai_not_exists_list.append(path)
-        return ["", "", "", "", ""]
+        return default
     items = []
     items.append(" / ".join(json['trainedWords']))
     items.append(json['baseModel'])
@@ -690,7 +695,7 @@ def copy_lora(path: str, new_path: str):
         return None
 
 
-def download_my_lora(dl_urls: str, lora1: str, lora2: str, lora3: str, lora4: str, lora5: str):
+def download_my_lora(dl_urls: str, lora1: str, lora2: str, lora3: str, lora4: str, lora5: str, lora6: str, lora7: str):
     path = download_lora(dl_urls)
     if path:
         if not lora1 or lora1 == "None":
@@ -703,9 +708,13 @@ def download_my_lora(dl_urls: str, lora1: str, lora2: str, lora3: str, lora4: st
             lora4 = path
         elif not lora5 or lora5 == "None":
             lora5 = path
+        #elif not lora6 or lora6 == "None":
+        #    lora6 = path
+        #elif not lora7 or lora7 == "None":
+        #    lora7 = path
     choices = get_all_lora_tupled_list()
     return gr.update(value=lora1, choices=choices), gr.update(value=lora2, choices=choices), gr.update(value=lora3, choices=choices),\
-        gr.update(value=lora4, choices=choices), gr.update(value=lora5, choices=choices)
+        gr.update(value=lora4, choices=choices), gr.update(value=lora5, choices=choices), gr.update(value=lora6, choices=choices), gr.update(value=lora7, choices=choices)
 
 
 def get_valid_lora_name(query: str, model_name: str):
@@ -745,25 +754,31 @@ def get_valid_lora_wt(prompt: str, lora_path: str, lora_wt: float):
     return wt
 
 
-def set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
-    if not "Classic" in str(prompt_syntax):  return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
+def set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt):
+    if not "Classic" in str(prompt_syntax):  return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt
     lora1 = get_valid_lora_name(lora1, model_name)
     lora2 = get_valid_lora_name(lora2, model_name)
     lora3 = get_valid_lora_name(lora3, model_name)
     lora4 = get_valid_lora_name(lora4, model_name)
     lora5 = get_valid_lora_name(lora5, model_name)
-    if not "<lora" in prompt: return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
+    #lora6 = get_valid_lora_name(lora6, model_name)
+    #lora7 = get_valid_lora_name(lora7, model_name)
+    if not "<lora" in prompt: return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt
     lora1_wt = get_valid_lora_wt(prompt, lora1, lora1_wt)
     lora2_wt = get_valid_lora_wt(prompt, lora2, lora2_wt)
     lora3_wt = get_valid_lora_wt(prompt, lora3, lora3_wt)
     lora4_wt = get_valid_lora_wt(prompt, lora4, lora4_wt)
     lora5_wt = get_valid_lora_wt(prompt, lora5, lora5_wt)
+    #lora6_wt = get_valid_lora_wt(prompt, lora6, lora5_wt)
+    #lora7_wt = get_valid_lora_wt(prompt, lora7, lora5_wt)
     on1, label1, tag1, md1 = get_lora_info(lora1)
     on2, label2, tag2, md2 = get_lora_info(lora2)
     on3, label3, tag3, md3 = get_lora_info(lora3)
     on4, label4, tag4, md4 = get_lora_info(lora4)
     on5, label5, tag5, md5 = get_lora_info(lora5)
-    lora_paths = [lora1, lora2, lora3, lora4, lora5]
+    #on6, label6, tag6, md6 = get_lora_info(lora6)
+    #on7, label7, tag7, md7 = get_lora_info(lora7)
+    lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
     prompts = prompt.split(",") if prompt else []
     for p in prompts:
         p = str(p).strip()
@@ -780,30 +795,40 @@ def set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2,
                 continue
             elif not on1:
                 lora1 = path
-                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
                 lora1_wt = safe_float(wt)
                 on1 = True
             elif not on2:
                 lora2 = path
-                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
                 lora2_wt = safe_float(wt)
                 on2 = True
             elif not on3:
                 lora3 = path
-                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
                 lora3_wt = safe_float(wt)
                 on3 = True
             elif not on4:
                 lora4 = path
-                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
                 lora4_wt = safe_float(wt)
                 on4 = True
             elif not on5:
                 lora5 = path
-                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
                 lora5_wt = safe_float(wt)
                 on5 = True
-    return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
+            #elif not on6:
+            #    lora6 = path
+            #    lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
+            #    lora6_wt = safe_float(wt)
+            #    on6 = True
+            #elif not on7:
+            #    lora7 = path
+            #    lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
+            #    lora7_wt = safe_float(wt)
+            #    on7 = True
+    return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt
 
 
 def get_lora_info(lora_path: str):
@@ -864,13 +889,15 @@ def apply_lora_prompt(prompt: str = "", lora_info: str = ""):
     return gr.update(value=prompt)
 
 
-def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
+def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt):
     on1, label1, tag1, md1 = get_lora_info(lora1)
     on2, label2, tag2, md2 = get_lora_info(lora2)
     on3, label3, tag3, md3 = get_lora_info(lora3)
     on4, label4, tag4, md4 = get_lora_info(lora4)
     on5, label5, tag5, md5 = get_lora_info(lora5)
-    lora_paths = [lora1, lora2, lora3, lora4, lora5]
+    on6, label6, tag6, md6 = get_lora_info(lora6)
+    on7, label7, tag7, md7 = get_lora_info(lora7)
+    lora_paths = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
 
     output_prompt = prompt
     if "Classic" in str(prompt_syntax):
@@ -895,6 +922,8 @@ def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3,
         if on3: lora_prompts.append(f"<lora:{to_lora_key(lora3)}:{lora3_wt:.2f}>")
         if on4: lora_prompts.append(f"<lora:{to_lora_key(lora4)}:{lora4_wt:.2f}>")
         if on5: lora_prompts.append(f"<lora:{to_lora_key(lora5)}:{lora5_wt:.2f}>")
+        #if on6: lora_prompts.append(f"<lora:{to_lora_key(lora6)}:{lora6_wt:.2f}>")
+        #if on7: lora_prompts.append(f"<lora:{to_lora_key(lora7)}:{lora7_wt:.2f}>")
         output_prompt = ", ".join(list_uniq(output_prompts + lora_prompts + [""]))
     choices = get_all_lora_tupled_list()
 
@@ -907,7 +936,11 @@ def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3,
      gr.update(value=lora4, choices=choices), gr.update(value=lora4_wt),\
      gr.update(value=tag4, label=label4, visible=on4), gr.update(visible=on4), gr.update(value=md4, visible=on4),\
      gr.update(value=lora5, choices=choices), gr.update(value=lora5_wt),\
-     gr.update(value=tag5, label=label5, visible=on5), gr.update(visible=on5), gr.update(value=md5, visible=on5)
+     gr.update(value=tag5, label=label5, visible=on5), gr.update(visible=on5), gr.update(value=md5, visible=on5),\
+     gr.update(value=lora6, choices=choices), gr.update(value=lora6_wt),\
+     gr.update(value=tag6, label=label6, visible=on6), gr.update(visible=on6), gr.update(value=md6, visible=on6),\
+     gr.update(value=lora7, choices=choices), gr.update(value=lora7_wt),\
+     gr.update(value=tag7, label=label7, visible=on7), gr.update(visible=on7), gr.update(value=md7, visible=on7)
 
 
 def get_my_lora(link_url, romanize):
@@ -926,7 +959,6 @@ def get_my_lora(link_url, romanize):
             path.resolve().rename(new_path.resolve())
             update_lora_dict(str(new_path))
             l_path = str(new_path)
-    new_lora_model_list = get_lora_model_list()
     new_lora_tupled_list = get_all_lora_tupled_list()
     msg_lora = "Downloaded"
     if l_name:
@@ -943,6 +975,10 @@ def get_my_lora(link_url, romanize):
         choices=new_lora_tupled_list
     ), gr.update(
         choices=new_lora_tupled_list
+    ), gr.update(
+        choices=new_lora_tupled_list
+    ), gr.update(
+        choices=new_lora_tupled_list
     ), gr.update(
         value=msg_lora
     )
@@ -975,12 +1011,19 @@ def move_file_lora(filepaths):
         choices=new_lora_tupled_list
     ), gr.update(
         choices=new_lora_tupled_list
+    ), gr.update(
+        choices=new_lora_tupled_list
+    ), gr.update(
+        choices=new_lora_tupled_list
     )
 
 
-CIVITAI_SORT = ["Highest Rated", "Most Downloaded", "Newest"]
+CIVITAI_SORT = ["Highest Rated", "Most Downloaded", "Most Liked", "Most Discussed", "Most Collected", "Most Buzz", "Newest"]
 CIVITAI_PERIOD = ["AllTime", "Year", "Month", "Week", "Day"]
-CIVITAI_BASEMODEL = ["Pony", "Illustrious", "SDXL 1.0", "SD 1.5", "Flux.1 D", "Flux.1 S"]
+CIVITAI_BASEMODEL = ["Pony", "Illustrious", "SDXL 1.0", "SD 1.5", "Flux.1 D", "Flux.1 S"] # , "SD 3.5"
+CIVITAI_TYPE = ["Checkpoint", "TextualInversion", "Hypernetwork", "AestheticGradient", "LORA", "LoCon", "DoRA",
+                "Controlnet", "Upscaler", "MotionModule", "VAE", "Poses", "Wildcards", "Workflows", "Other"]
+CIVITAI_FILETYPE = ["Model", "VAE", "Config", "Training Data"]
 
 
 def get_civitai_info(path):
@@ -1025,6 +1068,7 @@ def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1
                            sort: str = "Highest Rated", period: str = "AllTime", tag: str = "", user: str = "", page: int = 1):
     user_agent = get_user_agent()
     headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
+    if CIVITAI_API_KEY: headers['Authorization'] = f'Bearer {{{CIVITAI_API_KEY}}}'
     base_url = 'https://civitai.com/api/v1/models'
     params = {'types': ['LORA'], 'sort': sort, 'period': period, 'limit': limit, 'page': int(page), 'nsfw': 'true'}
     if query: params["query"] = query

requirements.txt

@@ -14,6 +14,6 @@ numpy<2
 opencv-python
 deepspeed
 mediapipe
-openai==1.37.0
+openai>=1.37.0
 translatepy
 unidecode