Upload 4 files

app.py

@@ -163,7 +163,6 @@ def process_string(input_string):
 ## BEGIN MOD
 from modutils import (
     download_private_repo,
-    get_private_lora_model_lists,
     get_local_model_list,
     get_model_id_list,
     escape_lora_basename,
@@ -172,6 +171,7 @@ from modutils import (
     get_tupled_embed_list,
     update_lora_dict,
     get_lora_model_list,
+    get_all_lora_tupled_list,
 )
 from env import (
     hf_token,
@@ -253,18 +253,19 @@ def get_my_lora(link_url):
             path.resolve().rename(new_path.resolve())
             update_lora_dict(str(new_path))
     new_lora_model_list = get_lora_model_list()
+    new_lora_tupled_list = get_all_lora_tupled_list()
     
     return gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list), value=new_lora_model_list[-1]
+        choices=new_lora_tupled_list, value=new_lora_model_list[-1]
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
-    ),
+        choices=new_lora_tupled_list
+    )
 ## END MOD
 
 print('\033[33m🏁 Download and listing of valid models completed.\033[0m')
@@ -384,7 +385,6 @@ from modutils import (
     move_file_lora,
     set_lora_trigger,
     set_lora_prompt,
-    get_lora_tupled_list,
     apply_lora_prompt,
     search_civitai_lora,
     select_civitai_lora,
@@ -1032,35 +1032,35 @@ with gr.Blocks(theme="NoCrypt/miku@>=1.2.2", elem_id="main", css=CSS) as app:
                     hires_negative_prompt_gui = gr.Textbox(label="Hires Negative Prompt", placeholder="Main negative prompt will be use", lines=3)
 
                 with gr.Accordion("LoRA", open=False, visible=True) as menu_lora:
-                    lora1_gui = gr.Dropdown(label="Lora1", choices=get_lora_tupled_list(lora_model_list), value="", allow_custom_value=True)
+                    lora1_gui = gr.Dropdown(label="Lora1", choices=get_all_lora_tupled_list(), value="", allow_custom_value=True)
                     lora_scale_1_gui = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="Lora Scale 1")
                     with gr.Row():
                         with gr.Group():
                             lora1_trigger_gui = gr.Textbox(label="Lora1 prompts", info="Example of prompt:", value="None", show_copy_button=True, interactive=False, visible=False)
                             lora1_copy_button = gr.Button(value="Copy example to prompt", visible=False)
                         lora1_desc_gui = gr.Markdown(value="", visible=False)
-                    lora2_gui = gr.Dropdown(label="Lora2", choices=get_lora_tupled_list(lora_model_list), value="", allow_custom_value=True)
+                    lora2_gui = gr.Dropdown(label="Lora2", choices=get_all_lora_tupled_list(), value="", allow_custom_value=True)
                     lora_scale_2_gui = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="Lora Scale 2")
                     with gr.Row():
                         with gr.Group():
                             lora2_trigger_gui = gr.Textbox(label="Lora2 prompts", info="Example of prompt:", value="None", show_copy_button=True, interactive=False, visible=False)
                             lora2_copy_button = gr.Button(value="Copy example to prompt", visible=False)
                         lora2_desc_gui = gr.Markdown(value="", visible=False)
-                    lora3_gui = gr.Dropdown(label="Lora3", choices=get_lora_tupled_list(lora_model_list), value="", allow_custom_value=True)
+                    lora3_gui = gr.Dropdown(label="Lora3", choices=get_all_lora_tupled_list(), value="", allow_custom_value=True)
                     lora_scale_3_gui = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="Lora Scale 3")
                     with gr.Row():
                         with gr.Group():
                             lora3_trigger_gui = gr.Textbox(label="Lora3 prompts", info="Example of prompt:", value="None", show_copy_button=True, interactive=False, visible=False)
                             lora3_copy_button = gr.Button(value="Copy example to prompt", visible=False)
                         lora3_desc_gui = gr.Markdown(value="", visible=False)
-                    lora4_gui = gr.Dropdown(label="Lora4", choices=get_lora_tupled_list(lora_model_list), value="", allow_custom_value=True)
+                    lora4_gui = gr.Dropdown(label="Lora4", choices=get_all_lora_tupled_list(), value="", allow_custom_value=True)
                     lora_scale_4_gui = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="Lora Scale 4")
                     with gr.Row():
                         with gr.Group():
                             lora4_trigger_gui = gr.Textbox(label="Lora4 prompts", info="Example of prompt:", value="None", show_copy_button=True, interactive=False, visible=False)
                             lora4_copy_button = gr.Button(value="Copy example to prompt", visible=False)
                         lora4_desc_gui = gr.Markdown(value="", visible=False)
-                    lora5_gui = gr.Dropdown(label="Lora5", choices=get_lora_tupled_list(lora_model_list), value="", allow_custom_value=True)
+                    lora5_gui = gr.Dropdown(label="Lora5", choices=get_all_lora_tupled_list(), value="", allow_custom_value=True)
                     lora_scale_5_gui = gr.Slider(minimum=-2, maximum=2, step=0.01, value=1.00, label="Lora Scale 5")
                     with gr.Row():
                         with gr.Group():

