Upload 4 files

app.py

@@ -20,10 +20,10 @@ from mod import (clear_cache, get_repo_safetensors, is_repo_name, is_repo_exists
                  description_ui, compose_lora_json, is_valid_lora, fuse_loras, save_image, preprocess_i2i_image,
                  get_trigger_word, enhance_prompt, set_control_union_image,
                  get_control_union_mode, set_control_union_mode, get_control_params, translate_to_en)
-from flux import (search_civitai_lora, select_civitai_lora, search_civitai_lora_json,
-                  download_my_lora, get_all_lora_tupled_list, apply_lora_prompt,
-                  update_loras)
-from modutils import get_t2i_model_info, download_hf_file
+from modutils import (search_civitai_lora, select_civitai_lora, search_civitai_lora_json,
+                      download_my_lora_flux, get_all_lora_tupled_list, apply_lora_prompt_flux,
+                      update_loras_flux, update_civitai_selection, get_civitai_tag, CIVITAI_SORT, CIVITAI_PERIOD,
+                      get_t2i_model_info, download_hf_file)
 from tagger.tagger import predict_tags_wd, compose_prompt_to_copy
 from tagger.fl2flux import predict_tags_fl2_flux
 
@@ -674,7 +674,8 @@ css = '''
 #custom_lora_btn{margin-top: auto;margin-bottom: 11px}
 #random_btn{font-size: 300%}
 #component-11{align-self: stretch;}
-.info {text-align:center; !important}
+.info { align-items: center; text-align: center; }
+.desc [src$='#float'] { float: right; margin: 20px; }
 '''
 with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_cache=(60, 3600)) as app:
     with gr.Tab("FLUX LoRA the Explorer"):
@@ -730,14 +731,8 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
         with gr.Row():
             with gr.Column():
                 selected_info = gr.Markdown("")
-                gallery = gr.Gallery(
-                    [(item["image"], item["title"]) for item in loras],
-                    label="LoRA Gallery",
-                    allow_preview=False,
-                    columns=5,
-                    elem_id="gallery",
-                    show_share_button=False
-                )
+                gallery = gr.Gallery([(item["image"], item["title"]) for item in loras], label="LoRA Gallery", allow_preview=False,
+                                     columns=5, elem_id="gallery", show_share_button=False, interactive=False)
                 with gr.Group():
                     with gr.Row(elem_id="custom_lora_structure"):
                         custom_lora = gr.Textbox(label="Custom LoRA", info="LoRA Hugging Face path or *.safetensors public URL", placeholder="multimodalart/vintage-ads-flux", scale=3, min_width=150)
@@ -802,15 +797,18 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
                             with gr.Accordion("From URL", open=True, visible=True):
                                 with gr.Row():
                                     lora_search_civitai_basemodel = gr.CheckboxGroup(label="Search LoRA for", choices=["Flux.1 D", "Flux.1 S"], value=["Flux.1 D"])
-                                    lora_search_civitai_sort = gr.Radio(label="Sort", choices=["Highest Rated", "Most Downloaded", "Newest"], value="Most Downloaded")
-                                    lora_search_civitai_period = gr.Radio(label="Period", choices=["AllTime", "Year", "Month", "Week", "Day"], value="Month")
+                                    lora_search_civitai_sort = gr.Radio(label="Sort", choices=CIVITAI_SORT, value="Most Downloaded")
+                                    lora_search_civitai_period = gr.Radio(label="Period", choices=CIVITAI_PERIOD, value="Month")
                                 with gr.Row():
                                     lora_search_civitai_query = gr.Textbox(label="Query", placeholder="flux", lines=1)
-                                    lora_search_civitai_tag = gr.Textbox(label="Tag", lines=1)
-                                    lora_search_civitai_submit = gr.Button("Search on Civitai")
+                                    lora_search_civitai_tag = gr.Dropdown(label="Tag", choices=get_civitai_tag(), value=get_civitai_tag()[0], allow_custom_value=True)
+                                    lora_search_civitai_user = gr.Textbox(label="Username", lines=1)
+                                lora_search_civitai_submit = gr.Button("Search on Civitai")
                                 with gr.Row():
                                     lora_search_civitai_json = gr.JSON(value={}, visible=False)
-                                    lora_search_civitai_desc = gr.Markdown(value="", visible=False)
+                                    lora_search_civitai_desc = gr.Markdown(value="", visible=False, elem_classes="desc")
+                                with gr.Accordion("Select from Gallery", open=False):
+                                    lora_search_civitai_gallery = gr.Gallery([], label="Results", allow_preview=False, columns=5, show_share_button=False, interactive=False)
                                 lora_search_civitai_result = gr.Dropdown(label="Search Results", choices=[("", "")], value="", allow_custom_value=True, visible=False)
                                 lora_download_url = gr.Textbox(label="LoRA URL", placeholder="https://civitai.com/api/download/models/28907", lines=1)
                                 with gr.Row():
