TOOL_INSTRUCTION = """
## Tool calling rules

When you need to call a tool, you MUST use the following format.

<tool_call>
{
  "name": "tool_name",
  "arguments": { JSON }
}

Rules:
- Output ONLY the <tool_call> block
- Do NOT explain anything
- Do NOT use markdown
- Do NOT add extra text
- Do NOT wrap in code blocks
- arguments MUST be valid JSON object
- If multiple tools are needed, output multiple <tool_call> blocks sequentially
- If no tool is needed, answer normally

Example:

User: read file
Assistant:
<tool_call>
{
  "name": "read",
  "arguments": {
    "path": "/home/test.txt"
  }
}

For multiple tool calls, you may also output:

<tool_call>
[
  {
    "name": "tool1",
    "arguments": {...}
  },
  {
    "name": "tool2",
    "arguments": {...}
  }
]

"""

def build_prompt_from_messages(messages, tools=None, create_new=False):
    parts = []

    # ---------- messages ----------
    for m in messages:
        role = m.get("role")
        content = m.get("content")

        if create_new and role == "system" and not HIAGENT_HAS_OPENCLAW_PROMPT and content:
            # if HIAGENT_HAS_OPENCLAW_PROMPT and content.startswith("You are a personal assistant running inside OpenClaw."):
            #     continue
            parts.append(f"[system]\n{content}")
            parts.append(f"\n{TOOL_INSTRUCTION.strip()}")

            # ---------- tools schema ----------
            if tools:
                tool_desc = ["Available tools:\n"]

                for t in tools:
                    func = t.get("function", {})
                    name = func.get("name")
                    desc = func.get("description", "")
                    params = func.get("parameters", {})

                    tool_desc.append(f"Tool: {name}")
                    if desc:
                        tool_desc.append(f"Description: {desc}")

                    if params:
                        tool_desc.append("Parameters JSON schema:")
                        tool_desc.append(json.dumps(params, indent=2, ensure_ascii=False))

                    tool_desc.append("")

                parts.append("\n".join(tool_desc))

        elif role == "user" and content:
            parts.append(f"[user]\n{content}")

        elif role == "assistant":
            tool_calls = m.get("tool_calls")

            if tool_calls:
                # {"role": "assistant", "content": null, "tool_calls": [{"id": "call08690af73f584d3386d63b10509f55d9", "type": "function", "function": {"name": "read", "arguments": "{\"path\":\"/home/devuser/.openclaw/workspace/SOUL.md\"}"}}, {"id": "call937287b1a26e4c83aed8a9fdd261ec3c", "type": "function", "function": {"name": "read", "arguments": "{\"path\":\"/home/devuser/.openclaw/workspace/USER.md\"}"}}]}
                parts.append("[assistant]\n" + json.dumps(tool_calls, ensure_ascii=False))
            elif content:
                # {"role": "assistant", "content": [{"type": "text", "text": "Hey. I'm back online. \n\nI see we're still getting to know each other — your profile's pretty blank. What's on your mind? "}]}
                parts.append(f"[assistant]\n{content}")

        elif role == "tool":
            #  {"role": "tool", "content": "Successfully wrote 269 bytes to /home/xxx", "tool_call_id": "call76e5d5301407447f833d9b71b973ecc7"}
            call_id = m.get("tool_call_id", "")
            parts.append(f"[tool:{call_id}]\n{content}")

    # parts.append("[assistant]")

    return "\n\n".join(parts)

