Upload 6 files

Dockerfile

@@ -22,5 +22,5 @@ ENV PYTHONUNBUFFERED=1
 # 暴露端口
 EXPOSE 3000
 
-# 使用 gunicorn 作为生产级 WSGI 服务器，添加超时和保活设置
-CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "--timeout", "120", "--keep-alive", "5", "--worker-class", "sync", "app:app"]
+# 使用 gunicorn 作为生产级 WSGI 服务器
+CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "app:app"]

app.py

@@ -107,7 +107,7 @@ def create_custom_session():
     return session
 
 # 添加速率限制相关的常量
-AUTH_RETRY_DELAY = 60  # 认证���试延迟（秒）
+AUTH_RETRY_DELAY = 60  # 认证重试延迟（秒）
 AUTH_BACKOFF_FACTOR = 2  # 退避因子
 AUTH_MAX_RETRIES = 3  # 最大重试次数
 AUTH_CHECK_INTERVAL = 300  # 健康检查间隔（秒）
@@ -309,84 +309,37 @@ class MultiAuthManager:
         self.current_index = 0
         self._last_rotation = time.time()
         self._rotation_interval = 300  # 5分钟轮转间隔
-        self.last_successful_index = 0  # 记录上次成功的账号索引
-        self.last_success_date = datetime.now().date()  # 记录上次成功的日期
-        self.model_usage = {}  # 记录每个模型最后使用的成功账号
 
-    def ensure_valid_token(self, model):
-        """改进的token验证方法，优先使用上次成功的模型特定账号"""
-        # 首先尝试使用该模型上次成功的账号
-        if model in self.model_usage:
-            last_index = self.model_usage[model]
-            auth_manager = self.auth_managers[last_index]
-            if auth_manager.is_model_available(model) and auth_manager.ensure_valid_token():
-                logger.info(f"Using last successful account for model {model}: {auth_manager._email}")
-                return auth_manager
-            else:
-                logger.info(f"Last successful account {auth_manager._email} is no longer available for model {model}")
-                # 从模型使用记录中移除不可用的账号
-                del self.model_usage[model]
+    def _should_rotate(self) -> bool:
+        """检查是否应该轮转到下一个账号"""
+        return time.time() - self._last_rotation >= self._rotation_interval
 
-        # 如果该模型没有成功记录或上次的账号不可用，从头开始尝试所有账号
-        tried_accounts = set()
-        start_index = self.current_index
-        current = start_index
+    def get_next_auth_manager(self, model):
+        """改进的账号选择逻辑"""
+        if self._should_rotate():
+            self.current_index = (self.current_index + 1) % len(self.auth_managers)
+            self._last_rotation = time.time()
 
-        while len(tried_accounts) < len(self.auth_managers):
-            auth_manager = self.auth_managers[current]
-            
-            if auth_manager._email not in tried_accounts:
-                tried_accounts.add(auth_manager._email)
-                logger.info(f"Trying account {auth_manager._email} for model {model}")
-                
-                if auth_manager.is_model_available(model):
-                    if auth_manager.ensure_valid_token():
-                        # 更新该模型的成功账号记录
-                        self.model_usage[model] = current
-                        self.current_index = (current + 1) % len(self.auth_managers)  # 更新当前索引为下一个
-                        logger.info(f"Found available account for model {model}: {auth_manager._email}")
-                        return auth_manager
-                    else:
-                        logger.info(f"Token validation failed for account {auth_manager._email}")
-                else:
-                    logger.info(f"Model {model} not available for account {auth_manager._email}")
-            
-            current = (current + 1) % len(self.auth_managers)
-            if current == start_index:
-                break
-                
-        # 如果是新的一天，重置所有状态
-        if datetime.now().date() > self.last_success_date:
-            logger.info("New day started, resetting all model status")
-            self.reset_all_model_status()
-            self.last_success_date = datetime.now().date()
-            self.model_usage.clear()
-            
-            # 重新尝试第一个账号
-            auth_manager = self.auth_managers[0]
-            if auth_manager.ensure_valid_token():
-                self.current_index = 1  # 设置为下一个账号
-                self.model_usage[model] = 0
-                logger.info(f"Using first account after reset: {auth_manager._email}")
+        start_index = self.current_index
+        for _ in range(len(self.auth_managers)):
+            auth_manager = self.auth_managers[self.current_index]
+            if auth_manager.is_model_available(model) and auth_manager._should_attempt_auth():
                 return auth_manager
