bizyengine 1.2.2__tar.gz → 1.2.3__tar.gz

{bizyengine-1.2.2 → bizyengine-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.2
+Version: 1.2.3
 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

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/bizyair_extras/__init__.py

@@ -15,6 +15,7 @@ from .nodes_ipadapter_plus.nodes_ipadapter_plus import *
 from .nodes_janus_pro import *
 from .nodes_kolors_mz import *
 from .nodes_model_advanced import *
+from .nodes_nunchaku import *
 from .nodes_sd3 import *
 from .nodes_segment_anything import *
 from .nodes_testing_utils import *

bizyengine-1.2.3/bizyengine/bizyair_extras/nodes_nunchaku.py

@@ -0,0 +1,193 @@
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO, data_types
+from bizyengine.core.configs.conf import config_manager
+from bizyengine.core.path_utils import path_manager as folder_paths
+
+
+class NunchakuFluxDiTLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        attention_options = ["nunchaku-fp16"]
+        dtype_options = ["bfloat16"]
+        return {
+            "required": {
+                "model_path": (
+                    ["svdq-int4-flux.1-dev"],
+                    {"tooltip": "The SVDQuant quantized FLUX.1 models."},
+                ),
+                "cache_threshold": (
+                    "FLOAT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 1,
+                        "step": 0.001,
+                        "tooltip": "Adjusts the caching tolerance like `residual_diff_threshold` in WaveSpeed. "
+                        "Increasing the value enhances speed at the cost of quality. "
+                        "A typical setting is 0.12. Setting it to 0 disables the effect.",
+                    },
+                ),
+                "attention": (
+                    attention_options,
+                    {
+                        "default": attention_options[0],
+                        "tooltip": "Attention implementation. The default implementation is `flash-attention2`. "
+                        "`nunchaku-fp16` use FP16 attention, offering ~1.2× speedup. "
+                        "Note that 20-series GPUs can only use `nunchaku-fp16`.",
+                    },
+                ),
+                "cpu_offload": (
+                    ["disable"],
+                    {
+                        "default": "auto",
+                        "tooltip": "Whether to enable CPU offload for the transformer model."
+                        "auto' will enable it if the GPU memory is less than 14G.",
+                    },
+                ),
+                "device_id": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 0,
+                        "step": 1,
+                        "display": "number",
+                        "lazy": True,
+                        "tooltip": "The GPU device ID to use for the model.",
+                    },
+                ),
+                "data_type": (
+                    dtype_options,
+                    {
+                        "default": dtype_options[0],
+                        "tooltip": "Specifies the model's data type. Default is `bfloat16`. "
+                        "For 20-series GPUs, which do not support `bfloat16`, use `float16` instead.",
+                    },
+                ),
+            },
+            "optional": {
+                "i2f_mode": (
+                    ["enabled", "always"],
+                    {
+                        "default": "enabled",
+                        "tooltip": "The GEMM implementation for 20-series GPUs"
+                        "— this option is only applicable to these GPUs.",
+                    },
+                )
+            },
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    CATEGORY = "Nunchaku"
+    NODE_DISPLAY_NAME = "Nunchaku FLUX DiT Loader"
+
+
+class NunchakuTextEncoderLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model_type": (["flux"],),
+                "text_encoder1": (folder_paths.get_filename_list("text_encoders"),),
+                "text_encoder2": (folder_paths.get_filename_list("text_encoders"),),
+                "t5_min_length": (
+                    "INT",
+                    {
+                        "default": 512,
+                        "min": 256,
+                        "max": 1024,
+                        "step": 128,
+                        "display": "number",
+                        "lazy": True,
+                    },
+                ),
+                "use_4bit_t5": (["disable"],),
+                "int4_model": (
+                    ["none"],
+                    {"tooltip": "The name of the 4-bit T5 model."},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.CLIP,)
+    # FUNCTION = "load_text_encoder"
+    CATEGORY = "Nunchaku"
+    NODE_DISPLAY_NAME = "Nunchaku Text Encoder Loader"
+
+
+class NunchakuFluxLoraLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (
+                    data_types.MODEL,
+                    {"tooltip": "The diffusion model the LoRA will be applied to."},
+                ),
+                "lora_name": (
+                    [
+                        "to choose",
+                    ],
+                    {"tooltip": "The name of the LoRA."},
+                ),
+                "lora_strength": (
+                    "FLOAT",
+                    {
+                        "default": 1.0,
+                        "min": -100.0,
+                        "max": 100.0,
+                        "step": 0.01,
+                        "tooltip": "How strongly to modify the diffusion model. This value can be negative.",
+                    },
+                ),
+                "model_version_id": (
+                    "STRING",
+                    {
+                        "default": "",
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    OUTPUT_TOOLTIPS = ("The modified diffusion model.",)
+    FUNCTION = "load_lora"
+    NODE_DISPLAY_NAME = "Nunchaku FLUX.1 LoRA Loader"
+
+    CATEGORY = "Nunchaku"
+    DESCRIPTION = (
+        "LoRAs are used to modify the diffusion model, "
+        "altering the way in which latents are denoised such as applying styles. "
+        "You can link multiple LoRA nodes."
+    )
+
+    @classmethod
+    def VALIDATE_INPUTS(cls, lora_name, **kwargs):
+        if lora_name == "" or lora_name is None:
+            return False
+        return True
+
+    def load_lora(
+        self,
+        model,
+        lora_name,
+        lora_strength,
+        model_version_id: str = None,
+    ):
+        assigned_id = self.assigned_id
+        new_model: BizyAirNodeIO = model.copy(assigned_id)
+
+        if model_version_id is not None and model_version_id != "":
+            # use model version id as lora name
+            lora_name = (
+                f"{config_manager.get_model_version_id_prefix()}{model_version_id}"
+            )
+        new_model.add_node_data(
+            class_type="NunchakuFluxLoraLoader",
+            inputs={
+                "model": model,
+                "lora_name": lora_name,
+                "lora_strength": lora_strength,
+            },
+            outputs={"slot_index": 0},
+        )
+        return (new_model,)

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/core/common/client.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 import pprint
 import urllib.error
@@ -17,9 +18,12 @@ __all__ = ["send_request"]
 
 from dataclasses import dataclass, field
 
-from .env_var import BIZYAIR_API_KEY, BIZYAIR_DEBUG, BIZYAIR_SERVER_ADDRESS
-
-IS_API_KEY_VALID = None
+from .env_var import (
+    BIZYAIR_API_KEY,
+    BIZYAIR_DEBUG,
+    BIZYAIR_SERVER_ADDRESS,
+    create_api_key_file,
+)
 
 version_path = os.path.join(os.path.dirname(__file__), "..", "..", "version.txt")
 with open(version_path, "r") as file:
@@ -29,34 +33,39 @@ with open(version_path, "r") as file:
 @dataclass
 class APIKeyState:
     current_api_key: str = field(default=None)
-    is_valid: bool = field(default=None)
+    is_valid: bool = field(default=False)
 
 
+# Actual api key in use
 api_key_state = APIKeyState()
 
 
-def set_api_key(api_key: str = "YOUR_API_KEY", override: bool = False):
-    global BIZYAIR_API_KEY, api_key_state
-    if api_key_state.is_valid is not None and not override:
+def set_api_key(api_key: str = "YOUR_API_KEY", override: bool = False) -> bool:
+    logging.debug("client.py set_api_key called")
+    global api_key_state
+    if api_key_state.is_valid and not override:
         warnings.warn("API key has already been set and will not be overridden.")
-        return
+        return True
     if validate_api_key(api_key):
-        BIZYAIR_API_KEY = api_key
+        create_api_key_file(api_key)
         api_key_state.is_valid = True
-        print("\033[92mAPI key is set successfully.\033[0m")
+        api_key_state.current_api_key = api_key
+        logging.info("\033[92mAPI key is set successfully.\033[0m")
+        return True
     else:
-        api_key_state.is_valid = False
         warnings.warn("Invalid API key provided.")
+        return False
 
 
 def validate_api_key(api_key: str = None) -> bool:
-    global api_key_state
+    logging.debug("validating api key...")
     if not api_key or not isinstance(api_key, str):
-        warnings.warn("API key is not set.")
+        warnings.warn("invalid api_key")
         return False
+
+    is_valid = False
     # if api_key_state.current_api_key == api_key and api_key_state.is_valid is not None:
     #     return api_key_state.is_valid
-    api_key_state.current_api_key = api_key
     url = f"{BIZYAIR_SERVER_ADDRESS}/user/info"
     headers = {"accept": "application/json", "authorization": f"Bearer {api_key}"}
     try:
@@ -64,34 +73,37 @@ def validate_api_key(api_key: str = None) -> bool:
             method="GET", url=url, headers=headers, callback=None
         )
         if "message" not in response_data or response_data["message"] != "Ok":
-            api_key_state.is_valid = False
             raise ValueError(
                 f"\033[91mAPI key validation failed. API Key: {api_key}\033[0m"
             )
         else:
-            api_key_state.is_valid = True
+            is_valid = True
     except ConnectionError as ce:
-        api_key_state.is_valid = False
         raise ValueError(f"\033[91mConnection error: {ce}\033[0m")
     except PermissionError as pe:
-        api_key_state.is_valid = False
         raise ValueError(
             f"\033[91mError validating API key: {api_key}, error: {pe}\033[0m"
         )
     except Exception as e:
-        api_key_state.is_valid = False
         raise ValueError(f"\033[91mOther error: {e}\033[0m")
-    return api_key_state.is_valid
+
+    logging.debug(f"api key validated: {is_valid}")
+    return is_valid
 
 
 def get_api_key() -> str:
-    global BIZYAIR_API_KEY
+    logging.debug("client.py get_api_key called")
+    global api_key_state
     try:
-        validate_api_key(BIZYAIR_API_KEY)
+        if not api_key_state.is_valid:
+            if validate_api_key(BIZYAIR_API_KEY):
+                api_key_state.is_valid = True
+                api_key_state.current_api_key = BIZYAIR_API_KEY
+                logging.info("API key set successfully")
     except Exception as e:
-        print(str(e))
+        logging.error(str(e))
         raise ValueError(str(e))
-    return BIZYAIR_API_KEY
+    return api_key_state.current_api_key
 
 
 def _headers():
@@ -141,8 +153,8 @@ def send_request(
         error_message = str(e)
         response_body = e.read().decode("utf-8") if hasattr(e, "read") else "N/A"
         if verbose:
-            print(f"URLError encountered: {error_message}")
-            print(f"Response Body: {response_data}")
+            logging.error(f"URLError encountered: {error_message}")
+            logging.info(f"Response Body: {response_data}")
         code, message = "N/A", "N/A"
         try:
             response_dict = json.loads(response_body)
@@ -152,7 +164,7 @@ def send_request(
 
         except json.JSONDecodeError:
             if verbose:
-                print("Failed to decode response body as JSON.")
+                logging.error("Failed to decode response body as JSON.")
 
         if "Unauthorized" in error_message:
             raise PermissionError(
@@ -234,7 +246,7 @@ async def async_send_request(
                 if response.status != 200:
                     error_message = f"HTTP Status {response.status}"
                     if verbose:
-                        print(f"Error encountered: {error_message}")
+                        logging.error(f"Error encountered: {error_message}")
                     if response.status == 401:
                         raise PermissionError(
                             "Key is invalid, please refer to https://cloud.siliconflow.cn to get the API key.\n"
@@ -251,17 +263,18 @@ async def async_send_request(
                     return callback(json.loads(response_data))
                 return json.loads(response_data)
     except aiohttp.ClientError as e:
-        print(f"Error fetching data: {e}")
+        logging.error(f"Error fetching data: {e}")
         return {}
     except Exception as e:
-        print(f"Error fetching data: {str(e)}")
+        logging.error(f"Error fetching data: {str(e)}")
         return {}
 
 
 def fetch_models_by_type(
     url: str, model_type: str, *, method="GET", verbose=False
 ) -> dict:
-    if not validate_api_key(BIZYAIR_API_KEY):
+    global api_key_state
+    if not api_key_state.is_valid:
         return {}
 
     payload = {"type": model_type}

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/core/common/env_var.py

@@ -1,4 +1,5 @@
 import configparser
+import logging
 import os
 from os import environ
 from pathlib import Path
@@ -59,7 +60,7 @@ def env(key, type_, default=None):
 
 
 def load_api_key():
-
+    logging.debug("load_api_key called")
     file_path = BIZYAIR_COMFYUI_PATH / "api_key.ini"
 
     if file_path.is_file() and file_path.exists():
@@ -73,6 +74,7 @@ def load_api_key():
 
 
 def create_api_key_file(api_key):
+    logging.debug("create_api_key_file called")
     config = configparser.ConfigParser()
     config["auth"] = {"api_key": api_key}
     file_path = BIZYAIR_COMFYUI_PATH / "api_key.ini"
@@ -84,9 +86,9 @@ def create_api_key_file(api_key):
 
 
 #   production:
-#     service_address: https://bizyair-api.siliconflow.cn/x/v1
+#     service_address: https://api.bizyair.cn/x/v1
 #   uat:
-#     service_address: https://uat-bizyair-api.siliconflow.cn/x/v1
+#     service_address: https://uat-api.bizyair.cn/x/v1
 _BIZYAIR_DOMAIN = os.getenv("BIZYAIR_DOMAIN", "https://api.bizyair.cn")
 BIZYAIR_DOMAIN = ServerAddress(_BIZYAIR_DOMAIN)
 BIZYAIR_X_SERVER = f"{_BIZYAIR_DOMAIN}/x/v1"
@@ -94,6 +96,7 @@ BIZYAIR_Y_SERVER = f"{_BIZYAIR_DOMAIN}/y/v1"
 
 BIZYAIR_SERVER_ADDRESS = ServerAddress(BIZYAIR_X_SERVER)
 
+# Initial value, DO NOT CHANGE IN ACTUAL CODE!!!
 BIZYAIR_API_KEY = env("BIZYAIR_API_KEY", str, load_api_key()[1])
 # Development Settings
 BIZYAIR_DEV_REQUEST_URL = env("BIZYAIR_DEV_REQUEST_URL", str, None)

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/core/configs/models.json

@@ -82,6 +82,7 @@
     "t5xxl_fp16.safetensors",
     "t5xxl_fp8_e4m3fn.safetensors"
   ],
+  "text_encoders":["t5xxl_fp16.safetensors","clip_l.safetensors"],
   "upscale_models": [
     "4x_NMKD-Siax_200k.pth",
     "RealESRGAN_x4plus.pth",

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/core/configs/models.yaml

@@ -52,6 +52,17 @@ model_rules:
           unet_name:
             - ^flux/flux1-schnell.sft$
 
+  - mode_type: unet
+    base_model: FLUX
+    describe: NunchakuFluxDiT
+    score: 5
+    route: /supernode/bizyair-flux-nunchaku1-unet
+    nodes:
+      - class_type: NunchakuFluxDiTLoader
+        inputs:
+          model_path:
+            - '.*'
+
   - mode_type: unet
     base_model: Shuttle
     describe: shuttle-3.1-aesthetic

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/misc/auth.py

@@ -1,23 +1,17 @@
+import logging
 import os
 import uuid
 from pathlib import Path
 
-import bizyengine.core
+import bizyengine.core.common
 import server
 from aiohttp import web
-from bizyengine.core.common import create_api_key_file, load_api_key, validate_api_key
 
-API_KEY = None
 # html_file_path = Path(os.path.dirname(os.path.abspath(__file__))) / "set_api_key.html"
 # with open(html_file_path, "r", encoding="utf-8") as htmlfile:
 #     set_api_key_html = htmlfile.read()
 
 
-has_key, api_key = load_api_key()
-if has_key:
-    API_KEY = api_key
-
-
 # @server.PromptServer.instance.routes.get("/bizyair/set-api-key")
 # async def set_api_key_page(request):
 #     return web.Response(text=set_api_key_html, content_type="text/html")
@@ -25,55 +19,50 @@ if has_key:
 
 @server.PromptServer.instance.routes.post("/bizyair/set_api_key")
 async def set_api_key(request):
-    global API_KEY
     try:
         data = await request.post()
         api_key = data.get("api_key")
         if api_key:
-            if not validate_api_key(api_key):
+            if not bizyengine.core.common.set_api_key(api_key, True):
                 error_msg = "Wrong API key provided, please refer to cloud.siliconflow.cn to get the key"
-                print("set_api_key:", error_msg)
+                logging.error("set_api_key:", error_msg)
                 return web.Response(
                     text=error_msg,
                     status=400,
                 )
-            create_api_key_file(api_key)
-            API_KEY = api_key
-            bizyengine.core.set_api_key(API_KEY, override=True)
-            print("Set the key sucessfully.")
+            logging.info("Set api key sucessfully.")
             return web.Response(text="ok")
         else:
             error_msg = "No API key provided, please refer to cloud.siliconflow.cn to get the key"
-            print("set_api_key:", error_msg)
+            logging.error("set_api_key:", error_msg)
             return web.Response(
                 text=error_msg,
                 status=400,
             )
     except Exception as e:
-        print(f"set api key error: {str(e)}")
+        logging.error(f"set api key error: {str(e)}")
         return web.Response(text=str(e), status=500)
 
 
 @server.PromptServer.instance.routes.get("/bizyair/get_api_key")
 async def get_api_key(request):
-    global API_KEY
+    logging.debug("auth.py get_api_key called")
     try:
-        has_key, api_key = load_api_key()
-        if has_key:
-            API_KEY = api_key
-            bizyengine.core.set_api_key(API_KEY)
+        if bizyengine.core.common.get_api_key():
             return web.Response(text="Key has been loaded from the api_key.ini file")
         else:
+            logging.debug("getting api key from cookie")
             api_key = request.cookies.get("api_key")
             if not api_key:
-                print("No api key found in cookies")
+                logging.error("No api key found in cookies")
                 return web.Response(
                     text="No api key found in cookies, please refer to cloud.siliconflow.cn to get the key",
                     status=404,
                 )
-            API_KEY = api_key
-            bizyengine.core.set_api_key(API_KEY)
-            return web.Response(text="Key has been loaded from the cookies")
+            if bizyengine.core.common.set_api_key(api_key):
+                return web.Response(text="Key has been loaded from the cookies")
+            logging.error("cannot set api key")
+            return web.Response(text="Cannot set api key", status=500)
 
     except Exception as e:
         return web.Response(text=str(e), status=500)

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine/misc/utils.py

@@ -123,9 +123,9 @@ def format_bytes(num_bytes: int) -> str:
 
 
 def get_api_key():
-    from .auth import API_KEY
+    from bizyengine.core.common import get_api_key as bcc_get_api_key
 
-    return API_KEY
+    return bcc_get_api_key()
 
 
 def get_llm_response(

bizyengine-1.2.3/bizyengine/version.txt

@@ -0,0 +1 @@
+1.2.3

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.2
+Version: 1.2.3
 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

{bizyengine-1.2.2 → bizyengine-1.2.3}/bizyengine.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ bizyengine/bizyair_extras/nodes_image_utils.py
 bizyengine/bizyair_extras/nodes_ip2p.py
 bizyengine/bizyair_extras/nodes_janus_pro.py
 bizyengine/bizyair_extras/nodes_model_advanced.py
+bizyengine/bizyair_extras/nodes_nunchaku.py
 bizyengine/bizyair_extras/nodes_sd3.py
 bizyengine/bizyair_extras/nodes_segment_anything.py
 bizyengine/bizyair_extras/nodes_segment_anything_utils.py

bizyengine-1.2.2/bizyengine/version.txt

@@ -1 +0,0 @@
-1.2.2