modutils.py

@@ -1,6 +1,7 @@
 import json
 import gradio as gr
 from huggingface_hub import HfApi
+import os
 from pathlib import Path
 
 from env import (
@@ -10,29 +11,21 @@ from env import (
     HF_MODEL_USER_LIKES,
     directory_loras,
     hf_read_token,
+    hf_token,
+    CIVITAI_API_KEY,
 )
 
+
 def get_user_agent():
     return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:127.0) Gecko/20100101 Firefox/127.0'
 
 
-def change_interface_mode(mode: str):
-    if mode == "Fast":
-        return gr.update(open=False), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
-        gr.update(visible=True), gr.update(open=False), gr.update(visible=True), gr.update(open=False),\
-        gr.update(visible=True), gr.update(value="Fast")
-    elif mode == "Simple": # t2i mode
-        return gr.update(open=True), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
-        gr.update(visible=True), gr.update(open=False), gr.update(visible=False), gr.update(open=True),\
-        gr.update(visible=False), gr.update(value="Standard")
-    elif mode == "LoRA": # t2i LoRA  mode
-        return gr.update(open=True), gr.update(visible=True), gr.update(open=True), gr.update(open=False),\
-        gr.update(visible=True), gr.update(open=True), gr.update(visible=True), gr.update(open=False),\
-        gr.update(visible=False), gr.update(value="Standard")
-    else: # Standard
-        return gr.update(open=False), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
-        gr.update(visible=True), gr.update(open=False), gr.update(visible=True), gr.update(open=False),\
-        gr.update(visible=True), gr.update(value="Standard")
+def list_uniq(l):
+        return sorted(set(l), key=l.index)
+
+
+def list_sub(a, b):
+    return [e for e in a if e not in b]
 
 
 def get_local_model_list(dir_path):
@@ -45,25 +38,83 @@ def get_local_model_list(dir_path):
     return model_list
 
 
-def list_uniq(l):
-        return sorted(set(l), key=l.index)
+def download_things(directory, url, hf_token="", civitai_api_key=""):
+    url = url.strip()
+    
+    if "drive.google.com" in url:
+        original_dir = os.getcwd()
+        os.chdir(directory)
+        os.system(f"gdown --fuzzy {url}")
+        os.chdir(original_dir)
+    elif "huggingface.co" in url:
+        url = url.replace("?download=true", "")
+        # url = urllib.parse.quote(url, safe=':/')  # fix encoding
+        if "/blob/" in url:
+            url = url.replace("/blob/", "/resolve/")
+        user_header = f'"Authorization: Bearer {hf_token}"'
+        if hf_token:
+            os.system(f"aria2c --console-log-level=error --summary-interval=10 --header={user_header} -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
+        else:
+            os.system (f"aria2c --optimize-concurrent-downloads --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 {url} -d {directory}  -o {url.split('/')[-1]}")
+    elif "civitai.com" in url:
+        if "?" in url:
+            url = url.split("?")[0]
+        if civitai_api_key:
+            url = url + f"?token={civitai_api_key}"
+            os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
+        else:
+            print("\033[91mYou need an API key to download Civitai models.\033[0m")
+    else:
+        os.system(f"aria2c --console-log-level=error --summary-interval=10 -c -x 16 -k 1M -s 16 -d {directory} {url}")
 
 
-def list_sub(a, b):
-    return [e for e in a if e not in b]
+def escape_lora_basename(basename: str):
+    return basename.replace(".", "_").replace(" ", "_").replace(",", "")
 
 
-def normalize_prompt_list(tags):
-    prompts = []
-    for tag in tags:
-        tag = str(tag).strip()
-        if tag:
-            prompts.append(tag)
-    return prompts
+def to_lora_key(path: str):
+    return escape_lora_basename(Path(path).stem)
 
 
-def escape_lora_basename(basename: str):
-    return basename.replace(".", "_").replace(" ", "_").replace(",", "")
+def to_lora_path(key: str):
+    if Path(key).is_file(): return key
+    path = Path(f"{directory_loras}/{escape_lora_basename(key)}.safetensors")
+    return str(path)
+
+
+def safe_float(input):
+    output = 1.0
+    try:
+        output = float(input)
+    except Exception:
+        output = 1.0
+    return output
+
+
+def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
+    from datetime import datetime, timezone, timedelta
+    progress(0, desc="Updating gallery...")
+    dt_now = datetime.now(timezone(timedelta(hours=9)))
+    basename = dt_now.strftime('%Y%m%d_%H%M%S_')
+    i = 1
+    if not images: return images
+    output_images = []
+    output_paths = []
+    for image in images:
+        filename = basename + str(i) + ".png"
+        i += 1
+        oldpath = Path(image[0])
+        newpath = oldpath
+        try:
+            if oldpath.exists():
+                newpath = oldpath.resolve().rename(Path(filename).resolve())
+        except Exception:
+           pass
+        finally: 
+            output_paths.append(str(newpath))
+            output_images.append((str(newpath), str(filename)))
+    progress(1, desc="Gallery updated.")
+    return gr.update(value=output_images), gr.update(value=output_paths), gr.update(visible=True)
 
 
 def download_private_repo(repo_id, dir_path, is_replace):
@@ -72,6 +123,7 @@ def download_private_repo(repo_id, dir_path, is_replace):
     try:
         snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], use_auth_token=hf_read_token)
     except Exception as e:
+        print(f"Error: Failed to download {repo_id}. ")
         return
     if is_replace:
         for file in Path(dir_path).glob("*"):
@@ -102,24 +154,6 @@ def get_private_model_list(repo_id, dir_path):
     return model_list
 
 
-private_lora_model_list = []
-def get_private_lora_model_lists():
-    global private_lora_model_list
-    if len(private_lora_model_list) != 0: return private_lora_model_list
-    models1 = []
-    models2 = []
-    for repo in HF_LORA_PRIVATE_REPOS1:
-        models1.extend(get_private_model_list(repo, directory_loras))
-    for repo in HF_LORA_PRIVATE_REPOS2:
-        models2.extend(get_private_model_list(repo, directory_loras))
-    models = list_uniq(models1 + sorted(models2))
-    private_lora_model_list = models
-    return models
-
-
-private_lora_model_list = get_private_lora_model_lists()
-
-
 def download_private_file(repo_id, path, is_replace):
     from huggingface_hub import hf_hub_download
     file = Path(path)
@@ -142,7 +176,10 @@ def download_private_file_from_somewhere(path, is_replace):
     download_private_file(repo_id, path, is_replace)
 
 
+model_id_list = []
 def get_model_id_list():
+    global model_id_list
+    if len(model_id_list) != 0: return model_id_list
     api = HfApi()
     model_ids = []
     try:
@@ -153,6 +190,7 @@ def get_model_id_list():
         for author in HF_MODEL_USER_EX:
             models_ex = api.list_models(author=author, cardData=True, sort="last_modified")
     except Exception as e:
+        print(f"Error: Failed to list {author}'s models. ")
         return model_ids
     for model in models_likes:
         model_ids.append(model.id) if not model.private else ""
@@ -163,15 +201,20 @@ def get_model_id_list():
             anime_models.append(model.id) if 'anime' in model.tags else real_models.append(model.id)
     model_ids.extend(anime_models)
     model_ids.extend(real_models)
+    model_id_list = model_ids.copy()
     return model_ids
 
 
+model_id_list = get_model_id_list()
+
+
 def get_t2i_model_info(repo_id: str):
     api = HfApi()
     try:
         if " " in repo_id or not api.repo_exists(repo_id): return ""
         model = api.model_info(repo_id=repo_id)
     except Exception as e:
+        print(f"Error: Failed to get {repo_id}'s info. ")
         return ""
     if model.private or model.gated: return ""
     tags = model.tags
@@ -220,71 +263,37 @@ def get_tupled_model_list(model_list):
     return tupled_list
 
 
-def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
-    from datetime import datetime, timezone, timedelta
-    progress(0, desc="Updating gallery...")
-    dt_now = datetime.now(timezone(timedelta(hours=9)))
-    basename = dt_now.strftime('%Y%m%d_%H%M%S_')
-    i = 1
-    if not images: return images
-    output_images = []
-    output_paths = []
-    for image in images:
-        filename = basename + str(i) + ".png"
-        i += 1
-        oldpath = Path(image[0])
-        newpath = oldpath
-        try:
-            if oldpath.exists():
-                newpath = oldpath.resolve().rename(Path(filename).resolve())
-        except Exception:
-           pass
-        finally: 
-            output_paths.append(str(newpath))
-            output_images.append((str(newpath), str(filename)))
-    progress(1, desc="Gallery updated.")
-    return gr.update(value=output_images), gr.update(value=output_paths), gr.update(visible=True)
-
+private_lora_dict = {}
+try:
+    with open('lora_dict.json', encoding='utf-8') as f:
+        d = json.load(f)
+        for k, v in d.items():
+            private_lora_dict[escape_lora_basename(k)] = v
+except Exception:
+    pass
+loras_dict = {"None": ["", "", "", "", ""], "": ["", "", "", "", ""]} | private_lora_dict.copy()
+civitai_not_exists_list = []
+loras_url_to_path_dict = {} # {"URL to download": "local filepath", ...}
+civitai_lora_last_results = {}  # {"URL to download": {search results}, ...}
+all_lora_list = []
 
