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

bizyengine/bizyair_extras/third_party_api/nodes_veo3.py

@@ -0,0 +1,193 @@
+from bizyairsdk import tensor_to_bytesio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+class Veo_V3_1_I2V_API(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "first_frame_image": ("IMAGE", {"tooltip": "首帧图片"}),
+                "model": (["veo3.1-fast", "veo3.1-pro"], {"default": "veo3.1-fast"}),
+            },
+            "optional": {
+                "last_frame_image": ("IMAGE", {"tooltip": "尾帧图片"}),
+                "aspect_ratio": (
+                    ["9:16", "16:9"],
+                    {"default": "16:9"},
+                ),
+            },
+        }
+
+    NODE_DISPLAY_NAME = "Veo3.1 Image To Video"
+    RETURN_TYPES = ("VIDEO",)
+    RETURN_NAMES = ("video",)
+    CATEGORY = "☁️BizyAir/External APIs/Veo"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        # 参数
+        model = kwargs.get("model", "veo3.1-fast")
+        prompt = kwargs.get("prompt", "")
+        aspect_ratio = kwargs.get("aspect_ratio", "16:9")
+        first_frame_image = kwargs.get("first_frame_image", None)
+        last_frame_image = kwargs.get("last_frame_image", None)
+
+        if prompt is None or prompt.strip() == "":
+            raise ValueError("Prompt is required")
+
+        # 上传图片
+        if first_frame_image is None:
+            raise ValueError("First frame image is required")
+        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 = {
+            "aspect_ratio": aspect_ratio,
+            "model": model,
+            "prompt": prompt,
+            "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, "veo3.1"
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)
+
+
+class Veo_V3_1_I2V_REF_API(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "ref_image_1": ("IMAGE", {"tooltip": "参考图片1"}),
+                "model": (["veo3.1-fast"], {"default": "veo3.1-fast"}),
+            },
+            "optional": {
+                "ref_image_2": ("IMAGE", {"tooltip": "参考图片2"}),
+                "ref_image_3": ("IMAGE", {"tooltip": "参考图片3"}),
+                "aspect_ratio": (["16:9"], {"default": "16:9"}),
+            },
+        }
+
+    NODE_DISPLAY_NAME = "Veo3.1 Image To Video (Reference Images)"
+    RETURN_TYPES = ("VIDEO",)
+    RETURN_NAMES = ("video",)
+    CATEGORY = "☁️BizyAir/External APIs/Veo"
+    FUNCTION = "api_call"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        # 参数
+        model = kwargs.get("model", "veo3.1-fast")
+        prompt = kwargs.get("prompt", "")
+        aspect_ratio = kwargs.get("aspect_ratio", "16:9")
+        ref_image_1 = kwargs.get("ref_image_1", None)
+        ref_image_2 = kwargs.get("ref_image_2", None)
+        ref_image_3 = kwargs.get("ref_image_3", None)
+
+        if prompt is None or prompt.strip() == "":
+            raise ValueError("Prompt is required")
+
+        # 上传图片
+        ref_images = []
+        if ref_image_1 is not None:
+            ref_image_1_url = self.upload_file(
+                tensor_to_bytesio(image=ref_image_1, total_pixels=4096 * 4096),
+                f"{prompt_id}_ref_1.png",
+                headers,
+            )
+            ref_images.append(ref_image_1_url)
+        if ref_image_2 is not None:
+            ref_image_2_url = self.upload_file(
+                tensor_to_bytesio(image=ref_image_2, total_pixels=4096 * 4096),
+                f"{prompt_id}_ref_2.png",
+                headers,
+            )
+            ref_images.append(ref_image_2_url)
+        if ref_image_3 is not None:
+            ref_image_3_url = self.upload_file(
+                tensor_to_bytesio(image=ref_image_3, total_pixels=4096 * 4096),
+                f"{prompt_id}_ref_3.png",
+                headers,
+            )
+            ref_images.append(ref_image_3_url)
+        if len(ref_images) == 0:
+            raise ValueError("At least one reference image is required")
+        data = {
+            "aspect_ratio": aspect_ratio,
+            "model": model,
+            "prompt": prompt,
+            "urls": ref_images,
+        }
+        return data, "veo3.1"
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)
+
+
+class Veo_V3_1_T2V_API(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "model": (["veo3.1-fast", "veo3.1-pro"], {"default": "veo3.1-fast"}),
+            },
+            "optional": {
+                "aspect_ratio": (
+                    ["9:16", "16:9"],
+                    {"default": "16:9"},
+                ),
+            },
+        }
+
+    NODE_DISPLAY_NAME = "Veo3.1 Text To Video"
+    RETURN_TYPES = ("VIDEO",)
+    RETURN_NAMES = ("video",)
+    CATEGORY = "☁️BizyAir/External APIs/Veo"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        model = kwargs.get("model", "veo3.1-fast")
+        prompt = kwargs.get("prompt", "")
+        aspect_ratio = kwargs.get("aspect_ratio", "16:9")
+
+        if prompt is None or prompt.strip() == "":
+            raise ValueError("Prompt is required")
+        data = {
+            "aspect_ratio": aspect_ratio,
+            "model": model,
+            "prompt": prompt,
+        }
+        return data, "veo3.1"
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)

