939 lines
32 KiB
Python
939 lines
32 KiB
Python
"""
|
||
远光软件微调平台 - Flask 后端 API
|
||
"""
|
||
import os
|
||
import sys
|
||
import json
|
||
import pymysql
|
||
import yaml
|
||
import time
|
||
import logging
|
||
from datetime import datetime
|
||
from logging.handlers import TimedRotatingFileHandler, RotatingFileHandler
|
||
from flask import Flask, request, jsonify, send_from_directory
|
||
from flask_cors import CORS
|
||
from werkzeug.utils import secure_filename
|
||
|
||
# 导入API蓝图
|
||
from api import register_blueprints
|
||
|
||
# 获取项目根目录
|
||
PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
sys.path.insert(0, PROJECT_ROOT)
|
||
|
||
# 加载配置
|
||
CONFIG_PATH = os.path.join(PROJECT_ROOT, 'config.yaml')
|
||
|
||
|
||
def load_config():
|
||
"""加载配置文件"""
|
||
with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
|
||
return yaml.safe_load(f)
|
||
|
||
|
||
CONFIG = load_config()
|
||
|
||
# ============ 日志系统配置 ============
|
||
LOG_BASE_DIR = os.path.join(PROJECT_ROOT, 'logs')
|
||
|
||
|
||
def setup_logger(name='app'):
|
||
"""配置日志系统，按日期分目录存储"""
|
||
# 创建当天的日志目录
|
||
today = datetime.now().strftime('%Y-%m-%d')
|
||
log_dir = os.path.join(LOG_BASE_DIR, today)
|
||
os.makedirs(log_dir, exist_ok=True)
|
||
|
||
# 获取或创建 logger
|
||
logger = logging.getLogger(name)
|
||
logger.setLevel(logging.DEBUG)
|
||
|
||
# 清除已存在的处理器
|
||
logger.handlers.clear()
|
||
|
||
# 1. 全部日志处理器 (TimedRotatingFileHandler - 每天午夜分割)
|
||
all_log_path = os.path.join(log_dir, 'all.log')
|
||
all_handler = TimedRotatingFileHandler(all_log_path, when='midnight', interval=1, backupCount=30, encoding='utf-8')
|
||
all_handler.setLevel(logging.DEBUG)
|
||
all_handler.setFormatter(logging.Formatter(
|
||
'[%(asctime)s] %(levelname)s in %(module)s: %(message)s',
|
||
datefmt='%Y-%m-%d %H:%M:%S'
|
||
))
|
||
|
||
# 2. 错误日志处理器 (RotatingFileHandler - 10MB大小分割，保留10个备份)
|
||
error_log_path = os.path.join(log_dir, 'error.log')
|
||
error_handler = RotatingFileHandler(error_log_path, maxBytes=10*1024*1024, backupCount=10, encoding='utf-8')
|
||
error_handler.setLevel(logging.ERROR)
|
||
error_handler.setFormatter(logging.Formatter(
|
||
'[%(asctime)s] %(levelname)s in %(module)s: %(message)s',
|
||
datefmt='%Y-%m-%d %H:%M:%S'
|
||
))
|
||
|
||
# 3. 请求日志处理器
|
||
request_log_path = os.path.join(log_dir, 'request.log')
|
||
request_handler = RotatingFileHandler(request_log_path, maxBytes=10*1024*1024, backupCount=10, encoding='utf-8')
|
||
request_handler.setLevel(logging.INFO)
|
||
request_handler.setFormatter(logging.Formatter(
|
||
'[%(asctime)s] %(message)s',
|
||
datefmt='%Y-%m-%d %H:%M:%S'
|
||
))
|
||
|
||
# 4. 控制台处理器
|
||
console_handler = logging.StreamHandler()
|
||
console_handler.setLevel(logging.INFO)
|
||
console_handler.setFormatter(logging.Formatter(
|
||
'[%(asctime)s] %(levelname)s: %(message)s',
|
||
datefmt='%H:%M:%S'
|
||
))
|
||
|
||
# 添加处理器到 logger
|
||
logger.addHandler(all_handler)
|
||
logger.addHandler(error_handler)
|
||
logger.addHandler(console_handler)
|
||
|
||
# 为请求日志创建单独的 logger
|
||
request_logger = logging.getLogger('request')
|
||
request_logger.setLevel(logging.INFO)
|
||
request_logger.handlers.clear()
|
||
request_logger.addHandler(request_handler)
|
||
request_logger.addHandler(console_handler)
|
||
|
||
return logger
|
||
|
||
|
||
# 初始化日志系统
|
||
logger = setup_logger('app')
|
||
request_logger = logging.getLogger('request')
|
||
|
||
logger.info('=' * 50)
|
||
logger.info('服务启动')
|
||
logger.info('=' * 50)
|
||
|
||
|
||
def get_db_connection():
|
||
"""获取数据库连接"""
|
||
db_config = CONFIG['database']
|
||
return pymysql.connect(
|
||
host=db_config['host'],
|
||
port=db_config['port'],
|
||
user=db_config['username'],
|
||
password=db_config['password'],
|
||
database=db_config['name'],
|
||
charset=db_config.get('charset', 'utf8mb4'),
|
||
cursorclass=pymysql.cursors.DictCursor
|
||
)
|
||
|
||
|
||
def init_database():
|
||
"""初始化数据库表"""
|
||
logger.info("正在初始化数据库...")
|
||
try:
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
|
||
tables = [
|
||
# 精调训练表
|
||
"""CREATE TABLE IF NOT EXISTS fine_tune (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
base_model VARCHAR(255),
|
||
train_type VARCHAR(50),
|
||
train_method VARCHAR(50),
|
||
gpus JSON COMMENT 'GPU硬件选择，支持多卡训练',
|
||
dataset_id INT,
|
||
valid_split VARCHAR(50),
|
||
valid_ratio INT DEFAULT 10,
|
||
output_model_name VARCHAR(255),
|
||
status VARCHAR(50) DEFAULT 'pending',
|
||
progress INT DEFAULT 0,
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 我的模型表
|
||
"""CREATE TABLE IF NOT EXISTS my_models (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
type VARCHAR(100),
|
||
version VARCHAR(50),
|
||
description TEXT,
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 模型评测表
|
||
"""CREATE TABLE IF NOT EXISTS model_eval (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
model_name VARCHAR(255) NOT NULL,
|
||
dataset VARCHAR(255),
|
||
metric VARCHAR(100),
|
||
score DECIMAL(10, 4),
|
||
status VARCHAR(50) DEFAULT 'completed',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 模型部署表
|
||
"""CREATE TABLE IF NOT EXISTS model_deploy (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
model_name VARCHAR(255) NOT NULL,
|
||
endpoint VARCHAR(255),
|
||
instance VARCHAR(100),
|
||
status VARCHAR(50) DEFAULT 'running',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 模型对比表
|
||
"""CREATE TABLE IF NOT EXISTS model_compare (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
model_name VARCHAR(255) NOT NULL,
|
||
description TEXT,
|
||
models JSON,
|
||
status VARCHAR(50) DEFAULT 'pending',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 数据集管理表
|
||
"""CREATE TABLE IF NOT EXISTS dataset_manage (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
type VARCHAR(100),
|
||
size VARCHAR(50),
|
||
count INT,
|
||
description TEXT,
|
||
file_path VARCHAR(500),
|
||
file_count INT DEFAULT 0,
|
||
storage_type VARCHAR(50) DEFAULT 'local',
|
||
minio_config TEXT,
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 数据集文件表
|
||
"""CREATE TABLE IF NOT EXISTS dataset_files (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
dataset_id INT NOT NULL,
|
||
file_name VARCHAR(255) NOT NULL,
|
||
file_path VARCHAR(500) NOT NULL,
|
||
file_size BIGINT DEFAULT 0,
|
||
file_type VARCHAR(50),
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
FOREIGN KEY (dataset_id) REFERENCES dataset_manage(id) ON DELETE CASCADE
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 数据生成表
|
||
"""CREATE TABLE IF NOT EXISTS data_generate (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
template VARCHAR(255),
|
||
count INT DEFAULT 0,
|
||
status VARCHAR(50) DEFAULT 'pending',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 权限管理表
|
||
"""CREATE TABLE IF NOT EXISTS permission (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
username VARCHAR(100) NOT NULL,
|
||
role VARCHAR(50) DEFAULT 'user',
|
||
permissions TEXT,
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 模型管理表
|
||
"""CREATE TABLE IF NOT EXISTS model_manage (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
type VARCHAR(100),
|
||
model_source VARCHAR(20) DEFAULT 'local',
|
||
path VARCHAR(500),
|
||
api_url VARCHAR(500),
|
||
api_key VARCHAR(500),
|
||
model_name VARCHAR(255),
|
||
description TEXT,
|
||
purpose VARCHAR(50) DEFAULT 'inference',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 评测维度表
|
||
"""CREATE TABLE IF NOT EXISTS model_dimension (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
name VARCHAR(255) NOT NULL,
|
||
type VARCHAR(100),
|
||
description TEXT,
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 系统配置表
|
||
"""CREATE TABLE IF NOT EXISTS sys_config (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
config_key VARCHAR(100) NOT NULL UNIQUE,
|
||
config_value TEXT,
|
||
description VARCHAR(255),
|
||
update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4""",
|
||
|
||
# 用户表
|
||
"""CREATE TABLE IF NOT EXISTS users (
|
||
id INT AUTO_INCREMENT PRIMARY KEY,
|
||
username VARCHAR(100) NOT NULL UNIQUE,
|
||
password VARCHAR(255) NOT NULL,
|
||
role VARCHAR(50) DEFAULT 'user',
|
||
create_time DATETIME DEFAULT CURRENT_TIMESTAMP
|
||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4"""
|
||
]
|
||
|
||
for i, table_sql in enumerate(tables):
|
||
try:
|
||
cursor.execute(table_sql)
|
||
logger.debug(f"表 {i+1}/{len(tables)} 创建/检查成功")
|
||
except Exception as e:
|
||
logger.error(f"表 {i+1} 创建失败: {e}")
|
||
|
||
# 为已存在的表添加缺失的列（静默处理，不显示重复列的提示）
|
||
for table_col in [("model_manage", "purpose"), ("model_eval", "name"), ("fine_tune", "gpus")]:
|
||
try:
|
||
table_name, col_name = table_col
|
||
cursor.execute(f"ALTER TABLE {table_name} ADD COLUMN {col_name} JSON")
|
||
logger.debug(f"{table_name} 表添加 {col_name} 列成功")
|
||
except Exception:
|
||
pass # 列已存在时不输出任何信息
|
||
|
||
# 插入默认管理员用户
|
||
cursor.execute("SELECT * FROM users WHERE username = 'admin'")
|
||
if not cursor.fetchone():
|
||
cursor.execute("INSERT INTO users (username, password, role) VALUES ('admin', 'admin', 'admin')")
|
||
logger.info("默认管理员用户创建成功")
|
||
|
||
conn.commit()
|
||
cursor.close()
|
||
conn.close()
|
||
logger.info("数据库初始化完成")
|
||
except Exception as e:
|
||
logger.error(f"数据库初始化失败: {e}")
|
||
raise
|
||
|
||
|
||
app = Flask(__name__)
|
||
app.config['SECRET_KEY'] = CONFIG['secret_key']
|
||
app.config['CORS_HEADERS'] = 'Content-Type'
|
||
# 使用字符串形式的 origins
|
||
CORS(app, origins="*", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"], allow_headers=["Content-Type", "Authorization"], supports_credentials=False)
|
||
|
||
# 注册蓝图
|
||
register_blueprints(app)
|
||
|
||
|
||
# ============ 请求日志中间件 ============
|
||
@app.after_request
|
||
def log_request(response):
|
||
"""记录所有API请求"""
|
||
# 排除健康检查接口
|
||
if request.path != '/api/health':
|
||
request_logger.info(f'{request.method} {request.path} - {response.status_code}')
|
||
return response
|
||
|
||
|
||
# ============ 健康检查 ============
|
||
@app.route('/api/health', methods=['GET'])
|
||
def health_check():
|
||
"""健康检查接口，返回系统监控数据"""
|
||
import psutil
|
||
try:
|
||
cpu_percent = int(psutil.cpu_percent(interval=None))
|
||
memory = psutil.virtual_memory()
|
||
memory_percent = int(memory.percent)
|
||
disk = psutil.disk_usage('/')
|
||
disk_percent = int(disk.percent)
|
||
|
||
return jsonify({
|
||
'status': 'ok',
|
||
'code': 0,
|
||
'data': {
|
||
'cpu_percent': cpu_percent,
|
||
'memory_percent': memory_percent,
|
||
'disk_percent': disk_percent
|
||
}
|
||
})
|
||
except Exception as e:
|
||
logger.error(f"健康检查失败: {e}")
|
||
return jsonify({'status': 'error', 'code': 1, 'message': str(e)})
|
||
|
||
|
||
# ============ 详细系统监控 ============
|
||
@app.route('/api/system-info', methods=['GET'])
|
||
def system_info():
|
||
"""获取详细系统监控信息"""
|
||
import psutil
|
||
import os
|
||
try:
|
||
# CPU 信息
|
||
cpu_percent = psutil.cpu_percent(interval=None)
|
||
cpu_counts = psutil.cpu_count()
|
||
cpu_freq = psutil.cpu_freq()
|
||
|
||
# 内存信息
|
||
memory = psutil.virtual_memory()
|
||
|
||
# 磁盘信息
|
||
disk = psutil.disk_usage('/')
|
||
disk_io = psutil.disk_io_counters()
|
||
|
||
# 网络信息
|
||
net_io = psutil.net_io_counters()
|
||
|
||
# 系统启动时间
|
||
boot_time = psutil.boot_time()
|
||
uptime_seconds = time.time() - boot_time
|
||
|
||
# GPU 信息
|
||
gpu_list = []
|
||
try:
|
||
import pynvml
|
||
pynvml.nvmlInit()
|
||
gpu_count = pynvml.nvmlDeviceGetCount()
|
||
for i in range(gpu_count):
|
||
try:
|
||
handle = pynvml.nvmlDeviceGetHandleByIndex(i)
|
||
name = pynvml.nvmlDeviceGetName(handle)
|
||
|
||
# 获取显存信息
|
||
try:
|
||
mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
|
||
memory_used = mem_info.used
|
||
memory_total = mem_info.total
|
||
except:
|
||
memory_used = 0
|
||
memory_total = 0
|
||
|
||
# 获取利用率
|
||
try:
|
||
util = pynvml.nvmlDeviceGetUtilizationRates(handle)
|
||
gpu_util = util.gpu
|
||
mem_util = util.memory
|
||
except:
|
||
gpu_util = 0
|
||
mem_util = 0
|
||
|
||
# 获取温度 - pynvml 11.x API: 只接受handle参数
|
||
try:
|
||
temp = pynvml.nvmlDeviceGetTemperature(handle)
|
||
except:
|
||
temp = 0
|
||
|
||
# 获取功耗
|
||
try:
|
||
power = pynvml.nvmlDeviceGetPowerUsage(handle)
|
||
except:
|
||
power = 0
|
||
|
||
# 获取风扇转速 (百分比)
|
||
try:
|
||
fan_speed = pynvml.nvmlDeviceGetFanSpeed(handle)
|
||
except:
|
||
fan_speed = 0
|
||
|
||
# 获取显卡时钟频率 (MHz)
|
||
try:
|
||
clock = pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_SM)
|
||
except:
|
||
clock = 0
|
||
|
||
# 获取显存时钟频率 (MHz)
|
||
try:
|
||
mem_clock = pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_MEM)
|
||
except:
|
||
mem_clock = 0
|
||
|
||
# 获取驱动版本信息
|
||
try:
|
||
version = pynvml.nvmlSystemGetDriverVersion()
|
||
except:
|
||
version = ''
|
||
|
||
gpu_list.append({
|
||
'name': name.decode() if isinstance(name, bytes) else name,
|
||
'memory_used_gb': round(memory_used / (1024**3), 1),
|
||
'memory_total_gb': round(memory_total / (1024**3), 1),
|
||
'gpu_percent': gpu_util,
|
||
'memory_percent': mem_util,
|
||
'temperature': temp,
|
||
'power_w': round(power / 1000, 1) if power > 0 else 0,
|
||
'fan_speed': fan_speed,
|
||
'clock_mhz': clock,
|
||
'memory_clock_mhz': mem_clock,
|
||
'driver_version': version.decode() if isinstance(version, bytes) else version
|
||
})
|
||
except Exception as e:
|
||
logger.debug(f"获取GPU {i} 信息失败: {e}")
|
||
continue
|
||
pynvml.nvmlShutdown()
|
||
except Exception as e:
|
||
logger.warning(f"获取GPU信息失败: {e}")
|
||
gpu_list = []
|
||
|
||
return jsonify({
|
||
'code': 0,
|
||
'data': {
|
||
'cpu': {
|
||
'percent': cpu_percent,
|
||
'cores': cpu_counts,
|
||
'frequency_mhz': cpu_freq.current if cpu_freq else 0
|
||
},
|
||
'memory': {
|
||
'percent': memory.percent,
|
||
'used_gb': round(memory.used / (1024**3), 1),
|
||
'total_gb': round(memory.total / (1024**3), 1),
|
||
'available_gb': round(memory.available / (1024**3), 1),
|
||
'cached_gb': round(memory.cached / (1024**3), 1) if hasattr(memory, 'cached') else 0
|
||
},
|
||
'disk': {
|
||
'percent': disk.percent,
|
||
'used_gb': round(disk.used / (1024**3), 0),
|
||
'total_gb': round(disk.total / (1024**3), 0),
|
||
'read_mb': round(disk_io.read_bytes / (1024**2), 0),
|
||
'write_mb': round(disk_io.write_bytes / (1024**2), 0)
|
||
},
|
||
'network': {
|
||
'upload_mb': round(net_io.bytes_sent / (1024**2), 1),
|
||
'download_mb': round(net_io.bytes_recv / (1024**2), 1)
|
||
},
|
||
'system': {
|
||
'uptime_seconds': uptime_seconds,
|
||
'process_count': len(psutil.pids())
|
||
},
|
||
'gpu': gpu_list
|
||
}
|
||
})
|
||
except Exception as e:
|
||
logger.error(f"获取系统信息失败: {e}")
|
||
return jsonify({'code': 1, 'message': str(e)})
|
||
|
||
|
||
# ============ 通用 CRUD 操作 ============
|
||
def generic_get_all(table_name, order_by='create_time DESC'):
|
||
"""通用查询所有"""
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute(f"SELECT * FROM {table_name} ORDER BY {order_by}")
|
||
result = cursor.fetchall()
|
||
cursor.close()
|
||
conn.close()
|
||
return result
|
||
|
||
|
||
def generic_get_by_id(table_name, id_val):
|
||
"""通用按ID查询"""
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute(f"SELECT * FROM {table_name} WHERE id = %s", (id_val,))
|
||
result = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
return result
|
||
|
||
|
||
def generic_create(table_name, data):
|
||
"""通用创建"""
|
||
import json
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
# 处理JSON字段，将列表和字典转为JSON字符串
|
||
processed_values = []
|
||
for value in data.values():
|
||
if isinstance(value, (list, dict)):
|
||
processed_values.append(json.dumps(value, ensure_ascii=False))
|
||
else:
|
||
processed_values.append(value)
|
||
columns = ', '.join(data.keys())
|
||
placeholders = ', '.join(['%s'] * len(data))
|
||
sql = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
|
||
cursor.execute(sql, processed_values)
|
||
conn.commit()
|
||
new_id = cursor.lastrowid
|
||
cursor.close()
|
||
conn.close()
|
||
return new_id
|
||
|
||
|
||
def generic_update(table_name, id_val, data):
|
||
"""通用更新"""
|
||
import json
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
# 处理JSON字段，将列表和字典转为JSON字符串
|
||
processed_values = []
|
||
for value in data.values():
|
||
if isinstance(value, (list, dict)):
|
||
processed_values.append(json.dumps(value, ensure_ascii=False))
|
||
else:
|
||
processed_values.append(value)
|
||
set_clause = ', '.join([f"{k} = %s" for k in data.keys()])
|
||
sql = f"UPDATE {table_name} SET {set_clause} WHERE id = %s"
|
||
values = processed_values + [id_val]
|
||
cursor.execute(sql, values)
|
||
conn.commit()
|
||
cursor.close()
|
||
conn.close()
|
||
|
||
|
||
def generic_delete(table_name, id_val):
|
||
"""通用删除"""
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute(f"DELETE FROM {table_name} WHERE id = %s", (id_val,))
|
||
conn.commit()
|
||
cursor.close()
|
||
conn.close()
|
||
|
||
|
||
# ============ 登录接口 ============
|
||
@app.route('/api/login', methods=['POST'])
|
||
def login():
|
||
data = request.json
|
||
username = data.get('username')
|
||
password = data.get('password')
|
||
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT * FROM users WHERE username = %s AND password = %s", (username, password))
|
||
user = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
|
||
if user:
|
||
return jsonify({'code': 0, 'message': '登录成功', 'data': {'username': user['username'], 'role': user['role']}})
|
||
return jsonify({'code': 1, 'message': '用户名或密码错误'})
|
||
|
||
|
||
# ============ 精调训练接口 ============
|
||
@app.route('/api/fine-tune', methods=['GET'])
|
||
def get_fine_tune():
|
||
return jsonify({'code': 0, 'data': generic_get_all('fine_tune')})
|
||
|
||
|
||
@app.route('/api/fine-tune', methods=['POST'])
|
||
def create_fine_tune():
|
||
data = request.json
|
||
new_id = generic_create('fine_tune', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/fine-tune/<int:id>', methods=['PUT'])
|
||
def update_fine_tune(id):
|
||
data = request.json
|
||
generic_update('fine_tune', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/fine-tune/<int:id>', methods=['DELETE'])
|
||
def delete_fine_tune(id):
|
||
generic_delete('fine_tune', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 我的模型接口 ============
|
||
@app.route('/api/my-models', methods=['GET'])
|
||
def get_my_models():
|
||
return jsonify({'code': 0, 'data': generic_get_all('my_models')})
|
||
|
||
|
||
@app.route('/api/my-models', methods=['POST'])
|
||
def create_my_model():
|
||
data = request.json
|
||
new_id = generic_create('my_models', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/my-models/<int:id>', methods=['PUT'])
|
||
def update_my_model(id):
|
||
data = request.json
|
||
generic_update('my_models', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/my-models/<int:id>', methods=['DELETE'])
|
||
def delete_my_model(id):
|
||
generic_delete('my_models', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 模型评测接口 ============
|
||
@app.route('/api/model-eval', methods=['GET'])
|
||
def get_model_eval():
|
||
return jsonify({'code': 0, 'data': generic_get_all('model_eval')})
|
||
|
||
|
||
@app.route('/api/model-eval', methods=['POST'])
|
||
def create_model_eval():
|
||
data = request.json
|
||
|
||
# 获取模型名称和数据集名称
|
||
model_id = data.get('model_id')
|
||
dataset_id = data.get('dataset_id')
|
||
eval_dimension = data.get('eval_dimension', '')
|
||
|
||
# 获取模型名称
|
||
model_name = ''
|
||
if model_id:
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT name FROM model_manage WHERE id = %s", (model_id,))
|
||
model_result = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
if model_result:
|
||
model_name = model_result['name']
|
||
|
||
# 获取数据集名称
|
||
dataset_name = ''
|
||
if dataset_id:
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT name FROM dataset_manage WHERE id = %s", (dataset_id,))
|
||
dataset_result = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
if dataset_result:
|
||
dataset_name = dataset_result['name']
|
||
|
||
# 构建插入数据，映射到数据库字段
|
||
insert_data = {
|
||
'name': data.get('name', ''),
|
||
'model_name': model_name,
|
||
'dataset': dataset_name,
|
||
'metric': eval_dimension,
|
||
'status': 'pending'
|
||
}
|
||
|
||
new_id = generic_create('model_eval', insert_data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/model-eval/<int:id>', methods=['PUT'])
|
||
def update_model_eval(id):
|
||
data = request.json
|
||
|
||
# 构建更新数据，映射到数据库字段
|
||
update_data = {}
|
||
|
||
if 'name' in data:
|
||
update_data['name'] = data['name']
|
||
|
||
if 'model_id' in data:
|
||
model_id = data['model_id']
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT name FROM model_manage WHERE id = %s", (model_id,))
|
||
model_result = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
update_data['model_name'] = model_result['name'] if model_result else ''
|
||
|
||
if 'dataset_id' in data:
|
||
dataset_id = data['dataset_id']
|
||
conn = get_db_connection()
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT name FROM dataset_manage WHERE id = %s", (dataset_id,))
|
||
dataset_result = cursor.fetchone()
|
||
cursor.close()
|
||
conn.close()
|
||
update_data['dataset'] = dataset_result['name'] if dataset_result else ''
|
||
|
||
if 'eval_dimension' in data:
|
||
update_data['metric'] = data['eval_dimension']
|
||
|
||
if update_data:
|
||
generic_update('model_eval', id, update_data)
|
||
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/model-eval/<int:id>', methods=['DELETE'])
|
||
def delete_model_eval(id):
|
||
generic_delete('model_eval', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 模型部署接口 ============
|
||
@app.route('/api/model-deploy', methods=['GET'])
|
||
def get_model_deploy():
|
||
return jsonify({'code': 0, 'data': generic_get_all('model_deploy')})
|
||
|
||
|
||
@app.route('/api/model-deploy', methods=['POST'])
|
||
def create_model_deploy():
|
||
data = request.json
|
||
new_id = generic_create('model_deploy', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/model-deploy/<int:id>', methods=['PUT'])
|
||
def update_model_deploy(id):
|
||
data = request.json
|
||
generic_update('model_deploy', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/model-deploy/<int:id>', methods=['DELETE'])
|
||
def delete_model_deploy(id):
|
||
generic_delete('model_deploy', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 模型管理接口 ============
|
||
@app.route('/api/model-manage', methods=['GET'])
|
||
def get_model_manage():
|
||
return jsonify({'code': 0, 'data': generic_get_all('model_manage')})
|
||
|
||
|
||
@app.route('/api/model-manage', methods=['POST'])
|
||
def create_model_manage():
|
||
data = request.json
|
||
new_id = generic_create('model_manage', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/model-manage/<int:id>', methods=['PUT'])
|
||
def update_model_manage(id):
|
||
data = request.json
|
||
generic_update('model_manage', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/model-manage/<int:id>', methods=['DELETE'])
|
||
def delete_model_manage(id):
|
||
generic_delete('model_manage', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 模型对比接口 ============
|
||
@app.route('/api/model-compare', methods=['GET'])
|
||
def get_model_compare():
|
||
return jsonify({'code': 0, 'data': generic_get_all('model_compare')})
|
||
|
||
|
||
@app.route('/api/model-compare/<int:id>', methods=['GET'])
|
||
def get_model_compare_by_id(id):
|
||
"""获取单个模型对比任务"""
|
||
result = generic_get_by_id('model_compare', id)
|
||
if result:
|
||
return jsonify({'code': 0, 'data': result})
|
||
return jsonify({'code': 1, 'message': '任务不存在'})
|
||
|
||
|
||
@app.route('/api/model-compare', methods=['POST'])
|
||
def create_model_compare():
|
||
data = request.json
|
||
new_id = generic_create('model_compare', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/model-compare/<int:id>', methods=['PUT'])
|
||
def update_model_compare(id):
|
||
data = request.json
|
||
generic_update('model_compare', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/model-compare/<int:id>', methods=['DELETE'])
|
||
def delete_model_compare(id):
|
||
generic_delete('model_compare', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 数据生成接口 ============
|
||
@app.route('/api/data-generate', methods=['GET'])
|
||
def get_data_generate():
|
||
return jsonify({'code': 0, 'data': generic_get_all('data_generate')})
|
||
|
||
|
||
@app.route('/api/data-generate', methods=['POST'])
|
||
def create_data_generate():
|
||
data = request.json
|
||
new_id = generic_create('data_generate', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/data-generate/<int:id>', methods=['PUT'])
|
||
def update_data_generate(id):
|
||
data = request.json
|
||
generic_update('data_generate', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/data-generate/<int:id>', methods=['DELETE'])
|
||
def delete_data_generate(id):
|
||
generic_delete('data_generate', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 权限管理接口 ============
|
||
@app.route('/api/permission', methods=['GET'])
|
||
def get_permission():
|
||
return jsonify({'code': 0, 'data': generic_get_all('permission')})
|
||
|
||
|
||
@app.route('/api/permission', methods=['POST'])
|
||
def create_permission():
|
||
data = request.json
|
||
new_id = generic_create('permission', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/permission/<int:id>', methods=['PUT'])
|
||
def update_permission(id):
|
||
data = request.json
|
||
generic_update('permission', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/permission/<int:id>', methods=['DELETE'])
|
||
def delete_permission(id):
|
||
generic_delete('permission', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
# ============ 系统配置接口 ============
|
||
@app.route('/api/sys-config', methods=['GET'])
|
||
def get_sys_config():
|
||
return jsonify({'code': 0, 'data': generic_get_all('sys_config')})
|
||
|
||
|
||
@app.route('/api/sys-config', methods=['POST'])
|
||
def create_sys_config():
|
||
data = request.json
|
||
new_id = generic_create('sys_config', data)
|
||
return jsonify({'code': 0, 'message': '创建成功', 'id': new_id})
|
||
|
||
|
||
@app.route('/api/sys-config/<int:id>', methods=['PUT'])
|
||
def update_sys_config(id):
|
||
data = request.json
|
||
generic_update('sys_config', id, data)
|
||
return jsonify({'code': 0, 'message': '更新成功'})
|
||
|
||
|
||
@app.route('/api/sys-config/<int:id>', methods=['DELETE'])
|
||
def delete_sys_config(id):
|
||
generic_delete('sys_config', id)
|
||
return jsonify({'code': 0, 'message': '删除成功'})
|
||
|
||
|
||
if __name__ == '__main__':
|
||
# 启动前先初始化数据库
|
||
init_database()
|
||
app_config = CONFIG['app']
|
||
host = app_config['host']
|
||
port = app_config['port']
|
||
debug = app_config.get('debug', True)
|
||
logger.info(f'服务启动于 http://{host}:{port}')
|
||
logger.info(f'Debug模式: {debug}')
|
||
app.run(host=host, port=port, debug=debug)
|