@@ -901,22 +899,24 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
     prompt_enhance.click(enhance_prompt, [prompt], [prompt], queue=False, show_api=False)
 
     gr.on(
-        triggers=[lora_search_civitai_submit.click, lora_search_civitai_query.submit, lora_search_civitai_tag.submit],
+        triggers=[lora_search_civitai_submit.click, lora_search_civitai_query.submit],
         fn=search_civitai_lora,
-        inputs=[lora_search_civitai_query, lora_search_civitai_basemodel, lora_search_civitai_sort, lora_search_civitai_period, lora_search_civitai_tag],
-        outputs=[lora_search_civitai_result, lora_search_civitai_desc, lora_search_civitai_submit, lora_search_civitai_query],
+        inputs=[lora_search_civitai_query, lora_search_civitai_basemodel, lora_search_civitai_sort, lora_search_civitai_period,
+                lora_search_civitai_tag, lora_search_civitai_user, lora_search_civitai_gallery],
+        outputs=[lora_search_civitai_result, lora_search_civitai_desc, lora_search_civitai_submit, lora_search_civitai_query, lora_search_civitai_gallery],
         scroll_to_output=True,
         queue=True,
         show_api=False,
     )
     lora_search_civitai_json.change(search_civitai_lora_json, [lora_search_civitai_query, lora_search_civitai_basemodel], [lora_search_civitai_json], queue=True, show_api=True)  # fn for api
     lora_search_civitai_result.change(select_civitai_lora, [lora_search_civitai_result], [lora_download_url, lora_search_civitai_desc], scroll_to_output=True, queue=False, show_api=False)
+    lora_search_civitai_gallery.select(update_civitai_selection, None, [lora_search_civitai_result], queue=False, show_api=False)
 
     for i, l in enumerate(lora_repo):
         deselect_lora_button.click(lambda: ("", 1.0), None, [lora_repo[i], lora_wt[i]], queue=False, show_api=False)
         gr.on(
             triggers=[lora_download[i].click],
-            fn=download_my_lora,
+            fn=download_my_lora_flux,
             inputs=[lora_download_url, lora_repo[i]],
             outputs=[lora_repo[i]],
             scroll_to_output=True,
@@ -925,14 +925,14 @@ with gr.Blocks(theme='NoCrypt/miku@>=1.2.2', fill_width=True, css=css, delete_ca
         )
         gr.on(
             triggers=[lora_repo[i].change, lora_wt[i].change],
-            fn=update_loras,
+            fn=update_loras_flux,
             inputs=[prompt, lora_repo[i], lora_wt[i]],
             outputs=[prompt, lora_repo[i], lora_wt[i], lora_info[i], lora_md[i]],
             queue=False,
             trigger_mode="once",
             show_api=False,
         ).success(get_repo_safetensors, [lora_repo[i]], [lora_weights[i]], queue=False, show_api=False
-        ).success(apply_lora_prompt, [lora_info[i]], [lora_trigger[i]], queue=False, show_api=False
+        ).success(apply_lora_prompt_flux, [lora_info[i]], [lora_trigger[i]], queue=False, show_api=False
         ).success(compose_lora_json, [lora_repo_json, lora_num[i], lora_repo[i], lora_wt[i], lora_weights[i], lora_trigger[i]], [lora_repo_json], queue=False, show_api=False)
         
     for i, m in enumerate(cn_mode):

mod.py

@@ -5,7 +5,8 @@ from PIL import Image
 from pathlib import Path
 import gc
 import subprocess
-from env import num_cns, model_trigger, HF_TOKEN
+from env import num_cns, model_trigger, HF_TOKEN, CIVITAI_API_KEY, download_lora_list, directory_loras
+from modutils import download_things
 import os
 
 
@@ -18,6 +19,12 @@ control_images = [None] * num_cns
 control_modes = [-1] * num_cns
 control_scales = [0] * num_cns
 
+# Download stuffs
+download_lora = ", ".join(download_lora_list)
+for url in [url.strip() for url in download_lora.split(',')]:
+    if not os.path.exists(f"./loras/{url.split('/')[-1]}"):
+        download_things(directory_loras, url, HF_TOKEN, CIVITAI_API_KEY)
+
 
 def is_repo_name(s):
     import re

modutils.py

@@ -2,11 +2,16 @@ import spaces
 import json
 import gradio as gr
 import os
+import re
 from pathlib import Path
 from PIL import Image
-from huggingface_hub import HfApi, HfFolder, hf_hub_download, snapshot_download
+import shutil
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
 import urllib.parse
-import re
+import pandas as pd
+from huggingface_hub import HfApi, HfFolder, hf_hub_download, snapshot_download
 
 
 from env import (HF_LORA_PRIVATE_REPOS1, HF_LORA_PRIVATE_REPOS2,
@@ -38,7 +43,6 @@ def list_sub(a, b):
 
 
 def is_repo_name(s):
-    import re
     return re.fullmatch(r'^[^/]+?/[^/]+?$', s)
 
 
@@ -226,7 +230,6 @@ def save_gallery_images(images, progress=gr.Progress(track_tqdm=True)):
 
 
 def download_private_repo(repo_id, dir_path, is_replace):
-    from huggingface_hub import snapshot_download
     if not hf_read_token: return
     try:
         snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], use_auth_token=hf_read_token)
