|
import spaces
|
|
import os
|
|
from stablepy import (
|
|
Model_Diffusers,
|
|
SCHEDULE_TYPE_OPTIONS,
|
|
SCHEDULE_PREDICTION_TYPE_OPTIONS,
|
|
check_scheduler_compatibility,
|
|
TASK_AND_PREPROCESSORS,
|
|
)
|
|
from constants import (
|
|
TASK_STABLEPY,
|
|
TASK_MODEL_LIST,
|
|
UPSCALER_DICT_GUI,
|
|
UPSCALER_KEYS,
|
|
PROMPT_W_OPTIONS,
|
|
WARNING_MSG_VAE,
|
|
SDXL_TASK,
|
|
MODEL_TYPE_TASK,
|
|
POST_PROCESSING_SAMPLER,
|
|
DIFFUSERS_CONTROLNET_MODEL,
|
|
|
|
)
|
|
from stablepy.diffusers_vanilla.style_prompt_config import STYLE_NAMES
|
|
import torch
|
|
import re
|
|
from stablepy import (
|
|
scheduler_names,
|
|
IP_ADAPTERS_SD,
|
|
IP_ADAPTERS_SDXL,
|
|
)
|
|
import time
|
|
from PIL import ImageFile
|
|
from utils import (
|
|
get_model_list,
|
|
extract_parameters,
|
|
get_model_type,
|
|
extract_exif_data,
|
|
create_mask_now,
|
|
download_diffuser_repo,
|
|
get_used_storage_gb,
|
|
delete_model,
|
|
progress_step_bar,
|
|
html_template_message,
|
|
escape_html,
|
|
)
|
|
from image_processor import preprocessor_tab
|
|
from datetime import datetime
|
|
import gradio as gr
|
|
import logging
|
|
import diffusers
|
|
import warnings
|
|
from stablepy import logger
|
|
from diffusers import FluxPipeline
|
|
|
|
|
|
ImageFile.LOAD_TRUNCATED_IMAGES = True
|
|
torch.backends.cuda.matmul.allow_tf32 = True
|
|
|
|
print(os.getenv("SPACES_ZERO_GPU"))
|
|
|
|
|
|
logging.getLogger("diffusers").setLevel(logging.ERROR)
|
|
diffusers.utils.logging.set_verbosity(40)
|
|
warnings.filterwarnings(action="ignore", category=FutureWarning, module="diffusers")
|
|
warnings.filterwarnings(action="ignore", category=UserWarning, module="diffusers")
|
|
warnings.filterwarnings(action="ignore", category=FutureWarning, module="transformers")
|
|
logger.setLevel(logging.DEBUG)
|
|
|
|
from env import (
|
|
HF_TOKEN, HF_READ_TOKEN,
|
|
CIVITAI_API_KEY, HF_LORA_PRIVATE_REPOS1, HF_LORA_PRIVATE_REPOS2,
|
|
HF_LORA_ESSENTIAL_PRIVATE_REPO, HF_VAE_PRIVATE_REPO,
|
|
HF_SDXL_EMBEDS_NEGATIVE_PRIVATE_REPO, HF_SDXL_EMBEDS_POSITIVE_PRIVATE_REPO,
|
|
DIRECTORY_MODELS, DIRECTORY_LORAS, DIRECTORY_VAES, DIRECTORY_EMBEDS,
|
|
DIRECTORY_EMBEDS_SDXL, DIRECTORY_EMBEDS_POSITIVE_SDXL,
|
|
LOAD_DIFFUSERS_FORMAT_MODEL, DOWNLOAD_MODEL_LIST, DOWNLOAD_LORA_LIST,
|
|
DOWNLOAD_VAE_LIST, DOWNLOAD_EMBEDS)
|
|
|
|
from modutils import (to_list, list_uniq, list_sub, get_model_id_list, get_tupled_embed_list,
|
|
get_tupled_model_list, get_lora_model_list, download_private_repo, download_things)
|
|
|
|
|
|
download_model = ", ".join(DOWNLOAD_MODEL_LIST)
|
|
|
|
download_vae = ", ".join(DOWNLOAD_VAE_LIST)
|
|
|
|
download_lora = ", ".join(DOWNLOAD_LORA_LIST)
|
|
|
|
|
|
download_private_repo(HF_VAE_PRIVATE_REPO, DIRECTORY_VAES, False)
|
|
|
|
load_diffusers_format_model = list_uniq(LOAD_DIFFUSERS_FORMAT_MODEL + get_model_id_list())
|
|
|
|
|
|
|
|
for url in [url.strip() for url in download_model.split(',')]:
|
|
if not os.path.exists(f"./models/{url.split('/')[-1]}"):
|
|
download_things(DIRECTORY_MODELS, url, HF_TOKEN, CIVITAI_API_KEY)
|
|
for url in [url.strip() for url in download_vae.split(',')]:
|
|
if not os.path.exists(f"./vaes/{url.split('/')[-1]}"):
|
|
download_things(DIRECTORY_VAES, url, HF_TOKEN, CIVITAI_API_KEY)
|
|
for url in [url.strip() for url in download_lora.split(',')]:
|
|
if not os.path.exists(f"./loras/{url.split('/')[-1]}"):
|
|
download_things(DIRECTORY_LORAS, url, HF_TOKEN, CIVITAI_API_KEY)
|
|
|
|
|
|
for url_embed in DOWNLOAD_EMBEDS:
|
|
if not os.path.exists(f"./embedings/{url_embed.split('/')[-1]}"):
|
|
download_things(DIRECTORY_EMBEDS, url_embed, HF_TOKEN, CIVITAI_API_KEY)
|
|
|
|
|
|
embed_list = get_model_list(DIRECTORY_EMBEDS)
|
|
single_file_model_list = get_model_list(DIRECTORY_MODELS)
|
|
model_list = list_uniq(get_model_id_list() + LOAD_DIFFUSERS_FORMAT_MODEL + single_file_model_list)
|
|
|
|
|
|
lora_model_list = get_lora_model_list()
|
|
vae_model_list = get_model_list(DIRECTORY_VAES)
|
|
vae_model_list.insert(0, "BakedVAE")
|
|
vae_model_list.insert(0, "None")
|
|
|
|
download_private_repo(HF_SDXL_EMBEDS_NEGATIVE_PRIVATE_REPO, DIRECTORY_EMBEDS_SDXL, False)
|
|
download_private_repo(HF_SDXL_EMBEDS_POSITIVE_PRIVATE_REPO, DIRECTORY_EMBEDS_POSITIVE_SDXL, False)
|
|
embed_sdxl_list = get_model_list(DIRECTORY_EMBEDS_SDXL) + get_model_list(DIRECTORY_EMBEDS_POSITIVE_SDXL)
|
|
|
|
def get_embed_list(pipeline_name):
|
|
return get_tupled_embed_list(embed_sdxl_list if pipeline_name == "StableDiffusionXLPipeline" else embed_list)
|
|
|
|
|
|
print('\033[33m🏁 Download and listing of valid models completed.\033[0m')
|
|
|
|
flux_repo = "camenduru/FLUX.1-dev-diffusers"
|
|
flux_pipe = FluxPipeline.from_pretrained(
|
|
flux_repo,
|
|
transformer=None,
|
|
torch_dtype=torch.bfloat16,
|
|
).to("cuda")
|
|
components = flux_pipe.components
|
|
components.pop("transformer", None)
|
|
delete_model(flux_repo)
|
|
|
|
|
|
class GuiSD:
|
|
def __init__(self, stream=True):
|
|
self.model = None
|
|
self.status_loading = False
|
|
self.sleep_loading = 4
|
|
self.last_load = datetime.now()
|
|
self.inventory = []
|
|
|
|
def update_storage_models(self, storage_floor_gb=24, required_inventory_for_purge=3):
|
|
while get_used_storage_gb() > storage_floor_gb:
|
|
if len(self.inventory) < required_inventory_for_purge:
|
|
break
|
|
removal_candidate = self.inventory.pop(0)
|
|
delete_model(removal_candidate)
|
|
|
|
def update_inventory(self, model_name):
|
|
if model_name not in single_file_model_list:
|
|
self.inventory = [
|
|
m for m in self.inventory if m != model_name
|
|
] + [model_name]
|
|
print(self.inventory)
|
|
|
|
def load_new_model(self, model_name, vae_model, task, controlnet_model, progress=gr.Progress(track_tqdm=True)):
|
|
|
|
|
|
|
|
self.update_storage_models()
|
|
|
|
vae_model = vae_model if vae_model != "None" else None
|
|
model_type = get_model_type(model_name)
|
|
dtype_model = torch.bfloat16 if model_type == "FLUX" else torch.float16
|
|
|
|
if not os.path.exists(model_name):
|
|
_ = download_diffuser_repo(
|
|
repo_name=model_name,
|
|
model_type=model_type,
|
|
revision="main",
|
|
token=True,
|
|
)
|
|
|
|
self.update_inventory(model_name)
|
|
|
|
for i in range(68):
|
|
if not self.status_loading:
|
|
self.status_loading = True
|
|
if i > 0:
|
|
time.sleep(self.sleep_loading)
|
|
print("Previous model ops...")
|
|
break
|
|
time.sleep(0.5)
|
|
print(f"Waiting queue {i}")
|
|
yield "Waiting queue"
|
|
|
|
self.status_loading = True
|
|
|
|
yield f"Loading model: {model_name}"
|
|
|
|
if vae_model == "BakedVAE":
|
|
if not os.path.exists(model_name):
|
|
vae_model = model_name
|
|
else:
|
|
vae_model = None
|
|
elif vae_model:
|
|
vae_type = "SDXL" if "sdxl" in vae_model.lower() else "SD 1.5"
|
|
if model_type != vae_type:
|
|
gr.Warning(WARNING_MSG_VAE)
|
|
|
|
print("Loading model...")
|
|
|
|
try:
|
|
start_time = time.time()
|
|
|
|
if self.model is None:
|
|
self.model = Model_Diffusers(
|
|
base_model_id=model_name,
|
|
task_name=TASK_STABLEPY[task],
|
|
vae_model=vae_model,
|
|
type_model_precision=dtype_model,
|
|
retain_task_model_in_cache=False,
|
|
controlnet_model=controlnet_model,
|
|
device="cpu",
|
|
env_components=components,
|
|
)
|
|
self.model.advanced_params(image_preprocessor_cuda_active=True)
|
|
else:
|
|
if self.model.base_model_id != model_name:
|
|
load_now_time = datetime.now()
|
|
elapsed_time = max((load_now_time - self.last_load).total_seconds(), 0)
|
|
|
|
if elapsed_time <= 9:
|
|
print("Waiting for the previous model's time ops...")
|
|
time.sleep(9 - elapsed_time)
|
|
|
|
self.model.device = torch.device("cpu")
|
|
self.model.load_pipe(
|
|
model_name,
|
|
task_name=TASK_STABLEPY[task],
|
|
vae_model=vae_model,
|
|
type_model_precision=dtype_model,
|
|
retain_task_model_in_cache=False,
|
|
controlnet_model=controlnet_model,
|
|
)
|
|
|
|
end_time = time.time()
|
|
self.sleep_loading = max(min(int(end_time - start_time), 10), 4)
|
|
except Exception as e:
|
|
self.last_load = datetime.now()
|
|
self.status_loading = False
|
|
self.sleep_loading = 4
|
|
raise e
|
|
|
|
self.last_load = datetime.now()
|
|
self.status_loading = False
|
|
|
|
yield f"Model loaded: {model_name}"
|
|
|
|
|
|
@torch.inference_mode()
|
|
def generate_pipeline(
|
|
self,
|
|
prompt,
|
|
neg_prompt,
|
|
num_images,
|
|
steps,
|
|
cfg,
|
|
clip_skip,
|
|
seed,
|
|
lora1,
|
|
lora_scale1,
|
|
lora2,
|
|
lora_scale2,
|
|
lora3,
|
|
lora_scale3,
|
|
lora4,
|
|
lora_scale4,
|
|
lora5,
|
|
lora_scale5,
|
|
lora6,
|
|
lora_scale6,
|
|
lora7,
|
|
lora_scale7,
|
|
sampler,
|
|
schedule_type,
|
|
schedule_prediction_type,
|
|
img_height,
|
|
img_width,
|
|
model_name,
|
|
vae_model,
|
|
task,
|
|
image_control,
|
|
preprocessor_name,
|
|
preprocess_resolution,
|
|
image_resolution,
|
|
style_prompt,
|
|
style_json_file,
|
|
image_mask,
|
|
strength,
|
|
low_threshold,
|
|
high_threshold,
|
|
value_threshold,
|
|
distance_threshold,
|
|
recolor_gamma_correction,
|
|
tile_blur_sigma,
|
|
controlnet_output_scaling_in_unet,
|
|
controlnet_start_threshold,
|
|
controlnet_stop_threshold,
|
|
textual_inversion,
|
|
syntax_weights,
|
|
upscaler_model_path,
|
|
upscaler_increases_size,
|
|
esrgan_tile,
|
|
esrgan_tile_overlap,
|
|
hires_steps,
|
|
hires_denoising_strength,
|
|
hires_sampler,
|
|
hires_prompt,
|
|
hires_negative_prompt,
|
|
hires_before_adetailer,
|
|
hires_after_adetailer,
|
|
hires_schedule_type,
|
|
hires_guidance_scale,
|
|
controlnet_model,
|
|
loop_generation,
|
|
leave_progress_bar,
|
|
disable_progress_bar,
|
|
image_previews,
|
|
display_images,
|
|
save_generated_images,
|
|
filename_pattern,
|
|
image_storage_location,
|
|
retain_compel_previous_load,
|
|
retain_detailfix_model_previous_load,
|
|
retain_hires_model_previous_load,
|
|
t2i_adapter_preprocessor,
|
|
t2i_adapter_conditioning_scale,
|
|
t2i_adapter_conditioning_factor,
|
|
xformers_memory_efficient_attention,
|
|
freeu,
|
|
generator_in_cpu,
|
|
adetailer_inpaint_only,
|
|
adetailer_verbose,
|
|
adetailer_sampler,
|
|
adetailer_active_a,
|
|
prompt_ad_a,
|
|
negative_prompt_ad_a,
|
|
strength_ad_a,
|
|
face_detector_ad_a,
|
|
person_detector_ad_a,
|
|
hand_detector_ad_a,
|
|
mask_dilation_a,
|
|
mask_blur_a,
|
|
mask_padding_a,
|
|
adetailer_active_b,
|
|
prompt_ad_b,
|
|
negative_prompt_ad_b,
|
|
strength_ad_b,
|
|
face_detector_ad_b,
|
|
person_detector_ad_b,
|
|
hand_detector_ad_b,
|
|
mask_dilation_b,
|
|
mask_blur_b,
|
|
mask_padding_b,
|
|
retain_task_cache_gui,
|
|
guidance_rescale,
|
|
image_ip1,
|
|
mask_ip1,
|
|
model_ip1,
|
|
mode_ip1,
|
|
scale_ip1,
|
|
image_ip2,
|
|
mask_ip2,
|
|
model_ip2,
|
|
mode_ip2,
|
|
scale_ip2,
|
|
pag_scale,
|
|
):
|
|
info_state = html_template_message("Navigating latent space...")
|
|
yield info_state, gr.update(), gr.update()
|
|
|
|
vae_model = vae_model if vae_model != "None" else None
|
|
loras_list = [lora1, lora2, lora3, lora4, lora5, lora6, lora7]
|
|
vae_msg = f"VAE: {vae_model}" if vae_model else ""
|
|
msg_lora = ""
|
|
|
|
|
|
loras_list = [s if s else "None" for s in loras_list]
|
|
global lora_model_list
|
|
lora_model_list = get_lora_model_list()
|
|
|
|
|
|
print("Config model:", model_name, vae_model, loras_list)
|
|
|
|
task = TASK_STABLEPY[task]
|
|
|
|
params_ip_img = []
|
|
params_ip_msk = []
|
|
params_ip_model = []
|
|
params_ip_mode = []
|
|
params_ip_scale = []
|
|
|
|
all_adapters = [
|
|
(image_ip1, mask_ip1, model_ip1, mode_ip1, scale_ip1),
|
|
(image_ip2, mask_ip2, model_ip2, mode_ip2, scale_ip2),
|
|
]
|
|
|
|
if not hasattr(self.model.pipe, "transformer"):
|
|
for imgip, mskip, modelip, modeip, scaleip in all_adapters:
|
|
if imgip:
|
|
params_ip_img.append(imgip)
|
|
if mskip:
|
|
params_ip_msk.append(mskip)
|
|
params_ip_model.append(modelip)
|
|
params_ip_mode.append(modeip)
|
|
params_ip_scale.append(scaleip)
|
|
|
|
concurrency = 5
|
|
self.model.stream_config(concurrency=concurrency, latent_resize_by=1, vae_decoding=False)
|
|
|
|
if task != "txt2img" and not image_control:
|
|
raise ValueError("No control image found: To use this function, you have to upload an image in 'Image ControlNet/Inpaint/Img2img'")
|
|
|
|
if task == "inpaint" and not image_mask:
|
|
raise ValueError("No mask image found: Specify one in 'Image Mask'")
|
|
|
|
if upscaler_model_path in UPSCALER_KEYS[:9]:
|
|
upscaler_model = upscaler_model_path
|
|
else:
|
|
directory_upscalers = 'upscalers'
|
|
os.makedirs(directory_upscalers, exist_ok=True)
|
|
|
|
url_upscaler = UPSCALER_DICT_GUI[upscaler_model_path]
|
|
|
|
if not os.path.exists(f"./upscalers/{url_upscaler.split('/')[-1]}"):
|
|
download_things(directory_upscalers, url_upscaler, HF_TOKEN)
|
|
|
|
upscaler_model = f"./upscalers/{url_upscaler.split('/')[-1]}"
|
|
|
|
logging.getLogger("ultralytics").setLevel(logging.INFO if adetailer_verbose else logging.ERROR)
|
|
|
|
adetailer_params_A = {
|
|
"face_detector_ad": face_detector_ad_a,
|
|
"person_detector_ad": person_detector_ad_a,
|
|
"hand_detector_ad": hand_detector_ad_a,
|
|
"prompt": prompt_ad_a,
|
|
"negative_prompt": negative_prompt_ad_a,
|
|
"strength": strength_ad_a,
|
|
|
|
"mask_dilation": mask_dilation_a,
|
|
"mask_blur": mask_blur_a,
|
|
"mask_padding": mask_padding_a,
|
|
"inpaint_only": adetailer_inpaint_only,
|
|
"sampler": adetailer_sampler,
|
|
}
|
|
|
|
adetailer_params_B = {
|
|
"face_detector_ad": face_detector_ad_b,
|
|
"person_detector_ad": person_detector_ad_b,
|
|
"hand_detector_ad": hand_detector_ad_b,
|
|
"prompt": prompt_ad_b,
|
|
"negative_prompt": negative_prompt_ad_b,
|
|
"strength": strength_ad_b,
|
|
|
|
"mask_dilation": mask_dilation_b,
|
|
"mask_blur": mask_blur_b,
|
|
"mask_padding": mask_padding_b,
|
|
}
|
|
pipe_params = {
|
|
"prompt": prompt,
|
|
"negative_prompt": neg_prompt,
|
|
"img_height": img_height,
|
|
"img_width": img_width,
|
|
"num_images": num_images,
|
|
"num_steps": steps,
|
|
"guidance_scale": cfg,
|
|
"clip_skip": clip_skip,
|
|
"pag_scale": float(pag_scale),
|
|
"seed": seed,
|
|
"image": image_control,
|
|
"preprocessor_name": preprocessor_name,
|
|
"preprocess_resolution": preprocess_resolution,
|
|
"image_resolution": image_resolution,
|
|
"style_prompt": style_prompt if style_prompt else "",
|
|
"style_json_file": "",
|
|
"image_mask": image_mask,
|
|
"strength": strength,
|
|
"low_threshold": low_threshold,
|
|
"high_threshold": high_threshold,
|
|
"value_threshold": value_threshold,
|
|
"distance_threshold": distance_threshold,
|
|
"recolor_gamma_correction": float(recolor_gamma_correction),
|
|
"tile_blur_sigma": int(tile_blur_sigma),
|
|
"lora_A": lora1 if lora1 != "None" else None,
|
|
"lora_scale_A": lora_scale1,
|
|
"lora_B": lora2 if lora2 != "None" else None,
|
|
"lora_scale_B": lora_scale2,
|
|
"lora_C": lora3 if lora3 != "None" else None,
|
|
"lora_scale_C": lora_scale3,
|
|
"lora_D": lora4 if lora4 != "None" else None,
|
|
"lora_scale_D": lora_scale4,
|
|
"lora_E": lora5 if lora5 != "None" else None,
|
|
"lora_scale_E": lora_scale5,
|
|
"lora_F": lora6 if lora6 != "None" else None,
|
|
"lora_scale_F": lora_scale6,
|
|
"lora_G": lora7 if lora7 != "None" else None,
|
|
"lora_scale_G": lora_scale7,
|
|
|
|
"textual_inversion": get_embed_list(self.model.class_name) if textual_inversion else [],
|
|
|
|
"syntax_weights": syntax_weights,
|
|
"sampler": sampler,
|
|
"schedule_type": schedule_type,
|
|
"schedule_prediction_type": schedule_prediction_type,
|
|
"xformers_memory_efficient_attention": xformers_memory_efficient_attention,
|
|
"gui_active": True,
|
|
"loop_generation": loop_generation,
|
|
"controlnet_conditioning_scale": float(controlnet_output_scaling_in_unet),
|
|
"control_guidance_start": float(controlnet_start_threshold),
|
|
"control_guidance_end": float(controlnet_stop_threshold),
|
|
"generator_in_cpu": generator_in_cpu,
|
|
"FreeU": freeu,
|
|
"adetailer_A": adetailer_active_a,
|
|
"adetailer_A_params": adetailer_params_A,
|
|
"adetailer_B": adetailer_active_b,
|
|
"adetailer_B_params": adetailer_params_B,
|
|
"leave_progress_bar": leave_progress_bar,
|
|
"disable_progress_bar": disable_progress_bar,
|
|
"image_previews": image_previews,
|
|
"display_images": display_images,
|
|
"save_generated_images": save_generated_images,
|
|
"filename_pattern": filename_pattern,
|
|
"image_storage_location": image_storage_location,
|
|
"retain_compel_previous_load": retain_compel_previous_load,
|
|
"retain_detailfix_model_previous_load": retain_detailfix_model_previous_load,
|
|
"retain_hires_model_previous_load": retain_hires_model_previous_load,
|
|
"t2i_adapter_preprocessor": t2i_adapter_preprocessor,
|
|
"t2i_adapter_conditioning_scale": float(t2i_adapter_conditioning_scale),
|
|
"t2i_adapter_conditioning_factor": float(t2i_adapter_conditioning_factor),
|
|
"upscaler_model_path": upscaler_model,
|
|
"upscaler_increases_size": upscaler_increases_size,
|
|
"esrgan_tile": esrgan_tile,
|
|
"esrgan_tile_overlap": esrgan_tile_overlap,
|
|
"hires_steps": hires_steps,
|
|
"hires_denoising_strength": hires_denoising_strength,
|
|
"hires_prompt": hires_prompt,
|
|
"hires_negative_prompt": hires_negative_prompt,
|
|
"hires_sampler": hires_sampler,
|
|
"hires_before_adetailer": hires_before_adetailer,
|
|
"hires_after_adetailer": hires_after_adetailer,
|
|
"hires_schedule_type": hires_schedule_type,
|
|
"hires_guidance_scale": hires_guidance_scale,
|
|
"ip_adapter_image": params_ip_img,
|
|
"ip_adapter_mask": params_ip_msk,
|
|
"ip_adapter_model": params_ip_model,
|
|
"ip_adapter_mode": params_ip_mode,
|
|
"ip_adapter_scale": params_ip_scale,
|
|
}
|
|
|
|
|
|
if guidance_rescale:
|
|
pipe_params["guidance_rescale"] = guidance_rescale
|
|
|
|
self.model.device = torch.device("cuda:0")
|
|
if hasattr(self.model.pipe, "transformer") and loras_list != ["None"] * self.model.num_loras:
|
|
self.model.pipe.transformer.to(self.model.device)
|
|
print("transformer to cuda")
|
|
|
|
actual_progress = 0
|
|
info_images = gr.update()
|
|
for img, [seed, image_path, metadata] in self.model(**pipe_params):
|
|
info_state = progress_step_bar(actual_progress, steps)
|
|
actual_progress += concurrency
|
|
if image_path:
|
|
info_images = f"Seeds: {str(seed)}"
|
|
if vae_msg:
|
|
info_images = info_images + "<br>" + vae_msg
|
|
|
|
if "Cannot copy out of meta tensor; no data!" in self.model.last_lora_error:
|
|
msg_ram = "Unable to process the LoRAs due to high RAM usage; please try again later."
|
|
print(msg_ram)
|
|
msg_lora += f"<br>{msg_ram}"
|
|
|
|
for status, lora in zip(self.model.lora_status, self.model.lora_memory):
|
|
if status:
|
|
msg_lora += f"<br>Loaded: {lora}"
|
|
elif status is not None:
|
|
msg_lora += f"<br>Error with: {lora}"
|
|
|
|
if msg_lora:
|
|
info_images += msg_lora
|
|
|
|
info_images = info_images + "<br>" + "GENERATION DATA:<br>" + escape_html(metadata[-1]) + "<br>-------<br>"
|
|
|
|
download_links = "<br>".join(
|
|
[
|
|
f'<a href="{path.replace("/images/", "/file=/home/user/app/images/")}" download="{os.path.basename(path)}">Download Image {i + 1}</a>'
|
|
for i, path in enumerate(image_path)
|
|
]
|
|
)
|
|
if save_generated_images:
|
|
info_images += f"<br>{download_links}"
|
|
|
|
if not isinstance(img, list): img = [img]
|
|
img = save_images(img, metadata)
|
|
img = [(i, None) for i in img]
|
|
|
|
info_state = "COMPLETE"
|
|
|
|
yield info_state, img, info_images
|
|
|
|
|
|
def dynamic_gpu_duration(func, duration, *args):
|
|
|
|
@spaces.GPU(duration=duration)
|
|
def wrapped_func():
|
|
yield from func(*args)
|
|
|
|
return wrapped_func()
|
|
|
|
|
|
@spaces.GPU
|
|
def dummy_gpu():
|
|
return None
|
|
|
|
|
|
def sd_gen_generate_pipeline(*args):
|
|
gpu_duration_arg = int(args[-1]) if args[-1] else 59
|
|
verbose_arg = int(args[-2])
|
|
load_lora_cpu = args[-3]
|
|
generation_args = args[:-3]
|
|
lora_list = [
|
|
None if item == "None" or item == "" else item
|
|
for item in [args[7], args[9], args[11], args[13], args[15], args[17], args[19]]
|
|
]
|
|
lora_status = [None] * sd_gen.model.num_loras
|
|
|
|
msg_load_lora = "Updating LoRAs in GPU..."
|
|
if load_lora_cpu:
|
|
msg_load_lora = "Updating LoRAs in CPU..."
|
|
|
|
if lora_list != sd_gen.model.lora_memory and lora_list != [None] * sd_gen.model.num_loras:
|
|
yield msg_load_lora, gr.update(), gr.update()
|
|
|
|
|
|
if load_lora_cpu:
|
|
lora_status = sd_gen.model.load_lora_on_the_fly(
|
|
lora_A=lora_list[0], lora_scale_A=args[8],
|
|
lora_B=lora_list[1], lora_scale_B=args[10],
|
|
lora_C=lora_list[2], lora_scale_C=args[12],
|
|
lora_D=lora_list[3], lora_scale_D=args[14],
|
|
lora_E=lora_list[4], lora_scale_E=args[16],
|
|
lora_F=lora_list[5], lora_scale_F=args[18],
|
|
lora_G=lora_list[6], lora_scale_G=args[20],
|
|
)
|
|
print(lora_status)
|
|
|
|
sampler_name = args[21]
|
|
schedule_type_name = args[22]
|
|
_, _, msg_sampler = check_scheduler_compatibility(
|
|
sd_gen.model.class_name, sampler_name, schedule_type_name
|
|
)
|
|
if msg_sampler:
|
|
gr.Warning(msg_sampler)
|
|
|
|
if verbose_arg:
|
|
for status, lora in zip(lora_status, lora_list):
|
|
if status:
|
|
gr.Info(f"LoRA loaded in CPU: {lora}")
|
|
elif status is not None:
|
|
gr.Warning(f"Failed to load LoRA: {lora}")
|
|
|
|
if lora_status == [None] * sd_gen.model.num_loras and sd_gen.model.lora_memory != [None] * sd_gen.model.num_loras and load_lora_cpu:
|
|
lora_cache_msg = ", ".join(
|
|
str(x) for x in sd_gen.model.lora_memory if x is not None
|
|
)
|
|
gr.Info(f"LoRAs in cache: {lora_cache_msg}")
|
|
|
|
msg_request = f"Requesting {gpu_duration_arg}s. of GPU time.\nModel: {sd_gen.model.base_model_id}"
|
|
if verbose_arg:
|
|
gr.Info(msg_request)
|
|
print(msg_request)
|
|
yield msg_request.replace("\n", "<br>"), gr.update(), gr.update()
|
|
|
|
start_time = time.time()
|
|
|
|
|
|
yield from dynamic_gpu_duration(
|
|
sd_gen.generate_pipeline,
|
|
gpu_duration_arg,
|
|
*generation_args,
|
|
)
|
|
|
|
end_time = time.time()
|
|
execution_time = end_time - start_time
|
|
msg_task_complete = (
|
|
f"GPU task complete in: {int(round(execution_time, 0) + 1)} seconds"
|
|
)
|
|
|
|
if verbose_arg:
|
|
gr.Info(msg_task_complete)
|
|
print(msg_task_complete)
|
|
|
|
yield msg_task_complete, gr.update(), gr.update()
|
|
|
|
|
|
@spaces.GPU(duration=15)
|
|
def esrgan_upscale(image, upscaler_name, upscaler_size):
|
|
if image is None: return None
|
|
|
|
from stablepy.diffusers_vanilla.utils import save_pil_image_with_metadata
|
|
from stablepy import UpscalerESRGAN
|
|
|
|
exif_image = extract_exif_data(image)
|
|
|
|
url_upscaler = UPSCALER_DICT_GUI[upscaler_name]
|
|
directory_upscalers = 'upscalers'
|
|
os.makedirs(directory_upscalers, exist_ok=True)
|
|
if not os.path.exists(f"./upscalers/{url_upscaler.split('/')[-1]}"):
|
|
download_things(directory_upscalers, url_upscaler, HF_TOKEN)
|
|
|
|
scaler_beta = UpscalerESRGAN(0, 0)
|
|
image_up = scaler_beta.upscale(image, upscaler_size, f"./upscalers/{url_upscaler.split('/')[-1]}")
|
|
|
|
image_path = save_pil_image_with_metadata(image_up, f'{os.getcwd()}/up_images', exif_image)
|
|
|
|
return image_path
|
|
|
|
|
|
|
|
dynamic_gpu_duration.zerogpu = True
|
|
sd_gen_generate_pipeline.zerogpu = True
|
|
sd_gen = GuiSD()
|
|
|
|
|
|
from pathlib import Path
|
|
from PIL import Image
|
|
import PIL
|
|
import numpy as np
|
|
import random
|
|
import json
|
|
import shutil
|
|
from tagger.tagger import insert_model_recom_prompt
|
|
from modutils import (safe_float, escape_lora_basename, to_lora_key, to_lora_path, valid_model_name, set_textual_inversion_prompt,
|
|
get_local_model_list, get_model_pipeline, get_private_lora_model_lists, get_valid_lora_name, get_state, set_state,
|
|
get_valid_lora_path, get_valid_lora_wt, get_lora_info, CIVITAI_SORT, CIVITAI_PERIOD, CIVITAI_BASEMODEL,
|
|
normalize_prompt_list, get_civitai_info, search_lora_on_civitai, translate_to_en, get_t2i_model_info, get_civitai_tag, save_image_history,
|
|
get_all_lora_list, get_all_lora_tupled_list, update_lora_dict, download_lora, copy_lora, download_my_lora, set_prompt_loras,
|
|
apply_lora_prompt, update_loras, search_civitai_lora, search_civitai_lora_json, update_civitai_selection, select_civitai_lora)
|
|
|
|
|
|
|
|
def infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps,
|
|
model_name=load_diffusers_format_model[0], lora1=None, lora1_wt=1.0, lora2=None, lora2_wt=1.0,
|
|
lora3=None, lora3_wt=1.0, lora4=None, lora4_wt=1.0, lora5=None, lora5_wt=1.0, lora6=None, lora6_wt=1.0, lora7=None, lora7_wt=1.0,
|
|
task=TASK_MODEL_LIST[0], prompt_syntax="Classic", sampler="Euler", vae=None, schedule_type=SCHEDULE_TYPE_OPTIONS[0], schedule_prediction_type=SCHEDULE_PREDICTION_TYPE_OPTIONS[0],
|
|
clip_skip=True, pag_scale=0.0, free_u=False, guidance_rescale=0., image_control=None, image_mask=None, strength=0.35, image_resolution=1024,
|
|
controlnet_model=DIFFUSERS_CONTROLNET_MODEL[0], control_net_output_scaling=1.0, control_net_start_threshold=0., control_net_stop_threshold=1.,
|
|
preprocessor_name="Canny", preprocess_resolution=512, low_threshold=100, high_threshold=200,
|
|
value_threshold=0.1, distance_threshold=0.1, recolor_gamma_correction=1., tile_blur_sigma=9,
|
|
image_ip1=None, mask_ip1=None, model_ip1="plus_face", mode_ip1="original", scale_ip1=0.7,
|
|
image_ip2=None, mask_ip2=None, model_ip2="base", mode_ip2="style", scale_ip2=0.7,
|
|
upscaler_model_path=None, upscaler_increases_size=1.0, esrgan_tile=5, esrgan_tile_overlap=8, hires_steps=30, hires_denoising_strength=0.55,
|
|
hires_sampler="Use same sampler", hires_schedule_type="Use same schedule type", hires_guidance_scale=-1, hires_prompt="", hires_negative_prompt="",
|
|
adetailer_inpaint_only=True, adetailer_verbose=False, adetailer_sampler="Use same sampler", adetailer_active_a=False,
|
|
prompt_ad_a="", negative_prompt_ad_a="", strength_ad_a=0.35, face_detector_ad_a=True, person_detector_ad_a=True, hand_detector_ad_a=False,
|
|
mask_dilation_a=4, mask_blur_a=4, mask_padding_a=32, adetailer_active_b=False, prompt_ad_b="", negative_prompt_ad_b="", strength_ad_b=0.35,
|
|
face_detector_ad_b=True, person_detector_ad_b=True, hand_detector_ad_b=False, mask_dilation_b=4, mask_blur_b=4, mask_padding_b=32,
|
|
active_textual_inversion=False, gpu_duration=59, translate=False, recom_prompt=True, progress=gr.Progress(track_tqdm=True)):
|
|
MAX_SEED = np.iinfo(np.int32).max
|
|
|
|
style_prompt = None
|
|
style_json = None
|
|
hires_before_adetailer = False
|
|
hires_after_adetailer = True
|
|
loop_generation = 1
|
|
leave_progress_bar = True
|
|
disable_progress_bar = False
|
|
image_previews = True
|
|
display_images = False
|
|
save_generated_images = False
|
|
filename_pattern = "model,seed"
|
|
image_storage_location = "./images"
|
|
retain_compel_previous_load = False
|
|
retain_detailfix_model_previous_load = False
|
|
retain_hires_model_previous_load = False
|
|
t2i_adapter_preprocessor = True
|
|
adapter_conditioning_scale = 1
|
|
adapter_conditioning_factor = 0.55
|
|
xformers_memory_efficient_attention = False
|
|
generator_in_cpu = False
|
|
retain_task_cache = True
|
|
load_lora_cpu = False
|
|
verbose_info = False
|
|
|
|
images: list[tuple[PIL.Image.Image, str | None]] = []
|
|
progress(0, desc="Preparing...")
|
|
|
|
if randomize_seed: seed = random.randint(0, MAX_SEED)
|
|
generator = torch.Generator().manual_seed(seed).seed()
|
|
|
|
if translate:
|
|
prompt = translate_to_en(prompt)
|
|
negative_prompt = translate_to_en(prompt)
|
|
|
|
prompt, negative_prompt = insert_model_recom_prompt(prompt, negative_prompt, model_name, recom_prompt)
|
|
progress(0.5, desc="Preparing...")
|
|
lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt = \
|
|
set_prompt_loras(prompt, prompt_syntax, model_name, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt, lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt)
|
|
lora1 = get_valid_lora_path(lora1)
|
|
lora2 = get_valid_lora_path(lora2)
|
|
lora3 = get_valid_lora_path(lora3)
|
|
lora4 = get_valid_lora_path(lora4)
|
|
lora5 = get_valid_lora_path(lora5)
|
|
lora6 = get_valid_lora_path(lora6)
|
|
lora7 = get_valid_lora_path(lora7)
|
|
progress(1, desc="Preparation completed. Starting inference...")
|
|
|
|
progress(0, desc="Loading model...")
|
|
for _ in sd_gen.load_new_model(valid_model_name(model_name), vae, task, controlnet_model):
|
|
pass
|
|
progress(1, desc="Model loaded.")
|
|
progress(0, desc="Starting Inference...")
|
|
for info_state, stream_images, info_images in sd_gen_generate_pipeline(prompt, negative_prompt, 1, num_inference_steps,
|
|
guidance_scale, clip_skip, generator, lora1, lora1_wt, lora2, lora2_wt, lora3, lora3_wt,
|
|
lora4, lora4_wt, lora5, lora5_wt, lora6, lora6_wt, lora7, lora7_wt, sampler, schedule_type, schedule_prediction_type,
|
|
height, width, model_name, vae, task, image_control, preprocessor_name, preprocess_resolution, image_resolution,
|
|
style_prompt, style_json, image_mask, strength, low_threshold, high_threshold, value_threshold, distance_threshold,
|
|
recolor_gamma_correction, tile_blur_sigma, control_net_output_scaling, control_net_start_threshold, control_net_stop_threshold,
|
|
active_textual_inversion, prompt_syntax, upscaler_model_path, upscaler_increases_size, esrgan_tile, esrgan_tile_overlap,
|
|
hires_steps, hires_denoising_strength, hires_sampler, hires_prompt, hires_negative_prompt, hires_before_adetailer, hires_after_adetailer,
|
|
hires_schedule_type, hires_guidance_scale, controlnet_model, loop_generation, leave_progress_bar, disable_progress_bar, image_previews,
|
|
display_images, save_generated_images, filename_pattern, image_storage_location, retain_compel_previous_load, retain_detailfix_model_previous_load,
|
|
retain_hires_model_previous_load, t2i_adapter_preprocessor, adapter_conditioning_scale, adapter_conditioning_factor, xformers_memory_efficient_attention,
|
|
free_u, generator_in_cpu, adetailer_inpaint_only, adetailer_verbose, adetailer_sampler, adetailer_active_a, prompt_ad_a, negative_prompt_ad_a,
|
|
strength_ad_a, face_detector_ad_a, person_detector_ad_a, hand_detector_ad_a, mask_dilation_a, mask_blur_a, mask_padding_a,
|
|
adetailer_active_b, prompt_ad_b, negative_prompt_ad_b, strength_ad_b, face_detector_ad_b, person_detector_ad_b, hand_detector_ad_b,
|
|
mask_dilation_b, mask_blur_b, mask_padding_b, retain_task_cache, guidance_rescale, image_ip1, mask_ip1, model_ip1, mode_ip1, scale_ip1,
|
|
image_ip2, mask_ip2, model_ip2, mode_ip2, scale_ip2, pag_scale, load_lora_cpu, verbose_info, gpu_duration
|
|
):
|
|
images = stream_images if isinstance(stream_images, list) else images
|
|
progress(1, desc="Inference completed.")
|
|
output_image = images[0][0] if images else None
|
|
|
|
return output_image
|
|
|
|
|
|
|
|
def _infer(prompt, negative_prompt, seed, randomize_seed, width, height, guidance_scale, num_inference_steps,
|
|
model_name=load_diffusers_format_model[0], lora1=None, lora1_wt=1.0, lora2=None, lora2_wt=1.0,
|
|
lora3=None, lora3_wt=1.0, lora4=None, lora4_wt=1.0, lora5=None, lora5_wt=1.0, lora6=None, lora6_wt=1.0, lora7=None, lora7_wt=1.0,
|
|
task=TASK_MODEL_LIST[0], prompt_syntax="Classic", sampler="Euler", vae=None, schedule_type=SCHEDULE_TYPE_OPTIONS[0], schedule_prediction_type=SCHEDULE_PREDICTION_TYPE_OPTIONS[0],
|
|
clip_skip=True, pag_scale=0.0, free_u=False, guidance_rescale=0., gpu_duration=59, translate=False, recom_prompt=True, progress=gr.Progress(track_tqdm=True)):
|
|
return gr.update()
|
|
|
|
|
|
infer.zerogpu = True
|
|
_infer.zerogpu = True
|
|
|
|
|
|
def pass_result(result):
|
|
return result
|
|
|
|
|
|
def get_samplers():
|
|
return scheduler_names
|
|
|
|
|
|
def get_vaes():
|
|
return vae_model_list
|
|
|
|
|
|
def update_task_options(model_name, task_name):
|
|
new_choices = MODEL_TYPE_TASK[get_model_type(valid_model_name(model_name))]
|
|
|
|
if task_name not in new_choices:
|
|
task_name = "txt2img"
|
|
|
|
return gr.update(value=task_name, choices=new_choices)
|
|
|
|
|
|
def change_preprocessor_choices(task):
|
|
task = TASK_STABLEPY[task]
|
|
if task in TASK_AND_PREPROCESSORS.keys():
|
|
choices_task = TASK_AND_PREPROCESSORS[task]
|
|
else:
|
|
choices_task = TASK_AND_PREPROCESSORS["canny"]
|
|
return gr.update(choices=choices_task, value=choices_task[0])
|
|
|
|
|
|
def get_ti_choices(model_name: str):
|
|
return get_embed_list(get_model_pipeline(valid_model_name(model_name)))
|
|
|
|
|
|
def update_textual_inversion(active_textual_inversion: bool, model_name: str):
|
|
return gr.update(choices=get_ti_choices(model_name) if active_textual_inversion else [])
|
|
|
|
|
|
cached_diffusers_model_tupled_list = get_tupled_model_list(load_diffusers_format_model)
|
|
def get_diffusers_model_list(state: dict = {}):
|
|
show_diffusers_model_list_detail = get_state(state, "show_diffusers_model_list_detail")
|
|
if show_diffusers_model_list_detail:
|
|
return cached_diffusers_model_tupled_list
|
|
else:
|
|
return load_diffusers_format_model
|
|
|
|
|
|
def enable_diffusers_model_detail(is_enable: bool = False, model_name: str = "", state: dict = {}):
|
|
show_diffusers_model_list_detail = is_enable
|
|
new_value = model_name
|
|
index = 0
|
|
if model_name in set(load_diffusers_format_model):
|
|
index = load_diffusers_format_model.index(model_name)
|
|
if is_enable:
|
|
new_value = cached_diffusers_model_tupled_list[index][1]
|
|
else:
|
|
new_value = load_diffusers_format_model[index]
|
|
set_state(state, "show_diffusers_model_list_detail", show_diffusers_model_list_detail)
|
|
return gr.update(value=is_enable), gr.update(value=new_value, choices=get_diffusers_model_list(state)), state
|
|
|
|
|
|
quality_prompt_list = [
|
|
{
|
|
"name": "None",
|
|
"prompt": "",
|
|
"negative_prompt": "lowres",
|
|
},
|
|
{
|
|
"name": "Animagine Common",
|
|
"prompt": "anime artwork, anime style, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres",
|
|
"negative_prompt": "lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
|
|
},
|
|
{
|
|
"name": "Pony Anime Common",
|
|
"prompt": "source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres",
|
|
"negative_prompt": "source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends",
|
|
},
|
|
{
|
|
"name": "Pony Common",
|
|
"prompt": "source_anime, score_9, score_8_up, score_7_up",
|
|
"negative_prompt": "source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends",
|
|
},
|
|
{
|
|
"name": "Animagine Standard v3.0",
|
|
"prompt": "masterpiece, best quality",
|
|
"negative_prompt": "lowres, bad anatomy, bad hands, text, error, missing fingers, extra digit, fewer digits, cropped, worst quality, low quality, normal quality, jpeg artifacts, signature, watermark, username, blurry, artist name",
|
|
},
|
|
{
|
|
"name": "Animagine Standard v3.1",
|
|
"prompt": "masterpiece, best quality, very aesthetic, absurdres",
|
|
"negative_prompt": "lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]",
|
|
},
|
|
{
|
|
"name": "Animagine Light v3.1",
|
|
"prompt": "(masterpiece), best quality, very aesthetic, perfect face",
|
|
"negative_prompt": "(low quality, worst quality:1.2), very displeasing, 3d, watermark, signature, ugly, poorly drawn",
|
|
},
|
|
{
|
|
"name": "Animagine Heavy v3.1",
|
|
"prompt": "(masterpiece), (best quality), (ultra-detailed), very aesthetic, illustration, disheveled hair, perfect composition, moist skin, intricate details",
|
|
"negative_prompt": "longbody, lowres, bad anatomy, bad hands, missing fingers, pubic hair, extra digit, fewer digits, cropped, worst quality, low quality, very displeasing",
|
|
},
|
|
]
|
|
|
|
|
|
style_list = [
|
|
{
|
|
"name": "None",
|
|
"prompt": "",
|
|
"negative_prompt": "",
|
|
},
|
|
{
|
|
"name": "Cinematic",
|
|
"prompt": "cinematic still, emotional, harmonious, vignette, highly detailed, high budget, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy",
|
|
"negative_prompt": "cartoon, graphic, text, painting, crayon, graphite, abstract, glitch, deformed, mutated, ugly, disfigured",
|
|
},
|
|
{
|
|
"name": "Photographic",
|
|
"prompt": "cinematic photo, 35mm photograph, film, bokeh, professional, 4k, highly detailed",
|
|
"negative_prompt": "drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly",
|
|
},
|
|
{
|
|
"name": "Anime",
|
|
"prompt": "anime artwork, anime style, vibrant, studio anime, highly detailed",
|
|
"negative_prompt": "photo, deformed, black and white, realism, disfigured, low contrast",
|
|
},
|
|
{
|
|
"name": "Manga",
|
|
"prompt": "manga style, vibrant, high-energy, detailed, iconic, Japanese comic style",
|
|
"negative_prompt": "ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, Western comic style",
|
|
},
|
|
{
|
|
"name": "Digital Art",
|
|
"prompt": "concept art, digital artwork, illustrative, painterly, matte painting, highly detailed",
|
|
"negative_prompt": "photo, photorealistic, realism, ugly",
|
|
},
|
|
{
|
|
"name": "Pixel art",
|
|
"prompt": "pixel-art, low-res, blocky, pixel art style, 8-bit graphics",
|
|
"negative_prompt": "sloppy, messy, blurry, noisy, highly detailed, ultra textured, photo, realistic",
|
|
},
|
|
{
|
|
"name": "Fantasy art",
|
|
"prompt": "ethereal fantasy concept art, magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy",
|
|
"negative_prompt": "photographic, realistic, realism, 35mm film, dslr, cropped, frame, text, deformed, glitch, noise, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, sloppy, duplicate, mutated, black and white",
|
|
},
|
|
{
|
|
"name": "Neonpunk",
|
|
"prompt": "neonpunk style, cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional",
|
|
"negative_prompt": "painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured",
|
|
},
|
|
{
|
|
"name": "3D Model",
|
|
"prompt": "professional 3d model, octane render, highly detailed, volumetric, dramatic lighting",
|
|
"negative_prompt": "ugly, deformed, noisy, low poly, blurry, painting",
|
|
},
|
|
]
|
|
|
|
|
|
preset_styles = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in style_list}
|
|
preset_quality = {k["name"]: (k["prompt"], k["negative_prompt"]) for k in quality_prompt_list}
|
|
|
|
|
|
def process_style_prompt(prompt: str, neg_prompt: str, styles_key: str = "None", quality_key: str = "None"):
|
|
def to_list(s):
|
|
return [x.strip() for x in s.split(",") if not s == ""]
|
|
|
|
def list_sub(a, b):
|
|
return [e for e in a if e not in b]
|
|
|
|
def list_uniq(l):
|
|
return sorted(set(l), key=l.index)
|
|
|
|
animagine_ps = to_list("anime artwork, anime style, vibrant, studio anime, highly detailed, masterpiece, best quality, very aesthetic, absurdres")
|
|
animagine_nps = to_list("lowres, (bad), text, error, fewer, extra, missing, worst quality, jpeg artifacts, low quality, watermark, unfinished, displeasing, oldest, early, chromatic aberration, signature, extra digits, artistic error, username, scan, [abstract]")
|
|
pony_ps = to_list("source_anime, score_9, score_8_up, score_7_up, masterpiece, best quality, very aesthetic, absurdres")
|
|
pony_nps = to_list("source_pony, source_furry, source_cartoon, score_6, score_5, score_4, busty, ugly face, mutated hands, low res, blurry face, black and white, the simpsons, overwatch, apex legends")
|
|
prompts = to_list(prompt)
|
|
neg_prompts = to_list(neg_prompt)
|
|
|
|
all_styles_ps = []
|
|
all_styles_nps = []
|
|
for d in style_list:
|
|
all_styles_ps.extend(to_list(str(d.get("prompt", ""))))
|
|
all_styles_nps.extend(to_list(str(d.get("negative_prompt", ""))))
|
|
|
|
all_quality_ps = []
|
|
all_quality_nps = []
|
|
for d in quality_prompt_list:
|
|
all_quality_ps.extend(to_list(str(d.get("prompt", ""))))
|
|
all_quality_nps.extend(to_list(str(d.get("negative_prompt", ""))))
|
|
|
|
quality_ps = to_list(preset_quality[quality_key][0])
|
|
quality_nps = to_list(preset_quality[quality_key][1])
|
|
styles_ps = to_list(preset_styles[styles_key][0])
|
|
styles_nps = to_list(preset_styles[styles_key][1])
|
|
|
|
prompts = list_sub(prompts, animagine_ps + pony_ps + all_styles_ps + all_quality_ps)
|
|
neg_prompts = list_sub(neg_prompts, animagine_nps + pony_nps + all_styles_nps + all_quality_nps)
|
|
|
|
last_empty_p = [""] if not prompts and type != "None" and type != "Auto" and styles_key != "None" and quality_key != "None" else []
|
|
last_empty_np = [""] if not neg_prompts and type != "None" and type != "Auto" and styles_key != "None" and quality_key != "None" else []
|
|
|
|
if type == "Animagine":
|
|
prompts = prompts + animagine_ps
|
|
neg_prompts = neg_prompts + animagine_nps
|
|
elif type == "Pony":
|
|
prompts = prompts + pony_ps
|
|
neg_prompts = neg_prompts + pony_nps
|
|
|
|
prompts = prompts + styles_ps + quality_ps
|
|
neg_prompts = neg_prompts + styles_nps + quality_nps
|
|
|
|
prompt = ", ".join(list_uniq(prompts) + last_empty_p)
|
|
neg_prompt = ", ".join(list_uniq(neg_prompts) + last_empty_np)
|
|
|
|
return gr.update(value=prompt), gr.update(value=neg_prompt)
|
|
|
|
|
|
def save_images(images: list[Image.Image], metadatas: list[str]):
|
|
from PIL import PngImagePlugin
|
|
try:
|
|
output_images = []
|
|
for image, metadata in zip(images, metadatas):
|
|
info = PngImagePlugin.PngInfo()
|
|
info.add_text("parameters", metadata)
|
|
savefile = "image.png"
|
|
image.save(savefile, "PNG", pnginfo=info)
|
|
output_images.append(str(Path(savefile).resolve()))
|
|
return output_images
|
|
except Exception as e:
|
|
print(f"Failed to save image file: {e}")
|
|
raise Exception(f"Failed to save image file:") from e
|
|
|
