bizyengine 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

bizyengine/bizy_server/api_client.py

@@ -1,3 +1,5 @@
+import asyncio
+import json
 import os
 import urllib
 
@@ -19,6 +21,10 @@ version_path = os.path.join(os.path.dirname(__file__), "..", "version.txt")
 with open(version_path, "r") as file:
     CLIENT_VERSION = file.read().strip()
 
+# API请求地址
+QWEN_MODEL_API_URL = "https://api.siliconflow.cn/v1/chat/completions"
+QWEN_IMAGE_API_URL = "https://api.siliconflow.cn/v1/images/generations"
+
 
 class APIClient:
     def __init__(self):
@@ -1071,3 +1077,139 @@ class APIClient:
         except Exception as e:
             print(f"\033[31m[BizyAir]\033[0m Fail to get recent cost: {str(e)}")
             return None, errnos.GET_RECENT_COST
+
+    async def forward_model_request(self, request_data):
+        try:
+            import asyncio
+            import json
+
+            from .stream_response import StreamResponse
+
+            request_data["stream"] = True
+            # 参数检查
+            if "messages" not in request_data:
+                return None, errnos.MODEL_API_ERROR
+
+            if (
+                not isinstance(request_data["messages"], list)
+                or len(request_data["messages"]) == 0
+            ):
+                return None, errnos.MODEL_API_ERROR
+
+            # 获取用户API密钥
+            api_key = get_api_key()
+
+            # 创建自定义流式响应对象，设置60秒超时
+            response_stream = StreamResponse(request_data, timeout=60)
+
+            # 异步启动连接和数据请求
+            asyncio.create_task(response_stream.connect_and_request(api_key))
+
+            # 返回流式响应对象
+            return response_stream, None
+
+        except Exception as e:
+            print(f"\033[31m[BizyAir]\033[0m Model API forwarding failed: {str(e)}")
+            return None, errnos.MODEL_API_ERROR
+
+    async def stream_model_response(self, response):
+        """
+        流式传输模型响应
+
+        Args:
+            response: 从API获取的StreamResponse对象
+
+        Returns:
+            一个异步生成器，用于流式传输响应数据
+        """
+        # 生成请求ID用于日志
+        req_id = f"stream-{id(response)}"
+
+        # 验证response对象是否有效
+        if not response:
+            print(f"\033[31m[BizyAir-{req_id}]\033[0m 无效的response对象 (为None)")
+            yield b'data: {"error": "Invalid response object (None)"}\n\n'
+            yield b"data: [DONE]\n\n"
+            return
+
+        if not hasattr(response, "content") or not hasattr(
+            response.content, "iter_any"
+        ):
+            print(
+                f"\033[31m[BizyAir-{req_id}]\033[0m 无效的response对象 (缺少必要方法)"
+            )
+            yield b'data: {"error": "Invalid response object (missing methods)"}\n\n'
+            yield b"data: [DONE]\n\n"
+            return
+
+        error_occurred = False
+        chunks_forwarded = 0
+        chunk = None  # 定义在外部，以便finally块可以访问
+
+        try:
+            # 使用StreamResponse.iter_any方法创建流式传输生成器
+            async for chunk in response.content.iter_any():
+                chunks_forwarded += 1
+
+                yield chunk
+                # 是否是结束标记
+                if b"data: [DONE]" in chunk:
+                    break
+                # 是否包含错误
+                if b'data: {"error"' in chunk or b'data: {"message":' in chunk:
+                    error_occurred = True
+
+        except Exception as e:
+            error_occurred = True
+            error_msg = f"读取流式数据失败: {str(e)}"
+            print(f"\033[31m[BizyAir-{req_id}]\033[0m {error_msg}")
+
+            # 返回错误消息
+            error_json = json.dumps({"error": error_msg})
+            yield f"data: {error_json}\n\n".encode("utf-8")
+
+            # 如果还没有发送过DONE，则发送
+            if chunks_forwarded == 0 or (chunk and not b"data: [DONE]" in chunk):
+                yield b"data: [DONE]\n\n"
+
+        finally:
+            # 如果没有发生错误，但也没有转发任何数据，发送一个空响应
+            if not error_occurred and chunks_forwarded == 0:
+                yield b'data: {"content": ""}\n\n'
+                yield b"data: [DONE]\n\n"
+
+    async def release(self):
+        """关闭连接"""
+        if self.writer and not self.closed:
+            self.writer.close()
+            try:
+                await self.writer.wait_closed()
+            except Exception:
+                pass
+            self.closed = True
+
+    async def forward_image_request(self, request_data):
+        try:
+            api_key = get_api_key()
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            }
+            # 创建异步HTTP会话
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    QWEN_IMAGE_API_URL, headers=headers, json=request_data
+                ) as response:
+                    # 读取并解析响应
+                    if response.status != 200:
+                        error_text = await response.text()
+                        print(
+                            f"\033[31m[BizyAir]\033[0m Image generation failed: {error_text}"
+                        )
+                        return None, errnos.MODEL_API_ERROR
+
+                    result = await response.json()
+                    return result, None
+        except Exception as e:
+            print(f"\033[31m[BizyAir]\033[0m Image generation request failed: {str(e)}")
+            return None, errnos.MODEL_API_ERROR