bizyengine/bizyair_extras/third_party_api/nodes_wan_api.py

@@ -0,0 +1,198 @@
+from bizyairsdk import tensor_to_bytesio
+
+from bizyengine.bizyair_extras.utils.audio import save_audio
+
+from .trd_nodes_base import BizyAirTrdApiBaseNode
+
+
+class Wan_V2_5_I2V_API(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+            },
+            "optional": {
+                "audio": ("AUDIO",),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "negative_prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "resolution": (
+                    ["480P", "720P", "1080P"],
+                    {"default": "1080P"},
+                ),
+                "duration": ([5, 10], {"default": 5}),
+                "prompt_extend": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "是否开启prompt智能改写。开启后使用大模型对输入prompt进行智能改写。对于较短的prompt生成效果提升明显，但会增加耗时。",
+                    },
+                ),
+                "auto_audio": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "是否由模型自动生成声音，优先级低于audio参数。",
+                    },
+                ),
+            },
+        }
+
+    NODE_DISPLAY_NAME = "Wan2.5 Image To Video"
+    RETURN_TYPES = ("VIDEO", "STRING")
+    RETURN_NAMES = ("video", "actual_prompt")
+    CATEGORY = "☁️BizyAir/External APIs/WanVideo"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        # 参数
+        prompt = kwargs.get("prompt", "")
+        negative_prompt = kwargs.get("negative_prompt", "")
+        audio = kwargs.get("audio", None)
+        resolution = kwargs.get("resolution", "1080P")
+        duration = kwargs.get("duration", 5)
+        prompt_extend = kwargs.get("prompt_extend", True)
+        auto_audio = kwargs.get("auto_audio", True)
+        image = kwargs.get("image", None)
+
+        model = "wan2.5-i2v-preview"
+        input = {
+            "resolution": resolution,
+            "prompt_extend": prompt_extend,
+            "duration": duration,
+            "audio": auto_audio,
+            "model": model,
+        }
+        if prompt is not None and prompt.strip() != "":
+            input["prompt"] = prompt
+        if negative_prompt is not None and negative_prompt.strip() != "":
+            input["negative_prompt"] = negative_prompt
+
+        # 上传图片&音频
+        if image is not None:
+            image_url = self.upload_file(
+                tensor_to_bytesio(image=image, total_pixels=4096 * 4096),
+                f"{prompt_id}.png",
+                headers,
+            )
+            input["img_url"] = image_url
+        if audio is not None:
+            audio_url = self.upload_file(
+                save_audio(audio=audio, format="mp3"), f"{prompt_id}.mp3", headers
+            )
+            input["audio_url"] = audio_url
+
+        return input, model
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)
+
+
+class Wan_V2_5_T2V_API(BizyAirTrdApiBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+            },
+            "optional": {
+                "audio": ("AUDIO",),
+                "negative_prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                    },
+                ),
+                "size": (
+                    [
+                        "832*480",
+                        "480*832",
+                        "624*624",
+                        "1280*720",
+                        "720*1280",
+                        "960*960",
+                        "1088*832",
+                        "832*1088",
+                        "1920*1080",
+                        "1080*1920",
+                        "1440*1440",
+                        "1632*1248",
+                        "1248*1632",
+                    ],
+                    {"default": "1920*1080"},
+                ),
+                "duration": ([5, 10], {"default": 5}),
+                "prompt_extend": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "是否开启prompt智能改写。开启后使用大模型对输入prompt进行智能改写。对于较短的prompt生成效果提升明显，但会增加耗时。",
+                    },
+                ),
+                "auto_audio": (
+                    "BOOLEAN",
+                    {
+                        "default": True,
+                        "tooltip": "是否由模型自动生成声音，优先级低于audio参数。",
+                    },
+                ),
+            },
+        }
+
+    NODE_DISPLAY_NAME = "Wan2.5 Text To Video"
+    RETURN_TYPES = ("VIDEO", "STRING")
+    RETURN_NAMES = ("video", "actual_prompt")
+    CATEGORY = "☁️BizyAir/External APIs/WanVideo"
+
+    def handle_inputs(self, headers, prompt_id, **kwargs):
+        # 参数
+        model = "wan2.5-t2v-preview"
+        negative_prompt = kwargs.get("negative_prompt", "")
+        audio = kwargs.get("audio", None)
+        size = kwargs.get("size", "1920*1080")
+        duration = kwargs.get("duration", 5)
+        prompt_extend = kwargs.get("prompt_extend", True)
+        auto_audio = kwargs.get("auto_audio", True)
+        prompt = kwargs.get("prompt", "")
+
+        input = {
+            "size": size,
+            "prompt_extend": prompt_extend,
+            "duration": duration,
+            "audio": auto_audio,
+            "model": model,
+        }
+        if prompt is not None and prompt.strip() != "":
+            input["prompt"] = prompt
+        if negative_prompt is not None and negative_prompt.strip() != "":
+            input["negative_prompt"] = negative_prompt
+
+        # 上传音频
+        if audio is not None:
+            audio_url = self.upload_file(
+                save_audio(audio=audio, format="mp3"), f"{prompt_id}.mp3", headers
+            )
+            input["audio_url"] = audio_url
+
+        return input, model
+
+    def handle_outputs(self, outputs):
+        return (outputs[0][0],)