-optimization_list = {
-    "None": [28, 7., 'Euler a', False, 'None', 1.],
-    "Default": [28, 7., 'Euler a', False, 'None', 1.],
-    "SPO": [28, 7., 'Euler a', True, 'loras/spo_sdxl_10ep_4k-data_lora_diffusers.safetensors', 1.],
-    "DPO": [28, 7., 'Euler a', True, 'loras/sdxl-DPO-LoRA.safetensors', 1.],
-    "DPO Turbo": [8, 2.5, 'LCM', True, 'loras/sd_xl_dpo_turbo_lora_v1-128dim.safetensors', 1.],
-    "SDXL Turbo": [8, 2.5, 'LCM', True, 'loras/sd_xl_turbo_lora_v1.safetensors', 1.],
-    "Hyper-SDXL 12step": [12, 5., 'TCD', True, 'loras/Hyper-SDXL-12steps-CFG-lora.safetensors', 1.],
-    "Hyper-SDXL 8step": [8, 5., 'TCD', True, 'loras/Hyper-SDXL-8steps-CFG-lora.safetensors', 1.],
-    "Hyper-SDXL 4step": [4, 0, 'TCD', True, 'loras/Hyper-SDXL-4steps-lora.safetensors', 1.],
-    "Hyper-SDXL 2step": [2, 0, 'TCD', True, 'loras/Hyper-SDXL-2steps-lora.safetensors', 1.],
-    "Hyper-SDXL 1step": [1, 0, 'TCD', True, 'loras/Hyper-SDXL-1steps-lora.safetensors', 1.],
-    "PCM 16step": [16, 4., 'Euler a trailing', True, 'loras/pcm_sdxl_normalcfg_16step_converted.safetensors', 1.],
-    "PCM 8step": [8, 4., 'Euler a trailing', True, 'loras/pcm_sdxl_normalcfg_8step_converted.safetensors', 1.],
-    "PCM 4step": [4, 2., 'Euler a trailing', True, 'loras/pcm_sdxl_smallcfg_4step_converted.safetensors', 1.],
-    "PCM 2step": [2, 1., 'Euler a trailing', True, 'loras/pcm_sdxl_smallcfg_2step_converted.safetensors', 1.],
-}
 
+private_lora_model_list = []
+def get_private_lora_model_lists():
+    global private_lora_model_list
+    if len(private_lora_model_list) != 0: return private_lora_model_list
+    models1 = []
+    models2 = []
+    for repo in HF_LORA_PRIVATE_REPOS1:
+        models1.extend(get_private_model_list(repo, directory_loras))
+    for repo in HF_LORA_PRIVATE_REPOS2:
+        models2.extend(get_private_model_list(repo, directory_loras))
+    models = list_uniq(models1 + sorted(models2))
+    private_lora_model_list = models.copy()
+    return models
 
-def set_optimization(opt, steps_gui, cfg_gui, sampler_gui, clip_skip_gui, lora_gui, lora_scale_gui):
-    if not opt in list(optimization_list.keys()): opt = "None"
-    def_steps_gui = 28
-    def_cfg_gui = 7.
-    steps = optimization_list.get(opt, "None")[0]
-    cfg = optimization_list.get(opt, "None")[1]
-    sampler = optimization_list.get(opt, "None")[2]
-    clip_skip = optimization_list.get(opt, "None")[3]
-    lora = optimization_list.get(opt, "None")[4]
-    lora_scale = optimization_list.get(opt, "None")[5]
-    if opt == "None":
-        steps = max(steps_gui, def_steps_gui)
-        cfg = max(cfg_gui, def_cfg_gui)
-        clip_skip = clip_skip_gui
-    elif opt == "SPO" or opt == "DPO":
-        steps = max(steps_gui, def_steps_gui)
-        cfg = max(cfg_gui, def_cfg_gui)
 
