Upload 3 files

Dockerfile

@@ -6,16 +6,9 @@ WORKDIR /app
 # 复制依赖文件
 COPY requirements.txt .
 
-# 安装系统依赖和 Python 包
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-    gcc \
-    python3-dev \
-    && pip install --upgrade pip \
-    && pip install --no-cache-dir -r requirements.txt gunicorn \
-    && apt-get purge -y --auto-remove gcc python3-dev \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
+# 安装 gunicorn 和其他依赖
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt gunicorn
 
 # 复制应用程序文件
 COPY app.py .
@@ -30,4 +23,4 @@ ENV PYTHONUNBUFFERED=1
 EXPOSE 3000
 
 # 使用 gunicorn 作为生产级 WSGI 服务器
-CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "--timeout", "120", "--worker-class", "sync", "app:app"]
+CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "app:app"]

app.py

@@ -8,7 +8,7 @@ import re
 import socket
 from concurrent.futures import ThreadPoolExecutor
 from functools import lru_cache, wraps
-from typing import Dict, Any, Callable, List, Tuple, Optional, Union
+from typing import Dict, Any, Callable, List, Tuple
 import requests
 import tiktoken
 from flask import Flask, Response, jsonify, request, stream_with_context
@@ -20,9 +20,6 @@ from cachetools import TTLCache
 import threading
 from time import sleep
 from datetime import datetime, timedelta
-import aiohttp
-import asyncio
-import atexit
 
 # 新增导入
 import register_bot
@@ -374,8 +371,7 @@ def get_notdiamond_headers(auth_manager):
             'accept-language': 'zh-CN,zh;q=0.9',
             'content-type': 'application/json',
             'user-agent': _USER_AGENT,
-            'authorization': f'Bearer {auth_manager.get_jwt_value()}',
-            'Host': NOTDIAMOND_DOMAIN  # 添加 Host 头
+            'authorization': f'Bearer {auth_manager.get_jwt_value()}'
         }
         headers_cache[cache_key] = headers
         return headers
@@ -782,145 +778,8 @@ def build_payload(request_data, model_id):
     
     return payload
 
-# 修改理相关的常量和配置
-PROXY_API_BASE = "https://269900.xyz"
-PROXY_CHECK_INTERVAL = 300  # 5分钟检查一次代理可用性
-PROXY_MAX_LATENCY = 5000  # 最大延迟(毫秒)
-MAX_PROXIES = 10  # 保持的最大代理数量
-PROXY_TIMEOUT = 5  # 代理请求超时时间（秒）
-
-class ProxyManager:
-    def __init__(self):
-        self.proxies: List[Dict[str, Union[str, int, float]]] = []
-        self.last_update = 0
-        self.lock = threading.Lock()
-        self.session = requests.Session()
-
-    def fetch_proxies(self):
-        """同步获取代理列表"""
-        try:
-            endpoint = f"{PROXY_API_BASE}/fetch_all?region=cn&count=5"
-            response = self.session.get(endpoint, timeout=PROXY_TIMEOUT)
-            
-            if response.status_code == 200:
-                # 解析文本响应
-                proxy_list = [p.strip() for p in response.text.split(',') if p.strip()]
-                
-                with self.lock:
-                    self.proxies = []
-                    for proxy_str in proxy_list:
-                        proxy_info = self._parse_proxy_string(proxy_str)
-                        if proxy_info:
-                            self.proxies.append(proxy_info)
-                    
-                    self.last_update = time.time()
-                    logger.info(f"Successfully fetched {len(self.proxies)} proxies")
-            else:
-                logger.error(f"Failed to fetch proxies, status: {response.status_code}")
-                
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error fetching proxies: {e}")
-        except Exception as e:
-            logger.error(f"Unexpected error in fetch_proxies: {e}")
-        finally:
-            if not self.proxies:
-                logger.warning("No proxies available, will retry later")
-
-    def get_proxy(self) -> Optional[str]:
-        """获取一个可用的代理"""
-        with self.lock:
-            current_time = time.time()
-            
-            if not self.proxies or (current_time - self.last_update) > PROXY_CHECK_INTERVAL:
-                self.fetch_proxies()
-            
-            if not self.proxies:
-                return None
-            
-            valid_proxies = [p for p in self.proxies if p['fails'] < 3]
-            if not valid_proxies:
-                self.fetch_proxies()
-                valid_proxies = [p for p in self.proxies if p['fails'] < 3]
-                if not valid_proxies:
-                    return None
-                
-            proxy = min(valid_proxies, key=lambda x: (x['fails'], x['last_use']))
-            proxy['last_use'] = current_time
-            return proxy['url']
-
-    def mark_proxy_failed(self, proxy_url: str) -> None:
-        """标记代理失败"""
-        with self.lock:
-            for proxy in self.proxies:
-                if proxy['url'] == proxy_url:
-                    proxy['fails'] += 1
-                    if proxy['fails'] >= 3:
-                        self.proxies.remove(proxy)
-                        logger.info(f"Removed failed proxy: {proxy_url}")
-                    break
-
-    def check_proxy(self, proxy_url: str) -> bool:
-        """同步检查代理是否可用"""
-        try:
-            response = self.session.get(
-                'https://www.google.com',
-                proxies={'https': proxy_url},
-                timeout=PROXY_TIMEOUT
-            )
-            return response.status_code == 200
-        except Exception:
-            return False
-
-    def _parse_proxy_string(self, proxy_str: str) -> Optional[Dict[str, Union[str, int, float]]]:
-        """解析代理字符串"""
-        try:
-            proxy_str = proxy_str.strip()
-            if not proxy_str:
-                return None
-                
-            if proxy_str.startswith(('http://', 'https://', 'socks4://', 'socks5://')):
-                proxy_type = proxy_str.split('://')[0]
-                address = proxy_str.split('://')[1]
-            else:
-                proxy_type = 'http'
-                address = proxy_str
-                
-            if ':' in address:
-                ip, port = address.split(':')
-                port = int(port)
-            else:
-                return None
-                
-            return {
-                'url': proxy_str if proxy_str.startswith(('http://', 'https://', 'socks4://', 'socks5://')) 
-                       else f"http://{proxy_str}",
-                'type': proxy_type,
-                'ip': ip,
-                'port': port,
-                'last_use': 0,
-                'fails': 0
-            }
-        except Exception as e:
-            logger.error(f"Error parsing proxy string '{proxy_str}': {e}")
-            return None
-
-    def __del__(self):
-        """清理资源"""
-        if hasattr(self, 'session'):
-            self.session.close()
-
-# 修改代理管理器的创建方式
-proxy_manager = None
-
-def get_proxy_manager():
-    """获取或创建代理管理器实例"""
-    global proxy_manager
-    if proxy_manager is None:
-        proxy_manager = ProxyManager()
-    return proxy_manager
-
 def make_request(payload, auth_manager, model_id):
