Upload 50 files

DrawBridgeAPI/api_server.py

@@ -0,0 +1,440 @@
+import base64
+import os
+import httpx
+import asyncio
+import time
+import traceback
+import json
+import itertools
+import argparse
+import uvicorn
+import logging
+import warnings
+import uuid
+import aiofiles
+import gradio
+import threading
+
+os.environ['CIVITAI_API_TOKEN'] = 'kunkun'
+os.environ['FAL_KEY'] = 'Daisuki'
+path_env = os.getenv("CONF_PATH")
+
+from .utils import request_model, topaz, run_later
+from .base_config import setup_logger, init_instance
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, RedirectResponse
+from fastapi.exceptions import HTTPException
+from pathlib import Path
+
+from .locales import _
+
+app = FastAPI()
+
+parser = argparse.ArgumentParser(description='Run the FastAPI application.')
+parser.add_argument('--host', type=str, default='0.0.0.0',
+                    help='The host IP address to listen on (default: 0.0.0.0).')
+parser.add_argument('--port', type=int, default=8000,
+                    help='The port number to listen on (default: 8000).')
+parser.add_argument('--conf', '-c', type=str, default='./config.yaml',
+                    help='配置文件路径', dest='conf')
+
+args = parser.parse_args()
+port = args.port
+host = args.host
+config_file_path = path_env or args.conf
+
+init_instance.init(config_file_path)
+config = init_instance.config
+redis_client = init_instance.redis_client
+
+from .backend import TaskHandler, Backend, StaticHandler
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+logger = setup_logger("[API]")
+logging.getLogger("uvicorn.access").disabled = True
+logging.getLogger("uvicorn.error").disabled = True
+logging.getLogger("fastapi").disabled = True
+
+
+class Api:
+    def __init__(self):
+        self.app = app
+        self.backend_instance = Backend()
+
+        self.add_api_route(
+            "/sdapi/v1/txt2img",
+            self.txt2img_api,
+            methods=["POST"],
+            # response_model=request_model.Txt2ImgRequest
+        )
+        self.add_api_route(
+            "/sdapi/v1/img2img",
+            self.img2img_api,
+            methods=["POST"],
+            # response_model=request_model.Img2ImgRequest
+        )
+        self.add_api_route(
+            "/sdapi/v1/sd-models",
+            self.get_sd_models,
+            methods=["GET"]
+        )
+        self.add_api_route(
+            "/sdapi/v1/progress",
+            self.get_progress,
+            methods=["GET"]
+        )
+        self.add_api_route(
+            "/sdapi/v1/memory",
+            self.get_memory,
+            methods=["GET"]
+        )
+        self.add_api_route(
+            "/sdapi/v1/options",
+            self.get_options,
+            methods=["GET"]
+        )
+        self.add_api_route(
+            "/sdapi/v1/options",
+            self.set_options,
+            methods=["POST"]
+        )
+        self.add_api_route(
+            "/sdapi/v1/prompt-styles",
+            self.get_prompt_styles,
+            methods=["GET"]
+        )
+
+        if config.server_settings['build_in_tagger']:
+
+            from .utils.tagger import wd_tagger_handler, wd_logger
+            self.add_api_route(
+                "/tagger/v1/interrogate",
+                self.tagger,
+                methods=["POST"],
+                response_model=request_model.TaggerRequest
+            )
+
+            if config.server_settings['llm_caption']['enable']:
+                from .utils.llm_captions import llm_logger, joy_caption_handler
+                self.add_api_route(
+                    "/llm/caption",
+                    self.llm_caption,
+                    methods=["POST"],
+                    response_model=request_model.TaggerRequest
+                )
+
+        if config.server_settings['build_in_photoai']['exec_path']:
+            self.add_api_route(
+                "/topazai/image",
+                self.topaz_ai,
+                methods=["POST"]
+            )
+
+    def add_api_route(self, path: str, endpoint, **kwargs):
+        return self.app.add_api_route(path, endpoint, **kwargs)
+
+    @staticmethod
+    async def generate_handle(data) -> TaskHandler:
+
+        model_to_backend = None
+        if data['override_settings'].get("sd_model_checkpoint", None):
+            model_to_backend = data['override_settings'].get("sd_model_checkpoint", None)
+
+        styles = data.get('styles', [])
+        selected_style = []
+        selected_comfyui_style = []
+
+        logger.error(styles)
+
+        if styles:
+            api_styles = StaticHandler.get_prompt_style()
+
+            for index, i in enumerate(api_styles):
+                for style in styles:
+                    if style in i['name']:
+                        if 'comfyui' in i['name']:
+                            logger.info(f"{_('Selected ComfyUI style')} - {i['name']}")
+                            selected_comfyui_style.append(i['name'])
+                        else:
+                            selected_style.append(i['name'])
+
+        if selected_style:
+            for i in selected_style:
+                data['prompt'] = data.get('prompt', '') + i['prompt']
+                data['negative_prompt'] = data.get('negative_prompt', '') + i['negative_prompt']
+
+        task_handler = TaskHandler(
+            data,
+            model_to_backend=model_to_backend,
+            comfyui_json=selected_comfyui_style[0].replace('comfyui-work-flows-', '') if selected_comfyui_style else None
+        )
+
+        return task_handler
+
+    @staticmethod
+    async def txt2img_api(request: request_model.Txt2ImgRequest, api: Request):
+
+        data = request.model_dump()
+        client_host = api.client.host
+
+        task_handler = await Api.generate_handle(data)
+
+        try:
+            logger.info(f"{_('Exec TXT2IMG')} - {client_host}")
+            result = await task_handler.txt2img()
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            raise HTTPException(status_code=500, detail=str(e))
+
+        if result is None:
+            raise HTTPException(500, detail='Result not found')
+
+        return result
+
+    @staticmethod
+    async def img2img_api(request: request_model.Img2ImgRequest, api: Request):
+        data = request.model_dump()
+        client_host = api.client.host
+
+        if len(data['init_images']) == 0:
+            raise HTTPException(status_code=400, detail=_('IMG2IMG Requires image to start'))
+
+        task_handler = await Api.generate_handle(data)
+
+        try:
+            logger.info(f"{_('Exec IMG2IMG')} - {client_host}")
+            result = await task_handler.img2img()
+        except Exception as e:
+            logger.error(traceback.format_exc())
+            raise HTTPException(status_code=500, detail=str(e))
+
+        if result is None:
+            raise HTTPException(500, detail='Result not found')
+
+        return result
+
+    @staticmethod
+    async def get_sd_models():
+
+        task_list = []
+        path = '/sdapi/v1/sd-models'
+
+        task_handler = TaskHandler({}, None, path, reutrn_instance=True, override_model_select=True)
+        instance_list: list[Backend] = await task_handler.txt2img()
+
+        for i in instance_list:
+            task_list.append(i.get_models())
+        resp = await asyncio.gather(*task_list)
+
+        models_dict = {}
+        api_respond = []
+        for i in resp:
+            models_dict = models_dict | i
+            api_respond = api_respond + list(i.values())
+
+        api_respond = list(itertools.chain.from_iterable(api_respond))
+
+        redis_resp: bytes = redis_client.get('models')
+        redis_resp: dict = json.loads(redis_resp.decode('utf-8'))
+        redis_resp.update(models_dict)
+        redis_client.set('models', json.dumps(redis_resp))
+        return api_respond
+
+    async def tagger(self, request: request_model.TaggerRequest):
+        from .utils.tagger import wd_tagger_handler, wd_logger
+
+        data = request.model_dump()
+        base64_image = await self.download_img_from_url(data)
+        caption = await wd_tagger_handler.tagger_main(base64_image, data['threshold'], data['exclude_tags'])
+        resp = {}
+
+        resp['caption'] = caption
+        wd_logger.info(f"{_('Caption Successful')}, {caption}")
+        return JSONResponse(resp)
+
+    async def llm_caption(self, request: request_model.TaggerRequest):
+
+        from .utils.llm_captions import llm_logger, joy_caption_handler
+        from .utils.tagger import wd_tagger_handler, wd_logger
+
+        data = request.model_dump()
+        base64_image = await self.download_img_from_url(data)
+
+        try:
+            caption = await joy_caption_handler.get_caption(base64_image, data['exclude_tags'])
+        except Exception as e:
+            traceback.print_exc()
+            raise HTTPException(status_code=500, detail=str(e))
+
+        resp = {}
+
+        resp['llm'] = caption
+        llm_logger.info(f"{_('Caption Successful')}, {caption}")
+        # caption = await wd_tagger_handler.tagger_main(
+        #     base64_image,
+        #     data['threshold'],
+        #     data['exclude_tags']
+        # )
+        #
+        # resp['caption'] = caption
+        # wd_logger.info(f"打标成功,{caption}")
+        return JSONResponse(resp)
+
+    async def get_progress(self):
+        return JSONResponse(self.backend_instance.format_progress_api_resp(0.0, time.time()))
+
+    async def get_memory(self):
+        return JSONResponse(self.backend_instance.format_vram_api_resp())
+
+    @staticmethod
+    async def get_options():
+        return JSONResponse(StaticHandler.get_backend_options())
+
+    @staticmethod
+    async def set_options(request: request_model.SetConfigRequest):
+
+        data = request.model_dump()
+        if data.get('sd_model_checkpoint', None):
+            logger.info(_("Lock to backend has configured"))
+            StaticHandler.set_lock_to_backend(data.get('sd_model_checkpoint'))
+
+        return
+
+    @staticmethod
+    async def topaz_ai(request: request_model.TopazAiRequest):
+        data = request.model_dump()
+
+        unique_id = str(uuid.uuid4())
+        save_dir = Path("saved_images") / unique_id
+        processed_dir = save_dir / 'processed'
+        save_dir.mkdir(parents=True, exist_ok=True)
+        del data['output_folder']
+
+        try:
+
+            if data['image']:
+                base64_image = data['image']
+                input_image_path = save_dir / f"{unique_id}_image.png"
+                async with aiofiles.open(input_image_path, "wb") as image_file:
+                    await image_file.write(base64.b64decode(base64_image))
+                output, error, return_code = await asyncio.get_running_loop().run_in_executor(
+                    None, topaz.run_tpai(
+                        input_folder=str(save_dir.resolve()),
+                        output_folder=str(processed_dir.resolve()),
+                        **data
+                    )
+                )
+            elif data['input_folder']:
+                output, error, return_code = await asyncio.get_running_loop().run_in_executor(
+                    None, topaz.run_tpai(
+                        output_folder=str(processed_dir.resolve()),
+                        **data
+                    )
+                )
+        except:
+            traceback.print_exc()
+            raise HTTPException(status_code=500, detail="Error occurred while processing the image.")
+
+        if return_code == 0:
+            files = list(processed_dir.glob("*"))
+
+            processed_image_path = files[0]
+            if processed_image_path.exists():
+                async with aiofiles.open(processed_image_path, "rb") as img_file:
+                    encoded_image = base64.b64encode(await img_file.read()).decode('utf-8')
+                processed_dir.rmdir()
+                return {"status": "success", "image": encoded_image}
+            else:
+                raise HTTPException(status_code=500, detail="Processed image not found.")
+        else:
+            raise HTTPException(status_code=500, detail=f"Error: {error}")
+
+    async def download_img_from_url(self, data):
+
+        base64_image = data['image']
+
+        if data['image'].startswith("http"):
+            image_url = data['image']
+            logger.info(f"{_('URL detected')}: {image_url}")
+            response = await self.backend_instance.http_request(
+                "GET",
+                image_url,
+                format=False
+            )
+
+            if response.status_code != 200:
+                logger.warning(_("Image download failed!"))
+
+            base64_image = base64.b64encode(response.read())
+
+        return base64_image
+
+    @staticmethod
+    async def get_prompt_styles():
+
+        task_list = []
+        path = '/sdapi/v1/prompt-styles'
+
+        task_handler = TaskHandler({}, None, path, reutrn_instance=True, override_model_select=True)
+        instance_list: list[Backend] = await task_handler.txt2img()
+
+        for i in instance_list:
+            task_list.append(i.get_all_prompt_style())
+        resp = await asyncio.gather(*task_list)
+
+        api_respond = []
+        for i in resp:
+            api_respond += i
+
+        StaticHandler.set_prompt_style(api_respond)
+
+        return api_respond
+
+    async def init_api(self):
+        await self.get_sd_models()
+        await self.get_prompt_styles()
+
+
+api_instance = Api()
+
+
+@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+async def proxy(path: str, request: Request):
+    client_host = request.client.host
+
+    task_handler = TaskHandler({}, request, path)
+
+    try:
+        logger.info(f"{_('Exec forwarding')} - {client_host}")
+        result = await task_handler.sd_api()
+    except Exception as e:
+        logger.error(traceback.format_exc())
+        raise HTTPException(500, detail=str(e))
+
+    if result is None:
+        raise HTTPException(500, detail='Result not found')
+
+    return result
+
+
+@app.get("/backend-control")
+async def get_backend_control(backend: str, key: str, value: bool):
+    pass
+
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info(_('Waiting for API initialization'))
+    await api_instance.init_api()
+    logger.info(_('API initialization completed'))
+
+
+if __name__ == "__main__":
+
+    # if config.server_settings['start_gradio']:
+    #     demo = create_gradio_interface(host, port)
+    #     app = gradio.mount_gradio_app(api_instance.app, demo, path="/")
+
+    uvicorn.run(api_instance.app, host=host, port=port)

DrawBridgeAPI/app.py

@@ -0,0 +1,105 @@
+import json
+import asyncio
+import gradio as gr
+import os
+os.environ['CIVITAI_API_TOKEN'] = 'kunkun'
+os.environ['FAL_KEY'] = 'Daisuki'
+os.environ['CONF_PATH'] = './config.yaml'
+from PIL import Image
+
+import io
+import base64
+import httpx
+from .base_config import init_instance
+from .backend import TaskHandler
+from .locales import _
+
+
+class Gradio:
+    def __init__(self, host, port):
+        self.host = '127.0.0.1' if host == '0.0.0.0' else host
+        self.port = port
+
+    def get_caption(self, image):
+        caption = httpx.post(
+            f"http://{self.host}:{self.port}/tagger/v1/interrogate",
+             json=json.loads({"image": image}), timeout=600).json()
+        return caption
+
+
+def format_caption_output(caption_result):
+    llm_text = caption_result.get("llm", '')
+    word_scores = "\n".join([f"{word}: {score}" for word, score in caption_result["caption"].items()])
+    word_ = ",".join([f"{word}" for word in caption_result["caption"].keys()])
+    return llm_text, word_scores, word_
+
+
+async def create_gradio_interface(host, port):
+
+    gradio_api = Gradio(host, port)
+    from .api_server import api_instance
+    all_models = [i['title'] for i in await api_instance.get_sd_models()]
+    init_instance.logger.info(f"{_('Server is ready!')} Listen on {host}:{port}")
+
+    async def get_image(model, prompt, negative_prompt, width, height, cfg_scale, steps):
+
+        payload = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "width": width,
+            "height": height,
+            "steps": steps,
+            "cfg_scale": cfg_scale
+        }
+
+        task_handler = TaskHandler(payload, model_to_backend=model)
+        result = await task_handler.txt2img()
+        image_data = result.get("images")[0]
+        image = Image.open(io.BytesIO(base64.b64decode(image_data)))
+        return image
+
+    with gr.Blocks() as demo:
+        with gr.Tab("txt2img"):
+            with gr.Row():
+                with gr.Column():
+                    model = gr.Dropdown(label="Model", choices=all_models)
+                    prompt = gr.Textbox(label="Prompt", placeholder="Enter your prompt here...")
+                    negative_prompt = gr.Textbox(label="Negative Prompt",
+                                                 placeholder="Enter your negative prompt here...")
+                    width = gr.Slider(label="Width", minimum=64, maximum=2048, step=1, value=512)
+                    height = gr.Slider(label="Height", minimum=64, maximum=2048, step=1, value=512)
+                    cfg_scale = gr.Slider(label="CFG Scale", minimum=1, maximum=30, step=0.1, value=7.5)
+                    steps = gr.Slider(label="Steps", minimum=1, maximum=200, step=1, value=20)
+                    generate_button = gr.Button("Generate Image")
+
+                with gr.Column():
+                    output_image = gr.Image(label="Generated Image")
+
+            generate_button.click(get_image, [model, prompt, negative_prompt, width, height, cfg_scale, steps],
+                                  output_image)
+
+        with gr.Tab("Caption"):
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.Image(label="Input Image")
+                    caption_button = gr.Button("Get Caption")
+
+                with gr.Column():
+                    llm_output = gr.Textbox(label="Natural Language Description")
+                    word_output_ = gr.Textbox(label="Keywords", lines=6)
+                    word_output = gr.Textbox(label="Keywords with Scores", lines=6)
+
+                caption_button.click(
+                    lambda image: format_caption_output(gradio_api.get_caption(image)),
+                    inputs=[input_image],
+                    outputs=[llm_output, word_output, word_output_]
+                )
+
+    return demo
+
+
+async def run_gradio(host, port):
+    interface = await create_gradio_interface(host, port)
+    interface.launch(server_name=host, server_port=port+1)
+
+asyncio.run(run_gradio("127.0.0.1", 5421))

DrawBridgeAPI/backend/FLUX_falai.py

@@ -0,0 +1,100 @@
+import traceback
+import piexif
+import fal_client
+import os
+
+from io import BytesIO
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = "Fal-AI - FLUX.1 [schnell]"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[FLUX-FalAI]')
+
+        token = self.config.fal_ai[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[2]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def get_shape(self):
+
+        aspect_ratio = self.width / self.height
+        tolerance = 0.05
+
+        def is_close_to_ratio(ratio):
+            return abs(aspect_ratio - ratio) < tolerance
+
+        if self.width == self.height:
+            return "square"
+        elif is_close_to_ratio(4 / 3):
+            return "portrait_4_3" if self.height > self.width else "landscape_4_3"
+        elif is_close_to_ratio(16 / 9):
+            return "portrait_16_9" if self.height > self.width else "landscape_16_9"
+        else:
+            return "portrait_4_3"
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def get_img_comment(self):
+
+        image_data = self.img_btyes[0]
+        image_file = BytesIO(image_data)
+        image_bytes = image_file.getvalue()
+        exif_dict = piexif.load(image_bytes)
+        try:
+            user_comment = exif_dict['Exif'].get(piexif.ExifIFD.UserComment)
+        except Exception:
+            return 'No Raw Data'
+
+        return user_comment.decode('utf-8', errors='ignore')
+
+    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):
+
+        os.environ['FAL_KEY'] = self.token
+        image_shape = await self.get_shape()
+        self.steps = int(self.steps / 3)
+
+        handler = await fal_client.submit_async(
+            "fal-ai/flux/schnell",
+            arguments={
+                "prompt": self.tags,
+                "image_size": image_shape,
+                "seed": self.seed,
+                "num_inference_steps": self.steps,  # FLUX不需要很高的步数
+                "num_images": self.total_img_count,
+                "enable_safety_checker": True
+            },
+        )
+
+        response = await handler.get()
+
+        try:
+            if response['images']:
+                images_list = response['images']
+                for i in images_list:
+                    self.img_url.append(i['url'])
+            else:
+                raise ValueError("图片没有被生成,可能是图片没有完成或者结果不可用")
+        except Exception as e:
+            self.fail_on_requesting = True
+            self.logger.error(f"请求API失败: {e}\n{traceback.format_exc()}")
+
+        await self.err_formating_to_sd_style()

DrawBridgeAPI/backend/FLUX_replicate.py