def parse_hiagent_tool_calls(text: str):
    tool_calls = []

    # ---------- <tool_call> ----------
    idx = 0
    while True:
        start = text.find("<tool_call>", idx)
        if start == -1:
            break

        cursor = start + len("<tool_call>")

        # 跳过空白
        while cursor < len(text) and text[cursor].isspace():
            cursor += 1

        if cursor >= len(text):
            break

        # ---------- 情况 A: 直接 JSON 对象 ----------
        if text[cursor] in "{[":
            json_str, end = _extract_balanced_json(text, cursor)
            if json_str:
                try:
                    data = json.loads(json_str)

                    # 如果是数组
                    if isinstance(data, list):
                        for item in data:
                            func = item.get("function", item)
                            tool_calls.append(
                                HiAgentToolCall(
                                    id=item.get("id") or f"call_{uuid.uuid4().hex}",
                                    name=func.get("name"),
                                    arguments=normalize_arguments(
                                        func.get("arguments", {})
                                    ),
                                )
                            )
                    else:
                        tool_calls.append(
                            HiAgentToolCall(
                                id=data.get("id") or f"call_{uuid.uuid4().hex}",
                                name=data.get("name"),
                                arguments=normalize_arguments(
                                    data.get("arguments", {})
                                ),
                            )
                        )

                    idx = end
                    continue
                except Exception:
                    pass

        # ---------- 情况 B: name{...} ----------
        name_match = re.match(r"([a-zA-Z_][a-zA-Z0-9_]*)", text[cursor:])
        if name_match:
            name = name_match.group(1)
            cursor += len(name)

            while cursor < len(text) and text[cursor].isspace():
                cursor += 1

            if cursor < len(text) and text[cursor] == "{":
                json_str, end = _extract_balanced_json(text, cursor)
                if json_str:
                    try:
                        args = json.loads(json_str)
                        tool_calls.append(
                            HiAgentToolCall(
                                id=f"call_{uuid.uuid4().hex}",
                                name=name,
                                arguments=args,
                            )
                        )
                        idx = end
                        continue
                    except Exception:
                        pass

        idx = cursor + 1

    if tool_calls:
        return tool_calls, None

    return None, text

from fastapi.responses import StreamingResponse


def sse_pack(data):
    return f"data: {json.dumps(data, ensure_ascii=False)}\n\n"


def build_stream_text_chunks(text, model="custom-model", chunk_size=10):
    for i in range(0, len(text), chunk_size):
        chunk = text[i:i+chunk_size]
        yield sse_pack({
            "id": f"chatcmpl-{uuid.uuid4()}",
            "object": "chat.completion.chunk",
            "created": int(time.time()),
            "model": model,
            "choices": [{
                "index": 0,
                "delta": {"content": chunk},
                "finish_reason": None
            }]
        })


def build_stream_tool_calls(tool_calls, model="custom-model"):

    yield sse_pack({
        "id": f"chatcmpl-{uuid.uuid4()}",
        "object": "chat.completion.chunk",
        "created": int(time.time()),
        "model": model,
        "choices": [
            {
                "index": 0,
                "delta": {
                    "tool_calls": [
                        tc.to_openai_tool_call() for tc in tool_calls
                    ]
                },
                "finish_reason": "tool_calls"
            }
        ]
    })


def stream_done():
    return "data: [DONE]\n\n"


def build_openai_stream_response(content, tool_calls=None):
    async def generator():

        # role chunk (recommended)
        yield sse_pack({
            "choices": [{
                "delta": {"role": "assistant"},
                "index": 0
            }]
        })

        # 1. content 文本
        if content:
            for chunk in build_stream_text_chunks(content):
                yield chunk

        # 2. tool calls
        if tool_calls:
            for chunk in build_stream_tool_calls(tool_calls):
                yield chunk

        # finish
        yield sse_pack({
            "choices": [{
                "delta": {},
                "finish_reason": "stop",
                "index": 0
            }]
        })

        yield stream_done()

    return StreamingResponse(
        generator(),
        media_type="text/event-stream"
    )

def compute_conversation_key(messages, max_assistant_turns=1):
    if not messages:
        return None
    
    if count_assistant_turns(messages) < max_assistant_turns:
        # 如果 assistant 轮数还不够，就不计算 key，强制新建会话
        return None

    text_list = []
    assistant_turns = 0

    for m in messages:
        role = m.get("role")
        if role == "system":
            continue
        content = m.get("content")
        text = ""
        if content:
            if isinstance(content, str):
                text = content
            elif isinstance(content, list):
                text = json.dumps(content, ensure_ascii=False)
            else:
                text = str(content)
        text_list.append(f"[{role}]\n{text}")

        if role == "assistant":
            assistant_turns += 1
            if assistant_turns >= max_assistant_turns:
                break

    key_material = "\n\n".join(text_list)
    h = hashlib.sha256(key_material.encode("utf-8")).hexdigest()
    return h

