bizyengine 1.2.68__py3-none-any.whl → 1.2.69__py3-none-any.whl

bizyengine/bizyair_extras/__init__.py

@@ -10,7 +10,6 @@ modules = [
     ".nodes_dataset",
     ".nodes_differential_diffusion",
     ".nodes_flux",
-    ".nodes_gemini",
     ".nodes_hunyuan3d",
     ".nodes_image_utils",
     ".nodes_ip2p",
@@ -22,19 +21,16 @@ modules = [
     ".nodes_reactor",
     ".nodes_sam2",
     ".nodes_sd3",
-    ".nodes_seedream",
     ".nodes_segment_anything",
     ".nodes_testing_utils",
     ".nodes_trellis",
     ".nodes_ultimatesdupscale",
     ".nodes_upscale_model",
     ".nodes_utils",
-    ".nodes_wan_api",
     ".nodes_wan_i2v",
     ".nodes_wan_video",
     ".route_bizyair_tools",
-    ".nodes_veo3",
-    ".nodes_sora2",
+    ".third_party_api",
 ]
 from bizyengine.core.common.utils import safe_star_import
 

bizyengine/bizyair_extras/third_party_api/__init__.py

@@ -0,0 +1,15 @@
+modules = [
+    ".nodes_hailuo",
+    ".nodes_gemini",
+    ".nodes_gpt",
+    ".nodes_kling",
+    ".nodes_doubao",
+    ".nodes_flux",
+    ".nodes_sora",
+    ".nodes_veo3",
+    ".nodes_wan_api",
+]
+from bizyengine.core.common.utils import safe_star_import
+
+for mod in modules:
+    safe_star_import(mod, package=__package__)

bizyengine/bizyair_extras/third_party_api/nodes_doubao.py

@@ -0,0 +1,404 @@
+from bizyairsdk import tensor_to_bytesio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+class Seedream4(BizyAirTrdApiBaseNode):
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    CATEGORY = "☁️BizyAir/External APIs/Doubao"
+    NODE_DISPLAY_NAME = "Seedream4"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "size": (
+                    [
+                        "1K Square (1024x1024)",
+                        "2K Square (2048x2048)",
+                        "4K Square (4096x4096)",
+                        "HD 16:9 (1920x1080)",
+                        "2K 16:9 (2560x1440)",
+                        "4K 16:9 (3840x2160)",
+                        "Portrait 9:16 (1080x1920)",
+                        "Portrait 3:4 (1536x2048)",
+                        "Landscape 4:3 (2048x1536)",
+                        "Ultra-wide 21:9 (3440x1440)",
+                        "Custom",
+                    ],
+                    {
+                        "default": "HD 16:9 (1920x1080)",
+                    },
+                ),
+                "custom_width": ("INT", {"default": 1920, "min": 1024, "max": 4096}),
+                "custom_height": ("INT", {"default": 1080, "min": 1024, "max": 4096}),
+                "model": (
+                    ["doubao-seedream-4-0-250828"],
+                    {"default": "doubao-seedream-4-0-250828"},
+                ),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+                "image2": ("IMAGE",),
+                "image3": ("IMAGE",),
+                "image4": ("IMAGE",),
+                "image5": ("IMAGE",),
+                "image6": ("IMAGE",),
+                "image7": ("IMAGE",),
+                "image8": ("IMAGE",),
+                "image9": ("IMAGE",),
+                "image10": ("IMAGE",),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        model = kwargs.get("model", "doubao-seedream-4-0-250828")
+        prompt = kwargs.get("prompt", "")
+        size = kwargs.get("size", "1K Square (1024x1024)")
+
+        match size:
+            case "1K Square (1024x1024)":
+                width = 1024
+                height = 1024
+            case "2K Square (2048x2048)":
+                width = 2048
+                height = 2048
+            case "4K Square (4096x4096)":
+                width = 4096
+                height = 4096
+            case "HD 16:9 (1920x1080)":
+                width = 1920
+                height = 1080
+            case "2K 16:9 (2560x1440)":
+                width = 2560
+                height = 1440
+            case "4K 16:9 (3840x2160)":
+                width = 3840
+                height = 2160
+            case "Portrait 9:16 (1080x1920)":
+                width = 1080
+                height = 1920
+            case "Portrait 3:4 (1536x2048)":
+                width = 1536
+                height = 2048
+            case "Landscape 4:3 (2048x1536)":
+                width = 2048
+                height = 1536
+            case "Ultra-wide 21:9 (3440x1440)":
+                width = 3440
+                height = 1440
+            case "Custom":
+                width = kwargs.get("custom_width", 1920)
+                height = kwargs.get("custom_height", 1080)
+
+            case _:
+                raise ValueError(f"Invalid size: {size}")
+
+        sizeStr = f"{width}x{height}"
+
+        images = []
+        total_size = 0
+        for i, img in enumerate(
+            [
+                kwargs.get("image", None),
+                kwargs.get("image2", None),
+                kwargs.get("image3", None),
+                kwargs.get("image4", None),
+                kwargs.get("image5", None),
+                kwargs.get("image6", None),
+                kwargs.get("image7", None),
+                kwargs.get("image8", None),
+                kwargs.get("image9", None),
+                kwargs.get("image10", None),
+            ],
+            1,
+        ):
+            if img is not None:
+                # 都当作PNG就行
+                bio = tensor_to_bytesio(image=img, total_pixels=4096 * 4096)
+                length = bio.getbuffer().nbytes
+                if length > 10 * 1024 * 1024:
+                    raise ValueError(
+                        "Image size is too large, Seedream 4.0 only supports up to 10MB"
+                    )
+                total_size += length
+                if total_size > 50 * 1024 * 1024:
+                    raise ValueError(
+                        "Total size of images is too large, BizyAir only supports up to 50MB"
+                    )
+                images.append(self.upload_file(bio, f"{prompt_id}_{i}.png", headers))
+
+        data = {
+            "prompt": prompt,
+            "size": sizeStr,
+            "image": images,
+            "model": model,
+            "watermark": False,
+            "response_format": "url",
+        }
+
+        return data, model
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)
+
+
+class Seededit3(BizyAirTrdApiBaseNode):
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "☁️BizyAir/External APIs/Doubao"
+    NODE_DISPLAY_NAME = "Seededit3"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (
+                    ["doubao-seededit-3-0-i2i-250628"],
+                    {"default": "doubao-seededit-3-0-i2i-250628"},
+                ),
+                "seed": ("INT", {"default": -1, "min": -1, "max": 2147483647}),
+                "guidance_scale": ("FLOAT", {"default": 5.5, "min": 1.0, "max": 10.0}),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        model = kwargs.get("model", "doubao-seededit-3-0-i2i-250628")
+        prompt = kwargs.get("prompt", "")
+        image = kwargs.get("image", None)
+        seed = kwargs.get("seed", -1)
+        guidance_scale = kwargs.get("guidance_scale", 5.5)
+        if image is None:
+            raise ValueError("Image is required")
+        # 上传图片
+        image_url = self.upload_file(
+            tensor_to_bytesio(image=image, total_pixels=4096 * 4096),
+            f"{prompt_id}.png",
+            headers,
+        )
+        data = {
+            "prompt": prompt,
+            "model": model,
+            "image": image_url,
+            "seed": seed,
+            "guidance_scale": guidance_scale,
+            "size": "adaptive",
+            "response_format": "url",
+            "watermark": False,
+        }
+        return data, model
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)
+
+
+class Seedance_1_0_T2V_API(BizyAirTrdApiBaseNode):
+    RETURN_TYPES = ("VIDEO",)
+    RETURN_NAMES = ("video",)
+    CATEGORY = "☁️BizyAir/External APIs/Doubao"
+    NODE_DISPLAY_NAME = "Seedance 1.0 Pro Text To Video"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (
+                    [
+                        "doubao-seedance-1-0-pro-250528",
+                        "doubao-seedance-1-0-pro-fast-251015",
+                    ],
+                    {"default": "doubao-seedance-1-0-pro-250528"},
+                ),
+                "resolution": (
+                    ["480p", "720p", "1080p"],
+                    {
+                        "default": "1080p",
+                        "tooltip": "分辨率+比例共同决定视频尺寸，具体尺寸请参考官方文档说明",
+                    },
+                ),
+                "ratio": (
+                    ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"],
+                    {
+                        "default": "adaptive",
+                        "tooltip": "比例+分辨率共同决定视频尺寸，具体尺寸请参考官方文档说明",
+                    },
+                ),
+                "duration": ("INT", {"default": 12, "min": 2, "max": 12}),
+                "fps": (
+                    [24],
+                    {
+                        "default": 24,
+                        "tooltip": "帧率固定24",
+                    },
+                ),
+                "camerafixed": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "平台可能在提示词中追加固定摄像机指令（效果不保证） ",
+                    },
+                ),
+                "seed": ("INT", {"default": -1, "min": -1, "max": 2147483647}),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        model = kwargs.get("model", "doubao-seedance-1-0-pro-250528")
+        prompt = kwargs.get("prompt", "")
+        resolution = kwargs.get("resolution", "1080p")
+        ratio = kwargs.get("ratio", "adaptive")
+        duration = kwargs.get("duration", 12)
+        camerafixed = kwargs.get("camerafixed", False)
+        seed = kwargs.get("seed", -1)
+        if prompt is None or prompt.strip() == "":
+            raise ValueError("Prompt is required")
+        data = {
+            "prompt": prompt,
+            "model": model,
+            "resolution": resolution,
+            "ratio": ratio,
+            "duration": duration,
+            "camerafixed": camerafixed,
+            "seed": seed,
+            "watermark": False,
+            "fps": 24,
+        }
+        return data, "doubao-seedance-1-0"
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)
+
+
+class Seedance_1_0_I2V_API(BizyAirTrdApiBaseNode):
+    RETURN_TYPES = ("VIDEO",)
+    RETURN_NAMES = ("video",)
+    CATEGORY = "☁️BizyAir/External APIs/Doubao"
+    NODE_DISPLAY_NAME = "Seedance 1.0 Pro Image To Video"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "first_frame_image": ("IMAGE",),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (
+                    [
+                        "doubao-seedance-1-0-pro-250528",
+                        "doubao-seedance-1-0-pro-fast-251015",
+                    ],
+                    {"default": "doubao-seedance-1-0-pro-250528"},
+                ),
+                "resolution": (
+                    ["480p", "720p", "1080p"],
+                    {
+                        "default": "1080p",
+                        "tooltip": "分辨率+比例共同决定视频尺寸，具体尺寸请参考官方文档说明",
+                    },
+                ),
+                "ratio": (
+                    ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"],
+                    {
+                        "default": "adaptive",
+                        "tooltip": "比例+分辨率共同决定视频尺寸，具体尺寸请参考官方文档说明",
+                    },
+                ),
+                "duration": ("INT", {"default": 12, "min": 2, "max": 12}),
+                "fps": (
+                    [24],
+                    {
+                        "default": 24,
+                        "tooltip": "帧率固定24",
+                    },
+                ),
+                "camerafixed": (
+                    "BOOLEAN",
+                    {
+                        "default": False,
+                        "tooltip": "平台可能在提示词中追加固定摄像机指令（效果不保证） ",
+                    },
+                ),
+                "seed": ("INT", {"default": -1, "min": -1, "max": 2147483647}),
+            },
+            "optional": {
+                "last_frame_image": ("IMAGE",),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        model = kwargs.get("model", "doubao-seedance-1-0-pro-250528")
+        prompt = kwargs.get("prompt", "")
+        resolution = kwargs.get("resolution", "1080p")
+        ratio = kwargs.get("ratio", "adaptive")
+        duration = kwargs.get("duration", 12)
+        camerafixed = kwargs.get("camerafixed", False)
+        seed = kwargs.get("seed", -1)
+        first_frame_image = kwargs.get("first_frame_image", None)
+        last_frame_image = kwargs.get("last_frame_image", None)
+        if first_frame_image is None:
+            raise ValueError("First frame image is required")
+        if (
+            last_frame_image is not None
+            and model == "doubao-seedance-1-0-pro-fast-251015"
+        ):
+            raise ValueError(
+                "Last frame image is not supported for doubao-seedance-1-0-pro-fast-251015"
+            )
+        first_frame_image_url = self.upload_file(
+            tensor_to_bytesio(image=first_frame_image, total_pixels=4096 * 4096),
+            f"{prompt_id}_first.png",
+            headers,
+        )
+        data = {
+            "prompt": prompt,
+            "model": model,
+            "resolution": resolution,
+            "ratio": ratio,
+            "duration": duration,
+            "camerafixed": camerafixed,
+            "seed": seed,
+            "watermark": False,
+            "fps": 24,
+            "first_frame_image": first_frame_image_url,
+        }
+        if last_frame_image is not None:
+            last_frame_image_url = self.upload_file(
+                tensor_to_bytesio(image=last_frame_image, total_pixels=4096 * 4096),
+                f"{prompt_id}_last.png",
+                headers,
+            )
+            data["last_frame_image"] = last_frame_image_url
+        return data, "doubao-seedance-1-0"
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)

