Super-squash branch 'main' using huggingface_hub

Co-authored-by: r3gm <[email protected]>

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,15 @@
+---
+title: 🧩 DiffuseCraft Mod
+emoji: 🧩🖼️📦
+colorFrom: red
+colorTo: pink
+sdk: gradio
+sdk_version: 4.37.2
+app_file: app.py
+pinned: false
+header: mini
+license: mit
+short_description: Stunning images using stable diffusion.
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,1896 @@
+import spaces
+import os
+from stablepy import Model_Diffusers
+from stablepy.diffusers_vanilla.model import scheduler_names
+from stablepy.diffusers_vanilla.style_prompt_config import STYLE_NAMES
+import torch
+import re
+import shutil
+import random
+from stablepy import (
+    CONTROLNET_MODEL_IDS,
+    VALID_TASKS,
+    T2I_PREPROCESSOR_NAME,
+    FLASH_LORA,
+    SCHEDULER_CONFIG_MAP,
+    scheduler_names,
+    IP_ADAPTER_MODELS,
+    IP_ADAPTERS_SD,
+    IP_ADAPTERS_SDXL,
+    REPO_IMAGE_ENCODER,
+    ALL_PROMPT_WEIGHT_OPTIONS,
+    SD15_TASKS,
+    SDXL_TASKS,
+)
+import urllib.parse
+
+preprocessor_controlnet = {
+  "openpose": [
+    "Openpose",
+    "None",
+  ],
+  "scribble": [
+    "HED",
+    "Pidinet",
+    "None",
+  ],
+  "softedge": [
+    "Pidinet",
+    "HED",
+    "HED safe",
+    "Pidinet safe",
+    "None",
+  ],
+  "segmentation": [
+    "UPerNet",
+    "None",
+  ],
+  "depth": [
+    "DPT",
+    "Midas",
+    "None",
+  ],
+  "normalbae": [
+    "NormalBae",
+    "None",
+  ],
+  "lineart": [
+    "Lineart",
+    "Lineart coarse",
+    "Lineart (anime)",
+    "None",
+    "None (anime)",
+  ],
+  "shuffle": [
+    "ContentShuffle",
+    "None",
+  ],
+  "canny": [
+    "Canny"
+  ],
+  "mlsd": [
+    "MLSD"
+  ],
+  "ip2p": [
+    "ip2p"
+  ]
+}
+
+task_stablepy = {
+    'txt2img': 'txt2img',
+    'img2img': 'img2img',
+    'inpaint': 'inpaint',
+    # 'canny T2I Adapter': 'sdxl_canny_t2i',  # NO HAVE STEP CALLBACK PARAMETERS SO NOT WORKS WITH DIFFUSERS 0.29.0
+    # 'sketch  T2I Adapter': 'sdxl_sketch_t2i',
+    # 'lineart  T2I Adapter': 'sdxl_lineart_t2i',
+    # 'depth-midas  T2I Adapter': 'sdxl_depth-midas_t2i',
+    # 'openpose  T2I Adapter': 'sdxl_openpose_t2i',
+    'openpose ControlNet': 'openpose',
+    'canny ControlNet': 'canny',
+    'mlsd ControlNet': 'mlsd',
+    'scribble ControlNet': 'scribble',
+    'softedge ControlNet': 'softedge',
+    'segmentation ControlNet': 'segmentation',
+    'depth ControlNet': 'depth',
+    'normalbae ControlNet': 'normalbae',
+    'lineart ControlNet': 'lineart',
+    # 'lineart_anime ControlNet': 'lineart_anime',
+    'shuffle ControlNet': 'shuffle',
+    'ip2p ControlNet': 'ip2p',
+    'optical pattern ControlNet': 'pattern',
+    'tile realistic': 'sdxl_tile_realistic',
+}
+
+task_model_list = list(task_stablepy.keys())
+
+
+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 get_model_list(directory_path):
+    model_list = []
+    valid_extensions = {'.ckpt' , '.pt', '.pth', '.safetensors', '.bin'}
+
+    for filename in os.listdir(directory_path):
+        if os.path.splitext(filename)[1] in valid_extensions:
+            name_without_extension = os.path.splitext(filename)[0]
+            file_path = os.path.join(directory_path, filename)
+            # model_list.append((name_without_extension, file_path))
+            model_list.append(file_path)
+            print('\033[34mFILE: ' + file_path + '\033[0m')
+    return model_list
+
+
+def process_string(input_string):
+    parts = input_string.split('/')
+
+    if len(parts) == 2:
+        first_element = parts[1]
+        complete_string = input_string
+        result = (first_element, complete_string)
+        return result
+    else:
+        return None
+
+
+directory_models = 'models'
+os.makedirs(directory_models, exist_ok=True)
+directory_loras = 'loras'
+os.makedirs(directory_loras, exist_ok=True)
+directory_vaes = 'vaes'
+os.makedirs(directory_vaes, exist_ok=True)
+
+
+## BEGIN MOD
+from modutils import (
+    download_private_repo,
+    get_private_model_lists,
+    get_model_id_list,
+    list_uniq,
+    get_tupled_embed_list,
+    update_lora_dict,
+)
+
+# - **Download SD 1.5 Models**
+#download_model = "https://huggingface.co/frankjoshua/toonyou_beta6/resolve/main/toonyou_beta6.safetensors"
+download_model = ""
+# - **Download VAEs**
+download_vae_list = [
+    'https://huggingface.co/madebyollin/sdxl-vae-fp16-fix/resolve/main/sdxl.vae.safetensors?download=true',
+    'https://huggingface.co/nubby/blessed-sdxl-vae-fp16-fix/resolve/main/sdxl_vae-fp16fix-c-1.1-b-0.5.safetensors?download=true',
+    'https://huggingface.co/nubby/blessed-sdxl-vae-fp16-fix/resolve/main/sdxl_vae-fp16fix-blessed.safetensors?download=true',
+]
+download_vae = ", ".join(download_vae_list)
+# - **Download LoRAs**
+download_lora_list = []
+download_lora = ", ".join(download_lora_list)
+
+HF_LORA_PRIVATE_REPOS = ['John6666/loratest1', 'John6666/loratest3', 'John6666/loratest4', 'John6666/loratest']
+HF_LORA_ESSENTIAL_PRIVATE_REPO = 'John6666/loratest1'
+download_private_repo(HF_LORA_ESSENTIAL_PRIVATE_REPO, directory_loras, True)
+download_private_repo('John6666/vaetest', directory_vaes, False)
+
+load_diffusers_format_model = [
+    'stabilityai/stable-diffusion-xl-base-1.0',
+    'cagliostrolab/animagine-xl-3.1',
+    'misri/epicrealismXL_v7FinalDestination',
+    'misri/juggernautXL_juggernautX',
+    'misri/zavychromaxl_v80',
+    'SG161222/RealVisXL_V4.0',
+    'misri/newrealityxlAllInOne_Newreality40',
+    'eienmojiki/Anything-XL',
+    'eienmojiki/Starry-XL-v5.2',
+    'gsdf/CounterfeitXL',
+    'kitty7779/ponyDiffusionV6XL',
+    'John6666/ebara-mfcg-pony-mix-v12-sdxl',
+    'John6666/t-ponynai3-v51-sdxl',
+    'yodayo-ai/kivotos-xl-2.0',
+    'yodayo-ai/holodayo-xl-2.1',
+    'digiplay/majicMIX_sombre_v2',
+    'digiplay/majicMIX_realistic_v6',
+    'digiplay/majicMIX_realistic_v7',
+    'digiplay/DreamShaper_8',
+    'digiplay/BeautifulArt_v1',
+    'digiplay/DarkSushi2.5D_v1',
+    'digiplay/darkphoenix3D_v1.1',
+    'digiplay/BeenYouLiteL11_diffusers',
+    'rubbrband/revAnimated_v2Rebirth',
+    'youknownothing/cyberrealistic_v50',
+    'votepurchase/counterfeitV30_v30',
+    'Meina/MeinaMix_V11',
+    'Meina/MeinaUnreal_V5',
+    'Meina/MeinaPastel_V7',
+    'rubbrband/realcartoon3d_v16',
+    'rubbrband/realcartoonRealistic_v14',
+    'KBlueLeaf/Kohaku-XL-Epsilon-rev2',
+    'Raelina/Rae-Diffusion-XL-V2',
+]
+
+load_diffusers_format_model = list_uniq(get_model_id_list() + load_diffusers_format_model)
+## END MOD
+
+CIVITAI_API_KEY = os.environ.get("CIVITAI_API_KEY")
+hf_token = os.environ.get("HF_TOKEN")
+
+# Download stuffs
+for url in [url.strip() for url in download_model.split(',')]:
+    if not os.path.exists(f"./models/{url.split('/')[-1]}"):
+        download_things(directory_models, url, hf_token, CIVITAI_API_KEY)
+for url in [url.strip() for url in download_vae.split(',')]:
+    if not os.path.exists(f"./vaes/{url.split('/')[-1]}"):
+        download_things(directory_vaes, url, hf_token, CIVITAI_API_KEY)
+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)
+
+# Download Embeddings
+directory_embeds = 'embedings'
+os.makedirs(directory_embeds, exist_ok=True)
+download_embeds = [
+    'https://huggingface.co/datasets/Nerfgun3/bad_prompt/blob/main/bad_prompt_version2.pt',
+    'https://huggingface.co/embed/negative/resolve/main/EasyNegativeV2.safetensors',
+    'https://huggingface.co/embed/negative/resolve/main/bad-hands-5.pt',
+    ]
+
+for url_embed in download_embeds:
+    if not os.path.exists(f"./embedings/{url_embed.split('/')[-1]}"):
+        download_things(directory_embeds, url_embed, hf_token, CIVITAI_API_KEY)
+
+# Build list models
+embed_list = get_model_list(directory_embeds)
+model_list = get_model_list(directory_models)
+model_list = load_diffusers_format_model + model_list
+lora_model_list = list_uniq(get_private_model_lists(HF_LORA_PRIVATE_REPOS, directory_loras) + get_model_list(directory_loras))
+lora_model_list.insert(0, "None")
+vae_model_list = get_model_list(directory_vaes)
+vae_model_list.insert(0, "None")
+
+## BEGIN MOD
+directory_embeds_sdxl = 'embedings_xl'
+os.makedirs(directory_embeds_sdxl, exist_ok=True)
+download_private_repo('John6666/embeddingstest', directory_embeds_sdxl, False)
+directory_embeds_postitive_sdxl = 'embedings_xl/positive'
+os.makedirs(directory_embeds_postitive_sdxl, exist_ok=True)
+download_private_repo('John6666/embeddingspositivetest', directory_embeds_postitive_sdxl, False)
+embed_sdxl_list = get_model_list(directory_embeds_sdxl) + get_model_list(directory_embeds_postitive_sdxl)
+
+def get_embed_list(pipeline_name):
+    return get_tupled_embed_list(embed_sdxl_list if pipeline_name == "StableDiffusionXLPipeline" else embed_list)
+
+def get_my_lora(link_url):
+    for url in [url.strip() for url in link_url.split(',')]:
+        if not os.path.exists(f"./loras/{url.split('/')[-1]}"):
+            download_things(directory_loras, url, hf_token, CIVITAI_API_KEY)
+            update_lora_dict(f"./loras/{url.split('/')[-1]}")
+    new_lora_model_list = list_uniq(get_private_model_lists(HF_LORA_PRIVATE_REPOS, directory_loras) + get_model_list(directory_loras))
+    new_lora_model_list.insert(0, "None")
+    
+    return gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ),
+## END MOD
+
+print('\033[33m🏁 Download and listing of valid models completed.\033[0m')
+
+upscaler_dict_gui = {
+    None : None,
+    "Lanczos" : "Lanczos",
+    "Nearest" : "Nearest",
+    "RealESRGAN_x4plus" : "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth",
+    "RealESRNet_x4plus" : "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/RealESRNet_x4plus.pth",
+    "RealESRGAN_x4plus_anime_6B": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth",
+    "RealESRGAN_x2plus": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.1/RealESRGAN_x2plus.pth",
+    "realesr-animevideov3": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-animevideov3.pth",
+    "realesr-general-x4v3": "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth",
+    "realesr-general-wdn-x4v3" : "https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-wdn-x4v3.pth",
+    "4x-UltraSharp" : "https://huggingface.co/Shandypur/ESRGAN-4x-UltraSharp/resolve/main/4x-UltraSharp.pth",
+    "4x_foolhardy_Remacri" : "https://huggingface.co/FacehugmanIII/4x_foolhardy_Remacri/resolve/main/4x_foolhardy_Remacri.pth",
+    "Remacri4xExtraSmoother" : "https://huggingface.co/hollowstrawberry/upscalers-backup/resolve/main/ESRGAN/Remacri%204x%20ExtraSmoother.pth",
+    "AnimeSharp4x" : "https://huggingface.co/hollowstrawberry/upscalers-backup/resolve/main/ESRGAN/AnimeSharp%204x.pth",
+    "lollypop" : "https://huggingface.co/hollowstrawberry/upscalers-backup/resolve/main/ESRGAN/lollypop.pth",
+    "RealisticRescaler4x" : "https://huggingface.co/hollowstrawberry/upscalers-backup/resolve/main/ESRGAN/RealisticRescaler%204x.pth",
+    "NickelbackFS4x" : "https://huggingface.co/hollowstrawberry/upscalers-backup/resolve/main/ESRGAN/NickelbackFS%204x.pth"
+}
+
+
+def extract_parameters(input_string):
+    parameters = {}
+    input_string = input_string.replace("\n", "")
+
+    if not "Negative prompt:" in input_string:
+        print("Negative prompt not detected")
+        parameters["prompt"] = input_string
+        return parameters
+
+    parm = input_string.split("Negative prompt:")
+    parameters["prompt"] = parm[0]
+    if not "Steps:" in parm[1]:
+        print("Steps not detected")
+        parameters["neg_prompt"] = parm[1]
+        return parameters
+    parm = parm[1].split("Steps:")
+    parameters["neg_prompt"] = parm[0]
+    input_string = "Steps:" + parm[1]
+
+    # Extracting Steps
+    steps_match = re.search(r'Steps: (\d+)', input_string)
+    if steps_match:
+        parameters['Steps'] = int(steps_match.group(1))
+
+    # Extracting Size
+    size_match = re.search(r'Size: (\d+x\d+)', input_string)
+    if size_match:
+        parameters['Size'] = size_match.group(1)
+        width, height = map(int, parameters['Size'].split('x'))
+        parameters['width'] = width
+        parameters['height'] = height
+
+    # Extracting other parameters
+    other_parameters = re.findall(r'(\w+): (.*?)(?=, \w+|$)', input_string)
+    for param in other_parameters:
+        parameters[param[0]] = param[1].strip('"')
+
+    return parameters
+
+
+#######################
+# GUI
+#######################
+import spaces
+import gradio as gr
+from PIL import Image
+import IPython.display
+import time, json
+from IPython.utils import capture
+import logging
+logging.getLogger("diffusers").setLevel(logging.ERROR)
+import diffusers
+diffusers.utils.logging.set_verbosity(40)
+import warnings
+warnings.filterwarnings(action="ignore", category=FutureWarning, module="diffusers")
+warnings.filterwarnings(action="ignore", category=UserWarning, module="diffusers")
+warnings.filterwarnings(action="ignore", category=FutureWarning, module="transformers")
+## BEGIN MOD
+from stablepy import logger
+logger.setLevel(logging.CRITICAL)
+
+from transformers.utils.hub import move_cache
+move_cache()
+
+from v2 import (
+    V2UI,
+    parse_upsampling_output,
+    V2_ALL_MODELS,
+)
+from utils import (
+    gradio_copy_text,
+    COPY_ACTION_JS,
+    V2_ASPECT_RATIO_OPTIONS,
+    V2_RATING_OPTIONS,
+    V2_LENGTH_OPTIONS,
+    V2_IDENTITY_OPTIONS
+)
+from tagger import (
+    predict_tags_wd,
+    convert_danbooru_to_e621_prompt,
+    remove_specific_prompt,
+    insert_recom_prompt,
+    compose_prompt_to_copy,
+    translate_prompt,
+)
+from modutils import (
+    get_t2i_model_info,
+    get_tupled_model_list,
+    save_gallery_images,
+    upload_file_lora,
+    move_file_lora,
+    set_lora_trigger,
+    set_lora_prompt,
+    get_lora_tupled_list,
+    apply_lora_prompt,
+    set_textual_inversion_prompt,
+    get_model_pipeline,
+    set_optimization,
+    set_sampler_settings,
+    process_style_prompt,
+    optimization_list,
+    preset_styles,
+    preset_quality,
+    preset_sampler_setting,
+    set_quick_presets,
+)
+def description_ui():
+    gr.Markdown(
+        """
+## Danbooru Tags Transformer V2 Demo with WD Tagger
+(Image =>) Prompt => Upsampled longer prompt
+- Mod of p1atdev's [Danbooru Tags Transformer V2 Demo](https://huggingface.co/spaces/p1atdev/danbooru-tags-transformer-v2) and [WD Tagger with 🤗 transformers](https://huggingface.co/spaces/p1atdev/wd-tagger-transformers).
+- Models: p1atdev's [wd-swinv2-tagger-v3-hf](https://huggingface.co/p1atdev/wd-swinv2-tagger-v3-hf), [dart-v2-moe-sft](https://huggingface.co/p1atdev/dart-v2-moe-sft)
+"""
+    )
+## END MOD
+
+
+def info_html(json_data, title, subtitle):
+    return f"""
+        <div style='padding: 0; border-radius: 10px;'>
+            <p style='margin: 0; font-weight: bold;'>{title}</p>
+            <details>
+                <summary>Details</summary>
+                <p style='margin: 0; font-weight: bold;'>{subtitle}</p>
+            </details>
+        </div>
+        """
+
+class GuiSD:
+    def __init__(self, stream=True):
+        self.model = None
+    
+        print("Loading model...")
+        self.model = Model_Diffusers(
+            base_model_id="cagliostrolab/animagine-xl-3.1",
+            task_name="txt2img",
+            vae_model=None,
+            type_model_precision=torch.float16,
+            retain_task_model_in_cache=False,
+        )
+
+    def load_new_model(self, model_name, vae_model, task, progress=gr.Progress(track_tqdm=True)):
+
+        yield f"Loading model: {model_name}"
+        
+        vae_model = vae_model if vae_model != "None" else None
+
+        if model_name in model_list:
+            model_is_xl = "xl" in model_name.lower()
+            sdxl_in_vae = vae_model and "sdxl" in vae_model.lower()
+            model_type = "SDXL" if model_is_xl else "SD 1.5"
+            incompatible_vae = (model_is_xl and vae_model and not sdxl_in_vae) or (not model_is_xl and sdxl_in_vae)
+
+            if incompatible_vae:
+                vae_model = None
+
+        
+        self.model.load_pipe(
+            model_name,
+            task_name=task_stablepy[task],
+            vae_model=vae_model if vae_model != "None" else None,
+            type_model_precision=torch.float16,
+            retain_task_model_in_cache=False,
+        )
+        yield f"Model loaded: {model_name}"
+
+    @spaces.GPU
+    def generate_pipeline(
+        self,
+        prompt,
+        neg_prompt,
+        num_images,
+        steps,
+        cfg,
+        clip_skip,
+        seed,
+        lora1,
+        lora_scale1,
+        lora2,
+        lora_scale2,
+        lora3,
+        lora_scale3,
+        lora4,
+        lora_scale4,
+        lora5,
+        lora_scale5,
+        sampler,
+        img_height,
+        img_width,
+        model_name,
+        vae_model,
+        task,
+        image_control,
+        preprocessor_name,
+        preprocess_resolution,
+        image_resolution,
+        style_prompt,  # list []
+        style_json_file,
+        image_mask,
+        strength,
+        low_threshold,
+        high_threshold,
+        value_threshold,
+        distance_threshold,
+        controlnet_output_scaling_in_unet,
+        controlnet_start_threshold,
+        controlnet_stop_threshold,
+        textual_inversion,
+        syntax_weights,
+        upscaler_model_path,
+        upscaler_increases_size,
+        esrgan_tile,
+        esrgan_tile_overlap,
+        hires_steps,
+        hires_denoising_strength,
+        hires_sampler,
+        hires_prompt,
+        hires_negative_prompt,
+        hires_before_adetailer,
+        hires_after_adetailer,
+        loop_generation,
+        leave_progress_bar,
+        disable_progress_bar,
+        image_previews,
+        display_images,
+        save_generated_images,
+        image_storage_location,
+        retain_compel_previous_load,
+        retain_detailfix_model_previous_load,
+        retain_hires_model_previous_load,
+        t2i_adapter_preprocessor,
+        t2i_adapter_conditioning_scale,
+        t2i_adapter_conditioning_factor,
+        xformers_memory_efficient_attention,
+        freeu,
+        generator_in_cpu,
+        adetailer_inpaint_only,
+        adetailer_verbose,
+        adetailer_sampler,
+        adetailer_active_a,
+        prompt_ad_a,
+        negative_prompt_ad_a,
+        strength_ad_a,
+        face_detector_ad_a,
+        person_detector_ad_a,
+        hand_detector_ad_a,
+        mask_dilation_a,
+        mask_blur_a,
+        mask_padding_a,
+        adetailer_active_b,
+        prompt_ad_b,
+        negative_prompt_ad_b,
+        strength_ad_b,
+        face_detector_ad_b,
+        person_detector_ad_b,
+        hand_detector_ad_b,
+        mask_dilation_b,
+        mask_blur_b,
+        mask_padding_b,
+        retain_task_cache_gui,
+        image_ip1,
+        mask_ip1,
+        model_ip1,
+        mode_ip1,
+        scale_ip1,
+        image_ip2,
+        mask_ip2,
+        model_ip2,
+        mode_ip2,
+        scale_ip2,
+    ):
+        
+        vae_model = vae_model if vae_model != "None" else None
+        loras_list = [lora1, lora2, lora3, lora4, lora5]
+        vae_msg = f"VAE: {vae_model}" if vae_model else ""
+        msg_lora = []
+
+        
+        if model_name in model_list:
+            model_is_xl = "xl" in model_name.lower()
+            sdxl_in_vae = vae_model and "sdxl" in vae_model.lower()
+            model_type = "SDXL" if model_is_xl else "SD 1.5"
+            incompatible_vae = (model_is_xl and vae_model and not sdxl_in_vae) or (not model_is_xl and sdxl_in_vae)
+
+            if incompatible_vae:
+                msg_inc_vae = (
+                    f"The selected VAE is for a { 'SD 1.5' if model_is_xl else 'SDXL' } model, but you"
+                    f" are using a { model_type } model. The default VAE "
+                    "will be used."
+                )
+                gr.Info(msg_inc_vae)
+                vae_msg = msg_inc_vae
+                vae_model = None
+
+            for la in loras_list:
+                if la is not None and la != "None" and la in lora_model_list:
+                    print(la)
+                    lora_type = ("animetarot" in la.lower() or "Hyper-SD15-8steps".lower() in la.lower())
+                    if (model_is_xl and lora_type) or (not model_is_xl and not lora_type):
+                        msg_inc_lora = f"The LoRA {la} is for { 'SD 1.5' if model_is_xl else 'SDXL' }, but you are using { model_type }."
+                        gr.Info(msg_inc_lora)
+                        msg_lora.append(msg_inc_lora)
+
+        task = task_stablepy[task]
+
+        params_ip_img = []
+        params_ip_msk = []
+        params_ip_model = []
+        params_ip_mode = []
+        params_ip_scale = []
+
+        all_adapters = [
+            (image_ip1, mask_ip1, model_ip1, mode_ip1, scale_ip1),
+            (image_ip2, mask_ip2, model_ip2, mode_ip2, scale_ip2),
+        ]
+
+        for imgip, mskip, modelip, modeip, scaleip in all_adapters:
+            if imgip:
+                params_ip_img.append(imgip)
+                if mskip:
+                    params_ip_msk.append(mskip)
+                params_ip_model.append(modelip)
+                params_ip_mode.append(modeip)
+                params_ip_scale.append(scaleip)
+
+        # First load
+        model_precision = torch.float16
+        if not self.model:
+            from modelstream import Model_Diffusers2
+
+            print("Loading model...")
+            self.model = Model_Diffusers2(
+                base_model_id=model_name,
+                task_name=task,
+                vae_model=vae_model if vae_model != "None" else None,
+                type_model_precision=model_precision,
+                retain_task_model_in_cache=retain_task_cache_gui,
+            )
+
+        if task != "txt2img" and not image_control:
+            raise ValueError("No control image found: To use this function, you have to upload an image in 'Image ControlNet/Inpaint/Img2img'")
+
+        if task == "inpaint" and not image_mask:
+            raise ValueError("No mask image found: Specify one in 'Image Mask'")
+
+        if upscaler_model_path in [None, "Lanczos", "Nearest"]:
+            upscaler_model = upscaler_model_path
+        else:
+            directory_upscalers = 'upscalers'
+            os.makedirs(directory_upscalers, exist_ok=True)
+
+            url_upscaler = upscaler_dict_gui[upscaler_model_path]
+
+            if not os.path.exists(f"./upscalers/{url_upscaler.split('/')[-1]}"):
+                download_things(directory_upscalers, url_upscaler, hf_token)
+
+            upscaler_model = f"./upscalers/{url_upscaler.split('/')[-1]}"
+
+        logging.getLogger("ultralytics").setLevel(logging.INFO if adetailer_verbose else logging.ERROR)
+
+        print("Config model:", model_name, vae_model, loras_list)
+
+        self.model.load_pipe(
+            model_name,
+            task_name=task,
+            vae_model=vae_model if vae_model != "None" else None,
+            type_model_precision=model_precision,
+            retain_task_model_in_cache=retain_task_cache_gui,
+        )
+
+## BEGIN MOD
+#        if textual_inversion and self.model.class_name == "StableDiffusionXLPipeline":
+#            print("No Textual inversion for SDXL")
+## END MOD
+
+        adetailer_params_A = {
+            "face_detector_ad" : face_detector_ad_a,
+            "person_detector_ad" : person_detector_ad_a,
+            "hand_detector_ad" : hand_detector_ad_a,
+            "prompt": prompt_ad_a,
+            "negative_prompt" : negative_prompt_ad_a,
+            "strength" : strength_ad_a,
+            # "image_list_task" : None,
+            "mask_dilation" : mask_dilation_a,
+            "mask_blur" : mask_blur_a,
+            "mask_padding" : mask_padding_a,
+            "inpaint_only" : adetailer_inpaint_only,
+            "sampler" : adetailer_sampler,
+        }
+
+        adetailer_params_B = {
+            "face_detector_ad" : face_detector_ad_b,
+            "person_detector_ad" : person_detector_ad_b,
+            "hand_detector_ad" : hand_detector_ad_b,
+            "prompt": prompt_ad_b,
+            "negative_prompt" : negative_prompt_ad_b,
+            "strength" : strength_ad_b,
+            # "image_list_task" : None,
+            "mask_dilation" : mask_dilation_b,
+            "mask_blur" : mask_blur_b,
+            "mask_padding" : mask_padding_b,
+        }
+        pipe_params = {
+            "prompt": prompt,
+            "negative_prompt": neg_prompt,
+            "img_height": img_height,
+            "img_width": img_width,
+            "num_images": num_images,
+            "num_steps": steps,
+            "guidance_scale": cfg,
+            "clip_skip": clip_skip,
+            "seed": seed,
+            "image": image_control,
+            "preprocessor_name": preprocessor_name,
+            "preprocess_resolution": preprocess_resolution,
+            "image_resolution": image_resolution,
+            "style_prompt": style_prompt if style_prompt else "",
+            "style_json_file": "",
+            "image_mask": image_mask,  # only for Inpaint
+            "strength": strength,  # only for Inpaint or ...
+            "low_threshold": low_threshold,
+            "high_threshold": high_threshold,
+            "value_threshold": value_threshold,
+            "distance_threshold": distance_threshold,
+            "lora_A": lora1 if lora1 != "None" else None,
+            "lora_scale_A": lora_scale1,
+            "lora_B": lora2 if lora2 != "None" else None,
+            "lora_scale_B": lora_scale2,
+            "lora_C": lora3 if lora3 != "None" else None,
+            "lora_scale_C": lora_scale3,
+            "lora_D": lora4 if lora4 != "None" else None,
+            "lora_scale_D": lora_scale4,
+            "lora_E": lora5 if lora5 != "None" else None,
+            "lora_scale_E": lora_scale5,
+## BEGIN MOD
+            "textual_inversion": get_embed_list(self.model.class_name) if textual_inversion else [],
+## END MOD
+            "syntax_weights": syntax_weights,  # "Classic"
+            "sampler": sampler,
+            "xformers_memory_efficient_attention": xformers_memory_efficient_attention,
+            "gui_active": True,
+            "loop_generation": loop_generation,
+            "controlnet_conditioning_scale": float(controlnet_output_scaling_in_unet),
+            "control_guidance_start": float(controlnet_start_threshold),
+            "control_guidance_end": float(controlnet_stop_threshold),
+            "generator_in_cpu": generator_in_cpu,
+            "FreeU": freeu,
+            "adetailer_A": adetailer_active_a,
+            "adetailer_A_params": adetailer_params_A,
+            "adetailer_B": adetailer_active_b,
+            "adetailer_B_params": adetailer_params_B,
+            "leave_progress_bar": leave_progress_bar,
+            "disable_progress_bar": disable_progress_bar,
+            "image_previews": image_previews,
+            "display_images": display_images,
+            "save_generated_images": save_generated_images,
+            "image_storage_location": image_storage_location,
+            "retain_compel_previous_load": retain_compel_previous_load,
+            "retain_detailfix_model_previous_load": retain_detailfix_model_previous_load,
+            "retain_hires_model_previous_load": retain_hires_model_previous_load,
+            "t2i_adapter_preprocessor": t2i_adapter_preprocessor,
+            "t2i_adapter_conditioning_scale": float(t2i_adapter_conditioning_scale),
+            "t2i_adapter_conditioning_factor": float(t2i_adapter_conditioning_factor),
+            "upscaler_model_path": upscaler_model,
+            "upscaler_increases_size": upscaler_increases_size,
+            "esrgan_tile": esrgan_tile,
+            "esrgan_tile_overlap": esrgan_tile_overlap,
+            "hires_steps": hires_steps,
+            "hires_denoising_strength": hires_denoising_strength,
+            "hires_prompt": hires_prompt,
+            "hires_negative_prompt": hires_negative_prompt,
+            "hires_sampler": hires_sampler,
+            "hires_before_adetailer": hires_before_adetailer,
+            "hires_after_adetailer": hires_after_adetailer,
+            "ip_adapter_image": params_ip_img,
+            "ip_adapter_mask": params_ip_msk,
+            "ip_adapter_model": params_ip_model,
+            "ip_adapter_mode": params_ip_mode,
+            "ip_adapter_scale": params_ip_scale,
+        }
+
+        # print(pipe_params)
+
+        random_number = random.randint(1, 100)
+        if random_number < 25 and num_images < 3:
+            if not upscaler_model and steps < 45 and task in ["txt2img", "img2img"] and not adetailer_active_a and not adetailer_active_b:
+                num_images *=2
+                pipe_params["num_images"] = num_images
+                gr.Info("Num images x 2 🎉")
+
+        # Maybe fix lora issue: 'Cannot copy out of meta tensor; no data!''
+        self.model.pipe.to("cuda:0" if torch.cuda.is_available() else "cpu")
+
+        info_state = f"PROCESSING "
+        for img, seed, data in self.model(**pipe_params):
+            info_state += ">"
+            if data:
+                info_state = f"COMPLETED. Seeds: {str(seed)}"
+                if vae_msg:
+                    info_state = info_state + "<br>" + vae_msg
+                if msg_lora:
+                    info_state = info_state + "<br>" + "<br>".join(msg_lora)
+            yield img, info_state
+
+
+sd_gen = GuiSD()
+
+## BEGIN MOD
+CSS ="""
+.contain { display: flex; flex-direction: column; }
+#component-0 { height: 100%; }
+#gallery { flex-grow: 1; }
+"""
+## END MOD
+
+sdxl_task = [k for k, v in task_stablepy.items() if v in SDXL_TASKS ]
+sd_task = [k for k, v in task_stablepy.items() if v in SD15_TASKS ]
+def update_task_options(model_name, task_name):
+    if model_name in model_list:
+        if "xl" in model_name.lower():
+            new_choices = sdxl_task
+        else:
+            new_choices = sd_task
+
+        if task_name not in new_choices:
+            task_name = "txt2img"
+
+        return gr.update(value=task_name, choices=new_choices)
+    else:
+        return gr.update(value=task_name, choices=task_model_list)
+
+## BEGIN MOD
+with gr.Blocks(theme="NoCrypt/miku", elem_id="main", css=CSS) as app:
+    gr.Markdown("# 🧩 DiffuseCraft Mod")
+    gr.Markdown(
+        f"""
+            This space is a modification of [r3gm's DiffuseCraft](https://huggingface.co/spaces/r3gm/DiffuseCraft).
+            """
+    )
+    with gr.Row():
+        with gr.Tab("Generation"):
+            v2b = V2UI()
+            with gr.Column(scale=2):
+                with gr.Accordion("Model and Task", open=False):
+                    task_gui = gr.Dropdown(label="Task", choices=sdxl_task, value=task_model_list[0])
+                    model_name_gui = gr.Dropdown(label="Model", info="You can enter a huggingface model repo_id to want to use.", choices=get_tupled_model_list(model_list), value="votepurchase/animagine-xl-3.1", allow_custom_value=True)
+                    model_info_gui = gr.Markdown()
+                    with gr.Row():
+                        quick_model_type_gui = gr.Radio(label="Model Type", choices=["None", "Animagine", "Pony"], value="None", interactive=True)
+                        quick_genre_gui = gr.Radio(label="Genre", choices=["Anime", "Photo"], value="Anime", interactive=True)
+                        quick_speed_gui = gr.Radio(label="Speed", choices=["Fast", "Standard", "Heavy"], value="Standard", interactive=True)
+                        quick_aspect_gui = gr.Radio(label="Aspect Ratio", choices=["1:1", "3:4"], value="3:4", interactive=True)
+                    quality_selector_gui = gr.Dropdown(label="Quality Tags Presets", interactive=True, choices=list(preset_quality.keys()), value="None")
+                    style_selector_gui = gr.Dropdown(label="Style Preset", interactive=True, choices=list(preset_styles.keys()), value="None")
+                    sampler_selector_gui = gr.Dropdown(label="Sampler Quick Settings", interactive=True, choices=list(preset_sampler_setting.keys()), value="None")
+                    optimization_gui = gr.Dropdown(label="Optimization for SDXL", choices=list(optimization_list.keys()), value="None", interactive=True)
+                with gr.Accordion("Generate prompt from Image", open=False):
+                    input_image_gui = gr.Image(label="Input image", type="pil", sources=["upload", "clipboard"], height=256)
+                    with gr.Accordion(label="Advanced options", open=False):
+                        general_threshold_gui = gr.Slider(label="Threshold", minimum=0.0, maximum=1.0, value=0.3, step=0.01, interactive=True)
+                        character_threshold_gui = gr.Slider(label="Character threshold", minimum=0.0, maximum=1.0, value=0.8, step=0.01, interactive=True)
+                        tag_type_gui = gr.Radio(label="Convert tags to", info="danbooru for Animagine, e621 for Pony.", choices=["danbooru", "e621"], value="danbooru")
+                        recom_prompt_gui = gr.Radio(label="Insert reccomended prompt", choices=["None", "Animagine", "Pony"], value="None", interactive=True)
+                        keep_tags_gui = gr.Radio(label="Remove tags leaving only the following", choices=["body", "dress", "all"], value="all")
+                    image_algorithms = gr.CheckboxGroup(["Use WD Tagger", "Use Florence-2-SD3-Long-Captioner"], label="Algorithms", value=["Use WD Tagger"], visible=False)
+                    generate_from_image_btn_gui = gr.Button(value="GENERATE TAGS FROM IMAGE", size="lg", variant="primary")
+                with gr.Group():
+                    prompt_gui = gr.Textbox(lines=6, placeholder="1girl, solo, ...", label="Prompt", show_copy_button=True)
+                    with gr.Accordion("Negative prompt, etc.", open=False):
+                        neg_prompt_gui = gr.Textbox(lines=3, placeholder="lowres, (bad), ...", label="Negative prompt", show_copy_button=True)
+                        translate_prompt_button = gr.Button(value="Translate prompt to English", size="sm", variant="secondary")
+                        insert_prompt_gui = gr.Radio(label="Insert reccomended positive / negative prompt", choices=["None", "Animagine", "Pony"], value="None", interactive=True, scale=2)
+                        prompt_type_gui = gr.Radio(label="Convert tags to", choices=["danbooru", "e621"], value="e621", visible=False)
+                        prompt_type_button = gr.Button(value="Convert prompt to Pony e621 style", size="sm", variant="secondary")
+                        with gr.Row():
+                            character_dbt = gr.Textbox(lines=1, placeholder="kafuu chino, ...", label="Character names")
+                            series_dbt = gr.Textbox(lines=1, placeholder="Is the order a rabbit?, ...", label="Series names")
+                            generate_db_random_button = gr.Button(value="Generate random prompt from character", size="sm", variant="secondary")
+                            model_name_dbt = gr.Dropdown(label="Model", choices=list(V2_ALL_MODELS.keys()), value=list(V2_ALL_MODELS.keys())[0], visible=False)
+                            aspect_ratio_dbt = gr.Radio(label="Aspect ratio", choices=list(V2_ASPECT_RATIO_OPTIONS), value="square", visible=False)
+                            length_dbt = gr.Radio(label="Length", choices=list(V2_LENGTH_OPTIONS), value="very_long", visible=False)
+                            identity_dbt = gr.Radio(label="Keep identity", choices=list(V2_IDENTITY_OPTIONS), value="lax", visible=False)                    
+                            ban_tags_dbt = gr.Textbox(label="Ban tags", placeholder="alternate costumen, ...", value="futanari, censored, furry, furrification", visible=False)
+                            elapsed_time_dbt = gr.Markdown(label="Elapsed time", value="", visible=False)
+                            copy_button_dbt = gr.Button(value="Copy to clipboard", visible=False)
+                        rating_dbt = gr.Radio(label="Rating", choices=list(V2_RATING_OPTIONS), value="explicit")
+                        with gr.Row():
+                            set_params_gui = gr.Button(value="↙️")
+                            clear_prompt_gui = gr.Button(value="🗑️")
+                            set_random_seed = gr.Button(value="🎲")
+                    
+                generate_button = gr.Button(value="GENERATE IMAGE", size="lg", variant="primary")
+
+                model_name_gui.change(
+                    update_task_options,
+                    [model_name_gui, task_gui],
+                    [task_gui],
+                )
+
+                load_model_gui = gr.HTML()
+
+                result_images = gr.Gallery(
+                    label="Generated images",
+                    show_label=False,
+                    elem_id="gallery",
+                    columns=[2],
+                    rows=[2],
+                    object_fit="contain",
+                    # height="auto",
+                    interactive=False,
+                    preview=False,
+                    show_share_button=False,
+                    show_download_button=True,
+                    selected_index=50,
+                    format="png",
+                )
+
+                result_images_files = gr.Files(interactive=False, visible=False)
+
+                actual_task_info = gr.HTML()
+
+                with gr.Accordion("Generation settings", open=False, visible=True):
+                    steps_gui = gr.Slider(minimum=1, maximum=100, step=1, value=28, label="Steps")
+                    cfg_gui = gr.Slider(minimum=0, maximum=30, step=0.5, value=7.0, label="CFG")
+                    sampler_gui = gr.Dropdown(label="Sampler", choices=scheduler_names, value="Euler a")
+                    img_width_gui = gr.Slider(minimum=64, maximum=4096, step=8, value=1024, label="Img Width")
+                    img_height_gui = gr.Slider(minimum=64, maximum=4096, step=8, value=1024, label="Img Height")
+                    with gr.Row():
+                        clip_skip_gui = gr.Checkbox(value=False, label="Layer 2 Clip Skip")
+                        free_u_gui = gr.Checkbox(value=False, label="FreeU")
+                    seed_gui = gr.Number(minimum=-1, maximum=9999999999, value=-1, label="Seed")
+
+                    with gr.Row(equal_height=False):
+                        
+                        def run_set_params_gui(base_prompt):
+                            valid_receptors = {  # default values
+                                "prompt": gr.update(value=base_prompt),
+                                "neg_prompt": gr.update(value=""),
+                                "Steps": gr.update(value=30),
+                                "width": gr.update(value=1024),
+                                "height": gr.update(value=1024),
+                                "Seed": gr.update(value=-1),
+                                "Sampler": gr.update(value="Euler a"),
+                                "scale": gr.update(value=7.5), # cfg
+                                "skip": gr.update(value=True),
+                            }
+                            valid_keys = list(valid_receptors.keys())
+
+                            parameters = extract_parameters(base_prompt)
+                            for key, val in parameters.items():
+                                # print(val)
+                                if key in valid_keys:
+                                    if key == "Sampler":
+                                        if val not in scheduler_names:
+                                            continue
+                                    elif key == "skip":
+                                        if int(val) >= 2:
+                                            val = True
+                                    if key == "prompt":
+                                        if ">" in val and "<" in val:
+                                            val = re.sub(r'<[^>]+>', '', val)
+                                            print("Removed LoRA written in the prompt")
+                                    if key in ["prompt", "neg_prompt"]:
+                                        val = val.strip()
+                                    if key in ["Steps", "width", "height", "Seed"]:
+                                        val = int(val)
+                                    if key == "scale":
+                                        val = float(val)
+                                    if key == "Seed":
+                                        continue
+                                    valid_receptors[key] = gr.update(value=val)
+                                    # print(val, type(val))
+                                    # print(valid_receptors)
+                            return [value for value in valid_receptors.values()]
+
+                        set_params_gui.click(
+                            run_set_params_gui, [prompt_gui],[
+                                prompt_gui,
+                                neg_prompt_gui,
+                                steps_gui,
+                                img_width_gui,
+                                img_height_gui,
+                                seed_gui,
+                                sampler_gui,
+                                cfg_gui,
+                                clip_skip_gui,
+                            ],
+                        )
+                        
+                        def run_clear_prompt_gui():
+                            return gr.update(value=""), gr.update(value="")
+                        clear_prompt_gui.click(
+                            run_clear_prompt_gui, [], [prompt_gui, neg_prompt_gui]
+                        )
+
+                        def run_set_random_seed():
+                            return -1
+                        set_random_seed.click(
+                            run_set_random_seed, [], seed_gui
+                        )
+
+                    num_images_gui = gr.Slider(minimum=1, maximum=4, step=1, value=1, label="Images")
+                    prompt_s_options = [
+                        ("Compel format: (word)weight", "Compel"),
+                        ("Classic format: (word:weight)", "Classic"),
+                        ("Classic-original format: (word:weight)", "Classic-original"),
+                        ("Classic-no_norm format: (word:weight)", "Classic-no_norm"),
+                        ("Classic-ignore", "Classic-ignore"),
+                        ("None", "None"),
+                    ]
+                    prompt_syntax_gui = gr.Dropdown(label="Prompt Syntax", choices=prompt_s_options, value=prompt_s_options[1][1])
+                    vae_model_gui = gr.Dropdown(label="VAE Model", choices=vae_model_list)
+
+                with gr.Accordion("Hires fix", open=False, visible=True):
+
+                    upscaler_keys = list(upscaler_dict_gui.keys())
+
+                    upscaler_model_path_gui = gr.Dropdown(label="Upscaler", choices=upscaler_keys, value=None)
+                    upscaler_increases_size_gui = gr.Slider(minimum=1.1, maximum=6., step=0.1, value=1.0, label="Upscale by")
+                    esrgan_tile_gui = gr.Slider(minimum=0, value=100, maximum=500, step=1, label="ESRGAN Tile")
+                    esrgan_tile_overlap_gui = gr.Slider(minimum=1, maximum=200, step=1, value=10, label="ESRGAN Tile Overlap")
+                    hires_steps_gui = gr.Slider(minimum=0, value=30, maximum=100, step=1, label="Hires Steps")
+                    hires_denoising_strength_gui = gr.Slider(minimum=0.1, maximum=1.0, step=0.01, value=0.55, label="Hires Denoising Strength")
+                    hires_sampler_gui = gr.Dropdown(label="Hires Sampler", choices=["Use same sampler"] + scheduler_names[:-1], value="Use same sampler")
+                    hires_prompt_gui = gr.Textbox(label="Hires Prompt", placeholder="Main prompt will be use", lines=3)
+                    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):
+                    lora1_gui = gr.Dropdown(label="Lora1", choices=get_lora_tupled_list(lora_model_list), 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="", 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), 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="", 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), 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="", 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), 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="", 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), 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():
+                            lora5_trigger_gui = gr.Textbox(label="Lora5 prompts", info="Example of prompt", value="", show_copy_button=True, interactive=False, visible=False)
+                            lora5_copy_button = gr.Button(value="Copy example to prompt", visible=False)
+                        lora5_desc_gui = gr.Markdown(value="", visible=False)
+
+                    with gr.Accordion("From URL", open=True, visible=True):
+                        text_lora = gr.Textbox(label="URL", placeholder="http://...my_lora_url.safetensors", lines=1)
+                        button_lora = gr.Button("Get and update lists of LoRAs")
+                        button_lora.click(
+                            get_my_lora,
+                            [text_lora],
+                            [lora1_gui, lora2_gui, lora3_gui, lora4_gui, lora5_gui]
+                        )
+
+                    with gr.Accordion("From Local", open=True, visible=True):
+                        file_output_lora = gr.File(label="Uploaded LoRA", file_types=['.ckpt', '.pt', '.pth', '.safetensors', '.bin'], file_count="multiple", interactive=False, visible=False)
+                        upload_button_lora = gr.UploadButton(label="Upload LoRA from your disk (very slow)", file_types=['.ckpt' , '.pt', '.pth', '.safetensors', '.bin'], file_count="multiple")
+                        upload_button_lora.upload(upload_file_lora, upload_button_lora, file_output_lora).success(
+                            move_file_lora,
+                            [file_output_lora],
+                            [lora1_gui, lora2_gui, lora3_gui, lora4_gui, lora5_gui]
+                        )
+## END MOD
+                with gr.Accordion("IP-Adapter", open=False, visible=True):##############
+
+                    IP_MODELS = sorted(list(set(IP_ADAPTERS_SD + IP_ADAPTERS_SDXL)))
+                    MODE_IP_OPTIONS = ["original", "style", "layout", "style+layout"]
+
+                    with gr.Accordion("IP-Adapter 1", open=False, visible=True):
+                        image_ip1 = gr.Image(label="IP Image", type="filepath")
+                        mask_ip1 = gr.Image(label="IP Mask", type="filepath")
+                        model_ip1 = gr.Dropdown(value="plus_face", label="Model", choices=IP_MODELS)
+                        mode_ip1 = gr.Dropdown(value="original", label="Mode", choices=MODE_IP_OPTIONS)
+                        scale_ip1 = gr.Slider(minimum=0., maximum=2., step=0.01, value=0.7, label="Scale")
+                    with gr.Accordion("IP-Adapter 2", open=False, visible=True):
+                        image_ip2 = gr.Image(label="IP Image", type="filepath")
+                        mask_ip2 = gr.Image(label="IP Mask (optional)", type="filepath")
+                        model_ip2 = gr.Dropdown(value="base", label="Model", choices=IP_MODELS)
+                        mode_ip2 = gr.Dropdown(value="style", label="Mode", choices=MODE_IP_OPTIONS)
+                        scale_ip2 = gr.Slider(minimum=0., maximum=2., step=0.01, value=0.7, label="Scale")
+
+                with gr.Accordion("ControlNet / Img2img / Inpaint", open=False, visible=True):
+                    image_control = gr.Image(label="Image ControlNet/Inpaint/Img2img", type="filepath")
+                    image_mask_gui = gr.Image(label="Image Mask", type="filepath")
+                    strength_gui = gr.Slider(
+                        minimum=0.01, maximum=1.0, step=0.01, value=0.55, label="Strength",
+                        info="This option adjusts the level of changes for img2img and inpainting."
+                    )
+                    image_resolution_gui = gr.Slider(minimum=64, maximum=2048, step=64, value=1024, label="Image Resolution")
+                    preprocessor_name_gui = gr.Dropdown(label="Preprocessor Name", choices=preprocessor_controlnet["canny"])
+
+                    def change_preprocessor_choices(task):
+                        task = task_stablepy[task]
+                        if task in preprocessor_controlnet.keys():
+                            choices_task = preprocessor_controlnet[task]
+                        else:
+                            choices_task = preprocessor_controlnet["canny"]
+                        return gr.update(choices=choices_task, value=choices_task[0])
+
+                    task_gui.change(
+                        change_preprocessor_choices,
+                        [task_gui],
+                        [preprocessor_name_gui],
+                    )
+                    preprocess_resolution_gui = gr.Slider(minimum=64, maximum=2048, step=64, value=512, label="Preprocess Resolution")
+                    low_threshold_gui = gr.Slider(minimum=1, maximum=255, step=1, value=100, label="Canny low threshold")
+                    high_threshold_gui = gr.Slider(minimum=1, maximum=255, step=1, value=200, label="Canny high threshold")
+                    value_threshold_gui = gr.Slider(minimum=1, maximum=2.0, step=0.01, value=0.1, label="Hough value threshold (MLSD)")
+                    distance_threshold_gui = gr.Slider(minimum=1, maximum=20.0, step=0.01, value=0.1, label="Hough distance threshold (MLSD)")
+                    control_net_output_scaling_gui = gr.Slider(minimum=0, maximum=5.0, step=0.1, value=1, label="ControlNet Output Scaling in UNet")
+                    control_net_start_threshold_gui = gr.Slider(minimum=0, maximum=1, step=0.01, value=0, label="ControlNet Start Threshold (%)")
+                    control_net_stop_threshold_gui = gr.Slider(minimum=0, maximum=1, step=0.01, value=1, label="ControlNet Stop Threshold (%)")
+
+                with gr.Accordion("T2I adapter", open=False, visible=True):
+                    t2i_adapter_preprocessor_gui = gr.Checkbox(value=True, label="T2i Adapter Preprocessor")
+                    adapter_conditioning_scale_gui = gr.Slider(minimum=0, maximum=5., step=0.1, value=1, label="Adapter Conditioning Scale")
+                    adapter_conditioning_factor_gui = gr.Slider(minimum=0, maximum=1., step=0.01, value=0.55, label="Adapter Conditioning Factor (%)")
+
+                with gr.Accordion("Styles", open=False, visible=True):
+
+                    try:
+                        style_names_found = sd_gen.model.STYLE_NAMES
+                    except:
+                        style_names_found = STYLE_NAMES
+
+                    style_prompt_gui = gr.Dropdown(
+                        style_names_found,
+                        multiselect=True,
+                        value=None,
+                        label="Style Prompt",
+                        interactive=True,
+                    )
+                    style_json_gui = gr.File(label="Style JSON File")
+                    style_button = gr.Button("Load styles")
+
+                    def load_json_style_file(json):
+                        if not sd_gen.model:
+                            gr.Info("First load the model")
+                            return gr.update(value=None, choices=STYLE_NAMES)
+
+                        sd_gen.model.load_style_file(json)
+                        gr.Info(f"{len(sd_gen.model.STYLE_NAMES)} styles loaded")
+                        return gr.update(value=None, choices=sd_gen.model.STYLE_NAMES)
+
+                    style_button.click(load_json_style_file, [style_json_gui], [style_prompt_gui])                        
+
+## BEGIN MOD
+                with gr.Accordion("Textual inversion", open=False, visible=True):
+                    active_textual_inversion_gui = gr.Checkbox(value=False, label="Active Textual Inversion in prompt")
+                    use_textual_inversion_gui = gr.CheckboxGroup(choices=get_embed_list(get_model_pipeline(model_name_gui.value)) if active_textual_inversion_gui.value else [], value=None, label="Use Textual Invertion in prompt")
+                    def update_textual_inversion_gui(active_textual_inversion_gui, model_name_gui):
+                        return gr.update(choices=get_embed_list(get_model_pipeline(model_name_gui)) if active_textual_inversion_gui else [])
+                    active_textual_inversion_gui.change(update_textual_inversion_gui, [active_textual_inversion_gui, model_name_gui], [use_textual_inversion_gui])
+                    model_name_gui.change(update_textual_inversion_gui, [active_textual_inversion_gui, model_name_gui], [use_textual_inversion_gui])
+## END MOD
+
+                with gr.Accordion("Detailfix", open=False, visible=True):
+
+                    # Adetailer Inpaint Only
+                    adetailer_inpaint_only_gui = gr.Checkbox(label="Inpaint only", value=True)
+
+                    # Adetailer Verbose
+                    adetailer_verbose_gui = gr.Checkbox(label="Verbose", value=False)
+
+                    # Adetailer Sampler
+                    adetailer_sampler_options = ["Use same sampler"] + scheduler_names[:-1]
+                    adetailer_sampler_gui = gr.Dropdown(label="Adetailer sampler:", choices=adetailer_sampler_options, value="Use same sampler")
+
+                    with gr.Accordion("Detailfix A", open=False, visible=True):
+                        # Adetailer A
+                        adetailer_active_a_gui = gr.Checkbox(label="Enable Adetailer A", value=False)
+                        prompt_ad_a_gui = gr.Textbox(label="Main prompt", placeholder="Main prompt will be use", lines=3)
+                        negative_prompt_ad_a_gui = gr.Textbox(label="Negative prompt", placeholder="Main negative prompt will be use", lines=3)
+                        strength_ad_a_gui = gr.Number(label="Strength:", value=0.35, step=0.01, minimum=0.01, maximum=1.0)
+                        face_detector_ad_a_gui = gr.Checkbox(label="Face detector", value=True)
+                        person_detector_ad_a_gui = gr.Checkbox(label="Person detector", value=True)
+                        hand_detector_ad_a_gui = gr.Checkbox(label="Hand detector", value=False)
+                        mask_dilation_a_gui = gr.Number(label="Mask dilation:", value=4, minimum=1)
+                        mask_blur_a_gui = gr.Number(label="Mask blur:", value=4, minimum=1)
+                        mask_padding_a_gui = gr.Number(label="Mask padding:", value=32, minimum=1)
+
+                    with gr.Accordion("Detailfix B", open=False, visible=True):
+                        # Adetailer B
+                        adetailer_active_b_gui = gr.Checkbox(label="Enable Adetailer B", value=False)
+                        prompt_ad_b_gui = gr.Textbox(label="Main prompt", placeholder="Main prompt will be use", lines=3)
+                        negative_prompt_ad_b_gui = gr.Textbox(label="Negative prompt", placeholder="Main negative prompt will be use", lines=3)
+                        strength_ad_b_gui = gr.Number(label="Strength:", value=0.35, step=0.01, minimum=0.01, maximum=1.0)
+                        face_detector_ad_b_gui = gr.Checkbox(label="Face detector", value=True)
+                        person_detector_ad_b_gui = gr.Checkbox(label="Person detector", value=True)
+                        hand_detector_ad_b_gui = gr.Checkbox(label="Hand detector", value=False)
+                        mask_dilation_b_gui = gr.Number(label="Mask dilation:", value=4, minimum=1)
+                        mask_blur_b_gui = gr.Number(label="Mask blur:", value=4, minimum=1)
+                        mask_padding_b_gui = gr.Number(label="Mask padding:", value=32, minimum=1)
+
+                with gr.Accordion("Other settings", open=False, visible=True):
+                    image_previews_gui = gr.Checkbox(value=True, label="Image Previews")
+                    hires_before_adetailer_gui = gr.Checkbox(value=False, label="Hires Before Adetailer")
+                    hires_after_adetailer_gui = gr.Checkbox(value=True, label="Hires After Adetailer")
+                    generator_in_cpu_gui = gr.Checkbox(value=False, label="Generator in CPU")
+
+                with gr.Accordion("More settings", open=False, visible=False):
+                    loop_generation_gui = gr.Slider(minimum=1, value=1, label="Loop Generation")
+                    retain_task_cache_gui = gr.Checkbox(value=False, label="Retain task model in cache")
+                    leave_progress_bar_gui = gr.Checkbox(value=True, label="Leave Progress Bar")
+                    disable_progress_bar_gui = gr.Checkbox(value=False, label="Disable Progress Bar")
+                    display_images_gui = gr.Checkbox(value=True, label="Display Images")
+                    save_generated_images_gui = gr.Checkbox(value=False, label="Save Generated Images")
+                    image_storage_location_gui = gr.Textbox(value="./images", label="Image Storage Location")
+                    retain_compel_previous_load_gui = gr.Checkbox(value=False, label="Retain Compel Previous Load")
+                    retain_detailfix_model_previous_load_gui = gr.Checkbox(value=False, label="Retain Detailfix Model Previous Load")
+                    retain_hires_model_previous_load_gui = gr.Checkbox(value=False, label="Retain Hires Model Previous Load")
+                    xformers_memory_efficient_attention_gui = gr.Checkbox(value=False, label="Xformers Memory Efficient Attention")
+
+## BEGIN MOD
+                with gr.Accordion("Examples and help", open=True, visible=True):
+                    gr.Examples(
+                        examples=[
+                            [
+                                "1girl, souryuu asuka langley, neon genesis evangelion, plugsuit, pilot suit, red bodysuit, sitting, crossing legs, black eye patch, cat hat, throne, symmetrical, looking down, from bottom, looking at viewer, outdoors, masterpiece, best quality, very aesthetic, absurdres",
+                                "nsfw, 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]",
+                                1,
+                                30,
+                                7.5,
+                                True,
+                                -1,
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                None,
+                                1.0,                        
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                "Euler a",
+                                1152,
+                                896,
+                                "votepurchase/animagine-xl-3.1",
+                                None, # vae
+                                "txt2img",
+                                None, # img conttol
+                                "Canny", # preprocessor
+                                512, # preproc resolution
+                                1024, # img resolution
+                                None, # Style prompt
+                                None, # Style json
+                                None, # img Mask
+                                0.35, # strength
+                                100, # low th canny
+                                200, # high th canny
+                                0.1, # value mstd
+                                0.1, # distance mstd
+                                1.0, # cn scale
+                                0., # cn start
+                                1., # cn end
+                                False, # ti
+                                "Classic",
+                                None,
+                            ],
+                            [
+                                "solo, princess Zelda OOT, score_9, score_8_up, score_8, medium breasts, cute, eyelashes, cute small face, long hair, crown braid, hairclip, pointy ears, soft curvy body, looking at viewer, smile, blush, white dress, medium body, (((holding the Master Sword))), standing, deep forest in the background",
+                                "score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white,",
+                                1,
+                                30,
+                                5.,
+                                True,
+                                -1,
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                None,
+                                1.0,                        
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                "Euler a",
+                                1024,
+                                1024,
+                                "votepurchase/ponyDiffusionV6XL",
+                                None, # vae
+                                "txt2img",
+                                None, # img conttol
+                                "Canny", # preprocessor
+                                512, # preproc resolution
+                                1024, # img resolution
+                                None, # Style prompt
+                                None, # Style json
+                                None, # img Mask
+                                0.35, # strength
+                                100, # low th canny
+                                200, # high th canny
+                                0.1, # value mstd
+                                0.1, # distance mstd
+                                1.0, # cn scale
+                                0., # cn start
+                                1., # cn end
+                                False, # ti
+                                "Classic",
+                                None,
+                            ],
+                            [
+                                "1girl, oomuro sakurako, yuru yuri, official art, school uniform, anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres",
+                                "photo, deformed, black and white, realism, disfigured, low contrast, 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]",
+                                1,
+                                40,
+                                7.0,
+                                True,
+                                -1,
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                None,
+                                1.0,                        
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                "Euler a",
+                                1024,
+                                1024,
+                                "Raelina/Rae-Diffusion-XL-V2",
+                                "vaes/sdxl.vae.safetensors", # vae
+                                "txt2img",
+                                None, # img conttol
+                                "Canny", # preprocessor
+                                512, # preproc resolution
+                                1024, # img resolution
+                                None, # Style prompt
+                                None, # Style json
+                                None, # img Mask
+                                0.35, # strength
+                                100, # low th canny
+                                200, # high th canny
+                                0.1, # value mstd
+                                0.1, # distance mstd
+                                1.0, # cn scale
+                                0., # cn start
+                                1., # cn end
+                                False, # ti
+                                "Classic",
+                                None,
+                            ],
+                            [
+                                "yoshida yuuko, machikado mazoku, 1girl, solo, demon horns,horns, school uniform, long hair, open mouth, skirt, demon girl, ahoge, shiny, shiny hair, anime artwork",
+                                "nsfw, 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]",
+                                1,
+                                50,
+                                7.,
+                                True,
+                                -1,
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                None,
+                                1.0,                        
+                                None,
+                                1.0,
+                                None,
+                                1.0,
+                                "Euler a",
+                                1024,
+                                1024,
+                                "votepurchase/animagine-xl-3.1",
+                                None, # vae
+                                "img2img",
+                                "color_image.png", # img conttol
+                                "Canny", # preprocessor
+                                512, # preproc resolution
+                                1024, # img resolution
+                                None, # Style prompt
+                                None, # Style json
+                                None, # img Mask
+                                0.35, # strength
+                                100, # low th canny
+                                200, # high th canny
+                                0.1, # value mstd
+                                0.1, # distance mstd
+                                1.0, # cn scale
+                                0., # cn start
+                                1., # cn end
+                                False, # ti
+                                "Classic",
+                                None,
+                            ],
+                        ],
+                        fn=sd_gen.generate_pipeline,
+                        inputs=[
+                            prompt_gui,
+                            neg_prompt_gui,
+                            num_images_gui,
+                            steps_gui,
+                            cfg_gui,
+                            clip_skip_gui,
+                            seed_gui,
+                            lora1_gui,
+                            lora_scale_1_gui,
+                            lora2_gui,
+                            lora_scale_2_gui,
+                            lora3_gui,
+                            lora_scale_3_gui,
+                            lora4_gui,
+                            lora_scale_4_gui,
+                            lora5_gui,
+                            lora_scale_5_gui,
+                            sampler_gui,
+                            img_height_gui,
+                            img_width_gui,
+                            model_name_gui,
+                            vae_model_gui,
+                            task_gui,
+                            image_control,
+                            preprocessor_name_gui,
+                            preprocess_resolution_gui,
+                            image_resolution_gui,
+                            style_prompt_gui,
+                            style_json_gui,
+                            image_mask_gui,
+                            strength_gui,
+                            low_threshold_gui,
+                            high_threshold_gui,
+                            value_threshold_gui,
+                            distance_threshold_gui,
+                            control_net_output_scaling_gui,
+                            control_net_start_threshold_gui,
+                            control_net_stop_threshold_gui,
+                            active_textual_inversion_gui,
+                            prompt_syntax_gui,
+                            upscaler_model_path_gui,
+                        ],
+                        outputs=[result_images],
+                        cache_examples=False,
+                        elem_id="examples",
+                    )
+## END MOD
+
+        with gr.Tab("Inpaint mask maker", render=True):
+
+            def create_mask_now(img, invert):            
+                import numpy as np
+                import time
+
+                time.sleep(0.5)
+
+                transparent_image = img["layers"][0]
+
+                # Extract the alpha channel
+                alpha_channel = np.array(transparent_image)[:, :, 3]
+
+                # Create a binary mask by thresholding the alpha channel
+                binary_mask = alpha_channel > 1
+
+                if invert:
+                    print("Invert")
+                    # Invert the binary mask so that the drawn shape is white and the rest is black
+                    binary_mask = np.invert(binary_mask)
+
+                # Convert the binary mask to a 3-channel RGB mask
+                rgb_mask = np.stack((binary_mask,) * 3, axis=-1)
+
+                # Convert the mask to uint8
+                rgb_mask = rgb_mask.astype(np.uint8) * 255
+
+                return img["background"], rgb_mask
+
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # image_base = gr.ImageEditor(label="Base image", show_label=True, brush=gr.Brush(colors=["#000000"]))
+                    image_base = gr.ImageEditor(
+                        sources=["upload", "clipboard"],
+                        # crop_size="1:1",
+                        # enable crop (or disable it)
+                        # transforms=["crop"],
+                        brush=gr.Brush(
+                        default_size="16", # or leave it as 'auto'
+                        color_mode="fixed", # 'fixed' hides the user swatches and colorpicker, 'defaults' shows it
+                        # default_color="black", # html names are supported
+                        colors=[
+                            "rgba(0, 0, 0, 1)", # rgb(a)
+                            "rgba(0, 0, 0, 0.1)",
+                            "rgba(255, 255, 255, 0.1)",
+                            # "hsl(360, 120, 120)" # in fact any valid colorstring
+                        ]
+                        ),
+                        eraser=gr.Eraser(default_size="16")
+                    )
+                    invert_mask = gr.Checkbox(value=False, label="Invert mask")
+                    btn = gr.Button("Create mask")
+                with gr.Column(scale=1):
+                    img_source = gr.Image(interactive=False)
+                    img_result = gr.Image(label="Mask image", show_label=True, interactive=False)
+                    btn_send = gr.Button("Send to the first tab")
+
+                btn.click(create_mask_now, [image_base, invert_mask], [img_source, img_result])
+
+                def send_img(img_source, img_result):
+                    return img_source, img_result
+                btn_send.click(send_img, [img_source, img_result], [image_control, image_mask_gui])
+
+## BEGIN MOD
+        model_name_gui.change(get_t2i_model_info, [model_name_gui], [model_info_gui])
+
+        quick_model_type_gui.change(
+            set_quick_presets,
+            [quick_genre_gui, quick_model_type_gui, quick_speed_gui, quick_aspect_gui],
+            [quality_selector_gui, style_selector_gui, sampler_selector_gui, optimization_gui],
+        )
+        quick_genre_gui.change(
+            set_quick_presets,
+            [quick_genre_gui, quick_model_type_gui, quick_speed_gui, quick_aspect_gui],
+            [quality_selector_gui, style_selector_gui, sampler_selector_gui, optimization_gui],
+        )
+        quick_speed_gui.change(
+            set_quick_presets,
+            [quick_genre_gui, quick_model_type_gui, quick_speed_gui, quick_aspect_gui],
+            [quality_selector_gui, style_selector_gui, sampler_selector_gui, optimization_gui],
+        )
+        quick_aspect_gui.change(
+            set_quick_presets,
+            [quick_genre_gui, quick_model_type_gui, quick_speed_gui, quick_aspect_gui],
+            [quality_selector_gui, style_selector_gui, sampler_selector_gui, optimization_gui],
+        )
+
+        quality_selector_gui.change(
+            process_style_prompt,
+            inputs=[prompt_gui, neg_prompt_gui, style_selector_gui, quality_selector_gui, insert_prompt_gui],
+            outputs=[prompt_gui, neg_prompt_gui],
+        )
+        style_selector_gui.change(
+            process_style_prompt,
+            inputs=[prompt_gui, neg_prompt_gui, style_selector_gui, quality_selector_gui, insert_prompt_gui],
+            outputs=[prompt_gui, neg_prompt_gui],
+        )
+        sampler_selector_gui.change(set_sampler_settings, [sampler_selector_gui], [sampler_gui, steps_gui, cfg_gui, clip_skip_gui, img_width_gui, img_height_gui, optimization_gui])
+        optimization_gui.change(set_optimization, [optimization_gui, steps_gui, cfg_gui, sampler_gui, clip_skip_gui, lora5_gui, lora_scale_5_gui], [steps_gui, cfg_gui, sampler_gui, clip_skip_gui, lora5_gui, lora_scale_5_gui])
+
+        lora1_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])\
+        .then(set_lora_trigger, [lora1_gui], [lora1_trigger_gui, lora1_copy_button, lora1_desc_gui, lora1_gui])
+        lora2_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])\
+        .then(set_lora_trigger, [lora2_gui], [lora2_trigger_gui, lora2_copy_button, lora2_desc_gui, lora2_gui])
+        lora3_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])\
+        .then(set_lora_trigger, [lora3_gui], [lora3_trigger_gui, lora3_copy_button, lora3_desc_gui, lora3_gui])
+        lora4_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])\
+        .then(set_lora_trigger, [lora4_gui], [lora4_trigger_gui, lora4_copy_button, lora4_desc_gui, lora4_gui])
+        lora5_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])\
+        .then(set_lora_trigger, [lora5_gui], [lora5_trigger_gui, lora5_copy_button, lora5_desc_gui, lora5_gui])
+        lora_scale_1_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        lora_scale_2_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        lora_scale_3_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        lora_scale_4_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        lora_scale_5_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        prompt_syntax_gui.change(set_lora_prompt, [prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui], [prompt_gui])
+        lora1_copy_button.click(apply_lora_prompt, [prompt_gui, lora1_trigger_gui], [prompt_gui])
+        lora2_copy_button.click(apply_lora_prompt, [prompt_gui, lora2_trigger_gui], [prompt_gui])
+        lora3_copy_button.click(apply_lora_prompt, [prompt_gui, lora3_trigger_gui], [prompt_gui])
+        lora4_copy_button.click(apply_lora_prompt, [prompt_gui, lora4_trigger_gui], [prompt_gui])
+        lora5_copy_button.click(apply_lora_prompt, [prompt_gui, lora5_trigger_gui], [prompt_gui])
+
+        use_textual_inversion_gui.change(set_textual_inversion_prompt, [use_textual_inversion_gui, prompt_gui, neg_prompt_gui, prompt_syntax_gui], [prompt_gui, neg_prompt_gui])
+
+        generate_from_image_btn_gui.click(
+            predict_tags_wd,
+            inputs=[input_image_gui, prompt_gui, image_algorithms, general_threshold_gui, character_threshold_gui],
+            outputs=[
+                series_dbt,
+                character_dbt,
+                prompt_gui,
+                copy_button_dbt,
+            ],
+        ).then(
+            compose_prompt_to_copy, inputs=[character_dbt, series_dbt, prompt_gui], outputs=[prompt_gui]
+        ).then(
+            remove_specific_prompt, inputs=[prompt_gui, keep_tags_gui], outputs=[prompt_gui],
+        ).then(
+            convert_danbooru_to_e621_prompt, inputs=[prompt_gui, tag_type_gui], outputs=[prompt_gui],
+        ).then(
+            insert_recom_prompt, inputs=[prompt_gui, neg_prompt_gui, recom_prompt_gui], outputs=[prompt_gui, neg_prompt_gui],
+        )
+
+        v2b.input_components = [
+            model_name_dbt,
+            series_dbt,
+            character_dbt,
+            prompt_gui,
+            rating_dbt,
+            aspect_ratio_dbt,
+            length_dbt,
+            identity_dbt,
+            ban_tags_dbt,
+        ]
+        
+        insert_prompt_gui.change(
+            process_style_prompt,
+            inputs=[prompt_gui, neg_prompt_gui, style_selector_gui, quality_selector_gui, insert_prompt_gui],
+            outputs=[prompt_gui, neg_prompt_gui],
+        )
+
+        prompt_type_button.click(
+            convert_danbooru_to_e621_prompt,
+            inputs=[prompt_gui, prompt_type_gui],
+            outputs=[prompt_gui],
+        )
+
+        generate_db_random_button.click(
+            parse_upsampling_output(v2b.on_generate),
+            inputs=[
+                *v2b.input_components,
+            ],
+            outputs=[prompt_gui, elapsed_time_dbt, copy_button_dbt, copy_button_dbt],
+        )
+
+        translate_prompt_button.click(translate_prompt, inputs=[prompt_gui], outputs=[prompt_gui])
+        translate_prompt_button.click(translate_prompt, inputs=[character_dbt], outputs=[character_dbt])
+        translate_prompt_button.click(translate_prompt, inputs=[series_dbt], outputs=[series_dbt])
+
+        generate_button.click(
+            fn=sd_gen.load_new_model,
+            inputs=[
+                model_name_gui,
+                vae_model_gui,
+                task_gui
+            ],
+            outputs=[load_model_gui],
+            queue=True,
+            show_progress="minimal",
+        ).success(
+            fn=sd_gen.generate_pipeline,
+            inputs=[
+                prompt_gui,
+                neg_prompt_gui,
+                num_images_gui,
+                steps_gui,
+                cfg_gui,
+                clip_skip_gui,
+                seed_gui,
+                lora1_gui,
+                lora_scale_1_gui,
+                lora2_gui,
+                lora_scale_2_gui,
+                lora3_gui,
+                lora_scale_3_gui,
+                lora4_gui,
+                lora_scale_4_gui,
+                lora5_gui,
+                lora_scale_5_gui,
+                sampler_gui,
+                img_height_gui,
+                img_width_gui,
+                model_name_gui,
+                vae_model_gui,
+                task_gui,
+                image_control,
+                preprocessor_name_gui,
+                preprocess_resolution_gui,
+                image_resolution_gui,
+                style_prompt_gui,
+                style_json_gui,
+                image_mask_gui,
+                strength_gui,
+                low_threshold_gui,
+                high_threshold_gui,
+                value_threshold_gui,
+                distance_threshold_gui,
+                control_net_output_scaling_gui,
+                control_net_start_threshold_gui,
+                control_net_stop_threshold_gui,
+                active_textual_inversion_gui,
+                prompt_syntax_gui,
+                upscaler_model_path_gui,
+                upscaler_increases_size_gui,
+                esrgan_tile_gui,
+                esrgan_tile_overlap_gui,
+                hires_steps_gui,
+                hires_denoising_strength_gui,
+                hires_sampler_gui,
+                hires_prompt_gui,
+                hires_negative_prompt_gui,
+                hires_before_adetailer_gui,
+                hires_after_adetailer_gui,
+                loop_generation_gui,
+                leave_progress_bar_gui,
+                disable_progress_bar_gui,
+                image_previews_gui,
+                display_images_gui,
+                save_generated_images_gui,
+                image_storage_location_gui,
+                retain_compel_previous_load_gui,
+                retain_detailfix_model_previous_load_gui,
+                retain_hires_model_previous_load_gui,
+                t2i_adapter_preprocessor_gui,
+                adapter_conditioning_scale_gui,
+                adapter_conditioning_factor_gui,
+                xformers_memory_efficient_attention_gui,
+                free_u_gui,
+                generator_in_cpu_gui,
+                adetailer_inpaint_only_gui,
+                adetailer_verbose_gui,
+                adetailer_sampler_gui,
+                adetailer_active_a_gui,
+                prompt_ad_a_gui,
+                negative_prompt_ad_a_gui,
+                strength_ad_a_gui,
+                face_detector_ad_a_gui,
+                person_detector_ad_a_gui,
+                hand_detector_ad_a_gui,
+                mask_dilation_a_gui,
+                mask_blur_a_gui,
+                mask_padding_a_gui,
+                adetailer_active_b_gui,
+                prompt_ad_b_gui,
+                negative_prompt_ad_b_gui,
+                strength_ad_b_gui,
+                face_detector_ad_b_gui,
+                person_detector_ad_b_gui,
+                hand_detector_ad_b_gui,
+                mask_dilation_b_gui,
+                mask_blur_b_gui,
+                mask_padding_b_gui,
+                retain_task_cache_gui,
+                image_ip1,
+                mask_ip1,
+                model_ip1,
+                mode_ip1,
+                scale_ip1,
+                image_ip2,
+                mask_ip2,
+                model_ip2,
+                mode_ip2,
+                scale_ip2,
+            ],
+            outputs=[result_images, actual_task_info],
+            queue=True,
+            show_progress="minimal",
+        ).success(save_gallery_images, [result_images], [result_images, result_images_files, result_images_files])
+
+        with gr.Tab("Danbooru Tags Transformer with WD Tagger", render=True):
+            v2 = V2UI()
+            with gr.Column(scale=2):
+                with gr.Group():
+                    input_image = gr.Image(label="Input image", type="pil", sources=["upload", "clipboard"], height=256)
+                    with gr.Accordion(label="Advanced options", open=False):
+                        general_threshold = gr.Slider(label="Threshold", minimum=0.0, maximum=1.0, value=0.3, step=0.01, interactive=True)
+                        character_threshold = gr.Slider(label="Character threshold", minimum=0.0, maximum=1.0, value=0.8, step=0.01, interactive=True)
+                        input_tag_type = gr.Radio(label="Convert tags to", info="danbooru for Animagine, e621 for Pony.", choices=["danbooru", "e621"], value="danbooru")
+                        recom_prompt = gr.Radio(label="Insert reccomended prompt", choices=["None", "Animagine", "Pony"], value="None", interactive=True)
+                    image_algorithms = gr.CheckboxGroup(["Use WD Tagger", "Use Florence-2-SD3-Long-Captioner"], label="Algorithms", value=["Use WD Tagger"], visible=False)
+                    keep_tags = gr.Radio(label="Remove tags leaving only the following", choices=["body", "dress", "all"], value="all")
+                    generate_from_image_btn = gr.Button(value="GENERATE TAGS FROM IMAGE", size="lg", variant="primary")
+                
+                with gr.Group():
+                    input_character = gr.Textbox(label="Character tags", placeholder="hatsune miku")
+                    input_copyright = gr.Textbox(label="Copyright tags", placeholder="vocaloid")
+                    input_general = gr.TextArea(label="General tags", lines=4, placeholder="1girl, ...", value="")
+                    input_tags_to_copy = gr.Textbox(value="", visible=False)
+                    copy_input_btn = gr.Button(value="Copy to clipboard", size="sm", interactive=False)
+                    translate_input_prompt_button = gr.Button(value="Translate prompt to English", size="sm", variant="secondary")
+                    tag_type = gr.Radio(label="Output tag conversion", info="danbooru for Animagine, e621 for Pony.", choices=["danbooru", "e621"], value="e621", visible=False)
+                    input_rating = gr.Radio(label="Rating", choices=list(V2_RATING_OPTIONS), value="explicit")
+                    with gr.Accordion(label="Advanced options", open=False):
+                        input_aspect_ratio = gr.Radio(label="Aspect ratio", info="The aspect ratio of the image.", choices=list(V2_ASPECT_RATIO_OPTIONS), value="square")
+                        input_length = gr.Radio(label="Length", info="The total length of the tags.", choices=list(V2_LENGTH_OPTIONS), value="very_long")
+                        input_identity = gr.Radio(label="Keep identity", info="How strictly to keep the identity of the character or subject. If you specify the detail of subject in the prompt, you should choose `strict`. Otherwise, choose `none` or `lax`. `none` is very creative but sometimes ignores the input prompt.", choices=list(V2_IDENTITY_OPTIONS), value="lax")                    
+                        input_ban_tags = gr.Textbox(label="Ban tags", info="Tags to ban from the output.", placeholder="alternate costumen, ...", value="censored")
+                        model_name = gr.Dropdown(label="Model", choices=list(V2_ALL_MODELS.keys()), value=list(V2_ALL_MODELS.keys())[0])
+                        dummy_np = gr.Textbox(label="Negative prompt", value="", visible=False)
+                        recom_animagine = gr.Textbox(label="Animagine reccomended prompt", value="Animagine", visible=False)
+                        recom_pony = gr.Textbox(label="Pony reccomended prompt", value="Pony", visible=False)
+
+                generate_btn = gr.Button(value="GENERATE TAGS", size="lg", variant="primary")
+
+                with gr.Group():
+                    output_text = gr.TextArea(label="Output tags", interactive=False, show_copy_button=True)
+                    copy_btn = gr.Button(value="Copy to clipboard", size="sm", interactive=False)
+                    elapsed_time_md = gr.Markdown(label="Elapsed time", value="", visible=False)
+
+                with gr.Group():
+                    output_text_pony = gr.TextArea(label="Output tags (Pony e621 style)", interactive=False, show_copy_button=True)
+                    copy_btn_pony = gr.Button(value="Copy to clipboard", size="sm", interactive=False)
+
+                description_ui()
+
+        v2.input_components = [
+            model_name,
+            input_copyright,
+            input_character,
+            input_general,
+            input_rating,
+            input_aspect_ratio,
+            input_length,
+            input_identity,
+            input_ban_tags,
+        ]
+
+        translate_input_prompt_button.click(translate_prompt, inputs=[input_general], outputs=[input_general])
+        translate_input_prompt_button.click(translate_prompt, inputs=[input_character], outputs=[input_character])
+        translate_input_prompt_button.click(translate_prompt, inputs=[input_copyright], outputs=[input_copyright])
+
+        generate_from_image_btn.click(
+            predict_tags_wd,
+            inputs=[input_image, input_general, image_algorithms, general_threshold, character_threshold],
+            outputs=[
+                input_copyright,
+                input_character,
+                input_general,
+                copy_input_btn,
+            ],
+        ).then(
+            remove_specific_prompt, inputs=[input_general, keep_tags], outputs=[input_general],
+        ).then(
+            convert_danbooru_to_e621_prompt, inputs=[input_general, input_tag_type], outputs=[input_general],
+        ).then(
+            insert_recom_prompt, inputs=[input_general, dummy_np, recom_prompt], outputs=[input_general, dummy_np],
+        )
+        copy_input_btn.click(compose_prompt_to_copy, inputs=[input_character, input_copyright, input_general], outputs=[input_tags_to_copy]).then(
+            gradio_copy_text, inputs=[input_tags_to_copy], js=COPY_ACTION_JS,
+        )
+
+        generate_btn.click(
+            parse_upsampling_output(v2.on_generate),
+            inputs=[
+                *v2.input_components,
+            ],
+            outputs=[output_text, elapsed_time_md, copy_btn, copy_btn_pony],
+        ).then(
+            convert_danbooru_to_e621_prompt, inputs=[output_text, tag_type], outputs=[output_text_pony],
+        ).then(
+            insert_recom_prompt, inputs=[output_text, dummy_np, recom_animagine], outputs=[output_text, dummy_np],
+        ).then(
+            insert_recom_prompt, inputs=[output_text_pony, dummy_np, recom_pony], outputs=[output_text_pony, dummy_np],
+        )
+        copy_btn.click(gradio_copy_text, inputs=[output_text], js=COPY_ACTION_JS)
+        copy_btn_pony.click(gradio_copy_text, inputs=[output_text_pony], js=COPY_ACTION_JS)
+
+    gr.DuplicateButton(value="Duplicate Space for private use (This demo does not work on CPU. Requires Space with GPU available.)", elem_id="duplicate-button", visible=os.getenv("SHOW_DUPLICATE_BUTTON") == "1")
+
+app.queue()
+
+app.launch(
+    show_error=False,
+    debug=False,
+)
+## END MOD