@app.post("/v1/chat/completions")
async def chat(body: dict):

    stream = body.get("stream", False)
    messages = body.get("messages") or []
    tools = body.get("tools")

    # 计算会话 key（忽略 system）
    conv_key = compute_conversation_key(messages)
    conversation_id = None
    if conv_key:
        obj = get_conversation_by_key(conv_key)
        if obj:
            conversation_id = obj["app_conversation_id"]
            idx = find_last_assistant_index(messages)
            prompt = build_prompt_from_messages(messages[idx+1:], tools=tools, create_new=False)
    if not conversation_id:
        conversation_id = create_conversation()
        prompt = build_prompt_from_messages(messages, tools=tools, create_new=True)

    regenerate_conversation = False
    content = None
    tool_calls = None
    token_usage = None

    try:
        content, tool_calls, token_usage = chat_query(conversation_id, prompt)
    except Exception as e:
        print("Error during chat query:", str(e))
        # 400
        if "Conversation expired or invalid" in str(e):
            if conv_key:
                delete_conversation(conv_key)
            conversation_id = create_conversation()
            prompt = build_prompt_from_messages(messages, tools=tools, create_new=True)
            regenerate_conversation = True

            # 重新用完整消息构建 prompt，会导致一大段文本塞到同一次会话里，极有可能消耗大量上下文，但目前没有更好的选择了
            try:
                content, tool_calls, token_usage = chat_query(conversation_id, prompt)
            except Exception as e:
                print("Error during chat query for new conversation:", str(e))
                return build_openai_response("hiagent 请求失败: " + str(e), stream=stream)
        else:
            return build_openai_response("hiagent 请求失败: " + str(e), stream=stream)

    openclaw_message = build_openclaw_assistant_format(content, tool_calls)
    messages.append(openclaw_message)
    assistant_turns = count_assistant_turns(messages)

    if not conv_key:
        new_conv_key = compute_conversation_key(messages)
        if new_conv_key:
            save_conversation(new_conv_key, conversation_id, int(time.time()), turn_count=assistant_turns)
    elif not regenerate_conversation:
        update_turn_count(conv_key, assistant_turns)
    else:
        save_conversation(conv_key, conversation_id, int(time.time()), turn_count=assistant_turns)

    resp = build_openai_response(content, tool_calls=tool_calls, stream=stream, token_usage=token_usage)

    return resp

@app.post("/v1/chat/completions")
async def chat(body: dict):

    user_id = "default_user"
    stream = body.get("stream", False)
    messages = body.get("messages") or []
    tools = body.get("tools")

    # 构造完整历史 prompt
    prompt = build_prompt_from_messages(messages, tools=tools)

    try:
        # 每次创建新的 hiagent 会话（不复用）
        conversation_id = create_conversation(user_id)
        answer = chat_query(user_id, conversation_id, prompt)

    except Exception as e:
        print("Error during chat query:", str(e))
        if stream:
            return build_openai_stream_response("hiagent 请求失败: " + str(e))
        else:
            return build_openai_response_text("hiagent 请求失败: " + str(e))
    
    # 解析 tool call
    tool_calls, prefix_text = parse_hiagent_tool_calls(answer)

    # ---------- STREAM ----------
    if stream:
        # return build_openai_stream_response(answer, tool_calls=tool_calls, prefix_text=prefix_text)
        return build_openai_stream_response(answer, tool_calls=tool_calls, prefix_text=None)

    # ---------- NON STREAM ----------

    if tool_calls:
        resp = build_openai_response_tool_calls(tool_calls, content=prefix_text)

    else:
        resp = build_openai_response_text(answer)

    return resp

import os
import sys

if sys.platform == "win32":
    os.system('')

import subprocess
import json
import csv
from pathlib import Path
from collections import Counter

ROOT_DIR = "/path/to/rust/projects"

output_name = ROOT_DIR.split("/")[-1].replace("dataset-", "")

OUTPUT_CSV = f"clippy-output/{output_name}_clippy.csv"


