bizyengine 1.2.58__py3-none-any.whl → 1.2.71__py3-none-any.whl

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,)

bizyengine/bizyair_extras/third_party_api/nodes_gemini.py

@@ -0,0 +1,403 @@
+from bizyairsdk import tensor_to_bytesio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+# FROM: https://github.com/ShmuelRonen/ComfyUI-NanoBanano/blob/9eeb8f2411fd0ff08791bdf5e24eec347456c8b8/nano_banano.py#L191
+def build_prompt_for_operation(
+    prompt,
+    operation,
+    has_references=False,
+    aspect_ratio="auto",
+    character_consistency=True,
+):
+    """Build optimized prompt based on operation type"""
+
+    auto_aspect = (
+        "keep the original image aspect ratio"
+        if has_references
+        else "use an appropriate aspect ratio"
+    )
+    aspect_instructions = {
+        "1:1": "square format",
+        "16:9": "widescreen landscape format",
+        "9:16": "portrait format",
+        "4:3": "standard landscape format",
+        "3:4": "standard portrait format",
+        "auto": auto_aspect,
+    }
+
+    base_quality = "Generate a high-quality, photorealistic image"
+    format_instruction = f"in {aspect_instructions.get(aspect_ratio, auto_aspect)}"
+
+    if operation == "generate":
+        if has_references:
+            final_prompt = f"{base_quality} inspired by the style and elements of the reference images. {prompt}. {format_instruction}."
+        else:
+            final_prompt = f"{base_quality} of: {prompt}. {format_instruction}."
+
+    elif operation == "edit":
+        if not has_references:
+            return "Error: Edit operation requires reference images"
+        # No aspect ratio for edit - preserve original image dimensions
+        final_prompt = f"Edit the provided reference image(s). {prompt}. Maintain the original composition and quality while making the requested changes."
+
+    elif operation == "style_transfer":
+        if not has_references:
+            return "Error: Style transfer requires reference images"
+        final_prompt = f"Apply the style from the reference images to create: {prompt}. Blend the stylistic elements naturally. {format_instruction}."
+
+    elif operation == "object_insertion":
+        if not has_references:
+            return "Error: Object insertion requires reference images"
+        final_prompt = f"Insert or blend the following into the reference image(s): {prompt}. Ensure natural lighting, shadows, and perspective. {format_instruction}."
+
+    if character_consistency and has_references:
+        final_prompt += " Maintain character consistency and visual identity from the reference images."
+
+    return final_prompt
+
+
+class NanoBanana(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "NanoBanana"
+    RETURN_TYPES = ("IMAGE", "STRING")
+    CATEGORY = "☁️BizyAir/External APIs/Gemini"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "operation": (
+                    ["generate", "edit", "style_transfer", "object_insertion"],
+                    {
+                        "default": "generate",
+                        "tooltip": "Choose the type of image operation",
+                    },
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "top_p": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2147483647}),
+                "max_tokens": ("INT", {"default": 8192, "min": 1, "max": 8192}),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+                "image2": ("IMAGE",),
+                "image3": ("IMAGE",),
+                "image4": ("IMAGE",),
+                "image5": ("IMAGE",),
+                "quality": (
+                    ["standard", "high"],
+                    {"default": "high", "tooltip": "Image generation quality"},
+                ),
+                "aspect_ratio": (
+                    ["1:1", "16:9", "9:16", "4:3", "3:4", "auto"],
+                    {"default": "auto", "tooltip": "Output image aspect ratio"},
+                ),
+                "character_consistency": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Maintain character consistency across edits",
+                    },
+                ),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        operation = kwargs.get("operation", "generate")
+        temperature = kwargs.get("temperature", 1.0)
+        top_p = kwargs.get("top_p", 1.0)
+        seed = kwargs.get("seed", 0)
+        max_tokens = kwargs.get("max_tokens", 8192)
+        quality = kwargs.get("quality", "high")
+        aspect_ratio = kwargs.get("aspect_ratio", "auto")
+        character_consistency = kwargs.get("character_consistency", True)
+        prompt = kwargs.get("prompt", "")
+
+        parts = []
+        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),
+            ],
+            1,
+        ):
+            if img is not None:
+                url = self.upload_file(
+                    tensor_to_bytesio(image=img, total_pixels=4096 * 4096),
+                    f"{prompt_id}_{i}.png",
+                    headers,
+                )
+                parts.append(url)
+
+        prompt = build_prompt_for_operation(
+            prompt,
+            operation,
+            has_references=len(parts) > 0,
+            aspect_ratio=aspect_ratio,
+            character_consistency=character_consistency,
+        )
+        if quality == "high":
+            prompt += " Use the highest quality settings available."
+
+        data = {
+            "urls": parts,
+            "prompt": prompt,
+            "temperature": temperature,
+            "top_p": top_p,
+            "seed": seed,
+            "max_tokens": max_tokens,
+        }
+        if aspect_ratio != "auto":
+            data["aspect_ratio"] = aspect_ratio
+        return data, "gemini-2.5-flash-image"
+
+    def handle_outputs(self, outputs):
+        text = None
+        if len(outputs[1]) > 0:
+            image = outputs[1][0]
+        else:
+            raise ValueError("No image found in response")
+        if len(outputs[2]) > 0:
+            text = outputs[2][0]
+        return (image, text)
+
+
+class NanoBananaPro(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "NanoBananaPro"
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("image", "string")
+    CATEGORY = "☁️BizyAir/External APIs/Gemini"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "operation": (
+                    ["generate", "edit", "style_transfer", "object_insertion"],
+                    {
+                        "default": "generate",
+                        "tooltip": "Choose the type of image operation",
+                    },
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "top_p": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2147483647}),
+                "max_tokens": ("INT", {"default": 32768, "min": 1, "max": 32768}),
+                "aspect_ratio": (
+                    [
+                        "1:1",
+                        "2:3",
+                        "3:2",
+                        "3:4",
+                        "4:3",
+                        "4:5",
+                        "5:4",
+                        "9:16",
+                        "16:9",
+                        "21:9",
+                        "auto",
+                    ],
+                    {"default": "auto", "tooltip": "Output image aspect ratio"},
+                ),
+                "resolution": (["1K", "2K", "4K", "auto"], {"default": "auto"}),
+            },
+            "optional": {
+                "images": ("IMAGE",),
+                "quality": (
+                    ["standard", "high"],
+                    {"default": "high", "tooltip": "Image generation quality"},
+                ),
+                "character_consistency": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "Maintain character consistency across edits",
+                    },
+                ),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        operation = kwargs.get("operation", "generate")
+        temperature = kwargs.get("temperature", 1.0)
+        top_p = kwargs.get("top_p", 1.0)
+        seed = kwargs.get("seed", 0)
+        max_tokens = kwargs.get("max_tokens", 32768)
+        quality = kwargs.get("quality", "high")
+        aspect_ratio = kwargs.get("aspect_ratio", "auto")
+        resolution = kwargs.get("resolution", "auto")
+        images = kwargs.get("images", None)
+        character_consistency = kwargs.get("character_consistency", True)
+        prompt = kwargs.get("prompt", "")
+
+        if images is not None and len(images) > 14:
+            raise ValueError("Maximum number of images is 14")
+        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)
+
+        prompt = build_prompt_for_operation(
+            prompt,
+            operation,
+            has_references=len(parts) > 0,
+            aspect_ratio=aspect_ratio,
+            character_consistency=character_consistency,
+        )
+        if quality == "high":
+            prompt += " Use the highest quality settings available."
+
+        data = {
+            "urls": parts,
+            "prompt": prompt,
+            "temperature": temperature,
+            "top_p": top_p,
+            "seed": seed,
+            "max_tokens": max_tokens,
+        }
+        if aspect_ratio != "auto":
+            data["aspect_ratio"] = aspect_ratio
+        if resolution != "auto":
+            data["resolution"] = resolution
+        return data, "gemini-3-pro-image-preview"
+
+    def handle_outputs(self, outputs):
+        text = None
+        if len(outputs[1]) > 0:
+            image = outputs[1][0]
+        else:
+            raise ValueError("No image found in response")
+        if len(outputs[2]) > 0:
+            text = outputs[2][0]
+        return (image, text)
+
+
+class NanoBananaProOfficial(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "top_p": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.05},
+                ),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 2147483647}),
+                "max_tokens": ("INT", {"default": 32768, "min": 1, "max": 32768}),
+                "aspect_ratio": (
+                    [
+                        "1:1",
+                        "2:3",
+                        "3:2",
+                        "3:4",
+                        "4:3",
+                        "4:5",
+                        "5:4",
+                        "9:16",
+                        "16:9",
+                        "21:9",
+                        "auto",
+                    ],
+                    {"default": "auto", "tooltip": "Output image aspect ratio"},
+                ),
+                "resolution": (["1K", "2K", "4K", "auto"], {"default": "auto"}),
+            },
+            "optional": {
+                "images": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("image", "string")
+    CATEGORY = "☁️BizyAir/External APIs/Gemini"
+    NODE_DISPLAY_NAME = "NanoBananaPro (Official Parameters)"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        prompt = kwargs.get("prompt", "")
+        temperature = kwargs.get("temperature", 1.0)
+        top_p = kwargs.get("top_p", 1.0)
+        seed = kwargs.get("seed", 0)
+        max_tokens = kwargs.get("max_tokens", 32768)
+        aspect_ratio = kwargs.get("aspect_ratio", "auto")
+        resolution = kwargs.get("resolution", "auto")
+        images = kwargs.get("images", None)
+        if images is not None and len(images) > 14:
+            raise ValueError("Maximum number of images is 14")
+        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 = {
+            "urls": parts,
+            "prompt": prompt,
+            "temperature": temperature,
+            "top_p": top_p,
+            "seed": seed,
+            "max_tokens": max_tokens,
+        }
+        if aspect_ratio != "auto":
+            data["aspect_ratio"] = aspect_ratio
+        if resolution != "auto":
+            data["resolution"] = resolution
+        return data, "gemini-3-pro-image-preview"
+
+    def handle_outputs(self, outputs):
+        text = None
+        if len(outputs[1]) > 0:
+            image = outputs[1][0]
+        else:
+            raise ValueError("No image found in response")
+        if len(outputs[2]) > 0:
+            text = outputs[2][0]
+        return (image, text)

bizyengine/bizyair_extras/third_party_api/nodes_gpt.py

@@ -0,0 +1,101 @@
+from bizyairsdk import tensor_to_bytesio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+class GPT_IMAGE_1_T2I_API(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "GPT Image 1 Text To Image"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    CATEGORY = "☁️BizyAir/External APIs/OpenAI"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "size": (["1:1", "2:3", "3:2"], {"default": "1:1"}),
+                "variants": ([1, 2, 4], {"default": 1}),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        prompt = kwargs.get("prompt", "")
+        size = kwargs.get("size", "1:1")
+        variants = kwargs.get("variants", 1)
+        data = {
+            "prompt": prompt,
+            "size": size,
+            "variants": variants,
+        }
+        if variants == 4:
+            data["provider"] = "KieAI"
+        return data, "gpt-image-1"
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)
+
+
+class GPT_IMAGE_EDIT_API(BizyAirTrdApiBaseNode):
+    NODE_DISPLAY_NAME = "GPT Image Edit"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    CATEGORY = "☁️BizyAir/External APIs/OpenAI"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "size": (["1:1", "2:3", "3:2"], {"default": "1:1"}),
+                "variants": ([1, 2, 4], {"default": 1}),
+            },
+        }
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        images = kwargs.get("images", None)
+        if images is None:
+            raise ValueError("Images are required")
+        prompt = kwargs.get("prompt", "")
+        size = kwargs.get("size", "1:1")
+        variants = kwargs.get("variants", 1)
+
+        urls = []
+        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,
+                )
+                urls.append(url)
+        if len(urls) == 0:
+            raise ValueError("At least one image is required")
+
+        data = {
+            "urls": urls,
+            "prompt": prompt,
+            "size": size,
+            "variants": variants,
+        }
+        if variants == 4:
+            data["provider"] = "KieAI"
+        return data, "gpt-image-1"
+
+    def handle_outputs(self, outputs):
+        images = self.combine_images(outputs[1])
+        return (images,)