app.py

import transformers
transformers.utils.move_cache()
import random
import tempfile
import time
import gradio as gr
import numpy as np
import torch
import math
import re
import sys
from gradio import inputs
from diffusers import (
    AutoencoderKL,
    #UNet2DConditionModel,
    ControlNetModel,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    HeunDiscreteScheduler,
    KDPM2AncestralDiscreteScheduler,
    KDPM2DiscreteScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UniPCMultistepScheduler,
    DEISMultistepScheduler,
    DDPMScheduler,
    DDIMScheduler,
    DPMSolverSDEScheduler,
    DPMSolverSinglestepScheduler,
    T2IAdapter,
    SASolverScheduler,
    EDMEulerScheduler,
    EDMDPMSolverMultistepScheduler,
    ConsistencyDecoderVAE,
)
from modules.u_net_condition_modify import UNet2DConditionModel
from modules.model_diffusers import (
    StableDiffusionPipeline_finetune,
    StableDiffusionControlNetPipeline_finetune,
    StableDiffusionControlNetImg2ImgPipeline_finetune,
    StableDiffusionImg2ImgPipeline_finetune,
    StableDiffusionInpaintPipeline_finetune,
    StableDiffusionControlNetInpaintPipeline_finetune,
)
from modules.attention_modify import AttnProcessor,IPAdapterAttnProcessor,AttnProcessor2_0,IPAdapterAttnProcessor2_0
from modules.model_k_diffusion import StableDiffusionPipeline
from torchvision import transforms
from transformers import CLIPTokenizer, CLIPTextModel,CLIPImageProcessor
from PIL import Image,ImageOps, ImageChops
from pathlib import Path
from safetensors.torch import load_file
import modules.safe as _
from modules.lora import LoRANetwork
import os
import cv2
from controlnet_aux import PidiNetDetector, HEDdetector,LineartAnimeDetector,LineartDetector,MLSDdetector,OpenposeDetector,MidasDetector,NormalBaeDetector,ContentShuffleDetector,ZoeDetector
from transformers import pipeline
from modules import samplers_extra_k_diffusion
import gc
import copy
from modules.preprocessing_segmentation import preprocessing_segmentation
import torch.nn.functional as F
from modules.t2i_adapter import setup_model_t2i_adapter
from diffusers.image_processor import IPAdapterMaskProcessor
from typing import Callable, Dict, List, Optional, Union
from insightface.app import FaceAnalysis
from insightface.utils import face_align
from diffusers.utils import load_image
from transformers import (
    CLIPImageProcessor,
    CLIPVisionModelWithProjection,
)
embeddings_dict = dict()
lora_dict = dict()
lora_scale_dict = dict()
# lora_dict = {'Not using Lora':None,}
# lora_scale_dict = {'Not using Lora':1.0,}
# lora_lst = ['Not using Lora']
lora_lst = ['Not using Lora']
formula = [
    ['w = token_weight_martix * sigma * std(qk)',0],
    ['w = token_weight_martix * log(1 + sigma) * max(qk)',1],
    ['w = token_weight_martix * log(1 + sigma) * std(qk)',2],
    ['w = token_weight_martix * log(1 + sigma^2) * std(qk)',3],
]

encoding_type ={
    "Automatic111 Encoding": 0,
    "Long Prompt Encoding": 1,
    "Short Prompt Encoding": 2,
}
model_ip_adapter_lst = ['IP-Adapter','IP-Adapter VIT-G','IP-Adapter Light','IP-Adapter Light v1.1','IP-Adapter Face','IP-Adapter FaceID','IP-Adapter Plus','IP-Adapter Plus Face',"IP-Adapter Plus FaceID","IP-Adapter Plus FaceIDv2"]

model_ip_adapter_type = {
    "IP-Adapter": "ip-adapter_sd15.bin",
    "IP-Adapter VIT-G": "ip-adapter_sd15_vit-G.bin",
    "IP-Adapter Light": "ip-adapter_sd15_light.bin",
    "IP-Adapter Light v1.1": "ip-adapter_sd15_light_v11.bin",
    "IP-Adapter Face":"ip-adapter-full-face_sd15.bin",
    "IP-Adapter FaceID":"ip-adapter-faceid_sd15.bin",
    "IP-Adapter Plus": "ip-adapter-plus_sd15.bin",
    "IP-Adapter Plus Face": "ip-adapter-plus-face_sd15.bin",
    "IP-Adapter Plus FaceID": "ip-adapter-faceid-plus_sd15.bin",
    "IP-Adapter Plus FaceIDv2": "ip-adapter-faceid-plusv2_sd15.bin",
}

controlnet_lst = ["Canny","Depth","Openpose","Soft Edge","Lineart","Lineart (anime)","Scribble","MLSD","Semantic Segmentation","Normal Map","Shuffle","Instruct Pix2Pix"]
adapter_lst = ["Canny","Sketch","Color","Depth","Openpose","Semantic Segmentation","Zoedepth"]
controlnet_type ={
    "Canny": "lllyasviel/control_v11p_sd15_canny",
    "Depth": "lllyasviel/control_v11f1p_sd15_depth",
    "Openpose": "lllyasviel/control_v11p_sd15_openpose",
    "Soft Edge": "lllyasviel/control_v11p_sd15_softedge",
    "Lineart":"ControlNet-1-1-preview/control_v11p_sd15_lineart",
    "Lineart (anime)":"lllyasviel/control_v11p_sd15s2_lineart_anime",
    "Scribble":"lllyasviel/control_v11p_sd15_scribble",
    "MLSD":"lllyasviel/control_v11p_sd15_mlsd",
    "Semantic Segmentation":"lllyasviel/control_v11p_sd15_seg",
    "Normal Map":"lllyasviel/control_v11p_sd15_normalbae",
    "Shuffle":"lllyasviel/control_v11e_sd15_shuffle",
    "Instruct Pix2Pix":"lllyasviel/control_v11e_sd15_ip2p",
}
adapter_type ={
    "Canny": "TencentARC/t2iadapter_canny_sd15v2",
    "Sketch": "TencentARC/t2iadapter_sketch_sd15v2",
    "Color": "TencentARC/t2iadapter_color_sd14v1",
    "Depth": "TencentARC/t2iadapter_depth_sd15v2",
    "Openpose":"TencentARC/t2iadapter_openpose_sd14v1",
    "Semantic Segmentation":"TencentARC/t2iadapter_seg_sd14v1",
    "Zoedepth":"TencentARC/t2iadapter_zoedepth_sd15v1",
}
models_single_file = []
models = [
    ("AbyssOrangeMix2", "Korakoe/AbyssOrangeMix2-HF"),
    ("BloodOrangeMix", "WarriorMama777/BloodOrangeMix"),
    ("ElyOrangeMix", "WarriorMama777/ElyOrangeMix"),
    ("Pastal Mix", "JamesFlare/pastel-mix"),
    ("Basil Mix", "nuigurumi/basil_mix"),
    ("Stable Diffusion v1.5", "runwayml/stable-diffusion-v1-5"),
    ("Stable Diffusion v2.1", "stabilityai/stable-diffusion-2-1-base"),
    ("Realistic Vision v1.4", "SG161222/Realistic_Vision_V1.4"),
    ("Dreamlike Photoreal v2.0", "dreamlike-art/dreamlike-photoreal-2.0"),
    ("Waifu-diffusion v1.4", "hakurei/waifu-diffusion"),
    ("Stable diffusion PixelArt v1.4", "Onodofthenorth/SD_PixelArt_SpriteSheet_Generator"),
    ("Anything v3", "Linaqruf/anything-v3.0"),
    ("Sketch style", "Cosk/sketchstyle-cutesexyrobutts"),
    ("Anything v5", "stablediffusionapi/anything-v5"),
    ("Counterfeit v2.5", "gsdf/Counterfeit-V2.5"),
    ("Edge of realism", "stablediffusionapi/edge-of-realism"),
    ("Photorealistic fuen", "claudfuen/photorealistic-fuen-v1"),
    ("Protogen x5.8 (Scifi-Anime)", "darkstorm2150/Protogen_x5.8_Official_Release"),
    ("Dreamlike Anime", "dreamlike-art/dreamlike-anime-1.0"),
    ("Something V2.2", "NoCrypt/SomethingV2_2"),
    ("Realistic Vision v3.0", "SG161222/Realistic_Vision_V3.0_VAE"),
    ("Noosphere v3.0", "digiplay/Noosphere_v3"),
    ("Beauty Fool v1.2", "digiplay/BeautyFool_v1.2VAE_pruned"),
    ("Prefix RealisticMix v1.0", "digiplay/PrefixRealisticMix_v1"),
    ("Prefix FantasyMix v1.0", "digiplay/PrefixFantasyMix_v1"),
    ("Unstable Diffusers YamerMIX v3.0", "digiplay/unstableDiffusersYamerMIX_v3"),
    ("GTA5 Artwork Diffusion", "ItsJayQz/GTA5_Artwork_Diffusion"),
    ("Open Journey", "prompthero/openjourney"),
    ("SoapMix2.5D v2.0", "digiplay/SoapMix2.5D_v2"),
    ("CoffeeMix v2.0", "digiplay/CoffeeMix_v2"),
    ("helloworld v3.0", "digiplay/helloworld_v3"),
    ("ARRealVX v1.1", "digiplay/ARRealVX1.1"),
    ("Fishmix v1.0", "digiplay/fishmix_other_v1"),
    ("DiamondCoalMix v2.0", "digiplay/DiamondCoalMix_v2_pruned_diffusers"),
    ("ISOMix v3.22", "digiplay/ISOmix_v3.22"),
    ("Pika v2", "digiplay/Pika_v2"),
    ("BluePencil v0.9b", "digiplay/bluePencil_v09b"),
    ("MeinaPastel v6", "Meina/MeinaPastel_V6"),
    ("Realistic Vision v4", "SG161222/Realistic_Vision_V4.0"),
    ("Revanimated v1.2.2", "stablediffusionapi/revanimated"),
    ("NeverEnding Dream v1.2.2", "Lykon/NeverEnding-Dream"),
    ("CetusMixCoda", "Stax124/CetusMixCoda"),
    ("NewMarsMix R11", "digiplay/NewMarsMix_R11"),
    ("Juggernaut Final", "digiplay/Juggernaut_final"),
    ("BlankCanvas v1.0", "digiplay/BlankCanvas_v1"),
    ("FumizukiMix v1.0", "digiplay/FumizukiMix_v1"),
    ("CampurSari v1.0", "digiplay/CampurSari_Gen1"),
    ("Realisian v1.0", "digiplay/Realisian_v5"),
    ("Real Epic Majic Revolution v1.0", "digiplay/RealEpicMajicRevolution_v1"),
    ("QuinceMix v2.0", "digiplay/quincemix_v2"),
    ("Counterfeit v3.0", "stablediffusionapi/counterfeit-v30"),
    ("MeinaMix v11.0", "Meina/MeinaMix_V11"),
    ("MeinaPastel V7.0", "Meina/MeinaPastel_V7"),
    ("Alter V3.0", "Meina/Alter_V3"),
    ("MeinaUnreal V5.0", "Meina/MeinaUnreal_V5"),
    ("MeinaHentai V5.0", "Meina/MeinaHentai_V5"),
    ("AnyOrangeMix Mint", "GraydientPlatformAPI/anyorange-mint"),
]

#Name / link / True = single file , False = need config.json 
vae_link ={
    "Vae ft MSE": "stabilityai/sd-vae-ft-mse",
    "Vae ft MSE original": "stabilityai/sd-vae-ft-mse-original/vae-ft-mse-840000-ema-pruned.safetensors",
    "Vae ft EMA": "stabilityai/sd-vae-ft-ema",
    "Vae ft EMA original": "stabilityai/sd-vae-ft-ema-original/vae-ft-ema-560000-ema-pruned.safetensors",
    "ClearVAE V2.1" : "digiplay/VAE/ClearVAE_V2.1.safetensors",
    "Blessed": "digiplay/VAE/blessed.vae.pt",
    "Color101VAE v1": "digiplay/VAE/color101VAE_v1.safetensors",
    "kl-f8-anime2": "digiplay/VAE/klF8Anime2VAE_klF8Anime2VAE.ckpt",
    "Mangled Merge": "digiplay/VAE/mangledMergeVAE_v10.pt",
    "Orangemix": "digiplay/VAE/orangemix.vae.pt",
    "Stable 780000": "digiplay/VAE/stable-780000.vae.pt",
    "CustomVAE Q6": "duongve/VAE/customvae_q6.safetensors",
    "Voidnoise VAE": "duongve/VAE/voidnoiseVAE_baseonR0829.safetensors",
    "Lastpiece Contrast": "duongve/VAE/lastpieceVAE_contrast.safetensors",
    "Lastpiece Brightness": "duongve/VAE/lastpieceVAE_brightness.safetensors",
    "Berry's Mix v1.0": "duongve/VAE/berrysMixVAE_v10.safetensors",
    "Async's VAE v1.0": "duongve/VAE/asyncsVAE_v10.safetensors",
    "WD-VAE v1.0": "duongve/VAE/wdVAE_v10.safetensors",
    "Nocturnal": "duongve/VAE/nocturnalVAE_.safetensors",
    "Apricots": "duongve/VAE/apricotsVAESeries_tensorQuantizerV10.safetensors",
    "Earth & Dusk v1.0": "duongve/VAE/earthDuskVAE_v10.safetensors",
    "HotaruVAE Anime v1.0": "duongve/VAE/hotaruvae_AnimeV10.safetensors",
    "HotaruVAE Real v1.0": "duongve/VAE/hotaruvae_RealV10.safetensors",
    "Consistency Decoder": "openai/consistency-decoder",
}

vae_single_file ={
    "Vae ft MSE": False,
    "Vae ft MSE original": True,
    "Vae ft EMA": False,
    "Vae ft EMA original": True,
    "ClearVAE V2.1": True,
    "Blessed": True,
    "Color101VAE v1": True,
    "kl-f8-anime2": True,
    "Mangled Merge": True,
    "Orangemix": True,
    "Stable 780000": True,
    "CustomVAE Q6": True,
    "Voidnoise VAE": True,
    "Lastpiece Contrast": True,
    "Lastpiece Brightness": True,
    "Berry's Mix v1.0": True,
    "Async's VAE v1.0": True,
    "WD-VAE v1.0": True,
    "Nocturnal": True,
    "Apricots": True,
    "Earth & Dusk v1.0": True,
    "HotaruVAE Anime v1.0": True,
    "HotaruVAE Real v1.0": True,
    "Consistency Decoder": False,
}


vae_lst = [
    "Default",
    "Vae ft MSE",
    "Vae ft MSE original",
    "Vae ft EMA",
    "Vae ft EMA original",
    "ClearVAE V2.1",
    "Blessed",
    "Color101VAE v1",
    "kl-f8-anime2",
    "Mangled Merge",
    "Orangemix",
    "Stable 780000",
    "CustomVAE Q6",
    "Voidnoise VAE",
    "Lastpiece Contrast",
    "Lastpiece Brightness",
    "Berry's Mix v1.0",
    "Async's VAE v1.0",
    "WD-VAE v1.0",
    "Nocturnal",
    "Apricots",
    "Earth & Dusk v1.0",
    "HotaruVAE Anime v1.0",
    "HotaruVAE Real v1.0",
    "Consistency Decoder",
]

keep_vram = [
    "Korakoe/AbyssOrangeMix2-HF",
    "WarriorMama777/BloodOrangeMix",
    "WarriorMama777/ElyOrangeMix",
    "JamesFlare/pastel-mix",
    "nuigurumi/basil_mix",
    "runwayml/stable-diffusion-v1-5",
    "stabilityai/stable-diffusion-2-1-base",
    "SG161222/Realistic_Vision_V1.4",
    "dreamlike-art/dreamlike-photoreal-2.0",
    "hakurei/waifu-diffusion",
    "Onodofthenorth/SD_PixelArt_SpriteSheet_Generator",
    "Linaqruf/anything-v3.0",
    "Cosk/sketchstyle-cutesexyrobutts",
    "stablediffusionapi/anything-v5",
    "gsdf/Counterfeit-V2.5",
    "stablediffusionapi/edge-of-realism",
    "claudfuen/photorealistic-fuen-v1",
    "darkstorm2150/Protogen_x5.8_Official_Release",
    "dreamlike-art/dreamlike-anime-1.0",
    "NoCrypt/SomethingV2_2",
    "SG161222/Realistic_Vision_V3.0_VAE",
    "digiplay/Noosphere_v3",
    "digiplay/BeautyFool_v1.2VAE_pruned",
    "digiplay/PrefixRealisticMix_v1",
    "digiplay/PrefixFantasyMix_v1",
    "digiplay/unstableDiffusersYamerMIX_v3",
    "ItsJayQz/GTA5_Artwork_Diffusion",
    "prompthero/openjourney",
    "digiplay/SoapMix2.5D_v2",
    "digiplay/CoffeeMix_v2",
    "digiplay/helloworld_v3",
    "digiplay/ARRealVX1.1",
    "digiplay/fishmix_other_v1",
    "digiplay/DiamondCoalMix_v2_pruned_diffusers",
    "digiplay/ISOmix_v3.22",
    "digiplay/Pika_v2",
    "digiplay/bluePencil_v09b",
    "Meina/MeinaPastel_V6",
    "SG161222/Realistic_Vision_V4.0",
    "stablediffusionapi/revanimated",
    "Lykon/NeverEnding-Dream",
    "Stax124/CetusMixCoda",
    "digiplay/NewMarsMix_R11",
    "digiplay/Juggernaut_final",
    "digiplay/BlankCanvas_v1",
    "digiplay/FumizukiMix_v1",
    "digiplay/CampurSari_Gen1",
    "digiplay/Realisian_v5",
    "digiplay/RealEpicMajicRevolution_v1",
    "stablediffusionapi/counterfeit-v30",
    "Meina/MeinaMix_V11",
    "Meina/MeinaPastel_V7",
    "Meina/Alter_V3",
    "Meina/MeinaUnreal_V5",
    "Meina/MeinaHentai_V5",
    "GraydientPlatformAPI/anyorange-mint",
]
base_name, base_model = models[0]

