bizyengine 1.2.6__py3-none-any.whl → 1.2.8__py3-none-any.whl

bizyengine/bizyair_extras/__init__.py

@@ -22,5 +22,6 @@ from .nodes_testing_utils import *
 from .nodes_trellis import *
 from .nodes_ultimatesdupscale import *
 from .nodes_upscale_model import *
+from .nodes_wan_i2v import *
 from .nodes_wan_video import *
 from .route_bizyair_tools import *

bizyengine/bizyair_extras/nodes_flux.py

@@ -56,7 +56,7 @@ class FluxGuidance(BizyAirBaseNode):
 
     CATEGORY = "advanced/conditioning/flux"
 
-    def append(self, conditioning: BizyAirNodeIO, guidance):
+    def append(self, conditioning: BizyAirNodeIO, guidance, **kwargs):
         new_conditioning = conditioning.copy(self.assigned_id)
         new_conditioning.add_node_data(
             class_type="FluxGuidance",

bizyengine/bizyair_extras/nodes_image_utils.py

@@ -31,7 +31,7 @@ class LoadImageURL(BizyAirBaseNode):
     FUNCTION = "apply"
     NODE_DISPLAY_NAME = "Load Image (URL)"
 
-    def apply(self, url: str):
+    def apply(self, url: str, **kwargs):
         url = url.strip()
         input_dir = folder_paths.get_input_directory()
 
@@ -88,6 +88,6 @@ class Image_Encode(BizyAirBaseNode):
     RETURN_TYPES = ("IMAGE",)
     NODE_DISPLAY_NAME = "Image Encode"
 
-    def apply(self, image, lossless=False):
+    def apply(self, image, lossless=False, **kwargs):
         out = encode_data(image, lossless=lossless)
         return (out,)

bizyengine/bizyair_extras/nodes_nunchaku.py

@@ -167,11 +167,7 @@ class NunchakuFluxLoraLoader(BizyAirBaseNode):
         return True
 
     def load_lora(
-        self,
-        model,
-        lora_name,
-        lora_strength,
-        model_version_id: str = None,
+        self, model, lora_name, lora_strength, model_version_id: str = None, **kwargs
     ):
         assigned_id = self.assigned_id
         new_model: BizyAirNodeIO = model.copy(assigned_id)

bizyengine/bizyair_extras/nodes_segment_anything.py

@@ -219,6 +219,7 @@ class BizyAirDetailMethodPredict(BizyAirBaseNode):
         detail_dilate,
         black_point,
         white_point,
+        **kwargs
     ):
 
         ret_images = []

bizyengine/bizyair_extras/nodes_trellis.py

@@ -178,7 +178,7 @@ class BizyAirDownloadFile(BizyAirBaseNode):
     OUTPUT_NODE = True
     OUTPUT_IS_LIST = (False,)
 
-    def main(self, url, file_name):
+    def main(self, url, file_name, **kwargs):
         assert url is not None
         file_name = file_name + ".glb"
         out_dir = os.path.join(folder_paths.get_output_directory(), "trellis_output")

bizyengine/bizyair_extras/nodes_ultimatesdupscale.py

@@ -124,7 +124,7 @@ class UltimateSDUpscale(BizyAirBaseNode):
         return prepare_inputs(required, optional)
 
     RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "upscale"
+    # FUNCTION = "upscale"
     CATEGORY = "image/upscaling"
 
     def upscale(self, **kwargs):

bizyengine/bizyair_extras/nodes_wan_i2v.py

