Delete sora-api-master

sora-api-master/.gitignore

@@ -1,53 +0,0 @@
-# 确保文本文件在仓库中使用 LF
-* text=auto eol=lf
-# API密钥配置
-api_keys.json
-admin_config.json
-*.key
-
-# 环境变量和配置
-.env
-*.env
-config.local.json
-
-# 生成的图像文件
-src/static/images/*
-!src/static/images/.gitkeep
-
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-env/
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-*.egg-info/
-.installed.cfg
-*.egg
-venv/
-.venv/
-
-# 日志文件
-*.log
-logs/
-
-# IDE配置
-.idea/
-.vscode/
-*.swp
-*.swo
-.DS_Store
-
-# Docker
-.dockerignore 

sora-api-master/Dockerfile

@@ -1,29 +0,0 @@
-FROM python:3.10-slim
-
-WORKDIR /app
-
-# 设置Python环境
-ENV PYTHONDONTWRITEBYTECODE=1
-ENV PYTHONUNBUFFERED=1
-ENV PYTHONIOENCODING=utf-8
-
-# 安装依赖
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 复制应用代码
-COPY . .
-
-# 创建必要的目录
-RUN mkdir -p /app/src/static/images && \
-    chmod -R 777 /app/src/static
-
-# 暴露端口
-EXPOSE 8890
-
-# 设置健康检查
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-  CMD curl -f http://localhost:8890/health || exit 1
-
-# 启动应用
-CMD ["python", "run.py"] 

sora-api-master/README.md

@@ -1,485 +0,0 @@
-# OpenAI兼容的Sora API服务
-
-这是一个为Sora提供OpenAI兼容接口的API服务。该服务使用cloudscraper绕过Cloudflare验证，支持多key轮询、并发处理和标准的OpenAI接口格式。
-
-## 功能特点
-
-- **OpenAI兼容接口**：完全兼容OpenAI的`/v1/chat/completions`接口
-- **CF验证绕过**：使用cloudscraper库成功绕过Cloudflare验证
-- **多key轮询**：支持多个Sora认证token，根据权重和速率限制智能选择
-- **并发处理**：支持多个并发请求
-- **流式响应**：支持SSE格式的流式响应
-- **图像处理**：支持文本到图像生成和图像到图像生成（Remix）
-- **异步处理**：支持异步生成图像，返回立即响应，防止请求超时
-- **状态查询**：提供API端点查询异步任务的状态和结果
-- **优化性能**：经过代码优化，提高请求处理速度和资源利用率
-- **健康检查**：支持容器健康检查功能
-
-## 环境要求
-
-- Python 3.8+
-- FastAPI 0.95.0+
-- cloudscraper 1.2.71+
-- 其他依赖见requirements.txt
-
-## 快速部署指南
-
-
-你可以直接运行不指定任何环境变量，所有环境变量都可以在面板里面配置
-
-
-管理员登录密钥默认：sk-123456
-
-
-api请求密钥不设置默认和管理员登录密钥相同
-
-
-docker 一键运行
-   ```bash
-   docker run -d -p 8890:8890 --name sora-api 1hei1/sora-api:latest
-   ```
-
-
-
-### 方法一：直接运行
-
-1. 克隆仓库
-   ```bash
-   git clone https://github.com/1hei1/sora-api.git
-   cd sora-api
-   ```
-
-2. 安装依赖
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. 配置API Keys（两种方式）
-   - **方式1**: 创建api_keys.json文件
-     ```json
-     [
-       {"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60},
-       {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}
-     ]
-     ```
-   - **方式2**: 设置环境变量
-     ```bash
-     # Linux/macOS
-     export API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]'  
-     
-     # Windows (PowerShell)
-     $env:API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]'
-     
-     # Windows (CMD)
-     set API_KEYS=[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]  
-     ```
-
-4. 配置代理（可选，如果需要）
-   ```bash
-   # Linux/macOS - 基本代理
-   export PROXY_HOST=127.0.0.1
-   export PROXY_PORT=7890
-   
-   # Linux/macOS - 带认证的代理
-   export PROXY_HOST=127.0.0.1
-   export PROXY_PORT=7890
-   export PROXY_USER=username
-   export PROXY_PASS=password
-   
-   # Windows (PowerShell) - 基本代理
-   $env:PROXY_HOST="127.0.0.1"
-   $env:PROXY_PORT="7890"
-   
-   # Windows (PowerShell) - 带认证的代理
-   $env:PROXY_HOST="127.0.0.1"
-   $env:PROXY_PORT="7890"
-   $env:PROXY_USER="username"
-   $env:PROXY_PASS="password"
-   
-   # Windows (CMD) - 基本代理
-   set PROXY_HOST=127.0.0.1
-   set PROXY_PORT=7890
-   
-   # Windows (CMD) - 带认证的代理
-   set PROXY_HOST=127.0.0.1
-   set PROXY_PORT=7890
-   set PROXY_USER=username
-   set PROXY_PASS=password
-   ```
-
-5. 启动服务
-   ```bash
-   python run.py
-   ```
-
-6. 访问服务
-   - API服务地址: http://localhost:8890
-   - 后台管理面板: http://localhost:8890/admin
-
-### 方法二：Docker部署
-
-1. 构建Docker镜像
-   ```bash
-   docker build -t sora-api .
-   ```
-
-2. 运行Docker容器（不同配置选项）
-
-   **基本运行方式**:
-   ```bash
-   docker run -d -p 8890:8890 --name sora-api sora-api
-   ```
-
-   **使用预打包镜像**:
-   ```bash
-   docker run -d -p 8890:8890 --name sora-api 1hei1/sora-api:latest
-   ```
-
-   **使用预打包镜像并配置API密钥**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]' \
-     --name sora-api \
-     1hei1/sora-api:v0.1
-   ```
-
-   **使用预打包镜像并配置代理**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
-     -e PROXY_HOST=host.docker.internal \
-     -e PROXY_PORT=7890 \
-     --name sora-api \
-     1hei1/sora-api:v0.1
-   ```
-
-   **带API密钥配置**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}, {"key": "Bearer your-sora-token-2", "weight": 2, "max_rpm": 60}]' \
-     --name sora-api \
-     sora-api
-   ```
-
-   **带基本代理配置**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
-     -e PROXY_HOST=host.docker.internal \
-     -e PROXY_PORT=7890 \
-     --name sora-api \
-     sora-api
-   ```
-
-   **带认证代理配置**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
-     -e PROXY_HOST=host.docker.internal \
-     -e PROXY_PORT=7890 \
-     -e PROXY_USER=username \
-     -e PROXY_PASS=password \
-     --name sora-api \
-     sora-api
-   ```
-
-   **使用外部配置文件**:
-   ```bash
-   # 首先确保api_keys.json文件已正确配置
-   docker run -d -p 8890:8890 \
-     -v $(pwd)/api_keys.json:/app/api_keys.json \
-     -e PROXY_HOST=host.docker.internal \
-     -e PROXY_PORT=7890 \
-     --name sora-api \
-     sora-api
-   ```
-
-   **挂载本地目录保存图片**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -v /your/local/path:/app/src/static/images \
-     --name sora-api \
-     sora-api
-   ```
-
-   **启用详细日志**:
-   ```bash
-   docker run -d -p 8890:8890 \
-     -e API_KEYS='[{"key": "Bearer your-sora-token-1", "weight": 1, "max_rpm": 60}]' \
-     -e VERBOSE_LOGGING=true \
-     --name sora-api \
-     sora-api
-   ```
-
-   **注意**: 在Docker中使用宿主机代理时，请使用`host.docker.internal`而不是`127.0.0.1`作为代理主机地址。
-
-3. 检查容器状态
-   ```bash
-   docker ps
-   docker logs sora-api
-   ```
-
-4. 停止和移除容器
-   ```bash
-   docker stop sora-api
-   docker rm sora-api
-   ```
-
-## 环境变量说明
-
-| 环境变量 | 描述 | 默认值 | 示例 |
-|---------|------|--------|------|
-| `API_HOST` | API服务监听地址 | `0.0.0.0` | `127.0.0.1` |
-| `API_PORT` | API服务端口 | `8890` | `9000` |
-| `BASE_URL` | API基础URL（生成图片的时候需要用到） | `http://0.0.0.0:8890` | `https://api.example.com` |  
-| `PROXY_HOST` | HTTP代理主机 | 空（不使用代理） | `127.0.0.1` |
-| `PROXY_PORT` | HTTP代理端口 | 空（不使用代理） | `7890` |
-| `PROXY_USER` | HTTP代理用户名 | 空（不使用认证） | `username` |
-| `PROXY_PASS` | HTTP代理密码 | 空（不使用认证） | `password` |
-| `IMAGE_SAVE_DIR` | 图片保存目录 | `src/static/images` | `/data/images` |
-| `IMAGE_LOCALIZATION` | 是否启用图片本地化 | `False` | `True` |
-| `ADMIN_KEY` | 管理员API密钥（登录界面输入的密码） | `sk-123456` | `sk-youradminkey` |
-| `API_AUTH_TOKEN` | API认证令牌（使用api服务传入的key） | 空 | `your-auth-token` |
-| `VERBOSE_LOGGING` | 是否启用详细日志 | `False` | `True` |
-
-## API密钥配置说明
-
-API密钥配置采用JSON格式，每个密钥包含以下属性：
-
-- `key`: Sora认证令牌（必须包含Bearer前缀）
-- `weight`: 轮询权重，数字越大被选中概率越高
-- `max_rpm`: 每分钟最大请求数（速率限制）
-
-示例:
-```json
-[
-  {
-    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
-    "weight": 1,
-    "max_rpm": 60
-  },
-  {
-    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
-    "weight": 2,
-    "max_rpm": 60
-  }
-]
-```
-
-## 使用示例
-
-### 使用curl发送请求
-
-```bash
-# 文本到图像请求（非流式）
-curl -X POST http://localhost:8890/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-api-key" \
-  -d '{
-    "model": "sora-1.0",
-    "messages": [
-      {"role": "user", "content": "生成一只在草地上奔跑的金毛犬"}
-    ],
-    "n": 1,
-    "stream": false
-  }'
-
-# 文本到图像请求（流式）
-curl -X POST http://localhost:8890/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-api-key" \
-  -d '{
-    "model": "sora-1.0",
-    "messages": [
-      {"role": "user", "content": "生成一只在草地上奔跑的金毛犬"}
-    ],
-    "n": 1,
-    "stream": true
-  }'
-
-# 查询异步任务状态
-curl -X GET http://localhost:8890/v1/generation/chatcmpl-123456789abcdef \
-  -H "Authorization: Bearer your-api-key"
-```
-
-## 常见问题排查
-
-1. **连接超时或无法连接**
-   - 检查代理配置是否正确
-   - 如使用代理认证，确认用户名密码正确
-   - 确认Sora服务器是否可用
-   - 检查本地网络连接
-
-2. **API密钥加载失败**
-   - 确认api_keys.json格式正确
-   - 检查环境变量API_KEYS是否正确设置
-   - 查看日志中的错误信息
-
-3. **图片生成失败**
-   - 确认Sora令牌有效性
-   - 查看日志中的错误信息
-   - 检查是否超出账户额度限制
-
-4. **Docker容器启动失败**
-   - 检查端口是否被占用
-   - 确认环境变量设置正确
-   - 查看Docker日志中的错误信息
-   
-5. **环境变量API_AUTH_TOKEN和ADMIN_KEY的区别**
-   - 环境变量 API_AUTH_TOKEN代表你在cheery studio 或者newapi里调用填写的令牌
-   - 环境变量 ADMIN_KEY 代表你管理面板的登录密码
-   - 当不设置API_AUTH_TOKE时 其值默认等于ADMIN_KEY的值
-   
-6. **环境变量BASE_URL的作用**
-   - 这个是图��本地化时设置的，比如生成了一张图片，获取到图片原始url，由于有的客户端不能访问sora，所以要本地化，这个base_url就是指定本地化图片的url前缀。
-   
-6. **token无效**
-   - 首次使用的token需要设置用户名，可以使用下面的脚本批量设置用户名：
- ```python
-import random
-import string
-import logging
-import cloudscraper
-
-# Configure logging
-tlogging = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
-
-# --- Configuration ---
-PROXY = {
-    "http": "http://127.0.0.1:7890",
-    "https": "http://127.0.0.1:7890"
-}
-PROFILE_API = "https://sora.chatgpt.com/backend/me"
-TOKENS_FILE = "tokens.txt"  # 每行一个 Bearer token
-RESULTS_FILE = "update_results.txt"  # 保存更新结果
-USERNAME_LENGTH = 8  # 随机用户名长度
-
-# --- Utilities ---
-def random_username(length: int = USERNAME_LENGTH) -> str:
-    """生成全小写随机用户名"""
-    return ''.join(random.choices(string.ascii_lowercase, k=length))
-
-
-def sanitize_headers(headers: dict) -> dict:
-    """
-    移除所有非 Latin-1 字符，确保 headers 可以被底层 HTTP 库正确编码。
-    """
-    new = {}
-    for k, v in headers.items():
-        if isinstance(v, str):
-            new[k] = v.encode('latin-1', 'ignore').decode('latin-1')
-        else:
-            new[k] = v
-    return new
-
-
-class SoraBatchUpdater:
-    def __init__(self, proxy: dict = None):
-        self.proxy = proxy or {}
-
-    def update_username_for_token(self, token: str) -> tuple[bool, str]:
-        """
-        针对单个 Bearer token，生成随机用户名并发送更新请求。
-        返回 (success, message)。
-        """
-        scraper = cloudscraper.create_scraper()
-        if self.proxy:
-            scraper.proxies = self.proxy
-
-        headers = {
-            "Accept": "*/*",
-            "Accept-Language": "zh-CN,zh;q=0.9",
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {token}",
-            "sec-ch-ua": '"Chromium";v="136", "Google Chrome";v="136", "Not.A/Brand";v="99"',
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": '"Windows"',
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-        }
-        headers = sanitize_headers(headers)
-
-        new_username = random_username()
-        payload = {"username": new_username}
-
-        try:
-            resp = scraper.post(
-                PROFILE_API,
-                headers=headers,
-                json=payload,
-                allow_redirects=False,
-                timeout=15
-            )
-            status = resp.status_code
-            if resp.ok:
-                msg = f"OK ({new_username})"
-                logging.info("Token %s: updated to %s", token[:6], new_username)
-                return True, msg
-            else:
-                text = resp.text.replace('\n', '')
-                msg = f"Failed {status}: {text}"  # 简要错误信息
-                logging.warning("Token %s: %s", token[:6], msg)
-                return False, msg
-        except Exception as e:
-            msg = str(e)
-            logging.error("Token %s exception: %s", token[:6], msg)
-            return False, msg
-
-    def batch_update(self, tokens: list[str]) -> None:
-        """
-        对一组 Bearer token 批量更新用户名，并将结果写入 RESULTS_FILE。
-        """
-        results = []
-        for token in tokens:
-            success, message = self.update_username_for_token(token)
-            results.append((token, success, message))
-
-        # 写入结果文件
-        with open(RESULTS_FILE, 'w', encoding='utf-8') as f:
-            for token, success, msg in results:
-                status = 'SUCCESS' if success else 'ERROR'
-                f.write(f"{token} ---- {status} ---- {msg}\n")
-        logging.info("Batch update complete. Results saved to %s", RESULTS_FILE)
-
-
-def load_tokens(filepath: str) -> list[str]:
-    """从文件加载每行一个 token 的列表"""
-    try:
-        with open(filepath, 'r', encoding='utf-8') as f:
-            return [line.strip() for line in f if line.strip()]
-    except FileNotFoundError:
-        logging.error("Tokens file not found: %s", filepath)
-        return []
-
-
-if __name__ == '__main__':
-    tokens = load_tokens(TOKENS_FILE)
-    if not tokens:
-        logging.error("No tokens to update. Exiting.")
-    else:
-        updater = SoraBatchUpdater(proxy=PROXY)
-        updater.batch_update(tokens)
-
-```
-
-
-## 性能优化
-
-最新版本包含以下性能优化：
-
-1. **代码重构**：简化了代码结构，提高可读性和可维护性
-2. **内存优化**：减少不必要的内存使用，优化大型图像处理
-3. **异步处理**：全面使用异步处理提高并发性能
-4. **错误处理**：改进了错误处理和日志记录
-5. **密钥管理**：优化了密钥轮询算法，提高了可靠性
-6. **容器优化**：增强了Docker容器配置，支持健康检查
-
-## 贡献
-
-欢迎提交问题报告和改进建议！
-
-## 许可证
-
-MIT 

sora-api-master/api_keys.json.example

@@ -1,12 +0,0 @@
-[
-  {
-    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
-    "weight": 1,
-    "max_rpm": 60
-  },
-  {
-    "key": "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
-    "weight": 2,
-    "max_rpm": 60
-  }
-] 

sora-api-master/docs/image_localization.md

@@ -1 +0,0 @@
- 

sora-api-master/requirements.txt

@@ -1,28 +0,0 @@
-# Web框架
-fastapi>=0.101.1
-uvicorn>=0.23.2
-pydantic>=2.3.0
-python-multipart==0.0.6
-
-# HTTP请求
-cloudscraper==1.2.71
-aiohttp>=3.8.5
-aiofiles==0.8.0
-
-# 工具
-python-dotenv>=1.0.0
-requests==2.30.0
-pillow==10.0.0
-cryptography==41.0.3
-psutil==5.9.5
-tzdata>=2023.3
-pytz>=2023.3
-retry>=0.9.2
-fuzzywuzzy>=0.18.0
-python-Levenshtein>=0.21.1
-tzlocal>=5.0.1
-humanize>=4.7.0
-prettytable>=3.8.0
-natsort>=8.4.0
-tenacity>=8.2.3
-PyJWT>=2.6.0 

sora-api-master/run.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-import sys
-import os
-import logging
-
-# 设置日志
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("sora-api")
-
-# 设置控制台输出编码为UTF-8
-if sys.platform.startswith('win'):
-    os.system("chcp 65001")
-    sys.stdout.reconfigure(encoding='utf-8')
-elif sys.stdout.encoding != 'utf-8':
-    sys.stdout.reconfigure(encoding='utf-8')
-
-# 确保src目录在路径中
-sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
-
-# 提前加载app和key_manager，确保API密钥在启动前已加载
-from src.app import app, key_manager
-from src.main import init_app
-from src.config import Config
-import uvicorn
-
-if __name__ == "__main__":
-    # 设置环境变量确保正确处理UTF-8
-    os.environ["PYTHONIOENCODING"] = "utf-8"
-    
-    # 初始化应用
-    init_app()
-    
-    # 启动服务
-    logger.info(f"启动OpenAI兼容的Sora API服务: {Config.HOST}:{Config.PORT}")
-    logger.info(f"已加载 {len(key_manager.keys)} 个API密钥")
-    uvicorn.run(
-        "src.app:app",
-        host=Config.HOST,
-        port=Config.PORT,
-        reload=False  # 生产环境关闭自动重载
-    ) 

sora-api-master/src/__init__.py

@@ -1,2 +0,0 @@
-# Sora API服务包
-# 包含对Sora的API调用封装，提供OpenAI兼容接口 

sora-api-master/src/api/__init__.py

@@ -1,29 +0,0 @@
-import logging
-from fastapi import APIRouter
-from .admin import router as admin_router
-from .generation import router as generation_router
-from .chat import router as chat_router
-from .health import router as health_router
-# 添加auth路由
-from .auth import router as auth_router
-
-# 设置日志
-logger = logging.getLogger("sora-api.api")
-
-# 创建v1版本路由（兼容OpenAI API）
-v1_router = APIRouter(prefix="/v1")
-
-# 创建主路由
-main_router = APIRouter()
-
-# 向v1路由注册相关功能路由
-v1_router.include_router(generation_router)
-v1_router.include_router(chat_router)
-
-# 注册所有路由
-main_router.include_router(v1_router) # 保持与OpenAI API兼容的v1前缀路由
-main_router.include_router(admin_router, tags=["admin"])
-main_router.include_router(health_router, tags=["health"])
-main_router.include_router(auth_router, tags=["auth"])
-
-logger.info("API路由已初始化")

sora-api-master/src/api/admin.py

@@ -1,463 +0,0 @@
-import os
-import logging
-import dotenv
-from typing import Dict, Any, List
-from fastapi import APIRouter, Depends, HTTPException
-from fastapi.responses import FileResponse
-
-from ..models.schemas import ApiKeyCreate, ApiKeyUpdate, ConfigUpdate, LogLevelUpdate, BatchOperation, BatchImportOperation
-from ..api.dependencies import verify_admin, verify_admin_jwt
-from ..config import Config
-from ..key_manager import key_manager
-from ..sora_integration import SoraClient
-
-# 设置日志
-logger = logging.getLogger("sora-api.admin")
-
-# 日志系统配置
-class LogConfig:
-    LEVEL = os.getenv("LOG_LEVEL", "WARNING").upper()
-    FORMAT = "%(asctime)s [%(levelname)s] %(message)s"
-
-# 创建路由
-router = APIRouter(prefix="/api")
-
-# 密钥管理API
-@router.get("/keys")
-async def get_all_keys(admin_token = Depends(verify_admin_jwt)):
-    """获取所有API密钥"""
-    return key_manager.get_all_keys()
-
-@router.get("/keys/{key_id}")
-async def get_key(key_id: str, admin_token = Depends(verify_admin_jwt)):
-    """获取单个API密钥详情"""
-    key = key_manager.get_key_by_id(key_id)
-    if not key:
-        raise HTTPException(status_code=404, detail="密钥不存在")
-    return key
-
-@router.post("/keys")
-async def create_key(key_data: ApiKeyCreate, admin_token = Depends(verify_admin_jwt)):
-    """创建新API密钥"""
-    try:
-        # 确保密钥值包含 Bearer 前缀
-        key_value = key_data.key_value
-        if not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-            
-        new_key = key_manager.add_key(
-            key_value,
-            name=key_data.name,
-            weight=key_data.weight,
-            rate_limit=key_data.rate_limit,
-            is_enabled=key_data.is_enabled,
-            notes=key_data.notes
-        )
-        
-        # 通过Config永久保存所有密钥
-        Config.save_api_keys(key_manager.keys)
-        
-        return new_key
-    except Exception as e:
-        logger.error(f"创建密钥失败: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=400, detail=str(e))
-
-@router.put("/keys/{key_id}")
-async def update_key(key_id: str, key_data: ApiKeyUpdate, admin_token = Depends(verify_admin_jwt)):
-    """更新API密钥信息"""
-    try:
-        # 如果提供了新的密钥值，确保包含Bearer前缀
-        key_value = key_data.key_value
-        if key_value and not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-            key_data.key_value = key_value
-            
-        updated_key = key_manager.update_key(
-            key_id,
-            key_value=key_data.key_value,
-            name=key_data.name,
-            weight=key_data.weight,
-            rate_limit=key_data.rate_limit,
-            is_enabled=key_data.is_enabled,
-            notes=key_data.notes
-        )
-        if not updated_key:
-            raise HTTPException(status_code=404, detail="密钥不存在")
-        
-        # 通过Config永久保存所有密钥
-        Config.save_api_keys(key_manager.keys)
-        
-        return updated_key
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"更新密钥失败: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=400, detail=str(e))
-
-@router.delete("/keys/{key_id}")
-async def delete_key(key_id: str, admin_token = Depends(verify_admin_jwt)):
-    """删除API密钥"""
-    success = key_manager.delete_key(key_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="密钥不存在")
-    
-    # 通过Config永久保存所有密钥
-    Config.save_api_keys(key_manager.keys)
-    
-    return {"status": "success", "message": "密钥已删除"}
-
-@router.get("/stats")
-async def get_usage_stats(admin_token = Depends(verify_admin_jwt)):
-    """获取API使用统计"""
-    stats = key_manager.get_usage_stats()
-    
-    # 处理daily_usage数据，确保前端能够正确显示
-    daily_usage = {}
-    keys_usage = {}
-    
-    # 从past_7_days数据转换为daily_usage格式
-    for date, counts in stats.get("past_7_days", {}).items():
-        daily_usage[date] = counts.get("successful", 0) + counts.get("failed", 0)
-    
-    # 获取每个密钥的使用情况
-    for key in key_manager.keys:
-        key_id = key.get("id")
-        key_name = key.get("name") or f"密钥_{key_id[:6]}"
-        
-        # 获取该密钥的使用统计
-        if key_id in key_manager.usage_stats:
-            key_stats = key_manager.usage_stats[key_id]
-            total_requests = key_stats.get("total_requests", 0)
-            
-            if total_requests > 0:
-                keys_usage[key_name] = total_requests
-    
-    # 添加到返回数据中
-    stats["daily_usage"] = daily_usage
-    stats["keys_usage"] = keys_usage
-    
-    return stats
-
-@router.post("/keys/test")
-async def test_key(key_data: ApiKeyCreate, admin_token = Depends(verify_admin_jwt)):
-    """测试API密钥是否有效"""
-    try:
-        # 获取密钥值
-        key_value = key_data.key_value.strip()
-        
-        # 确保密钥格式正确
-        if not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-        
-        # 获取代理配置
-        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
-        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
-        proxy_user = Config.PROXY_USER if Config.PROXY_USER and Config.PROXY_USER.strip() else None
-        proxy_pass = Config.PROXY_PASS if Config.PROXY_PASS and Config.PROXY_PASS.strip() else None
-        
-        test_client = SoraClient(
-            proxy_host=proxy_host,
-            proxy_port=proxy_port,
-            proxy_user=proxy_user,
-            proxy_pass=proxy_pass,
-            auth_token=key_value
-        )
-        
-        # 执行简单API调用测试连接
-        test_result = await test_client.test_connection()
-        logger.info(f"API密钥测试结果: {test_result}")
-        
-        # 检查底层测试结果的状态
-        if test_result.get("status") == "success":
-            # API连接测试成功
-            return {
-                "status": "success", 
-                "message": "API密钥测试成功", 
-                "details": test_result,
-                "success": True
-            }
-        else:
-            # API连接测试失败
-            return {
-                "status": "error", 
-                "message": f"API密钥测试失败: {test_result.get('message', '连接失败')}", 
-                "details": test_result,
-                "success": False
-            }
-    except Exception as e:
-        logger.error(f"测试密钥失败: {str(e)}", exc_info=True)
-        return {
-            "status": "error", 
-            "message": f"API密钥测试失败: {str(e)}",
-            "success": False
-        }
-
-@router.post("/keys/batch")
-async def batch_operation(operation: Dict[str, Any], admin_token = Depends(verify_admin_jwt)):
-    """批量操作API密钥"""
-    try:
-        action = operation.get("action")
-        logger.info(f"接收到批量操作请求: {action}")
-        
-        if not action:
-            logger.warning("批量操作缺少action参数")
-            raise HTTPException(status_code=400, detail="缺少必要参数: action")
-        
-        logger.info(f"批量操作类型: {action}")
-        
-        if action == "import":
-            # 批量导入API密钥
-            keys_data = operation.get("keys", [])
-            if not keys_data:
-                logger.warning("批量导入缺少keys数据")
-                raise HTTPException(status_code=400, detail="未提供密钥数据")
-            
-            logger.info(f"准备导入 {len(keys_data)} 个密钥")
-            
-            # 对每个密钥处理Bearer前缀
-            for key_data in keys_data:
-                if isinstance(key_data, dict):
-                    key_value = key_data.get("key", "").strip()
-                    if key_value and not key_value.startswith("Bearer "):
-                        key_data["key"] = f"Bearer {key_value}"
-            
-            # 执行批量导入
-            try:
-                result = key_manager.batch_import_keys(keys_data)
-                logger.info(f"导入结果: 成功={result['imported']}, 跳过={result['skipped']}")
-                
-                # 通过Config永久保存所有密钥
-                Config.save_api_keys(key_manager.keys)
-                
-                return {
-                    "success": True,
-                    "message": f"成功导入 {result['imported']} 个密钥，跳过 {result['skipped']} 个重复密钥",
-                    "imported": result["imported"],
-                    "skipped": result["skipped"]
-                }
-            except Exception as e:
-                logger.error(f"批量导入密钥错误: {str(e)}", exc_info=True)
-                raise HTTPException(status_code=500, detail=f"导入密钥失败: {str(e)}")
-                
-        elif action not in ["enable", "disable", "delete"]:
-            logger.warning(f"不支持的批量操作: {action}")
-            raise HTTPException(status_code=400, detail=f"不支持的操作: {action}")
-            
-        # 对于非导入操作，需要提供key_ids
-        key_ids = operation.get("key_ids", [])
-        if not key_ids:
-            logger.warning(f"{action}操作缺少key_ids参数")
-            raise HTTPException(status_code=400, detail="缺少必要参数: key_ids")
-            
-        # 确保key_ids是一个列表
-        if isinstance(key_ids, str):
-            key_ids = [key_ids]
-            
-        logger.info(f"批量{action}操作 {len(key_ids)} 个密钥")
-            
-        if action == "enable":
-            # 批量启用
-            success_count = 0
-            for key_id in key_ids:
-                updated = key_manager.update_key(key_id, is_enabled=True)
-                if updated:
-                    success_count += 1
-            
-            # 通过Config永久保存所有密钥
-            Config.save_api_keys(key_manager.keys)
-            
-            logger.info(f"成功启用 {success_count} 个密钥")
-            return {
-                "success": True,
-                "message": f"已成功启用 {success_count} 个密钥",
-                "affected": success_count
-            }
-        elif action == "disable":
-            # 批量禁用
-            success_count = 0
-            for key_id in key_ids:
-                updated = key_manager.update_key(key_id, is_enabled=False)
-                if updated:
-                    success_count += 1
-            
-            # 通过Config永久保存所有密钥
-            Config.save_api_keys(key_manager.keys)
-            
-            logger.info(f"成功禁用 {success_count} 个密钥")
-            return {
-                "success": True,
-                "message": f"已成功禁用 {success_count} 个密钥",
-                "affected": success_count
-            }
-        elif action == "delete":
-            # 批量删除
-            success_count = 0
-            for key_id in key_ids:
-                if key_manager.delete_key(key_id):
-                    success_count += 1
-            
-            # 通过Config永久保存所有密钥
-            Config.save_api_keys(key_manager.keys)
-            
-            logger.info(f"成功删除 {success_count} 个密钥")
-            return {
-                "success": True,
-                "message": f"已成功删除 {success_count} 个密钥",
-                "affected": success_count
-            }
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"批量操作失败: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-# 配置管理API
-@router.get("/config")
-async def get_config(admin_token = Depends(verify_admin_jwt)):
-    """获取当前系统配置"""
-    return {
-        "HOST": Config.HOST,
-        "PORT": Config.PORT,
-        "BASE_URL": Config.BASE_URL,
-        "PROXY_HOST": Config.PROXY_HOST,
-        "PROXY_PORT": Config.PROXY_PORT,
-        "PROXY_USER": Config.PROXY_USER,
-        "PROXY_PASS": "******" if Config.PROXY_PASS else "",
-        "IMAGE_LOCALIZATION": Config.IMAGE_LOCALIZATION,
-        "IMAGE_SAVE_DIR": Config.IMAGE_SAVE_DIR,
-        "API_AUTH_TOKEN": bool(Config.API_AUTH_TOKEN)  # 只返回是否设置，不返回实际值
-    }
-
-@router.post("/config")
-async def update_config(config_data: ConfigUpdate, admin_token = Depends(verify_admin_jwt)):
-    """更新系统配置"""
-    try:
-        changes = []
-        
-        # 更新代理设置
-        if config_data.PROXY_HOST is not None:
-            Config.PROXY_HOST = config_data.PROXY_HOST
-            changes.append("PROXY_HOST")
-            # 更新环境变量
-            os.environ["PROXY_HOST"] = config_data.PROXY_HOST
-            
-        if config_data.PROXY_PORT is not None:
-            Config.PROXY_PORT = config_data.PROXY_PORT
-            changes.append("PROXY_PORT")
-            # 更新环境变量
-            os.environ["PROXY_PORT"] = config_data.PROXY_PORT
-            
-        # 更新代理认证设置
-        if config_data.PROXY_USER is not None:
-            Config.PROXY_USER = config_data.PROXY_USER
-            changes.append("PROXY_USER")
-            # 更新环境变量
-            os.environ["PROXY_USER"] = config_data.PROXY_USER
-            
-        if config_data.PROXY_PASS is not None:
-            Config.PROXY_PASS = config_data.PROXY_PASS
-            changes.append("PROXY_PASS")
-            # 更新环境变量
-            os.environ["PROXY_PASS"] = config_data.PROXY_PASS
-            
-        # 更新基础URL设置
-        if config_data.BASE_URL is not None:
-            Config.BASE_URL = config_data.BASE_URL
-            changes.append("BASE_URL")
-            # 更新环境变量
-            os.environ["BASE_URL"] = config_data.BASE_URL
-            
-        # 更新图片本地化设置
-        if config_data.IMAGE_LOCALIZATION is not None:
-            Config.IMAGE_LOCALIZATION = config_data.IMAGE_LOCALIZATION
-            changes.append("IMAGE_LOCALIZATION")
-            # 更新环境变量
-            os.environ["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
-            
-        if config_data.IMAGE_SAVE_DIR is not None:
-            Config.IMAGE_SAVE_DIR = config_data.IMAGE_SAVE_DIR
-            changes.append("IMAGE_SAVE_DIR")
-            # 更新环境变量
-            os.environ["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
-            # 确保目录存在
-            os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-            
-        # 保存到.env文件
-        if config_data.save_to_env and changes:
-            env_file = os.path.join(Config.BASE_DIR, '.env')
-            env_data = {}
-            
-            # 先读取现有的.env文件
-            if os.path.exists(env_file):
-                env_data = dotenv.dotenv_values(env_file)
-                
-            # 更新环境变量
-            for field in changes:
-                value = getattr(Config, field)
-                env_data[field] = str(value)
-                
-            # 写入.env文件
-            with open(env_file, 'w') as f:
-                for key, value in env_data.items():
-                    f.write(f"{key}={value}\n")
-                    
-            logger.info(f"已将配置保存到.env文件: {changes}")
-        
-        return {
-            "status": "success", 
-            "message": f"配置已更新: {', '.join(changes) if changes else '无变更'}"
-        }
-    except Exception as e:
-        logger.error(f"更新配置失败: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=400, detail=f"更新配置失败: {str(e)}")
-
-@router.post("/logs/level")
-async def update_log_level(data: LogLevelUpdate, admin_token = Depends(verify_admin_jwt)):
-    """更新日志级别"""
-    try:
-        # 验证日志级别
-        level = data.level.upper()
-        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-        
-        if level not in valid_levels:
-            raise HTTPException(status_code=400, detail=f"无效的日志级别: {level}")
-        
-        # 更新根日志记录器的级别
-        root_logger = logging.getLogger()
-        root_logger.setLevel(getattr(logging, level))
-        
-        # 同时更新sora-api模块的日志级别
-        sora_logger = logging.getLogger("sora-api")
-        sora_logger.setLevel(getattr(logging, level))
-        
-        # 记录日志级别变更
-        logger.info(f"日志级别已更新为: {level}")
-        
-        # 如果需要，保存到环境变量
-        if data.save_to_env:
-            env_file = os.path.join(Config.BASE_DIR, '.env')
-            env_data = {}
-            
-            # 先读取现有的.env文件
-            if os.path.exists(env_file):
-                env_data = dotenv.dotenv_values(env_file)
-                
-            # 更新LOG_LEVEL环境变量
-            env_data["LOG_LEVEL"] = level
-                
-            # 写入.env文件
-            with open(env_file, 'w') as f:
-                for key, value in env_data.items():
-                    f.write(f"{key}={value}\n")
-            
-            # 记录配置保存
-            logger.info(f"已将日志级别保存到.env文件: LOG_LEVEL={level}")
-        
-        return {"status": "success", "message": f"日志级别已更新为: {level}"}
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"更新日志级别失败: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=400, detail=f"更新日志级别失败: {str(e)}")
-
-# 管理员密钥API - 已移至app.py中

sora-api-master/src/api/auth.py

@@ -1,96 +0,0 @@
-import jwt
-import time
-import uuid
-import logging
-from typing import Dict, Any
-from fastapi import APIRouter, HTTPException, Depends
-from pydantic import BaseModel
-
-from ..config import Config
-
-# 设置日志
-logger = logging.getLogger("sora-api.auth")
-
-# 创建路由
-router = APIRouter(prefix="/api/auth")
-
-# JWT配置
-JWT_SECRET = Config.ADMIN_KEY  # 使用管理员密钥作为JWT秘钥
-JWT_ALGORITHM = "HS256"
-JWT_EXPIRATION = 3600  # 令牌有效期1小时
-
-# 认证请求模型
-class LoginRequest(BaseModel):
-    admin_key: str
-
-# 令牌响应模型
-class TokenResponse(BaseModel):
-    token: str
-    expires_in: int
-    token_type: str = "bearer"
-
-# 创建JWT令牌
-def create_jwt_token(data: Dict[str, Any], expires_delta: int = JWT_EXPIRATION) -> str:
-    payload = data.copy()
-    issued_at = int(time.time())
-    expiration = issued_at + expires_delta
-    payload.update({
-        "iat": issued_at,
-        "exp": expiration,
-        "jti": str(uuid.uuid4())
-    })
-    
-    token = jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALGORITHM)
-    return token
-
-# 验证JWT令牌
-def verify_jwt_token(token: str) -> Dict[str, Any]:
-    try:
-        payload = jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
-        # 检查token是否已过期
-        if payload.get("exp", 0) < time.time():
-            raise HTTPException(status_code=401, detail="令牌已过期")
-        return payload
-    except jwt.PyJWTError as e:
-        logger.warning(f"JWT验证失败: {str(e)}")
-        raise HTTPException(status_code=401, detail="无效的令牌")
-
-# 登录API
-@router.post("/login", response_model=TokenResponse)
-async def login(request: LoginRequest):
-    """管理员登录，返回JWT令牌"""
-    # 验证管理员密钥
-    if request.admin_key != Config.ADMIN_KEY:
-        logger.warning(f"尝试使用无效的管理员密钥登录")
-        # 使用固定延迟以防止计时攻击
-        time.sleep(1)
-        raise HTTPException(status_code=401, detail="管理员密钥错误")
-    
-    # 创建令牌
-    token_data = {
-        "sub": "admin",
-        "role": "admin",
-        "name": "管理员"
-    }
-    
-    token = create_jwt_token(token_data)
-    logger.info(f"管理员登录成功，生成新令牌")
-    
-    return TokenResponse(token=token, expires_in=JWT_EXPIRATION)
-
-# 刷新令牌API
-@router.post("/refresh", response_model=TokenResponse)
-async def refresh_token(token: str = Depends(verify_jwt_token)):
-    """刷新JWT令牌"""
-    # 创建新令牌，保持相同的sub和role
-    token_data = {
-        "sub": token.get("sub"),
-        "role": token.get("role", "admin"),
-        "name": token.get("name", "管理员"),
-        "refresh_count": token.get("refresh_count", 0) + 1
-    }
-    
-    new_token = create_jwt_token(token_data)
-    logger.info(f"令牌刷新成功，生成新令牌")
-    
-    return TokenResponse(token=new_token, expires_in=JWT_EXPIRATION) 

sora-api-master/src/api/chat.py

@@ -1,168 +0,0 @@
-import uuid
-import time
-import re
-import logging
-from typing import Dict, Any, List, Optional
-from fastapi import APIRouter, Depends, BackgroundTasks, HTTPException
-from fastapi.responses import StreamingResponse, JSONResponse
-
-from ..models.schemas import ChatCompletionRequest
-from ..api.dependencies import verify_api_key, get_sora_client_dep
-from ..services.image_service import process_image_task, format_think_block
-from ..services.streaming import generate_streaming_response, generate_streaming_remix_response
-from ..key_manager import key_manager
-
-# 设置日志
-logger = logging.getLogger("sora-api.chat")
-
-# 创建路由
-router = APIRouter()
-
-@router.post("/chat/completions")
-async def chat_completions(
-    request: ChatCompletionRequest,
-    background_tasks: BackgroundTasks,
-    client_info = Depends(get_sora_client_dep()),
-    api_key: str = Depends(verify_api_key)
-):
-    """
-    聊天完成端点 - 处理文本到图像和图像到图像的请求
-    兼容OpenAI API格式
-    """
-    # 解析客户端信息
-    sora_client, sora_auth_token = client_info
-    
-    # 记录开始时间
-    start_time = time.time()
-    success = False
-    
-    try:
-        # 分析用户消息
-        user_messages = [m for m in request.messages if m.role == "user"]
-        if not user_messages:
-            raise HTTPException(status_code=400, detail="至少需要一条用户消息")
-        
-        last_user_message = user_messages[-1]
-        prompt = ""
-        image_data = None
-        
-        # 提取提示词和图片数据
-        if isinstance(last_user_message.content, str):
-            # 简单的字符串内容
-            prompt = last_user_message.content
-            
-            # 检查是否包含内嵌的base64图片
-            pattern = r'data:image\/[^;]+;base64,([^"]+)'
-            match = re.search(pattern, prompt)
-            if match:
-                image_data = match.group(1)
-                # 从提示词中删除base64数据
-                prompt = re.sub(pattern, "[已上传图片]", prompt)
-        else:
-            # 多模态内容，提取文本和图片
-            content_items = last_user_message.content
-            text_parts = []
-            
-            for item in content_items:
-                if item.type == "text" and item.text:
-                    text_parts.append(item.text)
-                elif item.type == "image_url" and item.image_url:
-                    # 如果有图片URL包含base64数据
-                    url = item.image_url.get("url", "")
-                    if url.startswith("data:image/"):
-                        pattern = r'data:image\/[^;]+;base64,([^"]+)'
-                        match = re.search(pattern, url)
-                        if match:
-                            image_data = match.group(1)
-                            text_parts.append("[已上传图片]")
-            
-            prompt = " ".join(text_parts)
-        
-        # 检查是否为流式响应
-        if request.stream:
-            # 流式响应处理
-            if image_data:
-                response = StreamingResponse(
-                    generate_streaming_remix_response(sora_client, prompt, image_data, request.n),
-                    media_type="text/event-stream"
-                )
-            else:
-                response = StreamingResponse(
-                    generate_streaming_response(sora_client, prompt, request.n),
-                    media_type="text/event-stream"
-                )
-            success = True
-            
-            # 记录请求结果
-            response_time = time.time() - start_time
-            key_manager.record_request_result(sora_auth_token, success, response_time)
-            
-            return response
-        else:
-            # 非流式响应 - 返回一个即时响应，表示任务已接收
-            request_id = f"chatcmpl-{uuid.uuid4().hex}"
-            
-            # 创建后台任务
-            if image_data:
-                background_tasks.add_task(
-                    process_image_task,
-                    request_id,
-                    sora_client,
-                    "remix",
-                    prompt,
-                    image_data=image_data,
-                    num_images=request.n
-                )
-            else:
-                background_tasks.add_task(
-                    process_image_task,
-                    request_id,
-                    sora_client,
-                    "generation",
-                    prompt,
-                    num_images=request.n,
-                    width=720,
-                    height=480
-                )
-                
-            # 返回正在处理的响应
-            processing_message = "正在准备生成任务，请稍候..."
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": int(time.time()),
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": format_think_block(processing_message)
-                        },
-                        "finish_reason": "processing"
-                    }
-                ],
-                "usage": {
-                    "prompt_tokens": len(prompt) // 4,
-                    "completion_tokens": 10,
-                    "total_tokens": len(prompt) // 4 + 10
-                }
-            }
-            
-            success = True
-            
-            # 记录请求结果
-            response_time = time.time() - start_time
-            key_manager.record_request_result(sora_auth_token, success, response_time)
-            
-            return JSONResponse(content=response)
-            
-    except Exception as e:
-        success = False
-        logger.error(f"处理聊天完成请求失败: {str(e)}", exc_info=True)
-        
-        # 记录请求结果
-        response_time = time.time() - start_time
-        key_manager.record_request_result(sora_auth_token, success, response_time)
-        
-        raise HTTPException(status_code=500, detail=f"图像生成失败: {str(e)}") 

sora-api-master/src/api/dependencies.py

@@ -1,131 +0,0 @@
-from typing import Optional, Tuple, Dict, Any
-from fastapi import Request, HTTPException, Depends, Header
-import aiohttp
-import logging
-from ..config import Config
-from .auth import verify_jwt_token
-
-logger = logging.getLogger("sora-api.dependencies")
-
-# 全局会话池
-session_pool: Optional[aiohttp.ClientSession] = None
-
-# 获取Sora客户端
-def get_sora_client(auth_token: str):
-    from ..sora_integration import SoraClient
-    
-    # 使用字典缓存客户端实例
-    if not hasattr(get_sora_client, "clients"):
-        get_sora_client.clients = {}
-        
-    if auth_token not in get_sora_client.clients:
-        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
-        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
-        proxy_user = Config.PROXY_USER if Config.PROXY_USER and Config.PROXY_USER.strip() else None
-        proxy_pass = Config.PROXY_PASS if Config.PROXY_PASS and Config.PROXY_PASS.strip() else None
-        
-        get_sora_client.clients[auth_token] = SoraClient(
-            proxy_host=proxy_host, 
-            proxy_port=proxy_port,
-            proxy_user=proxy_user,
-            proxy_pass=proxy_pass,
-            auth_token=auth_token
-        )
-    
-    return get_sora_client.clients[auth_token]
-
-# 从请求头中获取并验证认证令牌
-async def get_token_from_header(authorization: Optional[str] = Header(None)) -> str:
-    """从请求头中获取认证令牌"""
-    if not authorization:
-        raise HTTPException(status_code=401, detail="缺少认证头")
-    
-    if not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="无效的认证头格式")
-    
-    return authorization.replace("Bearer ", "")
-
-# 验证API key
-async def verify_api_key(request: Request):
-    """检查请求头中的API密钥"""
-    auth_header = request.headers.get("Authorization")
-    if not auth_header or not auth_header.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="缺少或无效的API key")
-    
-    api_key = auth_header.replace("Bearer ", "")
-    
-    # 验证API认证令牌
-    if Config.API_AUTH_TOKEN:
-        # 如果设置了API_AUTH_TOKEN环境变量，则进行验证
-        if api_key != Config.API_AUTH_TOKEN:
-            logger.warning(f"API认证失败: 提供的令牌不匹配")
-            raise HTTPException(status_code=401, detail="API认证失败，令牌无效")
-    else:
-        # 如果未设置API_AUTH_TOKEN，则验证是否为管理面板的key
-        from ..key_manager import key_manager
-        valid_keys = [k.get("key") for k in key_manager.get_all_keys() if k.get("is_enabled", False)]
-        if api_key not in valid_keys and api_key != Config.ADMIN_KEY:
-            logger.warning(f"API认证失败: 提供的key不在有效列表中")
-            raise HTTPException(status_code=401, detail="API认证失败，key无效")
-    
-    return api_key
-
-# 获取Sora客户端依赖
-def get_sora_client_dep(specific_key=None):
-    """返回一个依赖函数，用于获取Sora客户端
-    
-    Args:
-        specific_key: 指定使用的API密钥，如果不为None，则优先使用此密钥
-    """
-    async def _get_client(auth_token: str = Depends(verify_api_key)):
-        from ..key_manager import key_manager
-        
-        # 如果提供了特定密钥，则使用该密钥
-        if specific_key:
-            sora_auth_token = specific_key
-        else:
-            # 使用密钥管理器获取可用的API密钥
-            sora_auth_token = key_manager.get_key()
-            if not sora_auth_token:
-                raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
-            
-        # 获取Sora客户端
-        return get_sora_client(sora_auth_token), sora_auth_token
-    
-    return _get_client
-
-# 验证JWT令牌并验证管理员权限
-async def verify_admin_jwt(token: str = Depends(get_token_from_header)) -> Dict[str, Any]:
-    """验证JWT令牌并确认管理员权限"""
-    # 验证JWT令牌
-    payload = verify_jwt_token(token)
-    
-    # 验证是否为管理员角色
-    if payload.get("role") != "admin":
-        raise HTTPException(status_code=403, detail="没有管理员权限")
-    
-    return payload
-
-# 验证管理员权限（传统方法，保留向后兼容性）
-async def verify_admin(request: Request):
-    """验证管理员权限"""
-    auth_header = request.headers.get("Authorization")
-    if not auth_header or not auth_header.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="未授权")
-    
-    token = auth_header.replace("Bearer ", "")
-    
-    # 尝试JWT验证
-    try:
-        payload = verify_jwt_token(token)
-        if payload.get("role") == "admin":
-            return token
-    except HTTPException:
-        # JWT验证失败，尝试传统验证
-        pass
-    
-    # 传统验证（直接验证管理员密钥）
-    if token != Config.ADMIN_KEY:
-        raise HTTPException(status_code=403, detail="没有管理员权限")
-    
-    return token 

sora-api-master/src/api/generation.py

@@ -1,159 +0,0 @@
-import time
-import logging
-from typing import Dict, Any
-from fastapi import APIRouter, Depends, HTTPException
-from fastapi.responses import JSONResponse
-
-from ..api.dependencies import verify_api_key, get_sora_client_dep
-from ..services.image_service import get_generation_result, get_task_api_key
-from ..key_manager import key_manager
-
-# 设置日志
-logger = logging.getLogger("sora-api.generation")
-
-# 创建路由
-router = APIRouter()
-
-@router.get("/generation/{request_id}")
-async def check_generation_status(
-    request_id: str,
-    client_info = Depends(get_sora_client_dep()),
-    api_key: str = Depends(verify_api_key)
-):
-    """
-    检查图像生成任务的状态
-    
-    Args:
-        request_id: 要查询的请求ID
-        client_info: Sora客户端信息（由依赖提供）
-        api_key: API密钥（由依赖提供）
-    
-    Returns:
-        包含任务状态和结果的JSON响应
-    """
-    # 获取任务对应的原始API密钥
-    task_api_key = get_task_api_key(request_id)
-    
-    # 如果找到任务对应的API密钥，则使用该密钥获取客户端
-    if task_api_key:
-        # 获取使用特定API密钥的客户端
-        specific_client_dep = get_sora_client_dep(specific_key=task_api_key)
-        client_info = await specific_client_dep(api_key)
-    
-    # 解析客户端信息
-    _, sora_auth_token = client_info
-    
-    # 记录开始时间
-    start_time = time.time()
-    success = False
-    
-    try:
-        # 获取任务结果
-        result = get_generation_result(request_id)
-        
-        if result.get("status") == "not_found":
-            raise HTTPException(status_code=404, detail=f"找不到生成任务: {request_id}")
-        
-        if result.get("status") == "completed":
-            # 任务已完成，返回结果
-            image_urls = result.get("image_urls", [])
-            
-            # 构建OpenAI兼容的响应
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": result.get("timestamp", int(time.time())),
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": i,
-                        "message": {
-                            "role": "assistant",
-                            "content": f"![Generated Image]({url})"
-                        },
-                        "finish_reason": "stop"
-                    }
-                    for i, url in enumerate(image_urls)
-                ],
-                "usage": {
-                    "prompt_tokens": 0,
-                    "completion_tokens": 20,
-                    "total_tokens": 20
-                }
-            }
-            success = True
-            
-        elif result.get("status") == "failed":
-            # 任务失败
-            message = result.get("message", f"```think\n生成失败: {result.get('error', '未知错误')}\n```")
-            
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": result.get("timestamp", int(time.time())),
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": message
-                        },
-                        "finish_reason": "error"
-                    }
-                ],
-                "usage": {
-                    "prompt_tokens": 0,
-                    "completion_tokens": 10,
-                    "total_tokens": 10
-                }
-            }
-            success = False
-            
-        else:  # 处理中
-            # 任务仍在处理中
-            message = result.get("message", "```think\n正在生成图像，请稍候...\n```")
-            
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": result.get("timestamp", int(time.time())),
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": message
-                        },
-                        "finish_reason": "processing"
-                    }
-                ],
-                "usage": {
-                    "prompt_tokens": 0,
-                    "completion_tokens": 10,
-                    "total_tokens": 10
-                }
-            }
-            success = True
-            
-        # 记录请求结果
-        response_time = time.time() - start_time
-        key_manager.record_request_result(sora_auth_token, success, response_time)
-        
-        # 返回响应
-        return JSONResponse(content=response)
-        
-    except HTTPException:
-        # 直接重新抛出HTTP异常
-        raise
-    except Exception as e:
-        # 处理其他异常
-        success = False
-        logger.error(f"检查任务状态失败: {str(e)}", exc_info=True)
-        
-        # 记录请求结果
-        response_time = time.time() - start_time
-        key_manager.record_request_result(sora_auth_token, success, response_time)
-        
-        raise HTTPException(status_code=500, detail=f"检查任务状态失败: {str(e)}") 

sora-api-master/src/api/health.py

@@ -1,57 +0,0 @@
-import time
-import platform
-import os
-import sys
-import psutil
-from fastapi import APIRouter, Depends
-from ..key_manager import key_manager
-
-# 创建路由
-router = APIRouter()
-
-@router.get("/health")
-async def health_check():
-    """
-    API健康检查端点
-    
-    返回:
-        基本的健康状态信息
-    """
-    return {
-        "status": "ok",
-        "timestamp": time.time(),
-        "version": "2.0.0"
-    }
-
-@router.get("/health/extended")
-async def extended_health_check():
-    """
-    扩展的健康检查端点
-    
-    返回:
-        详细的系统和服务状态信息
-    """
-    # 获取系统信息
-    system_info = {
-        "platform": platform.platform(),
-        "python_version": sys.version,
-        "cpu_count": psutil.cpu_count(),
-        "memory_total": psutil.virtual_memory().total,
-        "memory_available": psutil.virtual_memory().available,
-        "disk_usage": psutil.disk_usage('/').percent
-    }
-    
-    # 获取服务信息
-    service_info = {
-        "uptime": time.time() - psutil.Process(os.getpid()).create_time(),
-        "active_keys": sum(1 for k in key_manager.keys if k.get("is_enabled", False)),
-        "total_keys": len(key_manager.keys),
-    }
-    
-    return {
-        "status": "ok",
-        "timestamp": time.time(),
-        "version": "2.0.0",
-        "system": system_info,
-        "service": service_info,
-    } 

sora-api-master/src/app.py

@@ -1,171 +0,0 @@
-import os
-import aiohttp
-import logging
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.exceptions import RequestValidationError
-
-from .config import Config
-from .key_manager import key_manager
-from .api import main_router
-from .api.dependencies import session_pool
-
-# 配置日志
-logging.basicConfig(
-    level=getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper()),
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S"
-)
-
-logger = logging.getLogger("sora-api")
-
-# 创建FastAPI应用
-app = FastAPI(
-    title="OpenAI Compatible Sora API",
-    description="为Sora提供OpenAI兼容接口的API服务",
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-)
-
-# 配置CORS中间件
-origins = [
-    "http://localhost",
-    "http://localhost:8890",
-    f"http://{Config.HOST}:{Config.PORT}",
-    Config.BASE_URL,
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE"],
-    allow_headers=["Authorization", "Content-Type"],
-)
-
-# 异常处理
-@app.exception_handler(RequestValidationError)
-async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    """处理请求验证错误"""
-    return JSONResponse(
-        status_code=422,
-        content={"detail": f"请求验证错误: {str(exc)}"}
-    )
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """全局异常处理器"""
-    # 记录错误
-    logger.error(f"全局异常: {str(exc)}", exc_info=True)
-    
-    # 如果是已知的HTTPException，保持原始状态码和详情
-    if isinstance(exc, HTTPException):
-        return JSONResponse(
-            status_code=exc.status_code,
-            content={"detail": exc.detail}
-        )
-    
-    # 其他异常返回500状态码
-    return JSONResponse(
-        status_code=500,
-        content={"detail": f"服务器内部错误: {str(exc)}"}
-    )
-
-# 应用启动和关闭事件
-@app.on_event("startup")
-async def startup_event():
-    """应用启动时执行的操作"""
-    global session_pool
-    # 创建共享会话池
-    session_pool = aiohttp.ClientSession()
-    logger.info("应用已启动，创建了全局会话池")
-    
-    # 初始化时保存管理员密钥
-    Config.save_admin_key()
-    
-    # 确保静态文件目录存在
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
-    os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-    
-    # 输出图片保存目录的信息 
-    logger.info(f"图片保存目录: {Config.IMAGE_SAVE_DIR}")
-    
-    # 图片访问URL
-    base_url = Config.BASE_URL.rstrip('/')
-    if Config.STATIC_PATH_PREFIX:
-        logger.info(f"图片将通过 {base_url}{Config.STATIC_PATH_PREFIX}/images/<filename> 访问")
-    else:
-        logger.info(f"图片将通过 {base_url}/images/<filename> 访问")
-    
-    # 打印配置信息
-    Config.print_config()
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """应用关闭时执行的操作"""
-    # 关闭会话池
-    if session_pool:
-        await session_pool.close()
-    logger.info("应用已关闭，清理了全局会话池")
-
-# 添加根路径路由
-@app.get("/")
-async def root():
-    """根路径，返回系统状态信息"""
-    return {
-        "status": "OK",
-        "message": "系统运行正常",
-        "version": app.version,
-        "name": app.title
-    }
-
-# 挂载静态文件目录
-app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
-
-# 通用图片访问路由 - 支持多种路径格式
-@app.get("/images/{filename}")
-@app.get("/static/images/{filename}")
-async def get_image(filename: str):
-    """处理图片请求 - 无论保存在哪里"""
-    # 直接从IMAGE_SAVE_DIR获取图片
-    file_path = os.path.join(Config.IMAGE_SAVE_DIR, filename)
-    if os.path.exists(file_path):
-        return FileResponse(file_path)
-    else:
-        logger.warning(f"请求的图片不存在: {file_path}")
-        raise HTTPException(status_code=404, detail="图片不存在")
-
-# 添加静态文件路径前缀的兼容路由
-if Config.STATIC_PATH_PREFIX:
-    prefix_path = Config.STATIC_PATH_PREFIX.lstrip("/")
-    
-    @app.get(f"/{prefix_path}/images/{{filename}}")
-    async def get_prefixed_image(filename: str):
-        """处理带前缀的图片请求"""
-        return await get_image(filename)
-
-# 管理界面路由
-@app.get("/admin")
-async def admin_panel():
-    """返回管理面板HTML页面"""
-    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
-
-# 现在使用JWT��证，不再需要直接暴露管理员密钥
-
-# 注册所有API路由
-app.include_router(main_router)
-
-# 应用入口点（供uvicorn直接调用）
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "app:app",
-        host=Config.HOST,
-        port=Config.PORT,
-        reload=Config.VERBOSE_LOGGING
-    ) 

sora-api-master/src/app.py.backup

@@ -1,1159 +0,0 @@
-import asyncio
-import json
-import time
-import uuid
-import base64
-import os
-import tempfile
-import threading
-import dotenv
-import logging
-from typing import List, Dict, Any, Optional, Union
-from fastapi import FastAPI, HTTPException, Depends, Request, BackgroundTasks, File, UploadFile, Form
-from fastapi.responses import StreamingResponse, JSONResponse, FileResponse, HTMLResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel, Field
-import uvicorn
-import re
-
-from .key_manager import KeyManager
-from .sora_integration import SoraClient
-from .config import Config
-from .utils import localize_image_urls  # 导入新增的图片本地化功能
-
-# 日志系统配置
-class LogConfig:
-    LEVEL = os.getenv("LOG_LEVEL", "WARNING").upper()
-    FORMAT = "%(asctime)s [%(levelname)s] %(message)s"
-
-# 初始化日志
-logging.basicConfig(
-    level=getattr(logging, LogConfig.LEVEL),
-    format=LogConfig.FORMAT,
-    datefmt="%Y-%m-%d %H:%M:%S"
-)
-logger = logging.getLogger("sora-api")
-
-# 打印日志级别信息
-logger.info(f"日志级别设置为: {LogConfig.LEVEL}")
-logger.info(f"要调整日志级别，请设置环境变量 LOG_LEVEL=DEBUG|INFO|WARNING|ERROR")
-
-# 创建FastAPI应用
-app = FastAPI(title="OpenAI Compatible Sora API")
-
-# 添加CORS支持
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# 确保静态文件目录存在
-os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
-os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
-os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
-os.makedirs(os.path.join(Config.STATIC_DIR, "images"), exist_ok=True)  # 确保图片目录存在
-
-# 打印配置信息
-Config.print_config()
-
-# 挂载静态文件目录
-app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
-
-# 初始化Key管理器
-key_manager = KeyManager(storage_file=Config.KEYS_STORAGE_FILE)
-
-# 初始化时保存管理员密钥
-Config.save_admin_key()
-
-# 创建Sora客户端池
-sora_clients = {}
-
-# 存储生成结果的全局字典
-generation_results = {}
-
-# 请求模型
-class ContentItem(BaseModel):
-    type: str
-    text: Optional[str] = None
-    image_url: Optional[Dict[str, str]] = None
-
-class ChatMessage(BaseModel):
-    role: str
-    content: Union[str, List[ContentItem]]
-
-class ChatCompletionRequest(BaseModel):
-    model: str
-    messages: List[ChatMessage]
-    temperature: Optional[float] = 1.0
-    top_p: Optional[float] = 1.0
-    n: Optional[int] = 1
-    stream: Optional[bool] = False
-    max_tokens: Optional[int] = None
-    presence_penalty: Optional[float] = 0
-    frequency_penalty: Optional[float] = 0
-
-# API密钥管理模型
-class ApiKeyCreate(BaseModel):
-    name: str = Field(..., description="密钥名称")
-    key_value: str = Field(..., description="Bearer Token值")
-    weight: int = Field(default=1, ge=1, le=10, description="权重值")
-    rate_limit: int = Field(default=60, description="每分钟最大请求数")
-    is_enabled: bool = Field(default=True, description="是否启用")
-    notes: Optional[str] = Field(default=None, description="备注信息")
-
-class ApiKeyUpdate(BaseModel):
-    name: Optional[str] = None
-    key_value: Optional[str] = None
-    weight: Optional[int] = None
-    rate_limit: Optional[int] = None
-    is_enabled: Optional[bool] = None
-    notes: Optional[str] = None
-    
-# 获取Sora客户端
-def get_sora_client(auth_token: str) -> SoraClient:
-    if auth_token not in sora_clients:
-        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
-        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
-        
-        sora_clients[auth_token] = SoraClient(
-            proxy_host=proxy_host, 
-            proxy_port=proxy_port,
-            auth_token=auth_token
-        )
-    return sora_clients[auth_token]
-
-# 验证API key
-async def verify_api_key(request: Request):
-    auth_header = request.headers.get("Authorization")
-    if not auth_header or not auth_header.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="缺少或无效的API key")
-    
-    api_key = auth_header.replace("Bearer ", "")
-    # 在实际应用中，这里应该验证key的有效性
-    # 这里简化处理，假设所有key都有效
-    return api_key
-
-# 验证管理员权限
-async def verify_admin(request: Request):
-    auth_header = request.headers.get("Authorization")
-    if not auth_header or not auth_header.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="未授权")
-    
-    admin_key = auth_header.replace("Bearer ", "")
-    # 这里应该检查是否为管理员密钥
-    # 简化处理，假设admin_key是预设的管理员密钥
-    if admin_key != Config.ADMIN_KEY:
-        raise HTTPException(status_code=403, detail="没有管理员权限")
-    return admin_key
-
-# 将处理中状态消息格式化为think代码块
-def format_think_block(message):
-    """将消息放入```think代码块中"""
-    return f"```think\n{message}\n```"
-
-# 后台任务处理函数 - 文本生成图像
-async def process_image_generation(
-    request_id: str,
-    sora_client: SoraClient,
-    prompt: str,
-    num_images: int = 1,
-    width: int = 720,
-    height: int = 480
-):
-    try:
-        # 更新状态为生成中
-        generation_results[request_id] = {
-            "status": "processing",
-            "message": format_think_block("正在生成图像中，请耐心等待..."),
-            "timestamp": int(time.time())
-        }
-        
-        # 生成图像
-        logger.info(f"[{request_id}] 开始生成图像, 提示词: {prompt}")
-        image_urls = await sora_client.generate_image(
-            prompt=prompt,
-            num_images=num_images,
-            width=width,
-            height=height
-        )
-        
-        # 验证生成结果
-        if isinstance(image_urls, str):
-            logger.warning(f"[{request_id}] 图像生成失败或返回了错误信息: {image_urls}")
-            generation_results[request_id] = {
-                "status": "failed",
-                "error": image_urls,
-                "message": format_think_block(f"图像生成失败: {image_urls}"),
-                "timestamp": int(time.time())
-            }
-            return
-            
-        if not image_urls:
-            logger.warning(f"[{request_id}] 图像生成返回了空列表")
-            generation_results[request_id] = {
-                "status": "failed",
-                "error": "图像生成返回了空结果",
-                "message": format_think_block("图像生成失败: 服务器返回了空结果"),
-                "timestamp": int(time.time())
-            }
-            return
-            
-        logger.info(f"[{request_id}] 成功生成 {len(image_urls)} 张图片")
-        if logger.isEnabledFor(logging.DEBUG):
-            for i, url in enumerate(image_urls):
-                logger.debug(f"[{request_id}] 图片 {i+1}: {url}")
-        
-        # 本地化图片URL
-        if Config.IMAGE_LOCALIZATION:
-            logger.info(f"[{request_id}] 准备进行图片本地化处理")
-            logger.debug(f"[{request_id}] 图片本地化配置: 启用={Config.IMAGE_LOCALIZATION}, 保存目录={Config.IMAGE_SAVE_DIR}")
-            try:
-                localized_urls = await localize_image_urls(image_urls)
-                logger.info(f"[{request_id}] 图片本地化处理完成")
-                
-                # 检查本地化结果
-                if not localized_urls:
-                    logger.warning(f"[{request_id}] 本地化处理返回了空列表，将使用原始URL")
-                    localized_urls = image_urls
-                
-                # 检查是否所有URL都被正确本地化
-                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
-                logger.info(f"[{request_id}] 本地化结果: 总计 {len(localized_urls)} 张图片，成功本地化 {local_count} 张")
-                
-                if local_count == 0:
-                    logger.warning(f"[{request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
-                    localized_urls = image_urls
-                
-                # 打印结果对比
-                if logger.isEnabledFor(logging.DEBUG):
-                    for i, (orig, local) in enumerate(zip(image_urls, localized_urls)):
-                        logger.debug(f"[{request_id}] 图片 {i+1} 本地化结果: {orig} -> {local}")
-                
-                image_urls = localized_urls
-            except Exception as e:
-                logger.error(f"[{request_id}] 图片本地化过程中发生错误: {str(e)}")
-                if logger.isEnabledFor(logging.DEBUG):
-                    import traceback
-                    logger.debug(traceback.format_exc())
-                logger.info(f"[{request_id}] 由于错误，将使用原始URL")
-        else:
-            logger.info(f"[{request_id}] 图片本地化功能未启用，使用原始URL")
-        
-        # 存储结果
-        generation_results[request_id] = {
-            "status": "completed",
-            "image_urls": image_urls,
-            "timestamp": int(time.time())
-        }
-        
-        # 30分钟后自动清理结果
-        threading.Timer(1800, lambda: generation_results.pop(request_id, None)).start()
-        
-    except Exception as e:
-        error_message = f"图像生成失败: {str(e)}"
-        generation_results[request_id] = {
-            "status": "failed",
-            "error": error_message,
-            "message": format_think_block(error_message),
-            "timestamp": int(time.time())
-        }
-        logger.error(f"图像生成失败 (ID: {request_id}): {str(e)}")
-        if logger.isEnabledFor(logging.DEBUG):
-            import traceback
-            logger.debug(traceback.format_exc())
-
-# 后台任务处理函数 - 带图片的remix
-async def process_image_remix(
-    request_id: str,
-    sora_client: SoraClient,
-    prompt: str,
-    image_data: str,
-    num_images: int = 1
-):
-    try:
-        # 更新状态为处理中
-        generation_results[request_id] = {
-            "status": "processing",
-            "message": format_think_block("正在处理上传的图片..."),
-            "timestamp": int(time.time())
-        }
-        
-        # 保存base64图片到临时文件
-        temp_dir = tempfile.mkdtemp()
-        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
-        
-        try:
-            # 解码并保存图片
-            with open(temp_image_path, "wb") as f:
-                f.write(base64.b64decode(image_data))
-            
-            # 更新状态为上传中
-            generation_results[request_id] = {
-                "status": "processing",
-                "message": format_think_block("正在上传图片到Sora服务..."),
-                "timestamp": int(time.time())
-            }
-            
-            # 上传图片
-            upload_result = await sora_client.upload_image(temp_image_path)
-            media_id = upload_result['id']
-            
-            # 更新状态为生成中
-            generation_results[request_id] = {
-                "status": "processing",
-                "message": format_think_block("正在基于图片生成新图像..."),
-                "timestamp": int(time.time())
-            }
-            
-            # 执行remix生成
-            logger.info(f"[{request_id}] 开始生成Remix图像, 提示词: {prompt}")
-            image_urls = await sora_client.generate_image_remix(
-                prompt=prompt,
-                media_id=media_id,
-                num_images=num_images
-            )
-            
-            # 本地化图片URL
-            if Config.IMAGE_LOCALIZATION:
-                logger.info(f"[{request_id}] 准备进行图片本地化处理")
-                localized_urls = await localize_image_urls(image_urls)
-                image_urls = localized_urls
-                logger.info(f"[{request_id}] Remix图片本地化处理完成")
-            
-            # 存储结果
-            generation_results[request_id] = {
-                "status": "completed",
-                "image_urls": image_urls,
-                "timestamp": int(time.time())
-            }
-            
-            # 30分钟后自动清理结果
-            threading.Timer(1800, lambda: generation_results.pop(request_id, None)).start()
-            
-        finally:
-            # 清理临时文件
-            if os.path.exists(temp_image_path):
-                os.remove(temp_image_path)
-            if os.path.exists(temp_dir):
-                os.rmdir(temp_dir)
-                
-    except Exception as e:
-        error_message = f"图像Remix失败: {str(e)}"
-        generation_results[request_id] = {
-            "status": "failed",
-            "error": error_message,
-            "message": format_think_block(error_message),
-            "timestamp": int(time.time())
-        }
-        logger.error(f"图像Remix失败 (ID: {request_id}): {str(e)}")
-
-# 添加一个新端点用于检查生成状态
-@app.get("/v1/generation/{request_id}")
-async def check_generation_status(request_id: str, api_key: str = Depends(verify_api_key)):
-    """
-    检查图像生成任务的状态
-    """
-    # 获取一个可用的key并记录开始时间
-    sora_auth_token = key_manager.get_key()
-    if not sora_auth_token:
-        raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
-        
-    start_time = time.time()
-    success = False
-    
-    try:
-        if request_id not in generation_results:
-            raise HTTPException(status_code=404, detail=f"找不到生成任务: {request_id}")
-        
-        result = generation_results[request_id]
-        
-        if result["status"] == "completed":
-            image_urls = result["image_urls"]
-            
-            # 构建OpenAI兼容的响应
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": result["timestamp"],
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": i,
-                        "message": {
-                            "role": "assistant",
-                            "content": f"![Generated Image]({url})"
-                        },
-                        "finish_reason": "stop"
-                    }
-                    for i, url in enumerate(image_urls)
-                ],
-                "usage": {
-                    "prompt_tokens": 0,  # 简化的令牌计算
-                    "completion_tokens": 20,
-                    "total_tokens": 20
-                }
-            }
-            success = True
-            return JSONResponse(content=response)
-        
-        elif result["status"] == "failed":
-            if "message" in result:
-                # 返回带有格式化错误消息的响应
-                response = {
-                    "id": request_id,
-                    "object": "chat.completion",
-                    "created": result["timestamp"],
-                    "model": "sora-1.0",
-                    "choices": [
-                        {
-                            "index": 0,
-                            "message": {
-                                "role": "assistant",
-                                "content": result["message"]
-                            },
-                            "finish_reason": "error"
-                        }
-                    ],
-                    "usage": {
-                        "prompt_tokens": 0,
-                        "completion_tokens": 10,
-                        "total_tokens": 10
-                    }
-                }
-                success = False
-                return JSONResponse(content=response)
-            else:
-                # 向后兼容，使用老的方式
-                raise HTTPException(status_code=500, detail=f"生成失败: {result['error']}")
-        
-        else:  # 处理中
-            message = result.get("message", "```think\n正在生成图像，请稍候...\n```")
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": result["timestamp"],
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": message
-                        },
-                        "finish_reason": "processing"
-                    }
-                ],
-                "usage": {
-                    "prompt_tokens": 0,
-                    "completion_tokens": 10,
-                    "total_tokens": 10
-                }
-            }
-            success = True
-            return JSONResponse(content=response)
-    except Exception as e:
-        success = False
-        raise HTTPException(status_code=500, detail=f"检查任务状态失败: {str(e)}")
-    finally:
-        # 记录请求结果
-        response_time = time.time() - start_time
-        key_manager.record_request_result(sora_auth_token, success, response_time)
-
-# 聊天完成端点
-@app.post("/v1/chat/completions")
-async def chat_completions(
-    request: ChatCompletionRequest,
-    api_key: str = Depends(verify_api_key),
-    background_tasks: BackgroundTasks = None
-):
-    # 获取一个可用的key
-    sora_auth_token = key_manager.get_key()
-    if not sora_auth_token:
-        raise HTTPException(status_code=429, detail="所有API key都已达到速率限制")
-    
-    # 获取Sora客户端
-    sora_client = get_sora_client(sora_auth_token)
-    
-    # 分析最后一条用户消息以提取内容
-    user_messages = [m for m in request.messages if m.role == "user"]
-    if not user_messages:
-        raise HTTPException(status_code=400, detail="至少需要一条用户消息")
-    
-    last_user_message = user_messages[-1]
-    prompt = ""
-    image_data = None
-    
-    # 提取提示词和图片数据
-    if isinstance(last_user_message.content, str):
-        # 简单的字符串内容
-        prompt = last_user_message.content
-        
-        # 检查是否包含内嵌的base64图片
-        pattern = r'data:image\/[^;]+;base64,([^"]+)'
-        match = re.search(pattern, prompt)
-        if match:
-            image_data = match.group(1)
-            # 从提示词中删除base64数据，以保持提示词的可读性
-            prompt = re.sub(pattern, "[已上传图片]", prompt)
-    else:
-        # 多模态内容，提取文本和图片
-        content_items = last_user_message.content
-        text_parts = []
-        
-        for item in content_items:
-            if item.type == "text" and item.text:
-                text_parts.append(item.text)
-            elif item.type == "image_url" and item.image_url:
-                # 如果有图片URL包含base64数据
-                url = item.image_url.get("url", "")
-                if url.startswith("data:image/"):
-                    pattern = r'data:image\/[^;]+;base64,([^"]+)'
-                    match = re.search(pattern, url)
-                    if match:
-                        image_data = match.group(1)
-                        text_parts.append("[已上传图片]")
-        
-        prompt = " ".join(text_parts)
-    
-    # 记录开始时间
-    start_time = time.time()
-    success = False
-    
-    # 处理图片生成
-    try:
-        # 检查是否为流式响应
-        if request.stream:
-            # 流式响应特殊处理文本+图片的情况
-            if image_data:
-                response = StreamingResponse(
-                    generate_streaming_remix_response(sora_client, prompt, image_data, request.n),
-                    media_type="text/event-stream"
-                )
-            else:
-                response = StreamingResponse(
-                    generate_streaming_response(sora_client, prompt, request.n),
-                    media_type="text/event-stream"
-                )
-            success = True
-            
-            # 记录请求结果（流式响应立即记录）
-            response_time = time.time() - start_time
-            key_manager.record_request_result(sora_auth_token, success, response_time)
-            
-            return response
-        else:
-            # 对于非流式响应，返回一个即时响应，表示任务已接收
-            # 创建一个唯一ID
-            request_id = f"chatcmpl-{uuid.uuid4().hex}"
-            
-            # 在结果字典中创建初始状态
-            processing_message = "正在准备生成任务，请稍候..."
-            generation_results[request_id] = {
-                "status": "processing",
-                "message": format_think_block(processing_message),
-                "timestamp": int(time.time())
-            }
-            
-            # 添加后台任务
-            if image_data:
-                background_tasks.add_task(
-                    process_image_remix,
-                    request_id,
-                    sora_client,
-                    prompt,
-                    image_data,
-                    request.n
-                )
-            else:
-                background_tasks.add_task(
-                    process_image_generation,
-                    request_id,
-                    sora_client,
-                    prompt,
-                    request.n,
-                    720,  # width
-                    480   # height
-                )
-                
-            # 立即返回一个"正在处理中"的响应
-            response = {
-                "id": request_id,
-                "object": "chat.completion",
-                "created": int(time.time()),
-                "model": "sora-1.0",
-                "choices": [
-                    {
-                        "index": 0,
-                        "message": {
-                            "role": "assistant",
-                            "content": format_think_block(processing_message)
-                        },
-                        "finish_reason": "processing"
-                    }
-                ],
-                "usage": {
-                    "prompt_tokens": len(prompt) // 4,
-                    "completion_tokens": 10,
-                    "total_tokens": len(prompt) // 4 + 10
-                }
-            }
-            
-            success = True
-            
-            # 记录请求结果（非流式响应立即记录）
-            response_time = time.time() - start_time
-            key_manager.record_request_result(sora_auth_token, success, response_time)
-            
-            return JSONResponse(content=response)            
-    except Exception as e:
-        success = False
-        
-        # 记录请求结果（异常情况也记录）
-        response_time = time.time() - start_time
-        key_manager.record_request_result(sora_auth_token, success, response_time)
-        
-        raise HTTPException(status_code=500, detail=f"图像生成失败: {str(e)}")
-
-# 流式响应生成器 - 普通文本到图像
-async def generate_streaming_response(
-    sora_client: SoraClient,
-    prompt: str,
-    n_images: int = 1
-):
-    request_id = f"chatcmpl-{uuid.uuid4().hex}"
-    
-    # 发送开始事件
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
-    
-    # 发送处理中的消息（放在代码块中）
-    start_msg = "```think\n正在生成图像，请稍候...\n"
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': start_msg}, 'finish_reason': None}]})}\n\n"
-    
-    # 创建一个后台任务来生成图像
-    logger.info(f"[流式响应 {request_id}] 开始生成图像, 提示词: {prompt}")
-    generation_task = asyncio.create_task(sora_client.generate_image(
-        prompt=prompt,
-        num_images=n_images,
-        width=720,
-        height=480
-    ))
-    
-    # 每5秒发送一条"仍在生成中"的消息，防止连接超时
-    progress_messages = [
-        "正在处理您的请求...",
-        "仍在生成图像中，请继续等待...",
-        "Sora正在创作您的图像作品...",
-        "图像生成需要一点时间，感谢您的耐心等待...",
-        "我们正在努力为您创作高质量图像..."
-    ]
-    
-    i = 0
-    while not generation_task.done():
-        # 每5秒发送一次进度消息
-        await asyncio.sleep(5)
-        progress_msg = progress_messages[i % len(progress_messages)]
-        i += 1
-        content = "\n" + progress_msg + "\n"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
-    
-    try:
-        # 获取生成结果
-        image_urls = await generation_task
-        logger.info(f"[流式响应 {request_id}] 图像生成完成，获取到 {len(image_urls) if isinstance(image_urls, list) else '非列表'} 个URL")
-        
-        # 本地化图片URL
-        if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
-            logger.info(f"[流式响应 {request_id}] 准备进行图片本地化处理")
-            try:
-                localized_urls = await localize_image_urls(image_urls)
-                logger.info(f"[流式响应 {request_id}] 图片本地化处理完成")
-                
-                # 检查本地化结果
-                if not localized_urls:
-                    logger.warning(f"[流式响应 {request_id}] 本地化处理返回了空列表，将使用原始URL")
-                    localized_urls = image_urls
-                
-                # 检查是否所有URL都被正确本地化
-                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
-                if local_count == 0:
-                    logger.warning(f"[流式响应 {request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
-                    localized_urls = image_urls
-                else:
-                    logger.info(f"[流式响应 {request_id}] 成功本地化 {local_count}/{len(localized_urls)} 张图片")
-                
-                # 打印本地化对比结果
-                if logger.isEnabledFor(logging.DEBUG):
-                    for i, (orig, local) in enumerate(zip(image_urls, localized_urls)):
-                        logger.debug(f"[流式响应 {request_id}] 图片 {i+1}: {orig} -> {local}")
-                
-                image_urls = localized_urls
-            except Exception as e:
-                logger.error(f"[流式响应 {request_id}] 图片本地化过程中发生错误: {str(e)}")
-                if logger.isEnabledFor(logging.DEBUG):
-                    import traceback
-                    logger.debug(traceback.format_exc())
-                logger.info(f"[流式响应 {request_id}] 由于错误，将使用原始URL")
-        elif not Config.IMAGE_LOCALIZATION:
-            logger.info(f"[流式响应 {request_id}] 图片本地化功能未启用")
-        elif not isinstance(image_urls, list) or not image_urls:
-            logger.warning(f"[流式响应 {request_id}] 无法进行本地化: 图像结果不是有效的URL列表")
-        
-        # 结束代码块
-        content_str = "\n```\n\n"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-        
-        # 添加生成的图片URLs
-        for i, url in enumerate(image_urls):
-            if i > 0:
-                content_str = "\n\n"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-            
-            image_markdown = f"![Generated Image]({url})"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
-        
-        # 发送完成事件
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
-        
-        # 发送结束标志
-        yield "data: [DONE]\n\n"
-    except Exception as e:
-        error_msg = f"图像生成失败: {str(e)}"
-        logger.error(f"[流式响应 {request_id}] 错误: {error_msg}")
-        if logger.isEnabledFor(logging.DEBUG):
-            import traceback
-            logger.debug(traceback.format_exc())
-        error_content = f"\n{error_msg}\n```"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
-        yield "data: [DONE]\n\n"
-
-# 流式响应生成器 - 带图片的remix
-async def generate_streaming_remix_response(
-    sora_client: SoraClient,
-    prompt: str,
-    image_data: str,
-    n_images: int = 1
-):
-    request_id = f"chatcmpl-{uuid.uuid4().hex}"
-    
-    # 发送开始事件
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
-    
-    try:
-        # 保存base64图片到临时文件
-        temp_dir = tempfile.mkdtemp()
-        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
-        
-        try:
-            # 解码并保存图片
-            with open(temp_image_path, "wb") as f:
-                f.write(base64.b64decode(image_data))
-            
-            # 上传图片
-            upload_msg = "```think\n上传图片中...\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': upload_msg}, 'finish_reason': None}]})}\n\n"
-            
-            logger.info(f"[流式响应Remix {request_id}] 上传图片中")
-            upload_result = await sora_client.upload_image(temp_image_path)
-            media_id = upload_result['id']
-            
-            # 发送生成中消息
-            generate_msg = "\n基于图片生成新图像中...\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': generate_msg}, 'finish_reason': None}]})}\n\n"
-            
-            # 创建一个后台任务来生成图像
-            logger.info(f"[流式响应Remix {request_id}] 开始生成图像，提示词: {prompt}")
-            generation_task = asyncio.create_task(sora_client.generate_image_remix(
-                prompt=prompt,
-                media_id=media_id,
-                num_images=n_images
-            ))
-            
-            # 每5秒发送一条"仍在生成中"的消息，防止连接超时
-            progress_messages = [
-                "正在处理您的请求...",
-                "仍在生成图像中，请继续等待...",
-                "Sora正在基于您的图片创作新作品...",
-                "图像生成需要一点时间，感谢您的耐心等待...",
-                "正在努力融合您的风格和提示词，打造专属图像..."
-            ]
-            
-            i = 0
-            while not generation_task.done():
-                # 每5秒发送一次进度消息
-                await asyncio.sleep(5)
-                progress_msg = progress_messages[i % len(progress_messages)]
-                i += 1
-                content = "\n" + progress_msg + "\n"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
-            
-            # 获取生成结果
-            image_urls = await generation_task
-            logger.info(f"[流式响应Remix {request_id}] 图像生成完成")
-            
-            # 本地化图片URL
-            if Config.IMAGE_LOCALIZATION:
-                logger.info(f"[流式响应Remix {request_id}] 进行图片本地化处理")
-                localized_urls = await localize_image_urls(image_urls)
-                image_urls = localized_urls
-                logger.info(f"[流式响应Remix {request_id}] 图片本地化处理完成")
-            else:
-                logger.info(f"[流式响应Remix {request_id}] 图片本地化功能未启用")
-            
-            # 结束代码块
-            content_str = "\n```\n\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-            
-            # 发送图片URL作为Markdown
-            for i, url in enumerate(image_urls):
-                if i > 0:
-                    newline_str = "\n\n"
-                    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': newline_str}, 'finish_reason': None}]})}\n\n"
-                
-                image_markdown = f"![Generated Image]({url})"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
-            
-            # 发送完成事件
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
-            
-            # 发送结束标志
-            yield "data: [DONE]\n\n"
-            
-        finally:
-            # 清理临时文件
-            if os.path.exists(temp_image_path):
-                os.remove(temp_image_path)
-            if os.path.exists(temp_dir):
-                os.rmdir(temp_dir)
-                
-    except Exception as e:
-        error_msg = f"图像Remix失败: {str(e)}"
-        logger.error(f"[流式响应Remix {request_id}] 错误: {error_msg}")
-        if logger.isEnabledFor(logging.DEBUG):
-            import traceback
-            logger.debug(traceback.format_exc())
-        error_content = f"\n{error_msg}\n```"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
-    
-    # 结束流
-    yield "data: [DONE]\n\n"
-
-# API密钥管理端点
-@app.get("/api/keys")
-async def get_all_keys(admin_key: str = Depends(verify_admin)):
-    """获取所有API密钥"""
-    return key_manager.get_all_keys()
-
-@app.get("/api/keys/{key_id}")
-async def get_key(key_id: str, admin_key: str = Depends(verify_admin)):
-    """获取单个API密钥详情"""
-    key = key_manager.get_key_by_id(key_id)
-    if not key:
-        raise HTTPException(status_code=404, detail="密钥不存在")
-    return key
-
-@app.post("/api/keys")
-async def create_key(key_data: ApiKeyCreate, admin_key: str = Depends(verify_admin)):
-    """创建新API密钥"""
-    try:
-        # 确保密钥值包含 Bearer 前缀
-        key_value = key_data.key_value
-        if not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-            
-        new_key = key_manager.add_key(
-            key_value,
-            name=key_data.name,
-            weight=key_data.weight,
-            rate_limit=key_data.rate_limit,
-            is_enabled=key_data.is_enabled,
-            notes=key_data.notes
-        )
-        
-        # 通过Config永久保存所有密钥
-        Config.save_api_keys(key_manager.keys)
-        
-        return new_key
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.put("/api/keys/{key_id}")
-async def update_key(key_id: str, key_data: ApiKeyUpdate, admin_key: str = Depends(verify_admin)):
-    """更新API密钥信息"""
-    try:
-        # 如果提供了新的密钥值，确保包含Bearer前缀
-        key_value = key_data.key_value
-        if key_value and not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-            key_data.key_value = key_value
-            
-        updated_key = key_manager.update_key(
-            key_id,
-            key_value=key_data.key_value,
-            name=key_data.name,
-            weight=key_data.weight,
-            rate_limit=key_data.rate_limit,
-            is_enabled=key_data.is_enabled,
-            notes=key_data.notes
-        )
-        if not updated_key:
-            raise HTTPException(status_code=404, detail="密钥不存在")
-        
-        # 通过Config永久保存所有密钥
-        Config.save_api_keys(key_manager.keys)
-        
-        return updated_key
-    except Exception as e:
-        raise HTTPException(status_code=400, detail=str(e))
-
-@app.delete("/api/keys/{key_id}")
-async def delete_key(key_id: str, admin_key: str = Depends(verify_admin)):
-    """删除API密钥"""
-    success = key_manager.delete_key(key_id)
-    if not success:
-        raise HTTPException(status_code=404, detail="密钥不存在")
-    
-    # 通过Config永久保存所有密钥
-    Config.save_api_keys(key_manager.keys)
-    
-    return {"status": "success", "message": "密钥已删除"}
-
-@app.get("/api/stats")
-async def get_usage_stats(admin_key: str = Depends(verify_admin)):
-    """获取API使用统计"""
-    return key_manager.get_usage_stats()
-
-@app.post("/api/keys/test")
-async def test_key(key_data: ApiKeyCreate, admin_key: str = Depends(verify_admin)):
-    """测试API密钥是否有效"""
-    try:
-        # 确保密钥值包含 Bearer 前缀
-        key_value = key_data.key_value
-        if not key_value.startswith("Bearer "):
-            key_value = f"Bearer {key_value}"
-        
-        # 获取代理配置
-        proxy_host = Config.PROXY_HOST if Config.PROXY_HOST and Config.PROXY_HOST.strip() else None
-        proxy_port = Config.PROXY_PORT if Config.PROXY_PORT and Config.PROXY_PORT.strip() else None
-        
-        # 创建临时客户端测试连接
-        test_client = SoraClient(
-            proxy_host=proxy_host,
-            proxy_port=proxy_port,
-            auth_token=key_value
-        )
-        # 执行简单API调用测试连接
-        test_result = await test_client.test_connection()
-        return {"status": "success", "message": "API密钥测试成功", "details": test_result}
-    except Exception as e:
-        return {"status": "error", "message": f"API密钥测试失败: {str(e)}"}
-
-@app.post("/api/keys/batch")
-async def batch_operation(operation: Dict[str, Any], admin_key: str = Depends(verify_admin)):
-    """批量操作API密钥"""
-    action = operation.get("action")
-    key_ids = operation.get("key_ids", [])
-    
-    if not action or not key_ids:
-        raise HTTPException(status_code=400, detail="无效的请求参数")
-    
-    # 确保key_ids是一个列表
-    if isinstance(key_ids, str):
-        key_ids = [key_ids]
-    
-    results = {}
-    
-    if action == "enable":
-        for key_id in key_ids:
-            success = key_manager.update_key(key_id, is_enabled=True)
-            results[key_id] = "success" if success else "failed"
-    elif action == "disable":
-        for key_id in key_ids:
-            success = key_manager.update_key(key_id, is_enabled=False)
-            results[key_id] = "success" if success else "failed"
-    elif action == "delete":
-        for key_id in key_ids:
-            success = key_manager.delete_key(key_id)
-            results[key_id] = "success" if success else "failed"
-    else:
-        raise HTTPException(status_code=400, detail="不支持的操作类型")
-    
-    # 通过Config永久保存所有密钥
-    Config.save_api_keys(key_manager.keys)
-    
-    return {"status": "success", "results": results}
-
-# 健康检查端点
-@app.get("/health")
-async def health_check():
-    return {"status": "ok", "timestamp": time.time()}
-
-# 管理界面路由
-@app.get("/admin")
-async def admin_panel():
-    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
-
-# 管理员密钥API
-@app.get("/admin/key")
-async def admin_key():
-    return {"admin_key": Config.ADMIN_KEY}
-
-# 挂载静态文件
-app.mount("/admin", StaticFiles(directory=os.path.join(Config.STATIC_DIR, "admin"), html=True), name="admin")
-
-# 配置管理模型
-class ConfigUpdate(BaseModel):
-    IMAGE_LOCALIZATION: Optional[bool] = None
-    IMAGE_SAVE_DIR: Optional[str] = None
-    LOG_LEVEL: Optional[str] = None
-
-# 配置管理页面
-@app.get("/admin/config")
-async def config_panel():
-    return FileResponse("src/static/admin/config.html")
-
-# 获取当前配置
-@app.get("/api/config")
-async def get_config(admin_key: str = Depends(verify_admin)):
-    """获取当前系统配置"""
-    return {
-        "IMAGE_LOCALIZATION": Config.IMAGE_LOCALIZATION,
-        "IMAGE_SAVE_DIR": Config.IMAGE_SAVE_DIR,
-        "LOG_LEVEL": LogConfig.LEVEL
-    }
-
-# 更新配置
-@app.post("/api/config")
-async def update_config(config_data: ConfigUpdate, admin_key: str = Depends(verify_admin)):
-    """更新系统配置"""
-    changes = {}
-    
-    if config_data.IMAGE_LOCALIZATION is not None:
-        old_value = Config.IMAGE_LOCALIZATION
-        Config.IMAGE_LOCALIZATION = config_data.IMAGE_LOCALIZATION
-        os.environ["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
-        changes["IMAGE_LOCALIZATION"] = {
-            "old": old_value,
-            "new": Config.IMAGE_LOCALIZATION
-        }
-    
-    if config_data.IMAGE_SAVE_DIR is not None:
-        old_value = Config.IMAGE_SAVE_DIR
-        Config.IMAGE_SAVE_DIR = config_data.IMAGE_SAVE_DIR
-        os.environ["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
-        
-        # 确保目录存在
-        os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-        
-        changes["IMAGE_SAVE_DIR"] = {
-            "old": old_value,
-            "new": Config.IMAGE_SAVE_DIR
-        }
-    
-    if config_data.LOG_LEVEL is not None:
-        old_value = LogConfig.LEVEL
-        level = config_data.LOG_LEVEL.upper()
-        # 验证日志级别是否有效
-        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-        if level not in valid_levels:
-            raise HTTPException(status_code=400, detail=f"无效的日志级别，有效值：{', '.join(valid_levels)}")
-            
-        # 更新日志级别
-        LogConfig.LEVEL = level
-        logging.getLogger("sora-api").setLevel(getattr(logging, level))
-        os.environ["LOG_LEVEL"] = level
-        
-        changes["LOG_LEVEL"] = {
-            "old": old_value,
-            "new": level
-        }
-        
-        logger.info(f"日志级别已更改为: {level}")
-    
-    # 保存到.env文件以持久化配置
-    try:
-        dotenv_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env")
-        
-        # 读取现有.env文件
-        env_vars = {}
-        if os.path.exists(dotenv_file):
-            with open(dotenv_file, "r") as f:
-                for line in f:
-                    if line.strip() and not line.startswith("#"):
-                        key, value = line.strip().split("=", 1)
-                        env_vars[key] = value
-        
-        # 更新值
-        if config_data.IMAGE_LOCALIZATION is not None:
-            env_vars["IMAGE_LOCALIZATION"] = str(config_data.IMAGE_LOCALIZATION)
-        if config_data.IMAGE_SAVE_DIR is not None:
-            env_vars["IMAGE_SAVE_DIR"] = config_data.IMAGE_SAVE_DIR
-        if config_data.LOG_LEVEL is not None:
-            env_vars["LOG_LEVEL"] = config_data.LOG_LEVEL.upper()
-        
-        # 写回文件
-        with open(dotenv_file, "w") as f:
-            for key, value in env_vars.items():
-                f.write(f"{key}={value}\n")
-    except Exception as e:
-        logger.error(f"保存配置到.env文件失败: {str(e)}")
-    
-    return {
-        "success": True,
-        "message": "配置已更新",
-        "changes": changes
-    }
-
-# 日志级别控制
-class LogLevelUpdate(BaseModel):
-    level: str = Field(..., description="日志级别")
-
-@app.post("/api/logs/level")
-async def update_log_level(data: LogLevelUpdate, admin_key: str = Depends(verify_admin)):
-    """更新系统日志级别"""
-    level = data.level.upper()
-    
-    # 验证日志级别是否有效
-    valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
-    if level not in valid_levels:
-        raise HTTPException(status_code=400, detail=f"无效的日志级别，有效值：{', '.join(valid_levels)}")
-        
-    # 更新日志级别
-    old_level = LogConfig.LEVEL
-    LogConfig.LEVEL = level
-    logging.getLogger("sora-api").setLevel(getattr(logging, level))
-    os.environ["LOG_LEVEL"] = level
-    
-    # 记录变更
-    logger.info(f"日志级别已更改为: {level}")
-    
-    # 更新.env文件
-    try:
-        dotenv_file = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), ".env")
-        
-        # 读取现有.env文件
-        env_vars = {}
-        if os.path.exists(dotenv_file):
-            with open(dotenv_file, "r") as f:
-                for line in f:
-                    if line.strip() and not line.startswith("#"):
-                        key, value = line.strip().split("=", 1)
-                        env_vars[key] = value
-                        
-        # 更新日志级别
-        env_vars["LOG_LEVEL"] = level
-        
-        # 写回文件
-        with open(dotenv_file, "w") as f:
-            for key, value in env_vars.items():
-                f.write(f"{key}={value}\n")
-    except Exception as e:
-        logger.warning(f"保存日志级别到.env文件失败: {str(e)}")
-    
-    return {
-        "success": True,
-        "message": f"日志级别已更改: {old_level} -> {level}"
-    } 

sora-api-master/src/app.py.optimized

@@ -1,129 +0,0 @@
-import os
-import aiohttp
-import logging
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.responses import JSONResponse, FileResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.exceptions import RequestValidationError
-
-from .config import Config
-from .key_manager import KeyManager
-from .api import main_router
-from .api.dependencies import session_pool
-
-# 配置日志
-logging.basicConfig(
-    level=getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper()),
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%Y-%m-%d %H:%M:%S"
-)
-
-logger = logging.getLogger("sora-api")
-
-# 全局键管理器
-key_manager = KeyManager(storage_file=Config.KEYS_STORAGE_FILE)
-
-# 创建FastAPI应用
-app = FastAPI(
-    title="OpenAI Compatible Sora API",
-    description="为Sora提供OpenAI兼容接口的API服务",
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-)
-
-# 配置CORS中间件
-origins = [
-    "http://localhost",
-    "http://localhost:8890",
-    f"http://{Config.HOST}:{Config.PORT}",
-    Config.BASE_URL,
-]
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=origins,
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE"],
-    allow_headers=["Authorization", "Content-Type"],
-)
-
-# 异常处理
-@app.exception_handler(RequestValidationError)
-async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    """处理请求验证错误"""
-    return JSONResponse(
-        status_code=422,
-        content={"detail": f"请求验证错误: {str(exc)}"}
-    )
-
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """全局异常处理器"""
-    # 记录错误
-    logger.error(f"全局异常: {str(exc)}", exc_info=True)
-    
-    # 如果是已知的HTTPException，保持原始状态码和详情
-    if isinstance(exc, HTTPException):
-        return JSONResponse(
-            status_code=exc.status_code,
-            content={"detail": exc.detail}
-        )
-    
-    # 其他异常返回500状态码
-    return JSONResponse(
-        status_code=500,
-        content={"detail": f"服务器内部错误: {str(exc)}"}
-    )
-
-# 应用启动和关闭事件
-@app.on_event("startup")
-async def startup_event():
-    """应用启动时执行的操作"""
-    global session_pool
-    # 创建共享会话池
-    session_pool = aiohttp.ClientSession()
-    logger.info("应用已启动，创建了全局会话池")
-    
-    # 初始化时保存管理员密钥
-    Config.save_admin_key()
-    
-    # 确保静态文件目录存在
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin"), exist_ok=True)
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/js"), exist_ok=True)
-    os.makedirs(os.path.join(Config.STATIC_DIR, "admin/css"), exist_ok=True)
-    os.makedirs(os.path.join(Config.STATIC_DIR, "images"), exist_ok=True)
-    
-    # 打印配置信息
-    Config.print_config()
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """应用关闭时执行的操作"""
-    # 关闭会话池
-    if session_pool:
-        await session_pool.close()
-    logger.info("应用已关闭，清理了全局会话池")
-
-# 挂载静态文件目录
-app.mount("/static", StaticFiles(directory=Config.STATIC_DIR), name="static")
-
-# 管理界面路由
-@app.get("/admin")
-async def admin_panel():
-    """返回管理面板HTML页面"""
-    return FileResponse(os.path.join(Config.STATIC_DIR, "admin/index.html"))
-
-# 注册所有API路由
-app.include_router(main_router)
-
-# 应用入口点（供uvicorn直接调用）
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "app:app",
-        host=Config.HOST,
-        port=Config.PORT,
-        reload=Config.VERBOSE_LOGGING
-    ) 

sora-api-master/src/config.py

@@ -1,179 +0,0 @@
-import os
-import json
-import uuid
-from typing import List, Dict
-import logging
-
-logger = logging.getLogger("sora-api.config")
-
-class Config:
-    # API服务配置
-    HOST = os.getenv("API_HOST", "0.0.0.0")
-    PORT = int(os.getenv("API_PORT", "8890"))
-    
-    # 基础URL配置
-    BASE_URL = os.getenv("BASE_URL", f"http://0.0.0.0:{PORT}")
-    
-    # 静态文件路径前缀，用于处理应用部署在子路径的情况
-    # 例如: /sora-api 表示应用部署在 /sora-api 下
-    STATIC_PATH_PREFIX = os.getenv("STATIC_PATH_PREFIX", "")
-    
-    # 代理配置
-    PROXY_HOST = os.getenv("PROXY_HOST", "")
-    PROXY_PORT = os.getenv("PROXY_PORT", "")
-    PROXY_USER = os.getenv("PROXY_USER", "")
-    PROXY_PASS = os.getenv("PROXY_PASS", "")
-    
-    # 目录配置
-    ROOT_DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
-    BASE_DIR = ROOT_DIR
-    STATIC_DIR = os.getenv("STATIC_DIR", os.path.join(BASE_DIR, "src/static"))
-    
-    # 图片保存目录 - 用户只需设置这一项
-    IMAGE_SAVE_DIR = os.getenv("IMAGE_SAVE_DIR", os.path.join(STATIC_DIR, "images"))
-    
-    # 图片本地化配置
-    IMAGE_LOCALIZATION = os.getenv("IMAGE_LOCALIZATION", "False").lower() in ("true", "1", "yes")
-    
-    # 当外部访问地址与服务器地址不同时，可通过BASE_URL覆盖图片访问地址
-    # 例如：当服务器在内网，但通过反向代理从外网访问时
-    
-    # API Keys配置
-    API_KEYS = []
-    
-    # 管理员配置
-    ADMIN_KEY = os.getenv("ADMIN_KEY", "sk-123456")
-    KEYS_STORAGE_FILE = os.getenv("KEYS_STORAGE_FILE", "api_keys.json")
-    
-    # API认证令牌
-    API_AUTH_TOKEN = os.getenv("API_AUTH_TOKEN", "")
-    
-    # 日志配置
-    VERBOSE_LOGGING = os.getenv("VERBOSE_LOGGING", "False").lower() in ("true", "1", "yes")
-    
-    @classmethod
-    def print_config(cls):
-        """打印当前配置信息"""
-        print("\n==== Sora API 配置信息 ====")
-        print(f"基础目录: {cls.BASE_DIR}")
-        print(f"API服务地址: {cls.HOST}:{cls.PORT}")
-        print(f"基础URL: {cls.BASE_URL}")
-        
-        # API认证信息
-        if cls.API_AUTH_TOKEN:
-            print(f"API认证令牌: 已设置 (长度: {len(cls.API_AUTH_TOKEN)})")
-        else:
-            print(f"API认证令牌: 未设置 (将使用管理面板的key)")
-        
-        # 详细日志
-        if cls.VERBOSE_LOGGING:
-            print(f"静态文件目录: {cls.STATIC_DIR}")
-            print(f"图片保存目录: {cls.IMAGE_SAVE_DIR}")
-            print(f"图片本地化: {'启用' if cls.IMAGE_LOCALIZATION else '禁用'}")
-            
-            # 代理配置信息
-            if cls.PROXY_HOST:
-                proxy_info = f"{cls.PROXY_HOST}:{cls.PROXY_PORT}"
-                if cls.PROXY_USER:
-                    proxy_info = f"{cls.PROXY_USER}:****@{proxy_info}"
-                print(f"代理配置: {proxy_info}")
-            else:
-                print(f"代理配置: (未配置)")
-        
-        # 确保必要目录存在
-        cls._ensure_directories()
-        
-    @classmethod
-    def _ensure_directories(cls):
-        """确保必要的目录存在"""
-        # 检查静态文件目录
-        if not os.path.exists(cls.STATIC_DIR):
-            print(f"⚠️ 警告: 静态文件目录不存在: {cls.STATIC_DIR}")
-        elif cls.VERBOSE_LOGGING:
-            print(f"✅ 静态文件目录存在")
-            
-        # 检查并创建图片保存目录
-        if not os.path.exists(cls.IMAGE_SAVE_DIR):
-            try:
-                os.makedirs(cls.IMAGE_SAVE_DIR, exist_ok=True)
-                if cls.VERBOSE_LOGGING:
-                    print(f"✅ 已创建图片保存目录: {cls.IMAGE_SAVE_DIR}")
-            except Exception as e:
-                print(f"❌ 创建图片保存目录失败: {str(e)}")
-        elif cls.VERBOSE_LOGGING:
-            print(f"✅ 图片保存目录存在")
-            
-            # 测试写入权限
-            try:
-                test_file = os.path.join(cls.IMAGE_SAVE_DIR, '.test_write')
-                with open(test_file, 'w') as f:
-                    f.write('test')
-                os.remove(test_file)
-                print(f"✅ 图片保存目录有写入权限")
-            except Exception as e:
-                print(f"❌ 图片保存目录没有写入权限: {str(e)}")
-    
-    @classmethod
-    def load_api_keys(cls):
-        """加载API密钥"""
-        # 先从环境变量加载
-        api_keys_str = os.getenv("API_KEYS", "")
-        if api_keys_str:
-            try:
-                cls.API_KEYS = json.loads(api_keys_str)
-                if cls.VERBOSE_LOGGING:
-                    logger.info(f"已从环境变量加载 {len(cls.API_KEYS)} 个API keys")
-                return
-            except json.JSONDecodeError as e:
-                logger.error(f"解析环境变量API keys失败: {e}")
-                
-        # 再从文件加载
-        try:
-            if os.path.exists(cls.KEYS_STORAGE_FILE):
-                with open(cls.KEYS_STORAGE_FILE, "r", encoding="utf-8") as f:
-                    keys_data = json.load(f)
-                    if isinstance(keys_data, dict) and "keys" in keys_data:
-                        cls.API_KEYS = [k for k in keys_data["keys"] if k.get("key")]
-                    else:
-                        cls.API_KEYS = keys_data
-                    
-                    if cls.VERBOSE_LOGGING:
-                        logger.info(f"已从文件加载 {len(cls.API_KEYS)} 个API keys")
-        except Exception as e:
-            logger.error(f"从文件加载API keys失败: {e}") 
-    
-    @classmethod
-    def save_api_keys(cls, keys_data):
-        """保存API密钥到文件"""
-        try:
-            keys_storage_file = os.path.join(cls.BASE_DIR, cls.KEYS_STORAGE_FILE)
-            
-            with open(keys_storage_file, "w", encoding="utf-8") as f:
-                if isinstance(keys_data, list):
-                    json.dump({"keys": keys_data}, f, ensure_ascii=False, indent=2)
-                else:
-                    json.dump(keys_data, f, ensure_ascii=False, indent=2)
-            
-            # 更新内存中的keys
-            if isinstance(keys_data, dict) and "keys" in keys_data:
-                cls.API_KEYS = [k for k in keys_data["keys"] if k.get("key")]
-            else:
-                cls.API_KEYS = keys_data
-                
-            if cls.VERBOSE_LOGGING:
-                logger.info(f"API keys已保存至 {keys_storage_file}")
-        except Exception as e:
-            logger.error(f"保存API keys失败: {e}")
-    
-    @classmethod
-    def save_admin_key(cls):
-        """保存管理员密钥到文件"""
-        try:
-            admin_config_file = os.path.join(cls.BASE_DIR, "admin_config.json")
-            with open(admin_config_file, "w", encoding="utf-8") as f:
-                json.dump({"admin_key": cls.ADMIN_KEY}, f, indent=2)
-            
-            if cls.VERBOSE_LOGGING:
-                logger.info(f"管理员密钥已保存至 {admin_config_file}")
-        except Exception as e:
-            logger.error(f"保存管理员密钥失败: {e}") 

sora-api-master/src/key_manager.py

@@ -1,777 +0,0 @@
-import time
-import random
-import uuid
-import json
-import os
-import logging
-import threading
-from typing import Dict, List, Optional, Any, Union, Tuple, Callable
-
-# 初始化日志
-logger = logging.getLogger("sora-api.key_manager")
-
-class KeyManager:
-    def __init__(self, storage_file: str = "api_keys.json"):
-        """
-        初始化密钥管理器
-        
-        Args:
-            storage_file: 密钥存储文件路径
-        """
-        self.keys = []  # 密钥列表
-        self.storage_file = storage_file
-        self.usage_stats = {}  # 使用统计
-        self._lock = threading.RLock()  # 添加可重入锁以支持并发访问
-        self._working_keys = {}  # 新增：记录正在工作中的密钥 {key_value: task_id}
-        self._load_keys()
-        
-    def _load_keys(self) -> None:
-        """从环境变量或文件加载密钥"""
-        keys_loaded = False
-        
-        # 先尝试从环境变量加载
-        api_keys_str = os.getenv("API_KEYS", "")
-        if api_keys_str:
-            try:
-                env_data = json.loads(api_keys_str)
-                self._process_keys_data(env_data)
-                if len(self.keys) > 0:
-                    logger.info(f"已从环境变量加载 {len(self.keys)} 个密钥")
-                    keys_loaded = True
-                else:
-                    logger.warning("环境变量API_KEYS存在但未包含有效密钥")
-            except json.JSONDecodeError as e:
-                logger.error(f"解析环境变量API keys失败: {str(e)}")
-        
-            # 如果环境变量未设置、解析失败或未加载到密钥，从文件加载
-        if not keys_loaded:
-            try:
-                if os.path.exists(self.storage_file):
-                    logger.info(f"尝试从文件加载密钥: {self.storage_file}")
-                    with open(self.storage_file, 'r', encoding='utf-8') as f:
-                        data = json.load(f)
-                        keys_before = len(self.keys)
-                        self._process_keys_data(data)
-                        keys_loaded = len(self.keys) > keys_before
-                        logger.info(f"已从文件加载 {len(self.keys) - keys_before} 个密钥")
-                else:
-                    logger.warning(f"密钥文件不存在: {self.storage_file}")
-            except Exception as e:
-                logger.error(f"加载密钥失败: {str(e)}")
-                
-        if len(self.keys) == 0:
-            logger.warning("未能从环境变量或文件加载任何密钥")
-
-        
-    def _process_keys_data(self, data):
-        """处理不同格式的密钥数据"""
-        # 处理不同的数据格式
-        if isinstance(data, list):
-            # 旧版格式：直接是密钥列表
-            raw_keys = data
-            self.keys = []
-            self.usage_stats = {}
-            
-            # 为每个密钥创建完整的记录
-            for key_info in raw_keys:
-                if isinstance(key_info, dict):
-                    key_value = key_info.get("key")
-                    if not key_value:
-                        logger.warning(f"忽略无效密钥配置: {key_info}")
-                        continue
-                        
-                    # 确保有ID
-                    key_id = key_info.get("id") or str(uuid.uuid4())
-                    
-                    # 构建完整的密钥记录
-                    key_record = {
-                        "id": key_id,
-                        "name": key_info.get("name", ""),
-                        "key": key_value,
-                        "weight": key_info.get("weight", 1),
-                        "max_rpm": key_info.get("max_rpm", 60),
-                        "requests": 0,
-                        "last_reset": time.time(),
-                        "available": key_info.get("is_enabled", True),
-                        "is_enabled": key_info.get("is_enabled", True),
-                        "created_at": key_info.get("created_at", time.time()),
-                        "last_used": key_info.get("last_used"),
-                        "notes": key_info.get("notes")
-                    }
-                    
-                    self.keys.append(key_record)
-                    
-                    # 初始化使用统计
-                    self.usage_stats[key_id] = {
-                        "total_requests": 0,
-                        "successful_requests": 0,
-                        "failed_requests": 0,
-                        "daily_usage": {},
-                        "average_response_time": 0
-                    }
-                elif isinstance(key_info, str):
-                    # 如果是字符串，直接作为密钥值
-                    key_id = str(uuid.uuid4())
-                    self.keys.append({
-                        "id": key_id,
-                        "name": "",
-                        "key": key_info,
-                        "weight": 1,
-                        "max_rpm": 60,
-                        "requests": 0,
-                        "last_reset": time.time(),
-                        "available": True,
-                        "is_enabled": True,
-                        "created_at": time.time(),
-                        "last_used": None,
-                        "notes": None
-                    })
-                    
-                    # 初始化使用统计
-                    self.usage_stats[key_id] = {
-                        "total_requests": 0,
-                        "successful_requests": 0,
-                        "failed_requests": 0,
-                        "daily_usage": {},
-                        "average_response_time": 0
-                    }
-        else:
-            # 新版格式：包含keys和usage_stats的字典
-            self.keys = data.get('keys', [])
-            self.usage_stats = data.get('usage_stats', {})
-    
-    def _save_keys(self) -> None:
-        """保存密钥到文件"""
-        try:
-            with open(self.storage_file, 'w', encoding='utf-8') as f:
-                json.dump({
-                    'keys': self.keys,
-                    'usage_stats': self.usage_stats
-                }, f, ensure_ascii=False, indent=2)
-                
-            # 同时更新Config中的API_KEYS
-            try:
-                from .config import Config
-                Config.API_KEYS = self.keys
-            except (ImportError, AttributeError):
-                logger.debug("无法更新Config中的API_KEYS")
-        except Exception as e:
-            logger.error(f"保存密钥失败: {str(e)}")
-            
-    def add_key(self, key_value: str, name: str = "", weight: int = 1, 
-                rate_limit: int = 60, is_enabled: bool = True, notes: str = None) -> Dict[str, Any]:
-        """
-        添加密钥
-        
-        Args:
-            key_value: 密钥值
-            name: 密钥名称
-            weight: 权重
-            rate_limit: 速率限制(每分钟请求数)
-            is_enabled: 是否启用
-            notes: 备注
-            
-        Returns:
-            添加的密钥信息
-        """
-        with self._lock:  # 使用锁保护添加过程
-            # 检查密钥是否已存在
-            for key in self.keys:
-                if key.get("key") == key_value:
-                    return key
-            
-            key_id = str(uuid.uuid4())
-            new_key = {
-                "id": key_id,
-                "name": name,
-                "key": key_value,
-                "weight": weight,
-                "max_rpm": rate_limit,
-                "requests": 0,
-                "last_reset": time.time(),
-                "available": is_enabled,
-                "is_enabled": is_enabled,
-                "created_at": time.time(),
-                "last_used": None,
-                "notes": notes
-            }
-            self.keys.append(new_key)
-            
-            # 初始化使用统计
-            self.usage_stats[key_id] = {
-                "total_requests": 0,
-                "successful_requests": 0,
-                "failed_requests": 0,
-                "daily_usage": {},
-                "average_response_time": 0
-            }
-            
-            self._save_keys()
-            logger.info(f"已添加密钥: {name or key_id}")
-            return new_key
-    
-    def get_all_keys(self) -> List[Dict[str, Any]]:
-        """获取所有密钥信息（已隐藏完整密钥值）"""
-        with self._lock:  # 使用锁保护读取过程
-            result = []
-            for key in self.keys:
-                key_copy = key.copy()
-                if "key" in key_copy:
-                    # 只显示密钥前6位和后4位
-                    full_key = key_copy["key"]
-                    if len(full_key) > 10:
-                        key_copy["key"] = full_key[:6] + "..." + full_key[-4:]
-                
-                # 增加临时禁用信息的处理
-                if key_copy.get("temp_disabled_until"):
-                    temp_disabled_until = key_copy["temp_disabled_until"]
-                    # 确保temp_disabled_until是时间戳格式
-                    if isinstance(temp_disabled_until, (int, float)):
-                        # 转换为可读格式，但保留原始时间戳，让前端可以自行处理
-                        disabled_until_date = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(temp_disabled_until))
-                        key_copy["temp_disabled_until_formatted"] = disabled_until_date
-                        key_copy["temp_disabled_remaining"] = int(temp_disabled_until - time.time())
-                
-                result.append(key_copy)
-            return result
-    
-    def get_key_by_id(self, key_id: str) -> Optional[Dict[str, Any]]:
-        """根据ID获取密钥信息"""
-        with self._lock:  # 使用锁保护读取过程
-            for key in self.keys:
-                if key.get("id") == key_id:
-                    return key
-            return None
-    
-    def update_key(self, key_id: str, **kwargs) -> Optional[Dict[str, Any]]:
-        """
-        更新密钥信息
-        
-        Args:
-            key_id: 密钥ID
-            **kwargs: 要更新的字段
-            
-        Returns:
-            更新后的密钥信息，未找到则返回None
-        """
-        with self._lock:  # 使用锁保护更新过程
-            for key in self.keys:
-                if key.get("id") == key_id:
-                    # 更新提供的字段
-                    for field, value in kwargs.items():
-                        if value is not None:
-                            if field == "is_enabled":
-                                key["available"] = value  # 同步更新available字段
-                            key[field] = value
-                    
-                    self._save_keys()
-                    logger.info(f"已更新密钥: {key.get('name') or key_id}")
-                    return key
-            
-            logger.warning(f"未找到密钥: {key_id}")
-            return None
-    
-    def delete_key(self, key_id: str) -> bool:
-        """
-        删除密钥
-        
-        Args:
-            key_id: 密钥ID
-            
-        Returns:
-            是否成功删除
-        """
-        with self._lock:  # 使用锁保护删除过程
-            original_length = len(self.keys)
-            self.keys = [key for key in self.keys if key.get("id") != key_id]
-            
-            # 如果成功删除，保存密钥
-            if len(self.keys) < original_length:
-                self._save_keys()
-                return True
-                
-            return False
-    
-    def batch_import_keys(self, keys_data: List[Dict[str, Any]]) -> Dict[str, int]:
-        """
-        批量导入密钥
-        
-        Args:
-            keys_data: 密钥数据列表，每个元素为包含密钥信息的字典
-            
-        Returns:
-            导入结果统计
-        """
-        with self._lock:  # 使用锁保护导入过程
-            imported_count = 0
-            skipped_count = 0
-            
-            # 获取现有密钥值
-            existing_keys = {key.get("key") for key in self.keys}
-            
-            for key_data in keys_data:
-                key_value = key_data.get("key")
-                if not key_value:
-                    continue
-                    
-                # 检查密钥是否已存在
-                if key_value in existing_keys:
-                    skipped_count += 1
-                    continue
-                    
-                # 添加新密钥
-                key_id = str(uuid.uuid4())
-                new_key = {
-                    "id": key_id,
-                    "name": key_data.get("name", ""),
-                    "key": key_value,
-                    "weight": key_data.get("weight", 1),
-                    "max_rpm": key_data.get("rate_limit", 60),
-                    "requests": 0,
-                    "last_reset": time.time(),
-                    "available": key_data.get("enabled", True),
-                    "is_enabled": key_data.get("enabled", True),
-                    "created_at": time.time(),
-                    "last_used": None,
-                    "notes": key_data.get("notes")
-                }
-                self.keys.append(new_key)
-                existing_keys.add(key_value)  # 添加到已存在集合中
-                
-                # 初始化使用统计
-                self.usage_stats[key_id] = {
-                    "total_requests": 0,
-                    "successful_requests": 0,
-                    "failed_requests": 0,
-                    "daily_usage": {},
-                    "average_response_time": 0
-                }
-                
-                imported_count += 1
-                
-            # 保存密钥
-            if imported_count > 0:
-                self._save_keys()
-                
-            return {
-                "imported": imported_count,
-                "skipped": skipped_count
-            }
-    
-    def get_key(self) -> Optional[str]:
-        """获取下一个可用的密钥"""
-        with self._lock:  # 使用锁保护整个获取密钥过程
-            if not self.keys:
-                logger.warning("没有可用的密钥")
-                return None
-                
-            # 重置计数器（如果需要）
-            current_time = time.time()
-            temporary_disabled_updated = False
-            
-            for key in self.keys:
-                # 检查是否有被临时禁用的密钥需要重新启用
-                if key.get("temp_disabled_until") and current_time > key.get("temp_disabled_until"):
-                    key["is_enabled"] = True
-                    key["available"] = True
-                    key["temp_disabled_until"] = None
-                    temporary_disabled_updated = True
-                    logger.info(f"密钥 {key.get('name') or key.get('id')} 的临时禁用已��除")
-                    
-                if current_time - key["last_reset"] >= 60:
-                    key["requests"] = 0
-                    key["last_reset"] = current_time
-                    if not key.get("temp_disabled_until"):  # 只有未被临时禁用的密钥才会被重新激活
-                        key["available"] = key.get("is_enabled", True)
-            
-            # 如果有任何临时禁用的密钥被更新，保存变更
-            if temporary_disabled_updated:
-                self._save_keys()
-            
-            # 筛选可用的密钥，排除工作中的密钥
-            available_keys = []
-            for k in self.keys:
-                key_value = k.get("key", "")
-                clean_key = key_value.replace("Bearer ", "") if key_value.startswith("Bearer ") else key_value
-                
-                # 检查此密钥是否在工作中
-                is_working = clean_key in self._working_keys
-                
-                if k.get("available", False) and not is_working:
-                    available_keys.append(k)
-            
-            if not available_keys:
-                logger.warning("没有可用的密钥（所有密钥都达到速率限制、被禁用或正在工作中）")
-                return None
-                
-            # 根据权重选择密钥
-            weights = [k.get("weight", 1) for k in available_keys]
-            selected_idx = random.choices(range(len(available_keys)), weights=weights, k=1)[0]
-            selected_key = available_keys[selected_idx]
-            
-            # 更新使用统计
-            selected_key["requests"] += 1
-            selected_key["last_used"] = current_time
-            
-            # 检查是否达到速率限制
-            if selected_key["requests"] >= selected_key.get("max_rpm", 60):
-                selected_key["available"] = False
-            
-            # 保存数据 - 并发环境下调整为每次都保存，避免状态不一致
-            # 原来是随机保存（10%的概率）
-            self._save_keys()
-            
-            # 确保返回的密钥包含"Bearer "前缀
-            key_value = selected_key["key"]
-            if not key_value.startswith("Bearer "):
-                key_value = f"Bearer {key_value}"
-            
-            return key_value
-    
-    def record_request_result(self, key: str, success: bool, response_time: float = 0) -> None:
-        """
-        记录请求结果
-        
-        Args:
-            key: 密钥值
-            success: 请求是否成功
-            response_time: 响应时间(秒)
-        """
-        if not key:
-            logger.warning("记录请求结果失败：密钥为空")
-            return
-            
-        with self._lock:  # 使用锁保护记录过程
-            # 去掉可能的Bearer前缀
-            key_for_search = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
-            
-            # 查找对应的密钥ID
-            key_id = None
-            key_info = None
-            for k in self.keys:
-                stored_key = k.get("key", "").replace("Bearer ", "") if k.get("key", "").startswith("Bearer ") else k.get("key", "")
-                if stored_key == key_for_search:
-                    key_id = k.get("id")
-                    key_info = k
-                    break
-                    
-            if not key_id:
-                logger.warning(f"记录请求结果失败：未找到密钥 {key_for_search[:6]}...")
-                return
-                
-            # 初始化usage_stats如果该密钥还没有统计数据
-            if key_id not in self.usage_stats:
-                self.usage_stats[key_id] = {
-                    "total_requests": 0,
-                    "successful_requests": 0,
-                    "failed_requests": 0,
-                    "daily_usage": {},
-                    "average_response_time": 0
-                }
-                
-            # 记录请求结果
-            stats = self.usage_stats[key_id]
-            stats["total_requests"] += 1
-            
-            if success:
-                stats["successful_requests"] += 1
-            else:
-                stats["failed_requests"] += 1
-                
-            # 记录响应时间
-            if response_time > 0:
-                if stats["average_response_time"] == 0:
-                    stats["average_response_time"] = response_time
-                else:
-                    # 使用加权平均
-                    old_avg = stats["average_response_time"]
-                    total = stats["total_requests"]
-                    # 避免 total 为0或1时产生问题，尽管前面 total_requests 已经增加了
-                    if total > 0:
-                        stats["average_response_time"] = ((old_avg * (total - 1)) + response_time) / total
-                    else: # 理论上不应该发生，因为 total_requests 已经增加了
-                        stats["average_response_time"] = response_time
-                    
-            # 记录每日使用情况
-            today = time.strftime("%Y-%m-%d")
-            if today not in stats["daily_usage"]:
-                stats["daily_usage"][today] = {"successful": 0, "failed": 0} # 初始化每日统计
-            
-            # 根据成功与否更新每日统计
-            if success:
-                stats["daily_usage"][today]["successful"] += 1
-            else:
-                stats["daily_usage"][today]["failed"] += 1
-                
-            # 保留最近30天的数据
-            if len(stats["daily_usage"]) > 30:
-                # 获取所有日期并排序，然后删除最早的
-                sorted_dates = sorted(stats["daily_usage"].keys())
-                if sorted_dates: # 确保列表不为空
-                    oldest_date = sorted_dates[0]
-                    del stats["daily_usage"][oldest_date]
-                    
-            # 更新密钥的最后使用时间
-            if key_info and "last_used" in key_info:
-                key_info["last_used"] = time.time()
-                
-            # 并发环境下每次都保存，确保统计准确性
-            self._save_keys()
-    
-    def get_usage_stats(self) -> Dict[str, Any]:
-        """获取使用统计信息"""
-        with self._lock:  # 使用锁保护读取过程
-            total_keys = len(self.keys)
-            active_keys = sum(1 for k in self.keys if k.get("is_enabled", False))
-            available_keys = sum(1 for k in self.keys if k.get("available", False))
-            
-            total_requests = sum(stats.get("total_requests", 0) for stats in self.usage_stats.values())
-            successful_requests = sum(stats.get("successful_requests", 0) for stats in self.usage_stats.values())
-            
-            # 计算成功率
-            success_rate = (successful_requests / total_requests * 100) if total_requests > 0 else 0
-            
-            # 计算每个密钥的平均响应时间
-            avg_response_times = [stats.get("average_response_time", 0) for stats in self.usage_stats.values() if stats.get("average_response_time", 0) > 0]
-            overall_avg_response_time = sum(avg_response_times) / len(avg_response_times) if avg_response_times else 0
-            
-            # 获取过去7天的使用情况
-            past_7_days = {}
-            for key_id, stats in self.usage_stats.items():
-                daily_usage = stats.get("daily_usage", {})
-                for date, count_data in daily_usage.items():
-                    if date not in past_7_days:
-                        past_7_days[date] = {"successful": 0, "failed": 0}
-                    # 正确处理字典类型的count_data
-                    past_7_days[date]["successful"] += count_data.get("successful", 0)
-                    past_7_days[date]["failed"] += count_data.get("failed", 0)
-                    
-            # 只保留最近7天
-            dates = sorted(past_7_days.keys(), reverse=True)[:7]
-            past_7_days = {date: past_7_days[date] for date in dates}
-            
-            return {
-                "total_keys": total_keys,
-                "active_keys": active_keys,
-                "available_keys": available_keys,
-                "total_requests": total_requests,
-                "successful_requests": successful_requests,
-                "failed_requests": total_requests - successful_requests,
-                "success_rate": success_rate,
-                "average_response_time": overall_avg_response_time,
-                "past_7_days": past_7_days
-            } 
-
-    def mark_key_as_working(self, key: str, task_id: str) -> None:
-        """
-        将密钥标记为工作中状态
-        
-        Args:
-            key: API密钥值（可能包含Bearer前缀）
-            task_id: 关联的任务ID
-        """
-        with self._lock:
-            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
-            self._working_keys[clean_key] = task_id
-            logger.debug(f"密钥已标记为工作中，关联任务ID: {task_id}")
-    
-    def release_key(self, key: str) -> None:
-        """
-        释放工作中的密钥
-        
-        Args:
-            key: API密钥值（可能包含Bearer前缀）
-        """
-        with self._lock:
-            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
-            if clean_key in self._working_keys:
-                del self._working_keys[clean_key]
-                logger.debug(f"密钥已释放")
-    
-    def is_key_working(self, key: str) -> bool:
-        """
-        检查密钥是否正在工作中
-        
-        Args:
-            key: API密钥值（可能包含Bearer前缀）
-            
-        Returns:
-            bool: 是否在工作中
-        """
-        with self._lock:
-            clean_key = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
-            return clean_key in self._working_keys
-
-    def mark_key_invalid(self, key: str) -> Optional[str]:
-        """
-        将指定的密钥标记为无效（临时禁用而不是永久禁用），并返回一个新的可用密钥
-        
-        Args:
-            key: API密钥值（可能包含Bearer前缀）
-            
-        Returns:
-            Optional[str]: 新的可用密钥，如果没有可用密钥则返回None
-        """
-        # 调用临时禁用方法，设置24小时禁用时间
-        return self.mark_key_temp_disabled(key, hours=24.0)
-        
-    def mark_key_temp_disabled(self, key: str, hours: float = 12.0) -> Optional[str]:
-        """
-        将指定的密钥临时禁用指定小时数，并返回一个新的可用密钥
-        
-        Args:
-            key: API密钥值（可能包含Bearer前缀）
-            hours: 禁用小时数
-            
-        Returns:
-            Optional[str]: 新的可用密钥，如果没有可用密钥则返回None
-        """
-        with self._lock:  # 使用锁保护临时禁用过程
-            # 去掉可能的Bearer前缀
-            key_for_search = key.replace("Bearer ", "") if key.startswith("Bearer ") else key
-            
-            # 检查是否是因为密钥在工作中导致的错误
-            if key_for_search in self._working_keys:
-                logger.warning(f"尝试禁用正在工作中的密钥（任务ID: {self._working_keys[key_for_search]}），跳过禁用操作")
-                # 获取一个新密钥返回，但不禁用当前密钥
-                new_key = self.get_key()
-                if new_key:
-                    logger.info(f"已返回新密钥，但未禁用工作中的密钥")
-                    return new_key
-                else:
-                    logger.warning("没有可用的备用密钥")
-                    return None
-            
-            # 查找对应的密钥
-            key_found = False
-            disabled_key_id = None
-            for key_info in self.keys:
-                stored_key = key_info.get("key", "").replace("Bearer ", "") if key_info.get("key", "").startswith("Bearer ") else key_info.get("key", "")
-                if stored_key == key_for_search:
-                    # 标记密钥为临时禁用
-                    disabled_until = time.time() + (hours * 3600)  # 当前时间加上禁用小时数
-                    key_info["available"] = False
-                    key_info["temp_disabled_until"] = disabled_until
-                    key_info["notes"] = (key_info.get("notes") or "") + f"\n[自动] 在 {time.strftime('%Y-%m-%d %H:%M:%S')} 被临时禁用{hours}小时"
-                    key_found = True
-                    disabled_key_id = key_info.get("id")
-                    logger.warning(f"密钥 {key_info.get('name') or key_info.get('id')} 被临时禁用{hours}小时")
-                    break
-            
-            if key_found:
-                # 保存更改
-                self._save_keys()
-                
-                # 获取新的密钥，排除已禁用的
-                new_key = self.get_key()
-                if new_key:
-                    logger.info(f"已自动切换到新的密钥")
-                    return new_key
-                else:
-                    logger.warning("没有可用的备用密钥")
-                    return None
-            else:
-                logger.warning(f"未找到要临时禁用的密钥")
-                return None
-            
-    def retry_request(self, original_key: str, request_func: Callable, max_retries: int = 1, 
-                     max_key_switches: int = 3) -> Tuple[bool, Any, str]:
-        """
-        出错时自动重试请求，并在需要时切换密钥
-        
-        Args:
-            original_key: 原始API密钥（可能包含Bearer前缀）
-            request_func: 执行请求的函数，接受一个参数(密钥)并返回(成功标志, 结果)
-            max_retries: 使用同一密钥的最大重试次数
-            max_key_switches: 最大密钥切换次数
-            
-        Returns:
-            Tuple[bool, Any, str]: (是否成功, 请求结果, 使用的密钥)
-        """
-        current_key = original_key
-        current_key_switches = 0
-        
-        # 首先用原始密钥尝试
-        for attempt in range(max_retries + 1):  # +1是因为第一次不算重试
-            try:
-                success, result = request_func(current_key)
-                # 成功的请求不应该导致密钥被禁用
-                if success:
-                    # 记录请求成功，避免不必要的密钥禁用
-                    with self._lock:
-                        self.record_request_result(current_key, True)
-                    return True, result, current_key
-                logger.warning(f"请求失败(尝试 {attempt+1}/{max_retries+1}): {result}")
-            except Exception as e:
-                logger.error(f"请求异常(尝试 {attempt+1}/{max_retries+1}): {str(e)}")
-            
-            # 如果这不是最后一次尝试，等���一秒后重试
-            if attempt < max_retries:
-                time.sleep(1)
-                
-        # 如果原始密钥的所有重试都失败，尝试切换密钥
-        tried_keys = set([current_key.replace("Bearer ", "") if current_key.startswith("Bearer ") else current_key])
-        
-        while current_key_switches < max_key_switches:
-            # 获取新的密钥
-            with self._lock:
-                new_key = self.get_key()
-            if not new_key:
-                logger.warning("没有更多可用的密钥")
-                break
-                
-            # 确保不使用已经尝试过的密钥
-            clean_new_key = new_key.replace("Bearer ", "") if new_key.startswith("Bearer ") else new_key
-            if clean_new_key in tried_keys:
-                continue
-                
-            tried_keys.add(clean_new_key)
-            current_key = new_key
-            current_key_switches += 1
-            
-            logger.info(f"切换到新密钥 (切换 {current_key_switches}/{max_key_switches})")
-            
-            # 用新密钥尝试
-            for attempt in range(max_retries + 1):
-                try:
-                    success, result = request_func(current_key)
-                    if success:
-                        # 记录请求成功
-                        with self._lock:
-                            self.record_request_result(current_key, True)
-                        return True, result, current_key
-                    logger.warning(f"使用新密钥请求失败(尝试 {attempt+1}/{max_retries+1}): {result}")
-                except Exception as e:
-                    logger.error(f"使用新密钥请求异常(尝试 {attempt+1}/{max_retries+1}): {str(e)}")
-                
-                # 如果这不是最后一次尝试，等待一秒后重试
-                if attempt < max_retries:
-                    time.sleep(1)
-        
-        # 所有尝试都失败，临时禁用原始密钥
-        # 但是在并发环境下，这可能是因为网络或服务问题，而非密钥问题
-        # 增加额外检查以减少不必要的密钥禁用
-        should_disable = True
-        
-        # 在临时禁用前，确认是否是密钥问题而非服务或网络问题
-        # 此处可以添加额外逻辑来判断是否应该禁用密钥
-        
-        if should_disable:
-            logger.error(f"所有重试和密钥切换尝试都失败，临时禁用原始密钥")
-            with self._lock:
-                self.mark_key_temp_disabled(original_key, hours=6.0)  # 减少禁用时间，避免资源浪费
-        else:
-            logger.warning(f"所有重试和密钥切换尝试都失败，但可能是服务问题而非密钥问题，不禁用密钥")
-        
-        # 返回最后一次尝试的结果
-        return False, result, current_key
-
-# 创建全局密钥管理器实例
-storage_file = os.getenv("KEYS_STORAGE_FILE", "api_keys.json")
-# 如果提供了绝对路径则直接使用，否则使用相对路径
-if not os.path.isabs(storage_file):
-    base_dir = os.getenv("BASE_DIR", os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-    storage_file = os.path.join(base_dir, storage_file)
-
-key_manager = KeyManager(storage_file=storage_file)
-logger.info(f"初始化全局密钥管理器，存储文件: {storage_file}") 

sora-api-master/src/main.py

@@ -1,44 +0,0 @@
-import uvicorn
-import logging
-from .app import app, key_manager
-from .config import Config
-
-# 获取日志记录器
-logger = logging.getLogger("sora-api.main")
-
-def init_app():
-    """初始化应用程序"""
-    try:
-        # 密钥管理器已在app.py中初始化并加载完成
-        # 检查是否有可用的密钥
-        if not key_manager.keys:
-            logger.warning("未配置API key，将使用测试密钥")
-            key_manager.add_key(
-                key_value="Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9...",
-                name="默认测试密钥"
-            )
-        
-        logger.info(f"API服务初始化完成，已加载 {len(key_manager.keys)} 个API key")
-    except Exception as e:
-        logger.error(f"API服务初始化失败: {str(e)}")
-        raise
-
-def start():
-    """启动API服务"""
-    # 初始化应用
-    init_app()
-    
-    # 打印配置信息
-    Config.print_config()
-    
-    # 启动服务
-    logger.info(f"启动服务: {Config.HOST}:{Config.PORT}")
-    uvicorn.run(
-        "src.app:app",
-        host=Config.HOST,
-        port=Config.PORT,
-        reload=Config.VERBOSE_LOGGING  # 仅在调试模式下开启自动重载
-    )
-
-if __name__ == "__main__":
-    start()

sora-api-master/src/models/__init__.py

@@ -1 +0,0 @@
-

sora-api-master/src/models/schemas.py

@@ -1,86 +0,0 @@
-from typing import List, Dict, Any, Optional, Union
-from pydantic import BaseModel, Field
-
-# 聊天完成请求模型
-class ContentItem(BaseModel):
-    type: str
-    text: Optional[str] = None
-    image_url: Optional[Dict[str, str]] = None
-
-class ChatMessage(BaseModel):
-    role: str
-    content: Union[str, List[ContentItem]]
-
-class ChatCompletionRequest(BaseModel):
-    model: str
-    messages: List[ChatMessage]
-    temperature: Optional[float] = 1.0
-    top_p: Optional[float] = 1.0
-    n: Optional[int] = 1
-    stream: Optional[bool] = False
-    max_tokens: Optional[int] = None
-    presence_penalty: Optional[float] = 0
-    frequency_penalty: Optional[float] = 0
-
-# API密钥创建模型
-class ApiKeyCreate(BaseModel):
-    name: str = Field(..., description="密钥名称")
-    key_value: str = Field(..., description="密钥值")
-    weight: int = Field(1, description="权重")
-    rate_limit: int = Field(60, description="速率限制(每分钟请求数)")
-    is_enabled: bool = Field(True, description="是否启用")
-    notes: Optional[str] = Field(None, description="备注")
-
-# API密钥更新模型
-class ApiKeyUpdate(BaseModel):
-    name: Optional[str] = Field(None, description="密钥名称")
-    key_value: Optional[str] = Field(None, description="密钥值")
-    weight: Optional[int] = Field(None, description="权重")
-    rate_limit: Optional[int] = Field(None, description="速率限制(每分钟请求数)")
-    is_enabled: Optional[bool] = Field(None, description="是否启用")
-    notes: Optional[str] = Field(None, description="备注")
-
-# 批量操作基础模型
-class BatchOperation(BaseModel):
-    action: str = Field(..., description="操作类型：import, enable, disable, delete")
-    key_ids: Optional[List[str]] = Field(None, description="要操作的密钥ID列表")
-
-# 批量导入的密钥项模型
-class ImportKeyItem(BaseModel):
-    name: str = Field(..., description="密钥名称")
-    key: str = Field(..., description="密钥值")
-    weight: int = Field(1, description="权重")
-    rate_limit: int = Field(60, description="速率限制(每分钟请求数)")
-    enabled: bool = Field(True, description="是否启用")
-    notes: Optional[str] = Field(None, description="备注")
-
-# 批量导入模型
-class BatchImportOperation(BatchOperation):
-    keys: List[ImportKeyItem] = Field(..., description="要导入的密钥列表")
-    key_ids: Optional[List[str]] = None
-
-# 系统配置更新模型
-class ConfigUpdate(BaseModel):
-    PROXY_HOST: Optional[str] = Field(None, description="代理服务器主机")
-    PROXY_PORT: Optional[str] = Field(None, description="代理服务器端口")
-    PROXY_USER: Optional[str] = Field(None, description="代理服务器用户名")
-    PROXY_PASS: Optional[str] = Field(None, description="代理服务器密码")
-    BASE_URL: Optional[str] = Field(None, description="基础URL，用于图片访问地址")
-    IMAGE_LOCALIZATION: Optional[bool] = Field(None, description="是否启用图片本地化存储")
-    IMAGE_SAVE_DIR: Optional[str] = Field(None, description="图片保存目录")
-    save_to_env: bool = Field(True, description="是否保存到环境变量文件")
-
-# 日志级别更新模型
-class LogLevelUpdate(BaseModel):
-    level: str = Field(..., description="日志级别: DEBUG, INFO, WARNING, ERROR, CRITICAL")
-    save_to_env: bool = Field(True, description="是否保存到环境变量文件")
-
-# JWT认证请求模型
-class LoginRequest(BaseModel):
-    admin_key: str = Field(..., description="管理员密钥")
-
-# JWT令牌响应模型
-class TokenResponse(BaseModel):
-    token: str = Field(..., description="JWT令牌")
-    expires_in: int = Field(..., description="有效期(秒)")
-    token_type: str = Field("bearer", description="令牌类型") 

sora-api-master/src/services/__init__.py

@@ -1 +0,0 @@
-

sora-api-master/src/services/image_service.py

@@ -1,235 +0,0 @@
-import asyncio
-import base64
-import os
-import tempfile
-import time
-import uuid
-import logging
-import threading
-from typing import List, Dict, Any, Optional, Union, Tuple
-
-from ..sora_integration import SoraClient
-from ..config import Config
-from ..utils import localize_image_urls
-
-logger = logging.getLogger("sora-api.image_service")
-
-# 存储生成结果的全局字典
-generation_results = {}
-
-# 存储任务与API密钥的映射关系
-task_to_api_key = {}
-
-# 将处理中状态消息格式化为think代码块
-def format_think_block(message: str) -> str:
-    """将消息放入```think代码块中"""
-    return f"```think\n{message}\n```"
-
-async def process_image_task(
-    request_id: str,
-    sora_client: SoraClient,
-    task_type: str,
-    prompt: str,
-    **kwargs
-) -> None:
-    """
-    统一的图像处理任务函数
-    
-    Args:
-        request_id: 请求ID
-        sora_client: Sora客户端实例
-        task_type: 任务类型 ("generation" 或 "remix")
-        prompt: 提示词
-        **kwargs: 其他参数，取决于任务类型
-    """
-    try:
-        # 保存当前任务使用的API密钥，以便后续使用同一密钥进行操作
-        current_api_key = sora_client.auth_token
-        task_to_api_key[request_id] = current_api_key
-        
-        # 更新状态为处理中
-        generation_results[request_id] = {
-            "status": "processing",
-            "message": format_think_block("正在准备生成任务，请稍候..."),
-            "timestamp": int(time.time()),
-            "api_key": current_api_key  # 记录使用的API密钥
-        }
-        
-        # 根据任务类型执行不同操作
-        if task_type == "generation":
-            # 文本到图像生成
-            num_images = kwargs.get("num_images", 1)
-            width = kwargs.get("width", 720)
-            height = kwargs.get("height", 480)
-            
-            # 更新状态
-            generation_results[request_id] = {
-                "status": "processing",
-                "message": format_think_block("正在生成图像，请耐心等待..."),
-                "timestamp": int(time.time()),
-                "api_key": current_api_key
-            }
-            
-            # 生成图像
-            logger.info(f"[{request_id}] 开始生成图像, 提示词: {prompt}")
-            image_urls = await sora_client.generate_image(
-                prompt=prompt,
-                num_images=num_images,
-                width=width,
-                height=height
-            )
-            
-        elif task_type == "remix":
-            # 图像到图像生成（Remix）
-            image_data = kwargs.get("image_data")
-            num_images = kwargs.get("num_images", 1)
-            
-            if not image_data:
-                raise ValueError("缺少图像数据")
-                
-            # 更新状态
-            generation_results[request_id] = {
-                "status": "processing",
-                "message": format_think_block("正在处理上传的图片..."),
-                "timestamp": int(time.time()),
-                "api_key": current_api_key
-            }
-            
-            # 保存base64图片到临时文件
-            temp_dir = tempfile.mkdtemp()
-            temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
-            
-            try:
-                # 解码并保存图片
-                with open(temp_image_path, "wb") as f:
-                    f.write(base64.b64decode(image_data))
-                
-                # 更新状态
-                generation_results[request_id] = {
-                    "status": "processing",
-                    "message": format_think_block("正在上传图片到Sora服务..."),
-                    "timestamp": int(time.time()),
-                    "api_key": current_api_key
-                }
-                
-                # 上传图片 - 确保使用与初始请求相同的API密钥
-                upload_result = await sora_client.upload_image(temp_image_path)
-                media_id = upload_result['id']
-                
-                # 更新状态
-                generation_results[request_id] = {
-                    "status": "processing",
-                    "message": format_think_block("正在基于图片生成新图像..."),
-                    "timestamp": int(time.time()),
-                    "api_key": current_api_key
-                }
-                
-                # 执行remix生成
-                logger.info(f"[{request_id}] 开始生成Remix图像, 提示词: {prompt}")
-                image_urls = await sora_client.generate_image_remix(
-                    prompt=prompt,
-                    media_id=media_id,
-                    num_images=num_images
-                )
-                
-            finally:
-                # 清理临时文件
-                if os.path.exists(temp_image_path):
-                    os.remove(temp_image_path)
-                if os.path.exists(temp_dir):
-                    os.rmdir(temp_dir)
-        else:
-            raise ValueError(f"未知的任务类型: {task_type}")
-        
-        # 验证生成结果
-        if isinstance(image_urls, str):
-            logger.warning(f"[{request_id}] 图像生成失败或返回了错误信息: {image_urls}")
-            generation_results[request_id] = {
-                "status": "failed",
-                "error": image_urls,
-                "message": format_think_block(f"图像生成失败: {image_urls}"),
-                "timestamp": int(time.time()),
-                "api_key": current_api_key
-            }
-            return
-            
-        if not image_urls:
-            logger.warning(f"[{request_id}] 图像生成返回了空列表")
-            generation_results[request_id] = {
-                "status": "failed",
-                "error": "图像生成返回了空结果",
-                "message": format_think_block("图像生成失败: 服务器返回了空结果"),
-                "timestamp": int(time.time()),
-                "api_key": current_api_key
-            }
-            return
-            
-        logger.info(f"[{request_id}] 成功生成 {len(image_urls)} 张图片")
-        
-        # 本地化图片URL
-        if Config.IMAGE_LOCALIZATION:
-            logger.info(f"[{request_id}] 准备进行图片本地化处理")
-            try:
-                localized_urls = await localize_image_urls(image_urls)
-                logger.info(f"[{request_id}] 图片本地化处理完成")
-                
-                # 检查本地化结果
-                if not localized_urls:
-                    logger.warning(f"[{request_id}] 本地化处理返回了空列表，将使用原始URL")
-                    localized_urls = image_urls
-                
-                # 检查是否所有URL都被正确本地化
-                local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
-                logger.info(f"[{request_id}] 本地化结果: 总计 {len(localized_urls)} 张图片，成功本地化 {local_count} 张")
-                
-                if local_count == 0:
-                    logger.warning(f"[{request_id}] 警告：没有一个URL被成功本地化，将使用原始URL")
-                    localized_urls = image_urls
-                
-                image_urls = localized_urls
-            except Exception as e:
-                logger.error(f"[{request_id}] 图片本地化过程中发生错误: {str(e)}", exc_info=True)
-                logger.info(f"[{request_id}] 由于错误，将使用原始URL")
-        else:
-            logger.info(f"[{request_id}] 图片本地化功能未启用，使用原始URL")
-        
-        # 存储结果
-        generation_results[request_id] = {
-            "status": "completed",
-            "image_urls": image_urls,
-            "timestamp": int(time.time()),
-            "api_key": current_api_key
-        }
-        
-        # 30分钟后自动清理结果
-        def cleanup_task():
-            generation_results.pop(request_id, None)
-            task_to_api_key.pop(request_id, None)
-            
-        threading.Timer(1800, cleanup_task).start()
-        
-    except Exception as e:
-        error_message = f"图像生成失败: {str(e)}"
-        generation_results[request_id] = {
-            "status": "failed",
-            "error": error_message,
-            "message": format_think_block(error_message),
-            "timestamp": int(time.time()),
-            "api_key": sora_client.auth_token  # 记录当前API密钥
-        }
-        logger.error(f"图像生成失败 (ID: {request_id}): {str(e)}", exc_info=True)
-
-def get_generation_result(request_id: str) -> Dict[str, Any]:
-    """获取生成结果"""
-    if request_id not in generation_results:
-        return {
-            "status": "not_found",
-            "error": f"找不到生成任务: {request_id}",
-            "timestamp": int(time.time())
-        }
-    
-    return generation_results[request_id]
-
-def get_task_api_key(request_id: str) -> Optional[str]:
-    """获取任务对应的API密钥"""
-    return task_to_api_key.get(request_id) 

sora-api-master/src/services/streaming.py

@@ -1,231 +0,0 @@
-import json
-import time
-import asyncio
-import logging
-from typing import AsyncGenerator, List, Dict, Any
-
-from ..sora_integration import SoraClient
-from ..config import Config
-from ..utils import localize_image_urls
-from .image_service import format_think_block
-
-logger = logging.getLogger("sora-api.streaming")
-
-async def generate_streaming_response(
-    sora_client: SoraClient,
-    prompt: str,
-    n_images: int = 1
-) -> AsyncGenerator[str, None]:
-    """
-    文本到图像的流式响应生成器
-    
-    Args:
-        sora_client: Sora客户端
-        prompt: 提示词
-        n_images: 生成图像数量
-    
-    Yields:
-        SSE格式的响应数据
-    """
-    request_id = f"chatcmpl-stream-{time.time()}-{hash(prompt) % 10000}"
-    
-    # 发送开始事件
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
-    
-    # 发送处理中的消息（放在代码块中）
-    start_msg = "```think\n正在生成图像，请稍候...\n"
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': start_msg}, 'finish_reason': None}]})}\n\n"
-    
-    # 创建一个后台任务来生成图像
-    logger.info(f"[流式响应 {request_id}] 开始生成图像, 提示词: {prompt}")
-    generation_task = asyncio.create_task(sora_client.generate_image(
-        prompt=prompt,
-        num_images=n_images,
-        width=720,
-        height=480
-    ))
-    
-    # 每5秒发送一条"仍在生成中"的消息，防止连接超时
-    progress_messages = [
-        "正在处理您的请求...",
-        "仍在生成图像中，请继续等待...",
-        "Sora正在创作您的图像作品...",
-        "图像生成需要一点时间，感谢您的耐心等待...",
-        "我们正在努力为您创作高质量图像..."
-    ]
-    
-    i = 0
-    while not generation_task.done():
-        # 每5秒发送一次进度消息
-        await asyncio.sleep(5)
-        progress_msg = progress_messages[i % len(progress_messages)]
-        i += 1
-        content = "\n" + progress_msg + "\n"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
-    
-    try:
-        # 获取生成结果
-        image_urls = await generation_task
-        logger.info(f"[流式响应 {request_id}] 图像生成完成，获取到 {len(image_urls) if isinstance(image_urls, list) else '非列表'} 个URL")
-        
-        # 本地化图片URL
-        if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
-            logger.info(f"[流式响应 {request_id}] 准备进行图片本地化处理")
-            try:
-                localized_urls = await localize_image_urls(image_urls)
-                image_urls = localized_urls
-                logger.info(f"[流式响应 {request_id}] 图片本地化处理完成")
-            except Exception as e:
-                logger.error(f"[流式响应 {request_id}] 图片本地化过程中发生错误: {str(e)}", exc_info=True)
-                logger.info(f"[流式响应 {request_id}] 由于错误，将使用原始URL")
-        elif not Config.IMAGE_LOCALIZATION:
-            logger.info(f"[流式响应 {request_id}] 图片本地化功能未启用")
-        
-        # 结束代码块
-        content_str = "\n```\n\n"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-        
-        # 添加生成的图片URLs
-        for i, url in enumerate(image_urls):
-            if i > 0:
-                content_str = "\n\n"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-            
-            image_markdown = f"![Generated Image]({url})"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
-        
-        # 发送完成事件
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
-        
-        # 发送结束标志
-        yield "data: [DONE]\n\n"
-        
-    except Exception as e:
-        error_msg = f"图像生成失败: {str(e)}"
-        logger.error(f"[流式响应 {request_id}] 错误: {error_msg}", exc_info=True)
-        error_content = f"\n{error_msg}\n```"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
-        yield "data: [DONE]\n\n"
-
-async def generate_streaming_remix_response(
-    sora_client: SoraClient,
-    prompt: str,
-    image_data: str,
-    n_images: int = 1
-) -> AsyncGenerator[str, None]:
-    """
-    图像到图像的流式响应生成器
-    
-    Args:
-        sora_client: Sora客户端
-        prompt: 提示词
-        image_data: Base64编码的图像数据
-        n_images: 生成图像数量
-    
-    Yields:
-        SSE格式的响应数据
-    """
-    import os
-    import tempfile
-    import uuid
-    import base64
-    
-    request_id = f"chatcmpl-stream-remix-{time.time()}-{hash(prompt) % 10000}"
-    
-    # 发送开始事件
-    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'role': 'assistant'}, 'finish_reason': None}]})}\n\n"
-    
-    try:
-        # 保存base64图片到临时文件
-        temp_dir = tempfile.mkdtemp()
-        temp_image_path = os.path.join(temp_dir, f"upload_{uuid.uuid4()}.png")
-        
-        try:
-            # 解码并保存图片
-            with open(temp_image_path, "wb") as f:
-                f.write(base64.b64decode(image_data))
-            
-            # 上传图片
-            upload_msg = "```think\n上传图片中...\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': upload_msg}, 'finish_reason': None}]})}\n\n"
-            
-            logger.info(f"[流式响应Remix {request_id}] 上传图片中")
-            upload_result = await sora_client.upload_image(temp_image_path)
-            media_id = upload_result['id']
-            
-            # 发送生成中消息
-            generate_msg = "\n基于图片生成新图像中...\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': generate_msg}, 'finish_reason': None}]})}\n\n"
-            
-            # 创建后台任务生成图像
-            logger.info(f"[流式响应Remix {request_id}] 开始生成图像，提示词: {prompt}")
-            generation_task = asyncio.create_task(sora_client.generate_image_remix(
-                prompt=prompt,
-                media_id=media_id,
-                num_images=n_images
-            ))
-            
-            # 每5秒发送一条"仍在生成中"的消息
-            progress_messages = [
-                "正在处理您的请求...",
-                "仍在生成图像中，请继续等待...",
-                "Sora正在基于您的图片创作新作品...",
-                "图像生成需要一点时间，感谢您的耐心等待...",
-                "正在融合您的风格和提示词，打造专属图像..."
-            ]
-            
-            i = 0
-            while not generation_task.done():
-                await asyncio.sleep(5)
-                progress_msg = progress_messages[i % len(progress_messages)]
-                i += 1
-                content = "\n" + progress_msg + "\n"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content}, 'finish_reason': None}]})}\n\n"
-            
-            # 获取生成结果
-            image_urls = await generation_task
-            logger.info(f"[流式响应Remix {request_id}] 图像生成完成")
-            
-            # 本地化图片URL
-            if Config.IMAGE_LOCALIZATION:
-                logger.info(f"[流式响应Remix {request_id}] 进行图片本地化处理")
-                localized_urls = await localize_image_urls(image_urls)
-                image_urls = localized_urls
-                logger.info(f"[流式响应Remix {request_id}] 图片本地化处理完成")
-            else:
-                logger.info(f"[流式响应Remix {request_id}] 图片本地化功能未启用")
-            
-            # 结束代码块
-            content_str = "\n```\n\n"
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': content_str}, 'finish_reason': None}]})}\n\n"
-            
-            # 发送图片URL作为Markdown
-            for i, url in enumerate(image_urls):
-                if i > 0:
-                    newline_str = "\n\n"
-                    yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': newline_str}, 'finish_reason': None}]})}\n\n"
-                
-                image_markdown = f"![Generated Image]({url})"
-                yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': image_markdown}, 'finish_reason': None}]})}\n\n"
-            
-            # 发送完成事件
-            yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {}, 'finish_reason': 'stop'}]})}\n\n"
-            
-            # 发送结束标志
-            yield "data: [DONE]\n\n"
-            
-        finally:
-            # 清理临时文件
-            if os.path.exists(temp_image_path):
-                os.remove(temp_image_path)
-            if os.path.exists(temp_dir):
-                os.rmdir(temp_dir)
-                
-    except Exception as e:
-        error_msg = f"图像Remix失败: {str(e)}"
-        logger.error(f"[流式响应Remix {request_id}] 错误: {error_msg}", exc_info=True)
-        error_content = f"\n{error_msg}\n```"
-        yield f"data: {json.dumps({'id': request_id, 'object': 'chat.completion.chunk', 'created': int(time.time()), 'model': 'sora-1.0', 'choices': [{'index': 0, 'delta': {'content': error_content}, 'finish_reason': 'error'}]})}\n\n"
-    
-    # 结束流
-    yield "data: [DONE]\n\n" 

sora-api-master/src/sora_generator.py

@@ -1,1145 +0,0 @@
-import cloudscraper
-import time
-import json
-import random
-import string
-import os
-import mimetypes # To guess file mime type
-import argparse # For better command-line arguments
-import asyncio
-from .utils import localize_image_urls
-from .config import Config
-
-class SoraImageGenerator:
-    def __init__(self, proxy_host=None, proxy_port=None, proxy_user=None, proxy_pass=None, auth_token=None):
-        # 使用Config.VERBOSE_LOGGING替代直接从环境变量读取SORA_DEBUG
-        self.DEBUG = Config.VERBOSE_LOGGING
-        
-        # 设置代理
-        if proxy_host and proxy_port:
-            # 如果有认证信息，添加到代理URL中
-            if proxy_user and proxy_pass:
-                proxy_auth = f"{proxy_user}:{proxy_pass}@"
-                self.proxies = {
-                    "http": f"http://{proxy_auth}{proxy_host}:{proxy_port}",
-                    "https": f"http://{proxy_auth}{proxy_host}:{proxy_port}"
-                }
-                if self.DEBUG:
-                    print(f"已配置带认证的代理: {proxy_user}:****@{proxy_host}:{proxy_port}")
-            else:
-                self.proxies = {
-                    "http": f"http://{proxy_host}:{proxy_port}",
-                    "https": f"http://{proxy_host}:{proxy_port}"
-                }
-                if self.DEBUG:
-                    print(f"已配置代理: {proxy_host}:{proxy_port}")
-        else:
-            self.proxies = None
-            if self.DEBUG:
-                print("代理未配置。请求将直接发送。")
-        # 创建 cloudscraper 实例
-        self.scraper = cloudscraper.create_scraper(
-            browser={
-                'browser': 'chrome',
-                'platform': 'windows',
-                'mobile': False
-            }
-        )
-        # 设置通用请求头 - 移除 Content-Type 和 openai-sentinel-token (会动态添加)
-        self.base_headers = {
-            "accept": "*/*",
-            "accept-language": "zh-CN,zh;q=0.9",
-            "cache-control": "no-cache",
-            "pragma": "no-cache",
-            "priority": "u=1, i",
-            "sec-ch-ua": "\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\"",
-            "sec-ch-ua-mobile": "?0",
-            "sec-ch-ua-platform": "\"Windows\"",
-            "sec-fetch-dest": "empty",
-            "sec-fetch-mode": "cors",
-            "sec-fetch-site": "same-origin",
-            # Referer 会根据操作不同设置
-        }
-        # 设置认证Token (从外部传入或硬编码)
-        self.auth_token = auth_token or "Bearer eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS92MSJdLCJjbGllbnRfaWQiOiJhcHBfWDh6WTZ2VzJwUTl0UjNkRTduSzFqTDVnSCIsImV4cCI6MTc0Nzk3MDExMSwiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS9hdXRoIjp7InVzZXJfaWQiOiJ1c2VyLWdNeGM0QmVoVXhmTW1iTDdpeUtqengxYiJ9LCJodHRwczovL2FwaS5vcGVuYWkuY29tL3Byb2ZpbGUiOnsiZW1haWwiOiIzajVtOTFud3VtckBmcmVlLnViby5lZHUuZ24iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZX0sImlhdCI6MTc0NzEwNjExMSwiaXNzIjoiaHR0cHM6Ly9hdXRoLm9wZW5haS5jb20iLCJqdGkiOiIzMGM4ZDJhOS0yNzkxLTRhNjQtODI2OS0yMzU3OGFhMmI0MTEiLCJuYmYiOjE3NDcxMDYxMTEsInB3ZF9hdXRoX3RpbWUiOjE3NDcxMDYxMDkxMDksInNjcCI6WyJvcGVuaWQiLCJlbWFpbCIsInByb2ZpbGUiLCJvZmZsaW5lX2FjY2VzcyIsIm1vZGVsLnJlcXVlc3QiLCJtb2RlbC5yZWFkIiwib3JnYW5pemF0aW9uLnJlYWQiLCJvcmdhbml6YXRpb24ud3JpdGUiXSwic2Vzc2lvbl9pZCI6ImF1dGhzZXNzX21yWFRwZlVENU51TDFsV05xNUhSOW9lYiIsInN1YiI6ImF1dGgwfDY4MjFkYWYyNjhiYjgxMzFkMDRkYTAwNCJ9.V4ZqYJuf_f7F_DrMMRrt-ymul5HUrqENVkiFyEwfYmzMFWthEGS6Ryia100QRlprw8jjGscHZXlUFaOcRNIarcBig8fBY6n_AB3J34MlcBv6peS-3_EJlIiH_N7j_mu-8lNpJbxk9lSlFaGpKU1IOO7kBuaAmLH-iErM-wqBfSlnnAq8h4iqBDxi4CMTcAhVm2-qG7u7f0Ho1TCGa7wrdchWtZxyfHIqNWkC88qBlUwTH5g2vRL419_zIKEWKyAtV2WNI68vpyBLrRVhtnpDh0jcrm2WqCj2X2LQqNFkFKoui3wCdG9Vskpl39l9sV54HuV7w6stQIausR1F4Y9NbjsBAyLIimZOllCwYAefTC2BOpIHfOA3_D58G3SEiRADVK7pK7ip6QsEI__GteoeCuRvZA9b5jLmhVS0SUlDYSOoNwlJ_ejfEpPJcmHUchFa7bUkS-XVrEUgr1yP5FxPwWUyn7UWrW_dZ3lVW1EU4Bp6Kp6JuwyOFf2Mj-V3_9tc8qJRClI8WHUf6In0hiO_pGbFCI2opkF3XusAQKmTB12nPBsmSlwewigTPhAj3nf-8Ze3O-etnBrV5pz_woIwQsQ54T-wgEdrLWDE6dSqNDulfpldF6Cok62212kW8w3SY3V7VSq5Tr1KRyWXJEH-haVb6qmAE2ldDjeHvJossWg" # 替换成你的有效Token或从环境变量读取
-        if not self.auth_token or not self.auth_token.startswith("Bearer "):
-            raise ValueError("无效或缺失的认证Token (应以 'Bearer ' 开头)")
-        self.gen_url = "https://sora.chatgpt.com/backend/video_gen"
-        self.check_url = "https://sora.chatgpt.com/backend/video_gen"
-        self.upload_url = "https://sora.chatgpt.com/backend/uploads"
-        
-        # 显示是否启用了图片本地化功能
-        if Config.IMAGE_LOCALIZATION:
-            if self.DEBUG:
-                print(f"图片本地化功能已启用，图片将保存到：{Config.IMAGE_SAVE_DIR}")
-            os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-    
-    def _get_dynamic_headers(self, content_type="application/json", referer="https://sora.chatgpt.com/explore"):
-        """为每个请求生成包含动态sentinel token的headers"""
-        headers = self.base_headers.copy()
-        headers["authorization"] = self.auth_token
-        headers["openai-sentinel-token"] = self._generate_sentinel_token()
-        headers["referer"] = referer
-        if content_type: # multipart/form-data 时 Content-Type 由 requests 自动设置
-            headers["content-type"] = content_type
-        return headers
-    
-    def _generate_sentinel_token(self):
-        """生成一个随机修改的sentinel-token"""
-        base_token = {
-            "p": "gAAAAABWzIxMjksIk1vbiBNYXkgMTIgMjAyNSAxODo1ODowOSBHTVQrMDgwMCAo5Lit5Zu95qCH5YeG5pe26Ze0KSIsMjI0ODE0Njk0NCw5LCJNb3ppbGxhLzUuMCAoV2luZG93cyBOVCAxMC4wOyBXaW42NDsgeDY0KSBBcHBsZVdlYktpdC81MzcuMzYgKEtIVE1MLCBsaWtlIEdlY2tvKSBDaHJvbWUvMTM2LjAuMC4wIFNhZmFyaS81MzcuMzYiLCJodHRwczovL3NvcmEtY2RuLm9haXN0YXRpYy5jb20vX25leHQvc3RhdGljL2NodW5rcy93ZWJwYWNrLWU1MDllMDk0N2RlZWM0Y2YuanMiLG51bGwsInpoLUNOIiwiemgtQ04semgiLDEwLCJwcm9kdWN0U3Vi4oiSMjAwMzAxMDciLCJfcmVhY3RMaXN0ZW5pbmd2cXAzdWtpNmh6IiwiX19zZW50aW5lbF9pbml0X3BlbmRpbmciLDEyMDczMzEuNSwiN2M4OTMxM2EtZTY0Mi00MjI4LTk5ZDQtNTRlZDRjYzQ3MGZiIiwiIiwxNl0=",
-            "t": "SBYdBBoGFhQRdVtbdxEYEQEaHQAAFhQRYwN2T2IEUH5pRHJyYx51YnJybFBhWHZkYgRyUHgDclZzH2l5a1gXUWVlcRMRGBEBHR0HBBYUEXpnfVt9YFAJDB8WAAIAAgYRDgxpYltjSl55SWJEZV9mXx4KFh8WGAAaBxYUEXVydW9ydXJ1b3J1cnVvcnVydW9ydXJ1b3J1b3J1b3J1b3J1DgkMHxYBAgALAxEOHh0BBwIXCwwEBx8FAwADGwAAHxYcBxoFDQwJFnFDEw4WHxYXBxoCBwwJFmB2dGRxYgBqdHVLf2hUX3VySWpVcVNNa3ZiYW13dgtyb3J5cHxvam12YWB7YgN2THVcYnxsSwR7fH9mfHJlZ1F3VARtcVwLcGpiV2pwaEdmZFhgdGZLbWRxXAdQbHJ5dHNvanlwQ29Xd1QEZnFmXFJoWFBRbEZ2e3JTWVF8YnFvd2ZUd2xiR3Vzb1BxcWV3UXxLbmxrYV9Wf3FxfHNJclVydU1qdXJtaHJmUH9sYnF1fElcdXtMdH5sdnZmZAR+ZmpUcXZzVgN2cUN3UHZyZWhyXAd8bHJ5cnVGdW1lWGRScWIAamBlDgkMHxYKBgADDREODHZjcWx/AnIBZkJLV2FTRWZWZX5Pa2JHVWsDbmRie1xgYXFoUWxfbmlhBQJ4f3FmUGFJBnNkWEphZ3VET2VYcntpA25kYntDVWRYf2Z3ZXZ9Vl9hXXZ1RGZseENzZnJ3Z3YCdn1WX2FddnVEZmx4Q3NmcndkFh8WFwAaBAUMCRZrcnh7fF92T2Z1eXx2dW5pZ1YKXGIFRnFhX3ZAZmJLUXwAfmtgeGlxYQVoeFdYdU1iYgJjfFsBAVJ7YUxrB1ZDVUR+fGthcXN4ZkRrbH9lWmtsG0FiAkdIZHFXZnxffnRiVgZsa3JeUmVlQEhhQ31ybFsNZ2VCS2NmWEZFZlhMWWQEcWJ2ZWZdZx5XdWRYXnllcVxJanMKWnQARElXdgoDUHx4WlZ0UEBWB0tNTQBuQW4dAlNXWXRUV11cXWkHQwx0XW5BUW9QbWVyRnFhZWJIVwR1UHtfRGdSeGl1YQUfcmJ2V0h3Zgd4bFR9cWdCUHFmZU1qd199amVDeQx5X3JRYB51ZWRYXnlSZHJcdAVHdXtmcWlWaXFwV1hGXlB0Q2hlX1dQf2V+fWB7cndqcl5YUF92TXRxV3V3AkBXY0JpbWRfSlJ8AgVLZGFHdnwCRHBnHFdzZlheV2wCYmZmbAZjfF9iUWxoBmJrYkp/UAJiZmVleXB4ZWZhdR9HYmJ2Qn5iX3JKdGFbV3xfdmF1HnVmZWF0f2V1THlmdXlTd3t+VFJ2Q05RfEZbV3tiAVIHAlpLAXICVXZpRmpzbEVXa1wcUgZXBwxO",
-            "c": "gAAAAABoIdRAZEk6qAnDRqdimKxPhXtA_xBkiDXhKF4LUmlNY6CZmfNxZiabjPHk_DCEUnnyq-y6JPj-D46YPk-6r7zR6qS64hEwGYt9Hh_8vUIod-7PLh9qPKqdYl4TBCVUgtrbhTWfse7s6NHCSy1T0Nzj2C6vAUPhzAx4LAMIrl2YbElkUVPgwELyYF_inh3zliwZL-zp4zR3LOABcrGqlrLoP7_kNrwcIZwlVD1RNlnHy9TEFsRzYOMQo_DbagZAK1h87arrMonZHBi9ukfiGuvCQP-y76j61b4qaQPMA19EoURLwnotVBWUIBpHEEoH9vmPb817sGwQ2R8XHoAVR4dwYs_7EoS8H8kAlUVZDjAKGq5x48nvZrarLBjYJXXsfJLuxhibNYXG1hKNbOdi1w-Xl1NgqSPAb-MuwnyDLPGE5MeLkwM2Dl3jD7G6B2Z2F993cvW7mOOs0OebZ6NMgIrZnTG4mMI7PirPY95JWmztDfeuFLJ_V_kyaSP--BZCIIAB4074RBVitIrJEwceWVW3zXOOHWJoDax7E0nfa5abvLGCjdEeJfNx4Fcp7iYFN_E8iR0f797DLlFh4uFLv1DPhipYtQFpPPUlbxKu9H9W4IDr7Hv_LgfvFo0VwLzV6ANZPGmdza67dAsKXrWtXlCrVNfqFoVO4wI4n-zrE3lcUPzI_ZJebF2HGlzerTvqgU5R0i4fzUGY4-UqpWlVurP-rCJY2ARcSMSyPXnPGetl5Z2m-f9k7K3n7txrfv2293jyyRTVAZLC9aLrBOFWHD4cf0aiwisgJ9IKnhhnoJ-WF8NuvFS7l1Z0d2zTnndjuryb0M36Og4b_Ku3aJKS0_Eqbns8_bUXdEPh5_15T_92_1yf5jy-amrgolgcO_7yJqX5aU9-PUUiaP3WzeyidMSH4Vtls63tQ5evUlDkEHfNKoyCYaSxpzA_FsNmPbMmcv3g1wNKg_W8V0Yh7ZrtW1L8229SpZFWc96Sg3CRPplk-dnVzV93lP7cN5o5ubGWZMkkz5UASjE5XLn8h5dx6neuOemKVHAj29QxOWmdGEehNvmeMec0k8uL9X-7yYBJSTnI066OR38JUUTFqTH3RSXI9M4ggals32P56bwUmawvZ-bu02qc3kCVI3oK9bnP8oTk0xTK5_bMrlevGYKG0qdPXamgdDfVg7hlNA2OTCnw6iRP6DJiPm_zKVdQa4z6SPJsdt_Q",
-            "id": self._generate_random_id(),
-            "flow": "sora_create_task" # This might need changing for uploads? Let's try keeping it.
-        }
-        # Simple randomization (can be improved if needed)
-        p_chars = list(base_token["p"])
-        for _ in range(random.randint(3, 7)):
-            pos = random.randint(10, len(p_chars) - 10)
-            p_chars[pos] = random.choice(string.ascii_letters + string.digits + "+/=")
-        base_token["p"] = "".join(p_chars)
-        c_chars = list(base_token["c"])
-        for _ in range(random.randint(3, 7)):
-            pos = random.randint(10, len(c_chars) - 10)
-            c_chars[pos] = random.choice(string.ascii_letters + string.digits + "+/=_-")
-        base_token["c"] = "".join(c_chars)
-        return json.dumps(base_token)
-    
-    def _generate_random_id(self):
-        """生成一个随机ID，格式类似于UUID"""
-        return f"{self._random_hex(8)}-{self._random_hex(4)}-{self._random_hex(4)}-{self._random_hex(4)}-{self._random_hex(12)}"
-    
-    def _random_hex(self, length):
-        """生成指定长度的随机十六进制字符串"""
-        return ''.join(random.choice(string.hexdigits.lower()) for _ in range(length))
-    
-    def generate_image(self, prompt, num_images=1, width=720, height=480):
-        """
-        生成一张或多张图片并返回图片URL列表
-        参数:
-        prompt (str): 图片生成提示词
-        num_images (int): 要生成的图片数量 (对应 n_variants)
-        width (int): 图片宽度
-        height (int): 图片高度
-        返回:
-        list[str] or str: 成功时返回包含图片URL的列表，失败时返回错误信息字符串
-        """
-        # 确保提示词是正确的UTF-8格式
-        if isinstance(prompt, bytes):
-            prompt = prompt.decode('utf-8')
-        
-        # 打印提示词，并处理可能的编码问题
-        try:
-            if self.DEBUG:
-                print(f"开始生成 {num_images} 张图片，提示词: '{prompt}'")
-        except UnicodeEncodeError:
-            if self.DEBUG:
-                print(f"开始生成 {num_images} 张图片，提示词: [编码显示问题，但数据正确]")
-        
-        payload = {
-            "type": "image_gen",
-            "operation": "simple_compose",
-            "prompt": prompt,
-            "n_variants": num_images, # 使用传入的数量
-            "width": width,
-            "height": height,
-            "n_frames": 1,
-            "inpaint_items": []
-        }
-        try:
-            task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/explore")
-            if not task_id:
-                # 任务提交失败，尝试切换密钥后重试
-                if self.DEBUG:
-                    print(f"任务提交失败，尝试切换API密钥后重试")
-                
-                try:
-                    # 导入在这里进行以避免循环导入
-                    from .key_manager import key_manager
-                    # 标记当前密钥为无效并获取新密钥
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试任务")
-                        # 使用新密钥重试提交任务
-                        task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/explore")
-                        if not task_id:
-                            return "任务提交失败（已尝试切换密钥）"
-                    else:
-                        return "任务提交失败（无可用的备用密钥）"
-                except ImportError:
-                    if self.DEBUG:
-                        print(f"无法导入key_manager，无法自动切换密钥")
-                    return "任务提交失败"
-                except Exception as e:
-                    if self.DEBUG:
-                        print(f"切换API密钥时发生错误: {str(e)}")
-                    return f"任务提交失败: {str(e)}"
-            
-            if self.DEBUG:
-                print(f"任务已提交，ID: {task_id}")
-            # 轮询检查任务状态，直到完成
-            image_urls = self._poll_task_status(task_id)
-            
-            # 如果轮询返回错误信息，也尝试切换密钥重试
-            if isinstance(image_urls, str) and ("失败" in image_urls or "错误" in image_urls or "error" in image_urls.lower()):
-                if self.DEBUG:
-                    print(f"任务执行失败，尝试切换API密钥后重试")
-                
-                try:
-                    from .key_manager import key_manager
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试整个生成过程")
-                        # 使用新密钥重试整个生成过程
-                        return self.generate_image(prompt, num_images, width, height)
-                except (ImportError, Exception) as e:
-                    if self.DEBUG:
-                        print(f"切换API密钥失败或重试失败: {str(e)}")
-            
-            # 图片本地化处理
-            if Config.IMAGE_LOCALIZATION and isinstance(image_urls, list) and image_urls:
-                if self.DEBUG:
-                    print(f"\n================================")
-                    print(f"开始图片本地化处理")
-                    print(f"图片本地化配置: 启用={Config.IMAGE_LOCALIZATION}, 保存目录={Config.IMAGE_SAVE_DIR}")
-                    print(f"需要本地化的图片数量: {len(image_urls)}")
-                    print(f"原始图片URLs: {image_urls}")
-                    print(f"================================\n")
-                
-                try:
-                    # 创建事件循环并运行图片本地化
-                    if self.DEBUG:
-                        print(f"创建异步事件循环处理图片下载...")
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                    
-                    if self.DEBUG:
-                        print(f"调用localize_image_urls函数...")
-                    localized_urls = loop.run_until_complete(localize_image_urls(image_urls))
-                    loop.close()
-                    if self.DEBUG:
-                        print(f"异步事件循环已关闭")
-                    
-                    if self.DEBUG:
-                        print(f"\n================================")
-                        print(f"图片本地化完成")
-                        print(f"原始URLs: {image_urls}")
-                        print(f"本地化后的URLs: {localized_urls}")
-                        print(f"================================\n")
-                    
-                    # 检查结果是否有效
-                    if not localized_urls:
-                        if self.DEBUG:
-                            print(f"❌ 警告：本地化后的URL列表为空，将使用原始URL")
-                        return image_urls
-                        
-                    # 检查是否所有URL都被正确本地化
-                    local_count = sum(1 for url in localized_urls if url.startswith("/static/") or "/static/" in url)
-                    if local_count == 0:
-                        if self.DEBUG:
-                            print(f"❌ 警告：没有一个URL被成功本地化，将使用原始URL")
-                        return image_urls
-                    elif local_count < len(localized_urls):
-                        if self.DEBUG:
-                            print(f"⚠️ 注意：部分URL未成功本地化 ({local_count}/{len(localized_urls)})")
-                        
-                    return localized_urls
-                except Exception as e:
-                    if self.DEBUG:
-                        print(f"❌ 图片本地化过程中发生错误: {str(e)}")
-                    import traceback
-                    traceback.print_exc()
-                    if self.DEBUG:
-                        print(f"由于错误，将返回原始URL")
-                    return image_urls
-            elif not Config.IMAGE_LOCALIZATION:
-                if self.DEBUG:
-                    print(f"图片本地化功能未启用，返回原始URLs")
-            elif not isinstance(image_urls, list):
-                if self.DEBUG:
-                    print(f"图片生成返回了非列表结果: {image_urls}，无法进行本地化")
-            elif not image_urls:
-                if self.DEBUG:
-                    print(f"图片生成返回了空列表，没有可本地化的内容")
-            
-            return image_urls
-        except Exception as e:
-            if self.DEBUG:
-                print(f"❌ 生成图片时出错: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            return f"生成图片时出错: {str(e)}"
-    
-    def upload_image(self, file_path):
-        """
-        上传本地图片文件到Sora后端
-        参数:
-        file_path (str): 本地图片文件的路径
-        返回:
-        dict or str: 成功时返回包含上传信息的字典，失败时返回错误信息字符串
-        """
-        if not os.path.exists(file_path):
-            return f"错误：文件未找到 '{file_path}'"
-        file_name = os.path.basename(file_path)
-        mime_type, _ = mimetypes.guess_type(file_path)
-        if not mime_type or not mime_type.startswith('image/'):
-            return f"错误：无法确定文件类型或文件不是图片 '{file_path}' (Mime: {mime_type})"
-        if self.DEBUG:
-            print(f"开始上传图片: {file_name} (Type: {mime_type})")
-        # multipart/form-data 请求不需要手动设置 Content-Type header
-        # requests 会根据 files 参数自动处理 boundary 和 Content-Type
-        headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library") # Referer from example
-        
-        # 尝试上传
-        return self._try_upload_with_retry(file_path, file_name, mime_type, headers)
-    
-    def _try_upload_with_retry(self, file_path, file_name, mime_type, headers, is_retry=False):
-        """尝试上传图片，失败时可能尝试切换密钥重试"""
-        # 保存当前的API密钥，确保整个上传过程使用相同的密钥
-        current_auth_token = self.auth_token
-        
-        files = {
-            'file': (file_name, open(file_path, 'rb'), mime_type),
-            'file_name': (None, file_name) # 第二个字段是文件名
-        }
-        try:
-            response = self.scraper.post(
-                self.upload_url,
-                headers=headers,
-                files=files, # 使用 files 参数上传文件
-                proxies=self.proxies,
-                timeout=60 # 上传可能需要更长时间
-            )
-            if response.status_code == 200:
-                result = response.json()
-                if self.DEBUG:
-                    print(f"图片上传成功! Media ID: {result.get('id')}")
-                # 确保返回的结果中包含上传时使用的API密钥信息
-                result['used_auth_token'] = current_auth_token
-                # print(f"上传响应: {json.dumps(result, indent=2)}") # 可选：打印完整响应
-                return result # 返回包含id, url等信息的字典
-            else:
-                error_msg = f"上传图片失败，状态码: {response.status_code}, 响应: {response.text}"
-                if self.DEBUG:
-                    print(error_msg)
-                
-                # 如果不是已经在重试，且响应表明可能是API密钥问题，尝试切换密钥
-                if not is_retry and (response.status_code in [401, 403] or "auth" in response.text.lower() or "token" in response.text.lower()):
-                    if self.DEBUG:
-                        print(f"上传失败可能与API密钥有关，尝试切换密钥后重试")
-                    
-                    try:
-                        from .key_manager import key_manager
-                        new_key = key_manager.mark_key_invalid(self.auth_token)
-                        if new_key:
-                            self.auth_token = new_key
-                            if self.DEBUG:
-                                print(f"已切换到新的API密钥，重试上传")
-                            # 更新头部信息并重试
-                            new_headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library")
-                            return self._try_upload_with_retry(file_path, file_name, mime_type, new_headers, is_retry=True)
-                    except (ImportError, Exception) as e:
-                        if self.DEBUG:
-                            print(f"切换API密钥失败: {str(e)}")
-                
-                return error_msg
-        except Exception as e:
-            error_msg = f"上传图片时出错: {str(e)}"
-            if self.DEBUG:
-                print(error_msg)
-            
-            # 如果不是已经在重试，尝试切换密钥后重试
-            if not is_retry:
-                if self.DEBUG:
-                    print(f"上传过程中发生异常，尝试切换API密钥后重试")
-                
-                try:
-                    from .key_manager import key_manager
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试上传")
-                        # 更新头部信息并重试
-                        new_headers = self._get_dynamic_headers(content_type=None, referer="https://sora.chatgpt.com/library")
-                        return self._try_upload_with_retry(file_path, file_name, mime_type, new_headers, is_retry=True)
-                except (ImportError, Exception) as err:
-                    if self.DEBUG:
-                        print(f"切换API密钥失败: {str(err)}")
-            
-            return error_msg
-        finally:
-            # 确保文件句柄被关闭
-            if 'file' in files and files['file'][1]:
-                files['file'][1].close()
-    
-    def generate_image_remix(self, prompt, uploaded_media_id, num_images=1, width=None, height=None):
-        """
-        基于已上传的图片进行重混（Remix）生成新图片
-        参数:
-        prompt (str): 图片生成提示词
-        uploaded_media_id (str): 通过 upload_image 获取的媒体ID (例如 "media_...")
-        num_images (int): 要生成的图片数量
-        width (int, optional): 输出图片宽度。如果为None，可能由API决定。
-        height (int, optional): 输出图片高度。如果为None，可能由API决定。
-        返回:
-        list[str] or str: 成功时返回包含图片URL的列表，失败时返回错误信息字符串
-        """
-        if self.DEBUG:
-            print(f"开始 Remix 图片 (ID: {uploaded_media_id})，提示词: '{prompt}'")
-            
-        # 如果上传图片时使用了特定API密钥，则确保使用同一个密钥进行remix
-        # 在upload_image的返回结果中可能包含used_auth_token
-        if isinstance(uploaded_media_id, dict) and 'id' in uploaded_media_id:
-            if 'used_auth_token' in uploaded_media_id and uploaded_media_id['used_auth_token'] != self.auth_token:
-                if self.DEBUG:
-                    print(f"检测到上传图片时使用了不同的API密钥，切换到匹配的密钥进行Remix操作")
-                self.auth_token = uploaded_media_id['used_auth_token']
-            uploaded_media_id = uploaded_media_id['id']
-        
-        # 获取上传图片的信息，特别是原始尺寸，如果未指定输出尺寸则可能需要
-        # (这里简化，假设API能处理尺寸或���们强制指定)
-        # 实际应用中可能需要先查询 media_id 的详情
-        payload = {
-            "prompt": prompt,
-            "n_variants": num_images,
-            "inpaint_items": [
-                {
-                    "type": "image",
-                    "frame_index": 0,
-                    "preset_id": None,
-                    "generation_id": None,
-                    "upload_media_id": uploaded_media_id, # 关键：引用上传的图片
-                    "source_start_frame": 0,
-                    "source_end_frame": 0,
-                    "crop_bounds": None
-                }
-            ],
-            "operation": "remix", # 关键：操作类型
-            "type": "image_gen",
-            "n_frames": 1,
-            "width": 720, # 可选，如果为None，API可能会基于输入调整
-            "height": 480 # 可选
-        }
-        # 只有当width和height都提供了值时才添加到payload中
-        if width is not None:
-            payload["width"] = width
-        if height is not None:
-            payload["height"] = height
-        try:
-            # 提交任务时使用 library 作为 referer，与示例一致
-            task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/library")
-            if not task_id:
-                # 任务提交失败，尝试切换密钥后重试
-                if self.DEBUG:
-                    print(f"Remix任务提交失败，尝试切换API密钥后重试")
-                
-                try:
-                    # 导入在这里进行以避免循环导入
-                    from .key_manager import key_manager
-                    # 标记当前密钥为无效并获取新密钥
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试Remix任务")
-                        # 使用新密钥重试提交任务
-                        task_id = self._submit_task(payload, referer="https://sora.chatgpt.com/library")
-                        if not task_id:
-                            return "Remix任务提交失败（已尝试切换密钥）"
-                    else:
-                        return "Remix任务提交失败（无可用的备用密钥）"
-                except ImportError:
-                    if self.DEBUG:
-                        print(f"无法导入key_manager，无法自动切换密钥")
-                    return "Remix任务提交失败"
-                except Exception as e:
-                    if self.DEBUG:
-                        print(f"切换API密钥时发生错误: {str(e)}")
-                    return f"Remix任务提交失败: {str(e)}"
-            
-            if self.DEBUG:
-                print(f"Remix 任务已提交，ID: {task_id}")
-            # 轮询检查任务状态
-            image_urls = self._poll_task_status(task_id)
-            
-            # 如果轮询返回错误信息，也尝试切换密钥重试
-            if isinstance(image_urls, str) and ("失败" in image_urls or "错误" in image_urls or "error" in image_urls.lower()):
-                if self.DEBUG:
-                    print(f"Remix任务执行失败，尝试切换API密钥后重试")
-                
-                try:
-                    from .key_manager import key_manager
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试整个Remix过程")
-                        # 使用新密钥重试整个生成过程
-                        return self.generate_image_remix(prompt, uploaded_media_id, num_images, width, height)
-                except (ImportError, Exception) as e:
-                    if self.DEBUG:
-                        print(f"切换API密钥失败或重试失败: {str(e)}")
-            
-            # 增加图片本地化支持
-            if image_urls and isinstance(image_urls, list):
-                if Config.IMAGE_LOCALIZATION:
-                    if self.DEBUG:
-                        print(f"正在本地化 Remix 生成的 {len(image_urls)} 张图片...")
-                    # 创建事件循环并运行图片本地化
-                    loop = asyncio.new_event_loop()
-                    asyncio.set_event_loop(loop)
-                    localized_urls = loop.run_until_complete(localize_image_urls(image_urls))
-                    loop.close()
-                    
-                    if self.DEBUG:
-                        print(f"Remix 图片本地化完成")
-                    return localized_urls
-            
-            return image_urls
-        except Exception as e:
-            # 如果发生异常，也尝试切换密钥重试
-            if self.DEBUG:
-                print(f"Remix生成过程中发生异常: {str(e)}，尝试切换API密钥")
-            
-            try:
-                from .key_manager import key_manager
-                new_key = key_manager.mark_key_invalid(self.auth_token)
-                if new_key:
-                    self.auth_token = new_key
-                    if self.DEBUG:
-                        print(f"已切换到新的API密钥，重试整个Remix过程")
-                    # 使用新密钥重试整个生成过程
-                    return self.generate_image_remix(prompt, uploaded_media_id, num_images, width, height)
-            except (ImportError, Exception) as err:
-                if self.DEBUG:
-                    print(f"切换API密钥失败或重试失败: {str(err)}")
-            
-            return f"Remix 生成图片时出错: {str(e)}"
-
-    def _submit_task(self, payload, referer="https://sora.chatgpt.com/explore"):
-        """提交生成任务 (通用，接受payload字典)"""
-        headers = self._get_dynamic_headers(content_type="application/json", referer=referer)
-        
-        # 获取当前的auth_token用于最后可能的释放
-        current_auth_token = self.auth_token
-        
-        try:
-            # 检查是否可以导入key_manager并标记密钥为工作中
-            try:
-                from .key_manager import key_manager
-                # 生成一个临时任务ID，用于标记密钥工作状态
-                temp_task_id = f"pending_task_{self._generate_random_id()}"
-                key_manager.mark_key_as_working(self.auth_token, temp_task_id)
-            except ImportError:
-                if self.DEBUG:
-                    print(f"无法导入key_manager，无法标记密钥工作状态")
-            except Exception as e:
-                if self.DEBUG:
-                    print(f"标记密钥工作状态时发生错误: {str(e)}")
-                
-            response = self.scraper.post(
-                self.gen_url,
-                headers=headers,
-                json=payload,
-                proxies=self.proxies,
-                timeout=20 # 增加超时时间
-            )
-            if response.status_code == 200:
-                try:
-                    result = response.json()
-                    task_id = result.get("id")
-                    if task_id:
-                        # 更新任务ID为实际分配的ID
-                        try:
-                            from .key_manager import key_manager
-                            # 更新工作中状态的任务ID
-                            key_manager.release_key(self.auth_token)  # 先释放临时ID
-                            key_manager.mark_key_as_working(self.auth_token, task_id)  # 用真实ID重新标记
-                            if self.DEBUG:
-                                print(f"已将密钥标记为工作中，任务ID: {task_id}")
-                        except (ImportError, Exception) as e:
-                            if self.DEBUG:
-                                print(f"更新密钥工作状态时发生错误: {str(e)}")
-                        
-                        return task_id
-                    else:
-                        # 任务提交成功但未返回ID，释放密钥
-                        try:
-                            from .key_manager import key_manager
-                            key_manager.release_key(self.auth_token)
-                            if self.DEBUG:
-                                print(f"任务提交未返回ID，已释放密钥")
-                        except (ImportError, Exception) as e:
-                            if self.DEBUG:
-                                print(f"释放密钥时发生错误: {str(e)}")
-                        
-                        # 检查响应中是否有可能表明API密钥问题的信息
-                        response_text = response.text.lower()
-                        is_auth_issue = False
-                        auth_keywords = ["authorization", "auth", "token", "permission", "unauthorized", "credentials", "login"]
-                        
-                        for keyword in auth_keywords:
-                            if keyword in response_text:
-                                is_auth_issue = True
-                                break
-                        
-                        if is_auth_issue:
-                            if self.DEBUG:
-                                print(f"API响应内容表明可能存在认证问题，尝试切换密钥")
-                            
-                            try:
-                                from .key_manager import key_manager
-                                new_key = key_manager.mark_key_invalid(self.auth_token)
-                                if new_key:
-                                    self.auth_token = new_key
-                                    if self.DEBUG:
-                                        print(f"已切换到新的API密钥，重试请求")
-                                    # 使用新密钥重试请求
-                                    return self._submit_task(payload, referer)
-                            except ImportError:
-                                if self.DEBUG:
-                                    print(f"无法导入key_manager，无法自动切换密钥")
-                            except Exception as e:
-                                if self.DEBUG:
-                                    print(f"切换API密钥时发生错误: {str(e)}")
-                        
-                        if self.DEBUG:
-                            print(f"提交任务成功，但响应中未找到任务ID。响应: {response.text}")
-                        return None
-                except json.JSONDecodeError:
-                    # 释放密钥
-                    try:
-                        from .key_manager import key_manager
-                        key_manager.release_key(self.auth_token)
-                        if self.DEBUG:
-                            print(f"JSON解析失败，已释放密钥")
-                    except (ImportError, Exception) as e:
-                        if self.DEBUG:
-                            print(f"释放密钥时发生错误: {str(e)}")
-                            
-                    if self.DEBUG:
-                        print(f"提交任务成功，但无法解析响应JSON。状态码: {response.status_code}, 响应: {response.text}")
-                    return None
-            else:
-                # 释放密钥
-                try:
-                    from .key_manager import key_manager
-                    key_manager.release_key(self.auth_token)
-                    if self.DEBUG:
-                        print(f"请求失败，已释放密钥")
-                except (ImportError, Exception) as e:
-                    if self.DEBUG:
-                        print(f"释放密钥时发生错误: {str(e)}")
-                
-                if self.DEBUG:
-                    print(f"提交任务失败，状态码: {response.status_code}")
-                if self.DEBUG:
-                    print(f"请求Payload: {json.dumps(payload)}")
-                if self.DEBUG:
-                    print(f"响应内容: {response.text}")
-                
-                # 特殊处理429错误（太多并发任务）
-                if response.status_code == 429:
-                    response_text = response.text.lower()
-                    is_concurrent_issue = (
-                        "concurrent" in response_text or 
-                        "too many" in response_text or 
-                        "wait" in response_text or
-                        "progress" in response_text
-                    )
-                    
-                    if is_concurrent_issue:
-                        if self.DEBUG:
-                            print(f"检测到并发限制错误，当前密钥正在处理其他任务，获取新密钥但不禁用当前密钥")
-                        try:
-                            from .key_manager import key_manager
-                            # 不标记为无效，但获取一个新的可用密钥
-                            new_key = key_manager.get_key()
-                            if new_key:
-                                self.auth_token = new_key
-                                if self.DEBUG:
-                                    print(f"已获取新的API密钥，重试请求")
-                                # 使用新密钥重试请求
-                                return self._submit_task(payload, referer)
-                            else:
-                                if self.DEBUG:
-                                    print(f"没有可用的备用密钥")
-                        except (ImportError, Exception) as e:
-                            if self.DEBUG:
-                                print(f"获取新密钥时发生错误: {str(e)}")
-                        return None
-                
-                # 检查是否是认证失败（401/403）或其他可能表明API密钥失效的情况
-                response_text = response.text.lower()
-                is_auth_issue = (
-                    response.status_code in [401, 403] or
-                    "authorization" in response_text or
-                    "auth" in response_text or
-                    "token" in response_text or
-                    "permission" in response_text or
-                    "unauthorized" in response_text or
-                    "credentials" in response_text or
-                    "login" in response_text or
-                    "invalid" in response_text
-                ) and not (
-                    # 排除并发限制导致的错误
-                    "concurrent" in response_text or 
-                    "too many" in response_text or 
-                    "wait" in response_text or
-                    "progress" in response_text
-                )
-                
-                if is_auth_issue:
-                    if self.DEBUG:
-                        print(f"API密钥可能已失效，尝试切换密钥")
-                    
-                    try:
-                        # 导入在这里进行以避免循环导入
-                        from .key_manager import key_manager
-                        # 标记当前密钥为无效并获取新密钥
-                        new_key = key_manager.mark_key_invalid(self.auth_token)
-                        if new_key:
-                            self.auth_token = new_key
-                            if self.DEBUG:
-                                print(f"已切换到新的API密钥，重试请求")
-                            # 使用新密钥重试请求
-                            return self._submit_task(payload, referer)
-                    except ImportError:
-                        if self.DEBUG:
-                            print(f"无法导入key_manager，无法自动切换密钥")
-                    except Exception as e:
-                        if self.DEBUG:
-                            print(f"切换API密钥时发生错误: {str(e)}")
-                            
-                return None
-        except Exception as e:
-            # 确保释放密钥
-            try:
-                from .key_manager import key_manager
-                key_manager.release_key(current_auth_token)
-                if self.DEBUG:
-                    print(f"发生异常，已释放密钥")
-            except (ImportError, Exception) as release_err:
-                if self.DEBUG:
-                    print(f"释放密钥时发生错误: {str(release_err)}")
-                
-            if self.DEBUG:
-                print(f"提交任务时出错: {str(e)}")
-            
-            # 检查异常信息中是否包含可能的认证问题
-            error_str = str(e).lower()
-            is_auth_issue = (
-                "authorization" in error_str or
-                "auth" in error_str or
-                "token" in error_str or
-                "permission" in error_str or
-                "unauthorized" in error_str or
-                "credentials" in error_str or
-                "login" in error_str
-            )
-            
-            if is_auth_issue:
-                if self.DEBUG:
-                    print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
-                
-                try:
-                    from .key_manager import key_manager
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试请求")
-                        # 使用新密钥重试请求
-                        return self._submit_task(payload, referer)
-                except (ImportError, Exception) as err:
-                    if self.DEBUG:
-                        print(f"切换API密钥失败: {str(err)}")
-            
-            return None
-            
-    def _poll_task_status(self, task_id, max_attempts=40, interval=5):
-        """
-        轮询检查任务状态，直到完成，返回所有生成的图片URL列表
-        """
-        # 保存当前使用的密钥，确保最后可以正确释放
-        current_auth_token = self.auth_token
-        
-        if self.DEBUG:
-            print(f"开始轮询任务 {task_id} 的状态...")
-        try:
-            for attempt in range(max_attempts):
-                try:
-                    headers = self._get_dynamic_headers(referer="https://sora.chatgpt.com/library") # Polling often happens from library view
-                    query_url = f"{self.check_url}?limit=10" # 获取最近的任务，减少数据量
-                    response = self.scraper.get(
-                        query_url,
-                        headers=headers,
-                        proxies=self.proxies,
-                        timeout=15
-                    )
-                    if response.status_code == 200:
-                        try:
-                            result = response.json()
-                            task_responses = result.get("task_responses", [])
-                            # 查找对应的任务
-                            for task in task_responses:
-                                if task.get("id") == task_id:
-                                    status = task.get("status")
-                                    if self.DEBUG:
-                                        print(f"  任务 {task_id} 状态: {status} (尝试 {attempt+1}/{max_attempts})")
-                                    if status == "succeeded":
-                                        # 任务成功完成，释放密钥
-                                        try:
-                                            from .key_manager import key_manager
-                                            key_manager.release_key(current_auth_token)
-                                            if self.DEBUG:
-                                                print(f"任务成功完成，已释放密钥")
-                                        except (ImportError, Exception) as e:
-                                            if self.DEBUG:
-                                                print(f"释放密钥时发生错误: {str(e)}")
-                                                
-                                        generations = task.get("generations", [])
-                                        image_urls = []
-                                        if generations:
-                                            for gen in generations:
-                                                url = gen.get("url")
-                                                if url:
-                                                    image_urls.append(url)
-                                        if image_urls:
-                                            if self.DEBUG:
-                                                print(f"任务 {task_id} 成功完成！找到 {len(image_urls)} 张图片。")
-                                            return image_urls
-                                        else:
-                                            if self.DEBUG:
-                                                print(f"任务 {task_id} 状态为 succeeded，但在响应中未找到有效的图片URL。")
-                                            if self.DEBUG:
-                                                print(f"任务详情: {json.dumps(task, indent=2)}")
-                                            return "任务成功但未找到图片URL"
-                                    elif status == "failed":
-                                        # 任务失败，释放密钥
-                                        try:
-                                            from .key_manager import key_manager
-                                            key_manager.release_key(current_auth_token)
-                                            if self.DEBUG:
-                                                print(f"任务失败，已释放密钥")
-                                        except (ImportError, Exception) as e:
-                                            if self.DEBUG:
-                                                print(f"释放密钥时发生错误: {str(e)}")
-                                                
-                                        failure_reason = task.get("failure_reason", "未知原因")
-                                        if self.DEBUG:
-                                            print(f"任务 {task_id} 失败: {failure_reason}")
-                                        # 检查是否是因为API密钥问题导致的失败
-                                        failure_reason_lower = failure_reason.lower()
-                                        auth_keywords = [
-                                            "authorization", "auth", "token", "permission", 
-                                            "unauthorized", "credentials", "login", "invalid"
-                                        ]
-                                        is_auth_issue = any(keyword in failure_reason_lower for keyword in auth_keywords)
-                                        
-                                        if is_auth_issue:
-                                            if self.DEBUG:
-                                                print(f"检测到API密钥可能失效，尝试切换密钥")
-                                            try:
-                                                # 导入在这里进行以避免循环导入
-                                                from .key_manager import key_manager
-                                                # 标记当前密钥为无效并获取新密钥
-                                                new_key = key_manager.mark_key_invalid(self.auth_token)
-                                                if new_key:
-                                                    self.auth_token = new_key
-                                                    if self.DEBUG:
-                                                        print(f"已切换到新的API密钥")
-                                            except ImportError:
-                                                if self.DEBUG:
-                                                    print(f"无法导入key_manager，无法自动切换密钥")
-                                            except Exception as e:
-                                                if self.DEBUG:
-                                                    print(f"切换API密钥时发生错误: {str(e)}")
-                                            return f"任务失败: {failure_reason}"
-                                    elif status in ["rejected", "needs_user_review"]:
-                                        # 任务被拒绝，释放密钥
-                                        try:
-                                            from .key_manager import key_manager
-                                            key_manager.release_key(current_auth_token)
-                                            if self.DEBUG:
-                                                print(f"任务被拒绝，已释放密钥")
-                                        except (ImportError, Exception) as e:
-                                            if self.DEBUG:
-                                                print(f"释放密钥时发生错误: {str(e)}")
-                                                
-                                        if self.DEBUG:
-                                            print(f"任务 {task_id} 被拒绝或需要审查: {status}")
-                                        return f"任务被拒绝或需审查: {status}"
-                                    # else status is pending, processing, etc. - continue polling
-                                    break # Found the task, no need to check others in this response
-                            else:
-                                # Task ID not found in the recent list, maybe it's older or just submitted
-                                if self.DEBUG:
-                                    print(f"  未在最近任务列表中找到 {task_id}，继续等待... (尝试 {attempt+1}/{max_attempts})")
-                        except json.JSONDecodeError:
-                            if self.DEBUG:
-                                print(f"检查任务状态时无法解析响应JSON。状态码: {response.status_code}, 响应: {response.text}")
-                    else:
-                        if self.DEBUG:
-                            print(f"检查任务状态失败，状态码: {response.status_code}, 响应: {response.text}")
-                        
-                        # 检查是否是认证失败或其他可能表明API密钥失效的情况
-                        response_text = response.text.lower()
-                        is_auth_issue = (
-                            response.status_code in [401, 403, 429] or
-                            "authorization" in response_text or
-                            "auth" in response_text or
-                            "token" in response_text or
-                            "permission" in response_text or
-                            "unauthorized" in response_text or
-                            "credentials" in response_text or
-                            "login" in response_text or
-                            "invalid" in response_text
-                        )
-                        
-                        if is_auth_issue:
-                            if self.DEBUG:
-                                print(f"API密钥可能已失效，尝试切换密钥")
-                            
-                            try:
-                                # 导入在这里进行以避免循环导入
-                                from .key_manager import key_manager
-                                # 标记当前密钥为无效并获取新密钥
-                                new_key = key_manager.mark_key_invalid(self.auth_token)
-                                if new_key:
-                                    self.auth_token = new_key
-                                    if self.DEBUG:
-                                        print(f"已切换到新的API密钥，重试请求")
-                                    # 使用新密钥继续轮询
-                                    continue
-                            except ImportError:
-                                if self.DEBUG:
-                                    print(f"无法导入key_manager，无法自动切换密钥")
-                            except Exception as e:
-                                if self.DEBUG:
-                                    print(f"切换API密钥时发生错误: {str(e)}")
-                                    
-                    time.sleep(interval)  # 等待一段时间后再次检查
-                except Exception as e:
-                    if self.DEBUG:
-                        print(f"检查任务状态时出错: {str(e)}")
-                    
-                    # 检查异常信息中是否包含可能的认证问题
-                    error_str = str(e).lower()
-                    is_auth_issue = (
-                        "authorization" in error_str or
-                        "auth" in error_str or
-                        "token" in error_str or
-                        "permission" in error_str or
-                        "unauthorized" in error_str or
-                        "credentials" in error_str or
-                        "login" in error_str
-                    )
-                    
-                    if is_auth_issue:
-                        if self.DEBUG:
-                            print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
-                        
-                        try:
-                            from .key_manager import key_manager
-                            new_key = key_manager.mark_key_invalid(self.auth_token)
-                            if new_key:
-                                self.auth_token = new_key
-                                if self.DEBUG:
-                                    print(f"已切换到新的API密钥，重试请求")
-                                # 重置当前尝试次数，继续轮询
-                                continue
-                        except (ImportError, Exception) as err:
-                            if self.DEBUG:
-                                print(f"切换API密钥失败: {str(err)}")
-                    
-                    # Add a slightly longer delay on error to avoid hammering the server
-                    time.sleep(interval * 1.5)
-            
-            # 如果达到最大尝试次数，释放密钥
-            try:
-                from .key_manager import key_manager
-                key_manager.release_key(current_auth_token)
-                if self.DEBUG:
-                    print(f"轮询超时，已释放密钥")
-            except (ImportError, Exception) as e:
-                if self.DEBUG:
-                    print(f"释放密钥时发生错误: {str(e)}")
-                    
-            return f"任务 {task_id} 超时 ({max_attempts * interval}秒)，未能获取最终状态"
-        except Exception as e:
-            # 确保在异常情况下也释放密钥
-            try:
-                from .key_manager import key_manager
-                key_manager.release_key(current_auth_token)
-                if self.DEBUG:
-                    print(f"轮询过程发生异常，已释放密钥")
-            except (ImportError, Exception) as release_err:
-                if self.DEBUG:
-                    print(f"释放密钥时发生错误: {str(release_err)}")
-                
-            if self.DEBUG:
-                print(f"轮询任务状态时发生未处理的异常: {str(e)}")
-            import traceback
-            traceback.print_exc()
-            return f"轮询任务状态时出错: {str(e)}"
-
-    def test_connection(self):
-        """
-        测试API连接是否有效，仅发送一个轻量级请求
-        返回:
-        dict: 包含连接状态信息的字典
-        """
-        start_time = time.time()  # 记录开始时间，用于计算响应时间
-        success = False  # 初始化请求结果标识
-        
-        try:
-            # 使用简单的GET请求来验证连接和认证
-            headers = self._get_dynamic_headers(referer="https://sora.chatgpt.com/explore")
-            response = self.scraper.get(
-                "https://sora.chatgpt.com/backend/parameters",
-                headers=headers,
-                proxies=self.proxies,
-                timeout=10
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                # 检查返回的数据中是否含有关键字段，确认API确实有效
-                api_valid = result.get("can_create_images") is not None or "limits_for_images" in result
-                
-                if api_valid:
-                    success = True  # 标记请求成功
-                    # 记录请求结果（成功）
-                    try:
-                        from .key_manager import key_manager
-                        response_time = time.time() - start_time
-                        key_manager.record_request_result(self.auth_token, success, response_time)
-                    except (ImportError, Exception) as e:
-                        if self.DEBUG:
-                            print(f"记录请求结果失败: {str(e)}")
-                    
-                    return {
-                        "status": "success",
-                        "message": "API连接测试成功",
-                        "data": result
-                    }
-                else:
-                    # API返回200但数据不符合预期
-                    success = False  # 标记请求失败
-                    
-                    # 记录请求结果（失败）
-                    try:
-                        from .key_manager import key_manager
-                        response_time = time.time() - start_time
-                        key_manager.record_request_result(self.auth_token, success, response_time)
-                    except (ImportError, Exception) as e:
-                        if self.DEBUG:
-                            print(f"记录请求结果失败: {str(e)}")
-                    
-                    return {
-                        "status": "error",
-                        "message": "API连接测试失败：返回数据格式不符合预期",
-                        "response": result
-                    }
-            else:
-                # 检查是否是认证失败或其他可能表明API密钥失效的情况
-                response_text = response.text.lower()
-                is_auth_issue = (
-                    response.status_code in [401, 403, 429] or
-                    "authorization" in response_text or
-                    "auth" in response_text or
-                    "token" in response_text or
-                    "permission" in response_text or
-                    "unauthorized" in response_text or
-                    "credentials" in response_text or
-                    "login" in response_text or
-                    "invalid" in response_text
-                )
-                
-                success = False  # 标记请求失败
-                
-                # 记录请求结果（失败）
-                try:
-                    from .key_manager import key_manager
-                    response_time = time.time() - start_time
-                    key_manager.record_request_result(self.auth_token, success, response_time)
-                except (ImportError, Exception) as e:
-                    if self.DEBUG:
-                        print(f"记录请求结果失败: {str(e)}")
-                
-                if is_auth_issue:
-                    if self.DEBUG:
-                        print(f"API密钥可能已失效，尝试切换密钥")
-                    
-                    try:
-                        # 导入在这里进行以避免循环导入
-                        from .key_manager import key_manager
-                        # 标记当前密钥为无效并获取新密钥
-                        new_key = key_manager.mark_key_invalid(self.auth_token)
-                        if new_key:
-                            self.auth_token = new_key
-                            if self.DEBUG:
-                                print(f"已切换到新的API密钥，重试连接测试")
-                            # 使用新密钥重试
-                            return self.test_connection()
-                    except ImportError:
-                        if self.DEBUG:
-                            print(f"无法导入key_manager，无法自动切换密钥")
-                    except Exception as e:
-                        if self.DEBUG:
-                            print(f"切换API密钥时发生错误: {str(e)}")
-                
-                return {
-                    "status": "error",
-                    "message": f"API连接测试失败，状态码: {response.status_code}",
-                    "response": response.text
-                }
-        except Exception as e:
-            success = False  # 标记请求失败
-            
-            # 记录请求结果（异常失败）
-            try:
-                from .key_manager import key_manager
-                response_time = time.time() - start_time
-                key_manager.record_request_result(self.auth_token, success, response_time)
-            except (ImportError, Exception) as err:
-                if self.DEBUG:
-                    print(f"记录请求结果失败: {str(err)}")
-            
-            # 检查异常信息中是否包含可能的认证问题
-            error_str = str(e).lower()
-            is_auth_issue = (
-                "authorization" in error_str or
-                "auth" in error_str or
-                "token" in error_str or
-                "permission" in error_str or
-                "unauthorized" in error_str or
-                "credentials" in error_str or
-                "login" in error_str
-            )
-            
-            if is_auth_issue:
-                if self.DEBUG:
-                    print(f"异常信息表明可能存在API密钥问题，尝试切换密钥")
-                
-                try:
-                    from .key_manager import key_manager
-                    new_key = key_manager.mark_key_invalid(self.auth_token)
-                    if new_key:
-                        self.auth_token = new_key
-                        if self.DEBUG:
-                            print(f"已切换到新的API密钥，重试连接测试")
-                        # 使用新密钥重试
-                        return self.test_connection()
-                except (ImportError, Exception) as err:
-                    if self.DEBUG:
-                        print(f"切换API密钥失败: {str(err)}")
-            
-            raise Exception(f"API连接测试失败: {str(e)}") 

sora-api-master/src/sora_integration.py

@@ -1,114 +0,0 @@
-import asyncio
-import concurrent.futures
-from typing import List, Dict, Any, Optional, Union
-import json
-import os
-import base64
-import tempfile
-import uuid
-
-# 导入原有的SoraImageGenerator类
-from .sora_generator import SoraImageGenerator
-
-class SoraClient:
-    def __init__(self, proxy_host=None, proxy_port=None, proxy_user=None, proxy_pass=None, auth_token=None):
-        """初始化Sora客户端，使用cloudscraper绕过CF验证"""
-        self.generator = SoraImageGenerator(
-            proxy_host=proxy_host, 
-            proxy_port=proxy_port,
-            proxy_user=proxy_user,
-            proxy_pass=proxy_pass,
-            auth_token=auth_token
-        )
-        # 保存原始的auth_token，用于检测是否已更新
-        self.auth_token = auth_token
-        # 创建线程池执行器
-        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=10)
-        
-    async def generate_image(self, prompt: str, num_images: int = 1, 
-                           width: int = 720, height: int = 480) -> List[str]:
-        """异步包装SoraImageGenerator.generate_image方法"""
-        loop = asyncio.get_running_loop()
-        # 使用线程池执行同步方法（因为cloudscraper不是异步的）
-        result = await loop.run_in_executor(
-            self.executor, 
-            lambda: self.generator.generate_image(prompt, num_images, width, height)
-        )
-        
-        # 检查generator中的auth_token是否已经被更新（由自动切换密钥机制）
-        if self.generator.auth_token != self.auth_token:
-            self.auth_token = self.generator.auth_token
-        
-        if isinstance(result, list):
-            return result
-        else:
-            raise Exception(f"图像生成失败: {result}")
-    
-    async def upload_image(self, image_path: str) -> Dict:
-        """异步包装上传图片方法"""
-        loop = asyncio.get_running_loop()
-        result = await loop.run_in_executor(
-            self.executor,
-            lambda: self.generator.upload_image(image_path)
-        )
-        
-        # 检查generator中的auth_token是否已经被更新
-        if self.generator.auth_token != self.auth_token:
-            self.auth_token = self.generator.auth_token
-        
-        if isinstance(result, dict) and 'id' in result:
-            return result
-        else:
-            raise Exception(f"图片上传失败: {result}")
-            
-    async def generate_image_remix(self, prompt: str, media_id: str, 
-                                 num_images: int = 1) -> List[str]:
-        """异步包装remix方法"""
-        loop = asyncio.get_running_loop()
-        
-        # 处理可能包含API密钥信息的media_id对象
-        if isinstance(media_id, dict) and 'id' in media_id:
-            # 如果上传时使用的密钥与当前不同，则先切换密钥
-            if 'used_auth_token' in media_id and media_id['used_auth_token'] != self.auth_token:
-                self.auth_token = media_id['used_auth_token']
-                # 同步更新generator的auth_token
-                self.generator.auth_token = self.auth_token
-            # 提取实际的media_id
-            media_id = media_id['id']
-            
-        result = await loop.run_in_executor(
-            self.executor,
-            lambda: self.generator.generate_image_remix(prompt, media_id, num_images)
-        )
-        
-        # 检查generator中的auth_token是否已经被更新
-        if self.generator.auth_token != self.auth_token:
-            self.auth_token = self.generator.auth_token
-        
-        if isinstance(result, list):
-            return result
-        else:
-            raise Exception(f"Remix生成失败: {result}")
-            
-    async def test_connection(self) -> Dict:
-        """测试API连接是否有效"""
-        try:
-            # 简单测试上传功能，这个方法会调用API但不会真正上传文件
-            loop = asyncio.get_running_loop()
-            result = await loop.run_in_executor(
-                self.executor,
-                lambda: self.generator.test_connection()
-            )
-            
-            # 检查generator中的auth_token是否已经被更新
-            if self.generator.auth_token != self.auth_token:
-                self.auth_token = self.generator.auth_token
-            
-            # 直接返回generator.test_connection的结果，保留所有信息
-            return result
-        except Exception as e:
-            return {"status": "error", "message": f"API连接测试失败: {str(e)}"}
-            
-    def close(self):
-        """关闭线程池"""
-        self.executor.shutdown(wait=False) 

sora-api-master/src/static/admin/config.html

@@ -1,99 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Sora API - 配置管理</title>
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
-    <link href="css/admin.css" rel="stylesheet">
-</head>
-<body>
-    <div class="container">
-        <h1 class="my-4">Sora API - 配置管理</h1>
-        
-        <div id="messages" class="mb-4"></div>
-        
-        <div class="card mb-4">
-            <div class="card-header">
-                <h5 class="mb-0">系统配置</h5>
-            </div>
-            <div class="card-body">
-                <form id="configForm">
-                    <div class="mb-3">
-                        <label class="form-label fw-bold">HTTP代理设置</label>
-                        <div class="row g-3">
-                            <div class="col-md-6">
-                                <label for="proxy_host" class="form-label">代理主机</label>
-                                <input type="text" class="form-control" id="proxy_host" placeholder="例如: 127.0.0.1">
-                            </div>
-                            <div class="col-md-6">
-                                <label for="proxy_port" class="form-label">代理端口</label>
-                                <input type="text" class="form-control" id="proxy_port" placeholder="例如: 7890">
-                            </div>
-                        </div>
-                        <div class="mt-3">
-                            <label class="form-label">代理认证 (可选)</label>
-                            <div class="row g-3">
-                                <div class="col-md-6">
-                                    <label for="proxy_user" class="form-label">用户名</label>
-                                    <input type="text" class="form-control" id="proxy_user" placeholder="代理用户名">
-                                </div>
-                                <div class="col-md-6">
-                                    <label for="proxy_pass" class="form-label">密码</label>
-                                    <input type="password" class="form-control" id="proxy_pass" placeholder="代理密码">
-                                </div>
-                            </div>
-                        </div>
-                        <div class="form-text text-muted mt-2">如需使用代理访问Sora API，请填写以上信息，留空表示不使用代理</div>
-                    </div>
-                    
-                    <hr>
-                    
-                    <div class="mb-3">
-                        <label class="form-label fw-bold">图片本地化设置</label>
-                        <div class="form-check form-switch">
-                            <input class="form-check-input" type="checkbox" id="image_localization">
-                            <label class="form-check-label" for="image_localization">启用图片本地化</label>
-                        </div>
-                        <div class="form-text text-muted">启用后，Sora生成的图片将被下载并保存到本地服务器，避免客户端无法访问外部链接的问题</div>
-                    </div>
-                    
-                    <div class="mb-3">
-                        <label for="image_save_dir" class="form-label">图片保存目录</label>
-                        <input type="text" class="form-control" id="image_save_dir" placeholder="src/static/images">
-                        <div class="form-text text-muted">相对于工作目录的路径，必须确保目录存在且有写入权限</div>
-                    </div>
-                    
-                    <button type="button" id="saveConfig" class="btn btn-primary">保存配置</button>
-                </form>
-            </div>
-        </div>
-        
-        <div class="card mb-4">
-            <div class="card-header">
-                <h5 class="mb-0">帮助说明</h5>
-            </div>
-            <div class="card-body">
-                <p><strong>HTTP代理设置：</strong></p>
-                <ul>
-                    <li>如果您的服务器无法直接访问Sora API，可以配置HTTP代理</li>
-                    <li>代理认证是可选的，如果您的代理服务器不需要认证，请留空</li>
-                    <li>在Docker环境中，代理主机通常设置为<code>host.docker.internal</code>而不是<code>127.0.0.1</code></li>
-                </ul>
-                
-                <p><strong>图片本地化功能说明：</strong></p>
-                <ul>
-                    <li>本功能解决Sora图片URL无法访问的问题，将生成的图片保存到本地服务器</li>
-                    <li>启用后，系统会自动下载Sora返回的图片并存储到指定目录</li>
-                    <li>API返回的图片链接将替换为本地URL地址</li>
-                    <li>确保���置的保存目录有足够的磁盘空间和访问权限</li>
-                </ul>
-                <p class="text-warning"><strong>注意：</strong> 配置变更会立即生效，但不会影响已经生成的图片</p>
-            </div>
-        </div>
-    </div>
-    
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"></script>
-    <script src="js/config.js"></script>
-</body>
-</html> 

sora-api-master/src/static/admin/css/style.css

@@ -1,424 +0,0 @@
-/* 全局样式 */
-:root {
-    --sidebar-width: 250px;
-    --sidebar-bg: #343a40;
-    --sidebar-color: #fff;
-    --primary-color: #0d6efd;
-    --success-color: #198754;
-    --warning-color: #ffc107;
-    --danger-color: #dc3545;
-    --info-color: #0dcaf0;
-    --transition-speed: 0.3s;
-}
-
-body {
-    font-family: 'Segoe UI', 'Microsoft YaHei', 'Arial', sans-serif;
-    background-color: #f8f9fa;
-    overflow-x: hidden;
-    margin: 0;
-    padding: 0;
-    min-height: 100vh;
-}
-
-/* 登录页面样式 */
-#login-container, .login-container {
-    background-color: #f8f9fa;
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100vh;
-    z-index: 1050;
-    align-items: center;
-    justify-content: center;
-}
-
-#login-container .card {
-    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.1);
-    border-radius: 15px;
-    overflow: hidden;
-    width: 400px;
-    max-width: 90%;
-}
-
-#login-container .card-header {
-    background-color: var(--primary-color);
-    padding: 1.5rem 1rem;
-}
-
-#login-container .bi-shield-lock {
-    color: var(--primary-color);
-}
-
-#login-form .btn-primary {
-    background-color: var(--primary-color);
-    border-color: var(--primary-color);
-    padding: 0.6rem 1.2rem;
-    font-weight: 500;
-}
-
-#login-form .btn-primary:hover {
-    background-color: #0b5ed7;
-    border-color: #0a58ca;
-}
-
-#login-error {
-    border-radius: 8px;
-}
-
-/* 页面布局 */
-.wrapper {
-    display: flex;
-    width: 100%;
-    min-height: 100vh;
-    align-items: stretch;
-    position: relative;
-}
-
-/* 侧边栏样式 */
-#sidebar {
-    min-width: 250px;
-    max-width: 250px;
-    background: var(--sidebar-bg);
-    color: var(--sidebar-color);
-    transition: all var(--transition-speed);
-    height: 100vh;
-    position: fixed;
-    z-index: 999;
-    box-shadow: 0 0 15px rgba(0, 0, 0, 0.1);
-    top: 0;
-    left: 0;
-}
-
-#sidebar.active {
-    margin-left: -250px;
-}
-
-#sidebar .sidebar-header {
-    padding: 20px;
-    background: #212529;
-    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
-}
-
-#sidebar ul.components {
-    padding: 20px 0;
-    height: calc(100vh - 140px);
-    overflow-y: auto;
-}
-
-#sidebar ul li a {
-    padding: 12px 20px;
-    font-size: 1.1em;
-    display: block;
-    color: #fff;
-    text-decoration: none;
-    transition: all 0.3s;
-    border-left: 3px solid transparent;
-}
-
-#sidebar ul li a:hover {
-    background: #495057;
-    border-left: 3px solid var(--primary-color);
-}
-
-#sidebar ul li.active > a {
-    background: var(--primary-color);
-    color: white;
-    border-left: 3px solid #fff;
-}
-
-#sidebar ul li.sidebar-footer {
-    margin-top: auto;
-    border-top: 1px solid rgba(255, 255, 255, 0.1);
-    position: absolute;
-    bottom: 0;
-    width: 100%;
-}
-
-#sidebar ul li.sidebar-footer a {
-    color: rgba(255, 255, 255, 0.8);
-}
-
-#sidebar ul li.sidebar-footer a:hover {
-    background: rgba(220, 53, 69, 0.6);
-    color: white;
-}
-
-/* 主内容区样式 */
-#content {
-    width: calc(100% - 250px);
-    padding: 0;
-    min-height: 100vh;
-    transition: all 0.3s;
-    position: absolute;
-    right: 0;
-    overflow-x: hidden;
-}
-
-#content.active {
-    width: 100%;
-}
-
-/* 内容页面样式 */
-.content-page {
-    display: none;
-    padding: 0 20px 30px;
-}
-
-.content-page.active {
-    display: block;
-    animation: fadeIn 0.3s;
-}
-
-/* 表格样式 */
-.table th {
-    font-weight: 600;
-    border-top: none;
-    white-space: nowrap;
-}
-
-.table td {
-    vertical-align: middle;
-}
-
-/* 状态标签样式 */
-.status-badge {
-    display: inline-block;
-    padding: 0.25em 0.6em;
-    font-size: 85%;
-    font-weight: 600;
-    line-height: 1;
-    text-align: center;
-    white-space: nowrap;
-    vertical-align: baseline;
-    border-radius: 0.25rem;
-    cursor: help;
-}
-
-.status-enabled {
-    background-color: var(--success-color);
-    color: white;
-}
-
-.status-disabled {
-    background-color: var(--danger-color);
-    color: white;
-}
-
-.status-temp-disabled {
-    background-color: var(--warning-color);
-    color: black;
-    position: relative;
-}
-
-/* 为临时禁用状态的提示信息添加样式 */
-.small.text-muted {
-    font-size: 0.75rem;
-    display: block;
-    margin-top: 3px;
-}
-
-/* 让状态标签支持鼠标悬停提示 */
-.status-badge:hover {
-    background-color: #ffd700;
-    color: black;
-}
-
-/* 响应式调整 */
-@media (max-width: 768px) {
-    #sidebar {
-        margin-left: -250px;
-    }
-    #sidebar.active {
-        margin-left: 0;
-    }
-    #content {
-        width: 100%;
-    }
-    #content.active {
-        width: calc(100% - 250px);
-    }
-    #sidebarCollapse {
-        display: block;
-    }
-    .navbar .container-fluid {
-        padding-left: 10px;
-        padding-right: 10px;
-    }
-}
-
-/* 卡片样式美化 */
-.card {
-    border: none;
-    border-radius: 10px;
-    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.05);
-    margin-bottom: 20px;
-    overflow: hidden;
-}
-
-.card-header {
-    background-color: #fff;
-    border-bottom: 1px solid rgba(0, 0, 0, 0.05);
-    padding: 15px 20px;
-    font-weight: 500;
-}
-
-.card-body {
-    padding: 20px;
-}
-
-/* 按钮样式 */
-.btn-primary {
-    background-color: var(--primary-color);
-    border-color: var(--primary-color);
-}
-
-.btn-primary:hover {
-    background-color: #0b5ed7;
-    border-color: #0a58ca;
-}
-
-.btn-success {
-    background-color: var(--success-color);
-    border-color: var(--success-color);
-}
-
-.btn-danger {
-    background-color: var(--danger-color);
-    border-color: var(--danger-color);
-}
-
-/* 表单元素样式 */
-.form-control:focus {
-    border-color: var(--primary-color);
-    box-shadow: 0 0 0 0.2rem rgba(13, 110, 253, 0.25);
-}
-
-/* 操作按钮样式 */
-.action-btn {
-    margin-right: 5px;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    width: 2.2rem;
-    height: 2.2rem;
-    padding: 0;
-    border-radius: 50%;
-}
-
-.action-btn i {
-    font-size: 0.9rem;
-}
-
-/* 密钥值样式 */
-.key-value {
-    max-width: 180px;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    white-space: nowrap;
-    font-family: monospace;
-    font-size: 0.9rem;
-}
-
-/* 统计卡片样式 */
-.card.bg-primary, .card.bg-success, .card.bg-danger, .card.bg-info {
-    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
-    transition: transform 0.3s ease;
-}
-
-.card.bg-primary:hover, .card.bg-success:hover, .card.bg-danger:hover, .card.bg-info:hover {
-    transform: translateY(-5px);
-}
-
-.card.bg-primary .card-title, .card.bg-success .card-title, 
-.card.bg-danger .card-title, .card.bg-info .card-title {
-    font-size: 1rem;
-    opacity: 0.9;
-}
-
-.card.bg-primary .card-text, .card.bg-success .card-text, 
-.card.bg-danger .card-text, .card.bg-info .card-text {
-    font-size: 1.8rem;
-    font-weight: 600;
-}
-
-/* 图表容器 */
-canvas {
-    width: 100% !important;
-    height: 300px !important;
-}
-
-/* 导航栏样式 */
-.navbar {
-    box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
-    background-color: #fff !important;
-}
-
-/* 管理员密钥显示 */
-#admin-key-display {
-    font-size: 0.8rem;
-    font-family: monospace;
-}
-
-/* Toast通知样式 */
-.toast {
-    border-radius: 8px;
-    box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
-}
-
-/* 动画效果 */
-@keyframes fadeIn {
-    from { opacity: 0; }
-    to { opacity: 1; }
-}
-
-/* 最近的API密钥列表样式 */
-#recent-keys-list .list-group-item {
-    padding: 0.75rem 1rem;
-    border-left: none;
-    border-right: none;
-}
-
-#recent-keys-list .list-group-item:hover {
-    background-color: rgba(13, 110, 253, 0.05);
-}
-
-/* 模态框样式 */
-.modal-content {
-    border-radius: 12px;
-    border: none;
-    box-shadow: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
-    overflow: hidden;
-}
-
-.modal-header {
-    border-bottom: 1px solid rgba(0, 0, 0, 0.05);
-}
-
-.modal-footer {
-    border-top: 1px solid rgba(0, 0, 0, 0.05);
-}
-
-/* 分页样式 */
-.pagination {
-    margin-bottom: 0;
-}
-
-.page-link {
-    color: var(--primary-color);
-    border-radius: 4px;
-    margin: 0 2px;
-}
-
-.page-item.active .page-link {
-    background-color: var(--primary-color);
-    border-color: var(--primary-color);
-}
-
-/* 搜索框样式 */
-#search-keys {
-    min-width: 250px;
-    border-radius: 20px;
-    padding-left: 15px;
-    padding-right: 15px;
-} 

sora-api-master/src/static/admin/index.html

@@ -1,512 +0,0 @@
-<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Sora API - 管理控制台</title>
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css">
-    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.10.0/font/bootstrap-icons.css">
-    <link rel="stylesheet" href="/static/admin/css/style.css">
-</head>
-<body>
-    <!-- 登录页面 -->
-    <div id="login-container" style="display: flex;" class="login-container">
-        <div class="card shadow-lg">
-            <div class="card-header bg-primary text-white text-center py-3">
-                <h4>Sora API 管理控制台</h4>
-            </div>
-            <div class="card-body p-4">
-                <div class="text-center mb-4">
-                    <i class="bi bi-shield-lock" style="font-size: 3rem;"></i>
-                    <h5 class="mt-2">管理员登录</h5>
-                </div>
-                <form id="login-form">
-                    <div class="mb-3">
-                        <label for="admin-key-input" class="form-label">管理员密钥</label>
-                        <input type="password" class="form-control" id="admin-key-input" required>
-                        <div class="form-text">请输入管理员密钥以访问管理控制台</div>
-                    </div>
-                    <div class="d-grid gap-2">
-                        <button type="submit" class="btn btn-primary">登录</button>
-                    </div>
-                </form>
-                <div id="login-error" class="alert alert-danger mt-3" style="display: none;"></div>
-            </div>
-        </div>
-    </div>
-
-    <!-- 管理控制台 -->
-    <div id="admin-panel" style="display: none;" class="wrapper">
-        <!-- 侧边栏导航 -->
-        <nav id="sidebar">
-            <div class="sidebar-header d-flex align-items-center">
-                <h3 class="mb-0">Sora API</h3>
-            </div>
-
-            <ul class="list-unstyled components">
-                <li class="active">
-                    <a href="#" data-page="dashboard"><i class="bi bi-speedometer2 me-2"></i>仪表盘</a>
-                </li>
-                <li>
-                    <a href="#" data-page="keys"><i class="bi bi-key-fill me-2"></i>API密钥管理</a>
-                </li>
-                <li>
-                    <a href="#" data-page="stats"><i class="bi bi-graph-up me-2"></i>使用统计</a>
-                </li>
-                <li>
-                    <a href="#" data-page="settings"><i class="bi bi-gear-fill me-2"></i>系统设置</a>
-                </li>
-                <li class="sidebar-footer">
-                    <a href="#" id="logout-btn"><i class="bi bi-box-arrow-right me-2"></i>退出登录</a>
-                </li>
-            </ul>
-        </nav>
-
-        <!-- 页面内容区 -->
-        <div id="content">
-            <!-- 顶部导航栏 -->
-            <nav class="navbar navbar-expand-lg navbar-light bg-light shadow-sm mb-4">
-                <div class="container-fluid">
-                    <button type="button" id="sidebarCollapse" class="btn btn-primary">
-                        <i class="bi bi-list"></i>
-                    </button>
-                    <div class="ms-3 d-none d-md-block">
-                        <h5 class="mb-0" id="current-page-title">仪表盘</h5>
-                    </div>
-                    <div class="ms-auto d-flex align-items-center">
-                        <span class="badge bg-primary me-3" id="admin-key-display"></span>
-                        <span class="text-muted d-none d-md-block">欢迎回来，管理员</span>
-                    </div>
-                </div>
-            </nav>
-            
-            <!-- 仪表盘页面 -->
-            <div id="dashboard-page" class="content-page active container-fluid">
-                <div class="row mb-4">
-                    <div class="col-12">
-                        <h4 class="mb-4">系统概览</h4>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-primary text-white h-100">
-                            <div class="card-body">
-                                <h5 class="card-title">总API密钥</h5>
-                                <h3 id="total-keys" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-success text-white h-100">
-                            <div class="card-body">
-                                <h5 class="card-title">激活密钥</h5>
-                                <h3 id="active-keys" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-danger text-white h-100">
-                            <div class="card-body">
-                                <h5 class="card-title">禁用密钥</h5>
-                                <h3 id="disabled-keys" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-info text-white h-100">
-                            <div class="card-body">
-                                <h5 class="card-title">今日请求</h5>
-                                <h3 id="today-requests" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-                
-                <div class="row">
-                    <div class="col-lg-8 mb-4">
-                        <div class="card h-100">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">近期请求趋势</h5>
-                            </div>
-                            <div class="card-body">
-                                <canvas id="dashboard-requests-chart"></canvas>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-lg-4 mb-4">
-                        <div class="card h-100">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">最新API密钥</h5>
-                            </div>
-                            <div class="card-body p-0">
-                                <div class="list-group list-group-flush" id="recent-keys-list">
-                                    <!-- JS动态加载 -->
-                                </div>
-                            </div>
-                            <div class="card-footer text-end">
-                                <a href="#" class="btn btn-sm btn-primary" data-page="keys">查看全部</a>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- API密钥管理页面 -->
-            <div id="keys-page" class="content-page container-fluid">
-                <div class="row mb-4">
-                    <div class="col-12">
-                        <div class="card">
-                            <div class="card-body">
-                                <div class="d-flex justify-content-between flex-wrap mb-3">
-                                    <div class="mb-2">
-                                        <button id="add-key-btn" class="btn btn-primary me-2">
-                                            <i class="bi bi-plus-circle me-1"></i> 添加密钥
-                                        </button>
-                                        <div class="btn-group">
-                                            <button class="btn btn-outline-secondary dropdown-toggle" type="button" data-bs-toggle="dropdown">
-                                                批量操作
-                                            </button>
-                                            <ul class="dropdown-menu">
-                                                <li><a class="dropdown-item batch-action" data-action="enable" href="#">启用选中</a></li>
-                                                <li><a class="dropdown-item batch-action" data-action="disable" href="#">禁用选中</a></li>
-                                                <li><hr class="dropdown-divider"></li>
-                                                <li><a class="dropdown-item batch-action text-danger" data-action="delete" href="#">删除选中</a></li>
-                                            </ul>
-                                        </div>
-                                        <button id="import-keys-btn" class="btn btn-outline-primary ms-2">
-                                            <i class="bi bi-upload me-1"></i> 批量导入
-                                        </button>
-                                    </div>
-                                    <div class="mb-2">
-                                        <input type="text" id="search-keys" class="form-control" placeholder="搜索密钥...">
-                                    </div>
-                                </div>
-                                
-                                <div class="table-responsive">
-                                    <table class="table table-hover">
-                                        <thead>
-                                            <tr>
-                                                <th><input type="checkbox" id="select-all"></th>
-                                                <th>名称</th>
-                                                <th>密钥值</th>
-                                                <th>状��</th>
-                                                <th>权重</th>
-                                                <th>速率限制</th>
-                                                <th>创建时间</th>
-                                                <th>最后使用</th>
-                                                <th>操作</th>
-                                            </tr>
-                                        </thead>
-                                        <tbody id="keys-table-body">
-                                            <!-- JS动态加载 -->
-                                        </tbody>
-                                    </table>
-                                </div>
-                                
-                                <div id="pagination" class="d-flex justify-content-center mt-4">
-                                    <!-- JS动态加载 -->
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- 使用统计页面 -->
-            <div id="stats-page" class="content-page container-fluid">
-                <div class="row">
-                    <div class="col-12">
-                        <h4 class="mb-4">使用统计</h4>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-primary text-white">
-                            <div class="card-body">
-                                <h5 class="card-title">总请求次数</h5>
-                                <h3 id="total-requests" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-success text-white">
-                            <div class="card-body">
-                                <h5 class="card-title">成功请求</h5>
-                                <h3 id="successful-requests" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-danger text-white">
-                            <div class="card-body">
-                                <h5 class="card-title">失败请求</h5>
-                                <h3 id="failed-requests" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="col-md-6 col-lg-3 mb-4">
-                        <div class="card bg-info text-white">
-                            <div class="card-body">
-                                <h5 class="card-title">成功率</h5>
-                                <h3 id="success-rate" class="card-text">--</h3>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-                
-                <div class="row">
-                    <!-- 请求趋势图 -->
-                    <div class="col-lg-8 mb-4">
-                        <div class="card">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">请求趋势</h5>
-                            </div>
-                            <div class="card-body">
-                                <canvas id="requests-chart"></canvas>
-                            </div>
-                        </div>
-                    </div>
-                    
-                    <!-- 密钥使用分布 -->
-                    <div class="col-lg-4 mb-4">
-                        <div class="card">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">密钥使用分布</h5>
-                            </div>
-                            <div class="card-body">
-                                <canvas id="keys-usage-chart"></canvas>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-            
-            <!-- 设置页面 -->
-            <div id="settings-page" class="content-page container-fluid">
-                <div class="row">
-                    <div class="col-12">
-                        <h4 class="mb-4">系统设置</h4>
-                    </div>
-                    <div class="col-md-6 mb-4">
-                        <div class="card">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">管理员密钥</h5>
-                            </div>
-                            <div class="card-body">
-                                <div class="mb-3">
-                                    <label for="admin-key" class="form-label">管理员密钥</label>
-                                    <div class="input-group">
-                                        <input type="password" class="form-control" id="admin-key" readonly>
-                                        <button class="btn btn-outline-secondary" type="button" id="show-admin-key">
-                                            <i class="bi bi-eye"></i>
-                                        </button>
-                                        <button class="btn btn-outline-secondary" type="button" id="copy-admin-key">
-                                            <i class="bi bi-clipboard"></i>
-                                        </button>
-                                    </div>
-                                    <div class="form-text">此密钥用于访问管理界面，请妥善保管</div>
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                    
-                    <div class="col-md-6 mb-4">
-                        <div class="card">
-                            <div class="card-header">
-                                <h5 class="card-title mb-0">系统配置</h5>
-                            </div>
-                            <div class="card-body">
-                                <form id="settings-form">
-                                    <div class="mb-3">
-                                        <label for="proxy-host" class="form-label">代理主机</label>
-                                        <input type="text" class="form-control" id="proxy-host">
-                                    </div>
-                                    <div class="mb-3">
-                                        <label for="proxy-port" class="form-label">代理端口</label>
-                                        <input type="text" class="form-control" id="proxy-port">
-                                    </div>
-                                    
-                                    <div class="mb-3">
-                                        <label for="proxy-user" class="form-label">代理用户名</label>
-                                        <input type="text" class="form-control" id="proxy-user">
-                                    </div>
-                                    
-                                    <div class="mb-3">
-                                        <label for="proxy-pass" class="form-label">代理密码</label>
-                                        <input type="password" class="form-control" id="proxy-pass">
-                                        <div class="form-text">如果代理服务器需要认证，请填写用户名和密码</div>
-                                    </div>
-                                    
-                                    <hr>
-                                    <h6 class="mb-3">图片本地化设置</h6>
-                                    
-                                    <div class="mb-3 form-check">
-                                        <input type="checkbox" class="form-check-input" id="image-localization">
-                                        <label class="form-check-label" for="image-localization">启用图片本地化</label>
-                                        <div class="form-text">启用后，Sora生成的图片将被下载并保存到本地服务器，避免客户端无法访问外部链接</div>
-                                    </div>
-                                    
-                                    <div class="mb-3">
-                                        <label for="base-url" class="form-label">Base URL</label>
-                                        <input type="text" class="form-control" id="base-url" placeholder="http://example.com">
-                                        <div class="form-text">设置访问本地化图片的基础URL，例如：http://example.com 或 https://your-domain.com</div>
-                                    </div>
-                                    
-                                    <div class="mb-3">
-                                        <label for="image-save-dir" class="form-label">图片保存目录</label>
-                                        <input type="text" class="form-control" id="image-save-dir" placeholder="src/static/images">
-                                        <div class="form-text">相对于工作目录的路径，必须确保目录存在且有写入权限</div>
-                                    </div>
-                                    
-                                    <button type="submit" class="btn btn-primary">保存设置</button>
-                                </form>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-    
-    <!-- 添加/编辑密钥对话框 -->
-    <div class="modal fade" id="keyModal" tabindex="-1">
-        <div class="modal-dialog">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title" id="keyModalLabel">添加新密钥</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                </div>
-                <div class="modal-body">
-                    <form id="key-form">
-                        <input type="hidden" id="key-id">
-                        <div class="mb-3">
-                            <label for="key-name" class="form-label">密钥名称</label>
-                            <input type="text" class="form-control" id="key-name" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="key-value" class="form-label">密钥值 (Bearer Token)</label>
-                            <input type="text" class="form-control" id="key-value" required>
-                            <div class="form-text">输入OpenAI格式的API密钥，无需添加"Bearer "前缀，系统会自动处理</div>
-                        </div>
-                        <div class="mb-3">
-                            <label for="key-weight" class="form-label">权重 (1-10)</label>
-                            <input type="number" class="form-control" id="key-weight" min="1" max="10" value="1">
-                            <div class="form-text">权重越高，被选中的概率越大</div>
-                        </div>
-                        <div class="mb-3">
-                            <label for="key-rate-limit" class="form-label">速率限制 (每分钟请求数)</label>
-                            <input type="number" class="form-control" id="key-rate-limit" min="1" value="60">
-                        </div>
-                        <div class="mb-3 form-check">
-                            <input type="checkbox" class="form-check-input" id="key-enabled" checked>
-                            <label class="form-check-label" for="key-enabled">启用</label>
-                        </div>
-                        <div class="mb-3">
-                            <label for="key-notes" class="form-label">备注</label>
-                            <textarea class="form-control" id="key-notes" rows="2"></textarea>
-                        </div>
-                    </form>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
-                    <button type="button" class="btn btn-primary" id="test-key-btn">测试连接</button>
-                    <button type="button" class="btn btn-success" id="save-key-btn">保存</button>
-                </div>
-            </div>
-        </div>
-    </div>
-    
-    <!-- 确认对话框 -->
-    <div class="modal fade" id="confirmModal" tabindex="-1">
-        <div class="modal-dialog">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title" id="confirmModalLabel">确认操作</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                </div>
-                <div class="modal-body" id="confirm-message">
-                    确定要执行此操作吗？
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
-                    <button type="button" class="btn btn-danger" id="confirm-btn">确认</button>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <!-- 批量导入密钥对话框 -->
-    <div class="modal fade" id="importKeysModal" tabindex="-1">
-        <div class="modal-dialog modal-lg">
-            <div class="modal-content">
-                <div class="modal-header">
-                    <h5 class="modal-title">批量导入API密钥</h5>
-                    <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-                </div>
-                <div class="modal-body">
-                    <ul class="nav nav-tabs" id="importTabs" role="tablist">
-                        <li class="nav-item" role="presentation">
-                            <button class="nav-link active" id="paste-tab" data-bs-toggle="tab" data-bs-target="#paste-content" type="button" role="tab">粘贴内容</button>
-                        </li>
-                        <li class="nav-item" role="presentation">
-                            <button class="nav-link" id="file-tab" data-bs-toggle="tab" data-bs-target="#file-upload" type="button" role="tab">上传文件</button>
-                        </li>
-                    </ul>
-                    <div class="tab-content mt-3" id="importTabsContent">
-                        <div class="tab-pane fade show active" id="paste-content" role="tabpanel">
-                            <div class="mb-3">
-                                <label for="keys-text" class="form-label">API密钥列表</label>
-                                <textarea class="form-control" id="keys-text" rows="10" placeholder="支持两种格式：&#10;1. 每行一个密钥&#10;2. 每行格式：[名称],[API密钥],[权重(可选)],[速率限制(可选)]&#10;&#10;例如：&#10;sk-abcdefg123456&#10;我的密钥2,sk-hijklmn789012,5,100"></textarea>
-                            </div>
-                        </div>
-                        <div class="tab-pane fade" id="file-upload" role="tabpanel">
-                            <div class="mb-3">
-                                <label for="keys-file" class="form-label">选择文件</label>
-                                <input class="form-control" type="file" id="keys-file" accept=".txt,.csv">
-                                <div class="form-text">支持TXT或CSV文件，每行格式同上</div>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="form-check mt-3">
-                        <input class="form-check-input" type="checkbox" id="auto-enable-keys" checked>
-                        <label class="form-check-label" for="auto-enable-keys">
-                            自动启用导入的密钥
-                        </label>
-                    </div>
-                    <div class="alert alert-info mt-3">
-                        <i class="bi bi-info-circle me-2"></i> 批量导入将跳过重复的密钥值。如果名称重复但密钥值不同，将作为新密钥添加。
-                    </div>
-                    <div id="import-preview" class="mt-3" style="display: none;">
-                        <h6>导入预览 (<span id="preview-count">0</span>个密钥)</h6>
-                        <div class="table-responsive">
-                            <table class="table table-sm">
-                                <thead>
-                                    <tr>
-                                        <th>名称</th>
-                                        <th>密钥</th>
-                                        <th>权重</th>
-                                        <th>速率限制</th>
-                                    </tr>
-                                </thead>
-                                <tbody id="preview-table-body">
-                                </tbody>
-                            </table>
-                        </div>
-                    </div>
-                </div>
-                <div class="modal-footer">
-                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
-                    <button type="button" class="btn btn-primary" id="preview-import-btn">预览</button>
-                    <button type="button" class="btn btn-success" id="confirm-import-btn" disabled>导入</button>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <!-- Toast通知 -->
-    <div class="position-fixed bottom-0 end-0 p-3" style="z-index: 5">
-        <div id="toast-container"></div>
-    </div>
-
-    <!-- JavaScript库 -->
-    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-    <script src="/static/admin/js/main.js"></script>
-</body>
-</html> 

sora-api-master/src/static/admin/js/config.js

@@ -1,121 +0,0 @@
-document.addEventListener('DOMContentLoaded', function() {
-    // 获取当前配置
-    fetchConfig();
-    
-    // 保存配置按钮事件
-    document.getElementById('saveConfig').addEventListener('click', saveConfig);
-});
-
-// 获取当前配置
-function fetchConfig() {
-    fetch('/api/config', {
-        method: 'GET',
-        headers: {
-            'Authorization': 'Bearer ' + getAdminKey()
-        }
-    })
-    .then(response => {
-        if (!response.ok) {
-            throw new Error('获取配置失败，请检查管理员密钥是否正确');
-        }
-        return response.json();
-    })
-    .then(data => {
-        // 代理设置
-        document.getElementById('proxy_host').value = data.PROXY_HOST || '';
-        document.getElementById('proxy_port').value = data.PROXY_PORT || '';
-        document.getElementById('proxy_user').value = data.PROXY_USER || '';
-        
-        // 代理密码字段
-        const proxyPassField = document.getElementById('proxy_pass');
-        if (data.PROXY_PASS && data.PROXY_PASS !== '') {
-            // 设置代理密码占位符，防止用户修改
-            proxyPassField.setAttribute('placeholder', '已设置代理密码 (请保留空)');
-        } else {
-            proxyPassField.setAttribute('placeholder', '代理密码');
-        }
-        
-        // 图像本地化设置
-        document.getElementById('image_localization').checked = data.IMAGE_LOCALIZATION || false;
-        document.getElementById('image_save_dir').value = data.IMAGE_SAVE_DIR || 'src/static/images';
-    })
-    .catch(error => {
-        showMessage('错误', error.message, 'danger');
-    });
-}
-
-// 保存配置
-function saveConfig() {
-    // 获取代理设置
-    const proxyHost = document.getElementById('proxy_host').value.trim();
-    const proxyPort = document.getElementById('proxy_port').value.trim();
-    const proxyUser = document.getElementById('proxy_user').value.trim();
-    const proxyPass = document.getElementById('proxy_pass').value.trim();
-    
-    // 获取图像本地化设置
-    const imageLocalization = document.getElementById('image_localization').checked;
-    const imageSaveDir = document.getElementById('image_save_dir').value.trim();
-    
-    // 创建配置对象
-    const config = {
-        PROXY_HOST: proxyHost,
-        PROXY_PORT: proxyPort,
-        PROXY_USER: proxyUser,
-        IMAGE_LOCALIZATION: imageLocalization,
-        IMAGE_SAVE_DIR: imageSaveDir,
-        save_to_env: true
-    };
-    
-    // 如果代理密码存在，则添加到配置对象中
-    if (proxyPass) {
-        config.PROXY_PASS = proxyPass;
-    }
-    
-    fetch('/api/config', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': 'Bearer ' + getAdminKey()
-        },
-        body: JSON.stringify(config)
-    })
-    .then(response => {
-        if (!response.ok) {
-            throw new Error('保存配置失败，请检查管理员密钥是否正确');
-        }
-        return response.json();
-    })
-    .then(data => {
-        showMessage('成功', '配置已保存', 'success');
-        
-        // 成功后，立即重新获取配置以更新显示
-        setTimeout(fetchConfig, 1000);
-    })
-    .catch(error => {
-        showMessage('错误', error.message, 'danger');
-    });
-}
-
-// 获取管理员密钥
-function getAdminKey() {
-    return localStorage.getItem('adminKey') || '';
-}
-
-// 显示消息
-function showMessage(title, message, type) {
-    const alertDiv = document.createElement('div');
-    alertDiv.className = `alert alert-${type} alert-dismissible fade show`;
-    alertDiv.innerHTML = `
-        <strong>${title}:</strong> ${message}
-        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
-    `;
-    
-    const messagesContainer = document.getElementById('messages');
-    messagesContainer.appendChild(alertDiv);
-    
-    // 5秒后自动关闭
-    setTimeout(() => {
-        alertDiv.classList.remove('show');
-        setTimeout(() => alertDiv.remove(), 150);
-    }, 5000);
-} 

sora-api-master/src/static/admin/js/main.js

@@ -1,1631 +0,0 @@
-// 全局变量
-let adminKey = '';
-let keysData = [];
-let currentPage = 1;
-const keysPerPage = 10;
-let statsData = null;
-let dashboardRequestsChart = null;
-let requestsChart = null;
-let keysUsageChart = null;
-let systemSettings = {
-    proxyHost: '',
-    proxyPort: '',
-    proxyUser: '',
-    proxyPass: ''
-};
-// token过期时间
-let tokenExpiry = null;
-// JWT配置
-const JWT_EXPIRATION = 3600; // 令牌有效期1小时（秒）
-// 导入预览数据
-let importPreviewData = [];
-
-// DOM 加载完成后执行
-document.addEventListener('DOMContentLoaded', () => {
-    // 检查是否已登录
-    checkAuth();
-    
-    // 绑定登录表单提交事件
-    document.getElementById('login-form').addEventListener('submit', async (e) => {
-        e.preventDefault();
-        await handleLogin();
-    });
-    
-    // 绑定退出登录事件
-    document.getElementById('logout-btn').addEventListener('click', (e) => {
-        e.preventDefault();
-        handleLogout();
-    });
-    
-    // 侧边栏切换
-    document.getElementById('sidebarCollapse').addEventListener('click', () => {
-        const sidebar = document.getElementById('sidebar');
-        const content = document.getElementById('content');
-        
-        sidebar.classList.toggle('active');
-        content.classList.toggle('active');
-    });
-    
-    // 页面切换
-    document.querySelectorAll('[data-page]').forEach(link => {
-        link.addEventListener('click', (e) => {
-            e.preventDefault();
-            const targetPage = link.getAttribute('data-page');
-            
-            // 验证token是否有效
-            if (!isTokenValid()) {
-                handleLogout();
-                showToast('登录已过期，请重新登录', 'warning');
-                return;
-            }
-            
-            // 更新导航链接激活状态
-            document.querySelectorAll('#sidebar li').forEach(li => li.classList.remove('active'));
-            link.closest('li').classList.add('active');
-            
-            // 更新页面标题
-            document.getElementById('current-page-title').textContent = link.textContent.trim();
-            
-            // 隐藏所有页面，只显示目标页面
-            document.querySelectorAll('.content-page').forEach(page => {
-                page.classList.remove('active');
-                page.style.display = 'none';
-            });
-            document.getElementById(`${targetPage}-page`).classList.add('active');
-            document.getElementById(`${targetPage}-page`).style.display = 'block';
-            
-            // 加载相应页面的数据
-            switch (targetPage) {
-                case 'dashboard':
-                    loadDashboard();
-                    break;
-                case 'keys':
-                    loadKeys();
-                    break;
-                case 'stats':
-                    loadStats();
-                    break;
-                case 'settings':
-                    loadSettings();
-                    break;
-            }
-        });
-    });
-    
-    // 仪表盘页面的"查看全部"按钮
-    document.querySelectorAll('#dashboard-page [data-page]').forEach(link => {
-        link.addEventListener('click', (e) => {
-            e.preventDefault();
-            const targetPage = link.getAttribute('data-page');
-            // 触发相应导航的点击事件
-            document.querySelector(`#sidebar a[data-page="${targetPage}"]`).click();
-        });
-    });
-    
-    // 添加密钥按钮事件
-    document.getElementById('add-key-btn').addEventListener('click', () => {
-        // 重置表单
-        document.getElementById('key-form').reset();
-        document.getElementById('key-id').value = '';
-        document.getElementById('keyModalLabel').textContent = '添加新密钥';
-        
-        // 显示模态框
-        const keyModal = new bootstrap.Modal(document.getElementById('keyModal'));
-        keyModal.show();
-    });
-    
-    // 保存密钥按钮事件
-    document.getElementById('save-key-btn').addEventListener('click', saveKey);
-    
-    // 测试密钥按钮事件
-    document.getElementById('test-key-btn').addEventListener('click', testKey);
-    
-    // 全选/取消全选
-    document.getElementById('select-all').addEventListener('change', (e) => {
-        const checkboxes = document.querySelectorAll('#keys-table-body input[type="checkbox"]');
-        checkboxes.forEach(checkbox => checkbox.checked = e.target.checked);
-    });
-    
-    // 批量操作事件
-    document.querySelectorAll('.batch-action').forEach(action => {
-        action.addEventListener('click', (e) => {
-            e.preventDefault();
-            const actionType = action.getAttribute('data-action');
-            const selectedIds = getSelectedKeyIds();
-            
-            if (selectedIds.length === 0) {
-                showToast('请至少选择一个密钥', 'warning');
-                return;
-            }
-            
-            // 显示确认对话框
-            let message = '';
-            if (actionType === 'enable') {
-                message = `确定要启用选中的 ${selectedIds.length} 个密钥吗？`;
-            } else if (actionType === 'disable') {
-                message = `确定要禁用选中的 ${selectedIds.length} 个密钥吗？`;
-            } else if (actionType === 'delete') {
-                message = `确定要删除选中的 ${selectedIds.length} 个密钥吗？此操作不可恢复！`;
-            }
-            
-            showConfirmDialog(message, () => {
-                batchOperation(actionType, selectedIds);
-            });
-        });
-    });
-    
-    // 搜索框事件
-    document.getElementById('search-keys').addEventListener('input', (e) => {
-        const searchTerm = e.target.value.toLowerCase();
-        if (searchTerm) {
-            const filteredKeys = keysData.filter(key => 
-                key.name.toLowerCase().includes(searchTerm) || 
-                key.key.toLowerCase().includes(searchTerm)
-            );
-            renderKeysTable(filteredKeys);
-        } else {
-            renderKeysTable(keysData);
-        }
-    });
-    
-    // 管理员密钥显示/隐藏
-    document.getElementById('show-admin-key').addEventListener('click', () => {
-        const adminKeyInput = document.getElementById('admin-key');
-        if (adminKeyInput.type === 'password') {
-            adminKeyInput.type = 'text';
-            document.getElementById('show-admin-key').innerHTML = '<i class="bi bi-eye-slash"></i>';
-        } else {
-            adminKeyInput.type = 'password';
-            document.getElementById('show-admin-key').innerHTML = '<i class="bi bi-eye"></i>';
-        }
-    });
-    
-    // 复制管理员密钥
-    document.getElementById('copy-admin-key').addEventListener('click', () => {
-        const adminKeyInput = document.getElementById('admin-key');
-        adminKeyInput.type = 'text';
-        adminKeyInput.select();
-        document.execCommand('copy');
-        adminKeyInput.type = 'password';
-        showToast('管理员密钥已复制到剪贴板', 'success');
-    });
-    
-    // 设置表单提交
-    document.getElementById('settings-form').addEventListener('submit', async (e) => {
-        e.preventDefault();
-        await saveSettings();
-    });
-    
-    // 批量导入密钥按钮事件
-    document.getElementById('import-keys-btn').addEventListener('click', () => {
-        // 重置导入表单和预览
-        document.getElementById('keys-text').value = '';
-        document.getElementById('keys-file').value = '';
-        document.getElementById('auto-enable-keys').checked = true;
-        document.getElementById('import-preview').style.display = 'none';
-        document.getElementById('confirm-import-btn').disabled = true;
-        importPreviewData = [];
-        
-        // 显示导入模态框
-        const importModal = new bootstrap.Modal(document.getElementById('importKeysModal'));
-        importModal.show();
-    });
-    
-    // 预览导入按钮事件
-    document.getElementById('preview-import-btn').addEventListener('click', previewImport);
-    
-    // 确认导入按钮事件
-    document.getElementById('confirm-import-btn').addEventListener('click', confirmImport);
-    
-    // 文件选择事件
-    document.getElementById('keys-file').addEventListener('change', async (e) => {
-        if (e.target.files.length > 0) {
-            const file = e.target.files[0];
-            const reader = new FileReader();
-            
-            reader.onload = function(event) {
-                document.getElementById('keys-text').value = event.target.result;
-            };
-            
-            reader.readAsText(file);
-        }
-    });
-});
-
-// 检查是否已登录
-function checkAuth() {
-    const savedAdminKey = localStorage.getItem('adminKey');
-    const savedTokenExpiry = localStorage.getItem('tokenExpiry');
-    
-    if (savedAdminKey && savedTokenExpiry) {
-        adminKey = savedAdminKey;
-        tokenExpiry = parseInt(savedTokenExpiry);
-        
-        // 检查token是否已过期
-        if (isTokenValid()) {
-            showAdminPanel();
-            // 初始化其他数据
-            displayAdminKey();
-            loadDashboard(); // 初始加载仪表盘页面
-            
-            // 如果token即将过期（小于5分钟），则刷新
-            const fiveMinutesInMs = 5 * 60 * 1000;
-            if (tokenExpiry - new Date().getTime() < fiveMinutesInMs) {
-                refreshToken();
-            }
-        } else {
-            // token已过期，清除存储并显示登录面板
-            handleLogout();
-            showToast('登录已过期，请重新登录', 'warning');
-        }
-    } else {
-        showLoginPanel();
-    }
-}
-
-// 处理登录
-async function handleLogin() {
-    const inputKey = document.getElementById('admin-key-input').value.trim();
-    if (!inputKey) {
-        showLoginError('请输入管理员密钥');
-        return;
-    }
-    
-    try {
-        // 显示加载状态
-        document.querySelector('#login-form button').disabled = true;
-        document.querySelector('#login-form button').innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 登录中...';
-        
-        // 使用fetch API进行登录请求
-        const response = await fetch('/api/auth/login', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({ admin_key: inputKey })
-        });
-        
-        // 恢复按钮状态
-        document.querySelector('#login-form button').disabled = false;
-        document.querySelector('#login-form button').innerHTML = '登录';
-        
-        if (response.ok) {
-            const data = await response.json();
-            adminKey = data.token;
-            tokenExpiry = new Date().getTime() + (data.expires_in * 1000);
-            
-            // 保存至本地存储
-            localStorage.setItem('adminKey', adminKey);
-            localStorage.setItem('tokenExpiry', tokenExpiry.toString());
-            
-            // 隐藏错误信息
-            document.getElementById('login-error').style.display = 'none';
-            
-            // 显示管理面板
-            showAdminPanel();
-            displayAdminKey();
-            loadDashboard();
-        } else {
-            // 登录失败
-            try {
-                const error = await response.json();
-                showLoginError(error.detail || '登录失败，请检查管理员密钥');
-            } catch {
-                showLoginError('登录失败，请检查管理员密钥');
-            }
-        }
-    } catch (error) {
-        // 处理网络错误等异常
-        document.querySelector('#login-form button').disabled = false;
-        document.querySelector('#login-form button').innerHTML = '登录';
-        console.error('验证管理员密钥失败:', error);
-        showLoginError('验证失败，请稍后再试');
-    }
-}
-
-// 显示登录错误
-function showLoginError(message) {
-    const errorElement = document.getElementById('login-error');
-    errorElement.textContent = message;
-    errorElement.style.display = 'block';
-    
-    // 3秒后自动隐藏
-    setTimeout(() => {
-        errorElement.style.display = 'none';
-    }, 3000);
-}
-
-// 处理登出
-function handleLogout() {
-    localStorage.removeItem('adminKey');
-    localStorage.removeItem('tokenExpiry');
-    adminKey = '';
-    tokenExpiry = null;
-    showLoginPanel();
-    document.getElementById('admin-key-input').value = '';
-}
-
-// 检查token是否有效
-function isTokenValid() {
-    if (!tokenExpiry) return false;
-    // 检查token是否过期（留10秒缓冲）
-    return new Date().getTime() < tokenExpiry - 10000;
-}
-
-// 刷新token
-async function refreshToken() {
-    try {
-        const response = await fetch('/api/auth/refresh', {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${adminKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
-        
-        if (response.ok) {
-            const data = await response.json();
-            adminKey = data.token;
-            tokenExpiry = new Date().getTime() + (data.expires_in * 1000);
-            localStorage.setItem('adminKey', adminKey);
-            localStorage.setItem('tokenExpiry', tokenExpiry.toString());
-            return true;
-        } else {
-            return false;
-        }
-    } catch (error) {
-        console.error('刷新token失败:', error);
-        return false;
-    }
-}
-
-// 显示登录面板
-function showLoginPanel() {
-    document.getElementById('login-container').style.display = 'flex';
-    document.getElementById('admin-panel').style.display = 'none';
-    // 清除可能存在的错误信息
-    document.getElementById('login-error').style.display = 'none';
-}
-
-// 显示管理面板
-function showAdminPanel() {
-    document.getElementById('login-container').style.display = 'none';
-    document.getElementById('admin-panel').style.display = 'flex';
-    
-    // 确保侧边栏正常显示
-    document.getElementById('sidebar').classList.remove('active');
-    document.getElementById('content').classList.remove('active');
-    
-    // 初始化显示仪表盘页面，隐藏其他页面
-    document.querySelectorAll('.content-page').forEach(page => {
-        page.classList.remove('active');
-        page.style.display = 'none';
-    });
-    document.getElementById('dashboard-page').classList.add('active');
-    document.getElementById('dashboard-page').style.display = 'block';
-    
-    // 更新导航栏状态
-    document.querySelectorAll('#sidebar li').forEach(li => li.classList.remove('active'));
-    document.querySelector('#sidebar li:first-child').classList.add('active');
-    
-    // 更新页面标题
-    document.getElementById('current-page-title').textContent = '仪���盘';
-}
-
-// 显示管理员密钥信息
-function displayAdminKey() {
-    // 设置到隐藏输入框
-    document.getElementById('admin-key').value = adminKey;
-    
-    // 显示密钥部分信息
-    const keyDisplay = adminKey.substring(0, 6) + '...' + adminKey.substring(adminKey.length - 4);
-    document.getElementById('admin-key-display').textContent = '管理员: ' + keyDisplay;
-}
-
-// API请求包装函数，处理token刷新逻辑
-async function apiRequest(url, options = {}) {
-    // 检查token是否即将到期（剩余5分钟以内）
-    const fiveMinutesInMs = 5 * 60 * 1000;
-    if (tokenExpiry && (tokenExpiry - new Date().getTime() < fiveMinutesInMs)) {
-        // 刷新token
-        const refreshSuccess = await refreshToken();
-        if (!refreshSuccess) {
-            // token刷新失败，需要重新登录
-            handleLogout();
-            showToast('登录已过期，请重新登录', 'warning');
-            return null;
-        }
-    }
-    
-    // 确保options中包含正确的headers
-    options.headers = options.headers || {};
-    options.headers['Authorization'] = `Bearer ${adminKey}`;
-    
-    // 如果是POST/PUT请求且有body，确保设置正确的Content-Type
-    if ((options.method === 'POST' || options.method === 'PUT') && options.body) {
-        // 确保Content-Type正确设置
-        if (!options.headers['Content-Type']) {
-            options.headers['Content-Type'] = 'application/json';
-        }
-    }
-    
-    // 发送请求
-    try {
-        const response = await fetch(url, options);
-        
-        // 处理401/403错误（未授权）
-        if (response.status === 401 || response.status === 403) {
-            // 尝试刷新token
-            if (await refreshToken()) {
-                // 刷新成功，使用新token重试请求
-                options.headers['Authorization'] = `Bearer ${adminKey}`;
-                const retryResponse = await fetch(url, options);
-                if (retryResponse.ok) {
-                    return await retryResponse.json();
-                }
-            }
-            
-            // 刷新失败或重试失败，需要重新登录
-            handleLogout();
-            showToast('登录已过期，请重新登录', 'warning');
-            return null;
-        }
-        
-        // 其他错误
-        if (!response.ok) {
-            // 尝试解析错误消息
-            try {
-                const errorData = await response.json();
-                throw new Error(`请求失败: ${response.status} - ${errorData.detail || errorData.message || response.statusText}`);
-            } catch (e) {
-                throw new Error(`请求失败: ${response.status} ${response.statusText}`);
-            }
-        }
-        
-        return await response.json();
-    } catch (error) {
-        console.error('API请求错误:', error);
-        showToast(`请求失败: ${error.message}`, 'error');
-        return null;
-    }
-}
-
-// 加载密钥列表
-async function loadKeys() {
-    try {
-        // 显示加载中
-        document.getElementById('keys-table-body').innerHTML = '<tr><td colspan="9" class="text-center">加载中...</td></tr>';
-        
-        const data = await apiRequest('/api/keys');
-        if (data) {
-            keysData = data;
-            renderKeysTable(keysData);
-        }
-    } catch (error) {
-        console.error('加载密钥失败:', error);
-        document.getElementById('keys-table-body').innerHTML = 
-            `<tr><td colspan="9" class="text-center text-danger">加载失败: ${error.message}</td></tr>`;
-    }
-}
-
-// 渲染密钥表格
-function renderKeysTable(keys) {
-    const tableBody = document.getElementById('keys-table-body');
-    tableBody.innerHTML = '';
-    
-    if (keys.length === 0) {
-        tableBody.innerHTML = '<tr><td colspan="9" class="text-center">暂无密钥数据</td></tr>';
-        return;
-    }
-    
-    // 分页处理
-    const startIndex = (currentPage - 1) * keysPerPage;
-    const endIndex = startIndex + keysPerPage;
-    const keysToShow = keys.slice(startIndex, endIndex);
-    
-    // 渲染表格行
-    keysToShow.forEach(key => {
-        const row = document.createElement('tr');
-        
-        // 创建时间和最后使用时间格式化
-        const createDate = key.created_at ? new Date(key.created_at * 1000).toLocaleString() : '未知';
-        const lastUsedDate = key.last_used ? new Date(key.last_used * 1000).toLocaleString() : '从未使用';
-        
-        // 确定密钥状态
-        let statusText = '';
-        let statusClass = '';
-        let statusTitle = '';
-        let remainingTimeText = '';
-        
-        if (key.temp_disabled_until) {
-            // 临时禁用 - 使用格式化后的时间
-            statusText = '临时禁用';
-            statusClass = 'status-temp-disabled';
-            
-            // 优先使用服务器返回的格式化时间
-            const enableTimeText = key.temp_disabled_until_formatted || 
-                                  new Date(key.temp_disabled_until * 1000).toLocaleString();
-            
-            statusTitle = `将于 ${enableTimeText} 恢复`;
-            
-            // 如果有剩余时间信息，添加可读性更强的显示
-            if (key.temp_disabled_remaining !== undefined) {
-                const remainingSecs = key.temp_disabled_remaining;
-                if (remainingSecs > 0) {
-                    // 转换为 小时:分钟:秒 格式
-                    const hours = Math.floor(remainingSecs / 3600);
-                    const minutes = Math.floor((remainingSecs % 3600) / 60);
-                    const seconds = remainingSecs % 60;
-                    
-                    remainingTimeText = `剩余 ${hours}小时${minutes}分钟`;
-                } else {
-                    remainingTimeText = '即将恢复';
-                }
-            }
-        } else if (key.is_enabled) {
-            // 启用
-            statusText = '启用';
-            statusClass = 'status-enabled';
-        } else {
-            // 永久禁用
-            statusText = '禁用';
-            statusClass = 'status-disabled';
-        }
-        
-        row.innerHTML = `
-            <td><input type="checkbox" name="key-checkbox" class="key-checkbox" value="${key.id}" data-id="${key.id}"></td>
-            <td>${key.name || '未命名'}</td>
-            <td class="key-value">${key.key}</td>
-            <td>
-                <span class="status-badge ${statusClass}" title="${statusTitle}">
-                    ${statusText}
-                </span>
-                ${key.temp_disabled_until ? 
-                    `<div class="small text-muted">
-                        启用于: ${key.temp_disabled_until_formatted || new Date(key.temp_disabled_until * 1000).toLocaleString()}
-                        ${remainingTimeText ? `<br>${remainingTimeText}` : ''}
-                    </div>` : ''}
-            </td>
-            <td>${key.weight || 1}</td>
-            <td>${key.max_rpm || 60}/分钟</td>
-            <td>${createDate}</td>
-            <td>${lastUsedDate}</td>
-            <td>
-                <button class="btn btn-sm btn-primary action-btn edit-key" data-id="${key.id}" title="编辑">
-                    <i class="bi bi-pencil"></i>
-                </button>
-                <button class="btn btn-sm btn-danger action-btn delete-key" data-id="${key.id}" title="删除">
-                    <i class="bi bi-trash"></i>
-                </button>
-                <button class="btn btn-sm btn-secondary action-btn copy-key" data-key="${key.key}" title="复制密钥">
-                    <i class="bi bi-clipboard"></i>
-                </button>
-            </td>
-        `;
-        
-        tableBody.appendChild(row);
-    });
-    
-    // 绑定操作按钮事件
-    bindTableEvents();
-    
-    // 更新分页
-    renderPagination(keys.length);
-}
-
-// 绑定表格操作事件
-function bindTableEvents() {
-    // 编辑按钮
-    document.querySelectorAll('.edit-key').forEach(btn => {
-        btn.addEventListener('click', async () => {
-            const keyId = btn.getAttribute('data-id');
-            await loadKeyDetails(keyId);
-            
-            // 显示模态框
-            document.getElementById('keyModalLabel').textContent = '编辑密钥';
-            const keyModal = new bootstrap.Modal(document.getElementById('keyModal'));
-            keyModal.show();
-        });
-    });
-    
-    // 删除按钮
-    document.querySelectorAll('.delete-key').forEach(btn => {
-        btn.addEventListener('click', () => {
-            const keyId = btn.getAttribute('data-id');
-            const keyName = btn.closest('tr').children[1].textContent;
-            
-            showConfirmDialog(`确定要删除密钥 "${keyName}" 吗？此操作不可恢复！`, () => {
-                deleteKey(keyId);
-            });
-        });
-    });
-    
-    // 复制按钮
-    document.querySelectorAll('.copy-key').forEach(btn => {
-        btn.addEventListener('click', () => {
-            const keyValue = btn.getAttribute('data-key');
-            navigator.clipboard.writeText(keyValue)
-                .then(() => showToast('密钥已复制到剪贴板', 'success'))
-                .catch(err => showToast('复制失败: ' + err, 'error'));
-        });
-    });
-}
-
-// 渲染分页
-function renderPagination(totalKeys) {
-    const pagination = document.getElementById('pagination');
-    pagination.innerHTML = '';
-    
-    if (totalKeys <= keysPerPage) {
-        return;
-    }
-    
-    const totalPages = Math.ceil(totalKeys / keysPerPage);
-    const ul = document.createElement('ul');
-    ul.className = 'pagination';
-    
-    // 上一页
-    const prevLi = document.createElement('li');
-    prevLi.className = `page-item ${currentPage === 1 ? 'disabled' : ''}`;
-    prevLi.innerHTML = `<a class="page-link" href="#" data-page="${currentPage - 1}">上一页</a>`;
-    ul.appendChild(prevLi);
-    
-    // 页码
-    for (let i = 1; i <= totalPages; i++) {
-        const li = document.createElement('li');
-        li.className = `page-item ${currentPage === i ? 'active' : ''}`;
-        li.innerHTML = `<a class="page-link" href="#" data-page="${i}">${i}</a>`;
-        ul.appendChild(li);
-    }
-    
-    // 下一页
-    const nextLi = document.createElement('li');
-    nextLi.className = `page-item ${currentPage === totalPages ? 'disabled' : ''}`;
-    nextLi.innerHTML = `<a class="page-link" href="#" data-page="${currentPage + 1}">下一页</a>`;
-    ul.appendChild(nextLi);
-    
-    pagination.appendChild(ul);
-    
-    // 绑定页码点击事件
-    document.querySelectorAll('.page-link').forEach(link => {
-        link.addEventListener('click', (e) => {
-            e.preventDefault();
-            if (link.parentElement.classList.contains('disabled')) {
-                return;
-            }
-            currentPage = parseInt(link.getAttribute('data-page'));
-            renderKeysTable(keysData);
-        });
-    });
-}
-
-// 加载单个密钥详情
-async function loadKeyDetails(keyId) {
-    try {
-        const keyData = await apiRequest(`/api/keys/${keyId}`);
-        if (!keyData) return;
-        
-        // 填充表单
-        document.getElementById('key-id').value = keyData.id;
-        document.getElementById('key-name').value = keyData.name || '';
-        document.getElementById('key-value').value = keyData.key || '';
-        document.getElementById('key-weight').value = keyData.weight || 1;
-        document.getElementById('key-rate-limit').value = keyData.max_rpm || 60;
-        document.getElementById('key-enabled').checked = keyData.is_enabled;
-        document.getElementById('key-notes').value = keyData.notes || '';
-    } catch (error) {
-        console.error('加载密钥详情失败:', error);
-        showToast('加载密钥详情失败: ' + error.message, 'error');
-    }
-}
-
-// 保存密钥
-async function saveKey() {
-    try {
-        const keyId = document.getElementById('key-id').value;
-        const keyData = {
-            name: document.getElementById('key-name').value,
-            key_value: document.getElementById('key-value').value,
-            weight: parseInt(document.getElementById('key-weight').value),
-            rate_limit: parseInt(document.getElementById('key-rate-limit').value),
-            is_enabled: document.getElementById('key-enabled').checked,
-            notes: document.getElementById('key-notes').value
-        };
-        
-        if (!keyData.name || !keyData.key_value) {
-            showToast('密钥名称和值不能为空', 'warning');
-            return;
-        }
-        
-        let url, method;
-        
-        if (keyId) {
-            // 更新现有密钥
-            url = `/api/keys/${keyId}`;
-            method = 'PUT';
-        } else {
-            // 创建新密钥
-            url = '/api/keys';
-            method = 'POST';
-        }
-        
-        const options = {
-            method,
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(keyData)
-        };
-        
-        const result = await apiRequest(url, options);
-        if (!result) return;
-        
-        // 关闭模态框
-        const keyModal = bootstrap.Modal.getInstance(document.getElementById('keyModal'));
-        keyModal.hide();
-        
-        // 重新加载密钥列表
-        await loadKeys();
-        
-        // 如果是仪表盘页面，也更新仪表盘数据
-        if (document.getElementById('dashboard-page').classList.contains('active')) {
-            await loadDashboard();
-        }
-        
-        // 显示成功消息
-        showToast(keyId ? '密钥更新成功' : '密钥添加成功', 'success');
-    } catch (error) {
-        console.error('保存密钥失败:', error);
-        showToast('保存密钥失败: ' + error.message, 'error');
-    }
-}
-
-// 测试密钥连接
-async function testKey() {
-    try {
-        const keyValue = document.getElementById('key-value').value;
-        
-        if (!keyValue) {
-            showToast('请输入有效的密钥值', 'warning');
-            return;
-        }
-        
-        const keyName = document.getElementById('key-name').value || '新密钥';
-        
-        // 显示测试中状态
-        const testButton = document.getElementById('test-key-btn');
-        const originalText = testButton.innerHTML;
-        testButton.innerHTML = '<i class="bi bi-hourglass-split me-1"></i> 测试中...';
-        testButton.disabled = true;
-        
-        const testData = {
-            name: keyName,
-            key_value: keyValue
-        };
-        
-        const result = await apiRequest('/api/keys/test', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(testData)
-        });
-        
-        // 恢复按钮状态
-        testButton.innerHTML = originalText;
-        testButton.disabled = false;
-        
-        if (!result) return;
-        
-        if (result.status === "success") {
-            showToast(`测试成功: ${result.message || '密钥可用'}`, 'success');
-        } else {
-            showToast(`测试失败: ${result.message || '密钥无法连接'}`, 'warning');
-        }
-    } catch (error) {
-        console.error('测试密钥失败:', error);
-        showToast('测试密钥失败: ' + error.message, 'error');
-        
-        // 恢复按钮状态
-        const testButton = document.getElementById('test-key-btn');
-        testButton.innerHTML = '<i class="bi bi-shield-check me-1"></i> 测试连接';
-        testButton.disabled = false;
-    }
-}
-
-// 删除密钥
-async function deleteKey(keyId) {
-    try {
-        const result = await apiRequest(`/api/keys/${keyId}`, {
-            method: 'DELETE'
-        });
-        
-        if (!result) return;
-        
-        // 重新加载密钥列表
-        await loadKeys();
-        
-        // 如果是仪表盘页面，也更新仪表盘数据
-        if (document.getElementById('dashboard-page').classList.contains('active')) {
-            await loadDashboard();
-        }
-        
-        // 显示成功消息
-        showToast('密钥删除成功', 'success');
-    } catch (error) {
-        console.error('删除密钥失败:', error);
-        showToast('删除密钥失败: ' + error.message, 'error');
-    }
-}
-
-// 批量操作
-async function batchOperation(action, keyIds) {
-    try {
-        const operationData = {
-            action: action,
-            key_ids: keyIds
-        };
-        
-        const result = await apiRequest('/api/keys/batch', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(operationData)
-        });
-        
-        if (!result) return;
-        
-        // 重新加载密钥列表
-        await loadKeys();
-        
-        // 如果是仪表盘页面，也更新仪表盘数据
-        if (document.getElementById('dashboard-page').classList.contains('active')) {
-            await loadDashboard();
-        }
-        
-        // 显示成功消息
-        let message = '';
-        if (action === 'enable') {
-            message = '批量启用成功';
-        } else if (action === 'disable') {
-            message = '批量禁用成功';
-        } else if (action === 'delete') {
-            message = '批量删除成功';
-        }
-        
-        showToast(message, 'success');
-    } catch (error) {
-        console.error('批量操作失败:', error);
-        showToast('批量操作失败: ' + error.message, 'error');
-    }
-}
-
-// 获取所有选中的密钥ID
-function getSelectedKeyIds() {
-    const checkboxes = document.querySelectorAll('#keys-table-body input[type="checkbox"]:checked');
-    return Array.from(checkboxes).map(checkbox => checkbox.getAttribute('data-id'));
-}
-
-// 加载统计数据
-async function loadStats() {
-    try {
-        // 显示加载中状态
-        document.getElementById('total-requests').textContent = '加载中...';
-        document.getElementById('successful-requests').textContent = '加载中...';
-        document.getElementById('failed-requests').textContent = '加载中...';
-        document.getElementById('success-rate').textContent = '加载中...';
-        
-        const data = await apiRequest('/api/stats');
-        if (data) {
-            statsData = data;
-            
-            // 渲染统计卡片
-            renderStats();
-            
-            // 渲染图表
-            renderRequestsChart(statsData.daily_usage);
-            renderKeysUsageChart(statsData.keys_usage);
-        }
-    } catch (error) {
-        console.error('加载统计数据失败:', error);
-        
-        // 创建模拟数据
-        statsData = {
-            total_requests: Math.floor(Math.random() * 5000) + 1000,
-            successful_requests: Math.floor(Math.random() * 4000) + 800,
-            daily_usage: generateMockDailyUsage(),
-            keys_usage: generateMockKeysUsage()
-        };
-        
-        // 渲染模拟数据
-        renderStats();
-        renderRequestsChart(statsData.daily_usage);
-        renderKeysUsageChart(statsData.keys_usage);
-    }
-}
-
-// 渲染统计卡片
-function renderStats() {
-    if (!statsData) {
-        // 如果没有统计数据，使用默认值
-        statsData = {
-            total_requests: 0,
-            successful_requests: 0
-        };
-    }
-    
-    const totalRequests = statsData.total_requests || 0;
-    const successfulRequests = statsData.successful_requests || 0;
-    const failedRequests = totalRequests - successfulRequests;
-    const successRate = totalRequests > 0 ? ((successfulRequests / totalRequests) * 100).toFixed(1) + '%' : '0%';
-    
-    // 更新统计卡片
-    document.getElementById('total-requests').textContent = totalRequests;
-    document.getElementById('successful-requests').textContent = successfulRequests;
-    document.getElementById('failed-requests').textContent = failedRequests;
-    document.getElementById('success-rate').textContent = successRate;
-}
-
-// 渲染请求趋势图
-function renderRequestsChart(dailyUsage) {
-    // 准备数据
-    const dates = Object.keys(dailyUsage || {}).sort();
-    const lastDates = dates.slice(-30); // 最近30天
-    
-    const chartData = {
-        labels: lastDates.map(date => date.substring(5)), // 只显示月-日
-        datasets: [{
-            label: '请求数',
-            data: lastDates.map(date => dailyUsage[date] || 0),
-            backgroundColor: 'rgba(13, 110, 253, 0.4)',
-            borderColor: 'rgba(13, 110, 253, 1)',
-            borderWidth: 2
-        }]
-    };
-    
-    // 销毁现有图表
-    if (requestsChart) {
-        requestsChart.destroy();
-    }
-    
-    // 创建新图表
-    const ctx = document.getElementById('requests-chart').getContext('2d');
-    requestsChart = new Chart(ctx, {
-        type: 'bar',
-        data: chartData,
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: {
-                    display: false
-                },
-                tooltip: {
-                    mode: 'index',
-                    intersect: false
-                }
-            },
-            scales: {
-                x: {
-                    grid: {
-                        display: false
-                    }
-                },
-                y: {
-                    beginAtZero: true,
-                    ticks: {
-                        precision: 0
-                    }
-                }
-            }
-        }
-    });
-}
-
-// 渲染密钥使用分布图
-function renderKeysUsageChart(keysUsage) {
-    // 准备数据
-    const keys = Object.keys(keysUsage || {});
-    const values = keys.map(key => keysUsage[key]);
-    
-    // 只显示前8个密钥，其余归为"其他"
-    let displayKeys = keys;
-    let displayValues = values;
-    
-    if (keys.length > 8) {
-        displayKeys = keys.slice(0, 7);
-        displayValues = values.slice(0, 7);
-        
-        // 计算"其他"的总和
-        const othersSum = values.slice(7).reduce((sum, value) => sum + value, 0);
-        displayKeys.push('其他');
-        displayValues.push(othersSum);
-    }
-    
-    // 生成颜色
-    const backgroundColors = [
-        'rgba(13, 110, 253, 0.7)',   // 主蓝色
-        'rgba(220, 53, 69, 0.7)',    // 红色
-        'rgba(25, 135, 84, 0.7)',    // 绿色
-        'rgba(255, 193, 7, 0.7)',    // 黄色
-        'rgba(111, 66, 193, 0.7)',   // 紫色
-        'rgba(23, 162, 184, 0.7)',   // 青色
-        'rgba(102, 16, 242, 0.7)',   // 靛蓝色
-        'rgba(108, 117, 125, 0.7)'   // 灰色
-    ];
-    
-    const chartData = {
-        labels: displayKeys,
-        datasets: [{
-            data: displayValues,
-            backgroundColor: backgroundColors,
-            borderColor: backgroundColors.map(color => color.replace('0.7', '1')),
-            borderWidth: 1
-        }]
-    };
-    
-    // 销毁现有图表
-    if (keysUsageChart) {
-        keysUsageChart.destroy();
-    }
-    
-    // 创建新图表
-    const ctx = document.getElementById('keys-usage-chart').getContext('2d');
-    keysUsageChart = new Chart(ctx, {
-        type: 'pie',
-        data: chartData,
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: {
-                    position: 'right'
-                }
-            }
-        }
-    });
-}
-
-// 加载系统设置
-async function loadSettings() {
-    try {
-        const data = await apiRequest('/api/config');
-        if (!data) return;
-        
-        // 设置现有的代理设置
-        document.getElementById('proxy-host').value = data.PROXY_HOST || '';
-        document.getElementById('proxy-port').value = data.PROXY_PORT || '';
-        document.getElementById('proxy-user').value = data.PROXY_USER || '';
-        document.getElementById('proxy-pass').value = '';
-        
-        // 设置基础URL
-        document.getElementById('base-url').value = data.BASE_URL || '';
-        
-        // 设置图片本地化配置
-        document.getElementById('image-localization').checked = data.IMAGE_LOCALIZATION || false;
-        document.getElementById('image-save-dir').value = data.IMAGE_SAVE_DIR || 'src/static/images';
-    } catch (error) {
-        console.error('加载设置失败:', error);
-        showToast('获取设置失败: ' + error.message, 'error');
-    }
-}
-
-// 保存系统设置
-async function saveSettings() {
-    try {
-        // 获取表单数据
-        const config = {
-            PROXY_HOST: document.getElementById('proxy-host').value,
-            PROXY_PORT: document.getElementById('proxy-port').value,
-            PROXY_USER: document.getElementById('proxy-user').value,
-            PROXY_PASS: document.getElementById('proxy-pass').value,
-            BASE_URL: document.getElementById('base-url').value,
-            IMAGE_LOCALIZATION: document.getElementById('image-localization').checked,
-            IMAGE_SAVE_DIR: document.getElementById('image-save-dir').value || 'src/static/images',
-            save_to_env: true
-        };
-        
-        // 调用API保存到服务器
-        const result = await apiRequest('/api/config', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(config)
-        });
-        
-        if (!result) return;
-        
-        showToast('设置已保存', 'success');
-    } catch (error) {
-        console.error('保存设置失败:', error);
-        showToast('保存设置失败: ' + error.message, 'error');
-    }
-}
-
-// 显示确认对话框
-function showConfirmDialog(message, callback) {
-    document.getElementById('confirm-message').textContent = message;
-    const confirmModal = new bootstrap.Modal(document.getElementById('confirmModal'));
-    
-    // 确认按钮事件
-    document.getElementById('confirm-btn').onclick = () => {
-        confirmModal.hide();
-        if (typeof callback === 'function') {
-            callback();
-        }
-    };
-    
-    confirmModal.show();
-}
-
-// 显示提示消息
-function showToast(message, type = 'info') {
-    // 创建Toast元素
-    const toastId = 'toast-' + Date.now();
-    const toastEl = document.createElement('div');
-    toastEl.className = `toast align-items-center text-white bg-${type}`;
-    toastEl.id = toastId;
-    toastEl.setAttribute('role', 'alert');
-    toastEl.setAttribute('aria-live', 'assertive');
-    toastEl.setAttribute('aria-atomic', 'true');
-    
-    toastEl.innerHTML = `
-        <div class="d-flex">
-            <div class="toast-body">
-                ${message}
-            </div>
-            <button type="button" class="btn-close btn-close-white me-2 m-auto" data-bs-dismiss="toast" aria-label="Close"></button>
-        </div>
-    `;
-    
-    // 添加到容器
-    document.getElementById('toast-container').appendChild(toastEl);
-    
-    // 显示Toast
-    const toast = new bootstrap.Toast(toastEl, {
-        autohide: true,
-        delay: 3000
-    });
-    toast.show();
-    
-    // 监听隐藏事件，删除元素
-    toastEl.addEventListener('hidden.bs.toast', () => {
-        toastEl.remove();
-    });
-}
-
-// 加载仪表盘数据
-async function loadDashboard() {
-    try {
-        // 先加载密钥统计
-        await loadKeyStats();
-        
-        // 再加载使用统计
-        await loadUsageStats();
-        
-        // 加载最近的密钥
-        await loadRecentKeys();
-    } catch (error) {
-        console.error('加载仪表盘数据失败:', error);
-        showToast('仪表盘数据加载失败', 'error');
-    }
-}
-
-// 加载密钥统计
-async function loadKeyStats() {
-    try {
-        const data = await apiRequest('/api/keys');
-        if (!data) return;
-        
-        keysData = data;
-        
-        // 计算统计数据
-        const totalKeys = keysData.length;
-        const activeKeys = keysData.filter(key => key.is_enabled).length;
-        const disabledKeys = totalKeys - activeKeys;
-        
-        // 更新统计卡片
-        document.getElementById('total-keys').textContent = totalKeys;
-        document.getElementById('active-keys').textContent = activeKeys;
-        document.getElementById('disabled-keys').textContent = disabledKeys;
-    } catch (error) {
-        console.error('加载密钥统计失败:', error);
-    }
-}
-
-// 加载使用统计
-async function loadUsageStats() {
-    try {
-        const data = await apiRequest('/api/stats');
-        if (!data) return;
-        
-        // 更新仪表盘统计数据
-        const totalRequests = data.total_requests || 0;
-        const successfulRequests = data.successful_requests || 0;
-        const failedRequests = data.failed_requests || 0;
-        
-        // 更新统计卡片
-        document.getElementById('total-requests').textContent = totalRequests;
-        document.getElementById('successful-requests').textContent = successfulRequests;
-        document.getElementById('failed-requests').textContent = failedRequests;
-        
-        // 计算成功率
-        const successRate = totalRequests > 0 ? Math.round((successfulRequests / totalRequests) * 100) : 0;
-        document.getElementById('success-rate').textContent = `${successRate}%`;
-        
-        // 获取今日使用量
-        const today = new Date().toISOString().split('T')[0];
-        const todayRequests = (data.daily_usage && data.daily_usage[today]) || 0;
-        document.getElementById('today-requests').textContent = todayRequests;
-        
-        // 设置图表数据
-        statsData = data;
-        
-        // 更新图表
-        renderDashboardRequestsChart(data.daily_usage || {});
-        
-        // 渲染请求趋势图和密钥使用分布图
-        renderRequestsChart(data.daily_usage || {});
-        renderKeysUsageChart(data.keys_usage || {});
-        
-        console.log("图表数据已更新:", {
-            daily_usage: data.daily_usage,
-            keys_usage: data.keys_usage
-        });
-    } catch (error) {
-        console.error('加载使用统计失败:', error);
-    }
-}
-
-// 加载最近的密钥
-async function loadRecentKeys() {
-    try {
-        if (!keysData || keysData.length === 0) {
-            const data = await apiRequest('/api/keys');
-            if (!data) return;
-            keysData = data;
-        }
-        
-        // 按创建时间排序，获取最近的5个
-        const recentKeys = [...keysData]
-            .sort((a, b) => (b.created_at || 0) - (a.created_at || 0))
-            .slice(0, 5);
-            
-        const recentKeysList = document.getElementById('recent-keys-list');
-        recentKeysList.innerHTML = '';
-        
-        if (recentKeys.length === 0) {
-            recentKeysList.innerHTML = '<div class="list-group-item text-center text-muted">暂无密钥数据</div>';
-            return;
-        }
-        
-        recentKeys.forEach(key => {
-            const createDate = key.created_at ? new Date(key.created_at * 1000).toLocaleDateString() : '未知';
-            const li = document.createElement('a');
-            li.className = 'list-group-item list-group-item-action d-flex justify-content-between align-items-center';
-            li.href = '#';
-            li.innerHTML = `
-                <div>
-                    <strong>${key.name || '未命名'}</strong>
-                    <div class="text-muted small">${key.key.substring(0, 10)}...</div>
-                </div>
-                <div>
-                    <span class="badge ${key.is_enabled ? 'bg-success' : 'bg-danger'} rounded-pill">
-                        ${key.is_enabled ? '启用' : '禁用'}
-                    </span>
-                    <small class="text-muted ms-2">${createDate}</small>
-                </div>
-            `;
-            recentKeysList.appendChild(li);
-            
-            // 点击跳转到密钥管理页面
-            li.addEventListener('click', (e) => {
-                e.preventDefault();
-                document.querySelector('#sidebar a[data-page="keys"]').click();
-            });
-        });
-    } catch (error) {
-        console.error('加载最近密钥失败:', error);
-    }
-}
-
-// 渲染仪表盘请求趋势图
-function renderDashboardRequestsChart(dailyUsage) {
-    // 获取最近7天的日期
-    const dates = [];
-    const now = new Date();
-    for (let i = 6; i >= 0; i--) {
-        const date = new Date(now);
-        date.setDate(now.getDate() - i);
-        dates.push(date.toISOString().split('T')[0]);
-    }
-    
-    // 准备图表数据
-    const chartData = {
-        labels: dates.map(date => date.substring(5)), // 只显示月-日
-        datasets: [{
-            label: '每日请求数',
-            data: dates.map(date => (dailyUsage && dailyUsage[date]) || 0),
-            borderColor: '#0d6efd',
-            backgroundColor: 'rgba(13, 110, 253, 0.1)',
-            borderWidth: 2,
-            fill: true,
-            tension: 0.3
-        }]
-    };
-    
-    // 销毁现有图表
-    if (dashboardRequestsChart) {
-        dashboardRequestsChart.destroy();
-    }
-    
-    // 创建新图表
-    const ctx = document.getElementById('dashboard-requests-chart').getContext('2d');
-    dashboardRequestsChart = new Chart(ctx, {
-        type: 'line',
-        data: chartData,
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: {
-                    display: false
-                },
-                tooltip: {
-                    mode: 'index',
-                    intersect: false
-                }
-            },
-            scales: {
-                x: {
-                    grid: {
-                        display: false
-                    }
-                },
-                y: {
-                    beginAtZero: true,
-                    ticks: {
-                        precision: 0
-                    }
-                }
-            }
-        }
-    });
-}
-
-// 批量导入密钥预览
-async function previewImport() {
-    const keysText = document.getElementById('keys-text').value.trim();
-    
-    if (!keysText) {
-        showToast('请输入或上传密钥数据', 'warning');
-        return;
-    }
-    
-    try {
-        // 解析密钥数据
-        const lines = keysText.split('\n').filter(line => line.trim());
-        importPreviewData = [];
-        
-        console.log(`开始处理 ${lines.length} 行数据`);
-        
-        for (let i = 0; i < lines.length; i++) {
-            try {
-                const line = lines[i];
-                // 安全获取子字符串
-                const safeSubstring = (str, start, end) => {
-                    if (!str) return '';
-                    return str.substring(start, Math.min(end, str.length));
-                };
-                
-                console.log(`处理第 ${i+1} 行: ${safeSubstring(line, 0, 10)}...`);
-                
-                // 检查是否是单行密钥格式（不包含逗号）
-                if (!line.includes(',')) {
-                    const keyValue = line.trim();
-                    console.log(`  单行格式，密钥值: ${safeSubstring(keyValue, 0, 5)}...`);
-                    
-                    // 几乎不做验证 - 只要不是空字符串或太短就接受
-                    if (!keyValue || keyValue.length < 5) {
-                        console.log(`  密钥太短，跳过`);
-                        continue; // 跳过太短的密钥
-                    }
-                    
-                    // 为密钥自动生成名称（使用前5位）
-                    const keyName = `密钥_${safeSubstring(keyValue, 0, 5)}`;
-                    
-                    importPreviewData.push({
-                        name: keyName,
-                        key: keyValue,
-                        weight: 1,
-                        rate_limit: 60,
-                        enabled: document.getElementById('auto-enable-keys').checked
-                    });
-                    console.log(`  添加到预览数据，当前共 ${importPreviewData.length} 个`);
-                    continue;
-                }
-                
-                // 处理标准格式（带逗号分隔）
-                const parts = line.split(',').map(part => part.trim());
-                console.log(`  标准格式，分割后有 ${parts.length} 部分`);
-                
-                if (parts.length < 2) {
-                    console.log(`  部分数量不足2，跳过`);
-                    continue; // 跳过格式不正确的行
-                }
-                
-                const keyName = parts[0] || `密钥_未命名_${i+1}`;
-                const keyValue = parts[1] || '';
-                const weight = parts.length > 2 ? parseInt(parts[2]) || 1 : 1;
-                const rateLimit = parts.length > 3 ? parseInt(parts[3]) || 60 : 60;
-                
-                console.log(`  名称: ${keyName}, 密钥: ${safeSubstring(keyValue, 0, 5)}..., 权重: ${weight}, 速率: ${rateLimit}`);
-                
-                // 几乎不做验证 - 只要不是空字符串或太短就接受
-                if (!keyValue || keyValue.length < 5) {
-                    console.log(`  密钥太短，跳过`);
-                    continue; // 跳过太短的密钥
-                }
-                
-                importPreviewData.push({
-                    name: keyName,
-                    key: keyValue,
-                    weight: weight,
-                    rate_limit: rateLimit,
-                    enabled: document.getElementById('auto-enable-keys').checked
-                });
-                console.log(`  添加到预览数据，当前共 ${importPreviewData.length} 个`);
-            } catch (lineError) {
-                console.error(`处理第 ${i+1} 行时出错:`, lineError);
-                // 继续处理下一行
-                continue;
-            }
-        }
-        
-        console.log(`处理完成，共有 ${importPreviewData.length} 个有效密钥`);
-        
-        // 显示预览
-        if (importPreviewData.length > 0) {
-            renderImportPreview();
-            document.getElementById('preview-count').textContent = importPreviewData.length;
-            document.getElementById('import-preview').style.display = 'block';
-            document.getElementById('confirm-import-btn').disabled = false;
-            console.log('预览渲染完成，启用导入按钮');
-        } else {
-            showToast('未找到有效的密钥数据', 'warning');
-            document.getElementById('import-preview').style.display = 'none';
-            document.getElementById('confirm-import-btn').disabled = true;
-            console.log('未找到有效密钥，禁用导入按钮');
-        }
-    } catch (error) {
-        console.error('预览导入失败:', error);
-        showToast('预览失败: ' + error.message, 'danger');
-    }
-}
-
-// 渲染导入预览表格
-function renderImportPreview() {
-    const tableBody = document.getElementById('preview-table-body');
-    tableBody.innerHTML = '';
-    
-    // 限制预览最多显示10行
-    const displayData = importPreviewData.slice(0, 10);
-    
-    displayData.forEach(key => {
-        const row = document.createElement('tr');
-        
-        // 名称
-        const nameCell = document.createElement('td');
-        nameCell.textContent = key.name;
-        row.appendChild(nameCell);
-        
-        // 密钥(部分隐藏)
-        const keyCell = document.createElement('td');
-        const maskedKey = key.key.substring(0, 5) + '...' + key.key.substring(key.key.length - 4);
-        keyCell.textContent = maskedKey;
-        row.appendChild(keyCell);
-        
-        // 权重
-        const weightCell = document.createElement('td');
-        weightCell.textContent = key.weight;
-        row.appendChild(weightCell);
-        
-        // 速率限制
-        const rateLimitCell = document.createElement('td');
-        rateLimitCell.textContent = key.rate_limit;
-        row.appendChild(rateLimitCell);
-        
-        tableBody.appendChild(row);
-    });
-    
-    // 如果有更多未显示的行
-    if (importPreviewData.length > 10) {
-        const moreRow = document.createElement('tr');
-        const moreCell = document.createElement('td');
-        moreCell.colSpan = 4;
-        moreCell.textContent = `... 另外 ${importPreviewData.length - 10} 个密钥未在预览中显示`;
-        moreCell.className = 'text-center text-muted';
-        moreRow.appendChild(moreCell);
-        tableBody.appendChild(moreRow);
-    }
-}
-
-// 确认导入密钥
-async function confirmImport() {
-    if (importPreviewData.length === 0) {
-        showToast('没有要导入的密钥', 'warning');
-        return;
-    }
-    
-    try {
-        // 显示加载状态
-        const importBtn = document.getElementById('confirm-import-btn');
-        const originalText = importBtn.textContent;
-        importBtn.disabled = true;
-        importBtn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 导入中...';
-        
-        console.log('准备发送批量导入请求，数据预览：', importPreviewData.slice(0, 2));
-        
-        // 简化数据处理
-        const requestData = {
-            action: "import",
-            keys: []
-        };
-        
-        // 手动将每个importPreviewData项转换为普通对象
-        for (const item of importPreviewData) {
-            requestData.keys.push({
-                name: item.name || "",
-                key: item.key || "",
-                weight: item.weight || 1,
-                rate_limit: item.rate_limit || 60,
-                enabled: item.enabled !== undefined ? item.enabled : true
-            });
-        }
-        
-        console.log('发送请求到 /api/keys/batch，请求数据：', requestData);
-        
-        // 发送请求
-        const response = await apiRequest('/api/keys/batch', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(requestData)
-        });
-        
-        console.log('收到批量导入响应：', response);
-        
-        if (response && response.success) {
-            // 隐藏模态框
-            bootstrap.Modal.getInstance(document.getElementById('importKeysModal')).hide();
-            
-            // 刷新密钥列表
-            await loadKeys();
-            
-            // 显示成功消息
-            const successCount = response.imported || importPreviewData.length;
-            const skippedCount = response.skipped || 0;
-            let message = `成功导入 ${successCount} 个密钥`;
-            if (skippedCount > 0) {
-                message += `，${skippedCount} 个重复密钥已跳过`;
-            }
-            showToast(message, 'success');
-            console.log('导入成功完成');
-        } else {
-            const errorMsg = (response && response.message) ? response.message : '未知错误';
-            showToast('导入失败: ' + errorMsg, 'danger');
-            console.error('导入失败，服务器响应：', response);
-        }
-    } catch (error) {
-        console.error('导入过程中发生异常:', error);
-        showToast('导入失败: ' + error.message, 'danger');
-    } finally {
-        // 恢复按钮状态
-        const importBtn = document.getElementById('confirm-import-btn');
-        importBtn.disabled = false;
-        importBtn.textContent = '导入';
-    }
-} 

sora-api-master/src/utils.py

@@ -1,208 +0,0 @@
-import os
-import uuid
-import aiohttp
-import aiofiles
-import logging
-import ssl
-from urllib.parse import urlparse
-from .config import Config
-
-# 初始化日志
-logger = logging.getLogger("sora-api.utils")
-
-# 图片本地化调试开关
-IMAGE_DEBUG = os.getenv("IMAGE_DEBUG", "").lower() in ("true", "1", "yes")
-
-# 修复Python 3.11之前版本中HTTPS代理处理HTTPS请求的问题
-# 参考: https://docs.aiohttp.org/en/stable/client_advanced.html#proxy-support
-try:
-    import aiohttp.connector
-    orig_create_connection = aiohttp.connector.TCPConnector._create_connection
-
-    async def patched_create_connection(self, req, traces, timeout):
-        if req.ssl and req.proxy and req.proxy.scheme == 'https':
-            # 为代理连接创建SSL上下文
-            proxy_ssl = ssl.create_default_context()
-            req.proxy_ssl = proxy_ssl
-            
-            if IMAGE_DEBUG:
-                logger.debug("已应用HTTPS代理补丁")
-        
-        return await orig_create_connection(self, req, traces, timeout)
-    
-    # 应用猴子补丁
-    aiohttp.connector.TCPConnector._create_connection = patched_create_connection
-    
-    if IMAGE_DEBUG:
-        logger.debug("已启用aiohttp HTTPS代理支持补丁")
-except Exception as e:
-    logger.warning(f"应用HTTPS代理补丁失败: {e}")
-
-async def download_and_save_image(image_url: str) -> str:
-    """
-    下载图片并保存到本地
-    
-    Args:
-        image_url: 图片URL
-        
-    Returns:
-        本地化后的图片URL
-    """
-    # 如果未启用本地化或URL已经是本地路径，直接返回
-    if not Config.IMAGE_LOCALIZATION:
-        if IMAGE_DEBUG:
-            logger.debug(f"图片本地化未启用，返回原始URL: {image_url}")
-        return image_url
-    
-    # 检查是否已经是本地URL
-    # 准备URL检测所需的信息
-    parsed_base_url = urlparse(Config.BASE_URL)
-    base_path = parsed_base_url.path.rstrip('/')
-    
-    # 直接检查常见的图片URL模式
-    local_url_patterns = [
-        "/images/",
-        "/static/images/",
-        f"{base_path}/images/",
-        f"{base_path}/static/images/"
-    ]
-    
-    # 检查是否有自定义前缀
-    if Config.STATIC_PATH_PREFIX:
-        prefix = Config.STATIC_PATH_PREFIX
-        if not prefix.startswith('/'):
-            prefix = f"/{prefix}"
-        local_url_patterns.append(f"{prefix}/images/")
-        local_url_patterns.append(f"{base_path}{prefix}/images/")
-    
-    # 检查是否符合任何本地URL模式
-    is_local_url = any(pattern in image_url for pattern in local_url_patterns)
-    
-    if is_local_url:
-        if IMAGE_DEBUG:
-            logger.debug(f"URL已是本地图片路径: {image_url}")
-        
-        # 如果是相对路径，补充完整的URL
-        if image_url.startswith("/"):
-            return f"{parsed_base_url.scheme}://{parsed_base_url.netloc}{image_url}"
-        return image_url
-    
-    try:
-        # 生成文件名和保存路径
-        parsed_url = urlparse(image_url)
-        file_extension = os.path.splitext(parsed_url.path)[1] or ".png"
-        filename = f"{uuid.uuid4()}{file_extension}"
-        save_path = os.path.join(Config.IMAGE_SAVE_DIR, filename)
-        
-        # 确保保存目录存在
-        os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-        
-        if IMAGE_DEBUG:
-            logger.debug(f"下载图片: {image_url} -> {save_path}")
-        
-        # 配置代理
-        proxy = None
-        if Config.PROXY_HOST and Config.PROXY_PORT:
-            proxy_auth = None
-            if Config.PROXY_USER and Config.PROXY_PASS:
-                proxy_auth = aiohttp.BasicAuth(Config.PROXY_USER, Config.PROXY_PASS)
-            
-            proxy_url = f"http://{Config.PROXY_HOST}:{Config.PROXY_PORT}"
-            if IMAGE_DEBUG:
-                auth_info = f" (使用认证)" if proxy_auth else ""
-                logger.debug(f"使用代理: {proxy_url}{auth_info}")
-            proxy = proxy_url
-        
-        # 下载图片
-        timeout = aiohttp.ClientTimeout(total=60)
-        async with aiohttp.ClientSession(timeout=timeout) as session:
-            # 创建请求参数
-            request_kwargs = {"timeout": 30}
-            if proxy:
-                request_kwargs["proxy"] = proxy
-                if Config.PROXY_USER and Config.PROXY_PASS:
-                    request_kwargs["proxy_auth"] = aiohttp.BasicAuth(Config.PROXY_USER, Config.PROXY_PASS)
-            
-            async with session.get(image_url, **request_kwargs) as response:
-                if response.status != 200:
-                    logger.warning(f"下载失败，状态码: {response.status}, URL: {image_url}")
-                    return image_url
-                
-                content = await response.read()
-                if not content:
-                    logger.warning("下载内容为空")
-                    return image_url
-                
-                # 保存图片
-                async with aiofiles.open(save_path, "wb") as f:
-                    await f.write(content)
-        
-        # 检查文件是否成功保存
-        if not os.path.exists(save_path) or os.path.getsize(save_path) == 0:
-            logger.warning(f"图片保存失败: {save_path}")
-            if os.path.exists(save_path):
-                os.remove(save_path)
-            return image_url
-        
-        # 返回本地URL
-        # 获取文件名
-        filename = os.path.basename(save_path)
-        
-        # 解析基础URL
-        parsed_base_url = urlparse(Config.BASE_URL)
-        base_path = parsed_base_url.path.rstrip('/')
-        
-        # 使用固定的图片URL格式
-        relative_url = f"/images/{filename}"
-        
-        # 如果设置了STATIC_PATH_PREFIX，优先使用该前缀
-        if Config.STATIC_PATH_PREFIX:
-            prefix = Config.STATIC_PATH_PREFIX
-            if not prefix.startswith('/'):
-                prefix = f"/{prefix}"
-            relative_url = f"{prefix}/images/{filename}"
-        
-        # 如果BASE_URL有子路径，添加到相对路径前
-        if base_path:
-            relative_url = f"{base_path}{relative_url}"
-        
-        # 处理重复斜杠
-        while "//" in relative_url:
-            relative_url = relative_url.replace("//", "/")
-        
-        # 生成完整URL
-        full_url = f"{parsed_base_url.scheme}://{parsed_base_url.netloc}{relative_url}"
-        
-        if IMAGE_DEBUG:
-            logger.debug(f"图片保存成功: {full_url}")
-            logger.debug(f"图片保存路径: {save_path}")
-        
-        return full_url
-    except Exception as e:
-        logger.error(f"图片下载失败: {str(e)}", exc_info=IMAGE_DEBUG)
-        return image_url
-
-async def localize_image_urls(image_urls: list) -> list:
-    """
-    批量将图片URL本地化
-    
-    Args:
-        image_urls: 图片URL列表
-        
-    Returns:
-        本地化后的URL列表
-    """
-    if not Config.IMAGE_LOCALIZATION or not image_urls:
-        return image_urls
-    
-    if IMAGE_DEBUG:
-        logger.debug(f"本地化 {len(image_urls)} 个URL: {image_urls}")
-    else:
-        logger.info(f"本地化 {len(image_urls)} 个图片")
-    
-    localized_urls = []
-    for url in image_urls:
-        localized_url = await download_and_save_image(url)
-        localized_urls.append(localized_url)
-    
-    return localized_urls 

sora-api-master/test_client.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import requests
-import json
-import time
-import sys
-import base64
-import os
-
-# 设置UTF-8编码
-if sys.platform.startswith('win'):
-    os.system("chcp 65001")
-    if hasattr(sys.stdout, 'reconfigure'):
-        sys.stdout.reconfigure(encoding='utf-8')
-
-API_URL = "http://127.0.0.1:8890/v1/chat/completions"
-API_KEY = "sk-123456"  # 替换为实际的API key
-
-def test_text_to_image(prompt="生成一只可爱的猫咪", stream=False):
-    """测试文本到图像生成"""
-    print(f"\n===== 测试文本到图像生成 =====")
-    try:
-        print(f"提示词: '{prompt}'")
-    except UnicodeEncodeError:
-        print(f"提示词: [包含非ASCII字符]")
-    print(f"流式响应: {stream}")
-    
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {API_KEY}"
-    }
-    
-    payload = {
-        "model": "sora-1.0",
-        "messages": [
-            {"role": "user", "content": prompt}
-        ],
-        "n": 1,
-        "stream": stream
-    }
-    
-    start_time = time.time()
-    response = requests.post(
-        API_URL,
-        headers=headers,
-        json=payload,
-        stream=stream
-    )
-    
-    if response.status_code != 200:
-        print(f"错误: 状态码 {response.status_code}")
-        print(response.text)
-        return
-    
-    if stream:
-        # 处理流式响应
-        print("流式响应内容:")
-        for line in response.iter_lines():
-            if line:
-                line = line.decode('utf-8')
-                if line.startswith("data: "):
-                    data = line[6:]
-                    if data == "[DONE]":
-                        print("[完成]")
-                    else:
-                        try:
-                            json_data = json.loads(data)
-                            if 'choices' in json_data and json_data['choices'] and 'delta' in json_data['choices'][0]:
-                                delta = json_data['choices'][0]['delta']
-                                if 'content' in delta:
-                                    print(f"接收内容: {delta['content']}")
-                        except Exception as e:
-                            print(f"解析响应时出错: {e}")
-    else:
-        # 处理普通响应
-        try:
-            data = response.json()
-            print(f"响应内容:")
-            print(json.dumps(data, indent=2, ensure_ascii=False))
-            
-            if 'choices' in data and data['choices']:
-                image_url = None
-                content = data['choices'][0]['message']['content']
-                if "![Generated Image](" in content:
-                    image_url = content.split("![Generated Image](")[1].split(")")[0]
-                    print(f"\n生成的图片URL: {image_url}")
-        except Exception as e:
-            print(f"解析响应时出错: {e}")
-    
-    elapsed = time.time() - start_time
-    print(f"请求耗时: {elapsed:.2f}秒")
-
-def test_image_to_image(image_path, prompt="将这张图片变成动漫风格"):
-    """测试图像到图像生成（Remix）"""
-    print(f"\n===== 测试图像到图像生成 =====")
-    print(f"图片路径: '{image_path}'")
-    print(f"提示词: '{prompt}'")
-    
-    # 读取并转换图片为base64
-    try:
-        with open(image_path, "rb") as image_file:
-            base64_image = base64.b64encode(image_file.read()).decode('utf-8')
-    except Exception as e:
-        print(f"读取图片失败: {e}")
-        return
-    
-    # 构建请求
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {API_KEY}"
-    }
-    
-    payload = {
-        "model": "sora-1.0",
-        "messages": [
-            {"role": "user", "content": f"data:image/jpeg;base64,{base64_image}\n{prompt}"}
-        ],
-        "n": 1,
-        "stream": False
-    }
-    
-    start_time = time.time()
-    response = requests.post(
-        API_URL,
-        headers=headers,
-        json=payload
-    )
-    
-    if response.status_code != 200:
-        print(f"错误: 状态码 {response.status_code}")
-        print(response.text)
-        return
-    
-    # 处理响应
-    try:
-        data = response.json()
-        print(f"响应内容:")
-        print(json.dumps(data, indent=2, ensure_ascii=False))
-        
-        if 'choices' in data and data['choices']:
-            image_url = None
-            content = data['choices'][0]['message']['content']
-            if "![Generated Image](" in content:
-                image_url = content.split("![Generated Image](")[1].split(")")[0]
-                print(f"\n生成的图片URL: {image_url}")
-    except Exception as e:
-        print(f"解析响应时出错: {e}")
-    
-    elapsed = time.time() - start_time
-    print(f"请求耗时: {elapsed:.2f}秒")
-
-def main():
-    """主函数"""
-    if len(sys.argv) < 2:
-        print("用法: python test_client.py <测试类型> [参数...]")
-        print("测试类型:")
-        print("  text2img <提示词> [stream=true/false]")
-        print("  img2img <图片路径> <提示词>")
-        return
-    
-    test_type = sys.argv[1].lower()
-    
-    if test_type == "text2img":
-        prompt = sys.argv[2] if len(sys.argv) > 2 else "生成一只可爱的猫咪"
-        stream = False
-        if len(sys.argv) > 3 and sys.argv[3].lower() == "stream=true":
-            stream = True
-        test_text_to_image(prompt, stream)
-    elif test_type == "img2img":
-        if len(sys.argv) < 3:
-            print("错误: 需要图片路径")
-            return
-        image_path = sys.argv[2]
-        prompt = sys.argv[3] if len(sys.argv) > 3 else "将这张图片变成动漫风格"
-        test_image_to_image(image_path, prompt)
-    else:
-        print(f"错误: 未知的测试类型 '{test_type}'")
-
-if __name__ == "__main__":
-    main() 

sora-api-master/test_image_download.py

@@ -1,131 +0,0 @@
-import asyncio
-import os
-import sys
-import logging
-
-# 配置日志
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-
-# 添加src目录到Python路径
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from src.utils import download_and_save_image, localize_image_urls
-from src.config import Config
-
-# 设置为True启用本地化
-Config.IMAGE_LOCALIZATION = True
-# 打开调试日志
-os.environ["IMAGE_DEBUG"] = "true"
-# 确保目录存在
-os.makedirs(Config.IMAGE_SAVE_DIR, exist_ok=True)
-
-async def test_single_download():
-    """测试单个图片下载"""
-    # 使用一个可靠的图片URL进行测试
-    test_url = "https://pic.baidu.com/feed/b90e7bec54e736d1f9ddbe94c2691f254d4ade13.jpeg"
-    print(f"测试单个图片下载: {test_url}")
-    
-    local_url = await download_and_save_image(test_url)
-    print(f"下载结果: {local_url}")
-    
-    # 检查文件是否真的下载了
-    if local_url.startswith("http"):
-        # 处理完整URL的情况
-        url_path = local_url.split(Config.BASE_URL, 1)[-1]
-        if url_path.startswith("/static/"):
-            relative_path = url_path[len("/static/"):]
-            file_path = os.path.join(Config.STATIC_DIR, relative_path)
-            print(f"完整URL转换为文件路径: {file_path}")
-            
-            if os.path.exists(file_path):
-                print(f"文件存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
-            else:
-                print(f"文件不存在: {file_path}")
-                # 尝试查找可能的文件
-                dir_path = os.path.dirname(file_path)
-                if os.path.exists(dir_path):
-                    print(f"目录存在: {dir_path}")
-                    print(f"目录内容: {os.listdir(dir_path)}")
-                else:
-                    print(f"目录不存在: {dir_path}")
-        else:
-            print(f"URL格式异常: {local_url}")
-    elif local_url.startswith("/static/"):
-        # 从URL恢复实际的文件路径
-        relative_path = local_url[len("/static/"):]
-        file_path = os.path.join(Config.STATIC_DIR, relative_path)
-        print(f"相对URL转换为文件路径: {file_path}")
-        
-        if os.path.exists(file_path):
-            print(f"文件存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
-        else:
-            print(f"文件不存在: {file_path}")
-    else:
-        print("下载失败，返回了原始URL")
-
-async def test_multiple_downloads():
-    """测试多个图片下载"""
-    test_urls = [
-        "https://pic.baidu.com/feed/b90e7bec54e736d1f9ddbe94c2691f254d4ade13.jpeg",
-        "https://pic1.zhimg.com/v2-b78b719d8782ad5146851b87bbd3a9fb_r.jpg"
-    ]
-    print(f"\n测试多个图片下载: {test_urls}")
-    
-    local_urls = await localize_image_urls(test_urls)
-    
-    print(f"本地化结果: {local_urls}")
-    
-    # 验证所有文件是否下载成功
-    for i, url in enumerate(local_urls):
-        print(f"\n检查文件 {i+1}:")
-        if url.startswith("http"):
-            # 处理完整URL的情况
-            if url.startswith(Config.BASE_URL):
-                url_path = url.split(Config.BASE_URL, 1)[-1]
-                if url_path.startswith("/static/"):
-                    relative_path = url_path[len("/static/"):]
-                    file_path = os.path.join(Config.STATIC_DIR, relative_path)
-                    print(f"完整URL转换为文件路径: {file_path}")
-                    
-                    if os.path.exists(file_path):
-                        print(f"文件 {i+1} 存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
-                    else:
-                        print(f"文件 {i+1} 不存在: {file_path}")
-                        # 尝试查找可能的文件
-                        dir_path = os.path.dirname(file_path)
-                        if os.path.exists(dir_path):
-                            print(f"目录存在: {dir_path}")
-                            print(f"目录内容: {os.listdir(dir_path)}")
-                        else:
-                            print(f"目录不存在: {dir_path}")
-                else:
-                    print(f"URL格式异常: {url}")
-            else:
-                print(f"文件 {i+1} 下载失败，返回了原始URL: {url}")
-        elif url.startswith("/static/"):
-            # 从URL恢复实际的文件路径
-            relative_path = url[len("/static/"):]
-            file_path = os.path.join(Config.STATIC_DIR, relative_path)
-            print(f"相对URL转换为文件路径: {file_path}")
-            
-            if os.path.exists(file_path):
-                print(f"文件 {i+1} 存在: {file_path}, 大小: {os.path.getsize(file_path)} 字节")
-            else:
-                print(f"文件 {i+1} 不存在: {file_path}")
-        else:
-            print(f"文件 {i+1} 下载失败，返回了原始URL: {url}")
-
-async def main():
-    print(f"配置信息:")
-    print(f"IMAGE_LOCALIZATION: {Config.IMAGE_LOCALIZATION}")
-    print(f"STATIC_DIR: {Config.STATIC_DIR}")
-    print(f"IMAGE_SAVE_DIR: {Config.IMAGE_SAVE_DIR}")
-    
-    await test_single_download()
-    await test_multiple_downloads()
-
-if __name__ == "__main__":
-    asyncio.run(main())