bizyengine 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

bizyengine/bizy_server/api_client.py

@@ -1,3 +1,5 @@
+import asyncio
+import json
 import os
 import urllib
 
@@ -9,6 +11,7 @@ from bizyengine.core.common.env_var import (
     BIZYAIR_X_SERVER,
     BIZYAIR_Y_SERVER,
 )
+from openai import OpenAI
 
 from .errno import ErrorNo, errnos
 from .error_handler import ErrorHandler
@@ -19,6 +22,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 +1078,64 @@ 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
+
+    def forward_model_request(self, request_data):
+        try:
+            request_data["stream"] = True
+            # 硅基云API接受top_k但是openai库不支持
+            request_data.pop("top_k")
+            # 参数检查
+            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
+
+            if "model" not in request_data:
+                return None, errnos.MODEL_API_ERROR
+
+            # TODO: 前端能选择provider、model之后删除下句
+            request_data["model"] = f"SiliconFlow:{request_data['model']}"
+
+            client = OpenAI(
+                base_url=BIZYAIR_X_SERVER,
+                api_key=get_api_key(),
+                timeout=60.0,
+                max_retries=0,
+            )
+            return client.chat.completions.with_streaming_response.create(
+                **request_data
+            )
+
+        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 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
@@ -9,6 +10,7 @@ import urllib.parse
 import uuid
 
 import aiohttp
+import openai
 from server import PromptServer
 
 from .api_client import APIClient
@@ -23,6 +25,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 +960,114 @@ 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()
+
+                # 转发请求到模型服务
+                with self.api_client.forward_model_request(request_data) as response:
+                    # 创建并准备流式响应
+                    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)
+
+                    # 开始流式传输
+                    any_chunk_sent = False  # 跟踪是否发送了任何数据块
+                    try:
+                        for bytes in response.iter_bytes(1024):
+                            if bytes:
+                                await resp.write(bytes)
+                                any_chunk_sent = True
+                                await resp.drain()  # 确保数据被立即发送
+                    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)}"
+                                )
+
+                    try:
+                        await resp.write_eof()
+                    except Exception as e:
+                        print(
+                            f"\033[31m[聊天请求-{req_id}]\033[0m 结束响应时出错: {str(e)}"
+                        )
+
+                    return resp
+
+            except openai.APIConnectionError as e:
+                print("The server could not be reached")
+                print(
+                    e.__cause__
+                )  # an underlying Exception, likely raised within httpx.
+            except openai.RateLimitError:
+                print("A 429 status code was received; we should back off a bit.")
+            except openai.APIStatusError as e:
+                print("Another non-200-range status code was received")
+                print(e.status_code)
+                print(e.response)
+            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)
+
+        @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/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/misc/llm.py