-    """改进的请求函数，支持代理"""
+    """发送请求并处理可能的认证刷新和模型特定错误。"""
     global multi_auth_manager
     max_retries = 3
     retry_delay = 1
@@ -940,6 +799,7 @@ def make_request(payload, auth_manager, model_id):
             else:
                 raise Exception("无法注册新账号")
 
+    # 记录已尝试的账号
     tried_accounts = set()
     
     while len(tried_accounts) < len(multi_auth_manager.auth_managers):
@@ -947,6 +807,7 @@ def make_request(payload, auth_manager, model_id):
         if not auth_manager:
             break
             
+        # 如果这个账号已经尝试过，继续下一个
         if auth_manager._email in tried_accounts:
             continue
             
@@ -957,61 +818,46 @@ 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
+                ).result()
                 
-                # 创建新的会话
-                session = requests.Session()
-                adapter = CustomHTTPAdapter(max_retries=3)
-                session.mount('https://', adapter)
-                session.mount('http://', adapter)
+                if response.status_code == 200 and response.headers.get('Content-Type') == 'text/event-stream':
+                    logger.info(f"请求成功，使用账号 {auth_manager._email}")
+                    return response
                 
-                # 直接使用IP而不是域名
-                url = url.replace(NOTDIAMOND_DOMAIN, NOTDIAMOND_IP)
+                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)
+                    break  # 跳出重试循环，尝试下一个账号
+                
+                logger.error(f"Request failed with status {response.status_code} for account {auth_manager._email}")
                 
-                try:
-                    response = session.post(
-                        url,
-                        headers=headers,
-                        json=payload,
-                        stream=True,
-                        timeout=(5, 30),  # (连接超时, 读取超时)
-                        verify=False  # 禁用SSL验证
-                    )
-                    
-                    if response.status_code == 200:
-                        return response
-                        
-                    if response.status_code == 401:
-                        logger.info(f"Token expired for account {auth_manager._email}, attempting refresh")
-                        if auth_manager.ensure_valid_token():
-                            continue
-                    
-                    if response.status_code == 403:
-                        logger.warning(f"Model {model_id} usage limit reached for account {auth_manager._email}")
-                        auth_manager.set_model_unavailable(model_id)
-                        break
-                    
-                    logger.error(f"Request failed with status {response.status_code}")
-                    
-                except requests.exceptions.RequestException as e:
-                    logger.error(f"Request attempt {attempt + 1} failed: {e}")
-                    if attempt < max_retries - 1:
-                        time.sleep(retry_delay)
-                    continue
-                    
             except Exception as e:
-                logger.error(f"Unexpected error during request: {e}")
+                logger.error(f"Request attempt {attempt + 1} failed for account {auth_manager._email}: {e}")
                 if attempt < max_retries - 1:
                     time.sleep(retry_delay)
                 continue
-            finally:
-                session.close()
 
+    # 所有账号都尝试过且失败后，才进行注册
     if len(tried_accounts) == len(multi_auth_manager.auth_managers):
         logger.info("所有现有账号都已尝试，开始注册新账号")
         successful_accounts = register_bot.register_and_verify(5)
         if successful_accounts:
             credentials = [(account['email'], account['password']) for account in successful_accounts]
             multi_auth_manager = MultiAuthManager(credentials)
+            # 使用新注册的账号重试请求
             return make_request(payload, None, model_id)
     
     raise Exception("所有账号均不可用，且注册新账号失败")
@@ -1067,9 +913,3 @@ if __name__ == "__main__":
     port = int(os.environ.get("PORT", 3000))
     app.run(debug=False, host='0.0.0.0', port=port, threaded=True)
 
-@atexit.register
-def cleanup():
-    """清理资源"""
-    if proxy_manager:
-        logger.info("Cleaning up resources...")
-

requirements.txt

@@ -8,4 +8,3 @@ urllib3==1.26.9
 beautifulsoup4==4.11.1
 Pillow==9.2.0
 lxml==4.9.1
-aiohttp==3.8.1