Update app.py

app.py

@@ -6,30 +6,40 @@ import time
 import os
 import re
 import logging
+from itertools import cycle
 
 # 配置日志输出（可调整级别为DEBUG以获得更详细日志）
 logging.basicConfig(level=logging.INFO)
-
 _COOKIES = os.getenv("COOKIES", "")
+
 API_KEY = os.getenv("API_KEY", "linux.do")
-if not API_KEY:
-    logging.warning("API_KEY 未设置！")
 
 app = Flask(__name__)
 
+COOKIES = _COOKIES.split(',')
+iterator = cycle(COOKIES)
+
+cookie_index = 0
+
+def get_cookie():
+    return next(iterator)
+
 @app.before_request
 def check_api_key():
-    auth = request.headers.get("Authorization", "")
-    if auth != f"Bearer {API_KEY}":
-        logging.warning("未经授权的访问尝试，传入的 key: %s", auth)
+    key = request.headers.get("Authorization")
+    if key != "Bearer " + API_KEY:
+        logging.warning("Unauthorized access attempt with key: %s", key)
         return jsonify({"success": False, "message": "Unauthorized: Invalid API key"}), 403
 
 @app.route('/v1/models', methods=['GET'])
 def get_models():
-    logging.info("收到 /v1/models 请求")
-    headers = {"Content-Type": "application/json", "Cookie": _COOKIES}
+    logging.info("Received /v1/models request")
+    _cookie = get_cookie()
+    logging.info(_cookie[:50])
+    headers = {"Content-Type": "application/json", "Cookie": _cookie}
     response = requests.get('https://chat.akash.network/api/models', headers=headers)
     models_data = response.json()
+    print(models_data)
     current_timestamp = int(time.time())
     converted_data = {
         "object": "list",
@@ -50,66 +60,66 @@ def get_models():
                 "description": model.get("description"),
                 "available": model.get("available")
             }
-            for model in models_data.get("models", [])
+            for model in models_data
         ]
     }
-    logging.info("返回 /v1/models 响应: %s", json.dumps(converted_data, ensure_ascii=False))
+    logging.info("Response for /v1/models: %s", json.dumps(converted_data, ensure_ascii=False))
     return jsonify(converted_data)
 
-def build_chunk(chat_id, model, token=None, finish_reason=None):
-    """
-    构造单个 chunk 数据，符合 OpenAI API 流式响应格式。
-    """
-    chunk = {
-        "id": f"chatcmpl-{chat_id}",
-        "object": "chat.completion.chunk",
-        "created": int(time.time()),
-        "model": model,
-        "choices": [{
-            "delta": {"content": token} if token is not None else {},
-            "index": 0,
-            "finish_reason": finish_reason
-        }]
-    }
-    return chunk
-
 def generate_stream(akash_response, chat_id, model):
     """
-    解析 Akash 接口的流式响应数据，并生成符合 OpenAI API 格式的 chunk 数据。
+    解析 Akash 接口的流式响应数据，并生成符合 OpenAI API 流返回格式的 chunk 数据。
     """
     for line in akash_response.iter_lines():
         if not line:
             continue
         try:
             line_str = line.decode('utf-8').strip()
-            parts = line_str.split(':', 1)
-            if len(parts) != 2:
-                logging.error("流数据格式异常: %s", line_str)
-                continue
-            msg_type, msg_data = parts
+            msg_type, msg_data = line_str.split(':', 1)
             if msg_type == '0':
                 token = msg_data.strip()
+                # 去掉两边的引号并处理转义字符
                 if token.startswith('"') and token.endswith('"'):
                     token = token[1:-1].replace('\\"', '"')
                 token = token.replace("\\n", "\n")
-                chunk = build_chunk(chat_id, model, token=token, finish_reason=None)
-                logging.debug("流式 chunk: %s", json.dumps(chunk, ensure_ascii=False))
+                chunk = {
+                    "id": f"chatcmpl-{chat_id}",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "delta": {"content": token},
+                        "index": 0,
+                        "finish_reason": None
+                    }]
+                }
+                logging.info("Streaming chunk: %s", json.dumps(chunk, ensure_ascii=False))
                 yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
             elif msg_type in ['e', 'd']:
-                chunk = build_chunk(chat_id, model, finish_reason="stop")
-                logging.debug("流式结束 chunk: %s", json.dumps(chunk, ensure_ascii=False))
+                chunk = {
+                    "id": f"chatcmpl-{chat_id}",
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": model,
+                    "choices": [{
+                        "delta": {},
+                        "index": 0,
+                        "finish_reason": "stop"
+                    }]
+                }
+                logging.info("Streaming finish chunk: %s", json.dumps(chunk, ensure_ascii=False))
                 yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
                 yield "data: [DONE]\n\n"
                 break
         except Exception as ex:
