bizyengine 0.4.2__py3-none-any.whl

bizyengine/bizy_server/utils.py

@@ -0,0 +1,93 @@
+import os
+from pathlib import Path
+
+from .errno import errnos
+from .resp import ErrResponse
+
+TYPE_OPTIONS = {
+    "LoRA": "LoRA",
+    "Controlnet": "Controlnet",
+}
+
+BASE_MODEL_TYPE_OPTIONS = {
+    "Flux.1 D": "Flux.1 D",
+    "SDXL": "SDXL",
+    "SD 1.5": "SD 1.5",
+    "SD 3.5": "SD 3.5",
+    "Pony": "Pony",
+    "Kolors": "Kolors",
+    "Hunyuan 1": "Hunyuan 1",
+    "Other": "Other",
+}
+
+ALLOW_TYPES = list(TYPE_OPTIONS.values())
+ALLOW_BASE_MODEL_TYPES = list(BASE_MODEL_TYPE_OPTIONS.values())
+ALLOW_UPLOADABLE_EXT_NAMES = [
+    ".safetensors",
+    ".pth",
+    ".bin",
+    ".pt",
+    ".ckpt",
+    ".gguf",
+    ".sft",
+]
+
+current_path = os.path.abspath(os.path.dirname(__file__))
+
+
+def get_html_content(filename: str):
+    html_file_path = Path(current_path) / filename
+    with open(html_file_path, "r", encoding="utf-8") as htmlfile:
+        html_content = htmlfile.read()
+    return html_content
+
+
+def is_string_valid(s):
+    # 检查s是否已经被定义（即不是None）且不是空字符串
+    if s is not None and s != "":
+        return True
+    else:
+        return False
+
+
+def to_slash(path):
+    return path.replace("\\", "/")
+
+
+def check_str_param(json_data, param_name: str, err):
+    if param_name not in json_data:
+        return ErrResponse(err)
+    if not is_string_valid(json_data[param_name]):
+        return ErrResponse(err)
+    return None
+
+
+def check_type(json_data):
+    if "type" not in json_data:
+        return ErrResponse(errnos.INVALID_TYPE)
+    if not is_string_valid(json_data["type"]) or (
+        json_data["type"] not in ALLOW_TYPES and json_data["type"] != "Workflow"
+    ):
+        return ErrResponse(errnos.INVALID_TYPE)
+    return None
+
+
+def types():
+    types = []
+    for k, v in TYPE_OPTIONS.items():
+        types.append({"label": k, "value": v})
+    return types
+
+
+def base_model_types():
+    base_model_types = []
+    for k, v in BASE_MODEL_TYPE_OPTIONS.items():
+        base_model_types.append({"label": k, "value": v})
+    return base_model_types
+
+
+def is_allow_ext_name(local_file_name):
+    if not os.path.isfile(local_file_name):
+        return False
+    _, ext = os.path.splitext(local_file_name)
+    return ext.lower() in ALLOW_UPLOADABLE_EXT_NAMES

bizyengine/bizyair_extras/__init__.py

@@ -0,0 +1,24 @@
+from .nodes_advanced_refluxcontrol import *
+from .nodes_cogview4 import *
+from .nodes_comfyui_detail_daemon import *
+from .nodes_comfyui_instantid import *
+from .nodes_comfyui_layerstyle_advance import *
+from .nodes_comfyui_pulid_flux import *
+from .nodes_controlnet import *
+from .nodes_custom_sampler import *
+from .nodes_dataset import *
+from .nodes_differential_diffusion import *
+from .nodes_flux import *
+from .nodes_image_utils import *
+from .nodes_ip2p import *
+from .nodes_ipadapter_plus.nodes_ipadapter_plus import *
+from .nodes_janus_pro import *
+from .nodes_kolors_mz import *
+from .nodes_model_advanced import *
+from .nodes_sd3 import *
+from .nodes_segment_anything import *
+from .nodes_testing_utils import *
+from .nodes_trellis import *
+from .nodes_ultimatesdupscale import *
+from .nodes_upscale_model import *
+from .nodes_wan_video import *

bizyengine/bizyair_extras/nodes_advanced_refluxcontrol.py