@@ -0,0 +1,222 @@
+import json
+import time
+import warnings
+
+import requests
+
+try:
+    from comfy_api_nodes.apinode_utils import (
+        download_url_to_video_output,
+        tensor_to_base64_string,
+    )
+except ModuleNotFoundError as e:
+    download_url_to_video_output = None
+    tensor_to_base64_string = None
+
+    ERROR_MSG = f"Error {e} ComfyUI API nodes module not found. Please ensure you have ComfyUI version 0.3.36 or later installed."
+
+    warnings.warn(ERROR_MSG)
+
+
+from ..core.common import client
+from ..core.common.env_var import BIZYAIR_DEBUG
+from ..core.nodes_base import BizyAirBaseNode
+
+
+class WanApiNodeBase:
+    MODEL_ENDPOINTS = {
+        "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers": "https://bizyair-api.siliconflow.cn/x/v1/supernode/faas-wan-i2v-14b-480p-server"
+    }
+
+
+class Wan_LoraLoader(BizyAirBaseNode):
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "lora_name": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "https://huggingface.co/Remade-AI/Squish/resolve/main/squish_18.safetensors",
+                        "tooltip": "LoRA 模型下载地址",
+                    },
+                ),
+            },
+            "optional": {
+                "lora_weight": (
+                    "FLOAT",
+                    {
+                        "default": 1,
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.05,
+                        "tooltip": "LoRA权重强度",
+                    },
+                )
+            },
+        }
+
+    RETURN_TYPES = ("LORA_CONFIG",)
+    RETURN_NAMES = ("lora_config",)
+    FUNCTION = "apply_lora"
+    CATEGORY = "Diffusers/WAN Video Generation"
+
+    def apply_lora(self, lora_name, lora_weight=0.75, **kwargs):
+        return ([(lora_name, lora_weight)],)
+
+
+class Wan_ImageToVideoPipeline(WanApiNodeBase, BizyAirBaseNode):
+
+    POLLING_INTERVAL = 10  # sec
+    MAX_POLLING_TIME = 60 * 20  # sec
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": (
+                    "IMAGE",
+                    {
+                        "default": None,
+                        "tooltip": "Optional reference image to guide video generation",
+                    },
+                ),
+                "model_id": (["Wan-AI/Wan2.1-I2V-14B-480P-Diffusers"],),
+                "prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                        "tooltip": "Text description of the video",
+                    },
+                ),
+            },
+            "optional": {
+                "negative_prompt": (
+                    "STRING",
+                    {
+                        "multiline": True,
+                        "default": "",
+                        "tooltip": "Negative text prompt to guide what to avoid in the video",
+                    },
+                ),
+                "steps": ("INT", {"default": 30, "min": 1, "max": 40}),
+                "cfg": (
+                    "FLOAT",
+                    {
+                        "default": 6.0,
+                        "min": 0.0,
+                        "max": 100.0,
+                        "step": 0.1,
+                        "round": 0.01,
+                    },
+                ),
+                "seed": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 0xFFFFFFFF,
+                        "step": 1,
+                        "display": "number",
+                        "control_after_generate": True,
+                        "tooltip": "Seed for video generation (0 for random)",
+                    },
+                ),
+                "use_teacache": (["enable", "disable"],),
+                "lora_config": ("LORA_CONFIG", {}),
+            },
+        }
+
+    RETURN_TYPES = ("VIDEO",)
+
+    FUNCTION = "generate_video"
+    CATEGORY = "Diffusers/WAN Video Generation"
+
+    def _encode_image(self, image_tensor):
+        # https://docs.comfy.org/custom-nodes/backend/snippets
+        tensor_to_base64_string(image_tensor=image_tensor, mime_type="image/webp")
+        base64_str = "data:image/webp;base64," + tensor_to_base64_string(
+            image_tensor=image_tensor, mime_type="image/webp"
+        )
+        return base64_str
+
+    def _prepare_headers(self):
+        headers = client._headers()
+        headers["X-Fn-Task-Mode"] = "non-blocking"
+        return headers
+
+    def _send_initial_request(self, endpoint, request_data):
+        headers = self._prepare_headers()
+        response = client.send_request(
+            url=endpoint,
+            data=json.dumps({"prompt": request_data}).encode(),
+            headers=headers,
+        )
+        return response["query_url"]
+
+    def _poll_for_completion(self, query_url):
+        start_time = time.time()
+        headers = self._prepare_headers()
+
+        while time.time() - start_time < self.MAX_POLLING_TIME:
+            response = requests.get(query_url, headers=headers)
+            try:
+                response_data = response.json()
+                if response_data["data_status"] == "COMPLETED":
+                    return response_data
+                time.sleep(self.POLLING_INTERVAL)
+            except (json.JSONDecodeError, KeyError) as e:
+                if BIZYAIR_DEBUG:
+                    print(
+                        f"Response parsing error: {e} | Raw response: {response.text}"
+                    )
+                time.sleep(self.POLLING_INTERVAL)
+
+        raise TimeoutError("Task processing timeout")
+
+    def _process_result(self, result_data):
+        video_url = result_data["data"]["payload"]
+        return (download_url_to_video_output(video_url),)
+
+    def generate_video(
+        self,
+        model_id: str,
+        prompt: str,
+        negative_prompt: str = "",
+        seed: int = 0,
+        image=None,
+        lora_config=[],
+        use_teacache="enable",
+        **kwargs,
+    ):
+        if download_url_to_video_output is None or tensor_to_base64_string is None:
+            raise ImportError(ERROR_MSG)
+
+        req_dict = {}
+        req_dict["guidance_scale"] = kwargs.pop("cfg", 6.0)
+        req_dict["num_inference_steps"] = kwargs.pop("steps", 30)
+        req_dict["prompt"] = prompt
+        req_dict["negative_prompt"] = negative_prompt
+        req_dict["seed"] = seed
+        if lora_config:
+            if len(lora_config) > 1:
+                raise NotImplementedError(f"TODO, tmp only support one lora")
+            req_dict["lora_name_list"] = [x[0] for x in lora_config]
+            req_dict["lora_weight_list"] = [x[1] for x in lora_config]
+        else:
+            req_dict["lora_name_list"] = []
+            req_dict["lora_weight_list"] = []
+
+        if use_teacache == "enable":
+            req_dict["teacache"] = 0.3
+        else:
+            req_dict["teacache"] = 0
+
+        req_dict["image"] = self._encode_image(image_tensor=image)
+        endpoint = self.MODEL_ENDPOINTS[model_id]
+        query_url = self._send_initial_request(endpoint, request_data=req_dict)
+        result = self._poll_for_completion(query_url)
+        return self._process_result(result)