samplers_k_diffusion = [
    ('Euler', 'sample_euler', {}),
    ('Euler a', 'sample_euler_ancestral', {"uses_ensd": True}),
    ('LMS', 'sample_lms', {}),
    ('LCM', samplers_extra_k_diffusion.sample_lcm, {"second_order": True}),
    ('Heun', 'sample_heun', {"second_order": True}),
    ('Heun++', samplers_extra_k_diffusion.sample_heunpp2, {"second_order": True}),
    ('DDPM', samplers_extra_k_diffusion.sample_ddpm, {"second_order": True}),
    ('DPM2', 'sample_dpm_2', {'discard_next_to_last_sigma': True}),
    ('DPM2 a', 'sample_dpm_2_ancestral', {'discard_next_to_last_sigma': True, "uses_ensd": True}),
    ('DPM++ 2S a', 'sample_dpmpp_2s_ancestral', {"uses_ensd": True, "second_order": True}),
    ('DPM++ 2M', 'sample_dpmpp_2m', {}),
    ('DPM++ SDE', 'sample_dpmpp_sde', {"second_order": True, "brownian_noise": True}),
    ('DPM++ 2M SDE', 'sample_dpmpp_2m_sde', {"brownian_noise": True}),
    ('DPM++ 3M SDE', 'sample_dpmpp_3m_sde', {'discard_next_to_last_sigma': True, "brownian_noise": True}),
    ('DPM fast (img-to-img)', 'sample_dpm_fast', {"uses_ensd": True}),
    ('DPM adaptive (img-to-img)', 'sample_dpm_adaptive', {"uses_ensd": True}),
    ('DPM++ 2M SDE Heun', 'sample_dpmpp_2m_sde', {"brownian_noise": True, "solver_type": "heun"}),
    ('Restart', samplers_extra_k_diffusion.restart_sampler, {"second_order": True}),
    ('Euler Karras', 'sample_euler', {'scheduler': 'karras'}),
    ('Euler a Karras', 'sample_euler_ancestral', {'scheduler': 'karras',"uses_ensd": True}),
    ('LMS Karras', 'sample_lms', {'scheduler': 'karras'}),
    ('LCM Karras', samplers_extra_k_diffusion.sample_lcm, {'scheduler': 'karras',"second_order": True}),
    ('Heun Karras', 'sample_heun', {'scheduler': 'karras',"second_order": True}),
    ('Heun++ Karras', samplers_extra_k_diffusion.sample_heunpp2, {'scheduler': 'karras',"second_order": True}),
    ('DDPM Karras', samplers_extra_k_diffusion.sample_ddpm, {'scheduler': 'karras', "second_order": True}),
    ('DPM2 Karras', 'sample_dpm_2', {'scheduler': 'karras', 'discard_next_to_last_sigma': True, "uses_ensd": True, "second_order": True}),
    ('DPM2 a Karras', 'sample_dpm_2_ancestral', {'scheduler': 'karras', 'discard_next_to_last_sigma': True, "uses_ensd": True, "second_order": True}),
    ('DPM++ 2S a Karras', 'sample_dpmpp_2s_ancestral', {'scheduler': 'karras', "uses_ensd": True, "second_order": True}),
    ('DPM++ 2M Karras', 'sample_dpmpp_2m', {'scheduler': 'karras'}),
    ('DPM++ SDE Karras', 'sample_dpmpp_sde', {'scheduler': 'karras', "second_order": True, "brownian_noise": True}),
    ('DPM++ 2M SDE Karras', 'sample_dpmpp_2m_sde', {'scheduler': 'karras', "brownian_noise": True}),
    ('DPM++ 2M SDE Heun Karras', 'sample_dpmpp_2m_sde', {'scheduler': 'karras', "brownian_noise": True, "solver_type": "heun"}),
    ('DPM++ 3M SDE Karras', 'sample_dpmpp_3m_sde', {'scheduler': 'karras', 'discard_next_to_last_sigma': True, "brownian_noise": True}),
    ('Restart Karras', samplers_extra_k_diffusion.restart_sampler, {'scheduler': 'karras', "second_order": True}),
    ('Euler Exponential', 'sample_euler', {'scheduler': 'exponential'}),
    ('Euler a Exponential', 'sample_euler_ancestral', {'scheduler': 'exponential',"uses_ensd": True}),
    ('LMS Exponential', 'sample_lms', {'scheduler': 'exponential'}),
    ('LCM Exponential', samplers_extra_k_diffusion.sample_lcm, {'scheduler': 'exponential',"second_order": True}),
    ('Heun Exponential', 'sample_heun', {'scheduler': 'exponential',"second_order": True}),
    ('Heun++ Exponential', samplers_extra_k_diffusion.sample_heunpp2, {'scheduler': 'exponential',"second_order": True}),
    ('DDPM Exponential', samplers_extra_k_diffusion.sample_ddpm, {'scheduler': 'exponential', "second_order": True}),
    ('DPM++ 2M Exponential', 'sample_dpmpp_2m', {'scheduler': 'exponential'}),
    ('DPM++ 2M SDE Exponential', 'sample_dpmpp_2m_sde', {'scheduler': 'exponential', "brownian_noise": True}),
    ('DPM++ 2M SDE Heun Exponential', 'sample_dpmpp_2m_sde', {'scheduler': 'exponential', "brownian_noise": True, "solver_type": "heun"}),
    ('DPM++ 3M SDE Exponential', 'sample_dpmpp_3m_sde', {'scheduler': 'exponential', 'discard_next_to_last_sigma': True, "brownian_noise": True}),
    ('Restart Exponential', samplers_extra_k_diffusion.restart_sampler, {'scheduler': 'exponential', "second_order": True}),
    ('Euler Polyexponential', 'sample_euler', {'scheduler': 'polyexponential'}),
    ('Euler a Polyexponential', 'sample_euler_ancestral', {'scheduler': 'polyexponential',"uses_ensd": True}),
    ('LMS Polyexponential', 'sample_lms', {'scheduler': 'polyexponential'}),
    ('LCM Polyexponential', samplers_extra_k_diffusion.sample_lcm, {'scheduler': 'polyexponential',"second_order": True}),
    ('Heun Polyexponential', 'sample_heun', {'scheduler': 'polyexponential',"second_order": True}),
    ('Heun++ Polyexponential', samplers_extra_k_diffusion.sample_heunpp2, {'scheduler': 'polyexponential',"second_order": True}),
    ('DDPM Polyexponential', samplers_extra_k_diffusion.sample_ddpm, {'scheduler': 'polyexponential', "second_order": True}), 
    ('DPM++ 2M Polyexponential', 'sample_dpmpp_2m', {'scheduler': 'polyexponential'}),
    ('DPM++ 2M SDE Heun Polyexponential', 'sample_dpmpp_2m_sde', {'scheduler': 'polyexponential', "brownian_noise": True, "solver_type": "heun"}),
    ('DPM++ 3M SDE Polyexponential', 'sample_dpmpp_3m_sde', {'scheduler': 'polyexponential', 'discard_next_to_last_sigma': True, "brownian_noise": True}),
    ('Restart Polyexponential', samplers_extra_k_diffusion.restart_sampler, {'scheduler': 'polyexponential', "second_order": True}),
]

#Add to sigma sp which library is missing
'''class DEISMultistepScheduler_modify(DEISMultistepScheduler):
    def _convert_to_karras(self, in_sigmas: torch.FloatTensor, num_inference_steps) -> torch.FloatTensor:
        """Constructs the noise schedule of Karras et al. (2022)."""

        sigma_min: float = in_sigmas[-1].item()
        sigma_max: float = in_sigmas[0].item()

        rho = 7.0  # 7.0 is the value used in the paper
        ramp = np.linspace(0, 1, num_inference_steps)
        min_inv_rho = sigma_min ** (1 / rho)
        max_inv_rho = sigma_max ** (1 / rho)
        sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
        return sigmas

    def _sigma_to_t(self, sigma, log_sigmas):
        # get log sigma
        log_sigma = np.log(sigma)

        # get distribution
        dists = log_sigma - log_sigmas[:, np.newaxis]

        # get sigmas range
        low_idx = np.cumsum((dists >= 0), axis=0).argmax(axis=0).clip(max=log_sigmas.shape[0] - 2)
        high_idx = low_idx + 1

        low = log_sigmas[low_idx]
        high = log_sigmas[high_idx]

        # interpolate sigmas
        w = (low - log_sigma) / (low - high)
        w = np.clip(w, 0, 1)

        # transform interpolation to time range
        t = (1 - w) * low_idx + w * high_idx
        t = t.reshape(sigma.shape)
        return t'''