modutils.py

@@ -0,0 +1,751 @@
+import os
+import json
+import gradio as gr
+from PIL import Image
+
+HF_LORA_PRIVATE_REPOS = ['John6666/loratest1', 'John6666/loratest3', 'John6666/loratest4', 'John6666/loratest']
+directory_loras = 'loras'
+
+
+def get_model_list(directory_path):
+    model_list = []
+    valid_extensions = {'.ckpt', '.pt', '.pth', '.safetensors', '.bin'}
+
+    for filename in os.listdir(directory_path):
+        if os.path.splitext(filename)[1] in valid_extensions:
+            name_without_extension = os.path.splitext(filename)[0]
+            file_path = os.path.join(directory_path, filename)
+            # model_list.append((name_without_extension, file_path))
+            model_list.append(file_path)
+#            print('\033[34mFILE: ' + file_path + '\033[0m')
+    return model_list
+
+
+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 normalize_prompt_list(tags):
+    prompts = []
+    for tag in tags:
+        tag = str(tag).strip()
+        if tag:
+            prompts.append(tag)
+    return prompts
+
+
+def escape_lora_basename(basename: str):
+    return basename.replace(".", "_").replace(" ", "_").replace(",", "")
+
+
+def download_private_repo(repo_id, dir_path, is_replace):
+    from huggingface_hub import snapshot_download
+    hf_read_token = os.environ.get('HF_READ_TOKEN')
+    if not hf_read_token: return
+    snapshot_download(repo_id=repo_id, local_dir=dir_path, allow_patterns=['*.ckpt', '*.pt', '*.pth', '*.safetensors', '*.bin'], use_auth_token=hf_read_token)
+    if is_replace:
+        from pathlib import Path
+        for file in Path(dir_path).glob("*"):
+            if file.exists() and "." in file.stem or " " in file.stem and file.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
+                newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}')
+                file.rename(newpath)
+
+
+private_model_path_repo_dict = {}
+
+
+def get_private_model_list(repo_id, dir_path):
+    global private_model_path_repo_dict
+    from huggingface_hub import HfApi
+    api = HfApi()
+    hf_read_token = os.environ.get('HF_READ_TOKEN')
+    if not hf_read_token: return []
+    files = api.list_repo_files(repo_id, token=hf_read_token)
+    model_list = []
+    for file in files:
+        from pathlib import Path
+        path = Path(f"{dir_path}/{file}")
+        if path.suffix in ['.ckpt', '.pt', '.pth', '.safetensors', '.bin']:
+            model_list.append(str(path))
+    for model in model_list:
+        private_model_path_repo_dict[model] = repo_id
+    return model_list
+
+
+def get_private_model_lists(repo_id_list, dir_path):
+    models = []
+    for repo in repo_id_list:
+        models.extend(get_private_model_list(repo, dir_path))
+    models = list_uniq(models)
+    return models
+
+
+def download_private_file(repo_id, path, is_replace):
+    from huggingface_hub import hf_hub_download
+    from pathlib import Path
+    file = Path(path)
+    newpath = Path(f'{file.parent.name}/{escape_lora_basename(file.stem)}{file.suffix}') if is_replace else file
+    hf_read_token = os.environ.get('HF_READ_TOKEN')
+    if not hf_read_token or newpath.exists(): return
+    filename = file.name
+    dirname = file.parent.name
+    hf_hub_download(repo_id=repo_id, filename=filename, local_dir=dirname, use_auth_token=hf_read_token)
+    if is_replace:
+        file.rename(newpath)
+
+
+def download_private_file_from_somewhere(path, is_replace):
+    if not path in private_model_path_repo_dict.keys(): return
+    repo_id = private_model_path_repo_dict.get(path, None)
+    download_private_file(repo_id, path, is_replace)
+
+
+def get_model_id_list():
+    from huggingface_hub import HfApi
+    api = HfApi()
+    model_ids = []
+
+    models_vp = api.list_models(author="votepurchase", cardData=True, sort="likes")
+    models_john = api.list_models(author="John6666", cardData=True, sort="last_modified")
+
+    for model in models_vp:
+        model_ids.append(model.id) if not model.private else ""
+
+    anime_models = []
+    real_models = []
+    for model in models_john:
+        if not model.private:
+            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)
+
+    return model_ids
+
+
+def get_t2i_model_info(repo_id: str):
+    from huggingface_hub import HfApi
+    api = HfApi()
+    if " " in repo_id or not api.repo_exists(repo_id): return ""
+    model = api.model_info(repo_id=repo_id)
+    if model.private or model.gated: return ""
+
+    tags = model.tags
+    info = []
+    url = f"https://huggingface.co/{repo_id}/"
+    if not 'diffusers' in tags: return ""
+    if 'diffusers:StableDiffusionXLPipeline' in tags:
+        info.append("SDXL")
+    elif 'diffusers:StableDiffusionPipeline' in tags:
+        info.append("SD1.5")
+    if model.card_data and model.card_data.tags:
+        info.extend(list_sub(model.card_data.tags, ['text-to-image', 'stable-diffusion', 'stable-diffusion-api', 'safetensors', 'stable-diffusion-xl']))
+    info.append(f"DLs: {model.downloads}")
+    info.append(f"likes: {model.likes}")
+    info.append(model.last_modified.strftime("lastmod: %Y-%m-%d"))
+
+    md = f"Model Info: {', '.join(info)}, [Model Repo]({url})"
+    return gr.update(value=md)
+
+
+def get_tupled_model_list(model_list):
+    if not model_list: return []
+    tupled_list = []
+    for repo_id in model_list:
+        from huggingface_hub import HfApi
+        api = HfApi()
+        if not api.repo_exists(repo_id): continue
+        model = api.model_info(repo_id=repo_id)
+        if model.private or model.gated: continue
+
+        tags = model.tags
+        info = []
+        if not 'diffusers' in tags: continue
+        if 'diffusers:StableDiffusionXLPipeline' in tags:
+            info.append("SDXL")
+        elif 'diffusers:StableDiffusionPipeline' in tags:
+            info.append("SD1.5")
+        if model.card_data and model.card_data.tags:
+            info.extend(list_sub(model.card_data.tags, ['text-to-image', 'stable-diffusion', 'stable-diffusion-api', 'safetensors', 'stable-diffusion-xl']))
+
+        if "pony" in info:
+            info.remove("pony")
+            name = f"{repo_id} (Pony🐴, {', '.join(info)})"
+        else:
+            name = f"{repo_id} ({', '.join(info)})"
+        tupled_list.append((name, repo_id))
+    return tupled_list
+
+
+def save_gallery_images(images):
+    from datetime import datetime, timezone, timedelta
+    japan_tz = timezone(timedelta(hours=9))
+    dt_now = datetime.utcnow().replace(tzinfo=timezone.utc).astimezone(japan_tz)
+    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:
+        from pathlib import Path
+        filename = basename + str(i) + ".png"
+        oldpath = Path(image[0])
+        newpath = oldpath.rename(Path(filename))
+        output_paths.append(str(newpath))
+        output_images.append((str(newpath), str(filename)))
+        i += 1
+    return gr.update(value=output_images), gr.update(value=output_paths), gr.update(visible=True),
+
+
+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., 'Euler a trailing', True, 'loras/Hyper-SDXL-12steps-CFG-lora.safetensors', 0.9],
+    "Hyper-SDXL 8step": [8, 5., 'Euler a trailing', True, 'loras/Hyper-SDXL-8steps-CFG-lora.safetensors', 0.9],
+    "Hyper-SDXL 4step": [4, 0, 'Euler a trailing', True, 'loras/Hyper-SDXL-4steps-lora.safetensors', 0.9],
+    "Hyper-SDXL 2step": [2, 0, 'Euler a trailing', True, 'loras/Hyper-SDXL-2steps-lora.safetensors', 0.9],
+    "Hyper-SDXL 1step": [1, 0, 'Euler a trailing', True, 'loras/Hyper-SDXL-1steps-lora.safetensors', 0.9],
+    "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, lora1_gui, lora_scale_1_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]
+    lora1 = optimization_list.get(opt, "None")[4]
+    lora_scale_1 = 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=lora1), gr.update(value=lora_scale_1),
+
+
+def set_lora_prompt(prompt_gui, prompt_syntax_gui, lora1_gui, lora_scale_1_gui, lora2_gui, lora_scale_2_gui, lora3_gui, lora_scale_3_gui, lora4_gui, lora_scale_4_gui, lora5_gui, lora_scale_5_gui):
+    import os
+    if not "Classic" in str(prompt_syntax_gui): return prompt_gui
+    loras = []
+    if lora1_gui:
+        basename = os.path.splitext(os.path.basename(lora1_gui))[0]
+        loras.append(f"<lora:{basename}:{lora_scale_1_gui:.2f}>")
+    if lora2_gui:
+        basename = os.path.splitext(os.path.basename(lora2_gui))[0]
+        loras.append(f"<lora:{basename}:{lora_scale_2_gui:.2f}>")
+    if lora3_gui:
+        basename = os.path.splitext(os.path.basename(lora3_gui))[0]
+        loras.append(f"<lora:{basename}:{lora_scale_3_gui:.2f}>")
+    if lora4_gui:
+        basename = os.path.splitext(os.path.basename(lora4_gui))[0]
+        loras.append(f"<lora:{basename}:{lora_scale_4_gui:.2f}>")
+    if lora5_gui:
+        basename = os.path.splitext(os.path.basename(lora5_gui))[0]
+        loras.append(f"<lora:{basename}:{lora_scale_5_gui:.2f}>")
+
+    tags = prompt_gui.split(",") if prompt_gui else []
+    prompts = []
+    for tag in tags:
+        tag = str(tag).strip()
+        if tag and not "<lora" in tag:
+            prompts.append(tag)
+
+    empty = [""]
+    prompt = ", ".join(prompts + loras + empty)
+
+    return gr.update(value=prompt)
+
+
+temp_dict = {}
+lora_trigger_dict = {}
+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
+
+
+civitai_not_exists_list = []
+
+
+def get_civitai_info(path):
+    global civitai_not_exists_list
+    import requests
+    if path in set(civitai_not_exists_list): return ["", "", "", "", ""]
+    from pathlib import Path
+    if not Path(path).exists(): return None
+    from fake_useragent import UserAgent
+    ua = UserAgent()
+    user_agent = ua.random
+    headers = {'User-Agent': user_agent, 'content-type': 'application/json'}
+    base_url = 'https://civitai.com/api/v1/model-versions/by-hash/'
+    params = {}
+    import hashlib
+    with open(path, 'rb') as file:
+        file_data = file.read()
+    hash_sha256 = hashlib.sha256(file_data).hexdigest()
+    url = base_url + hash_sha256
+    r = requests.get(url, params=params, headers=headers, timeout=(3.0, 7.5))
+    if not r.ok: return None
+    json = r.json()
+    if not 'baseModel' in json:
+        civitai_not_exists_list.append(path)
+        return ["", "", "", "", ""]
+    items = []
+    items.append(" / ".join(json['trainedWords']))
+    items.append(json['baseModel'])
+    items.append(json['model']['name'])
+    items.append(f"https://civitai.com/models/{json['modelId']}")
+    items.append(json['images'][0]['url'])
+    return items
+
+
+def update_lora_dict(path):
+    global lora_trigger_dict
+    from pathlib import Path
+    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_tupled_list(lora_model_list):
+    global lora_trigger_dict
+    from pathlib import Path
+    if not lora_model_list: return []
+    tupled_list = []
+    local_models = set(get_model_list(directory_loras))
+    for model in lora_model_list:
+        basename = Path(model).stem
+        key = escape_lora_basename(basename)
+        items = None
+        if key in lora_trigger_dict.keys():
+            items = lora_trigger_dict.get(key, None)
+        elif model in local_models:
+            items = get_civitai_info(model)
+            if items != None:
+                lora_trigger_dict[key] = items
+        name = basename
+        value = model
+        if items and items[2] != "":
+            if items[1] == "Pony":
+                name = f"{basename} (for {items[1]}🐴, {items[2]})"
+            else:
+                name = f"{basename} (for {items[1]}, {items[2]})"
+        tupled_list.append((name, value))
+    return tupled_list
+
+
+def set_lora_trigger(lora_gui: str):
+    from pathlib import Path
+    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="", visible=True)
+    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_private_model_lists(HF_LORA_PRIVATE_REPOS, directory_loras) + get_model_list(directory_loras)):
+        return gr.update(value="", visible=False), gr.update(visible=False), gr.update(value="", visible=False), gr.update(value="", visible=True)
+    if not new_path.exists():
+        download_private_file_from_somewhere(str(path), True)
+    basename = new_path.stem
+    tag = ""
+    label = f'Trigger: {basename}  /  Prompt:'
+    value = "None"
+    md = "None"
+    flag = False
+    items = lora_trigger_dict.get(basename, None)
+    if items == None:
+        items = get_civitai_info(str(new_path))
+        if items != None:
+            lora_trigger_dict[basename] = items
+            flag = True
+    if items and items[2] != "":
+        tag = items[0]
+        label = f'Trigger: {basename}  /  Prompt:'
+        if items[1] == "Pony":
+            label = f'Trigger: {basename}  /  Prompt (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]})'
+    if tag and flag:
+        new_lora_model_list = list_uniq(get_private_model_lists(HF_LORA_PRIVATE_REPOS, directory_loras) + get_model_list(directory_loras))
+        return gr.update(value=tag, label=label, visible=True), gr.update(visible=True),\
+              gr.update(value=md, visible=True), gr.update(value=str(new_path), choices=get_lora_tupled_list(new_lora_model_list))
+    elif tag:
+        return gr.update(value=tag, label=label, visible=True), gr.update(visible=True),\
+              gr.update(value=md, visible=True), gr.update(value=str(new_path))
+    else:
+        return gr.update(value=value, label=label, visible=True), gr.update(visible=True),\
+              gr.update(value=md, visible=True), gr.update(visible=True)
+
+
+def apply_lora_prompt(prompt_gui: str, lora_trigger_gui: str):
+    if lora_trigger_gui == "None": return gr.update(value=prompt_gui)
+    tags = prompt_gui.split(",") if prompt_gui else []
+    prompts = normalize_prompt_list(tags)
+
+    lora_tag = lora_trigger_gui.replace("/",",")
+    lora_tags = lora_tag.split(",") if str(lora_trigger_gui) != "None" else []
+    lora_prompts = normalize_prompt_list(lora_tags)
+ 
+    empty = [""]
+    prompt = ", ".join(list_uniq(prompts + lora_prompts) + empty)
+    return gr.update(value=prompt)
+
+
+def upload_file_lora(files):
+    file_paths = [file.name for file in files]
+    return gr.update(value=file_paths, visible=True)
+
+def move_file_lora(filepaths):
+    import shutil
+    from pathlib import Path
+    for file in filepaths:
+        path = Path(shutil.move(Path(file).absolute(), Path(f"./{directory_loras}").absolute()))
+        newpath = Path(f'{path.parent.name}/{escape_lora_basename(path.stem)}{path.suffix}')
+        path.rename(newpath)
+        update_lora_dict(str(newpath))
+
+    new_lora_model_list = list_uniq(get_private_model_lists(HF_LORA_PRIVATE_REPOS, directory_loras) + get_model_list(directory_loras))
+    new_lora_model_list.insert(0, "None")
+    
+    return gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ), gr.update(
+        choices=get_lora_tupled_list(new_lora_model_list)
+    ),
+
+
+quality_prompt_list = [
+    {
+        "name": "None",
+        "prompt": "",
+        "negative_prompt": "lowres",
+    },
+    {
+        "name": "Animagine Common",
+        "prompt": "anime artwork, anime style, key visual, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres",
+        "negative_prompt": "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]",
+    },
+    {
+        "name": "Pony Anime Common",
+        "prompt": "source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres",
+        "negative_prompt": "source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends",
+    },
+    {
+        "name": "Pony Common",
+        "prompt": "source_anime, score_9, score_8_up, score_7_up",
+        "negative_prompt": "source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends",
+    },
+    {
+        "name": "Animagine Standard v3.0",
+        "prompt": "masterpiece, best quality",
+        "negative_prompt": "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, artist name",
+    },
+    {
+        "name": "Animagine Standard v3.1",
+        "prompt": "masterpiece, best quality, very aesthetic, absurdres",
+        "negative_prompt": "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]",
+    },
+    {
+        "name": "Animagine Light v3.1",
+        "prompt": "(masterpiece), best quality, very aesthetic, perfect face",
+        "negative_prompt": "(low quality, worst quality:1.2), very displeasing, 3d, watermark, signature, ugly, poorly drawn",
+    },
+    {
+        "name": "Animagine Heavy v3.1",
+        "prompt": "(masterpiece), (best quality), (ultra-detailed), very aesthetic, illustration, disheveled hair, perfect composition, moist skin, intricate details",
+        "negative_prompt": "longbody, lowres, bad anatomy, bad hands, missing fingers, pubic hair, extra digit, fewer digits, cropped, worst quality, low quality, very displeasing",
+    },
+]
+
+
+style_list = [
+    {
+        "name": "None",
+        "prompt": "",
+        "negative_prompt": "",
+    },
+    {
+        "name": "Cinematic",
+        "prompt": "cinematic still, emotional, harmonious, vignette, highly detailed, high budget, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy",
+        "negative_prompt": "cartoon, graphic, text, painting, crayon, graphite, abstract, glitch, deformed, mutated, ugly, disfigured",
+    },
+    {
+        "name": "Photographic",
+        "prompt": "cinematic photo, 35mm photograph, film, bokeh, professional, 4k, highly detailed",
+        "negative_prompt": "drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly",
+    },
+    {
+        "name": "Anime",
+        "prompt": "anime artwork, anime style, key visual, vibrant, studio anime, highly detailed",
+        "negative_prompt": "photo, deformed, black and white, realism, disfigured, low contrast",
+    },
+    {
+        "name": "Manga",
+        "prompt": "manga style, vibrant, high-energy, detailed, iconic, Japanese comic style",
+        "negative_prompt": "ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, Western comic style",
+    },
+    {
+        "name": "Digital Art",
+        "prompt": "concept art, digital artwork, illustrative, painterly, matte painting, highly detailed",
+        "negative_prompt": "photo, photorealistic, realism, ugly",
+    },
+    {
+        "name": "Pixel art",
+        "prompt": "pixel-art, low-res, blocky, pixel art style, 8-bit graphics",
+        "negative_prompt": "sloppy, messy, blurry, noisy, highly detailed, ultra textured, photo, realistic",
+    },
+    {
+        "name": "Fantasy art",
+        "prompt": "ethereal fantasy concept art, magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy",
+        "negative_prompt": "photographic, realistic, realism, 35mm film, dslr, cropped, frame, text, deformed, glitch, noise, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, sloppy, duplicate, mutated, black and white",
+    },
+    {
+        "name": "Neonpunk",
+        "prompt": "neonpunk style, cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional",
+        "negative_prompt": "painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured",
+    },
+    {
+        "name": "3D Model",
+        "prompt": "professional 3d model, octane render, highly detailed, volumetric, dramatic lighting",
+        "negative_prompt": "ugly, deformed, noisy, low poly, blurry, painting",
+    },
+]
+
+
+# [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"],
+    "Anime 3:4 Fast": ["LCM", 8, 2.5, True, 896, 1152, "DPO Turbo"],
+    "Anime 3:4 Standard": ["Euler a", 28, 7., True, 896, 1152, "None"],
+    "Anime 3:4 Heavy": ["Euler a", 40, 7., True, 896, 1152, "None"],
+    "Anime 1:1 Fast": ["LCM", 8, 2.5, True, 1024, 1024, "DPO Turbo"],
+    "Anime 1:1 Standard": ["Euler a", 28, 7., True, 1024, 1024, "None"],
+    "Anime 1:1 Heavy": ["Euler a", 40, 7., True, 1024, 1024, "None"],
+    "Photo 3:4 Fast": ["LCM", 8, 2.5, False, 896, 1152, "DPO Turbo"],
+    "Photo 3:4 Standard": ["DPM++ 2M Karras", 28, 7., False, 896, 1152, "None"],
+    "Photo 3:4 Heavy": ["DPM++ 2M Karras", 40, 7., False, 896, 1152, "None"],
+    "Photo 1:1 Fast": ["LCM", 8, 2.5, False, 1024, 1024, "DPO Turbo"],
+    "Photo 1:1 Standard": ["DPM++ 2M Karras", 28, 7., False, 1024, 1024, "None"],
+    "Photo 1:1 Heavy": ["DPM++ 2M Karras", 40, 7., False, 1024, 1024, "None"],
+}
+
+
+def set_sampler_settings(sampler_setting):
+    if not sampler_setting in list(preset_sampler_setting.keys()) or sampler_setting == "None":
+        return gr.update(value="Euler a"), gr.update(value=28), gr.update(value=7.), gr.update(value=True),\
+              gr.update(value=1024), gr.update(value=1024), gr.update(value="None")
+    v = preset_sampler_setting.get(sampler_setting, ["Euler a", 28, 7., True, 1024, 1024])
+    # sampler, steps, cfg, clip_skip, width, height, optimization
+    return gr.update(value=v[0]), gr.update(value=v[1]), gr.update(value=v[2]), gr.update(value=v[3]),\
+          gr.update(value=v[4]), gr.update(value=v[5]), gr.update(value=v[6])
+
+
+preset_styles = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in style_list}
+preset_quality = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in quality_prompt_list}
+
+
+def process_style_prompt(prompt: str, neg_prompt: str, styles_key: str = "None", quality_key: str = "None", type: str = "None"):
+    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, key visual, 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")
+    pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
+    prompts = to_list(prompt)
+    neg_prompts = to_list(neg_prompt)
+
+    all_styles_ps = []
+    all_styles_nps = []
+    for d in style_list:
+        all_styles_ps.extend(to_list(str(d.get("prompt", ""))))
+        all_styles_nps.extend(to_list(str(d.get("negative_prompt", ""))))
+
+    all_quality_ps = []
+    all_quality_nps = []
+    for d in quality_prompt_list:
+        all_quality_ps.extend(to_list(str(d.get("prompt", ""))))
+        all_quality_nps.extend(to_list(str(d.get("negative_prompt", ""))))
+
+    quality_ps = to_list(preset_quality[quality_key][0])
+    quality_nps = to_list(preset_quality[quality_key][1])
+    styles_ps = to_list(preset_styles[styles_key][0])
+    styles_nps = to_list(preset_styles[styles_key][1])
+
+    prompts = list_sub(prompts, animagine_ps + pony_ps + all_styles_ps + all_quality_ps)
+    neg_prompts = list_sub(neg_prompts, animagine_nps + pony_nps + all_styles_nps + all_quality_nps)
+
+    last_empty_p = [""] if not prompts and type != "None" and styles_key != "None" and quality_key != "None" else []
+    last_empty_np = [""] if not neg_prompts and type != "None" and styles_key != "None" and quality_key != "None" else []
+
+    if type == "Animagine":
+        prompts = prompts + animagine_ps
+        neg_prompts = neg_prompts + animagine_nps
+    elif type == "Pony":
+        prompts = prompts + pony_ps
+        neg_prompts = neg_prompts + pony_nps
+
+    prompts = prompts + styles_ps + quality_ps
+    neg_prompts = neg_prompts + styles_nps + quality_nps
+
+    prompt = ", ".join(list_uniq(prompts) + last_empty_p)
+    neg_prompt = ", ".join(list_uniq(neg_prompts) + last_empty_np)
+
+    return prompt, neg_prompt
+
+
+def set_quick_presets(genre:str = "None", type:str = "None", speed:str = "None", aspect:str = "None"):
+    quality = "None"
+    style = "None"
+    sampler = "None"
+    opt = "None"
+
+    if genre == "Anime":
+        style = "Anime"
+        if aspect == "1:1":
+            if speed == "Heavy":
+                sampler = "Anime 1:1 Heavy"
+            elif speed == "Fast":
+                sampler = "Anime 1:1 Fast"
+            else:
+                sampler = "Anime 1:1 Standard"
+        elif aspect == "3:4":
+            if speed == "Heavy":
+                sampler = "Anime 3:4 Heavy"
+            elif speed == "Fast":
+                sampler = "Anime 3:4 Fast"
+            else:
+                sampler = "Anime 3:4 Standard"
+        if type == "Pony":
+            quality = "Pony Anime Common"
+        else:
+            quality = "Animagine Common"
+    elif genre == "Photo":
+        style = "Photographic"
+        if aspect == "1:1":
+            if speed == "Heavy":
+                sampler = "Photo 1:1 Heavy"
+            elif speed == "Fast":
+                sampler = "Photo 1:1 Fast"
+            else:
+                sampler = "Photo 1:1 Standard"
+        elif aspect == "3:4":
+            if speed == "Heavy":
+                sampler = "Photo 3:4 Heavy"
+            elif speed == "Fast":
+                sampler = "Photo 3:4 Fast"
+            else:
+                sampler = "Photo 3:4 Standard"
+        if type == "Pony":
+            quality = "Pony Common"
+        else:
+            quality = "None"
+
+    if speed == "Fast":
+        opt = "DPO Turbo"
+        if genre == "Anime" and type != "Pony": quality = "Animagine Light v3.1"
+
+    return gr.update(value=quality), gr.update(value=style), gr.update(value=sampler), gr.update(value=opt)
+
+
+textual_inversion_dict = {}
+with open('textual_inversion_dict.json', encoding='utf-8') as f:
+    textual_inversion_dict = json.load(f)
+
+
+textual_inversion_file_token_list = []
+
+
+def get_tupled_embed_list(embed_list):
+    from pathlib import Path
+    global textual_inversion_file_list
+    tupled_list = []
+    for file in embed_list:
+        token = textual_inversion_dict.get(Path(file).name, [Path(file).stem.replace(",",""), False])[0]
+        tupled_list.append((token, file))
+        textual_inversion_file_token_list.append(token)
+    return tupled_list
+
+
+def set_textual_inversion_prompt(textual_inversion_gui, prompt_gui, neg_prompt_gui, prompt_syntax_gui):
+    ti_tags = list(textual_inversion_dict.values()) + textual_inversion_file_token_list
+    tags = prompt_gui.split(",") if prompt_gui else []
+    prompts = []
+    for tag in tags:
+        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:
+        from pathlib import Path
+        tokens = textual_inversion_dict.get(Path(ti).name, [Path(ti).stem.replace(",",""), False])
+        is_positive = tokens[1] == True or "positive" in Path(ti).parent.name
+        if is_positive: # positive prompt
+            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),
+
+
+def get_model_pipeline(repo_id: str):
+    from huggingface_hub import HfApi
+    api = HfApi()
+    default = "StableDiffusionPipeline"
+    if " " in repo_id or not api.repo_exists(repo_id): return default
+    model = api.model_info(repo_id=repo_id)
+    if model.private or model.gated: return default
+
+    tags = model.tags
+    if not 'diffusers' in tags: return default
+    if 'diffusers:StableDiffusionXLPipeline' in tags:
+        return "StableDiffusionXLPipeline"
+    elif 'diffusers:StableDiffusionPipeline' in tags:
+        return "StableDiffusionPipeline"
+    else:
+        return default

