Upload app.py

app.py

@@ -7,7 +7,7 @@ import uuid
 import re
 import socket
 from concurrent.futures import ThreadPoolExecutor
-from functools import wraps
+from functools import lru_cache, wraps
 from typing import Dict, Any, Callable, List, Tuple
 import requests
 import tiktoken
@@ -46,7 +46,7 @@ if not _PASTE_API_URL:
 app = Flask(__name__)
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
-CORS(app, resources={r"/": {"origins": "*"}})
+CORS(app, resources={r"/*": {"origins": "*"}})
 executor = ThreadPoolExecutor(max_workers=10)
 
 proxy_url = os.getenv('PROXY_URL')
@@ -64,7 +64,7 @@ def require_api_key(f):
         auth_header = request.headers.get('Authorization')
         if not auth_header:
             return jsonify({'error': 'No API key provided'}), 401
-
+        
         try:
             # 从 Bearer token 中提取API密钥
             provided_key = auth_header.split('Bearer ')[-1].strip()
@@ -72,12 +72,12 @@ def require_api_key(f):
                 return jsonify({'error': 'Invalid API key'}), 401
         except Exception:
             return jsonify({'error': 'Invalid Authorization header format'}), 401
-
+            
         return f(*args, **kwargs)
     return decorated_function
 
 refresh_token_cache = TTLCache(maxsize=1000, ttl=3600)
-headers_cache = TTLCache(maxsize=100, ttl=3600)  # 增加缓存大小
+headers_cache = TTLCache(maxsize=1, ttl=3600)  # 1小时过期
 token_refresh_lock = threading.Lock()
 
 # 自定义连接函数
@@ -114,58 +114,6 @@ AUTH_CHECK_INTERVAL = 300  # 健康检查间隔（秒）
 AUTH_RATE_LIMIT_WINDOW = 3600  # 速率限制窗口（秒）
 AUTH_MAX_REQUESTS = 100  # 每个窗口最大请求数
 
-# 模型信息
-MODEL_INFO = {
-    "gpt-4o-mini": {
-        "provider": "openai",
-        "mapping": "gpt-4o-mini"
-    },
-    "gpt-4o": {
-        "provider": "openai",
-        "mapping": "gpt-4o"
-    },
-    "gpt-4-turbo": {
-        "provider": "openai",
-        "mapping": "gpt-4-turbo-2024-04-09"
-    },
-    "chatgpt-4o-latest": {
-        "provider": "openai",
-        "mapping": "chatgpt-4o-latest"
-    },
-    "gemini-1.5-pro-latest": {
-        "provider": "google",
-        "mapping": "models/gemini-1.5-pro-latest"
-    },
-    "gemini-1.5-flash-latest": {
-        "provider": "google",
-        "mapping": "models/gemini-1.5-flash-latest"
-    },
-    "llama-3.1-70b-instruct": {
-        "provider": "togetherai",
-        "mapping": "meta.llama3-1-70b-instruct-v1:0"
-    },
-    "llama-3.1-405b-instruct": {
-        "provider": "togetherai",
-        "mapping": "meta.llama3-1-405b-instruct-v1:0"
-    },
-    "claude-3-5-sonnet-20241022": {
-        "provider": "anthropic",
-        "mapping": "anthropic.claude-3-5-sonnet-20241022-v2:0"
-    },
-    "claude-3-5-haiku-20241022": {
-        "provider": "anthropic",
-        "mapping": "anthropic.claude-3-5-haiku-20241022-v1:0"
-    },
-    "perplexity": {
-        "provider": "perplexity",
-        "mapping": "llama-3.1-sonar-large-128k-online"
-    },
-    "mistral-large-2407": {
-        "provider": "mistral",
-        "mapping": "mistral.mistral-large-2407-v1:0"
-    }
-}
-
 class AuthManager:
     def __init__(self, email: str, password: str):
         self._email: str = email
@@ -185,44 +133,38 @@ class AuthManager:
         self._auth_attempts = 0
         self._auth_window_start = time.time()
         self._backoff_delay = AUTH_RETRY_DELAY