def find_rust_projects(root):
    """查找 Rust 项目目录，兼容 translation_raw 结构"""
    projects = set()

    root = Path(root)

    # 原有逻辑：查找 Cargo.toml
    for path in root.rglob("Cargo.toml"):
        projects.add(path.parent)

    # 新增逻辑：查找 translation_raw / translation_raw_WIP
    for dir_path in root.rglob("*"):
        if not dir_path.is_dir():
            continue

        cargo = dir_path / "Cargo.toml"
        if cargo.exists():
            continue

        translation_raw = dir_path / "translation_raw"
        translation_raw_wip = dir_path / "translation_raw_WIP"

        if translation_raw.exists() and translation_raw.is_dir():
            projects.add(translation_raw)

        if translation_raw_wip.exists() and translation_raw_wip.is_dir():
            projects.add(translation_raw_wip)

    return sorted(projects)


def run_clippy(project_path):
    """运行 clippy 并统计 lint"""
    cmd = [
        "cargo",
        "clippy",
        "--message-format=json",
        "--all-targets",
        "--all-features"
    ]

    process = subprocess.Popen(
        cmd,
        cwd=project_path,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )

    lint_counter = Counter()
    level_counter = Counter()

    for line in process.stdout:
        try:
            msg = json.loads(line)
        except json.JSONDecodeError:
            continue

        if msg.get("reason") != "compiler-message":
            continue

        message = msg.get("message", {})
        code = message.get("code")
        level = message.get("level")

        if not code:
            continue

        lint_name = code.get("code")
        if not lint_name:
            continue

        # 只统计 clippy
        if not lint_name.startswith("clippy::"):
            continue

        lint_counter[lint_name] += 1
        level_counter[level] += 1

    process.wait()

    return lint_counter, level_counter


def main():
    projects = find_rust_projects(ROOT_DIR)

    print(f"Found {len(projects)} Rust projects")

    rows = []

    for project in projects:
        print(f"Running clippy: {project}")

        lint_counter, level_counter = run_clippy(project)

        # 保留最后一段路径
        project_path = str(project)
        project_name = project_path.split("/")[-1]
        if project_name == "translation_raw" or project_name == "translation_raw_WIP":
            suffix = "_raw" if project_name == "translation_raw" else "_opt"
            project_name = project_path.split("/")[-2] + suffix


        row = {
            "project": project_name,
            "warnings": level_counter.get("warning", 0),
            "errors": level_counter.get("error", 0),
            "total": sum(level_counter.values())
        }

        # 可选：加入常见 lint
        for lint, count in lint_counter.items():
            row[lint] = count

        rows.append(row)

    # 收集所有列名
    fieldnames = set()
    for r in rows:
        fieldnames.update(r.keys())

    fieldnames = sorted(fieldnames)
    # 把 project, warnings, errors, total 放在前面
    fieldnames = ["project", "warnings", "errors", "total"] + [f for f in fieldnames if f not in {"project", "warnings", "errors", "total"}]

    # 写入 CSV
    with open(OUTPUT_CSV, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)

    print(f"Saved to {OUTPUT_CSV}")


if __name__ == "__main__":
    main()

import os
import re
import argparse
from collections import defaultdict


def clean_title(title: str) -> str:
    """去除markdown格式并清理非法文件名字符"""
    # 去掉markdown格式
    title = re.sub(r"[*_`~]", "", title)

    # 去掉链接
    title = re.sub(r"\[(.*?)\]\(.*?\)", r"\1", title)

    # 去掉图片
    title = re.sub(r"!\[(.*?)\]\(.*?\)", r"\1", title)

    # 清理非法字符
    title = re.sub(r'[\\/:"*?<>|]+', "", title)

    return title.strip()


def parse_markdown(file_path):
    """解析markdown标题结构"""
    with open(file_path, "r", encoding="utf-8") as f:
        lines = f.readlines()

    headers = []

    for i, line in enumerate(lines):
        m = re.match(r'^(#+)\s+(.*)', line)
        if m:
            level = len(m.group(1))
            title = m.group(2).strip()
            headers.append({
                "level": level,
                "title": title,
                "line": i
            })

    return lines, headers


def find_base_level(headers):
    """找到文档中最高级标题"""
    return min(h["level"] for h in headers)


def ensure_unique(name, counter):
    """同级重名处理"""
    if counter[name] == 0:
        counter[name] += 1
        return name
    else:
        new_name = f"{name}({counter[name]})"
        counter[name] += 1
        return new_name