bizyengine/bizy_server/errno.py

@@ -442,3 +442,18 @@ class errnos:
     GET_RECENT_COST = ErrorNo(
         500, 500157, None, {"en": "Failed to get recent cost", "zh": "获取最近消费失败"}
     )
+
+    MODEL_API_ERROR = ErrorNo(
+        500, 500158, None, {"en": "Failed to call model API", "zh": "调用模型API失败"}
+    )
+
+    MODEL_API_TIMEOUT = ErrorNo(
+        500, 500159, None, {"en": "Model API request timeout", "zh": "模型API请求超时"}
+    )
+
+    STREAMING_CONNECTION_ERROR = ErrorNo(
+        500,
+        500160,
+        None,
+        {"en": "Streaming connection closed unexpectedly", "zh": "流式连接异常关闭"},
+    )

bizyengine/bizy_server/server.py

@@ -1,5 +1,6 @@
 import asyncio
 import configparser
+import json
 import logging
 import os
 import shutil
@@ -23,6 +24,7 @@ COMMUNITY_API = f"{API_PREFIX}/community"
 MODEL_HOST_API = f"{API_PREFIX}/modelhost"
 USER_API = f"{API_PREFIX}/user"
 INVOICE_API = f"{API_PREFIX}/invoices"
+MODEL_API = f"{API_PREFIX}/model"
 
 logging.basicConfig(level=logging.DEBUG)
 
@@ -957,6 +959,163 @@ class BizyAirServer:
 
             return OKResponse(resp)
 