samplers_diffusers = [
    ('Euler a', lambda ddim_scheduler_config: EulerAncestralDiscreteScheduler.from_config(ddim_scheduler_config), {}),
    ('Euler', lambda ddim_scheduler_config: EulerDiscreteScheduler.from_config(ddim_scheduler_config), {}),
    #('EDM Euler', lambda ddim_scheduler_config: EDMEulerScheduler.from_config(ddim_scheduler_config), {}),
    ('LMS', lambda ddim_scheduler_config: LMSDiscreteScheduler.from_config(ddim_scheduler_config), {}),
    ('Heun',lambda ddim_scheduler_config: HeunDiscreteScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM2',lambda ddim_scheduler_config: KDPM2DiscreteScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM2 a',lambda ddim_scheduler_config: KDPM2AncestralDiscreteScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM++ 2S a',lambda ddim_scheduler_config: DPMSolverSinglestepScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM++ 2M',lambda ddim_scheduler_config: DPMSolverMultistepScheduler.from_config(ddim_scheduler_config), {}),
    #('EDM DPM++ 2M',lambda ddim_scheduler_config: EDMDPMSolverMultistepScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM++ SDE',lambda ddim_scheduler_config: DPMSolverSDEScheduler.from_config(ddim_scheduler_config), {}),
    ('DPM++ 2M SDE',lambda ddim_scheduler_config: DPMSolverMultistepScheduler.from_config(ddim_scheduler_config,algorithm_type="sde-dpmsolver++"), {}),
    #('EDM DPM++ 2M SDE',lambda ddim_scheduler_config: EDMDPMSolverMultistepScheduler.from_config(ddim_scheduler_config,algorithm_type="sde-dpmsolver++"), {}),
    ('DEIS',lambda ddim_scheduler_config: DEISMultistepScheduler.from_config(ddim_scheduler_config), {}),
    ('UniPC Time Uniform 1',lambda ddim_scheduler_config: UniPCMultistepScheduler.from_config(ddim_scheduler_config,solver_type = "bh1"), {}),
    ('UniPC Time Uniform 2',lambda ddim_scheduler_config: UniPCMultistepScheduler.from_config(ddim_scheduler_config,solver_type = "bh2"), {}),
    ('SA-Solver',lambda ddim_scheduler_config: SASolverScheduler.from_config(ddim_scheduler_config), {}),
    ('Euler Karras', lambda ddim_scheduler_config: EulerDiscreteScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('LMS Karras',lambda ddim_scheduler_config: LMSDiscreteScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),   
    ('Heun Karras',lambda ddim_scheduler_config: HeunDiscreteScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM2 Karras',lambda ddim_scheduler_config: KDPM2DiscreteScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM2 a Karras',lambda ddim_scheduler_config: KDPM2AncestralDiscreteScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM++ 2S a Karras',lambda ddim_scheduler_config: DPMSolverSinglestepScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM++ 2M Karras',lambda ddim_scheduler_config: DPMSolverMultistepScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM++ SDE Karras',lambda ddim_scheduler_config: DPMSolverSDEScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('DPM++ 2M SDE Karras',lambda ddim_scheduler_config: DPMSolverMultistepScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True,algorithm_type="sde-dpmsolver++"), {}),
    ('DEIS Karras',lambda ddim_scheduler_config: DEISMultistepScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
    ('UniPC Time Uniform 1 Karras',lambda ddim_scheduler_config: UniPCMultistepScheduler.from_config(ddim_scheduler_config,solver_type = "bh1",use_karras_sigmas=True), {}),
    ('UniPC Time Uniform 2 Karras',lambda ddim_scheduler_config: UniPCMultistepScheduler.from_config(ddim_scheduler_config,solver_type = "bh2",use_karras_sigmas=True), {}),
    ('SA-Solver Karras',lambda ddim_scheduler_config: SASolverScheduler.from_config(ddim_scheduler_config,use_karras_sigmas=True), {}),
]


# samplers_diffusers = [
#     ("DDIMScheduler", "diffusers.schedulers.DDIMScheduler", {})
#     ("DDPMScheduler", "diffusers.schedulers.DDPMScheduler", {})
#     ("DEISMultistepScheduler", "diffusers.schedulers.DEISMultistepScheduler", {})
# ]

start_time = time.time()
timeout = 1800

scheduler = DDIMScheduler.from_pretrained(
    base_model,
    subfolder="scheduler",
)
'''vae = AutoencoderKL.from_pretrained(
    "stabilityai/sd-vae-ft-mse", 
    torch_dtype=torch.float16
)'''

vae = AutoencoderKL.from_pretrained(base_model,
    subfolder="vae",
    #torch_dtype=torch.float16,
)
if vae is None:
    vae = AutoencoderKL.from_pretrained(
        "stabilityai/sd-vae-ft-mse", 
        #torch_dtype=torch.float16,
    )
text_encoder = CLIPTextModel.from_pretrained(
    base_model,
    subfolder="text_encoder",
    #torch_dtype=torch.float16,
)
tokenizer = CLIPTokenizer.from_pretrained(
    base_model,
    subfolder="tokenizer",
    #torch_dtype=torch.float16,
)
unet = UNet2DConditionModel.from_pretrained(
    base_model,
    subfolder="unet",
    #torch_dtype=torch.float16,
)
feature_extract = CLIPImageProcessor.from_pretrained(
    base_model,
    subfolder="feature_extractor",
)
pipe = StableDiffusionPipeline(
    text_encoder=text_encoder,
    tokenizer=tokenizer,
    unet=unet,
    vae=vae,
    scheduler=scheduler,
    feature_extractor = feature_extract,
)

if torch.cuda.is_available():
    pipe = pipe.to("cuda")

def get_model_list():
    return models

scheduler_cache ={
    base_name: scheduler
}
te_cache = {
    base_name: text_encoder
}
vae_cache = {
    base_name: vae
}
unet_cache = {
    base_name: unet
}

lora_cache = {
    base_name: LoRANetwork(text_encoder, unet)
}
tokenizer_cache ={
    base_name: tokenizer
}
feature_cache ={
    base_name: feature_extract
}
controlnetmodel_cache ={
    
}
adapter_cache ={
    
}

vae_enhance_cache ={
    
}
te_base_weight_length = text_encoder.get_input_embeddings().weight.data.shape[0]
original_prepare_for_tokenization = tokenizer.prepare_for_tokenization
current_model = base_name

def setup_controlnet(name_control,device):
    global controlnet_type,controlnetmodel_cache
    if name_control not in controlnetmodel_cache:
        model_control = ControlNetModel.from_pretrained(name_control, 
                                                        #torch_dtype=torch.float16
                                                       ).to(device)
        controlnetmodel_cache[name_control] = model_control
    return controlnetmodel_cache[name_control]

def setup_adapter(adapter_sp,device):
    global model_ip_adapter_type,adapter_cache
    if adapter_sp not in adapter_cache:
        model_control = T2IAdapter.from_pretrained(adapter_sp, 
                                                   #torch_dtype=torch.float16
                                                  ).to(device)
        adapter_cache[adapter_sp] = model_control
    return adapter_cache[adapter_sp]

def setup_vae(model,vae_used = "Default"):
    global vae_link,vae_single_file
    vae_model = None
    if vae_used == "Default":
        vae_model = AutoencoderKL.from_pretrained(model,subfolder="vae",
                                                  #torch_dtype=torch.float16
                                                 )
    elif vae_used == "Consistency Decoder":
        vae_model = ConsistencyDecoderVAE.from_pretrained(vae_link[vae_used], 
                                                          #torch_dtype=torch.float16
                                                         )
    else:
        if vae_single_file[vae_used]:
            vae_model = AutoencoderKL.from_single_file(vae_link[vae_used],
                                                       #torch_dtype=torch.float16
                                                      )
        else:
            vae_model = AutoencoderKL.from_pretrained(vae_link[vae_used],
                                                      #torch_dtype=torch.float16
                                                     )
    if vae_model is None:
        vae_model = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", 
                                                  #torch_dtype=torch.float16
                                                 )
    return vae_model



def setup_model(name,clip_skip, lora_group=None,diffuser_pipeline = False ,control_net_model = None,img_input = None,device = "cpu",mask_inpaiting = None,vae_used = "Default"):
    global current_model,vae_link,vae_single_file,models_single_file

    keys = [k[0] for k in models]
    model = models[keys.index(name)][1]
    if name not in unet_cache:
        if name not in models_single_file:
            try:
                vae_model = AutoencoderKL.from_pretrained(model,subfolder="vae"
                                                          #,torch_dtype=torch.float16
                                                         )
            except OSError:
                vae_model = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", 
                                                          #torch_dtype=torch.float16
                                                         )

            try:
                unet = UNet2DConditionModel.from_pretrained(model, subfolder="unet", 
                                                            #torch_dtype=torch.float16
                                                           )
            except OSError:
                unet = UNet2DConditionModel.from_pretrained(base_model, subfolder="unet", 
                                                            #torch_dtype=torch.float16
                                                           )

            try:
                text_encoder = CLIPTextModel.from_pretrained(model, subfolder="text_encoder", 
                                                             #torch_dtype=torch.float16
                                                            )
            except OSError:
                text_encoder = CLIPTextModel.from_pretrained(base_model, subfolder="text_encoder", 
                                                             #torch_dtype=torch.float16
                                                            )

            try:
                tokenizer = CLIPTokenizer.from_pretrained(model,subfolder="tokenizer",
                                                          #torch_dtype=torch.float16
                                                         )
            except OSError:
                tokenizer = CLIPTokenizer.from_pretrained(base_model,subfolder="tokenizer",
                                                          #torch_dtype=torch.float16
                                                         )

            try:
                scheduler = DDIMScheduler.from_pretrained(model,subfolder="scheduler")
            except OSError:
                scheduler = DDIMScheduler.from_pretrained(base_model,subfolder="scheduler")

            try:
                feature_extract = CLIPImageProcessor.from_pretrained(model,subfolder="feature_extractor")
            except OSError:
                feature_extract = CLIPImageProcessor.from_pretrained(base_model,subfolder="feature_extractor")    
        else:
            pipe_get = StableDiffusionPipeline_finetune.from_single_file(model,safety_checker= None,requires_safety_checker = False,
                                                                         #torch_dtype=torch.float16
                                                                        ).to(device)
            vae_model = pipe_get.vae
            unet = pipe_get.unet
            text_encoder = pipe_get.text_encoder
            tokenizer = pipe_get.tokenizer
            scheduler = pipe_get.scheduler
            feature_extract = pipe_get.feature_extractor if pipe_get.feature_extractor is not None else CLIPImageProcessor.from_pretrained(base_model,subfolder="feature_extractor")
            del pipe_get 

        # if vae_model is None:
        #     vae_model = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", torch_dtype=torch.float16)
        scheduler_cache[name] = scheduler
        unet_cache[name] = unet
        te_cache[name] = text_encoder
        vae_cache[name] = vae_model
        tokenizer_cache[name] = tokenizer
        feature_cache[name] = feature_extract
        #lora_cache[model] = LoRANetwork(text_encoder, unet)

    if vae_used != "Default" and vae_used not in vae_enhance_cache:
        vae_enhance_cache[vae_used] = setup_vae(model,vae_used)

    if current_model != name:
        #if current_model not in keep_vram:
            # offload current model
        unet_cache[current_model].to(device)
        te_cache[current_model].to(device)
        vae_cache[current_model].to(device)
        current_model = name

    local_te, local_unet,local_sche,local_vae,local_token,local_feature = copy.deepcopy(te_cache[name]), copy.deepcopy(unet_cache[name]),scheduler_cache[name],vae_cache[name], copy.deepcopy(tokenizer_cache[name]),feature_cache[name]
    if vae_used != "Default":
        local_vae = vae_enhance_cache[vae_used]
    if torch.cuda.is_available():
        local_unet.to("cuda")
        local_te.to("cuda")
        local_vae.to("cuda")
    #local_unet.set_attn_processor(AttnProcessor())
    #local_lora.reset()

    
    if diffuser_pipeline:
        if control_net_model is not None:
            if mask_inpaiting and img_input:
                pipe = StableDiffusionControlNetInpaintPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    controlnet = control_net_model,
                    safety_checker= None,
                    scheduler = local_sche,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
            elif img_input is not None:
                #pipe = StableDiffusionControlNetImg2ImgPipeline_finetune.from_pretrained(model,safety_checker = None,controlnet=control_net_model, torch_dtype=torch.float16).to(device)
                pipe = StableDiffusionControlNetImg2ImgPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    controlnet = control_net_model,
                    safety_checker= None,
                    scheduler = local_sche,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
            else:
                #pipe = StableDiffusionControlNetPipeline_finetune.from_pretrained(model,safety_checker = None,controlnet=control_net_model, torch_dtype=torch.float16).to(device)
                pipe = StableDiffusionControlNetPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    controlnet = control_net_model,
                    scheduler = local_sche,
                    safety_checker= None,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
        else:
            if mask_inpaiting and img_input:
                pipe = StableDiffusionInpaintPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    scheduler = local_sche,
                    safety_checker= None,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
            elif img_input is not None:
                #pipe = StableDiffusionImg2ImgPipeline_finetune.from_pretrained(model,safety_checker = None, torch_dtype=torch.float16).to(device)
                pipe = StableDiffusionImg2ImgPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    scheduler = local_sche,
                    safety_checker= None,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
            else:
                #pipe = StableDiffusionPipeline_finetune.from_pretrained(model,safety_checker = None, torch_dtype=torch.float16).to(device)
                pipe = StableDiffusionPipeline_finetune(
                    vae= local_vae,
                    text_encoder= local_te,
                    tokenizer=local_token,
                    unet=local_unet,
                    scheduler = local_sche,
                    safety_checker= None,
                    feature_extractor=local_feature,
                    requires_safety_checker = False,
                ).to(device)
    else:
        #global pipe
        #pipe.text_encoder, pipe.unet,pipe.scheduler,pipe.vae = local_te, local_unet,local_sche,local_vae
        
        pipe = StableDiffusionPipeline(
            text_encoder=local_te,
            tokenizer=local_token,
            unet=local_unet,
            vae=local_vae,
            scheduler=local_sche,
            feature_extractor=local_feature,
        ).to(device)
        

    #if lora_state is not None and lora_state != "":
    if lora_group is not None and len(lora_group) > 0:
        global lora_scale_dict
        adapter_name_lst = []
        adapter_weights_lst = []
        for name, file in lora_group.items():
            pipe.load_lora_weights(file, adapter_name = name)
            adapter_name_lst.append(name)
            adapter_weights_lst.append(lora_scale_dict[name])
        pipe.set_adapters(adapter_name_lst, adapter_weights=adapter_weights_lst)
            #pipe.fuse_lora(lora_scale=lora_scale_dict[name])
        #pipe = load_lora_control_pipeline(pipe,lora_state,lora_scale,device)
    
    pipe.unet.set_attn_processor(AttnProcessor())
    if hasattr(F, "scaled_dot_product_attention"):
        pipe.unet.set_attn_processor(AttnProcessor2_0())

    if diffuser_pipeline == False:
        pipe.setup_unet(pipe.unet)
        pipe.tokenizer.prepare_for_tokenization = local_token.prepare_for_tokenization
        #pipe.tokenizer.added_tokens_encoder = {}
        #pipe.tokenizer.added_tokens_decoder = {}
        #pipe.setup_text_encoder(clip_skip, local_te)
    '''if lora_state is not None and lora_state != "":
        local_lora.load(lora_state, lora_scale)
        local_lora.to(local_unet.device, dtype=local_unet.dtype)

    pipe.text_encoder, pipe.unet,pipe.scheduler,pipe.vae = local_te, local_unet,local_sche,local_vae
    pipe.setup_unet(local_unet)
    pipe.tokenizer.prepare_for_tokenization = local_token.prepare_for_tokenization
    pipe.tokenizer.added_tokens_encoder = {}
    pipe.tokenizer.added_tokens_decoder = {}
    pipe.setup_text_encoder(clip_skip, local_te)'''
    torch.cuda.empty_cache()
    gc.collect()
    return pipe


def error_str(error, title="Error"):
    return (
        f"""#### {title}
            {error}"""
        if error
        else ""
    )

def make_token_names(embs):
    all_tokens = []
    for name, vec in embs.items():
        tokens = [f'emb-{name}-{i}' for i in range(len(vec))]
        all_tokens.append(tokens)
    return all_tokens

def setup_tokenizer(tokenizer, embs):
    reg_match = [re.compile(fr"(?:^|(?<=\s|,)){k}(?=,|\s|$)") for k in embs.keys()]
    clip_keywords = [' '.join(s) for s in make_token_names(embs)]

    def parse_prompt(prompt: str):
        for m, v in zip(reg_match, clip_keywords):
            prompt = m.sub(v, prompt)
        return prompt

    def prepare_for_tokenization(self, text: str, is_split_into_words: bool = False, **kwargs):
        text = parse_prompt(text)
        r = original_prepare_for_tokenization(text, is_split_into_words, **kwargs)
        return r
        tokenizer.prepare_for_tokenization = prepare_for_tokenization.__get__(tokenizer, CLIPTokenizer)
    return [t for sublist in make_token_names(embs) for t in sublist]


def convert_size(size_bytes):
    if size_bytes == 0:
        return "0B"
    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
    i = int(math.floor(math.log(size_bytes, 1024)))
    p = math.pow(1024, i)
    s = round(size_bytes / p, 2)
    return "%s %s" % (s, size_name[i])

def load_lora_control_pipeline(pipeline_control,file_path,lora_scale,device):
    state_dict = load_file(file_path,device=device)

    LORA_PREFIX_UNET = 'lora_unet'
    LORA_PREFIX_TEXT_ENCODER = 'lora_te'
    alpha = lora_scale

    visited = []

    # directly update weight in diffusers model
    for key in state_dict:
    
        # it is suggested to print out the key, it usually will be something like below
        # "lora_te_text_model_encoder_layers_0_self_attn_k_proj.lora_down.weight"
    
        # as we have set the alpha beforehand, so just skip
        if '.alpha' in key or key in visited:
            continue
        
        if 'text' in key:
            layer_infos = key.split('.')[0].split(LORA_PREFIX_TEXT_ENCODER+'_')[-1].split('_')
            curr_layer = pipeline_control.text_encoder
        else:
            layer_infos = key.split('.')[0].split(LORA_PREFIX_UNET+'_')[-1].split('_')
            curr_layer = pipeline_control.unet

        # find the target layer
        temp_name = layer_infos.pop(0)
        while len(layer_infos) > -1:
            try:
                curr_layer = curr_layer.__getattr__(temp_name)
                if len(layer_infos) > 0:
                    temp_name = layer_infos.pop(0)
                elif len(layer_infos) == 0:
                    break
            except Exception:
                if len(temp_name) > 0:
                    temp_name += '_'+layer_infos.pop(0)
                else:
                    temp_name = layer_infos.pop(0)
    
        # org_forward(x) + lora_up(lora_down(x)) * multiplier
        pair_keys = []
        if 'lora_down' in key:
            pair_keys.append(key.replace('lora_down', 'lora_up'))
            pair_keys.append(key)
        else:
            pair_keys.append(key)
            pair_keys.append(key.replace('lora_up', 'lora_down'))
    
        # update weight
        if len(state_dict[pair_keys[0]].shape) == 4:
            weight_up = state_dict[pair_keys[0]].squeeze(3).squeeze(2).to(torch.float32)
            weight_down = state_dict[pair_keys[1]].squeeze(3).squeeze(2).to(torch.float32)
            curr_layer.weight.data += alpha * torch.mm(weight_up, weight_down).unsqueeze(2).unsqueeze(3)
        else:
            weight_up = state_dict[pair_keys[0]].to(torch.float32)
            weight_down = state_dict[pair_keys[1]].to(torch.float32)
            curr_layer.weight.data += alpha * torch.mm(weight_up, weight_down)
        
        # update visited list
        for item in pair_keys:
            visited.append(item)
    torch.cuda.empty_cache()
    gc.collect()
    return pipeline_control


def colorize(value, vmin=None, vmax=None, cmap='gray_r', invalid_val=-99, invalid_mask=None, background_color=(128, 128, 128, 255), gamma_corrected=False, value_transform=None):
    """Converts a depth map to a color image.

    Args:
        value (torch.Tensor, numpy.ndarry): Input depth map. Shape: (H, W) or (1, H, W) or (1, 1, H, W). All singular dimensions are squeezed
        vmin (float, optional): vmin-valued entries are mapped to start color of cmap. If None, value.min() is used. Defaults to None.
        vmax (float, optional):  vmax-valued entries are mapped to end color of cmap. If None, value.max() is used. Defaults to None.
        cmap (str, optional): matplotlib colormap to use. Defaults to 'magma_r'.
        invalid_val (int, optional): Specifies value of invalid pixels that should be colored as 'background_color'. Defaults to -99.
        invalid_mask (numpy.ndarray, optional): Boolean mask for invalid regions. Defaults to None.
        background_color (tuple[int], optional): 4-tuple RGB color to give to invalid pixels. Defaults to (128, 128, 128, 255).
        gamma_corrected (bool, optional): Apply gamma correction to colored image. Defaults to False.
        value_transform (Callable, optional): Apply transform function to valid pixels before coloring. Defaults to None.

    Returns:
        numpy.ndarray, dtype - uint8: Colored depth map. Shape: (H, W, 4)
    """
    if isinstance(value, torch.Tensor):
        value = value.detach().cpu().numpy()

    value = value.squeeze()
    if invalid_mask is None:
        invalid_mask = value == invalid_val
    mask = np.logical_not(invalid_mask)

    # normalize
    vmin = np.percentile(value[mask],2) if vmin is None else vmin
    vmax = np.percentile(value[mask],85) if vmax is None else vmax
    if vmin != vmax:
        value = (value - vmin) / (vmax - vmin)  # vmin..vmax
    else:
        # Avoid 0-division
        value = value * 0.

    # squeeze last dim if it exists
    # grey out the invalid values

    value[invalid_mask] = np.nan
    cmapper = matplotlib.cm.get_cmap(cmap)
    if value_transform:
        value = value_transform(value)
        # value = value / value.max()
    value = cmapper(value, bytes=True)  # (nxmx4)

    img = value[...]
    img[invalid_mask] = background_color

    if gamma_corrected:
        img = img / 255
        img = np.power(img, 2.2)
        img = img * 255
        img = img.astype(np.uint8)
    return img

def adapter_preprocessing(model_adapter,img_control,low_threshold_adapter = None,high_threshold_adapter=None,has_body=False,has_hand=False,has_face=False,preprocessor_adapter=None,disable_preprocessing_adapter=False):
    if disable_preprocessing_adapter == True :
        return img_control.copy()
    device = 'cpu'
    if torch.cuda.is_available():
        device = 'cuda'
    if model_adapter == 'Canny':
        img_control = np.array(img_control)
        img_control = cv2.Canny(img_control, low_threshold_adapter, high_threshold_adapter)
        img_control = Image.fromarray(img_control)
    elif model_adapter == 'Openpose':
        #model_openpose = OpenposeDetector()
        processor = OpenposeDetector.from_pretrained('lllyasviel/ControlNet').to(device)
        img_control = processor(img_control, include_body=has_body, include_hand=has_hand, include_face=has_face)
        #img_control = model_openpose(img_control, has_hand)[0]
    elif model_adapter == 'Depth':
        #model_midas = MidasDetector()
        #img_control =  model_midas(resize_image(img_control))[0]
        if preprocessor_adapter == 'DPT':
            processor = pipeline('depth-estimation')
            img_control = processor(img_control)['depth']
            img_control = np.array(img_control)
            img_control = img_control[:, :, None]
            img_control = np.concatenate([img_control, img_control, img_control], axis=2)
            img_control = Image.fromarray(img_control)
        else:
            processor = MidasDetector.from_pretrained("lllyasviel/Annotators").to(device)
            img_control = processor(img_control)
    elif model_adapter == 'Semantic Segmentation':
        img_control = preprocessing_segmentation(preprocessor_adapter,img_control)
    elif model_adapter == 'Color':
        img_control = img_control.resize((8, 8))
        img_control = img_control.resize((512, 512), resample=Image.Resampling.NEAREST)
    elif model_adapter == 'Zoedepth':
        '''processor = torch.hub.load("isl-org/ZoeDepth", "ZoeD_N", pretrained=True).to(device)
        img_control = processor.infer_pil(img_control)
        img_control = Image.fromarray(colorize(img_control)).convert('RGB')'''
        '''processor = ZoeDetector.from_pretrained("lllyasviel/Annotators").to(device)
        img_control = processor(img_control)'''
        processor = ZoeDetector.from_pretrained("valhalla/t2iadapter-aux-models", filename="zoed_nk.pth", model_type="zoedepth_nk").to(device)
        img_control = processor(img_control, gamma_corrected=True)
    else:
        active_model = False
        if model_adapter == 'Sketch':
            active_model = True
        if preprocessor_name == 'HED':
            processor = HEDdetector.from_pretrained('lllyasviel/Annotators').to(device)
        else:
            processor = PidiNetDetector.from_pretrained('lllyasviel/Annotators').to(device)
        img_control = processor(img_control,scribble=active_model)
        #img_control = np.array(img_control)
    #img = cv2.resize(img_control,(width, height))
    #img_input = img_input.resize((width, height), Image.LANCZOS)
    #img_control = img_control.resize((width, height), Image.LANCZOS)
    if model_adapter != 'Canny' and model_adapter != 'Semantic Segmentation' and model_adapter != 'Color':
        del processor
    torch.cuda.empty_cache()
    gc.collect()
    return img_control

def control_net_preprocessing(control_net_model,img_control,low_threshold = None,high_threshold=None,has_body=False,has_hand=False,has_face=False,preprocessor_name=None,disable_preprocessing=False):
    if disable_preprocessing == True or control_net_model == 'Instruct Pix2Pix':
        return img_control.copy()
    device = 'cpu'
    if torch.cuda.is_available():
        device = 'cuda'
    if control_net_model == 'Canny':
        img_control = np.array(img_control)
        img_control = cv2.Canny(img_control, low_threshold, high_threshold)
        img_control = img_control[:, :, None]
        img_control = np.concatenate([img_control, img_control, img_control], axis=2)
        img_control = Image.fromarray(img_control)
    elif control_net_model == 'Openpose':
        #model_openpose = OpenposeDetector()
        processor = OpenposeDetector.from_pretrained('lllyasviel/ControlNet').to(device)
        img_control = processor(img_control, include_body=has_body, include_hand=has_hand, include_face=has_face)
        #img_control = model_openpose(img_control, has_hand)[0]
    elif control_net_model == 'Depth':
        #model_midas = MidasDetector()
        #img_control =  model_midas(resize_image(img_control))[0]
        if preprocessor_name == 'DPT':
            processor = pipeline('depth-estimation')
            img_control = processor(img_control)['depth']
            img_control = np.array(img_control)
            img_control = img_control[:, :, None]
            img_control = np.concatenate([img_control, img_control, img_control], axis=2)
            img_control = Image.fromarray(img_control)
        else:
            processor = MidasDetector.from_pretrained("lllyasviel/Annotators").to(device)
            img_control = processor(img_control)      
    elif control_net_model == 'Lineart (anime)':
        processor = LineartAnimeDetector.from_pretrained("lllyasviel/Annotators").to(device)
        img_control = processor(img_control)
        #img_control = np.array(img_control)
    elif control_net_model == 'Lineart':
        processor = LineartDetector.from_pretrained("lllyasviel/Annotators").to(device)
        img_control = processor(img_control)
        #img_control = np.array(img_control)
    elif control_net_model == 'MLSD':
        processor = MLSDdetector.from_pretrained("lllyasviel/ControlNet").to(device)
        img_control = processor(img_control)
        #img_control = np.array(img_control)
    elif control_net_model == 'Semantic Segmentation':
        img_control = preprocessing_segmentation(preprocessor_name,img_control)
    elif control_net_model == 'Normal Map':
        processor = NormalBaeDetector.from_pretrained("lllyasviel/Annotators").to(device)
        img_control = processor(img_control)
    elif control_net_model == 'Shuffle':
        processor = ContentShuffleDetector()
        img_control = processor(img_control)
    else:
        active_model = False
        if control_net_model == 'Scribble':
            active_model = True
        if preprocessor_name == 'HED':
            processor = HEDdetector.from_pretrained('lllyasviel/Annotators').to(device)
        else:
            processor = PidiNetDetector.from_pretrained('lllyasviel/Annotators').to(device)
        img_control = processor(img_control,scribble=active_model)
        #img_control = np.array(img_control)
    #img = cv2.resize(img_control,(width, height))
    #img_input = img_input.resize((width, height), Image.LANCZOS)
    #img_control = img_control.resize((width, height), Image.LANCZOS)
    if control_net_model != 'Canny' and control_net_model != 'Semantic Segmentation':
        del processor
    torch.cuda.empty_cache()
    gc.collect()
    return img_control

def add_embedding(pipe_model,embs):
    tokenizer, text_encoder = pipe_model.tokenizer, pipe_model.text_encoder
    if embs is not None and len(embs) > 0:
        ti_embs = {}
        for name, file in embs.items():
            if str(file).endswith(".pt"):
                loaded_learned_embeds = torch.load(file, map_location="cpu")
            else:
                loaded_learned_embeds = load_file(file, device="cpu")
            loaded_learned_embeds = loaded_learned_embeds["string_to_param"]["*"] if "string_to_param" in loaded_learned_embeds else loaded_learned_embeds
            if isinstance(loaded_learned_embeds, dict):
                #loaded_learned_embeds = list(loaded_learned_embeds.values())[-1]
                ti_embs.update(loaded_learned_embeds)
            else:
                ti_embs[name] = loaded_learned_embeds

        if len(ti_embs) > 0:
            '''for key, value in ti_embs.items():
                if isinstance(value, dict):
                    ti_embs.pop(key)
                    ti_embs.update(value)'''
            tokens = setup_tokenizer(tokenizer, ti_embs)
            added_tokens = tokenizer.add_tokens(tokens)
            delta_weight = torch.cat([val for val in ti_embs.values()], dim=0)

            assert added_tokens == delta_weight.shape[0]
            text_encoder.resize_token_embeddings(len(tokenizer))
            token_embeds = text_encoder.get_input_embeddings().weight.data
            token_embeds[-delta_weight.shape[0]:] = delta_weight
    torch.cuda.empty_cache()
    gc.collect()
    return pipe_model

def add_embedding_with_diffusers(pipe,embs):
    if embs is not None and len(embs) > 0:
        for name, file in embs.items():
            pipe.load_textual_inversion(file)
    torch.cuda.empty_cache()
    gc.collect()
    return pipe


def mask_region_apply_ip_adapter(mask,invert_ip_adapter_mask_mode):
    if mask is None:
        return None
    #define black is region masked
    if not isinstance(mask,List):
        mask = [mask]
    if len(mask) == 0:
        return None
    if invert_ip_adapter_mask_mode:
        mask = [ImageOps.invert(i).convert('RGB') for i in mask]
    processor = IPAdapterMaskProcessor()
    masks = processor.preprocess(mask)
    '''mask = mask.resize((width, height), Image.BICUBIC)
    mask = np.array(mask).astype(np.float32) / 255.0
    #If the region is black apply ( 0 = black)
    mask = np.expand_dims(np.where(mask==0, 1,0)[:, :, 0], axis=0)
    if mask.ndim == 3:
        mask = mask[..., None]

    mask = torch.from_numpy(mask.transpose(0, 3, 1, 2))
    return mask[0]'''
    return masks

def ip_adapter_face_id_embedding(lst_img_face_id_embed,device,dtype,guidance_scale,plus_faceid = False):
    ref_images_embeds = []
    ref_unc_images_embeds = []
    ip_adapter_images = []
    app = FaceAnalysis(name="buffalo_l", providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
    app.prepare(ctx_id=0, det_size=(640, 640))
    if not isinstance(lst_img_face_id_embed,list):
        lst_img_face_id_embed = [lst_img_face_id_embed]
    for im in lst_img_face_id_embed:
        #im = load_image(im)
        image = cv2.cvtColor(np.asarray(im), cv2.COLOR_BGR2RGB)
        faces = app.get(image) #faces is a list
        if len(faces) == 0:
            raise ValueError(
                "Can not find any faces in the image."
            )
        if plus_faceid:
            ip_adapter_images.append(face_align.norm_crop(image, landmark=faces[0].kps, image_size=224)) #For plus faceid
        image = torch.from_numpy(faces[0].normed_embedding)
        image_embeds = image.unsqueeze(0)
        uncond_image_embeds = torch.zeros_like(image_embeds)
        ref_images_embeds.append(image_embeds)
        ref_unc_images_embeds.append(uncond_image_embeds)
    ref_images_embeds = torch.stack(ref_images_embeds, dim=0)
    if guidance_scale > 1 :
        ref_unc_images_embeds = torch.stack(ref_unc_images_embeds, dim=0)
        single_image_embeds = torch.cat([ref_unc_images_embeds, ref_images_embeds], dim=0).to(device,dtype=dtype)
    else:
        single_image_embeds = ref_images_embeds.to(device,dtype=dtype)
    return single_image_embeds,ip_adapter_images


lst_control = []
lst_adapter =[]
lst_ip_adapter = []
current_number_ip_adapter = 0
current_number_control = 0
current_number_adapter = 0
def inference(
    prompt,
    guidance,
    steps,
    width=512,
    height=512,
    clip_skip =2,
    seed=0,
    neg_prompt="",
    state=None,
    img_input=None,
    i2i_scale=0.5,
    hr_enabled=False,
    hr_method="Latent",
    hr_scale=1.5,
    hr_denoise=0.8,
    sampler="DPM++ 2M Karras",
    embs=None,
    model=None,
    lora_group = None,
    #lora_state=None,
    #lora_scale=None,
    formula_setting = None,
    controlnet_enabled = False,
    control_net_model = None,
    low_threshold = None,
    high_threshold = None,
    has_body = False,
    has_hand = False,
    has_face = False,
    img_control = None,
    image_condition = None,
    controlnet_scale = 0,
    preprocessor_name = None,
    diffuser_pipeline = False,
    sampler_hires="DPM++ 2M Karras",
    latent_processing = 0,
    control_guidance_start = 0.0,
    control_guidance_end = 1.0,
    multi_controlnet = False,
    disable_preprocessing = False,
    region_condition = False,
    hr_process_enabled = False,
    ip_adapter = False,
    model_ip_adapter = None,
    inf_adapt_image = None,
    inf_adapt_image_strength = 1.0,
    hr_region_condition = False,
    adapter_enabled = False,
    model_adapter = None,
    low_threshold_adapter = None,
    high_threshold_adapter = None,
    has_body_openpose_adapter = False,
    has_hand_openpose_adapter = False,
    has_face_openpose_adapter = False,
    adapter_img = None,
    image_condition_adapter = None,
    preprocessor_adapter = None,
    adapter_conditioning_scale = 0,
    adapter_conditioning_factor = None,
    multi_adapter = False,
    disable_preprocessing_adapter = False,
    ip_adapter_multi = False,
    guidance_rescale = 0,
    inf_control_adapt_image = None,
    long_encode = 0,
    inpaiting_mode = False,
    invert_mask_mode = False,
    mask_upload = None,
    inf_image_inpaiting = None,
    invert_ip_adapter_mask_mode = True,
    vae_used = "Default",
):
    global formula,controlnet_type,lst_control,lst_adapter,model_ip_adapter_type,adapter_type,lst_ip_adapter,current_number_ip_adapter,encoding_type
    img_control_input = None
    device = "cpu"
    if torch.cuda.is_available():
        device = "cuda"
    if region_condition == False:
        state = None

    mask_inpaiting = None
    if inpaiting_mode and isinstance(inf_image_inpaiting,dict):
        mask_inpaiting =  inf_image_inpaiting["mask"]
        img_input = inf_image_inpaiting["image"]
        diff = ImageChops.difference(mask_inpaiting, img_input)
        if diff.getbbox() is None:
            mask_inpaiting = None
    if inpaiting_mode and mask_upload:
        mask_inpaiting = mask_upload
    if mask_inpaiting and invert_mask_mode:
        mask_inpaiting = ImageOps.invert(mask_inpaiting).convert('RGB')
    
    if adapter_enabled:
        if len(lst_adapter) > 0 and multi_adapter:
            adapter_img = []
            model_adapter = []
            adapter_conditioning_scale = []
            adapter_conditioning_factor = []
            for i in range( len(lst_adapter)):
                setting_processing = list(lst_adapter[i].items())
                setting_processing = setting_processing[:-2]
                setting_processing = dict(setting_processing)
                image_sp_adapter = adapter_preprocessing(**setting_processing)
                adapter_img.append(image_sp_adapter)
                adapter_sp = adapter_type[lst_adapter[i]["model_adapter"]]
                model_adapter.append(setup_adapter(adapter_sp,device))
                adapter_conditioning_scale.append(float(lst_adapter[i]["adapter_conditioning_scale"]))
                adapter_conditioning_factor.append(float(lst_adapter[i]["adapter_conditioning_factor"]))
            adapter_conditioning_factor = adapter_conditioning_factor[-1]
            torch.cuda.empty_cache()
            gc.collect()
        elif adapter_img is not None and multi_adapter ==False:
            adapter_img = adapter_preprocessing(model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,disable_preprocessing_adapter)
            model_adapter = adapter_type[model_adapter]
            adapter_conditioning_scale = float(adapter_conditioning_scale)
            adapter_conditioning_factor = float(adapter_conditioning_factor)
            torch.cuda.empty_cache()
            gc.collect()
            model_adapter=setup_adapter(model_adapter,device)
            torch.cuda.empty_cache()
            gc.collect()
        else:
            model_adapter = None 
            adapter_img = None
    else:
        model_adapter = None 
        adapter_img = None


    if controlnet_enabled:
        if len(lst_control) > 0 and multi_controlnet:
            img_control = []
            control_net_model = []
            controlnet_scale = []
            control_guidance_start = []
            control_guidance_end = []
            for i in range( len(lst_control)):
                setting_processing = list(lst_control[i].items())
                setting_processing = setting_processing[:-3]
                setting_processing = dict(setting_processing)
                image_sp_control = control_net_preprocessing(**setting_processing)
                img_control.append(image_sp_control)
                conrol_net_sp = controlnet_type[lst_control[i]["control_net_model"]]
                control_net_model.append(setup_controlnet(conrol_net_sp,device))
                controlnet_scale.append(float(lst_control[i]["controlnet_scale"]))
                control_guidance_start.append(float(lst_control[i]["control_guidance_start"]))
                control_guidance_end.append(float(lst_control[i]["control_guidance_end"]))
            torch.cuda.empty_cache()
            gc.collect()
        elif img_control is not None and multi_controlnet ==False:
            img_control = control_net_preprocessing(control_net_model,img_control,low_threshold,high_threshold,has_body,has_hand,has_face,preprocessor_name,disable_preprocessing)
            control_net_model = controlnet_type[control_net_model]
            controlnet_scale = float(controlnet_scale)
            control_guidance_start = float(control_guidance_start)
            control_guidance_end = float(control_guidance_end)
            torch.cuda.empty_cache()
            gc.collect()
            control_net_model=setup_controlnet(control_net_model,device)
            torch.cuda.empty_cache()
            gc.collect()
        else:
            control_net_model = None 
            img_control = None
    else:
        control_net_model = None 
        img_control = None
    keys_f = [k[0] for k in formula]
    formula_setting = formula[keys_f.index(formula_setting)][1]
    if seed is None or seed < 0:
        seed = random.randint(0, sys.maxsize)

    #lora_state = lora_dict[lora_state]
    pipe = setup_model(model,clip_skip, lora_group,diffuser_pipeline,control_net_model,img_input,device,mask_inpaiting,vae_used)
    generator = torch.Generator(device).manual_seed(int(seed))
    if formula_setting == 0:
        weight_func = lambda w, sigma, qk: w * sigma * qk.std()
    elif formula_setting == 1:
        weight_func = lambda w, sigma, qk: w * math.log(1 + sigma) * qk.max()
    elif formula_setting == 2:
        weight_func = lambda w, sigma, qk: w * math.log(1 + sigma) * qk.std()
    else:
        weight_func = lambda w, sigma, qk: w * math.log(1 + sigma**2) * qk.std()
    start_time = time.time()

    sampler_name, sampler_opt = None, None
    '''for label, funcname, options in samplers_k_diffusion:
        if label == sampler_hires:
            sampler_name_hires, sampler_opt_hires = funcname, options'''

    #add_Textual Inversion or text embeddings
    pipe = add_embedding(pipe,embs)
    width_resize_mask_ipadapter = width
    height_resize_mask_ipadapter = height
    if img_input is not None:
        width_resize_mask_ipadapter = img_input.width
        height_resize_mask_ipadapter = img_input.height    
    setup_model_t2i_adapter(pipe,model_adapter)
    cross_attention_kwargs = {}

    #Get type encoding
    long_encode = encoding_type[long_encode]
    ip_adapter_image_embeds = None
    faceid_plus_v2 = False
    #clip_embeds = None #Support for faceid_plus

    if ip_adapter == True:
        #inf_adapt_image = None
        ip_adapter_images_faceid_plus = []
        if ip_adapter_multi and len(lst_ip_adapter) > 0:

            ip_adapter_image_lst =[]
            model_ip_adapter_lst = []
            scale_ip_adapter_lst = []
            region_aplly_lst = []

            ip_adapter_image_vitg_lst =[]
            model_ip_adapter_vitg_lst = []
            scale_ip_adapter_vitg_lst = []
            region_aplly_vitg_lst = []

            ip_adapter_faceid_image_lst =[]
            model_ip_adapter_faceid_lst = []
            scale_ip_adapter_faceid_lst = []
            region_aplly_lst_faceid = []

            ip_adapter_faceid_plus_image_lst =[]
            model_ip_adapter_faceid_plus_lst = []
            scale_ip_adapter_faceid_plus_lst = []
            region_aplly_lst_faceid_plus = []

            #Support not marks
            img_full_black = Image.new('RGB', (width, height), (0, 0, 0))
            img_full_white = Image.new('RGB', (width, height), (255, 255, 255))

            for i in lst_ip_adapter:
                if 'VIT-G' in i["model"]:
                    ip_adapter_image_vitg_lst.append(i["image"])
                    model_ip_adapter_vitg_lst.append(model_ip_adapter_type[i["model"]])
                    scale_ip_adapter_vitg_lst.append(float(i["scale"]))
                    if i["region_apply"] is not None:
                        region_aplly_vitg_lst.append(i["region_apply"])
                    else:
                        if invert_ip_adapter_mask_mode:
                            region_aplly_vitg_lst.append(img_full_black)
                        else:
                            region_aplly_vitg_lst.append(img_full_white)
                elif 'FaceID' not in i["model"]:
                    ip_adapter_image_lst.append(i["image"])
                    model_ip_adapter_lst.append(model_ip_adapter_type[i["model"]])
                    scale_ip_adapter_lst.append(float(i["scale"]))
                    if i["region_apply"] is not None:
                        region_aplly_lst.append(i["region_apply"])
                    else:
                        if invert_ip_adapter_mask_mode:
                            region_aplly_lst.append(img_full_black)
                        else:
                            region_aplly_lst.append(img_full_white)
                elif 'Plus FaceID' in i["model"]:
                    if 'Plus FaceIDv2' in i["model"]:
                        faceid_plus_v2 = True
                    ip_adapter_faceid_plus_image_lst.append(i["image"])
                    model_ip_adapter_faceid_plus_lst.append(model_ip_adapter_type[i["model"]])
                    scale_ip_adapter_faceid_plus_lst.append(float(i["scale"]))
                    if i["region_apply"] is not None:
                        region_aplly_lst_faceid_plus.append(i["region_apply"])
                    else:
                        if invert_ip_adapter_mask_mode:
                            region_aplly_lst_faceid_plus.append(img_full_black)
                        else:
                            region_aplly_lst_faceid_plus.append(img_full_white)
                else:
                    ip_adapter_faceid_image_lst.append(i["image"])
                    model_ip_adapter_faceid_lst.append(model_ip_adapter_type[i["model"]])
                    scale_ip_adapter_faceid_lst.append(float(i["scale"]))
                    if i["region_apply"] is not None:
                        region_aplly_lst_faceid.append(i["region_apply"])
                    else:
                        if invert_ip_adapter_mask_mode:
                            region_aplly_lst_faceid.append(img_full_black)
                        else:
                            region_aplly_lst_faceid.append(img_full_white)

            #Concat faceid and ipadapter
            none_img_encoder = False
            # if len(model_ip_adapter_lst) == 0:
            #     only_face_id = 1

            if len(ip_adapter_faceid_image_lst) > 0 or len(ip_adapter_image_vitg_lst) > 0 or len(ip_adapter_faceid_plus_image_lst) > 0:
                #Image_encode vit-H
                ip_adapter_embeds = []
                ip_adapter_vitg_embeds = []
                ip_adapter_image_embeds_faceid = []
                ip_adapter_image_embeds_faceid_plus = []
                if len(model_ip_adapter_lst) > 0:
                    pipe.load_ip_adapter("h94/IP-Adapter", subfolder="models", weight_name=model_ip_adapter_lst)
                    pipe.set_ip_adapter_scale(scale_ip_adapter_lst)
                    ip_adapter_embeds = pipe.prepare_ip_adapter_image_embeds(ip_adapter_image_lst,None,device,1, guidance>1)
                    pipe.unload_ip_adapter()

                if len(ip_adapter_faceid_image_lst) > 0:
                    ip_adapter_image_embeds_faceid,_ = ip_adapter_face_id_embedding(ip_adapter_faceid_image_lst,device,pipe.unet.dtype,guidance,False)
                    ip_adapter_image_embeds_faceid = [ip_adapter_image_embeds_faceid]
                if len(ip_adapter_faceid_plus_image_lst) >0:
                    ip_adapter_image_embeds_faceid_plus,ip_adapter_images_faceid_plus = ip_adapter_face_id_embedding(ip_adapter_faceid_plus_image_lst,device,pipe.unet.dtype,guidance,True)
                    ip_adapter_image_embeds_faceid_plus = [ip_adapter_image_embeds_faceid_plus]
                #Image encoder vit-G
                if len(ip_adapter_image_vitg_lst) > 0:
                    pipe.load_ip_adapter("h94/IP-Adapter", subfolder="models", weight_name=model_ip_adapter_vitg_lst,image_encoder_folder=None)
                    pipe.set_ip_adapter_scale(scale_ip_adapter_vitg_lst)
                    pipe.image_encoder = CLIPVisionModelWithProjection.from_pretrained(
                        "h94/IP-Adapter", subfolder="sdxl_models/image_encoder",
                    ).to(device, dtype=pipe.unet.dtype)
                    ip_adapter_vitg_embeds = pipe.prepare_ip_adapter_image_embeds(ip_adapter_image_vitg_lst,None,device,1, guidance>1)
                    pipe.unload_ip_adapter()

                ip_adapter_image_embeds = ip_adapter_embeds + ip_adapter_image_embeds_faceid + ip_adapter_vitg_embeds + ip_adapter_image_embeds_faceid_plus

                inf_adapt_image = None
                none_img_encoder = True
                if not isinstance(ip_adapter_image_embeds, list):
                    ip_adapter_image_embeds = [ip_adapter_image_embeds]
            else:
                inf_adapt_image = ip_adapter_image_lst
                ip_adapter_image_embeds = None

            region_aplly_lst = region_aplly_lst + region_aplly_lst_faceid + region_aplly_vitg_lst + region_aplly_lst_faceid_plus
            load_model = ["h94/IP-Adapter"]*len(model_ip_adapter_lst) + ["h94/IP-Adapter-FaceID"]*len(model_ip_adapter_faceid_lst) + ["h94/IP-Adapter"]*len(model_ip_adapter_vitg_lst) + ["h94/IP-Adapter-FaceID"]*len(model_ip_adapter_faceid_plus_lst)
            subfolder = ["models"]*len(model_ip_adapter_lst) + [None]*len(model_ip_adapter_faceid_lst) + ["models"] * len(model_ip_adapter_vitg_lst) + [None]*len(model_ip_adapter_faceid_plus_lst)
            model_ip_adapter_lst = model_ip_adapter_lst + model_ip_adapter_faceid_lst + model_ip_adapter_vitg_lst + model_ip_adapter_faceid_plus_lst
            scale_ip_adapter_lst = scale_ip_adapter_lst + scale_ip_adapter_faceid_lst + scale_ip_adapter_vitg_lst + scale_ip_adapter_faceid_plus_lst

            clip_embeds = None
            if len(ip_adapter_images_faceid_plus) > 0:
                pipe.load_ip_adapter("h94/IP-Adapter-FaceID", subfolder=None, weight_name=model_ip_adapter_faceid_plus_lst,image_encoder_folder=None)
                pipe.image_encoder = CLIPVisionModelWithProjection.from_pretrained(
                    "laion/CLIP-ViT-H-14-laion2B-s32B-b79K"
                ).to(device, dtype=pipe.unet.dtype)
                # Extract CLIP embeddings
                clip_embeds = pipe.prepare_ip_adapter_image_embeds([ip_adapter_images_faceid_plus], None, device, 1, guidance>1)[0] #num_images = 1
                pipe.unload_ip_adapter()

            if none_img_encoder:
                pipe.load_ip_adapter(load_model, subfolder=subfolder, weight_name=model_ip_adapter_lst,image_encoder_folder=None)
            else:
                pipe.load_ip_adapter(load_model, subfolder=subfolder, weight_name=model_ip_adapter_lst)
            pipe.set_ip_adapter_scale(scale_ip_adapter_lst)

            if len(ip_adapter_images_faceid_plus) > 0:
                pipe.image_encoder = CLIPVisionModelWithProjection.from_pretrained(
                    "laion/CLIP-ViT-H-14-laion2B-s32B-b79K"
                ).to(device, dtype=pipe.unet.dtype)

                # Set CLIP embeddings as class parameter
                pipe.unet.encoder_hid_proj.image_projection_layers[0].clip_embeds = clip_embeds.to(dtype=pipe.unet.dtype)
                pipe.unet.encoder_hid_proj.image_projection_layers[0].shortcut = faceid_plus_v2

            cross_attention_kwargs = {"ip_adapter_masks":mask_region_apply_ip_adapter(region_aplly_lst,invert_ip_adapter_mask_mode)}
        elif inf_adapt_image is not None and ip_adapter_multi == False:
            if 'VIT-G' in model_ip_adapter:
                model_ip_adapter = model_ip_adapter_type[model_ip_adapter]
                pipe.load_ip_adapter("h94/IP-Adapter", subfolder="models", weight_name=model_ip_adapter,image_encoder_folder=None)
                pipe.set_ip_adapter_scale(float(inf_adapt_image_strength))
                pipe.image_encoder = CLIPVisionModelWithProjection.from_pretrained(
                    "h94/IP-Adapter", subfolder="sdxl_models/image_encoder",
                ).to(device, dtype=pipe.unet.dtype)
                cross_attention_kwargs = {"ip_adapter_masks":mask_region_apply_ip_adapter(inf_control_adapt_image,invert_ip_adapter_mask_mode)}
            elif 'FaceID' not in model_ip_adapter:
                model_ip_adapter = model_ip_adapter_type[model_ip_adapter]
                pipe.load_ip_adapter("h94/IP-Adapter", subfolder="models", weight_name=model_ip_adapter)
                pipe.set_ip_adapter_scale(float(inf_adapt_image_strength))
                cross_attention_kwargs = {"ip_adapter_masks":mask_region_apply_ip_adapter(inf_control_adapt_image,invert_ip_adapter_mask_mode)}
            elif 'Plus FaceID' in model_ip_adapter:
                if 'Plus FaceIDv2' in model_ip_adapter:
                    faceid_plus_v2 = True
                model_ip_adapter = model_ip_adapter_type[model_ip_adapter]
                pipe.load_ip_adapter("h94/IP-Adapter-FaceID", subfolder=None, weight_name=model_ip_adapter,image_encoder_folder=None)
                pipe.set_ip_adapter_scale(float(inf_adapt_image_strength))
                ip_adapter_image_embeds,ip_adapter_images_faceid_plus = ip_adapter_face_id_embedding([inf_adapt_image],device,pipe.unet.dtype,guidance,True)
                if not isinstance(ip_adapter_image_embeds, list):
                    ip_adapter_image_embeds = [ip_adapter_image_embeds]
                cross_attention_kwargs = {"ip_adapter_masks":mask_region_apply_ip_adapter(inf_control_adapt_image,invert_ip_adapter_mask_mode)}
                if len(ip_adapter_images_faceid_plus) > 0:
                    pipe.image_encoder = CLIPVisionModelWithProjection.from_pretrained(
                            "laion/CLIP-ViT-H-14-laion2B-s32B-b79K"
                    ).to(device, dtype=pipe.unet.dtype)
                    # Extract CLIP embeddings
                    clip_embeds = pipe.prepare_ip_adapter_image_embeds([ip_adapter_images_faceid_plus], None, device, 1, guidance>1)[0] #num_images = 1

                    # Set CLIP embeddings as class parameter
                    pipe.unet.encoder_hid_proj.image_projection_layers[0].clip_embeds = clip_embeds.to(dtype=pipe.unet.dtype)
                    pipe.unet.encoder_hid_proj.image_projection_layers[0].shortcut = faceid_plus_v2
                    #pipe.unload_ip_adapter()
                inf_adapt_image = None
            else:
                model_ip_adapter = model_ip_adapter_type[model_ip_adapter]
                pipe.load_ip_adapter("h94/IP-Adapter-FaceID", subfolder=None, weight_name=model_ip_adapter,image_encoder_folder=None)
                pipe.set_ip_adapter_scale(float(inf_adapt_image_strength))
                ip_adapter_image_embeds,_ = ip_adapter_face_id_embedding([inf_adapt_image],device,pipe.unet.dtype,guidance,False)
                if not isinstance(ip_adapter_image_embeds, list):
                    ip_adapter_image_embeds = [ip_adapter_image_embeds]
                cross_attention_kwargs = {"ip_adapter_masks":mask_region_apply_ip_adapter(inf_control_adapt_image,invert_ip_adapter_mask_mode)}
                inf_adapt_image = None
        else:
            inf_adapt_image = None
    else:
        inf_adapt_image = None

    if diffuser_pipeline:
        for label, funcname, options in samplers_diffusers:
            if label == sampler:
                sampler_name, sampler_opt = funcname, options
            if label == sampler_hires:
                sampler_name_hires, sampler_opt_hires = funcname, options
        pipe.scheduler = sampler_name(pipe.scheduler.config)
        output_type = 'pil'
        if hr_enabled and img_input is None:
            output_type = 'latent'
        #Need to reduce clip_skip by 1 because when using clip_skip the value will increase in the encode_prompt 
        config = {
            "prompt": prompt,
            "negative_prompt": neg_prompt,
            "num_inference_steps": int(steps),
            "guidance_scale": guidance,
            "generator": generator,
            "region_map_state": state,
            #"region_map_attn_weight": g_strength,
            "latent_processing": latent_processing,
            'weight_func':weight_func,
            'clip_skip' :int(clip_skip),
            "output_type" : output_type,
            "image_t2i_adapter":adapter_img,
            "adapter_conditioning_scale":adapter_conditioning_scale,
            "adapter_conditioning_factor":adapter_conditioning_factor,
            "guidance_rescale":guidance_rescale,
            "long_encode" : int(long_encode),
            "ip_adapter_image_embeds": ip_adapter_image_embeds,
            "cross_attention_kwargs": cross_attention_kwargs
        }
        '''if ip_adapter == False:
            inf_adapt_image = None'''
        
        if mask_inpaiting and img_input and inpaiting_mode and control_net_model:
            result = pipe(mask_image = mask_inpaiting,width=img_input.width,height=img_input.height, controlnet_conditioning_scale = controlnet_scale,inf_adapt_image=inf_adapt_image,image =img_input , control_image=img_control,strength =  i2i_scale,control_guidance_start=control_guidance_start,control_guidance_end=control_guidance_end,**config)
        elif control_net_model is not None and img_input is not None:
            result = pipe(controlnet_conditioning_scale = controlnet_scale,inf_adapt_image=inf_adapt_image,image =img_input , control_image=img_control,strength =  i2i_scale,control_guidance_start=control_guidance_start,control_guidance_end=control_guidance_end,**config)
        elif control_net_model is not None:
            result = pipe(width = width,height = height,controlnet_conditioning_scale = controlnet_scale, image=img_control,control_guidance_start=control_guidance_start,control_guidance_end=control_guidance_end,ip_adapter_image=inf_adapt_image,**config)
        elif mask_inpaiting and img_input and inpaiting_mode:
            result = pipe(image =img_input,ip_adapter_image=inf_adapt_image,mask_image = mask_inpaiting,strength=i2i_scale,width=img_input.width,height=img_input.height,**config)
        elif img_input is not None:
            result = pipe(image =img_input,strength =  i2i_scale,ip_adapter_image=inf_adapt_image,**config)
        else:
            result = pipe(height = height, width = width,ip_adapter_image=inf_adapt_image,**config)            
        if hr_enabled and img_input is None:
            del pipe
            torch.cuda.empty_cache()
            gc.collect()
            pipe = setup_model(model,clip_skip, lora_group,diffuser_pipeline,control_net_model,True,device,vae_used)
            #add_Textual Inversion or text embeddings
            pipe = add_embedding(pipe,embs)
            pipe.scheduler = sampler_name_hires(pipe.scheduler.config)
            vae_scale_factor = 2 ** (len(pipe.vae.config.block_out_channels) - 1)
            target_height = int(height * upscale_x // vae_scale_factor  )* 8
            target_width = int(width * upscale_x // vae_scale_factor)*8
            latents = result[-1].unsqueeze(0)
            #print(latents.shape)
            latents = torch.nn.functional.interpolate(
                latents,
                size=(
                    int(target_height // vae_scale_factor),
                    int(target_width // vae_scale_factor),
                ),
                mode=latent_upscale_modes[hr_method]["upscale_method"],
                antialias=latent_upscale_modes[hr_method]["upscale_antialias"],
            )
                
            config = {
                "prompt": prompt,
                "negative_prompt": neg_prompt,
                "num_inference_steps": int(steps),
                "guidance_scale": guidance,
                "generator": generator,
                "region_map_state": state,
                #"region_map_attn_weight": g_strength,
                "latent_processing": hr_process_enabled,
                'weight_func':weight_func,
                'clip_skip' :int(clip_skip),
                "image_t2i_adapter":adapter_img,
                "adapter_conditioning_scale":adapter_conditioning_scale,
                "adapter_conditioning_factor":adapter_conditioning_factor,
                "guidance_rescale":guidance_rescale,
                "long_encode" : int(long_encode),
                "ip_adapter_image_embeds": ip_adapter_image_embeds,
                "cross_attention_kwargs":cross_attention_kwargs,
            }
            if control_net_model is not None:
                upscale_result = pipe(width=int(target_width),height=int(target_height),controlnet_conditioning_scale = controlnet_scale,image = latents, control_image=img_control,strength = hr_denoise,control_guidance_start=control_guidance_start,control_guidance_end=control_guidance_end,**config)
            else:
                upscale_result = pipe(width=int(target_width),height=int(target_height),image = latents,strength = hr_denoise,**config)
            #print(type(upscale_result[-1]))
            #print(upscale_result)
            result = result[:-1] + upscale_result
    else:
        for label, funcname, options in samplers_k_diffusion:
            if label == sampler:
                sampler_name, sampler_opt = funcname, options
            if label == sampler_hires:
                sampler_name_hires, sampler_opt_hires = funcname, options
        config = {
            "negative_prompt": neg_prompt,
            "num_inference_steps": int(steps),
            "guidance_scale": guidance,
            "generator": generator,
            "sampler_name": sampler_name,
            "sampler_opt": sampler_opt,
            "region_map_state": state,
            #"region_map_attn_weight": g_strength,
            "start_time": start_time,
            "timeout": timeout,
            "latent_processing": latent_processing,
            'weight_func':weight_func,
            'seed': int(seed),
            'sampler_name_hires': sampler_name_hires,
            'sampler_opt_hires': sampler_opt_hires,
            "latent_upscale_processing": hr_process_enabled,
            "ip_adapter_image":inf_adapt_image,
            "controlnet_conditioning_scale":controlnet_scale,
            "control_img": img_control,
            "control_guidance_start":control_guidance_start,
            "control_guidance_end":control_guidance_end,
            "image_t2i_adapter":adapter_img,
            "adapter_conditioning_scale":adapter_conditioning_scale,
            "adapter_conditioning_factor":adapter_conditioning_factor,
            "guidance_rescale":guidance_rescale,
            'clip_skip' :int(clip_skip),
            "long_encode" : int(long_encode),
            "ip_adapter_image_embeds": ip_adapter_image_embeds,
            "cross_attention_kwargs":cross_attention_kwargs,
        }
        #if control_net_model is not None:
        pipe.setup_controlnet(control_net_model)
        if mask_inpaiting and img_input and inpaiting_mode:
            result = pipe.inpaiting(prompt, image=img_input,mask_image = mask_inpaiting,strength=i2i_scale,width=img_input.width,height=img_input.height, **config)
        elif img_input is not None:
            result = pipe.img2img(prompt, image=img_input, strength=i2i_scale,width=img_input.width,height=img_input.height, **config)
        elif hr_enabled:
            result = pipe.txt2img(
                prompt,
                width=width,
                height=height,
                upscale=True,
                upscale_x=hr_scale,
                upscale_denoising_strength=hr_denoise,
                **config,
                **latent_upscale_modes[hr_method],
            )
        else:
            result = pipe.txt2img(prompt, width=width, height=height, **config)
    

    end_time = time.time()
                  
    vram_free, vram_total = torch.cuda.mem_get_info()
    if ip_adapter :
        pipe.unload_ip_adapter()
    if lora_group is not None and len(lora_group) > 0:
        #pipe.unfuse_lora()#Unload lora
        pipe.unload_lora_weights()
    #if embs is not None and len(embs) > 0:
        #pipe.unload_textual_inversion()
    del pipe
    torch.cuda.empty_cache()
    gc.collect()
    print(f"done: model={model}, res={result[-1].width}x{result[-1].height}, step={steps}, time={round(end_time-start_time, 2)}s, vram_alloc={convert_size(vram_total-vram_free)}/{convert_size(vram_total)}")
    return gr.Image.update(result[-1], label=f"Initial Seed: {seed}"),result
    


color_list = []

def get_color(n):
    for _ in range(n - len(color_list)):
        color_list.append(tuple(np.random.random(size=3) * 256))
    return color_list


def create_mixed_img(current, state, w=512, h=512):
    w, h = int(w), int(h)
    image_np = np.full([h, w, 4], 255)
    if state is None:
        state = {}

    colors = get_color(len(state))
    idx = 0

    for key, item in state.items():
        if item["map"] is not None:
            m = item["map"] < 255
            alpha = 150
            if current == key:
                alpha = 200
            image_np[m] = colors[idx] + (alpha,)
        idx += 1

    return image_np

def apply_size_sketch(width,height,state,inf_image,inpaiting_mode,inf_image_inpaiting):
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height 
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
        #update_img = gr.Image.update(value=create_mixed_img("", state, w_change, h_change))
        #return state, update_img,gr.Image.update(width=w_change,height = h_change)
    else:
        w_change = int(width)
        h_change = int(height)

    if state is not None:
        for key, item in state.items():
            if item["map"] is not None:
                #inverted_image = PIL.ImageOps.invert(item["map"].convert('RGB'))
                item["map"] = resize(item["map"], w_change, h_change)
    
    update_img = gr.Image.update(value=create_mixed_img("", state, w_change, h_change))
    return state, update_img,gr.Image.update(width=w_change,height = h_change)


# width.change(apply_new_res, inputs=[width, height, global_stats], outputs=[global_stats, sp, rendered])
'''def apply_new_res(w, h, state,inf_image,rendered):
    if inf_image is not None:
        return state, rendered
    w, h = int(w), int(h)

    if state is not None:
        for key, item in state.items():
            if item["map"] is not None:
                item["map"] = resize(item["map"], w, h)
    
    update_img = gr.Image.update(value=create_mixed_img("", state, w, h))
    return state, update_img'''


def detect_text(text, state, width, height,formula_button,inf_image,inpaiting_mode,inf_image_inpaiting):
    global formula
    if text is None or text == "":
        return None, None, gr.Radio.update(value=None,visible = False), None,gr.Dropdown.update(value = formula_button)

    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(width)
        h_change = int(height)


    t = text.split(",")
    new_state = {}

    for item in t:
        item = item.strip()
        if item == "":
            continue
        if state is not None and item in state:
            new_state[item] = {
                "map": state[item]["map"],
                "weight": state[item]["weight"],
                "mask_outsides": state[item]["mask_outsides"],
            }
        else:
            new_state[item] = {
                "map": None,
                "weight": 0.5,
                "mask_outsides": 0
            }
    update = gr.Radio.update(choices=[key for key in new_state.keys()], value=None,visible = True)
    update_img = gr.update(value=create_mixed_img("", new_state, w_change, h_change))
    update_sketch = gr.update(value=None, interactive=False)
    return new_state, update_sketch, update, update_img,gr.Dropdown.update(value = formula_button)

def detect_text1(text, state, width, height,formula_button,inf_image,inpaiting_mode,inf_image_inpaiting):
    global formula
    if text is None or text == "":
        return None, None, gr.Radio.update(value=None,visible = False), None,gr.Dropdown.update(value = formula_button)

    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(width)
        h_change = int(height)

    t = text.split(",")
    new_state = {}

    for item in t:
        item = item.strip()
        if item == "":
            continue
        if state is not None and item in state:
            new_state[item] = {
                "map": state[item]["map"],
                "weight": state[item]["weight"],
                "mask_outsides": state[item]["mask_outsides"],
            }
        else:
            new_state[item] = {
                "map": None,
                "weight": 0.5,
                "mask_outsides": False
            }
    update = gr.Radio.update(choices=[key for key in new_state.keys()], value=None,visible = True)
    update_img = gr.update(value=create_mixed_img("", new_state, w_change, h_change))
    return new_state, update, update_img,gr.Dropdown.update(value = formula_button)


def resize(img, w, h):
    trs = transforms.Compose(
        [
            transforms.ToPILImage(),
            #transforms.Resize(min(h, w)),
            transforms.Resize((h, w),interpolation=transforms.InterpolationMode.BICUBIC),
            transforms.CenterCrop((h, w)),
        ]
    )
    result = np.array(trs(img), dtype=np.uint8)
    return result


def switch_canvas(entry, state, width, height,inf_image,inpaiting_mode,inf_image_inpaiting):
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(width)
        h_change = int(height)

    if entry is None or state is None:
        return None, 0.5, False, create_mixed_img("", state, w_change, h_change)

    return (
        gr.update(value=None, interactive=True),
        gr.update(value=state[entry]["weight"] if entry in state else 0.5),
        gr.update(value=state[entry]["mask_outsides"] if entry in state else False),
        create_mixed_img(entry, state, w_change, h_change),
    )


def apply_canvas(selected, draw, state, w, h,inf_image,inpaiting_mode,inf_image_inpaiting):
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(w)
        h_change = int(h)


    if state is not None and selected in state and draw is not None:
        w, h = int(w_change), int(h_change)
        state[selected]["map"] = resize(draw, w, h)
    return state, gr.Image.update(value=create_mixed_img(selected, state, w, h))


def apply_weight(selected, weight, state):
    if state is not None and selected in state:
        state[selected]["weight"] = weight
    return state


def apply_option(selected, mask, state):
    if state is not None and selected in state:
        state[selected]["mask_outsides"] = mask
    return state

clustering_image =[]
number_clustering = 0 
def is_image_black(image):

    average_intensity = image.mean()

    if average_intensity < 10:
        return True
    else:
        return False
def change_diferent_black_to_white(image):

    width, height = image.size

    for x in range(width):
        for y in range(height):
            r, g, b = image.getpixel((x, y))

            if r != 0 and g != 0 and b != 0:
                image.putpixel((x, y), (255, 255, 255))
    return image

def change_black_to_other_color(image,color_list):

    width, height = image.size
    new_pixel = (random.randrange(1,256), random.randrange(1,256), random.randrange(1,256))
    while new_pixel in color_list:
        new_pixel = (random.randrange(1,256), random.randrange(1,256), random.randrange(1,256))
    for x in range(width):
        for y in range(height):
            pixel = image.getpixel((x, y))

            if pixel == (0, 0, 0):
                image.putpixel((x, y), new_pixel)
    return image

def get_color_mask(color, image, threshold=30):
    """
    Returns a color mask for the given color in the given image.
    """
    img_array = np.array(image, dtype=np.uint8)
    color_diff = np.sum((img_array - color) ** 2, axis=-1)
    img_array[color_diff > threshold] = img_array[color_diff > threshold] * 0
    return Image.fromarray(img_array)

def unique_colors(image, threshold=0.01):
    colors = image.getcolors(image.size[0] * image.size[1])
    total_pixels = image.size[0] * image.size[1]
    unique_colors = []
    for count, color in colors:
        if count / total_pixels > threshold:
            unique_colors.append(color)
    return unique_colors

def extract_color_textboxes(color_map_image,MAX_NUM_COLORS):
    #color_map_image = Image.open(color_map_image) 
    #color_map_image = cv2.imread(color_map_image)
    color_map_image= Image.fromarray(color_map_image.astype('uint8'), 'RGB')
    # Get unique colors in color_map_image
    colors = unique_colors(color_map_image)
    color_map_image = change_black_to_other_color(color_map_image,colors)
    colors = unique_colors(color_map_image)
    color_masks = [get_color_mask(color, color_map_image) for color in colors]
    # Append white blocks to color_masks to fill up to MAX_NUM_COLORS
    num_missing_masks = MAX_NUM_COLORS - len(color_masks)
    white_mask = Image.new("RGB", color_map_image.size, color=(32, 32, 32))
    color_masks += [white_mask] * num_missing_masks
    color_output =[]
    for i in range(0,len(color_masks)) :
      #color_masks[i] = color_masks[i].convert('L')
      color_masks[i] = change_diferent_black_to_white(color_masks[i])
      color_masks[i] = np.array(color_masks[i])
      color_masks[i] = cv2.cvtColor(color_masks[i], cv2.COLOR_RGB2GRAY)
      color_masks[i] = 255.0 - color_masks[i]
      if is_image_black(color_masks[i]) == False:
        color_masks[i] = color_masks[i].astype(np.uint8)
        color_output.append(color_masks[i])
    return color_output



def apply_image_clustering(image, selected, w, h, strength, mask, state,inf_image,inpaiting_mode,inf_image_inpaiting):
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(w)
        h_change = int(h)

    if state is not None and selected in state:
        state[selected] = {
            "map": resize(image, w_change, h_change), 
            "weight": strength, 
            "mask_outsides": mask
        }   
    return state, gr.Image.update(value=create_mixed_img(selected, state, w_change, h_change))


# sp2, radio, width, height, global_stats
def apply_image(image, selected, w, h, strength, mask, state,inf_image,inpaiting_mode,inf_image_inpaiting):
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(w)
        h_change = int(h)


    if state is not None and selected in state:
        image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        state[selected] = {
            "map": resize(image, w_change, h_change), 
            "weight": strength, 
            "mask_outsides": mask 
        }
    elif state is not None:
        key_state = list(state.keys())
        global number_clustering,clustering_image
        number_clustering = 0
        clustering_image = []
        clustering_image = extract_color_textboxes(image,len(state)+1)
        number_clustering = len(clustering_image)
        if len(state) > len(clustering_image):
            amount_add = len(clustering_image)
        else:
            amount_add = len(state)
        for i in range(0,amount_add):
            state[key_state[i]] = {
                "map": resize(clustering_image[i], w_change, h_change), 
                "weight": strength, 
                "mask_outsides": mask
            }
    return state, gr.Image.update(value=create_mixed_img(selected, state, w_change, h_change))
#rendered, apply_style, apply_clustering_style,Previous,Next,Completed,sp2,sp3
def apply_base_on_color(sp2,state, width, height,inf_image,inpaiting_mode,inf_image_inpaiting):
    global number_clustering,clustering_image
    if inpaiting_mode and inf_image_inpaiting:
        w_change = inf_image_inpaiting["image"].width
        h_change = inf_image_inpaiting["image"].height
    elif inf_image is not None:
        w_change = inf_image.width
        h_change = inf_image.height 
    else:
        w_change = int(width)
        h_change = int(height)

    number_clustering = 0
    clustering_image = []
    clustering_image = extract_color_textboxes(sp2,len(state)+1)
    new_state = {}
    for i in state:
        new_state[i] = {
            "map": None,
            "weight": 0.5,
            "mask_outsides": False
        }
    return gr.Image.update(value = create_mixed_img("", new_state, w_change, h_change)),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Image.update(visible = False),gr.Image.update(value=clustering_image[0],visible = True),gr.Button.update(visible = True),new_state
def completing_clustering(sp2):
    return gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Image.update(visible = True),gr.Image.update(visible = False),gr.Button.update(visible = False)
def previous_image_page(sp3):
    global clustering_image,number_clustering
    number_clustering = number_clustering - 1
    if number_clustering < 0:
        number_clustering = len(clustering_image)-1
    return gr.Image.update(value = clustering_image[number_clustering])

def next_image_page(sp3):
    global clustering_image,number_clustering
    number_clustering = number_clustering + 1
    if number_clustering >= len(clustering_image):
        number_clustering = 0
    return gr.Image.update(value = clustering_image[number_clustering])
# [ti_state, lora_state, ti_vals, lora_vals, uploads]


def get_file_link_sp(link):
    import requests
    import os
    from urllib.parse import unquote

    file_name = None
    absolute_path = None

    try:
        response = requests.get(link)
        response.raise_for_status()
    except requests.exceptions.HTTPError as err:
        print(f"There was an error downloading: {err}")
    else:
        content_disposition = response.headers.get("content-disposition")
        if content_disposition:
            file_name = content_disposition.split("filename=")[1]
            file_name = unquote(file_name)
            # remove quotation marks
            file_name = file_name.strip('"')
        else:
            file_name = "downloaded_file"

        with open(file_name, "wb") as f:
            f.write(response.content)

        #Get absolute_path
        absolute_path = os.path.abspath(file_name)
        #Change format file_name
        file_name = file_name.split('.')[0]
        file_name = file_name.replace('_',' ')
        file_name = file_name.replace('-',' ')
        file_name = file_name.title()
        
    return absolute_path, file_name


def get_file_link(link):
    import requests
    import os
    from urllib.parse import unquote

    file_name = None
    absolute_path = None

    try:
        with requests.get(link, stream=True) as response:
            response.raise_for_status()
            
            # Get file size from headers
            total_size = int(response.headers.get('content-length', 0))
            content_disposition = response.headers.get("content-disposition")
            if content_disposition:
                file_name = content_disposition.split("filename=")[1]
                file_name = unquote(file_name)
                # remove quotation marks
                file_name = file_name.strip('"')
            else:
                file_name = "downloaded_file"

            # Stream download and write to file
            chunk_size = 1024
            downloaded_size = 0
            with open(file_name, "wb") as f:
                for chunk in response.iter_content(chunk_size=chunk_size):
                    if chunk:
                        f.write(chunk)
                        downloaded_size += len(chunk)
                        # Print download progress
                        progress = (downloaded_size / total_size) * 100
                        if progress%10 == 0:
                            print(f"Download progress: {progress:.2f}% ({downloaded_size / 1024:.2f} KB / {total_size / 1024:.2f} KB)")

            # Get absolute_path
            absolute_path = os.path.abspath(file_name)
            # Change format file_name
            file_name = file_name.split('.')[0]
            file_name = file_name.replace('_', ' ')
            file_name = file_name.replace('-', ' ')
            file_name = file_name.title()
            
    except requests.exceptions.HTTPError as err:
        print(f"There was an error downloading: {err}")
    
    return absolute_path, file_name




def add_net(files,link_download):
    global lora_scale_dict, lora_lst, lora_dict, embeddings_dict
    if files is None and (link_download is None or link_download == ''):
        return gr.CheckboxGroup.update(choices=list(embeddings_dict.keys())),gr.CheckboxGroup.update(choices=list(lora_dict.keys())),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],),gr.File.update(value=None),gr.Textbox.update(value = ''),
    if link_download is not None and link_download != '':
        path_file, file_name_download = get_file_link(link_download)
        if file_name_download:
            items_dl = Path(path_file)
            if items_dl.suffix == ".pt":
                state_dict = torch.load(path_file, map_location="cpu")
            else:
                state_dict = load_file(path_file, device="cpu")
            if any("lora" in k for k in state_dict.keys()):
                #lora_state = file.name
                if file_name_download not in lora_dict:
                    lora_lst.append(file_name_download)
                    lora_dict[file_name_download] = path_file
                    lora_scale_dict[file_name_download] = 1.0
            else:
                if file_name_download not in embeddings_dict:
                    embeddings_dict[file_name_download] = path_file
    if files is not None:
        for file in files:
            item = Path(file.name)
            stripedname = str(item.stem).strip()
            stripedname = stripedname.replace('_',' ')
            stripedname = stripedname.replace('-',' ')
            stripedname = stripedname.title()
            if item.suffix == ".pt":
                state_dict = torch.load(file.name, map_location="cpu")
            else:
                state_dict = load_file(file.name, device="cpu")
            if any("lora" in k for k in state_dict.keys()):
                #lora_state = file.name
                if stripedname not in lora_dict:
                    lora_lst.append(stripedname)
                    lora_dict[stripedname] = file.name
                    lora_scale_dict[stripedname] = 1.0
            else:
                #ti_state[stripedname] = file.name
                if stripedname not in embeddings_dict:
                    embeddings_dict[stripedname] = file.name 
    return gr.CheckboxGroup.update(choices=list(embeddings_dict.keys())), gr.CheckboxGroup.update(choices=list(lora_dict.keys())),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],),gr.File.update(value=None),gr.Textbox.update(value = ''),

def change_lora_value(lora_vals):
    global lora_scale_dict
    if len(lora_scale_dict) == 0 or lora_vals == 'Not using Lora':
        return gr.Slider.update(value = 1.0)
    return gr.Slider.update(value = lora_scale_dict[lora_vals])
def update_lora_value(lora_scale,lora_vals):
    global lora_scale_dict
    if len(lora_scale_dict) and lora_vals != 'Not using Lora': 
        lora_scale_dict[lora_vals] = float(lora_scale)


# [ti_state, lora_state, ti_vals, lora_vals, uploads]
def clean_states(ti_state,lora_group):
    global lora_dict,embeddings_dict,lora_lst,lora_scale_dict
    delete_lora = list(lora_dict.values())
    for i in delete_lora:
        os.remove(i)
    delete_embed_lst = list(embeddings_dict.values())
    for i in delete_embed_lst:
        os.remove(i)
    embeddings_dict = dict()
    lora_dict = dict()
    lora_scale_dict = dict()
    lora_lst = ['Not using Lora']
    return dict(),dict(),gr.CheckboxGroup.update(choices=list(embeddings_dict.keys()),value = None),gr.CheckboxGroup.update(choices=list(lora_dict.keys()),value = None),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],),gr.File.update(value=None),gr.Text.update(f""),gr.Text.update(f""),gr.Textbox.update(value = ''),