@@ -0,0 +1,112 @@
+import traceback
+import piexif
+import os
+import replicate
+
+from io import BytesIO
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = "Replicate - FLUX.1 [schnell]"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[FLUX-Replicate]')
+
+        token = self.config.replicate[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[3]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def get_shape(self):
+
+        aspect_ratio = self.width / self.height
+        tolerance = 0.05
+
+        def is_close_to_ratio(ratio):
+            return abs(aspect_ratio - ratio) < tolerance
+
+        if self.width == self.height:
+            return "1:1"
+        elif is_close_to_ratio(16 / 9):
+            return "16:9"
+        elif is_close_to_ratio(21 / 9):
+            return "21:9"
+        elif is_close_to_ratio(2 / 3):
+            return "2:3"
+        elif is_close_to_ratio(3 / 2):
+            return "3:2"
+        elif is_close_to_ratio(4 / 5):
+            return "4:5"
+        elif is_close_to_ratio(5 / 4):
+            return "5:4"
+        elif is_close_to_ratio(9 / 16):
+            return "9:16"
+        elif is_close_to_ratio(9 / 21):
+            return "9:21"
+        else:
+            return "2:3"
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def get_img_comment(self):
+
+        image_data = self.img_btyes[0]
+        image_file = BytesIO(image_data)
+        image_bytes = image_file.getvalue()
+        exif_dict = piexif.load(image_bytes)
+        try:
+            user_comment = exif_dict['Exif'].get(piexif.ExifIFD.UserComment)
+        except Exception:
+            return 'No Raw Data'
+
+        return user_comment.decode('utf-8', errors='ignore')
+
+    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):
+
+        os.environ['REPLICATE_API_TOKEN'] = self.token
+        image_shape = await self.get_shape()
+
+        input_ = {
+            "prompt": self.tags,
+            "seed": self.seed,
+            "num_outputs": self.total_img_count,
+            "aspect_ratio": image_shape,
+            "output_format": 'png',
+            "output_quality": 90
+        }
+
+        output = await replicate.async_run(
+            "black-forest-labs/flux-schnell",
+            input=input_
+        )
+
+        try:
+            if output:
+                for i in output:
+                    self.img_url.append(i)
+            else:
+                raise ValueError("图片没有被生成,可能是图片没有完成或者结果不可用")
+        except Exception as e:
+            self.fail_on_requesting = True
+            self.logger.error(f"请求API失败: {e}\n{traceback.format_exc()}")
+
+        await self.err_formating_to_sd_style()
+

DrawBridgeAPI/backend/SD_A1111_webui.py

@@ -0,0 +1,88 @@
+from urllib.parse import urlencode
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = "StableDiffusion"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[SD-A1111]')
+        self.current_config: dict = self.config.a1111webui_setting
+
+        self.backend_url = self.current_config['backend_url'][self.count]
+        name = self.current_config['name'][self.count]
+        self.backend_name = self.config.backend_name_list[1]
+        self.workload_name = f"{self.backend_name}-{name}"
+
+    async def exec_login(self):
+        login_data = {
+            'username': self.current_config['username'][self.count],
+            'password': self.current_config['password'][self.count]
+        }
+        encoded_data = urlencode(login_data)
+
+        response = await self.http_request(
+            method="POST",
+            target_url=f"{self.backend_url}/login",
+            headers={
+                "Content-Type": "application/x-www-form-urlencoded",
+                "accept": "application/json"
+            },
+            content=encoded_data,
+        )
+        if response.get('error') == "error":
+            self.logger.warning(f"后端{self.backend_name}登录失败")
+            self.fail_on_login = True
+            return False, 500
+        else:
+            self.logger.info(f"后端{self.backend_name}登录成功")
+            return True, 200
+
+    async def check_backend_usability(self):
+
+        if self.login:
+            resp = await self.exec_login()
+            if resp[0] is None:
+                self.fail_on_login = True
+                self.logger.warning(f"后端{self.backend_name}登陆失败")
+                return False, resp
+
+    async def get_backend_working_progress(self):
+        """
+        获取后端工作进度, 默认A1111
+        :return:
+        """
+        self.get_backend_id()
+        respond = await self.http_request(
+            "GET",
+            f"{self.backend_url}/sdapi/v1/options",
+            verify=False,
+            proxy=False,
+            use_aiohttp=False
+        )
+
+        print(respond)
+
+        self.model = respond['sd_model_checkpoint']
+        self.model_hash = respond
+
+        if self.current_config['auth'][self.count]:
+            self.login = True
+            await self.exec_login()
+
+        api_url = f"{self.backend_url}/sdapi/v1/progress"
+
+        resp = await self.http_request(
+            method="GET",
+            target_url=api_url,
+            format=False
+        )
+
+        resp_json = resp.json()
+        return resp_json, resp.status_code, self.backend_url, resp.status_code
+
+

DrawBridgeAPI/backend/SD_civitai_API.py

@@ -0,0 +1,108 @@
+import traceback
+import piexif
+import os
+import civitai
+
+from io import BytesIO
+
+from .base import Backend
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = "Civitai - urn:air:sd1:checkpoint:civitai:4201@130072"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[Civitai]')
+
+        token = self.config.civitai[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[0]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def get_img_comment(self):
+
+        image_data = self.img_btyes[0]
+        image_file = BytesIO(image_data)
+        image_bytes = image_file.getvalue()
+        exif_dict = piexif.load(image_bytes)
+        try:
+            user_comment = exif_dict['Exif'].get(piexif.ExifIFD.UserComment)
+        except KeyError:
+            return 'No Raw Data'
+
+        return user_comment.decode('utf-8', errors='ignore')
+
+    async def check_backend_usability(self):
+
+        self.headers['Authorization'] = f"Bearer {self.token}"
+        response = await self.http_request(
+            method="GET",
+            target_url='https://civitai.com/api/v1/models',
+            headers=self.headers,
+            params=None,
+            format=True
+        )
+
+        if isinstance(response, dict) and 'error' in response:
+            self.fail_on_login = True
+            return False
+        else:
+            resp_json = response
+            return True, (resp_json, 200)
+
+    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):
+
+        self.logger.info(f"开始使用{self.token}获取图片")
+
+        os.environ['CIVITAI_API_TOKEN'] = self.token
+        os.environ['HTTP_PROXY'] = self.config.civitai_setting['proxy'][self.count]
+        os.environ['HTTPS_PROXY'] = self.config.civitai_setting['proxy'][self.count]
+        await self.check_backend_usability()
+
+        input_ = {
+            "model": "urn:air:sd1:checkpoint:civitai:4201@130072",
+            "params": {
+                "prompt": self.tags,
+                "negativePrompt": self.ntags,
+                "scheduler": self.sampler,
+                "steps": self.steps,
+                "cfgScale": self.scale,
+                "width": self.width,
+                "height": self.height,
+                "clipSkip": 2,
+                "seed": self.seed
+            }
+        }
+
+        self.logger.info(f"任务已经发送!本次生图{self.total_img_count}张")
+
+        for i in range(self.total_img_count):
+
+            try:
+                response = await civitai.image.create(input_, wait=True)
+                if response['jobs'][0]['result'].get('available'):
+                    self.img_url.append(response['jobs'][0]['result'].get('blobUrl'))
+                else:
+                    raise ValueError("图片没有被生成,可能是图片没有完成或者结果不可用")
+            except Exception as e:
+                self.fail_on_requesting = True
+                self.logger.error(f"请求API失败: {e}\n{traceback.format_exc()}")
+
+        await self.err_formating_to_sd_style()
+
+
+
+

DrawBridgeAPI/backend/__init__.py

@@ -0,0 +1,909 @@
+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 ComfyuiHandler(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 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
+
+        # info_str = ''
+
+        # for key, values in cls.backend_avg_dict.items():
+        #     info_str += f"{key}: 最近10次生成时间{values}\n"
+        #
+        # cls.load_balance_logger.info(info_str)
+
+    @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)
+        # 获取api队列状态
+        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()
+            # ava_url_tuple = (ava_url, reverse_dict[ava_url], all_resp, len(normal_backend), vram_dict[ava_url])
+
+    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)
+
+
+
+

DrawBridgeAPI/backend/base.py

@@ -0,0 +1,984 @@
+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

DrawBridgeAPI/backend/comfyui.py

@@ -0,0 +1,423 @@
+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())

DrawBridgeAPI/backend/liblibai.py

@@ -0,0 +1,205 @@
+import asyncio
+import json
+import traceback
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.xl = self.config.liblibai_setting['xl'][self.count]
+        self.flux = self.config.liblibai_setting['flux'][self.count]
+        site_name = 'LiblibAI_XL' if self.xl else 'LiblibAI'
+        self.model = f"{site_name} - {self.config.liblibai_setting['model_name'][self.count]}"
+        self.model_id = self.config.liblibai_setting['model'][self.count]
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[LiblibAI]')
+
+        token = self.config.liblibai[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[4]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def heart_beat(self, id_):
+        self.logger.info(f"{id_}开始请求")
+        for i in range(60):
+
+            response = await self.http_request(
+                method="POST",
+                target_url=f"https://liblib-api.vibrou.com/gateway/sd-api/generate/progress/msg/v3/{id_}",
+                headers=self.headers,
+                content=json.dumps({"flag": 0}),
+                verify=False
+            )
+
+            # 检查请求结果并处理
+            if response.get('error') == "error":
+                self.logger.warning(f"Failed to request: {response}")
+                raise RuntimeError('服务器返回错误')
+            if response['code'] != 0 or response['data']['statusMsg'] == '执行异常':
+                raise RuntimeError('服务器返回错误')
+
+            images = response['data']['images']
+
+            if images is None:
+                self.logger.info(f"第{i+1}次心跳，未返回结果")
+                await asyncio.sleep(5)
+                continue
+            else:
+                # await self.set_backend_working_status(available=True)
+                for i in images:
+                    if 'porn' in i['previewPath']:
+                        self.nsfw_detected = True
+                        self.logger.warning("API侧检测到NSFW图片")
+                    else:
+                        self.logger.img(f"图片url: {i['previewPath']}")
+                        self.img_url.append(i['previewPath'])
+                        self.comment = i['imageInfo']
+                break
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def check_backend_usability(self):
+        pass
+
+    async def err_formating_to_sd_style(self):
+
+        if self.nsfw_detected:
+            await self.return_build_image()
+        else:
+            await self.download_img()
+
+        self.format_api_respond()
+
+        self.result = self.build_respond
+
+    async def posting(self):
+
+        if self.xl or self.flux:
+            if self.xl:
+                pre_tag, pre_ntag = tuple(self.config.liblibai_setting.get('preference')[self.count]['pretags']['xl'])
+            elif self.flux:
+                pre_tag, pre_ntag = tuple(self.config.liblibai_setting.get('preference')[self.count]['pretags']['flux'])
+            self.tags = pre_tag + self.tags
+            self.ntags = pre_ntag + self.ntags
+            if self.enable_hr:
+                self.width = int(self.width * self.hr_scale)
+                self.height = int(self.height * self.hr_scale)
+                self.enable_hr = False
+            elif self.width * self.height < 1048576:
+                self.width = int(self.width * 1.5)
+                self.height = int(self.height * 1.5)
+
+        self.steps = self.config.liblibai_setting.get('preference')[self.count].get('steps', 12)
+
+        if self.flux:
+            input_ = {
+                "checkpointId": 2295774,
+                "generateType": 17,
+                "frontCustomerReq": {
+                    "windowId": "",
+                    "tabType": "txt2img",
+                    "conAndSegAndGen": "gen"
+                },
+                "adetailerEnable": 0,
+                "text2imgV3": {
+                    "clipSkip": 2,
+                    "checkPointName": 2295774,
+                    "prompt": self.tags,
+                    "negPrompt": self.ntags,
+                    "seed": self.seed,
+                    "randnSource": 0,
+                    "samplingMethod": 31,
+                    "imgCount": self.batch_size,
+                    "samplingStep": self.steps,
+                    "cfgScale": self.scale,
+                    "width": self.width,
+                    "height": self.height
+                },
+                "taskQueuePriority": 1
+            }
+
+        else:
+            input_ = {
+                "checkpointId": self.model_id,
+                "generateType": 1,
+                "frontCustomerReq": {
+                    # "frontId": "f46f8e35-5728-4ded-b163-832c3b85009d",
+                    "windowId": "",
+                    "tabType": "txt2img",
+                    "conAndSegAndGen": "gen"
+                }
+            ,
+                "adetailerEnable": 0,
+                "text2img": {
+                    "prompt": self.tags,
+                    "negativePrompt": self.ntags,
+                    "extraNetwork": "",
+                    "samplingMethod": 0,
+                    "samplingStep": self.steps,
+                    "width": self.width,
+                    "height": self.height,
+                    "imgCount": self.batch_size,
+                    "cfgScale": self.scale,
+                    "seed": self.seed,
+                    "seedExtra": 0,
+                    "hiResFix": 0,
+                    "restoreFaces": 0,
+                    "tiling": 0,
+                    "clipSkip": 2,
+                    "randnSource": 0,
+                    "tileDiffusion": None
+                }
+            ,
+                "taskQueuePriority": 1
+            }
+
+        if self.enable_hr and self.flux is False and self.xl is False:
+
+            hr_payload = {
+                "hiresSteps": self.hr_second_pass_steps,
+                "denoisingStrength": self.denoising_strength,
+                "hiResFix": 1 if self.enable_hr else 0,
+                "hiResFixInfo": {
+                    "upscaler": 6,
+                    "upscaleBy": self.hr_scale,
+                    "resizeWidth": int(self.width * self.hr_scale),
+                    "resizeHeight": int(self.height * self.hr_scale)
+                }
+            }
+
+            input_['text2img'].update(hr_payload)
+
+        new_headers = {
+            "Accept": "application/json, text/plain, */*",
+            "Token": self.token
+        }
+        self.headers.update(new_headers)
+
+        response = await self.http_request(
+            method="POST",
+            target_url="https://liblib-api.vibrou.com/gateway/sd-api/generate/image",
+            headers=self.headers,
+            content=json.dumps(input_),
+            verify=False
+        )
+
+        # 检查请求结果
+        if response.get('error') == "error":
+            self.logger.warning(f"Failed to request: {response}")
+        else:
+            task = response
+            if task.get('msg') == 'Insufficient power':
+                self.logger.warning('费用不足!')
+            self.logger.info(f"API返回{task}")
+            task_id = task['data']
+            await self.heart_beat(task_id)
+
+        await self.err_formating_to_sd_style()
+
+

DrawBridgeAPI/backend/midjourney.py

@@ -0,0 +1,175 @@
+import time
+
+import aiohttp
+
+from .base import Backend
+from PIL import Image
+import asyncio
+import json
+import traceback
+import math
+import zipfile
+import io
+import os
+import aiofiles
+import base64
+
+from pathlib import Path
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = f"MidJourney"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[MidJourney]')
+
+        self.backend_url = self.config.midjourney['backend_url'][self.count]
+        self.backend_name = self.config.backend_name_list[10]
+        self.workload_name = f"{self.backend_name}-{self.config.midjourney['name'][self.count]}"
+
+    async def heart_beat(self, id_):
+        task_url = f"{self.backend_url}/mj/task/{id_}/fetch"
+
+        while True:
+            try:
+                resp = await self.http_request("GET", task_url, format=True)
+                status = resp.get('status')
+                content = ''
+
+                if status == "SUCCESS":
+                    content = resp['imageUrl']
+                    self.img_url.append(resp['imageUrl'])
+                    self.logger.img(f"任务{id_}成功完成，图片URL：{resp['imageUrl']}")
+                    return content
+
+                elif status == "FAILED":
+                    content = resp.get('failReason') or '未知原因'
+                    self.logger.error(f"任务处理失败，原因：{content}")
+
+                    raise Exception(f"任务处理失败，原因：{content}")
+
+                elif status == "NOT_START":
+                    content = '任务未开始'
+
+                elif status == "IN_PROGRESS":
+                    content = '任务正在运行'
+                    if resp.get('progress'):
+                        content += f"，进度：{resp['progress']}"
+
+                elif status == "SUBMITTED":
+                    content = '任务已提交处理'
+
+                elif status == "FAILURE":
+                    fail_reason = resp.get('failReason') or '未知原因'
+                    self.logger.error(f"任务处理失败，原因：{fail_reason}")
+                    if "Banned prompt detected" in fail_reason:
+                        await self.return_build_image("NSFW Prompt Detected")
+                        return
+                    else:
+                        raise Exception(f"任务处理失败，原因：{content}")
+
+                else:
+                    content = status
+
+                self.logger.info(f"任务{id_}状态：{content}")
+
+                await asyncio.sleep(5)
+
+            except Exception as e:
+                self.logger.error(f"任务{id_}心跳监控出错: {str(e)}")
+                raise
+
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def get_shape(self):
+
+        gcd = math.gcd(self.width, self.height)
+
+        simplified_width = self.width // gcd
+        simplified_height = self.height // gcd
+
+        ar = f"{simplified_width}:{simplified_height}"
+
+        return ar
+
+    async def check_backend_usability(self):
+        pass
+
+    async def split_image(self):
+        img = Image.open(io.BytesIO(self.img_btyes[0]))
+        width, height = img.size
+
+        half_width = width // 2
+        half_height = height // 2
+
+        coordinates = [(0, 0, half_width, half_height),
+                       (half_width, 0, width, half_height),
+                       (0, half_height, half_width, height),
+                       (half_width, half_height, width, height)]
+
+        images = [img.crop(c) for c in coordinates]
+
+        images_bytes = [io.BytesIO() for _ in range(4)]
+        base64_images = []
+
+        for i in range(4):
+            images[i].save(images_bytes[i], format='PNG')
+
+            images_bytes[i].seek(0)
+            base64_image = base64.b64encode(images_bytes[i].getvalue()).decode('utf-8')
+
+            base64_images.append(base64_image)
+
+        self.img_btyes += images_bytes
+        self.img += base64_images
+
+    # async def formating_to_sd_style(self):
+    #
+    #     await self.download_img()
+    #     await self.split_image()
+    #
+    #     self.format_api_respond()
+    #     self.result = self.build_respond
+
+    async def posting(self):
+
+        accept_ratio = await self.get_shape()
+
+        ntags = f"--no {self.ntags}" if self.ntags else ""
+
+        build_prompt = f"{self.tags} --ar {accept_ratio} --seed {self.seed}" + ' ' + ntags + ' '
+
+        payload = {
+            "prompt": build_prompt
+        }
+
+        if self.config.midjourney['auth_toekn'][self.count]:
+            self.headers.update({"mj-api-secret": self.config.midjourney['auth_toekn'][self.count]})
+
+        resp = await self.http_request(
+            "POST",
+            f"{self.backend_url}/mj/submit/imagine",
+            headers=self.headers,
+            content=json.dumps(payload),
+            format=True
+        )
+
+        if resp.get('code') == 24:
+            await self.return_build_image(text="NSFW Prompt Detected")
+
+        elif resp.get('code') == 1:
+            task_id = resp.get('result')
+            self.task_id = task_id
+            self.logger.info(f"任务提交成功，任务id: {task_id}")
+
+            await self.heart_beat(task_id)
+            await self.download_img()
+            await self.split_image()
+
+        self.format_api_respond()
+        self.result = self.build_respond

DrawBridgeAPI/backend/novelai.py

@@ -0,0 +1,161 @@
+import time
+
+import aiohttp
+
+from .base import Backend
+import asyncio
+import json
+import traceback
+import zipfile
+import io
+import os
+import aiofiles
+import base64
+
+from pathlib import Path
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = f"NovelAI - {self.config.novelai_setting['model'][self.count]}"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[NovelAI]')
+
+        token = self.config.novelai[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[9]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+        self.save_path = Path(f'saved_images/{self.task_type}/{self.current_date}/{self.workload_name[:12]}')
+
+        self.reflex_dict['sampler'] = {
+            "DPM++ 2M": "k_dpmpp_2m",
+            "DPM++ SDE": "k_dpmpp_sde",
+            "DPM++ 2M SDE": "k_dpmpp_2m_sde",
+            "DPM++ 2S a": "k_dpmpp_2s_ancestral",
+            "Euler a": "k_euler_ancestral",
+            "Euler": "k_euler",
+            "DDIM": "ddim_v3"
+        }
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    async def get_shape(self):
+        aspect_ratio = self.width / self.height
+
+        resolutions = {
+            "832x1216": (832, 1216),
+            "1216x832": (1216, 832),
+            "1024x1024": (1024, 1024),
+        }
+
+        closest_resolution = min(resolutions.keys(),
+                                 key=lambda r: abs((resolutions[r][0] / resolutions[r][1]) - aspect_ratio))
+
+        self.width, self.height = resolutions[closest_resolution]
+
+        return closest_resolution
+
+    async def check_backend_usability(self):
+        pass
+
+    async def err_formating_to_sd_style(self):
+
+        if self.nsfw_detected:
+            await self.return_build_image()
+
+        self.format_api_respond()
+
+        self.result = self.build_respond
+
+    async def posting(self):
+
+        self.sampler = self.reflex_dict['sampler'].get(self.sampler, "k_euler_ancestral")
+
+        header = {
+            "authorization": "Bearer " + self.token,
+            ":authority": "https://api.novelai.net",
+            ":path": "/ai/generate-image",
+            "content-type": "application/json",
+            "referer": "https://novelai.net",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
+        }
+
+        post_api = "https://image.novelai.net/ai/generate-image"
+
+        await self.get_shape()
+
+        parameters = {
+            "width": self.width,
+            "height": self.height,
+            "qualityToggle": False,
+            "scale": self.scale,
+            "sampler": self.sampler,
+            "steps": self.steps,
+            "seed": self.seed,
+            "n_samples": 1,
+            "ucPreset": 0,
+            "negative_prompt": self.ntags,
+        }
+
+        json_data = {
+            "input": self.tags,
+            "model": self.config.novelai_setting['model'][self.count],
+            "parameters": parameters
+        }
+
+        async def send_request():
+
+            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=300)) as session:
+                while True:
+                    async with session.post(
+                            post_api,
+                            headers=header,
+                            json=json_data,
+                            ssl=False,
+                            proxy=self.config.server_settings['proxy']
+                    ) as response:
+
+                        if response.status == 429:
+                            resp_text = await response.json()
+                            if resp_text['message'] == 'Rate limited':
+                                raise Exception("触发频率限制")
+                            self.logger.warning(f"token繁忙中..., {resp_text}")
+                            wait_time = 5
+                            await asyncio.sleep(wait_time)
+                        else:
+                            response_data = await response.read()
+                            try:
+                                with zipfile.ZipFile(io.BytesIO(response_data)) as z:
+                                    z.extractall(self.save_path)
+                            except:
+                                try:
+                                    resp_text = await response.json()
+                                except:
+                                    if resp_text['statusCode'] == 402:
+                                        self.logger.warning(f"token余额不足, {resp_text}")
+                            return
+
+        await send_request()
+
+        # self.save_path = self.save_path
+        # self.save_path.mkdir(parents=True, exist_ok=True)
+
+        await self.images_to_base64(self.save_path)
+
+        await self.err_formating_to_sd_style()
+
+    async def images_to_base64(self, save_path):
+
+        for filename in os.listdir(save_path):
+            if filename.endswith('.png'):
+                file_path = os.path.join(save_path, filename)
+                async with aiofiles.open(file_path, "rb") as image_file:
+                    image_data = await image_file.read()
+                    encoded_string = base64.b64encode(image_data).decode('utf-8')
+                    self.img.append(encoded_string)
+                    self.img_btyes.append(image_data)