output.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class UpsamplingOutput:
+    upsampled_tags: str
+
+    copyright_tags: str
+    character_tags: str
+    general_tags: str
+    rating_tag: str
+    aspect_ratio_tag: str
+    length_tag: str
+    identity_tag: str
+
+    elapsed_time: float = 0.0

packages.txt

@@ -0,0 +1 @@
+git-lfs aria2 -y ffmpeg

pre-requirements.txt

@@ -0,0 +1 @@
+pip>=23.0.0

requirements.txt

@@ -0,0 +1,17 @@
+git+https://github.com/R3gm/stablepy.git@test_stream
+torch==2.2.0
+gdown
+opencv-python
+pytorch-lightning
+torchvision
+accelerate
+transformers
+optimum[onnxruntime]
+spaces
+dartrs
+huggingface_hub
+httpx==0.13.3
+httpcore
+googletrans==4.0.0rc1
+timm
+fake-useragent

tagger.py

@@ -0,0 +1,450 @@
+from PIL import Image
+import torch
+import gradio as gr
+import spaces  # ZERO GPU
+
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+)
+
+WD_MODEL_NAMES = ["p1atdev/wd-swinv2-tagger-v3-hf"]
+WD_MODEL_NAME = WD_MODEL_NAMES[0]
+
+wd_model = AutoModelForImageClassification.from_pretrained(WD_MODEL_NAME, trust_remote_code=True)
+wd_model.to("cuda" if torch.cuda.is_available() else "cpu")
+wd_processor = AutoImageProcessor.from_pretrained(WD_MODEL_NAME, trust_remote_code=True)
+
+
+def _people_tag(noun: str, minimum: int = 1, maximum: int = 5):
+    return (
+        [f"1{noun}"]
+        + [f"{num}{noun}s" for num in range(minimum + 1, maximum + 1)]
+        + [f"{maximum+1}+{noun}s"]
+    )
+
+
+PEOPLE_TAGS = (
+    _people_tag("girl") + _people_tag("boy") + _people_tag("other") + ["no humans"]
+)
+
+
+RATING_MAP = {
+    "general": "safe",
+    "sensitive": "sensitive",
+    "questionable": "nsfw",
+    "explicit": "explicit, nsfw",
+}
+DANBOORU_TO_E621_RATING_MAP = {
+    "safe": "rating_safe",
+    "sensitive": "rating_safe",
+    "nsfw": "rating_explicit",
+    "explicit, nsfw": "rating_explicit",
+    "explicit": "rating_explicit",
+    "rating:safe": "rating_safe",
+    "rating:general": "rating_safe",
+    "rating:sensitive": "rating_safe",
+    "rating:questionable, nsfw": "rating_explicit",
+    "rating:explicit, nsfw": "rating_explicit",
+}
+
+
+def load_dict_from_csv(filename):
+    with open(filename, 'r', encoding="utf-8") as f:
+        lines = f.readlines()
+    dict = {}
+    for line in lines:
+        parts = line.strip().split(',')
+        dict[parts[0]] = parts[1]
+    return dict
+
+
+anime_series_dict = load_dict_from_csv('character_series_dict.csv')
+
+
+def character_list_to_series_list(character_list):
+    output_series_tag = []
+    series_tag = ""
+    series_dict = anime_series_dict
+    for tag in character_list:
+        series_tag = series_dict.get(tag, "")
+        if tag.endswith(")"):
+            tags = tag.split("(")
+            character_tag = "(".join(tags[:-1])
+            if character_tag.endswith(" "):
+                character_tag = character_tag[:-1]
+            series_tag = tags[-1].replace(")", "")
+
+    if series_tag:
+        output_series_tag.append(series_tag)
+
+    return output_series_tag
+
+
+def danbooru_to_e621(dtag, e621_dict):
+    def d_to_e(match, e621_dict):
+        dtag = match.group(0)
+        etag = e621_dict.get(dtag.strip().replace("_", " "), "")
+        if etag:
+            return etag
+        else:
+            return dtag
+    
+    import re
+    tag = re.sub(r'[\w ]+', lambda wrapper: d_to_e(wrapper, e621_dict), dtag, 2)
+
+    return tag
+
+
+danbooru_to_e621_dict = load_dict_from_csv('danbooru_e621.csv')
+
+
+def convert_danbooru_to_e621_prompt(input_prompt: str = "", prompt_type: str = "danbooru"):
+    if prompt_type == "danbooru": return input_prompt
+    tags = input_prompt.split(",") if input_prompt else []
+    people_tags: list[str] = []
+    other_tags: list[str] = []
+    rating_tags: list[str] = []
+
+    e621_dict = danbooru_to_e621_dict
+    for tag in tags:
+        tag = tag.strip().replace("_", " ")
+        tag = danbooru_to_e621(tag, e621_dict)
+        if tag in PEOPLE_TAGS:        
+            people_tags.append(tag)
+        elif tag in DANBOORU_TO_E621_RATING_MAP.keys():
+            rating_tags.append(DANBOORU_TO_E621_RATING_MAP.get(tag.replace(" ",""), ""))            
+        else:
+            other_tags.append(tag)
+
+    rating_tags = sorted(set(rating_tags), key=rating_tags.index)
+    rating_tags = [rating_tags[0]] if rating_tags else []
+    rating_tags = ["explicit, nsfw"] if rating_tags and rating_tags[0] == "explicit" else rating_tags
+
+    output_prompt = ", ".join(people_tags + other_tags + rating_tags)
+    
+    return output_prompt
+
+
+def translate_prompt(prompt: str = ""):
+    def translate_to_english(prompt):
+        import httpcore
+        setattr(httpcore, 'SyncHTTPTransport', 'AsyncHTTPProxy')
+        from googletrans import Translator
+        translator = Translator()
+        try:
+            translated_prompt = translator.translate(prompt, src='auto', dest='en').text
+            return translated_prompt
+        except Exception as e:
+            return prompt
+
+    def is_japanese(s):
+        import unicodedata
+        for ch in s:
+            name = unicodedata.name(ch, "") 
+            if "CJK UNIFIED" in name or "HIRAGANA" in name or "KATAKANA" in name:
+                return True
+        return False
+
+    def to_list(s):
+        return [x.strip() for x in s.split(",")]
+    
+    prompts = to_list(prompt)
+    outputs = []
+    for p in prompts:
+        p = translate_to_english(p) if is_japanese(p) else p
+        outputs.append(p)
+
+    return ", ".join(outputs)
+
+
+def translate_prompt_to_ja(prompt: str = ""):
+    def translate_to_japanese(prompt):
+        import httpcore
+        setattr(httpcore, 'SyncHTTPTransport', 'AsyncHTTPProxy')
+        from googletrans import Translator
+        translator = Translator()
+        try:
+            translated_prompt = translator.translate(prompt, src='en', dest='ja').text
+            return translated_prompt
+        except Exception as e:
+            return prompt
+
+    def is_japanese(s):
+        import unicodedata
+        for ch in s:
+            name = unicodedata.name(ch, "") 
+            if "CJK UNIFIED" in name or "HIRAGANA" in name or "KATAKANA" in name:
+                return True
+        return False
+
+    def to_list(s):
+        return [x.strip() for x in s.split(",")]
+    
+    prompts = to_list(prompt)
+    outputs = []
+    for p in prompts:
+        p = translate_to_japanese(p) if not is_japanese(p) else p
+        outputs.append(p)
+
+    return ", ".join(outputs)
+
+
+def tags_to_ja(itag, dict):
+    def t_to_j(match, dict):
+        tag = match.group(0)
+        ja = dict.get(tag.strip().replace("_", " "), "")
+        if ja:
+            return ja
+        else:
+            return tag
+    
+    import re
+    tag = re.sub(r'[\w ]+', lambda wrapper: t_to_j(wrapper, dict), itag, 2)
+
+    return tag
+
+
+def convert_tags_to_ja(input_prompt: str = ""):
+    tags = input_prompt.split(",") if input_prompt else []
+    out_tags = []
+
+    tags_to_ja_dict = load_dict_from_csv('all_tags_ja_ext.csv')
+    dict = tags_to_ja_dict
+    for tag in tags:
+        tag = tag.strip().replace("_", " ")
+        tag = tags_to_ja(tag, dict)
+        out_tags.append(tag)
+    
+    return ", ".join(out_tags)
+
+
+def insert_recom_prompt(prompt: str = "", neg_prompt: str = "", type: str = "None"):
+    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, key visual, 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")
+    pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
+    prompts = to_list(prompt)
+    neg_prompts = to_list(neg_prompt)
+
+    prompts = list_sub(prompts, animagine_ps + pony_ps)
+    neg_prompts = list_sub(neg_prompts, animagine_nps + pony_nps)
+
+    last_empty_p = [""] if not prompts and type != "None" else []
+    last_empty_np = [""] if not neg_prompts and type != "None" else []
+
+    if type == "Animagine":
+        prompts = prompts + animagine_ps
+        neg_prompts = neg_prompts + animagine_nps
+    elif type == "Pony":
+        prompts = prompts + pony_ps
+        neg_prompts = neg_prompts + pony_nps
+
+    prompt = ", ".join(list_uniq(prompts) + last_empty_p)
+    neg_prompt = ", ".join(list_uniq(neg_prompts) + last_empty_np)
+
+    return prompt, neg_prompt
+
+
+tag_group_dict = load_dict_from_csv('tag_group.csv')
+
+
+def remove_specific_prompt(input_prompt: str = "", keep_tags: str = "all"):
+    def is_dressed(tag):
+        import re
+        p = re.compile(r'dress|cloth|uniform|costume|vest|sweater|coat|shirt|jacket|blazer|apron|leotard|hood|sleeve|skirt|shorts|pant|loafer|ribbon|necktie|bow|collar|glove|sock|shoe|boots|wear|emblem')
+        return p.search(tag)
+
+    def is_background(tag):
+        import re
+        p = re.compile(r'background|outline|light|sky|build|day|screen|tree|city')
+        return p.search(tag)
+
+    un_tags = ['solo']
+    group_list = ['groups', 'body_parts', 'attire', 'posture', 'objects', 'creatures', 'locations', 'disambiguation_pages', 'commonly_misused_tags', 'phrases', 'verbs_and_gerunds', 'subjective', 'nudity', 'sex_objects', 'sex', 'sex_acts', 'image_composition', 'artistic_license', 'text', 'year_tags', 'metatags']
+    keep_group_dict = {
+        "body": ['groups', 'body_parts'],
+        "dress": ['groups', 'body_parts', 'attire'],
+        "all": group_list,
+    }
+
+    def is_necessary(tag, keep_tags, group_dict):
+        if keep_tags == "all":
+            return True
+        elif tag in un_tags or group_dict.get(tag, "") in explicit_group:
+            return False
+        elif keep_tags == "body" and is_dressed(tag):
+            return False
+        elif is_background(tag):
+            return False
+        else:
+            return True
+    
+    if keep_tags == "all": return input_prompt
+    keep_group = keep_group_dict.get(keep_tags, keep_group_dict["body"])
+    explicit_group = list(set(group_list) ^ set(keep_group))
+
+    tags = input_prompt.split(",") if input_prompt else []
+    people_tags: list[str] = []
+    other_tags: list[str] = []
+
+    group_dict = tag_group_dict
+    for tag in tags:
+        tag = tag.strip().replace("_", " ")
+        if tag in PEOPLE_TAGS:
+            people_tags.append(tag)
+        elif is_necessary(tag, keep_tags, group_dict):
+            other_tags.append(tag)
+
+    output_prompt = ", ".join(people_tags + other_tags)
+    
+    return output_prompt
+
+
+def sort_taglist(tags: list[str]):
+    if not tags: return []
+    character_tags: list[str] = []
+    series_tags: list[str] = []
+    people_tags: list[str] = []
+    group_list = ['groups', 'body_parts', 'attire', 'posture', 'objects', 'creatures', 'locations', 'disambiguation_pages', 'commonly_misused_tags', 'phrases', 'verbs_and_gerunds', 'subjective', 'nudity', 'sex_objects', 'sex', 'sex_acts', 'image_composition', 'artistic_license', 'text', 'year_tags', 'metatags']
+    group_tags = {}
+    other_tags: list[str] = []
+    rating_tags: list[str] = []
+
+    group_dict = tag_group_dict
+    group_set = set(group_dict.keys())
+    character_set = set(anime_series_dict.keys())
+    series_set = set(anime_series_dict.values())
+    rating_set = set(DANBOORU_TO_E621_RATING_MAP.keys()) | set(DANBOORU_TO_E621_RATING_MAP.values())
+
+    for tag in tags:
+        tag = tag.strip().replace("_", " ")
+        if tag in PEOPLE_TAGS:
+            people_tags.append(tag)
+        elif tag in rating_set:
+            rating_tags.append(tag)
+        elif tag in group_set:
+            elem = group_dict[tag]
+            group_tags[elem] = group_tags[elem] + [tag] if elem in group_tags else [tag]
+        elif tag in character_set:
+            character_tags.append(tag)
+        elif tag in series_set:
+            series_tags.append(tag)
+        else:
+            other_tags.append(tag)
+
+    output_group_tags: list[str] = []
+    for k in group_list:
+        output_group_tags.extend(group_tags.get(k, []))
+
+    rating_tags = [rating_tags[0]] if rating_tags else []
+    rating_tags = ["explicit, nsfw"] if rating_tags and rating_tags[0] == "explicit" else rating_tags
+
+    output_tags = character_tags + series_tags + people_tags + output_group_tags + other_tags + rating_tags
+    
+    return output_tags
+
+
+def sort_tags(tags: str):
+    if not tags: return ""
+    taglist: list[str] = []
+    for tag in tags.split(","):
+        taglist.append(tag.strip())
+    taglist = list(filter(lambda x: x != "", taglist))
+    return ", ".join(sort_taglist(taglist))
+
+
+def postprocess_results(results: dict[str, float], general_threshold: float, character_threshold: float):
+    results = {
+        k: v for k, v in sorted(results.items(), key=lambda item: item[1], reverse=True)
+    }
+
+    rating = {}
+    character = {}
+    general = {}
+
+    for k, v in results.items():
+        if k.startswith("rating:"):
+            rating[k.replace("rating:", "")] = v
+            continue
+        elif k.startswith("character:"):
+            character[k.replace("character:", "")] = v
+            continue
+
+        general[k] = v
+
+    character = {k: v for k, v in character.items() if v >= character_threshold}
+    general = {k: v for k, v in general.items() if v >= general_threshold}
+
+    return rating, character, general
+
+
+def gen_prompt(rating: list[str], character: list[str], general: list[str]):
+    people_tags: list[str] = []
+    other_tags: list[str] = []
+    rating_tag = RATING_MAP[rating[0]]
+
+    for tag in general:
+        if tag in PEOPLE_TAGS:
+            people_tags.append(tag)
+        else:
+            other_tags.append(tag)
+
+    all_tags = people_tags + other_tags
+
+    return ", ".join(all_tags)
+
+
+@spaces.GPU()
+def predict_tags(image: Image.Image, general_threshold: float = 0.3, character_threshold: float = 0.8):
+    inputs = wd_processor.preprocess(image, return_tensors="pt")
+
+    outputs = wd_model(**inputs.to(wd_model.device, wd_model.dtype))
+    logits = torch.sigmoid(outputs.logits[0])  # take the first logits
+
+    # get probabilities
+    results = {
+        wd_model.config.id2label[i]: float(logit.float()) for i, logit in enumerate(logits)
+    }
+
+    # rating, character, general
+    rating, character, general = postprocess_results(
+        results, general_threshold, character_threshold
+    )
+
+    prompt = gen_prompt(
+        list(rating.keys()), list(character.keys()), list(general.keys())
+    )
+
+    output_series_tag = ""
+    output_series_list = character_list_to_series_list(character.keys())
+    if output_series_list:
+        output_series_tag = output_series_list[0]
+    else:
+        output_series_tag = ""
+
+    return output_series_tag, ", ".join(character.keys()), prompt, gr.update(interactive=True),
+
+
+def predict_tags_wd(image: Image.Image, input_tags: str, algo: list[str], general_threshold: float = 0.3, character_threshold: float = 0.8):
+    if not "Use WD Tagger" in algo and len(algo) != 0:
+        return "", "", input_tags, gr.update(interactive=True),
+    return predict_tags(image, general_threshold, character_threshold)
+
+
+def compose_prompt_to_copy(character: str, series: str, general: str):
+    characters = character.split(",") if character else []
+    serieses = series.split(",") if series else []
+    generals = general.split(",") if general else []
+    tags = characters + serieses + generals
+    cprompt = ",".join(tags) if tags else ""
+    return cprompt