-        # 标记账号不可用直到特定时间
-        self.unavailable_until = 0
 
     def _should_attempt_auth(self) -> bool:
         """检查是否应该尝试认证请求"""
         current_time = time.time()
-
-        # 检查是否在不可用期内
-        if current_time < self.unavailable_until:
-            return False
-
+        
         # 检查是否在退避期内
         if current_time - self._last_auth_attempt < self._backoff_delay:
             return False
-
+            
         # 检查速率限制窗口
         if current_time - self._auth_window_start > AUTH_RATE_LIMIT_WINDOW:
             # 重置窗口
             self._auth_window_start = current_time
             self._auth_attempts = 0
             self._backoff_delay = AUTH_RETRY_DELAY
-
+            
         # 检查请求数量
         if self._auth_attempts >= AUTH_MAX_REQUESTS:
             return False
-
+            
         return True
 
     def login(self) -> bool:
         """改进的登录方法，包含速率限制和退避机制"""
         if not self._should_attempt_auth():
-            self._logger.warning(f"Rate limit reached for {self._email}, waiting {self._backoff_delay}s")
+            logger.warning(f"Rate limit reached for {self._email}, waiting {self._backoff_delay}s")
             return False
 
         try:
             self._last_auth_attempt = time.time()
             self._auth_attempts += 1
-
+            
             url = f"{_API_BASE_URL}/auth/v1/token?grant_type=password"
             headers = self._get_headers(with_content_type=True)
             data = {
@@ -230,32 +172,31 @@ class AuthManager:
                 "password": self._password,
                 "gotrue_meta_security": {}
             }
-
+            
             response = self._make_request('POST', url, headers=headers, json=data)
-
+            
             if response.status_code == 429:
                 self._backoff_delay *= AUTH_BACKOFF_FACTOR
-                self._logger.warning(f"Rate limit hit, increasing backoff to {self._backoff_delay}s")
+                logger.warning(f"Rate limit hit, increasing backoff to {self._backoff_delay}s")
                 return False
-
+                
             response.raise_for_status()
             self._user_info = response.json()
             self._refresh_token = self._user_info.get('refresh_token', '')
             self._access_token = self._user_info.get('access_token', '')
             self._token_expiry = time.time() + self._user_info.get('expires_in', 3600)
-
+            
             # 重置退避延迟
             self._backoff_delay = AUTH_RETRY_DELAY
             self._log_values()
             return True
-
+            
         except requests.RequestException as e:
-            self._logger.error(f"\033[91m登录请求错误: {e}\033[0m")
+            logger.error(f"\033[91m登录请求错误: {e}\033[0m")
             self._backoff_delay *= AUTH_BACKOFF_FACTOR
             return False
 
     def refresh_user_token(self) -> bool:
-        """刷新用户令牌"""
         url = f"{_API_BASE_URL}/auth/v1/token?grant_type=refresh_token"
         headers = self._get_headers(with_content_type=True)
         data = {"refresh_token": self._refresh_token}
@@ -286,13 +227,13 @@ class AuthManager:
         """改进的token验证方法"""
         if self.is_token_valid():
             return True
-
+            
         if not self._should_attempt_auth():
             return False
-
+            
         if self._refresh_token and self.refresh_user_token():
             return True
-
+            
         return self.login()
 
     def clear_auth(self) -> None:
@@ -302,14 +243,6 @@ class AuthManager:
         self._access_token = ""
         self._token_expiry = 0
 
-    def set_unavailable_until_next_day(self) -> None:
-        """将账号标记为不可用，直到次日"""
-        now = datetime.now()
-        next_day = now + timedelta(days=1)
-        next_day_start = datetime(year=next_day.year, month=next_day.month, day=next_day.day)
-        self.unavailable_until = next_day_start.timestamp()
-        self._logger.info(f"Account {self._email} marked as unavailable until {next_day_start}")
-
     def _log_values(self) -> None:
         """记录刷新令牌到日志中。"""
         self._logger.info(f"\033[92mRefresh Token: {self._refresh_token}\033[0m")
@@ -322,17 +255,17 @@ class AuthManager:
         try:
             login_url = f"{_BASE_URL}/login"
             response = self._make_request('GET', login_url)
