|
|
import asyncio
|
|
|
import random
|
|
|
import json
|
|
|
import time
|
|
|
|
|
|
import aiofiles
|
|
|
|
|
|
from tqdm import tqdm
|
|
|
from pathlib import Path
|
|
|
from fastapi import Request
|
|
|
from fastapi.responses import JSONResponse
|
|
|
from typing import Union
|
|
|
from colorama import Fore, Style
|
|
|
from colorama import init
|
|
|
init()
|
|
|
|
|
|
from ..base_config import setup_logger, init_instance
|
|
|
from .SD_civitai_API import AIDRAW
|
|
|
from .SD_A1111_webui import AIDRAW as AIDRAW2
|
|
|
from .FLUX_falai import AIDRAW as AIDRAW3
|
|
|
from .FLUX_replicate import AIDRAW as AIDRAW4
|
|
|
from .liblibai import AIDRAW as AIDRAW5
|
|
|
from .tusiart import AIDRAW as AIDRAW6
|
|
|
from .seaart import AIDRAW as AIDRAW7
|
|
|
from .yunjie import AIDRAW as AIDRAW8
|
|
|
from .comfyui import AIDRAW as AIDRAW9
|
|
|
from .novelai import AIDRAW as AIDRAW10
|
|
|
from .midjourney import AIDRAW as AIDRAW11
|
|
|
from .base import Backend
|
|
|
|
|
|
from DrawBridgeAPI.locales import _ as i18n
|
|
|
|
|
|
class BaseHandler:
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
payload,
|
|
|
request: Request = None,
|
|
|
path: str = None,
|
|
|
comfyui_task=None,
|
|
|
):
|
|
|
self.task_list = []
|
|
|
self.instance_list: list[Backend] = []
|
|
|
self.payload = payload
|
|
|
self.request = request
|
|
|
self.path = path
|
|
|
self.config = init_instance.config
|
|
|
self.all_task_list = list(range(len(list(self.config.name_url[0].keys()))))
|
|
|
self.enable_backend: dict = {}
|
|
|
self.comfyui_task: str = comfyui_task
|
|
|
|
|
|
async def get_enable_task(
|
|
|
self,
|
|
|
enable_task
|
|
|
):
|
|
|
"""
|
|
|
此函数的作用是获取示例并且只保留选择了的后端
|
|
|
:param enable_task:
|
|
|
:return:
|
|
|
"""
|
|
|
tasks = [
|
|
|
self.get_civitai_task(),
|
|
|
self.get_a1111_task(),
|
|
|
self.get_falai_task(),
|
|
|
self.get_replicate_task(),
|
|
|
self.get_liblibai_task(),
|
|
|
self.get_tusiart_task(),
|
|
|
self.get_seaart_task(),
|
|
|
self.get_yunjie_task(),
|
|
|
self.get_comfyui_task(),
|
|
|
self.get_novelai_task(),
|
|
|
self.get_midjourney_task()
|
|
|
]
|
|
|
|
|
|
all_backend_instance = await asyncio.gather(*tasks)
|
|
|
all_backend_instance_list = [item for sublist in all_backend_instance for item in sublist]
|
|
|
|
|
|
|
|
|
all_backend_dict: dict = self.config.name_url[0]
|
|
|
items = list(all_backend_dict.items())
|
|
|
self.enable_backend = dict([items[i] for i in enable_task])
|
|
|
|
|
|
self.instance_list = [all_backend_instance_list[i] for i in enable_task]
|
|
|
|
|
|
async def get_civitai_task(self):
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.civitai:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_a1111_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.a1111webui['name']:
|
|
|
aidraw_instance = AIDRAW2(
|
|
|
count=counter,
|
|
|
payload=self.payload,
|
|
|
request=self.request,
|
|
|
path=self.path
|
|
|
)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_falai_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.fal_ai:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW3(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_replicate_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.replicate:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW4(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_liblibai_task(self):
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.liblibai:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW5(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_tusiart_task(self):
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.tusiart:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW6(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_seaart_task(self):
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.seaart:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW7(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_yunjie_task(self):
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.yunjie:
|
|
|
if i is not None:
|
|
|
aidraw_instance = AIDRAW8(count=counter, payload=self.payload)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_comfyui_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
|
|
|
hr_mode = self.payload.get('enable_hr', None)
|
|
|
|
|
|
for i in self.config.comfyui['name']:
|
|
|
|
|
|
try:
|
|
|
selected_task = (
|
|
|
"sdbase_txt2img_hr_fix" if hr_mode
|
|
|
else self.config.comfyui.get('default_workflows', ['sdbase_txt2img'])[counter]
|
|
|
)
|
|
|
except IndexError:
|
|
|
selected_task = "sdbase_txt2img"
|
|
|
|
|
|
img2img = self.payload.get("init_images", [])
|
|
|
if img2img:
|
|
|
selected_task = "sdbase_img2img"
|
|
|
|
|
|
aidraw_instance = AIDRAW9(
|
|
|
count=counter,
|
|
|
payload=self.payload,
|
|
|
request=self.request,
|
|
|
path=self.path,
|
|
|
comfyui_api_json=self.comfyui_task or selected_task
|
|
|
)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_novelai_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
for i in self.config.novelai:
|
|
|
aidraw_instance = AIDRAW10(
|
|
|
count=counter,
|
|
|
payload=self.payload
|
|
|
)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
async def get_midjourney_task(self):
|
|
|
|
|
|
instance_list = []
|
|
|
counter = 0
|
|
|
|
|
|
for i in self.config.midjourney['name']:
|
|
|
|
|
|
aidraw_instance = AIDRAW11(
|
|
|
count=counter,
|
|
|
payload=self.payload
|
|
|
)
|
|
|
counter += 1
|
|
|
instance_list.append(aidraw_instance)
|
|
|
|
|
|
return instance_list
|
|
|
|
|
|
|
|
|
class TXT2IMGHandler(BaseHandler):
|
|
|
|
|
|
def __init__(self, payload=None, comfyui_task: str = None):
|
|
|
super().__init__(comfyui_task=comfyui_task, payload=payload)
|
|
|
|
|
|
async def get_all_instance(self) -> tuple[list[Backend], dict]:
|
|
|
|
|
|
man_enable_task = self.config.server_settings['enable_txt2img_backends']
|
|
|
if len(man_enable_task) != 0:
|
|
|
man_enable_task = man_enable_task
|
|
|
else:
|
|
|
man_enable_task = self.all_task_list
|
|
|
|
|
|
await self.get_enable_task(man_enable_task)
|
|
|
|
|
|
return self.instance_list, self.enable_backend
|
|
|
|
|
|
|
|
|
class IMG2IMGHandler(BaseHandler):
|
|
|
|
|
|
def __init__(self, payload=None, comfyui_task: str = None):
|
|
|
super().__init__(comfyui_task=comfyui_task, payload=payload)
|
|
|
|
|
|
async def get_all_instance(self) -> tuple[list[Backend], dict]:
|
|
|
|
|
|
man_enable_task = self.config.server_settings['enable_img2img_backends']
|
|
|
if len(man_enable_task) != 0:
|
|
|
man_enable_task = man_enable_task
|
|
|
else:
|
|
|
man_enable_task = self.all_task_list
|
|
|
|
|
|
await self.get_enable_task(man_enable_task)
|
|
|
|
|
|
return self.instance_list, self.enable_backend
|
|
|
|
|
|
|
|
|
class A1111WebuiHandler(BaseHandler):
|
|
|
|
|
|
async def get_all_instance(self) -> tuple[list[Backend], dict]:
|
|
|
|
|
|
await self.get_enable_task([1])
|
|
|
|
|
|
return self.instance_list, self.enable_backend
|
|
|
|
|
|
|
|
|
class A1111WebuiHandlerAPI(BaseHandler):
|
|
|
async def get_all_instance(self) -> tuple[list[Backend], dict]:
|
|
|
|
|
|
man_enable_task = self.config.server_settings['enable_sdapi_backends']
|
|
|
if len(man_enable_task) != 0:
|
|
|
man_enable_task = man_enable_task
|
|
|
else:
|
|
|
man_enable_task = self.all_task_list
|
|
|
|
|
|
await self.get_enable_task(man_enable_task)
|
|
|
|
|
|
return self.instance_list, self.enable_backend
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class StaticHandler:
|
|
|
lock_to_backend = None
|
|
|
prompt_style: list = None
|
|
|
|
|
|
@classmethod
|
|
|
def set_lock_to_backend(cls, selected_model: str):
|
|
|
cls.lock_to_backend = selected_model
|
|
|
|
|
|
@classmethod
|
|
|
def get_lock_to_backend(cls):
|
|
|
return cls.lock_to_backend
|
|
|
|
|
|
@classmethod
|
|
|
def get_prompt_style(cls):
|
|
|
return cls.prompt_style
|
|
|
|
|
|
@classmethod
|
|
|
def set_prompt_style(cls, prompt_style: list):
|
|
|
cls.prompt_style = prompt_style
|
|
|
|
|
|
@classmethod
|
|
|
def get_backend_options(cls):
|
|
|
build_resp = {
|
|
|
"samples_save": True,
|
|
|
"samples_format": "png",
|
|
|
"samples_filename_pattern": "",
|
|
|
"save_images_add_number": True,
|
|
|
"grid_save": True,
|
|
|
"grid_format": "png",
|
|
|
"grid_extended_filename": False,
|
|
|
"grid_only_if_multiple": True,
|
|
|
"grid_prevent_empty_spots": False,
|
|
|
"grid_zip_filename_pattern": "",
|
|
|
"n_rows": -1.0,
|
|
|
"font": "",
|
|
|
"grid_text_active_color": "#000000",
|
|
|
"grid_text_inactive_color": "#999999",
|
|
|
"grid_background_color": "#ffffff",
|
|
|
"enable_pnginfo": True,
|
|
|
"save_txt": False,
|
|
|
"save_images_before_face_restoration": False,
|
|
|
"save_images_before_highres_fix": False,
|
|
|
"save_images_before_color_correction": False,
|
|
|
"save_mask": False,
|
|
|
"save_mask_composite": False,
|
|
|
"jpeg_quality": 80.0,
|
|
|
"webp_lossless": False,
|
|
|
"export_for_4chan": True,
|
|
|
"img_downscale_threshold": 4.0,
|
|
|
"target_side_length": 4000.0,
|
|
|
"img_max_size_mp": 200.0,
|
|
|
"use_original_name_batch": True,
|
|
|
"use_upscaler_name_as_suffix": False,
|
|
|
"save_selected_only": True,
|
|
|
"save_init_img": False,
|
|
|
"temp_dir": "",
|
|
|
"clean_temp_dir_at_start": False,
|
|
|
"save_incomplete_images": False,
|
|
|
"outdir_samples": "",
|
|
|
"outdir_txt2img_samples": "outputs/txt2img-images",
|
|
|
"outdir_img2img_samples": "outputs/img2img-images",
|
|
|
"outdir_extras_samples": "outputs/extras-images",
|
|
|
"outdir_grids": "",
|
|
|
"outdir_txt2img_grids": "outputs/txt2img-grids",
|
|
|
"outdir_img2img_grids": "outputs/img2img-grids",
|
|
|
"outdir_save": "log/images",
|
|
|
"outdir_init_images": "outputs/init-images",
|
|
|
"save_to_dirs": True,
|
|
|
"grid_save_to_dirs": True,
|
|
|
"use_save_to_dirs_for_ui": False,
|
|
|
"directories_filename_pattern": "[date]",
|
|
|
"directories_max_prompt_words": 8.0,
|
|
|
"ESRGAN_tile": 192.0,
|
|
|
"ESRGAN_tile_overlap": 8.0,
|
|
|
"realesrgan_enabled_models": [
|
|
|
"R-ESRGAN 4x+",
|
|
|
"R-ESRGAN 4x+ Anime6B"
|
|
|
],
|
|
|
"upscaler_for_img2img": None,
|
|
|
"face_restoration": False,
|
|
|
"face_restoration_model": "CodeFormer",
|
|
|
"code_former_weight": 0.5,
|
|
|
"face_restoration_unload": False,
|
|
|
"auto_launch_browser": "Local",
|
|
|
"show_warnings": False,
|
|
|
"show_gradio_deprecation_warnings": True,
|
|
|
"memmon_poll_rate": 8.0,
|
|
|
"samples_log_stdout": False,
|
|
|
"multiple_tqdm": True,
|
|
|
"print_hypernet_extra": False,
|
|
|
"list_hidden_files": True,
|
|
|
"disable_mmap_load_safetensors": False,
|
|
|
"hide_ldm_prints": True,
|
|
|
"api_enable_requests": True,
|
|
|
"api_forbid_local_requests": True,
|
|
|
"api_useragent": "",
|
|
|
"unload_models_when_training": False,
|
|
|
"pin_memory": False,
|
|
|
"save_optimizer_state": False,
|
|
|
"save_training_settings_to_txt": True,
|
|
|
"dataset_filename_word_regex": "",
|
|
|
"dataset_filename_join_string": " ",
|
|
|
"training_image_repeats_per_epoch": 1.0,
|
|
|
"training_write_csv_every": 500.0,
|
|
|
"training_xattention_optimizations": False,
|
|
|
"training_enable_tensorboard": False,
|
|
|
"training_tensorboard_save_images": False,
|
|
|
"training_tensorboard_flush_every": 120.0,
|
|
|
"sd_model_checkpoint": cls.lock_to_backend if cls.lock_to_backend else 'DrawBridgeAPI-Auto-Select',
|
|
|
"sd_checkpoints_limit": 1.0,
|
|
|
"sd_checkpoints_keep_in_cpu": True,
|
|
|
"sd_checkpoint_cache": 3,
|
|
|
"sd_unet": "None",
|
|
|
"enable_quantization": False,
|
|
|
"enable_emphasis": True,
|
|
|
"enable_batch_seeds": True,
|
|
|
"comma_padding_backtrack": 20.0,
|
|
|
"CLIP_stop_at_last_layers": 3.0,
|
|
|
"upcast_attn": False,
|
|
|
"randn_source": "GPU",
|
|
|
"tiling": False,
|
|
|
"hires_fix_refiner_pass": "second pass",
|
|
|
"sdxl_crop_top": 0.0,
|
|
|
"sdxl_crop_left": 0.0,
|
|
|
"sdxl_refiner_low_aesthetic_score": 2.5,
|
|
|
"sdxl_refiner_high_aesthetic_score": 6.0,
|
|
|
"sd_vae_explanation": "<abbr title='Variational autoencoder'>VAE</abbr> is a neural network that transforms a standard <abbr title='red/green/blue'>RGB</abbr>\nimage into latent space representation and back. Latent space representation is what stable diffusion is working on during sampling\n(i.e. when the progress bar is between empty and full). For txt2img, VAE is used to create a resulting image after the sampling is finished.\nFor img2img, VAE is used to process user's input image before the sampling, and to create an image after sampling.",
|
|
|
"sd_vae_checkpoint_cache": 0,
|
|
|
"sd_vae": "None",
|
|
|
"sd_vae_overrides_per_model_preferences": False,
|
|
|
"auto_vae_precision": True,
|
|
|
"sd_vae_encode_method": "Full",
|
|
|
"sd_vae_decode_method": "Full",
|
|
|
"inpainting_mask_weight": 1.0,
|
|
|
"initial_noise_multiplier": 1.0,
|
|
|
"img2img_extra_noise": 0,
|
|
|
"img2img_color_correction": False,
|
|
|
"img2img_fix_steps": False,
|
|
|
"img2img_background_color": "#ffffff",
|
|
|
"img2img_editor_height": 720.0,
|
|
|
"img2img_sketch_default_brush_color": "#ffffff",
|
|
|
"img2img_inpaint_mask_brush_color": "#ffffff",
|
|
|
"img2img_inpaint_sketch_default_brush_color": "#ffffff",
|
|
|
"return_mask": False,
|
|
|
"return_mask_composite": False,
|
|
|
"cross_attention_optimization": "Automatic",
|
|
|
"s_min_uncond": 0.0,
|
|
|
"token_merging_ratio": 0.0,
|
|
|
"token_merging_ratio_img2img": 0.0,
|
|
|
"token_merging_ratio_hr": 0.0,
|
|
|
"pad_cond_uncond": False,
|
|
|
"persistent_cond_cache": True,
|
|
|
"batch_cond_uncond": True,
|
|
|
"use_old_emphasis_implementation": False,
|
|
|
"use_old_karras_scheduler_sigmas": False,
|
|
|
"no_dpmpp_sde_batch_determinism": False,
|
|
|
"use_old_hires_fix_width_height": False,
|
|
|
"dont_fix_second_order_samplers_schedule": False,
|
|
|
"hires_fix_use_firstpass_conds": False,
|
|
|
"use_old_scheduling": False,
|
|
|
"interrogate_keep_models_in_memory": False,
|
|
|
"interrogate_return_ranks": False,
|
|
|
"interrogate_clip_num_beams": 1.0,
|
|
|
"interrogate_clip_min_length": 24.0,
|
|
|
"interrogate_clip_max_length": 48.0,
|
|
|
"interrogate_clip_dict_limit": 1500.0,
|
|
|
"interrogate_clip_skip_categories": [],
|
|
|
"interrogate_deepbooru_score_threshold": 0.5,
|
|
|
"deepbooru_sort_alpha": True,
|
|
|
"deepbooru_use_spaces": True,
|
|
|
"deepbooru_escape": True,
|
|
|
"deepbooru_filter_tags": "",
|
|
|
"extra_networks_show_hidden_directories": True,
|
|
|
"extra_networks_hidden_models": "When searched",
|
|
|
"extra_networks_default_multiplier": 1.0,
|
|
|
"extra_networks_card_width": 0,
|
|
|
"extra_networks_card_height": 0,
|
|
|
"extra_networks_card_text_scale": 1.0,
|
|
|
"extra_networks_card_show_desc": True,
|
|
|
"extra_networks_add_text_separator": " ",
|
|
|
"ui_extra_networks_tab_reorder": "",
|
|
|
"textual_inversion_print_at_load": False,
|
|
|
"textual_inversion_add_hashes_to_infotext": True,
|
|
|
"sd_hypernetwork": "None",
|
|
|
"localization": "None",
|
|
|
"gradio_theme": "Default",
|
|
|
"gradio_themes_cache": True,
|
|
|
"gallery_height": "",
|
|
|
"return_grid": True,
|
|
|
"do_not_show_images": False,
|
|
|
"send_seed": True,
|
|
|
"send_size": True,
|
|
|
"js_modal_lightbox": True,
|
|
|
"js_modal_lightbox_initially_zoomed": True,
|
|
|
"js_modal_lightbox_gamepad": False,
|
|
|
"js_modal_lightbox_gamepad_repeat": 250.0,
|
|
|
"show_progress_in_title": True,
|
|
|
"samplers_in_dropdown": True,
|
|
|
"dimensions_and_batch_together": True,
|
|
|
"keyedit_precision_attention": 0.1,
|
|
|
"keyedit_precision_extra": 0.05,
|
|
|
"keyedit_delimiters": ".,\\/!?%^*;:{}=`~()",
|
|
|
"keyedit_move": True,
|
|
|
"quicksettings_list": [
|
|
|
"sd_model_checkpoint",
|
|
|
"sd_unet",
|
|
|
"sd_vae",
|
|
|
"CLIP_stop_at_last_layers"
|
|
|
],
|
|
|
"ui_tab_order": [],
|
|
|
"hidden_tabs": [],
|
|
|
"ui_reorder_list": [],
|
|
|
"hires_fix_show_sampler": False,
|
|
|
"hires_fix_show_prompts": False,
|
|
|
"disable_token_counters": False,
|
|
|
"add_model_hash_to_info": True,
|
|
|
"add_model_name_to_info": True,
|
|
|
"add_user_name_to_info": False,
|
|
|
"add_version_to_infotext": True,
|
|
|
"disable_weights_auto_swap": True,
|
|
|
"infotext_styles": "Apply if any",
|
|
|
"show_progressbar": True,
|
|
|
"live_previews_enable": True,
|
|
|
"live_previews_image_format": "png",
|
|
|
"show_progress_grid": True,
|
|
|
"show_progress_every_n_steps": 10.0,
|
|
|
"show_progress_type": "Approx NN",
|
|
|
"live_preview_allow_lowvram_full": False,
|
|
|
"live_preview_content": "Prompt",
|
|
|
"live_preview_refresh_period": 1000.0,
|
|
|
"live_preview_fast_interrupt": False,
|
|
|
"hide_samplers": [],
|
|
|
"eta_ddim": 0.0,
|
|
|
"eta_ancestral": 1.0,
|
|
|
"ddim_discretize": "uniform",
|
|
|
"s_churn": 0.0,
|
|
|
"s_tmin": 0.0,
|
|
|
"s_tmax": 0,
|
|
|
"s_noise": 1.0,
|
|
|
"k_sched_type": "Automatic",
|
|
|
"sigma_min": 0.0,
|
|
|
"sigma_max": 0.0,
|
|
|
"rho": 0.0,
|
|
|
"eta_noise_seed_delta": 0,
|
|
|
"always_discard_next_to_last_sigma": False,
|
|
|
"sgm_noise_multiplier": False,
|
|
|
"uni_pc_variant": "bh1",
|
|
|
"uni_pc_skip_type": "time_uniform",
|
|
|
"uni_pc_order": 3.0,
|
|
|
"uni_pc_lower_order_final": True,
|
|
|
"postprocessing_enable_in_main_ui": [],
|
|
|
"postprocessing_operation_order": [],
|
|
|
"upscaling_max_images_in_cache": 5.0,
|
|
|
"disabled_extensions": [],
|
|
|
"disable_all_extensions": "none",
|
|
|
"restore_config_state_file": "",
|
|
|
"sd_checkpoint_hash": "91e0f7cbaf70676153810c231e8703bf26b3208c116a3d1f2481cbc666905471"
|
|
|
}
|
|
|
|
|
|
return build_resp
|
|
|
|
|
|
|
|
|
class TaskHandler(StaticHandler):
|
|
|
|
|
|
backend_avg_dict: dict = {}
|
|
|
write_count: dict = {}
|
|
|
backend_images: dict = {}
|
|
|
|
|
|
backend_site_list = None
|
|
|
load_balance_logger = setup_logger('[AvgTimeCalculator]')
|
|
|
load_balance_sample = 10
|
|
|
|
|
|
redis_client = None
|
|
|
backend_status = None
|
|
|
|
|
|
@classmethod
|
|
|
def update_backend_status(cls):
|
|
|
cls.backend_status = json.loads(cls.redis_client.get("workload"))
|
|
|
|
|
|
@classmethod
|
|
|
def get_redis_client(cls):
|
|
|
cls.redis_client = init_instance.redis_client
|
|
|
|
|
|
@classmethod
|
|
|
async def get_backend_avg_work_time(cls) -> dict:
|
|
|
backend_sites = cls.backend_site_list
|
|
|
|
|
|
avg_time_key = ""
|
|
|
|
|
|
avg_time_data = cls.redis_client.get("backend_avg_time")
|
|
|
if avg_time_data is None:
|
|
|
cls.redis_client.set(avg_time_key, json.dumps(cls.backend_avg_dict))
|
|
|
else:
|
|
|
new_data = json.loads(avg_time_data)
|
|
|
for key, values in new_data.items():
|
|
|
if key in cls.backend_avg_dict:
|
|
|
cls.backend_avg_dict[key].extend(
|
|
|
values[-cls.load_balance_sample:] if len(values) >= cls.load_balance_sample else
|
|
|
values
|
|
|
)
|
|
|
else:
|
|
|
cls.backend_avg_dict[key] = (values[-cls.load_balance_sample:] if
|
|
|
len(values) >= cls.load_balance_sample else values)
|
|
|
|
|
|
cls.backend_avg_dict[key] = cls.backend_avg_dict[key][-10:]
|
|
|
|
|
|
avg_time_dict = {}
|
|
|
for backend_site in backend_sites:
|
|
|
spend_time_list = cls.backend_avg_dict.get(backend_site, [])
|
|
|
if spend_time_list and len(spend_time_list) >= cls.load_balance_sample:
|
|
|
sorted_list = sorted(spend_time_list)
|
|
|
trimmed_list = sorted_list[1:-1]
|
|
|
avg_time = sum(trimmed_list) / len(trimmed_list) if trimmed_list else None
|
|
|
avg_time_dict[backend_site] = avg_time
|
|
|
else:
|
|
|
avg_time_dict[backend_site] = None
|
|
|
|
|
|
return avg_time_dict
|
|
|
|
|
|
@classmethod
|
|
|
async def set_backend_work_time(cls, spend_time, backend_site, total_images=1):
|
|
|
spend_time_list = cls.backend_avg_dict.get(backend_site, [])
|
|
|
spend_time_list.append(int(spend_time/total_images))
|
|
|
|
|
|
if len(spend_time_list) >= cls.load_balance_sample:
|
|
|
spend_time_list = spend_time_list[-cls.load_balance_sample:]
|
|
|
|
|
|
cls.backend_avg_dict[backend_site] = spend_time_list
|
|
|
|
|
|
cls.write_count[backend_site] = cls.write_count.get(backend_site, 0) + 1
|
|
|
|
|
|
if cls.write_count.get(backend_site, 0) >= cls.load_balance_sample:
|
|
|
cls.redis_client.set("backend_avg_time", json.dumps(cls.backend_avg_dict))
|
|
|
cls.write_count[backend_site] = 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@classmethod
|
|
|
def set_backend_image(cls, num=0, backend_site=None, get=False) -> Union[None, dict]:
|
|
|
all_backend_dict = {}
|
|
|
|
|
|
if backend_site:
|
|
|
working_images = cls.backend_images.get(backend_site, 1)
|
|
|
working_images += num
|
|
|
cls.backend_images[backend_site] = working_images
|
|
|
|
|
|
if get:
|
|
|
for site in cls.backend_site_list:
|
|
|
all_backend_dict[site] = cls.backend_images.get(site, 1)
|
|
|
return all_backend_dict
|
|
|
|
|
|
@classmethod
|
|
|
def set_backend_list(cls, backend_dict):
|
|
|
cls.backend_site_list = list(backend_dict.values())
|
|
|
|
|
|
def __init__(
|
|
|
self,
|
|
|
payload=None,
|
|
|
request: Request = None,
|
|
|
path: str = None,
|
|
|
select_backend: int = None,
|
|
|
reutrn_instance: bool = False,
|
|
|
model_to_backend: str = None,
|
|
|
disable_loadbalance: bool = False,
|
|
|
comfyui_json: str = "",
|
|
|
override_model_select: bool = False,
|
|
|
):
|
|
|
self.payload = payload
|
|
|
self.instance_list = []
|
|
|
self.result = None
|
|
|
self.request = request
|
|
|
self.path = path
|
|
|
self.enable_backend = None
|
|
|
self.reutrn_instance = reutrn_instance
|
|
|
self.select_backend = select_backend
|
|
|
self.model_to_backend = model_to_backend
|
|
|
self.disable_loadbalance = disable_loadbalance
|
|
|
self.lock_to_backend = self.get_lock_to_backend() if override_model_select is False else None
|
|
|
self.comfyui_json: str = comfyui_json
|
|
|
|
|
|
self.total_images = (self.payload.get("batch_size", 1) * self.payload.get("n_iter", 1)) or 1
|
|
|
|
|
|
self.ava_backend_url = None
|
|
|
self.ava_backend_index = None
|
|
|
|
|
|
@staticmethod
|
|
|
def get_backend_name(model_name) -> str:
|
|
|
all_model: bytes = init_instance.redis_client.get('models')
|
|
|
all_model: dict = json.loads(all_model.decode('utf-8'))
|
|
|
for key, models in all_model.items():
|
|
|
if isinstance(models, list):
|
|
|
for model in models:
|
|
|
if model.get("title") == model_name or model.get("model_name") == model_name:
|
|
|
return key
|
|
|
|
|
|
@staticmethod
|
|
|
def get_backend_index(mapping_dict, key_to_find) -> int:
|
|
|
keys = list(mapping_dict.keys())
|
|
|
if key_to_find in keys:
|
|
|
return keys.index(key_to_find)
|
|
|
return None
|
|
|
|
|
|
async def txt2img(self):
|
|
|
|
|
|
self.instance_list, self.enable_backend = await TXT2IMGHandler(
|
|
|
self.payload,
|
|
|
comfyui_task=self.comfyui_json
|
|
|
).get_all_instance()
|
|
|
|
|
|
await self.choice_backend()
|
|
|
return self.result
|
|
|
|
|
|
async def img2img(self):
|
|
|
|
|
|
self.instance_list, self.enable_backend = await IMG2IMGHandler(
|
|
|
self.payload,
|
|
|
comfyui_task=self.comfyui_json
|
|
|
).get_all_instance()
|
|
|
|
|
|
await self.choice_backend()
|
|
|
return self.result
|
|
|
|
|
|
async def sd_api(self) -> JSONResponse or list[Backend]:
|
|
|
|
|
|
self.instance_list, self.enable_backend = await A1111WebuiHandlerAPI(
|
|
|
self.payload,
|
|
|
self.request,
|
|
|
self.path
|
|
|
).get_all_instance()
|
|
|
|
|
|
await self.choice_backend()
|
|
|
return self.result
|
|
|
|
|
|
|
|
|
async def choice_backend(self):
|
|
|
|
|
|
from DrawBridgeAPI.locales import _ as i18n
|
|
|
|
|
|
if self.disable_loadbalance:
|
|
|
return
|
|
|
backend_url_dict = self.enable_backend
|
|
|
self.set_backend_list(backend_url_dict)
|
|
|
self.get_redis_client()
|
|
|
reverse_dict = {value: key for key, value in backend_url_dict.items()}
|
|
|
|
|
|
tasks = []
|
|
|
is_avaiable = 0
|
|
|
status_dict = {}
|
|
|
ava_url = None
|
|
|
n = -1
|
|
|
e = -1
|
|
|
normal_backend = None
|
|
|
idle_backend = []
|
|
|
|
|
|
logger = setup_logger(custom_prefix='[LOAD_BALANCE]')
|
|
|
|
|
|
if self.reutrn_instance:
|
|
|
self.result = self.instance_list
|
|
|
return
|
|
|
for i in self.instance_list:
|
|
|
task = i.get_backend_working_progress()
|
|
|
tasks.append(task)
|
|
|
|
|
|
key = self.get_backend_name(self.model_to_backend or self.lock_to_backend)
|
|
|
if self.model_to_backend and key is not None:
|
|
|
|
|
|
backend_index = self.get_backend_index(backend_url_dict, key)
|
|
|
logger.info(f"{i18n('Manually select model')}: {self.model_to_backend}, {i18n('Backend select')}{key[:24]}")
|
|
|
|
|
|
self.ava_backend_url = backend_url_dict[key]
|
|
|
self.ava_backend_index = backend_index
|
|
|
|
|
|
await self.exec_generate()
|
|
|
|
|
|
elif self.lock_to_backend:
|
|
|
if self.lock_to_backend and key is not None:
|
|
|
backend_index = self.get_backend_index(backend_url_dict, key)
|
|
|
logger.info(f"{i18n('Backend locked')}: {key[:24]}")
|
|
|
|
|
|
self.ava_backend_url = backend_url_dict[key]
|
|
|
self.ava_backend_index = backend_index
|
|
|
|
|
|
await self.exec_generate()
|
|
|
|
|
|
else:
|
|
|
all_resp = await asyncio.gather(*tasks, return_exceptions=True)
|
|
|
logger.info(i18n('Starting backend selection'))
|
|
|
for resp_tuple in all_resp:
|
|
|
e += 1
|
|
|
if isinstance(resp_tuple, None or Exception):
|
|
|
logger.warning(i18n('Backend %s is down') % self.instance_list[e].workload_name[:24])
|
|
|
else:
|
|
|
try:
|
|
|
if resp_tuple[3] in [200, 201]:
|
|
|
n += 1
|
|
|
status_dict[resp_tuple[2]] = resp_tuple[0]["eta_relative"]
|
|
|
normal_backend = (list(status_dict.keys()))
|
|
|
else:
|
|
|
raise RuntimeError
|
|
|
except RuntimeError or TypeError:
|
|
|
logger.warning(i18n('Backend %s is failed or locked') % self.instance_list[e].workload_name[:24])
|
|
|
continue
|
|
|
else:
|
|
|
|
|
|
if resp_tuple[0]["progress"] in [0, 0.0]:
|
|
|
is_avaiable += 1
|
|
|
idle_backend.append(normal_backend[n])
|
|
|
else:
|
|
|
pass
|
|
|
|
|
|
total = 100
|
|
|
progress = int(resp_tuple[0]["progress"] * 100)
|
|
|
show_str = f"{list(backend_url_dict.keys())[e][:24]}"
|
|
|
show_str = show_str.ljust(50, "-")
|
|
|
|
|
|
bar_format = f"{Fore.CYAN}[Progress] {{l_bar}}{{bar}}|{Style.RESET_ALL}"
|
|
|
|
|
|
with tqdm(
|
|
|
total=total,
|
|
|
desc=show_str + "-->",
|
|
|
bar_format=bar_format
|
|
|
) as pbar:
|
|
|
pbar.update(progress)
|
|
|
if len(normal_backend) == 0:
|
|
|
logger.error(i18n('No available backend'))
|
|
|
raise RuntimeError(i18n('No available backend'))
|
|
|
|
|
|
backend_total_work_time = {}
|
|
|
avg_time_dict = await self.get_backend_avg_work_time()
|
|
|
backend_image = self.set_backend_image(get=True)
|
|
|
|
|
|
eta = 0
|
|
|
|
|
|
for (site, time_), (_, image_count) in zip(avg_time_dict.items(), backend_image.items()):
|
|
|
self.load_balance_logger.info(
|
|
|
i18n('Backend: %s Average work time: %s seconds, Current tasks: %s') % (site, time_, image_count - 1)
|
|
|
)
|
|
|
if site in normal_backend:
|
|
|
self.update_backend_status()
|
|
|
for key in self.backend_status:
|
|
|
if site in key:
|
|
|
end_time = self.backend_status[key].get('end_time', None)
|
|
|
start_time = self.backend_status[key].get('start_time', None)
|
|
|
if start_time:
|
|
|
if end_time:
|
|
|
eta = 0
|
|
|
else:
|
|
|
current_time = time.time()
|
|
|
eta = int(current_time - start_time)
|
|
|
|
|
|
effective_time = 1 if time_ is None else time_
|
|
|
total_work_time = effective_time * int(image_count)
|
|
|
|
|
|
eta = eta if time_ else 0
|
|
|
self.load_balance_logger.info(f"{i18n('Extra time weight')}{eta}")
|
|
|
|
|
|
backend_total_work_time[site] = total_work_time - eta if (total_work_time - eta) >= 0 else total_work_time
|
|
|
|
|
|
total_time_dict = list(backend_total_work_time.values())
|
|
|
rev_dict = {}
|
|
|
for key, value in backend_total_work_time.items():
|
|
|
if value in rev_dict:
|
|
|
rev_dict[(value, key)] = value
|
|
|
else:
|
|
|
rev_dict[value] = key
|
|
|
|
|
|
sorted_list = sorted(total_time_dict)
|
|
|
fastest_backend = sorted_list[0]
|
|
|
ava_url = rev_dict[fastest_backend]
|
|
|
self.load_balance_logger.info(i18n('Backend %s is the fastest, has been selected') % ava_url[:24])
|
|
|
ava_url_index = list(backend_url_dict.values()).index(ava_url)
|
|
|
|
|
|
self.ava_backend_url = ava_url
|
|
|
self.ava_backend_index = ava_url_index
|
|
|
|
|
|
await self.exec_generate()
|
|
|
|
|
|
|
|
|
async def exec_generate(self):
|
|
|
self.set_backend_image(self.total_images, self.ava_backend_url)
|
|
|
fifo = None
|
|
|
try:
|
|
|
fifo = await self.instance_list[self.ava_backend_index].send_result_to_api()
|
|
|
except:
|
|
|
pass
|
|
|
finally:
|
|
|
self.set_backend_image(-self.total_images, self.ava_backend_url)
|
|
|
self.result = fifo.result if fifo is not None else None
|
|
|
await self.set_backend_work_time(fifo.spend_time, self.ava_backend_url, fifo.total_img_count)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