bizyengine/core/__init__.py

@@ -4,5 +4,7 @@ from bizyengine.core.nodes_base import (
     NODE_CLASS_MAPPINGS,
     NODE_DISPLAY_NAME_MAPPINGS,
     BizyAirBaseNode,
+    BizyAirMiscBaseNode,
+    pop_api_key_and_prompt_id,
 )
 from bizyengine.core.nodes_io import BizyAirNodeIO, create_node_data

bizyengine/core/commands/processors/prompt_processor.py

@@ -3,7 +3,7 @@ from collections import deque
 from typing import Any, Dict, List
 
 from bizyengine.core.commands.base import Processor  # type: ignore
-from bizyengine.core.common import client, get_api_key
+from bizyengine.core.common import client
 from bizyengine.core.common.caching import BizyAirTaskCache, CacheConfig
 from bizyengine.core.common.env_var import (
     BIZYAIR_DEBUG,
@@ -15,7 +15,6 @@ from bizyengine.core.path_utils import (
     convert_prompt_label_path_to_real_path,
     guess_url_from_node,
 )
-from server import PromptServer
 
 
 def is_link(obj):
@@ -34,7 +33,9 @@ from dataclasses import dataclass
 
 
 class SearchServiceRouter(Processor):
-    def process(self, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str]):
+    def process(
+        self, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str], **kwargs
+    ):
         if BIZYAIR_DEV_REQUEST_URL:
             return BIZYAIR_DEV_REQUEST_URL
 
@@ -83,18 +84,15 @@ class SearchServiceRouter(Processor):
         return f"{BIZYAIR_SERVER_ADDRESS}{out_route}"
 
     def validate_input(
-        self, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str]
+        self, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str], **kwargs
     ):
         assert len(last_node_ids) == 1
         return True
 
 
 class PromptProcessor(Processor):
-    def _exec_info(self, prompt: Dict[str, Dict[str, Any]]):
-        exec_info = {
-            "model_version_ids": [],
-            "api_key": get_api_key(),
-        }
+    def _exec_info(self, prompt: Dict[str, Dict[str, Any]], api_key: str):
+        exec_info = {"model_version_ids": [], "api_key": api_key}
 
         model_version_id_prefix = config_manager.get_model_version_id_prefix()
         for node_id, node_data in prompt.items():
@@ -105,26 +103,31 @@ class PromptProcessor(Processor):
         return exec_info
 
     def process(
-        self, url: str, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str]
+        self,
+        url: str,
+        prompt: Dict[str, Dict[str, Any]],
+        last_node_ids: List[str],
+        **kwargs,
     ):
         dict = {
             "prompt": prompt,
             "last_node_id": last_node_ids[0],
-            "exec_info": self._exec_info(prompt),
+            "exec_info": self._exec_info(prompt, kwargs["api_key"]),
         }