-
+            
             match = re.search(r'<script src="(/_next/static/chunks/app/layout-[^"]+\.js)"', response.text)
             if not match:
                 raise ValueError("未找到匹配的脚本标签")
             js_url = f"{_BASE_URL}{match.group(1)}"
             js_response = self._make_request('GET', js_url)
-
-            api_key_match = re.search(r'\$\$"https://spuckhogycrxcbomznwo\.supabase\.co","([^"]+)"\$\$', js_response.text)
+            
+            api_key_match = re.search(r'\("https://spuckhogycrxcbomznwo\.supabase\.co","([^"]+)"\)', js_response.text)
             if not api_key_match:
                 raise ValueError("未能匹配API key")
-
+            
             self._api_key = api_key_match.group(1)
             return self._api_key
         except (requests.RequestException, ValueError) as e:
@@ -376,25 +309,21 @@ class MultiAuthManager:
         self.current_index = 0
         self._last_rotation = time.time()
         self._rotation_interval = 300  # 5分钟轮转间隔
-        self.last_successful_index = -1  # 上一次成功的账号索引
 
     def _should_rotate(self) -> bool:
         """检查是否应该轮转到下一个账号"""
         return time.time() - self._last_rotation >= self._rotation_interval
 
     def get_next_auth_manager(self, model):
-        """改进的账号选择逻辑，从上一次成功的账号开始"""
-        if self.last_successful_index == -1:
-            self.current_index = 0
-        else:
-            self.current_index = (self.last_successful_index + 1) % len(self.auth_managers)
+        """改进的账号选择逻辑"""
+        if self._should_rotate():
+            self.current_index = (self.current_index + 1) % len(self.auth_managers)
+            self._last_rotation = time.time()
 
         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():
-                self.last_successful_index = self.current_index
-                self.current_index = (self.current_index + 1) % len(self.auth_managers)
                 return auth_manager
             self.current_index = (self.current_index + 1) % len(self.auth_managers)
             if self.current_index == start_index:
@@ -402,7 +331,6 @@ class MultiAuthManager:
         return None
 
     def ensure_valid_token(self, model):
-        """确保有有效的token"""
         for _ in range(len(self.auth_managers)):
             auth_manager = self.get_next_auth_manager(model)
             if auth_manager and auth_manager.ensure_valid_token():
@@ -413,18 +341,13 @@ class MultiAuthManager:
         for auth_manager in self.auth_managers:
             auth_manager.reset_model_status()
 
-    def mark_account_unavailable(self, auth_manager):
-        """标记账号为不可用直到次日"""
-        auth_manager.set_unavailable_until_next_day()
-
 def require_auth(func: Callable) -> Callable:
     """装饰器，确保在调用API之前有有效的token。"""
     @wraps(func)
-    def wrapper(*args, **kwargs):
-        auth_manager = multi_auth_manager.ensure_valid_token(kwargs.get('model_id', ''))
-        if not auth_manager:
+    def wrapper(self, *args, **kwargs):
+        if not self.ensure_valid_token():
             raise Exception("无法获取有效的授权token")
-        return func(*args, **kwargs)
+        return func(self, *args, **kwargs)
     return wrapper
 
 # 全局的 MultiAuthManager 对象
@@ -439,7 +362,7 @@ def get_notdiamond_url():
 def get_notdiamond_headers(auth_manager):
     """返回用于 notdiamond API 请求的头信息。"""
     cache_key = f'notdiamond_headers_{auth_manager.get_jwt_value()}'
-
+    
     try:
         return headers_cache[cache_key]
     except KeyError:
@@ -453,6 +376,57 @@ def get_notdiamond_headers(auth_manager):
         headers_cache[cache_key] = headers
         return headers
 