def add_model(insert_model):
    global models,keep_vram,models_single_file
    insert_model=insert_model.replace(" ", "")
    if len(insert_model) == 0:
        return gr.Dropdown.update(choices=[k[0] for k in get_model_list()],value=base_name),gr.Textbox.update(value = '')
    if 'https' in insert_model:
        path_file, file_name_download = get_file_link(insert_model)
        for i in models:
            if file_name_download in i:
                return gr.Dropdown.update(choices=[k[0] for k in get_model_list()],value=base_name),gr.Textbox.update(value = '')
        models.append((file_name_download,path_file))
        keep_vram.append(path_file)
        models_single_file.append(file_name_download)
    else:
        author,name = insert_model.split('/')
        name = name.replace('_',' ')
        name = name.replace('-',' ')
        name = name.title()
        for i in models:
            if name in i or insert_model in i:
                return gr.Dropdown.update(choices=[k[0] for k in get_model_list()],value=base_name),gr.Textbox.update(value = '')
        models.append((name,insert_model))
        keep_vram.append(insert_model)
    return gr.Dropdown.update(choices=[k[0] for k in get_model_list()],value=base_name),gr.Textbox.update(value = '')

def add_vae(insert_vae,single_load_file):
    global vae_link,vae_single_file,vae_lst
    insert_vae=insert_vae.replace(" ", "")
    if len(insert_vae) == 0:
        return gr.Dropdown.update(choices=[k for k in vae_lst],value=vae_lst[0]),gr.Textbox.update(value = ''),gr.Checkbox.update(value = False),
    if 'https' in insert_vae:
        path_file, file_name_download = get_file_link(insert_vae)
        if file_name_download not in vae_lst:
            vae_lst.append(file_name_download)
            vae_link[file_name_download] = path_file
            vae_single_file[file_name_download] = True
    else:    
        name = insert_vae.split('/')[-1]
        name = name.split('.')[0]
        name = name.replace('_',' ')
        name = name.replace('-',' ')
        name = name.title()
        if name not in vae_lst:
            vae_lst.append(name)
            vae_link[name] = insert_vae
            vae_single_file[name] = single_load_file
    return gr.Dropdown.update(choices=[k for k in vae_lst],value=vae_lst[0]),gr.Textbox.update(value = ''),gr.Checkbox.update(value = False),