bizyengine/bizyair_extras/third_party_api/trd_nodes_base.py

@@ -0,0 +1,182 @@
+import abc
+import io
+import json
+import logging
+import time
+from typing import List, Tuple
+
+import requests
+import torch
+from bizyairsdk import bytesio_to_image_tensor, common_upscale
+from comfy_api.latest._input_impl import VideoFromFile
+
+from bizyengine.core import (
+    BizyAirMiscBaseNode,
+    pop_api_key_and_prompt_id,
+    register_node,
+)
+from bizyengine.core.common import client
+from bizyengine.core.common.client import send_request
+from bizyengine.core.common.env_var import BIZYAIR_X_SERVER
+from bizyengine.core.nodes_base import PREFIX
+
+from ..utils.aliyun_oss import parse_upload_token, upload_file_without_sdk
+
+
+class TrdBase(abc.ABC):
+    @abc.abstractmethod
+    # Return: data, model, prompt
+    def handle_inputs(self, headers, prompt_id, **kwargs) -> Tuple[dict, str]:
+        pass
+
+    @abc.abstractmethod
+    # Return: videos, images, texts
+    def handle_outputs(
+        self, outputs: Tuple[List[VideoFromFile], List[torch.Tensor], List[str]]
+    ) -> Tuple:
+        pass
+
+
+class BizyAirTrdApiBaseNode(BizyAirMiscBaseNode, TrdBase):
+    FUNCTION = "api_call"
+    OUTPUT_NODE = False
+
+    def __init_subclass__(cls, **kwargs):
+        register_node(cls, PREFIX)
+
+    def api_call(self, **kwargs):
+        extra_data = pop_api_key_and_prompt_id(kwargs)
+        headers = client.headers(api_key=extra_data["api_key"])
+        prompt_id = extra_data["prompt_id"]
+        headers["X-BIZYAIR-PROMPT-ID"] = prompt_id
+
+        data, model = self.handle_inputs(headers, prompt_id, **kwargs)
+        outputs = self.create_task_and_wait_for_completion(data, model, headers)
+        return self.handle_outputs(outputs)
+
+    def create_task_and_wait_for_completion(
+        self, data, model, headers
+    ) -> Tuple[List[VideoFromFile], List[torch.Tensor], List[str]]:
+        # 创建任务
+        create_task_url = f"{BIZYAIR_X_SERVER}/trd_api/{model}"
+        json_payload = json.dumps(data).encode("utf-8")
+        logging.debug(f"json_payload: {json_payload}")
+        create_api_resp = send_request(
+            url=create_task_url,
+            data=json_payload,
+            headers=headers,
+        )
+        logging.debug(
+            f"{self.NODE_DISPLAY_NAME} create task api resp: {create_api_resp}"
+        )
+
+        # 检查任务创建是否成功
+        if "data" not in create_api_resp or "request_id" not in create_api_resp["data"]:
+            raise ValueError(f"Invalid response: {create_api_resp}")
+
+        # 轮询获取结果，最多等待1小时
+        request_id = create_api_resp["data"]["request_id"]
+        logging.info(f"{self.NODE_DISPLAY_NAME} task created, request_id: {request_id}")
+        start_time = time.time()
+        status_url = f"{BIZYAIR_X_SERVER}/trd_api/{request_id}"
+        while time.time() - start_time < 3600:
+            time.sleep(10)
+            try:
+                status_api_resp = send_request(
+                    method="GET",
+                    url=status_url,
+                    headers=headers,
+                )
+            except Exception as e:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api error: {e}"
+                )
+                continue
+
+            if "data" not in status_api_resp:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api resp no data: {status_api_resp}"
+                )
+                continue
+            if "status" not in status_api_resp["data"]:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} status api resp no status: {status_api_resp}"
+                )
+                continue
+            status = status_api_resp["data"]["status"]
+            if status == "failed":
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} failed: {status_api_resp}"
+                )
+            if status == "running":
+                continue
+
+            # 成功，获取输出结果
+            if "outputs" not in status_api_resp["data"]:
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} no outputs: {status_api_resp}"
+                )
+            logging.info(
+                f"{self.NODE_DISPLAY_NAME} task {request_id} success: {status_api_resp}"
+            )
+            # 分别处理视频、图片、文本
+            videos = []
+            images = []
+            texts = []
+            outputs = status_api_resp["data"]["outputs"]
+            try:
+                if "videos" in outputs:
+                    for video_url in outputs["videos"]:
+                        video_resp = requests.get(video_url, stream=True, timeout=3600)
+                        video_resp.raise_for_status()  # 非 2xx 会抛异常
+                        videos.append(VideoFromFile(io.BytesIO(video_resp.content)))
+                if "images" in outputs:
+                    for image_url in outputs["images"]:
+                        image_resp = requests.get(image_url, stream=True, timeout=3600)
+                        image_resp.raise_for_status()  # 非 2xx 会抛异常
+                        images.append(
+                            bytesio_to_image_tensor(io.BytesIO(image_resp.content))
+                        )
+                if "texts" in outputs:
+                    for text in outputs["texts"]:
+                        texts.append(text)
+            except Exception as e:
+                logging.error(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} handle outputs error: {e}"
+                )
+                raise ValueError(
+                    f"{self.NODE_DISPLAY_NAME} task {request_id} handle outputs error: {e}, please download the outputs manually, outputs: {outputs}"
+                )
+
+            return (videos, images, texts)
+
+        raise ValueError(
+            f"{self.NODE_DISPLAY_NAME} task timed out, request ID: {request_id}"
+        )
+
+    def upload_file(self, bytes, file_name, headers):
+        oss_token_url = (
+            f"{BIZYAIR_X_SERVER}/upload/token?file_name={file_name}&file_type=inputs"
+        )
+        token_resp = send_request("GET", oss_token_url, headers=headers)
+        auth_info = parse_upload_token(token_resp)
+        return upload_file_without_sdk(file_content=bytes, **auth_info)
+
+    def combine_images(self, images: List[torch.Tensor]) -> torch.Tensor:
+        s = None
+        if images is not None and len(images) > 0:
+            for _, image in enumerate(images):
+                if s is None:
+                    s = image
+                else:
+                    # ComfyUI BatchImage logic
+                    if s.shape[1:] != image.shape[1:]:
+                        image = common_upscale(
+                            image.movedim(-1, 1),
+                            s.shape[2],
+                            image.shape[1],
+                            "bilinear",
+                            "center",
+                        ).movedim(1, -1)
+                    s = torch.cat((s, image), dim=0)
+        return s

bizyengine/core/__init__.py

@@ -6,5 +6,6 @@ from bizyengine.core.nodes_base import (
     BizyAirBaseNode,
     BizyAirMiscBaseNode,
     pop_api_key_and_prompt_id,
+    register_node,
 )
 from bizyengine.core.nodes_io import BizyAirNodeIO, create_node_data

bizyengine/version.txt

@@ -1 +1 @@
-1.2.68
+1.2.69

{bizyengine-1.2.68.dist-info → bizyengine-1.2.69.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.68
+Version: 1.2.69
 Summary: [a/BizyAir](https://github.com/siliconflow/BizyAir) Comfy Nodes that can run in any environment.
 Author-email: SiliconFlow <yaochi@siliconflow.cn>
 Project-URL: Repository, https://github.com/siliconflow/BizyAir
@@ -14,7 +14,7 @@ Requires-Dist: inputimeout
 Requires-Dist: openai>=1.77.0
 Requires-Dist: pycryptodome
 Requires-Dist: mcp>=1.18.0
-Requires-Dist: bizyairsdk>=0.1.3
+Requires-Dist: bizyairsdk>=0.1.5
 
 ## BizyEngine