+        @self.prompt_server.routes.post(f"/{MODEL_API}/chat")
+        async def chat_completions(request):
+            response = None  # 确保变量在退出前定义
+            resp = None  # 响应对象引用
+            req_id = f"req-{id(request)}"  # 为请求生成唯一ID
+
+            try:
+                # 解析请求数据
+                request_data = await request.json()
+
+                # 转发请求到模型服务
+                response, err = await self.api_client.forward_model_request(
+                    request_data
+                )
+                if err is not None:
+                    print(
+                        f"\033[31m[聊天请求-{req_id}]\033[0m 转发请求失败: {err.message}"
+                    )
+                    return ErrResponse(err)
+
+                # 创建并准备流式响应
+                resp = aiohttp.web.StreamResponse(
+                    status=200,
+                    reason="OK",
+                    headers={
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-cache",
+                        "Connection": "keep-alive",
+                        "X-Accel-Buffering": "no",  # 禁用Nginx缓冲
+                    },
+                )
+                await resp.prepare(request)
+
+                # 确保异步生成器正确创建
+                generator = self.api_client.stream_model_response(response)
+                if not generator:
+                    print(f"\033[31m[聊天请求-{req_id}]\033[0m 创建异步生成器失败")
+                    # 返回错误响应
+                    if not resp.prepared:
+                        return ErrResponse(errnos.MODEL_API_ERROR)
+                    else:
+                        # 如果响应已准备，发送错误数据帧
+                        try:
+                            error_msg = json.dumps({"error": "创建数据流失败"})
+                            await resp.write(f"data: {error_msg}\n\n".encode("utf-8"))
+                            await resp.write(b"data: [DONE]\n\n")
+                        except Exception as e:
+                            print(
+                                f"\033[31m[聊天请求-{req_id}]\033[0m 写入错误消息时出错: {str(e)}"
+                            )
+                        finally:
+                            try:
+                                await resp.write_eof()
+                            except:
+                                pass
+                        return resp
+
+                # 开始流式传输
+                any_chunk_sent = False  # 跟踪是否发送了任何数据块
+
+                try:
+                    async for chunk in generator:
+                        if chunk:
+                            try:
+                                await resp.write(chunk)
+                                any_chunk_sent = True
+                                await resp.drain()  # 确保数据被立即发送
+                            except (
+                                ConnectionResetError,
+                                ConnectionError,
+                                aiohttp.ClientOSError,
+                            ) as e:
+                                print(
+                                    f"\033[31m[聊天请求-{req_id}]\033[0m 流式传输中连接错误: {str(e)}"
+                                )
+                                break
+                except Exception as e:
+                    print(f"\033[31m[聊天请求-{req_id}]\033[0m 流式传输错误: {str(e)}")
+                    # 如果尚未发送任何数据块，尝试发送错误信息
+                    if not any_chunk_sent and not resp.prepared:
+                        return ErrResponse(errnos.MODEL_API_ERROR)
+                    elif not any_chunk_sent:
+                        try:
+                            error_msg = json.dumps({"error": f"流式传输错误: {str(e)}"})
+                            await resp.write(f"data: {error_msg}\n\n".encode("utf-8"))
+                            await resp.write(b"data: [DONE]\n\n")
+                        except Exception as write_err:
+                            print(
+                                f"\033[31m[聊天请求-{req_id}]\033[0m 写入错误消息时出错: {str(write_err)}"
+                            )
+
+                # 检查是否发送了数据
+                if not any_chunk_sent:
+                    print(
+                        f"\033[33m[聊天请求-{req_id}]\033[0m 警告: 没有发送任何数据块"
+                    )
+                    try:
+                        await resp.write(b'data: {"content": ""}\n\n')
+                        await resp.write(b"data: [DONE]\n\n")
+                    except Exception as e:
+                        print(
+                            f"\033[31m[聊天请求-{req_id}]\033[0m 写入空响应时出错: {str(e)}"
+                        )
+
+                try:
+                    await resp.write_eof()
+                except Exception as e:
+                    print(
+                        f"\033[31m[聊天请求-{req_id}]\033[0m 结束响应时出错: {str(e)}"
+                    )
+
+                return resp
+
+            except Exception as e:
+                print(
+                    f"\033[31m[聊天请求-{req_id}]\033[0m 处理请求时发生错误: {str(e)}"
+                )
+                # 如果响应已经准备好，尝试发送错误信息
+                if resp and resp.prepared:
+                    try:
+                        error_msg = json.dumps({"error": f"服务器错误: {str(e)}"})
+                        await resp.write(f"data: {error_msg}\n\n".encode("utf-8"))
+                        await resp.write(b"data: [DONE]\n\n")
+                        await resp.write_eof()
+                    except:
+                        pass
+                    return resp
+
+                return ErrResponse(errnos.MODEL_API_ERROR)
+
+            finally:
+                # 确保所有资源被释放
+                if response and hasattr(response, "release"):
+                    try:
+                        await response.release()
+                    except Exception as e:
+                        print(
+                            f"\033[31m[聊天请求-{req_id}]\033[0m 关闭连接时出错: {str(e)}"
+                        )
+
+        @self.prompt_server.routes.post(f"/{MODEL_API}/images")
+        async def image_generations(request):
+            try:
+                # 解析请求数据
+                request_data = await request.json()
+
+                # 转发图像生成请求
+                result, err = await self.api_client.forward_image_request(request_data)
+                if err is not None:
+                    return ErrResponse(err)
+
+                # 返回结果
+                return OKResponse(result)
+
+            except Exception:
+                return ErrResponse(errnos.MODEL_API_ERROR)
+
     async def send_json(self, event, data, sid=None):
         message = {"type": event, "data": data}
 

bizyengine/bizy_server/stream_response.py