-    return gr.update(value=steps), gr.update(value=cfg), gr.update(value=sampler),\
-          gr.update(value=clip_skip), gr.update(value=lora), gr.update(value=lora_scale),
+private_lora_model_list = get_private_lora_model_lists()
 
 
 def set_lora_prompt(prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui,\
@@ -318,19 +327,6 @@ def set_lora_prompt(prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui,
     return gr.update(value=prompt)
 
 
-lora_trigger_dict = {"None": ["", "", "", "", ""], "": ["", "", "", "", ""]}
-try:
-    with open('lora_dict.json', encoding='utf-8') as f:
-        temp_dict = json.load(f)
-        for k, v in temp_dict.items():
-            lora_trigger_dict[escape_lora_basename(k)] = v
-except Exception:
-    pass
-
-
-civitai_not_exists_list = []
-
-
 def get_civitai_info(path):
     global civitai_not_exists_list
     import requests
@@ -368,15 +364,6 @@ def get_civitai_info(path):
     return items
 
 
-def update_lora_dict(path):
-    global lora_trigger_dict
-    key = escape_lora_basename(Path(path).stem)
-    if key in lora_trigger_dict.keys(): return
-    items = get_civitai_info(path)
-    if items == None: return
-    lora_trigger_dict[key] = items
-
-
 def get_lora_model_list():
     loras = list_uniq(get_private_lora_model_lists() + get_local_model_list(directory_loras))
     loras.insert(0, "None")
@@ -384,22 +371,29 @@ def get_lora_model_list():
     return loras
 
 
-def get_lora_tupled_list(lora_model_list):
-    global lora_trigger_dict
-    if not lora_model_list: return []
+def get_all_lora_list():
+    global all_lora_list
+    loras = get_lora_model_list()
+    all_lora_list = loras.copy()
+    return loras
+
+
+def get_all_lora_tupled_list():
+    global loras_dict
+    models = get_all_lora_list()
+    if not models: return []
     tupled_list = []
-    local_models = set(get_local_model_list(directory_loras))
-    for model in lora_model_list:
-        #if not model: continue
-        basename = Path(model).stem if model else ""
-        key = escape_lora_basename(basename)
+    for model in models:
+        #if not model: continue # to avoid GUI-related bug
+        basename = Path(model).stem
+        key = to_lora_key(model)
         items = None
-        if key in lora_trigger_dict.keys():
-            items = lora_trigger_dict.get(key, None)
-        elif model in local_models:
+        if key in loras_dict.keys():
+            items = loras_dict.get(key, None)
+        else:
             items = get_civitai_info(model)
             if items != None:
-                lora_trigger_dict[key] = items
+                loras_dict[key] = items
         name = basename
         value = model
         if items and items[2] != "":
@@ -411,12 +405,312 @@ def get_lora_tupled_list(lora_model_list):
     return tupled_list
 
 
+def update_lora_dict(path):
+    global loras_dict
+    key = escape_lora_basename(Path(path).stem)
+    if key in loras_dict.keys(): return
+    items = get_civitai_info(path)
+    if items == None: return
+    loras_dict[key] = items
+
+
+def download_lora(dl_urls: str):
+    global loras_url_to_path_dict
+    dl_path = ""
+    before = get_local_model_list(directory_loras)
+    urls = []
+    for url in [url.strip() for url in dl_urls.split(',')]:
+        local_path = f"{directory_loras}/{url.split('/')[-1]}"
+        if not Path(local_path).exists():
+            download_things(directory_loras, url, hf_token, CIVITAI_API_KEY)
+            urls.append(url)
+    after = get_local_model_list(directory_loras)
+    new_files = list_sub(after, before)
+    i = 0
+    for file in new_files:
+        path = Path(file)
+        if path.exists():
+            new_path = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
+            path.resolve().rename(new_path.resolve())
+            loras_url_to_path_dict[urls[i]] = str(new_path)
+            update_lora_dict(str(new_path))
+            dl_path = str(new_path)
+        i += 1
+    return dl_path
+
+
+def copy_lora(path: str, new_path: str):
+    import shutil
+    if path == new_path: return new_path
+    cpath = Path(path)
+    npath = Path(new_path)
+    if cpath.exists():
+        try:
+            shutil.copy(str(cpath.resolve()), str(npath.resolve()))
+        except Exception:
+            return None
+        update_lora_dict(str(npath))
+        return new_path
+    else:
+        return None
+
+
+def download_my_lora(dl_urls: str, lora1: str, lora2: str, lora3: str, lora4: str, lora5: str):
+    path = download_lora(dl_urls)
+    if path:
+        if not lora1 or lora1 == "None":
+            lora1 = path
+        elif not lora2 or lora2 == "None":
+            lora2 = path
+        elif not lora3 or lora3 == "None":
+            lora3 = path
+        elif not lora4 or lora4 == "None":
+            lora4 = path
+        elif not lora5 or lora5 == "None":
+            lora5 = 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)
+
+
+def get_valid_lora_name(query: str):
+    path = "None"
+    if not query or query == "None": return "None"
+    if to_lora_key(query) in loras_dict.keys(): return query
+    if query in loras_url_to_path_dict.keys():
+        path = loras_url_to_path_dict[query]
+    else:
+        path = to_lora_path(query.strip().split('/')[-1])
+    if Path(path).exists():
+        return path
+    elif "http" in query:
+        dl_file = download_lora(query)
+        if dl_file and Path(dl_file).exists(): return dl_file
+    else:
+        dl_file = find_similar_lora(query)
+        if dl_file and Path(dl_file).exists(): return dl_file
+    return "None"
+
+
+def get_valid_lora_path(query: str):
+    path = None
+    if not query or query == "None": return None
+    if to_lora_key(query) in loras_dict.keys(): return query
+    if Path(path).exists():
+        return path
+    else:
+        return None
+
+
+def get_valid_lora_wt(prompt: str, lora_path: str, lora_wt: float):
+    import re
+    wt = lora_wt
+    result = re.findall(f'<lora:{to_lora_key(lora_path)}:(.+?)>', prompt)
+    if not result: return wt
+    wt = safe_float(result[0][0])
+    return wt
+
+
+def set_prompt_loras(prompt, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
+    import re
+    lora1 = get_valid_lora_name(lora1)
+    lora2 = get_valid_lora_name(lora2)
+    lora3 = get_valid_lora_name(lora3)
+    lora4 = get_valid_lora_name(lora4)
+    lora5 = get_valid_lora_name(lora5)
+    if not "<lora" in prompt: return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_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)
+    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]
+
+    prompts = prompt.split(",") if prompt else []
+    for p in prompts:
+        p = str(p).strip()
+        if "<lora" in p:
+            result = re.findall(r'<lora:(.+?):(.+?)>', p)
+            if not result: continue
+            key = result[0][0]
+            wt = result[0][1]
+            path = to_lora_path(key)
+            if not key in loras_dict.keys() or not path:
+                path = get_valid_lora_name(path)
+                if not path or path == "None": continue
+            if path in lora_paths:
+                continue
+            elif not on1:
+                lora1 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora1_wt = safe_float(wt)
+                on1 = True
+            elif not on2:
+                lora2 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora2_wt = safe_float(wt)
+                on2 = True
+            elif not on3:
+                lora3 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora3_wt = safe_float(wt)
+                on3 = True
+            elif not on4:
+                lora4 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora4_wt = safe_float(wt)
+                on4, label4, tag4, md4 = get_lora_info(lora4)
+            elif not on5:
+                lora5 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora5_wt = safe_float(wt)
+                on5 = True
+
+    return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
+
+
+def get_lora_info(lora_path: str):
+    is_valid = False
+    tag = ""
+    label = ""
+    md = "None"
+    if not lora_path or lora_path == "None": return is_valid, label, tag, md
+    path = Path(lora_path)
+    new_path = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
+    if not to_lora_key(str(new_path)) in loras_dict.keys() and not str(path) in set(all_lora_list):
+        return tag, label, md
+    if not new_path.exists():
+        download_private_file_from_somewhere(str(path), True)
+    basename = new_path.stem
+    label = f'Name: {basename}'
+    items = loras_dict.get(basename, None)
+    if items == None:
+        items = get_civitai_info(str(new_path))
+        if items != None:
+            loras_dict[basename] = items
+    if items and items[2] != "":
+        tag = items[0]
+        label = f'Name: {basename}'
+        if items[1] == "Pony":
+            label = f'Name: {basename} (for Pony🐴)'
+        if items[4]:
+            md = f'<img src="{items[4]}" alt="thumbnail" width="150" height="240"><br>[LoRA Model URL]({items[3]})'
+        elif items[3]:
+            md = f'[LoRA Model URL]({items[3]})'
+    is_valid = True
+    return is_valid, label, tag, md
+
+
+def normalize_prompt_list(tags: list[str]):
+    prompts = []
+    for tag in tags:
+        tag = str(tag).strip()
+        if tag:
+            prompts.append(tag)
+    return prompts
+
+'''
+def apply_lora_prompt(prompt: str, lora_info: str):
+    if lora_info == "None": return gr.update(value=prompt)
+    tags = prompt.split(",") if prompt else []
+    prompts = normalize_prompt_list(tags)
+
+    lora_tag = lora_info.replace("/",",")
+    lora_tags = lora_tag.split(",") if str(lora_info) != "None" else []
+    lora_prompts = normalize_prompt_list(lora_tags)
+ 
+    empty = [""]
+    prompt = ", ".join(list_uniq(prompts + lora_prompts) + empty)
+    return gr.update(value=prompt)
+'''
+
+def update_loras(prompt, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
+    import re
+    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]
+
+    prompts = prompt.split(",") if prompt else []
+    output_prompts = []
+    for p in prompts:
+        p = str(p).strip()
+        if "<lora" in p:
+            result = re.findall(r'<lora:(.+?):(.+?)>', p)
+            if not result: continue
+            key = result[0][0]
+            wt = result[0][1]
+            path = to_lora_path(key)
+            if not key in loras_dict.keys() or not path: continue
+            if path in lora_paths:
+                output_prompts.append(f"<lora:{to_lora_key(path)}:{safe_float(wt):.2f}>")
+            elif not on1:
+                lora1 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora1_wt = safe_float(wt)
+                on1, label1, tag1, md1 = get_lora_info(lora1)
+                output_prompts.append(f"<lora:{to_lora_key(lora1)}:{lora1_wt:.2f}>")
+            elif not on2:
+                lora2 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora2_wt = safe_float(wt)
+                on2, label2, tag2, md2 = get_lora_info(lora2)
+                output_prompts.append(f"<lora:{to_lora_key(lora2)}:{lora2_wt:.2f}>")
+            elif not on3:
+                lora3 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora3_wt = safe_float(wt)
+                on3, label3, tag3, md3 = get_lora_info(lora3)
+                output_prompts.append(f"<lora:{to_lora_key(lora3)}:{lora3_wt:.2f}>")
+            elif not on4:
+                lora4 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora4_wt = safe_float(wt)
+                on4, label4, tag4, md4 = get_lora_info(lora4)
+                output_prompts.append(f"<lora:{to_lora_key(lora4)}:{lora4_wt:.2f}>")
+            elif not on5:
+                lora5 = path
+                lora_paths = [lora1, lora2, lora3, lora4, lora5]
+                lora5_wt = safe_float(wt)
+                on5, label5, tag5, md5 = get_lora_info(lora5)
+                output_prompts.append(f"<lora:{to_lora_key(lora5)}:{lora5_wt:.2f}>")
+        elif p:
+            output_prompts.append(p)
+    lora_prompts = []
+    if on1: lora_prompts.append(f"<lora:{to_lora_key(lora1)}:{lora1_wt:.2f}>")
+    if on2: lora_prompts.append(f"<lora:{to_lora_key(lora2)}:{lora2_wt:.2f}>")
+    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}>")
+    output_prompt = ", ".join(list_uniq(output_prompts + lora_prompts + [""]))
+
+    choices = get_all_lora_tupled_list()
+
+    return gr.update(value=output_prompt), gr.update(value=lora1, choices=choices), gr.update(value=lora1_wt),\
+     gr.update(value=tag1, label=label1, visible=on1), gr.update(visible=on1), gr.update(value=md1, visible=on1),\
+     gr.update(value=lora2, choices=choices), gr.update(value=lora2_wt),\
+     gr.update(value=tag2, label=label2, visible=on2), gr.update(visible=on2), gr.update(value=md2, visible=on2),\
+     gr.update(value=lora3, choices=choices), gr.update(value=lora3_wt),\
+     gr.update(value=tag3, label=label3, visible=on3), gr.update(visible=on3), gr.update(value=md3, visible=on3),\
+     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)
+
+
 def set_lora_trigger(lora_gui: str):
     if not lora_gui or lora_gui == "None": return gr.update(value="", visible=False), gr.update(visible=False),\
           gr.update(value="", visible=False), gr.update(value="")
     path = Path(lora_gui)
     new_path = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