+MODEL_INFO = {
+    "gpt-4o-mini": {
+        "provider": "openai",
+        "mapping": "gpt-4o-mini"
+    },
+    "gpt-4o": {
+        "provider": "openai",
+        "mapping": "gpt-4o"
+    },
+    "gpt-4-turbo": {
+        "provider": "openai",
+        "mapping": "gpt-4-turbo-2024-04-09"
+    },
+    "chatgpt-4o-latest": {
+        "provider": "openai",
+        "mapping": "chatgpt-4o-latest"
+    },
+    "gemini-1.5-pro-latest": {
+        "provider": "google",
+        "mapping": "models/gemini-1.5-pro-latest"
+    },
+    "gemini-1.5-flash-latest": {
+        "provider": "google",
+        "mapping": "models/gemini-1.5-flash-latest"
+    },
+    "llama-3.1-70b-instruct": {
+        "provider": "togetherai",
+        "mapping": "meta.llama3-1-70b-instruct-v1:0"
+    },
+    "llama-3.1-405b-instruct": {
+        "provider": "togetherai",
+        "mapping": "meta.llama3-1-405b-instruct-v1:0"
+    },
+    "claude-3-5-sonnet-20241022": {
+        "provider": "anthropic",
+        "mapping": "anthropic.claude-3-5-sonnet-20241022-v2:0"
+    },
+    "claude-3-5-haiku-20241022": {
+        "provider": "anthropic",
+        "mapping": "anthropic.claude-3-5-haiku-20241022-v1:0"
+    },
+    "perplexity": {
+        "provider": "perplexity",
+        "mapping": "llama-3.1-sonar-large-128k-online"
+    },
+    "mistral-large-2407": {
+        "provider": "mistral",
+        "mapping": "mistral.mistral-large-2407-v1:0"
+    }
+}
+
 def generate_system_fingerprint():
     """生成并返回唯一的系统指纹。"""
     return f"fp_{uuid.uuid4().hex[:10]}"
@@ -476,10 +450,10 @@ def create_openai_chunk(content, model, finish_reason=None, usage=None):
             }
         ]
     }
-
+    
     if usage is not None:
         chunk["usage"] = usage
-
+    
     return chunk
 
 def count_tokens(text, model="gpt-3.5-turbo-0301"):
@@ -497,28 +471,28 @@ def stream_notdiamond_response(response, model):
     """改进的流式响应处理，确保保持上下文完整性。"""
     buffer = ""
     full_content = ""
-
+    
     for chunk in response.iter_content(chunk_size=1024):
         if chunk:
             try:
                 new_content = chunk.decode('utf-8')
                 buffer += new_content
                 full_content += new_content
-
+                
                 # 创建完整的响应块
                 chunk_data = create_openai_chunk(new_content, model)
-
+                
                 # 确保响应块包含完整的上下文
                 if 'choices' in chunk_data and chunk_data['choices']:
                     chunk_data['choices'][0]['delta']['content'] = new_content
                     chunk_data['choices'][0]['context'] = full_content  # 添加完整上下文
-
+                
                 yield chunk_data
-
+                
             except Exception as e:
                 logger.error(f"Error processing chunk: {e}")
                 continue
-
+    
     # 发送完成标记
     final_chunk = create_openai_chunk('', model, 'stop')
     if 'choices' in final_chunk and final_chunk['choices']:
@@ -529,17 +503,17 @@ def handle_non_stream_response(response, model, prompt_tokens):
     """改进的非流式响应处理，确保保持完整上下文。"""
     full_content = ""
     context_buffer = []
-
+    
     try:
         for chunk in response.iter_content(chunk_size=1024):
             if chunk:
                 content = chunk.decode('utf-8')
                 full_content += content
                 context_buffer.append(content)
-
+        
         completion_tokens = count_tokens(full_content, model)
         total_tokens = prompt_tokens + completion_tokens
-
+        
         # 创建包含完整上下文的响应
         response_data = {
             "id": f"chatcmpl-{uuid.uuid4()}",
@@ -564,9 +538,9 @@ def handle_non_stream_response(response, model, prompt_tokens):
                 "total_tokens": total_tokens
             }
         }
-
+        
         return jsonify(response_data)
-
+        
     except Exception as e:
         logger.error(f"Error processing non-stream response: {e}")
         raise
@@ -574,19 +548,19 @@ def handle_non_stream_response(response, model, prompt_tokens):
 def generate_stream_response(response, model, prompt_tokens):
     """生成流式 HTTP 响应。"""
     total_completion_tokens = 0
