bizyengine 0.4.2__py3-none-any.whl

bizyengine/bizyair_extras/nodes_testing_utils.py

@@ -0,0 +1,139 @@
+"""
+pip install numpy scikit-image pillow
+
+"""
+
+import os
+import random
+
+import folder_paths
+import numpy as np
+from bizyengine.core import NODE_CLASS_MAPPINGS
+from bizyengine.core.image_utils import decode_data, encode_data
+from PIL import Image
+
+
+class ImagesTest:
+    # https://docs.comfy.org/essentials/custom_node_images_and_masks#images
+    def __init__(self):
+        self.output_dir = folder_paths.get_temp_directory()
+        self.type = "temp"
+        self.prefix_append = "_temp_" + "".join(
+            random.choice("abcdefghijklmnopqrstupvxyz") for x in range(5)
+        )
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images1": ("IMAGE",),
+                "images2": ("IMAGE",),
+                "ssim_threshold": ("STRING", {"default": "0.9"}),
+                "raise_if_diff": (["enable", "disable"],),
+                "image_id": ("STRING", {"default": "ComfyUI"}),
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "save_images"
+
+    OUTPUT_NODE = True
+
+    CATEGORY = "images_test"
+
+    def save_images(
+        self,
+        images1,
+        images2,
+        ssim_threshold: float,
+        raise_if_diff: str,
+        image_id="ComfyUI",
+        prompt=None,
+        extra_pnginfo=None,
+    ):
+        from skimage.metrics import structural_similarity as ssim
+
+        assert len(images1) == len(images2)
+        filename_prefix = image_id[:]
+        filename_prefix += self.prefix_append
+        (
+            full_output_folder,
+            filename,
+            counter,
+            subfolder,
+            filename_prefix,
+        ) = folder_paths.get_save_image_path(
+            filename_prefix,
+            self.output_dir,
+            images1[0].shape[1],
+            images1[0].shape[0],
+        )
+        results = list()
+        for image1, image2 in zip(images1, images2):
+
+            # image diff
+            image = image1.cpu() - image2.cpu()
+
+            i = 255.0 * image.cpu().numpy()
+            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+            metadata = None
+            file = f"{filename}_{counter:05}_.png"
+            img.save(
+                os.path.join(full_output_folder, file),
+                pnginfo=metadata,
+                compress_level=4,
+            )
+            results.append(
+                {"filename": file, "subfolder": subfolder, "type": self.type}
+            )
+            counter += 1
+
+            max_diff = image.abs().max().item()
+
+            img1 = self.image_to_numpy(image1)
+            img2 = self.image_to_numpy(image2)
+            ssim = ssim(img1, img2, channel_axis=2)
+
+            print(
+                "\033[91m"
+                f"[ShowImageDiff {image_id}] Max value of diff is {max_diff}, image simularity is {ssim:.6f}"
+                + "\033[0m"
+            )
+
+            if raise_if_diff == "enable":
+                assert ssim > float(
+                    ssim_threshold
+                ), f"Image diff is too large, ssim is {ssim}, "
+
+        return {"ui": {"images": results}}
+
+    def image_to_numpy(self, image):
+        i = 255.0 * image.cpu().numpy()
+        img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+        return np.array(img)
+
+
+class ImageEncodeDecodeTest:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"image": ("IMAGE",)},
+            "optional": {
+                "lossless": (
+                    "BOOLEAN",
+                    {"default": False, "label_on": "yes", "label_off": "no"},
+                ),
+            },
+        }
+
+    CATEGORY = "images_test"
+    FUNCTION = "test"
+    RETURN_TYPES = ("IMAGE",)
+
+    def test(self, image, lossless=False):
+        return (decode_data(encode_data(image, lossless=lossless)),)
+
+
+NODE_CLASS_MAPPINGS["Tools_ImagesTest"] = ImagesTest
+NODE_CLASS_MAPPINGS["Tools_ImageEncodeDecodeTest"] = ImageEncodeDecodeTest

bizyengine/bizyair_extras/nodes_trellis.py