textual_inversion_dict.json

@@ -0,0 +1,74 @@
+{
+  "bad_prompt_version2.pt": [
+    "bad_prompt",
+    false
+  ],
+  "EasyNegativeV2.safetensors": [
+    "EasyNegative",
+    false
+  ],
+  "bad-hands-5.pt": [
+    "bad_hand",
+    false
+  ],
+  "negativeXL_A.safetensors": [
+    "negativeXL_A",
+    false
+  ],
+  "negativeXL_B.safetensors": [
+    "negativeXL_B",
+    false
+  ],
+  "negativeXL_C.safetensors": [
+    "negativeXL_C",
+    false
+  ],
+  "negativeXL_D.safetensors": [
+    "negativeXL_D",
+    false
+  ],
+  "unaestheticXL2v10.safetensors": [
+    "2v10",
+    false
+  ],
+  "unaestheticXL_AYv1.safetensors": [
+    "_AYv1",
+    false
+  ],
+  "unaestheticXL_Alb2.safetensors": [
+    "_Alb2",
+    false
+  ],
+  "unaestheticXL_Jug6.safetensors": [
+    "_Jug6",
+    false
+  ],
+  "unaestheticXL_bp5.safetensors": [
+    "_bp5",
+    false
+  ],
+  "unaestheticXL_hk1.safetensors": [
+    "_hk1",
+    false
+  ],
+  "unaestheticXLv1.safetensors": [
+    "v1.0",
+    false
+  ],
+  "unaestheticXLv13.safetensors": [
+    "v1.3",
+    false
+  ],
+  "unaestheticXLv31.safetensors": [
+    "v3.1",
+    false
+  ],
+  "unaestheticXL_Sky3.1.safetensors": [
+    "_Sky3.1",
+    false
+  ],
+  "SimplePositiveXLv2.safetensors": [
+    "SIMPLEPOSITIVEXLV2",
+    true
+  ]
+}