@@ -0,0 +1,62 @@
+"""ComfyUI Advanced Redux Control
+Reference: https://github.com/kaibioinfo/ComfyUI_AdvancedRefluxControl
+"""
+
+from bizyengine.core import BizyAirBaseNode, data_types
+from bizyengine.core.path_utils import path_manager as folder_paths
+
+STRENGTHS = ["highest", "high", "medium", "low", "lowest"]
+STRENGTHS_VALUES = [1, 2, 3, 4, 5]
+IMAGE_MODES = ["center crop (square)", "keep aspect ratio", "autocrop with mask"]
+
+
+class StyleModelApplySimple(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "conditioning": (data_types.CONDITIONING,),
+                "style_model": (data_types.STYLE_MODEL,),
+                "clip_vision_output": ("CLIP_VISION_OUTPUT",),
+                "image_strength": (STRENGTHS, {"default": "medium"}),
+            }
+        }
+
+    RETURN_TYPES = (data_types.CONDITIONING,)
+    CATEGORY = "conditioning/style_model"
+    NODE_DISPLAY_NAME = "Apply style model (simple)"
+
+
+class ReduxAdvanced(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "conditioning": (data_types.CONDITIONING,),
+                "style_model": (data_types.STYLE_MODEL,),
+                "clip_vision": ("CLIP_VISION",),
+                "image": ("IMAGE",),
+                "downsampling_factor": ("INT", {"default": 3, "min": 1, "max": 9}),
+                "downsampling_function": (
+                    ["nearest", "bilinear", "bicubic", "area", "nearest-exact"],
+                    {"default": "area"},
+                ),
+                "mode": (IMAGE_MODES, {"default": "center crop (square)"}),
+                "weight": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            },
+            "optional": {
+                "mask": ("MASK",),
+                "autocrop_margin": (
+                    "FLOAT",
+                    {"default": 0.1, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            },
+        }
+
+    RETURN_TYPES = (data_types.CONDITIONING, "IMAGE", "MASK")
+    # FUNCTION = "apply_stylemodel"
+    NODE_DISPLAY_NAME = "Apply Redux model (advanced)"
+    CATEGORY = "conditioning/style_model"

bizyengine/bizyair_extras/nodes_cogview4.py

@@ -0,0 +1,31 @@
+from bizyengine.core import BizyAirBaseNode
+
+
+class CogView4_6B_Pipe(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(self):
+        default_prompt = "A vibrant cherry red sports car sits proudly under the gleaming sun, its polished exterior smooth and flawless, casting a mirror-like reflection. The car features a low, aerodynamic body, angular headlights that gaze forward like predatory eyes, and a set of black, high-gloss racing rims that contrast starkly with the red. A subtle hint of chrome embellishes the grille and exhaust, while the tinted windows suggest a luxurious and private interior. The scene conveys a sense of speed and elegance, the car appearing as if it's about to burst into a sprint along a coastal road, with the ocean's azure waves crashing in the background.The license plate number of the car is 'CogView4'. The car sprinted along a coastal road, with the same sports car printed on the roadside billboard and large Chinese text '遥遥领先' written to it. The text was yellow, with thick strokes and heavy shadow lines."
+        return {
+            "required": {
+                "prompt": ("STRING", {"default": default_prompt, "multiline": True}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 1e14}),
+                "guidance_scale": (
+                    "FLOAT",
+                    {"default": 3.5, "min": 0.1, "max": 100, "step": 0.1},
+                ),
+                "num_images_per_prompt": (
+                    "INT",
+                    {"default": 1, "min": 1, "max": 4, "step": 1},
+                ),
+                "num_inference_steps": (
+                    "INT",
+                    {"default": 30, "min": 1, "max": 100, "step": 1},
+                ),
+                "width": ("INT", {"default": 1536, "min": 16, "max": 4096, "step": 16}),
+                "height": ("INT", {"default": 832, "min": 16, "max": 4096, "step": 16}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "CogView4 Wrapper"

bizyengine/bizyair_extras/nodes_comfyui_detail_daemon.py

@@ -0,0 +1,180 @@
+"""
+Reference: https://github.com/Jonseed/ComfyUI-Detail-Daemon
+"""
+
+from bizyengine.core import BizyAirBaseNode
+
+
+class DetailDaemonSamplerNode(BizyAirBaseNode):
+    DESCRIPTION = "This sampler wrapper works by adjusting the sigma passed to the model, while the rest of sampling stays the same."
+    CATEGORY = "sampling/custom_sampling/samplers"
+    RETURN_TYPES = ("SAMPLER",)
+    # FUNCTION = "go"
+
+    NODE_DISPLAY_NAME = "Detail Daemon Sampler"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict:
+        return {
+            "required": {
+                "sampler": ("SAMPLER",),
+                "detail_amount": (
+                    "FLOAT",
+                    {"default": 0.1, "min": -5.0, "max": 5.0, "step": 0.01},
+                ),
+                "start": (
+                    "FLOAT",
+                    {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "end": (
+                    "FLOAT",
+                    {"default": 0.8, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "bias": (
+                    "FLOAT",
+                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "exponent": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.05},
+                ),
+                "start_offset": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01},
+                ),
+                "end_offset": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01},
+                ),
+                "fade": (
+                    "FLOAT",
+                    {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "smooth": ("BOOLEAN", {"default": True}),
+                "cfg_scale_override": (
+                    "FLOAT",
+                    {
+                        "default": 0,
+                        "min": 0.0,
+                        "max": 100.0,
+                        "step": 0.5,
+                        "round": 0.01,
+                        "tooltip": "If set to 0, the sampler will automatically determine the CFG scale (if possible). Set to some other value to override.",
+                    },
+                ),
+            },
+        }
+
+
+class MultiplySigmas(BizyAirBaseNode):
+    # FUNCTION = "simple_output"
+    RETURN_TYPES = ("SIGMAS",)
+    CATEGORY = "sampling/custom_sampling/sigmas"
+    NODE_DISPLAY_NAME = "Multiply Sigmas (stateless)"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict:
+        return {
+            "required": {
+                "sigmas": ("SIGMAS", {"forceInput": True}),
+                "factor": (
+                    "FLOAT",
+                    {"default": 1, "min": 0, "max": 100, "step": 0.001},
+                ),
+                "start": ("FLOAT", {"default": 0, "min": 0, "max": 1, "step": 0.001}),
+                "end": ("FLOAT", {"default": 1, "min": 0, "max": 1, "step": 0.001}),
+            }
+        }
+
+
+class LyingSigmaSampler(BizyAirBaseNode):
+    CATEGORY = "sampling/custom_sampling"
+    RETURN_TYPES = ("SAMPLER",)
+    NODE_DISPLAY_NAME = "Lying Sigma Sampler"
+    # FUNCTION = "go"
+
+    @classmethod
+    def INPUT_TYPES(cls) -> dict:
+        return {
+            "required": {
+                "sampler": ("SAMPLER",),
+                "dishonesty_factor": (
+                    "FLOAT",
+                    {
+                        "default": -0.05,
+                        "min": -0.999,
+                        "step": 0.01,
+                        "tooltip": "Multiplier for sigmas passed to the model. -0.05 means we reduce the sigma by 5%.",
+                    },
+                ),
+            },
+            "optional": {
+                "start_percent": (
+                    "FLOAT",
+                    {"default": 0.1, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "end_percent": (
+                    "FLOAT",
+                    {"default": 0.9, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            },
+        }
+
+
+class DetailDaemonGraphSigmasNode(BizyAirBaseNode):
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    CATEGORY = "sampling/custom_sampling/sigmas"
+    NODE_DISPLAY_NAME = "Detail Daemon Graph Sigmas"
+    # FUNCTION = "make_graph"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "sigmas": ("SIGMAS", {"forceInput": True}),
+                "detail_amount": (
+                    "FLOAT",
+                    {"default": 0.1, "min": -5.0, "max": 5.0, "step": 0.01},
+                ),
+                "start": (
+                    "FLOAT",
+                    {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "end": (
+                    "FLOAT",
+                    {"default": 0.8, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "bias": (
+                    "FLOAT",
+                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+                "exponent": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.05},
+                ),
+                "start_offset": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01},
+                ),
+                "end_offset": (
+                    "FLOAT",
+                    {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01},
+                ),
+                "fade": (
+                    "FLOAT",
+                    {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "smooth": ("BOOLEAN", {"default": True}),
+                "cfg_scale": (
+                    "FLOAT",
+                    {
+                        "default": 1.0,
+                        "min": 0.0,
+                        "max": 100.0,
+                        "step": 0.5,
+                        "round": 0.01,
+                    },
+                ),
+            },
+        }

bizyengine/bizyair_extras/nodes_comfyui_instantid.py

@@ -0,0 +1,164 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+from bizyengine.core.path_utils import path_manager as folder_paths
+
+
+class InstantIDModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid_file": (folder_paths.get_filename_list("instantid"),)
+            }
+        }
+
+    RETURN_TYPES = (data_types.INSTANTID,)
+    FUNCTION = "default_function"
+    CATEGORY = "InstantID"
+    NODE_DISPLAY_NAME = "Load InstantID Model"
+
+
+class ApplyInstantID(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid": (data_types.INSTANTID,),
+                "insightface": (data_types.FACEANALYSIS,),
+                "control_net": (data_types.CONTROL_NET,),
+                "image": ("IMAGE",),
+                "model": (data_types.MODEL,),
+                "positive": (data_types.CONDITIONING,),
+                "negative": (data_types.CONDITIONING,),
+                "weight": (
+                    "FLOAT",
+                    {
+                        "default": 0.8,
+                        "min": 0.0,
+                        "max": 5.0,
+                        "step": 0.01,
+                    },
+                ),
+                "start_at": (
+                    "FLOAT",
+                    {
+                        "default": 0.0,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.001,
+                    },
+                ),
+                "end_at": (
+                    "FLOAT",
+                    {
+                        "default": 1.0,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.001,
+                    },
+                ),
+            },
+            "optional": {
+                "image_kps": ("IMAGE",),
+                "mask": ("MASK",),
+            },
+        }
+
+    RETURN_TYPES = (
+        data_types.MODEL,
+        data_types.CONDITIONING,
+        data_types.CONDITIONING,
+    )
+    RETURN_NAMES = (
+        "MODEL",
+        "positive",
+        "negative",
+    )
+    # FUNCTION = "apply_instantid" use default_function
+    CATEGORY = "InstantID"
+    NODE_DISPLAY_NAME = "Apply InstantID"
+
+
+class ApplyInstantIDAdvanced(ApplyInstantID):
+    NODE_DISPLAY_NAME = "Apply InstantID Adavanced"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "instantid": (data_types.INSTANTID,),
+                "insightface": (data_types.FACEANALYSIS,),
+                "control_net": (data_types.CONTROL_NET,),
+                "image": ("IMAGE",),
+                "model": (data_types.MODEL,),
+                "positive": (data_types.CONDITIONING,),
+                "negative": (data_types.CONDITIONING,),
+                "ip_weight": (
+                    "FLOAT",
+                    {
+                        "default": 0.8,
+                        "min": 0.0,
+                        "max": 3.0,
+                        "step": 0.01,
+                    },
+                ),
+                "cn_strength": (
+                    "FLOAT",
+                    {
+                        "default": 0.8,
+                        "min": 0.0,
+                        "max": 10.0,
+                        "step": 0.01,
+                    },
+                ),
+                "start_at": (
+                    "FLOAT",
+                    {
+                        "default": 0.0,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.001,
+                    },
+                ),
+                "end_at": (
+                    "FLOAT",
+                    {
+                        "default": 1.0,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.001,
+                    },
+                ),
+                "noise": (
+                    "FLOAT",
+                    {
+                        "default": 0.0,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.1,
+                    },
+                ),
+                "combine_embeds": (
+                    ["average", "norm average", "concat"],
+                    {"default": "average"},
+                ),
+            },
+            "optional": {
+                "image_kps": ("IMAGE",),
+                "mask": ("MASK",),
+            },
+        }
+
+
+class InstantIDFaceAnalysis(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "provider": (["CUDA"],),
+            },
+        }
+
+    RETURN_TYPES = (data_types.FACEANALYSIS,)
+    # FUNCTION = "load_insight_face"
+    CATEGORY = "InstantID"
+    NODE_DISPLAY_NAME = "InstantID Face Analysis"