bizyengine/bizyair_extras/third_party_api/nodes_flux.py

@@ -0,0 +1,173 @@
+from bizyairsdk import tensor_to_bytesio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+class Flux_Kontext_API(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "Flux Kontext API"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "☁️BizyAir/External APIs/Flux"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (
+                    ["flux-kontext-pro", "flux-kontext-max"],
+                    {"default": "flux-kontext-pro"},
+                ),
+                "aspect_ratio": (
+                    ["21:9", "16:9", "4:3", "1:1", "3:4", "9:16"],
+                    {"default": "16:9"},
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2147483647}),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        prompt = kwargs.get("prompt", "")
+        image = kwargs.get("image", None)
+        model = kwargs.get("model", "flux-kontext-pro")
+        aspect_ratio = kwargs.get("aspect_ratio", "16:9")
+        seed = kwargs.get("seed", 0)
+        data = {
+            "prompt": prompt,
+            "model": model,
+            "aspect_ratio": aspect_ratio,
+            "seed": seed,
+        }
+        if image is not None:
+            image_url = self.upload_file(
+                tensor_to_bytesio(image=image, total_pixels=4096 * 4096),
+                f"{prompt_id}.png",
+                headers,
+            )
+            data["image"] = image_url
+        return data, "flux-kontext"
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)
+
+
+class Flux_2_API(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "Flux 2 API"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "☁️BizyAir/External APIs/Flux"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (
+                    ["flux-2-pro", "flux-2-flex"],
+                    {"default": "flux-2-pro"},
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2147483647}),
+                "width": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 0,
+                        "step": 16,
+                        "tooltip": "必须为16的倍数，0代表使用输入图片宽度",
+                    },
+                ),
+                "height": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 0,
+                        "step": 16,
+                        "tooltip": "必须为16的倍数，0代表使用输入图片高度",
+                    },
+                ),
+                "safety_tolerance": (
+                    "INT",
+                    {"min": 0, "max": 5, "default": 2, "tooltip": "值越大越宽松"},
+                ),
+                "guidance": (
+                    "FLOAT",
+                    {"min": 1.5, "max": 10, "default": 4.5, "tooltip": "仅flex支持"},
+                ),
+                "steps": (
+                    "INT",
+                    {"min": 1, "max": 50, "default": 50, "tooltip": "仅flex支持"},
+                ),
+            },
+            "optional": {
+                "images": ("IMAGE",),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        images = kwargs.get("images", None)
+        prompt = kwargs.get("prompt", "")
+        model = kwargs.get("model", "flux-2-pro")
+        width = kwargs.get("width", 1024)
+        height = kwargs.get("height", 1024)
+        safety_tolerance = kwargs.get("safety_tolerance", 2)
+        guidance = kwargs.get("guidance", 4.5)
+        steps = kwargs.get("steps", 50)
+        seed = kwargs.get("seed", 0)
+        if images is not None and len(images) > 8 and model == "flux-2-pro":
+            raise ValueError("Maximum number of images is 8 for flux-2-pro")
+        if images is not None and len(images) > 10 and model == "flux-2-flex":
+            raise ValueError("Maximum number of images is 10 for flux-2-flex")
+        if width < 0 or height < 0:
+            raise ValueError(
+                "Width and height must be greater than 0, or supply 0 value to use input image's original size"
+            )
+        if safety_tolerance < 0 or safety_tolerance > 6:
+            raise ValueError("Safety tolerance must be between 0 and 6")
+        if guidance < 1.5 or guidance > 10:
+            raise ValueError("Guidance must be between 1.5 and 10")
+        if steps < 1 or steps > 50:
+            raise ValueError("Steps must be between 1 and 50")
+        parts = []
+        for batch_number, img in enumerate(images if images is not None else []):
+            if img is not None:
+                url = self.upload_file(
+                    tensor_to_bytesio(image=img, total_pixels=4096 * 4096),
+                    f"{prompt_id}_{batch_number}.png",
+                    headers,
+                )
+                parts.append(url)
+        data = {
+            "prompt": prompt,
+            "model": model,
+            "safety_tolerance": safety_tolerance,
+            "guidance": guidance,
+            "steps": steps,
+            "seed": seed,
+        }
+        if width > 0:
+            data["width"] = width
+        if height > 0:
+            data["height"] = height
+        if len(parts) > 0:
+            data["urls"] = parts
+        return data, "flux-2"
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)