utils.py

@@ -0,0 +1,45 @@
+import gradio as gr
+from dartrs.v2 import AspectRatioTag, LengthTag, RatingTag, IdentityTag
+
+
+V2_ASPECT_RATIO_OPTIONS: list[AspectRatioTag] = [
+    "ultra_wide",
+    "wide",
+    "square",
+    "tall",
+    "ultra_tall",
+]
+V2_RATING_OPTIONS: list[RatingTag] = [
+    "sfw",
+    "general",
+    "sensitive",
+    "nsfw",
+    "questionable",
+    "explicit",
+]
+V2_LENGTH_OPTIONS: list[LengthTag] = [
+    "very_short",
+    "short",
+    "medium",
+    "long",
+    "very_long",
+]
+V2_IDENTITY_OPTIONS: list[IdentityTag] = [
+    "none",
+    "lax",
+    "strict",
+]
+
+
+# ref: https://qiita.com/tregu148/items/fccccbbc47d966dd2fc2
+def gradio_copy_text(_text: None):
+    gr.Info("Copied!")
+
+
+COPY_ACTION_JS = """\
+(inputs, _outputs) => {
+  // inputs is the string value of the input_text
+  if (inputs.trim() !== "") {
+    navigator.clipboard.writeText(inputs);
+  }
+}"""

