Upload app.py

app.py

@@ -309,42 +309,43 @@ class MultiAuthManager:
         self.current_index = 0
         self._last_rotation = time.time()
         self._rotation_interval = 300  # 5分钟轮转间隔
-        self.last_successful_index = 0  # 新增：记录上一次成功的账号索引
-        self.daily_rotation_triggered = False  # 新增：标记是否触发过每日轮询
+        self.last_successful_index = 0  # 记录上次成功的账号索引
+        self.last_success_date = datetime.now().date()  # 记录上次成功的日期
 
     def get_next_auth_manager(self, model):
-        """改进的账号选择逻辑，从上一次成功的账号开始"""
-        # 如果当前账号可用，直接返回
-        current_auth = self.auth_managers[self.last_successful_index]
-        if current_auth.is_model_available(model) and current_auth._should_attempt_auth():
-            return current_auth
-
-        # 如果当前账号不可用，且未触发每日轮询，则等待到第二天
-        if not self.daily_rotation_triggered:
-            return None
-
-        # 进行账号轮询
+        """改进的账号选择逻辑，优先使用上次成功的账号"""
+        current_date = datetime.now().date()
+        
+        # 如果是新的一天，重置状态并从第一个账号开始
+        if current_date > self.last_success_date:
+            self.current_index = 0
+            self.last_successful_index = 0
+            self.last_success_date = current_date
+            self.reset_all_model_status()
+            return self.auth_managers[0] if self.auth_managers else None
+
+        # 优先使用上次成功的账号
+        auth_manager = self.auth_managers[self.last_successful_index]
+        if auth_manager.is_model_available(model) and auth_manager._should_attempt_auth():
+            return auth_manager
+
+        # 如果上次成功的账号不可用，才开始轮询其他账号
         start_index = (self.last_successful_index + 1) % len(self.auth_managers)
-        current_index = start_index
+        current = start_index
         
-        while True:
-            auth_manager = self.auth_managers[current_index]
+        while current != self.last_successful_index:
+            auth_manager = self.auth_managers[current]
             if auth_manager.is_model_available(model) and auth_manager._should_attempt_auth():
-                self.last_successful_index = current_index
+                self.last_successful_index = current
                 return auth_manager
-                
-            current_index = (current_index + 1) % len(self.auth_managers)
-            if current_index == start_index:
-                break
-                
+            current = (current + 1) % len(self.auth_managers)
+            
         return None
 
-    def set_successful_account(self, auth_manager):
-        """记录成功使用的账号索引"""
-        for i, manager in enumerate(self.auth_managers):
-            if manager._email == auth_manager._email:
-                self.last_successful_index = i
-                break
+    def update_last_successful(self, index):
+        """更新最后一次成功使用的账号索引"""
+        self.last_successful_index = index
+        self.last_success_date = datetime.now().date()
 
     def ensure_valid_token(self, model):
         for _ in range(len(self.auth_managers)):
@@ -747,7 +748,7 @@ def handle_request():
         }), 500
 
 def build_payload(request_data, model_id):
-    """构建请求有效负载，确保保持完整的上下文。"""
+    """构建请求有���负载，确保保持完���的上下文。"""
     messages = request_data.get('messages', [])
     
     # 检查是否已经存在系统消息
@@ -821,9 +822,6 @@ def make_request(payload, auth_manager, model_id):
     while len(tried_accounts) < len(multi_auth_manager.auth_managers):
         auth_manager = multi_auth_manager.get_next_auth_manager(model_id)
         if not auth_manager:
-            if not multi_auth_manager.daily_rotation_triggered:
-                logger.info("当前账号不可用，等待至次日重试")
-                raise Exception("当前账号不可用，请等待至次日重试")
             break
             
         # 如果这个账号已经尝试过，继续下一个
@@ -847,7 +845,9 @@ def make_request(payload, auth_manager, model_id):
                 
                 if response.status_code == 200 and response.headers.get('Content-Type') == 'text/event-stream':
                     logger.info(f"请求成功，使用账号 {auth_manager._email}")
-                    multi_auth_manager.set_successful_account(auth_manager)  # 记录成功的账号
+                    # 更新最后成功使用的账号索引
+                    current_index = multi_auth_manager.auth_managers.index(auth_manager)
+                    multi_auth_manager.update_last_successful(current_index)
                     return response
                 
                 headers_cache.clear()
@@ -883,43 +883,49 @@ def make_request(payload, auth_manager, model_id):
     raise Exception("所有账号均不可用，且注册新账号失败")
 
 def health_check():
-    """改进的健康检查函数，每次只检查一个账号"""
+    """改进的健康检查函数，每60秒只检查一个账号"""
     check_index = 0
-    last_check_time = time.time()
-    last_date = datetime.now().date()
+    last_check_date = datetime.now().date()
     
     while True:
         try:
             if multi_auth_manager:
-                current_time = time.time()
                 current_date = datetime.now().date()
                 
-                # 检查是否是新的一天
-                if current_date > last_date:
-                    multi_auth_manager.daily_rotation_triggered = True
-                    multi_auth_manager.reset_all_model_status()
-                    logger.info("New day started - Reset model status for all accounts")
-                    last_date = current_date
-                
-                # 每60秒检查一个账号
-                if current_time - last_check_time >= 60:
+                # 如果是新的一天，重置检查索引
+                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]
+                    email = auth_manager._email
                     
                     if auth_manager._should_attempt_auth():
                         if not auth_manager.ensure_valid_token():
-                            logger.warning(f"Auth token validation failed during health check for {auth_manager._email}")
+                            logger.warning(f"Auth token validation failed during health check for {email}")
                             auth_manager.clear_auth()
                         else:
-                            logger.info(f"Health check passed for {auth_manager._email}")
+                            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 = 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()
+                    logger.info("Reset model status for all accounts")
                     
         except Exception as e:
             logger.error(f"Health check error: {e}")
             
-        sleep(1)  # 降低CPU使用率
+        sleep(60)  # 每60秒检查一个账号
 
 # 为了兼容 Flask CLI 和 Gunicorn，修改启动逻辑
 if __name__ != "__main__":