@@ -0,0 +1,268 @@
+import asyncio
+import json
+import ssl
+from typing import Any, Dict, List, Optional
+
+
+class ConnectionState:
+    """连接状态枚举"""
+
+    INIT = "初始化"
+    CONNECTING = "连接中"
+    CONNECTED = "已连接"
+    READING = "读取中"
+    CLOSING = "关闭中"
+    CLOSED = "已关闭"
+    ERROR = "错误"
+
+
+class StreamResponse:
+    """自定义流式响应类，支持状态管理和错误处理"""
+
+    def __init__(self, request_data: Dict[str, Any], timeout: int = 60):
+        # 请求和连接数据
+        self.request_data = request_data
+        self.reader = None
+        self.writer = None
+        self.timeout = timeout
+
+        # 连接状态管理
+        self.state = ConnectionState.INIT
+        self.state_lock = asyncio.Lock()  # 状态修改锁
+        self.connection_event = asyncio.Event()
+        self.error = None
+
+        # 数据相关
+        self.content = self
+        self.buffer = b""
+        self.chunks_received = 0
+        self.done_received = False
+
+        # 调试信息
+        self.debug_id = id(self)  # 用于日志区分不同实例
+
+    async def _set_state(self, new_state: str, error: Exception = None) -> None:
+        """线程安全地设置连接状态"""
+        async with self.state_lock:
+            self.state = new_state
+            if error:
+                self.error = error
+
+            # 如果状态为已连接，触发连接事件
+            if new_state == ConnectionState.CONNECTED:
+                self.connection_event.set()
+
+            # 如果状态为错误，也触发连接事件，让等待连接的代码继续执行并处理错误
+            if new_state == ConnectionState.ERROR:
+                self.connection_event.set()
+
+    async def connect_and_request(self, api_key: str):
+        """建立连接并发送请求，包含严格的状态管理"""
+        # 设置状态为连接中
+        await self._set_state(ConnectionState.CONNECTING)
+
+        try:
+            # 建立SSL连接，添加超时控制
+            connect_coro = asyncio.open_connection("api.siliconflow.cn", 443, ssl=True)
+            self.reader, self.writer = await asyncio.wait_for(
+                connect_coro, timeout=self.timeout
+            )
+
+            # 准备HTTP请求
+            json_data = json.dumps(self.request_data)
+            request = (
+                f"POST /v1/chat/completions HTTP/1.1\r\n"
+                f"Host: api.siliconflow.cn\r\n"
+                f"Authorization: Bearer {api_key}\r\n"
+                f"Accept: text/event-stream\r\n"
+                f"Content-Type: application/json\r\n"
+                f"Content-Length: {len(json_data)}\r\n"
+                f"Connection: keep-alive\r\n"
+                f"\r\n"
+                f"{json_data}"
+            )
+
+            # 检查是否仍在连接状态
+            async with self.state_lock:
+                if self.state != ConnectionState.CONNECTING:
+                    raise Exception(f"连接状态已变更为 {self.state}，无法发送请求")
+
+            # 发送请求
+            self.writer.write(request.encode("utf-8"))
+            await asyncio.wait_for(self.writer.drain(), timeout=self.timeout)
+
+            # 读取HTTP响应头
+            response_line = await asyncio.wait_for(
+                self.reader.readline(), timeout=self.timeout
+            )
+            if not response_line:
+                raise Exception("服务器关闭了连接")
+
+            status_line = response_line.decode("utf-8").strip()
+
+            if not status_line.startswith("HTTP/1.1 200"):
+                raise Exception(f"API请求失败: {status_line}")
+
+            # 读取响应头
+            headers = {}
+            while True:
+                # 再次检查状态
+                async with self.state_lock:
+                    if self.state != ConnectionState.CONNECTING:
+                        raise Exception(
+                            f"连接状态已变更为 {self.state}，停止读取响应头"
+                        )
+
+                line = await asyncio.wait_for(
+                    self.reader.readline(), timeout=self.timeout
+                )
+                if line == b"\r\n" or not line:
+                    break
+
+                try:
+                    header_line = line.decode("utf-8").strip()
+                    if ":" in header_line:
+                        key, value = header_line.split(":", 1)
+                        headers[key.strip()] = value.strip()
+                except Exception:
+                    pass
+
+            # 成功连接
+            await self._set_state(ConnectionState.CONNECTED)
+
+        except asyncio.TimeoutError as e:
+            await self._set_state(ConnectionState.ERROR, e)
+            await self.release()
+            raise Exception(f"连接超时 (>{self.timeout}秒)") from e
+
+        except Exception as e:
+            await self._set_state(ConnectionState.ERROR, e)
+            await self.release()
+            raise Exception(f"连接失败: {str(e)}") from e
+
+    async def iter_any(self):
+        """模拟aiohttp的iter_any方法"""
+        # 等待连接完成
+        if not self.connection_event.is_set():
+            try:
+                await asyncio.wait_for(
+                    self.connection_event.wait(), timeout=self.timeout
+                )
+            except asyncio.TimeoutError as e:
+                await self._set_state(ConnectionState.ERROR, e)
+                await self.release()
+                raise Exception(f"等待连接超时 (>{self.timeout}秒)") from e
+
+        # 检查连接状态
+        async with self.state_lock:
+            if self.state == ConnectionState.ERROR:
+                error_msg = f"连接发生错误: {str(self.error)}"
+                raise Exception(error_msg) from self.error
+
+            if self.state != ConnectionState.CONNECTED:
+                error_msg = f"连接状态为 {self.state}，无法读取数据"
+                raise Exception(error_msg)
+
+            # 设置状态为读取中
+            self.state = ConnectionState.READING
+
+        # 读取数据
+        try:
+            max_empty_chunks = 3  # 连续空块计数，防止无限循环
+            empty_chunk_count = 0
+
+            while True:
+                # 检查状态
+                async with self.state_lock:
+                    if self.state != ConnectionState.READING:
+                        break
+
+                try:
+                    # 读取一段数据，添加超时控制
+                    chunk = await asyncio.wait_for(
+                        self.reader.read(1024), timeout=self.timeout
+                    )
+
+                    # 检测连续空块，防止无限循环
+                    if not chunk:
+                        empty_chunk_count += 1
+                        if empty_chunk_count >= max_empty_chunks:
+                            break
+                        # 给个短暂的休息，避免CPU过度使用
+                        await asyncio.sleep(0.05)
+                        continue
+                    else:
+                        empty_chunk_count = 0
+
+                    # 更新计数并生成数据
+                    self.chunks_received += 1
+                    yield chunk
+
+                    # 检查是否接收到了结束标记 [DONE]
+                    if b"data: [DONE]" in chunk:
+                        self.done_received = True
+                        break
+
+                except asyncio.TimeoutError as e:
+                    await self._set_state(ConnectionState.ERROR, e)
+                    break
+
+                except (ConnectionError, OSError) as e:
+                    await self._set_state(ConnectionState.ERROR, e)
+                    break
+
+        except Exception as e:
+            await self._set_state(ConnectionState.ERROR, e)
+            error_msg = f"读取数据失败: {str(e)}"
+            raise
+        finally:
+            # 关闭连接
+            await self.release()
+
+    async def release(self):
+        """安全关闭连接并释放资源"""
+        async with self.state_lock:
+            # 检查是否已经在关闭或已关闭状态
+            if self.state in [ConnectionState.CLOSING, ConnectionState.CLOSED]:
+                return
+
+            # 设置状态为关闭中
+            self.state = ConnectionState.CLOSING
+
+        # 关闭写入端
+        if self.writer:
+            writer = self.writer
+            self.writer = None  # 清除引用
+            self.reader = None  # 清除引用
+
+            try:
+                # 尝试优雅关闭
+                if not writer.is_closing():
+                    # 先确保发送所有数据
+                    try:
+                        await asyncio.wait_for(writer.drain(), timeout=1.0)
+                    except (asyncio.TimeoutError, ConnectionError, OSError):
+                        # 忽略drain错误
+                        pass
+
+                    # 写入EOF标记
+                    try:
+                        writer.write_eof()
+                    except (OSError, RuntimeError):
+                        # 忽略无法写入EOF的错误
+                        pass
+
+                    # 关闭连接
+                    writer.close()
+
+                # 等待连接关闭完成
+                try:
+                    await asyncio.wait_for(writer.wait_closed(), timeout=2.0)
+                except (asyncio.TimeoutError, ConnectionError, OSError, RuntimeError):
+                    # 忽略等待关闭的错误
+                    pass
+            except Exception:
+                pass
+
+        # 设置为已关闭状态
+        await self._set_state(ConnectionState.CLOSED)

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/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/core/commands/servers/prompt_server.py