-        if (
-            PromptServer.instance is not None
-            and PromptServer.instance.last_prompt_id is not None
-        ):
-            dict["prompt_id"] = PromptServer.instance.last_prompt_id
-            print("Processing prompt with ID: " + PromptServer.instance.last_prompt_id)
+        if "prompt_id" in kwargs:
+            dict["prompt_id"] = kwargs["prompt_id"]
 
         return client.send_request(
             url=url,
             data=json.dumps(dict).encode("utf-8"),
+            headers=client.headers(api_key=kwargs["api_key"]),
         )
 
     def validate_input(
-        self, url: str, prompt: Dict[str, Dict[str, Any]], last_node_ids: List[str]
+        self,
+        url: str,
+        prompt: Dict[str, Dict[str, Any]],
+        last_node_ids: List[str],
+        **kwargs,
     ):
         return True

bizyengine/core/commands/servers/prompt_server.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List
 import comfy
 from bizyengine.core.commands.base import Command, Processor  # type: ignore
 from bizyengine.core.common.caching import BizyAirTaskCache, CacheConfig
-from bizyengine.core.common.client import send_request
+from bizyengine.core.common.client import headers, send_request
 from bizyengine.core.common.env_var import (
     BIZYAIR_DEBUG,
     BIZYAIR_DEV_GET_TASK_RESULT_SERVER,
@@ -20,7 +20,7 @@ from bizyengine.core.configs.conf import config_manager
 from bizyengine.core.image_utils import decode_data, encode_data
 
 
-def get_task_result(task_id: str, offset: int = 0) -> dict:
+def get_task_result(task_id: str, offset: int = 0, api_key: str = None) -> dict:
     """
     Get the result of a task.
     """
@@ -34,8 +34,12 @@ def get_task_result(task_id: str, offset: int = 0) -> dict:
 
     if BIZYAIR_DEBUG:
         print(f"Debug: get task result url: {url}")
+    _headers = headers(api_key=api_key)
     response_json = send_request(
-        method="GET", url=url, data=json.dumps({"offset": offset}).encode("utf-8")
+        method="GET",
+        url=url,
+        data=json.dumps({"offset": offset}).encode("utf-8"),
+        headers=_headers,
     )
     out = response_json
     events = out.get("data", {}).get("events", [])
@@ -47,7 +51,9 @@ def get_task_result(task_id: str, offset: int = 0) -> dict:
             and event["data"].startswith("https://")
         ):
             # event["data"] = requests.get(event["data"]).json()
-            event["data"] = send_request(method="GET", url=event["data"])
+            event["data"] = send_request(
+                method="GET", url=event["data"], headers=_headers
+            )
         new_events.append(event)
     out["data"]["events"] = new_events
     return out
@@ -59,6 +65,7 @@ class BizyAirTask:
     task_id: str
     data_pool: list[dict] = field(default_factory=list)
     data_status: str = None
+    api_key: str = None
 
     @staticmethod
     def check_inputs(inputs: dict) -> bool:
@@ -69,12 +76,19 @@ class BizyAirTask:
         )
 
     @classmethod
-    def from_data(cls, inputs: dict, check_inputs: bool = True) -> "BizyAirTask":
+    def from_data(
+        cls, inputs: dict, check_inputs: bool = True, **kwargs
+    ) -> "BizyAirTask":
         if check_inputs and not cls.check_inputs(inputs):
             raise ValueError(f"Invalid inputs: {inputs}")
         data = inputs.get("data", {})
         task_id = data.get("task_id", "")
-        return cls(task_id=task_id, data_pool=[], data_status="started")
+        return cls(
+            task_id=task_id,
+            data_pool=[],
+            data_status="started",
+            api_key=kwargs["api_key"],
+        )
 
     def is_finished(self) -> bool:
         if not self.data_pool:
@@ -85,7 +99,7 @@ class BizyAirTask:
 
     def send_request(self, offset: int = 0) -> dict:
         if offset >= len(self.data_pool):
-            return get_task_result(self.task_id, offset)
+            return get_task_result(self.task_id, offset, self.api_key)
         else:
             return self.data_pool[offset]
 
