bizyengine 0.4.2__py3-none-any.whl

bizyengine/bizyair_extras/nodes_comfyui_layerstyle_advance.py

@@ -0,0 +1,141 @@
+from bizyengine.core import BizyAirBaseNode
+
+# layerstyle advance
+NODE_NAME = "SegmentAnythingUltra V2"
+sam_model_dir_name = "sams"
+sam_model_list = {
+    "sam_vit_h (2.56GB)": {
+        "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth"
+    },
+    # "sam_vit_l (1.25GB)": {
+    #     "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth"
+    # },
+    # "sam_vit_b (375MB)": {
+    #     "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth"
+    # },
+    # "sam_hq_vit_h (2.57GB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_h.pth"
+    # },
+    # "sam_hq_vit_l (1.25GB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_l.pth"
+    # },
+    # "sam_hq_vit_b (379MB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_b.pth"
+    # },
+    # "mobile_sam(39MB)": {
+    #     "model_url": "https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt"
+    # }
+}
+
+groundingdino_model_dir_name = "grounding-dino"
+groundingdino_model_list = {
+    "GroundingDINO_SwinT_OGC (694MB)": {
+        "config_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GroundingDINO_SwinT_OGC.cfg.py",
+        "model_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/groundingdino_swint_ogc.pth",
+    },
+    # "GroundingDINO_SwinB (938MB)": {
+    #     "config_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GroundingDINO_SwinB.cfg.py",
+    #     "model_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/groundingdino_swinb_cogcoor.pth"
+    # },
+}
+
+
+def list_sam_model():
+    return list(sam_model_list.keys())
+
+
+def list_groundingdino_model():
+    return list(groundingdino_model_list.keys())
+
+
+class SegmentAnythingUltraV2(BizyAirBaseNode):
+
+    CLASS_TYPE_NAME = "LayerMask: SegmentAnythingUltra V2"
+    NODE_DISPLAY_NAME = "LayerMask: SegmentAnythingUltra V2(Advance)"
+
+    def __init__(self):
+        self.SAM_MODEL = None
+        self.DINO_MODEL = None
+        self.previous_sam_model = ""
+        self.previous_dino_model = ""
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+
+        method_list = [
+            "VITMatte",
+            "VITMatte(local)",
+            "PyMatting",
+            "GuidedFilter",
+        ]
+        device_list = ["cuda"]
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "sam_model": (list_sam_model(),),
+                "grounding_dino_model": (list_groundingdino_model(),),
+                "threshold": (
+                    "FLOAT",
+                    {"default": 0.3, "min": 0, "max": 1.0, "step": 0.01},
+                ),
+                "detail_method": (method_list,),
+                "detail_erode": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+                "detail_dilate": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+                "black_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.15,
+                        "min": 0.01,
+                        "max": 0.98,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "white_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.99,
+                        "min": 0.02,
+                        "max": 0.99,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "process_detail": ("BOOLEAN", {"default": True}),
+                "prompt": ("STRING", {"default": "subject"}),
+                "device": (device_list,),
+                "max_megapixels": (
+                    "FLOAT",
+                    {"default": 2.0, "min": 1, "max": 999, "step": 0.1},
+                ),
+                "cache_model": ("BOOLEAN", {"default": True}),
+            },
+            "optional": {},
+        }
+
+    RETURN_TYPES = (
+        "IMAGE",
+        "MASK",
+    )
+    RETURN_NAMES = (
+        "image",
+        "mask",
+    )
+    # FUNCTION = "segment_anything_ultra_v2"
+    CATEGORY = "😺dzNodes/LayerMask"
+
+
+NODE_CLASS_MAPPINGS = {
+    "LayerMask: SegmentAnythingUltra V2": SegmentAnythingUltraV2,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "LayerMask: SegmentAnythingUltra V2": "LayerMask: SegmentAnythingUltra V2(Advance)",
+}

bizyengine/bizyair_extras/nodes_comfyui_pulid_flux.py

