![](\"https://example.com/image.jpg\")
"
+ },
+ "finish_reason": "stop"
+ }
+ ],
+ "usage": {
+ "prompt_tokens": 10,
+ "completion_tokens": 0,
+ "total_tokens": 10
+ }
+}
+```
+
+---
+
+## 🏗️ 架构设计
+
+### 系统架构
+
+```
+┌─────────────────────────────────────────┐
+│ 前端 (Web UI) │
+│ • Vue3 管理界面 │
+│ • Token 管理 │
+│ • 配置管理 │
+└─────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────┐
+│ API 层 (FastAPI) │
+│ • OpenAI 兼容接口 │
+│ • 管理接口 │
+│ • 认证授权 │
+└─────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────┐
+│ 业务层 (Services) │
+│ • Token 管理 │
+│ • 负载均衡 │
+│ • 生成处理 │
+│ • 日志记录 │
+└─────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────┐
+│ 数据层 (SQLite) │
+│ • Token 存储 │
+│ • 任务记录 │
+│ • 日志存储 │
+└─────────────────────────────────────────┘
+ ↓
+┌─────────────────────────────────────────┐
+│ Sora API (上游) │
+│ • 图片生成 │
+│ • 视频生成 │
+└─────────────────────────────────────────┘
+```
+
+## 📄 许可证
+
+本项目采用 MIT 许可证。详见 [LICENSE](LICENSE) 文件。
+
+---
+
+## 🙏 致谢
+
+感谢所有贡献者和使用者的支持！
+
+---
+
+## 📞 联系方式
+
+- 提交 Issue：[GitHub Issues](https://github.com/TheSmallHanCat/sora2api/issues)
+- 讨论：[GitHub Discussions](https://github.com/TheSmallHanCat/sora2api/discussions)
+
+---
+
+**⭐ 如果这个项目对你有帮助，请给个 Star！**
diff --git a/config/setting.toml b/config/setting.toml
new file mode 100644
index 0000000..2bd9873
--- /dev/null
+++ b/config/setting.toml
@@ -0,0 +1,47 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[sora]
+base_url = "https://sora.chatgpt.com/backend"
+timeout = 120
+max_retries = 3
+poll_interval = 2.5
+max_poll_attempts = 600
+
+[server]
+host = "0.0.0.0"
+port = 8000
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[cache]
+timeout = 600
+base_url = "http://127.0.0.1:8000"
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+video_cooldown_threshold = 30
+error_ban_threshold = 3
+
+[proxy]
+proxy_enabled = false
+proxy_url = ""
+
+[watermark_free]
+watermark_free_enabled = false
+
+[video_length]
+default_length = "10s"
+
+[video_length.lengths]
+10s = 300
+15s = 450
diff --git a/config/setting_warp.toml b/config/setting_warp.toml
new file mode 100644
index 0000000..a56e87e
--- /dev/null
+++ b/config/setting_warp.toml
@@ -0,0 +1,47 @@
+[global]
+api_key = "han1234"
+admin_username = "admin"
+admin_password = "admin"
+
+[sora]
+base_url = "https://sora.chatgpt.com/backend"
+timeout = 120
+max_retries = 3
+poll_interval = 2.5
+max_poll_attempts = 600
+
+[server]
+host = "0.0.0.0"
+port = 8000
+
+[debug]
+enabled = false
+log_requests = true
+log_responses = true
+mask_token = true
+
+[cache]
+timeout = 600
+base_url = "http://127.0.0.1:8000"
+
+[generation]
+image_timeout = 300
+video_timeout = 1500
+
+[admin]
+video_cooldown_threshold = 30
+error_ban_threshold = 3
+
+[proxy]
+proxy_enabled = true
+proxy_url = "socks5://warp:1080"
+
+[watermark_free]
+watermark_free_enabled = false
+
+[video_length]
+default_length = "10s"
+
+[video_length.lengths]
+10s = 300
+15s = 450
diff --git a/docker-compose.warp.yml b/docker-compose.warp.yml
new file mode 100644
index 0000000..a654edc
--- /dev/null
+++ b/docker-compose.warp.yml
@@ -0,0 +1,36 @@
+version: '3.8'
+
+services:
+ sora2api:
+ image: thesmallhancat/sora2api:1.0
+ container_name: sora2api
+ ports:
+ - "8000:8000"
+ volumes:
+ - ./data:/app/data
+ - ./config/setting_warp.toml:/app/config/setting.toml
+ environment:
+ - PYTHONUNBUFFERED=1
+ restart: unless-stopped
+ depends_on:
+ - warp
+
+ warp:
+ image: caomingjun/warp
+ container_name: warp
+ restart: always
+ devices:
+ - /dev/net/tun:/dev/net/tun
+ ports:
+ - "1080:1080"
+ environment:
+ - WARP_SLEEP=2
+ cap_add:
+ - MKNOD
+ - AUDIT_WRITE
+ - NET_ADMIN
+ sysctls:
+ - net.ipv6.conf.all.disable_ipv6=0
+ - net.ipv4.conf.all.src_valid_mark=1
+ volumes:
+ - ./data:/var/lib/cloudflare-warp
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..8156629
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+ sora2api:
+ image: thesmallhancat/sora2api:1.0
+ container_name: sora2api
+ ports:
+ - "8000:8000"
+ volumes:
+ - ./data:/app/data
+ - ./config/setting.toml:/app/config/setting.toml
+ environment:
+ - PYTHONUNBUFFERED=1
+ restart: unless-stopped
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..50865d4
--- /dev/null
+++ b/main.py
@@ -0,0 +1,12 @@
+"""Application launcher script"""
+import uvicorn
+from src.core.config import config
+
+if __name__ == "__main__":
+ uvicorn.run(
+ "src.main:app",
+ host=config.server_host,
+ port=config.server_port,
+ reload=False
+ )
+
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..5c01f5f
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,12 @@
+fastapi==0.119.0
+uvicorn[standard]==0.32.1
+curl-cffi==0.13.0
+pyjwt==2.10.1
+python-multipart==0.0.20
+aiosqlite==0.20.0
+bcrypt==4.2.1
+python-dotenv==1.0.1
+pydantic==2.10.4
+pydantic-settings==2.7.0
+tomli==2.2.1
+toml
\ No newline at end of file
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000..0f1263c
--- /dev/null
+++ b/src/__init__.py
@@ -0,0 +1,4 @@
+"""Sora2API - OpenAI compatible Sora API proxy service"""
+
+__version__ = "1.0.0"
+
diff --git a/src/api/__init__.py b/src/api/__init__.py
new file mode 100644
index 0000000..516688b
--- /dev/null
+++ b/src/api/__init__.py
@@ -0,0 +1,7 @@
+"""API routes module"""
+
+from .routes import router as api_router
+from .admin import router as admin_router
+
+__all__ = ["api_router", "admin_router"]
+
diff --git a/src/api/admin.py b/src/api/admin.py
new file mode 100644
index 0000000..e317ce2
--- /dev/null
+++ b/src/api/admin.py
@@ -0,0 +1,831 @@
+"""Admin routes - Management endpoints"""
+from fastapi import APIRouter, HTTPException, Depends, Header
+from typing import List, Optional
+from datetime import datetime
+from pathlib import Path
+import secrets
+import toml
+from pydantic import BaseModel
+from ..core.auth import AuthManager
+from ..core.config import config
+from ..services.token_manager import TokenManager
+from ..services.proxy_manager import ProxyManager
+from ..core.database import Database
+from ..core.models import Token, AdminConfig, ProxyConfig
+
+router = APIRouter()
+
+# Dependency injection
+token_manager: TokenManager = None
+proxy_manager: ProxyManager = None
+db: Database = None
+generation_handler = None
+
+# Store active admin tokens (in production, use Redis or database)
+active_admin_tokens = set()
+
+def set_dependencies(tm: TokenManager, pm: ProxyManager, database: Database, gh=None):
+ """Set dependencies"""
+ global token_manager, proxy_manager, db, generation_handler
+ token_manager = tm
+ proxy_manager = pm
+ db = database
+ generation_handler = gh
+
+def verify_admin_token(authorization: str = Header(None)):
+ """Verify admin token from Authorization header"""
+ if not authorization:
+ raise HTTPException(status_code=401, detail="Missing authorization header")
+
+ # Support both "Bearer token" and "token" formats
+ token = authorization
+ if authorization.startswith("Bearer "):
+ token = authorization[7:]
+
+ if token not in active_admin_tokens:
+ raise HTTPException(status_code=401, detail="Invalid or expired token")
+
+ return token
+
+# Request/Response models
+class LoginRequest(BaseModel):
+ username: str
+ password: str
+
+class LoginResponse(BaseModel):
+ success: bool
+ token: Optional[str] = None
+ message: Optional[str] = None
+
+class AddTokenRequest(BaseModel):
+ token: str # Access Token (AT)
+ st: Optional[str] = None # Session Token (optional, for storage)
+ rt: Optional[str] = None # Refresh Token (optional, for storage)
+ remark: Optional[str] = None
+
+class ST2ATRequest(BaseModel):
+ st: str # Session Token
+
+class RT2ATRequest(BaseModel):
+ rt: str # Refresh Token
+
+class UpdateTokenStatusRequest(BaseModel):
+ is_active: bool
+
+class UpdateTokenRequest(BaseModel):
+ token: Optional[str] = None # Access Token
+ st: Optional[str] = None
+ rt: Optional[str] = None
+ remark: Optional[str] = None
+
+class UpdateAdminConfigRequest(BaseModel):
+ video_cooldown_threshold: int
+ error_ban_threshold: int
+
+class UpdateProxyConfigRequest(BaseModel):
+ proxy_enabled: bool
+ proxy_url: Optional[str] = None
+
+class UpdateAdminPasswordRequest(BaseModel):
+ old_password: str
+ new_password: str
+ username: Optional[str] = None # Optional: new username
+
+class UpdateAPIKeyRequest(BaseModel):
+ new_api_key: str
+
+class UpdateDebugConfigRequest(BaseModel):
+ enabled: bool
+
+class UpdateCacheTimeoutRequest(BaseModel):
+ timeout: int # Cache timeout in seconds
+
+class UpdateCacheBaseUrlRequest(BaseModel):
+ base_url: str # Cache base URL (e.g., https://yourdomain.com)
+
+class UpdateGenerationTimeoutRequest(BaseModel):
+ image_timeout: Optional[int] = None # Image generation timeout in seconds
+ video_timeout: Optional[int] = None # Video generation timeout in seconds
+
+class UpdateWatermarkFreeConfigRequest(BaseModel):
+ watermark_free_enabled: bool
+
+class UpdateVideoLengthConfigRequest(BaseModel):
+ default_length: str # "10s" or "15s"
+
+# Auth endpoints
+@router.post("/api/login", response_model=LoginResponse)
+async def login(request: LoginRequest):
+ """Admin login"""
+ if AuthManager.verify_admin(request.username, request.password):
+ # Generate simple token
+ token = f"admin-{secrets.token_urlsafe(32)}"
+ # Store token in active tokens
+ active_admin_tokens.add(token)
+ return LoginResponse(success=True, token=token, message="Login successful")
+ else:
+ return LoginResponse(success=False, message="Invalid credentials")
+
+@router.post("/api/logout")
+async def logout(token: str = Depends(verify_admin_token)):
+ """Admin logout"""
+ # Remove token from active tokens
+ active_admin_tokens.discard(token)
+ return {"success": True, "message": "Logged out successfully"}
+
+# Token management endpoints
+@router.get("/api/tokens")
+async def get_tokens(token: str = Depends(verify_admin_token)) -> List[dict]:
+ """Get all tokens with statistics"""
+ tokens = await token_manager.get_all_tokens()
+ result = []
+
+ for token in tokens:
+ stats = await db.get_token_stats(token.id)
+ result.append({
+ "id": token.id,
+ "token": token.token, # 完整的Access Token
+ "st": token.st, # 完整的Session Token
+ "rt": token.rt, # 完整的Refresh Token
+ "email": token.email,
+ "name": token.name,
+ "remark": token.remark,
+ "expiry_time": token.expiry_time.isoformat() if token.expiry_time else None,
+ "is_active": token.is_active,
+ "cooled_until": token.cooled_until.isoformat() if token.cooled_until else None,
+ "created_at": token.created_at.isoformat() if token.created_at else None,
+ "last_used_at": token.last_used_at.isoformat() if token.last_used_at else None,
+ "use_count": token.use_count,
+ "image_count": stats.image_count if stats else 0,
+ "video_count": stats.video_count if stats else 0,
+ "error_count": stats.error_count if stats else 0,
+ # 订阅信息
+ "plan_type": token.plan_type,
+ "plan_title": token.plan_title,
+ "subscription_end": token.subscription_end.isoformat() if token.subscription_end else None,
+ # Sora2信息
+ "sora2_supported": token.sora2_supported,
+ "sora2_invite_code": token.sora2_invite_code,
+ "sora2_redeemed_count": token.sora2_redeemed_count,
+ "sora2_total_count": token.sora2_total_count
+ })
+
+ return result
+
+@router.post("/api/tokens")
+async def add_token(request: AddTokenRequest, token: str = Depends(verify_admin_token)):
+ """Add a new Access Token"""
+ try:
+ new_token = await token_manager.add_token(
+ token_value=request.token,
+ st=request.st,
+ rt=request.rt,
+ remark=request.remark,
+ update_if_exists=False
+ )
+ return {"success": True, "message": "Token 添加成功", "token_id": new_token.id}
+ except ValueError as e:
+ # Token already exists
+ raise HTTPException(status_code=409, detail=str(e))
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=f"添加 Token 失败: {str(e)}")
+
+@router.post("/api/tokens/st2at")
+async def st_to_at(request: ST2ATRequest, token: str = Depends(verify_admin_token)):
+ """Convert Session Token to Access Token (only convert, not add to database)"""
+ try:
+ result = await token_manager.st_to_at(request.st)
+ return {
+ "success": True,
+ "message": "ST converted to AT successfully",
+ "access_token": result["access_token"],
+ "email": result.get("email"),
+ "expires": result.get("expires")
+ }
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/api/tokens/rt2at")
+async def rt_to_at(request: RT2ATRequest, token: str = Depends(verify_admin_token)):
+ """Convert Refresh Token to Access Token (only convert, not add to database)"""
+ try:
+ result = await token_manager.rt_to_at(request.rt)
+ return {
+ "success": True,
+ "message": "RT converted to AT successfully",
+ "access_token": result["access_token"],
+ "refresh_token": result.get("refresh_token"),
+ "expires_in": result.get("expires_in")
+ }
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.put("/api/tokens/{token_id}/status")
+async def update_token_status(
+ token_id: int,
+ request: UpdateTokenStatusRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update token status"""
+ try:
+ await token_manager.update_token_status(token_id, request.is_active)
+
+ # Reset error count when enabling token
+ if request.is_active:
+ await token_manager.record_success(token_id)
+
+ return {"success": True, "message": "Token status updated"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/api/tokens/{token_id}/enable")
+async def enable_token(token_id: int, token: str = Depends(verify_admin_token)):
+ """Enable a token and reset error count"""
+ try:
+ await token_manager.enable_token(token_id)
+ return {"success": True, "message": "Token enabled", "is_active": 1, "error_count": 0}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/api/tokens/{token_id}/disable")
+async def disable_token(token_id: int, token: str = Depends(verify_admin_token)):
+ """Disable a token"""
+ try:
+ await token_manager.disable_token(token_id)
+ return {"success": True, "message": "Token disabled", "is_active": 0}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/api/tokens/{token_id}/test")
+async def test_token(token_id: int, token: str = Depends(verify_admin_token)):
+ """Test if a token is valid and refresh Sora2 info"""
+ try:
+ result = await token_manager.test_token(token_id)
+ response = {
+ "success": True,
+ "status": "success" if result["valid"] else "failed",
+ "message": result["message"],
+ "email": result.get("email"),
+ "username": result.get("username")
+ }
+
+ # Include Sora2 info if available
+ if result.get("valid"):
+ response.update({
+ "sora2_supported": result.get("sora2_supported"),
+ "sora2_invite_code": result.get("sora2_invite_code"),
+ "sora2_redeemed_count": result.get("sora2_redeemed_count"),
+ "sora2_total_count": result.get("sora2_total_count")
+ })
+
+ return response
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.delete("/api/tokens/{token_id}")
+async def delete_token(token_id: int, token: str = Depends(verify_admin_token)):
+ """Delete a token"""
+ try:
+ await token_manager.delete_token(token_id)
+ return {"success": True, "message": "Token deleted"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.put("/api/tokens/{token_id}")
+async def update_token(
+ token_id: int,
+ request: UpdateTokenRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update token (AT, ST, RT, remark)"""
+ try:
+ await token_manager.update_token(
+ token_id=token_id,
+ token=request.token,
+ st=request.st,
+ rt=request.rt,
+ remark=request.remark
+ )
+ return {"success": True, "message": "Token updated"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+# Admin config endpoints
+@router.get("/api/admin/config")
+async def get_admin_config(token: str = Depends(verify_admin_token)) -> dict:
+ """Get admin configuration"""
+ admin_config = await db.get_admin_config()
+ return {
+ "video_cooldown_threshold": admin_config.video_cooldown_threshold,
+ "error_ban_threshold": admin_config.error_ban_threshold,
+ "api_key": config.api_key,
+ "admin_username": config.admin_username,
+ "debug_enabled": config.debug_enabled
+ }
+
+@router.post("/api/admin/config")
+async def update_admin_config(
+ request: UpdateAdminConfigRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update admin configuration"""
+ try:
+ admin_config = AdminConfig(
+ video_cooldown_threshold=request.video_cooldown_threshold,
+ error_ban_threshold=request.error_ban_threshold
+ )
+ await db.update_admin_config(admin_config)
+ return {"success": True, "message": "Configuration updated"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/api/admin/password")
+async def update_admin_password(
+ request: UpdateAdminPasswordRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update admin password and/or username"""
+ try:
+ # Verify old password
+ if not AuthManager.verify_admin(config.admin_username, request.old_password):
+ raise HTTPException(status_code=400, detail="Old password is incorrect")
+
+ # Update password in config file
+ config_path = Path("config/setting.toml")
+ if not config_path.exists():
+ raise HTTPException(status_code=500, detail="Config file not found")
+
+ # Read current config
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ # Update password
+ config_data["global"]["admin_password"] = request.new_password
+
+ # Update username if provided
+ if request.username:
+ config_data["global"]["admin_username"] = request.username
+
+ # Write back
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ config.admin_password = request.new_password
+ if request.username:
+ config.admin_username = request.username
+
+ # Invalidate all admin tokens (force re-login)
+ active_admin_tokens.clear()
+
+ return {"success": True, "message": "Password updated successfully. Please login again."}
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update password: {str(e)}")
+
+@router.post("/api/admin/apikey")
+async def update_api_key(
+ request: UpdateAPIKeyRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update API key"""
+ try:
+ # Update API key in config file
+ config_path = Path("config/setting.toml")
+ if not config_path.exists():
+ raise HTTPException(status_code=500, detail="Config file not found")
+
+ # Read current config
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ # Update API key
+ config_data["global"]["api_key"] = request.new_api_key
+
+ # Write back
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ config.api_key = request.new_api_key
+
+ return {"success": True, "message": "API key updated successfully"}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update API key: {str(e)}")
+
+@router.post("/api/admin/debug")
+async def update_debug_config(
+ request: UpdateDebugConfigRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update debug configuration"""
+ try:
+ # Update config file
+ config_path = Path("config/setting.toml")
+ if not config_path.exists():
+ raise HTTPException(status_code=500, detail="Config file not found")
+
+ # Read current config
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ # Ensure debug section exists
+ if "debug" not in config_data:
+ config_data["debug"] = {
+ "enabled": False,
+ "log_requests": True,
+ "log_responses": True,
+ "mask_token": True
+ }
+
+ # Update debug enabled
+ config_data["debug"]["enabled"] = request.enabled
+
+ # Write back
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ config.set_debug_enabled(request.enabled)
+
+ status = "enabled" if request.enabled else "disabled"
+ return {"success": True, "message": f"Debug mode {status}", "enabled": request.enabled}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update debug config: {str(e)}")
+
+# Proxy config endpoints
+@router.get("/api/proxy/config")
+async def get_proxy_config(token: str = Depends(verify_admin_token)) -> dict:
+ """Get proxy configuration"""
+ config = await proxy_manager.get_proxy_config()
+ return {
+ "proxy_enabled": config.proxy_enabled,
+ "proxy_url": config.proxy_url
+ }
+
+@router.post("/api/proxy/config")
+async def update_proxy_config(
+ request: UpdateProxyConfigRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update proxy configuration"""
+ try:
+ await proxy_manager.update_proxy_config(request.proxy_enabled, request.proxy_url)
+ return {"success": True, "message": "Proxy configuration updated"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+# Watermark-free config endpoints
+@router.get("/api/watermark-free/config")
+async def get_watermark_free_config(token: str = Depends(verify_admin_token)) -> dict:
+ """Get watermark-free mode configuration"""
+ config = await db.get_watermark_free_config()
+ return {
+ "watermark_free_enabled": config.watermark_free_enabled
+ }
+
+@router.post("/api/watermark-free/config")
+async def update_watermark_free_config(
+ request: UpdateWatermarkFreeConfigRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update watermark-free mode configuration"""
+ try:
+ await db.update_watermark_free_config(request.watermark_free_enabled)
+
+ # Update in-memory config
+ from ..core.config import config
+ config.set_watermark_free_enabled(request.watermark_free_enabled)
+
+ return {"success": True, "message": "Watermark-free mode configuration updated"}
+ except Exception as e:
+ raise HTTPException(status_code=400, detail=str(e))
+
+# Statistics endpoints
+@router.get("/api/stats")
+async def get_stats(token: str = Depends(verify_admin_token)):
+ """Get system statistics"""
+ tokens = await token_manager.get_all_tokens()
+ active_tokens = await token_manager.get_active_tokens()
+
+ total_images = 0
+ total_videos = 0
+ total_errors = 0
+
+ for token in tokens:
+ stats = await db.get_token_stats(token.id)
+ if stats:
+ total_images += stats.image_count
+ total_videos += stats.video_count
+ total_errors += stats.error_count
+
+ return {
+ "total_tokens": len(tokens),
+ "active_tokens": len(active_tokens),
+ "total_images": total_images,
+ "total_videos": total_videos,
+ "total_errors": total_errors
+ }
+
+# Sora2 endpoints
+@router.post("/api/tokens/{token_id}/sora2/activate")
+async def activate_sora2(
+ token_id: int,
+ invite_code: str,
+ token: str = Depends(verify_admin_token)
+):
+ """Activate Sora2 with invite code"""
+ try:
+ # Get token
+ token_obj = await db.get_token(token_id)
+ if not token_obj:
+ raise HTTPException(status_code=404, detail="Token not found")
+
+ # Activate Sora2
+ result = await token_manager.activate_sora2_invite(token_obj.token, invite_code)
+
+ if result.get("success"):
+ # Get new invite code after activation
+ sora2_info = await token_manager.get_sora2_invite_code(token_obj.token)
+
+ # Update database
+ await db.update_token_sora2(
+ token_id,
+ supported=True,
+ invite_code=sora2_info.get("invite_code"),
+ redeemed_count=sora2_info.get("redeemed_count", 0),
+ total_count=sora2_info.get("total_count", 0)
+ )
+
+ return {
+ "success": True,
+ "message": "Sora2 activated successfully",
+ "already_accepted": result.get("already_accepted", False),
+ "invite_code": sora2_info.get("invite_code"),
+ "redeemed_count": sora2_info.get("redeemed_count", 0),
+ "total_count": sora2_info.get("total_count", 0)
+ }
+ else:
+ return {
+ "success": False,
+ "message": "Failed to activate Sora2"
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to activate Sora2: {str(e)}")
+
+# Logs endpoints
+@router.get("/api/logs")
+async def get_logs(limit: int = 100, token: str = Depends(verify_admin_token)):
+ """Get recent logs with token email"""
+ logs = await db.get_recent_logs(limit)
+ return [{
+ "id": log.get("id"),
+ "token_id": log.get("token_id"),
+ "token_email": log.get("token_email"),
+ "token_username": log.get("token_username"),
+ "operation": log.get("operation"),
+ "status_code": log.get("status_code"),
+ "duration": log.get("duration"),
+ "created_at": log.get("created_at")
+ } for log in logs]
+
+# Cache config endpoints
+@router.post("/api/cache/config")
+async def update_cache_timeout(
+ request: UpdateCacheTimeoutRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update cache timeout"""
+ try:
+ if request.timeout < 60:
+ raise HTTPException(status_code=400, detail="Cache timeout must be at least 60 seconds")
+
+ if request.timeout > 86400:
+ raise HTTPException(status_code=400, detail="Cache timeout cannot exceed 24 hours (86400 seconds)")
+
+ # Update config file
+ config_path = Path("config/setting.toml")
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ if "cache" not in config_data:
+ config_data["cache"] = {}
+
+ config_data["cache"]["timeout"] = request.timeout
+
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ config.set_cache_timeout(request.timeout)
+
+ # Reload config to ensure consistency
+ config.reload_config()
+
+ # Update file cache timeout
+ if generation_handler:
+ generation_handler.file_cache.set_timeout(request.timeout)
+
+ return {
+ "success": True,
+ "message": f"Cache timeout updated to {request.timeout} seconds",
+ "timeout": request.timeout
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update cache timeout: {str(e)}")
+
+@router.post("/api/cache/base-url")
+async def update_cache_base_url(
+ request: UpdateCacheBaseUrlRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update cache base URL"""
+ try:
+ # Validate base URL format (optional, can be empty)
+ base_url = request.base_url.strip()
+ if base_url and not (base_url.startswith("http://") or base_url.startswith("https://")):
+ raise HTTPException(
+ status_code=400,
+ detail="Base URL must start with http:// or https://"
+ )
+
+ # Remove trailing slash
+ if base_url:
+ base_url = base_url.rstrip('/')
+
+ # Update config file
+ config_path = Path("config/setting.toml")
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ if "cache" not in config_data:
+ config_data["cache"] = {}
+
+ config_data["cache"]["base_url"] = base_url
+
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ config.set_cache_base_url(base_url)
+
+ # Reload config to ensure consistency
+ config.reload_config()
+
+ return {
+ "success": True,
+ "message": f"Cache base URL updated to: {base_url or 'server address'}",
+ "base_url": base_url
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update cache base URL: {str(e)}")
+
+@router.get("/api/cache/config")
+async def get_cache_config(token: str = Depends(verify_admin_token)):
+ """Get cache configuration"""
+ # Reload config from file to get latest values
+ config.reload_config()
+
+ return {
+ "success": True,
+ "config": {
+ "timeout": config.cache_timeout,
+ "base_url": config.cache_base_url, # 返回实际配置的值，可能为空字符串
+ "effective_base_url": config.cache_base_url or f"http://{config.server_host}:{config.server_port}" # 实际生效的值
+ }
+ }
+
+# Generation timeout config endpoints
+@router.get("/api/generation/timeout")
+async def get_generation_timeout(token: str = Depends(verify_admin_token)):
+ """Get generation timeout configuration"""
+ # Reload config from file to get latest values
+ config.reload_config()
+
+ return {
+ "success": True,
+ "config": {
+ "image_timeout": config.image_timeout,
+ "video_timeout": config.video_timeout
+ }
+ }
+
+@router.post("/api/generation/timeout")
+async def update_generation_timeout(
+ request: UpdateGenerationTimeoutRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update generation timeout configuration"""
+ try:
+ # Validate timeouts
+ if request.image_timeout is not None:
+ if request.image_timeout < 60:
+ raise HTTPException(status_code=400, detail="Image timeout must be at least 60 seconds")
+ if request.image_timeout > 3600:
+ raise HTTPException(status_code=400, detail="Image timeout cannot exceed 1 hour (3600 seconds)")
+
+ if request.video_timeout is not None:
+ if request.video_timeout < 60:
+ raise HTTPException(status_code=400, detail="Video timeout must be at least 60 seconds")
+ if request.video_timeout > 7200:
+ raise HTTPException(status_code=400, detail="Video timeout cannot exceed 2 hours (7200 seconds)")
+
+ # Update config file
+ config_path = Path("config/setting.toml")
+ with open(config_path, "r", encoding="utf-8") as f:
+ config_data = toml.load(f)
+
+ if "generation" not in config_data:
+ config_data["generation"] = {}
+
+ if request.image_timeout is not None:
+ config_data["generation"]["image_timeout"] = request.image_timeout
+
+ if request.video_timeout is not None:
+ config_data["generation"]["video_timeout"] = request.video_timeout
+
+ with open(config_path, "w", encoding="utf-8") as f:
+ toml.dump(config_data, f)
+
+ # Update in-memory config
+ if request.image_timeout is not None:
+ config.set_image_timeout(request.image_timeout)
+ if request.video_timeout is not None:
+ config.set_video_timeout(request.video_timeout)
+
+ # Reload config to ensure consistency
+ config.reload_config()
+
+ # Update TokenLock timeout if image timeout was changed
+ if request.image_timeout is not None and generation_handler:
+ generation_handler.load_balancer.token_lock.set_lock_timeout(config.image_timeout)
+
+ return {
+ "success": True,
+ "message": "Generation timeout configuration updated",
+ "config": {
+ "image_timeout": config.image_timeout,
+ "video_timeout": config.video_timeout
+ }
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update generation timeout: {str(e)}")
+
+# Video length config endpoints
+@router.get("/api/video/length/config")
+async def get_video_length_config(token: str = Depends(verify_admin_token)):
+ """Get video length configuration"""
+ import json
+ try:
+ video_length_config = await db.get_video_length_config()
+ lengths = json.loads(video_length_config.lengths_json)
+ return {
+ "success": True,
+ "config": {
+ "default_length": video_length_config.default_length,
+ "lengths": lengths
+ }
+ }
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to get video length config: {str(e)}")
+
+@router.post("/api/video/length/config")
+async def update_video_length_config(
+ request: UpdateVideoLengthConfigRequest,
+ token: str = Depends(verify_admin_token)
+):
+ """Update video length configuration"""
+ import json
+ try:
+ # Validate default_length
+ if request.default_length not in ["10s", "15s"]:
+ raise HTTPException(status_code=400, detail="default_length must be '10s' or '15s'")
+
+ # Fixed lengths mapping (not modifiable)
+ lengths = {"10s": 300, "15s": 450}
+ lengths_json = json.dumps(lengths)
+
+ # Update database
+ await db.update_video_length_config(request.default_length, lengths_json)
+
+ return {
+ "success": True,
+ "message": "Video length configuration updated",
+ "config": {
+ "default_length": request.default_length,
+ "lengths": lengths
+ }
+ }
+ except HTTPException:
+ raise
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to update video length config: {str(e)}")
diff --git a/src/api/routes.py b/src/api/routes.py
new file mode 100644
index 0000000..7f78840
--- /dev/null
+++ b/src/api/routes.py
@@ -0,0 +1,167 @@
+"""API routes - OpenAI compatible endpoints"""
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse
+from datetime import datetime
+from typing import List
+import json
+from ..core.auth import verify_api_key_header
+from ..core.models import ChatCompletionRequest
+from ..services.generation_handler import GenerationHandler, MODEL_CONFIG
+
+router = APIRouter()
+
+# Dependency injection will be set up in main.py
+generation_handler: GenerationHandler = None
+
+def set_generation_handler(handler: GenerationHandler):
+ """Set generation handler instance"""
+ global generation_handler
+ generation_handler = handler
+
+@router.get("/v1/models")
+async def list_models(api_key: str = Depends(verify_api_key_header)):
+ """List available models"""
+ models = []
+
+ for model_id, config in MODEL_CONFIG.items():
+ description = f"{config['type'].capitalize()} generation"
+ if config['type'] == 'image':
+ description += f" - {config['width']}x{config['height']}"
+ else:
+ description += f" - {config['orientation']}"
+
+ models.append({
+ "id": model_id,
+ "object": "model",
+ "owned_by": "sora2api",
+ "description": description
+ })
+
+ return {
+ "object": "list",
+ "data": models
+ }
+
+@router.post("/v1/chat/completions")
+async def create_chat_completion(
+ request: ChatCompletionRequest,
+ api_key: str = Depends(verify_api_key_header)
+):
+ """Create chat completion (unified endpoint for image and video generation)"""
+ try:
+ # Extract prompt from messages
+ if not request.messages:
+ raise HTTPException(status_code=400, detail="Messages cannot be empty")
+
+ last_message = request.messages[-1]
+ content = last_message.content
+
+ # Handle both string and array format (OpenAI multimodal)
+ prompt = ""
+ image_data = request.image # Default to request.image if provided
+
+ if isinstance(content, str):
+ # Simple string format
+ prompt = content
+ elif isinstance(content, list):
+ # Array format (OpenAI multimodal)
+ for item in content:
+ if isinstance(item, dict):
+ if item.get("type") == "text":
+ prompt = item.get("text", "")
+ elif item.get("type") == "image_url":
+ # Extract base64 image from data URI
+ image_url = item.get("image_url", {})
+ url = image_url.get("url", "")
+ if url.startswith("data:image"):
+ # Extract base64 data from data URI
+ if "base64," in url:
+ image_data = url.split("base64,", 1)[1]
+ else:
+ image_data = url
+ else:
+ raise HTTPException(status_code=400, detail="Invalid content format")
+
+ if not prompt:
+ raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+
+ # Validate model
+ if request.model not in MODEL_CONFIG:
+ raise HTTPException(status_code=400, detail=f"Invalid model: {request.model}")
+
+ # Handle streaming
+ if request.stream:
+ async def generate():
+ import json as json_module # Import inside function to avoid scope issues
+ try:
+ async for chunk in generation_handler.handle_generation(
+ model=request.model,
+ prompt=prompt,
+ image=image_data,
+ stream=True
+ ):
+ yield chunk
+ except Exception as e:
+ # Return OpenAI-compatible error format
+ error_response = {
+ "error": {
+ "message": str(e),
+ "type": "server_error",
+ "param": None,
+ "code": None
+ }
+ }
+ error_chunk = f'data: {json_module.dumps(error_response)}\n\n'
+ yield error_chunk
+ yield 'data: [DONE]\n\n'
+
+ return StreamingResponse(
+ generate(),
+ media_type="text/event-stream",
+ headers={
+ "Cache-Control": "no-cache",
+ "Connection": "keep-alive",
+ "X-Accel-Buffering": "no"
+ }
+ )
+ else:
+ # Non-streaming response
+ result = None
+ async for chunk in generation_handler.handle_generation(
+ model=request.model,
+ prompt=prompt,
+ image=image_data,
+ stream=False
+ ):
+ result = chunk
+
+ if result:
+ import json
+ return JSONResponse(content=json.loads(result))
+ else:
+ # Return OpenAI-compatible error format
+ return JSONResponse(
+ status_code=500,
+ content={
+ "error": {
+ "message": "Generation failed",
+ "type": "server_error",
+ "param": None,
+ "code": None
+ }
+ }
+ )
+
+ except Exception as e:
+ # Return OpenAI-compatible error format
+ return JSONResponse(
+ status_code=500,
+ content={
+ "error": {
+ "message": str(e),
+ "type": "server_error",
+ "param": None,
+ "code": None
+ }
+ }
+ )
diff --git a/src/core/__init__.py b/src/core/__init__.py
new file mode 100644
index 0000000..58fafa5
--- /dev/null
+++ b/src/core/__init__.py
@@ -0,0 +1,14 @@
+"""Core modules"""
+
+from .config import config
+from .database import Database
+from .models import *
+from .auth import AuthManager, verify_api_key_header
+
+__all__ = [
+ "config",
+ "Database",
+ "AuthManager",
+ "verify_api_key_header",
+]
+
diff --git a/src/core/auth.py b/src/core/auth.py
new file mode 100644
index 0000000..8e08f14
--- /dev/null
+++ b/src/core/auth.py
@@ -0,0 +1,38 @@
+"""Authentication module"""
+import bcrypt
+from typing import Optional
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from .config import config
+
+security = HTTPBearer()
+
+class AuthManager:
+ """Authentication manager"""
+
+ @staticmethod
+ def verify_api_key(api_key: str) -> bool:
+ """Verify API key"""
+ return api_key == config.api_key
+
+ @staticmethod
+ def verify_admin(username: str, password: str) -> bool:
+ """Verify admin credentials"""
+ return username == config.admin_username and password == config.admin_password
+
+ @staticmethod
+ def hash_password(password: str) -> str:
+ """Hash password"""
+ return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+
+ @staticmethod
+ def verify_password(password: str, hashed: str) -> bool:
+ """Verify password"""
+ return bcrypt.checkpw(password.encode(), hashed.encode())
+
+async def verify_api_key_header(credentials: HTTPAuthorizationCredentials = Security(security)) -> str:
+ """Verify API key from Authorization header"""
+ api_key = credentials.credentials
+ if not AuthManager.verify_api_key(api_key):
+ raise HTTPException(status_code=401, detail="Invalid API key")
+ return api_key
diff --git a/src/core/config.py b/src/core/config.py
new file mode 100644
index 0000000..f323f68
--- /dev/null
+++ b/src/core/config.py
@@ -0,0 +1,157 @@
+"""Configuration management"""
+import tomli
+from pathlib import Path
+from typing import Dict, Any
+
+class Config:
+ """Application configuration"""
+
+ def __init__(self):
+ self._config = self._load_config()
+
+ def _load_config(self) -> Dict[str, Any]:
+ """Load configuration from setting.toml"""
+ config_path = Path(__file__).parent.parent.parent / "config" / "setting.toml"
+ with open(config_path, "rb") as f:
+ return tomli.load(f)
+
+ def reload_config(self):
+ """Reload configuration from file"""
+ self._config = self._load_config()
+
+ def get_raw_config(self) -> Dict[str, Any]:
+ """Get raw configuration dictionary"""
+ return self._config
+
+ @property
+ def admin_username(self) -> str:
+ return self._config["global"]["admin_username"]
+
+ @admin_username.setter
+ def admin_username(self, value: str):
+ self._config["global"]["admin_username"] = value
+
+ @property
+ def sora_base_url(self) -> str:
+ return self._config["sora"]["base_url"]
+
+ @property
+ def sora_timeout(self) -> int:
+ return self._config["sora"]["timeout"]
+
+ @property
+ def sora_max_retries(self) -> int:
+ return self._config["sora"]["max_retries"]
+
+ @property
+ def poll_interval(self) -> float:
+ return self._config["sora"]["poll_interval"]
+
+ @property
+ def max_poll_attempts(self) -> int:
+ return self._config["sora"]["max_poll_attempts"]
+
+ @property
+ def server_host(self) -> str:
+ return self._config["server"]["host"]
+
+ @property
+ def server_port(self) -> int:
+ return self._config["server"]["port"]
+
+ @property
+ def debug_enabled(self) -> bool:
+ return self._config.get("debug", {}).get("enabled", False)
+
+ @property
+ def debug_log_requests(self) -> bool:
+ return self._config.get("debug", {}).get("log_requests", True)
+
+ @property
+ def debug_log_responses(self) -> bool:
+ return self._config.get("debug", {}).get("log_responses", True)
+
+ @property
+ def debug_mask_token(self) -> bool:
+ return self._config.get("debug", {}).get("mask_token", True)
+
+ # Mutable properties for runtime updates
+ @property
+ def api_key(self) -> str:
+ return self._config["global"]["api_key"]
+
+ @api_key.setter
+ def api_key(self, value: str):
+ self._config["global"]["api_key"] = value
+
+ @property
+ def admin_password(self) -> str:
+ return self._config["global"]["admin_password"]
+
+ @admin_password.setter
+ def admin_password(self, value: str):
+ self._config["global"]["admin_password"] = value
+
+ def set_debug_enabled(self, enabled: bool):
+ """Set debug mode enabled/disabled"""
+ if "debug" not in self._config:
+ self._config["debug"] = {}
+ self._config["debug"]["enabled"] = enabled
+
+ @property
+ def cache_timeout(self) -> int:
+ """Get cache timeout in seconds"""
+ return self._config.get("cache", {}).get("timeout", 7200)
+
+ def set_cache_timeout(self, timeout: int):
+ """Set cache timeout in seconds"""
+ if "cache" not in self._config:
+ self._config["cache"] = {}
+ self._config["cache"]["timeout"] = timeout
+
+ @property
+ def cache_base_url(self) -> str:
+ """Get cache base URL"""
+ return self._config.get("cache", {}).get("base_url", "")
+
+ def set_cache_base_url(self, base_url: str):
+ """Set cache base URL"""
+ if "cache" not in self._config:
+ self._config["cache"] = {}
+ self._config["cache"]["base_url"] = base_url
+
+ @property
+ def image_timeout(self) -> int:
+ """Get image generation timeout in seconds"""
+ return self._config.get("generation", {}).get("image_timeout", 300)
+
+ def set_image_timeout(self, timeout: int):
+ """Set image generation timeout in seconds"""
+ if "generation" not in self._config:
+ self._config["generation"] = {}
+ self._config["generation"]["image_timeout"] = timeout
+
+ @property
+ def video_timeout(self) -> int:
+ """Get video generation timeout in seconds"""
+ return self._config.get("generation", {}).get("video_timeout", 1500)
+
+ def set_video_timeout(self, timeout: int):
+ """Set video generation timeout in seconds"""
+ if "generation" not in self._config:
+ self._config["generation"] = {}
+ self._config["generation"]["video_timeout"] = timeout
+
+ @property
+ def watermark_free_enabled(self) -> bool:
+ """Get watermark-free mode enabled status"""
+ return self._config.get("watermark_free", {}).get("enabled", False)
+
+ def set_watermark_free_enabled(self, enabled: bool):
+ """Set watermark-free mode enabled/disabled"""
+ if "watermark_free" not in self._config:
+ self._config["watermark_free"] = {}
+ self._config["watermark_free"]["enabled"] = enabled
+
+# Global config instance
+config = Config()
diff --git a/src/core/database.py b/src/core/database.py
new file mode 100644
index 0000000..d69358e
--- /dev/null
+++ b/src/core/database.py
@@ -0,0 +1,613 @@
+"""Database storage layer"""
+import aiosqlite
+import json
+from datetime import datetime
+from typing import Optional, List
+from pathlib import Path
+from .models import Token, TokenStats, Task, RequestLog, AdminConfig, ProxyConfig, WatermarkFreeConfig
+
+class Database:
+ """SQLite database manager"""
+
+ def __init__(self, db_path: str = None):
+ if db_path is None:
+ # Store database in data directory
+ data_dir = Path(__file__).parent.parent.parent / "data"
+ data_dir.mkdir(exist_ok=True)
+ db_path = str(data_dir / "hancat.db")
+ self.db_path = db_path
+
+ def db_exists(self) -> bool:
+ """Check if database file exists"""
+ return Path(self.db_path).exists()
+
+ async def init_db(self):
+ """Initialize database tables"""
+ async with aiosqlite.connect(self.db_path) as db:
+ # Tokens table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS tokens (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token TEXT UNIQUE NOT NULL,
+ email TEXT NOT NULL,
+ username TEXT NOT NULL,
+ name TEXT NOT NULL,
+ st TEXT,
+ rt TEXT,
+ remark TEXT,
+ expiry_time TIMESTAMP,
+ is_active BOOLEAN DEFAULT 1,
+ cooled_until TIMESTAMP,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ last_used_at TIMESTAMP,
+ use_count INTEGER DEFAULT 0,
+ plan_type TEXT,
+ plan_title TEXT,
+ subscription_end TIMESTAMP,
+ sora2_supported BOOLEAN,
+ sora2_invite_code TEXT,
+ sora2_redeemed_count INTEGER DEFAULT 0,
+ sora2_total_count INTEGER DEFAULT 0
+ )
+ """)
+
+ # Add sora2 columns if they don't exist (migration)
+ try:
+ await db.execute("ALTER TABLE tokens ADD COLUMN sora2_supported BOOLEAN")
+ except:
+ pass # Column already exists
+
+ try:
+ await db.execute("ALTER TABLE tokens ADD COLUMN sora2_invite_code TEXT")
+ except:
+ pass # Column already exists
+
+ try:
+ await db.execute("ALTER TABLE tokens ADD COLUMN sora2_redeemed_count INTEGER DEFAULT 0")
+ except:
+ pass # Column already exists
+
+ try:
+ await db.execute("ALTER TABLE tokens ADD COLUMN sora2_total_count INTEGER DEFAULT 0")
+ except:
+ pass # Column already exists
+
+ # Token stats table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS token_stats (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token_id INTEGER NOT NULL,
+ image_count INTEGER DEFAULT 0,
+ video_count INTEGER DEFAULT 0,
+ error_count INTEGER DEFAULT 0,
+ last_error_at TIMESTAMP,
+ FOREIGN KEY (token_id) REFERENCES tokens(id)
+ )
+ """)
+
+ # Tasks table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS tasks (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ task_id TEXT UNIQUE NOT NULL,
+ token_id INTEGER NOT NULL,
+ model TEXT NOT NULL,
+ prompt TEXT NOT NULL,
+ status TEXT NOT NULL DEFAULT 'processing',
+ progress FLOAT DEFAULT 0,
+ result_urls TEXT,
+ error_message TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ completed_at TIMESTAMP,
+ FOREIGN KEY (token_id) REFERENCES tokens(id)
+ )
+ """)
+
+ # Request logs table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS request_logs (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ token_id INTEGER,
+ operation TEXT NOT NULL,
+ request_body TEXT,
+ response_body TEXT,
+ status_code INTEGER NOT NULL,
+ duration FLOAT NOT NULL,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ FOREIGN KEY (token_id) REFERENCES tokens(id)
+ )
+ """)
+
+ # Admin config table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS admin_config (
+ id INTEGER PRIMARY KEY DEFAULT 1,
+ video_cooldown_threshold INTEGER DEFAULT 30,
+ error_ban_threshold INTEGER DEFAULT 3,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ """)
+
+ # Proxy config table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS proxy_config (
+ id INTEGER PRIMARY KEY DEFAULT 1,
+ proxy_enabled BOOLEAN DEFAULT 0,
+ proxy_url TEXT,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ """)
+
+ # Watermark-free config table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS watermark_free_config (
+ id INTEGER PRIMARY KEY DEFAULT 1,
+ watermark_free_enabled BOOLEAN DEFAULT 0,
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ """)
+
+ # Video length config table
+ await db.execute("""
+ CREATE TABLE IF NOT EXISTS video_length_config (
+ id INTEGER PRIMARY KEY DEFAULT 1,
+ default_length TEXT DEFAULT '10s',
+ lengths_json TEXT DEFAULT '{"10s": 300, "15s": 450}',
+ created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+ updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+ )
+ """)
+
+ # Create indexes
+ await db.execute("CREATE INDEX IF NOT EXISTS idx_task_id ON tasks(task_id)")
+ await db.execute("CREATE INDEX IF NOT EXISTS idx_task_status ON tasks(status)")
+ await db.execute("CREATE INDEX IF NOT EXISTS idx_token_active ON tokens(is_active)")
+
+ # Insert default admin config
+ await db.execute("""
+ INSERT OR IGNORE INTO admin_config (id, video_cooldown_threshold, error_ban_threshold)
+ VALUES (1, 30, 3)
+ """)
+
+ # Insert default proxy config
+ await db.execute("""
+ INSERT OR IGNORE INTO proxy_config (id, proxy_enabled, proxy_url)
+ VALUES (1, 0, NULL)
+ """)
+
+ # Insert default watermark-free config
+ await db.execute("""
+ INSERT OR IGNORE INTO watermark_free_config (id, watermark_free_enabled)
+ VALUES (1, 0)
+ """)
+
+ # Insert default video length config
+ await db.execute("""
+ INSERT OR IGNORE INTO video_length_config (id, default_length, lengths_json)
+ VALUES (1, '10s', '{"10s": 300, "15s": 450}')
+ """)
+
+ await db.commit()
+
+ async def init_config_from_toml(self, config_dict: dict):
+ """Initialize database configuration from setting.toml on first startup"""
+ async with aiosqlite.connect(self.db_path) as db:
+ # Initialize admin config
+ admin_config = config_dict.get("admin", {})
+ video_cooldown_threshold = admin_config.get("video_cooldown_threshold", 30)
+ error_ban_threshold = admin_config.get("error_ban_threshold", 3)
+
+ await db.execute("""
+ UPDATE admin_config
+ SET video_cooldown_threshold = ?, error_ban_threshold = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (video_cooldown_threshold, error_ban_threshold))
+
+ # Initialize proxy config
+ proxy_config = config_dict.get("proxy", {})
+ proxy_enabled = proxy_config.get("proxy_enabled", False)
+ proxy_url = proxy_config.get("proxy_url", "")
+ # Convert empty string to None
+ proxy_url = proxy_url if proxy_url else None
+
+ await db.execute("""
+ UPDATE proxy_config
+ SET proxy_enabled = ?, proxy_url = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (proxy_enabled, proxy_url))
+
+ # Initialize watermark-free config
+ watermark_config = config_dict.get("watermark_free", {})
+ watermark_free_enabled = watermark_config.get("watermark_free_enabled", False)
+
+ await db.execute("""
+ UPDATE watermark_free_config
+ SET watermark_free_enabled = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (watermark_free_enabled,))
+
+ # Initialize video length config
+ video_length_config = config_dict.get("video_length", {})
+ default_length = video_length_config.get("default_length", "10s")
+ lengths = video_length_config.get("lengths", {"10s": 300, "15s": 450})
+ lengths_json = json.dumps(lengths)
+
+ await db.execute("""
+ UPDATE video_length_config
+ SET default_length = ?, lengths_json = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (default_length, lengths_json))
+
+ await db.commit()
+
+ # Token operations
+ async def add_token(self, token: Token) -> int:
+ """Add a new token"""
+ async with aiosqlite.connect(self.db_path) as db:
+ cursor = await db.execute("""
+ INSERT INTO tokens (token, email, username, name, st, rt, remark, expiry_time, is_active,
+ plan_type, plan_title, subscription_end, sora2_supported, sora2_invite_code,
+ sora2_redeemed_count, sora2_total_count)
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+ """, (token.token, token.email, "", token.name, token.st, token.rt,
+ token.remark, token.expiry_time, token.is_active,
+ token.plan_type, token.plan_title, token.subscription_end,
+ token.sora2_supported, token.sora2_invite_code,
+ token.sora2_redeemed_count, token.sora2_total_count))
+ await db.commit()
+ token_id = cursor.lastrowid
+
+ # Create stats entry
+ await db.execute("""
+ INSERT INTO token_stats (token_id) VALUES (?)
+ """, (token_id,))
+ await db.commit()
+
+ return token_id
+
+ async def get_token(self, token_id: int) -> Optional[Token]:
+ """Get token by ID"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM tokens WHERE id = ?", (token_id,))
+ row = await cursor.fetchone()
+ if row:
+ return Token(**dict(row))
+ return None
+
+ async def get_token_by_value(self, token: str) -> Optional[Token]:
+ """Get token by value"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM tokens WHERE token = ?", (token,))
+ row = await cursor.fetchone()
+ if row:
+ return Token(**dict(row))
+ return None
+
+ async def get_active_tokens(self) -> List[Token]:
+ """Get all active tokens (enabled, not cooled down, not expired)"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("""
+ SELECT * FROM tokens
+ WHERE is_active = 1
+ AND (cooled_until IS NULL OR cooled_until < CURRENT_TIMESTAMP)
+ AND expiry_time > CURRENT_TIMESTAMP
+ ORDER BY last_used_at ASC NULLS FIRST
+ """)
+ rows = await cursor.fetchall()
+ return [Token(**dict(row)) for row in rows]
+
+ async def get_all_tokens(self) -> List[Token]:
+ """Get all tokens"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM tokens ORDER BY created_at DESC")
+ rows = await cursor.fetchall()
+ return [Token(**dict(row)) for row in rows]
+
+ async def update_token_usage(self, token_id: int):
+ """Update token usage"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE tokens
+ SET last_used_at = CURRENT_TIMESTAMP, use_count = use_count + 1
+ WHERE id = ?
+ """, (token_id,))
+ await db.commit()
+
+ async def update_token_status(self, token_id: int, is_active: bool):
+ """Update token status"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE tokens SET is_active = ? WHERE id = ?
+ """, (is_active, token_id))
+ await db.commit()
+
+ async def update_token_sora2(self, token_id: int, supported: bool, invite_code: Optional[str] = None,
+ redeemed_count: int = 0, total_count: int = 0):
+ """Update token Sora2 support info"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE tokens
+ SET sora2_supported = ?, sora2_invite_code = ?, sora2_redeemed_count = ?, sora2_total_count = ?
+ WHERE id = ?
+ """, (supported, invite_code, redeemed_count, total_count, token_id))
+ await db.commit()
+
+ async def update_token_cooldown(self, token_id: int, cooled_until: datetime):
+ """Update token cooldown"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE tokens SET cooled_until = ? WHERE id = ?
+ """, (cooled_until, token_id))
+ await db.commit()
+
+ async def delete_token(self, token_id: int):
+ """Delete token"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("DELETE FROM token_stats WHERE token_id = ?", (token_id,))
+ await db.execute("DELETE FROM tokens WHERE id = ?", (token_id,))
+ await db.commit()
+
+ async def update_token(self, token_id: int,
+ token: Optional[str] = None,
+ st: Optional[str] = None,
+ rt: Optional[str] = None,
+ remark: Optional[str] = None,
+ expiry_time: Optional[datetime] = None,
+ plan_type: Optional[str] = None,
+ plan_title: Optional[str] = None,
+ subscription_end: Optional[datetime] = None):
+ """Update token (AT, ST, RT, remark, expiry_time, subscription info)"""
+ async with aiosqlite.connect(self.db_path) as db:
+ # Build dynamic update query
+ updates = []
+ params = []
+
+ if token is not None:
+ updates.append("token = ?")
+ params.append(token)
+
+ if st is not None:
+ updates.append("st = ?")
+ params.append(st)
+
+ if rt is not None:
+ updates.append("rt = ?")
+ params.append(rt)
+
+ if remark is not None:
+ updates.append("remark = ?")
+ params.append(remark)
+
+ if expiry_time is not None:
+ updates.append("expiry_time = ?")
+ params.append(expiry_time)
+
+ if plan_type is not None:
+ updates.append("plan_type = ?")
+ params.append(plan_type)
+
+ if plan_title is not None:
+ updates.append("plan_title = ?")
+ params.append(plan_title)
+
+ if subscription_end is not None:
+ updates.append("subscription_end = ?")
+ params.append(subscription_end)
+
+ if updates:
+ params.append(token_id)
+ query = f"UPDATE tokens SET {', '.join(updates)} WHERE id = ?"
+ await db.execute(query, params)
+ await db.commit()
+
+ # Token stats operations
+ async def get_token_stats(self, token_id: int) -> Optional[TokenStats]:
+ """Get token statistics"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM token_stats WHERE token_id = ?", (token_id,))
+ row = await cursor.fetchone()
+ if row:
+ return TokenStats(**dict(row))
+ return None
+
+ async def increment_image_count(self, token_id: int):
+ """Increment image generation count"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE token_stats SET image_count = image_count + 1 WHERE token_id = ?
+ """, (token_id,))
+ await db.commit()
+
+ async def increment_video_count(self, token_id: int):
+ """Increment video generation count"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE token_stats SET video_count = video_count + 1 WHERE token_id = ?
+ """, (token_id,))
+ await db.commit()
+
+ async def increment_error_count(self, token_id: int):
+ """Increment error count"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE token_stats
+ SET error_count = error_count + 1, last_error_at = CURRENT_TIMESTAMP
+ WHERE token_id = ?
+ """, (token_id,))
+ await db.commit()
+
+ async def reset_error_count(self, token_id: int):
+ """Reset error count"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE token_stats SET error_count = 0 WHERE token_id = ?
+ """, (token_id,))
+ await db.commit()
+
+ # Task operations
+ async def create_task(self, task: Task) -> int:
+ """Create a new task"""
+ async with aiosqlite.connect(self.db_path) as db:
+ cursor = await db.execute("""
+ INSERT INTO tasks (task_id, token_id, model, prompt, status, progress)
+ VALUES (?, ?, ?, ?, ?, ?)
+ """, (task.task_id, task.token_id, task.model, task.prompt, task.status, task.progress))
+ await db.commit()
+ return cursor.lastrowid
+
+ async def update_task(self, task_id: str, status: str, progress: float,
+ result_urls: Optional[str] = None, error_message: Optional[str] = None):
+ """Update task status"""
+ async with aiosqlite.connect(self.db_path) as db:
+ completed_at = datetime.now() if status in ["completed", "failed"] else None
+ await db.execute("""
+ UPDATE tasks
+ SET status = ?, progress = ?, result_urls = ?, error_message = ?, completed_at = ?
+ WHERE task_id = ?
+ """, (status, progress, result_urls, error_message, completed_at, task_id))
+ await db.commit()
+
+ async def get_task(self, task_id: str) -> Optional[Task]:
+ """Get task by ID"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,))
+ row = await cursor.fetchone()
+ if row:
+ return Task(**dict(row))
+ return None
+
+ # Request log operations
+ async def log_request(self, log: RequestLog):
+ """Log a request"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ INSERT INTO request_logs (token_id, operation, request_body, response_body, status_code, duration)
+ VALUES (?, ?, ?, ?, ?, ?)
+ """, (log.token_id, log.operation, log.request_body, log.response_body,
+ log.status_code, log.duration))
+ await db.commit()
+
+ async def get_recent_logs(self, limit: int = 100) -> List[dict]:
+ """Get recent logs with token email"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("""
+ SELECT
+ rl.id,
+ rl.token_id,
+ rl.operation,
+ rl.request_body,
+ rl.response_body,
+ rl.status_code,
+ rl.duration,
+ rl.created_at,
+ t.email as token_email
+ FROM request_logs rl
+ LEFT JOIN tokens t ON rl.token_id = t.id
+ ORDER BY rl.created_at DESC
+ LIMIT ?
+ """, (limit,))
+ rows = await cursor.fetchall()
+ return [dict(row) for row in rows]
+
+ # Admin config operations
+ async def get_admin_config(self) -> AdminConfig:
+ """Get admin configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM admin_config WHERE id = 1")
+ row = await cursor.fetchone()
+ if row:
+ return AdminConfig(**dict(row))
+ return AdminConfig()
+
+ async def update_admin_config(self, config: AdminConfig):
+ """Update admin configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE admin_config
+ SET video_cooldown_threshold = ?, error_ban_threshold = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (config.video_cooldown_threshold, config.error_ban_threshold))
+ await db.commit()
+
+ # Proxy config operations
+ async def get_proxy_config(self) -> ProxyConfig:
+ """Get proxy configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM proxy_config WHERE id = 1")
+ row = await cursor.fetchone()
+ if row:
+ return ProxyConfig(**dict(row))
+ return ProxyConfig()
+
+ async def update_proxy_config(self, enabled: bool, proxy_url: Optional[str]):
+ """Update proxy configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE proxy_config
+ SET proxy_enabled = ?, proxy_url = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (enabled, proxy_url))
+ await db.commit()
+
+ # Watermark-free config operations
+ async def get_watermark_free_config(self) -> WatermarkFreeConfig:
+ """Get watermark-free configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM watermark_free_config WHERE id = 1")
+ row = await cursor.fetchone()
+ if row:
+ return WatermarkFreeConfig(**dict(row))
+ return WatermarkFreeConfig()
+
+ async def update_watermark_free_config(self, enabled: bool):
+ """Update watermark-free configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE watermark_free_config
+ SET watermark_free_enabled = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (enabled,))
+ await db.commit()
+
+ # Video length config operations
+ async def get_video_length_config(self):
+ """Get video length configuration"""
+ from .models import VideoLengthConfig
+ async with aiosqlite.connect(self.db_path) as db:
+ db.row_factory = aiosqlite.Row
+ cursor = await db.execute("SELECT * FROM video_length_config WHERE id = 1")
+ row = await cursor.fetchone()
+ if row:
+ return VideoLengthConfig(**dict(row))
+ return VideoLengthConfig()
+
+ async def update_video_length_config(self, default_length: str, lengths_json: str):
+ """Update video length configuration"""
+ async with aiosqlite.connect(self.db_path) as db:
+ await db.execute("""
+ UPDATE video_length_config
+ SET default_length = ?, lengths_json = ?, updated_at = CURRENT_TIMESTAMP
+ WHERE id = 1
+ """, (default_length, lengths_json))
+ await db.commit()
+
+ async def get_n_frames_for_length(self, length: str) -> int:
+ """Get n_frames value for a given video length"""
+ config = await self.get_video_length_config()
+ try:
+ lengths = json.loads(config.lengths_json)
+ return lengths.get(length, 300) # Default to 300 if not found
+ except:
+ return 300 # Default to 300 if JSON parsing fails
diff --git a/src/core/logger.py b/src/core/logger.py
new file mode 100644
index 0000000..71d3533
--- /dev/null
+++ b/src/core/logger.py
@@ -0,0 +1,217 @@
+"""Debug logger module for detailed API request/response logging"""
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Any, Optional
+from .config import config
+
+class DebugLogger:
+ """Debug logger for API requests and responses"""
+
+ def __init__(self):
+ self.log_file = Path("logs.txt")
+ self._setup_logger()
+
+ def _setup_logger(self):
+ """Setup file logger"""
+ # Create logger
+ self.logger = logging.getLogger("debug_logger")
+ self.logger.setLevel(logging.DEBUG)
+
+ # Remove existing handlers
+ self.logger.handlers.clear()
+
+ # Create file handler
+ file_handler = logging.FileHandler(
+ self.log_file,
+ mode='a',
+ encoding='utf-8'
+ )
+ file_handler.setLevel(logging.DEBUG)
+
+ # Create formatter
+ formatter = logging.Formatter(
+ '%(message)s',
+ datefmt='%Y-%m-%d %H:%M:%S'
+ )
+ file_handler.setFormatter(formatter)
+
+ # Add handler
+ self.logger.addHandler(file_handler)
+
+ # Prevent propagation to root logger
+ self.logger.propagate = False
+
+ def _mask_token(self, token: str) -> str:
+ """Mask token for logging (show first 6 and last 6 characters)"""
+ if not config.debug_mask_token or len(token) <= 12:
+ return token
+ return f"{token[:6]}...{token[-6:]}"
+
+ def _format_timestamp(self) -> str:
+ """Format current timestamp"""
+ return datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
+
+ def _write_separator(self, char: str = "=", length: int = 100):
+ """Write separator line"""
+ self.logger.info(char * length)
+
+ def log_request(
+ self,
+ method: str,
+ url: str,
+ headers: Dict[str, str],
+ body: Optional[Any] = None,
+ files: Optional[Dict] = None,
+ proxy: Optional[str] = None
+ ):
+ """Log API request details to log.txt"""
+
+ try:
+ self._write_separator()
+ self.logger.info(f"🔵 [REQUEST] {self._format_timestamp()}")
+ self._write_separator("-")
+
+ # Basic info
+ self.logger.info(f"Method: {method}")
+ self.logger.info(f"URL: {url}")
+
+ # Headers
+ self.logger.info("\n📋 Headers:")
+ masked_headers = dict(headers)
+ if "Authorization" in masked_headers:
+ auth_value = masked_headers["Authorization"]
+ if auth_value.startswith("Bearer "):
+ token = auth_value[7:]
+ masked_headers["Authorization"] = f"Bearer {self._mask_token(token)}"
+
+ for key, value in masked_headers.items():
+ self.logger.info(f" {key}: {value}")
+
+ # Body
+ if body is not None:
+ self.logger.info("\n📦 Request Body:")
+ if isinstance(body, (dict, list)):
+ body_str = json.dumps(body, indent=2, ensure_ascii=False)
+ self.logger.info(body_str)
+ else:
+ self.logger.info(str(body))
+
+ # Files
+ if files:
+ self.logger.info("\n📎 Files:")
+ for key in files.keys():
+ self.logger.info(f" {key}:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Token 总数
+-
+
+
+ 活跃 Token
+-
+
+
+ 总图片数
+-
+
+
+ 总视频数
+-
+
+
+ 错误次数
+-
+
+
+
+
+
+ Token 列表
+
+
+
+
+
+
+
+
+
+ | 邮箱 | +状态 | +过期时间 | +账户类型 | +Sora2 | +套餐到期 | +图片 | +视频 | +错误 | +备注 | +操作 | +
|---|
+
+
+
+
+
+
+
+
+
+
+ 安全配置
+
+
+
+
+
+
+ 管理员用户名
+
+
+
+
+
+
+
+
+
+
+
+
+
+ API 密钥配置
+
+
+
+
+
+
+ 当前使用的 API Key（只读）
+
+
+
+
+
+ 用于客户端调用 API 的密钥
+
+
+
+
+ 代理配置
+
+
+
+
+
+
+
+
+
+
+ 支持 HTTP 和 SOCKS5 代理
+
+
+
+
+ 视频生成次数限制
+
+
+
+
+
+
+ Token 生成视频达到此次数后冷却 12 小时
+
+
+
+
+
+ Token 连续错误达到此次数后自动禁用
+
+
+
+
+ 缓存配置
+
+
+
+
+
+
+ 文件缓存超时时间，范围：60-86400 秒（1分钟-24小时）
+
+
+
+
+
+
+ 留空则使用服务器地址，例如：https://yourdomain.com
+
+
+
+
+ 生成超时配置
+
+
+
+
+
+
+ 图片生成超时时间，范围：60-3600 秒（1分钟-1小时），超时后自动释放Token锁
+
+
+
+
+
+ 视频生成超时时间，范围：60-7200 秒（1分钟-2小时），超时后返回上游API超时错误
+
+
+
+
+ 视频时长配置
+
+
+
+
+
+
+
+ 选择视频生成的默认时长
+
+
+
+
+ 无水印模式配置
+
+
+
+
+
+
+ 开启后生成的视频将会被发布到sora平台并且提取返回无水印的视频，在缓存到本地后会自动删除发布的视频
+
+
+ 调试配置
+
+
+
+
+
+ 开启后，详细的上游API请求和响应日志将写入 logs.txt 文件，重启生效
+
+ + ⚠️ 注意：调试模式会产生非常非常大量的日志，仅限Debug时候开启，否则磁盘boom +
+
+
+
+
+
+
+
+
+
+ 请求日志
+ +
+
+
+
+
+ | 操作 | +Token邮箱 | +状态码 | +耗时(秒) | +时间 | +
|---|