@@ -265,7 +268,6 @@ def get_private_model_list(repo_id, dir_path):
 
 
 def download_private_file(repo_id, path, is_replace):
-    from huggingface_hub import hf_hub_download
     file = Path(path)
     newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}') if is_replace else file
     if not hf_read_token or newpath.exists(): return
@@ -389,7 +391,9 @@ except Exception as e:
 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}, ...}
+civitai_last_results = {}  # {"URL to download": {search results}, ...}
+civitai_last_choices = [("", "")]
+civitai_last_gallery = []
 all_lora_list = []
 
 
@@ -413,9 +417,6 @@ private_lora_model_list = get_private_lora_model_lists()
 
 def get_civitai_info(path):
     global civitai_not_exists_list
-    import requests
-    from urllib3.util import Retry
-    from requests.adapters import HTTPAdapter
     if path in set(civitai_not_exists_list): return ["", "", "", "", ""]
     if not Path(path).exists(): return None
     user_agent = get_user_agent()
@@ -450,7 +451,7 @@ def get_civitai_info(path):
 
 
 def get_lora_model_list():
-    loras = list_uniq(get_private_lora_model_lists() + get_local_model_list(directory_loras) + DIFFUSERS_FORMAT_LORAS)
+    loras = list_uniq(get_private_lora_model_lists() + DIFFUSERS_FORMAT_LORAS + get_local_model_list(directory_loras))
     loras.insert(0, "None")
     loras.insert(0, "")
     return loras
@@ -525,7 +526,6 @@ def download_lora(dl_urls: str):
 
 
 def copy_lora(path: str, new_path: str):
-    import shutil
     if path == new_path: return new_path
     cpath = Path(path)
     npath = Path(new_path)
@@ -589,7 +589,6 @@ def get_valid_lora_path(query: str):
 
 
 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
@@ -598,7 +597,6 @@ def get_valid_lora_wt(prompt: str, lora_path: str, lora_wt: float):
 
 
 def set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt):
-    import re
     if not "Classic" in str(prompt_syntax):  return lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt
     lora1 = get_valid_lora_name(lora1, model_name)
     lora2 = get_valid_lora_name(lora2, model_name)
@@ -718,7 +716,6 @@ def apply_lora_prompt(prompt: str = "", lora_info: str = ""):
 
 
 def update_loras(prompt, prompt_syntax, 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)
@@ -765,7 +762,6 @@ def update_loras(prompt, prompt_syntax, lora1, lora1_wt, lora2, lora2_wt, lora3,
 
 
 def get_my_lora(link_url):
-    from pathlib import Path
     before = get_local_model_list(directory_loras)
     for url in [url.strip() for url in link_url.split(',')]:
         if not Path(f"{directory_loras}/{url.split('/')[-1]}").exists():
@@ -802,7 +798,6 @@ def upload_file_lora(files, progress=gr.Progress(track_tqdm=True)):
 
 
 def move_file_lora(filepaths):
-    import shutil
     for file in filepaths:
         path = Path(shutil.move(Path(file).resolve(), Path(f"./{directory_loras}").resolve()))
         newpath = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
@@ -825,11 +820,13 @@ def move_file_lora(filepaths):
     )
 
 
+CIVITAI_SORT = ["Highest Rated", "Most Downloaded", "Newest"]
+CIVITAI_PERIOD = ["AllTime", "Year", "Month", "Week", "Day"]
+CIVITAI_BASEMODEL = ["Pony", "SD 1.5", "SDXL 1.0", "Flux.1 D", "Flux.1 S"]
+
+
 def get_civitai_info(path):
     global civitai_not_exists_list, loras_url_to_path_dict