@@ -18,7 +18,7 @@ from .utils import (
 
 
 async def fetch_all_models(api_key):
-    url = "https://api.siliconflow.cn/v1/models"
+    url = f"{BIZYAIR_SERVER_ADDRESS}/llm/models"
     headers = {"accept": "application/json", "authorization": f"Bearer {api_key}"}
     params = {"type": "text", "sub_type": "chat"}
 

bizyengine/misc/utils.py

@@ -8,6 +8,7 @@ import zlib
 from typing import List, Tuple, Union
 
 import numpy as np
+from bizyengine.core.common.env_var import BIZYAIR_SERVER_ADDRESS
 
 BIZYAIR_DEBUG = os.getenv("BIZYAIR_DEBUG", False)
 
@@ -135,7 +136,7 @@ def get_llm_response(
     max_tokens: int = 1024,
     temperature: float = 0.7,
 ):
-    api_url = "https://api.siliconflow.cn/v1/chat/completions"
+    api_url = f"{BIZYAIR_SERVER_ADDRESS}/chat/completions"
     API_KEY = get_api_key()
     headers = {
         "accept": "application/json",
@@ -169,7 +170,7 @@ def get_vlm_response(
     temperature: float = 0.7,
     detail: str = "auto",
 ):
-    api_url = "https://api.siliconflow.cn/v1/chat/completions"
+    api_url = f"{BIZYAIR_SERVER_ADDRESS}/chat/completions"
     API_KEY = get_api_key()
     headers = {
         "accept": "application/json",

bizyengine/version.txt

@@ -1 +1 @@
-1.2.3
+1.2.5

{bizyengine-1.2.3.dist-info → bizyengine-1.2.5.dist-info}/METADATA

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

@@ -1,13 +1,14 @@
 bizyengine/__init__.py,sha256=GP9V-JM07fz7uv_qTB43QEA2rKdrVJxi5I7LRnn_3ZQ,914
-bizyengine/version.txt,sha256=2C80rpqkG8Sgy1KaGsCJj-0J1rR5-xzETLZsNPFe6E0,6
+bizyengine/version.txt,sha256=_it8I3tabkKBiqPk9_xYIPScMiicMsliYO-JqMj209c,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=QFXzq-s2xURE9k4wLz5Hm_dxbyMH5fXhurwSYqJEZyU,39804
+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=V67smRHnVRy_vS4o3D1_uSO7to5_3ie8gVEvcIlj6QU,46439
+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=6Su2AZMMPlBcOdxgy-BWq89m9MJl7voLSWeDcdyagIo,922
 bizyengine/bizyair_extras/nodes_advanced_refluxcontrol.py,sha256=cecfjrtnjJAty9aNkhz8BlmHUC1NImkFlUDiA0COEa4,2242
@@ -50,7 +51,7 @@ 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=Bf_UAosHXyYJ1YJ93ltsvvzJDawIPPmCjVaMOW1Gw-o,10114
@@ -64,7 +65,7 @@ bizyengine/core/path_utils/path_manager.py,sha256=tRVAcpsYvfWD-tK7khLvNCZayB0wpU
 bizyengine/core/path_utils/utils.py,sha256=ksgNPyQaqilOImscLkSYizbRfDQropfxpL8tqIXardM,881
 bizyengine/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bizyengine/misc/auth.py,sha256=V7VoHZ9-ljT_gUUOOh7AeNnAyVuyiK8fiqSM8T8k948,2671
-bizyengine/misc/llm.py,sha256=6QZZpZSrHY6rmA6bmB9_cuiu34zcDKw7mAdsGiElYWQ,14332
+bizyengine/misc/llm.py,sha256=_y_NJ_38v5XziozV5f7qvYQit1MlfOphGKSttX7g_z8,14332
 bizyengine/misc/mzkolors.py,sha256=jnOHNvHzvPDqlKYFhPv4KKCuPV4izbuPPbykFsOcH-E,2588
 bizyengine/misc/nodes.py,sha256=9njflJfklynyY0XmOCCzxlq48EwaO9wfrQGyXMqxlXM,43186
 bizyengine/misc/nodes_controlnet_aux.py,sha256=9DoNT06go6fm2wjttUdPQKfqzumtEPnHUe3e93cCarc,16211
@@ -72,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=T9fPmnwUNYqYx0VYMFC_F478ru9m-8kMo_sZUZixM5s,6403
-bizyengine-1.2.3.dist-info/METADATA,sha256=d_yAXkoBXH5BoPl7jPBlBHUD1wtgHhrrcUg0VPntzss,574
-bizyengine-1.2.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-bizyengine-1.2.3.dist-info/top_level.txt,sha256=2zapzqxX-we5cRyJkGf9bd5JinRtXp3-_uDI-xCAnc0,11
-bizyengine-1.2.3.dist-info/RECORD,,
+bizyengine/misc/utils.py,sha256=_aO1lHtfDf7Bv0K4xvnZ1Fu5Y9MfMkuhkiS_g8687ng,6461
+bizyengine-1.2.5.dist-info/METADATA,sha256=_TjK2n7NeWTuZBuhivHRScZUbXPJXzPZa6-T8xYwnkA,574
+bizyengine-1.2.5.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
+bizyengine-1.2.5.dist-info/top_level.txt,sha256=2zapzqxX-we5cRyJkGf9bd5JinRtXp3-_uDI-xCAnc0,11
+bizyengine-1.2.5.dist-info/RECORD,,

{bizyengine-1.2.3.dist-info → bizyengine-1.2.5.dist-info}/WHEEL

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