def split_markdown(lines, headers, base_level, max_level, min_level):
    """根据标题切片"""
    sections = []

    for i, h in enumerate(headers):

        rel_level = h["level"] - base_level + 1

        if rel_level < max_level or rel_level > min_level:
            continue

        start = h["line"]
        end = len(lines)

        for j in range(i + 1, len(headers)):
            if headers[j]["level"] <= h["level"]:
                end = headers[j]["line"]
                break

        sections.append({
            "title": h["title"],
            "level": rel_level,
            "content": "".join(lines[start:end])
        })

    return sections


def write_file_mode(sections, output_dir):
    os.makedirs(output_dir, exist_ok=True)

    counter = defaultdict(int)

    for s in sections:
        name = clean_title(s["title"])
        name = ensure_unique(name, counter)

        path = os.path.join(output_dir, f"{name}.md")

        with open(path, "w", encoding="utf-8") as f:
            f.write(s["content"])


def write_tree_mode(sections, output_dir, max_level):
    stack = []
    counters = defaultdict(lambda: defaultdict(int))

    for s in sections:

        level = s["level"]

        while len(stack) >= level:
            stack.pop()

        title = clean_title(s["title"])

        parent_key = "/".join(stack)

        title = ensure_unique(title, counters[parent_key])

        stack.append(title)

        if level == max_level:
            dir_path = os.path.join(output_dir, *stack)
            os.makedirs(dir_path, exist_ok=True)

        else:
            dir_path = os.path.join(output_dir, *stack[:-1])
            os.makedirs(dir_path, exist_ok=True)

            path = os.path.join(dir_path, f"{title}.md")

            with open(path, "w", encoding="utf-8") as f:
                f.write(s["content"])


def main():
    parser = argparse.ArgumentParser()

    parser.add_argument("input_file")
    parser.add_argument("--output", default="output")
    parser.add_argument("--mode", choices=["file", "tree"], default="file")
    parser.add_argument("--max_level", type=int, default=1)
    parser.add_argument("--min_level", type=int)

    args = parser.parse_args()

    lines, headers = parse_markdown(args.input_file)

    if not headers:
        print("No headers found.")
        return

    base_level = find_base_level(headers)

    if args.mode == "file":
        min_level = args.max_level
    else:
        if args.min_level:
            min_level = args.min_level
        else:
            min_level = max(h["level"] - base_level + 1 for h in headers)

    sections = split_markdown(
        lines,
        headers,
        base_level,
        args.max_level,
        min_level
    )

    if args.mode == "file":
        write_file_mode(sections, args.output)
    else:
        write_tree_mode(sections, args.output, args.max_level)


if __name__ == "__main__":
    main()

def tmux_capture():
    result = subprocess.run(
        ["tmux", "capture-pane","-S", "-32767", "-t", TMUX_SESSION, "-p"], capture_output=True,
        text=True
    )
    return result.stdout

def wait_for_server_code():
    while True:
        output = tmux_capture()
        server_code = extract_server_code(output)
        ...
        time.sleep(1)

def start_waiting_thread():
    if waiting_thread is None or not waiting_thread.is_alive():
        ...

server_status = {
    "server_code": None,
    "active_save": None
}

STATUS_FILE = "data/server-status.txt"

# 当解析到 Server Code 后：
save_status_to_file(server_code, active_save)

# Flask 启动时：
if tmux_session_exists():
    load_status_from_file()

def _read_log_pipe_thread():
    """读取日志管道内容并写入日志文件"""
    if not os.path.exists(LOG_FILE):
        open(LOG_FILE, "w").close()

    with open(LOG_FILE, "r") as log_file:
        while True:
            if stop_reading_flag:
                break
            line = log_file.readline()
            if not line:
                socketio.sleep(0.1)
            else:
                load_status_from_string([line])
                socketio.emit("log_append", {
                    "line": line
                })

def tmux_session_exists():
    result = subprocess.run(
        ["tmux", "has-session", "-t", TMUX_SESSION],
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL
    )
    return result.returncode == 0

    cmd = RUN_SCRIPT + f" active_save={active_save}"
    if update:
        cmd += " update=1"

    result = subprocess.run(
        ["tmux", "new-session", "-s", TMUX_SESSION, "-d", cmd]
    )

def tmux_send(cmd):
    subprocess.run(
        ["tmux", "send-keys", "-t", TMUX_SESSION, cmd, "Enter"],
        check=False
    )