def reset_model_button(insert_model):
    return gr.Textbox.update(value = '')

def choose_tistate(ti_vals):
    if len(ti_vals) == 0:
        return dict(),gr.Text.update(""),gr.CheckboxGroup.update(choices=list(embeddings_dict.keys()),value = None)
    dict_copy = dict()
    for key, value in embeddings_dict.items():
        if key in ti_vals:
            dict_copy[key] = value
    lst_key = [key for key in dict_copy.keys()]
    lst_key = '; '.join(map(str, lst_key))
    return dict_copy,gr.Text.update(lst_key),gr.CheckboxGroup.update(choices=list(embeddings_dict.keys()),value = None)

def choose_lora_function(lora_list):
    global lora_dict
    if len(lora_list) == 0:
        return dict(),gr.Text.update(""),gr.CheckboxGroup.update(choices=list(lora_dict.keys()),value = None),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],)
    dict_copy = dict()
    for key, value in lora_dict.items():
        if key in lora_list:
            dict_copy[key] = value
    lst_key = [key for key in dict_copy.keys()]
    lst_key = '; '.join(map(str, lst_key))
    return dict_copy,gr.Text.update(lst_key),gr.CheckboxGroup.update(choices=list(lora_dict.keys()),value = None),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],)



def delete_embed(ti_vals,ti_state,embs_choose):
    if len(ti_vals) == 0:
        return gr.CheckboxGroup.update(choices=list(embeddings_dict.keys())),ti_state,gr.Text.update(embs_choose)
    for key in ti_vals:
        if key in ti_state:
            ti_state.pop(key)
        if key in embeddings_dict:
            os.remove(embeddings_dict[key])
            embeddings_dict.pop(key)
    if len(ti_state) >= 1:
        lst_key = [key for key in ti_state.keys()]
        lst_key = '; '.join(map(str, lst_key))
    else:
        lst_key =""
    return gr.CheckboxGroup.update(choices=list(embeddings_dict.keys()),value = None),ti_state,gr.Text.update(lst_key)