@@ -104,7 +104,7 @@ class BizyAirTask:
         return self.get_data(len(self.data_pool) - 1)
 
     def do_task_until_completed(
-        self, *, timeout: int = 600, poll_interval: float = 1
+        self, *, timeout: int = 3600, poll_interval: float = 1
     ) -> list[dict]:
         offset = 0
         start_time = time.time()
@@ -169,7 +169,7 @@ class PromptServer(Command):
             if BizyAirTask.check_inputs(result):
                 self.cache_manager.set(cache_key, result)
                 bz_task = BizyAirTask.from_data(result, check_inputs=False)
-                bz_task.do_task_until_completed(timeout=10 * 60)  # 10 minutes
+                bz_task.do_task_until_completed(timeout=60 * 60)  # 60 minutes
                 last_data = bz_task.get_last_data()
                 response_data = last_data.get("data")
             out = response_data["payload"]

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/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/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/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/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/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/version.txt

@@ -1 +1 @@
-1.2.2
+1.2.4

{bizyengine-1.2.2.dist-info → bizyengine-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.2
+Version: 1.2.4
 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.dist-info → bizyengine-1.2.4.dist-info}/RECORD

@@ -1,15 +1,16 @@
 bizyengine/__init__.py,sha256=GP9V-JM07fz7uv_qTB43QEA2rKdrVJxi5I7LRnn_3ZQ,914