DrawBridgeAPI/backend/seaart.py

@@ -0,0 +1,139 @@
+import asyncio
+import json
+import traceback
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+        # 需要更改
+        self.model = f"SeaArt - {self.config.seaart_setting['model'][self.count]}"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[SeaArt]')
+        token = self.config.seaart[self.count]
+
+        self.token = token
+        self.backend_name = self.config.backend_name_list[6]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def heart_beat(self, id_):
+        self.logger.info(f"{id_} 开始请求")
+        data = json.dumps({"task_ids": [id_]})
+        for i in range(60):
+            response = await self.http_request(
+                method="POST",
+                target_url="https://www.seaart.me/api/v1/task/batch-progress",
+                headers=self.headers,
+                content=data
+            )
+
+            if isinstance(response, dict) and 'error' in response:
+                raise RuntimeError(f"请求失败，错误信息: {response.get('details')}")
+            else:
+                items = response.get('data', {}).get('items', [])
+
+                if not items:
+                    self.logger.info(f"第{i + 1}次心跳，未返回结果")
+                    await asyncio.sleep(5)
+                    continue
+
+                for item in items:
+                    urls = item.get("img_uris")
+
+                    if urls is None:
+                        self.logger.info(f"第{i + 1}次心跳，未返回结果")
+                        await asyncio.sleep(5)
+                        continue
+
+                    elif isinstance(urls, list):
+                        for url in urls:
+                            self.logger.img(f"图片url: {url['url']}")
+                            self.img_url.append(url['url'])
+                        return
+
+        raise RuntimeError(f"任务 {id_} 在60次心跳后仍未完成")
+
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    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):
+
+        input_ = {
+            "action": 1,
+            "art_model_no": "1a486c58c2aa0601b57ddc263fc350d0",
+            "category": 1,
+            "speed_type": 1,
+            "meta":
+                {
+                    "prompt": self.tags,
+                    "negative_prompt": self.ntags,
+                    "restore_faces": self.restore_faces,
+                    "seed": self.seed,
+                    "sampler_name": self.sampler,
+                    "width": self.width,
+                    "height": self.height,
+                    "steps": self.steps,
+                    "cfg_scale": self.scale,
+                    "lora_models": [],
+                    "vae": "vae-ft-mse-840000-ema-pruned",
+                    "clip_skip": 1,
+                    "hr_second_pass_steps": 20,
+                    "lcm_mode": 0,
+                    "n_iter": 1,
+                    "embeddings": []
+                }
+        }
+
+        if self.enable_hr:
+
+            hr_payload = {
+                "hr_second_pass_steps": self.hr_second_pass_steps,
+                "enable_hr": True,
+                "hr_upscaler": "4x-UltraSharp",
+                "hr_scale": self.hr_scale,
+            }
+
+            input_['meta'].update(hr_payload)
+
+        new_headers = {
+            "Accept": "application/json, text/plain, */*",
+            "Token": self.token
+        }
+
+        self.headers.update(new_headers)
+
+        data = json.dumps(input_)
+        response = await self.http_request(
+            method="POST",
+            target_url="https://www.seaart.me/api/v1/task/create",
+            headers=self.headers,
+            content=data
+        )
+
+        if isinstance(response, dict) and 'error' in response:
+            self.logger.warning(f"{response.get('details')}")
+        else:
+            task = response
+            task_id = task.get('data', {}).get('id')
+
+            if task_id:
+                await self.heart_beat(task_id)
+
+        await self.err_formating_to_sd_style()
+

DrawBridgeAPI/backend/tusiart.py

@@ -0,0 +1,166 @@
+import asyncio
+import json
+import traceback
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+
+        self.model = f"TusiArt - tusiart.com/models/{self.config.tusiart_setting['model'][self.count]}"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[TusiArt]')
+
+        token = self.config.tusiart[self.count]
+        self.token = token
+        self.backend_name = self.config.backend_name_list[5]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def heart_beat(self, id_):
+        self.logger.info(f"{id_}开始请求")
+        self.headers['referer'] = "https://tusiart.com/models"
+        del self.headers['sec-ch-ua']
+
+        for i in range(60):
+            await asyncio.sleep(5)
+            self.logger.info(f"第{i + 1}次心跳")
+            response = await self.http_request(
+                method="GET",
+                target_url='https://api.tusiart.cn/works/v1/works/tasks?size=20&cursor=0&returnAllTask=true',
+                headers=self.headers
+            )
+
+            if isinstance(response, dict) and 'error' in response:
+                raise RuntimeError(f"Request failed with error: {response.get('details')}")
+            else:
+                resp_json = response
+                all_tasks = resp_json['data']['tasks']
+                task_found = False
+                for task in all_tasks:
+                    if task['taskId'] == id_:
+                        task_found = True
+                        if task['status'] == 'WAITING':
+                            break
+                        elif task['status'] == 'FINISH':
+                            matched = False
+                            for img in task['items']:
+                                if 'workspace.tusiassets.com' in img['url']:
+                                    self.logger.img(f"图片url: {img['url']}")
+                                    self.img_url.append(img['url'])
+                                    matched = True
+
+                            if matched:
+                                return
+                            else:
+                                self.logger.info(f"第{i + 1}次心跳，FINISH状态下未找到符合条件的URL")
+                                await asyncio.sleep(5)
+                                break
+                if not task_found:
+                    self.logger.info(f"任务 {id_} 未找到")
+                    await asyncio.sleep(5)
+                    continue
+
+        raise RuntimeError(f"任务 {id_} 在 {60} 次轮询后仍未完成")
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    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):
+
+        self.sampler = "Euler a"
+
+        input_ = {
+            "params":
+                {
+                    "baseModel":
+                     {
+                         "modelId": self.config.tusiart_setting['model'][self.count],
+                         "modelFileId": "708770380970509676"
+                     },
+                    "sdxl":
+                        {"refiner": False},
+                    "models": [],
+                    "embeddingModels": [],
+                    "sdVae": "Automatic",
+                    "prompt": self.tags,
+                    "negativePrompt": self.ntags,
+                    "height": self.height,
+                    "width": self.width,
+                    "imageCount": self.total_img_count,
+                    "steps": self.steps,
+                    "images": [],
+                    "cfgScale": self.scale,
+                    "seed": str(self.seed),
+                    "clipSkip": 2,
+                    "etaNoiseSeedDelta": 31337,
+                    "v1Clip": False,
+                    "samplerName": self.sampler
+                },
+            "taskType": "TXT2IMG",
+            "isRemix": False,
+            "captchaType": "CLOUDFLARE_TURNSTILE"
+        }
+
+        if self.enable_hr:
+
+            hr_payload = {
+                "enableHr": True,
+                "hrUpscaler": "R-ESRGAN 4x+ Anime6B",
+                "hrSecondPassSteps": self.hr_second_pass_steps,
+                "denoisingStrength": self.denoising_strength,
+                "hrResizeX": int(self.width*self.hr_scale),
+                "hrResizeY": int(self.height*self.hr_scale)
+            }
+
+            input_['params'].update(hr_payload)
+
+        new_headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Token": self.token,
+            "referer": self.config.tusiart_setting['referer'][self.count],
+            "sec-ch-ua": 'Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127'
+        }
+        self.headers.update(new_headers)
+
+        data = json.dumps(input_)
+
+        response = await self.http_request(
+            method="POST",
+            target_url="https://api.tusiart.cn/works/v1/works/task",
+            headers=self.headers,
+            content=data
+        )
+
+        if isinstance(response, dict) and 'error' in response:
+            pass
+        else:
+            task = response
+            if task['code'] == '1300100':
+                error_text = f"""
+后端：{self.config.tusiart_setting['note'][self.count]} 遇到人机验证，需到验证。
+请前往https://tusiart.com/使用一次生图来触发验证码。
+后端已被标记为不可使用,如需继续使用请重启API"
+"""
+                self.logger.warning("遇到人机验证！")
+                raise RuntimeError(error_text)
+            task_id = task['data']['task']['taskId']
+            await self.heart_beat(task_id)
+
+        await self.err_formating_to_sd_style()
+
+

DrawBridgeAPI/backend/yunjie.py

@@ -0,0 +1,133 @@
+import asyncio
+import json
+import traceback
+
+from .base import Backend
+
+
+class AIDRAW(Backend):
+
+    def __init__(self, count, payload, **kwargs):
+        super().__init__(count=count, payload=payload, **kwargs)
+        # 需要更改
+        self.model = f"YunJie - {self.config.yunjie_setting['model'][self.count]}"
+        self.model_hash = "c7352c5d2f"
+        self.logger = self.setup_logger('[YunJie]')
+        token = self.config.yunjie[self.count]
+
+        self.token = token
+        self.backend_name = self.config.backend_name_list[7]
+        self.workload_name = f"{self.backend_name}-{token}"
+
+    async def heart_beat(self, id_):
+        self.logger.info(f"{id_} 开始请求")
+        for i in range(60):
+            await asyncio.sleep(5)
+
+            data = json.dumps({"taskId": id_})
+            response = await self.http_request(
+                method="POST",
+                target_url="https://www.yunjie.art/rayvision/aigc/customer/task/progress",
+                headers=self.headers,
+                content=data
+            )
+
+            if isinstance(response, dict) and 'error' in response:
+                raise RuntimeError(f"请求失败，错误信息: {response.get('details')}")
+            else:
+                resp_json = response
+                if resp_json['code'] == "Account.Token.Expired":
+                    error_text = f"""
+                    后端：{self.config.yunjie_setting['note'][self.count]} token过期。
+                    请前往https://www.yunjie.art/ 登录重新获取token
+                    """
+                    self.logger.warning("token过期")
+                    raise RuntimeError(error_text)
+                items = resp_json.get('data', {}).get('data', [])
+                self.logger.info(f"第{i + 1}次心跳，未返回结果")
+
+                if not items:
+                    continue
+
+                for item in items:
+                    url = item.get("url")
+
+                    if url:
+                        self.logger.img(f"图片url: {url}")
+                        self.img_url.append(url)
+                        return
+
+        raise RuntimeError(f"任务 {id_} 在60次心跳后仍未完成")
+
+    async def update_progress(self):
+        # 覆写函数
+        pass
+
+    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):
+
+        input_ = {
+            "genModel": "advance",
+            "initImage": "",
+            "modelUuid": "MGC-17d172ee37c1b000",
+            "samplingMethod":
+                self.sampler,
+            "cfgScale": self.scale,
+            "samplingSteps": self.steps,
+            "plugins": [],
+            "clipSkip": 2,
+            "etaNoiseSeedDelta": 31337,
+            "prompt": self.tags,
+            "negativePrompt": self.ntags,
+            "resolutionX": self.width,
+            "resolutionY": self.height,
+            "genCount": self.total_img_count,
+            "seed": self.seed,
+            "tags": []
+        }
+
+        if self.enable_hr:
+
+            hr_payload = {
+                "hires":
+                    {"hrSecondPassSteps": self.hr_second_pass_steps,
+                     "denoisingStrength": self.denoising_strength,
+                     "hrScale": self.hr_scale,
+                     "hrUpscaler": "R-ESRGAN 4x+"
+                     }
+            }
+
+            input_.update(hr_payload)
+
+        new_headers = {
+            "Token": self.token
+        }
+        self.headers.update(new_headers)
+        data = json.dumps(input_)
+
+        # 使用 http_request 函数发送 POST 请求
+        response = await self.http_request(
+            method="POST",
+            target_url="https://www.yunjie.art/rayvision/aigc/customer/task/imageGen",
+            headers=self.headers,
+            content=data
+        )
+
+        if response.get("error", None):
+            self.logger.error(f"请求失败，错误信息: {response.get('details')}")
+        else:
+            task = response
+            task_id = task['data']['taskId']
+            await self.heart_beat(task_id)
+            await self.err_formating_to_sd_style()
+

DrawBridgeAPI/base_config.py