-
+    
     for chunk in stream_notdiamond_response(response, model):
         content = chunk['choices'][0]['delta'].get('content', '')
         total_completion_tokens += count_tokens(content, model)
-
+        
         chunk['usage'] = {
             "prompt_tokens": prompt_tokens,
             "completion_tokens": total_completion_tokens,
             "total_tokens": prompt_tokens + total_completion_tokens
         }
-
+        
         yield f"data: {json.dumps(chunk)}\n\n"
-
+    
     yield "data: [DONE]\n\n"
 
 def get_auth_credentials():
@@ -594,7 +568,7 @@ def get_auth_credentials():
     try:
         session = create_custom_session()
         headers = {
-            'accept': '/',
+            'accept': '*/*',
             'accept-language': 'zh-CN,zh;q=0.9',
             'user-agent': _USER_AGENT,
             'x-password': _PASTE_API_PASSWORD
@@ -624,13 +598,13 @@ def get_auth_credentials():
 def before_request():
     global multi_auth_manager
     credentials = get_auth_credentials()
-
+    
     # 如果没有凭据，尝试自动注册
     if not credentials:
         try:
             # 使用 register_bot 注册新账号
             successful_accounts = register_bot.register_and_verify(5)  # 注册5个账号
-
+            
             if successful_accounts:
                 # 更新凭据
                 credentials = [(account['email'], account['password']) for account in successful_accounts]
@@ -643,7 +617,7 @@ def before_request():
             logger.error(f"自动注册过程发生错误: {e}")
             multi_auth_manager = None
             return
-
+    
     if credentials:
         multi_auth_manager = MultiAuthManager(credentials)
     else:
@@ -698,11 +672,11 @@ def handle_request():
     global multi_auth_manager
     if not multi_auth_manager:
         return jsonify({'error': 'Unauthorized'}), 401
-
+    
     try:
         request_data = request.get_json()
         model_id = request_data.get('model', '')
-
+        
         auth_manager = multi_auth_manager.ensure_valid_token(model_id)
         if not auth_manager:
             return jsonify({'error': 'No available accounts for this model'}), 403
@@ -721,7 +695,7 @@ def handle_request():
             )
         else:
             return handle_non_stream_response(response, model_id, prompt_tokens)
-
+    
     except requests.RequestException as e:
         logger.error("Request error: %s", str(e), exc_info=True)
         return jsonify({
@@ -759,10 +733,10 @@ def handle_request():
 def build_payload(request_data, model_id):
     """构建请求有效负载，确保保持完整的上下文。"""
     messages = request_data.get('messages', [])
-
+    
     # 检查是否已经存在系统消息
     has_system_message = any(message.get('role') == 'system' for message in messages)
-
+    
     # 如果没有系统消息，添加默认的系统消息
     if not has_system_message:
         system_message = {
@@ -780,11 +754,11 @@ def build_payload(request_data, model_id):
             )
         }
         messages.insert(0, system_message)
-
+    
     # 获取模型映射
     model_info = MODEL_INFO.get(model_id, {})
     mapping = model_info.get('mapping', model_id)
-
+    
     # 构建完整的payload
     payload = {
         'model': mapping,
@@ -796,12 +770,12 @@ def build_payload(request_data, model_id):
         'frequency_penalty': request_data.get('frequency_penalty'),
         'top_p': request_data.get('top_p', 1),
     }
-
+    
     # 添加其他自定义参数
     for key, value in request_data.items():
         if key not in ['messages', 'model', 'stream', 'temperature'] and value is not None:
             payload[key] = value
-
+    
     return payload
 
 def make_request(payload, auth_manager, model_id):
@@ -809,9 +783,9 @@ def make_request(payload, auth_manager, model_id):
     global multi_auth_manager
     max_retries = 3
     retry_delay = 1
-
+    
     logger.info(f"尝试发送请求，模型：{model_id}")
-
+    
     # 确保 multi_auth_manager 存在
     if not multi_auth_manager:
         logger.error("MultiAuthManager 不存在，尝试重新初始化")
@@ -827,16 +801,16 @@ def make_request(payload, auth_manager, model_id):
 
     # 记录已尝试的账号
     tried_accounts = set()
-
+    
     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:
             break
-
+            
         # 如果这个账号已经尝试过，继续下一个
         if auth_manager._email in tried_accounts:
             continue
-
+            
         tried_accounts.add(auth_manager._email)
         logger.info(f"尝试使用账号 {auth_manager._email}")
 
@@ -851,29 +825,25 @@ def make_request(payload, auth_manager, model_id):
                     json=payload, 
                     stream=True
                 ).result()