-        
-        logger.warning(f"No available accounts found for model {model}")
+            self.current_index = (self.current_index + 1) % len(self.auth_managers)
+            if self.current_index == start_index:
+                break
         return None
 
-    def update_model_success(self, model, index):
-        """更新模型成功使用的账号索引"""
-        old_index = self.model_usage.get(model, None)
-        self.model_usage[model] = index
-        self.last_success_date = datetime.now().date()
-        if old_index != index:
-            logger.info(f"Updated successful account for model {model}: {self.auth_managers[index]._email}")
+    def ensure_valid_token(self, model):
+        for _ in range(len(self.auth_managers)):
+            auth_manager = self.get_next_auth_manager(model)
+            if auth_manager and auth_manager.ensure_valid_token():
+                return auth_manager
+        return None
 
     def reset_all_model_status(self):
-        """重置所有账号的状态和模型使用记录"""
         for auth_manager in self.auth_managers:
             auth_manager.reset_model_status()
-        self.model_usage.clear()
-        logger.info("Reset all model status and usage records")
 
 def require_auth(func: Callable) -> Callable:
     """装饰器，确保在调用API之前有有效的token。"""
@@ -593,7 +546,7 @@ def handle_non_stream_response(response, model, prompt_tokens):
         raise
 
 def generate_stream_response(response, model, prompt_tokens):
-    """生流式 HTTP 响应。"""
+    """生成流式 HTTP 响应。"""
     total_completion_tokens = 0
     
     for chunk in stream_notdiamond_response(response, model):
@@ -724,17 +677,17 @@ def handle_request():
         request_data = request.get_json()
         model_id = request_data.get('model', '')
         
-        # 不直接使用传入的 auth_manager，而是让 make_request 函数自己选择账号
+        auth_manager = multi_auth_manager.ensure_valid_token(model_id)
+        if not auth_manager:
+            return jsonify({'error': 'No available accounts for this model'}), 403
+
         stream = request_data.get('stream', False)
         prompt_tokens = count_message_tokens(
             request_data.get('messages', []),
             model_id
         )
         payload = build_payload(request_data, model_id)
-        
-        # 传入 None 作为 auth_manager，让 make_request 自己选择账号
-        response = make_request(payload, None, model_id)
-        
+        response = make_request(payload, auth_manager, model_id)
         if stream:
             return Response(
                 stream_with_context(generate_stream_response(response, model_id, prompt_tokens)),
@@ -754,6 +707,17 @@ def handle_request():
                 'details': str(e)
             }
         }), 503
+    except json.JSONDecodeError as e:
+        logger.error("JSON decode error: %s", str(e), exc_info=True)
+        return jsonify({
+            'error': {
+                'message': 'Invalid JSON in request',
+                'type': 'invalid_request_error',
+                'param': None,
+                'code': None,
+                'details': str(e)
+            }
+        }), 400
     except Exception as e:
         logger.error("Unexpected error: %s", str(e), exc_info=True)
         return jsonify({
@@ -767,7 +731,7 @@ def handle_request():
         }), 500
 
 def build_payload(request_data, model_id):
-    """构建请求有负载，确保保持完的上下文。"""
+    """构建请求有效负载，确保保持完整的上下文。"""
     messages = request_data.get('messages', [])
     
     # 检查是否已经存在系统消息
@@ -815,11 +779,10 @@ def build_payload(request_data, model_id):
     return payload
 
 def make_request(payload, auth_manager, model_id):
-    """改进的请求处理，添加超时控制"""
+    """发送请求并处理可能的认证刷新和模型特定错误。"""
     global multi_auth_manager
     max_retries = 3
     retry_delay = 1
-    request_timeout = 30  # 设置请求超时时间
     
     logger.info(f"尝试发送请求，模型：{model_id}")
     
@@ -836,14 +799,15 @@ def make_request(payload, auth_manager, model_id):
             else:
                 raise Exception("无法注册新账号")
 
-    # 记录尝试的账号
+    # 记录已尝试的账号
     tried_accounts = set()
     
     while len(tried_accounts) < len(multi_auth_manager.auth_managers):
-        auth_manager = multi_auth_manager.ensure_valid_token(model_id)
+        auth_manager = multi_auth_manager.get_next_auth_manager(model_id)
         if not auth_manager:
             break
             