v2.py

@@ -0,0 +1,214 @@
+import time
+import os
+import torch
+from typing import Callable
+
+from dartrs.v2 import (
+    V2Model,
+    MixtralModel,
+    MistralModel,
+    compose_prompt,
+    LengthTag,
+    AspectRatioTag,
+    RatingTag,
+    IdentityTag,
+)
+from dartrs.dartrs import DartTokenizer
+from dartrs.utils import get_generation_config
+
+
+import gradio as gr
+from gradio.components import Component
+
+try:
+    import spaces
+except ImportError:
+
+    class spaces:
+        def GPU(*args, **kwargs):
+            return lambda x: x
+
+
+from output import UpsamplingOutput
+
+
+HF_TOKEN = os.getenv("HF_TOKEN", None)
+
+V2_ALL_MODELS = {
+    "dart-v2-moe-sft": {
+        "repo": "p1atdev/dart-v2-moe-sft",
+        "type": "sft",
+        "class": MixtralModel,
+    },
+    "dart-v2-sft": {
+        "repo": "p1atdev/dart-v2-sft",
+        "type": "sft",
+        "class": MistralModel,
+    },
+}
+
+
+def prepare_models(model_config: dict):
+    model_name = model_config["repo"]
+    tokenizer = DartTokenizer.from_pretrained(model_name, auth_token=HF_TOKEN)
+    model = model_config["class"].from_pretrained(model_name, auth_token=HF_TOKEN)
+
+    return {
+        "tokenizer": tokenizer,
+        "model": model,
+    }
+
+
+def normalize_tags(tokenizer: DartTokenizer, tags: str):
+    """Just remove unk tokens."""
+    return ", ".join([tag for tag in tokenizer.tokenize(tags) if tag != "<|unk|>"])
+
+
+@torch.no_grad()
+def generate_tags(
+    model: V2Model,
+    tokenizer: DartTokenizer,
+    prompt: str,
+    ban_token_ids: list[int],
+):
+    output = model.generate(
+        get_generation_config(
+            prompt,
+            tokenizer=tokenizer,
+            temperature=1,
+            top_p=0.9,
+            top_k=100,
+            max_new_tokens=256,
+            ban_token_ids=ban_token_ids,
+        ),
+    )
+
+    return output
+
+
+def _people_tag(noun: str, minimum: int = 1, maximum: int = 5):
+    return (
+        [f"1{noun}"]
+        + [f"{num}{noun}s" for num in range(minimum + 1, maximum + 1)]
+        + [f"{maximum+1}+{noun}s"]
+    )
+
+
+PEOPLE_TAGS = (
+    _people_tag("girl") + _people_tag("boy") + _people_tag("other") + ["no humans"]
+)
+
+
+def gen_prompt_text(output: UpsamplingOutput):
+    # separate people tags (e.g. 1girl)
+    people_tags = []
+    other_general_tags = []
+    
+    for tag in output.general_tags.split(","):
+        tag = tag.strip()
+        if tag in PEOPLE_TAGS:
+            people_tags.append(tag)
+        else:
+            other_general_tags.append(tag)
+
+    return ", ".join(
+        [
+            part.strip()
+            for part in [
+                *people_tags,
+                output.character_tags,
+                output.copyright_tags,
+                *other_general_tags,
+                output.upsampled_tags,
+                output.rating_tag,
+            ]
+            if part.strip() != ""
+        ]
+    )
+
+
+def elapsed_time_format(elapsed_time: float) -> str:
+    return f"Elapsed: {elapsed_time:.2f} seconds"
+
+
+def parse_upsampling_output(
+    upsampler: Callable[..., UpsamplingOutput],
+):
+    def _parse_upsampling_output(*args) -> tuple[str, str, dict]:
+        output = upsampler(*args)
+
+        return (
+            gen_prompt_text(output),
+            elapsed_time_format(output.elapsed_time),
+            gr.update(interactive=True),
+            gr.update(interactive=True),
+        )
+
+    return _parse_upsampling_output
+
+
+class V2UI:
+    model_name: str | None = None
+    model: V2Model
+    tokenizer: DartTokenizer
+
+    input_components: list[Component] = []
+    generate_btn: gr.Button
+
+    def on_generate(
+        self,
+        model_name: str,
+        copyright_tags: str,
+        character_tags: str,
+        general_tags: str,
+        rating_tag: RatingTag,
+        aspect_ratio_tag: AspectRatioTag,
+        length_tag: LengthTag,
+        identity_tag: IdentityTag,
+        ban_tags: str,
+        *args,
+    ) -> UpsamplingOutput:
+        if self.model_name is None or self.model_name != model_name:
+            models = prepare_models(V2_ALL_MODELS[model_name])
+            self.model = models["model"]
+            self.tokenizer = models["tokenizer"]
+            self.model_name = model_name
+
+        # normalize tags
+        # copyright_tags = normalize_tags(self.tokenizer, copyright_tags)
+        # character_tags = normalize_tags(self.tokenizer, character_tags)
+        # general_tags = normalize_tags(self.tokenizer, general_tags)
+
+        ban_token_ids = self.tokenizer.encode(ban_tags.strip())
+
+        prompt = compose_prompt(
+            prompt=general_tags,
+            copyright=copyright_tags,
+            character=character_tags,
+            rating=rating_tag,
+            aspect_ratio=aspect_ratio_tag,
+            length=length_tag,
+            identity=identity_tag,
+        )
+
+        start = time.time()
+        upsampled_tags = generate_tags(
+            self.model,
+            self.tokenizer,
+            prompt,
+            ban_token_ids,
+        )
+        elapsed_time = time.time() - start
+
+        return UpsamplingOutput(
+            upsampled_tags=upsampled_tags,
+            copyright_tags=copyright_tags,
+            character_tags=character_tags,
+            general_tags=general_tags,
+            rating_tag=rating_tag,
+            aspect_ratio_tag=aspect_ratio_tag,
+            length_tag=length_tag,
+            identity_tag=identity_tag,
+            elapsed_time=elapsed_time,
+        )
+