-            logging.error("处理流数据时出错: %s", ex)
+            logging.error("Error processing stream line: %s", ex)
             continue
 
 @app.route('/v1/chat/completions', methods=['POST'])
 def chat_completions():
     try:
         data = request.get_json()
-        logging.info("收到 /v1/chat/completions 请求: %s", json.dumps(data, ensure_ascii=False))
+        logging.info("Received /v1/chat/completions request: %s", json.dumps(data, ensure_ascii=False))
         chat_id = str(uuid.uuid4()).replace('-', '')[:16]
         model = data.get('model', "DeepSeek-R1")
         akash_data = {
@@ -120,9 +130,11 @@ def chat_completions():
             "temperature": data.get('temperature', 0.6),
             "topP": data.get('top_p', 0.95)
         }
-        headers = {"Content-Type": "application/json", "Cookie": _COOKIES}
-        # 默认启用 stream 模式，但针对 AkashGen 模型关闭流式响应
-        stream_flag = data.get('stream', False)
+        _cookie = get_cookie()
+        logging.info(_cookie[:50])
+        headers = {"Content-Type": "application/json", "Cookie": _cookie}
+        # 默认 stream 模式开启，但针对 AkashGen 模型关闭流式响应
+        stream_flag = data.get('stream', True)
         if model == "AkashGen":
             stream_flag = False
 
@@ -132,7 +144,7 @@ def chat_completions():
             headers=headers,
             stream=stream_flag
         )
-        logging.info("Akash API 响应状态: %s", akash_response.status_code)
+        logging.info("Akash API response status: %s", akash_response.status_code)
 
         if stream_flag:
             return Response(
@@ -144,7 +156,6 @@ def chat_completions():
                 }
             )
         else:
-            # 非流式响应处理
             if model != "AkashGen":
                 text_matches = re.findall(r'0:"(.*?)"', akash_response.text)
                 parsed_text = "".join(text_matches)
@@ -158,39 +169,17 @@ def chat_completions():
                         "finish_reason": "stop"
                     }]
                 }
-                logging.info("非流式响应 payload: %s", json.dumps(response_payload, ensure_ascii=False))
+                logging.info("Non-stream response payload: %s", json.dumps(response_payload, ensure_ascii=False))
                 return Response(
                     json.dumps(response_payload, ensure_ascii=False),
                     status=akash_response.status_code,
                     mimetype='application/json'
                 )
             else:
-                user_query = data.get('messages', [])[0]["content"]
-                # 解决用dify或者new_api添加模型时报错
-                if user_query == "ping":
-                    text_matches = re.findall(r'0:"(.*?)"', akash_response.text)
-                    parsed_text = "".join(text_matches)
-                    response_payload = {
-                        "object": "chat.completion",
-                        "created": int(time.time() * 1000),
-                        "model": model,
-                        "choices": [{
-                            "index": 0,
-                            "message": {"role": "assistant", "content": parsed_text},
-                            "finish_reason": "stop"
-                        }]
-                    }
-                    logging.info("非流式响应 payload: %s", json.dumps(response_payload, ensure_ascii=False))
-                    return Response(
-                        json.dumps(response_payload, ensure_ascii=False),
-                        status=akash_response.status_code,
-                        mimetype='application/json'
-                    )
                 match = re.search(r"jobId='([^']+)'", akash_response.text)
                 if match:
                     job_id = match.group(1)
                     logging.info("AkashGen jobId: %s", job_id)
-                    # 轮询图片生成状态
                     while True:
                         try:
                             img_response = requests.get(
@@ -198,7 +187,7 @@ def chat_completions():
                                 headers=headers
                             )
                             img_data = img_response.json()
-                            if img_data and img_data[0]["status"] == "completed":
+                            if img_data[0]["status"] == "completed":
                                 response_payload = {
                                     "object": "chat.completion",
                                     "created": int(time.time() * 1000),
@@ -212,7 +201,7 @@ def chat_completions():
                                         "finish_reason": "stop"
                                     }]
                                 }
-                                logging.info("AkashGen 完成后的 payload: %s", json.dumps(response_payload, ensure_ascii=False))
+                                logging.info("AkashGen completed response payload: %s", json.dumps(response_payload, ensure_ascii=False))
                                 return Response(
                                     json.dumps(response_payload, ensure_ascii=False),
                                     status=akash_response.status_code,
@@ -228,7 +217,7 @@ def chat_completions():
                     return jsonify({"error": "当前官方服务异常"}), 500
 
     except Exception as e:
-        logging.exception("chat_completions 处理过程中出现异常:")
+        logging.exception("chat_completions error:")
         return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':