@@ -163,12 +177,12 @@ class PromptServer(Command):
             and "task_id" in result.get("data", {})
         )
 
-    def _get_result(self, result: Dict[str, Any], *, cache_key: str = None):
+    def _get_result(self, result: Dict[str, Any], *, cache_key: str = None, **kwargs):
         try:
             response_data = result["data"]
             if BizyAirTask.check_inputs(result):
                 self.cache_manager.set(cache_key, result)
-                bz_task = BizyAirTask.from_data(result, check_inputs=False)
+                bz_task = BizyAirTask.from_data(result, check_inputs=False, **kwargs)
                 bz_task.do_task_until_completed(timeout=60 * 60)  # 60 minutes
                 last_data = bz_task.get_last_data()
                 response_data = last_data.get("data")
@@ -187,7 +201,6 @@ class PromptServer(Command):
         *args,
         **kwargs,
     ):
-
         prompt = encode_data(prompt)
 
         if BIZYAIR_DEBUG:
@@ -197,7 +210,7 @@ class PromptServer(Command):
             }
             pprint.pprint(debug_info, indent=4)
 
-        url = self.router(prompt=prompt, last_node_ids=last_node_ids)
+        url = self.router(prompt=prompt, last_node_ids=last_node_ids, **kwargs)
 
         if BIZYAIR_DEBUG:
             print(f"Generated URL: {url}")
@@ -218,8 +231,10 @@ class PromptServer(Command):
                 print(f"Cache hit for sh256-{sh256}")
             out = cached_output
         else:
-            result = self.processor(url, prompt=prompt, last_node_ids=last_node_ids)
-            out = self._get_result(result, cache_key=sh256)
+            result = self.processor(
+                url, prompt=prompt, last_node_ids=last_node_ids, **kwargs
+            )
+            out = self._get_result(result, cache_key=sh256, **kwargs)
 
         if BIZYAIR_DEBUG:
             pprint.pprint({"out": truncate_long_strings(out, 50)}, indent=4)

bizyengine/core/common/client.py

@@ -22,6 +22,7 @@ from .env_var import (
     BIZYAIR_API_KEY,
     BIZYAIR_DEBUG,
     BIZYAIR_SERVER_ADDRESS,
+    BIZYAIR_SERVER_MODE,
     create_api_key_file,
 )
 
@@ -41,6 +42,8 @@ api_key_state = APIKeyState()
 
 
 def set_api_key(api_key: str = "YOUR_API_KEY", override: bool = False) -> bool:
+    if BIZYAIR_SERVER_MODE:
+        return
     logging.debug("client.py set_api_key called")
     global api_key_state
     if api_key_state.is_valid and not override:
@@ -58,6 +61,9 @@ def set_api_key(api_key: str = "YOUR_API_KEY", override: bool = False) -> bool:
 
 
 def validate_api_key(api_key: str = None) -> bool:
+    if BIZYAIR_SERVER_MODE:
+        return False
+
     logging.debug("validating api key...")
     if not api_key or not isinstance(api_key, str):
         warnings.warn("invalid api_key")
@@ -92,6 +98,8 @@ def validate_api_key(api_key: str = None) -> bool:
 
 
 def get_api_key() -> str:
+    if BIZYAIR_SERVER_MODE:
+        return None
     logging.debug("client.py get_api_key called")
     global api_key_state
     try:
@@ -106,11 +114,15 @@ def get_api_key() -> str:
     return api_key_state.current_api_key
 
 
-def _headers():
+def headers(api_key: str = None):
+    return _headers(api_key=api_key)
+
+
+def _headers(api_key: str = None):
     headers = {
         "accept": "application/json",
         "content-type": "application/json",
-        "authorization": f"Bearer {get_api_key()}",
+        "authorization": f"Bearer {api_key if api_key else get_api_key()}",
     }
     return headers
 

bizyengine/core/common/env_var.py

@@ -105,3 +105,5 @@ BIZYAIR_DEV_GET_TASK_RESULT_SERVER = env(
     "BIZYAIR_DEV_GET_TASK_RESULT_SERVER", str, None
 )
 BIZYAIR_PRODUCTION_TEST = env("BIZYAIR_PRODUCTION_TEST", str, None)
+# Server Mode
+BIZYAIR_SERVER_MODE = env("BIZYAIR_SERVER_MODE", bool, False)