bizyengine 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

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

@@ -63,7 +63,7 @@ class Wan_LoraLoader(BizyAirBaseNode):
     FUNCTION = "apply_lora"
     CATEGORY = "Diffusers/WAN Video Generation"
 
-    def apply_lora(self, lora_name, lora_weight=0.75):
+    def apply_lora(self, lora_name, lora_weight=0.75, **kwargs):
         return ([(lora_name, lora_weight)],)
 
 

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)

bizyengine/core/nodes_base.py

@@ -4,8 +4,11 @@ import warnings
 from functools import wraps
 from typing import List
 
+from bizyengine.core.common.env_var import BIZYAIR_DEBUG, BIZYAIR_SERVER_MODE
 from bizyengine.core.configs.conf import config_manager
+from server import PromptServer
 
+from .common.client import get_api_key
 from .data_types import is_send_request_datatype
 from .nodes_io import BizyAirNodeIO, create_node_data
 
@@ -23,6 +26,37 @@ PREFIX = f"BizyAir"
 NODE_CLASS_MAPPINGS = {}
 NODE_DISPLAY_NAME_MAPPINGS = {}
 
+BIZYAIR_PROMPT_KEY = "bizyair_prompt"
+BIZYAIR_PARAM_MAGIC_NODE_ID = "bizyair_magic_node"
+
+
+def pop_api_key_and_prompt_id(kwargs):
+    extra_data = {}
+    prompt = None
+    if BIZYAIR_PROMPT_KEY in kwargs:
+        prompt = kwargs.pop(BIZYAIR_PROMPT_KEY)
+    if BIZYAIR_SERVER_MODE:
+        if BIZYAIR_PARAM_MAGIC_NODE_ID in prompt:
+            extra_data["api_key"] = prompt[BIZYAIR_PARAM_MAGIC_NODE_ID]["_meta"][
+                "api_key"
+            ]
+            extra_data["prompt_id"] = prompt[BIZYAIR_PARAM_MAGIC_NODE_ID]["_meta"][
+                "prompt_id"
+            ]
+            logging.debug(
+                "Using server mode passed in prompt_id: " + extra_data["prompt_id"]
+            )
+    else:
+        extra_data["api_key"] = get_api_key()
+        if (
+            PromptServer.instance is not None
+            and PromptServer.instance.last_prompt_id is not None
+        ):
+            extra_data["prompt_id"] = PromptServer.instance.last_prompt_id
+            print("Processing prompt with ID: " + PromptServer.instance.last_prompt_id)
+
+    return extra_data
+
 
 def process_kwargs(kwargs):
     possibleWidgetNames = [
@@ -91,7 +125,7 @@ def ensure_unique_id(org_func, original_has_unique_id=False):
     return new_func
 
 
-def ensure_hidden_unique_id(org_input_types_func):
+def ensure_hidden_unique_id_and_prompt(org_input_types_func):
     original_has_unique_id = False
 
     @wraps(org_input_types_func)
@@ -105,6 +139,9 @@ def ensure_hidden_unique_id(org_input_types_func):
             result["hidden"]["unique_id"] = "UNIQUE_ID"
         else:
             original_has_unique_id = True
+        # Also set prompt, but to avoid naming conflict prefix with 'bizyair'
+        if BIZYAIR_PROMPT_KEY not in result["hidden"]:
+            result["hidden"][BIZYAIR_PROMPT_KEY] = "PROMPT"
         return result
 
     # Ensure original_has_unique_id is correctly set before returning
@@ -121,11 +158,19 @@ class BizyAirBaseNode:
         register_node(cls, PREFIX)
         cls.setup_input_types()
 
+        # 验证FUNCTION接受**kwargs
+        if BIZYAIR_DEBUG:
+            import inspect
+
+            sig = inspect.signature(getattr(cls, cls.FUNCTION))
+            params = sig.parameters.values()
+            assert any([True for p in params if p.kind == p.VAR_KEYWORD])
+
     @classmethod
     def setup_input_types(cls):
-        # https://docs.comfy.org/essentials/custom_node_more_on_inputs#hidden-inputs
-        new_input_types_func, original_has_unique_id = ensure_hidden_unique_id(
-            cls.INPUT_TYPES
+        # https://docs.comfy.org/custom-nodes/backend/more_on_inputs#hidden-and-flexible-inputs
+        new_input_types_func, original_has_unique_id = (
+            ensure_hidden_unique_id_and_prompt(cls.INPUT_TYPES)
         )
         cls.INPUT_TYPES = new_input_types_func
         setattr(
@@ -140,13 +185,14 @@ class BizyAirBaseNode:
         return str(self._assigned_id)
 
     def default_function(self, **kwargs):
+        extra_data = pop_api_key_and_prompt_id(kwargs)
         class_type = self._determine_class_type()
         kwargs = process_kwargs(kwargs)
         node_ios = self._process_non_send_request_types(class_type, kwargs)
         # TODO: add processing for send_request_types
         send_request_datatype_list = self._get_send_request_datatypes()
         if len(send_request_datatype_list) == len(self.RETURN_TYPES):
-            return self._process_all_send_request_types(node_ios)
+            return self._process_all_send_request_types(node_ios, **extra_data)
         return node_ios
 
     def _get_send_request_datatypes(self):
@@ -172,7 +218,39 @@ class BizyAirBaseNode:
             outs.append(node)
         return tuple(outs)
 
-    def _process_all_send_request_types(self, node_ios: List[BizyAirNodeIO]):
-        out = node_ios[0].send_request()
+    def _process_all_send_request_types(self, node_ios: List[BizyAirNodeIO], **kwargs):
+        out = node_ios[0].send_request(**kwargs)
         assert len(out) == len(self.RETURN_TYPES)
         return out
+
+
+class BizyAirMiscBaseNode:
+    # 作为Misc节点基类来保证hidden prompt, unique id存在
+    def __init_subclass__(cls, **kwargs):
+        if hasattr(cls, "CATEGORY"):
+            if not cls.CATEGORY.startswith(f"{LOGO}{PREFIX}"):
+                cls.CATEGORY = f"{LOGO}{PREFIX}/{cls.CATEGORY}"
+        cls.setup_input_types()
+
+        # 验证FUNCTION接受**kwargs
+        if BIZYAIR_DEBUG:
+            import inspect
+
+            sig = inspect.signature(getattr(cls, cls.FUNCTION))
+            params = sig.parameters.values()
+            assert any([True for p in params if p.kind == p.VAR_KEYWORD])
+
+    @classmethod
+    def setup_input_types(cls):
+        if not hasattr(cls, "INPUT_TYPES"):
+            cls.INPUT_TYPES = lambda: {}
+        # https://docs.comfy.org/custom-nodes/backend/more_on_inputs#hidden-and-flexible-inputs
+        new_input_types_func, original_has_unique_id = (
+            ensure_hidden_unique_id_and_prompt(cls.INPUT_TYPES)
+        )
+        cls.INPUT_TYPES = new_input_types_func
+        setattr(
+            cls,
+            cls.FUNCTION,
+            ensure_unique_id(getattr(cls, cls.FUNCTION), original_has_unique_id),
+        )

bizyengine/core/nodes_io.py

@@ -82,10 +82,10 @@ class BizyAirNodeIO:
                 self.nodes.update(other.nodes)
 
     def send_request(
-        self, url=None, headers=None, *, progress_callback=None, stream=False
+        self, url=None, headers=None, *, progress_callback=None, stream=False, **kwargs
     ) -> any:
         out = invoker.prompt_server.execute(
-            prompt=self.nodes, last_node_ids=[self.node_id]
+            prompt=self.nodes, last_node_ids=[self.node_id], **kwargs
         )
         return out