def delete_lora_function(lora_list,lora_group,lora_choose):
    global lora_dict,lora_lst,lora_scale_dict
    if len(lora_list) == 0:
        return gr.CheckboxGroup.update(choices=list(lora_dict.keys())),lora_group,gr.Text.update(lora_choose),gr.Dropdown.update()
    for key in lora_list:
        if key in lora_group:
            lora_group.pop(key)
        if key in lora_scale_dict:
            lora_scale_dict.pop(key)
        if key in lora_dict:
            os.remove(lora_dict[key])
            lora_dict.pop(key)
    if len(lora_group) >= 1:
        lst_key = [key for key in lora_group.keys()]
        lst_key = '; '.join(map(str, lst_key))
    else:
        lst_key =""
    lora_lst = ["Not using Lora"]+[key for key in lora_dict.keys()]
    return gr.CheckboxGroup.update(choices=list(lora_dict.keys()),value = None),lora_group,gr.Text.update(lst_key),gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],)

def lora_delete(lora_vals):
    global lora_dict
    global lora_lst
    if lora_vals == 'Not using Lora':
        return gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],)
    os.remove(lora_dict[lora_vals])
    lora_dict.pop(lora_vals)
    lora_lst.remove(lora_vals)
    return gr.Dropdown.update(choices=[k for k in lora_lst],value=lora_lst[0],)
#diffuser_pipeline,sampler,gallery,hr_enabled
def mode_diffuser_pipeline( controlnet_enabled):
    if controlnet_enabled == True:
        return gr.Checkbox.update(value = True),gr.Checkbox.update()
    return gr.Checkbox.update(value = False),gr.Checkbox.update(value = False)
'''def mode_diffuser_pipeline1(diffuser_pipeline, controlnet_enabled):
    assert diffuser_pipeline == False, "Please enable diffusers pipeline to use this option"
    return gr.Checkbox.update(value = True)'''

def res_cap(g, w, h, x):
    if g:
        return f"Enable upscaler: {w}x{h} to {int(w*x)//8 *8}x{int(h*x)//8 *8}"
    else:
        return "Enable upscaler"
#diffuser_pipeline,hr_enabled,sampler,gallery,controlnet_enabled
def mode_upscale(diffuser_pipeline, hr_scale, width, height,hr_enabled):
    if hr_enabled == True:
        return gr.Checkbox.update(value = False),gr.Checkbox.update(value = True,label=res_cap(True, width, height, hr_scale)),gr.Dropdown.update(value="DPM++ 2M Karras",choices=[s[0] for s in samplers_k_diffusion]),gr.Checkbox.update(value = False)
    return gr.Checkbox.update(value = False),gr.Checkbox.update(value = False,label=res_cap(False, width, height, hr_scale)),gr.Dropdown.update(value="DPM++ 2M Karras",choices=[s[0] for s in samplers_k_diffusion]),gr.Checkbox.update()

def change_control_net(model_control_net, low_threshold, high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose):
    if model_control_net == 'Canny':
        return gr.Slider.update(visible = True),gr.Slider.update(visible = True),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Radio.update(visible = False)
    if model_control_net == 'Depth':
        return gr.Slider.update(visible = False),gr.Slider.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Radio.update(visible = True,choices=["Midas","DPT"])
    if model_control_net == 'Openpose':
        return gr.Slider.update(visible = False),gr.Slider.update(visible = False),gr.Checkbox.update(visible = True),gr.Checkbox.update(visible = True),gr.Checkbox.update(visible = True),gr.Radio.update(visible = False)
    if model_control_net == 'Semantic Segmentation':
        return gr.Slider.update(visible = False),gr.Slider.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Radio.update(visible = True,choices=["Convnet tiny","Convnet small","Convnet base","Convnet large","Convnet xlarge","Swin tiny","Swin small","Swin base","Swin large"]) 
    if model_control_net =='Soft Edge' or model_control_net == 'Scribble' or model_control_net == 'Sketch':
        return gr.Slider.update(visible = False),gr.Slider.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Radio.update(visible = True,choices=["HED","PidiNet"])
    return gr.Slider.update(visible = False),gr.Slider.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Checkbox.update(visible = False),gr.Radio.update(visible = False)

previous_sampler = 'DPM++ 2M Karras'
previous_sampler_hires = 'DPM++ 2M Karras'
#sampler,gallery,hr_enabled,controlnet_enabled
def mode_diffuser_pipeline_sampler(diffuser_pipeline, sampler,sampler_hires):
    global previous_sampler, previous_sampler_hires
    sample_now = previous_sampler
    sampler_hires_now = previous_sampler_hires
    previous_sampler = sampler
    previous_sampler_hires = sampler_hires
    if diffuser_pipeline == False:
        return gr.Checkbox.update(value = False), gr.Dropdown.update(value=sample_now,choices=[s[0] for s in samplers_k_diffusion]),gr.Dropdown.update(value=sampler_hires_now,choices=[s[0] for s in samplers_k_diffusion])
    return gr.Checkbox.update(value = True),gr.Dropdown.update(value=sample_now,choices=[s[0] for s in samplers_diffusers]),gr.Dropdown.update(value=sampler_hires_now,choices=[s[0] for s in samplers_diffusers])

def change_gallery(latent_processing,hr_process_enabled):
    if latent_processing or hr_process_enabled:
        return gr.Gallery.update(visible = True)
    return gr.Gallery.update(visible = False)


in_edit_mode = False
in_edit_mode_adapter = False
def preview_image(model_control_net,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,img_control,preprocessor_name,multi_controlnet,disable_preprocessing):
    global in_edit_mode
    if multi_controlnet == True and in_edit_mode == True:
        global lst_control,current_number_control
        if model_control_net == lst_control[current_number_control]["control_net_model"]:
            setting_processing = list(lst_control[current_number_control].items())
            setting_processing = setting_processing[:-3]
            setting_processing = dict(setting_processing)
        else:
            setting_processing = {
            "control_net_model": model_control_net,
            "img_control": img_control,
            "low_threshold": low_threshold,
            "high_threshold": high_threshold,
            "has_body": has_body_openpose,
            "has_face": has_face_openpose,
            "has_hand": has_hand_openpose,
            "preprocessor_name": preprocessor_name,
            "disable_preprocessing":disable_preprocessing,
        }
        image_sp_control = control_net_preprocessing(**setting_processing)
        return gr.Image.update(image_sp_control)
    elif img_control is not None:
        image_show = control_net_preprocessing(model_control_net,img_control,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,disable_preprocessing)
        return gr.Image.update(image_show)
    return gr.Image.update(value = None)



def change_image_condition(image_condition):
    if image_condition is None:
        return gr.Image.update()
    return gr.Image.update(value= None)


#control_net_model,img_control,low_threshold = None,high_threshold=None,has_hand=None,preprocessor_name=None
def control_net_muti(control_net_model,img_control,low_threshold ,high_threshold,has_body,has_hand,has_face,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing):
    global lst_control
    if img_control is not None:
        config = {
            "control_net_model": control_net_model,
            "img_control": img_control,
            "low_threshold": low_threshold,
            "high_threshold": high_threshold,
            "has_body": has_body,
            "has_face": has_face,
            "has_hand": has_hand,
            "preprocessor_name": preprocessor_name,
            "disable_preprocessing":disable_preprocessing,
            "controlnet_scale": controlnet_scale,
            "control_guidance_start": control_guidance_start,
            "control_guidance_end": control_guidance_end,
        }
        lst_control.append(config)
    return gr.Image.update(value = None)

