bizyengine 1.2.2__tar.gz → 1.2.4__tar.gz

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

@@ -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 → bizyengine-1.2.4}/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-1.2.2 → bizyengine-1.2.4}/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-1.2.2 → bizyengine-1.2.4}/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-1.2.4/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-1.2.2 → bizyengine-1.2.4}/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 *