-
+                
                 if response.status_code == 200 and response.headers.get('Content-Type') == 'text/event-stream':
                     logger.info(f"请求成功，使用账号 {auth_manager._email}")
-                    # 记录最后成功的账号索引
-                    multi_auth_manager.last_successful_index = multi_auth_manager.auth_managers.index(auth_manager)
                     return response
-
+                
                 headers_cache.clear()
-
+                
                 if response.status_code == 401:  # Unauthorized
                     logger.info(f"Token expired for account {auth_manager._email}, attempting refresh")
                     if auth_manager.ensure_valid_token():
                         continue
-
+                
                 if response.status_code == 403:  # Forbidden, 模型使用限制
                     logger.warning(f"Model {model_id} usage limit reached for account {auth_manager._email}")
                     auth_manager.set_model_unavailable(model_id)
-                    # 标记账号为不可用直到次日
-                    multi_auth_manager.mark_account_unavailable(auth_manager)
                     break  # 跳出重试循环，尝试下一个账号
-
+                
                 logger.error(f"Request failed with status {response.status_code} for account {auth_manager._email}")
-
+                
             except Exception as e:
                 logger.error(f"Request attempt {attempt + 1} failed for account {auth_manager._email}: {e}")
                 if attempt < max_retries - 1:
@@ -889,45 +859,47 @@ def make_request(payload, auth_manager, model_id):
             multi_auth_manager = MultiAuthManager(credentials)
             # 使用新注册的账号重试请求
             return make_request(payload, None, model_id)
-
+    
     raise Exception("所有账号均不可用，且注册新账号失败")
 
 def health_check():
-    """改进的健康检查函数，每60秒只检测一个账号"""
-    last_check_index = 0  # 用于跟踪下一个要检查的账号索引
-
+    """改进的健康检查函数"""
+    last_check_time = {}  # 用于跟踪每个账号的最后检查时间
+    
     while True:
         try:
-            if multi_auth_manager and multi_auth_manager.auth_managers:
-                auth_manager = multi_auth_manager.auth_managers[last_check_index % len(multi_auth_manager.auth_managers)]
+            if multi_auth_manager:
                 current_time = time.time()
-
-                # 如果账号被标记为不可用，检查是否可以恢复
-                if current_time >= auth_manager.unavailable_until:
-                    auth_manager.unavailable_until = 0  # 重置不可用状态
-
-                    # 进行健康检查
-                    if auth_manager._should_attempt_auth():
+                
+                for auth_manager in multi_auth_manager.auth_managers:
+                    email = auth_manager._email
+                    
+                    # 检查是否需要进行健康检查
+                    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 {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}")
-                else:
-                    logger.info(f"Account {auth_manager._email} is still unavailable until {datetime.fromtimestamp(auth_manager.unavailable_until)}")
-
-                last_check_index += 1  # 更新下一个要检查的账��索引
-
+                            logger.info(f"Health check passed for {email}")
+                            
+                        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()
                     logger.info("Reset model status for all accounts")
-
+                    
         except Exception as e:
             logger.error(f"Health check error: {e}")
-
-        sleep(60)  # 主循环每分钟运行一次，检测一个账号
+            
+        sleep(60)  # 主循环每分钟运行一次
 
 # 为了兼容 Flask CLI 和 Gunicorn，修改启动逻辑
 if __name__ != "__main__":
@@ -937,6 +909,7 @@ if __name__ != "__main__":
 if __name__ == "__main__":
     health_check_thread = threading.Thread(target=health_check, daemon=True)
     health_check_thread.start()
-
+    
     port = int(os.environ.get("PORT", 3000))
-    app.run(debug=False, host='0.0.0.0', port=port, threaded=True)
+    app.run(debug=False, host='0.0.0.0', port=port, threaded=True)
+