import asyncio import copy import json import random import time import traceback import uuid from pathlib import Path from tqdm import tqdm import os import base64 import aiohttp from .base import Backend global __ALL_SUPPORT_NODE__ MAX_SEED = 2 ** 32 class AIDRAW(Backend): def __init__(self, count, payload, **kwargs): super().__init__(count=count, payload=payload, **kwargs) # 需要更改 self.model_hash = "c7352c5d2f" self.logger = self.setup_logger('[Comfyui]') backend = self.config.comfyui['name'][self.count] self.backend_name = self.config.backend_name_list[8] self.workload_name = f"{self.backend_name}-{backend}" self.current_config: dict = self.config.comfyui_setting self.model = f"Comfyui - {self.current_config['name'][self.count]}" self.backend_url = self.current_config['backend_url'][self.count] self.reflex_dict['sampler'] = { "DPM++ 2M": "dpmpp_2m", "DPM++ SDE": "dpmpp_sde", "DPM++ 2M SDE": "dpmpp_2m_sde", "DPM++ 2M SDE Heun": "dpmpp_2m_sde", "DPM++ 2S a": "dpmpp_2s_ancestral", "DPM++ 3M SDE": "dpmpp_3m_sde", "Euler a": "euler_ancestral", "Euler": "euler", "LMS": "lms", "Heun": "heun", "DPM2": "dpm_2", "DPM2 a": "dpm_2_ancestral", "DPM fast": "dpm_fast", "DPM adaptive": "dpm_adaptive", "Restart": "restart", "HeunPP2": "heunpp2", "IPNDM": "ipndm", "IPNDM_V": "ipndm_v", "DEIS": "deis", "DDIM": "ddim", "DDIM CFG++": "ddim", "PLMS": "plms", "UniPC": "uni_pc", "LCM": "lcm", "DDPM": "ddpm", # "[Forge] Flux Realistic": None, # "[Forge] Flux Realistic (Slow)": None, } self.reflex_dict['scheduler'] = { "Automatic": "normal", "Karras": "karras", "Exponential": "exponential", "SGM Uniform": "sgm_uniform", "Simple": "simple", "Normal": "normal", "DDIM": "ddim_uniform", "Beta": "beta" } self.reflex_dict['parameters'] = {} self.scheduler = self.reflex_dict['scheduler'].get(self.scheduler, "normal") self.sampler = self.reflex_dict['sampler'].get(self.sampler, "euler") self.model_path = self.config.comfyui['model'][self.count] self.logger.info(f"选择工作流{self.comfyui_api_json}") path_to_json = self.comfyui_api_json if self.comfyui_api_json: with open( Path(f"{os.path.dirname(os.path.abspath(__file__))}/../comfyui_workflows/{self.comfyui_api_json}.json").resolve(), 'r', encoding='utf-8') as f: self.comfyui_api_json = json.load(f) with open( Path(f"{os.path.dirname(os.path.abspath(__file__))}/../comfyui_workflows/{path_to_json}_reflex.json").resolve(), 'r', encoding='utf-8') as f: self.comfyui_api_json_reflex = json.load(f) async def heart_beat(self, id_): self.logger.info(f"{id_} 开始请求") async def get_images(): response = await self.http_request( method="GET", target_url=f"{self.backend_url}/history/{id_}", ) if response: for img in response[id_]['outputs'][str(self.comfyui_api_json_reflex.get('output', 9))]['images']: img_url = f"{self.backend_url}/view?filename={img['filename']}" self.img_url.append(img_url) async with aiohttp.ClientSession() as session: ws_url = f'{self.backend_url}/ws?clientId={self.client_id}' async with session.ws_connect(ws_url) as ws: self.logger.info(f"WS连接成功: {ws_url}") progress_bar = None async for msg in ws: if msg.type == aiohttp.WSMsgType.TEXT: ws_msg = json.loads(msg.data) # # current_node = ws_msg['data']['node'] if ws_msg['type'] == 'progress': value = ws_msg['data']['value'] max_value = ws_msg['data']['max'] if progress_bar is None: progress_bar = await asyncio.to_thread( tqdm, total=max_value, desc=f"Prompt ID: {ws_msg['data']['prompt_id']}", unit="steps" ) delta = value - progress_bar.n await asyncio.to_thread(progress_bar.update, delta) if ws_msg['type'] == 'executing': if ws_msg['data']['node'] is None: self.logger.info(f"{id_}绘画完成!") await get_images() await ws.close() # # elif msg.type == aiohttp.WSMsgType.BINARY: # if current_node == 'save_image_websocket_node': # bytes_msg = msg.data # images_output = output_images.get(current_node, []) # images_output.append(bytes_msg[8:]) # output_images[current_node] = images_output elif msg.type == aiohttp.WSMsgType.ERROR: self.logger.error(f"Error: {msg.data}") await ws.close() break if progress_bar is not None: await asyncio.to_thread(progress_bar.close) async def update_progress(self): # 覆写函数 pass async def get_backend_working_progress(self): self.get_backend_id() try: response = await self.http_request( method="GET", target_url=f"{self.backend_url}/queue", ) if response.get("error", None): available = False else: available = True if len(response["queue_running"]) == 0: progress = 0 else: progress = 0.99 build_resp = self.format_progress_api_resp(progress, self.start_time) sc = 200 if available is True else 500 except: traceback.print_exc() finally: return build_resp, sc, self.backend_url, sc async def check_backend_usability(self): pass async def err_formating_to_sd_style(self): await self.download_img() self.format_api_respond() self.result = self.build_respond async def posting(self): upload_img_resp_list = [] if self.init_images: for image in self.init_images: resp = await self.upload_base64_image(image, uuid.uuid4().hex) upload_img_resp_list.append(resp) self.update_api_json(upload_img_resp_list) input_ = { "client_id": self.client_id, "prompt": self.comfyui_api_json } respone = await self.http_request( method="POST", target_url=f"{self.backend_url}/prompt", headers=self.headers, content=json.dumps(input_) ) if respone.get("error", None): self.logger.error(respone) raise RuntimeError(respone["status_code"]) self.task_id = respone['prompt_id'] await self.heart_beat(self.task_id) await self.err_formating_to_sd_style() def update_api_json(self, init_images): api_json = copy.deepcopy(self.comfyui_api_json) raw_api_json = copy.deepcopy(self.comfyui_api_json) print(api_json) update_mapping = { "sampler": { "seed": self.seed, "steps": self.steps, "cfg": self.scale, "sampler_name": self.sampler, "scheduler": self.scheduler, "denoise": self.denoising_strength }, "seed": { "seed": self.seed, "noise_seed": self.seed }, "image_size": { "width": self.width, "height": self.height, "batch_size": self.batch_size }, "prompt": { "text": self.tags }, "negative_prompt": { "text": self.ntags }, "checkpoint": { "ckpt_name": self.model_path if self.model_path else None }, "latentupscale": { "width": int(self.width*self.hr_scale) if not self.hr_resize_x else self.hr_resize_x, "height": int(self.height*self.hr_scale) if not self.hr_resize_y else self.hr_resize_y, }, "load_image": { "image": init_images[0]['name'] if self.init_images else None }, "resize": { "width": int(self.width*self.hr_scale) if not self.hr_resize_x else self.hr_resize_x, "height": int(self.height*self.hr_scale) if not self.hr_resize_y else self.hr_resize_y, }, "hr_steps": { "seed": self.seed, "steps": self.hr_second_pass_steps, "cfg": self.hr_scale, "sampler_name": self.sampler, "scheduler": self.scheduler, "denoise": self.denoising_strength, }, "hr_prompt": { "text": self.hr_prompt }, "hr_negative_prompt": { "text": self.hr_negative_prompt }, "tipo": { "width": self.width, "height": self.height, "seed": self.seed, "tags": self.tags, }, "append_prompt": { } } __OVERRIDE_SUPPORT_KEYS__ = { 'keep', 'value', 'append_prompt', 'append_negative_prompt', 'remove', "randint", "get_text", "upscale", 'image' } __ALL_SUPPORT_NODE__ = set(update_mapping.keys()) for item, node_id in self.comfyui_api_json_reflex.items(): if node_id and item not in ("override", "note"): org_node_id = node_id if isinstance(node_id, list): node_id = node_id elif isinstance(node_id, int or str): node_id = [node_id] elif isinstance(node_id, dict): node_id = list(node_id.keys()) for id_ in node_id: id_ = str(id_) update_dict = api_json.get(id_, None) if update_dict and item in update_mapping: api_json[id_]['inputs'].update(update_mapping[item]) if isinstance(org_node_id, dict): for node, override_dict in org_node_id.items(): single_node_or = override_dict.get("override", {}) if single_node_or: for key, override_action in single_node_or.items(): if override_action == "randint": api_json[node]['inputs'][key] = random.randint(0, MAX_SEED) elif override_action == "keep": org_cons = raw_api_json[node]['inputs'][key] elif override_action == "append_prompt": prompt = raw_api_json[node]['inputs'][key] prompt = self.tags + prompt api_json[node]['inputs'][key] = prompt elif override_action == "append_negative_prompt": prompt = raw_api_json[node]['inputs'][key] prompt = self.ntags + prompt api_json[node]['inputs'][key] = prompt elif "upscale" in override_action: scale = 1.5 if "_" in override_action: scale = override_action.split("_")[1] if key == 'width': res = self.width elif key == 'height': res = self.height upscale_size = int(res * scale) api_json[node]['inputs'][key] = upscale_size elif "value" in override_action: override_value = raw_api_json[node]['inputs'][key] if "_" in override_action: override_value = override_action.split("_")[1] override_type = override_action.split("_")[2] if override_type == "int": override_value = int(override_value) elif override_type == "float": override_value = float(override_value) elif override_type == "str": override_value = str(override_value) api_json[node]['inputs'][key] = override_value elif "image" in override_action: image_id = int(override_action.split("_")[1]) api_json[node]['inputs'][key] = init_images[image_id]['name'] else: update_dict = api_json.get(node, None) if update_dict and item in update_mapping: api_json[node]['inputs'].update(update_mapping[item]) test_dict = { "sampler": 3, "image_size": 5, "prompt": 6, "negative_prompt": 7, "checkpoint": 4, "latentupscale": 10, "load_image": 0, "resize": 15, "hr_steps": 19, "hr_prompt": 21, "hr_negative_prompt": 22, "output": 9 } print(api_json) self.comfyui_api_json = api_json async def upload_base64_image(self, b64_image, name, image_type="input", overwrite=False): if b64_image.startswith("data:image"): header, b64_image = b64_image.split(",", 1) file_type = header.split(";")[0].split(":")[1].split("/")[1] else: raise ValueError("Invalid base64 image format.") image_data = base64.b64decode(b64_image) data = aiohttp.FormData() data.add_field('image', image_data, filename=f"{name}.{file_type}", content_type=f'image/{file_type}') data.add_field('type', image_type) data.add_field('overwrite', str(overwrite).lower()) async with aiohttp.ClientSession() as session: async with session.post(f"{self.backend_url}/upload/image", data=data) as response: return json.loads(await response.read())