-bizyengine/version.txt,sha256=xipcxhrEUlk1dT9ewoTAoFKksdpLOjWA3OK313ohVK4,6
+bizyengine/version.txt,sha256=VjoLTuw8d7vDSsYw1PpSFPXGcmrgFGhAT9cERzEQCE4,6
 bizyengine/bizy_server/__init__.py,sha256=SP9oSblnPo4KQyh7yOGD26YCskFAcQHAZy04nQBNRIw,200
-bizyengine/bizy_server/api_client.py,sha256=sTX_LQq9JFLSRYjn6beaOw3x5F5JYp0iTehuzcUwyhg,37225
-bizyengine/bizy_server/errno.py,sha256=iiel-LhT2o7v2BJpJn_mbVLG9Ett8WbqrT21B9j8hpA,15375
+bizyengine/bizy_server/api_client.py,sha256=VDdAwCi4NL1HtqVuIOopUBjxhRjLjhxBKVFraOXI01M,42386
+bizyengine/bizy_server/errno.py,sha256=nEr_A6ARwgIwlr1PFP8eg-HNAzz9r7l00fTKaq-ipxM,15826
 bizyengine/bizy_server/error_handler.py,sha256=MGrfO1AEqbfEgMWPL8B6Ypew_zHiQAdYGlhN9bZohrY,167
 bizyengine/bizy_server/execution.py,sha256=ayaEf6eGJKQsVZV-1_UlGlvwwmlH7FEek31Uq-MbUjA,1644
 bizyengine/bizy_server/profile.py,sha256=f4juAzJ73gCm0AhagYpt9WnG8HEI6xze_U96-omBLqU,3044
 bizyengine/bizy_server/resp.py,sha256=iOFT5Ud7VJBP2uqkojJIgc3y2ifMjjEXoj0ewneL9lc,710
-bizyengine/bizy_server/server.py,sha256=0rI_8m3jR_x2DsVEN0czWWO2mdaF7OyzXnnCnL3YRQc,41483
+bizyengine/bizy_server/server.py,sha256=qpbvT55Hp3C_XlEyQcW_XQVecOkn4dRzjhE0nA3Wd0g,48518
+bizyengine/bizy_server/stream_response.py,sha256=H2XHqlVRtQMhgdztAuG7l8-iV_Pm42u2x6WJ0gNVIW0,9654
 bizyengine/bizy_server/utils.py,sha256=C5tnMhvdtrrvwuCex3oERIGWrTWVb5dkXD1Txb5sJaE,2568
