bizyengine 1.2.4__tar.gz → 1.2.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.4
+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.4 → bizyengine-1.2.5}/bizyengine/bizy_server/api_client.py

@@ -11,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
@@ -1078,14 +1079,11 @@ class APIClient:
             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):
+    def forward_model_request(self, request_data):
         try:
-            import asyncio
-            import json
-
-            from .stream_response import StreamResponse
-
             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
@@ -1096,98 +1094,26 @@ class APIClient:
             ):
                 return None, errnos.MODEL_API_ERROR
 
-            # 获取用户API密钥
-            api_key = get_api_key()
-
-            # 创建自定义流式响应对象，设置60秒超时
-            response_stream = StreamResponse(request_data, timeout=60)
+            if "model" not in request_data:
+                return None, errnos.MODEL_API_ERROR
 
-            # 异步启动连接和数据请求
-            asyncio.create_task(response_stream.connect_and_request(api_key))
+            # TODO: 前端能选择provider、model之后删除下句
+            request_data["model"] = f"SiliconFlow:{request_data['model']}"
 
-            # 返回流式响应对象
-            return response_stream, None
+            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 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()

{bizyengine-1.2.4 → bizyengine-1.2.5}/bizyengine/bizy_server/server.py

@@ -10,6 +10,7 @@ import urllib.parse
 import uuid
 
 import aiohttp
+import openai
 from server import PromptServer
 
 from .api_client import APIClient
@@ -970,108 +971,69 @@ class BizyAirServer:
                 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}"
+                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缓冲
+                        },
                     )
-                    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  # 跟踪是否发送了任何数据块
+                    await resp.prepare(request)
 
-                try:
-                    async for chunk in generator:
-                        if chunk:
-                            try:
-                                await resp.write(chunk)
+                    # 开始流式传输
+                    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 (
-                                ConnectionResetError,
-                                ConnectionError,
-                                aiohttp.ClientOSError,
-                            ) as e:
+                    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(e)}"
+                                    f"\033[31m[聊天请求-{req_id}]\033[0m 写入错误消息时出错: {str(write_err)}"
                                 )
-                                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")
+                        await resp.write_eof()
                     except Exception as e:
                         print(
-                            f"\033[31m[聊天请求-{req_id}]\033[0m 写入空响应时出错: {str(e)}"
+                            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
+                    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)}"
@@ -1089,16 +1051,6 @@ class BizyAirServer:
 
                 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:

{bizyengine-1.2.4 → bizyengine-1.2.5}/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-1.2.4 → bizyengine-1.2.5}/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-1.2.5/bizyengine/version.txt

@@ -0,0 +1 @@
+1.2.5

{bizyengine-1.2.4 → bizyengine-1.2.5}/bizyengine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bizyengine
-Version: 1.2.4
+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.4/bizyengine/version.txt

@@ -1 +0,0 @@
-1.2.4