@@ -0,0 +1,199 @@
+import os
+import uuid
+
+import folder_paths
+import requests
+import torch
+from bizyengine.core import BizyAirBaseNode
+
+
+class BizyAir_IF_TrellisCheckpointLoader(BizyAirBaseNode):
+    """
+    Node to manage the loading of the TRELLIS model.
+    Follows ComfyUI conventions for model management.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """Define input types with device-specific options."""
+        device_options = ["cuda"]
+
+        return {
+            "required": {
+                "model_name": (["TRELLIS-image-large"],),
+                "dinov2_model": (
+                    ["dinov2_vitl14_reg", "dinov2_vitg14_reg"],
+                    {
+                        "default": "dinov2_vitl14_reg",
+                        "tooltip": "Select the Dinov2 model to use for the image to 3D conversion. Smaller models work but better results with larger models.",
+                    },
+                ),
+                "use_fp16": ("BOOLEAN", {"default": True}),
+                "attn_backend": (
+                    ["sage", "xformers", "flash_attn", "sdpa", "naive"],
+                    {
+                        "default": "sage",
+                        "tooltip": "Select the attention backend to use for the image to 3D conversion. Sage is experimental but faster",
+                    },
+                ),
+                "smooth_k": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Smooth k for sage attention. This is a hyperparameter that controls the smoothness of the attention distribution. It is a boolean value that determines whether to use smooth k or not. Smooth k is a hyperparameter that controls the smoothness of the attention distribution. It is a boolean value that determines whether to use smooth k or not.",
+                    },
+                ),
+                "spconv_algo": (
+                    ["implicit_gemm", "native"],
+                    {
+                        "default": "implicit_gemm",
+                        "tooltip": "Select the spconv algorithm to use for the image to 3D conversion. Implicit gemm is the best but slower. Native is the fastest but less accurate.",
+                    },
+                ),
+                "main_device": (device_options, {"default": device_options[0]}),
+            },
+        }
+
+    RETURN_TYPES = ("TRELLIS_MODEL",)
+    RETURN_NAMES = ("model",)
+    CATEGORY = "☁️BizyAir/Trellis"
+    NODE_DISPLAY_NAME = "☁️BizyAir Load Trellis"
+
+
+class BizyAir_IF_TrellisImageTo3D(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("TRELLIS_MODEL",),
+                "mode": (
+                    ["single", "multi"],
+                    {
+                        "default": "single",
+                        "tooltip": "Mode. single is a single image. with multi you can provide multiple reference angles for the 3D model",
+                    },
+                ),
+                "images": ("IMAGE", {"list": True}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0x7FFFFFFF}),
+                "ss_guidance_strength": (
+                    "FLOAT",
+                    {"default": 7.5, "min": 0.0, "max": 12.0, "step": 0.1},
+                ),
+                "ss_sampling_steps": ("INT", {"default": 12, "min": 1, "max": 50}),
+                "slat_guidance_strength": (
+                    "FLOAT",
+                    {"default": 3.0, "min": 0.0, "max": 12.0, "step": 0.1},
+                ),
+                "slat_sampling_steps": ("INT", {"default": 12, "min": 1, "max": 50}),
+                "multimode": (
+                    ["stochastic", "multidiffusion"],
+                    {"default": "stochastic"},
+                ),
+            },
+            "optional": {
+                "masks": ("MASK", {"list": True}),
+            },
+        }
+
+    RETURN_TYPES = (
+        "trellis_gaussian",
+        "trellis_mesh",
+    )
+    CATEGORY = "☁️BizyAir/Trellis"
+    NODE_DISPLAY_NAME = "☁️BizyAir Trellis Predict"
+    OUTPUT_NODE = True
+
+
+class BizyAir_Trans3D2GlbFile(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "trellis_gaussian": ("trellis_gaussian", {"forceInput": True}),
+                "trellis_mesh": ("trellis_mesh", {"forceInput": True}),
+                "mesh_simplify": (
+                    "FLOAT",
+                    {
+                        "default": 0.95,
+                        "min": 0.9,
+                        "max": 1.0,
+                        "step": 0.01,
+                        "tooltip": "Simplify the mesh. the lower the value more polygons the mesh will have",
+                    },
+                ),
+                "texture_size": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 512,
+                        "max": 2048,
+                        "step": 512,
+                        "tooltip": "Texture size. the higher the value the more detailed the texture will be",
+                    },
+                ),
+                "texture_mode": (
+                    ["blank", "fast", "opt"],
+                    {
+                        "default": "fast",
+                        "tooltip": "Texture mode. blank is no texture. fast is a fast texture. opt is a high quality texture",
+                    },
+                ),
+                "save_glb": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Save the GLB file this is the 3D model",
+                    },
+                ),
+                "save_texture": (
+                    "BOOLEAN",
+                    {"default": False, "tooltip": "Save the texture file"},
+                ),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/Trellis"
+    NODE_DISPLAY_NAME = "☁️BizyAir Generate Glb With Trellis"
+    RETURN_TYPES = ("STRING", "IMAGE")
+    RETURN_NAMES = ("url", "texture_image")
+
+
+class BizyAirDownloadFile(BizyAirBaseNode):
+    NODE_DISPLAY_NAME = "☁️BizyAir Download File"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "url": ("STRING", {"default": ""}),
+                "file_name": ("STRING", {"default": "default"}),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/Trellis"
+    FUNCTION = "main"
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("path",)
+    OUTPUT_NODE = True
+    OUTPUT_IS_LIST = (False,)
+
+    def main(self, url, file_name):
+        assert url is not None
+        file_name = file_name + ".glb"
+        out_dir = os.path.join(folder_paths.get_output_directory(), "trellis_output")
+        os.makedirs(out_dir, exist_ok=True)
+        local_path = os.path.join(out_dir, file_name)
+        output = os.path.join("trellis_output", file_name)
+        response = requests.get(url)
+        if response.status_code == 200:
+            with open(local_path, "wb") as file:
+                file.write(response.content)
+            print("download finished in {}".format(local_path))
+        else:
+            print(f"download error: {response.status_code}")
+        return (output,)
+
+    @classmethod
+    def IS_CHANGED(self, url, file_name, *args, **kwargs):
+        return uuid.uuid4().hex

bizyengine/bizyair_extras/nodes_ultimatesdupscale.py

@@ -0,0 +1,137 @@
+from enum import Enum
+
+import comfy
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO
+from bizyengine.core.data_types import CONDITIONING, MODEL, UPSCALE_MODEL, VAE
+
+
+class USDUMode(Enum):
+    LINEAR = 0
+    CHESS = 1
+    NONE = 2
+
+
+class USDUSFMode(Enum):
+    NONE = 0
+    BAND_PASS = 1
+    HALF_TILE = 2
+    HALF_TILE_PLUS_INTERSECTIONS = 3
+
+
+MAX_RESOLUTION = 8192
+# The modes available for Ultimate SD Upscale
+MODES = {
+    "Linear": USDUMode.LINEAR,
+    "Chess": USDUMode.CHESS,
+    "None": USDUMode.NONE,
+}
+# The seam fix modes
+SEAM_FIX_MODES = {
+    "None": USDUSFMode.NONE,
+    "Band Pass": USDUSFMode.BAND_PASS,
+    "Half Tile": USDUSFMode.HALF_TILE,
+    "Half Tile + Intersections": USDUSFMode.HALF_TILE_PLUS_INTERSECTIONS,
+}
+
+
+def USDU_base_inputs():
+    required = [
+        ("image", ("IMAGE",)),
+        # Sampling Params
+        ("model", (MODEL,)),
+        ("positive", (CONDITIONING,)),
+        ("negative", (CONDITIONING,)),
+        ("vae", (VAE,)),
+        ("upscale_by", ("FLOAT", {"default": 2, "min": 0.05, "max": 4, "step": 0.05})),
+        ("seed", ("INT", {"default": 0, "min": 0, "max": 0xFFFFFFFFFFFFFFFF})),
+        ("steps", ("INT", {"default": 20, "min": 1, "max": 10000, "step": 1})),
+        ("cfg", ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0})),
+        ("sampler_name", (comfy.samplers.KSampler.SAMPLERS,)),
+        ("scheduler", (comfy.samplers.KSampler.SCHEDULERS,)),
+        ("denoise", ("FLOAT", {"default": 0.2, "min": 0.0, "max": 1.0, "step": 0.01})),
+        # Upscale Params
+        ("upscale_model", (UPSCALE_MODEL,)),
+        ("mode_type", (list(MODES.keys()),)),
+        (
+            "tile_width",
+            ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
+        ),
+        (
+            "tile_height",
+            ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
+        ),
+        ("mask_blur", ("INT", {"default": 8, "min": 0, "max": 64, "step": 1})),
+        (
+            "tile_padding",
+            ("INT", {"default": 32, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+        ),
+        # Seam fix params
+        ("seam_fix_mode", (list(SEAM_FIX_MODES.keys()),)),
+        (
+            "seam_fix_denoise",
+            ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+        ),
+        (
+            "seam_fix_width",
+            ("INT", {"default": 64, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+        ),
+        ("seam_fix_mask_blur", ("INT", {"default": 8, "min": 0, "max": 64, "step": 1})),
+        (
+            "seam_fix_padding",
+            ("INT", {"default": 16, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
+        ),
+        # Misc
+        ("force_uniform_tiles", ("BOOLEAN", {"default": True})),
+        ("tiled_decode", ("BOOLEAN", {"default": False})),
+    ]
+
+    optional = []
+
+    return required, optional
+
+
+def prepare_inputs(required: list, optional: list = None):
+    inputs = {}
+    if required:
+        inputs["required"] = {}
+        for name, type in required:
+            inputs["required"][name] = type
+    if optional:
+        inputs["optional"] = {}
+        for name, type in optional:
+            inputs["optional"][name] = type
+    return inputs
+
+
+def remove_input(inputs: list, input_name: str):
+    for i, (n, _) in enumerate(inputs):
+        if n == input_name:
+            del inputs[i]
+            break
+
+
+def rename_input(inputs: list, old_name: str, new_name: str):
+    for i, (n, t) in enumerate(inputs):
+        if n == old_name:
+            inputs[i] = (new_name, t)
+            break
+
+
+class UltimateSDUpscale(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        required, optional = USDU_base_inputs()
+        return prepare_inputs(required, optional)
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "upscale"
+    CATEGORY = "image/upscaling"
+
+    def upscale(self, **kwargs):
+        model: BizyAirNodeIO = kwargs.get("model")
+        new_model = model.copy(self.assigned_id)
+        new_model.add_node_data(
+            class_type="UltimateSDUpscale",
+            inputs=kwargs,
+        )
+        return new_model.send_request()

bizyengine/bizyair_extras/nodes_upscale_model.py

@@ -0,0 +1,32 @@
+import bizyengine.core.path_utils as folder_paths
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO
+from bizyengine.core.data_types import UPSCALE_MODEL
+
+
+class UpscaleModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model_name": (folder_paths.get_filename_list("upscale_models"),),
+            }
+        }
+
+    RETURN_TYPES = (UPSCALE_MODEL,)
+    # FUNCTION = "load_model"
+    CATEGORY = "loaders"
+
+
+class ImageUpscaleWithModel(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "upscale_model": (UPSCALE_MODEL,),
+                "image": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    # FUNCTION = "upscale"
+    CATEGORY = "image/upscaling"

bizyengine/bizyair_extras/nodes_wan_video.py

@@ -0,0 +1,49 @@
+from bizyengine.core import BizyAirBaseNode
+
+
+class Wan_Model_Loader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "ckpt_name": (("Wan2.1-T2V-1.3B",),),
+            }
+        }
+
+    RETURN_TYPES = ("WAN_MODEL",)
+    RETURN_NAMES = ("model",)
+    CATEGORY = "WanT2V"
+
+
+class Wan_T2V_Pipeline(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("WAN_MODEL",),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "Two anthropomorphic cats in comfy boxing gear and bright gloves fight intensely on a spotlighted stage.",
+                    },
+                ),
+                "resolution": (
+                    ["480*832", "832*480", "624*624", "704*544", "544*704"],
+                    {"default": "480*832"},
+                ),
+                "sampling_steps": ("INT", {"default": 50, "min": 1, "max": 50}),
+                "guidance_scale": ("FLOAT", {"default": 6.0, "min": 0, "max": 20}),
+                "shift_scale": ("FLOAT", {"default": 8.0, "min": 0, "max": 20}),
+                "seed": ("INT", {"default": -1, "min": -1, "max": 0xFFFFFFFFFFFFFFFF}),
+                "negative_prompt": (
+                    "STRING",
+                    {"multiline": True, "default": "Low quality, blurry"},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("video_url",)
+    CATEGORY = "WanT2V"
+    # FUNCTION = "generate_video"

bizyengine/bizyair_extras/oauth_callback/main.py

@@ -0,0 +1,118 @@
+import argparse
+import asyncio
+import json
+
+import aiohttp
+from aiohttp import web
+
+
+# Set up command-line argument parsing
+def parse_arguments():
+    parser = argparse.ArgumentParser(description="OAuth Callback Server")
+    parser.add_argument(
+        "--account_endpoint",
+        type=str,
+        default="https://account.siliconflow.cn",
+        help="The account endpoint URL",
+    )
+    parser.add_argument(
+        "--cloud_endpoint",
+        type=str,
+        default="https://cloud.siliconflow.cn",
+        help="The cloud endpoint URL",
+    )
+    parser.add_argument(
+        "--client_id",
+        type=str,
+        default="SFaJLLq0y6CAMoyDm81aMu",
+        help="The client ID for OAuth",
+    )
+    parser.add_argument(
+        "--secret",
+        type=str,
+        required=True,
+        help="The secret for OAuth",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8080,
+        help="The port to run the server on",
+    )
+
+    return parser.parse_args()
+
+
+args = parse_arguments()
+ACCOUNT_ENDPOINT = args.account_endpoint
+CLOUD_ENDPOINT = args.cloud_endpoint
+client_id = args.client_id
+secret = args.secret
+port = args.port  # Added the port argument
+
+
+async def fetch_api_key(request):
+    code = request.rel_url.query.get("code")
+
+    if not code:
+        return web.Response(text="Missing 'code' parameter", status=400)
+
+    token_fetch_url = f"{ACCOUNT_ENDPOINT}/api/open/oauth"
+
+    # Prepare the payload
+    payload = {"clientId": client_id, "secret": secret, "code": code}
+
+    async with aiohttp.ClientSession() as session:
+        # Make the first POST request to fetch the token
+        async with session.post(token_fetch_url, json=payload) as response:
+            if not response.ok:
+                return web.Response(text="Failed to fetch access token", status=500)
+
+            token_json = await response.json()
+            access_token = (
+                token_json["data"]["access_token"] if token_json.get("status") else None
+            )
+
+            if not access_token:
+                return web.Response(text="Failed to retrieve access token", status=500)
+
+            print("access_token", access_token)
+
+            api_key_url = f"{CLOUD_ENDPOINT}/api/oauth/apikeys"
+            headers = {"Authorization": f"token {access_token}"}
+
+            # Make the second POST request to fetch API keys
+            async with session.post(api_key_url, headers=headers) as api_key_response:
+                api_keys_data = await api_key_response.json()
+                print("apiKeysData", api_keys_data)
+
+                if api_keys_data.get("data"):
+                    return web.Response(
+                        text=f"""
+                        <html>
+                        <head>
+                            <title>BizyAir</title>
+                        </head>
+                        <body>
+                            <h1>Just a moment...</h1>
+                            <script>
+                                window.opener.postMessage({json.dumps(api_keys_data["data"])}, '*');
+                            </script>
+                        </body>
+                        </html>
+                        """,
+                        content_type="text/html",
+                    )
+                else:
+                    return web.Response(text="Failed to fetch API key", status=500)
+
+
+async def init_app():
+    app = web.Application()
+    app.router.add_get("/bizyair/oauth_callback", fetch_api_key)
+    return app
+
+
+if __name__ == "__main__":
+    app = asyncio.run(init_app())
+    web.run_app(app, port=port)  # Use the port argument here

bizyengine/core/__init__.py

@@ -0,0 +1,8 @@
+import bizyengine.core.path_utils as path_utils
+from bizyengine.core.common import set_api_key, validate_api_key
+from bizyengine.core.nodes_base import (
+    NODE_CLASS_MAPPINGS,
+    NODE_DISPLAY_NAME_MAPPINGS,
+    BizyAirBaseNode,
+)
+from bizyengine.core.nodes_io import BizyAirNodeIO, create_node_data

bizyengine/core/commands/__init__.py

@@ -0,0 +1 @@
+from . import invoker