-bizyengine/bizyair_extras/__init__.py,sha256=Lnf-6vOrpkmzZ1H_AiBKlRo0pPt_A8HyUqGDXCZKOIc,892
+bizyengine/bizyair_extras/__init__.py,sha256=6Su2AZMMPlBcOdxgy-BWq89m9MJl7voLSWeDcdyagIo,922
 bizyengine/bizyair_extras/nodes_advanced_refluxcontrol.py,sha256=cecfjrtnjJAty9aNkhz8BlmHUC1NImkFlUDiA0COEa4,2242
 bizyengine/bizyair_extras/nodes_cogview4.py,sha256=Ni0TDOycczyDhYPvSR68TxGV_wE2uhaxd8MIj-J4-3o,2031
 bizyengine/bizyair_extras/nodes_comfyui_detail_daemon.py,sha256=i71it24tiGvZ3h-XFWISr4CpZszUtPuz3UrZARYluLk,6169
@@ -25,6 +26,7 @@ bizyengine/bizyair_extras/nodes_image_utils.py,sha256=f49VDIwI6opHwCuM4n8GKGtute
 bizyengine/bizyair_extras/nodes_ip2p.py,sha256=GSEFJvrs4f2tv0xwYkWqc8uhsXrzAJVPvvwcw0gTjR0,619
 bizyengine/bizyair_extras/nodes_janus_pro.py,sha256=hAdMsS09RkRHZn9cNwpmyOaH7ODOMjVt9SbBsD-UvbM,2665
 bizyengine/bizyair_extras/nodes_model_advanced.py,sha256=s-dbFRWCdsTxctFYaZtmVwZ8-xuPPHixtkHFCmR7zcs,1755
+bizyengine/bizyair_extras/nodes_nunchaku.py,sha256=trvQyHwYcT3mxV9-t2SR0pXk_qj0UHLqirlj3htaRc8,6832
 bizyengine/bizyair_extras/nodes_sd3.py,sha256=lZCxj0IFmuxk1fZTDcRKgVV5QWHjkUdpR4w9-DZbMf4,1727
 bizyengine/bizyair_extras/nodes_segment_anything.py,sha256=9Aeu4A2c2hA-Gu6kY6cINmZ3Y6DVXhWJCLjcW4M_v5o,7231
 bizyengine/bizyair_extras/nodes_segment_anything_utils.py,sha256=ZefAqrFrevDH3XY_wipr_VwKfeXrgpZEUFaqg_JGOdU,4714
@@ -49,20 +51,20 @@ bizyengine/core/commands/invoker.py,sha256=8wcIMd8k44o96LAvxFrIiKOlVtf1MW-AcMDXs
 bizyengine/core/commands/processors/model_hosting_processor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bizyengine/core/commands/processors/prompt_processor.py,sha256=0PxSCvhI4gZmV3cEjJl8lKNb08EFemFVRRXrupedNdU,4467
 bizyengine/core/commands/servers/model_server.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bizyengine/core/commands/servers/prompt_server.py,sha256=P-kRDXSRUkQvyZY16XOGsM4RbOo3-NWM9exJT1kGVHE,8139
+bizyengine/core/commands/servers/prompt_server.py,sha256=mGkwhY7qVeCDNFmmP-Bh-V_uX3cVkH7FAaIrjpcsEWg,8140
 bizyengine/core/common/__init__.py,sha256=GicZw6YeAZk1PsKmFDt9dm1F75zPUlpia9Q_ki5vW1Y,179
 bizyengine/core/common/caching.py,sha256=isliSZsQyrNjXmupW-BaZ2EoVF5G8t7aHAhbcELAn5M,6253
-bizyengine/core/common/client.py,sha256=SohohVYSAja8nHZpK1kaDNbdH0qPH638-a8xUDMxTqI,9761
-bizyengine/core/common/env_var.py,sha256=hKU1Wx5p3Ook1ydnpxmDSH828Kwy1r_fKgTpZWtDEWA,3138
+bizyengine/core/common/client.py,sha256=Bf_UAosHXyYJ1YJ93ltsvvzJDawIPPmCjVaMOW1Gw-o,10114
+bizyengine/core/common/env_var.py,sha256=ZiJc5G84MgVMRj7yxI7WWt8lmmanJiGSWl23NyWLbg4,3266
 bizyengine/core/common/utils.py,sha256=bm-XmSPy83AyjD0v5EfWp6jiO6_5p7rkZ_HQAuVmgmo,3086
 bizyengine/core/configs/conf.py,sha256=D_UWG9SSJnK5EhbrfNFryJQ8hUwwdvhOGlq1TielwpI,3830
