diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 000000000..06ff939f8 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,8 @@ +.venv/ +.git/ +.github/ +__pycache__/ +*.pyc +docs/ +tests/ +*.log diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index e7238872e..247ec2918 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,46 +1,43 @@ -name: CI +name: Windows package on: push: - - # Allows you to run this workflow manually from the Actions tab + pull_request: workflow_dispatch: jobs: build: - runs-on: ${{ matrix.os }} - strategy: - matrix: - include: - - os: windows-latest - architecture: 'x64' - name: 'win64' - + runs-on: windows-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Set up Python - uses: actions/setup-python@v3 + uses: actions/setup-python@v5 with: python-version: '3.13' - architecture: ${{matrix.architecture}} - name: Install requirements run: | pip install -r requirements.txt pip install pyinstaller - - name: Build win bin - run: pyinstaller -F main.py -n 'chaoxing' --add-data "resource;resource" --hidden-import=chardet + - name: Build binaries + run: | + pyinstaller -F main.py -n chaoxing --add-data "resource;resource" --hidden-import=chardet + pyinstaller -F setup_wizard.py -n chaoxing-setup --add-data "resource;resource" --add-data "config_template.ini;." --hidden-import main + + - name: Smoke test executable + run: ./dist/chaoxing.exe --help - name: Create release package run: | mkdir release copy dist\chaoxing.exe release\ + copy dist\chaoxing-setup.exe release\ copy config_template.ini release\ cd release - 7z a -tzip chaoxing.zip * + 7z a -tzip chaoxing-win64.zip * - uses: actions/upload-artifact@v4 with: - name: ${{ matrix.name }} - path: 'release/chaoxing.zip' + name: win64 + path: release/chaoxing-win64.zip diff --git a/.github/workflows/package.yml b/.github/workflows/package.yml new file mode 100644 index 000000000..e1aaf8e2d --- /dev/null +++ b/.github/workflows/package.yml @@ -0,0 +1,20 @@ +name: Installed wheel +on: [push, pull_request, workflow_dispatch] +permissions: + contents: read +jobs: + installed-wheel: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.13' + - run: pip install build + - run: python -m build + - run: pip install dist/*.whl + - name: Run installed package outside checkout + working-directory: /tmp + run: | + chaoxing --help + python -c "from api.cxsecret_font import FontHashDAO; FontHashDAO()" diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 000000000..3f53197ca --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,30 @@ +name: tests + +on: + push: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: tests-${{ github.ref }} + cancel-in-progress: true + +jobs: + unit-tests: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.13' + - name: Install dependencies + run: pip install -r requirements.txt + - name: Public contribution guard + run: python tools/audit/publication_guard.py + - name: Compile check + run: python -m compileall -q api main.py setup_wizard.py tools tests + - name: Unit tests (offline) + run: python -m unittest discover -s tests -t . diff --git a/.gitignore b/.gitignore index f7fa27481..e05d7a304 100644 --- a/.gitignore +++ b/.gitignore @@ -146,6 +146,8 @@ cookies.txt .config.ini config.ini chaoxing.log +# 多用户模式保存的账号(含明文密码,绝不能提交) +accounts/ config*.ini .chaoxing.log ./config.ini @@ -154,6 +156,27 @@ config*.ini .idea/ .vscode/ cache.json + +# 探针本机配置(含真实账号/课程参数,绝不入库) +tools/probe/local.env + +# 抓包文件:*.har 一律不入库;capture_*.txt 脱敏后可以入库(提交前必须自查) +docs/artifacts/*.har start*.bat .workbuddy/ myConfig/ + +# Private development material must never be published. +AGENTS.md +CLAUDE.md +docs/handoff/ +docs/artifacts/ +private/ +*.har +*capture*.txt +SESSION-LOG* +TASKS.yaml +HANDOFF* +AUDIT-REPORT* +.env.* +!.env.example diff --git a/Dockerfile b/Dockerfile index 0b14b5fd2..adadd2b4d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -2,16 +2,17 @@ FROM python:3.13-slim WORKDIR /app -COPY . /app +# 依赖单独一层,改代码不用重装依赖 +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple -RUN pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple +COPY api ./api +COPY resource ./resource +COPY tools ./tools +COPY main.py setup_wizard.py config_template.ini Makefile ./ -# 创建配置文件目录并提供默认配置 -RUN mkdir -p /config && \ - cp config_template.ini /config/config.ini +# 账号 / 配置 / cookie / 日志都落在 /root/.chaoxing,挂载出来才能持久化 +VOLUME ["/root/.chaoxing"] -# 定义卷,用户可以挂载自己的配置文件 -VOLUME /config - -# 使用配置文件启动应用 -ENTRYPOINT ["python3", "main.py", "-c", "/config/config.ini"] +# 默认进入交互式向导(docker run -it);也可以覆盖命令跑 main.py +ENTRYPOINT ["python3", "setup_wizard.py"] diff --git a/Makefile b/Makefile new file mode 100644 index 000000000..f2fa70ec4 --- /dev/null +++ b/Makefile @@ -0,0 +1,39 @@ +# 常用命令:给人和 Agent 共用 +PY ?= python3 +.PHONY: help test lint compile publication doctor + +help: ## 列出所有命令 + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN{FS=":.*?## "}{printf " \033[36m%-12s\033[0m %s\n", $$1, $$2}' + +# 本地默认解释器可能比 CI 新(如 3.14):注解求值时机不同, +# 提交前用 CI 同版本再跑一遍,避免"本地绿、CI 红"。 +# make test-313 # 系统 python3.13(没装依赖就跳过) +# make test-313 PY313=/tmp/cx313/bin/python # 自己建好的 3.13 venv +PY313 ?= python3.13 + +test-313: + @if ! command -v $(PY313) >/dev/null 2>&1 && [ ! -x "$(PY313)" ]; then \ + echo "没有 $(PY313),跳过(CI 会跑)"; \ + elif ! $(PY313) -c "import loguru, openai, bs4, lxml, requests, httpx, tqdm, tenacity" 2>/dev/null; then \ + echo "$(PY313) 缺依赖,跳过(CI 会跑)。本地对齐:python3.13 -m venv /tmp/cx313 && /tmp/cx313/bin/pip install -r requirements.txt"; \ + else \ + $(PY313) -m compileall -q api main.py setup_wizard.py tools tests && \ + $(PY313) -m unittest discover -s tests -t .; \ + fi + +test: ## 跑全量单测(离线) + $(PY) -m unittest discover -s tests -t . + +compile: ## 语法编译检查 + $(PY) -m compileall -q api main.py tools tests + +publication: + $(PY) tools/audit/publication_guard.py + +lint: publication compile test ## 提交前必跑:编译 + 单测 + +doctor: ## 环境自检 + @echo "python : $$($(PY) -V)" + @echo "venv : $$(test -x $(PY) && echo ok || echo missing)" + @echo "data : $$(test -d $$HOME/.chaoxing && echo $$HOME/.chaoxing || echo 'missing (~/.chaoxing)')" + @$(PY) -c "import requests, bs4, loguru, tqdm; print('deps : ok')" diff --git a/README.md b/README.md index f02e3a036..fe0428eaa 100644 --- a/README.md +++ b/README.md @@ -156,3 +156,49 @@ python main.py -a ask # 使用询问模式 - 本代码遵循 [GPL-3.0 License](https://github.com/Samueli924/chaoxing/blob/main/LICENSE) 协议,允许**开源/免费使用和引用/修改/衍生代码的开源/免费使用**,不允许**修改和衍生的代码作为闭源的商业软件发布和销售**,禁止**使用本代码盈利**,以此代码为基础的程序**必须**同样遵守 [GPL-3.0 License](https://github.com/Samueli924/chaoxing/blob/main/LICENSE) 协议 - 本代码仅用于**学习讨论**,禁止**用于盈利** - 他人或组织使用本代码进行的任何**违法行为**与本人无关 + +## 任务中心与交互式入口 + +新增任务中心教学任务:视频、文档阅读、章节同步、作业、主题讨论和 AI 实践。 +任务按分组顺序解锁,完成状态以平台复查为准;失败不会影响章节任务。 +思考题暂不支持,文档时长是否有效取决于平台返回的状态。 +真实观看时长、请求间隔和顺序解锁不能通过配置绕过。 + +```sh +python setup_wizard.py +./cx +./cx discuss +./cx review +``` + +向导支持选择账号、课程和任务范围。讨论区挑帖必须逐条预览和确认, +`--yes` 不绕过这一确认。任务讨论遵循 `task_center_submit_mode`: +`confirm` 逐项确认;`auto` 在检查与留痕后发送。 + +账号配置、密码、Cookie、缓存和日志保存在 `~/.chaoxing/`。 +生成的实质性文字在请求之前持久化到 `~/.chaoxing/reviews/`; +写入失败会阻止该项提交。记录区分取消、失败、未确认和平台接受。 +客观题选项显示在运行记录中,不进入正文复核文件。 +文本检查不能完整判断真实性,用户仍应复核内容。 + +可选题库和模型服务会接收问题及相关上下文;写作服务可能接收讨论参考文本, +通知服务会接收配置的通知。日志脱敏不能去除任意正文中的所有私人事实。 +不要公开凭据、账号数据或原始抓包;若凭据已公开,应在来源处撤销或更换。 +删除当前文件不会清除 Git 历史。公开贡献仅包含可维护的代码、 +用户文档和合成测试数据;工作笔记保存在仓库之外。 + +## 安装包和离线验证 + +```sh +pip install . +chaoxing --help +chaoxing-setup +python -m unittest discover -s tests -t . +python tools/audit/publication_guard.py +python tools/audit/01_human_likeness_audit.py --selftest +``` + +安装包包含字体映射和配置模板,支持在仓库目录之外运行。 +生成内容、取消和失败状态、顺序解锁与接口解析均有离线回归测试。 +开发时还应检查 Python 3.13、安装包和上游自动审查结果。 +公开贡献应从最新上游历史建立,按功能拆分并说明依赖,保留许可与作者归属。 diff --git a/api/accounts.py b/api/accounts.py new file mode 100644 index 000000000..a3d846028 --- /dev/null +++ b/api/accounts.py @@ -0,0 +1,146 @@ +# -*- coding: utf-8 -*- +"""多用户账号管理.""" +# +# 把每个用户的账号密码单独保存在用户数据目录(~/.chaoxing/accounts/)下,互不干扰。 +# 放在用户主目录而不是项目目录,升级代码 / git 操作都不会影响账号数据。 +# 账号文件格式(ini): +# [account] +# username = 13800000000 +# password = xxxxx +# name = 张三 ; 登录后自动记录,用于列表显示 +# last_used = YYYY-MM-DD ; 最后使用时间 + +import configparser +import os +import re +import time + +from api import paths +from api.configfile import read_config_file + +BASE = os.path.dirname(os.path.abspath(__file__)) +ROOT = os.path.dirname(BASE) +# 账号目录:用户数据目录下的 accounts/(由 api.paths 统一管理) +ACCOUNTS_DIR = paths.accounts_dir() + + +def ensure_dir(): + os.makedirs(ACCOUNTS_DIR, exist_ok=True) + + +def _safe_name(username): + """用手机号当文件名,去掉不安全的字符.""" + return re.sub(r"[^0-9A-Za-z_\-]", "_", str(username).strip()) + + +def account_path(username): + return os.path.join(ACCOUNTS_DIR, _safe_name(username) + ".ini") + + +def save_account(username, password, name="", course_ids=None, last_plan=None): + """保存(或更新)一个账号;未传的字段沿用已有值.""" + ensure_dir() + path = account_path(username) + username = str(username).strip() + + old = {} + if os.path.exists(path): + try: + old = load_account(username) or {} + except Exception: + old = {} + + cfg = configparser.ConfigParser() + cfg["account"] = { + "username": username, + "password": str(password), + "name": name or old.get("name", ""), + "last_used": time.strftime("%Y-%m-%d %H:%M"), + } + # 记住上次选的课程和方案,方便下次沿用 + cids = course_ids if course_ids is not None else old.get("course_ids", "") + plan = last_plan if last_plan is not None else old.get("last_plan", "") + if cids: + cfg["account"]["course_ids"] = cids + if plan: + cfg["account"]["last_plan"] = plan + + with open(path, "w", encoding="utf8") as f: + cfg.write(f) + try: + os.chmod(path, 0o600) + except OSError: + if os.name != "nt": + raise + return path + + +def load_account(username): + """读取一个账号,返回 dict 或 None.""" + # + # 文件内容损坏(手改坏、写到一半断电等)时返回 None, + # 而不是抛异常拖垮整个账号列表。 + path = account_path(username) + if not os.path.exists(path): + return None + cfg, _broken = read_config_file(path) + if not cfg.has_section("account"): + return None + + # 上次选的课程/任务点数,下次可沿用 + course_ids = cfg.get("account", "course_ids", fallback="") + last_plan = cfg.get("account", "last_plan", fallback="") + + return { + "username": cfg.get("account", "username", fallback=""), + "password": cfg.get("account", "password", fallback=""), + "name": cfg.get("account", "name", fallback=""), + "last_used": cfg.get("account", "last_used", fallback=""), + "course_ids": course_ids, + "last_plan": last_plan, + } + + +def list_accounts(): + """列出所有已保存的账号,最近使用的排前面.""" + ensure_dir() + items = [] + for fn in os.listdir(ACCOUNTS_DIR): + if not fn.endswith(".ini"): + continue + # 单个账号文件损坏不该让整个列表打不开,跳过即可 + try: + acc = load_account(fn[:-4]) + except Exception as exc: + from api.logger import logger + logger.warning("忽略无法读取的账号文件({})", type(exc).__name__) + continue + if acc and acc.get("username"): + items.append(acc) + items.sort(key=lambda a: a.get("last_used") or "", reverse=True) + return items + + +def latest_run_config(): + """最近使用的账号专属配置路径(cx discuss 这类命令没给 -c 时用它).""" + for item in list_accounts(): + path = os.path.join(ACCOUNTS_DIR, "run_" + _safe_name(item["username"]) + ".ini") + if os.path.exists(path): + return path + return "" + + +def delete_account(username): + path = account_path(username) + if os.path.exists(path): + os.remove(path) + return True + return False + + +def touch(username, name=None): + """更新最后使用时间(以及昵称).""" + acc = load_account(username) + if not acc: + return + save_account(acc["username"], acc["password"], name or acc.get("name", "")) diff --git a/api/ai_writer.py b/api/ai_writer.py new file mode 100644 index 000000000..f3dc9a929 --- /dev/null +++ b/api/ai_writer.py @@ -0,0 +1,613 @@ +# -*- coding: utf-8 -*- +"""生成并检查问答和讨论回复.""" +# +# 任务中心的问答(思考题、作业简答)和主题讨论不能用模板腔: +# 平台上老师和同学一眼就能看出 AI 味,讨论区还要求和其他同学的回复风格一致。 +# +# 这个模块负责两件事: +# 1. 用配置里的大模型([tiku] 段的 endpoint / key / model)生成内容 +# 2. 严格"去 AI 味":提示词约束 + 生成后清洗 + 长度/风格对齐参考文本 +# +# 注意:这里只负责写字,不负责任何提交动作。 + +import configparser +import json +import os +import re +import statistics +import time +from typing import Optional + +import requests +from loguru import logger + +from api import llm +from api import paths +from api.privacy import register_config + +# 一眼假的 AI 腔,生成后直接替换/删掉 +# 这些词出现在句首/段首就是模板腔,连同后面的顿断一起删掉 +AI_SMELL_PATTERNS = [ + (r"(^|[。!?!?\n])[ \t]*(首先|其次|再次|最后|另外|此外|总之|总而言之|综上所述|总的来说|值得注意的是)[,,::]?", r"\1"), + (r"(^|[。!?!?\n])[ \t]*(作为一名|作为一个|作为一位)[^,,。]{0,12}[,,]", r"\1"), + (r"(希望(这个|以上)?(回答|内容|讨论)?(对你|对大家)?(有所)?帮助)[。!!]?", ""), + (r"(如有(任何)?(疑问|问题|需要)[^。]{0,20})[。!!]?", ""), + (r"(让我们(一起)?(来)?(看看|探讨|学习))[^。]{0,10}[。!!]?", ""), +] +MARKDOWN_NOISE = re.compile( + r"\x60{3}.*?\x60{3}|^#{1,6}[ \t]*|^[ \t]*[-*+][ \t]+|^[ \t]*\d+[.、][ \t]*", + re.M | re.S, +) + + +class HumanLikeWriter: + """用大模型生成"像真人写的"课程问答 / 讨论回复.""" + + def __init__(self, tiku_config: Optional[dict] = None, config_path: Optional[str] = None): + """Initialize configuration and runtime state.""" + cfg = dict(tiku_config or {}) + if not cfg: + cfg = self._read_tiku_config(config_path) + register_config(cfg) + self.endpoint = (cfg.get("endpoint") or "").strip() + self.key = (cfg.get("key") or "").strip() + self.model = (cfg.get("model") or "").strip() + self.proxy = (cfg.get("http_proxy") or "").strip() or None + # thinking 策略:auto 让模型自己推理(V4.1 flash 默认带推理,写作质量更好) + self.thinking = llm.normalize_thinking(cfg.get("thinking", "auto")) + try: + self.interval = float(cfg.get("min_interval_seconds") or 0) + except (TypeError, ValueError): + self.interval = 0.0 + self._last_call = 0.0 + + @staticmethod + def _read_tiku_config(config_path: Optional[str] = None) -> dict: + path = config_path or paths.config_path() + if not os.path.exists(path): + return {} + parser = configparser.ConfigParser() + try: + parser.read(path, encoding="utf-8") + return dict(parser.items("tiku")) if parser.has_section("tiku") else {} + except Exception: + return {} + + @property + def available(self) -> bool: + return bool(self.endpoint and self.key and self.model) + def _thinking_steps(self) -> list: + """按配置的 thinking 模式返回尝试顺序(默认 auto:先让模型自己推理).""" + return llm.thinking_steps(self.thinking) + + # ------------------------------------------------------------------ 底层 + + def _chat(self, system: str, user: str, temperature: float = 0.95, max_tokens: int = 800) -> str: + if not self.available: + raise RuntimeError("没有配置可用的大模型([tiku] endpoint / key / model)") + if self.interval > 0 and self._last_call: + wait = self.interval - (time.time() - self._last_call) + if wait > 0: + time.sleep(wait) + url = self.endpoint.rstrip("/") + if not url.endswith("/chat/completions"): + url = url + "/chat/completions" + payload = { + "model": self.model, + "messages": [ + {"role": "system", "content": system}, + {"role": "user", "content": user}, + ], + "temperature": temperature, + "max_tokens": max_tokens, + } + steps = self._thinking_steps() + for index, step in enumerate(steps): + payload.pop("thinking", None) + payload.update(llm.thinking_payload(step)) + try: + resp = requests.post( + url, + headers={"Authorization": "Bearer " + self.key, "Content-Type": "application/json"}, + json=payload, + proxies={"http": self.proxy, "https": self.proxy} if self.proxy else None, + timeout=60, + ) + except Exception as exc: + if payload.get("thinking") and llm.is_thinking_param_error(exc) and index + 1 < len(steps): + continue + raise + self._last_call = time.time() + if resp.status_code >= 400: + # 有的部署不认 thinking 参数:去掉它再试一次 + if payload.get("thinking") and index + 1 < len(steps) and "thinking" in (resp.text or "").lower(): + continue + resp.raise_for_status() + data = resp.json() + content = (data["choices"][0]["message"]["content"] or "").strip() + if content: + return content + logger.debug("大模型第 {} 档 thinking={} 返回空内容(model={})", index + 1, step, self.model) + if index + 1 < len(steps): + time.sleep(1.0) + continue + raise RuntimeError("大模型连续返回空内容,拿不到可用文本(检查 model / thinking / max_tokens 配置)") + + # ------------------------------------------------------------ 去 AI 味 + + @staticmethod + def clean(text: str) -> str: + """把明显的 AI 腔和 markdown 痕迹洗掉.""" + if not text: + return "" + text = MARKDOWN_NOISE.sub("", text) + for pattern, repl in AI_SMELL_PATTERNS: + text = re.sub(pattern, repl, text, flags=re.M) + # 破折号是中文里很常见的停顿,别一律替换成逗号:全文都没有破折号本身就是一种"机器排版" + text = text.replace("**", "") + text = re.sub(r"[ \t]+", " ", text) + text = re.sub(r"\n{2,}", "\n", text).strip() + return text + + @staticmethod + def style_reference(posts) -> str: + """把同学们的回复整理成风格参考(长度、口吻、用词).""" + lines = [] + for index, post in enumerate(posts or [], 1): + if isinstance(post, dict): + content = post.get("content") or post.get("text") or "" + else: + content = str(post) + content = re.sub(r"\s+", " ", content).strip() + if content: + lines.append(str(index) + ". " + content[:160]) + return "\n".join(lines) + + # ------------------------------------------------------------ 对外接口 + + SYSTEM_STYLE = ( + "你在帮一名普通本科生写课程平台上的作业/讨论内容。" + "写出来的东西必须像一个真人随手打的,不能有 AI 腔:\n" + "1. 禁止出现:首先、其次、最后、总之、总而言之、综上所述、值得注意的是、" + "总的来说、希望对你有所帮助、作为一名学生、让我们一起来看看。\n" + "2. 不要用整齐的分点罗列,不要写小标题,不要用 emoji,不要用 markdown。\n" + "3. 句子长短要拉开:至少有一句 12 字以内的短句,不要每句都是四五十字的长句。\n" + "4. 口语词(我觉得、其实、反正、可能、感觉、挺、有点)整段最多用 2 次," + "更不要每个段落都用同一个词;结尾不要用\"反正……\"这类泛泛的总结," + "可以停在一个具体的观察、疑问或没解决的地方。\n" + "5. 不许编造个人履历和查不到的数据:不要写\"我实习的公司\"\"我是部门负责人\"" + "\"客户留存/毛利/三年数据\"这类真伪可被当面核对的内容。想举例子就用" + "课堂上讲过的概念、公开报道的案例,或者写成假设句(\"如果我在那样的公司……\")。\n" + "6. 例子要具体但不要用全网答案库里最烂大街的那几个(强生信条、阿里 102 年、" + "双减教培、PEST 定义……),尽量用身边可感知的场景或课上的案例。\n" + "7. 结构上不要'起承转合金句收尾':全文最多一句总结,结尾禁止用" + "\"不是……而是……\"\"真正难的是\"\"说到底\"这类可被引用的金句;" + "也**不要**拿\"我还没太想明白\"\"我也在琢磨\"当固定收尾——那只是换了个样子的口癖。" + "结尾朴素地停在一个具体观察上就行,允许话没说完,但不要刻意示弱。\n" + "7.1 思考题/作业简答这类要评分的内容,不要示弱收尾,也不要通篇不表态。\n" + "7.2 不许认领共同经历:\"我们小组上次讨论\"\"社团活动时\"\"课上讲的某个案例\"" + "这类说法必须有素材支撑;没给素材就只写课程概念、公开报道或假设句。\n" + "7.3 不许写\"往往/通常/多半\"开头的普适经验断言(例:\"总部给的模型和一线看到的往往差很多\")," + "这类句子既没有来源又容易被追问。\n" + "7.4 回答要围绕题目里的概念。只有提供了真实课程材料,才能引用教材、老师或课堂;" + "没有素材就解释题目概念或使用明确的假设句,不得编造材料来源。\n" + "7.5 引用政策/事件要小心时间线和因果,拿不准就只说背景、不下因果结论。\n" + "8. 引用公开政策/事件时,必须能说出时间或文件名称;说不出来就别举例。" + "不要写\"某公司\"\"某个区域\"\"多少小时\"\"几十单\"这种既模糊又当事实用的说法。\n" + "9. 不要编个人琐事:\"我上个月注册了个App\"\"我前几天去面试\"这种没有依据的" + "第一人称经历一律不写,没有真实素材就用课堂案例、公开事实或假设句。\n" + "10. 不要用\"三层递进\"排比收尾(\"A管的是……,B管的是……,C管的是……\"、" + "\"从……到……再到……\"),也不要用对偶句凑工整;结尾朴素一点。\n" + "11. 观点要清楚、态度认真,可以有一点点不完美的口语表达,全篇不要每句都通顺工整。\n" + "12. 只输出正文,不要任何解释或前后缀。" + ) + + # 输出侧硬黑名单:这些字样一旦出现在正文里,就是把平台的判分反馈回显给学生看 + LEAK_PATTERNS = ( + r"回答正确", r"回答错误", r"真遗憾", r"本题考核知识点", r"正确答案是", + r"正确答案为", r"依据\s*[::]", r"平台判据", r"你的回答", r"得分\s*\d", + r"参考解析", r"答案解析", + ) + HABIT_WORDS = ("我觉得", "其实", "反正", "感觉", "可能", "挺", "有点") + # 结尾金句/总结腔:审计指出"每篇都交一句可被引用的结论"是最强的机器指纹 + CLOSING_CLICHE = ( + r"不是[^。!?]{0,24}而是", r"并非[^。!?]{0,24}而是", + r"真正(难|重要|关键)的是", r"说到底", r"这才是", r"归根到底", + ) + # 无来源的"假具体":既模糊又当事实用,老师一问就穿 + UNSOURCED_SPECIFIC = ( + r"某(个|家|一)?(公司|企业|品牌|区域|城市|行业|领域|产线)", r"多少(小时|天|单|人)", + r"几十(单|万|个)", r"大概(几|几十)", r"近(三|两)年(的)?(数据|指标)", + r"(一些|不少|部分)(做|的)?[^,。;]{0,10}(品牌|企业|公司|商家|机构)", + r"之前(看过|了解过|刷到过)[^,。;]{0,12}(案例|例子|新闻)", + ) + # 真实犹豫/口语碎片:长文里至少要有 1 处,否则太顺滑 + HESITATION = ("说不好", "记不清", "没太想明白", "不太确定", "可能吧", "也说不准", + "没完全", "有点乱", "?", "?", "忘了", "大概是", "好像", "应该", + "印象里", "之类", "吧", "呢", "估计") + # 显式模板连接词:生成器也要拦,不然审计器会抓(两边规则要一致) + AI_CONNECTORS = ("首先", "其次", "再次", "最后", "总之", "总而言之", "综上所述", + "总的来说", "值得注意的是", "由此可见", "不难看出", "在当今社会") + # 三层递进/排比收尾:同一账号多篇都用同一套结构,是最容易被老师看出的破绽 + STRUCTURE_CLICHE = ( + r"从[^,。;]{0,14}到[^,。;]{0,14}再到", + r"[^,。;]{0,12}管的是[^,。;]{0,14},[^,。;]{0,12}(管|是)的是", + r"[^,。;]{0,10}管[^,。;]{0,8},[^,。;]{0,10}管[^,。;]{0,8},[^,。;]{0,10}管", + r"先[^,。;]{0,10}再[^,。;]{0,10}(最后|才能|然后)", + r"不是[^,。;]{0,14},(而)?是[^,。;]{0,16}", + ) + # 没有依据的第一人称琐事(编造个人经历) + FAKE_PERSONAL = ( + r"我(上个月|上上个月|前几天|上周|最近|上次|昨天)(注册|下载|买了|报名|参加|去|跟|面)", + r"我(一个|有个)(朋友|同学|亲戚)(跟|在|做|说)", + # 在校学生不会有真实的实习/在职经历,写了就是编的 + r"我(之前|以前|原来|上家|上一家|曾经)?[^,。;]{0,6}(实习|上班|就职|入职)", + # 兼职/打工同样是编的(实测模型会写"我在奶茶店做过兼职") + r"我(在|曾经在)[^,。;]{0,8}(兼职|打工|上班|实习)", + r"我(做|干|打)过[^,。;]{0,4}(兼职|暑假工|临时工|小时工)", + r"我们(公司|单位|企业)(里|的|在|要求|规定|考核)", + r"我(去年|前年|以前|曾经|曾|今年)[^。!?]{0,20}(参加|参与|做过|调查|实习|培训|面试)", + ) + # 认领共同经历(没有素材支撑时一律算编造) + CLAIMED_COMMUNITY = ( + r"我们(小组|班|社团|团队)(上次|之前|课上|讨论|做|在)", + r"(上次|之前|课上)(我们)?(小组|讨论|活动|讲)时", + r"课上(讲|说|提)(过|的)", + r"老师(说|讲|提)(过|的)|教材(上|里)(说|讲|提)|教材上", + r"我们(的)?(小组|班级?|社团|团队)[^。!?]{0,20}(曾经|做过|调查|讨论过|参加过)", + r"(根据|按照|正如)[^,。!?]{0,20}(教材|课本|老师|教师)", + r"(老师|教师|教材|课本|课堂|课上)[^。!?]{0,20}(强调|指出|讲过|说过|写过|论述|介绍过|解释过|教过)", + ) + # 示弱收尾:上一版为了防"金句收尾"引入,结果自己变成了统一口癖 + WEAK_ENDING = (r"(没太想明白|没完全(想|搞)明白|还在(琢磨|想)|也说不好|说不好|没搞懂|没想清楚)[。?!]*$",) + # 普适经验断言 + UNIVERSAL_CLAIM = ( + r"(往往|通常|多半|一般都会)[^。!?]{0,24}(总部|客户|一线|市场|财务|生意|老板|公司)", + ) + # 课程锚点 + COURSE_ANCHOR = ("课上", "教材", "老师", "这门课", "本章", "第几章", "课本") + + @classmethod + def find_leak(cls, text: str): + """返回正文里命中的"平台话术"(空列表表示干净).""" + return [pattern for pattern in cls.LEAK_PATTERNS if re.search(pattern, str(text or ""))] + + @classmethod + def habit_stats(cls, text: str) -> dict: + return {word: str(text or "").count(word) for word in cls.HABIT_WORDS + if str(text or "").count(word)} + + @staticmethod + def cut_at_sentence(text: str, max_chars: int) -> str: + """按整句截断,避免在句子中间被硬切(真人不会写半句话).""" + text = str(text or "") + if len(text) <= max_chars: + return text + window = text[:max_chars] + cut = max(window.rfind(mark) for mark in "。!?!") + return window[:cut + 1] if cut > 0 else window + + @classmethod + def style_problems(cls, text: str, require_hesitation: bool = False, + require_course_anchor: bool = False) -> list: + """真人化自检:返回命中的问题(空列表=过检).""" + # + # 检查范围: + # 结尾金句、无来源的假具体、口癖分布过密、长文没有一处真实的犹豫。 + text = str(text or "") + problems = [] + # No authenticated course or personal source material is accepted by this + # API. Reject source attribution and narrated experience conservatively, + # rather than enumerating time adverbs that a model can paraphrase. + checks = [ + (re.search('教材|课本|讲义|老师|教师|教授|授课|课上|课堂|(?:本章|本节|课程|讲义|原文).{0,8}(?:写|说|指出|提及|提到|强调)', text), '未经提供的课程来源'), + (re.search('(? habit_limit or any((count >= 3 for count in stats.values())), '口癖分布过密'), + (any((re.search(pattern, text) for pattern in cls.CLOSING_CLICHE)), '金句收束'), + (any((re.search(pattern, text) for pattern in cls.UNSOURCED_SPECIFIC)), '无来源的假具体'), + (any((re.search(pattern, text) for pattern in cls.FAKE_PERSONAL)), '编造的个人琐事'), + (any((word in text for word in cls.AI_CONNECTORS)), '模板连接词'), + (any((re.search(pattern, text.strip()) for pattern in cls.WEAK_ENDING)), '示弱收尾口癖'), + (any((re.search(pattern, text) for pattern in cls.CLAIMED_COMMUNITY)), '认领共同经历'), + (any((re.search(pattern, text) for pattern in cls.UNIVERSAL_CLAIM)), '普适经验断言'), + (require_course_anchor and (not any((word in text for word in cls.COURSE_ANCHOR))), '没有课程锚点'), + (any((re.search(pattern, text) for pattern in cls.STRUCTURE_CLICHE)), '三层排比/对偶'), + ] + problems.extend(message for matched, message in checks if matched) + # 句句都是长度接近的长句 = 低突发度,AIGC 检测的高权重特征 + sentences = [s for s in re.split(r"[。!?!?\n]", text) if s.strip()] + if len(sentences) >= 4: + lengths = [len(s) for s in sentences] + if statistics.pstdev(lengths) < 6 and min(lengths) >= 25: + problems.append("句子过于整齐") + # 只对"讨论/开放问答"这种口语场景要求犹豫痕迹;正式的思考题/作业简答 + # 本来就写得工整,硬塞"记不清"反而不像学生。 + if require_hesitation and len(text) >= 120 \ + and not any(mark in text for mark in cls.HESITATION): + problems.append("通篇太顺,没有犹豫/口语碎片") + return problems + + def _generate_text(self, user: str, max_chars: int, require_hesitation: bool = False, + require_course_anchor: bool = False, **kwargs) -> str: + """生成 + 自检:不合格就重写,平台判分话术残留直接报错.""" + # + # 宁可失败也不能把"回答正确/依据:/本题考核知识点"这类平台判分话术 + # 写进要提交给老师的正文里()。 + text = "" + last_problems = [] + for attempt in range(1, 4): + raw = self._chat(self.SYSTEM_STYLE, user, **kwargs) + text = self.cut_at_sentence(self.clean(raw), max_chars) + last_problems = self.style_problems( + text, require_hesitation=require_hesitation, + require_course_anchor=require_course_anchor, + ) + if not last_problems: + return self.cut_at_sentence(text, max_chars) + logger.debug("生成内容不合格(第 {} 次):{}", attempt, "、".join(last_problems)) + overused = [word for word, count in self.habit_stats(text).items() if count >= 2] + extra = (";这一版里「" + "、".join(overused) + "」用多了,换掉") if overused else "" + # 把这一版具体踩到的问题回给模型,比笼统说"写得像人一点"有效 + extra += ";这一版的问题是:" + "、".join(last_problems) + ",请针对这些改" + user = (user + "\n注意:不要出现\"回答正确/依据/本题考核知识点/你的回答\"这类平台判分用语;" + "不要用\"不是……而是……\"\"真正难的是\"\"说到底\"收尾;" + "不要写\"某公司/某个区域/多少小时/几十单\"这种编出来的具体;" + "口语词不要反复用同一个;句子长短要拉开," + "至少插一句 12 字以内的短句,不要每句都是四五十字的长句;" + "不要用\"我还没太想明白\"结尾;不要认领小组/社团/课堂经历;" + "不要写\"往往/通常\"开头的普适断言;围绕题目中的概念;" + "可以留一处不那么确定的表达,但不要用固定的那几句;" + "结尾不要每篇都点题或落在一句有味道的话上;" + "不要编造教材、老师或课堂来源" + extra + "。") + if "平台判分话术" in last_problems: + raise RuntimeError("生成内容里仍带有平台判分话术") + # 编造个人履历(实习/兼职/在职)是硬伤:宁可不提交,也不能把假经历发给老师 + if "编造的个人琐事" in last_problems: + raise RuntimeError("生成内容里仍在编造个人经历(实习/兼职/在职)") + raise RuntimeError("生成内容重写后仍未通过检查:" + "、".join(last_problems)) + + def answer(self, question: str, requirement: str = "", references=None, + max_chars: int = 220) -> str: + """给问答题/简答题写一段像真人的回答.""" + refs = self.style_reference(references) + user = ( + "题目:" + question + "\n" + + ("补充要求:" + requirement + "\n" if requirement else "") + + ("可以参考的同学答案:\n" + refs + "\n" if refs else "") + + "请写一段 " + str(max(60, max_chars - 60)) + "~" + str(max_chars) + " 字的回答," + "不要照抄参考内容,用你自己的话讲清楚观点和理由。" + ) + return self._generate_text(user, max_chars) + + def discussion(self, topic: str, requirement: str = "", existing_posts=None, + max_chars: int = 180, revision_hint: str = "", + previous_reply: str = "") -> str: + """给主题讨论写一条回复:目标"班里中等水平"的普通回复,不显眼也不掉队.""" + # + # 用户实测反馈:太机灵、太有个人风格("要我说…我甚至觉得…")反而不像普通同学。 + # 所以这里明确要求平实、普通、长度和多数同学接近;不追求语言上的亮点。 + refs = self.style_reference(existing_posts) + user = ( + "讨论主题:" + topic + "\n" + + ("老师的要求:" + requirement + "\n" if requirement else "") + + ("上一版草稿:\n" + str(previous_reply).strip() + "\n" if previous_reply else "") + + ("用户希望这样调整:" + str(revision_hint).strip() + "\n" if revision_hint else "") + + ("同学们已经发过的回复:\n" + refs + "\n" if refs else "") + + "请再写一条 " + str(max(30, max_chars - 50)) + "~" + str(max_chars) + " 字的回复:\n" + "- 目标是班里**中等水平**:直接回答老师的问题,一句明确观点 + 一两条" + "课本上/常识性的理由,语气平实、普通、不显眼;\n" + "- 不要写巧妙的类比,不要抖机灵,不要金句/排比,不要引经据典式展开;\n" + "- 也不要刻意示弱、不要用方言口癖、不要为了口语化而硬加语气词;\n" + "- 可以正常用“我认为/我觉得”开头,句子长短适中,不要每句都四五十字;\n" + "- 长度和上面多数同学差不多,不要写成 800 字小论文,也不要只写一句半;\n" + "- 直接给正文,不要写“我同意楼上”这类空话;\n" + + ("- 上面确实有同学的回复:只模仿他们的语气和长度," + "不要引用/复述某条回复的原话、楼层或编号(很容易编造出没出现过的话);\n" + if refs else + "- 这次没有同学回复可参考:请写一条能独立成立的回复," + "不要出现“楼上/前面那位/那个例子”这类指代别人发言的说法;\n") + + "- 不要编造个人经历(兼职/实习/打工/任职),没有真实经历就写课程里的说法、" + "公开案例或假设句(\u201c如果\u2026\u201d),也不要认领小组/班级经历。" + + ("\n- 必须吸收用户的调整方向,重新写一版完整正文;不要解释改了哪里,也不要照抄上一版。" + if revision_hint or previous_reply else "") + ) + return self._generate_text(user, max_chars) + + def practice_answer(self, question: str, requirement: str = "", context: str = "", + max_chars: int = 520) -> str: + """为 AI 实践的开放题生成更完整的课程回答.""" + user = ( + "AI 实践题目:" + str(question or "") + "\n" + + ("实践要求:" + str(requirement) + "\n" if requirement else "") + + ("当前维度/知识点:" + str(context) + "\n" if context else "") + + "请结合课程里的概念和一个具体场景回答,说明你的判断和可能的取舍。" + "没有真实经历就写成假设句或课堂案例,不要编造实习/职位/数据。" + "结尾不要总结升华,可以停在一处还不确定的地方。" + "回答要自然、具体、连贯,控制在 180~" + str(max(240, max_chars)) + + " 字,只输出回答正文。" + ) + return self._generate_text(user, max_chars, require_hesitation=True, + temperature=0.7, max_tokens=900) + + # AI 实践的客观题用多票自洽:同一个 prompt 采样几次取多数,降低偶发误判 + OBJECTIVE_VOTES = 3 + + def _vote(self, system: str, user: str, parse, votes: int = None, **kwargs): + """把一个 parse 函数套在多次采样上,返回票数最多的结果.""" + count = max(1, int(votes or self.OBJECTIVE_VOTES)) + tally: dict = {} + for _ in range(count): + try: + raw = self._chat(system, user, **kwargs) + except Exception as e: + logger.warning("多票作答第 {} 次调用失败: {}", _ + 1, e) + continue + key = parse(raw) + if key: + tally[key] = tally.get(key, 0) + 1 + if not tally: + return None + best = max(tally.items(), key=lambda item: item[1]) + if len(tally) > 1: + logger.debug("多票结果: {} -> 取 {}", tally, best[0]) + return best[0] + + def choose_options(self, question: str, options, multiple: bool = False, + context: str = "", exclude=None) -> str: + """为 AI 实践选择题选项,只返回平台需要的 A/B/C... 字母.""" + option_lines = [] + for item in options or []: + if isinstance(item, dict): + letter = str(item.get("option") or "").strip().upper() + content = str(item.get("optionContent") or item.get("content") or "") + else: + letter, content = "", str(item) + if letter: + option_lines.append(f"{letter}. {content}") + if not option_lines: + raise ValueError("选择题没有有效选项") + mode = "多选,可选择一个或多个" if multiple else "单选,只选择一个" + user = ( + "课程测验题。\n" + "题目:" + str(question or "") + "\n" + + ("考点提示:" + context + "\n" if context else "") + + "选项:\n" + "\n".join(option_lines) + "\n" + + "作答要求:\n" + "1) 先确定题目考的是哪个课程概念,再逐个选项对照概念判断;\n" + "2) 表述绝对化的选项(一定、总是、唯一、完全)通常不是标准答案," + "除非符合教材原意;\n" + "3) " + mode + ";\n" + "4) 最后一行的格式必须是「答案:X」(多选按字母顺序连写,如 答案:ABD)," + "前面可以有一两句简短判断依据,不要再写别的。" + ) + valid = {line.split(".", 1)[0].strip().upper() for line in option_lines} + + def parse(raw): + letters = self._extract_letters(raw, valid) + return "".join(letters) or None + + voted = self._vote( + "你是这门课程的答题助手,只依据课程理论作答," + "以选出标准答案为目标,不要靠选项格式或长度猜。", + user, + parse, + temperature=0.5, + max_tokens=400, + ) + if not voted: + raise ValueError("模型没有返回有效选择题选项") + selected = [letter for letter in voted] + order = {letter: index for index, letter in enumerate("ABCDE")} + if not multiple: + answer = selected[0] + # 平台判断题的是平台自己的大模型,同一个答案会被反复判错; + # 重试时换一个还没试过的选项,才有机会跳出循环。 + banned = {str(item).strip().upper() for item in (exclude or [])} + if answer in banned: + for letter in sorted(valid, key=lambda x: order.get(x, 99)): + if letter not in banned: + logger.info("选择题 {} 已判错过,改用 {} 重试", answer, letter) + return letter + return answer + selected = sorted(set(selected), key=lambda letter: order.get(letter, 99)) + answer = "".join(selected) + banned_sets = {"".join(sorted(str(item).upper())) for item in (exclude or [])} + if answer in banned_sets: + for letter in sorted(valid, key=lambda x: order.get(x, 99)): + if letter not in answer: + logger.info("多选题 {} 已判错过,补上 {} 重试", answer, letter) + return "".join(sorted(answer + letter, key=lambda x: order.get(x, 99))) + return answer + + @staticmethod + def _recent_feedback(data: dict, limit: int = 3, max_chars: int = 600) -> str: + """从 AI 实践对话里提取平台最近的解析/判据.""" + # + # 平台的 preAppendContent 在判错时会直接把正确概念讲出来 + # (例如"公司层战略是企业最高管理层制定的面向企业整体的总体战略,核心是确定经营领域"), + # 把它作为作答依据喂回模型,能显著提高重复题的正确率。 + hints = [] + messages = list((data or {}).get("messageList") or [])[-24:] + for message in reversed(messages): + if not isinstance(message, dict): + continue + payload = message.get("content") + if isinstance(payload, str): + try: + payload = json.loads(payload) + except (TypeError, ValueError): + payload = None + if not isinstance(payload, dict): + continue + text = str(payload.get("preAppendContent") or "").strip() + if not text: + continue + if not any(key in text for key in ("正确", "遗憾", "误解", "知识点", "核心")): + continue + text = re.sub(r"\s+", " ", text) + if text not in hints: + hints.append(text[:max_chars]) + if len(hints) >= limit: + break + return ";".join(reversed(hints)) + + @staticmethod + def _extract_letters(raw: str, valid: set) -> list: + """从模型输出里取选项字母:优先「答案:X」,否则只看最后一行.""" + text = str(raw or "") + marked = re.findall(r"答案\s*[::]?\s*([A-Ea-e]{1,5})", text) + if marked: + source = marked[-1] + else: + lines = [line.strip() for line in text.splitlines() if line.strip()] + source = lines[-1] if lines else "" + letters = [] + for letter in re.findall(r"[A-E]", source.upper()): + if letter in valid and letter not in letters: + letters.append(letter) + return letters + + def choose_judgement(self, question: str, context: str = "", exclude=None) -> str: + """为 AI 实践判断题返回平台使用的“对”或“错”.""" + user = ( + "课程判断题。\n" + "题目:" + str(question or "") + "\n" + + ("考点提示:" + context + "\n" if context else "") + + "作答要求:先依据课程概念判断这句话成立不成立," + "最后一行只写「答案:对」或「答案:错」,前面可以有一句简短理由。" + ) + def parse(raw): + text = str(raw or "") + marked = re.findall(r"答案\s*[::]?\s*([对错])", text) + if marked: + return marked[-1] + tail = "".join(line.strip() for line in text.splitlines()[-1:]) + if "对" in tail and "错" not in tail: + return "对" + if "错" in tail and "对" not in tail: + return "错" + return None + + answer = self._vote( + "你是这门课程的答题助手,严格依据课程理论判断正误。", + user, + parse, + temperature=0.3, + max_tokens=200, + ) + if not answer: + raise ValueError("模型没有返回明确的判断题答案") + banned = {str(item).strip() for item in (exclude or [])} + if answer in banned: + flipped = "错" if answer == "对" else "对" + logger.info("判断题 {} 已判错过,改用 {} 重试", answer, flipped) + return flipped + return answer diff --git a/api/answer.py b/api/answer.py index 02a3c8bfb..dfe0847f1 100644 --- a/api/answer.py +++ b/api/answer.py @@ -17,6 +17,8 @@ from openai import OpenAI from urllib3 import disable_warnings, exceptions +from api import llm +from api import paths as _paths from api.answer_check import check_answer from api.logger import logger @@ -28,15 +30,20 @@ class CacheDAO: - """ - @Author: SocialSisterYi - @Reference: https://github.com/SocialSisterYi/xuexiaoyi-to-xuexitong-tampermonkey-proxy - """ - DEFAULT_CACHE_FILE = "cache.json" + """@Author: SocialSisterYi.""" + + # @Reference: https://github.com/SocialSisterYi/xuexiaoyi-to-xuexitong-tampermonkey-proxy + # 答案缓存放在用户数据目录,升级代码不会丢失已积累的答案 + DEFAULT_CACHE_FILE = _paths.cache_path() + + # 锁必须是"类级"的:每次查询都会新建一个 CacheDAO 实例, + # 实例锁等于没锁 —— 两个章节同时答题时会各自读-改-写, + # 后写的把先写的覆盖掉,缓存里的题就丢了(#552)。 + _lock = threading.RLock() def __init__(self, file: str = DEFAULT_CACHE_FILE): + """Initialize configuration and runtime state.""" self.cache_file = Path(file) - self._lock = threading.RLock() if not self.cache_file.is_file(): self._write_cache({}) @@ -48,7 +55,11 @@ def _read_cache(self) -> dict: return {} try: with self.cache_file.open("r", encoding="utf8") as fp: - return json.load(fp) + data = json.load(fp) + if not isinstance(data, dict): + logger.warning("缓存文件内容不是对象({}),已忽略", type(data).__name__) + return {} + return data except json.JSONDecodeError as e: logger.error(f"缓存文件 JSON 解析失败: {e}, 尝试恢复...") # 尝试从原始二进制中以 utf-8 忽略错误地恢复有效 JSON 段 @@ -127,6 +138,10 @@ def _write_cache(self, data: dict) -> None: def get_cache(self, question: str) -> Optional[str]: data = self._read_cache() + # 缓存文件是合法 JSON 但不是对象时(例如被改成 [] 或 null)不能直接 .get + if not isinstance(data, dict): + logger.warning("缓存文件内容不是对象,已忽略并重新建立缓存") + return None return data.get(question) def add_cache(self, question: str, answer: str) -> None: @@ -137,8 +152,48 @@ def add_cache(self, question: str, answer: str) -> None: self._write_cache(data) +# 这些错误"再试也没用":出现一次就停止逐个题目重试 +FATAL_API_MARKERS = ( + # 认证 / 余额 + "401", "402", "unauthorized", "authentication", + "invalid_api_key", "invalid api key", "insufficient", "quota", + # 模型名写错 / 接口不存在 —— 重试多少次都一样 + "404", "model_not_found", "model not found", "does not exist", + "no such model", "unknown model", "invalid model", +) + + +def is_fatal_api_error(err) -> bool: + """判断是否是"再试也没用"的错误(Key 失效、余额不足等).""" + text = str(err).lower() + return any(m in text for m in FATAL_API_MARKERS) + + +def brief_error(err, limit=70) -> str: + """把冗长的 API 报错压成一句.""" + text = str(err).strip() + low = text.lower() + if "404" in low or "model_not_found" in low or "model not found" in low \ + or "does not exist" in low or "unknown model" in low or "invalid model" in low: + return "模型名不存在(检查配置里的 model)" + if "401" in low or "authentication" in low or "unauthorized" in low: + return "API Key 无效或已失效" + if "402" in low or "insufficient" in low or "quota" in low: + return "账户余额不足" + if "429" in low or "rate limit" in low: + return "请求过于频繁" + if "400" in low or "bad request" in low: + return "请求被服务方拒绝(400,通常是内容审核或参数不支持)" + if "timeout" in low or "timed out" in low: + return "连接超时" + if "connection" in low: + return "网络连接失败" + return text if len(text) <= limit else text[:limit - 1] + "…" + + class Tiku(ABC): - CONFIG_PATH = os.path.join(os.getcwd(), "config.ini") + # 默认配置路径:用户数据目录(由 api.paths 统一管理) + CONFIG_PATH = _paths.config_path() DISABLE = False # 停用标志 SUBMIT = False # 提交标志 COVER_RATE = 0.8 # 覆盖率 @@ -146,18 +201,18 @@ class Tiku(ABC): false_list = None def __init__(self, config_path: Optional[str] = None) -> None: - """ - 初始化题库基类。 - - Args: - config_path: 配置文件路径,若为 None 则使用默认的 CONFIG_PATH。 - """ + """初始化题库基类.""" + # + # Args: + # config_path: 配置文件路径,若为 None 则使用默认的 CONFIG_PATH。 self._name = None self._api = None self._conf = None self._config_path = config_path or self.CONFIG_PATH self.true_list = [] self.false_list = [] + # 熔断状态:一旦出现认证/余额类错误就不再逐个题目重试 + self._fatal_error = None @property def name(self): @@ -189,11 +244,16 @@ def init_tiku(self): if not self._conf: self.config_set(self._get_conf()) if not self.DISABLE: - # 设置提交模式 - self.SUBMIT = True if self._conf['submit'] == 'true' else False - self.COVER_RATE = float(self._conf['cover_rate']) - self.true_list = self._conf['true_list'].split(',') - self.false_list = self._conf['false_list'].split(',') + # 设置提交模式。 + # 用户手写的配置可能缺这些键,缺了就用安全默认值, + # 不要抛 KeyError 让整个程序崩掉。 + self.SUBMIT = str(self._conf.get('submit', 'false')).strip().lower() == 'true' + try: + self.COVER_RATE = float(self._conf.get('cover_rate', 0.9)) + except (TypeError, ValueError): + self.COVER_RATE = 0.9 + self.true_list = (self._conf.get('true_list') or '正确,对,√,是').split(',') + self.false_list = (self._conf.get('false_list') or '错误,错,×,否,不对,不正确').split(',') # 调用自定义题库初始化 self._init_tiku() @@ -202,12 +262,12 @@ def _init_tiku(self): pass def config_set(self, config): + from api.privacy import register_config + register_config(config) self._conf = config def _get_conf(self): - """ - 从默认配置文件查询配置, 如果未能查到, 停用题库 - """ + """从默认配置文件查询配置, 如果未能查到, 停用题库.""" try: config = configparser.ConfigParser() config.read(self._config_path, encoding="utf8") @@ -325,42 +385,96 @@ def query_all(self, q_list: list[dict], query_delay: float = 0.0) -> list[Option @abstractmethod def _query(self, q_info: dict) -> Optional[str]: - """ - 查询接口, 交由自定义题库实现 - """ + """查询接口, 交由自定义题库实现.""" pass def set_work_feedback(self, feedback) -> None: - """ - 设置上一轮章节检测的错误反馈,供支持反馈的大模型题库在重新作答时参考。 - - Args: - feedback: 错误反馈,可以是 str 或 list[str](描述哪些题目答错、正确答案是什么) - """ + """设置上一轮章节检测的错误反馈,供支持反馈的大模型题库在重新作答时参考.""" + # + # Args: + # feedback: 错误反馈,可以是 str 或 list[str](描述哪些题目答错、正确答案是什么) pass def _query_all(self, q_list: list[dict], query_delay: float = 0.0) -> list[Optional[str]]: - """ - 批量查询的实现接口,默认循环调用单个查询 _query。 - 子类若有批量查询或交互需求(如手动模式),可重写此方法。 - """ + """批量查询的实现接口,默认循环调用单个查询 _query.""" + # 子类若有批量查询或交互需求(如手动模式),可重写此方法。 results = [] - for q in q_list: + total = len(q_list) + + # 答题进度显示:避免用户以为程序卡死 + if total > 1: + print() + print(f" 正在作答 {total} 题(题库 + AI,请稍候)") + + skipped_by_breaker = 0 + for i, q in enumerate(q_list, 1): + if self._fatal_error: + # 已经确认答题服务不可用 -> 不再调用 API,也不再重复报错 + results.append(None) + skipped_by_breaker += 1 + continue + + if total > 1: + # 估算剩余时间:平均每题耗时 + self._print_answer_progress(i - 1, total) if query_delay > 0: time.sleep(query_delay) try: results.append(self._query(q)) except Exception as e: - logger.error(f"{self.name} 查询单个题目发生异常: {e}") + if is_fatal_api_error(e): + # 熔断:只说明这一次,后面的题直接跳过,不再反复报错 + self._fatal_error = brief_error(e) + logger.error( + "答题服务不可用:{}\n" + " 本套测验无法作答,剩余题目已跳过。\n" + " 修复后重新运行即可,已完成的任务点不会重复。", + self._fatal_error, + ) + else: + logger.error(f"{self.name} 查询单个题目发生异常: {brief_error(e)}") results.append(None) + + if total > 1: + self._print_answer_progress(total, total) + if skipped_by_breaker: + logger.warning( + "本套 {} 道题中有 {} 道因答题服务不可用被跳过", total, skipped_by_breaker + ) + return results + def _print_answer_progress(self, done, total): + """打印答题进度条(原地刷新).""" + try: + bar_len = 28 + filled = int(bar_len * done / total) if total else 0 + bar = "#" * filled + "-" * (bar_len - filled) + percent = int(done * 100 / total) if total else 0 + elapsed_note = "" + now = time.time() + start = getattr(self, "_answer_start_time", None) + if start is None: + self._answer_start_time = now + start = now + if done > 0: + avg = (now - start) / done + remain = avg * (total - done) + if remain >= 60: + elapsed_note = f" 预计还需 {int(remain // 60)} 分 {int(remain % 60)} 秒" + else: + elapsed_note = f" 预计还需 {int(remain)} 秒" + print(f"\r 答题进度: [{bar}] {done}/{total} {percent}%{elapsed_note} ", end="", flush=True) + if done >= total: + print() + self._answer_start_time = None + except Exception: + pass + @staticmethod def get_tiku_from_config(config: Optional[dict] = None, config_path: Optional[str] = None): - """ - 从配置文件加载题库, 这个配置可以是用户提供, 可以是默认配置文件 - """ + """从配置文件加载题库, 这个配置可以是用户提供, 可以是默认配置文件.""" conf = config path = config_path or Tiku.CONFIG_PATH if not conf: @@ -420,10 +534,8 @@ def get_tiku_from_config(config: Optional[dict] = None, config_path: Optional[st return fallback def judgement_select(self, answer: str) -> bool: - """ - 这是一个专用的方法, 要求配置维护两个选项列表, 一份用于正确选项, 一份用于错误选项, 以应对题库对判断题答案响应的各种可能的情况 - 它的作用是将获取到的答案answer与可能的选项列对比并返回对应的布尔值 - """ + """这是一个专用的方法, 要求配置维护两个选项列表, 一份用于正确选项, 一份用于错误选项, 以应对题库对判断题答案响应的各种可能的情况.""" + # 它的作用是将获取到的答案answer与可能的选项列对比并返回对应的布尔值 if self.DISABLE: return False # 对响应的答案作处理 @@ -447,9 +559,7 @@ def judgement_select(self, answer: str) -> bool: return random.choice([True, False]) def get_submit_params(self): - """ - 这是一个专用方法, 用于根据当前设置的提交模式, 响应对应的答题提交API中的pyFlag值 - """ + """这是一个专用方法, 用于根据当前设置的提交模式, 响应对应的答题提交API中的pyFlag值.""" # 留空直接提交, 1保存但不提交 if self.SUBMIT: return "" @@ -457,10 +567,8 @@ def get_submit_params(self): return "1" def check_llm_connection(self) -> bool: - """ - 检查大模型连接是否可用 - 默认返回 True(非大模型题库不需要检查) - """ + """检查大模型连接是否可用.""" + # 默认返回 True(非大模型题库不需要检查) return True @@ -594,7 +702,7 @@ def _query(self, q_info: dict): if not res_json['code']: # 如果是因为TOKEN次数到期, 则更换token if self._times == 0 or '次数不足' in res_json['data']['answer']: - logger.info(f'TOKEN查询次数不足, 将会更换并重新搜题') + logger.info('TOKEN查询次数不足, 将会更换并重新搜题') self._token_index += 1 self.load_token() # 重新查询 @@ -609,7 +717,7 @@ def _query(self, q_info: dict): return None def load_token(self): - token_list = self._conf['tokens'].split(',') + token_list = (self._conf.get('tokens') or '').split(',') if self._token_index == len(token_list): # TOKEN 用完 logger.error('TOKEN用完, 请自行更换再重启脚本') @@ -831,7 +939,7 @@ def _query(self, q_info: dict = None): # 检查该token是否有余额 if self._balance.get(token, 0) <= 0: - logger.error(f'{self.name}当前Token查询次数不足: ...{token[-5:]}') + logger.error(f'{self.name}当前Token查询次数不足: [redacted]') # 尝试选择其他有余额的token available_tokens = [t for t in self._tokens if self._balance.get(t, 0) > 0] if available_tokens: @@ -849,10 +957,10 @@ def _query(self, q_info: dict = None): try_times += 1 if ans: # 如果查询成功,减少余额 self._balance[token] -= 1 - logger.info(f'使用Token ...{token[-5:]} 查询成功,剩余次数: {self._balance[token]}') + logger.info(f'使用Token [redacted] 查询成功,剩余次数: {self._balance[token]}') break elif try_times < self._retry_times: - logger.warning(f'使用Token ...{token[-5:]} 查询失败,进行第 {try_times + 1} 次重试...') + logger.warning(f'使用Token [redacted] 查询失败,进行第 {try_times + 1} 次重试...') # 10次查询后更新余额 self._count = (self._count + 1) % 10 @@ -862,16 +970,14 @@ def _query(self, q_info: dict = None): return ans def _query_single(self, token: str = "", query: str = "") -> str: - """ - 查询单个问题的答案 - - Args: - token: API访问令牌 - query: 查询的问题内容 - - Returns: - 查询到的答案,如果失败则返回None - """ + """查询单个问题的答案.""" + # + # Args: + # token: API访问令牌 + # query: 查询的问题内容 + # + # Returns: + # 查询到的答案,如果失败则返回None # 验证输入参数 if not token: logger.error(f'{self.name}查询失败: 未提供有效的token') @@ -934,15 +1040,13 @@ def _query_single(self, token: str = "", query: str = "") -> str: return None def _parse_response(self, response): - """ - 解析API响应 - - Args: - response: HTTP响应对象 - - Returns: - 解析后的答案,如果解析失败则返回None - """ + """解析API响应.""" + # + # Args: + # response: HTTP响应对象 + # + # Returns: + # 解析后的答案,如果解析失败则返回None try: res_json = response.json() except json.JSONDecodeError: @@ -981,16 +1085,14 @@ def _parse_response(self, response): return self._extract_answer_by_type(q_type, answer) def _extract_answer_by_type(self, q_type: str, answer: dict) -> str: - """ - 根据题目类型提取答案 - - Args: - q_type: 题目类型 - answer: 答案字典 - - Returns: - 提取的答案文本 - """ + """根据题目类型提取答案.""" + # + # Args: + # q_type: 题目类型 + # answer: 答案字典 + # + # Returns: + # 提取的答案文本 if not isinstance(answer, dict): logger.error(f'{self.name}答案格式错误: 不是有效的字典格式') return None @@ -1079,7 +1181,7 @@ def update_times(self) -> None: balance = self.get_api_balance(token) self._balance[token] = balance logger.info( - f"当前LIKE知识库Token: ...{token[-5:]} 的剩余查询次数为: {balance} (仅供参考, 实际次数以查询结果为准)") + f"当前LIKE知识库Token: [redacted] 的剩余查询次数为: {balance} (仅供参考, 实际次数以查询结果为准)") def load_tokens(self) -> None: tokens_str = self._conf.get('tokens') @@ -1160,7 +1262,34 @@ def _query(self, q_info: dict): def _init_tiku(self): # self.load_token() - self.api = self._conf['url'] + self.api = self._conf.get('url', '') + + +def parse_answer_text(text: str) -> str: + """从模型输出里提取答案正文:兼容 JSON / 代码块 / "答案:X" / 纯文本.""" + # + # 模型有时返回 {"Answer": ["A"]},有时直接写 "答案:A",有时带 markdown 代码块, + # 以前只认第一种,其它情况一律记"无法解析"并退化成随机作答(错率高的直接原因之一)。 + if not text: + return "" + cleaned = llm.strip_code_fence(str(text)) + try: + data = json.loads(cleaned) + except (ValueError, TypeError): + data = None + if isinstance(data, dict): + for key in ("Answer", "answer", "答案", "result", "content"): + if key in data: + data = data[key] + break + if isinstance(data, list): + return "\n".join(str(item) for item in data).strip() + if isinstance(data, str): + return data.strip() + matched = re.search(r"(?:答案|Answer|答)\s*[::]?\s*(.+)", cleaned, re.IGNORECASE | re.DOTALL) + if matched: + return matched.group(1).strip() + return cleaned.strip() class AI(Tiku): @@ -1174,12 +1303,10 @@ def __init__(self, config_path: Optional[str] = None) -> None: self.work_feedback = None # 章节检测错误反馈(重做时参考) def set_work_feedback(self, feedback) -> None: - """ - 设置章节检测上一轮的错误反馈,供重新作答时参考。 - - Args: - feedback: str 或 list[str],描述答错的题目与正确答案 - """ + """设置章节检测上一轮的错误反馈,供重新作答时参考.""" + # + # Args: + # feedback: str 或 list[str],描述答错的题目与正确答案 self.work_feedback = feedback def _build_work_feedback_text(self) -> str: @@ -1197,17 +1324,23 @@ def _build_work_feedback_text(self) -> str: lines.append(str(item)) return "\n".join(lines) - def _is_deepseek_v4(self) -> bool: - return ( - 'api.deepseek.com' in (self.endpoint or '').lower() - and (self.model or '').lower().startswith('deepseek-v4') - ) - - def _completion_kwargs(self, **kwargs): - if self._is_deepseek_v4(): - # DeepSeek V4 defaults to thinking mode, which can leave message.content empty. - kwargs['extra_body'] = {'thinking': {'type': 'disabled'}} - return kwargs + def _client(self): + """按代理配置构造 OpenAI 客户端.""" + if self.http_proxy: + httpx_client = httpx.Client(proxy=self.http_proxy) + return OpenAI(http_client=httpx_client, base_url=self.endpoint, api_key=self.key) + return OpenAI(base_url=self.endpoint, api_key=self.key) + + def _complete(self, messages, **kwargs) -> str: + """统一的答题模型调用:thinking 默认交给模型自己(auto).""" + # + # :DeepSeek V4.1 flash 默认带推理且正文正常, + # 强关 thinking 只会降低正确率;旧版本"正文为空"的情况由 + # api/llm.create_completion 自动降级重试,reasoning_content 也能兜底。 + client = self._client() + return llm.create_completion( + client, model=self.model, messages=messages, + thinking=self.thinking, allow_reasoning_fallback=True, **kwargs) def _wait_for_interval(self): if self.last_request_time: @@ -1222,145 +1355,119 @@ def _query(self, q_info: dict): return self._query_locked(q_info) def _query_locked(self, q_info: dict): - def remove_md_json_wrapper(md_str): - # 使用正则表达式匹配Markdown代码块并提取内容 - pattern = r'^\s*```(?:json)?\s*(.*?)\s*```\s*$' - match = re.search(pattern, md_str, re.DOTALL) - return match.group(1).strip() if match else md_str.strip() - - if self.http_proxy: - proxy = self.http_proxy - httpx_client = httpx.Client(proxy=proxy) - client = OpenAI(http_client=httpx_client, base_url=self.endpoint, api_key=self.key) - else: - client = OpenAI(base_url=self.endpoint, api_key=self.key) - # 去除选项字母,防止大模型直接输出字母而非内容 - options_list = q_info['options'].split('\n') - cleaned_options = [re.sub(r"^[A-Z]\s*", "", option) for option in options_list] - options = "\n".join(cleaned_options) + # 保留选项字母:让模型直接回答 A/B/C,比"回答选项内容再匹配回字母"可靠得多 + options = q_info['options'] # 上一轮章节检测的错误反馈(若有) feedback_text = self._build_work_feedback_text() def _make_messages(system_content: str, user_content: str) -> list: """构造带反馈上下文的消息列表.""" - messages = [ - { - "role": "system", - "content": system_content - }, - ] + messages = [{"role": "system", "content": system_content}] if feedback_text: - messages.append( - { - "role": "system", - "content": feedback_text - } - ) - messages.append( - { - "role": "user", - "content": user_content - } - ) + messages.append({"role": "system", "content": feedback_text}) + messages.append({"role": "user", "content": user_content}) return messages - # 判断题目类型 - self._wait_for_interval() - self.last_request_time = time.time() - if q_info['type'] == "single": - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=_make_messages( - "本题为单选题,你只能选择一个选项,请根据题目和选项回答问题,以json格式输出正确的选项内容,示例回答:{\"Answer\": [\"答案\"]}。除此之外不要输出任何多余的内容,也不要使用MD语法。如果你使用了互联网搜索,也请不要返回搜索的结果和参考资料", - f"题目:{q_info['title']}\n选项:{options}" - ) - )) - elif q_info['type'] == 'multiple': - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=_make_messages( - "本题为多选题,你必须选择两个或以上选项,请根据题目和选项回答问题,以json格式输出正确的选项内容,示例回答:{\"Answer\": [\"答案1\",\n\"答案2\",\n\"答案3\"]}。除此之外不要输出任何多余的内容,也不要使用MD语法。如果你使用了互联网搜索,也请不要返回搜索的结果和参考资料", - f"题目:{q_info['title']}\n选项:{options}" - ) - )) - elif q_info['type'] == 'completion': - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=_make_messages( - "本题为填空题,你必须根据语境和相关知识填入合适的内容,请根据题目回答问题,以json格式输出正确的答案,示例回答:{\"Answer\": [\"答案\"]}。除此之外不要输出任何多余的内容,也不要使用MD语法。如果你使用了互联网搜索,也请不要返回搜索的结果和参考资料", - f"题目:{q_info['title']}" - ) - )) - elif q_info['type'] == 'judgement': - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=_make_messages( - "本题为判断题,你只能回答正确或者错误,请根据题目回答问题,以json格式输出正确的答案,示例回答:{\"Answer\": [\"正确\"]}。除此之外不要输出任何多余的内容,也不要使用MD语法。如果你使用了互联网搜索,也请不要返回搜索的结果和参考资料", - f"题目:{q_info['title']}" - ) - )) + q_type = q_info['type'] + if q_type == "single": + system = ("本题为单选题。请先自己判断,再只输出选项字母,以 json 格式回答," + "例如 {\"Answer\": [\"A\"]};不要输出选项内容、解释或多余文字。") + user = f"题目:{q_info['title']}\n选项:\n{options}" + elif q_type == "multiple": + system = ("本题为多选题。请选出所有正确选项(可能只有 1 个,也可能多个)," + "只输出选项字母,以 json 格式回答,例如 {\"Answer\": [\"A\",\"C\"]};" + "不确定的不要选、不要为了凑数多选,不要输出解释或多余文字。") + user = f"题目:{q_info['title']}\n选项:\n{options}" + elif q_type == "completion": + system = ("本题为填空题。请按空的顺序给出答案,用 # 分隔,以 json 格式回答," + "例如 {\"Answer\": [\"答案1#答案2\"]};不要输出解释或多余文字。") + user = f"题目:{q_info['title']}" + elif q_type == "judgement": + system = ("本题为判断题。只输出 {\"Answer\": [\"正确\"]} 或 {\"Answer\": [\"错误\"]}," + "不要输出解释或多余文字。") + user = f"题目:{q_info['title']}" else: - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=_make_messages( - "本题为简答题,你必须根据语境和相关知识填入合适的内容,请根据题目回答问题,以json格式输出正确的答案,示例回答:{\"Answer\": [\"这是我的答案\"]}。除此之外不要输出任何多余的内容,也不要使用MD语法。如果你使用了互联网搜索,也请不要返回搜索的结果和参考资料", - f"题目:{q_info['title']}" - ) - )) - - try: - response = json.loads(remove_md_json_wrapper(completion.choices[0].message.content)) - sep = "\n" - return sep.join(response['Answer']).strip() - except: + system = ("本题为简答题。请给出简洁准确的答案,以 json 格式回答," + "例如 {\"Answer\": [\"答案\"]};不要输出解释或多余文字。") + user = f"题目:{q_info['title']}" + messages = _make_messages(system, user) + + # 客观题多次采样投票:单次生成偶发看错选项,投票能明显降低错率 + votes = self.objective_votes if q_type in ("single", "multiple") else 1 + answers = [] + for _ in range(max(1, votes)): + self._wait_for_interval() + self.last_request_time = time.time() + try: + raw = self._complete(messages) + except Exception as e: + logger.error(f"{self.name} 调用失败:{e}") + continue + parsed = parse_answer_text(raw) + if parsed: + answers.append(parsed) + if not answers: logger.error("无法解析大模型输出内容") return None + if len(answers) == 1: + return answers[0] + + def _normalize(text): + stripped = str(text).strip() + letters = re.findall(r"[A-Za-z]", stripped) + if letters and re.fullmatch(r"[A-Za-z\s、,,;;/|\n]+", stripped): + return "".join(sorted({c.upper() for c in letters})) + return stripped + + grouped = {} + for item in answers: + grouped.setdefault(_normalize(item), []).append(item) + best_key = max(grouped, key=lambda key: len(grouped[key])) + chosen = grouped[best_key] + if len(grouped) > 1: + logger.info( + "客观题投票:{} 次采样,取多数答案 {}({}/{})", + len(answers), best_key, len(chosen), len(answers), + ) + return chosen[0] def _init_tiku(self): - self.endpoint = self._conf['endpoint'] - self.key = self._conf['key'] - self.model = self._conf['model'] - self.http_proxy = self._conf['http_proxy'] - self.min_interval_seconds = int(self._conf['min_interval_seconds']) + # 手写配置可能缺项,用安全默认值兜底,避免 KeyError + self.endpoint = self._conf.get('endpoint', '') + self.key = self._conf.get('key', '') + self.model = self._conf.get('model', '') + self.http_proxy = self._conf.get('http_proxy', '') + # thinking: auto=让模型自己决定(V4.1 起默认带推理,正确率更高); + # on/off 可强制;老版本"正文为空"由 api/llm 自动降级重试。 + self.thinking = llm.normalize_thinking(self._conf.get('thinking', 'auto')) + try: + self.objective_votes = max(1, min(5, int(float(self._conf.get('objective_votes', 3) or 3)))) + except (TypeError, ValueError): + self.objective_votes = 3 + try: + self.min_interval_seconds = int(float(self._conf.get('min_interval_seconds', 3))) + except (TypeError, ValueError): + self.min_interval_seconds = 3 def check_llm_connection(self) -> bool: - """ - 检查大模型连接是否可用 - 发送一个简单的测试请求来验证 API 配置 - """ + """检查大模型连接是否可用.""" + # 发送一个简单的测试请求来验证 API 配置 with self._lock: - logger.info(f'正在检查 {self.name} 连接...') + logger.debug(f'正在检查 {self.name} 连接...') try: - # 初始化客户端 - if self.http_proxy: - httpx_client = httpx.Client(proxy=self.http_proxy) - client = OpenAI(http_client=httpx_client, base_url=self.endpoint, api_key=self.key) - else: - client = OpenAI(base_url=self.endpoint, api_key=self.key) - # 限流等待 self._wait_for_interval() self.last_request_time = time.time() - # 发送测试请求 - completion = client.chat.completions.create(**self._completion_kwargs( - model=self.model, - messages=[ - { - 'role': 'user', - 'content': '你好,请回答:1+1 等于几?只回答数字。' - } - ], - max_tokens=200 # 增大以支持可能返回的 reasoning_content - )) - - # 统一检查响应 - if completion.choices: - msg = completion.choices[0].message - if msg.content or getattr(msg, 'reasoning_content', None): - logger.info(f'{self.name} 连接检查成功') - return True + # 发送测试请求(thinking 策略与答题一致,reasoning 也能兜底) + text = self._complete( + [{'role': 'user', 'content': '你好,请回答:1+1 等于几?只回答数字。'}], + max_tokens=200, + ) + if text: + logger.info(f'{self.name} 连接正常') + return True logger.error(f'{self.name} 连接检查失败:未收到响应') return False @@ -1463,19 +1570,20 @@ def remove_md_json_wrapper(md_str): def _init_tiku(self): # 从配置文件读取参数 self.api_endpoint = self._conf.get('siliconflow_endpoint', 'https://api.siliconflow.cn/v1/chat/completions') - self.api_key = self._conf['siliconflow_key'] + self.api_key = self._conf.get('siliconflow_key', '') self.model_name = self._conf.get('siliconflow_model', 'deepseek-ai/DeepSeek-V3') - self.min_interval = int(self._conf.get('min_interval_seconds', 3)) + try: + self.min_interval = int(float(self._conf.get('min_interval_seconds', 3))) + except (TypeError, ValueError): + self.min_interval = 3 def check_llm_connection(self) -> bool: - """ - 检查硅基流动大模型连接是否可用 - 发送一个简单的测试请求来验证 API 配置 - """ + """检查硅基流动大模型连接是否可用.""" + # 发送一个简单的测试请求来验证 API 配置 with self._lock: - logger.info(f'正在检查 {self.name} 连接...') + logger.debug(f'正在检查 {self.name} 连接...') try: headers = { 'Authorization': f'Bearer {self.api_key}', @@ -1491,7 +1599,9 @@ def check_llm_connection(self) -> bool: } ], 'stream': False, - 'max_tokens': 10, + # 思考模型会先输出 reasoning_content,正文要更多 token 才出得来。 + # 原来填 10 会把"配置正确"误判成"连接失败"(#603)。 + 'max_tokens': 200, 'temperature': 0.7, 'top_p': 0.7, 'response_format': {'type': 'text'} @@ -1510,12 +1620,16 @@ def check_llm_connection(self) -> bool: if response.status_code == 200: result = response.json() - if result.get('choices') and result['choices'][0]['message']['content']: - logger.info(f'{self.name} 连接检查成功') + choices = result.get('choices') if isinstance(result, dict) else None + message = {} + if choices and isinstance(choices, list) and isinstance(choices[0], dict): + message = choices[0].get('message') or {} + # 思考模型的正文可能在 reasoning_content 里,两种都算成功 + if message.get('content') or message.get('reasoning_content'): + logger.info(f'{self.name} 连接正常') return True - else: - logger.error(f'{self.name} 连接检查失败:未收到有效响应') - return False + logger.error(f'{self.name} 连接检查失败:未收到有效响应') + return False else: logger.error(f'{self.name} 连接检查失败:{response.status_code} {response.text}') return False @@ -1632,7 +1746,12 @@ def _single_query(self, q: dict) -> Optional[str]: print(f"\n【{type_str}】 {q['title']}") while True: - ans = input("请输入答案 (直接回车表示跳过/无答案): ").strip() + try: + ans = input("请输入答案 (直接回车表示跳过/无答案): ").strip() + except EOFError: + # 非交互环境(定时任务/管道)读不到输入,按"跳过"处理,不要抛异常 + print(" [提示] 当前环境读不到键盘输入,本题按跳过处理") + return None if not ans: print(f" [已记录] 题目: {q['title']} ---> 答案: [跳过/随机]") return None @@ -1648,9 +1767,7 @@ def _single_query(self, q: dict) -> Optional[str]: return normalized_ans def _validate_user_input(self, ans: str, q: dict) -> tuple[bool, str]: - """ - 验证用户手动输入的答案是否合规. - """ + """验证用户手动输入的答案是否合规.""" if not ans: return True, "" @@ -1677,9 +1794,7 @@ def _validate_judgement_input(self, ans: str) -> tuple[bool, str]: return True, "" def _validate_choice_input(self, ans: str, q: dict) -> tuple[bool, str]: - """ - 验证选择题手动输入是否合规. - """ + """验证选择题手动输入是否合规.""" options = q.get('options', '') parts = self._parse_options(options) valid_keys = self._extract_valid_keys(parts) @@ -1701,9 +1816,7 @@ def _validate_choice_input(self, ans: str, q: dict) -> tuple[bool, str]: return True, "" def _parse_options(self, options) -> list[str]: - """ - 解析选项. - """ + """解析选项.""" parts = [] if isinstance(options, str): parts = [o.strip() for o in options.split('\n') if o.strip()] @@ -1717,9 +1830,7 @@ def _parse_options(self, options) -> list[str]: return parts def _extract_valid_keys(self, parts: list[str]) -> list[str]: - """ - 提取合法的选项字母. - """ + """提取合法的选项字母.""" valid_keys = [] for p in parts: first_char = p[:1].upper() @@ -1728,9 +1839,7 @@ def _extract_valid_keys(self, parts: list[str]) -> list[str]: return valid_keys def _validate_text_match(self, ans: str, parts: list[str]) -> tuple[bool, str]: - """ - 验证用户输入的文本是否和选项文本匹配. - """ + """验证用户输入的文本是否和选项文本匹配.""" from api.answer_check import cut split_ans = cut(ans) if split_ans: @@ -1746,9 +1855,7 @@ def _validate_text_match(self, ans: str, parts: list[str]) -> tuple[bool, str]: return True, "" def _normalize_user_input(self, ans: str, q: dict) -> Optional[str]: - """ - 规整化用户的手动输入答案. - """ + """规整化用户的手动输入答案.""" if not ans: return None @@ -1764,9 +1871,7 @@ def _normalize_user_input(self, ans: str, q: dict) -> Optional[str]: return ans def _normalize_judgement_input(self, ans: str) -> str: - """ - 规整化判断题的手动输入. - """ + """规整化判断题的手动输入.""" val = ans.lower() if val in ['true', 't', '1', '对', '正确', '√', '是', 'yes', 'y']: return "正确" @@ -1775,9 +1880,7 @@ def _normalize_judgement_input(self, ans: str) -> str: return ans def _normalize_choice_input(self, ans: str, q: dict) -> str: - """ - 规整化选择题的手动输入. - """ + """规整化选择题的手动输入.""" options = q.get('options', '') parts = self._parse_options(options) valid_keys = self._extract_valid_keys(parts) @@ -1797,9 +1900,7 @@ def _normalize_choice_input(self, ans: str, q: dict) -> str: return ans def _batch_query_flow(self, q_list: list[dict]) -> list[Optional[str]]: - """ - 执行批量手动搜题交互. - """ + """执行批量手动搜题交互.""" self._print_batch_questions(q_list) sep_desc = self.separator @@ -1823,7 +1924,12 @@ def _batch_query_flow(self, q_list: list[dict]) -> list[Optional[str]]: ans = "" answers.append(ans) else: - raw_input = input(f"\n请一次性输入所有题目的答案 (使用 '{sep_desc}' 分割): ").strip() + try: + raw_input = input(f"\n请一次性输入所有题目的答案 (使用 '{sep_desc}' 分割): ").strip() + except EOFError: + # 非交互环境读不到输入:按"全部跳过"处理(与直接回车一致),不要死循环 + print(" [提示] 当前环境读不到键盘输入,本次测验按未作答处理") + return [None] * len(q_list) answers = self._split_batch_answers(raw_input, len(q_list)) has_error, temp_answers = self._parse_and_validate_batch(q_list, answers) @@ -1832,7 +1938,12 @@ def _batch_query_flow(self, q_list: list[dict]) -> list[Optional[str]]: print("\033[31m检测到存在不合规的答案,已拒绝确认,请重新输入!\033[0m") continue - confirm = input("确认使用上述答案?[Y/n]: ").strip().lower() + try: + confirm = input("确认使用上述答案?[y/n]: ").strip().lower() + except EOFError: + # 同上:读不到确认就按已校验通过的答案继续,避免死循环 + print(" [提示] 当前环境读不到键盘输入,已直接采用上述答案") + return temp_answers if confirm in ['', 'y', 'yes']: return temp_answers elif confirm == 'switch': diff --git a/api/base.py b/api/base.py index 3f726c363..8da4c8594 100644 --- a/api/base.py +++ b/api/base.py @@ -1,15 +1,16 @@ # -*- coding: utf-8 -*- import functools +import json import random import secrets import re +from html import unescape import threading import time from difflib import SequenceMatcher from enum import Enum, IntEnum from hashlib import md5 from typing import Optional, Literal -from typing_extensions import Self import requests from loguru import logger @@ -32,6 +33,19 @@ ) +# 验证码冷却:连续识别失败后,短时间内不再对每个任务点硬撞验证码 +_CAPTCHA_COOLDOWN_SECONDS = 60 +_captcha_cooldown_until = 0.0 + + +def _short_title(text, limit: int = 24) -> str: + """进度条上的任务名截断:长文件名会把整行撑爆,这里统一收短.""" + name = str(text or "").strip() + if len(name) <= limit: + return name + return name[: limit - 1] + "…" + + def get_timestamp(): return str(int(time.time() * 1000)) @@ -46,6 +60,15 @@ def __new__(cls, *args, **kwargs): return cls._instance def __init__(self): + # 单例只需初始化一次。 + # 注意:__new__ 返回单例后 __init__ 仍会被调用,若不拦截, + # 每次 get_session() 都会重建 Session 并从 cookie 文件重新加载登录态, + # 导致「cookie 文件丢失 = 登录态丢失 = 抛 Cannot get uid 崩溃」。 + """Initialize configuration and runtime state.""" + if getattr(self, "_initialized", False): + return + self._initialized = True + self._session = requests.Session() self._session.mount("https://", HTTPAdapter(max_retries=10)) self._session.mount("http://", HTTPAdapter(max_retries=10)) @@ -57,18 +80,27 @@ def __init__(self): self._session.cookies.update(use_cookies()) @classmethod - def get_instance(cls) -> Self: + def get_instance(cls) -> "SessionManager": return cls() @classmethod def get_session(cls) -> requests.Session: + """返回同一个 Session 实例(不会重建).""" instance = cls.get_instance() return instance._session @classmethod def update_cookies(cls): + """把磁盘上的 cookie 合并进当前 session(不清空已有的).""" cls.get_instance()._session.cookies.update(use_cookies()) + @classmethod + def reset(cls): + """显式重置会话(仅在确实需要全新会话时调用).""" + inst = cls.get_instance() + inst._initialized = False + inst.__init__() + @classmethod def relogin_if_needed(cls, chaoxing_instance) -> bool: with cls._login_lock: @@ -95,12 +127,17 @@ class Account: isSuccess = None def __init__(self, _username, _password): + """Initialize configuration and runtime state.""" + from api.privacy import register_secret + register_secret(_username) + register_secret(_password) self.username = _username self.password = _password class RateLimiter: def __init__(self, call_interval): + """Initialize configuration and runtime state.""" self.last_call = time.time() self.lock = threading.Lock() self.call_interval = call_interval @@ -144,10 +181,85 @@ class ActivityType(IntEnum): SIGNIN = 2 +# 填空题的题型代码(2 = 普通填空,10 = 新版填空) +_COMPLETION_TYPE_CODES = frozenset({"2", "10"}) + + +def _positive_int(value, default=0) -> int: + try: + parsed = int(str(value).strip()) + except (TypeError, ValueError): + return default + return parsed if parsed > 0 else default + + +def split_completion_answer(answer, expected_count=0) -> list: + """把填空题答案拆成"每个空一个值".""" + # + # 题库返回的多个空一般用 # 或换行分隔,但答案本身也可能含 # (比如 C#), + # 所以: + # · 网页明确写了空数时,只按这个数量切(1 个空就整段不切) + # · 没写空数时才按 # / 换行切 + if answer is None: + return [] + + if isinstance(answer, (list, tuple)): + items = [str(item).strip() for item in answer if str(item).strip()] + if expected_count == 1: + return ["\n".join(items)] if items else [] + if expected_count > 1 and len(items) > expected_count: + return items[:expected_count - 1] + ["\n".join(items[expected_count - 1:])] + return items + + text = str(answer).replace("\r\n", "\n").replace("\r", "\n").strip() + if not text: + return [] + if expected_count == 1: + # 网页只有一个空:整段都是这一空的答案,不能按 # 拆(例如 "C# 语言") + return [text] + + if expected_count > 1: + # 网页写了空数:按空数切,多的部分并进最后一空 + max_split = expected_count - 1 + pattern = r"[\n#]" + else: + # 网页没写空数:按换行 / # 切,能切出几段就当几个空 + max_split = 0 + pattern = r"[\n#]" + + return [piece.strip() for piece in re.split(pattern, text, maxsplit=max_split) if piece.strip()] + + +def build_completion_fields(form: dict, question: dict): + """填空题按空提交(#615 / #575).""" + # + # 学习通要求填空题提交 answerEditor{题目id}{第几空}(从 1 开始), + # 并用 tiankongsize{题目id} 声明空数;只发 answer{题目id} 的话, + # 网页端会显示"答案为空",测验永远不及格。 + # 非填空题原样返回,不做任何改动。 + question_id = str(question.get("id") or "") + if not question_id: + return + + answer_field = question.get("answerField") or {} + answer_type = str(answer_field.get(f"answertype{question_id}", "")) + if question.get("type") != "completion" and answer_type not in _COMPLETION_TYPE_CODES: + return + + # 已经在上面按 cover/随机 的规则算好了该提交什么,直接取用 + answer = form.get(f"answer{question_id}", "") + declared = _positive_int(form.get(f"tiankongsize{question_id}")) + parts = split_completion_answer(answer, expected_count=declared) + blank_count = declared or max(len(parts), 1) + + form.pop(f"answer{question_id}", None) + form[f"tiankongsize{question_id}"] = blank_count + for index in range(1, blank_count + 1): + form[f"answerEditor{question_id}{index}"] = parts[index - 1] if index <= len(parts) else "" + + def multi_cut(answer: str, origin_html_content="", logger=logger): - """ - 将多选题答案字符串按特定字符进行切割, 并返回切割后的答案列表 - """ + """将多选题答案字符串按特定字符进行切割, 并返回切割后的答案列表.""" res = cut(answer) if res is None: logger.warning( @@ -164,12 +276,55 @@ def clean_res(res): if isinstance(res, str): res = [res] for c in res: + text = str(c).strip() + if re.fullmatch(r"[A-Za-z]{2,}", text): + # 纯字母串("AC" / "ABD")是"多个选项字母",不是"A. 选项内容"这种前缀。 + # 以前会把首字母当编号删掉,导致漏选("AC"->"C") + # 或者整题匹配失败转随机("ABD"->"BD")(#427 / #502) + cleaned_res.append(text) + continue # 仅在字符串长度大于1时才尝试去除开头的字母编号,防止误删单个字母答案 cleaned = re.sub(r'^[A-Za-z]\s*[.、::)?)]?\s*|[.,!?;:,。!?;:]', '', c) if len(c) > 1 else c cleaned_res.append(cleaned.strip()) return cleaned_res +def build_multiple_answer(res, options, origin_html_content="") -> str: + """把题库返回的多选答案转成"要提交的选项字母串".""" + # + # 题库返回的形式很杂: + # "ABD" -> 直接就是字母 + # "A,B,D" / "A、B、D" -> 带分隔符的字母 + # "选项一的文字#选项二" -> 只能按文字匹配回字母 + # 返回空串表示一个都没匹配上(调用方会退化成随机作答)。 + options_list = multi_cut(options, origin_html_content) + res_list = multi_cut(res, origin_html_content) + if res_list is None or options_list is None: + return "" + + answer = "" + for item in clean_res(res_list): + # 纯字母串("AC" / "ABD")就是选项字母,逐个采用(#427 / #502) + if re.fullmatch(r"[A-Za-z]{2,}", item): + answer += item.upper() + continue + + matched = False + for option in options_list: + if is_subsequence(item, option): + # 去掉各种符号和前面ABCD之后,答案应当是选项的子序列 + answer += option[:1] + matched = True + break # 找到匹配项后立即停止,防止重复添加 + if not matched: + best_letter = best_option_by_similarity(item, options_list, threshold=0.8) + if best_letter: + answer += best_letter + + # 对答案进行排序, 否则会提交失败 + return "".join(sorted(set(answer))) + + def normalize_text(text: str) -> str: if not isinstance(text, str): text = str(text) @@ -276,20 +431,18 @@ def random_answer(options: str, q_type: str) -> str: # 判断题处理 elif q_type == "judgement": answer = "true" if random.choice([True, False]) else "false" - logger.info(f"随机选择 -> {answer}") + logger.trace(f"随机选择 -> {answer}") return answer def _parse_work_record_list(html_text: str) -> list[tuple[int, float]]: - """ - 解析章节检测作答记录列表页面(/work/record-list)。 - - Args: - html_text: record-list 页面 HTML - - Returns: - 作答记录列表,元素为 (作答序号times, 成绩score),例如 [(0, 80.0), (1, 100.0)] - """ + """解析章节检测作答记录列表页面(/work/record-list).""" + # + # Args: + # html_text: record-list 页面 HTML + # + # Returns: + # 作答记录列表,元素为 (作答序号times, 成绩score),例如 [(0, 80.0), (1, 100.0)] records = [] times_list = re.findall(r'viewNum">第(\d+)次', html_text) scores = re.findall(r'viewScore">([\d.]+)分', html_text) @@ -306,15 +459,13 @@ def _parse_work_record_list(html_text: str) -> list[tuple[int, float]]: def _parse_work_record_detail(html_text: str) -> list[dict]: - """ - 解析章节检测单次作答详情页面(/work/record-detail)。 - - Args: - html_text: record-detail 页面 HTML - - Returns: - 每题信息列表:{id, title, type_label, my_answer, correct_answer} - """ + """解析章节检测单次作答详情页面(/work/record-detail).""" + # + # Args: + # html_text: record-detail 页面 HTML + # + # Returns: + # 每题信息列表:{id, title, type_label, my_answer, correct_answer} questions = [] for qm in re.finditer(r'