# 退出
send_tmux_command("shutdown") 

@api.route("/upload-save", methods=["POST"])
def upload_save():
    if "file" not in request.files:
        return jsonify({"error": "No file"}), 400

    file = request.files["file"]
    if not file.filename.endswith(".zip"):
        return jsonify({"error": "Only zip allowed"}), 400
    
    file.seek(0, os.SEEK_END)
    size = file.tell()
    if size > 4 * 1024 * 1024:
        return jsonify({"error": "File too large"}), 400
    file.seek(0)

    with tempfile.TemporaryDirectory() as tmpdir:
        zip_path = os.path.join(tmpdir, "upload.zip")
        file.save(zip_path)

        with zipfile.ZipFile(zip_path) as z:
            z.extractall(tmpdir)

        entries = os.listdir(tmpdir)
        entries.remove("upload.zip")

        # 确保 zip 中只有一个根目录
        if len(entries) != 1:
            return jsonify({"error": "Zip must contain exactly one root directory"}), 400

        root_dir_name = entries[0]
        extracted_dir = os.path.join(tmpdir, root_dir_name)

        # 处理 zip 名称与文件夹名不同的情况
        if root_dir_name != file.filename[:-4]:
            shutil.move(extracted_dir, os.path.join(tmpdir, file.filename[:-4]))
            extracted_dir = os.path.join(tmpdir, file.filename[:-4])

        # 确保文件夹中有 Config.txt
        if not os.path.exists(os.path.join(extracted_dir, "Config.txt")):
            return jsonify({"error": "Missing Config.txt in root directory"}), 400

        save_name = file.filename[:-4]  # 不带扩展名的文件名
        dst = os.path.join(SAVES_DIR, save_name)

        if os.path.exists(dst):
            return jsonify({"error": "Save already exists"}), 400

        # 保存文件
        shutil.move(extracted_dir, dst)

    return jsonify({
        "message": f"Save {save_name} uploaded successfully",
        "save_name": save_name
    })

@api.route("/download-backup", methods=["GET"])
def download_backup():
    save_name = request.args.get("save_name")
    backup_name = request.args.get("backup_name")
    if not save_name or not backup_name:
        return jsonify({"error": "Save name and backup name are required"}), 400

    backup_path = os.path.join(SAVES_DIR, save_name, "Backup", backup_name)
    if not os.path.exists(backup_path):
        return jsonify({"error": "Backup not found"}), 400

    # 创建临时zip文件
    temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
    with zipfile.ZipFile(temp_zip.name, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for root, dirs, files in os.walk(backup_path):
            for file in files:
                file_path = os.path.join(root, file)
                arcname = os.path.relpath(file_path, backup_path)
                zipf.write(file_path, arcname)

    temp_zip.close()

    def generate():
        with open(temp_zip.name, 'rb') as f:
            while True:
                data = f.read(4096)
                if not data:
                    break
                yield data
        os.remove(temp_zip.name)

    response = app.response_class(generate(), mimetype='application/zip')
    response.headers.set('Content-Disposition', 'attachment', filename=f"{backup_name}.zip")
    return response

exclude_dirs = {"Workshop", "Backup"}

def backup_save():
    save_name = server_status["active_save"]
    if not save_name:
        return
    
    print(f"Backing up {save_name}...")
    
    # 游戏目录
    source_dir = os.path.join(SAVES_DIR, save_name)
    timestamp = time.strftime("%Y-%m-%d_%H-%M-%S", time.localtime())
    
    # 创建备份目录
    backup_dest = os.path.join(SAVES_DIR, save_name, "Backup", timestamp)
    os.makedirs(backup_dest, exist_ok=True)
    
    # 执行备份
    exclude_dirs = {"Workshop", "Backup"}
    copytree_with_exclusions(source_dir, backup_dest, exclude_dirs)
    
    # 删除超过最大数量的备份
    clean_old_backups(save_name)

from apscheduler.schedulers.background import BackgroundScheduler

backup_scheduler = BackgroundScheduler()
backup_scheduler.add_job(backup_save_scheduler, 'interval', minutes=BACKUP_INTERVAL_MINUTES)
# 如果服务器正在运行，则启动自动备份
backup_scheduler.start()