-bizyengine/core/configs/models.json,sha256=ut_ZbbdSJtAiG6DSHYoKKR2MUN7j-vnklJQVfJ7rwbg,2589
-bizyengine/core/configs/models.yaml,sha256=cEPRq5lsFWohqmjwTd7aM9Vy-WXwEec0rX627dQG-XU,8154
+bizyengine/core/configs/models.json,sha256=jCrqQgjVeHugLb191Xay5rg0m3duTVISPp_GxVGQ3HA,2656
+bizyengine/core/configs/models.yaml,sha256=Gbr5k-Yak_ybbPK50eK5wb6gKfDIWjdQ9QCVc7BvZ0Y,8399
 bizyengine/core/path_utils/__init__.py,sha256=5K9n4sexva0rfuYj3HcxdYeWnA1TuLTjpGGMFBTgnhM,240
 bizyengine/core/path_utils/path_manager.py,sha256=tRVAcpsYvfWD-tK7khLvNCZayB0wpU9L0tRTH4ZESzM,10549
 bizyengine/core/path_utils/utils.py,sha256=ksgNPyQaqilOImscLkSYizbRfDQropfxpL8tqIXardM,881
 bizyengine/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-bizyengine/misc/auth.py,sha256=d3ptxii981cdBq14p6nQnDMWkNsI0HmoWNOebwtcUQI,2814
+bizyengine/misc/auth.py,sha256=V7VoHZ9-ljT_gUUOOh7AeNnAyVuyiK8fiqSM8T8k948,2671
 bizyengine/misc/llm.py,sha256=6QZZpZSrHY6rmA6bmB9_cuiu34zcDKw7mAdsGiElYWQ,14332
 bizyengine/misc/mzkolors.py,sha256=jnOHNvHzvPDqlKYFhPv4KKCuPV4izbuPPbykFsOcH-E,2588
 bizyengine/misc/nodes.py,sha256=9njflJfklynyY0XmOCCzxlq48EwaO9wfrQGyXMqxlXM,43186
@@ -71,8 +73,8 @@ bizyengine/misc/nodes_controlnet_union_sdxl.py,sha256=e6Zs7unfPU-18VCLGgZXFOa0x1
 bizyengine/misc/route_sam.py,sha256=-bMIR2QalfnszipGxSxvDAHGJa5gPSrjkYPb5baaRg4,1561
 bizyengine/misc/segment_anything.py,sha256=RRm8FOfDY9VxdVrLjcdzJRh2pSM-kmNcCySuYnx9l7w,8677
 bizyengine/misc/supernode.py,sha256=MPoJN6H_oCV00lmv1LWtGdQwTlyQPI6gXdMDXgkFd7g,4197
-bizyengine/misc/utils.py,sha256=FRDEy63vDpssQxSFXrlK6WuXu15dNitYDIGGNOqtdH8,6353
-bizyengine-1.2.2.dist-info/METADATA,sha256=xk30yqMzfcY4UR1DqbDNX-Fq61jOY4fWUPQ2_wYkEjo,574
-bizyengine-1.2.2.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
-bizyengine-1.2.2.dist-info/top_level.txt,sha256=2zapzqxX-we5cRyJkGf9bd5JinRtXp3-_uDI-xCAnc0,11
-bizyengine-1.2.2.dist-info/RECORD,,
+bizyengine/misc/utils.py,sha256=T9fPmnwUNYqYx0VYMFC_F478ru9m-8kMo_sZUZixM5s,6403
+bizyengine-1.2.4.dist-info/METADATA,sha256=sH5YllXjbdg1c1r3s-I_AKIZ5Q7NKCPqSh7Pb_T6o0s,574
+bizyengine-1.2.4.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+bizyengine-1.2.4.dist-info/top_level.txt,sha256=2zapzqxX-we5cRyJkGf9bd5JinRtXp3-_uDI-xCAnc0,11
+bizyengine-1.2.4.dist-info/RECORD,,

{bizyengine-1.2.2.dist-info → bizyengine-1.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.0)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any