@@ -0,0 +1,88 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+from bizyengine.core.path_utils import path_manager as folder_paths
+
+# PuLID Flux datatypes
+PULIDFLUX = "BIZYAIR_PULIDFLUX"
+EVA_CLIP = "BIZYAIR_EVA_CLIP"
+FACEANALYSIS = "BIZYAIR_FACEANALYSIS"
+
+
+class PulidFluxModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"pulid_file": (folder_paths.get_filename_list("pulid"),)}}
+
+    RETURN_TYPES = (PULIDFLUX,)
+    RETURN_NAMES = ("pulid_flux",)
+    # FUNCTION = "load_model"
+    CATEGORY = "pulid"
+    NODE_DISPLAY_NAME = "Load PuLID Flux Model"
+
+
+class PulidFluxInsightFaceLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "provider": (
+                    [
+                        "CUDA",
+                    ],
+                ),
+            },
+        }
+
+    RETURN_TYPES = (FACEANALYSIS,)
+    RETURN_NAMES = ("face_analysis",)
+    # FUNCTION = "load_insightface"
+    CATEGORY = "pulid"
+    NODE_DISPLAY_NAME = "Load InsightFace (PuLID Flux)"
+
+
+class PulidFluxEvaClipLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {},
+        }
+
+    RETURN_TYPES = (EVA_CLIP,)
+    RETURN_NAMES = ("eva_clip",)
+    # FUNCTION = "load_eva_clip"
+    CATEGORY = "pulid"
+    NODE_DISPLAY_NAME = "Load Eva Clip (PuLID Flux)"
+
+
+class ApplyPulidFlux(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (data_types.MODEL,),
+                "pulid_flux": (PULIDFLUX,),
+                "eva_clip": (EVA_CLIP,),
+                "face_analysis": (FACEANALYSIS,),
+                "image": ("IMAGE",),
+                "weight": (
+                    "FLOAT",
+                    {"default": 1.0, "min": -1.0, "max": 5.0, "step": 0.05},
+                ),
+                "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": {
+                "attn_mask": ("MASK",),
+            },
+            "hidden": {"unique_id": "UNIQUE_ID"},
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    # FUNCTION = "apply_pulid_flux"
+    CATEGORY = "pulid"
+    NODE_DISPLAY_NAME = "Apply PuLID Flux"

bizyengine/bizyair_extras/nodes_controlnet.py

@@ -0,0 +1,50 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+from comfy.cldm.control_types import UNION_CONTROLNET_TYPES
+
+
+class SetUnionControlNetType(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "control_net": (data_types.CONTROL_NET,),
+                "type": (["auto"] + list(UNION_CONTROLNET_TYPES.keys()),),
+            }
+        }
+
+    CATEGORY = "conditioning/controlnet"
+    RETURN_TYPES = (data_types.CONTROL_NET,)
+
+    # FUNCTION = "set_controlnet_type"
+
+
+class ControlNetInpaintingAliMamaApply(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "positive": (data_types.CONDITIONING,),
+                "negative": (data_types.CONDITIONING,),
+                "control_net": (data_types.CONTROL_NET,),
+                "vae": (data_types.VAE,),
+                "image": ("IMAGE",),
+                "mask": ("MASK",),
+                "strength": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01},
+                ),
+                "start_percent": (
+                    "FLOAT",
+                    {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001},
+                ),
+                "end_percent": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001},
+                ),
+            }
+        }
+
+    # FUNCTION = "apply_inpaint_controlnet"
+    CATEGORY = "conditioning/controlnet"
+    RETURN_TYPES = (data_types.CONDITIONING, data_types.CONDITIONING)
+    RETURN_NAMES = ("positive", "negative")

bizyengine/bizyair_extras/nodes_custom_sampler.py