@@ -0,0 +1,334 @@
+import yaml as yaml_
+import shutil
+import redis
+import json
+import logging
+import os
+import traceback
+import sys
+
+import pydantic
+from packaging import version
+
+pyd_version = pydantic.__version__
+
+if version.parse(pyd_version) < version.parse("2.0"):
+    from pydantic import BaseSettings
+else:
+    try:
+        from pydantic_settings import BaseSettings
+    except:
+        traceback.print_exc()
+        import subprocess
+        subprocess.run([sys.executable, "-m", "pip", "install", "pydantic_settings"])
+        from pydantic_settings import BaseSettings
+
+from pathlib import Path
+
+redis_client = None
+
+api_current_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+class CustomFormatter(logging.Formatter):
+    def __init__(self, fmt=None, datefmt=None, style='%', prefix="[MAIN]"):
+        super().__init__(fmt, datefmt, style)
+        self.prefix = prefix
+
+    def format(self, record):
+        original_msg = record.msg
+        record.msg = f"{self.prefix} {original_msg}"
+        formatted_msg = super().format(record)
+        record.msg = original_msg  # 恢复原始消息
+        return formatted_msg
+
+
+# 字典用于跟踪已创建的日志记录器
+
+empty_dict = {"token": None}
+
+import logging
+
+
+class CustomFormatter(logging.Formatter):
+    """Custom formatter to add a fixed color for the prefix and variable colors for the log levels."""
+
+    def __init__(self, prefix="", img_prefix="", *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.prefix = f"\033[94m{prefix}\033[0m"  # 固定蓝色前缀
+        self.img_prefix = f"\033[93m{img_prefix}\033[0m"  # 固定黄色前缀
+        self.FORMATS = {
+            logging.DEBUG: f"{self.prefix} \033[94m[DEBUG]\033[0m %(message)s",
+            logging.INFO: f"{self.prefix} \033[92m[INFO]\033[0m %(message)s",
+            logging.WARNING: f"{self.prefix} \033[93m[WARNING]\033[0m %(message)s",
+            logging.ERROR: f"{self.prefix} \033[91m[ERROR]\033[0m %(message)s",
+            logging.CRITICAL: f"{self.prefix} \033[95m[CRITICAL]\033[0m %(message)s",
+            "IMG": f"{self.img_prefix} \033[93m[IMG]\033[0m %(message)s"  # 黄色前缀的 IMG 日志
+        }
+
+    def format(self, record):
+        log_fmt = self.FORMATS.get(record.levelno, self.FORMATS.get("IMG"))
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+class CustomLogger(logging.Logger):
+    """Custom logger class to add an img method."""
+
+    def __init__(self, name, level=logging.DEBUG):
+        super().__init__(name, level)
+        self.img_level = 25  # 自定义日志等级
+        logging.addLevelName(self.img_level, "IMG")
+
+    def img(self, msg, *args, **kwargs):
+        if self.isEnabledFor(self.img_level):
+            self._log(self.img_level, msg, args, **kwargs)
+
+
+loggers = {}
+
+
+def setup_logger(custom_prefix="[MAIN]"):
+    # 检查是否已经存在具有相同前缀的 logger
+    if custom_prefix in loggers:
+        return loggers[custom_prefix]
+
+    # 使用自定义的 Logger 类
+    logger = CustomLogger(custom_prefix)
+    logger.setLevel(logging.DEBUG)
+
+    # 创建一个控制台处理器并设置日志级别为DEBUG
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.DEBUG)
+
+    # 创建一个文件处理器来保存所有日志到 log.txt
+    file_handler = logging.FileHandler('log.log')
+    file_handler.setLevel(logging.DEBUG)
+
+    # 创建一个错误文件处理器来保存错误日志到 log_error.txt
+    error_file_handler = logging.FileHandler('log_error.log')
+    error_file_handler.setLevel(logging.ERROR)
+
+    # 创建一个文件处理器来保存IMG日志到 log_img.log
+    img_file_handler = logging.FileHandler('log_img.log')
+    img_file_handler.setLevel(logger.img_level)
+
+    # 创建格式器并将其添加到处理器
+    formatter = CustomFormatter(prefix=custom_prefix, img_prefix=custom_prefix)
+    console_handler.setFormatter(formatter)
+    file_handler.setFormatter(formatter)
+    error_file_handler.setFormatter(formatter)
+    img_file_handler.setFormatter(formatter)
+
+    # 将处理器添加到日志记录器
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+    logger.addHandler(error_file_handler)
+    logger.addHandler(img_file_handler)
+
+    # 将创建的 logger 存储在字典中
+    loggers[custom_prefix] = logger
+
+    return logger
+
+
+class Config(BaseSettings):
+
+    backend_name_list: list = []
+
+    server_settings: dict = None
+
+    civitai_setting: dict = empty_dict
+    a1111webui_setting: dict = {"backend_url": None}
+    fal_ai_setting: dict = empty_dict
+    replicate_setting: dict = empty_dict
+    liblibai_setting: dict = empty_dict
+    tusiart_setting: dict = empty_dict
+    seaart_setting: dict = empty_dict
+    yunjie_setting: dict = empty_dict
+    comfyui_setting: dict = empty_dict
+    novelai_setting: dict = empty_dict
+    midjourney_setting: dict = empty_dict
+
+    civitai: list or None = []
+    a1111webui: list = []
+    fal_ai: list = []
+    replicate: list = []
+    liblibai: list = []
+    tusiart: list = []
+    seaart: list = []
+    yunjie: list = []
+    comfyui: list = []
+    novelai: list = []
+    midjourney: list = []
+
+    civitai_name: dict = {}
+    a1111webui_name: dict = {}
+    fal_ai_name: dict = {}
+    replicate_name: dict = {}
+    liblibai_name: dict = {}
+    tusiart_name: dict = {}
+    seaart_name: dict = {}
+    yunjie_name: dict = {}
+    comfyui_name: dict = {}
+    novelai_name: dict = {}
+    midjourney_name: dict = {}
+
+    server_settings: dict = {}
+    retry_times: int = 3
+    proxy: str = ''
+
+    workload_dict: dict = {}
+
+    base_workload_dict: dict = {
+        "start_time": None,
+        "end_time": None,
+        "idle": True,
+        "available": True,
+        "fault": False
+    }
+
+    models_list: list = []
+
+    name_url: dict = {}
+
+
+def package_import(copy_to_config_path):
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    source_template = Path(os.path.join(current_dir, "config_example.yaml")).resolve()
+    shutil.copy(source_template, copy_to_config_path)
+
+
+class ConfigInit:
+
+    def __init__(self):
+        self.config = None
+        self.config_file_path = None
+        self.logger = setup_logger(custom_prefix="[INIT]")
+        self.redis_client = None
+
+    def load_config(self):
+
+        with open(self.config_file_path, "r", encoding="utf-8") as f:
+            yaml_config = yaml_.load(f, Loader=yaml_.FullLoader)
+            config = Config(**yaml_config)
+            self.logger.info('Loading config file completed')
+
+            return config
+
+    def init(self, config_file_path):
+
+        self.config_file_path = config_file_path
+        config = self.load_config()
+
+        config.backend_name_list = ['civitai', 'a1111', 'falai', 'replicate', 'liblibai', 'tusiart', 'seaart', 'yunjie',
+                                    'comfyui', 'novelai', 'midjourney']
+
+        welcome_txt = '''
+欢迎使用 
+_____                              ____           _       _                               _____    _____ 
+|  __ \                            |  _ \         (_)     | |                      /\     |  __ \  |_   _|
+| |  | |  _ __    __ _  __      __ | |_) |  _ __   _    __| |   __ _    ___       /  \    | |__) |   | |  
+| |  | | | '__|  / _` | \ \ /\ / / |  _ <  | '__| | |  / _` |  / _` |  / _ \     / /\ \   |  ___/    | |  
+| |__| | | |    | (_| |  \ V  V /  | |_) | | |    | | | (_| | | (_| | |  __/    / ____ \  | |       _| |_ 
+|_____/  |_|     \__,_|   \_/\_/   |____/  |_|    |_|  \__,_|  \__, |  \___|   /_/    \_\ |_|      |_____|
+                                                                __/ |                                     
+                                                                |___/
+关注雕雕, 关注雕雕喵
+项目地址/Project Re: https://github.com/DiaoDaiaChan/Stable-Diffusion-DrawBridgeAPI                                                                                                      
+        '''
+
+        print(welcome_txt)
+
+        config.civitai = config.civitai_setting['token']
+        config.a1111webui = config.a1111webui_setting
+        config.fal_ai = config.fal_ai_setting['token']
+        config.replicate = config.replicate_setting['token']
+        config.liblibai = config.liblibai_setting['token']
+        config.tusiart = config.tusiart_setting['token']
+        config.seaart = config.seaart_setting['token']
+        config.yunjie = config.yunjie_setting['token']
+        config.comfyui = config.comfyui_setting
+        config.novelai = config.novelai_setting['token']
+        config.midjourney = config.midjourney_setting
+
+        sources_list = [
+            (config.civitai, 0, config.civitai_name),
+            (config.a1111webui, 1, config.a1111webui_name),
+            (config.fal_ai, 2, config.fal_ai_name),
+            (config.replicate, 3, config.replicate_name),
+            (config.liblibai, 4, config.liblibai_name),
+            (config.tusiart, 5, config.tusiart_name),
+            (config.seaart, 6, config.seaart_name),
+            (config.yunjie, 7, config.yunjie_name),
+            (config.comfyui, 8, config.comfyui_name),
+            (config.novelai, 9, config.novelai_name),
+            (config.midjourney, 10, config.midjourney_name),
+        ]
+
+        def process_items(config, items, backend_index, name_dict):
+            if backend_index == 1:  # 特殊处理 config.a1111webui
+                for i in range(len(items['name'])):
+                    key = f"{config.backend_name_list[backend_index]}-{items['name'][i]}"
+                    config.workload_dict[key] = config.base_workload_dict
+                    name_dict[f"a1111-{items['name'][i]}"] = items['backend_url'][i]
+            elif backend_index == 8:
+                for i in range(len(items['name'])):
+                    key = f"{config.backend_name_list[backend_index]}-{items['name'][i]}"
+                    config.workload_dict[key] = config.base_workload_dict
+                    name_dict[f"comfyui-{items['name'][i]}"] = items['backend_url'][i]
+            elif backend_index == 10:
+                for i in range(len(items['name'])):
+                    key = f"{config.backend_name_list[backend_index]}-{items['name'][i]}"
+                    config.workload_dict[key] = config.base_workload_dict
+                    name_dict[f"midjourney-{items['name'][i]}"] = items['backend_url'][i]
+            else:
+                for n in items:
+                    key = f"{config.backend_name_list[backend_index]}-{n}"
+                    config.workload_dict[key] = config.base_workload_dict
+                    name_dict[key] = n
+
+        for items, backend_index, name_dict in sources_list:
+            process_items(config, items, backend_index, name_dict)
+
+        def merge_and_count(*args):
+            merged_dict = {}
+            lengths = []
+            for arg in args:
+                merged_dict |= arg[2]
+                lengths.append(len(arg[0]))
+            return merged_dict, tuple(lengths)
+
+        config.name_url = merge_and_count(*sources_list)
+
+        models_dict = {}
+        models_dict['is_loaded'] = False
+        for back_name in list(config.workload_dict.keys()):
+            models_dict[back_name] = config.models_list
+
+        try:
+            db_index = config.server_settings['redis_server'][3]
+        except IndexError:
+            db_index = 15
+
+        self.redis_client = redis.Redis(
+            host=config.server_settings['redis_server'][0],
+            port=config.server_settings['redis_server'][1],
+            password=config.server_settings['redis_server'][2],
+            db=db_index
+        )
+
+        self.logger.info('Redis connection successful')
+
+        workload_json = json.dumps(config.workload_dict)
+
+        rp = self.redis_client.pipeline()
+        rp.set('workload', workload_json)
+        rp.set('models', json.dumps(models_dict))
+        rp.set('styles', json.dumps([]))
+        rp.execute()
+
+        self.config = config
+
+
+init_instance = ConfigInit()

DrawBridgeAPI/comfyui_workflows/diaopony-hr.json