def previous_view_control():
    global lst_control,current_number_control
    if current_number_control <= 0:
        current_number_control = len(lst_control)-1
    else:
        current_number_control -= 1
    return gr.Dropdown.update(value = lst_control[current_number_control]["control_net_model"]),gr.Image.update(value = lst_control[current_number_control]["img_control"]),gr.Slider.update(value = lst_control[current_number_control]["low_threshold"]),gr.Slider.update(value = lst_control[current_number_control]["high_threshold"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_body"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_hand"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_face"]),gr.Radio.update(value = lst_control[current_number_control]["preprocessor_name"]),gr.Slider.update(value= lst_control[current_number_control]["controlnet_scale"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_start"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_end"]),gr.Checkbox.update(value = lst_control[current_number_control]["disable_preprocessing"])

def next_view_control():
    global lst_control,current_number_control
    if current_number_control >= len(lst_control)-1:
        current_number_control = 0
    else:
        current_number_control += 1
    return gr.Dropdown.update(value = lst_control[current_number_control]["control_net_model"]),gr.Image.update(value = lst_control[current_number_control]["img_control"]),gr.Slider.update(value = lst_control[current_number_control]["low_threshold"]),gr.Slider.update(value = lst_control[current_number_control]["high_threshold"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_body"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_hand"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_face"]),gr.Radio.update(value = lst_control[current_number_control]["preprocessor_name"]),gr.Slider.update(value= lst_control[current_number_control]["controlnet_scale"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_start"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_end"]),gr.Checkbox.update(value = lst_control[current_number_control]["disable_preprocessing"])

def apply_edit_control_net(control_net_model,img_control,low_threshold ,high_threshold,has_body,has_hand,has_face,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing):
    global lst_control,current_number_control,in_edit_mode
    if img_control is not None:
        config = {
            "control_net_model": control_net_model,
            "img_control": img_control,
            "low_threshold": low_threshold,
            "high_threshold": high_threshold,
            "has_body": has_body,
            "has_face": has_face,
            "has_hand": has_hand,
            "preprocessor_name": preprocessor_name,
            "disable_preprocessing":disable_preprocessing,
            "controlnet_scale": controlnet_scale,
            "control_guidance_start": control_guidance_start,
            "control_guidance_end": control_guidance_end,
        }
        lst_control[current_number_control] = config
        return gr.Dropdown.update(),gr.Image.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Checkbox.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Slider.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()
    else:
        lst_control.pop(current_number_control)
        current_number_control -=1
        if current_number_control == -1:
            current_number_control = len(lst_control)-1
        if len(lst_control) == 0:
            in_edit_mode = False
            return gr.Dropdown.update(),gr.Image.update(value = None),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Checkbox.update(value = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Slider.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()
        return gr.Dropdown.update(value = lst_control[current_number_control]["control_net_model"]),gr.Image.update(value = lst_control[current_number_control]["img_control"]),gr.Slider.update(value = lst_control[current_number_control]["low_threshold"]),gr.Slider.update(value = lst_control[current_number_control]["high_threshold"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_body"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_hand"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_face"]),gr.Radio.update(value = lst_control[current_number_control]["preprocessor_name"]),gr.Checkbox.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Slider.update(value= lst_control[current_number_control]["controlnet_scale"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_start"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_end"]),gr.Checkbox.update(value = lst_control[current_number_control]["disable_preprocessing"])

def complete_edit_multi():
    global current_number_control,in_edit_mode
    current_number_control = 0
    in_edit_mode = False
    return gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Image.update(value= None),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False)

def multi_controlnet_function(multi_controlnet):
    if multi_controlnet:
        return gr.Checkbox.update(value = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update()
    return gr.Checkbox.update(),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False)

def edit_multi_control_image_function():
    global lst_control,current_number_control,in_edit_mode
    if len(lst_control) > 0:
        in_edit_mode = True
        return gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Dropdown.update(value = lst_control[current_number_control]["control_net_model"]),gr.Image.update(value = lst_control[current_number_control]["img_control"]),gr.Slider.update(value = lst_control[current_number_control]["low_threshold"]),gr.Slider.update(value = lst_control[current_number_control]["high_threshold"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_body"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_hand"]),gr.Checkbox.update(value = lst_control[current_number_control]["has_face"]),gr.Radio.update(value = lst_control[current_number_control]["preprocessor_name"]),gr.Slider.update(value= lst_control[current_number_control]["controlnet_scale"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_start"]),gr.Slider.update(value= lst_control[current_number_control]["control_guidance_end"]),gr.Checkbox.update(value = lst_control[current_number_control]["disable_preprocessing"])
    in_edit_mode = False
    return gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Dropdown.update(),gr.Image.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Slider.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()

def ip_adapter_work(ip_adapter):
    if ip_adapter:
        return gr.Checkbox.update(value = True)
    return gr.Checkbox.update()


def preview_image_adapter(model_adapter,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,img_control,preprocessor_adapter,multi_adapter,disable_preprocessing_adapter):
    global in_edit_mode_adapter
    if multi_adapter == True and in_edit_mode_adapter == True:
        global lst_adapter,current_number_adapter
        if model_adapter == lst_adapter[current_number_adapter]["model_adapter"]:
            setting_processing = list(lst_adapter[current_number_adapter].items())
            setting_processing = setting_processing[:-3]
            setting_processing = dict(setting_processing)
        else:
            setting_processing = {
            "model_adapter": model_adapter,
            "img_control": img_control,
            "low_threshold_adapter": low_threshold_adapter,
            "high_threshold_adapter": high_threshold_adapter,
            "has_body": has_body_openpose_adapter,
            "has_face": has_face_openpose_adapter,
            "has_hand": has_hand_openpose_adapter,
            "preprocessor_adapter": preprocessor_adapter,
            "disable_preprocessing_adapter":disable_preprocessing_adapter,
        }
        image_sp_control = adapter_preprocessing(**setting_processing)
        return gr.Image.update(image_sp_control)
    elif img_control is not None:
        image_show = adapter_preprocessing(model_adapter,img_control,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,disable_preprocessing_adapter)
        return gr.Image.update(image_show)
    return gr.Image.update(value = None)



def change_image_condition_adapter(image_condition_adapter):
    if image_condition_adapter is None:
        return gr.Image.update()
    return gr.Image.update(value= None)


#control_net_model,img_control,low_threshold_adapter = None,high_threshold_adapter=None,has_hand=None,preprocessor_adapter=None
def adapter_muti(model_adapter,img_control,low_threshold_adapter ,high_threshold_adapter,has_body,has_hand,has_face,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter):
    global lst_adapter
    if img_control is not None:
        config = {
            "model_adapter": model_adapter,
            "img_control": img_control,
            "low_threshold_adapter": low_threshold_adapter,
            "high_threshold_adapter": high_threshold_adapter,
            "has_body": has_body,
            "has_face": has_face,
            "has_hand": has_hand,
            "preprocessor_adapter": preprocessor_adapter,
            "disable_preprocessing_adapter":disable_preprocessing_adapter,
            "adapter_conditioning_scale": adapter_conditioning_scale,
            "adapter_conditioning_factor": adapter_conditioning_factor,
        }
        lst_adapter.append(config)
    return gr.Image.update(value = None)

def previous_view_adapter():
    global lst_adapter,current_number_adapter
    if current_number_adapter <= 0:
        current_number_adapter = len(lst_adapter)-1
    else:
        current_number_adapter -= 1
    return gr.Dropdown.update(value = lst_adapter[current_number_adapter]["model_adapter"]),gr.Image.update(value = lst_adapter[current_number_adapter]["img_control"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["low_threshold_adapter"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["high_threshold_adapter"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_body"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_hand"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_face"]),gr.Radio.update(value = lst_adapter[current_number_adapter]["preprocessor_adapter"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_scale"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_factor"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["disable_preprocessing_adapter"])

def next_view_adapter():
    global lst_adapter,current_number_adapter
    if current_number_adapter >= len(lst_adapter)-1:
        current_number_adapter = 0
    else:
        current_number_adapter += 1
    return gr.Dropdown.update(value = lst_adapter[current_number_adapter]["model_adapter"]),gr.Image.update(value = lst_adapter[current_number_adapter]["img_control"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["low_threshold_adapter"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["high_threshold_adapter"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_body"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_hand"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_face"]),gr.Radio.update(value = lst_adapter[current_number_adapter]["preprocessor_adapter"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_scale"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_factor"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["disable_preprocessing_adapter"])

def apply_edit_adapter(model_adapter,img_control,low_threshold_adapter ,high_threshold_adapter,has_body,has_hand,has_face,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter):
    global lst_adapter,current_number_adapter,in_edit_mode_adapter
    if img_control is not None:
        config = {
            "model_adapter": model_adapter,
            "img_control": img_control,
            "low_threshold_adapter": low_threshold_adapter,
            "high_threshold_adapter": high_threshold_adapter,
            "has_body": has_body,
            "has_face": has_face,
            "has_hand": has_hand,
            "preprocessor_adapter": preprocessor_adapter,
            "disable_preprocessing_adapter":disable_preprocessing_adapter,
            "adapter_conditioning_scale": adapter_conditioning_scale,
            "adapter_conditioning_factor": adapter_conditioning_factor,
        }
        lst_adapter[current_number_adapter] = config
        return gr.Dropdown.update(),gr.Image.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Checkbox.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()
    else:
        lst_adapter.pop(current_number_adapter)
        current_number_adapter -=1
        if current_number_adapter == -1:
            current_number_adapter = len(lst_adapter)-1
        if len(lst_adapter) == 0:
            in_edit_mode_adapter = False
            return gr.Dropdown.update(),gr.Image.update(value = None),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Checkbox.update(value = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()
        return gr.Dropdown.update(value = lst_adapter[current_number_adapter]["model_adapter"]),gr.Image.update(value = lst_adapter[current_number_adapter]["img_control"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["low_threshold_adapter"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["high_threshold_adapter"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_body"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_hand"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_face"]),gr.Radio.update(value = lst_adapter[current_number_adapter]["preprocessor_adapter"]),gr.Checkbox.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_scale"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_factor"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["disable_preprocessing_adapter"])

def complete_edit_multi_adapter():
    global current_number_adapter,in_edit_mode_adapter
    current_number_adapter = 0
    in_edit_mode_adapter = False
    return gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Image.update(value= None),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False)

def multi_adapter_function(multi_adapter):
    if multi_adapter:
        return gr.Checkbox.update(value = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update()
    return gr.Checkbox.update(),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False)

def edit_multi_adapter_image_function():
    global lst_adapter,current_number_adapter,in_edit_mode_adapter
    if len(lst_adapter) > 0:
        in_edit_mode_adapter = True
        return gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = False),gr.Button.update(visible = False),gr.Dropdown.update(value = lst_adapter[current_number_adapter]["model_adapter"]),gr.Image.update(value = lst_adapter[current_number_adapter]["img_control"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["low_threshold_adapter"]),gr.Slider.update(value = lst_adapter[current_number_adapter]["high_threshold_adapter"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_body"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_hand"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["has_face"]),gr.Radio.update(value = lst_adapter[current_number_adapter]["preprocessor_adapter"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_scale"]),gr.Slider.update(value= lst_adapter[current_number_adapter]["adapter_conditioning_factor"]),gr.Checkbox.update(value = lst_adapter[current_number_adapter]["disable_preprocessing_adapter"])
    in_edit_mode_adapter = False
    return gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Button.update(),gr.Dropdown.update(),gr.Image.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Checkbox.update(),gr.Radio.update(),gr.Slider.update(),gr.Slider.update(),gr.Checkbox.update()


def ip_adpater_function(ip_adapter):
    if ip_adapter:
        return gr.Checkbox.update()
    return gr.Checkbox.update(value = False)

#ip_adapter,inf_adapt_image,inf_adapt_image_multi,inf_adapt_image_strength,inf_adapt_image_strength_multi,edit_ip_adapter_setting,apply_ip_adapter_setting
def ip_adpater_multi_function(ip_adapter_multi):
    if ip_adapter_multi:
        return gr.Dropdown.update(choices=[k for k in model_ip_adapter_lst[:-2]],value=model_ip_adapter_lst[0]),gr.Checkbox.update(value = True), gr.Image.update(visible = False), gr.Image.update(visible = True), gr.Slider.update(visible = False), gr.Slider.update(visible = True),gr.Button.update(visible = True),gr.Button.update(visible = True), gr.Image.update(visible = False), gr.Image.update(visible = True)
    return gr.Dropdown.update(choices=[k for k in model_ip_adapter_lst],value=model_ip_adapter_lst[0]),gr.Checkbox.update(), gr.Image.update(visible = True), gr.Image.update(visible = False), gr.Slider.update(visible = True), gr.Slider.update(visible = False),gr.Button.update(visible = False),gr.Button.update(visible = False), gr.Image.update(visible = True), gr.Image.update(visible = False)

def apply_ip_adapter_setting_function(model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi):
    global lst_ip_adapter,current_number_ip_adapter
    if inf_adapt_image_multi is not None:
        config ={
        "model" : model_ip_adapter,
        "image" : inf_adapt_image_multi,
        "region_apply": inf_control_adapt_image_multi,
        "scale" : float(inf_adapt_image_strength_multi),
        }
        lst_ip_adapter.append(config)
        return gr.Image.update(value = None),gr.Image.update(value = None)
    return gr.Image.update(value = None),gr.Image.update(value = None)

#model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,previous_ip_adapter_setting,next_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting
def edit_ip_adapter_setting_function():
    global lst_ip_adapter,current_number_ip_adapter
    if len(lst_ip_adapter) == 0:
        return (
            gr.Dropdown.update(),
            gr.Image.update(),
            gr.Slider.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Image.update(),
        )
    return (
        gr.Dropdown.update(value = lst_ip_adapter[current_number_ip_adapter]["model"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["image"]),
        gr.Slider.update(value = lst_ip_adapter[current_number_ip_adapter]["scale"]),
        gr.Button.update(visible = True),
        gr.Button.update(visible = True),
        gr.Button.update(visible = True),
        gr.Button.update(visible = True),
        gr.Button.update(visible = False),
        gr.Button.update(visible = False),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["region_apply"]),
    )

def previous_ip_adapter_setting_function():
    global lst_ip_adapter,current_number_ip_adapter
    current_number_ip_adapter -= 1
    if current_number_ip_adapter < 0:
        current_number_ip_adapter = len(lst_ip_adapter) -1
    return (
        gr.Dropdown.update(value = lst_ip_adapter[current_number_ip_adapter]["model"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["image"]),
        gr.Slider.update(value = lst_ip_adapter[current_number_ip_adapter]["scale"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["region_apply"]),
        )

def next_ip_adapter_setting_function():
    global lst_ip_adapter,current_number_ip_adapter
    current_number_ip_adapter += 1
    if current_number_ip_adapter == len(lst_ip_adapter):
        current_number_ip_adapter = 0
    return (
        gr.Dropdown.update(value = lst_ip_adapter[current_number_ip_adapter]["model"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["image"]),
        gr.Slider.update(value = lst_ip_adapter[current_number_ip_adapter]["scale"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["region_apply"]),
    )

#inf_adapt_image_multi,previous_ip_adapter_setting,next_ip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting
def complete_cip_adapter_setting_function():
    return (
        gr.Image.update(value = None),
        gr.Button.update(visible = False),
        gr.Button.update(visible = False),
        gr.Button.update(visible = True),
        gr.Button.update(visible = True),
        gr.Button.update(visible = False),
        gr.Button.update(visible = False),
        gr.Image.update(value = None),
    )


#model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,previous_ip_adapter_setting,next_ip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting
def apply_edit_ip_adapter_setting_function(model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi):
    global lst_ip_adapter,current_number_ip_adapter
    if inf_adapt_image_multi is not None:
        config_change = lst_ip_adapter[current_number_ip_adapter]
        config_change["model"] = model_ip_adapter
        config_change["image"] = inf_adapt_image_multi
        config_change["scale"] = float(inf_adapt_image_strength_multi)
        config_change["region_apply"] = inf_control_adapt_image_multi
        return (
            gr.Dropdown.update(),
            gr.Image.update(),
            gr.Slider.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Button.update(),
            gr.Image.update(),
            )
    #Delete 
    lst_ip_adapter.pop(current_number_ip_adapter)
    current_number_ip_adapter -= 1
    if len(lst_ip_adapter) == 0:
        return (
            gr.Dropdown.update(),
            gr.Image.update(value = None),
            gr.Slider.update(),
            gr.Button.update(visible = False),
            gr.Button.update(visible = False),
            gr.Button.update(visible = True),
            gr.Button.update(visible = True),
            gr.Button.update(visible = False),
            gr.Button.update(visible = False),
            gr.Image.update(value = None),
        )
    if current_number_ip_adapter == -1:
        current_number_ip_adapter = len(lst_ip_adapter)-1
    return (
        gr.Dropdown.update(value = lst_ip_adapter[current_number_ip_adapter]["model"]),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["image"]),
        gr.Slider.update(value = lst_ip_adapter[current_number_ip_adapter]["scale"]),
        gr.Button.update(),
        gr.Button.update(),
        gr.Button.update(),
        gr.Button.update(),
        gr.Button.update(),
        gr.Button.update(),
        gr.Image.update(value = lst_ip_adapter[current_number_ip_adapter]["region_apply"]),
    )

def inpaiting_mode_fuction(inpaiting_mode):
    if inpaiting_mode:
        return gr.Image.update(visible = False),gr.Image.update(visible = True), gr.Image.update(visible = True),gr.Checkbox.update(visible = True),gr.Button.update(visible = True),gr.Slider.update(value = 1.0)
    return gr.Image.update(visible = True),gr.Image.update(visible = False), gr.Image.update(visible = False),gr.Checkbox.update(visible = False),gr.Button.update(visible = False),gr.Slider.update(value = 0.5)

def get_mask_fuction(inf_image_inpaiting):
    img_mask = None
    if isinstance(inf_image_inpaiting,dict):
        img_mask = inf_image_inpaiting["mask"].copy()
    return gr.Image.update(img_mask)

latent_upscale_modes = {
    "Latent (bilinear)": {"upscale_method": "bilinear", "upscale_antialias": False},
    "Latent (bilinear antialiased)": {"upscale_method": "bilinear", "upscale_antialias": True},
    "Latent (bicubic)": {"upscale_method": "bicubic", "upscale_antialias": False},
    "Latent (bicubic antialiased)": {
        "upscale_method": "bicubic",
        "upscale_antialias": True,
    },
    "Latent (nearest)": {"upscale_method": "nearest", "upscale_antialias": False},
    "Latent (nearest-exact)": {
        "upscale_method": "nearest-exact",
        "upscale_antialias": False,
    },
    #"Latent (linear)": {"upscale_method": "linear", "upscale_antialias": False},
    #"Latent (trilinear)": {"upscale_method": "trilinear", "upscale_antialias": False},
    "Latent (area)": {"upscale_method": "area", "upscale_antialias": False},
}

css = """
.finetuned-diffusion-div div{
    display:inline-flex;
    align-items:center;
    gap:.8rem;
    font-size:1.75rem;
    padding-top:2rem;
}
.finetuned-diffusion-div div h1{
    font-weight:900;
    margin-bottom:7px
}
.finetuned-diffusion-div p{
    margin-bottom:10px;
    font-size:94%
}
.box {
  float: left;
  height: 20px;
  width: 20px;
  margin-bottom: 15px;
  border: 1px solid black;
  clear: both;
}
a{
    text-decoration:underline
}
.tabs{
    margin-top:0;
    margin-bottom:0
}
#gallery{
    min-height:20rem
}
.no-border {
    border: none !important;
}
 """
with gr.Blocks(css=css) as demo:
    gr.HTML(
        f"""
            <div class="finetuned-diffusion-div">
              <div>
                <h1>Demo for diffusion models</h1>
              </div>
              <p>Running on CPU 🥶 This demo does not work on CPU.</p>
            </div>
        """
    )
    global_stats = gr.State(value={})

    with gr.Row():

        with gr.Column(scale=55):
            model = gr.Dropdown(
                choices=[k[0] for k in get_model_list()],
                label="Model",
                value=base_name,
            )
            with gr.Row():
                image_out = gr.Image()
                gallery = gr.Gallery(label="Generated images", show_label=True, elem_id="gallery",visible = False).style(grid=[1], height="auto")

        with gr.Column(scale=45):

            with gr.Group():

                with gr.Row():
                    with gr.Column(scale=70):

                        prompt = gr.Textbox(
                            label="Prompt",
                            value="An adorable girl is sitting on the park",
                            show_label=True,
                            #max_lines=4,
                            placeholder="Enter prompt.",
                        )
                        neg_prompt = gr.Textbox(
                            label="Negative Prompt",
                            value="bad quality, low quality, jpeg artifact, cropped",
                            show_label=True,
                            #max_lines=4,
                            placeholder="Enter negative prompt.",
                        )

                    generate = gr.Button(value="Generate").style(
                        rounded=(False, True, True, False)
                    )

            with gr.Tab("Options"):

                with gr.Group():

                    # n_images = gr.Slider(label="Images", value=1, minimum=1, maximum=4, step=1)
                    with gr.Row():
                        diffuser_pipeline = gr.Checkbox(label="Using diffusers pipeline", value=False)
                        latent_processing = gr.Checkbox(label="Show processing", value=False)
                        region_condition = gr.Checkbox(label="Enable region condition", value=False)
                    with gr.Row():
                        guidance = gr.Slider(
                            label="Guidance scale", value=7.5, maximum=20
                        )
                        guidance_rescale = gr.Slider(
                            label="Guidance rescale", value=0, maximum=20
                        )
                    with gr.Row():
                        width = gr.Slider(
                            label="Width", value=512, minimum=64, maximum=1920, step=8
                        )
                        height = gr.Slider(
                            label="Height", value=512, minimum=64, maximum=1920, step=8
                        )
                    with gr.Row():
                        clip_skip = gr.Slider(
                            label="Clip Skip", value=2, minimum=1, maximum=12, step=1
                        )
                        steps = gr.Slider(
                            label="Steps", value=25, minimum=2, maximum=100, step=1
                        )
                    with gr.Row():   
                        long_encode = sampler = gr.Dropdown(
                            value="Automatic111 Encoding",
                            label="Encoding prompt type",
                            choices=[s for s in encoding_type],
                        )
                        sampler = gr.Dropdown(
                            value="DPM++ 2M Karras",
                            label="Sampler",
                            choices=[s[0] for s in samplers_k_diffusion],
                        )
                    with gr.Row():
                        seed = gr.Number(label="Seed (Lower than 0 = random)", value=-1)
                        Insert_model = gr.Textbox(
                            label="Insert model",
                            show_label=True,
                            placeholder="Enter a model's link.",
                        )
                        insert_model = gr.Button(value="Insert")
                        #reset_model = gr.Button(value="Reset") 
                    
                    insert_model.click(
                        add_model,
                        inputs=[Insert_model],
                        outputs=[model, Insert_model],
                        queue=False,
                    )
                    

            with gr.Tab("Image to image/Inpaiting"):
                with gr.Group():
                    with gr.Row():
                        inpaiting_mode = gr.Checkbox(label="Inpaiting", value=False)
                        invert_mask_mode = gr.Checkbox(label="Black areas are used", value=False,visible = False)
                    with gr.Row():
                        inf_image = gr.Image(
                            label="Image", source="upload", type="pil",
                        )
                        inf_image_inpaiting = gr.Image(
                            label="Image", source="upload", type="pil", tool="sketch",visible = False
                        )
                        mask_upload = gr.Image(
                            label="Mask", source="upload", type="pil",image_mode='L',visible = False,
                        )
                    inf_strength = gr.Slider(
                        label="Transformation strength",
                        minimum=0,
                        maximum=1,
                        step=0.01,
                        value=0.5,
                    )
                    get_mask = gr.Button(value="Get mask",visible = False)
                    inpaiting_mode.change(
                        inpaiting_mode_fuction,
                        inputs=[inpaiting_mode],
                        outputs=[inf_image,inf_image_inpaiting,mask_upload,invert_mask_mode,get_mask,inf_strength],
                        queue=False,
                    )
                    get_mask.click(
                        get_mask_fuction,
                        inputs=[inf_image_inpaiting],
                        outputs=[mask_upload],
                        queue=False,
                    )
            with gr.Tab("Hires fix"):
                with gr.Group():
                    with gr.Row():
                        hr_enabled = gr.Checkbox(label="Enable upscaler", value=False)
                        hr_process_enabled = gr.Checkbox(label="Show processing upscaler", value=False)
                        hr_region_condition = gr.Checkbox(label="Enable region condition upscaler", value=False)
                    with gr.Row():
                        hr_method = gr.Dropdown(
                            [key for key in latent_upscale_modes.keys()],
                            value="Latent (bilinear)",
                            label="Upscale method",
                        )
                        sampler_hires = gr.Dropdown(
                            value="DPM++ 2M Karras",
                            label="Sampler",
                            choices=[s[0] for s in samplers_k_diffusion],
                        )
                    
                    hr_scale = gr.Slider(
                        label="Upscale factor",
                        minimum=1.0,
                        maximum=2.0,
                        step=0.1,
                        value=1.2,
                    )
                    hr_denoise = gr.Slider(
                        label="Denoising strength",
                        minimum=0.0,
                        maximum=1.0,
                        step=0.1,
                        value=0.8,
                    )

                    hr_scale.change(
                        lambda g, x, w, h: gr.Checkbox.update(
                            label=res_cap(g, w, h, x)
                        ),
                        inputs=[hr_enabled, hr_scale, width, height],
                        outputs=hr_enabled,
                        queue=False,
                    )
                    hr_process_enabled.change(
                        change_gallery,
                        inputs=[latent_processing,hr_process_enabled],
                        outputs=[gallery],
                        queue=False,
                    )
            latent_processing.change(
                change_gallery,
                inputs=[latent_processing,hr_process_enabled],
                outputs=[gallery],
                queue=False,
            )
            with gr.Tab("IP-Adapter"):
                with gr.Group():
                    with gr.Row():
                        ip_adapter = gr.Checkbox(label="Using IP-Adapter", value=False)
                        ip_adapter_multi = gr.Checkbox(label="Using Multi IP-Adapter", value=False)
                        invert_ip_adapter_mask_mode = gr.Checkbox(label="Black areas are used", value=True)
                    model_ip_adapter = gr.Dropdown(
                        choices=[k for k in model_ip_adapter_lst],
                        label="Model IP-Adapter",
                        value=model_ip_adapter_lst[0],
                    )

                    with gr.Row():
                        inf_adapt_image = gr.Image(
                            label="IP-Adapter", source="upload", type="pil"
                        )
                        inf_control_adapt_image = gr.Image(
                            label="Region apply", source="upload", type="pil",image_mode='L'
                        )
                        inf_adapt_image_multi = gr.Image(
                            label="IP-Adapter", source="upload", type="pil",visible= False
                        )
                        inf_control_adapt_image_multi = gr.Image(
                            label="Region apply", source="upload", type="pil",image_mode='L',visible= False
                        )
                    inf_adapt_image_strength = gr.Slider(
                        label="IP-Adapter scale",
                        minimum=0,
                        maximum=2,
                        step=0.01,
                        value=1,
                    )
                    inf_adapt_image_strength_multi = gr.Slider(
                        label="IP-Adapter scale",
                        minimum=0,
                        maximum=2,
                        step=0.01,
                        value=1,
                        visible= False,
                    )
                    with gr.Row():
                        previous_ip_adapter_setting = gr.Button(value="Previous setting",visible = False)
                        next_ip_adapter_setting = gr.Button(value="Next setting",visible = False)
                    with gr.Row():
                        edit_ip_adapter_setting = gr.Button(value="Edit previous setting",visible = False)
                        apply_ip_adapter_setting = gr.Button(value="Apply setting",visible = False)
                    with gr.Row():
                        apply_edit_ip_adapter_setting = gr.Button(value="Apply change",visible = False)
                        complete_cip_adapter_setting = gr.Button(value="Complete change",visible = False) 
                    ip_adapter.change(
                        ip_adpater_function,
                        inputs=[ip_adapter],
                        outputs=[ip_adapter_multi],
                        queue=False,
                    )
                    ip_adapter_multi.change(
                        ip_adpater_multi_function,
                        inputs=[ip_adapter_multi],
                        outputs=[model_ip_adapter,ip_adapter,inf_adapt_image,inf_adapt_image_multi,inf_adapt_image_strength,inf_adapt_image_strength_multi,edit_ip_adapter_setting,apply_ip_adapter_setting,inf_control_adapt_image,inf_control_adapt_image_multi],
                        queue=False,
                    )
                    apply_ip_adapter_setting.click(
                        apply_ip_adapter_setting_function,
                        inputs = [model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi],
                        outputs = [inf_adapt_image_multi,inf_control_adapt_image_multi],
                    )
                    edit_ip_adapter_setting.click(
                        edit_ip_adapter_setting_function,
                        inputs = [],
                        outputs =[model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,previous_ip_adapter_setting,next_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting,inf_control_adapt_image_multi],
                        queue =False,
                    )
                    previous_ip_adapter_setting.click(
                        previous_ip_adapter_setting_function,
                        inputs = [],
                        outputs = [model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi],
                        queue = False,
                    )
                    next_ip_adapter_setting.click(
                        next_ip_adapter_setting_function,
                        inputs = [],
                        outputs = [model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi],
                        queue = False,
                    )
                    apply_edit_ip_adapter_setting.click(
                        apply_edit_ip_adapter_setting_function,
                        inputs = [model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,inf_control_adapt_image_multi],
                        outputs =[model_ip_adapter,inf_adapt_image_multi,inf_adapt_image_strength_multi,previous_ip_adapter_setting,next_ip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting,inf_control_adapt_image_multi],
                        queue = False,
                    )
                    complete_cip_adapter_setting.click(
                        complete_cip_adapter_setting_function,
                        inputs = [],
                        outputs = [inf_adapt_image_multi,previous_ip_adapter_setting,next_ip_adapter_setting,edit_ip_adapter_setting,apply_ip_adapter_setting,apply_edit_ip_adapter_setting,complete_cip_adapter_setting,inf_control_adapt_image_multi],
                        queue = False,
                    )                 
            with gr.Tab("Controlnet"):
                with gr.Group():
                    with gr.Row(): 
                        controlnet_enabled = gr.Checkbox(label="Enable Controlnet", value=False)
                        disable_preprocessing = gr.Checkbox(label="Disable preprocessing", value=False)
                        multi_controlnet = gr.Checkbox(label="Enable Multi Controlnet", value=False)
                    #sketch_enabled = gr.Checkbox(label="Sketch image", value=False)
                    model_control_net = gr.Dropdown(
                        choices=[k for k in controlnet_lst],
                        label="Model Controlnet",
                        value=controlnet_lst[0],
                    )
                    with gr.Row():
                        low_threshold = gr.Slider(
                            label="Canny low threshold", value=100, minimum=1, maximum=255, step=1
                        )
                        high_threshold = gr.Slider(
                            label="Canny high threshold", value=200, minimum=1, maximum=255, step=1
                        )
                    with gr.Row():
                        has_body_openpose = gr.Checkbox(label="Has body", value=True,visible= False)
                        has_hand_openpose = gr.Checkbox(label="Has hand", value=False,visible= False)
                        has_face_openpose = gr.Checkbox(label="Has face", value=False,visible= False)
                    preprocessor_name = gr.Radio(
                        label="Preprocessor",
                        type="value",
                        visible= False,
                    )
                    with gr.Row():
                        control_guidance_start = gr.Slider(
                            label="Control guidance start", value=0, minimum=0, maximum=1, step=0.01
                        )
                        control_guidance_end = gr.Slider(
                            label="Control guidance end", value=1, minimum=0, maximum=1, step=0.01
                        )
                    controlnet_scale = gr.Slider(
                            label="Controlnet scale", value=1, minimum=0, maximum=2, step=0.01
                        )
                    with gr.Row():
                        controlnet_img = gr.Image(
                            image_mode="RGB",
                            source="upload",
                            label = "Image",
                            type = 'pil',
                        )
                        image_condition = gr.Image(interactive=False,image_mode="RGB",label = "Preprocessor Preview",type = 'pil')
                    control_image_click = gr.Button(value="Preview")
                    with gr.Row():
                        previous_multi_control_image = gr.Button(value="Previous control setting",visible = False)
                        next_multi_control_image = gr.Button(value="Next control setting",visible = False)
                    with gr.Row():
                        edit_multi_control_image = gr.Button(value="Edit previous setting",visible = False)
                        apply_multi_control_image = gr.Button(value="Apply setting",visible = False)
                    with gr.Row():
                        apply_edit_multi = gr.Button(value="Apply change",visible = False)
                        complete_change_multi = gr.Button(value="Complete change",visible = False)

                    control_image_click.click(
                        preview_image,
                        inputs=[model_control_net,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,controlnet_img,preprocessor_name,multi_controlnet,disable_preprocessing],
                        outputs=[image_condition],
                        queue=False,
                    )
                    multi_controlnet.change(
                        multi_controlnet_function,
                        inputs=[multi_controlnet],
                        outputs=[controlnet_enabled,edit_multi_control_image,apply_multi_control_image,previous_multi_control_image,next_multi_control_image,apply_edit_multi,complete_change_multi],
                        queue=False,
                    )
                    edit_multi_control_image.click(
                        edit_multi_control_image_function,
                        inputs=[],
                        outputs=[previous_multi_control_image,next_multi_control_image,apply_edit_multi,complete_change_multi,edit_multi_control_image,apply_multi_control_image,model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        queue=False,
                    )

                    previous_multi_control_image.click(
                        previous_view_control,
                        inputs=[],
                        outputs=[model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        queue=False,
                    )

                    next_multi_control_image.click(
                        next_view_control,
                        inputs=[],
                        outputs=[model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        queue=False,
                    )

                    apply_multi_control_image.click(
                        control_net_muti,
                        inputs=[model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        outputs=[controlnet_img],
                        queue=False,
                    )
                    apply_edit_multi.click(
                        apply_edit_control_net,
                        inputs=[model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        outputs=[model_control_net,controlnet_img,low_threshold,high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name,multi_controlnet,previous_multi_control_image,next_multi_control_image,apply_edit_multi,complete_change_multi,controlnet_scale,control_guidance_start,control_guidance_end,disable_preprocessing],
                        queue=False,
                    )

                    complete_change_multi.click(
                        complete_edit_multi,
                        inputs=[],
                        outputs=[edit_multi_control_image,apply_multi_control_image,controlnet_img,apply_edit_multi,complete_change_multi,next_multi_control_image,previous_multi_control_image],
                        queue=False,
                    )

                    controlnet_img.change(
                        change_image_condition,
                        inputs=[image_condition],
                        outputs=[image_condition],
                        queue=False,
                    )
                    
                    model_control_net.change(
                        change_control_net,
                        inputs=[model_control_net, low_threshold, high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose],
                        outputs=[low_threshold, high_threshold,has_body_openpose,has_hand_openpose,has_face_openpose,preprocessor_name],
                        queue=False,
                    )

            with gr.Tab("T2I Adapter"):
                with gr.Group():
                    with gr.Row(): 
                        adapter_enabled = gr.Checkbox(label="Enable T2I Adapter", value=False)
                        disable_preprocessing_adapter = gr.Checkbox(label="Disable preprocessing", value=False)
                        multi_adapter = gr.Checkbox(label="Enable Multi T2I Adapter", value=False)
                    #sketch_enabled = gr.Checkbox(label="Sketch image", value=False)
                    model_adapter = gr.Dropdown(
                        choices=[k for k in adapter_lst],
                        label="Model Controlnet",
                        value=adapter_lst[0],
                    )
                    with gr.Row():
                        low_threshold_adapter = gr.Slider(
                            label="Canny low threshold", value=100, minimum=1, maximum=255, step=1
                        )
                        high_threshold_adapter = gr.Slider(
                            label="Canny high threshold", value=200, minimum=1, maximum=255, step=1
                        )
                    with gr.Row():
                        has_body_openpose_adapter = gr.Checkbox(label="Has body", value=True,visible= False)
                        has_hand_openpose_adapter = gr.Checkbox(label="Has hand", value=False,visible= False)
                        has_face_openpose_adapter = gr.Checkbox(label="Has face", value=False,visible= False)
                    preprocessor_adapter = gr.Radio(
                        label="Preprocessor",
                        type="value",
                        visible= False,
                    )
                    with gr.Row():
                        adapter_conditioning_scale = gr.Slider(
                            label="Conditioning scale", value=1, minimum=0, maximum=2, step=0.01
                        )
                        adapter_conditioning_factor = gr.Slider(
                            label="Conditioning factor", value=1, minimum=0, maximum=1, step=0.01
                        )
                    '''controlnet_scale = gr.Slider(
                            label="Controlnet scale", value=1, minimum=0, maximum=2, step=0.01
                        )'''
                    with gr.Row():
                        adapter_img = gr.Image(
                            image_mode="RGB",
                            source="upload",
                            label = "Image",
                            type = 'pil',
                        )
                        image_condition_adapter = gr.Image(interactive=False,image_mode="RGB",label = "Preprocessor Preview",type = 'pil')
                    adapter_image_click = gr.Button(value="Preview")
                    with gr.Row():
                        previous_multi_adapter_image = gr.Button(value="Previous adapter setting",visible = False)
                        next_multi_adapter_image = gr.Button(value="Next adapter setting",visible = False)
                    with gr.Row():
                        edit_multi_adapter_image = gr.Button(value="Edit previous setting",visible = False)
                        apply_multi_adapter_image = gr.Button(value="Apply setting",visible = False)
                    with gr.Row():
                        apply_edit_multi_adapter = gr.Button(value="Apply change",visible = False)
                        complete_change_multi_adapter = gr.Button(value="Complete change",visible = False)

                    adapter_image_click.click(
                        preview_image_adapter,
                        inputs=[model_adapter,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,adapter_img,preprocessor_adapter,multi_adapter,disable_preprocessing_adapter],
                        outputs=[image_condition_adapter],
                        queue=False,
                    )
                    multi_adapter.change(
                        multi_adapter_function,
                        inputs=[multi_adapter],
                        outputs=[adapter_enabled,edit_multi_adapter_image,apply_multi_adapter_image,previous_multi_adapter_image,next_multi_adapter_image,apply_edit_multi_adapter,complete_change_multi_adapter],
                        queue=False,
                    )
                    edit_multi_adapter_image.click(
                        edit_multi_adapter_image_function,
                        inputs=[],
                        outputs=[previous_multi_adapter_image,next_multi_adapter_image,apply_edit_multi_adapter,complete_change_multi_adapter,edit_multi_adapter_image,apply_multi_adapter_image,model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        queue=False,
                    )

                    previous_multi_adapter_image.click(
                        previous_view_adapter,
                        inputs=[],
                        outputs=[model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        queue=False,
                    )

                    next_multi_adapter_image.click(
                        next_view_adapter,
                        inputs=[],
                        outputs=[model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        queue=False,
                    )

                    apply_multi_adapter_image.click(
                        adapter_muti,
                        inputs=[model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        outputs=[adapter_img],
                        queue=False,
                    )
                    apply_edit_multi_adapter.click(
                        apply_edit_adapter,
                        inputs=[model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        outputs=[model_adapter,adapter_img,low_threshold_adapter,high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter,multi_adapter,previous_multi_adapter_image,next_multi_adapter_image,apply_edit_multi_adapter,complete_change_multi_adapter,adapter_conditioning_scale,adapter_conditioning_factor,disable_preprocessing_adapter],
                        queue=False,
                    )

                    complete_change_multi_adapter.click(
                        complete_edit_multi_adapter,
                        inputs=[],
                        outputs=[edit_multi_adapter_image,apply_multi_adapter_image,adapter_img,apply_edit_multi_adapter,complete_change_multi_adapter,next_multi_adapter_image,previous_multi_adapter_image],
                        queue=False,
                    )

                    adapter_img.change(
                        change_image_condition_adapter,
                        inputs=[image_condition_adapter],
                        outputs=[image_condition_adapter],
                        queue=False,
                    )
                    
                    model_adapter.change(
                        change_control_net,
                        inputs=[model_adapter, low_threshold_adapter, high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter],
                        outputs=[low_threshold_adapter, high_threshold_adapter,has_body_openpose_adapter,has_hand_openpose_adapter,has_face_openpose_adapter,preprocessor_adapter],
                        queue=False,
                    )

            diffuser_pipeline.change(
                mode_diffuser_pipeline_sampler,
                inputs=[diffuser_pipeline, sampler,sampler_hires],
                outputs=[diffuser_pipeline,sampler,sampler_hires],
                queue=False,
            )
            hr_enabled.change(
                lambda g, x, w, h: gr.Checkbox.update(
                    label=res_cap(g, w, h, x)
                ),
                inputs=[hr_enabled, hr_scale, width, height],
                outputs=hr_enabled,
                queue=False,
            )

            adapter_enabled.change(
                mode_diffuser_pipeline,
                inputs=[adapter_enabled],
                outputs=[adapter_enabled,multi_adapter],
                queue=False,
            )

            controlnet_enabled.change(
                mode_diffuser_pipeline,
                inputs=[controlnet_enabled],
                outputs=[controlnet_enabled,multi_controlnet],
                queue=False,
            )

            '''controlnet_enabled.change(
                mode_diffuser_pipeline1,
                inputs=[diffuser_pipeline, controlnet_enabled],
                outputs=[controlnet_enabled],
                queue=False,
                )'''

            with gr.Tab("Vae Setting"):
                with gr.Group():
                    vae_used = gr.Dropdown(
                        choices=[k for k in vae_lst],
                        label="Chosing Vae",
                        value=vae_lst[0],
                    )
                    with gr.Row():
                        with gr.Column():
                            Insert_vae = gr.Textbox(
                                label="Insert Vae's link",
                                show_label=True,
                                placeholder="Enter a Vae's link.",
                            )
                            single_load_file = gr.Checkbox(label="Is Single File", value=False)
                        insert_vae = gr.Button(value="Insert")
                    
                    insert_vae.click(
                        add_vae,
                        inputs=[Insert_vae,single_load_file],
                        outputs=[vae_used, Insert_vae,single_load_file],
                        queue=False,
                    )


            with gr.Tab("Embeddings/Loras"):

                ti_state = gr.State(dict())
                lora_group = gr.State(dict())

                with gr.Group():
                    with gr.Row():
                        with gr.Column():
                            ti_vals = gr.CheckboxGroup(label="Chosing embeddings")
                            embs_choose = gr.Text(label="Embeddings chosen")
                            with gr.Row():
                                choose_em = gr.Button(value="Select Embeddings")
                                delete_em = gr.Button(value="Delete Embeddings")
                        choose_em.click(choose_tistate,inputs=[ti_vals],outputs=[ti_state,embs_choose,ti_vals],queue=False,)
                        delete_em.click(delete_embed,inputs=[ti_vals,ti_state,embs_choose],outputs=[ti_vals,ti_state,embs_choose],queue=False,)

                    with gr.Row():
                        with gr.Column():
                            lora_list = gr.CheckboxGroup(label="Chosing Loras")
                            lora_choose = gr.Text(label="Loras chosen")
                            with gr.Row():
                                choose_lora = gr.Button(value="Select Loras")
                                delete_lora = gr.Button(value="Delete Loras")
                            lora_vals = gr.Dropdown(choices=[k for k in lora_lst],label="Loras Scale",value=lora_lst[0],)
                            choose_lora.click(choose_lora_function,inputs=[lora_list],outputs=[lora_group,lora_choose,lora_list,lora_vals],queue=False,)
                            delete_lora.click(delete_lora_function,inputs=[lora_list,lora_group,lora_choose],outputs=[lora_list,lora_group,lora_choose,lora_vals],queue=False,)
                            # delete_lora_but = gr.Button(value="Delete Lora")
                    link_download = gr.Textbox(
                        label="Insert lora's/embedding's link",
                        show_label=True,
                        placeholder="Enter a link download.",
                    )
                        #delete_lora_but.click(lora_delete,inputs=[lora_vals],outputs=[lora_vals],queue=False,)
                with gr.Row():

                    uploads = gr.Files(label="Upload new embeddings/lora")

                    with gr.Column():
                        lora_scale = gr.Slider(
                            label="Lora scale",
                            minimum=0,
                            maximum=2,
                            step=0.01,
                            value=1.0,
                        )
                        btn = gr.Button(value="Upload/Download")
                        btn_del = gr.Button(value="Reset")
                lora_vals.change(
                    change_lora_value,
                    inputs=[lora_vals],
                    outputs=[lora_scale],
                    queue=False,
                )

                lora_scale.change(
                    update_lora_value,
                    inputs=[lora_scale,lora_vals],
                    outputs=[],
                    queue=False,
                )

                btn.click(
                    add_net,
                    inputs=[uploads,link_download],
                    outputs=[ti_vals,lora_list, lora_vals, uploads,link_download],
                    queue=False,
                )
                btn_del.click(
                    clean_states,
                    inputs=[ti_state,lora_group],
                    outputs=[ti_state,lora_group, ti_vals,lora_list, lora_vals, uploads,embs_choose,lora_choose,link_download],
                    queue=False,
                )

        # error_output = gr.Markdown()

    gr.HTML(
        f"""
            <div class="finetuned-diffusion-div">
              <div>
                <h1>Define the object's region.</h1>
              </div>
              <p>
                Using the following formula as default: w = scale * token_weight_martix * sigma * std(qk).
              </p>
            </div>
        """
    )

    with gr.Row():

        with gr.Column(scale=55):
            formula_button = gr.Dropdown(
                choices=[k[0] for k in formula],
                label="Formual",
                value=formula[0][0],
            )

            rendered = gr.Image(
                invert_colors=True,
                source="canvas",
                interactive=False,
                image_mode="RGBA",
            )

        with gr.Column(scale=45):

            with gr.Group():
                with gr.Row():
                    with gr.Column(scale=70):
                        # g_strength = gr.Slider(
                        #     label="Compliance rate",
                        #     minimum=0,
                        #     maximum=2,
                        #     step=0.01,
                        #     value=0.4,
                        # )

                        text = gr.Textbox(
                            lines=2,
                            interactive=True,
                            label="Token to Draw: (Separate by comma)",
                        )

                        radio = gr.Radio([], label="Tokens",visible = False)

                    sk_update = gr.Button(value="Update").style(
                        rounded=(False, True, True, False)
                    )

                # g_strength.change(lambda b: gr.update(f"Scaled additional attn: $w = {b} \log (1 + \sigma) \std (Q^T K)$."), inputs=g_strength, outputs=[g_output])

            with gr.Tab("SketchPad"):

                sp = gr.Image(
                    width = 512,
                    height = 512,
                    image_mode="L",
                    tool="sketch",
                    source="canvas",
                    interactive=False
                )

                '''mask_outsides = gr.Checkbox(
                    label="Mask other areas", 
                    value=False
                )'''
                with gr.Row():
                    mask_outsides = gr.Slider(
                        label="Decrease unmarked region weight",
                        minimum=0,
                        maximum=3,
                        step=0.01,
                        value=0,
                    )

                    strength = gr.Slider(
                        label="Token-Region strength",
                        minimum=0,
                        maximum=3,
                        step=0.01,
                        value=0.5,
                    )

                width.change(
                    apply_size_sketch,
                    inputs=[width, height,global_stats,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, rendered,sp],
                    queue=False,
                )

                height.change(
                    apply_size_sketch,
                    inputs=[width, height,global_stats,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, rendered,sp],
                    queue=False,
                )

                inf_image.change(
                    apply_size_sketch,
                    inputs=[width, height,global_stats,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, rendered,sp],
                    queue=False,
                )


                sk_update.click(
                    detect_text,
                    inputs=[text, global_stats, width, height,formula_button,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, sp, radio, rendered,formula_button],
                    queue=False,
                )
                radio.change(
                    switch_canvas,
                    inputs=[radio, global_stats, width, height,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[sp, strength, mask_outsides, rendered],
                    queue=False,
                )
                sp.edit(
                    apply_canvas,
                    inputs=[radio, sp, global_stats, width, height,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, rendered],
                    queue=False,
                )
                strength.change(
                    apply_weight,
                    inputs=[radio, strength, global_stats],
                    outputs=[global_stats],
                    queue=False,
                )
                mask_outsides.change(
                    apply_option,
                    inputs=[radio, mask_outsides, global_stats],
                    outputs=[global_stats],
                    queue=False,
                )

            with gr.Tab("UploadFile"):

                sp2 = gr.Image(
                    image_mode="RGB",
                    source="upload",
                )

                sp3 = gr.Image(
                    image_mode="L",
                    source="canvas",
                    visible = False,
                    interactive = False,
                )
                with gr.Row():
                    previous_page = gr.Button(value="Previous",visible = False,)
                    next_page = gr.Button(value="Next",visible = False,)

                '''mask_outsides2 = gr.Checkbox(
                    label="Mask other areas", 
                    value=False,
                )'''

                with gr.Row():
                    mask_outsides2 = gr.Slider(
                        label="Decrease unmarked region weight",
                        minimum=0,
                        maximum=3,
                        step=0.01,
                        value=0,
                    )

                    strength2 = gr.Slider(
                        label="Token-Region strength",
                        minimum=0,
                        maximum=3,
                        step=0.01,
                        value=0.5,
                    )
                '''sk_update.click(
                    detect_text1,
                    inputs=[text, global_stats, width, height,formula_button,inf_image],
                    outputs=[global_stats, radio, rendered,formula_button],
                    queue=False,
                )'''


                with gr.Row():
                    apply_style = gr.Button(value="Apply")
                    apply_clustering_style = gr.Button(value="Extracting color regions")

                with gr.Row():
                    add_style = gr.Button(value="Apply",visible = False)
                    complete_clustering = gr.Button(value="Complete",visible = False)
                
                apply_style.click(
                    apply_image,
                    inputs=[sp2, radio, width, height, strength2, mask_outsides2, global_stats,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats, rendered],
                    queue=False,
                )
                apply_clustering_style.click(
                    apply_base_on_color,
                    inputs=[sp2,global_stats,width, height,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[rendered,apply_style,apply_clustering_style,previous_page,next_page,complete_clustering,sp2,sp3,add_style,global_stats],
                    queue=False,
                )
                previous_page.click(
                    previous_image_page,
                    inputs=[sp3],
                    outputs=[sp3],
                    queue=False,
                )
                next_page.click(
                    next_image_page,
                    inputs=[sp3],
                    outputs=[sp3],
                    queue=False,
                )
                add_style.click(
                    apply_image_clustering,
                    inputs=[sp3, radio, width, height, strength2, mask_outsides2, global_stats,inf_image,inpaiting_mode,inf_image_inpaiting],
                    outputs=[global_stats,rendered],
                    queue=False,
                )
                complete_clustering.click(
                    completing_clustering,
                    inputs=[sp2],
                    outputs=[apply_style,apply_clustering_style,previous_page,next_page,complete_clustering,sp2,sp3,add_style],
                    queue=False,
                )

            '''width.change(
                apply_new_res,
                inputs=[width, height, global_stats,inf_image,rendered],
                outputs=[global_stats, rendered],
                queue=False,
            )
            height.change(
                apply_new_res,
                inputs=[width, height, global_stats,inf_image,rendered],
                outputs=[global_stats, rendered],
                queue=False,
            )'''

    # color_stats = gr.State(value={})
    # text.change(detect_color, inputs=[sp, text, color_stats], outputs=[color_stats, rendered])
    # sp.change(detect_color, inputs=[sp, text, color_stats], outputs=[color_stats, rendered])

    inputs = [
        prompt,
        guidance,
        steps,
        width,
        height,
        clip_skip,
        seed,
        neg_prompt,
        global_stats,
        #g_strength,
        inf_image,
        inf_strength,
        hr_enabled,
        hr_method,
        hr_scale,
        hr_denoise,
        sampler,
        ti_state,
        model,
        lora_group,
        #lora_vals,
        #lora_scale,
        formula_button,
        controlnet_enabled,
        model_control_net,
        low_threshold,
        high_threshold,
        has_body_openpose,
        has_hand_openpose,
        has_face_openpose,
        controlnet_img,
        image_condition,
        controlnet_scale,
        preprocessor_name,
        diffuser_pipeline,
        sampler_hires,
        latent_processing,
        control_guidance_start,
        control_guidance_end,
        multi_controlnet,
        disable_preprocessing,
        region_condition,
        hr_process_enabled,
        ip_adapter,
        model_ip_adapter,
        inf_adapt_image,
        inf_adapt_image_strength,
        hr_region_condition,
        adapter_enabled,
        model_adapter,
        low_threshold_adapter,
        high_threshold_adapter,
        has_body_openpose_adapter,
        has_hand_openpose_adapter,
        has_face_openpose_adapter,
        adapter_img,
        image_condition_adapter,
        preprocessor_adapter,
        adapter_conditioning_scale,
        adapter_conditioning_factor,
        multi_adapter,
        disable_preprocessing_adapter,
        ip_adapter_multi,
        guidance_rescale,
        inf_control_adapt_image,
        long_encode,
        inpaiting_mode,
        invert_mask_mode,
        mask_upload,
        inf_image_inpaiting,
        invert_ip_adapter_mask_mode,
        vae_used,
    ]
    outputs = [image_out,gallery]
    prompt.submit(inference, inputs=inputs, outputs=outputs)
    generate.click(inference, inputs=inputs, outputs=outputs)

print(f"Space built in {time.time() - start_time:.2f} seconds")
#demo.queue().launch(share=True,debug=True)
demo.launch(enable_queue=True, server_name="0.0.0.0", server_port=7860)