@@ -0,0 +1,130 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+
+
+class DisableNoise(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {}}
+
+    RETURN_TYPES = ("NOISE",)
+    CATEGORY = "sampling/custom_sampling/noise"
+
+
+class VPScheduler(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                "beta_d": (
+                    "FLOAT",
+                    {
+                        "default": 19.9,
+                        "min": 0.0,
+                        "max": 5000.0,
+                        "step": 0.01,
+                        "round": False,
+                    },
+                ),  # TODO: fix default values
+                "beta_min": (
+                    "FLOAT",
+                    {
+                        "default": 0.1,
+                        "min": 0.0,
+                        "max": 5000.0,
+                        "step": 0.01,
+                        "round": False,
+                    },
+                ),
+                "eps_s": (
+                    "FLOAT",
+                    {
+                        "default": 0.001,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.0001,
+                        "round": False,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("SIGMAS",)
+    CATEGORY = "sampling/custom_sampling/schedulers"
+
+
+class SplitSigmas(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "sigmas": ("SIGMAS",),
+                "step": ("INT", {"default": 0, "min": 0, "max": 10000}),
+            }
+        }
+
+    RETURN_TYPES = ("SIGMAS", "SIGMAS")
+    RETURN_NAMES = ("high_sigmas", "low_sigmas")
+    CATEGORY = "sampling/custom_sampling/sigmas"
+
+
+class SplitSigmasDenoise(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "sigmas": ("SIGMAS",),
+                "denoise": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("SIGMAS", "SIGMAS")
+    RETURN_NAMES = ("high_sigmas", "low_sigmas")
+    CATEGORY = "sampling/custom_sampling/sigmas"
+
+    # FUNCTION = "get_sigmas"
+
+
+class FlipSigmas(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "sigmas": ("SIGMAS",),
+            }
+        }
+
+    RETURN_TYPES = ("SIGMAS",)
+    CATEGORY = "sampling/custom_sampling/sigmas"
+
+    # FUNCTION = "get_sigmas"
+
+
+class CFGGuider(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (data_types.MODEL,),
+                "positive": (data_types.CONDITIONING,),
+                "negative": (data_types.CONDITIONING,),
+                "cfg": (
+                    "FLOAT",
+                    {
+                        "default": 8.0,
+                        "min": 0.0,
+                        "max": 100.0,
+                        "step": 0.1,
+                        "round": 0.01,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("GUIDER",)
+
+    # FUNCTION = "get_guider"
+    CATEGORY = "sampling/custom_sampling/guiders"

bizyengine/bizyair_extras/nodes_dataset.py

@@ -0,0 +1,99 @@
+from bizyengine.core import BizyAirBaseNode
+
+
+class TrainDatasetAdd(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "dataset_config": ("JSON",),
+                "width": (
+                    "INT",
+                    {"min": 64, "default": 1024, "tooltip": "base resolution width"},
+                ),
+                "height": (
+                    "INT",
+                    {"min": 64, "default": 1024, "tooltip": "base resolution height"},
+                ),
+                "batch_size": (
+                    "INT",
+                    {
+                        "min": 1,
+                        "default": 2,
+                        "tooltip": "Higher batch size uses more memory and generalizes the training more",
+                    },
+                ),
+                "dataset_path": (
+                    [
+                        "to choose",
+                    ],
+                    # "STRING",
+                    # {
+                    #     "multiline": True,
+                    #     "default": "",
+                    #     "tooltip": "path to dataset, root is the 'ComfyUI' folder, with windows portable 'ComfyUI_windows_portable'",
+                    # },
+                ),
+                "dataset_version_id": (
+                    "STRING",
+                    {
+                        "default": "",
+                    },
+                ),
+                "class_tokens": (
+                    "STRING",
+                    {
+                        "multiline": False,
+                        "default": "trigger_word",
+                        "tooltip": "aka trigger word, if specified, will be added to the start of each caption, if no captions exist, will be used on it's own",
+                    },
+                ),
+                "enable_bucket": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "enable buckets for multi aspect ratio training",
+                    },
+                ),
+                "bucket_no_upscale": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "don't allow upscaling when bucketing",
+                    },
+                ),
+                "num_repeats": (
+                    "INT",
+                    {
+                        "default": 1,
+                        "min": 1,
+                        "tooltip": "number of times to repeat dataset for an epoch",
+                    },
+                ),
+                "min_bucket_reso": (
+                    "INT",
+                    {
+                        "default": 256,
+                        "min": 64,
+                        "max": 4096,
+                        "step": 8,
+                        "tooltip": "min bucket resolution",
+                    },
+                ),
+                "max_bucket_reso": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 64,
+                        "max": 4096,
+                        "step": 8,
+                        "tooltip": "max bucket resolution",
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("JSON",)
+    RETURN_NAMES = ("dataset",)
+    # FUNCTION = "create_config"
+    CATEGORY = "FluxTrainer"

bizyengine/bizyair_extras/nodes_differential_diffusion.py

@@ -0,0 +1,16 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+
+
+class DifferentialDiffusion(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (data_types.MODEL,),
+            }
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    # FUNCTION = "apply"
+    CATEGORY = "_for_testing"
+    INIT = False

bizyengine/bizyair_extras/nodes_flux.py

@@ -0,0 +1,69 @@
+from bizyengine.core import BizyAirBaseNode, data_types
+from bizyengine.core.nodes_io import BizyAirNodeIO
+
+
+class CLIPTextEncodeFlux(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "clip": (data_types.CLIP,),
+                "clip_l": ("STRING", {"multiline": True, "dynamicPrompts": True}),
+                "t5xxl": ("STRING", {"multiline": True, "dynamicPrompts": True}),
+                "guidance": (
+                    "FLOAT",
+                    {"default": 3.5, "min": 0.0, "max": 100.0, "step": 0.1},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.CONDITIONING,)
+    RETURN_NAMES = ("conditioning",)
+    # FUNCTION = "encode"
+
+    CATEGORY = "advanced/conditioning/flux"
+
+    # def encode(self, clip: BizyAirNodeIO, clip_l: str, t5xxl: str, guidance: float):
+    #     new_clip = clip.copy(self.assigned_id)
+    #     new_clip.add_node_data(
+    #         class_type="CLIPTextEncodeFlux",
+    #         inputs={
+    #             "clip": clip,
+    #             "clip_l": clip_l,
+    #             "t5xxl": t5xxl,
+    #             "guidance": guidance,
+    #         },
+    #         outputs={"slot_index": 0},
+    #     )
+    #     return (new_clip,)
+
+
+class FluxGuidance(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "conditioning": (data_types.CONDITIONING,),
+                "guidance": (
+                    "FLOAT",
+                    {"default": 3.5, "min": 0.0, "max": 100.0, "step": 0.1},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.CONDITIONING,)
+    FUNCTION = "append"
+
+    CATEGORY = "advanced/conditioning/flux"
+
+    def append(self, conditioning: BizyAirNodeIO, guidance):
+        new_conditioning = conditioning.copy(self.assigned_id)
+        new_conditioning.add_node_data(
+            class_type="FluxGuidance",
+            inputs={
+                "conditioning": conditioning,
+                "guidance": guidance,
+            },
+            outputs={"slot_index": 0},
+        )
+        return (new_conditioning,)

bizyengine/bizyair_extras/nodes_image_utils.py

@@ -0,0 +1,93 @@
+import base64
+import hashlib
+import os
+import re
+import urllib.request
+
+import folder_paths
+from bizyengine.core import BizyAirBaseNode
+from bizyengine.core.image_utils import encode_data
+from nodes import LoadImage
+
+
+class LoadImageURL(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "url": (
+                    "STRING",
+                    {
+                        "multiline": True,  # True if you want the field to look like the one on the ClipTextEncode node
+                        "default": "url or path",
+                        "lazy": True,
+                    },
+                ),
+            },
+        }
+
+    CATEGORY = "image_utils"
+    RETURN_TYPES = ("IMAGE", "MASK")
+    FUNCTION = "apply"
+    NODE_DISPLAY_NAME = "Load Image (URL)"
+
+    def apply(self, url: str):
+        url = url.strip()
+        input_dir = folder_paths.get_input_directory()
+
+        # check if it's a base64 encoded image
+        base64_pattern = r"^data:image/([a-zA-Z]+);base64,"
+        match = re.match(base64_pattern, url)
+
+        if match:
+            # get image format
+            image_format = match.group(1)
+            image_data = url.split(",")[1]
+
+            # calculate hash of the base64 data
+            hash_object = hashlib.md5(image_data.encode())
+            hash_value = hash_object.hexdigest()
+
+            filename = f"base64-{hash_value}.{image_format}"
+            file_path = os.path.join(input_dir, filename)
+
+            if not os.path.exists(file_path):
+                with open(file_path, "wb") as f:
+                    f.write(base64.b64decode(image_data))
+                print(f"Base64 image saved as {filename}")
+            else:
+                print(f"Base64 image {filename} already exists, skipping save.")
+        else:
+            filename = os.path.basename(url)
+            file_path = os.path.join(input_dir, filename)
+
+            if os.path.exists(file_path):
+                print(f"File {filename} already exists, skipping download.")
+            else:
+                urllib.request.urlretrieve(url, file_path)
+                print(f"Image successfully downloaded and saved as {filename}.")
+
+        return LoadImage().load_image(filename)
+
+
+class Image_Encode(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"image": ("IMAGE",)},
+            "optional": {
+                "lossless": (
+                    "BOOLEAN",
+                    {"default": False, "label_on": "yes", "label_off": "no"},
+                ),
+            },
+        }
+
+    CATEGORY = "image_utils"
+    FUNCTION = "apply"
+    RETURN_TYPES = ("IMAGE",)
+    NODE_DISPLAY_NAME = "Image Encode"
+
+    def apply(self, image, lossless=False):
+        out = encode_data(image, lossless=lossless)
+        return (out,)