-    import requests
-    from requests.adapters import HTTPAdapter
-    from urllib3.util import Retry
     default = ["", "", "", "", ""]
     if path in set(civitai_not_exists_list): return default
     if not Path(path).exists(): return None
@@ -867,16 +864,14 @@ def get_civitai_info(path):
 
 
 def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1.0"], limit: int = 100,
-                           sort: str = "Highest Rated", period: str = "AllTime", tag: str = ""):
-    import requests
-    from requests.adapters import HTTPAdapter
-    from urllib3.util import Retry
+                           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'}
     base_url = 'https://civitai.com/api/v1/models'
-    params = {'types': ['LORA'], 'sort': sort, 'period': period, 'limit': limit, 'nsfw': 'true'}
+    params = {'types': ['LORA'], 'sort': sort, 'period': period, 'limit': limit, 'page': int(page), 'nsfw': 'true'}
     if query: params["query"] = query
     if tag: params["tag"] = tag
+    if user: params["username"] = user
     session = requests.Session()
     retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
     session.mount("https://", HTTPAdapter(max_retries=retries))
@@ -893,46 +888,129 @@ def search_lora_on_civitai(query: str, allow_model: list[str] = ["Pony", "SDXL 1
         for j in json['items']:
             for model in j['modelVersions']:
                 item = {}
-                if model['baseModel'] not in set(allow_model): continue
+                if len(allow_model) != 0 and model['baseModel'] not in set(allow_model): continue
                 item['name'] = j['name']
-                item['creator'] = j['creator']['username']
-                item['tags'] = j['tags']
-                item['model_name'] = model['name']
-                item['base_model'] = model['baseModel']
+                item['creator'] = j['creator']['username'] if 'creator' in j.keys() and 'username' in j['creator'].keys() else ""
+                item['tags'] = j['tags'] if 'tags' in j.keys() else []
+                item['model_name'] = model['name'] if 'name' in model.keys() else ""
+                item['base_model'] = model['baseModel'] if 'baseModel' in model.keys() else ""
+                item['description'] = model['description'] if 'description' in model.keys() else ""
                 item['dl_url'] = model['downloadUrl']
-                item['md'] = f'<img src="{model["images"][0]["url"]}" alt="thumbnail" width="150" height="240"><br>[LoRA Model URL](https://civitai.com/models/{j["id"]})'
+                item['md'] = ""
+                if 'images' in model.keys() and len(model["images"]) != 0:
+                    item['img_url'] = model["images"][0]["url"]
+                    item['md'] += f'<img src="{model["images"][0]["url"]}#float" alt="thumbnail" width="150" height="240"><br>'
+                else: item['img_url'] = "/home/user/app/null.png"
+                item['md'] += f'''Model URL: [https://civitai.com/models/{j["id"]}](https://civitai.com/models/{j["id"]})<br>Model Name: {item["name"]}<br>
+                    Creator: {item["creator"]}<br>Tags: {", ".join(item["tags"])}<br>Base Model: {item["base_model"]}<br>Description: {item["description"]}'''
                 items.append(item)
         return items
 
 
-def search_civitai_lora(query, base_model, sort="Highest Rated", period="AllTime", tag=""):
-    global civitai_lora_last_results
-    items = search_lora_on_civitai(query, base_model, 100, sort, period, tag)
+def search_civitai_lora(query, base_model=[], sort=CIVITAI_SORT[0], period=CIVITAI_PERIOD[0], tag="", user="", gallery=[]):
+    global civitai_last_results, civitai_last_choices, civitai_last_gallery
+    civitai_last_choices = [("", "")]
+    civitai_last_gallery = []
+    civitai_last_results = {}
+    items = search_lora_on_civitai(query, base_model, 100, sort, period, tag, user)
     if not items: return gr.update(choices=[("", "")], value="", visible=False),\
-          gr.update(value="", visible=False), gr.update(visible=True), gr.update(visible=True)
-    civitai_lora_last_results = {}
+          gr.update(value="", visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
+    civitai_last_results = {}
     choices = []
+    gallery = []
     for item in items:
         base_model_name = "Pony🐴" if item['base_model'] == "Pony" else item['base_model']
         name = f"{item['name']} (for {base_model_name} / By: {item['creator']} / Tags: {', '.join(item['tags'])})"
         value = item['dl_url']
         choices.append((name, value))
-        civitai_lora_last_results[value] = item
+        gallery.append((item['img_url'], name))
+        civitai_last_results[value] = item
     if not choices: return gr.update(choices=[("", "")], value="", visible=False),\
-          gr.update(value="", visible=False), gr.update(visible=True), gr.update(visible=True)
-    result = civitai_lora_last_results.get(choices[0][1], "None")
+          gr.update(value="", visible=False), gr.update(visible=True), gr.update(visible=True), gr.update(visible=True)
+    civitai_last_choices = choices
+    civitai_last_gallery = gallery
+    result = civitai_last_results.get(choices[0][1], "None")
     md = result['md'] if result else ""
     return gr.update(choices=choices, value=choices[0][1], visible=True), gr.update(value=md, visible=True),\
-          gr.update(visible=True), gr.update(visible=True)
+          gr.update(visible=True), gr.update(visible=True), gr.update(value=gallery)
+
+
+def update_civitai_selection(evt: gr.SelectData):
+    try:
+        selected_index = evt.index
+        selected = civitai_last_choices[selected_index][1]
+        return gr.update(value=selected)
+    except Exception:
+        return gr.update(visible=True)
 
 
 def select_civitai_lora(search_result):
     if not "http" in search_result: return gr.update(value=""), gr.update(value="None", visible=True)
-    result = civitai_lora_last_results.get(search_result, "None")
+    result = civitai_last_results.get(search_result, "None")
     md = result['md'] if result else ""
     return gr.update(value=search_result), gr.update(value=md, visible=True)
 
 
+def download_my_lora_flux(dl_urls: str, lora):
+    path = download_lora(dl_urls)
+    if path: lora = path
+    choices = get_all_lora_tupled_list()
+    return gr.update(value=lora, choices=choices)
+
+
+def apply_lora_prompt_flux(lora_info: str):
+    if lora_info == "None": return ""
+    lora_tag = lora_info.replace("/",",")
+    lora_tags = lora_tag.split(",") if str(lora_info) != "None" else []
+    lora_prompts = normalize_prompt_list(lora_tags)
+    prompt = ", ".join(list_uniq(lora_prompts))
+    return prompt
+
+
+def update_loras_flux(prompt, lora, lora_wt):
+    on, label, tag, md = get_lora_info(lora)
+    choices = get_all_lora_tupled_list()
+    return gr.update(value=prompt), gr.update(value=lora, choices=choices), gr.update(value=lora_wt),\
+     gr.update(value=tag, label=label, visible=on), gr.update(value=md, visible=on)
+
+
+def search_civitai_lora_json(query, base_model):
+    results = {}
+    items = search_lora_on_civitai(query, base_model)
+    if not items: return gr.update(value=results)
+    for item in items:
+        results[item['dl_url']] = item
+    return gr.update(value=results)
+
+
+def get_civitai_tag():
+    default = [""]
+    user_agent = get_user_agent()
+    headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
+    base_url = 'https://civitai.com/api/v1/tags'
+    params = {'limit': 200}
+    session = requests.Session()
+    retries = Retry(total=5, backoff_factor=1, status_forcelist=[500, 502, 503, 504])
+    session.mount("https://", HTTPAdapter(max_retries=retries))
+    url = base_url
+    try:
+        r = session.get(url, params=params, headers=headers, stream=True, timeout=(3.0, 15))
+        if not r.ok: return default
+        j = dict(r.json()).copy()
+        if "items" not in j.keys(): return default
+        items = []
+        for item in j["items"]:
+            items.append([str(item.get("name", "")), int(item.get("modelCount", 0))])
+        df = pd.DataFrame(items)
+        df.sort_values(1, ascending=False)
+        tags = df.values.tolist()
+        tags = [""] + [l[0] for l in tags]
+        return tags
+    except Exception as e:
+        print(e)
+        return default
+
+
 LORA_BASE_MODEL_DICT = {
     "diffusers:StableDiffusionPipeline": ["SD 1.5"],
     "diffusers:StableDiffusionXLPipeline": ["Pony", "SDXL 1.0"],
@@ -1177,15 +1255,6 @@ preset_quality = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in qualit
 
 
 def process_style_prompt(prompt: str, neg_prompt: str, styles_key: str = "None", quality_key: str = "None", type: str = "Auto"):
-    def to_list(s):
-        return [x.strip() for x in s.split(",") if not s == ""]
-    
-    def list_sub(a, b):
-        return [e for e in a if e not in b]
-    
-    def list_uniq(l):
-        return sorted(set(l), key=l.index)
-
     animagine_ps = to_list("anime artwork, anime style, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
     animagine_nps = to_list("lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
     pony_ps = to_list("source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres")
@@ -1337,7 +1406,6 @@ def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_g
 
 
 def get_model_pipeline(repo_id: str):
-    from huggingface_hub import HfApi
     api = HfApi(token=HF_TOKEN)
     default = "StableDiffusionPipeline"
     try: