Upload 61 files

app.py

@@ -12,6 +12,9 @@ from werkzeug.middleware.proxy_fix import ProxyFix
 # 导入配置
 from config import SECRET_KEY
 
+# 导入API管理服务
+from core.api_manager import start_service
+
 # 设置时区为UTC+8 (亚洲/上海)，兼容Linux和Windows环境
 os.environ['TZ'] = 'Asia/Shanghai'
 try:
@@ -30,6 +33,8 @@ from routes.api import api_bp
 
 # 导入认证模块
 from utils.auth import AuthManager
+# 导入数据库模块
+from utils.db import init_db
 
 # 创建Flask应用
 app = Flask(__name__)
@@ -96,6 +101,13 @@ def authenticate():
 app.register_blueprint(web_bp)
 app.register_blueprint(api_bp)
 
+# 在应用启动时初始化数据库
+with app.app_context():
+    init_db()
+
 # 入口点
 if __name__ == '__main__':
+    # 启动API管理服务
+    api_service_threads = start_service()
+    # 应用启动
     app.run(debug=True, host='0.0.0.0', port=7860)

config.py

@@ -10,9 +10,12 @@ DATA_DIR = os.path.join(BASE_DIR, 'data')
 os.makedirs(DATA_DIR, exist_ok=True)
 
 # 数据文件路径
-API_KEYS_FILE = os.path.join(DATA_DIR, 'api_keys.json')
+API_KEYS_FILE = os.path.join(DATA_DIR, 'api_keys.json')  # 保留以供兼容性
 AUTH_FILE = os.path.join(DATA_DIR, 'auth_tokens.json')
 
+# SQLite数据库配置
+DATABASE_PATH = os.path.join(DATA_DIR, 'api_keys.db')
+
 # 应用密钥配置
 SECRET_KEY = os.environ.get('SECRET_KEY', secrets.token_hex(16))
 ADMIN_PASSWORD = os.environ.get('PASSWORD', '123456')
@@ -51,3 +54,15 @@ PLATFORM_STYLES = {
         "color": "#3246d3"
     }
 }
+
+# API调用节流控制配置
+PLATFORM_LIMITS = {
+    'openai': 30,
+    'anthropic': 30,  
+    'google': 30,    
+    'deepseek': 50,   
+    'default': 10   
+}
+
+# 请求节流时间窗口（秒）
+TIME_WINDOW = 10

core/api/google.py

@@ -93,7 +93,7 @@ def check_paid_account(api_key):
             "instances": [{"prompt": "Hi"}]
         }
         
-        timeout = 1
+        timeout = 3
         
         try:
             response = requests.post(imagen_url, params=params, json=payload, timeout=timeout)

core/api_manager.py

@@ -0,0 +1,206 @@
+"""
+API管理器 - 管理API请求的节流控制和队列调度
+提供API调用的桥接功能和请求限流控制
+"""
+import time
+import threading
+import importlib
+from typing import Any, Callable, Dict, List, Tuple, Union
+import config
+
+class ApiManager:
+    """
+    API管理器类 - 负责处理API请求的节流控制和队列管理
+    
+    为每个平台实现两个队列:
+    1. 完成队列: 记录发起请求的时间戳
+    2. 等待队列: 记录等待执行的请求
+    
+    定时任务每秒执行一次，清理完成队列中的过期请求，
+    并处理等待队列中的请求（如果有空位）
+    """
+    def __init__(self):
+        # 从config导入节流控制配置
+        self.platform_limits = config.PLATFORM_LIMITS
+        self.time_window = config.TIME_WINDOW
+        
+        # 初始化平台队列
+        self.completed_queues = {platform: [] for platform in self.platform_limits}
+        self.waiting_queues = {platform: [] for platform in self.platform_limits}
+        
+        # 线程安全锁
+        self.locks = {platform: threading.Lock() for platform in self.platform_limits}
+        
+        # 启动调度器
+        self._scheduler_active = True
+        self._start_scheduler()
+    
+    def _start_scheduler(self):
+        """启动定时调度器，每秒执行一次队列管理"""
+        self._process_queues()
+        if self._scheduler_active:
+            # 每秒执行一次
+            threading.Timer(1.0, self._start_scheduler).start()
+    
+    def _process_queues(self):
+        """处理所有平台的队列"""
+        current_time = time.time()
+        
+        for platform in self.platform_limits:
+            with self.locks[platform]:
+                # 1. 移除已超过时间窗口的完成请求
+                self._clean_completed_queue(platform, current_time)
+                
+                # 2. 处理等待队列中的请求（如果有空位）
+                self._process_waiting_queue(platform)
+    
+    def _clean_completed_queue(self, platform: str, current_time: float):
+        """清理完成队列中超时的请求"""
+        # 移除已经超过时间窗口的请求
+        self.completed_queues[platform] = [
+            timestamp for timestamp in self.completed_queues[platform]
+            if current_time - timestamp < self.time_window
+        ]
+    
+    def _process_waiting_queue(self, platform: str):
+        """处理等待队列中的请求"""
+        # 获取当前可用的请求数量
+        available_slots = self._get_available_slots(platform)
+        
+        # 处理等待队列中的请求
+        while available_slots > 0 and self.waiting_queues[platform]:
+            # 获取等待队列头部的请求
+            request_data = self.waiting_queues[platform].pop(0)
+            request_func, args, kwargs, result_event, result_container = request_data
+            
+            # 在新线程中执行请求
+            threading.Thread(
+                target=self._execute_request,
+                args=(platform, request_func, args, kwargs, result_event, result_container)
+            ).start()
+            
+            # 减少可用槽位
+            available_slots -= 1
+    
+    def _get_available_slots(self, platform: str) -> int:
+        """计算平台当前可用的请求槽位数"""
+        limit = self.platform_limits.get(platform, self.platform_limits['default'])
+        return max(0, limit - len(self.completed_queues[platform]))
+    
+    def _execute_request(self, platform: str, request_func: Callable, 
+                        args: Tuple, kwargs: Dict, 
+                        result_event: threading.Event, 
+                        result_container: List):
+        """执行请求并存储结果"""
+        try:
+            # 立即记录请求时间（添加到完成队列）
+            with self.locks[platform]:
+                self.completed_queues[platform].append(time.time())
+            
+            # 执行请求
+            result = request_func(*args, **kwargs)
+            
+            # 存储结果
+            result_container.append(result)
+        except Exception as e:
+            # 存储异常
+            result_container.append(e)
+        finally:
+            # 通知等待线程结果已准备好
+            result_event.set()
+    
+    def execute(self, platform: str, method_name: str, *args, **kwargs):
+        """
+        执行API请求，处理节流控制
+        
+        Args:
+            platform: API平台名称 (如 'openai', 'anthropic' 等)
+            method_name: 要调用的方法名称 (如 'validate_api_key')
+            *args, **kwargs: 传递给方法的参数
+            
+        Returns:
+            方法的返回值
+        """
+        # 确保平台支持
+        if platform not in self.platform_limits and platform != 'default':
+            # 如果不是已知平台，则使用默认限制
+            platform = 'default'
+            
+        # 导入相应平台的模块
+        try:
+            module = importlib.import_module(f"core.api.{platform}")
+        except ImportError:
+            raise ValueError(f"不支持的平台: {platform}")
+        
+        # 获取方法
+        if not hasattr(module, method_name):
+            raise ValueError(f"平台 {platform} 没有方法 {method_name}")
+        
+        method = getattr(module, method_name)
+        
+        # 创建结果容器和事件
+        result_container = []
+        result_event = threading.Event()
+        
+        # 请求函数
+        request_func = lambda *a, **kw: method(*a, **kw)
+        
+        with self.locks[platform]:
+            # 检查是否有可用槽位
+            if len(self.completed_queues[platform]) < self.platform_limits.get(platform, self.platform_limits['default']):
+                # 有槽位，立即执行
+                threading.Thread(
+                    target=self._execute_request,
+                    args=(platform, request_func, args, kwargs, result_event, result_container)
+                ).start()
+            else:
+                # 没有槽位，添加到等待队列
+                self.waiting_queues[platform].append((request_func, args, kwargs, result_event, result_container))
+        
+        # 等待结果（同步阻塞）
+        result_event.wait()
+        
+        # 获取结果
+        if not result_container:
+            raise RuntimeError("请求执行失败，没有结果")
+        
+        result = result_container[0]
+        if isinstance(result, Exception):
+            raise result
+            
+        return result
+        
+    def shutdown(self):
+        """关闭调度器"""
+        self._scheduler_active = False
+
+# 全局API管理器实例
+_api_manager = None
+
+def get_api_manager():
+    """
+    获取全局API管理器实例
+    
+    Returns:
+        ApiManager: API管理器实例
+    """
+    global _api_manager
+    if _api_manager is None:
+        _api_manager = ApiManager()
+    return _api_manager
+
+def start_service():
+    """
+    启动API管理服务
+    
+    Returns:
+        list: 服务相关的线程列表
+    """
+    # 初始化API管理器
+    api_manager = get_api_manager()
+    
+    # 此处可以添加其他需要启动的服务线程
+    # 例如: 监控线程、日志线程等
+    
+    # 返回服务线程列表（目前API管理器的调度线程是内部管理的，所以返回空列表）
+    return []

cron.py

@@ -0,0 +1,88 @@
+"""
+定时任务模块 - 定期更新所有API密钥
+"""
+import json
+import os
+import time
+import sched
+import threading
+import sqlite3
+from update import update
+from utils.db import get_db_connection
+from config import API_KEYS_FILE
+
+# 定义更新间隔（12小时，单位：秒）
+UPDATE_INTERVAL = 12 * 60 * 60
+
+def update_all_keys():
+    """
+    更新所有API密钥
+    """
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 开始更新所有API密钥...")
+    
+    # 从SQLite数据库获取所有密钥ID
+    conn = get_db_connection()
+    key_ids = []
+    
+    try:
+        cursor = conn.cursor()
+        cursor.execute('SELECT id FROM api_keys')
+        rows = cursor.fetchall()
+        key_ids = [row['id'] for row in rows]
+    except sqlite3.Error as e:
+        print(f"从数据库获取密钥时出错: {str(e)}")
+        
+        # 备用方案：尝试从JSON文件读取
+        if os.path.exists(API_KEYS_FILE):
+            try:
+                with open(API_KEYS_FILE, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+                key_ids = [key["id"] for key in data.get("api_keys", [])]
+            except Exception as e:
+                print(f"读取API密钥文件失败: {str(e)}")
+                return
+    finally:
+        if conn:
+            conn.close()
+    
+    # 如果没有找到密钥，则退出
+    if not key_ids:
+        print("没有找到API密钥，跳过更新")
+        return
+    
+    # 逐个更新API密钥
+    for key_id in key_ids:
+        result = update(key_id)
+        if result["success"]:
+            print(f"  - 密钥 {key_id} 更新成功")
+        else:
+            print(f"  - 密钥 {key_id} 更新失败: {result['message']}")
+    
+    print(f"[{time.strftime('%Y-%m-%d %H:%M:%S')}] 完成所有API密钥更新")
+
+def run_scheduler():
+    """
+    运行定时任务
+    """
+    scheduler = sched.scheduler(time.time, time.sleep)
+    
+    def scheduled_update():
+        update_all_keys()
+        # 再次安排下一次更新
+        scheduler.enter(UPDATE_INTERVAL, 1, scheduled_update, ())
+    
+    # 首次安排更新
+    scheduler.enter(UPDATE_INTERVAL, 1, scheduled_update, ())
+    
+    print(f"定时任务已启动，每 {UPDATE_INTERVAL // 3600} 小时更新一次API密钥")
+    scheduler.run()
+
+if __name__ == "__main__":
+    # 在单独的线程中运行定时任务，避免阻塞主线程
+    scheduler_thread = threading.Thread(target=run_scheduler)
+    scheduler_thread.daemon = True  # 设置为守护线程，当主线程退出时自动结束
+    scheduler_thread.start()
+    
+    # 保持主线程运行（可选，根据实际需求）
+    while True:
+        time.sleep(60)

models/api_key.py

@@ -6,14 +6,16 @@ import uuid
 from datetime import datetime
 import os
 import pytz
-from config import API_KEYS_FILE
+import sqlite3
+from utils.db import get_db_connection
+from config import API_KEYS_FILE, DATABASE_PATH
 
 class ApiKeyManager:
     """管理API密钥的类"""
     
     @staticmethod
     def load_keys():
-        """加载所有API密钥"""
+        """加载所有API密钥 (兼容旧的JSON方式)"""
         if not os.path.exists(API_KEYS_FILE):
             with open(API_KEYS_FILE, 'w', encoding='utf-8') as f:
                 json.dump({"api_keys": []}, f, ensure_ascii=False, indent=2)
@@ -27,49 +29,124 @@ class ApiKeyManager:
     
     @staticmethod
     def save_keys(data):
-        """保存API密钥数据"""
+        """保存API密钥数据 (兼容旧的JSON方式)"""
         with open(API_KEYS_FILE, 'w', encoding='utf-8') as f:
             json.dump(data, f, ensure_ascii=False, indent=2)
     
     @staticmethod
     def get_all_keys():
         """获取所有密钥"""
-        return ApiKeyManager.load_keys()
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute('SELECT * FROM api_keys')
+            rows = cursor.fetchall()
+            
+            # 转换为字典列表
+            api_keys = []
+            for row in rows:
+                key_dict = dict(row)
+                # 转换success字段从整数为布尔值
+                key_dict['success'] = bool(key_dict['success'])
+                api_keys.append(key_dict)
+            
+            return {"api_keys": api_keys}
+        except sqlite3.Error as e:
+            print(f"获取所有密钥时出错: {str(e)}")
+            # 如果数据库出错，尝试从JSON文件加载
+            return ApiKeyManager.load_keys()
+        finally:
+            conn.close()
     
     @staticmethod
     def add_key(platform, name, key):
         """添加新的API密钥"""
-        api_keys_data = ApiKeyManager.load_keys()
-        
         # 过滤掉key中的单引号、双引号、小括号、方括号和空格，防止存储时出错
         if key:
             key = key.replace("'", "").replace('"', "").replace('(', "").replace(')', "").replace('[', "").replace(']', "").replace(' ', "")
         
+        current_time = datetime.now(pytz.timezone('Asia/Shanghai')).isoformat()
+        new_key_id = str(uuid.uuid4())
+        
         new_key = {
-            "id": str(uuid.uuid4()),
+            "id": new_key_id,
             "platform": platform,
             "name": name,
             "key": key,
-            "created_at": datetime.now(pytz.timezone('Asia/Shanghai')).isoformat()
+            "created_at": current_time,
+            "updated_at": current_time,
+            "success": False,
+            "return_message": "等待测试",
+            "states": "",
+            "balance": 0
         }
         
-        api_keys_data["api_keys"].append(new_key)
-        ApiKeyManager.save_keys(api_keys_data)
-        
-        return new_key
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute('''
+            INSERT INTO api_keys 
+            (id, platform, name, key, created_at, updated_at, success, return_message, states, balance)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                new_key_id,
+                platform,
+                name,
+                key,
+                current_time,
+                current_time,
+                0,  # success是整数: 0表示False
+                "等待测试",
+                "",
+                0
+            ))
+            conn.commit()
+            
+            # 自动调用update函数验证密钥
+            from update import update
+            try:
+                print(f"[自动验证] 正在验证密钥 ID: {new_key_id}")
+                update_result = update(new_key_id)
+                print(f"[自动验证] 密钥验证结果: {update_result}")
+            except Exception as e:
+                print(f"[自动验证] 验证密钥时出错: {str(e)}")
+                
+            return new_key
+        except sqlite3.Error as e:
+            print(f"添加密钥时出错: {str(e)}")
+            conn.rollback()
+            # 如果数据库出错，尝试使用JSON方式保存
+            api_keys_data = ApiKeyManager.load_keys()
+            api_keys_data["api_keys"].append(new_key)
+            ApiKeyManager.save_keys(api_keys_data)
+            return new_key
+        finally:
+            conn.close()
     
     @staticmethod
     def delete_key(key_id):
         """删除指定的API密钥"""
-        api_keys_data = ApiKeyManager.load_keys()
-        
-        original_count = len(api_keys_data["api_keys"])
-        api_keys_data["api_keys"] = [k for k in api_keys_data["api_keys"] if k.get("id") != key_id]
-        
-        if len(api_keys_data["api_keys"]) < original_count:
-            ApiKeyManager.save_keys(api_keys_data)
-            return True
-        return False
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute('DELETE FROM api_keys WHERE id = ?', (key_id,))
+            deleted = cursor.rowcount > 0
+            conn.commit()
+            return deleted
+        except sqlite3.Error as e:
+            print(f"删除密钥时出错: {str(e)}")
+            conn.rollback()
+            # 如果数据库出错，尝试从JSON文件删除
+            api_keys_data = ApiKeyManager.load_keys()
+            original_count = len(api_keys_data["api_keys"])
+            api_keys_data["api_keys"] = [k for k in api_keys_data["api_keys"] if k.get("id") != key_id]
+            
+            if len(api_keys_data["api_keys"]) < original_count:
+                ApiKeyManager.save_keys(api_keys_data)
+                return True
+            return False
+        finally:
+            conn.close()
     
     @staticmethod
     def bulk_delete(key_ids):
@@ -77,16 +154,38 @@ class ApiKeyManager:
         if not key_ids:
             return 0
         
-        api_keys_data = ApiKeyManager.load_keys()
-        
-        original_count = len(api_keys_data["api_keys"])
-        api_keys_data["api_keys"] = [k for k in api_keys_data["api_keys"] if k.get("id") not in key_ids]
-        
-        deleted_count = original_count - len(api_keys_data["api_keys"])
-        if deleted_count > 0:
-            ApiKeyManager.save_keys(api_keys_data)
-        
-        return deleted_count
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
+            # 获取当前的密钥数量
+            cursor.execute('SELECT COUNT(*) FROM api_keys')
+            original_count = cursor.fetchone()[0]
+            
+            # 使用参数化查询构建占位符
+            placeholders = ','.join(['?'] * len(key_ids))
+            cursor.execute(f'DELETE FROM api_keys WHERE id IN ({placeholders})', key_ids)
+            
+            # 获取删除后的密钥数量
+            cursor.execute('SELECT COUNT(*) FROM api_keys')
+            new_count = cursor.fetchone()[0]
+            
+            conn.commit()
+            return original_count - new_count
+        except sqlite3.Error as e:
+            print(f"批量删除密钥时出错: {str(e)}")
+            conn.rollback()
+            # 如果数据库出错，尝试从JSON文件删除
+            api_keys_data = ApiKeyManager.load_keys()
+            original_count = len(api_keys_data["api_keys"])
+            api_keys_data["api_keys"] = [k for k in api_keys_data["api_keys"] if k.get("id") not in key_ids]
+            
+            deleted_count = original_count - len(api_keys_data["api_keys"])
+            if deleted_count > 0:
+                ApiKeyManager.save_keys(api_keys_data)
+            
+            return deleted_count
+        finally:
+            conn.close()
     
     @staticmethod
     def bulk_add_keys(keys_data):
@@ -101,54 +200,146 @@ class ApiKeyManager:
         if not keys_data:
             return []
         
-        api_keys_data = ApiKeyManager.load_keys()
         added_keys = []
-        
         now = datetime.now(pytz.timezone('Asia/Shanghai')).isoformat()
         
-        for key_info in keys_data:
-            platform = key_info.get("platform")
-            name = key_info.get("name")
-            key = key_info.get("key")
-            
-            # 过滤掉key中的单引号、双引号、小括号、方括号和空格，防止存储时出错
-            if key:
-                key = key.replace("'", "").replace('"', "").replace('(', "").replace(')', "").replace('[', "").replace(']', "").replace(' ', "")
-            
-            new_key = {
-                "id": str(uuid.uuid4()),
-                "platform": platform,
-                "name": name,
-                "key": key,
-                "created_at": now
-            }
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
             
-            api_keys_data["api_keys"].append(new_key)
-            added_keys.append(new_key)
-        
-        # 一次性保存所有添加的密钥
-        ApiKeyManager.save_keys(api_keys_data)
-        
-        return added_keys
+            for key_info in keys_data:
+                platform = key_info.get("platform")
+                name = key_info.get("name")
+                key = key_info.get("key")
+                
+                # 过滤掉key中的单引号、双引号、小括号、方括号和空格，防止存储时出错
+                if key:
+                    key = key.replace("'", "").replace('"', "").replace('(', "").replace(')', "").replace('[', "").replace(']', "").replace(' ', "")
+                
+                new_key_id = str(uuid.uuid4())
+                
+                new_key = {
+                    "id": new_key_id,
+                    "platform": platform,
+                    "name": name,
+                    "key": key,
+                    "created_at": now,
+                    "updated_at": now,
+                    "success": False,
+                    "return_message": "等待测试",
+                    "states": "",
+                    "balance": 0
+                }
+                
+                cursor.execute('''
+                INSERT INTO api_keys 
+                (id, platform, name, key, created_at, updated_at, success, return_message, states, balance)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    new_key_id,
+                    platform,
+                    name,
+                    key,
+                    now,
+                    now,
+                    0,  # success是整数: 0表示False
+                    "等待测试",
+                    "",
+                    0
+                ))
+                
+                added_keys.append(new_key)
+            
+            conn.commit()
+            
+            # 在批量添加完成后，启动一个单独的线程来验证所有新添加的密钥
+            from update import update
+            from threading import Thread
+            
+            def validate_keys():
+                for new_key in added_keys:
+                    try:
+                        key_id = new_key["id"]
+                        print(f"[自动验证] 正在验证密钥 ID: {key_id}")
+                        update_result = update(key_id)
+                        print(f"[自动验证] 密钥验证结果: {update_result}")
+                    except Exception as e:
+                        print(f"[自动验证] 验证密钥时出错: {str(e)}")
+            
+            # 启动验证线程
+            print(f"[自动验证] 启动验证线程，验证 {len(added_keys)} 个新添加的密钥")
+            validation_thread = Thread(target=validate_keys)
+            validation_thread.daemon = True  # 设置为守护线程，当主线程退出时自动结束
+            validation_thread.start()
+            
+            return added_keys
+        except sqlite3.Error as e:
+            print(f"批量添加密钥时出错: {str(e)}")
+            conn.rollback()
+            # 如果数据库出错，尝试使用JSON方式保存
+            api_keys_data = ApiKeyManager.load_keys()
+            for key in added_keys:
+                api_keys_data["api_keys"].append(key)
+            ApiKeyManager.save_keys(api_keys_data)
+            return added_keys
+        finally:
+            conn.close()
     
     @staticmethod
     def update_key(key_id, name, key):
         """更新API密钥信息"""
-        api_keys_data = ApiKeyManager.load_keys()
-        
         # 过滤掉key中的单引号、双引号、小括号、方括号和空格，防止存储时出错
         if key:
             key = key.replace("'", "").replace('"', "").replace('(', "").replace(')', "").replace('[', "").replace(']', "").replace(' ', "")
-            
-        updated_key = None
-        for k in api_keys_data["api_keys"]:
-            if k.get("id") == key_id:
-                k["name"] = name
-                k["key"] = key
-                updated_key = k
-                break
         
-        if updated_key:
-            ApiKeyManager.save_keys(api_keys_data)
+        updated_at = datetime.now(pytz.timezone('Asia/Shanghai')).isoformat()
+        
+        conn = get_db_connection()
+        try:
+            cursor = conn.cursor()
+            
+            # 更新密钥
+            cursor.execute('''
+            UPDATE api_keys 
+            SET name = ?, key = ?, updated_at = ?, success = ?, return_message = ?
+            WHERE id = ?
+            ''', (name, key, updated_at, 0, "等待测试", key_id))
+            
+            if cursor.rowcount > 0:
+                conn.commit()
+                
+                # 获取更新后的密钥信息
+                cursor.execute('SELECT * FROM api_keys WHERE id = ?', (key_id,))
+                row = cursor.fetchone()
+                
+                if row:
+                    updated_key = dict(row)
+                    # 转换success字段从整数为布尔值
+                    updated_key['success'] = bool(updated_key['success'])
+                    return updated_key
+            
+            return None
+        except sqlite3.Error as e:
+            print(f"更新密钥时出错: {str(e)}")
+            conn.rollback()
+            
+            # 如果数据库出错，尝试使用JSON方式更新
+            api_keys_data = ApiKeyManager.load_keys()
+            updated_key = None
+            for k in api_keys_data["api_keys"]:
+                if k.get("id") == key_id:
+                    k["name"] = name
+                    k["key"] = key
+                    k["updated_at"] = updated_at
+                    # 重置验证状态
+                    k["success"] = False
+                    k["return_message"] = "等待测试"
+                    updated_key = k
+                    break
             
-        return updated_key
+            if updated_key:
+                ApiKeyManager.save_keys(api_keys_data)
+                
+            return updated_key
+        finally:
+            conn.close()

routes/api.py

@@ -67,6 +67,22 @@ def bulk_add_api_keys():
         "message": f"成功添加 {len(added_keys)} 个API密钥"
     })
 
+@api_bp.route('/keys/update/<key_id>', methods=['POST', 'GET'])
+def update_api_key_status(key_id):
+    """更新API密钥状态"""
+    from update import update
+    try:
+        print(f"正在更新密钥ID: {key_id}")
+        result = update(key_id)
+        print(f"更新结果: {result}")
+        return jsonify({"success": True, "data": result})
+    except Exception as e:
+        import traceback
+        error_msg = str(e)
+        trace = traceback.format_exc()
+        print(f"更新密钥时出错: {error_msg}\n{trace}")
+        return jsonify({"success": False, "error": error_msg, "traceback": trace}), 500
+
 @api_bp.route('/keys/<key_id>', methods=['PUT'])
 def edit_api_key(key_id):
     """更新API密钥信息"""

routes/web.py

@@ -33,6 +33,11 @@ def index():
     is_ajax = request.args.get('ajax', '0') == '1'
     return render_template('index.html', platforms=PLATFORMS, grouped_keys=grouped_keys, platform_styles=PLATFORM_STYLES)
 
+@web_bp.route('/update-test')
+def update_test():
+    """API密钥更新测试页面"""
+    return render_template('update_test.html')
+
 @web_bp.route('/login', methods=['GET', 'POST'])
 def login():
     """用户登录"""

static/js/api-key-manager/api-key-creator.js

@@ -4,6 +4,7 @@
  */
 
 // 添加API密钥
+
 async function addApiKey() {
     if (!this.newKey.platform || !this.newKey.key) {
         this.errorMessage = '请填写所有必填字段。';
@@ -120,6 +121,30 @@ async function addApiKey() {
             
             // 重新加载API密钥数据而不刷新页面
             this.loadApiKeys();
+            
+            // 为每个新添加的API密钥调用update API
+            if (data.keys && data.keys.length > 0) {
+                // 延迟200ms确保UI更新
+                setTimeout(() => {
+                    data.keys.forEach(key => {
+                        console.log(`正在请求更新API密钥: ${key.id}`);
+                        fetch(`/api/keys/update/${key.id}`, { 
+                            method: 'POST' 
+                        }).then(response => {
+                            if (!response.ok) {
+                                throw new Error(`HTTP error! status: ${response.status}`);
+                            }
+                            return response.json();
+                        }).then(data => {
+                            console.log(`API密钥 ${key.id} 更新成功:`, data);
+                            // 更新成功后重新加载密钥列表
+                            this.loadApiKeys();
+                        }).catch(error => {
+                            console.error(`自动更新API密钥 ${key.id} 时出错:`, error);
+                        });
+                    });
+                }, 200);
+            }
 
             // 构建通知消息
             let title = `已添加 ${addedCount} 个API密钥`;

static/js/api-key-manager/api-key-editor.js

@@ -130,6 +130,25 @@ async function updateApiKey() {
             // 重新加载API密钥数据而不刷新页面
             this.loadApiKeys();
 
+            // 调用update API更新密钥状态
+            setTimeout(() => {
+                console.log(`正在请求更新API密钥: ${this.editKey.id}`);
+                fetch(`/api/keys/update/${this.editKey.id}`, { 
+                    method: 'POST'
+                }).then(response => {
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
+                    return response.json();
+                }).then(data => {
+                    console.log(`API密钥 ${this.editKey.id} 更新成功:`, data);
+                    // 更新成功后重新加载密钥列表
+                    this.loadApiKeys();
+                }).catch(error => {
+                    console.error(`自动更新API密钥 ${this.editKey.id} 时出错:`, error);
+                });
+            }, 200);
+
             Toast.fire({
                 icon: 'success',
                 title: 'API密钥已更新',

templates/components/api_key_list.html

@@ -213,9 +213,9 @@
                             <!-- 密钥名称 -->
                             <h3 class="text-sm font-medium text-gray-900 truncate">{{ key.name }}</h3>
                             
-                            <!-- 创建时间 - 重构版 -->
+                            <!-- 创建和更新时间 -->
                             <div class="mt-1.5 flex items-center">
-                                <!-- 日期部分 -->
+                                <!-- 创建时间部分 -->
                                 <div class="flex items-center mr-2">
                                     <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 text-gray-500 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                                         <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z" />
@@ -223,14 +223,59 @@
                                     <span class="text-xs text-gray-600">{{ key.created_at.split('T')[0] }}</span>
                                 </div>
                                 
-                                <!-- 时间部分 -->
-                                <div class="flex items-center">
+                                <!-- 创建时间 -->
+                                <div class="flex items-center mr-2">
                                     <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 text-gray-500 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
                                         <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
                                     </svg>
-                                    <span class="text-xs text-gray-600">{{ key.created_at.split('T')[1].split('.')[0] }}</span>
+                                    <span class="text-xs text-gray-600">创建: {{ key.created_at.split('T')[1].split('.')[0] }}</span>
+                                </div>
+                                
+                                <!-- 如果存在更新时间，显示更新时间 -->
+                                {% if key.updated_at %}
+                                <div class="flex items-center">
+                                    <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 text-blue-500 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15" />
+                                    </svg>
+                                    <span class="text-xs text-blue-600">更新: {{ key.updated_at.split('T')[1].split('.')[0] }}</span>
+                                </div>
+                                {% endif %}
+                            </div>
+                            
+                            <!-- 显示API状态信息 -->
+                            {% if key.success == True %}
+                            <div class="mt-1 flex flex-wrap gap-2">
+                                <!-- 如果有余额信息，显示余额 -->
+                                {% if key.balance %}
+                                <div class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-800">
+                                    <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8c-1.657 0-3 .895-3 2s1.343 2 3 2 3 .895 3 2-1.343 2-3 2m0-8c1.11 0 2.08.402 2.599 1M12 8V7m0 1v8m0 0v1m0-1c-1.11 0-2.08-.402-2.599-1M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+                                    </svg>
+                                    余额: {{ key.balance }}
+                                </div>
+                                {% endif %}
+                                
+                                <!-- 如果有状态信息，显示状态 -->
+                                {% if key.states %}
+                                <div class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-100 text-blue-800">
+                                    <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+                                    </svg>
+                                    状态: {{ key.states }}
+                                </div>
+                                {% endif %}
+                            </div>
+                            {% elif key.success == False and key.return_message %}
+                            <!-- 显示错误信息 -->
+                            <div class="mt-1 flex items-center">
+                                <div class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-red-100 text-red-800">
+                                    <svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5 mr-1" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+                                    </svg>
+                                    {{ key.return_message }}
                                 </div>
                             </div>
+                            {% endif %}
                             
                             <!-- 密钥值 -->
                             <div class="mt-1 relative group key-scroll-container custom-scrollbar overflow-x-auto">

templates/update_test.html

@@ -0,0 +1,294 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>API密钥测试更新</title>
+    <link rel="stylesheet" href="/static/css/base.css">
+    <link rel="stylesheet" href="/static/css/style.css">
+    <style>
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .key-list {
+            margin-top: 20px;
+            border: 1px solid #e5e7eb;
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        .key-item {
+            padding: 15px;
+            border-bottom: 1px solid #e5e7eb;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .key-item:last-child {
+            border-bottom: none;
+        }
+        .key-item:hover {
+            background-color: #f9fafb;
+        }
+        .key-info {
+            flex-grow: 1;
+        }
+        .key-name {
+            font-weight: 500;
+            margin-bottom: 5px;
+        }
+        .key-value {
+            font-family: monospace;
+            color: #6b7280;
+            word-break: break-all;
+        }
+        .key-platform {
+            color: #4f46e5;
+            font-size: 0.875rem;
+            margin-bottom: 8px;
+        }
+        .key-status {
+            display: flex;
+            flex-direction: column;
+            align-items: flex-end;
+            min-width: 120px;
+        }
+        .update-btn {
+            padding: 6px 12px;
+            border-radius: 6px;
+            background-color: #4f46e5;
+            color: white;
+            font-size: 0.875rem;
+            border: none;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        .update-btn:hover {
+            background-color: #4338ca;
+        }
+        .success-badge {
+            margin-top: 8px;
+            padding: 4px 8px;
+            border-radius: 9999px;
+            font-size: 0.75rem;
+            background-color: #dcfce7;
+            color: #16a34a;
+        }
+        .error-badge {
+            margin-top: 8px;
+            padding: 4px 8px;
+            border-radius: 9999px;
+            font-size: 0.75rem;
+            background-color: #fee2e2;
+            color: #dc2626;
+        }
+        .pending-badge {
+            margin-top: 8px;
+            padding: 4px 8px;
+            border-radius: 9999px;
+            font-size: 0.75rem;
+            background-color: #e0f2fe;
+            color: #0284c7;
+        }
+        #loading {
+            display: none;
+            margin: 20px auto;
+            text-align: center;
+            font-style: italic;
+            color: #6b7280;
+        }
+        .response-container {
+            margin-top: 15px;
+            background-color: #f9fafb;
+            border-radius: 6px;
+            padding: 10px;
+            font-family: monospace;
+            font-size: 0.875rem;
+            white-space: pre-wrap;
+            word-break: break-all;
+            display: none;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>API密钥测试与更新</h1>
+        <p>在此页面可以测试update.py脚本的功能，验证API密钥并更新其状态。</p>
+        
+        <div id="loading">正在加载API密钥列表...</div>
+        
+        <div id="keyList" class="key-list"></div>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', function() {
+            loadKeys();
+            
+            // 添加回主页的按钮
+            const container = document.querySelector('.container');
+            const backButton = document.createElement('a');
+            backButton.href = '/';
+            backButton.textContent = '返回主页';
+            backButton.style.display = 'inline-block';
+            backButton.style.marginTop = '20px';
+            backButton.style.color = '#4f46e5';
+            backButton.style.textDecoration = 'none';
+            container.appendChild(backButton);
+        });
+        
+        async function loadKeys() {
+            const loadingElement = document.getElementById('loading');
+            const keyListElement = document.getElementById('keyList');
+            
+            loadingElement.style.display = 'block';
+            keyListElement.innerHTML = '';
+            
+            try {
+                const response = await fetch('/api/keys');
+                const data = await response.json();
+                
+                if (data && data.api_keys && data.api_keys.length > 0) {
+                    data.api_keys.forEach(key => {
+                        const keyElement = createKeyElement(key);
+                        keyListElement.appendChild(keyElement);
+                    });
+                } else {
+                    keyListElement.innerHTML = '<div style="padding: 20px; text-align: center; color: #6b7280;">没有找到API密钥</div>';
+                }
+            } catch (error) {
+                console.error('加载API密钥失败:', error);
+                keyListElement.innerHTML = `<div style="padding: 20px; text-align: center; color: #dc2626;">加载API密钥失败: ${error.message}</div>`;
+            } finally {
+                loadingElement.style.display = 'none';
+            }
+        }
+        
+        function createKeyElement(key) {
+            const keyItem = document.createElement('div');
+            keyItem.className = 'key-item';
+            keyItem.id = `key-${key.id}`;
+            
+            // 密钥信息区域
+            const keyInfo = document.createElement('div');
+            keyInfo.className = 'key-info';
+            
+            // 平台信息
+            const platformElement = document.createElement('div');
+            platformElement.className = 'key-platform';
+            platformElement.textContent = getPlatformName(key.platform);
+            keyInfo.appendChild(platformElement);
+            
+            // 密钥名称
+            const nameElement = document.createElement('div');
+            nameElement.className = 'key-name';
+            nameElement.textContent = key.name;
+            keyInfo.appendChild(nameElement);
+            
+            // 密钥值
+            const valueElement = document.createElement('div');
+            valueElement.className = 'key-value';
+            valueElement.textContent = key.key;
+            keyInfo.appendChild(valueElement);
+            
+            // 如果有更新时间，显示
+            if (key.updated_at) {
+                const updatedElement = document.createElement('div');
+                updatedElement.style.fontSize = '0.75rem';
+                updatedElement.style.color = '#6b7280';
+                updatedElement.style.marginTop = '5px';
+                
+                const date = new Date(key.updated_at);
+                updatedElement.textContent = `上次更新: ${date.toLocaleString()}`;
+                keyInfo.appendChild(updatedElement);
+            }
+            
+            // 响应容器
+            const responseContainer = document.createElement('div');
+            responseContainer.className = 'response-container';
+            responseContainer.id = `response-${key.id}`;
+            keyInfo.appendChild(responseContainer);
+            
+            keyItem.appendChild(keyInfo);
+            
+            // 状态和按钮区域
+            const keyStatus = document.createElement('div');
+            keyStatus.className = 'key-status';
+            
+            // 更新按钮
+            const updateButton = document.createElement('button');
+            updateButton.className = 'update-btn';
+            updateButton.textContent = '更新状态';
+            updateButton.onclick = function() {
+                updateKeyStatus(key.id);
+            };
+            keyStatus.appendChild(updateButton);
+            
+            // 状态标签
+            const statusBadge = document.createElement('div');
+            if (key.success === true) {
+                statusBadge.className = 'success-badge';
+                statusBadge.textContent = '验证成功';
+            } else if (key.success === false) {
+                statusBadge.className = 'error-badge';
+                statusBadge.textContent = key.return_message || '验证失败';
+            } else {
+                statusBadge.className = 'pending-badge';
+                statusBadge.textContent = '等待验证';
+            }
+            keyStatus.appendChild(statusBadge);
+            
+            keyItem.appendChild(keyStatus);
+            
+            return keyItem;
+        }
+        
+        async function updateKeyStatus(keyId) {
+            const keyElement = document.getElementById(`key-${keyId}`);
+            const updateButton = keyElement.querySelector('.update-btn');
+            const responseContainer = document.getElementById(`response-${keyId}`);
+            
+            // 禁用按钮并显示加载状态
+            updateButton.disabled = true;
+            updateButton.textContent = '更新中...';
+            
+            try {
+                const response = await fetch(`/api/keys/update/${keyId}`, {
+                    method: 'POST'
+                });
+                
+                const result = await response.json();
+                
+                // 显示响应数据
+                responseContainer.textContent = JSON.stringify(result, null, 2);
+                responseContainer.style.display = 'block';
+                
+                // 刷新密钥列表
+                loadKeys();
+                
+            } catch (error) {
+                console.error(`更新密钥 ${keyId} 失败:`, error);
+                responseContainer.textContent = `更新失败: ${error.message}`;
+                responseContainer.style.display = 'block';
+            } finally {
+                // 恢复按钮状态
+                updateButton.disabled = false;
+                updateButton.textContent = '更新状态';
+            }
+        }
+        
+        function getPlatformName(platformId) {
+            const platforms = {
+                'openai': 'OpenAI',
+                'anthropic': 'Anthropic',
+                'google': 'Google',
+                'deepseek': 'DeepSeek'
+            };
+            
+            return platforms[platformId] || platformId;
+        }
+    </script>
+</body>
+</html>

update.py

@@ -0,0 +1,139 @@
+"""
+API密钥更新模块 - 提供API密钥的验证和更新功能
+"""
+import json
+import os
+import sqlite3
+from datetime import datetime
+from core.api_manager import get_api_manager
+from utils.db import get_db_connection
+from config import API_KEYS_FILE
+
+def update(key_id):
+    """
+    更新指定ID的API密钥
+    
+    Args:
+        key_id (str): 要更新的API密钥ID
+        
+    Returns:
+        dict: 包含更新结果的字典，成功时返回更新后的密钥信息，失败时返回错误信息
+    """
+    # 从SQLite数据库中获取密钥信息
+    conn = get_db_connection()
+    try:
+        cursor = conn.cursor()
+        cursor.execute('SELECT * FROM api_keys WHERE id = ?', (key_id,))
+        row = cursor.fetchone()
+        
+        if row is None:
+            # 数据库中找不到，尝试从JSON文件加载
+            # 这是为了支持旧版本的兼容
+            if os.path.exists(API_KEYS_FILE):
+                try:
+                    with open(API_KEYS_FILE, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                    
+                    for key in data.get("api_keys", []):
+                        if key.get("id") == key_id:
+                            key_data = key
+                            break
+                    else:
+                        return {"success": False, "message": f"未找到ID为 {key_id} 的API密钥"}
+                except Exception as e:
+                    return {"success": False, "message": f"读取API密钥文件失败: {str(e)}"}
+            else:
+                return {"success": False, "message": f"未找到ID为 {key_id} 的API密钥"}
+        else:
+            key_data = dict(row)
+        
+        # 获取平台和密钥
+        platform = key_data.get("platform")
+        api_key = key_data.get("key")
+        
+        # 获取API管理器
+        api_manager = get_api_manager()
+        
+        # 调用API管理器验证密钥
+        try:
+            result = api_manager.execute(platform, "validate_api_key", api_key)
+        except Exception as e:
+            return {"success": False, "message": f"验证API密钥时出错: {str(e)}"}
+        
+        # 当前时间
+        current_time = datetime.now().isoformat()
+        
+        # 将布尔值转换为整数
+        success_int = 1 if result.get("success", False) else 0
+        
+        # 更新密钥信息到SQLite数据库
+        try:
+            cursor.execute('''
+            UPDATE api_keys
+            SET states = ?, balance = ?, success = ?, return_message = ?, updated_at = ?
+            WHERE id = ?
+            ''', (
+                result.get("states", ""),
+                result.get("balance", 0),
+                success_int,
+                result.get("return_message", ""),
+                current_time,
+                key_id
+            ))
+            
+            # 如果数据库中没有此记录（可能是旧的JSON格式数据），则插入新记录
+            if cursor.rowcount == 0 and 'id' in key_data:
+                cursor.execute('''
+                INSERT OR REPLACE INTO api_keys
+                (id, platform, name, key, created_at, updated_at, success, return_message, states, balance)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    key_data.get("id"),
+                    key_data.get("platform"),
+                    key_data.get("name"),
+                    key_data.get("key"),
+                    key_data.get("created_at", current_time),
+                    current_time,
+                    success_int,
+                    result.get("return_message", ""),
+                    result.get("states", ""),
+                    result.get("balance", 0)
+                ))
+            
+            conn.commit()
+            
+            # 获取更新后的完整记录
+            cursor.execute('SELECT * FROM api_keys WHERE id = ?', (key_id,))
+            updated_row = cursor.fetchone()
+            
+            if updated_row:
+                updated_data = dict(updated_row)
+                # 将布尔值转换为布尔类型
+                updated_data['success'] = bool(updated_data['success'])
+                
+                return {
+                    "success": True, 
+                    "message": "API密钥更新成功",
+                    "data": updated_data
+                }
+            else:
+                # 如果以某种方式在更新过程中密钥被删除
+                return {"success": False, "message": f"更新期间ID为 {key_id} 的API密钥已被删除"}
+            
+        except sqlite3.Error as e:
+            conn.rollback()
+            return {"success": False, "message": f"更新数据库中的API密钥失败: {str(e)}"}
+        
+    except sqlite3.Error as e:
+        return {"success": False, "message": f"从数据库获取API密钥时出错: {str(e)}"}
+    finally:
+        if conn:
+            conn.close()
+
+if __name__ == "__main__":
+    # 可以在这里添加命令行参数解析的代码，用于直接从命令行调用
+    import sys
+    if len(sys.argv) > 1:
+        key_id = sys.argv[1]
+        result = update(key_id)
+        print(json.dumps(result, indent=2, ensure_ascii=False))

utils/db.py

@@ -0,0 +1,53 @@
+"""
+数据库工具模块 - 处理SQLite数据库连接和初始化
+"""
+import sqlite3
+import os
+from config import DATABASE_PATH
+
+def get_db_connection():
+    """
+    获取数据库连接
+    
+    Returns:
+        sqlite3.Connection: 数据库连接对象
+    """
+    conn = sqlite3.connect(DATABASE_PATH)
+    conn.row_factory = sqlite3.Row  # 使查询结果可以通过列名访问
+    return conn
+
+def init_db():
+    """
+    初始化数据库，创建必要的表
+    """
+    # 确保数据目录存在
+    os.makedirs(os.path.dirname(DATABASE_PATH), exist_ok=True)
+    
+    conn = get_db_connection()
+    try:
+        cursor = conn.cursor()
+        
+        # 创建API密钥表
+        cursor.execute('''
+        CREATE TABLE IF NOT EXISTS api_keys (
+            id TEXT PRIMARY KEY,
+            platform TEXT NOT NULL,
+            name TEXT NOT NULL,
+            key TEXT NOT NULL,
+            created_at TEXT NOT NULL,
+            updated_at TEXT NOT NULL,
+            success INTEGER DEFAULT 0,
+            return_message TEXT DEFAULT '等待测试',
+            states TEXT DEFAULT '',
+            balance REAL DEFAULT 0
+        )
+        ''')
+        
+        conn.commit()
+    except Exception as e:
+        print(f"初始化数据库时出错: {str(e)}")
+    finally:
+        conn.close()
+
+# 确保模块被导入时初始化数据库
+init_db()