-    if not new_path.stem in lora_trigger_dict.keys() and not str(path) in set(get_lora_model_list()):
+    if not new_path.stem in loras_dict.keys() and not str(path) in set(get_lora_model_list()):
         return gr.update(value="", visible=False), gr.update(visible=False),\
               gr.update(value="", visible=False), gr.update(value="")
     if not new_path.exists():
@@ -427,11 +721,11 @@ def set_lora_trigger(lora_gui: str):
     value = "None"
     md = "None"
     flag = False
-    items = lora_trigger_dict.get(basename, None)
+    items = loras_dict.get(basename, None)
     if items == None:
         items = get_civitai_info(str(new_path))
         if items != None:
-            lora_trigger_dict[basename] = items
+            loras_dict[basename] = items
             flag = True
     if items and items[2] != "":
         tag = items[0]
@@ -484,18 +778,19 @@ def move_file_lora(filepaths):
         update_lora_dict(str(newpath))
 
     new_lora_model_list = get_lora_model_list()
+    new_lora_tupled_list = get_all_lora_tupled_list()
     
     return gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list), value=new_lora_model_list[-1]
+        choices=new_lora_tupled_list, value=new_lora_model_list[-1]
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
+        choices=new_lora_tupled_list
     ), gr.update(
-        choices=get_lora_tupled_list(new_lora_model_list)
-    ),
+        choices=new_lora_tupled_list
+    )
 
 
 def search_lora_on_civitai(query: str, allow_model: list[str]):