+        # 如果这个账号已经尝试过，继续下一个
         if auth_manager._email in tried_accounts:
             continue
             
@@ -854,21 +818,16 @@ def make_request(payload, auth_manager, model_id):
             try:
                 url = get_notdiamond_url()
                 headers = get_notdiamond_headers(auth_manager)
-                
                 response = executor.submit(
                     requests.post, 
                     url, 
                     headers=headers, 
                     json=payload, 
-                    stream=True,
-                    timeout=request_timeout
-                ).result(timeout=request_timeout)
+                    stream=True
+                ).result()
                 
                 if response.status_code == 200 and response.headers.get('Content-Type') == 'text/event-stream':
                     logger.info(f"请求成功，使用账号 {auth_manager._email}")
-                    current_index = multi_auth_manager.auth_managers.index(auth_manager)
-                    # 更新模型特定的成功记录
-                    multi_auth_manager.update_model_success(model_id, current_index)
                     return response
                 
                 headers_cache.clear()
@@ -885,9 +844,6 @@ def make_request(payload, auth_manager, model_id):
                 
                 logger.error(f"Request failed with status {response.status_code} for account {auth_manager._email}")
                 
-            except (requests.Timeout, concurrent.futures.TimeoutError) as e:
-                logger.error(f"Request timeout for account {auth_manager._email}: {e}")
-                break
             except Exception as e:
                 logger.error(f"Request attempt {attempt + 1} failed for account {auth_manager._email}: {e}")
                 if attempt < max_retries - 1:
@@ -907,40 +863,34 @@ def make_request(payload, auth_manager, model_id):
     raise Exception("所有账号均不可用，且注册新账号失败")
 
 def health_check():
-    """改进的健康检查函数，每60秒只检查一个账号"""
-    check_index = 0
-    last_check_date = datetime.now().date()
+    """改进的健康检查函数"""
+    last_check_time = {}  # 用于跟踪每个账号的最后检查时间
     
     while True:
         try:
             if multi_auth_manager:
-                current_date = datetime.now().date()
+                current_time = time.time()
                 
-                # 如果是新的一天，重置检查索引
-                if current_date > last_check_date:
-                    check_index = 0
-                    last_check_date = current_date
-                    logger.info("New day started, resetting health check index")
-                    continue
-
-                # 只检查一个账号
-                if check_index < len(multi_auth_manager.auth_managers):
-                    auth_manager = multi_auth_manager.auth_managers[check_index]
+                for auth_manager in multi_auth_manager.auth_managers:
                     email = auth_manager._email
                     
-                    if auth_manager._should_attempt_auth():
+                    # 检查是否需要进行健康检查
+                    if email not in last_check_time or \
+                       current_time - last_check_time[email] >= AUTH_CHECK_INTERVAL:
+                        
+                        if not auth_manager._should_attempt_auth():
+                            logger.info(f"Skipping health check for {email} due to rate limiting")
+                            continue
+                            
                         if not auth_manager.ensure_valid_token():
                             logger.warning(f"Auth token validation failed during health check for {email}")
                             auth_manager.clear_auth()
                         else:
                             logger.info(f"Health check passed for {email}")
-                    else:
-                        logger.info(f"Skipping health check for {email} due to rate limiting")
-                    
-                    # 更新检查索引
-                    check_index = (check_index + 1) % len(multi_auth_manager.auth_managers)
+                            
+                        last_check_time[email] = current_time
                 
-                # 在每天午夜重置所有账号的模型使用状态
+                # 每天重置所有账号的模型使用状态
                 current_time_local = time.localtime()
                 if current_time_local.tm_hour == 0 and current_time_local.tm_min == 0:
                     multi_auth_manager.reset_all_model_status()
@@ -949,7 +899,7 @@ def health_check():
         except Exception as e:
             logger.error(f"Health check error: {e}")
             
-        sleep(60)  # 每60秒检查一个账号
+        sleep(60)  # 主循环每分钟运行一次
 
 # 为了兼容 Flask CLI 和 Gunicorn，修改启动逻辑
 if __name__ != "__main__":
@@ -962,3 +912,4 @@ if __name__ == "__main__":
     
     port = int(os.environ.get("PORT", 3000))
     app.run(debug=False, host='0.0.0.0', port=port, threaded=True)
+

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text