DrawBridgeAPI/backend/base.py

import random
import uuid

import aiofiles
import aiohttp
import json
import asyncio
import traceback
import time
import httpx

from tqdm import tqdm
from fastapi import Request
from fastapi.responses import JSONResponse
from pathlib import Path
from datetime import datetime
from typing import Union

from ..base_config import setup_logger
from ..base_config import init_instance
from ..utils import exceptions
from ..locales import _

import base64
from io import BytesIO
from PIL import Image, ImageDraw, ImageFont
from ..utils.shared import PATH_TO_COMFYUI_WORKFLOWS


class Backend:

    queues = {}
    locks = {}
    task_count = 0
    queue_logger = setup_logger('[QueueManager]')

    @classmethod
    def get_queue(cls, token):
        if token not in cls.queues:
            cls.queues[token] = asyncio.Queue()
        return cls.queues[token]

    @classmethod
    def get_lock(cls, token):
        if token not in cls.locks:
            cls.locks[token] = asyncio.Lock()
        return cls.locks[token]

    @classmethod
    async def add_to_queue(cls, token, request_func, *args, **kwargs):
        queue = cls.get_queue(token)
        future = asyncio.get_event_loop().create_future()

        await queue.put((request_func, args, kwargs, future))

        lock = cls.get_lock(token)

        if not lock.locked():
            asyncio.create_task(cls.process_queue(token))

        return await future

    @classmethod
    async def process_queue(cls, token):
        queue = cls.get_queue(token)
        lock = cls.get_lock(token)

        async with lock:
            while not queue.empty():

                request_func, args, kwargs, future = await queue.get()
                try:
                    result = await request_func(*args, **kwargs)
                    if not future.done():
                        future.set_result(result)
                    cls.queue_logger.info(f"Token: {token}, {_('Task completed successfully')}")
                except Exception as e:
                    if not future.done():
                        future.set_exception(e)
                    cls.queue_logger.info(f"Token: {token}, {_('Task failed')}: {e}")
                finally:
                    queue.task_done()

                cls.queue_logger.info(f"Token: {token}, {_('Remaining tasks in the queue')}")
            cls.queue_logger.info(f"Token: {token}, {_('No remaining tasks in the queue')}")

    def __init__(

        self,

        login: bool = False,

        backend_url: str = None,

        token: str = "",

        count: int = None,

        payload: dict = {},

        input_img: str = None,

        request: Request = None,

        path: str = None,

        comfyui_api_json: str = None,

        **kwargs,

    ):


        self.tags: str = payload.get('prompt', '1girl')
        self.ntags: str = payload.get('negative_prompt', '')
        self.seed: int = payload.get('seed', random.randint(0, 4294967295))
        self.seed_list: list[int] = [self.seed]
        self.steps: int = payload.get('steps', 20)
        self.scale: float = payload.get('cfg_scale', 7.0)
        self.width: int = payload.get('width', 512)
        self.height: int = payload.get('height', 512)
        self.sampler: str = payload.get('sampler_name', "Euler")
        self.restore_faces: bool = payload.get('restore_faces', False)
        self.scheduler: str = payload.get('scheduler', 'Normal')

        self.batch_size: int = payload.get('batch_size', 1)
        self.batch_count: int = payload.get('n_iter', 1)
        self.total_img_count: int = self.batch_size * self.batch_count

        self.enable_hr: bool = payload.get('enable_hr', False)
        self.hr_scale: float = payload.get('hr_scale', 1.5)
        self.hr_second_pass_steps: int = payload.get('hr_second_pass_steps', self.steps)
        self.hr_upscaler: str = payload.get('hr_upscaler', "")
        self.denoising_strength: float = payload.get('denoising_strength', 1.0)
        self.hr_resize_x: int = payload.get('hr_resize_x', 0)
        self.hr_resize_y: int = payload.get('hr_resize_y', 0)
        self.hr_sampiler: str = payload.get('hr_sampler_name', "Euler")
        self.hr_scheduler: str = payload.get('hr_scheduler', 'Normal')
        self.hr_prompt: str = payload.get('hr_prompt', '')
        self.hr_negative_prompt: str = payload.get('hr_negative_prompt', '')
        self.hr_distilled_cfg: float = payload.get('hr_distilled_cfg', 3.5)

        self.init_images: list = payload.get('init_images', [])

        self.xl = False
        self.flux = False
        self.clip_skip = 2
        self.final_width = None
        self.final_height = None
        self.model = "DiaoDaia"
        self.model_id = '20204'
        self.model_hash = "c7352c5d2f"
        self.model_list: list = []
        self.model_path = "models\\1053-S.ckpt"
        self.client_id = uuid.uuid4().hex

        self.comfyui_api_json = comfyui_api_json
        self.comfyui_api_json_reflex = None

        self.result: list = []
        self.time = time.strftime("%Y-%m-%d %H:%M:%S")

        self.backend_url = backend_url  # 后端url
        self.backend_id = None  # 用于区别后端, token或者ulr
        self.headers = {
            "Content-Type": "application/json",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0",
        }  # 后端headers
        self.login = login  # 是否需要登录后端
        self.token = token  # 后端token
        self.count = count  # 适用于后端的负载均衡中遍历的后端编号
        self.config = init_instance.config  # 配置文件
        self.backend_name = ''  # 后端名称
        self.current_config = None  # 当前后端的配置

        self.fail_on_login = None
        self.fail_on_requesting = None

        self.result = None  # api返回的结果
        self.img = []  # 返回的图片
        self.img_url = []
        self.img_btyes = []
        self.input_img = input_img

        self.payload = payload  # post时使用的负载
        self.request = request
        self.path = path

        self.logger = None
        self.setup_logger = setup_logger
        self.redis_client = init_instance.redis_client

        self.parameters = None  # 图片元数据
        self.post_event = None
        self.task_id = uuid.uuid4().hex
        self.task_type = 'txt2img'
        self.workload_name = None
        self.current_date = datetime.now().strftime('%Y%m%d')
        self.save_path = ''

        self.start_time = None
        self.end_time = None
        self.spend_time = None
        self.comment = None

        self.current_process = None

        self.build_info: dict = None
        self.build_respond: dict = None

        self.nsfw_detected = False
        self.DBAPIExceptions = exceptions.DrawBridgeAPIException

        self.reflex_dict = {}

    def format_api_respond(self):

        self.build_info = {
            "prompt": self.tags,
            "all_prompts": self.repeat(self.tags)
        ,
            "negative_prompt": self.ntags,
            "all_negative_prompts": self.repeat(self.ntags)
        ,
            "seed": self.seed_list,
            "all_seeds": self.seed_list,
            "subseed": self.seed,
            "all_subseeds": self.seed_list,
            "subseed_strength": 0,
            "width": self.width,
            "height": self.height,
            "sampler_name": self.sampler,
            "cfg_scale": self.scale,
            "steps": self.steps,
            "batch_size": 1,
            "restore_faces": False,
            "face_restoration_model": None,
            "sd_model_name": self.model,
            "sd_model_hash": self.model_hash,
            "sd_vae_name": 'no vae',
            "sd_vae_hash": self.model_hash,
            "seed_resize_from_w": -1,
            "seed_resize_from_h": -1,
            "denoising_strength": self.denoising_strength,
            "extra_generation_params": {

            },
            "index_of_first_image": 0,
            "infotexts": self.repeat(
                f"{self.tags}\\nNegative prompt: {self.ntags}\\nSteps: {self.steps}, Sampler: {self.sampler}, CFG scale: {self.scale}, Seed: {self.seed_list}, Size: {self.final_width}x{self.final_height}, Model hash: c7352c5d2f, Model: {self.model}, Denoising strength: {self.denoising_strength}, Clip skip: {self.clip_skip}, Version: 1.1.4"
            )
        ,
            "styles": [

            ],
            "job_timestamp": "0",
            "clip_skip": self.clip_skip,
            "is_using_inpainting_conditioning": False
        }

        self.build_respond = {
            "images": self.img,
            "videos": [],
            "images_url": self.img_url,
            "parameters": {
                "prompt": self.tags,
                "negative_prompt": self.ntags,
                "seed": self.seed_list,
                "subseed": -1,
                "subseed_strength": 0,
                "seed_resize_from_h": -1,
                "seed_resize_from_w": -1,
                "sampler_name": '',
                "batch_size": 1,
                "n_iter": self.total_img_count,
                "steps": self.steps,
                "cfg_scale": self.scale,
                "width": self.width,
                "height": self.height,
                "restore_faces": None,
                "tiling": None,
                "do_not_save_samples": None,
                "do_not_save_grid": None,
                "eta": None,
                "denoising_strength": 0,
                "s_min_uncond": None,
                "s_churn": None,
                "s_tmax": None,
                "s_tmin": None,
                "s_noise": None,
                "override_settings": None,
                "override_settings_restore_afterwards": True,
                "refiner_checkpoint": None,
                "refiner_switch_at": None,
                "disable_extra_networks": False,
                "comments": None,
                "enable_hr": True if self.enable_hr else False,
                "firstphase_width": 0,
                "firstphase_height": 0,
                "hr_scale": self.hr_scale,
                "hr_upscaler": None,
                "hr_second_pass_steps": self.hr_second_pass_steps,
                "hr_resize_x": 0,
                "hr_resize_y": 0,
                "hr_checkpoint_name": None,
                "hr_sampler_name": None,
                "hr_prompt": "",
                "hr_negative_prompt": "",
                "sampler_index": "Euler",
                "script_name": None,
                "script_args": [],
                "send_images": True,
                "save_images": False,
                "alwayson_scripts": {}
            },

            "info": ''
        }
        image = Image.open(BytesIO(self.img_btyes[0]))
        self.final_width, self.final_height = image.size

        str_info = json.dumps(self.build_info)
        self.build_respond['info'] = str_info

    def format_models_resp(self, input_list=None):
        models_resp_list = []
        input_list = input_list if input_list else [self.model]
        for i in input_list:
            built_reps = {
                "title": f"{i} [{self.model_hash}]",
                "model_name": i,
                "hash": f"{self.model_hash}",
                "sha256": "03f33720f33b67634b5da3a8bf2e374ef90ea03e85ab157fcf89bf48213eee4e",
                "filename": self.backend_name,
                "config": None
            }
            models_resp_list.append(built_reps)

        return models_resp_list

    @staticmethod
    async def write_image(img_data, save_path):
        """

        异步保存图片数据到指定路径。

        :param img_data: 图片的字节数据

        :param save_path: 保存图片的完整路径

        """
        if "view?filename=" in str(save_path):
            save_path = Path(str(save_path).replace("view?filename=", ""))
        async with aiofiles.open(save_path, 'wb') as img_file:
            await img_file.write(img_data)

    @staticmethod
    async def run_later(func, delay=1):
        loop = asyncio.get_running_loop()
        loop.call_later(
            delay,
            lambda: loop.create_task(
                func
            )
        )

    @staticmethod
    def format_progress_api_resp(progress, start_time) -> dict:
        build_resp = {
            "progress": progress,
            "eta_relative": 0.0,
            "state": {
                "skipped": False,
                "interrupted": False,
                "job": "",
                "job_count": 0,
                "job_timestamp": start_time,
                "job_no": 0,
                "sampling_step": 0,
                "sampling_steps": 0
            },
            "current_image": "data:image/png;base64,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",
            "textinfo": None
        }

        return build_resp

    @staticmethod
    def format_vram_api_resp():

        build_resp = {
          "ram": {
            "free": 61582063428.50122,
            "used": 2704183296,
            "total": 64286246724.50122
          },
          "cuda": {
            "system": {
              "free": 4281335808,
              "used": 2160787456,
              "total": 85899345920
            },
            "active": {
              "current": 699560960,
              "peak": 3680867328
            },
            "allocated": {
              "current": 699560960,
              "peak": 3680867328
            },
            "reserved": {
              "current": 713031680,
              "peak": 3751804928
            },
            "inactive": {
              "current": 13470720,
              "peak": 650977280
            },
            "events": {
              "retries": 0,
              "oom": 0
            }
          }
        }
        return build_resp

    @staticmethod
    async def http_request(

            method,

            target_url,

            headers=None,

            params=None,

            content=None,

            format=True,

            timeout=300,

            verify=True,

            http2=False,

            use_aiohttp=False,

            proxy=False

    ) -> Union[dict, httpx.Response, bytes, list]:

        logger = setup_logger("[HTTP_REQUEST]")

        if use_aiohttp:
            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=timeout)) as session:
                async with session.request(
                        method,
                        target_url,
                        headers=headers,
                        params=params,
                        data=content,
                        ssl=verify,
                        proxy=init_instance.config.server_settings['proxy'] if proxy else None
                ) as response:
                    if format:
                        return await response.json()
                    else:
                        return await response.read()

        proxies = {
            "http://": init_instance.config.server_settings['proxy'] if proxy else None,
            "https://": init_instance.config.server_settings['proxy'] if proxy else None,
        }

        async with httpx.AsyncClient(
                verify=verify,
                http2=http2,
                proxies=proxies
        ) as client:
            try:
                response = await client.request(
                    method,
                    target_url,
                    headers=headers,
                    params=params,
                    content=content,
                    timeout=timeout,
                )
                response.raise_for_status()
            except httpx.RequestError as e:
                error_info = {"error": "Request error", "details": traceback.format_exc()}
                logger.warning(error_info)
                return error_info
            except httpx.HTTPStatusError as e:
                error_info = {"error": "HTTP error", "status_code": e.response.status_code, "details": traceback.format_exc()}
                logger.warning(error_info)
                return error_info
            if format:
                return response.json()
            else:
                return response

    def repeat(self, input_):
        # 使用列表推导式生成重复的tag列表
        repeated_ = [input_ for _ in range(self.total_img_count)]
        return repeated_

    async def exec_login(self):
        pass

    async def check_backend_usability(self):
        pass

    async def get_backend_working_progress(self):

        self.get_backend_id()

        avg_time = 0
        try:
            if self.redis_client.exists("backend_avg_time"):
                backend_avg_dict = json.loads(self.redis_client.get("backend_avg_time"))
                spend_time_list = backend_avg_dict.get(self.backend_id, [])
                if spend_time_list and len(spend_time_list) >= 10:
                    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

            workload_dict = await self.set_backend_working_status(get=True)
            start_time = workload_dict.get('start_time', None)
            end_time = workload_dict.get('end_time', None)
            current_time = time.time()

            if end_time:
                progress = 0.0
            else:
                if start_time:
                    spend_time = current_time - start_time
                    self.logger.info(f"当前耗时: {spend_time}")

                    if avg_time:
                        progress = 0.99 if spend_time > avg_time else spend_time / avg_time
                    else:
                        progress = 0.99
                else:
                    progress = 0.0

            available = await self.set_backend_working_status(get=True, key="available")
            sc = 200 if available is True else 500
            build_resp = self.format_progress_api_resp(progress, self.start_time)

        except:
            traceback.print_exc()

        return build_resp, sc, self.backend_id, sc

    async def send_result_to_api(self):
        """

        获取生图结果的函数

        :return: 类A1111 webui返回值

        """
        if self.backend_id is None:
            self.get_backend_id()
        total_retry = self.config.retry_times

        for retry_times in range(total_retry):
            self.start_time = time.time()

            try:
                await self.set_backend_working_status(
                    params={"start_time": self.start_time, "idle": False, "end_time": None}
                )
                # 如果传入了Request对象/转发请求
                if self.request:
                    target_url = f"{self.backend_url}/{self.path}"

                    self.logger.info(f"{_('Forwarding request')} - {target_url}")

                    method = self.request.method
                    headers = self.request.headers
                    params = self.request.query_params
                    content = await self.request.body()

                    response = await self.http_request(method, target_url, headers, params, content, False)

                    try:
                        resp = response.json()
                    except json.JSONDecodeError:
                        self.logger.error(str(response.text))
                        raise RuntimeError(_('Backend returned error'))

                    self.result = JSONResponse(content=resp, status_code=response.status_code)
                else:

                    if "comfyui" in self.backend_name:
                        await self.add_to_queue(self.backend_id[:24], self.posting)
                        self.logger.info(_('Comfyui Backend, not using built-in multi-image generation management'))
                    elif "a1111" in self.backend_name:
                        await self.add_to_queue(self.backend_id[:24], self.posting)
                        self.logger.info(_('A1111 Backend, not using built-in multi-image generation management'))
                    else:
                        self.logger.info(f"{self.backend_name}: {self.backend_id[:24]} total {self.total_img_count} images")
                        for i in range(self.total_img_count):
                            if i > 0:
                                self.seed += 1
                                self.seed_list.append(self.seed)

                            await self.add_to_queue(self.backend_id[:24], self.posting)

                    if self.config.server_settings['enable_nsfw_check']:
                        await self.pic_audit()
                break

            except Exception as e:

                self.logger.info(f"{retry_times + 1} retries")
                self.logger.error(traceback.format_exc())

                # if retry_times >= (total_retry - 1):
                #     await asyncio.sleep(30)

                if retry_times == (total_retry - 1):

                    err = traceback.format_exc()
                    self.logger.error(f"{_('Over maximum retry times, posting still failed')}: {err}")
                    await self.return_build_image(text=f"Exception: {e}", title="FATAL")
                    await self.err_formating_to_sd_style()
                    return self

            finally:
                self.end_time = time.time()
                self.spend_time = self.end_time - self.start_time
                self.logger.info(_("Request completed, took %s seconds") % int(self.spend_time))
                await self.set_backend_working_status(params={"end_time": self.end_time, "idle": True})

        return self

    async def post_request(self):
        try:
            post_api = f"{self.backend_url}/sdapi/v1/txt2img"
            if self.init_images:
                post_api = f"{self.backend_url}/sdapi/v1/img2img"

            response = await self.http_request(
                method="POST",
                target_url=post_api,
                headers=self.headers,
                content=json.dumps(self.payload),
                format=False,

            )

            if isinstance(response, httpx.Response):
                resp_dict = response.json()

                if response.status_code not in [200, 201]:
                    self.logger.error(resp_dict)
                    if resp_dict.get("error") == "OutOfMemoryError":
                        self.logger.info(_("VRAM OOM detected, auto model unload and reload"))
                        await self.unload_and_reload(self.backend_url)
                else:
                    self.result = resp_dict
                    self.logger.info(_("Get a respond image, processing"))
            else:
                self.logger.error(f"{_('Request failed, error message:')} {response.get('details')}")
            return True

        except:
            traceback.print_exc()

    async def posting(self):
        
        """

        默认为a1111webui posting

        :return:

        """
        await self.post_request()

        # self.post_event = asyncio.Event()
        # post_task = asyncio.create_task(self.post_request())
        # # 此处为显示进度条
        # while not self.post_event.is_set():
        #     await self.show_progress_bar()
        #     await asyncio.sleep(2)
        #
        # ok = await post_task

    async def download_img(self, image_list=None):
        """

        使用aiohttp下载图片并保存到指定路径。

        """

        for url in self.img_url:
            response = await self.http_request(
                method="GET",
                target_url=url,
                headers=None,
                format=False,
                verify=False,
                proxy=True
            )

            if isinstance(response, httpx.Response):
                if response.status_code == 200:
                    img_data = response.read()
                    self.logger.info(_("Downloading image successful"))
                    self.img.append(base64.b64encode(img_data).decode('utf-8'))
                    self.img_btyes.append(img_data)
                    await self.save_image(img_data)
                else:
                    self.logger.error(f"{_('Image download failed!')}: {response.status_code}")
                    raise ConnectionError(_('Image download failed!'))
            else:
                self.logger.error(f"{_('Request failed, error message:')} {response.get('details')}")

    async def save_image(self, img_data, base_path="txt2img"):

        self.save_path = Path(f'saved_images/{self.task_type}/{self.current_date}/{self.workload_name[:12]}')
        self.save_path.mkdir(parents=True, exist_ok=True)

        img_filename = self.save_path / Path(self.task_id).name
        await self.run_later(self.write_image(img_data, img_filename), 1)

    async def unload_and_reload(self, backend_url=None):
        """

        释放a1111后端的显存

        :param backend_url: 后端url地址

        :return:

        """
        # 释放模型
        response = await self.http_request(
            method="POST",
            target_url=f"{backend_url}/sdapi/v1/unload-checkpoint",
            headers=None
        )

        if isinstance(response, httpx.Response):
            if response.status_code not in [200, 201]:
                error_message = await response.text()
                self.logger.error(f"释放模型失败，可能是webui版本太旧，未支持此API，错误: {error_message}")
        else:
            self.logger.error(f"{_('Request failed, error message:')} {response.get('details')}")

        # 重载模型
        response = await self.http_request(
            method="POST",
            target_url=f"{backend_url}/sdapi/v1/reload-checkpoint",
            headers=None
        )

        if isinstance(response, httpx.Response):
            if response.status_code not in [200, 201]:
                error_message = await response.text()
                self.logger.error(f"重载模型失败，错误: {error_message}")
            else:
                self.logger.info("重载模型成功")
        else:
            self.logger.error(f"{_('Request failed, error message:')} {response.get('details')}")

    async def get_backend_status(self):
        """

        共有函数, 用于获取各种类型的后端的工作状态

        :return:

        """
        await self.check_backend_usability()
        resp_json, resp_status = await self.get_backend_working_progress()

        return resp_json, resp_status

    async def show_progress_bar(self):
        """

        在控制台实时打印后端工作进度进度条

        :return:

        """
        show_str = f"[SD-A1111] [{self.time}] : {self.seed}"
        show_str = show_str.ljust(25, "-")
        with tqdm(total=1, desc=show_str + "-->", bar_format="{l_bar}{bar}|{postfix}\n") as pbar:
            while not self.post_event.is_set():
                self.current_process, eta = await self.update_progress()
                increment = self.current_process - pbar.n
                pbar.update(increment)
                pbar.set_postfix({"eta": f"{int(eta)}秒"})
                await asyncio.sleep(2)

    async def update_progress(self):
        """

        更新后端工作进度

        :return:

        """
        try:
            response = await self.http_request(
                method="GET",
                target_url=f"{self.backend_url}/sdapi/v1/progress",
                headers=None
            )

            if isinstance(response, httpx.Response):
                if response.status_code == 200:
                    resp_json = response.json()
                    return resp_json.get("progress"), resp_json.get("eta_relative")
                else:
                    self.logger.error(f"获取进度失败，状态码: {response.status_code}")
                    raise RuntimeError(f"获取进度失败，状态码: {response.status_code}")
            else:
                self.logger.error(f"请求失败，错误信息: {response.get('details')}")
                raise RuntimeError(f"请求失败，错误信息: {response.get('details')}")
        except:
            traceback.print_exc()
            return 0.404

    async def set_backend_working_status(

            self,

            params: dict = None,

            get: bool = False,

            key: str = None,

    ) -> bool or None:
        """

        设置或获取后端工作状态



        :param params: 包含要更新的参数的字典 (如 {'start_time': xxx, 'idle': True})

        :param get: 是否只读取

        :param key: 要获取的键

        :return: 获取或设置结果

        """
        current_backend_workload = self.redis_client.get('workload')
        backend_workload: dict = json.loads(current_backend_workload.decode('utf-8'))
        current_backend_workload: dict = backend_workload.get(self.workload_name)

        if get:
            if key is None:
                return current_backend_workload
            return current_backend_workload.get(key, None)

        if params:
            for param_key, param_value in params.items():
                if param_key in current_backend_workload:
                    current_backend_workload[param_key] = param_value

        backend_workload[self.workload_name] = current_backend_workload
        self.redis_client.set('workload', json.dumps(backend_workload))

        return True

    async def get_models(self) -> dict:

        if self.backend_name != self.config.backend_name_list[1]:
            respond = self.format_models_resp()

            backend_to_models_dict = {
                self.workload_name: respond
            }

            return backend_to_models_dict

        else:

            self.backend_url = self.config.a1111webui_setting['backend_url'][self.count]
            try:
                respond = await self.http_request(
                    "GET",
                    f"{self.backend_url}/sdapi/v1/sd-models",
                )
            except Exception:
                self.logger.warning(f"获取模型失败")
                respond = self.format_models_resp()

            backend_to_models_dict = {
                self.workload_name: respond
            }

            return backend_to_models_dict

    async def get_all_prompt_style(self) -> list:

        if self.backend_name == "comfyui":

            work_flows = []
            resp_dict = {}
            json_files = PATH_TO_COMFYUI_WORKFLOWS.glob("**/*.json")

            for json_file in json_files:
                prefixed_filename = f"comfyui-work-flows-{json_file.name}".replace('.json', '')
                if not json_file.name.endswith("_reflex.json"):
                    work_flows.append({"name": prefixed_filename, "prompt": "", "negative_prompt": ""})

            return work_flows

        else:

            resp = []

            try:
                self.backend_url = self.config.a1111webui_setting['backend_url'][self.count]
                respond = await self.http_request(
                    "GET",
                    f"{self.backend_url}/sdapi/v1/prompt-styles",
                    format=True
                )
                if respond.get('error', None):
                    self.logger.warning(f"获取预设失败")
                else:
                    resp = await respond.json()

            except:
                self.logger.warning(f"获取预设失败")
            finally:
                return resp

    async def pic_audit(self):
        from ..utils.tagger import wd_tagger_handler
        new_image_list = []
        for i in self.result['images']:
            is_nsfw = await wd_tagger_handler.tagger_main(i, 0.35, [], True)

            if is_nsfw:
                img_base64 = await self.return_build_image()
                new_image_list.append(img_base64)
            else:
                new_image_list.append(i)

        self.result['images'] = new_image_list

    async def return_build_image(self, title='Warning', text='NSFW Detected'):

        def draw_rounded_rectangle(draw, xy, radius, fill):
            x0, y0, x1, y1 = xy
            draw.rectangle([x0 + radius, y0, x1 - radius, y1], fill=fill)  # 中间部分
            draw.rectangle([x0, y0 + radius, x0 + radius, y1 - radius], fill=fill)  # 左上角
            draw.rectangle([x1 - radius, y0 + radius, x1, y1 - radius], fill=fill)  # 右上角
            draw.pieslice([x0, y0, x0 + 2 * radius, y0 + 2 * radius], 180, 270, fill=fill)  # 左上圆角
            draw.pieslice([x1 - 2 * radius, y0, x1, y0 + 2 * radius], 270, 360, fill=fill)  # 右上圆角
            draw.pieslice([x0, y1 - 2 * radius, x0 + 2 * radius, y1], 90, 180, fill=fill)  # 左下圆角
            draw.pieslice([x1 - 2 * radius, y1 - 2 * radius, x1, y1], 0, 90, fill=fill)  # 右下圆角

        # 创建一个新的图像
        img = Image.new("RGB", (512, 512), color=(255, 255, 255))
        draw = ImageDraw.Draw(img)

        # 设置字体大小
        title_font_size = 24
        text_font_size = 16

        # 加载默认字体
        title_font = ImageFont.load_default()
        text_font = ImageFont.load_default()

        # 绘制标题背景
        title_x = 20  # 左对齐，设置标题的横坐标
        title_y = 20  # 设置标题的纵坐标
        title_bbox = draw.textbbox((0, 0), title, font=title_font)

        # 绘制以标题为边界的背景
        draw_rounded_rectangle(draw,
                               (title_x - 10, title_y - 10, title_x + title_bbox[2] + 10, title_y + title_bbox[3] + 10),
                               radius=10, fill=(0, 0, 0))

        # 绘制标题
        draw.text((title_x, title_y), title, fill=(255, 255, 255), font=title_font)  # 白色标题

        # 准备绘制文本，设置最大宽度
        max_text_width = img.width - 40
        wrapped_text = []
        words = text.split(' ')
        current_line = ""

        for word in words:
            test_line = f"{current_line} {word}".strip()
            text_bbox = draw.textbbox((0, 0), test_line, font=text_font)
            if text_bbox[2] - text_bbox[0] <= max_text_width:
                current_line = test_line
            else:
                wrapped_text.append(current_line)
                current_line = word

        wrapped_text.append(current_line)  # 添加最后一行

        # 绘制内容文字
        text_y = title_y + 40  # 让内容文字与标题有间距
        for line in wrapped_text:
            text_x = 20  # 左对齐，设置内容文字的横坐标

            # 绘制内容文字背景
            text_bbox = draw.textbbox((0, 0), line, font=text_font)
            draw_rounded_rectangle(draw,
                                   (text_x - 10, text_y - 5, text_x + text_bbox[2] + 10, text_y + text_bbox[3] + 5),
                                   radius=10, fill=(0, 0, 0))

            # 绘制内容文字
            draw.text((text_x, text_y), line, fill=(255, 255, 255), font=text_font)  # 白色内容文字
            text_y += text_bbox[3] - text_bbox[1] + 5  # 行间距

        # 将图像保存到内存字节流中
        img_byte_array = BytesIO()
        img.save(img_byte_array, format='PNG')
        img_byte_array.seek(0)

        # 编码为base64
        base64_image = base64.b64encode(img_byte_array.getvalue()).decode('utf-8')
        self.img_btyes.append(img_byte_array.getvalue())
        self.img.append(base64_image)

        return base64_image

    def get_backend_id(self):
        self.backend_id = self.token or self.backend_url

    async def err_formating_to_sd_style(self):

        self.format_api_respond()

        self.result = self.build_respond