@@ -563,6 +858,58 @@ def select_civitai_lora(search_result):
     return gr.update(value=search_result), gr.update(value=md, visible=True)
 
 
+def find_similar_lora(q: str):
+    from rapidfuzz.process import extractOne
+    from rapidfuzz.utils import default_process
+    query = to_lora_key(q)
+    print(f"Finding <lora:{query}:...>...")
+    keys = list(private_lora_dict.keys())
+    values = [x[2] for x in list(private_lora_dict.values())]
+    s = default_process(query)
+    e1 = extractOne(s, keys + values, processor=default_process, score_cutoff=80.0)
+    key = ""
+    if e1:
+        e = e1[0]
+        if e in set(keys): key = e
+        elif e in set(values): key = keys[values.index(e)]
+    if key:
+        path = to_lora_path(key)
+        new_path = to_lora_path(query)
+        if not Path(path).exists():
+            if not Path(new_path).exists(): download_private_file_from_somewhere(path, True)
+            if Path(path).exists() and copy_lora(path, new_path): return new_path
+    print(f"Finding <lora:{query}:...> on Civitai...")
+    civitai_query = Path(query).stem if Path(query).is_file() else query
+    civitai_query = civitai_query.replace("_", " ").replace("-", " ")
+    base_model = ["Pony", "SDXL 1.0"]
+    items = search_lora_on_civitai(civitai_query, base_model, 1)
+    if items:
+        item = items[0]
+        path = download_lora(item['dl_url'])
+        new_path = query if Path(query).is_file() else to_lora_path(query)
+        if path and copy_lora(path, new_path): return new_path
+    return None
+
+
+def change_interface_mode(mode: str):
+    if mode == "Fast":
+        return gr.update(open=False), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
+        gr.update(visible=True), gr.update(open=False), gr.update(visible=True), gr.update(open=False),\
+        gr.update(visible=True), gr.update(value="Fast")
+    elif mode == "Simple": # t2i mode
+        return gr.update(open=True), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
+        gr.update(visible=True), gr.update(open=False), gr.update(visible=False), gr.update(open=True),\
+        gr.update(visible=False), gr.update(value="Standard")
+    elif mode == "LoRA": # t2i LoRA  mode
+        return gr.update(open=True), gr.update(visible=True), gr.update(open=True), gr.update(open=False),\
+        gr.update(visible=True), gr.update(open=True), gr.update(visible=True), gr.update(open=False),\
+        gr.update(visible=False), gr.update(value="Standard")
+    else: # Standard
+        return gr.update(open=False), gr.update(visible=True), gr.update(open=False), gr.update(open=False),\
+        gr.update(visible=True), gr.update(open=False), gr.update(visible=True), gr.update(open=False),\
+        gr.update(visible=True), gr.update(value="Standard")
+
+
 quality_prompt_list = [
     {
         "name": "None",
@@ -661,6 +1008,47 @@ style_list = [
 ]
 
 
+optimization_list = {
+    "None": [28, 7., 'Euler a', False, 'None', 1.],
+    "Default": [28, 7., 'Euler a', False, 'None', 1.],
+    "SPO": [28, 7., 'Euler a', True, 'loras/spo_sdxl_10ep_4k-data_lora_diffusers.safetensors', 1.],
+    "DPO": [28, 7., 'Euler a', True, 'loras/sdxl-DPO-LoRA.safetensors', 1.],
+    "DPO Turbo": [8, 2.5, 'LCM', True, 'loras/sd_xl_dpo_turbo_lora_v1-128dim.safetensors', 1.],
+    "SDXL Turbo": [8, 2.5, 'LCM', True, 'loras/sd_xl_turbo_lora_v1.safetensors', 1.],
+    "Hyper-SDXL 12step": [12, 5., 'TCD', True, 'loras/Hyper-SDXL-12steps-CFG-lora.safetensors', 1.],
+    "Hyper-SDXL 8step": [8, 5., 'TCD', True, 'loras/Hyper-SDXL-8steps-CFG-lora.safetensors', 1.],
+    "Hyper-SDXL 4step": [4, 0, 'TCD', True, 'loras/Hyper-SDXL-4steps-lora.safetensors', 1.],
+    "Hyper-SDXL 2step": [2, 0, 'TCD', True, 'loras/Hyper-SDXL-2steps-lora.safetensors', 1.],
+    "Hyper-SDXL 1step": [1, 0, 'TCD', True, 'loras/Hyper-SDXL-1steps-lora.safetensors', 1.],
+    "PCM 16step": [16, 4., 'Euler a trailing', True, 'loras/pcm_sdxl_normalcfg_16step_converted.safetensors', 1.],
+    "PCM 8step": [8, 4., 'Euler a trailing', True, 'loras/pcm_sdxl_normalcfg_8step_converted.safetensors', 1.],
+    "PCM 4step": [4, 2., 'Euler a trailing', True, 'loras/pcm_sdxl_smallcfg_4step_converted.safetensors', 1.],
+    "PCM 2step": [2, 1., 'Euler a trailing', True, 'loras/pcm_sdxl_smallcfg_2step_converted.safetensors', 1.],
+}
+
+
+def set_optimization(opt, steps_gui, cfg_gui, sampler_gui, clip_skip_gui, lora_gui, lora_scale_gui):
+    if not opt in list(optimization_list.keys()): opt = "None"
+    def_steps_gui = 28
+    def_cfg_gui = 7.
+    steps = optimization_list.get(opt, "None")[0]
+    cfg = optimization_list.get(opt, "None")[1]
+    sampler = optimization_list.get(opt, "None")[2]
+    clip_skip = optimization_list.get(opt, "None")[3]
+    lora = optimization_list.get(opt, "None")[4]
+    lora_scale = optimization_list.get(opt, "None")[5]
+    if opt == "None":
+        steps = max(steps_gui, def_steps_gui)
+        cfg = max(cfg_gui, def_cfg_gui)
+        clip_skip = clip_skip_gui
+    elif opt == "SPO" or opt == "DPO":
+        steps = max(steps_gui, def_steps_gui)
+        cfg = max(cfg_gui, def_cfg_gui)
+
+    return gr.update(value=steps), gr.update(value=cfg), gr.update(value=sampler),\
+          gr.update(value=clip_skip), gr.update(value=lora), gr.update(value=lora_scale),
+
+
 # [sampler_gui, steps_gui, cfg_gui, clip_skip_gui, img_width_gui, img_height_gui, optimization_gui]
 preset_sampler_setting = {
     "None": ["Euler a", 28, 7., True, 1024, 1024, "None"],
@@ -832,14 +1220,12 @@ def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_g
         tag = str(tag).strip()
         if tag and not tag in ti_tags:
             prompts.append(tag)
-
     ntags = neg_prompt_gui.split(",") if neg_prompt_gui else []
     neg_prompts = []
     for tag in ntags:
         tag = str(tag).strip()
         if tag and not tag in ti_tags:
             neg_prompts.append(tag)
-
     ti_prompts = []
     ti_neg_prompts = []
     for ti in textual_inversion_gui:
@@ -849,11 +1235,9 @@ def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_g
             ti_prompts.append(tokens[0])
         else: # negative prompt (default)
             ti_neg_prompts.append(tokens[0])
- 
     empty = [""]
     prompt = ", ".join(prompts + ti_prompts + empty)
     neg_prompt = ", ".join(neg_prompts + ti_neg_prompts + empty)
-
     return gr.update(value=prompt), gr.update(value=neg_prompt),
 
 

requirements.txt

@@ -13,4 +13,5 @@ huggingface_hub
 httpx==0.13.3
 httpcore
 googletrans==4.0.0rc1
-timm
+timm
+rapidfuzz