@@ -0,0 +1,213 @@
+{
+  "4": {
+    "inputs": {
+      "ckpt_name": "models\\DiaoDaiaPony - 100 Artists - testing.safetensors"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  },
+  "7": {
+    "inputs": {
+      "text": "score_3,poorly drawn,bad anatomy,bad proportions, watercolor painting, brush strokes,3d,2.5d,signature,watermark,bad face,distorted face,messed up eyes,deformed,(low quality, bad quality, worst quality:1.2),bad hand",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Negative Prompt)"
+    }
+  },
+  "53": {
+    "inputs": {
+      "width": 768,
+      "height": 1152,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "79": {
+    "inputs": {
+      "seed": 657283391776279,
+      "steps": 30,
+      "cfg": 8,
+      "sampler_name": "euler",
+      "scheduler": "karras",
+      "denoise": 1,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "103",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "53",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "88": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "91",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  },
+  "91": {
+    "inputs": {
+      "upscale_by": 2,
+      "seed": 291655160144038,
+      "steps": 12,
+      "cfg": 8,
+      "sampler_name": "dpmpp_2m",
+      "scheduler": "karras",
+      "denoise": 0.2,
+      "mode_type": "Linear",
+      "tile_width": 1024,
+      "tile_height": 1024,
+      "mask_blur": 8,
+      "tile_padding": 32,
+      "seam_fix_mode": "None",
+      "seam_fix_denoise": 1,
+      "seam_fix_width": 64,
+      "seam_fix_mask_blur": 8,
+      "seam_fix_padding": 16,
+      "force_uniform_tiles": true,
+      "tiled_decode": false,
+      "image": [
+        "92",
+        0
+      ],
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "103",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ],
+      "upscale_model": [
+        "93",
+        0
+      ]
+    },
+    "class_type": "UltimateSDUpscale",
+    "_meta": {
+      "title": "Ultimate SD Upscale"
+    }
+  },
+  "92": {
+    "inputs": {
+      "samples": [
+        "99",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "93": {
+    "inputs": {
+      "model_name": "4x-UltraSharp.pth"
+    },
+    "class_type": "UpscaleModelLoader",
+    "_meta": {
+      "title": "Load Upscale Model"
+    }
+  },
+  "98": {
+    "inputs": {
+      "upscale_method": "nearest-exact",
+      "width": 1152,
+      "height": 1536,
+      "crop": "disabled",
+      "samples": [
+        "79",
+        0
+      ]
+    },
+    "class_type": "LatentUpscale",
+    "_meta": {
+      "title": "Upscale Latent"
+    }
+  },
+  "99": {
+    "inputs": {
+      "seed": 641400482051274,
+      "steps": 20,
+      "cfg": 8,
+      "sampler_name": "euler",
+      "scheduler": "normal",
+      "denoise": 1,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "103",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "98",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "103": {
+    "inputs": {
+      "text": ",(qianqianjie:1.1),(shinyo yukino:1),roku 6,(miyu (miy u1308):1.1),momoko (momopoco), score_9,score_8_up,score_7_up,score_anime,amazing quality,very aesthetic,absurdres,",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/diaopony-hr_reflex.json

@@ -0,0 +1,7 @@
+{
+  "prompt": {"103": {"override": {"text": "append_prompt"}}},
+  "negative_prompt": {"7": {"override": {"text": "append_negative_prompt"}}},
+  "sampler": ["79", "99"],
+  "image_size": {"53": {}, "98": {"override": {"width": "upscale", "height": "upscale"}}},
+  "output": 88
+  }

DrawBridgeAPI/comfyui_workflows/diaopony-tipo.json

@@ -0,0 +1,132 @@
+{
+  "4": {
+    "inputs": {
+      "ckpt_name": "models\\DiaoDaiaPony - 100 Artists - testing.safetensors"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  },
+  "6": {
+    "inputs": {
+      "text": [
+        "50",
+        0
+      ],
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (TIPO Prompt)"
+    }
+  },
+  "7": {
+    "inputs": {
+      "text": "score_3,poorly drawn,bad anatomy,bad proportions, watercolor painting, brush strokes,3d,2.5d,signature,watermark,bad face,distorted face,messed up eyes,deformed,(low quality, bad quality, worst quality:1.2),bad hand",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Negative Prompt)"
+    }
+  },
+  "8": {
+    "inputs": {
+      "samples": [
+        "52",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "50": {
+    "inputs": {
+      "tags": "\n\nscore_9,score_8_up,score_7_up,score_anime,amazing quality,very aesthetic,absurdres",
+      "nl_prompt": "An illustration of",
+      "ban_tags": "text, censor, speech, say, illustrations, doll",
+      "tipo_model": "KBlueLeaf/TIPO-500M",
+      "format": "<|special|>, \n<|characters|>, <|copyrights|>, \n<|artist|>, \n\n<|general|>,\n\n<|extended|>.\n\n<|quality|>, <|meta|>, <|rating|>",
+      "width": 1024,
+      "height": 1024,
+      "temperature": 0.5,
+      "top_p": 0.95,
+      "min_p": 0.05,
+      "top_k": 80,
+      "tag_length": "long",
+      "nl_length": "long",
+      "seed": 1763
+    },
+    "class_type": "TIPO",
+    "_meta": {
+      "title": "TIPO"
+    }
+  },
+  "52": {
+    "inputs": {
+      "seed": 11451,
+      "steps": 20,
+      "cfg": 8,
+      "sampler_name": "euler",
+      "scheduler": "normal",
+      "denoise": 1,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "6",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "53",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "53": {
+    "inputs": {
+      "width": 1152,
+      "height": 1536,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "72": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "8",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/diaopony-tipo_reflex.json

@@ -0,0 +1,6 @@
+{
+  "tipo": {"50": {"override": {"tags": "append_prompt"}}},
+  "sampler": 52,
+  "image_size": 53,
+  "output": 72
+  }

DrawBridgeAPI/comfyui_workflows/flux-dev.json

@@ -0,0 +1,94 @@
+{
+  "1": {
+    "inputs": {
+      "ckpt_name": "models\\flux1-dev-bnb-nf4-v2.safetensors"
+    },
+    "class_type": "CheckpointLoaderNF4",
+    "_meta": {
+      "title": "CheckpointLoaderNF4"
+    }
+  },
+  "2": {
+    "inputs": {
+      "text": "a tank",
+      "clip": [
+        "1",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "3": {
+    "inputs": {
+      "seed": 861133332082627,
+      "steps": 20,
+      "cfg": 1,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "model": [
+        "1",
+        0
+      ],
+      "positive": [
+        "2",
+        0
+      ],
+      "negative": [
+        "2",
+        0
+      ],
+      "latent_image": [
+        "4",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "4": {
+    "inputs": {
+      "width": 512,
+      "height": 768,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "5": {
+    "inputs": {
+      "samples": [
+        "3",
+        0
+      ],
+      "vae": [
+        "1",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "6": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "5",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/flux-dev_reflex.json

@@ -0,0 +1,6 @@
+{
+  "prompt": 2,
+  "image_size": 4,
+  "output": 6,
+  "seed": 3
+  }

DrawBridgeAPI/comfyui_workflows/flux-schnell.json

@@ -0,0 +1,94 @@
+{
+  "1": {
+    "inputs": {
+      "ckpt_name": "models\\flux1-schnell-bnb-nf4.safetensors"
+    },
+    "class_type": "CheckpointLoaderNF4",
+    "_meta": {
+      "title": "CheckpointLoaderNF4"
+    }
+  },
+  "2": {
+    "inputs": {
+      "text": "a tank",
+      "clip": [
+        "1",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "3": {
+    "inputs": {
+      "seed": 0,
+      "steps": 4,
+      "cfg": 1,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 1,
+      "model": [
+        "1",
+        0
+      ],
+      "positive": [
+        "2",
+        0
+      ],
+      "negative": [
+        "2",
+        0
+      ],
+      "latent_image": [
+        "4",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "4": {
+    "inputs": {
+      "width": 512,
+      "height": 768,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "5": {
+    "inputs": {
+      "samples": [
+        "3",
+        0
+      ],
+      "vae": [
+        "1",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "6": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "5",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/flux-schnell_reflex.json

@@ -0,0 +1,6 @@
+{
+  "prompt": 2,
+  "image_size": 4,
+  "output": 6,
+  "seed": 3
+  }

DrawBridgeAPI/comfyui_workflows/flux修手.json

@@ -0,0 +1,254 @@
+{
+  "1": {
+    "inputs": {
+      "context_expand_pixels": 100,
+      "context_expand_factor": 1,
+      "fill_mask_holes": true,
+      "blur_mask_pixels": 16,
+      "invert_mask": false,
+      "blend_pixels": 16,
+      "rescale_algorithm": "bicubic",
+      "mode": "ranged size",
+      "force_width": 1024,
+      "force_height": 1024,
+      "rescale_factor": 1,
+      "min_width": 512,
+      "min_height": 512,
+      "max_width": 768,
+      "max_height": 768,
+      "padding": 32,
+      "image": [
+        "47",
+        0
+      ],
+      "mask": [
+        "50",
+        0
+      ]
+    },
+    "class_type": "InpaintCrop",
+    "_meta": {
+      "title": "✂️ Inpaint Crop"
+    }
+  },
+  "2": {
+    "inputs": {
+      "rescale_algorithm": "bislerp",
+      "stitch": [
+        "1",
+        0
+      ],
+      "inpainted_image": [
+        "15",
+        0
+      ]
+    },
+    "class_type": "InpaintStitch",
+    "_meta": {
+      "title": "✂️ Inpaint Stitch"
+    }
+  },
+  "3": {
+    "inputs": {
+      "image": "a87ed50d8e69b8bfb62df848bac69d12.png",
+      "upload": "image"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "Load Image"
+    }
+  },
+  "15": {
+    "inputs": {
+      "samples": [
+        "100",
+        0
+      ],
+      "vae": [
+        "99",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "19": {
+    "inputs": {
+      "positive": [
+        "32",
+        0
+      ],
+      "negative": [
+        "32",
+        0
+      ],
+      "vae": [
+        "99",
+        2
+      ],
+      "pixels": [
+        "1",
+        1
+      ],
+      "mask": [
+        "1",
+        2
+      ]
+    },
+    "class_type": "InpaintModelConditioning",
+    "_meta": {
+      "title": "InpaintModelConditioning"
+    }
+  },
+  "25": {
+    "inputs": {
+      "rescale_algorithm": "bicubic",
+      "mode": "ensure minimum size",
+      "min_width": 0,
+      "min_height": 1536,
+      "rescale_factor": 1,
+      "image": [
+        "26",
+        0
+      ],
+      "mask": [
+        "26",
+        1
+      ]
+    },
+    "class_type": "InpaintResize",
+    "_meta": {
+      "title": "✂️ Resize Image Before Inpainting"
+    }
+  },
+  "26": {
+    "inputs": {
+      "sam_model": "sam_vit_h (2.56GB)",
+      "grounding_dino_model": "GroundingDINO_SwinB (938MB)",
+      "threshold": 0.3,
+      "detail_method": "VITMatte",
+      "detail_erode": 6,
+      "detail_dilate": 6,
+      "black_point": 0.15,
+      "white_point": 0.99,
+      "process_detail": false,
+      "prompt": "hand",
+      "device": "cuda",
+      "max_megapixels": 2,
+      "cache_model": false,
+      "image": [
+        "3",
+        0
+      ]
+    },
+    "class_type": "LayerMask: SegmentAnythingUltra V2",
+    "_meta": {
+      "title": "LayerMask: SegmentAnythingUltra V2"
+    }
+  },
+  "32": {
+    "inputs": {
+      "text": "Masterpiece, High Definition, Real Person Portrait, 5 Fingers, Girl's Hand",
+      "clip": [
+        "99",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "47": {
+    "inputs": {
+      "fill_background": false,
+      "background_color": "#000000",
+      "RGBA_image": [
+        "25",
+        0
+      ],
+      "mask": [
+        "25",
+        1
+      ]
+    },
+    "class_type": "LayerUtility: ImageRemoveAlpha",
+    "_meta": {
+      "title": "LayerUtility: ImageRemoveAlpha"
+    }
+  },
+  "50": {
+    "inputs": {
+      "expand": 30,
+      "incremental_expandrate": 0.1,
+      "tapered_corners": false,
+      "flip_input": false,
+      "blur_radius": 10,
+      "lerp_alpha": 1,
+      "decay_factor": 1,
+      "fill_holes": false,
+      "mask": [
+        "25",
+        1
+      ]
+    },
+    "class_type": "GrowMaskWithBlur",
+    "_meta": {
+      "title": "Grow Mask With Blur"
+    }
+  },
+  "94": {
+    "inputs": {
+      "filename_prefix": "hand_fix",
+      "images": [
+        "2",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  },
+  "99": {
+    "inputs": {
+      "ckpt_name": "models\\flux1-dev-bnb-nf4-v2.safetensors"
+    },
+    "class_type": "CheckpointLoaderNF4",
+    "_meta": {
+      "title": "CheckpointLoaderNF4"
+    }
+  },
+  "100": {
+    "inputs": {
+      "seed": 266696528873091,
+      "steps": 20,
+      "cfg": 1,
+      "sampler_name": "euler",
+      "scheduler": "simple",
+      "denoise": 0.5,
+      "model": [
+        "99",
+        0
+      ],
+      "positive": [
+        "19",
+        0
+      ],
+      "negative": [
+        "19",
+        1
+      ],
+      "latent_image": [
+        "19",
+        2
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/flux修手_reflex.json

@@ -0,0 +1,5 @@
+{
+  "prompt": 32,
+  "output": 94,
+  "load_image":3
+}

DrawBridgeAPI/comfyui_workflows/sd3.5_txt2img.json

@@ -0,0 +1,187 @@
+{
+  "4": {
+    "inputs": {
+      "ckpt_name": "models\\sd3.5_large.safetensors"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  },
+  "6": {
+    "inputs": {
+      "text": "beautiful scenery nature glass bottle landscape, purple galaxy bottle,",
+      "clip": [
+        "11",
+        0
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "8": {
+    "inputs": {
+      "samples": [
+        "294",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "11": {
+    "inputs": {
+      "clip_name1": "clip_g.pth",
+      "clip_name2": "clip_l.safetensors",
+      "clip_name3": "t5xxl_fp16.safetensors"
+    },
+    "class_type": "TripleCLIPLoader",
+    "_meta": {
+      "title": "TripleCLIPLoader"
+    }
+  },
+  "13": {
+    "inputs": {
+      "shift": 3,
+      "model": [
+        "4",
+        0
+      ]
+    },
+    "class_type": "ModelSamplingSD3",
+    "_meta": {
+      "title": "ModelSamplingSD3"
+    }
+  },
+  "67": {
+    "inputs": {
+      "conditioning": [
+        "71",
+        0
+      ]
+    },
+    "class_type": "ConditioningZeroOut",
+    "_meta": {
+      "title": "ConditioningZeroOut"
+    }
+  },
+  "68": {
+    "inputs": {
+      "start": 0.1,
+      "end": 1,
+      "conditioning": [
+        "67",
+        0
+      ]
+    },
+    "class_type": "ConditioningSetTimestepRange",
+    "_meta": {
+      "title": "ConditioningSetTimestepRange"
+    }
+  },
+  "69": {
+    "inputs": {
+      "conditioning_1": [
+        "68",
+        0
+      ],
+      "conditioning_2": [
+        "70",
+        0
+      ]
+    },
+    "class_type": "ConditioningCombine",
+    "_meta": {
+      "title": "Conditioning (Combine)"
+    }
+  },
+  "70": {
+    "inputs": {
+      "start": 0,
+      "end": 0.1,
+      "conditioning": [
+        "71",
+        0
+      ]
+    },
+    "class_type": "ConditioningSetTimestepRange",
+    "_meta": {
+      "title": "ConditioningSetTimestepRange"
+    }
+  },
+  "71": {
+    "inputs": {
+      "text": "",
+      "clip": [
+        "11",
+        0
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "135": {
+    "inputs": {
+      "width": 1024,
+      "height": 1024,
+      "batch_size": 1
+    },
+    "class_type": "EmptySD3LatentImage",
+    "_meta": {
+      "title": "EmptySD3LatentImage"
+    }
+  },
+  "294": {
+    "inputs": {
+      "seed": 143084108695924,
+      "steps": 20,
+      "cfg": 4.5,
+      "sampler_name": "dpmpp_2m",
+      "scheduler": "sgm_uniform",
+      "denoise": 1,
+      "model": [
+        "13",
+        0
+      ],
+      "positive": [
+        "6",
+        0
+      ],
+      "negative": [
+        "69",
+        0
+      ],
+      "latent_image": [
+        "135",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "302": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "8",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/sd3.5_txt2img_reflex.json

@@ -0,0 +1,7 @@
+{
+  "prompt": 6,
+  "negative_prompt": 71,
+  "image_size": 135,
+  "output": 302,
+  "seed": 294
+  }

DrawBridgeAPI/comfyui_workflows/sdbase_img2img.json

@@ -0,0 +1,122 @@
+{
+  "3": {
+    "inputs": {
+      "seed": 280823642470253,
+      "steps": 20,
+      "cfg": 8,
+      "sampler_name": "dpmpp_2m",
+      "scheduler": "normal",
+      "denoise": 0.8700000000000001,
+      "model": [
+        "14",
+        0
+      ],
+      "positive": [
+        "6",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "12",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "6": {
+    "inputs": {
+      "text": "photograph of victorian woman with wings, sky clouds, meadow grass\n",
+      "clip": [
+        "14",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "7": {
+    "inputs": {
+      "text": "watermark, text\n",
+      "clip": [
+        "14",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "8": {
+    "inputs": {
+      "samples": [
+        "3",
+        0
+      ],
+      "vae": [
+        "14",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "9": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "8",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  },
+  "10": {
+    "inputs": {
+      "image": "example.png",
+      "upload": "image"
+    },
+    "class_type": "LoadImage",
+    "_meta": {
+      "title": "Load Image"
+    }
+  },
+  "12": {
+    "inputs": {
+      "pixels": [
+        "10",
+        0
+      ],
+      "vae": [
+        "14",
+        2
+      ]
+    },
+    "class_type": "VAEEncode",
+    "_meta": {
+      "title": "VAE Encode"
+    }
+  },
+  "14": {
+    "inputs": {
+      "ckpt_name": "v1-5-pruned-emaonly.ckpt"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/sdbase_img2img_reflex.json

@@ -0,0 +1,9 @@
+{
+  "sampler": 3,
+  "prompt": 6,
+  "image_size": 5,
+  "negative_prompt": 7,
+  "checkpoint": 14,
+  "output": 9,
+  "load_image":10
+  }

DrawBridgeAPI/comfyui_workflows/sdbase_txt2img.json

@@ -0,0 +1,107 @@
+{
+  "3": {
+    "inputs": {
+      "seed": 567570346829551,
+      "steps": 20,
+      "cfg": 8,
+      "sampler_name": "euler",
+      "scheduler": "normal",
+      "denoise": 1,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "6",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "5",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "4": {
+    "inputs": {
+      "ckpt_name": "models\\DiaoDaia_mix_4.5.ckpt"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  },
+  "5": {
+    "inputs": {
+      "width": 512,
+      "height": 512,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "6": {
+    "inputs": {
+      "text": "beautiful scenery nature glass bottle landscape, , purple galaxy bottle,",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "7": {
+    "inputs": {
+      "text": "text, watermark",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "8": {
+    "inputs": {
+      "samples": [
+        "3",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "9": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "8",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/sdbase_txt2img_hr_fix.json

@@ -0,0 +1,266 @@
+{
+  "3": {
+    "inputs": {
+      "seed": 213416933995644,
+      "steps": 20,
+      "cfg": 8,
+      "sampler_name": "euler_ancestral",
+      "scheduler": "normal",
+      "denoise": 1,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "6",
+        0
+      ],
+      "negative": [
+        "7",
+        0
+      ],
+      "latent_image": [
+        "5",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "4": {
+    "inputs": {
+      "ckpt_name": "models\\1053-S.ckpt"
+    },
+    "class_type": "CheckpointLoaderSimple",
+    "_meta": {
+      "title": "Load Checkpoint"
+    }
+  },
+  "5": {
+    "inputs": {
+      "width": 768,
+      "height": 512,
+      "batch_size": 1
+    },
+    "class_type": "EmptyLatentImage",
+    "_meta": {
+      "title": "Empty Latent Image"
+    }
+  },
+  "6": {
+    "inputs": {
+      "text": "beautiful scenery nature glass bottle landscape, , purple galaxy bottle,",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "7": {
+    "inputs": {
+      "text": "text, watermark",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "8": {
+    "inputs": {
+      "samples": [
+        "3",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "9": {
+    "inputs": {
+      "filename_prefix": "ComfyUI",
+      "images": [
+        "18",
+        0
+      ]
+    },
+    "class_type": "SaveImage",
+    "_meta": {
+      "title": "Save Image"
+    }
+  },
+  "10": {
+    "inputs": {
+      "upscale_method": "nearest-exact",
+      "width": 1536,
+      "height": 1152,
+      "crop": "disabled",
+      "samples": [
+        "16",
+        0
+      ]
+    },
+    "class_type": "LatentUpscale",
+    "_meta": {
+      "title": "Upscale Latent"
+    }
+  },
+  "12": {
+    "inputs": {
+      "model_name": "RealESRGAN_x4plus.pth"
+    },
+    "class_type": "UpscaleModelLoader",
+    "_meta": {
+      "title": "Load Upscale Model"
+    }
+  },
+  "14": {
+    "inputs": {
+      "upscale_model": [
+        "12",
+        0
+      ],
+      "image": [
+        "8",
+        0
+      ]
+    },
+    "class_type": "ImageUpscaleWithModel",
+    "_meta": {
+      "title": "Upscale Image (using Model)"
+    }
+  },
+  "15": {
+    "inputs": {
+      "upscale_method": "area",
+      "width": 1152,
+      "height": 768,
+      "crop": "disabled",
+      "image": [
+        "14",
+        0
+      ]
+    },
+    "class_type": "ImageScale",
+    "_meta": {
+      "title": "Upscale Image"
+    }
+  },
+  "16": {
+    "inputs": {
+      "pixels": [
+        "15",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEEncode",
+    "_meta": {
+      "title": "VAE Encode"
+    }
+  },
+  "18": {
+    "inputs": {
+      "samples": [
+        "19",
+        0
+      ],
+      "vae": [
+        "4",
+        2
+      ]
+    },
+    "class_type": "VAEDecode",
+    "_meta": {
+      "title": "VAE Decode"
+    }
+  },
+  "19": {
+    "inputs": {
+      "seed": 1069147258069384,
+      "steps": 8,
+      "cfg": 8,
+      "sampler_name": "euler",
+      "scheduler": "sgm_uniform",
+      "denoise": 0.6,
+      "model": [
+        "4",
+        0
+      ],
+      "positive": [
+        "21",
+        0
+      ],
+      "negative": [
+        "22",
+        0
+      ],
+      "latent_image": [
+        "10",
+        0
+      ]
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "20": {
+    "inputs": {
+      "seed": 85387134314530,
+      "steps": 20,
+      "cfg": 5.74,
+      "sampler_name": "dpm_2",
+      "scheduler": "normal",
+      "denoise": 1
+    },
+    "class_type": "KSampler",
+    "_meta": {
+      "title": "KSampler"
+    }
+  },
+  "21": {
+    "inputs": {
+      "text": "",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  },
+  "22": {
+    "inputs": {
+      "text": "",
+      "clip": [
+        "4",
+        1
+      ]
+    },
+    "class_type": "CLIPTextEncode",
+    "_meta": {
+      "title": "CLIP Text Encode (Prompt)"
+    }
+  }
+}

DrawBridgeAPI/comfyui_workflows/sdbase_txt2img_hr_fix_reflex.json

@@ -0,0 +1,13 @@
+{
+"sampler": 3,
+"prompt": 6,
+"image_size": 5,
+"negative_prompt": 7,
+"checkpoint": 4,
+"output": 9,
+"latentupscale": 10,
+"resize": 15,
+"hr_steps": 19,
+"hr_prompt": 21,
+"hr_negative_prompt": 22
+}

DrawBridgeAPI/comfyui_workflows/sdbase_txt2img_reflex.json

@@ -0,0 +1,8 @@
+{
+  "sampler": 3,
+  "prompt": 6,
+  "image_size": 5,
+  "negative_prompt": 7,
+  "checkpoint": 4,
+  "output": 9
+  }

DrawBridgeAPI/comfyui_workflows/创意融字 工作流Jianan_创意融字海报.json

@@ -0,0 +1,1789 @@
+{
+    "last_node_id": 70,
+    "last_link_id": 130,
+    "nodes": [
+        {
+            "id": 68,
+            "type": "LineArtPreprocessor",
+            "pos": [
+                631,
+                -867
+            ],
+            "size": {
+                "0": 315,
+                "1": 82
+            },
+            "flags": {
+
+            },
+            "order": 7,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 111,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        112,
+                        115
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "LineArtPreprocessor"
+            },
+            "widgets_values": [
+                "disable",
+                512
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 18,
+            "type": "ControlNetLoader",
+            "pos": [
+                977,
+                -874
+            ],
+            "size": {
+                "0": 339.6257019042969,
+                "1": 82
+            },
+            "flags": {
+                "collapsed": false
+            },
+            "order": 0,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "CONTROL_NET",
+                    "type": "CONTROL_NET",
+                    "links": [
+                        25
+                    ],
+                    "shape": 3,
+                    "label": "ControlNet"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetLoader"
+            },
+            "widgets_values": [
+                ""
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 42,
+            "type": "ControlNetLoader",
+            "pos": [
+                1349,
+                -876
+            ],
+            "size": {
+                "0": 368.9059753417969,
+                "1": 82
+            },
+            "flags": {
+                "collapsed": false
+            },
+            "order": 1,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "CONTROL_NET",
+                    "type": "CONTROL_NET",
+                    "links": [
+                        66
+                    ],
+                    "shape": 3,
+                    "label": "ControlNet"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetLoader"
+            },
+            "widgets_values": [
+                ""
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 22,
+            "type": "PreviewImage",
+            "pos": [
+                899,
+                -726
+            ],
+            "size": {
+                "0": 240.84320068359375,
+                "1": 246
+            },
+            "flags": {
+
+            },
+            "order": 11,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "images",
+                    "type": "IMAGE",
+                    "link": 112,
+                    "label": "图像"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "PreviewImage"
+            }
+        },
+        {
+            "id": 17,
+            "type": "ControlNetApply",
+            "pos": [
+                1240,
+                -653
+            ],
+            "size": {
+                "0": 210,
+                "1": 98
+            },
+            "flags": {
+
+            },
+            "order": 15,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "conditioning",
+                    "type": "CONDITIONING",
+                    "link": 23,
+                    "label": "条件"
+                },
+                {
+                    "name": "control_net",
+                    "type": "CONTROL_NET",
+                    "link": 25,
+                    "label": "ControlNet",
+                    "slot_index": 1
+                },
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 115,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "CONDITIONING",
+                    "type": "CONDITIONING",
+                    "links": [
+                        70
+                    ],
+                    "shape": 3,
+                    "label": "条件",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetApply"
+            },
+            "widgets_values": [
+                0.7000000000000001
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 41,
+            "type": "ControlNetApply",
+            "pos": [
+                1493,
+                -652
+            ],
+            "size": {
+                "0": 210,
+                "1": 98
+            },
+            "flags": {
+
+            },
+            "order": 16,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "conditioning",
+                    "type": "CONDITIONING",
+                    "link": 70,
+                    "label": "条件"
+                },
+                {
+                    "name": "control_net",
+                    "type": "CONTROL_NET",
+                    "link": 66,
+                    "label": "ControlNet",
+                    "slot_index": 1
+                },
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 119,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "CONDITIONING",
+                    "type": "CONDITIONING",
+                    "links": [
+                        71
+                    ],
+                    "shape": 3,
+                    "label": "条件",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetApply"
+            },
+            "widgets_values": [
+                0.8
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 20,
+            "type": "LoadImage",
+            "pos": [
+                59,
+                -877
+            ],
+            "size": {
+                "0": 244.5690155029297,
+                "1": 338.8974304199219
+            },
+            "flags": {
+                "collapsed": false
+            },
+            "order": 2,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        111,
+                        119
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                },
+                {
+                    "name": "MASK",
+                    "type": "MASK",
+                    "links": null,
+                    "shape": 3,
+                    "label": "遮罩"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "LoadImage"
+            },
+            "widgets_values": [
+                "1724338180087.png",
+                "image"
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#322",
+            "bgcolor": "#533"
+        },
+        {
+            "id": 15,
+            "type": "LoraLoader",
+            "pos": [
+                14.33333365122489,
+                -380.3333536783855
+            ],
+            "size": {
+                "0": 210,
+                "1": 150
+            },
+            "flags": {
+
+            },
+            "order": 9,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "model",
+                    "type": "MODEL",
+                    "link": 120,
+                    "label": "模型"
+                },
+                {
+                    "name": "clip",
+                    "type": "CLIP",
+                    "link": 121,
+                    "label": "CLIP"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "MODEL",
+                    "type": "MODEL",
+                    "links": [
+                        122
+                    ],
+                    "shape": 3,
+                    "label": "模型",
+                    "slot_index": 0
+                },
+                {
+                    "name": "CLIP",
+                    "type": "CLIP",
+                    "links": [
+                        123
+                    ],
+                    "shape": 3,
+                    "label": "CLIP",
+                    "slot_index": 1
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "LoraLoader"
+            },
+            "widgets_values": [
+                null,
+                0.8,
+                1
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 14,
+            "type": "LoraLoader",
+            "pos": [
+                285.33333365122496,
+                -380.3333536783855
+            ],
+            "size": {
+                "0": 210,
+                "1": 150
+            },
+            "flags": {
+
+            },
+            "order": 12,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "model",
+                    "type": "MODEL",
+                    "link": 122,
+                    "label": "模型"
+                },
+                {
+                    "name": "clip",
+                    "type": "CLIP",
+                    "link": 123,
+                    "label": "CLIP"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "MODEL",
+                    "type": "MODEL",
+                    "links": [
+                        124
+                    ],
+                    "shape": 3,
+                    "label": "模型",
+                    "slot_index": 0
+                },
+                {
+                    "name": "CLIP",
+                    "type": "CLIP",
+                    "links": [
+                        125
+                    ],
+                    "shape": 3,
+                    "label": "CLIP",
+                    "slot_index": 1
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "LoraLoader"
+            },
+            "widgets_values": [
+                null,
+                0.9,
+                1
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 16,
+            "type": "LoraLoader",
+            "pos": [
+                533.333333651225,
+                -383.3333536783855
+            ],
+            "size": {
+                "0": 235.24232482910156,
+                "1": 150
+            },
+            "flags": {
+
+            },
+            "order": 13,
+            "mode": 4,
+            "inputs": [
+                {
+                    "name": "model",
+                    "type": "MODEL",
+                    "link": 124,
+                    "label": "模型"
+                },
+                {
+                    "name": "clip",
+                    "type": "CLIP",
+                    "link": 125,
+                    "label": "CLIP"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "MODEL",
+                    "type": "MODEL",
+                    "links": [
+                        22
+                    ],
+                    "shape": 3,
+                    "label": "模型",
+                    "slot_index": 0
+                },
+                {
+                    "name": "CLIP",
+                    "type": "CLIP",
+                    "links": [
+                        20
+                    ],
+                    "shape": 3,
+                    "label": "CLIP",
+                    "slot_index": 1
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "LoraLoader"
+            },
+            "widgets_values": [
+                null,
+                0.9,
+                1
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 7,
+            "type": "CLIPTextEncode",
+            "pos": [
+                906,
+                -187
+            ],
+            "size": {
+                "0": 304.75079345703125,
+                "1": 132.6532440185547
+            },
+            "flags": {
+
+            },
+            "order": 8,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "clip",
+                    "type": "CLIP",
+                    "link": 5,
+                    "label": "CLIP"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "CONDITIONING",
+                    "type": "CONDITIONING",
+                    "links": [
+                        6,
+                        109
+                    ],
+                    "slot_index": 0,
+                    "label": "条件"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "CLIPTextEncode"
+            },
+            "widgets_values": [
+                "embedding:EasyNegativeV2,humans,people, "
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#322",
+            "bgcolor": "#533"
+        },
+        {
+            "id": 60,
+            "type": "UpscaleModelLoader",
+            "pos": [
+                162.99199549854984,
+                213.91385230251254
+            ],
+            "size": {
+                "0": 261.4676208496094,
+                "1": 84.79285430908203
+            },
+            "flags": {
+
+            },
+            "order": 3,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "UPSCALE_MODEL",
+                    "type": "UPSCALE_MODEL",
+                    "links": [
+                        95
+                    ],
+                    "shape": 3,
+                    "label": "放大模型"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "UpscaleModelLoader"
+            },
+            "widgets_values": [
+                "ESRGAN_4x"
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 59,
+            "type": "ImageUpscaleWithModel",
+            "pos": [
+                433.99199549855007,
+                215.91385230251257
+            ],
+            "size": {
+                "0": 241.79998779296875,
+                "1": 46
+            },
+            "flags": {
+                "collapsed": true
+            },
+            "order": 20,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "upscale_model",
+                    "type": "UPSCALE_MODEL",
+                    "link": 95,
+                    "label": "放大模型",
+                    "slot_index": 0
+                },
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 127,
+                    "label": "图像",
+                    "slot_index": 1
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        101
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ImageUpscaleWithModel"
+            },
+            "color": "#322",
+            "bgcolor": "#533"
+        },
+        {
+            "id": 64,
+            "type": "ImageScaleBy",
+            "pos": [
+                439.99199549855,
+                260.9138523025126
+            ],
+            "size": {
+                "0": 210,
+                "1": 95.07756805419922
+            },
+            "flags": {
+
+            },
+            "order": 21,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 101,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        92,
+                        99
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ImageScaleBy"
+            },
+            "widgets_values": [
+                "nearest-exact",
+                0.5
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 56,
+            "type": "TilePreprocessor",
+            "pos": [
+                350.9919954985504,
+                420.9138523025124
+            ],
+            "size": {
+                "0": 315,
+                "1": 82
+            },
+            "flags": {
+
+            },
+            "order": 22,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 92,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        94
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "TilePreprocessor"
+            },
+            "widgets_values": [
+                2,
+                512
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 58,
+            "type": "ControlNetLoader",
+            "pos": [
+                388.9919954985502,
+                636.9138523025122
+            ],
+            "size": {
+                "0": 315,
+                "1": 82
+            },
+            "flags": {
+                "collapsed": true
+            },
+            "order": 4,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "CONTROL_NET",
+                    "type": "CONTROL_NET",
+                    "links": [
+                        93
+                    ],
+                    "shape": 3,
+                    "label": "ControlNet"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetLoader"
+            },
+            "widgets_values": [
+                ""
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 62,
+            "type": "VAEEncode",
+            "pos": [
+                699.9919954985504,
+                635.9138523025122
+            ],
+            "size": {
+                "0": 210,
+                "1": 46
+            },
+            "flags": {
+                "collapsed": true
+            },
+            "order": 23,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "pixels",
+                    "type": "IMAGE",
+                    "link": 99,
+                    "label": "图像"
+                },
+                {
+                    "name": "vae",
+                    "type": "VAE",
+                    "link": 105,
+                    "label": "VAE"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "LATENT",
+                    "type": "LATENT",
+                    "links": [
+                        98
+                    ],
+                    "shape": 3,
+                    "label": "Latent"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "VAEEncode"
+            }
+        },
+        {
+            "id": 4,
+            "type": "CheckpointLoaderSimple",
+            "pos": [
+                -297,
+                -131
+            ],
+            "size": {
+                "0": 322.34063720703125,
+                "1": 125.84071350097656
+            },
+            "flags": {
+
+            },
+            "order": 5,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "MODEL",
+                    "type": "MODEL",
+                    "links": [
+                        106,
+                        120
+                    ],
+                    "slot_index": 0,
+                    "label": "模型"
+                },
+                {
+                    "name": "CLIP",
+                    "type": "CLIP",
+                    "links": [
+                        5,
+                        121
+                    ],
+                    "slot_index": 1,
+                    "label": "CLIP"
+                },
+                {
+                    "name": "VAE",
+                    "type": "VAE",
+                    "links": [
+                        42
+                    ],
+                    "slot_index": 2,
+                    "label": "VAE"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "CheckpointLoaderSimple"
+            },
+            "widgets_values": [
+                null
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 11,
+            "type": "Reroute",
+            "pos": [
+                852,
+                63
+            ],
+            "size": [
+                75,
+                26
+            ],
+            "flags": {
+
+            },
+            "order": 10,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "",
+                    "type": "*",
+                    "link": 42
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "",
+                    "type": "VAE",
+                    "links": [
+                        12,
+                        105,
+                        107
+                    ],
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "showOutputText": false,
+                "horizontal": false
+            }
+        },
+        {
+            "id": 63,
+            "type": "VAEDecode",
+            "pos": [
+                1285.9919954985496,
+                241.91385230251265
+            ],
+            "size": {
+                "0": 210,
+                "1": 46
+            },
+            "flags": {
+                "collapsed": true
+            },
+            "order": 26,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "samples",
+                    "type": "LATENT",
+                    "link": 100,
+                    "label": "Latent"
+                },
+                {
+                    "name": "vae",
+                    "type": "VAE",
+                    "link": 107,
+                    "label": "VAE"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        102
+                    ],
+                    "shape": 3,
+                    "label": "图像",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "VAEDecode"
+            }
+        },
+        {
+            "id": 61,
+            "type": "KSampler",
+            "pos": [
+                1028.9919954985496,
+                221.9138523025125
+            ],
+            "size": {
+                "0": 315,
+                "1": 474
+            },
+            "flags": {
+
+            },
+            "order": 25,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "model",
+                    "type": "MODEL",
+                    "link": 106,
+                    "label": "模型"
+                },
+                {
+                    "name": "positive",
+                    "type": "CONDITIONING",
+                    "link": 129,
+                    "label": "正面条件"
+                },
+                {
+                    "name": "negative",
+                    "type": "CONDITIONING",
+                    "link": 97,
+                    "label": "负面条件"
+                },
+                {
+                    "name": "latent_image",
+                    "type": "LATENT",
+                    "link": 98,
+                    "label": "Latent",
+                    "slot_index": 3
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "LATENT",
+                    "type": "LATENT",
+                    "links": [
+                        100
+                    ],
+                    "shape": 3,
+                    "label": "Latent",
+                    "slot_index": 0
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "KSampler"
+            },
+            "widgets_values": [
+                368308997265100,
+                "randomize",
+                32,
+                6,
+                "euler_ancestral",
+                "normal",
+                0.4
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#323",
+            "bgcolor": "#535"
+        },
+        {
+            "id": 57,
+            "type": "ControlNetApplyAdvanced",
+            "pos": [
+                683.9919954985504,
+                214.91385230251257
+            ],
+            "size": {
+                "0": 315,
+                "1": 166
+            },
+            "flags": {
+
+            },
+            "order": 24,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "positive",
+                    "type": "CONDITIONING",
+                    "link": 130,
+                    "label": "正面条件"
+                },
+                {
+                    "name": "negative",
+                    "type": "CONDITIONING",
+                    "link": 109,
+                    "label": "负面条件"
+                },
+                {
+                    "name": "control_net",
+                    "type": "CONTROL_NET",
+                    "link": 93,
+                    "label": "ControlNet",
+                    "slot_index": 2
+                },
+                {
+                    "name": "image",
+                    "type": "IMAGE",
+                    "link": 94,
+                    "label": "图像"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "positive",
+                    "type": "CONDITIONING",
+                    "links": [
+                        129
+                    ],
+                    "shape": 3,
+                    "label": "正面条件",
+                    "slot_index": 0
+                },
+                {
+                    "name": "negative",
+                    "type": "CONDITIONING",
+                    "links": [
+                        97
+                    ],
+                    "shape": 3,
+                    "label": "负面条件",
+                    "slot_index": 1
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "ControlNetApplyAdvanced"
+            },
+            "widgets_values": [
+                1,
+                0,
+                1
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 6,
+            "type": "CLIPTextEncode",
+            "pos": [
+                909,
+                -357
+            ],
+            "size": {
+                "0": 294.09674072265625,
+                "1": 124.96588134765625
+            },
+            "flags": {
+
+            },
+            "order": 14,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "clip",
+                    "type": "CLIP",
+                    "link": 20,
+                    "label": "CLIP"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "CONDITIONING",
+                    "type": "CONDITIONING",
+                    "links": [
+                        23,
+                        130
+                    ],
+                    "slot_index": 0,
+                    "label": "条件"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "CLIPTextEncode"
+            },
+            "widgets_values": [
+                "Masterpiece,best quality,detailed,(cake:1.1),cloud,flower,no_one,Conceptual product design,outdoor,c4dplus,hs,8k"
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#322",
+            "bgcolor": "#533"
+        },
+        {
+            "id": 65,
+            "type": "SaveImage",
+            "pos": [
+                1376.646858661257,
+                207.7515440348524
+            ],
+            "size": {
+                "0": 410.506103515625,
+                "1": 485.4575500488281
+            },
+            "flags": {
+
+            },
+            "order": 27,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "images",
+                    "type": "IMAGE",
+                    "link": 102,
+                    "label": "图像"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "SaveImage"
+            },
+            "widgets_values": [
+                "ComfyUI"
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#232",
+            "bgcolor": "#353"
+        },
+        {
+            "id": 5,
+            "type": "EmptyLatentImage",
+            "pos": [
+                1260,
+                -329
+            ],
+            "size": {
+                "0": 210,
+                "1": 112.68038177490234
+            },
+            "flags": {
+
+            },
+            "order": 6,
+            "mode": 0,
+            "outputs": [
+                {
+                    "name": "LATENT",
+                    "type": "LATENT",
+                    "links": [
+                        2
+                    ],
+                    "slot_index": 0,
+                    "label": "Latent"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "EmptyLatentImage"
+            },
+            "widgets_values": [
+                512,
+                768,
+                1
+            ],
+            "_widget_cache_map": {
+
+            }
+        },
+        {
+            "id": 3,
+            "type": "KSampler",
+            "pos": [
+                1497,
+                -388
+            ],
+            "size": {
+                "0": 263.527099609375,
+                "1": 474
+            },
+            "flags": {
+
+            },
+            "order": 17,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "model",
+                    "type": "MODEL",
+                    "link": 22,
+                    "label": "模型"
+                },
+                {
+                    "name": "positive",
+                    "type": "CONDITIONING",
+                    "link": 71,
+                    "label": "正面条件",
+                    "slot_index": 1
+                },
+                {
+                    "name": "negative",
+                    "type": "CONDITIONING",
+                    "link": 6,
+                    "label": "负面条件"
+                },
+                {
+                    "name": "latent_image",
+                    "type": "LATENT",
+                    "link": 2,
+                    "label": "Latent"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "LATENT",
+                    "type": "LATENT",
+                    "links": [
+                        7
+                    ],
+                    "slot_index": 0,
+                    "label": "Latent"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "KSampler"
+            },
+            "widgets_values": [
+                163854169040437,
+                "fixed",
+                50,
+                7,
+                "dpmpp_2m_sde",
+                "karras",
+                1
+            ],
+            "_widget_cache_map": {
+
+            },
+            "color": "#323",
+            "bgcolor": "#535"
+        },
+        {
+            "id": 8,
+            "type": "VAEDecode",
+            "pos": [
+                1820,
+                -366
+            ],
+            "size": {
+                "0": 210,
+                "1": 46
+            },
+            "flags": {
+                "collapsed": true
+            },
+            "order": 18,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "samples",
+                    "type": "LATENT",
+                    "link": 7,
+                    "label": "Latent"
+                },
+                {
+                    "name": "vae",
+                    "type": "VAE",
+                    "link": 12,
+                    "label": "VAE"
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "IMAGE",
+                    "type": "IMAGE",
+                    "links": [
+                        29,
+                        127
+                    ],
+                    "slot_index": 0,
+                    "label": "图像"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "VAEDecode"
+            }
+        },
+        {
+            "id": 21,
+            "type": "PreviewImage",
+            "pos": [
+                1774,
+                -312
+            ],
+            "size": {
+                "0": 344.7645263671875,
+                "1": 368.7522277832031
+            },
+            "flags": {
+
+            },
+            "order": 19,
+            "mode": 0,
+            "inputs": [
+                {
+                    "name": "images",
+                    "type": "IMAGE",
+                    "link": 29,
+                    "label": "图像"
+                }
+            ],
+            "properties": {
+                "Node name for S&R": "PreviewImage"
+            },
+            "color": "#232",
+            "bgcolor": "#353"
+        }
+    ],
+    "links": [
+        [
+            2,
+            5,
+            0,
+            3,
+            3,
+            "LATENT"
+        ],
+        [
+            5,
+            4,
+            1,
+            7,
+            0,
+            "CLIP"
+        ],
+        [
+            6,
+            7,
+            0,
+            3,
+            2,
+            "CONDITIONING"
+        ],
+        [
+            7,
+            3,
+            0,
+            8,
+            0,
+            "LATENT"
+        ],
+        [
+            12,
+            11,
+            0,
+            8,
+            1,
+            "VAE"
+        ],
+        [
+            20,
+            16,
+            1,
+            6,
+            0,
+            "CLIP"
+        ],
+        [
+            22,
+            16,
+            0,
+            3,
+            0,
+            "MODEL"
+        ],
+        [
+            23,
+            6,
+            0,
+            17,
+            0,
+            "CONDITIONING"
+        ],
+        [
+            25,
+            18,
+            0,
+            17,
+            1,
+            "CONTROL_NET"
+        ],
+        [
+            29,
+            8,
+            0,
+            21,
+            0,
+            "IMAGE"
+        ],
+        [
+            42,
+            4,
+            2,
+            11,
+            0,
+            "*"
+        ],
+        [
+            66,
+            42,
+            0,
+            41,
+            1,
+            "CONTROL_NET"
+        ],
+        [
+            70,
+            17,
+            0,
+            41,
+            0,
+            "CONDITIONING"
+        ],
+        [
+            71,
+            41,
+            0,
+            3,
+            1,
+            "CONDITIONING"
+        ],
+        [
+            92,
+            64,
+            0,
+            56,
+            0,
+            "IMAGE"
+        ],
+        [
+            93,
+            58,
+            0,
+            57,
+            2,
+            "CONTROL_NET"
+        ],
+        [
+            94,
+            56,
+            0,
+            57,
+            3,
+            "IMAGE"
+        ],
+        [
+            95,
+            60,
+            0,
+            59,
+            0,
+            "UPSCALE_MODEL"
+        ],
+        [
+            97,
+            57,
+            1,
+            61,
+            2,
+            "CONDITIONING"
+        ],
+        [
+            98,
+            62,
+            0,
+            61,
+            3,
+            "LATENT"
+        ],
+        [
+            99,
+            64,
+            0,
+            62,
+            0,
+            "IMAGE"
+        ],
+        [
+            100,
+            61,
+            0,
+            63,
+            0,
+            "LATENT"
+        ],
+        [
+            101,
+            59,
+            0,
+            64,
+            0,
+            "IMAGE"
+        ],
+        [
+            102,
+            63,
+            0,
+            65,
+            0,
+            "IMAGE"
+        ],
+        [
+            105,
+            11,
+            0,
+            62,
+            1,
+            "VAE"
+        ],
+        [
+            106,
+            4,
+            0,
+            61,
+            0,
+            "MODEL"
+        ],
+        [
+            107,
+            11,
+            0,
+            63,
+            1,
+            "VAE"
+        ],
+        [
+            109,
+            7,
+            0,
+            57,
+            1,
+            "CONDITIONING"
+        ],
+        [
+            111,
+            20,
+            0,
+            68,
+            0,
+            "IMAGE"
+        ],
+        [
+            112,
+            68,
+            0,
+            22,
+            0,
+            "IMAGE"
+        ],
+        [
+            115,
+            68,
+            0,
+            17,
+            2,
+            "IMAGE"
+        ],
+        [
+            119,
+            20,
+            0,
+            41,
+            2,
+            "IMAGE"
+        ],
+        [
+            120,
+            4,
+            0,
+            15,
+            0,
+            "MODEL"
+        ],
+        [
+            121,
+            4,
+            1,
+            15,
+            1,
+            "CLIP"
+        ],
+        [
+            122,
+            15,
+            0,
+            14,
+            0,
+            "MODEL"
+        ],
+        [
+            123,
+            15,
+            1,
+            14,
+            1,
+            "CLIP"
+        ],
+        [
+            124,
+            14,
+            0,
+            16,
+            0,
+            "MODEL"
+        ],
+        [
+            125,
+            14,
+            1,
+            16,
+            1,
+            "CLIP"
+        ],
+        [
+            127,
+            8,
+            0,
+            59,
+            1,
+            "IMAGE"
+        ],
+        [
+            129,
+            57,
+            0,
+            61,
+            1,
+            "CONDITIONING"
+        ],
+        [
+            130,
+            6,
+            0,
+            57,
+            0,
+            "CONDITIONING"
+        ]
+    ],
+    "groups": [
+        {
+            "title": "4X /2 _tile upscale  锐化 高清放大",
+            "bounding": [
+                144,
+                134,
+                1716,
+                582
+            ],
+            "color": "#3f789e",
+            "font_size": 24,
+            "locked": false
+        },
+        {
+            "title": "Contrlolnet",
+            "bounding": [
+                621,
+                -950,
+                1107,
+                466
+            ],
+            "color": "#3f789e",
+            "font_size": 24,
+            "locked": false
+        },
+        {
+            "title": "LORA",
+            "bounding": [
+                4,
+                -457,
+                774,
+                237
+            ],
+            "color": "#3f789e",
+            "font_size": 24,
+            "locked": false
+        },
+        {
+            "title": "prompt",
+            "bounding": [
+                896,
+                -431,
+                325,
+                387
+            ],
+            "color": "#3f789e",
+            "font_size": 24,
+            "locked": false
+        }
+    ],
+    "config": {
+
+    },
+    "extra": {
+        "0246.VERSION": [
+            0,
+            0,
+            4
+        ],
+        "ds": {
+            "scale": 0.7247295000000004,
+            "offset": [
+                -386.35423203542075,
+                673.0381820629576
+            ]
+        }
+    },
+    "version": 0.4
+}

DrawBridgeAPI/config_example.yaml

@@ -0,0 +1,208 @@
+civitai_setting: # civitai API token
+  token:
+    - You token here
+  model:
+    ''
+  proxy:
+    -
+a1111webui_setting:   # sd_webui 设置
+  backend_url:  # 后端地址
+    - http://127.0.0.1:7860
+    - http://127.0.0.1:7861
+  name:  # 后端备注名称
+    - 后端1
+    - 后端2
+  auth:  # 是否需要登录
+    - false
+    - false
+  username:  # 用户名
+    - admin
+    - admin
+  password:  # 密码
+    - admin
+    - admin
+  max_resolution:  # 最大分辨率，这个功能没写，暂时不生效
+    - null
+    - 1572864
+fal_ai_setting: # {"token": []}
+  token:  # 
+    - You token here
+  model:
+    ''
+replicate_setting: # {"token": []}
+  token:  # https://replicate.com/black-forest-labs/flux-schnell
+    - You token here
+  model:
+    ''
+liblibai_setting:
+# https://www.liblib.art/ # 按下F12 -> 应用 -> cookies -> https://www.liblib.art -> usertoken 的值 d812c12d83c640.....
+  token:  # 
+    - d812c12d83c640...
+    - 只要token填上了也算一个后端哦
+    - token3
+# 模型id获取方法 https://www.liblib.art/sd 先选择喜欢的模型 先按下F12 再 生图
+# 回到开发者控制台,网络选项 -> 找到名为 image 的请求,点击 负载 ， 请求负载 找到 checkpointId
+  model:  # 模型id
+    - 2332049
+    - 2676318
+    - 2675606
+  model_name:  # 模型名字，仅用作标记
+    - "liblib.art/modelinfo/d2f55cf374a7431cac13382182aed20c"
+    - "liblib.art/modelinfo/5ecc3218f1ef483ab63eeb4e4cff30cc"
+    - "liblib.art/modelinfo/fe3aac47589d4a20b24d0a6b045d607e"
+  xl:  # 是否为XL模型
+    - false
+    - true
+    - false
+  flux:  # 是否为FLUX模型
+    - false
+    - false
+    - false
+  preference:
+    - pretags:  # 内置prompt
+        1.5:  #  1.5模式下的预设词条，上面为正面，下面为负面
+          - ''  # prompt
+          - ''  # negative prompt
+        xl:  # xl 同上
+          - ""
+          - ""
+        flux:
+          - ''
+          - ''
+      steps: 20  # 步数
+    - pretags:
+        1.5:
+          - ''
+          - ''
+        xl:
+          - ""
+          - ""
+        flux:
+          - ''
+          - ''
+      steps: 20
+    - pretags:
+        1.5:
+          - ''
+          - ''
+        xl:
+          - ""
+          - ""
+        flux:
+          - ''
+          - ''
+      steps: 20
+
+tusiart_setting:  
+# 注意，有两个必填项，一个是token，一个是referer
+# https://tusiart.com/ 
+# 按下F12 -> 应用 -> cookies -> https://tusiart.com -> ta_token_prod 的值 eyJhbGciOiJI....
+  token:  #
+    - eyJhbGciOiJI....
+  model:  # 例如 https://tusiart.com/models/756170434619145524 # 取后面的数字
+    - 708770380971558251
+  note:
+    - 备注
+  referer:  # 你的用户首页! 点击右上角头像，复制链接 必填！！
+    - https://tusiart.com/u/759763664390847335
+seaart_setting:
+# https://www.seaart.ai/ # 登录 按下F12 -> 应用 -> cookies -> https://www.seaart.ai -> T 的值 eyJhbGciOiJI....
+  token:
+    - You token here
+  model:
+    -
+yunjie_setting:
+# https://www.yunjie.art/ # 登录 按下F12 -> 应用 -> cookies -> https://www.yunjie.art -> rayvision_aigc_token 的值 rsat:9IS5EH6vY
+  token:
+    - You token here
+  model:
+    -
+  note:
+      - 移动
+
+comfyui_setting:
+  backend_url:
+    - http://10.147.20.155:8188
+  name:
+    - default
+  model:
+    - models\\1053-S.ckpt
+  default_workflows:
+    - 'sdbase_txt2img'
+
+novelai_setting:
+  token:
+    - eyJhbGciOi...
+  model:
+    - nai-diffusion-3
+
+midjourney_setting:
+  backend_url:
+    - http://192.168.5.206:8081
+  name:
+    - default-mj-api
+  auth_toekn:
+    - null
+
+server_settings:
+  # 重点! 需要启动的后端, 有些后端你没配置的话依然启动会导致API报错（虽然API会将它锁定，之后请求就不会到它）
+  # 怎么数呢？ 比如在这个配置文件中 civitai 的第一个token是 0 a1111 的第一个后端是 1 , 第二个是2
+  # 所以 enable_txt2img_backends: [0,1] 表示启动 civitai第一个token 和 a1111的第一个后端
+  # 再比如 enable_txt2img_backends: [3, 4, 5] 表示启动 liblib 的所有两个token 和 tusiart的第一个token
+  enable_txt2img_backends: [13]
+  enable_img2img_backends: [1]
+  enable_sdapi_backends: [1]
+  redis_server:  # 必填 Redis服务器
+    - 127.0.0.1  # 地址
+    - 6379  # 端口
+    - null  # redis 密码
+    - 4 # redis数据库编号
+  enable_nsfw_check:
+    false  
+  save_image:  # 是否直接保存图片
+    true
+  build_in_tagger:
+    false
+  llm_caption:  # 使用llm用自然语言打标
+    enable:
+      false
+    clip:
+      google/siglip-so400m-patch14-384
+    llm:
+      unsloth/Meta-Llama-3.1-8B-bnb-4bit
+    image_adapter: # https://huggingface.co/spaces/fancyfeast/joy-caption-pre-alpha/tree/main/wpkklhc6
+      image_adapter.pt
+  build_in_photoai:
+    exec_path:
+      "C:\\Program Files\\Topaz Labs LLC\\Topaz Photo AI\\tpai.exe"
+  proxy:
+    "http://127.0.0.1:7890"
+
+  start_gradio:
+    False
+  same_port_with_api:
+    False
+  prompt_audit:
+    enable:
+      False
+    site:
+      api.openai.com
+    api_key:
+      null
+    http_proxy:
+      null
+
+
+backend_name_list:  # 不要动！
+  - civitai
+  - a1111
+  - falai
+  - replicate
+  - liblibai
+  - tusiart
+  - seaart
+  - yunjie
+  - comfyui
+  - novelai
+  - midjourney
+

DrawBridgeAPI/locales/__init__.py

@@ -0,0 +1,10 @@
+import os
+import gettext
+
+locale_dir = os.path.join(os.path.dirname(__file__))
+
+lang = gettext.translation('messages', localedir=locale_dir, languages=['zh'], fallback=True)
+lang.install()
+
+_ = lang.gettext
+i18n = _

DrawBridgeAPI/locales/zh/LC_MESSAGES/messages.po

@@ -0,0 +1,122 @@
+msgid "Loading config file completed"
+msgstr "加载配置文件完成"
+
+msgid "Redis connection successful"
+msgstr "Redis连接成功"
+
+msgid "Exec TXT2IMG"
+msgstr "开始进行文生图"
+
+msgid "IMG2IMG Requires image to start"
+msgstr "图生图需要图片来启动"
+
+msgid "Exec IMG2IMG"
+msgstr "开始进行图生图"
+
+msgid "Caption Successful"
+msgstr "打标成功"
+
+msgid "Lock to backend has configured"
+msgstr "设置已经锁定后端"
+
+msgid "URL detected"
+msgstr "检测到url"
+
+msgid "Image download failed!"
+msgstr "图片下载失败!"
+
+msgid "Exec forwarding"
+msgstr "开始进行转发"
+
+msgid "Waiting for API initialization"
+msgstr "请等待API初始化"
+
+msgid "Loading LLM"
+msgstr "LLM加载中"
+
+msgid "LLM loading completed, waiting for command"
+msgstr "LLM加载完成,等待命令"
+
+msgid "Loading Checkpoint"
+msgstr "模型加载中"
+
+msgid "Checkpoint loading completed, waiting for command"
+msgstr "模型加载完成,等待命令"
+
+msgid "Server is ready!"
+msgstr "服务器准备就绪!"
+
+msgid "Manually select model"
+msgstr "手动选择模型"
+
+msgid "Backend select"
+msgstr "已选择后端"
+
+msgid "Backend locked"
+msgstr "已锁定后端"
+
+msgid "Starting backend selection"
+msgstr "开始进行后端选择"
+
+msgid "Backend %s is down"
+msgstr "后端%s掉线"
+
+msgid "Backend %s is failed or locked"
+msgstr "后端%s出错或者锁定中"
+
+msgid "No available backend"
+msgstr "没有可用后端"
+
+msgid "Backend: %s Average work time: %s seconds, Current tasks: %s"
+msgstr "后端: %s 平均工作时间: %s秒, 现在进行中的任务: %s"
+
+msgid "Extra time weight"
+msgstr "额外的时间权重"
+
+msgid "Backend %s is the fastest, has been selected"
+msgstr "后端%s最快, 已经选择"
+
+msgid "Task completed successfully"
+msgstr "任务成功完成"
+
+msgid "Task failed"
+msgstr "任务失败"
+
+msgid "Remaining tasks in the queue"
+msgstr "队列中的剩余任务"
+
+msgid "No remaining tasks in the queue"
+msgstr "队列中已无任务"
+
+msgid "Forwarding request"
+msgstr "已转发请求"
+
+msgid "Backend returned error"
+msgstr "后端返回错误"
+
+msgid "Comfyui Backend, not using built-in multi-image generation management"
+msgstr "Comfyui后端, 不使用内置多图生成管理"
+
+msgid "A1111 Backend, not using built-in multi-image generation management"
+msgstr "A1111后端, 不使用内置多图生成管理"
+
+msgid "Over maximum retry times, posting still failed"
+msgstr "超过最大重试次数之后依然失败"
+
+msgid "Request completed, took %s seconds"
+msgstr "请求完成，共耗%s秒"
+
+msgid "VRAM OOM detected, auto model unload and reload"
+msgstr "检测到爆显存，执行自动模型释放并加载"
+
+msgid "Get a respond image, processing"
+msgstr "获取到返回图片，正在处理"
+
+msgid "Request failed, error message:"
+msgstr "请求失败，错误信息:"
+
+msgid "Downloading image successful"
+msgstr "图片下载成功"
+
+msgid "Selected ComfyUI style"
+msgstr "已选择ComfyUI工作流"

DrawBridgeAPI/utils/__init__.py

@@ -0,0 +1,91 @@
+import json
+
+import httpx
+from fastapi.exceptions import HTTPException
+from ..base_config import init_instance
+config = init_instance.config
+import asyncio
+
+
+async def http_request(
+        method,
+        target_url,
+        headers=None,
+        params=None,
+        content=None,
+        format=True
+):
+    async with httpx.AsyncClient() as client:
+
+        response = await client.request(
+            method,
+            target_url,
+            headers=headers,
+            params=params,
+            content=content
+        )
+
+        if response.status_code != 200:
+            raise HTTPException(500)
+        if format:
+            return response.json()
+        else:
+            return response
+
+
+async def run_later(func, delay=1):
+    loop = asyncio.get_running_loop()
+    loop.call_later(
+        delay,
+        lambda: loop.create_task(
+            func
+        )
+    )
+
+
+async def txt_audit(
+        msg,
+        prompt='''
+        接下来请你对一些聊天内容进行审核,
+        如果内容出现政治/暴恐内容（特别是我国的政治人物/或者和我国相关的政治）则请你输出<yes>, 
+        如果没有则输出<no>
+        '''
+):
+
+    from ..backend import Backend
+
+    system = [
+        {"role": "system",
+         "content": prompt}
+    ]
+
+    prompt = [{"role": "user", "content": msg}]
+
+    try:
+        resp = Backend.http_request(
+        "POST",
+        f"http://{config['prompt_audit']['site']}/v1/chat/completions",
+        {"Authorization": config['prompt_audit']['api_key']},
+        timeout=300,
+        format=True,
+        content= json.dumps(
+            {
+            "model": "gpt-3.5-turbo",
+            "messages": system + prompt,
+            "max_tokens": 4000,
+        }
+        )
+    )
+    except:
+        return "yes"
+    else:
+        res: str = remove_punctuation(resp['choices'][0]['message']['content'].strip())
+        return res
+
+
+def remove_punctuation(text):
+    import string
+    for i in range(len(text)):
+        if text[i] not in string.punctuation:
+            return text[i:]
+    return ""

DrawBridgeAPI/utils/custom_class.py

@@ -0,0 +1,28 @@
+from fal_client.client import AsyncClient
+from fal_client.auth import fetch_credentials
+
+import httpx
+import os
+
+USER_AGENT = "fal-client/0.2.2 (python)"
+
+
+class CustomAsyncClient(AsyncClient):
+    def __init__(self, key=None, default_timeout=120.0):
+        if key is None:
+            key = os.getenv("FAL_KEY")
+        super().__init__(key=key, default_timeout=default_timeout)
+
+    @property
+    def _client(self):
+        key = self.key
+        if key is None:
+            key = fetch_credentials()
+
+        return httpx.AsyncClient(
+            headers={
+                "Authorization": f"Key {key}",
+                "User-Agent": USER_AGENT,
+            },
+            timeout=self.default_timeout,
+        )

DrawBridgeAPI/utils/exceptions.py

@@ -0,0 +1,15 @@
+class DrawBridgeAPIException(Exception):
+
+    class DBAPIExceptions(Exception):
+        pass
+
+    class TokenExpired(DBAPIExceptions):
+        def __init__(self, message="Token expired."):
+            self.message = message
+            super().__init__(self.message)
+
+    class NeedRecaptcha(DBAPIExceptions):
+        def __init__(self, message="Need Recaptcha."):
+            self.message = message
+            super().__init__(self.message)
+

DrawBridgeAPI/utils/llm_caption_requirements.txt

@@ -0,0 +1,9 @@
+torch
+numpy
+pillow
+transformers>=4.43.3
+huggingface_hub
+protobuf
+bitsandbytes
+sentencepiece
+accelerate

DrawBridgeAPI/utils/llm_captions.py

@@ -0,0 +1,236 @@
+import asyncio
+import base64
+import warnings
+warnings.simplefilter(action='ignore', category=UserWarning)
+from torch import nn
+from io import BytesIO
+from transformers import AutoModel, AutoProcessor, AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast, \
+    AutoModelForCausalLM
+import torch
+import torch.amp.autocast_mode
+from PIL import Image
+import numpy as np
+from io import BytesIO
+
+from ..base_config import init_instance , setup_logger
+from ..locales import _
+
+llm_logger = setup_logger('[LLM-Caption]')
+
+class JoyPipeline:
+    def __init__(self):
+        self.clip_model = None
+        self.clip_processor = None
+        self.tokenizer = None
+        self.text_model = None
+        self.image_adapter = None
+        self.parent = None
+
+    def clearCache(self):
+        self.clip_model = None
+        self.clip_processor = None
+        self.tokenizer = None
+        self.text_model = None
+        self.image_adapter = None
+
+
+class ImageAdapter(nn.Module):
+    def __init__(self, input_features: int, output_features: int):
+        super().__init__()
+        self.linear1 = nn.Linear(input_features, output_features)
+        self.activation = nn.GELU()
+        self.linear2 = nn.Linear(output_features, output_features)
+
+    def forward(self, vision_outputs: torch.Tensor):
+        x = self.linear1(vision_outputs)
+        x = self.activation(x)
+        x = self.linear2(x)
+        return x
+
+
+class Joy_caption_load:
+
+    def __init__(self):
+        self.model = None
+        self.pipeline = JoyPipeline()
+        self.pipeline.parent = self
+        self.config = init_instance.config
+        pass
+
+    def loadCheckPoint(self):
+        # 清除一波
+        if self.pipeline != None:
+            self.pipeline.clearCache()
+
+            # clip
+        model_id = self.config.server_settings['llm_caption']['clip']
+
+        model = AutoModel.from_pretrained(model_id)
+        clip_processor = AutoProcessor.from_pretrained(model_id)
+        clip_model = AutoModel.from_pretrained(
+            model_id,
+            trust_remote_code=True
+        )
+
+        clip_model = clip_model.vision_model
+        clip_model.eval()
+        clip_model.requires_grad_(False)
+        clip_model.to("cuda")
+
+        # LLM
+        model_path_llm = self.config.server_settings['llm_caption']['llm']
+        tokenizer = AutoTokenizer.from_pretrained(model_path_llm, use_fast=False)
+        assert isinstance(tokenizer, PreTrainedTokenizer) or isinstance(tokenizer,
+                                                                        PreTrainedTokenizerFast), f"Tokenizer is of type {type(tokenizer)}"
+
+        text_model = AutoModelForCausalLM.from_pretrained(model_path_llm, device_map="auto", trust_remote_code=True)
+        text_model.eval()
+
+        # Image Adapte
+
+        image_adapter = ImageAdapter(clip_model.config.hidden_size,
+                                     text_model.config.hidden_size)  # ImageAdapter(clip_model.config.hidden_size, 4096)
+        image_adapter.load_state_dict(torch.load(self.config.server_settings['llm_caption']['image_adapter'], map_location="cpu", weights_only=True))
+        adjusted_adapter = image_adapter  # AdjustedImageAdapter(image_adapter, text_model.config.hidden_size)
+        adjusted_adapter.eval()
+        adjusted_adapter.to("cuda")
+
+        self.pipeline.clip_model = clip_model
+        self.pipeline.clip_processor = clip_processor
+        self.pipeline.tokenizer = tokenizer
+        self.pipeline.text_model = text_model
+        self.pipeline.image_adapter = adjusted_adapter
+
+    def clearCache(self):
+        if self.pipeline != None:
+            self.pipeline.clearCache()
+
+    def gen(self, model):
+        if self.model == None or self.model != model or self.pipeline == None:
+            self.model = model
+            self.loadCheckPoint()
+        return (self.pipeline,)
+
+
+class Joy_caption:
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def tensor2pil(t_image: torch.Tensor) -> Image:
+        return Image.fromarray(np.clip(255.0 * t_image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+    def gen(
+            self,
+            joy_pipeline=JoyPipeline,
+            image=Image,
+            prompt="A descriptive caption for this image",
+            max_new_tokens=300,
+            temperature=0.5,
+            cache=False
+    ):
+
+        if joy_pipeline.clip_processor == None:
+            joy_pipeline.parent.loadCheckPoint()
+
+        clip_processor = joy_pipeline.clip_processor
+        tokenizer = joy_pipeline.tokenizer
+        clip_model = joy_pipeline.clip_model
+        image_adapter = joy_pipeline.image_adapter
+        text_model = joy_pipeline.text_model
+
+        input_image = image
+
+        # Preprocess image
+        pImge = clip_processor(images=input_image, return_tensors='pt').pixel_values
+        pImge = pImge.to('cuda')
+
+        # Tokenize the prompt
+        prompt = tokenizer.encode(prompt, return_tensors='pt', padding=False, truncation=False,
+                                  add_special_tokens=False)
+        # Embed image
+        with torch.amp.autocast_mode.autocast('cuda', enabled=True):
+            vision_outputs = clip_model(pixel_values=pImge, output_hidden_states=True)
+            image_features = vision_outputs.hidden_states[-2]
+            embedded_images = image_adapter(image_features)
+            embedded_images = embedded_images.to('cuda')
+
+        # Embed prompt
+        prompt_embeds = text_model.model.embed_tokens(prompt.to('cuda'))
+        assert prompt_embeds.shape == (1, prompt.shape[1],
+                                       text_model.config.hidden_size), f"Prompt shape is {prompt_embeds.shape}, expected {(1, prompt.shape[1], text_model.config.hidden_size)}"
+        embedded_bos = text_model.model.embed_tokens(
+            torch.tensor([[tokenizer.bos_token_id]], device=text_model.device, dtype=torch.int64))
+
+        # Construct prompts
+        inputs_embeds = torch.cat([
+            embedded_bos.expand(embedded_images.shape[0], -1, -1),
+            embedded_images.to(dtype=embedded_bos.dtype),
+            prompt_embeds.expand(embedded_images.shape[0], -1, -1),
+        ], dim=1)
+
+        input_ids = torch.cat([
+            torch.tensor([[tokenizer.bos_token_id]], dtype=torch.long),
+            torch.zeros((1, embedded_images.shape[1]), dtype=torch.long),
+            prompt,
+        ], dim=1).to('cuda')
+        attention_mask = torch.ones_like(input_ids)
+
+        generate_ids = text_model.generate(input_ids, inputs_embeds=inputs_embeds, attention_mask=attention_mask,
+                                           max_new_tokens=max_new_tokens, do_sample=True, top_k=10,
+                                           temperature=temperature, suppress_tokens=None)
+
+        # Trim off the prompt
+        generate_ids = generate_ids[:, input_ids.shape[1]:]
+        if generate_ids[0][-1] == tokenizer.eos_token_id:
+            generate_ids = generate_ids[:, :-1]
+
+        caption = tokenizer.batch_decode(generate_ids, skip_special_tokens=False, clean_up_tokenization_spaces=False)[0]
+        r = caption.strip()
+
+        if cache == False:
+            joy_pipeline.parent.clearCache()
+
+        return (r,)
+
+
+class JoyCaptionHandler:
+    def __init__(self, config):
+        self.config = config
+        self.pipeline, self.joy_caption = self._initialize()
+
+    def _initialize(self):
+        llm_logger.info(_("Loading LLM"))
+        joy_caption_load = Joy_caption_load()
+        model_path = self.config.server_settings['llm_caption']['llm']
+        pipeline, = joy_caption_load.gen(model_path)
+        joy_caption = Joy_caption()
+        llm_logger.info(_("LLM loading completed, waiting for command"))
+        return pipeline, joy_caption
+
+    async def get_caption(self, image, ntags=[]):
+        if image.startswith(b"data:image/png;base64,"):
+            image = image.replace("data:image/png;base64,", "")
+        image = Image.open(BytesIO(base64.b64decode(image))).convert(mode="RGB")
+
+        extra_ = f"do not describe {','.join(ntags)} if it exist" if ntags else ''
+        loop = asyncio.get_event_loop()
+
+        caption = await loop.run_in_executor(
+            None,
+            self.joy_caption.gen,
+            self.pipeline,
+            image,
+            f"A descriptive caption for this image, do not describe a signature or text in the image,{extra_}",
+            300,
+            0.5,
+            True
+        )
+
+        return caption[0]
+
+
+config = init_instance.config
+if config.server_settings['llm_caption']['enable']:
+    joy_caption_handler = JoyCaptionHandler(config)

DrawBridgeAPI/utils/request_model.py

@@ -0,0 +1,153 @@
+from pydantic import BaseModel, conint
+from dataclasses import field
+from typing import Optional, List, Dict, Any
+from pathlib import Path
+import random
+
+
+class RequetModelClass(BaseModel):
+    pass
+
+
+class Txt2ImgRequest(RequetModelClass):
+    prompt: Optional[str] = ""
+    negative_prompt: Optional[str] = ""
+    styles: List[str] = []
+    seed: int = random.randint(0, 4294967295)
+    subseed: int = random.randint(0, 4294967295)
+    subseed_strength: float = 0
+    seed_resize_from_h: int = -1
+    seed_resize_from_w: int = -1
+    sampler_name: str = "Euler a"
+    batch_size: int = 1
+    n_iter: int = 1
+    steps: int = 20
+    cfg_scale: float = 7
+    width: int = 512
+    height: int = 512
+    restore_faces: bool = False
+    tiling: bool = False
+    do_not_save_samples: bool = False
+    do_not_save_grid: bool = False
+    eta: float = 0
+    denoising_strength: float = 1
+    s_min_uncond: float = 0
+    s_churn: float = 0
+    s_tmax: float = 0
+    s_tmin: float = 0
+    s_noise: float = 0
+    override_settings: Dict[str, Any] = {}
+    override_settings_restore_afterwards: bool = False
+    refiner_checkpoint: str = ""
+    refiner_switch_at: int = 0
+    disable_extra_networks: bool = False
+    comments: Dict[str, Any] = {}
+    enable_hr: bool = False
+    firstphase_width: int = 0
+    firstphase_height: int = 0
+    hr_scale: float = 2
+    hr_upscaler: str = ""
+    hr_second_pass_steps: int = 10
+    hr_resize_x: int = 0
+    hr_resize_y: int = 0
+    hr_checkpoint_name: str = ""
+    hr_sampler_name: str = ""
+    hr_prompt: str = ""
+    hr_negative_prompt: str = ""
+    sampler_index: str = "Euler a"
+    script_name: str = ""
+    script_args: List[Any] = []
+    send_images: bool = True
+    save_images: bool = True
+    alwayson_scripts: Dict[str, Any] = {}
+    scheduler: str = "Automatic"
+
+
+class Img2ImgRequest(RequetModelClass):
+    prompt: Optional[str] = ""
+    negative_prompt: Optional[str] = ""
+    styles: List[str] = []
+    seed: int = random.randint(0, 4294967295)
+    subseed: int = random.randint(0, 4294967295)
+    subseed_strength: float = 0
+    seed_resize_from_h: int = -1
+    seed_resize_from_w: int = -1
+    sampler_name: str = "Euler a"
+    batch_size: int = 1
+    n_iter: int = 1
+    steps: int = 50
+    cfg_scale: float = 7
+    width: int = 512
+    height: int = 512
+    restore_faces: bool = False
+    tiling: bool = False
+    do_not_save_samples: bool = False
+    do_not_save_grid: bool = False
+    eta: float = 0
+    denoising_strength: float = 0.75
+    s_min_uncond: float = 0
+    s_churn: float = 0
+    s_tmax: float = 0
+    s_tmin: float = 0
+    s_noise: float = 0
+    override_settings: Dict[str, Any] = {}
+    override_settings_restore_afterwards: bool = False
+    refiner_checkpoint: str = ""
+    refiner_switch_at: int = 0
+    disable_extra_networks: bool = False
+    comments: Dict[str, Any] = {}
+    init_images: List[str] = [""]
+    resize_mode: int = 0
+    image_cfg_scale: float = 0
+    mask: str = None
+    mask_blur_x: int = 4
+    mask_blur_y: int = 4
+    mask_blur: int = 0
+    inpainting_fill: int = 0
+    inpaint_full_res: bool = True
+    inpaint_full_res_padding: int = 0
+    inpainting_mask_invert: int = 0
+    initial_noise_multiplier: float = 0
+    latent_mask: str = ""
+    sampler_index: str = "Euler a"
+    include_init_images: bool = False
+    script_name: str = ""
+    script_args: List[Any] = []
+    send_images: bool = True
+    save_images: bool = True
+    alwayson_scripts: Dict[str, Any] = {}
+    scheduler: str = "Automatic"
+    # 以下为拓展
+
+
+class TaggerRequest(RequetModelClass):
+    image: str = '',
+    model: Optional[str] = 'wd14-vit-v2'
+    threshold: Optional[float] = 0.35,
+    exclude_tags: Optional[List[str]] = []
+
+
+class TopazAiRequest(BaseModel):
+    image: Optional[str] = None
+    input_folder: Optional[str or Path]
+    output_folder: Optional[str] = None
+    overwrite: Optional[bool] = False
+    recursive: Optional[bool] = False
+    format: Optional[str] = "preserve"  # 可选值: jpg, jpeg, png, tif, tiff, dng, preserve
+    quality: Optional[conint(ge=0, le=100)] = 95  # JPEG 质量，0到100之间
+    compression: Optional[conint(ge=0, le=10)] = 2  # PNG 压缩，0到10之间
+    bit_depth: Optional[conint(strict=True, ge=8, le=16)] = 16  # TIFF 位深度，8或16
+    tiff_compression: Optional[str] = "zip"  # 可选值: none, lzw, zip
+    show_settings: Optional[bool] = False
+    skip_processing: Optional[bool] = False
+    verbose: Optional[bool] = False
+    upscale: Optional[bool] = None
+    noise: Optional[bool] = None
+    sharpen: Optional[bool] = None
+    lighting: Optional[bool] = None
+    color: Optional[bool] = None
+
+
+class SetConfigRequest(BaseModel):
+    class Config:
+        extra = "allow"

DrawBridgeAPI/utils/shared.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+import os
+
+PATH_TO_COMFYUI_WORKFLOWS = Path(f"{os.path.dirname(os.path.abspath(__file__))}/../comfyui_workflows")
+

DrawBridgeAPI/utils/tagger-requirements.txt

@@ -0,0 +1,5 @@
+pandas
+numpy
+pillow
+huggingface_hub
+onnxruntime

DrawBridgeAPI/utils/tagger.py

@@ -0,0 +1,272 @@
+import os
+import asyncio
+
+import pandas as pd
+import numpy as np
+import base64
+
+from typing import Tuple, List, Dict
+from io import BytesIO
+from PIL import Image
+
+from pathlib import Path
+from huggingface_hub import hf_hub_download
+
+from ..base_config import setup_logger, init_instance
+from ..locales import _
+
+
+use_cpu = True
+tf_device_name = '/gpu:0' if not use_cpu else '/cpu:0'
+
+wd_logger = setup_logger('[TAGGER]')
+# https://github.com/toriato/stable-diffusion-webui-wd14-tagger
+
+
+class Interrogator:
+    @staticmethod
+    def postprocess_tags(
+        tags: Dict[str, float],
+        threshold=0.35,
+        additional_tags: List[str] = [],
+        exclude_tags: List[str] = [],
+        sort_by_alphabetical_order=False,
+        add_confident_as_weight=False,
+        replace_underscore=False,
+        replace_underscore_excludes: List[str] = [],
+        escape_tag=False
+    ) -> Dict[str, float]:
+        for t in additional_tags:
+            tags[t] = 1.0
+
+        tags = {
+            t: c
+            for t, c in sorted(
+                tags.items(),
+                key=lambda i: i[0 if sort_by_alphabetical_order else 1],
+                reverse=not sort_by_alphabetical_order
+            )
+            if (
+                c >= threshold
+                and t not in exclude_tags
+            )
+        }
+
+        new_tags = []
+        for tag in list(tags):
+            new_tag = tag
+
+            if replace_underscore and tag not in replace_underscore_excludes:
+                new_tag = new_tag.replace('_', ' ')
+
+            if escape_tag:
+                new_tag = tag.replace('_', '\\_')
+
+            if add_confident_as_weight:
+                new_tag = f'({new_tag}:{tags[tag]})'
+
+            new_tags.append((new_tag, tags[tag]))
+        tags = dict(new_tags)
+
+        return tags
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def load(self):
+        raise NotImplementedError()
+
+    def unload(self) -> bool:
+        unloaded = False
+
+        if hasattr(self, 'model') and self.model is not None:
+            del self.model
+            unloaded = True
+            print(f'Unloaded {self.name}')
+
+        if hasattr(self, 'tags'):
+            del self.tags
+
+        return unloaded
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidents
+        Dict[str, float]  # tag confidents
+    ]:
+        raise NotImplementedError()
+
+
+class WaifuDiffusionInterrogator(Interrogator):
+    def __init__(
+        self,
+        name: str,
+        model_path='model.onnx',
+        tags_path='selected_tags.csv',
+        **kwargs
+    ) -> None:
+        super().__init__(name)
+        self.model_path = model_path
+        self.tags_path = tags_path
+        self.kwargs = kwargs
+
+    def download(self) -> Tuple[os.PathLike, os.PathLike]:
+        wd_logger.info(f"Loading {self.name} model file from {self.kwargs['repo_id']}")
+
+        model_path = Path(hf_hub_download(
+            **self.kwargs, filename=self.model_path))
+        tags_path = Path(hf_hub_download(
+            **self.kwargs, filename=self.tags_path))
+        return model_path, tags_path
+
+    def load(self) -> None:
+        model_path, tags_path = self.download()
+
+        from onnxruntime import InferenceSession
+
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+        if use_cpu:
+            providers.pop(0)
+
+        self.model = InferenceSession(str(model_path), providers=providers)
+
+        wd_logger.info(f'Loaded {self.name} model from {model_path}')
+
+        self.tags = pd.read_csv(tags_path)
+
+    def interrogate(
+        self,
+        image: Image
+    ) -> Tuple[
+        Dict[str, float],  # rating confidents
+        Dict[str, float]  # tag confidents
+    ]:
+        if not hasattr(self, 'model') or self.model is None:
+            self.load()
+
+        _, height, _, _ = self.model.get_inputs()[0].shape
+
+        image = image.convert('RGBA')
+        new_image = Image.new('RGBA', image.size, 'WHITE')
+        new_image.paste(image, mask=image)
+        image = new_image.convert('RGB')
+        image = np.asarray(image)
+
+        image = image[:, :, ::-1]
+
+        # 模拟`dbimutils`的make_square和smart_resize功能
+        image = self.make_square(image, height)
+        image = self.smart_resize(image, height)
+        image = image.astype(np.float32)
+        image = np.expand_dims(image, 0)
+
+        input_name = self.model.get_inputs()[0].name
+        label_name = self.model.get_outputs()[0].name
+        confidents = self.model.run([label_name], {input_name: image})[0]
+
+        tags = self.tags[:][['name']]
+        tags['confidents'] = confidents[0]
+
+        ratings = dict(tags[:4].values)
+        tags = dict(tags[4:].values)
+
+        return ratings, tags
+
+    @staticmethod
+    def make_square(image, size):
+        old_size = image.shape[:2]
+        ratio = float(size) / max(old_size)
+        new_size = tuple([int(x * ratio) for x in old_size])
+        image = Image.fromarray(image)
+        image = image.resize(new_size, Image.LANCZOS)
+        new_image = Image.new("RGB", (size, size))
+        new_image.paste(image, ((size - new_size[0]) // 2,
+                                (size - new_size[1]) // 2))
+        return np.array(new_image)
+
+    @staticmethod
+    def smart_resize(image, size):
+        image = Image.fromarray(image)
+        image = image.resize((size, size), Image.LANCZOS)
+        return np.array(image)
+
+
+class WaifuDiffusionTaggerHandler:
+    def __init__(self, name, repo_id, revision, model_path, tags_path):
+        self.name = name
+        self.repo_id = repo_id
+        self.revision = revision
+        self.model_path = model_path
+        self.tags_path = tags_path
+        self.wd_instance = self._initialize()
+
+    def _initialize(self):
+        wd_instance = WaifuDiffusionInterrogator(
+            name=self.name,
+            repo_id=self.repo_id,
+            revision=self.revision,
+            model_path=self.model_path,
+            tags_path=self.tags_path
+        )
+        wd_logger.info(_("Loading Checkpoint"))
+        wd_instance.load()
+        wd_logger.info(_("Checkpoint loading completed, waiting for command"))
+        return wd_instance
+
+    async def tagger_main(self, base64_img, threshold, ntags=[], audit=False, ratings=False):
+        if base64_img.startswith("data:image/png;base64,"):
+            base64_img = base64_img.replace("data:image/png;base64,", "")
+
+        image_data = base64.b64decode(base64_img)
+        image = Image.open(BytesIO(image_data))
+
+        loop = asyncio.get_event_loop()
+        ratings, tags = await loop.run_in_executor(
+            None,
+            self.wd_instance.interrogate,
+            image
+        )
+        if ratings:
+            return ratings
+        if audit:
+            possibilities = ratings
+            value = list(possibilities.values())
+            value.sort(reverse=True)
+            reverse_dict = {value: key for key, value in possibilities.items()}
+            return True if reverse_dict[value[0]] == "questionable" or reverse_dict[value[0]] == "explicit" else False
+
+        # 处理标签
+        processed_tags = Interrogator.postprocess_tags(
+            tags=tags,
+            threshold=threshold,
+            additional_tags=['best quality', 'highres'],
+            exclude_tags=['lowres'] + ntags,
+            sort_by_alphabetical_order=False,
+            add_confident_as_weight=True,
+            replace_underscore=True,
+            replace_underscore_excludes=[],
+            escape_tag=False
+        )
+
+        def process_dict(input_dict):
+            processed_dict = {}
+            for key, value in input_dict.items():
+                cleaned_key = key.strip('()').split(':')[0]
+                processed_dict[cleaned_key] = value
+            return processed_dict
+
+        processed_tags = process_dict(processed_tags)
+        return {**ratings, **processed_tags}
+
+
+config = init_instance.config
+if config.server_settings['build_in_tagger']:
+    wd_tagger_handler = WaifuDiffusionTaggerHandler(
+        name='WaifuDiffusion',
+        repo_id='SmilingWolf/wd-v1-4-convnextv2-tagger-v2',
+        revision='v2.0',
+        model_path='model.onnx',
+        tags_path='selected_tags.csv'
+    )

DrawBridgeAPI/utils/topaz.py

@@ -0,0 +1,66 @@
+import subprocess
+from ..base_config import init_instance, setup_logger
+
+topazai_logger = setup_logger('[TopaAI]')
+
+
+def run_tpai(
+        input_folder, output_folder=None, overwrite=False, recursive=False,
+         format="preserve", quality=95, compression=2, bit_depth=16,
+         tiff_compression="zip", show_settings=False, skip_processing=False,
+         verbose=False, upscale=None, noise=None, sharpen=None,
+         lighting=None, color=None, **kwargs
+):
+    # 基本命令和输入文件夹
+    command = [rf'"{init_instance.config.server_settings["build_in_photoai"]["exec_path"]}"', f'"{input_folder}"']
+
+    # 输出文件夹
+    if output_folder:
+        command.extend(["--output", f'"{output_folder}"'])
+
+    # 覆盖现有文件
+    if overwrite:
+        command.append("--overwrite")
+
+    # 递归处理子文件夹
+    if recursive:
+        command.append("--recursive")
+
+    # 文件格式选项
+    if format:
+        command.extend(["--format", format])
+    if quality is not None:
+        command.extend(["--quality", str(quality)])
+    if compression is not None:
+        command.extend(["--compression", str(compression)])
+    if bit_depth is not None:
+        command.extend(["--bit-depth", str(bit_depth)])
+    if tiff_compression:
+        command.extend(["--tiff-compression", tiff_compression])
+
+    # 调试选项
+    if show_settings:
+        command.append("--showSettings")
+    if skip_processing:
+        command.append("--skipProcessing")
+    if verbose:
+        command.append("--verbose")
+
+    # 设置选项（实验性）
+    if upscale is not None:
+        command.extend(["--upscale", f"enabled={str(upscale).lower()}"])
+    if noise is not None:
+        command.extend(["--noise", f"enabled={str(noise).lower()}"])
+    if sharpen is not None:
+        command.extend(["--sharpen", f"enabled={str(sharpen).lower()}"])
+    if lighting is not None:
+        command.extend(["--lighting", f"enabled={str(lighting).lower()}"])
+    if color is not None:
+        command.extend(["--color", f"enabled={str(color).lower()}"])
+
+    # 打印并执行命令
+    topazai_logger.info(str(" ".join(command)))
+    result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+    # 返回结果，并忽略无法解码的字符
+    return result.stdout.decode(errors='ignore'), result.stderr.decode(errors='ignore'), result.returncode
+