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'
]*>(.*?)(?=
None: + """把平台在任务引擎上下文里下发的章节同步数据暂存到 owner 上(没有就保持原值).""" + # + # 任务引擎的"章节"任务点在网页上的同步链路是:视频打点 / job/document + # 的响应里带 stuJobInfo,章节页把它 postMessage 给任务中心父页面, + # 父页面再 POST autoPullChapterScore。这里的 stuJobInfo 就是那个 + # 唯一真实的请求体来源,不能自己拼 enc。 + if not isinstance(payload, dict): + return + info = payload.get("stuJobInfo") + if isinstance(info, dict) and info: + owner.last_student_job_info = info + + +class _CurlResponse: + """Curl 重放请求的返回值,接口和 requests.Response 保持最小兼容.""" + + def __init__(self, status_code: int, text: str, url: str): + """Initialize configuration and runtime state.""" + self.status_code = status_code + self.text = text + self.url = url + + def json(self): + return json.loads(self.text) + + +def _curl_config_value(value): + """Escape a single curl config value and reject control characters.""" + value = str(value) + if any(ord(char) < 32 or ord(char) == 127 for char in value): + raise ValueError("curl config values must not contain control characters") + return value.replace("\\", "\\\\").replace('"', '\\"') + + +def _curl_get(session, url, params, headers=None, timeout: int = 20): + """用系统 curl 原样重放一次 GET(cookie 走 stdin,不进命令行参数).""" + # + # 存在的意义:部分网络环境下 urllib3/OpenSSL 的 TLS 指纹会被超星风控在 + # mooc 视频打点接口上拒绝,返回 403 错误页;同一时刻用相同的 URL、查询参数、 + # Cookie、User-Agent 走 curl(SecureTransport/LibreSSL)却是 200()。 + # 所以这里只在 requests 拿到 403 时做一次等价重放,不影响正常环境。 + import shutil + import subprocess # nosec B404 - trusted curl, fixed argv, no shell + + curl = shutil.which("curl") + if not curl: + logger.debug("系统里没有 curl,跳过视频打点的 curl 重放") + return None + try: + prepared_url = requests.Request("GET", url, params=params).prepare().url + except Exception as e: # pragma: no cover - 构造 URL 失败极少见 + logger.debug("curl 重放前构造 URL 失败: {}", e) + return None + + try: + config_lines = [ + 'url = "%s"' % _curl_config_value(prepared_url), + "silent", + "show-error", + "max-time = %d" % int(timeout), + 'write-out = "\\n%{http_code}"', + ] + for key, value in (headers or {}).items(): + config_lines.append('header = "%s"' % _curl_config_value(f"{key}: {value}")) + cookie = "; ".join(f"{k}={v}" for k, v in session.cookies.items()) + if cookie: + config_lines.append('cookie = "%s"' % _curl_config_value(cookie)) + except ValueError: + logger.warning("curl 重放参数含控制字符,已拒绝") + return None + + try: + proc = subprocess.run( # nosec B603 - resolved curl, fixed argv; validated config via stdin + [curl, "-K", "-"], + input="\n".join(config_lines), + capture_output=True, + text=True, + timeout=int(timeout) + 10, + ) + except Exception as e: + logger.debug("curl 重放视频打点失败: {}", e) + return None + + out = proc.stdout or "" + body, sep, status = out.rpartition("\n") + if not sep: + logger.debug("curl 重放输出没有状态码: {}", out[:200]) + return None + try: + code = int(status.strip()) + except ValueError: + logger.debug("curl 重放状态码解析失败: {}", status[:50]) + return None + return _CurlResponse(code, body, prepared_url) + + +def _parse_progress_passed(resp, owner=None) -> bool: + """解析视频进度上报响应里的 isPassed.""" + # + # 上报接口被风控时可能返回 200 + 登录页/验证码页(不是 JSON), + # 或者 JSON 里没有 isPassed;以前直接取下标会抛异常把整个章节中断(#175 / #298), + # 这里统一按"还没通过"处理。 + # + # 顺带把平台下发的任务引擎同步数据(stuJobInfo)记到 owner 上。 + try: + payload = resp.json() + except ValueError: + logger.warning("视频进度上报返回的不是 JSON(可能被风控或需要验证码),按未通过处理") + return False + if not isinstance(payload, dict): + logger.warning("视频进度上报返回格式异常,按未通过处理") + return False + if owner is not None: + capture_student_job_info(owner, payload) + return bool(payload.get("isPassed", False)) + + +def _clean_answer_text(text) -> str: + """去掉答案里的 HTML 标签、实体和特殊空白.""" + value = re.sub(r"<[^>]+>", "", str(text or "")) + value = unescape(value) + value = value.replace("\u00a0", " ").replace("\u3000", " ") + return value.translate(_FULLWIDTH_MAP).strip() + + +def _letters_key(text) -> str: + """多选答案只比较字母集合:ABD / A,B,D / b,a,d 都算一样.""" + return "".join(sorted(set(re.findall(r"[A-Za-z]", str(text or "").upper())))) + + +def _judge_key(text) -> str: + """判断题归一化成 对/错.""" + squeezed = re.sub(r"[\s。.、,,;;::]", "", _clean_answer_text(text)).lower() + if squeezed in _TRUE_WORDS: + return "T" + if squeezed in _FALSE_WORDS: + return "F" + return squeezed + + +def answers_equal(my_answer, correct_answer, type_label="") -> bool: + """判断"我的答案"和"正确答案"是否一致.""" + # + # 页面上这两种写法的格式经常不一样(判断题 对/√、多选 ABD/A,B,D、 + # 填空里空格和分号混用),直接做字符串比较会把答对的判成答错, + # 导致明明通过了还要重做,最后甚至被记成失败(#627)。 + mine = _clean_answer_text(my_answer) + right = _clean_answer_text(correct_answer) + if not mine or not right: + return mine == right + if mine == right: + return True + + label = str(type_label or "") + if "判断" in label: + return _judge_key(mine) == _judge_key(right) + if "多选" in label: + key_mine = _letters_key(mine) + return bool(key_mine) and key_mine == _letters_key(right) + + # 其它题型:把各种分隔符统一成 |,忽略句读和全半角差异。 + # 注意不能直接把分隔符删掉:"C#" 和 "C" 删完就一样了,会误判成答对。 + def squeeze(value): + value = re.sub(r"""[\s#||,,、;;::]+""", "|", value) + value = re.sub(r"""[。.!!??()()【】\[\]"“”'’]+""", "", value) + # 不把首尾分隔符删掉:"C#" 和 "C" 删完会变成同一个字符串,那就把错的判成对了 + return value.lower() + + squeezed_mine = squeeze(mine) + return bool(squeezed_mine) and squeezed_mine == squeeze(right) + + +def evaluate_work_detail(detail) -> dict: + """逐题比较"我的答案"和"正确答案"(写法差异由 answers_equal 归一化).""" + # + # 返回 {"all_correct": bool, "feedback": [...], "unjudgeable": bool} + # + # unjudgeable=True 表示所有"不一致"的题目里,我们这边的答案是空的 —— + # 也就是页面根本没渲染出"我的答案"(可能只给了图标)。这种情况判定不可信, + # 调用方要按"拿不到成绩"处理,不能当成答错去重做(#627)。 + feedback = [] + all_correct = True + mismatched = 0 + empty_mine = 0 + unknown = 0 + + for q in detail: + if not q.get("parse_ok", True): + unknown += 1 + all_correct = False + continue + my_ans = (q.get("my_answer") or "").strip() + correct_ans = (q.get("correct_answer") or "").strip() + if answers_equal(my_ans, correct_ans, q.get("type_label")): + continue + all_correct = False + mismatched += 1 + if not my_ans: + empty_mine += 1 + feedback.append( + f"- 题目:{q.get('title', '')}\n" + f" 题型:{q.get('type_label', '')}\n" + f" 你的上次答案:{my_ans or '(空)'}\n" + f" 正确答案:{correct_ans or '(空)'}" + ) + + return { + "all_correct": all_correct, + "feedback": feedback, + "unjudgeable": bool(mismatched) and empty_mine == mismatched, + "unknown": unknown, + } _JUDGE_TRUE_SET = {'TRUE', 'T', '1', '对', '正确', '√', '是', 'YES', 'Y'} _JUDGE_FALSE_SET = {'FALSE', 'F', '0', '错', '错误', '×', 'X', '否', 'NO', 'N', '不对', '不正确'} def normalize_answer_text(ans) -> str: - """作答详情答案归一化: 消除 对/错与true/false、全半角标点等格式差异. - - 归一化是确定性的, 两侧同格式必然相等; 跨格式差异(如字母 vs 选项全文) - 交由调用方的满分分数兜底处理. - """ + """作答详情答案归一化: 消除 对/错与true/false、全半角标点等格式差异.""" + # + # 归一化是确定性的, 两侧同格式必然相等; 跨格式差异(如字母 vs 选项全文) + # 交由调用方的满分分数兜底处理. s = re.sub(r'\s+', '', str(ans or '')).upper() if s in _JUDGE_TRUE_SET: return 'TRUE' @@ -382,6 +755,7 @@ def normalize_answer_text(ans) -> str: class Chaoxing: def __init__(self, account: Account = None, tiku: Tiku = None, **kwargs): + """Initialize configuration and runtime state.""" self.account = account self.cipher = AESCipher() self.tiku = tiku @@ -389,12 +763,23 @@ def __init__(self, account: Account = None, tiku: Tiku = None, **kwargs): self.rollback_times = 0 self.rate_limiter = RateLimiter(0.5) # 其他接口速率限制比较松 self.video_log_limiter = RateLimiter(2) # 上报进度极其容易卡验证码,限制2s一次 + # 任务引擎的"章节"任务点:平台在视频/文档完成后,会把给任务引擎的 + # 同步数据(uid/finishCount/clazzId/enc/time/jobCount/knowledgeId) + # 塞在视频打点或 /mooc-ans/job/document 的响应里(字段名 stuJobInfo)。 + # 只有从任务引擎打开的章节页(isEngineNode=1)才会下发,这里暂存给上层做同步。 + self.last_student_job_info = None def login(self, login_with_cookies=False): + # 关键:把当前账号告诉 cookie 模块,之后 cookie 读写都落到该账号专属文件, + # 避免多账号之间互相覆盖(串号)。 + if self.account and self.account.username: + from api.cookies import set_current_account + set_current_account(self.account.username) + if login_with_cookies: logger.info("Logging in with cookies") SessionManager.update_cookies() - logger.debug(f"Logged in with cookies: {SessionManager.get_instance()._session.cookies}") + logger.debug("Cookie session loaded") if not self._validate_cookie_session(): logger.warning("Cookie 登录校验失败,尝试使用账号密码重新登录") if self.account and self.account.username and self.account.password: @@ -423,8 +808,25 @@ def login(self, login_with_cookies=False): "independentId": 0, } logger.trace("正在尝试登录...") - resp = _session.post(_url, headers=gc.HEADERS, data=_data) - if resp and resp.json()["status"] == True: + # 登录接口一定要带超时:以前没带,服务器卡住时表现为 + # "输入完密码后没反应",进程会一直挂着(#163 / #220) + try: + resp = _session.post(_url, headers=gc.HEADERS, data=_data, timeout=15) + except RequestException as e: + return {"status": False, "msg": f"连接登录服务器失败({type(e).__name__}),请检查网络后重试"} + + # 风控/验证码情况下返回的可能不是 JSON,或者 JSON 里没有 status/msg2, + # 以前直接取下标会抛 JSONDecodeError / KeyError(#164),这里统一兜底 + try: + payload = resp.json() + except ValueError: + logger.warning("登录接口返回的不是 JSON(可能被风控或需要验证码),状态码: {}", resp.status_code) + return {"status": False, "msg": "登录接口返回异常(可能需要验证码或触发了风控),请稍后重试"} + + if not isinstance(payload, dict): + return {"status": False, "msg": "登录接口返回格式异常,请稍后重试"} + + if payload.get("status") is True: save_cookies(_session) SessionManager.update_cookies() logger.info("登录成功...") @@ -435,8 +837,8 @@ def login(self, login_with_cookies=False): except Exception as e: logger.debug(f"获取当前登录用户名失败: {e}") return {"status": True, "msg": "登录成功"} - else: - return {"status": False, "msg": str(resp.json()["msg2"])} + + return {"status": False, "msg": str(payload.get("msg2") or "登录失败,请检查手机号 / 密码")} @staticmethod def get_name() -> str: @@ -516,8 +918,14 @@ def get_course_list(self): "query": "", "superstarClass": 0, } - _resp = _session.post(_url, data=_data) - course_list += decode_course_list(_resp.text) + # 和上面首个请求一样带上 Referer,否则接口容易返回非课程列表页, + # 目录里的课程会被静默漏掉(#313 / #417) + _resp = _session.post(_url, headers=_headers, data=_data) + folder_courses = decode_course_list(_resp.text) + if not folder_courses: + logger.warning("课程目录《{}》没有解析到课程,已跳过", + folder.get("rename", folder.get("id", ""))) + course_list += folder_courses return course_list def get_activity_list(self, course: dict) -> list[dict]: @@ -606,7 +1014,8 @@ def get_course_point(self, _courseid, _clazzid, _cpi): _resp = _session.get(_url) logger.trace(f"原始章节列表内容:\n{_resp.text}") - logger.info("课程章节读取成功...") + # 章节读取成功的提示交给 main.py 统一输出(一行汇总,避免刷屏) + logger.trace("课程章节读取成功...") return decode_course_point(_resp.text) def get_job_list(self, course: dict, point: dict) -> tuple[list[dict], dict]: @@ -625,6 +1034,9 @@ def get_job_list(self, course: dict, point: dict) -> tuple[list[dict], dict]: } # 学习界面任务卡片数, 很少有3个的, 但是对于章节解锁任务点少一个都不行, 可以从API /mooc-ans/mycourse/studentstudyAjax获取值, 或者干脆直接加, 但二者都会造成额外的请求 + parsed_any = False + _page0_parse_error = False + _missing_pages = [] for _possible_num in "0123456": logger.trace("开始读取章节所有任务点...") @@ -632,24 +1044,79 @@ def get_job_list(self, course: dict, point: dict) -> tuple[list[dict], dict]: cards_params.update({"num": _possible_num}) _resp = _session.get("https://mooc1.chaoxing.com/mooc-ans/knowledge/cards", params=cards_params) if _resp.status_code != 200: - logger.error(f"未知错误: {_resp.status_code} 正在跳过") - logger.error(_resp.text) - return [], {} + # 返回 None 表示"没读到",和"这一章本来就空"是两回事 + logger.error(f"章节任务点读取失败: HTTP {_resp.status_code}") + logger.debug(_resp.text[:500]) + return None, {} _job_list, _job_info = decode_course_card(_resp.text) if _job_info.get("notOpen", False): # 直接返回, 节省一次请求 logger.info("该章节未开放") return [], _job_info + if _job_info.get("parseError"): + # 新版泛雅把 num>=1 的页面改成 mArg = $mArg(由脚本注入), + # 页面里没有可解析的 JSON。这种页面跳过就行,不能因为它 + # 把整章判成"读取失败",否则新版课程一个任务点都刷不了。 + # + # 日志分级:num=0 失败才是真正的异常信号(登录失效/验证码/改版), + # num>=1 失败是每章都会发生的正常形态,只记 TRACE,避免刷屏误导。 + if _possible_num == "0": + _page0_parse_error = True + logger.warning( + "任务点第 0 页解析不出 mArg(可能是登录失效、验证码页或页面改版)" + ) + else: + _missing_pages.append(_possible_num) + continue + parsed_any = True job_list += _job_list job_info.update(_job_info) + if _missing_pages: + # 每章汇总成一条 DEBUG,不再逐页刷屏(新版 num>=1 本来就没有 JSON) + logger.debug( + "任务点第 {} 页无 mArg(新版只有第 0 页带全量),已跳过", + "、".join(_missing_pages), + ) + + # 一页都没解析出来才算读取失败(登录页 / 验证码页 / 彻底改版) + if not parsed_any: + return None, {"parseError": True} + if _page0_parse_error: + logger.warning( + "任务点第 0 页没解析出 mArg,但后续页有数据;下次整章读不到任务点时先检查登录状态" + ) + + # 同一批卡片可能跨页重复(新版 num=0 就带全量),按 jobid 去重 + seen_ids = set() + unique_jobs = [] + for _job in job_list: + _key = str(_job.get("jobid") or _job.get("id") or _job) + if _key in seen_ids: + continue + seen_ids.add(_key) + unique_jobs.append(_job) + job_list = unique_jobs + + unknown_types = job_info.get("unknownCardTypes") or [] + if unknown_types: + # 铁律 1:不认识的卡片不能当成"已完成",宁可报读取失败让人来看 + logger.error( + "章节 [{}] 出现未知任务点类型 {}:为避免把未完成记成完成,按读取失败处理", + point.get("title", ""), "、".join(str(t) for t in unknown_types), + ) + return None, job_info + if not job_list: - self.study_emptypage(course, point) + # 空章节也要把"访问"这一步做成功才算完成;失败同样按读取失败处理 + empty_result = self.study_emptypage(course, point) + if empty_result is not None and empty_result.is_failure(): + logger.error("空页面任务未完成,按读取失败处理: {}", point.get("title", "")) + return None, job_info - logger.trace(f"原始任务点列表内容:\n{_resp.text}") - logger.info("章节任务点读取成功...") + logger.trace("章节任务点读取成功...") return job_list, job_info @@ -670,6 +1137,7 @@ def video_progress_log( _type: str = "Video", _isdrag: int = 3, headers: Optional[dict] = None, + engine_info: bool = False, ) -> tuple[bool, int]: if headers is None: @@ -698,6 +1166,10 @@ def video_progress_log( "enc": enc, "dtype": _type } + # 任务引擎的"章节"任务点要求带上 courseEngineInfo=true, + # 章节刷完时平台才会在响应里下发 stuJobInfo(见类初始化里的说明)。 + if engine_info: + params["courseEngineInfo"] = "true" _url = ( f"https://mooc1.chaoxing.com/mooc-ans/multimedia/log/a/" @@ -719,8 +1191,26 @@ def video_progress_log( def perform_request(rt_val): params.update({"rt": rt_val, "_t": get_timestamp()}) res = _session.get(_url, params=params, headers=headers) + if res.status_code == 403: + # 少数网络环境下 urllib3/OpenSSL 会被这个接口的风控按客户端指纹拒绝 + # (403 + 错误页),同一参数走 curl 或浏览器都是 200。先原样重放一次, + # 重放成功就不算失败;重放也失败再走下面的验证码/403 分支。 + curl_res = _curl_get(_session, _url, params, headers) + if curl_res is not None and curl_res.status_code == 200: + logger.info( + "视频打点被客户端指纹拦截,已用 curl 重放成功: jobid={}", + _job.get("jobid"), + ) + res = curl_res + elif curl_res is not None: + logger.debug("curl 重放视频打点仍然失败: HTTP {}", curl_res.status_code) if res.status_code == 403 or '验证码' in res.text or 'validate' in res.text: - logger.warning("检测到验证码拦截,正在尝试自动通过验证码...") + global _captcha_cooldown_until + remain = _captcha_cooldown_until - time.time() + if remain > 0: + logger.debug("验证码冷却中,等待 {:.0f} 秒再试", remain) + time.sleep(min(remain, _CAPTCHA_COOLDOWN_SECONDS)) + logger.warning("触发验证码,正在自动识别…") try: from api.captcha import CxCaptcha cookies_str = "; ".join([f"{k}={v}" for k, v in _session.cookies.items()]) @@ -734,19 +1224,23 @@ def perform_request(rt_val): captcha_solver = CxCaptcha(user_agent=ua, cookies=cookies_str, ocr=ocr_inst) solved = False for attempt in range(3): - logger.info(f"第 {attempt + 1} 次尝试通关验证码...") + logger.debug("第 {} 次尝试通关验证码…", attempt + 1) if captcha_solver.try_pass(): - logger.success("验证码通关成功!") + logger.info("验证码已通过") solved = True break else: - logger.warning("验证码验证失败,正在重试...") + logger.debug("验证码识别失败,重试中…") time.sleep(2) if solved: _session.cookies.update(captcha_solver.s.cookies) res = _session.get(_url, params=params, headers=headers) else: - logger.error("多次验证码通关失败,可能需要手动干预。") + _captcha_cooldown_until = time.time() + _CAPTCHA_COOLDOWN_SECONDS + logger.warning( + "验证码多次识别失败,该任务点先跳过;{} 秒内不再重试验证码(稍后自动重试)", + _CAPTCHA_COOLDOWN_SECONDS, + ) except Exception as e: logger.error(f"验证码通关逻辑异常: {e}") return res @@ -769,7 +1263,7 @@ def perform_request(rt_val): resp = perform_request(rt) if resp.status_code == 200: logger.trace(resp.text) - return resp.json()["isPassed"], 200 + return _parse_progress_passed(resp, owner=self if engine_info else None), 200 elif resp.status_code == 403: logger.warning("出现403报错, 正常尝试切换rt") else: @@ -781,7 +1275,7 @@ def perform_request(rt_val): if resp.status_code == 200: logger.trace(resp.text) - return resp.json()["isPassed"], 200 + return _parse_progress_passed(resp, owner=self if engine_info else None), 200 elif resp.status_code == 403: logger.debug( @@ -791,14 +1285,14 @@ def perform_request(rt_val): ) # 若出现两个rt参数都返回403的情况, 则跳过当前任务 - logger.error("出现403报错, 尝试修复无效, 正在跳过当前任务点...") - logger.error("请求url: {}", resp.url) - logger.error("请求头: {}", dict(_session.headers) | headers) + logger.warning("这个任务被平台临时拦了一下,已跳过(稍后会自动重试;详情见日志文件)") + logger.debug("403 请求 url: {}", resp.url) + logger.debug("403 请求头: {}", dict(_session.headers) | headers) return False, 403 logger.error(f"未知错误: {resp.status_code}") - logger.error("请求url:", resp.url) - logger.error("请求头:", dict(_session.headers) | headers) + logger.debug("请求 url: {}", resp.url) + logger.debug("请求头: {}", dict(_session.headers) | headers) return False, resp.status_code def _refresh_video_status(self, session: requests.Session, job: dict, _type: Literal["Video", "Audio"]) \ @@ -852,27 +1346,94 @@ def _close_pbar_safe(pbar_ref): logger.trace(f"关闭进度条失败: {e}") return None - def study_video(self, _course, _job, _job_info, _speed: float = 1.0, - _type: Literal["Video", "Audio"] = "Video") -> StudyResult: - _session = SessionManager.get_session() + # 视频串行开关的进程级锁(见 study_video 说明) + _video_lock = threading.Lock() - headers = gc.VIDEO_HEADERS if _type == "Video" else gc.AUDIO_HEADERS + def study_video(self, _course, _job, _job_info, _speed: float = 1.0, + _type: Literal["Video", "Audio"] = "Video", + engine_info: bool = False) -> StudyResult: + """播放视频 / 音频任务.""" + # + # serial_video = true 时,同一个进程里一次只播一个视频。 + # 超星现在有心跳检测,多个视频同时播放容易被判定异常、把已刷的进度回退(#588), + # 所以遇到"刷完又变回没刷"的用户可以打开它换取稳定; + # 默认仍是并发(保持原来的速度),需要时在 config.ini 里设 serial_video = true。 + # engine_info 只在需要时多传一个参数:社区里有测试/扩展会替换 _study_video, + # 保持 5 参数调用形态,避免插件式猴子补丁被新参数打断。 + args = (_course, _job, _job_info, _speed, _type) + if engine_info: + args = args + (True,) + if not self.kwargs.get("serial_video", False): + return self._study_video(*args) + with Chaoxing._video_lock: + return self._study_video(*args) + + def _video_metadata(self, _session, _job, headers): + """Fetch and validate video tokens and duration before playback.""" _info_url = f"https://mooc1.chaoxing.com/ananas/status/{_job['objectid']}?k={self.get_fid()}&flag=normal" - _video_info = _session.get(_info_url, headers=headers).json() + # 视频信息接口偶尔会返回非 JSON(登录页 / 错误页),或者 status=failed 时 + # 干脆不带 dtoken、duration 这些字段。以前直接取键会抛 KeyError 把整个任务 + # 打挂(#290),这里统一按"这个任务读不到信息"处理,交给上层重试。 + try: + _video_info = _session.get(_info_url, headers=headers).json() + except Exception as e: + logger.error(f"读取视频信息失败({type(e).__name__}),跳过该任务点: {e}") + return None - if _video_info["status"] != "success": - logger.error(f"Unknown status: {_video_info['status']}") - return StudyResult.ERROR + if not isinstance(_video_info, dict): + logger.error("视频信息格式异常(不是 JSON 对象),跳过该任务点") + return None - _dtoken = _video_info["dtoken"] + if _video_info.get("status") != "success": + logger.error(f"视频信息状态异常(status={_video_info.get('status', '缺失')}),跳过该任务点") + return None - _crc = _video_info["crc"] - _key = _video_info["key"] + _dtoken = _video_info.get("dtoken") + if not _dtoken: + logger.error("视频信息缺少 dtoken,跳过该任务点") + return None # Time in the real world: last_iter, gc.THRESHOLD # Time in the video (can be scaled with the speed factor): duration, play_time, last_log_time, wait_time - duration = int(_video_info["duration"]) + try: + duration = int(_video_info.get("duration") or 0) + except (TypeError, ValueError): + duration = 0 + if duration <= 0: + logger.error("视频信息缺少时长(视频可能还没转码完成),跳过该任务点") + return None + return _dtoken, duration + + def _refresh_video_bar(self, pbar, duration, play_time, _job): + """Refresh playback output only when manual answering does not own stdin.""" + # 检查手动模式锁是否被锁定 + manual_locked = False + try: + manual_locked = TikuManual._manual_lock.locked() + except Exception as e: + logger.trace(f"无法检查手动锁状态: {e}") + + if manual_locked: + pbar = self._close_pbar_safe(pbar) + else: + if pbar is None: + pbar = tqdm(total=duration, initial=int(play_time), desc=_short_title(_job.get("name")), + unit_scale=True, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt}', leave=False) + pbar.n = int(play_time) + pbar.refresh() + return pbar + + def _study_video(self, _course, _job, _job_info, _speed: float = 1.0, + _type: Literal["Video", "Audio"] = "Video", + engine_info: bool = False) -> StudyResult: + _session = SessionManager.get_session() + + headers = gc.VIDEO_HEADERS if _type == "Video" else gc.AUDIO_HEADERS + metadata = self._video_metadata(_session, _job, headers) + if metadata is None: + return StudyResult.ERROR + _dtoken, duration = metadata play_time = int(_job["playTime"]) // 1000 last_log_time = 0 last_iter = time.time() @@ -884,19 +1445,46 @@ def study_video(self, _course, _job, _job_info, _speed: float = 1.0, max_forbidden_retry = 2 passed, state = self.video_progress_log(_session, _course, _job, _job_info, _dtoken, duration, duration, - _type, headers=headers, _isdrag=4) + _type, headers=headers, _isdrag=4, + engine_info=engine_info) if passed: logger.info("任务瞬间完成: {}", _job['name']) return StudyResult.SUCCESS + # 平台记的 playTime 是"看到的位置",通过与否要看真实累计观看时长: + # 进度显示 100% 但没通过(例如上一次的结束上报被风控/指纹挡掉)时, + # 在结尾反复重报没有意义,必须从头回看一遍(决 D3:不够就回看)。 + replay_used = False + if play_time >= duration: + logger.info( + "任务 {} 进度已到结尾({}s/{}s)但平台未通过,从头回看一遍", + _job.get("name", "?"), play_time, duration, + ) + play_time = 0 + replay_used = True + pbar = None + # 服务器一直返回"200 但未通过"时不能无限循环(#358 / #451): + # 正常播放需要的理论时间 + 5 分钟缓冲,超了就当作失败交给上层重试。 + remaining = duration if replay_used else max(duration - play_time, 0) + play_deadline = time.time() + remaining / max(_speed, 0.1) + 300 + stuck_reports = 0 + max_stuck_reports = 30 try: while not passed: + if time.time() > play_deadline: + logger.error( + "任务 {} 进度上报一直未被通过(已超过预计时间),先跳过,稍后重试", + _job.get("name", "?"), + ) + return StudyResult.ERROR + # Sometimes the last request needs to be sent several times to complete the task if play_time - last_log_time >= wait_time or play_time == duration: passed, state = self.video_progress_log(_session, _course, _job, _job_info, _dtoken, duration, - int(play_time), _type, headers=headers) + int(play_time), _type, headers=headers, + engine_info=engine_info) if state == 403: if forbidden_retry >= max_forbidden_retry: @@ -917,7 +1505,7 @@ def study_video(self, _course, _job, _job_info, _speed: float = 1.0, if refreshed_play_time is not None: play_time = int(refreshed_play_time) - logger.debug("刷新后的令牌: {}, 持续时间: {}, 播放时间: {}", _dtoken, duration, play_time) + logger.debug("视频令牌已刷新,持续时间: {}, 播放时间: {}", duration, play_time) pbar = self._close_pbar_safe(pbar) continue else: @@ -927,6 +1515,17 @@ def study_video(self, _course, _job, _job_info, _speed: float = 1.0, elif not passed and state != 200: return StudyResult.ERROR + # 已经播到结尾、平台却一直不确认"通过"时,重报几次就放弃, + # 否则会在这里无限重报(#358 / #451) + if not passed and play_time >= duration: + stuck_reports += 1 + if stuck_reports >= max_stuck_reports: + logger.error( + "任务 {} 已播放到结尾,但平台连续 {} 次未确认通过,先跳过稍后重试", + _job.get("name", "?"), stuck_reports, + ) + return StudyResult.ERROR + wait_time = int(random.uniform(30, 90)) last_log_time = play_time @@ -937,21 +1536,7 @@ def study_video(self, _course, _job, _job_info, _speed: float = 1.0, last_iter = time.time() play_time = min(duration, play_time + dt) - # 检查手动模式锁是否被锁定 - manual_locked = False - try: - manual_locked = TikuManual._manual_lock.locked() - except Exception as e: - logger.trace(f"无法检查手动锁状态: {e}") - - if manual_locked: - pbar = self._close_pbar_safe(pbar) - else: - if pbar is None: - pbar = tqdm(total=duration, initial=int(play_time), desc=_job["name"], - unit_scale=True, bar_format='{l_bar}{bar}| {n_fmt}/{total_fmt}', leave=False) - pbar.n = int(play_time) - pbar.refresh() + pbar = self._refresh_video_bar(pbar, duration, play_time, _job) time.sleep(gc.THRESHOLD) finally: @@ -960,41 +1545,113 @@ def study_video(self, _course, _job, _job_info, _speed: float = 1.0, logger.info("任务完成: {}", _job['name']) return StudyResult.SUCCESS - def study_document(self, _course, _job) -> StudyResult: - """ - Study a document in Chaoxing platform. - - This method makes a GET request to fetch document information for a given course and job. - - Args: - _course (dict): Dictionary containing course information with keys: - - courseId: ID of the course - - clazzId: ID of the class - _job (dict): Dictionary containing job information with keys: - - jobid: ID of the job - - otherinfo: String containing node information - - jtoken: Authentication token for the job - - Returns: - requests.Response: Response object from the GET request - - Note: - This method requires the following helper functions: - - init_session(): To initialize a new session - - get_timestamp(): To get current timestamp - - re module for regular expression matching - """ + def study_document(self, _course, _job, engine_info: bool = False) -> StudyResult: + """Study a document in Chaoxing platform.""" + # + # This method makes a GET request to fetch document information for a given course and job. + # + # Args: + # _course (dict): Dictionary containing course information with keys: + # - courseId: ID of the course + # - clazzId: ID of the class + # _job (dict): Dictionary containing job information with keys: + # - jobid: ID of the job + # - otherinfo: String containing node information + # - jtoken: Authentication token for the job + # engine_info (bool): 是否处于任务引擎的"章节"任务点上下文。为 True 时, + # 额外走一次引擎的 job/document 接口,平台可能因此下发 stuJobInfo + # (章节同步数据),由上层调用 autoPullChapterScore。 + # + # Returns: + # requests.Response: Response object from the GET request + # + # Note: + # This method requires the following helper functions: + # - init_session(): To initialize a new session + # - get_timestamp(): To get current timestamp + # - re module for regular expression matching _session = SessionManager.get_session() - _url = f"https://mooc1.chaoxing.com/ananas/job/document?jobid={_job['jobid']}&knowledgeid={re.findall(r'nodeId_(.*?)-', _job['otherinfo'])[0]}&courseid={_course['courseId']}&clazzid={_course['clazzId']}&jtoken={_job['jtoken']}&_dc={get_timestamp()}" + # otherinfo 里没有 nodeId 时不能直接 [0] 取(#22 / #374 这类 IndexError) + node_ids = re.findall(r"nodeId_(.*?)-", str(_job.get("otherinfo", ""))) + if not node_ids: + logger.error("文档任务缺少 nodeId 信息,跳过该任务点: {}", str(_job)[:200]) + return StudyResult.ERROR + _url = (f"https://mooc1.chaoxing.com/ananas/job/document?jobid={_job.get('jobid', '')}" + f"&knowledgeid={node_ids[0]}&courseid={_course.get('courseId', '')}" + f"&clazzid={_course.get('clazzId', '')}&jtoken={_job.get('jtoken', '')}" + f"&_dc={get_timestamp()}") _resp = _session.get(_url) if _resp.status_code != 200: + logger.error("章节文档打开失败 -> [{}]{}", _resp.status_code, str(_resp.text)[:120]) return StudyResult.ERROR - else: - return StudyResult.SUCCESS + # 只看 HTTP 200 会把平台拒绝当成功:能解析出 result=false 就判失败 + try: + _doc_data = _resp.json() + except ValueError: + _doc_data = None + if isinstance(_doc_data, dict) and _doc_data.get("result") is False: + logger.error("章节文档未完成 -> {}", str(_doc_data.get("msg") or _doc_data)[:160]) + return StudyResult.ERROR + logger.info("章节文档完成: {}", _job.get("name") or node_ids[0]) + if engine_info: + # 任务引擎节点下,浏览器读完文档走的正是这个接口;它会返回 + # stuJobInfo(章节同步数据)。拿不到不影响文档本身的学习结果。 + self.finish_engine_document_job(_course, _job) + return StudyResult.SUCCESS + + def finish_engine_document_job(self, _course, _job) -> Optional[dict]: + """任务引擎上下文的文档完成接口,返回并暂存平台下发的 stuJobInfo.""" + # + # 网页端(ananas/ueditor/documentJob.js 的 finishJob)在文档读完时请求 + # /mooc-ans/job/document?...&courseEngineInfo=true,响应里的 + # allowSendStuJobInfoMsg / stuJobInfo 会被回传给任务中心父页面, + # 父页面再 POST autoPullChapterScore。这里是 CLI 侧等价复现。 + node_ids = re.findall(r"nodeId_(.*?)-", str(_job.get("otherinfo", ""))) + if not node_ids: + return None + _session = SessionManager.get_session() + params = { + "jobid": _job.get("jobid", ""), + "knowledgeid": node_ids[0], + "courseid": _course.get("courseId", ""), + "clazzid": _course.get("clazzId", ""), + "jtoken": _job.get("jtoken", ""), + "checkMicroTopic": "true", + "microTopicId": _job.get("microTopicId", ""), + "courseEngineInfo": "true", + } + try: + resp = _session.get("https://mooc1.chaoxing.com/mooc-ans/job/document", + params=params, timeout=15) + except Exception as e: + logger.warning("文档任务引擎同步接口请求失败: {}", e) + return None + if getattr(resp, "status_code", 0) != 200: + logger.warning("文档任务引擎同步接口返回异常: HTTP {}", getattr(resp, "status_code", "?")) + return None + try: + payload = resp.json() + except ValueError: + logger.warning("文档任务引擎同步接口返回的不是 JSON,本次不同步章节成绩") + return None + if not isinstance(payload, dict): + return None + # 和网页端 documentJob.js 的 finishJob 一致:只有 status 为真才算接口成功 + if not payload.get("status"): + logger.debug("文档任务引擎同步接口未被接受: {}", str(payload)[:200]) + return None + capture_student_job_info(self, payload) + return payload.get("stuJobInfo") if isinstance(payload.get("stuJobInfo"), dict) else None def study_work(self, _course, _job, _job_info) -> StudyResult: if self.tiku.DISABLE or not self.tiku: - return StudyResult.SUCCESS + # 铁律:没有题库就不能把测验记成完成(历史 issue #223/#357)。 + # 返回 ERROR 会让这个任务点显示未完成,需要答题解锁的章节会停在这里。 + logger.error( + "章节测验 [{} - {}] 未作答:没有可用题库;该任务点不会记为完成。", + _course.get("title", "?"), _job.get("name", "?") + ) + return StudyResult.ERROR _session = SessionManager.get_session() _url = "https://mooc1.chaoxing.com/mooc-ans/api/work" @@ -1102,7 +1759,9 @@ def fetch_response_with_retry(): answers = list(answers) + [None] * (total_questions - len(answers)) answers = answers[:total_questions] - for q, res in zip(questions["questions"], answers): + from api.display import answer_line as _answer_line, answers_header as _answers_header, emit as _emit, emit_block as _emit_block + _emit(_answers_header(str(_job.get("name") or "章节测验"), len(questions["questions"]))) + for _qi, (q, res) in enumerate(zip(questions["questions"], answers), 1): logger.debug(f"当前题目信息 -> {q}") answer = "" if not res: @@ -1112,26 +1771,9 @@ def fetch_response_with_retry(): else: # 根据响应结果选择答案 if q["type"] == "multiple": - # 多选处理 - options_list = multi_cut(q["options"], _ORIGIN_HTML_CONTENT) - res_list = multi_cut(res, _ORIGIN_HTML_CONTENT) - if res_list is not None and options_list is not None: - for _a in clean_res(res_list): - matched = False - for o in options_list: - if ( - is_subsequence(_a, o) # 去掉各种符号和前面ABCD的答案应当是选项的子序列 - ): - answer += o[:1] - matched = True - break # 找到匹配项后立即停止,防止重复添加 - if not matched: - best_letter = best_option_by_similarity(_a, options_list, threshold=0.8) - if best_letter: - answer += best_letter - # 对答案进行排序, 否则会提交失败 - answer = "".join(sorted(set(answer))) - # else 如果分割失败那么就直接到下面去随机选 + # 多选处理(拆分 + 匹配逻辑见 build_multiple_answer) + answer = build_multiple_answer(res, q["options"], _ORIGIN_HTML_CONTENT) + # 匹配不到就往下走,由统一的"答案为空的兜底"改为随机作答 elif q["type"] == "single": # 单选也进行切割,主要是防止返回的答案有异常字符 options_list = multi_cut(q["options"], _ORIGIN_HTML_CONTENT) @@ -1147,7 +1789,8 @@ def fetch_response_with_retry(): answer = "true" if self.tiku.judgement_select(res) else "false" elif q["type"] == "completion": if isinstance(res, list): - answer = "".join(res) + # 多个空必须用 # 隔开,否则会被当成一个空的答案 + answer = "#".join(str(x).strip() for x in res if str(x).strip()) elif isinstance(res, str): answer = res else: @@ -1155,16 +1798,19 @@ def fetch_response_with_retry(): answer = res if not answer: # 检查 answer 是否为空 - logger.warning(f"找到答案但答案未能匹配 -> {res}\t随机选择答案") + logger.debug(f"找到答案但答案未能匹配 -> {res}\t随机选择答案") answer = random_answer(q["options"], q["type"]) # 如果为空,则随机选择答案 q[f'answerSource{q["id"]}'] = "random" else: logger.info(f"成功获取到答案:{answer}") q[f'answerSource{q["id"]}'] = "cover" found_answers += 1 - # 填充答案 + # 填充答案 + 实时留痕(控制台与运行日志各一份) q["answerField"][f'answer{q["id"]}'] = answer - logger.info(f'{q["title"]} 填写答案为 {answer}') + _emit(_answer_line(_qi, q.get("type"), answer, q.get("title"))) + if q.get("type") == "shortanswer": + _emit_block(f"简答 {_qi}", answer) + logger.debug(f'{q["title"]} 填写答案为 {answer}') cover_rate = (found_answers / total_questions) * 100 logger.info(f"章节检测题库覆盖率: {cover_rate:.0f}%") # 提交模式 现在与题库绑定,留空直接提交, 1保存但不提交 @@ -1201,48 +1847,85 @@ def fetch_response_with_retry(): } ) + # 填空题必须按空提交:answerEditor{id}1、answerEditor{id}2 … + tiankongsize{id}。 + # 只发 answer{id} 的话网页端会显示答案为空(#615 / #575)。 + for _q in questions["questions"]: + if isinstance(_q, dict): + build_completion_fields(questions, _q) + + from api import review as _review + review_items = [] + for question in questions["questions"]: + if question.get("type") != "shortanswer": + continue + text = questions.get(f"answer{question['id']}", "") + if text: + item = _review.record(_review.KIND_QUIZ, text, + course=_course.get("title", ""), task=_job.get("name", ""), + status="待提交" if questions["pyFlag"] == "" else "待保存") + if not item: + for previous in review_items: + _review.update(previous, "复核写入失败,未提交") + logger.error("简答题复核记录写入失败,本次不提交") + return StudyResult.ERROR + review_items.append(item) + del questions["questions"] # 4. 提交 - res = _session.post( - "https://mooc1.chaoxing.com/mooc-ans/work/addStudentWorkNew", - data=questions, - headers={ - "Host": "mooc1.chaoxing.com", - "sec-ch-ua-platform": '"Windows"', - "X-Requested-With": "XMLHttpRequest", - "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0", - "Accept": "application/json, text/javascript, */*; q=0.01", - "sec-ch-ua": '"Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"', - "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", - "sec-ch-ua-mobile": "?0", - "Origin": "https://mooc1.chaoxing.com", - "Sec-Fetch-Site": "same-origin", - "Sec-Fetch-Mode": "cors", - "Sec-Fetch-Dest": "empty", - "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6,ja;q=0.5", - }, - ) - if res.status_code == 200: - res_json = res.json() - if res_json["status"]: - logger.info(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题成功 -> {res_json["msg"]}') + accepted = False + try: + res = _session.post( + "https://mooc1.chaoxing.com/mooc-ans/work/addStudentWorkNew", + data=questions, + headers={ + "Host": "mooc1.chaoxing.com", + "sec-ch-ua-platform": '"Windows"', + "X-Requested-With": "XMLHttpRequest", + "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0", + "Accept": "application/json, text/javascript, */*; q=0.01", + "sec-ch-ua": '"Microsoft Edge";v="129", "Not=A?Brand";v="8", "Chromium";v="129"', + "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", + "sec-ch-ua-mobile": "?0", + "Origin": "https://mooc1.chaoxing.com", + "Sec-Fetch-Site": "same-origin", + "Sec-Fetch-Mode": "cors", + "Sec-Fetch-Dest": "empty", + "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6,ja;q=0.5", + }, + ) + if res.status_code == 200: + res_json = res.json() + if res_json["status"]: + accepted = True + logger.info(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题成功 -> {res_json["msg"]}') + else: + logger.error(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题失败 -> {res_json["msg"]}') + return StudyResult.ERROR else: - logger.error(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题失败 -> {res_json["msg"]}') + logger.error(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题失败 -> {res.text}') return StudyResult.ERROR - else: - logger.error(f'{"提交" if questions["pyFlag"] == "" else "保存"}答题失败 -> {res.text}') - return StudyResult.ERROR - # 5. 若只是保存未提交,无法判断成绩,保持原有行为 + finally: + for item in review_items: + _review.update(item, ("平台已接受提交" if questions["pyFlag"] == "" else "平台已保存,未提交") if accepted else "请求失败或平台未确认") + + # 5. 只保存未提交:平台不会把任务点记为完成,不能返回成功(铁律 1) if questions["pyFlag"] == "1": - return StudyResult.SUCCESS + logger.warning("章节检测已保存但未提交(submit=false),本任务点不记为完成") + return StudyResult.ERROR # 6. 提交后检查成绩:若未全部正确,则收集错误反馈并重新作答提交 - result_info = self._check_work_result(_session, _course, _job, _job_info, questions) + result_info = None + for _try in range(3): + result_info = self._check_work_result(_session, _course, _job, _job_info, questions) + if result_info is not None: + break + time.sleep(2) if result_info is None: - # 无法获取成绩详情(如接口异常),按原行为返回成功,避免误判失败 - return StudyResult.SUCCESS + # 读不到成绩就不能说通过(铁律 1):重试 3 次后按失败处理 + logger.error("提交后连续 3 次读不到章节检测成绩,本任务点不记为完成") + return StudyResult.ERROR score = float(result_info.get("score", 0.0) or 0.0) unknown = int(result_info.get("unknown", 0) or 0) @@ -1282,19 +1965,17 @@ def fetch_response_with_retry(): return StudyResult.ERROR def _check_work_result(self, _session, _course, _job, _job_info, questions) -> Optional[dict]: - """ - 章节检测提交后,查询最新一次作答的成绩与对错详情,供判断是否需要重做。 - - Args: - _session: 当前会话 - _course: 课程信息 - _job: 任务点信息 - questions: 提交时使用的表单数据(含 workId / workAnswerId 等) - - Returns: - {"all_correct": bool, "feedback": list[str], "score": float, "times": int} - 或 None(无法获取成绩详情时返回 None) - """ + """章节检测提交后,查询最新一次作答的成绩与对错详情,供判断是否需要重做.""" + # + # Args: + # _session: 当前会话 + # _course: 课程信息 + # _job: 任务点信息 + # questions: 提交时使用的表单数据(含 workId / workAnswerId 等) + # + # Returns: + # {"all_correct": bool, "feedback": list[str], "score": float, "times": int} + # 或 None(无法获取成绩详情时返回 None) work_id = str( questions.get("workId", "") or questions.get("workRelationId", "") @@ -1370,32 +2051,18 @@ def _check_work_result(self, _session, _course, _job, _job_info, questions) -> O # 已提交详情页:解析成绩与对错 detail = _parse_work_record_detail(html) if detail: - feedback = [] - all_correct = True - unknown = 0 - for q in detail: - if not q.get("parse_ok", True): - unknown += 1 - all_correct = False - continue - my_ans = (q.get("my_answer") or "").strip() - correct_ans = (q.get("correct_answer") or "").strip() - if normalize_answer_text(my_ans) != normalize_answer_text(correct_ans): - all_correct = False - feedback.append( - f"- 题目:{q.get('title', '')}\n" - f" 题型:{q.get('type_label', '')}\n" - f" 你的上次答案:{my_ans or '(空)'}\n" - f" 正确答案:{correct_ans or '(空)'}" - ) + evaluated = evaluate_work_detail(detail) + if evaluated["unjudgeable"]: + logger.warning("页面没有渲染出「我的答案」,无法逐题判断对错,本项等待复查") + return None m = re.search(r'本次成绩([\d.]+)分', html) score = float(m.group(1)) if m else 0.0 return { - "all_correct": all_correct, - "feedback": feedback, + "all_correct": evaluated["all_correct"], + "feedback": evaluated["feedback"], "score": score, "times": 0, - "unknown": unknown, + "unknown": evaluated["unknown"], } return None except Exception as e: @@ -1436,39 +2103,27 @@ def _check_work_result(self, _session, _course, _job, _job_info, questions) -> O logger.warning("章节检测作答详情解析为空,跳过成绩检查") return None - # 3. 逐题判断对错,收集错误反馈(解析失配的题跳过并计数, 避免误判全错) - feedback = [] - all_correct = True - unknown = 0 - for q in detail: - if not q.get("parse_ok", True): - unknown += 1 - all_correct = False - continue - my_ans = (q.get("my_answer") or "").strip() - correct_ans = (q.get("correct_answer") or "").strip() - if normalize_answer_text(my_ans) != normalize_answer_text(correct_ans): - all_correct = False - feedback.append( - f"- 题目:{q.get('title', '')}\n" - f" 题型:{q.get('type_label', '')}\n" - f" 你的上次答案:{my_ans or '(空)'}\n" - f" 正确答案:{correct_ans or '(空)'}" - ) + # 3. 逐题判断对错,收集错误反馈 + evaluated = evaluate_work_detail(detail) + if evaluated["unjudgeable"]: + # 页面没给出"我的答案"(只渲染了图标之类),判定不可信 + logger.warning("作答详情里没有「我的答案」,无法逐题判断对错,本项等待复查") + return None - logger.debug(f"章节检测成绩: {latest_score} 分, 全部正确: {all_correct}, 错题数: {len(feedback)}, 未解析题数: {unknown}") + logger.debug( + "章节检测成绩: {} 分, 全部正确: {}, 错题数: {}", + latest_score, evaluated["all_correct"], len(evaluated["feedback"]), + ) return { - "all_correct": all_correct, - "feedback": feedback, + "all_correct": evaluated["all_correct"], + "feedback": evaluated["feedback"], "score": latest_score, "times": latest_times, - "unknown": unknown, + "unknown": evaluated["unknown"], } def study_read(self, _course, _job, _job_info) -> StudyResult: - """ - 阅读任务学习, 仅完成任务点, 并不增长时长 - """ + """阅读任务学习, 仅完成任务点, 并不增长时长.""" _session = SessionManager.get_session() _resp = _session.get( url="https://mooc1.chaoxing.com/ananas/job/readv2", @@ -1483,21 +2138,26 @@ def study_read(self, _course, _job, _job_info) -> StudyResult: if _resp.status_code != 200: logger.error(f"阅读任务学习失败 -> [{_resp.status_code}]{_resp.text}") return StudyResult.ERROR - else: + try: _resp_json = _resp.json() - logger.info(f"阅读任务学习 -> {_resp_json['msg']}") - return StudyResult.SUCCESS + except ValueError: + logger.error("阅读任务返回非 JSON,无法确认结果,按失败处理") + return StudyResult.ERROR + if isinstance(_resp_json, dict) and _resp_json.get("result") is False: + logger.error("阅读任务未完成 -> {}", str(_resp_json.get("msg") or _resp_json)[:160]) + return StudyResult.ERROR + _msg = _resp_json.get("msg", "成功") if isinstance(_resp_json, dict) else "成功" + logger.info(f"阅读任务学习 -> {_msg}") + return StudyResult.SUCCESS def _send_monitor_heartbeat(self, course, point): - """ - 发送章节监控心跳包到 detect.chaoxing.com。 - - 模拟真实浏览器的 JSONP 打点请求,佐证访问行为的真人属性。 - - Args: - course: 课程信息字典 - point: 当前章节信息字典 - """ + """发送章节监控心跳包到 detect.chaoxing.com.""" + # + # 模拟真实浏览器的 JSONP 打点请求,佐证访问行为的真人属性。 + # + # Args: + # course: 课程信息字典 + # point: 当前章节信息字典 version = get_timestamp() callback = f"jsonp{secrets.randbelow(10**21 - 10**20) + 10**20}" params = { @@ -1574,14 +2234,12 @@ def _access_chapter_for_count(self, _course, point): return _resp.text def _extract_and_send_setlog(self, html_text): - """ - 从 studentstudyAjax 返回的 HTML 中提取 setlog URL 并执行。 - - 该 URL 包含服务端生成的 encode 参数,是记录章节学习次数的关键 API。 - - Args: - html_text: studentstudyAjax 返回的 HTML 内容 - """ + """从 studentstudyAjax 返回的 HTML 中提取 setlog URL 并执行.""" + # + # 该 URL 包含服务端生成的 encode 参数,是记录章节学习次数的关键 API。 + # + # Args: + # html_text: studentstudyAjax 返回的 HTML 内容 match = re.search( r']+src="(https://fystat-ans\.chaoxing\.com/log/setlog[^"]+)"', html_text @@ -1599,25 +2257,23 @@ def _extract_and_send_setlog(self, html_text): logger.trace(f"Setlog failed (non-critical): {e}") def increase_chapter_learning_count(self, course, points, target_count): - """ - 增加课程章节学习次数。 - - 循环遍历课程的所有章节,每访问一个章节页面: - 1. 调 studentstudyAjax 获取页面 HTML(含服务端生成的 setlog URL) - 2. 提取并执行 setlog URL(记录学习次数) - 3. 立即发送 monitor 心跳包(模拟 fn() 首次心跳) - 4. 停留 30 秒(模拟前端 setInterval(fn, 30000) 的间隔) - 5. 再次发送 monitor 心跳包(模拟 30s 后的第二次心跳) - 6. 计数器 +1,继续下一个章节 - - Args: - course: 课程信息字典 - points: 课程所有章节列表 - target_count: 目标总次数 - - Returns: - StudyResult: 操作结果 - """ + """增加课程章节学习次数.""" + # + # 循环遍历课程的所有章节,每访问一个章节页面: + # 1. 调 studentstudyAjax 获取页面 HTML(含服务端生成的 setlog URL) + # 2. 提取并执行 setlog URL(记录学习次数) + # 3. 立即发送 monitor 心跳包(模拟 fn() 首次心跳) + # 4. 停留 30 秒(模拟前端 setInterval(fn, 30000) 的间隔) + # 5. 再次发送 monitor 心跳包(模拟 30s 后的第二次心跳) + # 6. 计数器 +1,继续下一个章节 + # + # Args: + # course: 课程信息字典 + # points: 课程所有章节列表 + # target_count: 目标总次数 + # + # Returns: + # StudyResult: 操作结果 total = 0 consecutive_failures = 0 max_consecutive_failures = 10 diff --git a/api/captcha.py b/api/captcha.py index 8878530c2..c9353b941 100644 --- a/api/captcha.py +++ b/api/captcha.py @@ -1,14 +1,12 @@ -""" -Captcha API for Chaoxing - -本模块用于通过CX验证码,提供包括验证码获取、识别、验证等接口。 -使用了开源的验证码识别库[DdddOcr](https://github.com/sml2h3/ddddocr) - -Author: skreon -Email: 1340554713@qq.com -Date: 2025-06-05 -Version: 1.0.0 -""" +"""Captcha API for Chaoxing.""" +# +# 本模块用于通过CX验证码,提供包括验证码获取、识别、验证等接口。 +# 使用了开源的验证码识别库[DdddOcr](https://github.com/sml2h3/ddddocr) +# +# Author: skreon +# Email: 1340554713@qq.com +# Date: 2025-06-05 +# Version: 1.0.0 __author__ = "skreon 1340554713@qq.com" __version__ = "1.0.0" @@ -29,11 +27,9 @@ def ocr_init() -> Optional[DdddOcr]: - """ - 初始化OCR对象 - - Returns: DdddOcr对象 - """ + """初始化OCR对象.""" + # + # Returns: DdddOcr对象 if not HAS_DDDDOCR: logger.warning("未检测到 ddddocr 依赖,自动验证码识别将不可用。如遇403限制请在浏览器端手动完成验证。") return None @@ -48,19 +44,18 @@ def ocr_init() -> Optional[DdddOcr]: class CxCaptcha: - """ - CxCaptcha 类用于处理学习任务中出现的验证码 - - 该类提供了获取、识别和提交验证码的方法,使用 requests 库进行 HTTP 请求, - 并利用 DdddOcr 进行验证码识别。 - - Attributes: - host (str): 超星平台的主机地址。 - api (dict): 包含获取和提交验证码的 API 路径。 - user_agent (str): 用户代理字符串。 - cookies (str): 会话 cookies。 - s (requests.Session): 用于管理会话的请求对象。 - """ + """CxCaptcha 类用于处理学习任务中出现的验证码.""" + + # + # 该类提供了获取、识别和提交验证码的方法,使用 requests 库进行 HTTP 请求, + # 并利用 DdddOcr 进行验证码识别。 + # + # Attributes: + # host (str): 超星平台的主机地址。 + # api (dict): 包含获取和提交验证码的 API 路径。 + # user_agent (str): 用户代理字符串。 + # cookies (str): 会话 cookies。 + # s (requests.Session): 用于管理会话的请求对象。 host = 'https://mooc1.chaoxing.com' api = { @@ -69,14 +64,12 @@ class CxCaptcha: } def __init__(self, user_agent: str, cookies: str, ocr: Optional[DdddOcr] = _MISSING): - """ - 初始化 CxCaptcha 实例。 - - Args: - user_agent (str): 用户代理字符串。 - cookies (str): 会话 cookies。 - ocr (DdddOcr, optional): 已初始化的 DdddOcr 对象。如果未提供则自动初始化;如果显式传入 None 则禁用 OCR。据DdddOcr官方说明,每次初始化和初始化后的首次识别速度都非常慢,所以推荐传入一个现成的DdddOcr对象实现复用。 - """ + """初始化 CxCaptcha 实例.""" + # + # Args: + # user_agent (str): 用户代理字符串。 + # cookies (str): 会话 cookies。 + # ocr (DdddOcr, optional): 已初始化的 DdddOcr 对象。如果未提供则自动初始化;如果显式传入 None 则禁用 OCR。据DdddOcr官方说明,每次初始化和初始化后的首次识别速度都非常慢,所以推荐传入一个现成的DdddOcr对象实现复用。 self.user_agent = user_agent self.cookies = cookies @@ -91,12 +84,10 @@ def __init__(self, user_agent: str, cookies: str, ocr: Optional[DdddOcr] = _MISS self.ocr = ocr_init() if ocr is _MISSING else ocr def getCaptcha(self) -> Optional[bytes]: - """ - 获取验证码图片。 - - Returns: - Optional[bytes]: 返回验证码图片的二进制数据,如果获取失败则返回 None。 - """ + """获取验证码图片.""" + # + # Returns: + # Optional[bytes]: 返回验证码图片的二进制数据,如果获取失败则返回 None。 api = self.host + self.api['get'] random_t = randint(0, 2147483647) @@ -108,15 +99,13 @@ def getCaptcha(self) -> Optional[bytes]: return None def submitCaptcha(self, cap_token: str) -> bool: - """ - 提交验证码以完成验证。 - - Args: - cap_token (str): 验证码 token。 - - Returns: - bool: 如果提交成功并重定向,则返回 True;否则返回 False。 - """ + """提交验证码以完成验证.""" + # + # Args: + # cap_token (str): 验证码 token。 + # + # Returns: + # bool: 如果提交成功并重定向,则返回 True;否则返回 False。 api = self.host + self.api['submit'] params = { 'ucode': cap_token, @@ -129,15 +118,13 @@ def submitCaptcha(self, cap_token: str) -> bool: return False def recognition(self, img: bytes) -> str: - """ - 使用 DdddOcr 对验证码图片进行识别。 - - Args: - img (bytes): 验证码图片的二进制数据. - - Returns: - str: 返回识别出的验证码字符串。 - """ + """使用 DdddOcr 对验证码图片进行识别.""" + # + # Args: + # img (bytes): 验证码图片的二进制数据. + # + # Returns: + # str: 返回识别出的验证码字符串。 if not self.ocr: logger.error("ddddocr 实例未成功初始化,无法执行验证码识别") raise RuntimeError("ddddocr is not available") @@ -145,14 +132,12 @@ def recognition(self, img: bytes) -> str: return res def try_pass(self) -> bool: - """ - 尝试通过验证码验证流程。 - - 该方法会自动获取验证码、识别并提交。 - - Returns: - bool: 如果验证码成功通过验证,则返回 True;否则返回 False。 - """ + """尝试通过验证码验证流程.""" + # + # 该方法会自动获取验证码、识别并提交。 + # + # Returns: + # bool: 如果验证码成功通过验证,则返回 True;否则返回 False。 try: cap_img = self.getCaptcha() if not cap_img: diff --git a/api/config.py b/api/config.py index afecbd3d4..e78af510a 100644 --- a/api/config.py +++ b/api/config.py @@ -1,7 +1,11 @@ # -*- coding: utf-8 -*- +from api import paths + + class GlobalConst: AESKey = "u2oh6Vu^HWe4_AES" - COOKIES_PATH = "cookies.txt" + # cookie 文件放在用户数据目录(~/.chaoxing/),不在项目目录 + COOKIES_PATH = paths.legacy_cookies_path() HEADERS = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36", diff --git a/api/configfile.py b/api/configfile.py new file mode 100644 index 000000000..8be0b9e63 --- /dev/null +++ b/api/configfile.py @@ -0,0 +1,40 @@ +# -*- coding: utf-8 -*- +"""容错的 ini 读取工具.""" +# +# 配置文件是用户可以手改的,写坏(比如节标题之前冒出一行 key=value) +# 时不能直接抛异常让程序崩掉,而是尽量抢救还能用的内容。 +import configparser + + +def read_config_file(config_path, strict=False): + """读取 ini 文件,返回 (ConfigParser, broken).""" + # + # 正常情况下 broken=False。 + # 文件被写坏时,会丢掉破坏结构的行再读一次,并返回 broken=True, + # 调用方可以据此提示用户。 + config = configparser.ConfigParser(strict=strict) + try: + config.read(config_path, encoding="utf8") + return config, False + except (configparser.Error, UnicodeDecodeError, OSError): + pass + + kept = [] + seen_section = False + try: + with open(config_path, encoding="utf8", errors="replace") as fp: + for line in fp: + stripped = line.strip() + if stripped.startswith("[") and stripped.endswith("]"): + seen_section = True + kept.append(line) + elif not stripped or stripped.startswith(("#", ";")) or seen_section: + kept.append(line) + except OSError: + return config, True + + try: + config.read_string("".join(kept)) + except configparser.Error: + pass + return config, True diff --git a/api/cookies.py b/api/cookies.py index 4b81a291b..32fac445c 100644 --- a/api/cookies.py +++ b/api/cookies.py @@ -1,33 +1,89 @@ # -*- coding: utf-8 -*- +"""Cookie 读写(按账号隔离).""" +# +# 【为什么按账号隔离】 +# 原来所有账号共用一个 cookies.txt,A 登录写的 cookie 会被 B 覆盖, +# 一旦启用 cookie 登录,就可能拿着 B 的登录态去刷 A 的课(串号)。 +# +# 现在每个账号有独立的 cookie 文件,从结构上杜绝串号: +# accounts/cookies/<手机号>.txt +# +# 未指定账号时(老的单人模式)仍回退到项目根目录的 cookies.txt,保持兼容。 + +import os import os.path +import re import threading import requests +from api import paths from api.config import GlobalConst as gc # 定义全局 Cookie 文件锁,保证读写绝对安全 cookie_lock = threading.RLock() +BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +# cookie 文件按账号隔离,统一放在用户数据目录下(~/.chaoxing/accounts/cookies/) +COOKIES_DIR = paths.cookies_dir() + +# 当前会话使用的账号(由 main 在登录前设置) +_current_account = None + + +def _safe(name): + return re.sub(r"[^0-9A-Za-z_\-]", "_", str(name).strip()) + + +def set_current_account(username): + """设置当前账号;之后 cookie 读写都会用这个账号专属的文件.""" + global _current_account + _current_account = str(username).strip() if username else None + + +def current_account(): + return _current_account + -def save_cookies(session: requests.Session): +def cookie_path(username=None): + """返回该账号的 cookie 文件路径.""" + who = username or _current_account + if who: + os.makedirs(COOKIES_DIR, exist_ok=True) + return os.path.join(COOKIES_DIR, _safe(who) + ".txt") + return gc.COOKIES_PATH + + +def save_cookies(session: requests.Session, username=None): + from api.privacy import register_secret + for value in session.cookies.values(): + register_secret(value) with cookie_lock: buffer = "" for k, v in session.cookies.items(): buffer += f"{k}={v};" buffer = buffer.removesuffix(";") - with open(gc.COOKIES_PATH, "w") as f: + path = cookie_path(username) + parent = os.path.dirname(path) + if parent: + os.makedirs(parent, exist_ok=True) + with open(path, "w") as f: f.write(buffer) + try: + os.chmod(path, 0o600) + except OSError: + if os.name != "nt": + raise -def use_cookies() -> dict: +def use_cookies(username=None) -> dict: with cookie_lock: - if not os.path.exists(gc.COOKIES_PATH): + path = cookie_path(username) + if not os.path.exists(path): return {} - cookies = {} try: - with open(gc.COOKIES_PATH, "r") as f: + with open(path, "r") as f: buffer = f.read().strip() if not buffer: return {} @@ -40,5 +96,20 @@ def use_cookies() -> dict: cookies[parts[0]] = parts[1] except Exception: return {} - + from api.privacy import register_secret + for value in cookies.values(): + register_secret(value) return cookies + + +def clear_cookies(username=None): + """清掉某账号的 cookie(用于强制重新登录).""" + with cookie_lock: + path = cookie_path(username) + if os.path.exists(path): + try: + os.remove(path) + return True + except Exception: + return False + return False diff --git a/api/cxsecret_font.py b/api/cxsecret_font.py index 1445d1c51..8455b1b9e 100644 --- a/api/cxsecret_font.py +++ b/api/cxsecret_font.py @@ -9,6 +9,7 @@ import json import os import sys +import site from io import BytesIO from pathlib import Path from typing import Dict, IO, Optional, Union @@ -29,41 +30,41 @@ def resource_path(relative_path: str) -> str: - """ - 获取资源文件的路径,兼容PyInstaller打包后的环境 - - Args: - relative_path: 相对路径 - - Returns: - 资源文件的绝对路径 - """ + """获取资源文件的路径,兼容PyInstaller打包后的环境.""" + # + # Args: + # relative_path: 相对路径 + # + # Returns: + # 资源文件的绝对路径 try: # PyInstaller创建临时文件夹,定位路径 base_path = sys._MEIPASS except Exception: - # 非打包环境,使用当前目录 - base_path = os.path.abspath(".") + base_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) - return os.path.join(base_path, relative_path) + candidate = os.path.join(base_path, relative_path) + if os.path.isfile(candidate): + return candidate + for data_root in (base_path, sys.prefix, site.getuserbase()): + installed = os.path.join(data_root, "share", "chaoxing", os.path.basename(relative_path)) + if os.path.isfile(installed): + return installed + return candidate class FontHashDAO: - """ - 字体哈希数据访问对象,负责管理字体哈希映射表 - """ + """字体哈希数据访问对象,负责管理字体哈希映射表.""" def __init__(self, file_path: str = "resource/font_map_table.json"): - """ - 初始化字体哈希数据访问对象 - - Args: - file_path: 字体映射表JSON文件路径,相对于资源目录 - - Raises: - FileNotFoundError: 当字体映射表文件不存在时 - json.JSONDecodeError: 当字体映射表JSON格式错误时 - """ + """初始化字体哈希数据访问对象.""" + # + # Args: + # file_path: 字体映射表JSON文件路径,相对于资源目录 + # + # Raises: + # FileNotFoundError: 当字体映射表文件不存在时 + # json.JSONDecodeError: 当字体映射表JSON格式错误时 self.char_map: Dict[str, str] = {} # unicode -> hash self.hash_map: Dict[str, str] = {} # hash -> unicode @@ -76,27 +77,23 @@ def __init__(self, file_path: str = "resource/font_map_table.json"): raise FontDecodeError(f"加载字体映射表失败: {full_path} - {e}") from e def find_char(self, font_hash: str) -> Optional[str]: - """ - 通过字体哈希值查找对应的Unicode字符编码 - - Args: - font_hash: 字体哈希值 - - Returns: - 对应的Unicode字符编码,如果未找到则返回None - """ + """通过字体哈希值查找对应的Unicode字符编码.""" + # + # Args: + # font_hash: 字体哈希值 + # + # Returns: + # 对应的Unicode字符编码,如果未找到则返回None return self.hash_map.get(font_hash) def find_hash(self, char: str) -> Optional[str]: - """ - 通过Unicode字符编码查找对应的字体哈希值 - - Args: - char: Unicode字符编码 (如 "uni4E00") - - Returns: - 对应的字体哈希值,如果未找到则返回None - """ + """通过Unicode字符编码查找对应的字体哈希值.""" + # + # Args: + # char: Unicode字符编码 (如 "uni4E00") + # + # Returns: + # 对应的字体哈希值,如果未找到则返回None return self.char_map.get(char) @@ -111,15 +108,13 @@ def find_hash(self, char: str) -> Optional[str]: def hash_glyph(glyph: Glyph) -> str: - """ - 计算TTF字体字形的哈希值 - - Args: - glyph: TTF字体字形对象 - - Returns: - 字形的MD5哈希值 - """ + """计算TTF字体字形的哈希值.""" + # + # Args: + # glyph: TTF字体字形对象 + # + # Returns: + # 字形的MD5哈希值 if glyph.numberOfContours <= 0: return "" @@ -139,18 +134,16 @@ def hash_glyph(glyph: Glyph) -> str: def font2map(font_data: Union[IO, Path, str]) -> Dict[str, str]: - """ - 从字体文件或Base64编码的字体数据中提取字形哈希映射表 - - Args: - font_data: 字体文件路径、文件对象或Base64编码的字体数据 - - Returns: - 字形名称到哈希值的映射字典 ({"uni4E00": "hash值", ...}) - - Raises: - ValueError: 当无法解析字体数据时 - """ + """从字体文件或Base64编码的字体数据中提取字形哈希映射表.""" + # + # Args: + # font_data: 字体文件路径、文件对象或Base64编码的字体数据 + # + # Returns: + # 字形名称到哈希值的映射字典 ({"uni4E00": "hash值", ...}) + # + # Raises: + # ValueError: 当无法解析字体数据时 font_hashmap = {} # 处理Base64编码的字体数据 @@ -175,16 +168,14 @@ def font2map(font_data: Union[IO, Path, str]) -> Dict[str, str]: def decrypt(dst_fontmap: Dict[str, str], encrypted_text: str) -> str: - """ - 解密超星学习通加密字体的文本 - - Args: - dst_fontmap: 目标字体的字形哈希映射表 - encrypted_text: 加密的文本 - - Returns: - 解密后的文本 - """ + """解密超星学习通加密字体的文本.""" + # + # Args: + # dst_fontmap: 目标字体的字形哈希映射表 + # encrypted_text: 加密的文本 + # + # Returns: + # 解密后的文本 result = [] for char in encrypted_text: diff --git a/api/decode.py b/api/decode.py index c1d20a7b9..52bb754bc 100644 --- a/api/decode.py +++ b/api/decode.py @@ -1,10 +1,8 @@ # -*- coding: utf-8 -*- -""" -超星学习通数据解析模块 - -该模块负责解析超星学习通平台的课程、章节、任务点等各种数据, -并转换为程序内部使用的结构化数据格式。 -""" +"""超星学习通数据解析模块.""" +# +# 该模块负责解析超星学习通平台的课程、章节、任务点等各种数据, +# 并转换为程序内部使用的结构化数据格式。 import json import re from typing import List, Dict, Tuple, Any, Optional @@ -15,16 +13,70 @@ from api.logger import logger +# 平台上常见的"特殊空白"字符。 ( ) 在 GBK 控制台里无法编码, +# print 时会直接抛 UnicodeEncodeError 把程序打崩(#602),统一换成普通空格。 +_EXOTIC_CHARS = { + " ": " ", #   不间断空格 + " ": " ", # 图形空格 + " ": " ", # 窄不换行空格 + " ": " ", # 全角空格 + "​": "", # 零宽空格 + "‌": "", + "‍": "", + "": "", # BOM +} + + +def _sel_text(node, selector, default="") -> str: + """安全取选择器命中的文本:页面结构变了也只是取到空,不会抛 NoneType.text.""" + try: + found = node.select_one(selector) + except Exception: + return default + if not found: + return default + try: + return found.text + except Exception: + return default + + +def _sel_attr(node, selector, attr, default="") -> str: + """安全取选择器命中的属性值(同上,不会抛 NoneType.attrs).""" + try: + found = node.select_one(selector) + except Exception: + return default + if not found: + return default + try: + value = found.attrs.get(attr, default) + except Exception: + return default + if isinstance(value, list): + value = value[0] if value else default + return default if value is None else value + + +def clean_text(text) -> str: + """清理平台返回文本里的特殊空白字符,并把连续空格压成一个.""" + if text is None: + return "" + text = str(text) + for src, dst in _EXOTIC_CHARS.items(): + if src in text: + text = text.replace(src, dst) + return re.sub(r"[ \t\u00a0]{2,}", " ", text).strip() + + def decode_course_list(html_text: str) -> List[Dict[str, str]]: - """ - 解析课程列表页面,提取课程信息 - - Args: - html_text: 课程列表页面的HTML内容 - - Returns: - 课程信息列表,每个课程包含id、title、teacher等信息 - """ + """解析课程列表页面,提取课程信息.""" + # + # Args: + # html_text: 课程列表页面的HTML内容 + # + # Returns: + # 课程信息列表,每个课程包含id、title、teacher等信息 logger.trace("开始解码课程列表...") soup = BeautifulSoup(html_text, "lxml") raw_courses = soup.select("div.course") @@ -35,16 +87,27 @@ def decode_course_list(html_text: str) -> List[Dict[str, str]]: if course.select_one("a.not-open-tip") or course.select_one("div.not-open-tip"): continue + # 平台改版时字段可能缺失,缺了就当这条有问题跳过并记一条日志, + # 不能让整个课程列表直接崩掉(#58 / #392 这类 KeyError / AttributeError) + clazz_id = _sel_attr(course, "input.clazzId", "value") + course_id = _sel_attr(course, "input.courseId", "value") + cpi_match = re.findall(r"cpi=(.*?)&", _sel_attr(course, "a", "href")) + title = clean_text(_sel_attr(course, "span.course-name", "title")) or clean_text( + _sel_text(course, "span.course-name")) + if not (clazz_id and course_id and cpi_match and title): + logger.warning("课程条目缺少必要字段,已跳过: {}", str(course.attrs)[:200]) + continue + course_detail = { - "id": course.attrs["id"], - "info": course.attrs["info"], - "roleid": course.attrs["roleid"], - "clazzId": course.select_one("input.clazzId").attrs["value"], - "courseId": course.select_one("input.courseId").attrs["value"], - "cpi": re.findall(r"cpi=(.*?)&", course.select_one("a").attrs["href"])[0], - "title": course.select_one("span.course-name").attrs["title"], - "desc": course.select_one("p.margint10").attrs["title"] if course.select_one("p.margint10") else "", - "teacher": course.select_one("p.color3").attrs["title"] + "id": course.attrs.get("id", ""), + "info": course.attrs.get("info", ""), + "roleid": course.attrs.get("roleid", ""), + "clazzId": clazz_id, + "courseId": course_id, + "cpi": cpi_match[0], + "title": title, + "desc": clean_text(_sel_attr(course, "p.margint10", "title")), + "teacher": clean_text(_sel_attr(course, "p.color3", "title")) } course_list.append(course_detail) @@ -52,43 +115,46 @@ def decode_course_list(html_text: str) -> List[Dict[str, str]]: def decode_course_folder(html_text: str) -> List[Dict[str, str]]: - """ - 解析二级课程列表页面,提取文件夹信息 - - Args: - html_text: 二级课程列表页面的HTML内容 - - Returns: - 课程文件夹信息列表 - """ + """解析二级课程列表页面,提取文件夹信息.""" + # + # Args: + # html_text: 二级课程列表页面的HTML内容 + # + # Returns: + # 课程文件夹信息列表 logger.trace("开始解码二级课程列表...") soup = BeautifulSoup(html_text, "lxml") raw_courses = soup.select("ul.file-list>li") course_folder_list = [] for course in raw_courses: - if not course.attrs.get("fileid"): + folder_id = course.attrs.get("fileid") + if not folder_id: continue - course_folder_detail = { - "id": course.attrs["fileid"], - "rename": course.select_one("input.rename-input").attrs["value"] - } - course_folder_list.append(course_folder_detail) + # 目录条目缺 rename-input 时跳过这一条并告警, + # 不能让一个目录把整个课程列表读取打断 + folder_name = _sel_attr(course, "input.rename-input", "value") + if not folder_name: + logger.warning("课程目录条目缺少名称,已跳过: {}", str(course.attrs)[:150]) + continue + + course_folder_list.append({ + "id": folder_id, + "rename": clean_text(folder_name), + }) return course_folder_list def decode_course_point(html_text: str) -> Dict[str, Any]: - """ - 解析章节列表页面,提取章节点信息 - - Args: - html_text: 章节列表页面的HTML内容 - - Returns: - 章节信息字典,包含是否锁定状态和章节点列表 - """ + """解析章节列表页面,提取章节点信息.""" + # + # Args: + # html_text: 章节列表页面的HTML内容 + # + # Returns: + # 章节信息字典,包含是否锁定状态和章节点列表 logger.trace("开始解码章节列表...") soup = BeautifulSoup(html_text, "lxml") course_point = { @@ -109,38 +175,42 @@ def decode_course_point(html_text: str) -> Dict[str, Any]: def _extract_points_from_chapter(chapter_unit) -> List[Dict[str, Any]]: - """ - 从章节单元中提取章节点信息 - - Args: - chapter_unit: BeautifulSoup对象,表示一个章节单元 - - Returns: - 章节点信息列表 - """ + """从章节单元中提取章节点信息.""" + # + # Args: + # chapter_unit: BeautifulSoup对象,表示一个章节单元 + # + # Returns: + # 章节点信息列表 point_list = [] raw_points = chapter_unit.find_all("li") for raw_point in raw_points: point = raw_point.div - if "id" not in point.attrs: + if point is None or "id" not in point.attrs: + continue + + # id 解析不出来就跳过这一条,别用 [0] 直接 IndexError(#22 / #374) + id_match = re.findall(r"^cur(\d{1,20})$", str(point.attrs.get("id", ""))) + if not id_match: + logger.warning("章节点 id 异常,已跳过: {}", str(point.attrs)[:120]) continue + point_id = id_match[0] - point_id = re.findall(r"^cur(\d{1,20})$", point.attrs["id"])[0] - point_title = point.select_one("a.clicktitle").text.replace("\n", "").strip() + point_title = clean_text(_sel_text(point, "a.clicktitle").replace("\n", "")) or "未命名章节" # 提取任务数量 job_count = 1 # 默认为1 need_unlock = False - if point.select_one("input.knowledgeJobCount"): - job_count = point.select_one("input.knowledgeJobCount").attrs["value"] - elif point.select_one("span.bntHoverTips") and "解锁" in point.select_one("span.bntHoverTips").text: + hover_tips = _sel_text(point, "span.bntHoverTips") + job_count_attr = _sel_attr(point, "input.knowledgeJobCount", "value") + if job_count_attr: + job_count = job_count_attr + elif "解锁" in hover_tips: need_unlock = True # 判断是否已完成 - is_finished = False - if point.select_one("span.bntHoverTips") and "已完成" in point.select_one("span.bntHoverTips").text: - is_finished = True + is_finished = "已完成" in hover_tips point_detail = { "id": point_id, @@ -155,15 +225,13 @@ def _extract_points_from_chapter(chapter_unit) -> List[Dict[str, Any]]: def decode_course_card(html_text: str) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]: - """ - 解析任务点列表页面,提取任务点信息 - - Args: - html_text: 任务点列表页面的HTML内容 - - Returns: - 任务点列表和任务信息的元组 - """ + """解析任务点列表页面,提取任务点信息.""" + # + # Args: + # html_text: 任务点列表页面的HTML内容 + # + # Returns: + # 任务点列表和任务信息的元组 logger.trace("开始解码任务点列表...") # 检查章节是否未开放 @@ -173,10 +241,20 @@ def decode_course_card(html_text: str) -> Tuple[List[Dict[str, Any]], Dict[str, # 提取mArg参数 temp = re.findall(r"mArg=\{(.*?)\};", html_text.replace(" ", "")) if not temp: - return [], {} - - # 解析JSON数据 - cards_data = json.loads("{" + temp[0] + "}") + # 正常的学习页面一定带 mArg;取不到说明拿到的是登录页/验证码页/ + # 改版页面。标记 parseError,让上层按"读取失败"重试, + # 绝不能当成"这个章节没有任务点"直接打勾(#223 / #357)。 + # 逐页的"找不到 mArg"不再单独记日志:新版只有第 0 页带 mArg, + # 由 api/base.py 的 get_job_list 汇总成一条。 + return [], {"parseError": True} + + # 解析JSON数据。mArg 片段可能因为平台改版/截断而不是合法 JSON, + # 这里必须兜住:抛出去会让整个章节失败,兜住后按"读取失败"重试更靠谱 + try: + cards_data = json.loads("{" + temp[0] + "}") + except (ValueError, TypeError) as e: + logger.warning("任务点数据解析失败(mArg 不是合法 JSON): {}", e) + return [], {"parseError": True} if not cards_data: return [], {} @@ -186,21 +264,21 @@ def decode_course_card(html_text: str) -> Tuple[List[Dict[str, Any]], Dict[str, # 处理所有附件任务 cards = cards_data.get("attachments", []) - job_list = _process_attachment_cards(cards) + job_list, unknown_types = _process_attachment_cards(cards) + if unknown_types: + job_info["unknownCardTypes"] = unknown_types return job_list, job_info def _extract_job_info(cards_data: Dict[str, Any]) -> Dict[str, Any]: - """ - 从卡片数据中提取任务基本信息 - - Args: - cards_data: 卡片数据字典 - - Returns: - 任务基本信息字典 - """ + """从卡片数据中提取任务基本信息.""" + # + # Args: + # cards_data: 卡片数据字典 + # + # Returns: + # 任务基本信息字典 defaults = cards_data.get("defaults", {}) if not defaults: return {} @@ -217,17 +295,20 @@ def _extract_job_info(cards_data: Dict[str, Any]) -> Dict[str, Any]: } -def _process_attachment_cards(cards: List[Dict[str, Any]]) -> List[Dict[str, Any]]: - """ - 处理所有附件任务卡片,强化直播任务识别逻辑 - - Args: - cards: 附件任务卡片列表 - - Returns: - 处理后的任务列表 - """ +def _process_attachment_cards(cards: List[Dict[str, Any]]) -> Tuple[List[Dict[str, Any]], List[str]]: + """处理所有附件任务卡片,强化直播任务识别逻辑.""" + # + # Args: + # cards: 附件任务卡片列表 + # + # Returns: + # (处理后的任务列表, 无法识别的卡片类型列表) + # + # 平台新增任务点类型时必须让上层知道:整章卡片都不认识 → 任务列表为空, + # 以前会走"空章节"分支把章节记成完成(假完成)。现在把未知类型带上去, + # 由 get_job_list 按"读取失败"处理。 job_list = [] + unknown_types: List[str] = [] for index, card in enumerate(cards): # 跳过已通过的任务 @@ -285,14 +366,17 @@ def _process_attachment_cards(cards: List[Dict[str, Any]]) -> List[Dict[str, Any if work_job: job_list.append(work_job) else: - logger.warning(f"Unknown card type: {card_type}") - logger.warning(card) + # 未知类型不能静默丢弃:整章都是未知卡片时会被误判成"空章节已完成" + logger.error(f"Unknown card type: {card_type}") + logger.debug(card) + if card_type not in unknown_types: + unknown_types.append(card_type) - return job_list + return job_list, unknown_types def _process_live_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: - """处理直播类型任务,提取所有必要参数""" + """处理直播类型任务,提取所有必要参数.""" try: property_data = card.get("property", {}) return { @@ -314,7 +398,7 @@ def _process_live_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: def _process_read_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: - """处理阅读类型任务""" + """处理阅读类型任务.""" if not (card.get("type") == "read" and not card.get("property", {}).get("read", False)): return None @@ -332,7 +416,7 @@ def _process_read_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: def _process_video_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: - """处理视频类型任务""" + """处理视频类型任务.""" try: return { "type": "video", @@ -354,7 +438,7 @@ def _process_video_task(card: Dict[str, Any]) -> Optional[Dict[str, Any]]: def _process_document_task(card: Dict[str, Any]) -> Dict[str, Any]: - """处理文档类型任务""" + """处理文档类型任务.""" return { "type": "document", "jobid": card.get("jobid", ""), @@ -368,7 +452,7 @@ def _process_document_task(card: Dict[str, Any]) -> Dict[str, Any]: def _process_work_task(card: Dict[str, Any]) -> Dict[str, Any]: - """处理作业类型任务""" + """处理作业类型任务.""" return { "type": "workid", "jobid": card.get("jobid", ""), @@ -380,15 +464,13 @@ def _process_work_task(card: Dict[str, Any]) -> Dict[str, Any]: def decode_questions_info(html_content: str) -> Dict[str, Any]: - """ - 解析题目信息,提取表单数据和问题列表 - - Args: - html_content: 题目页面HTML内容 - - Returns: - 包含表单数据和问题列表的字典 - """ + """解析题目信息,提取表单数据和问题列表.""" + # + # Args: + # html_content: 题目页面HTML内容 + # + # Returns: + # 包含表单数据和问题列表的字典 soup = BeautifulSoup(html_content, "lxml") form_data = _extract_form_data(soup) @@ -403,7 +485,16 @@ def decode_questions_info(html_content: str) -> Dict[str, Any]: # 处理所有问题 questions = [] - for div_tag in soup.find("form").find_all("div", class_="singleQuesId"): + form_tag = soup.find("form") + if form_tag is None: + # 页面结构异常(最常见的是接口返回了登录页),交给上层按"无效响应"重试, + # 不要在这里抛 NoneType.find_all 把任务打挂(#593) + logger.warning("题目页面没有找到 form 表单,可能是登录页或页面结构变化") + form_data["questions"] = [] + form_data["answerwqbid"] = "" + return form_data + + for div_tag in form_tag.find_all("div", class_="singleQuesId"): question = _process_question(div_tag, font_decoder) if question: questions.append(question) @@ -416,10 +507,13 @@ def decode_questions_info(html_content: str) -> Dict[str, Any]: def _extract_form_data(soup: BeautifulSoup) -> Dict[str, Any]: - """从BeautifulSoup对象中提取表单数据""" - form_data = {} - form_tag = soup.find("form") + """从BeautifulSoup对象中提取表单数据.""" + return _extract_form_fields(soup.find("form")) + +def _extract_form_fields(form_tag) -> Dict[str, Any]: + """从 form 标签里提取所有非答案字段的 input.""" + form_data = {} if not form_tag: return form_data @@ -448,11 +542,125 @@ def _extract_form_data(soup: BeautifulSoup) -> Dict[str, Any]: return form_data +# 任务中心作业页(mooc2/work/dowork)的题型名 -> 题型代码(与 _get_question_type 对应) +_HOMEWORK_TYPE_CODES = { + "单选题": "0", + "多选题": "1", + "填空题": "2", + "判断题": "3", + "简答题": "4", +} + + +def decode_homework_page(html_content: str) -> Dict[str, Any]: + """解析「任务中心 -> 作业」的作答页(mooc2/work/dowork).""" + # + # 和章节测验页(knowledge/cards 里的 TiMu/Zy_TItle)结构不同: + # * 题型在隐藏 input answertype<题目id> 的 value 里(旧页在 div.TiMu 的 data 上) + # * 题干在 h3.mark_name,选项在 div.stem_answer 的 div.answerBg(带 aria-label) + # * 提交地址在 form#submitForm 的 action 上(带 token / totalQuestionNum), + # 提交接口是 addStudentWorkNewWeb,不是章节测验的 addStudentWorkNew + # + # 返回结构和 decode_questions_info 对齐(form 隐藏字段 + questions + answerwqbid), + # 额外带 form_action / form_method,供提交时原样复用。 + soup = BeautifulSoup(html_content, "lxml") + form_tag = soup.find("form", id="submitForm") or soup.find("form") + if form_tag is None: + logger.warning("作业页面没有找到 form 表单,可能是登录页或页面结构变化") + return {"questions": [], "answerwqbid": ""} + + form_data = _extract_form_fields(form_tag) + form_data["form_action"] = str(form_tag.attrs.get("action") or "") + form_data["form_method"] = str(form_tag.attrs.get("method") or "post").lower() + + font_decoder = None + if soup.find("style", id="cxSecretStyle"): + font_decoder = FontDecoder(html_content) + logger.info("作业页面有字体加密,已启用字体解密") + + questions = [] + for div_tag in form_tag.find_all("div", class_="singleQuesId"): + question = _process_homework_question(div_tag, form_tag, font_decoder) + if question: + questions.append(question) + + form_data["questions"] = questions + form_data["answerwqbid"] = ( + ",".join(q["id"] for q in questions) + "," if questions else "" + ) + return form_data + + +def _extract_homework_title(div_tag, font_decoder=None) -> str: + """提取作业题干.""" + # + # 作业页的题干是 "

1.(多选题)

题干…

",但

嵌在 + #

里属于非法 HTML,lxml 会把

提前闭合,题干段落变成 h3 的兄弟节点。 + # 只取 h3 会丢题干(实测第 1 题、填空题全部丢),所以这里按 DOM 顺序拼到 + # "选项区(div.stem_answer)"之前的所有文本。 + parts = [] + for child in div_tag.children: + name = getattr(child, "name", None) + if name == "div" and "stem_answer" in (child.get("class") or []): + break + if name == "input": + continue + if isinstance(child, NavigableString): + parts.append(str(child)) + elif name in ("h3", "p", "span", "div"): + parts.append(_extract_title(child, font_decoder)) + return clean_text("".join(parts)) + + +def _process_homework_question(div_tag, form_tag, font_decoder=None) -> Optional[Dict[str, Any]]: + """解析作业页里的单道题目(新版结构).""" + question_id = str(div_tag.attrs.get("data") or "").strip() + if not question_id: + return None + + type_code = "" + type_input = form_tag.find("input", attrs={"name": f"answertype{question_id}"}) + if type_input is not None: + type_code = str(type_input.attrs.get("value", "")).strip() + if not type_code: + type_name = str(div_tag.attrs.get("typeName") or "").strip() + type_code = _HOMEWORK_TYPE_CODES.get(type_name, "") + q_type = _get_question_type(type_code) + + q_title = _extract_homework_title(div_tag, font_decoder) + + options = [] + stem = div_tag.find("div", class_="stem_answer") + if stem is not None: + for option_tag in stem.find_all("div", class_="answerBg"): + text = _extract_choices(option_tag, font_decoder) + if text: + options.append(text) + if not options: + for li in stem.find_all("li"): + text = _extract_choices(li, font_decoder) + if text: + options.append(text) + options.sort() + + return { + "id": question_id, + "title": q_title, + "options": "\n".join(options), + "type": q_type, + "answerField": { + f"answer{question_id}": "", + f"answertype{question_id}": type_code, + }, + } + + def _process_question(div_tag, font_decoder=None) -> Dict[str, Any]: - """处理单个问题""" + """处理单个问题.""" # 提取问题ID和题目类型 question_id = div_tag.attrs.get("data", "") - q_type_code = div_tag.find("div", class_="TiMu").attrs.get("data", "") + timu_tag = div_tag.find("div", class_="TiMu") + q_type_code = timu_tag.attrs.get("data", "") if timu_tag is not None else "" q_type = _get_question_type(q_type_code) # 提取题目内容和选项 @@ -481,11 +689,12 @@ def _process_question(div_tag, font_decoder=None) -> Dict[str, Any]: def _get_question_type(type_code: str) -> str: - """根据题型代码返回题型名称""" + """根据题型代码返回题型名称.""" type_map = { "0": "single", # 单选题 "1": "multiple", # 多选题 "2": "completion", # 填空题 + "10": "completion", # 新版填空题 "3": "judgement", # 判断题 "4": "shortanswer", # 简答题 } @@ -498,7 +707,7 @@ def _get_question_type(type_code: str) -> str: def _extract_title(element, font_decoder=None) -> str: - """提取标题内容,支持解码加密字体""" + """提取标题内容,支持解码加密字体.""" if not element: return "" @@ -516,28 +725,37 @@ def _extract_title(element, font_decoder=None) -> str: # 如果有字体解码器,进行解码 if font_decoder: - return font_decoder.decode(cleaned_content) + return clean_text(font_decoder.decode(cleaned_content)) - return cleaned_content + return clean_text(cleaned_content) def _extract_choices(element, font_decoder=None) -> str: - """提取选项内容,支持解码加密字体""" + """提取选项内容,支持解码加密字体.""" if not element: return "" # 提取aria-label属性值作为选项,解决#474 - choice = element.get("aria-label") or element.get_text() - if not choice: - return "" + choice = element.get("aria-label") or element.get_text() or "" cleaned_content = re.sub(r"[\r\t\n]", "", choice) - if font_decoder: + if font_decoder and cleaned_content: cleaned_content = font_decoder.decode(cleaned_content) - cleaned_content = cleaned_content.strip() + cleaned_content = clean_text(cleaned_content) if cleaned_content.endswith("选择"): cleaned_content = cleaned_content[:-2].rstrip() + # 选项本身可能就是一张图片(电路图 / 公式图 / 结构图): + # 这时 aria-label 往往只有选项字母,真正的题目内容在 里。 + # 不把图片地址带上,传给题库的选项就退化成一串字母,图片题只能随机作答(#457)。 + # 只有"除了选项字母没有别的文字"时才追加,避免给普通文字选项加噪音。 + img_urls = [img.get("src", "") for img in element.find_all("img") if img.get("src")] + if img_urls: + bare = re.sub(r"^[A-Za-z]\s*[.、::]?\s*", "", cleaned_content).strip() + if not bare: + images = " ".join(f'' for url in img_urls) + cleaned_content = (cleaned_content + " " + images).strip() + return cleaned_content diff --git a/api/discussion.py b/api/discussion.py new file mode 100644 index 000000000..97303d9f0 --- /dev/null +++ b/api/discussion.py @@ -0,0 +1,441 @@ +# -*- coding: utf-8 -*- +"""讨论区浏览 + 挑帖子回复(模式 2).""" +# +# 模式 1 是"任务里的主题讨论":任务中心里 planType=14 的任务点,按分组顺序自动刷。 +# 模式 2 就是这里:先只读统计讨论区有多少帖子 → 用户挑要回复哪几条 → 逐条给草稿、 +# 确认后再发送。 +# +# 接口(,groupweb.chaoxing.com): +# * 帖子列表 GET /pc/topic/topiclist/{bbsid}/getTopicList +# ?folder_uuid=&page=1&pageSize=20&kw=&last_reply_time=&searchType=&authMappId=&isSetTop=1 +# * 帖子详情与发回复复用 TaskCenter.draft_reply / submit_reply(与模式 1 同一条链路)。 + +import re +import textwrap +import time +from typing import List, Optional, Tuple + +from api.logger import logger + +TOPIC_LIST_PATH = "/pc/topic/topiclist/{bbsid}/getTopicList" +DEFAULT_PAGE_SIZE = 20 +MAX_PAGES = 10 +SEND_INTERVAL_SECONDS = 1.5 +MAX_REVISION_HINT_LENGTH = 120 + + +def clip_text(text, limit: int = 20) -> str: + """按显示宽度截断(中文算 2 列),用于列表/预览行不撑爆终端.""" + value = re.sub(r"\s+", " ", str(text or "")).strip() + width = 0 + out = [] + for ch in value: + w = 2 if ord(ch) > 127 else 1 + if width + w > limit: + return "".join(out) + "…" + out.append(ch) + width += w + return value + + +def normalize_topic(item: dict) -> dict: + """把接口返回的一条帖子整理成界面要用的字段.""" + item = item or {} + title = str(item.get("title") or "").strip() + content = re.sub(r"\s+", " ", str(item.get("content") or "")).strip() + last = item.get("lastReply") or {} + return { + "uuid": str(item.get("uuid") or ""), + "id": item.get("id"), + "title": title or content, + "content": content, + "author": str(item.get("createrName") or "").strip(), + "reply_count": int(item.get("reply_count") or 0), + "time": str(item.get("ftime") or "").strip(), + "last_reply_name": str(last.get("name") or "").strip(), + "last_reply_time": str(last.get("formattime") or "").strip(), + "tags": str(item.get("tags") or "").strip(), + "top": bool(item.get("top")), + } + + +def fetch_topics(session, bbsid: str, page: int = 1, page_size: int = DEFAULT_PAGE_SIZE, + keyword: str = "", base: str = "") -> List[dict]: + """只读拉一页帖子;失败返回空列表(不抛异常).""" + from api.task_center import DISCUSSION_BASE + url = (base or DISCUSSION_BASE) + TOPIC_LIST_PATH.format(bbsid=bbsid) + params = { + "folder_uuid": "", + "page": max(1, int(page or 1)), + "pageSize": max(1, int(page_size or DEFAULT_PAGE_SIZE)), + "kw": keyword or "", + "last_reply_time": "", + "searchType": "", + "authMappId": "", + "isSetTop": "1", + } + try: + resp = session.get(url, params=params, timeout=20) + except Exception as e: + logger.warning("讨论区帖子列表请求失败: {}", e) + return [] + if getattr(resp, "status_code", 0) != 200: + logger.warning("讨论区帖子列表读取失败: HTTP {}", getattr(resp, "status_code", "?")) + return [] + try: + data = resp.json() + except ValueError: + logger.warning("讨论区帖子列表返回的不是 JSON(可能登录失效或页面改版)") + return [] + if not isinstance(data, dict) or not data.get("status"): + logger.warning("讨论区帖子列表被平台拒绝: {}", str(data)[:150]) + return [] + items = data.get("datas") + if not isinstance(items, list): + return [] + return [normalize_topic(it) for it in items if isinstance(it, dict) and it.get("uuid")] + + +def fetch_all_topics(session, bbsid: str, max_pages: int = MAX_PAGES) -> Tuple[List[dict], bool]: + """把讨论区的帖子读出来(只读,最多 max_pages 页).""" + # + # 返回 (帖子列表, 是否因为页数上限被截断)——截断时界面上要说"至少 N 条", + # 不能假装这就是全部。 + topics: List[dict] = [] + capped = False + for page in range(1, max(1, int(max_pages)) + 1): + batch = fetch_topics(session, bbsid, page=page) + if not batch: + break + topics.extend(batch) + if len(batch) < DEFAULT_PAGE_SIZE: + return topics, False + if page == max(1, int(max_pages)): + capped = True + return topics, capped + + +def resolve_bbsid(tc, course: dict) -> str: + """拿到课程的讨论区板块 id:优先问任务中心里的主题讨论任务点.""" + direct = str((course or {}).get("bbsid") or "").strip() + if direct: + return direct + try: + from api.task_center import PLAN_TYPE_DISCUSS + for task in tc.get_course_tasks(course) or []: + info = tc.open_task(task) + if not info: + continue + groups = tc.get_groups(info.get("encryTaskUserId", "")) or [] + for group in groups: + plans = tc.get_plans(info.get("encryTaskUserId", ""), + group.get("encryptGroupId", "")) or [] + for plan in plans: + if int(plan.get("planType") or -1) != PLAN_TYPE_DISCUSS: + continue + url = tc.get_study_url(info.get("encryTaskUserId", ""), + plan.get("encryptPlanId")) + matched = re.search(r"bbsid=([0-9a-fA-F]+)", url or "") + if matched: + return matched.group(1) + except Exception as e: + logger.debug("从任务中心解析讨论区板块失败: {}", e) + return "" + + +def render_topics(topics: List[dict], page: int = 1, offset: int = 0, + page_size: int = DEFAULT_PAGE_SIZE) -> str: + """列表视图:全局编号 + 回复数 + 作者 + 时间 + 正文.""" + if not topics: + return "\n 这一页没有帖子(可能已经翻到底,或该课程还没开放讨论区)。\n" + lines = ["", f" 第 {page} 页 · 第 {offset + 1}–{offset + len(topics)} 条", ""] + for idx, topic in enumerate(topics, 1): + number = offset + idx + who = topic.get("author") or "同学" + when = topic.get("time") or topic.get("last_reply_time") or "" + head = f" {number:>3}. [{topic.get('reply_count', 0)} 回复] {who}" + if when: + head += f" · {when}" + lines.append(head) + body = textwrap.fill(topic.get("title") or topic.get("content") or "", + width=62, initial_indent=" ", subsequent_indent=" ") + lines.append(body) + lines.append("") + return "\n".join(lines) + + +def parse_selection(raw: str, total: int) -> Optional[List[int]]: + """把 "1,3,5" / "1-3" / "all" 解析成 1 基序号列表;解析不了返回 None.""" + text = str(raw or "").strip().lower() + if not text: + return None + if text in ("all", "全部", "*"): + return list(range(1, total + 1)) + picked: List[int] = [] + for part in re.split(r"[,,、\s]+", text): + if not part: + continue + if "-" in part: + left, _, right = part.partition("-") + if not (left.strip().isdigit() and right.strip().isdigit()): + return None + start, end = int(left), int(right) + if start > end: + start, end = end, start + picked.extend(range(start, end + 1)) + elif part.isdigit(): + picked.append(int(part)) + else: + return None + picked = [n for n in dict.fromkeys(picked) if 1 <= n <= total] + return picked or None + + +def _ask(prompt: str) -> str: + try: + return input(prompt).strip() + except (EOFError, KeyboardInterrupt): + return "q" + + +def _revision_hint() -> str: + """读取一条简短重写方向;空白也允许,表示换一种写法.""" + hint = _ask(" 说说怎么改(如“更短一点、少讲案例”;回车=换一种写法) ") + if hint.lower() in ("q", "quit", "exit"): + return "q" + hint = hint.strip() + if len(hint) > MAX_REVISION_HINT_LENGTH: + print(f" · 优化方向过长,只取前 {MAX_REVISION_HINT_LENGTH} 个字") + hint = hint[:MAX_REVISION_HINT_LENGTH] + return hint or "换一种更自然、直接的说法,不要沿用上一版的句式。" + + +def _pick_course(courses: list, list_only: bool) -> Optional[dict]: + if len(courses) == 1 or list_only: + return courses[0] + print() + print(" 选择课程") + print(" " + "─" * 46) + for i, c in enumerate(courses, 1): + print(f" {i:>2}. {c.get('title', '')}") + print() + raw = _ask(" ▶ 输入序号 [回车=1 · q 退出] ") + if raw.lower() in ("q", "quit", "exit"): + return None + if raw == "": + return courses[0] + if raw.isdigit() and 1 <= int(raw) <= len(courses): + return courses[int(raw) - 1] + print(" ✘ 没有这个选项") + return None + + +def _board_course(tc, courses: list) -> Tuple[Optional[dict], str]: + """按顺序找第一门有讨论区的课程.""" + for course in courses: + bbsid = resolve_bbsid(tc, course) + if bbsid: + return course, bbsid + return None, "" + + +def _pick_reply_topics(topics, list_only): + """Browse pages and select topic indices, preserving safe exit behavior.""" + page_size = DEFAULT_PAGE_SIZE + page = 1 + total_pages = max(1, (len(topics) + page_size - 1) // page_size) + picked: List[int] = [] + while True: + offset = (page - 1) * page_size + chunk = topics[offset:offset + page_size] + print(render_topics(chunk, page=page, offset=offset, page_size=page_size)) + if list_only: + return {"ok": True, "sent": 0, "skipped": 0, "reason": "只列不回复"} + hint = "n 下一页" if page < total_pages else "" + back = "p 上一页" if page > 1 else "" + keys = " · ".join([k for k in (back, hint, "q 退出") if k]) + raw = _ask(f" ▶ 选要回复的帖子(如 1,3,5 / 1-3 / all;{keys}) ") + low = raw.lower() + if low in ("q", "quit", "exit", ""): + return {"ok": True, "sent": 0, "skipped": 0, "reason": "用户退出"} + if low == "n": + page = min(total_pages, page + 1) + continue + if low == "p": + page = max(1, page - 1) + continue + picked = parse_selection(raw, len(topics)) or [] + if not picked: + print(" ✘ 没看懂,可以填 1,3,5 / 1-3 / all") + continue + break + + return picked + + +def _reply_selected_topics(tc, bbsid, course, chosen): + """Preview, rewrite and individually confirm each selected reply.""" + sent = 0 + skipped = 0 + for index, topic in enumerate(chosen, 1): + name = topic.get("title") or "讨论区帖子" + print(f" [{index}/{len(chosen)}] {clip_text(name, 34)}") + draft = tc.draft_reply(bbsid, topic["uuid"], course=course, name=name) + if draft is None: + print(" ✘ 这条没生成出草稿,跳过") + skipped += 1 + print() + continue + if draft.get("has_replied"): + print(" · 你之前已经回复过这条,跳过(不重复发)") + skipped += 1 + print() + continue + while True: + print(" " + "─" * 44) + for line in textwrap.wrap(draft["reply"], width=60): + print(" " + line) + print(" " + "─" * 44) + # 安全默认:回车 = 跳过;r 只重写草稿,绝不提交任何版本。 + answer = _ask(" 怎么处理?[y 发送 · r 按提示重写 · 回车跳过 · q 退出] ") + if answer.lower() in ("q", "quit", "exit"): + print() + print(f" 已停止:发送 {sent} 条 · 跳过 {skipped} 条") + return {"ok": True, "sent": sent, "skipped": skipped, "reason": "用户中途退出"} + if answer.lower() in ("r", "rewrite", "改", "重写"): + hint = _revision_hint() + if hint == "q": + print() + print(f" 已停止:发送 {sent} 条 · 跳过 {skipped} 条") + return {"ok": True, "sent": sent, "skipped": skipped, "reason": "用户中途退出"} + revised = tc.draft_reply( + bbsid, topic["uuid"], course=course, name=name, + revision_hint=hint, previous_reply=draft["reply"], + ) + if revised is None: + print(" ✘ 没能重写草稿,保留这一版供你决定") + continue + if revised.get("has_replied"): + print(" · 你之前已经回复过这条,跳过(不重复发)") + skipped += 1 + print() + break + draft = revised + print(" · 已按你的方向重写,请再看一眼") + continue + if answer.lower() not in ("y", "yes", "是", "1"): + print(" · 已跳过这条") + skipped += 1 + print() + break + ok = tc.submit_reply(bbsid, topic["uuid"], course=course, name=name, + topic_info=draft["topic_info"], reply=draft["reply"], + referer=draft["referer"], echo=False) + if ok: + print(" ✓ 已发送") + sent += 1 + else: + print(" ✘ 发送失败(详见运行日志)") + skipped += 1 + print() + break + if index < len(chosen): + time.sleep(SEND_INTERVAL_SECONDS) + + return {"ok": True, "sent": sent, "skipped": skipped, "reason": ""} + + +def _select_discussion_course(tc, courses, list_only): + """Select a board course and confirm any fallback to a different course.""" + course = _pick_course(courses, list_only) + if course is None: + return {"ok": False, "sent": 0, "skipped": 0, "reason": "没有选择课程"} + + bbsid = resolve_bbsid(tc, course) + if not bbsid: + # 用户选的那门课没有讨论区:问一句再换,绝不静默改课 + others = [c for c in courses if c is not course] + picked_course, picked_bbsid = _board_course(tc, others) + if picked_course is None: + print(f" ✘ 《{course.get('title', '')}》没有讨论区板块,其它课程也没有") + return {"ok": False, "sent": 0, "skipped": 0, "reason": "没有找到讨论区板块"} + if list_only: + course, bbsid = picked_course, picked_bbsid + else: + answer = _ask(f" 《{course.get('title', '')}》没有讨论区,改去" + f"《{picked_course.get('title', '')}》吗?[y/n · 回车=否] ") + if answer.lower() not in ("y", "yes", "是", "1"): + return {"ok": False, "sent": 0, "skipped": 0, "reason": "用户取消了换课"} + course, bbsid = picked_course, picked_bbsid + + return course, bbsid + + +def discuss_cli(chaoxing, tc, config: dict, list_only: bool = False, + course_id: Optional[str] = None, courses: Optional[list] = None, + auto_yes: bool = False) -> dict: + """讨论区模式的入口:统计 → 挑帖子 → 草稿 → 确认 → 逐条发送.""" + # + # 返回 {ok, sent, skipped, reason}:调用方据此汇报,失败时绝不能说"已发送"。 + # auto_yes 只跳过"开始刷课"的确认;把 AI 写的回复发到公开讨论区必须逐条确认, + # 所以这里不因为 --yes 就静默群发(非交互输入会停在确认处并安全退出)。 + from api.task_center import TaskCenter + if tc is None: + tc = TaskCenter(chaoxing, config) + if courses is None: + try: + courses = chaoxing.get_course_list() or [] + except Exception as e: + print(f" ✘ 读取课程列表失败:{e}") + return {"ok": False, "sent": 0, "skipped": 0, "reason": "读取课程列表失败"} + courses = list(courses) + wanted = str(course_id or "").strip() + if wanted: + courses = [c for c in courses if str(c.get("courseId")) == wanted] + if not courses: + print(" ✘ 没有可用的课程") + return {"ok": False, "sent": 0, "skipped": 0, "reason": "没有可用的课程"} + + selection = _select_discussion_course(tc, courses, list_only) + if isinstance(selection, dict): + return selection + course, bbsid = selection + + title = str(course.get("title") or "") + print() + print(f" 讨论区 · {title}") + print(" " + "─" * 46) + print(" 正在读取帖子…") + topics, capped = fetch_all_topics(tc.session, bbsid) + if not topics: + print(" ✘ 没读到帖子(可能登录失效、页面改版,或这个讨论区还是空的)") + return {"ok": False, "sent": 0, "skipped": 0, "reason": "没读到帖子"} + if capped: + print(f" 至少 {len(topics)} 条帖子(只读了前 {MAX_PAGES} 页)· 已经回复过的会自动跳过") + else: + print(f" 共 {len(topics)} 条帖子 · 已经回复过的会自动跳过") + + picked = _pick_reply_topics(topics, list_only) + if isinstance(picked, dict): + return picked + + chosen = [topics[n - 1] for n in picked] + print() + preview = " | ".join(f"{n}. {clip_text(topics[n - 1].get('title') or '', 8)}" for n in picked[:4]) + more = f" 等 {len(chosen)} 条" if len(chosen) > 4 else "" + print(f" 将回复 {len(chosen)} 条:{preview}{more}") + print() + + result = _reply_selected_topics(tc, bbsid, course, chosen) + if result["reason"]: + return result + sent, skipped = result["sent"], result["skipped"] + + print(f" 完成:发送 {sent} 条 · 跳过 {skipped} 条") + if sent: + print(" (平台约 3 分钟后才显示完成,可在 ./cx review 里复核正文)") + again = _ask(" 还要继续挑别的帖子吗?[y/n · 回车=退出] ") + if again.lower() not in ("y", "yes", "是", "1"): + return {"ok": True, "sent": sent, "skipped": skipped, "reason": ""} + return discuss_cli(chaoxing, tc, config, list_only=False, course_id=course_id, + courses=courses, auto_yes=auto_yes) diff --git a/api/display.py b/api/display.py new file mode 100644 index 000000000..72db761c3 --- /dev/null +++ b/api/display.py @@ -0,0 +1,361 @@ +# -*- coding: utf-8 -*- +"""刷课进度显示.""" +# +# 目标:刷课时不再刷屏,每完成一个章节只输出一行,清晰可读。 +# +# 显示形式: +# ██████░░░░░░░░░░░░░░░░░░░░ 23/111 21% 剩 88 节 · 预计 12 分 30 秒 ✓ 1.2 什么是马克思主义 +# ██████████░░░░░░░░░░░░░░░░ 24/111 22% 剩 87 节 · 预计 12 分 10 秒 ⤼ 3.1 社会形态(未开放) +# ████████████░░░░░░░░░░░░░░ 25/111 23% 剩 86 节 · 预计 11 分 50 秒 ✗ 4.2.6 社会形态 +# +# ✓ 完成 ⤼ 跳过 ✗ 失败 +# +# 通过 tqdm.write 输出,与视频进度条共存不会互相破坏。 + +import re +import sys +import threading +import time +import unicodedata + +from tqdm import tqdm + + +def safe_console(): + """让控制台输出永远不会因为编码问题崩溃.""" + # + # Windows 中文版控制台默认是 GBK 编码,课程名 / 题干里只要出现一个 + #  ( ) 之类的字符,print 就会抛 UnicodeEncodeError 直接结束程序(#602)。 + # 这里只放宽错误处理(errors="replace"),不改编码 —— + # 改编码会让中文在旧控制台上变成乱码。 + for stream in (sys.stdout, sys.stderr): + try: + stream.reconfigure(errors="replace") + except (AttributeError, OSError, ValueError) as exc: + from api.logger import logger + logger.debug("控制台编码设置不可用({})", type(exc).__name__) + + +def _disp_width(text) -> int: + """字符串在终端里的显示宽度.""" + # 中文/全角字符占 2 列,ASCII 占 1 列 —— 直接用 len() 会导致中文对不齐。 + width = 0 + for ch in str(text): + if unicodedata.east_asian_width(ch) in ("W", "F"): + width += 2 + else: + width += 1 + return width + + +def _pad_right(text, width) -> str: + """按显示宽度右侧补空格.""" + text = str(text) + gap = width - _disp_width(text) + return text + (" " * gap if gap > 0 else "") + + +def _truncate(text, max_width) -> str: + """按显示宽度截断,超出部分用省略号.""" + text = str(text) + if _disp_width(text) <= max_width: + return text + out = "" + used = 0 + for ch in text: + w = 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 + if used + w > max_width - 1: + break + out += ch + used += w + return out + "…" + + +def _fmt_duration(seconds, ceil_min=False): + """秒 -> 可读时长;ceil_min=True 时不足 1 秒也显示 1 秒.""" + try: + seconds = float(seconds) + except Exception: + return "--" + if seconds < 0: + return "--" + if ceil_min: + import math + seconds = max(1, math.ceil(seconds)) + seconds = int(seconds) + if seconds < 60: + return str(seconds) + " 秒" + if seconds < 3600: + return str(seconds // 60) + " 分 " + str(seconds % 60) + " 秒" + return str(seconds // 3600) + " 小时 " + str((seconds % 3600) // 60) + " 分" + + +def _fmt_bar(done, total, width=20): + """文本进度条(用方块字符,比 # 更清晰).""" + if total <= 0: + return "░" * width + filled = int(width * done / total) + filled = max(0, min(width, filled)) + return "█" * filled + "░" * (width - filled) + + +# 章节标题开头的编号,例如 "1.2 什么是马克思主义" -> "1.2" +_LABEL_RE = re.compile(r"^\s*(\d+(?:[.\-]\d+)*)") + + +# ---------------------------------------------------------------- 作答留痕 + +QUESTION_TYPE_LABELS = { + 'single': '选择', + 'multiple': '多选', + 'judgement': '判断', + 'completion': '填空', + 'shortanswer': '简答', + 'unknown': '问答', +} + + +def clip(text, limit: int = 36) -> str: + """单行显示用的截断(按显示宽度,中文算 2 列).""" + value = re.sub(r'\s+', ' ', str(text or '')).strip() + if not value: + return '' + if _disp_width(value) <= limit: + return value + out = [] + width = 0 + for ch in value: + w = _disp_width(ch) + if width + w > limit - 1: + break + out.append(ch) + width += w + return ''.join(out) + '…' + + +def answer_line(index, q_type, answer, title: str = "") -> str: + """一题的作答留痕:序号 + 题型 + 题干提示 + 答案.""" + label = QUESTION_TYPE_LABELS.get(str(q_type or '').lower(), '作答') + hint = clip(title, 20) + prefix = f' {index:>2}. {label:<4}' + if hint: + prefix += hint + ' ' + body = str(answer or '').strip() + if _disp_width(body) > 36: + body = clip(body, 36) + f'({len(body)} 字)' + return prefix + body + + +def answers_header(title, count) -> str: + """一次作答的开头:题目数量一眼可见.""" + return f' 作答 · {clip(title, 24)}({count} 题)' + + +def emit(text): + """把一行留痕同时写到控制台和运行日志(普通运行日志即可回溯).""" + from api.privacy import redact + line = redact(str(text or '')) + if not line.strip(): + return + try: + print(line) + except (OSError, UnicodeError) as exc: + from api.logger import logger + logger.debug("控制台留痕输出失败({})", type(exc).__name__) + from api.logger import log_file_only + log_file_only(line.strip(), 'INFO') + + +def emit_block(title: str, text: str, width: int = 60) -> None: + """多行正文(讨论回复等)留痕:标题一行 + 折行正文.""" + import textwrap + if title: + emit(' ' + title) + body = re.sub(r'\s+', ' ', str(text or '')).strip() + if not body: + return + wrapped = textwrap.wrap(body, width=width) or [] + # 中文标点不落行首(读起来更顺) + no_lead = ',。、;:!?)》”’…' + fixed = [] + for line in wrapped: + if fixed and line and line[0] in no_lead: + fixed[-1] = fixed[-1] + line[0] + line = line[1:] + if line: + fixed.append(line) + for line in fixed: + emit(' ' + line) + +def chapter_label(point, max_width=20) -> str: + """章节简称:优先用编号(1.2 / 1.2.3),没有编号就退回标题本身.""" + # point 可以是章节字典,也可以直接是标题字符串。 + if isinstance(point, dict): + title = str(point.get("title") or "").strip() + else: + title = str(point or "").strip() + if not title: + return "未命名章节" + matched = _LABEL_RE.match(title) + if matched: + return matched.group(1) + return _truncate(title, max_width) + + +def compress_labels(labels, max_groups=3) -> str: + """把连续的编号压成区间.""" + # ['1.1', '1.2', '1.3', '2.1'] -> '1.1~1.3、2.1' + # 传入顺序必须和章节顺序一致。 + labels = [str(x) for x in labels] + if not labels: + return "" + + groups = [] + first = last = 0 + for i in range(1, len(labels)): + if i == last + 1: + last = i + else: + groups.append((first, last)) + first = last = i + groups.append((first, last)) + + parts = [] + for start, end in groups: + parts.append(labels[start] if start == end else labels[start] + "~" + labels[end]) + + if len(parts) > max_groups: + return "、".join(parts[:max_groups]) + " 等 " + str(len(parts)) + " 段" + return "、".join(parts) + + +def course_plan_summary(finished_points, pending_points, planned_count=None) -> str: + """一门课开刷前的一句话说明,让用户一眼看清"哪些已经刷过、从哪儿接着刷".""" + # + # 共 30 节待刷 + # 共 12 节已完成(1.1 ~ 3.4),从 4.1 开始 + # 共 12 节已完成(1.1 ~ 3.4),从 4.1 开始,本次刷 3 节 + # 共 30 节全部已完成 + finished_points = list(finished_points or []) + pending_points = list(pending_points or []) + done = len(finished_points) + total = done + len(pending_points) + + if total == 0: + return "没有读到章节" + if done == 0: + return "共 " + str(total) + " 节待刷" + + ranges = compress_labels([chapter_label(p) for p in finished_points]) + if not pending_points: + return "共 " + str(done) + " 节全部已完成" + + text = ("共 " + str(done) + " 节已完成(" + ranges + "),从 " + + chapter_label(pending_points[0]) + " 开始") + if planned_count is not None and planned_count < len(pending_points): + text += ",本次刷 " + str(planned_count) + " 节" + return text + + +class ChapterProgress: + """章节级进度:每完成一个章节输出一行整体进度.""" + + def __init__(self, total, enabled=True, title_width=30): + """Initialize configuration and runtime state.""" + self.total = int(total or 0) + self.done = 0 + self.failed = 0 + self.skipped = 0 + self.start_time = time.time() + self.title_width = title_width + self._lock = threading.Lock() + self._enabled = bool(enabled) and self.total > 0 + + # ---------- 内部 ---------- + def _elapsed(self): + return max(0.0, time.time() - self.start_time) + + def _eta(self): + """基于平均每章节耗时估算剩余时间.""" + processed = self.done + self.failed + self.skipped + if processed <= 0: + return None + avg = self._elapsed() / processed + remain = self.total - processed + if remain <= 0: + return 0 + return avg * remain + + def _render(self, mark, title, extra=""): + processed = self.done + self.failed + self.skipped + total = self.total + bar = _fmt_bar(processed, total) + remain = max(0, total - processed) + + # 只要还有未完成的章节就显示 ETA;全部完成时改为显示耗时 + if remain > 0: + eta = self._eta() + when_text = "预计 " + (_fmt_duration(eta, ceil_min=True) if eta is not None else "--") + else: + when_text = "耗时 " + _fmt_duration(self._elapsed()) + + name = _truncate(str(title).strip(), self.title_width) + + # 固定列宽(按显示宽度计算),保证多行对齐;整行控制在 80 列左右。 + # 百分比不单独列一栏:进度条本身已经直观表达了比例。 + counter = _pad_right(str(processed) + "/" + str(total), 7) + info = _pad_right("剩 " + str(remain) + " · " + when_text, 18) + + return " " + bar + " " + counter + info + " " + mark + " " + name + extra + + def _emit(self, line): + if not self._enabled: + return + try: + tqdm.write(line, file=sys.stderr) + sys.stderr.flush() + except Exception: + try: + print(line, file=sys.stderr, flush=True) + except (OSError, UnicodeError) as exc: + from api.logger import logger + logger.debug("进度输出不可用({})", type(exc).__name__) + + def _bump(self, kind, title, extra=""): + with self._lock: + if kind == "done": + self.done += 1 + mark = "✓" + elif kind == "skip": + self.skipped += 1 + mark = "⤼" + else: + self.failed += 1 + mark = "✗" + self._emit(self._render(mark, title, extra)) + + # ---------- 对外 ---------- + def chapter_done(self, title): + self._bump("done", title) + + def chapter_skipped(self, title, reason=""): + self._bump("skip", title, ("(" + reason + ")") if reason else "") + + def chapter_failed(self, title): + self._bump("fail", title) + + def summary(self): + """刷课结束时的总结.""" + if not self._enabled: + return + elapsed = self._elapsed() + parts = [] + if self.done: + parts.append("完成 " + str(self.done)) + if self.skipped: + parts.append("跳过 " + str(self.skipped)) + if self.failed: + parts.append("失败 " + str(self.failed)) + self._emit(" " + "─" * 46) + self._emit(" 刷课结束:共 " + str(self.total) + " 节 · " + + " · ".join(parts) + " · 耗时 " + _fmt_duration(elapsed)) diff --git a/api/font_decoder.py b/api/font_decoder.py index 1915c9e6f..079efab4d 100644 --- a/api/font_decoder.py +++ b/api/font_decoder.py @@ -9,21 +9,20 @@ class FontDecoder: - """超星加密字体解码器。 - - 用于解码超星平台使用特殊字体加密的内容。 - """ + """超星加密字体解码器.""" + + # + # 用于解码超星平台使用特殊字体加密的内容。 # 正则表达式常量 FONT_BASE64_PATTERN = r"base64,([\w\W]+?)\'" FONT_DATA_URL_PREFIX = "data:application/font-ttf;charset=utf-8;base64," def __init__(self, html_content: Optional[str] = None): - """初始化字体解码器。 - - Args: - html_content: 包含加密字体信息的HTML内容 - """ + """初始化字体解码器.""" + # + # Args: + # html_content: 包含加密字体信息的HTML内容 self.html_content = html_content self.__font_map: Optional[Dict] = None @@ -31,11 +30,10 @@ def __init__(self, html_content: Optional[str] = None): self.__init_font_map(html_content) def __init_font_map(self, html_content: str) -> None: - """从HTML内容中提取字体信息并初始化字体映射。 - - Args: - html_content: 包含加密字体信息的HTML内容 - """ + """从HTML内容中提取字体信息并初始化字体映射.""" + # + # Args: + # html_content: 包含加密字体信息的HTML内容 try: try: soup = BeautifulSoup(html_content, "lxml") @@ -59,27 +57,25 @@ def __init_font_map(self, html_content: str) -> None: self.__font_map = None def decode(self, target_str: str) -> str: - """解码加密字符串。 - - Args: - target_str: 需要解码的加密字符串 - - Returns: - 解码后的字符串 - - Raises: - ValueError: 当字体映射未初始化时抛出 - """ + """解码加密字符串.""" + # + # Args: + # target_str: 需要解码的加密字符串 + # + # Returns: + # 解码后的字符串 + # + # Raises: + # ValueError: 当字体映射未初始化时抛出 if not self.__font_map: raise FontDecodeError("字体映射未初始化,无法解码") return cxfont.decrypt(self.__font_map, target_str) def set_html_content(self, html_content: str) -> None: - """设置新的HTML内容并重新初始化字体映射。 - - Args: - html_content: 包含加密字体信息的HTML内容 - """ + """设置新的HTML内容并重新初始化字体映射.""" + # + # Args: + # html_content: 包含加密字体信息的HTML内容 self.html_content = html_content self.__init_font_map(html_content) diff --git a/api/guard.py b/api/guard.py new file mode 100644 index 000000000..a2b6f8e4a --- /dev/null +++ b/api/guard.py @@ -0,0 +1,211 @@ +# -*- coding: utf-8 -*- +"""启动检查(人工确认门禁).""" +# +# 设计目标:零技术基础也能安全使用。 +# 规则: +# 1. 账号密码是必填项,没有就停止,不存在"跳过"。 +# 2. 课程 ID 是必填项,没填就停止,绝不会自动刷全部课程。 +# 3. 没配 API Key 时,章节测验不会真的作答 —— 必须人工确认后才继续。 + +import os +import sys + +from api import paths +from api.configfile import read_config_file + +LINE = "=" * 62 + + +class UserAbort(Exception): + """用户主动取消 / 未确认.""" + + +def _can_prompt(): + """是否能与用户交互(有终端).""" + try: + return sys.stdin.isatty() + except Exception: + return False + + +def _ask_yes(prompt): + """询问 y/n,默认 n(安全默认).""" + if not _can_prompt(): + return False + try: + ans = input(prompt + " [y/n]\n> ").strip().lower() + except (EOFError, KeyboardInterrupt): + print() + return False + return ans in ("y", "yes", "是", "1", "true") + + +def _stop(title, details, how_to_fix): + """必填项缺失:直接停止,不给继续选项.""" + print() + print(LINE) + print(" ✘ " + title) + print(LINE) + print(details) + print() + print(" 怎么解决:") + print(how_to_fix) + print() + print(" 程序已停止,不会执行任何刷课操作。") + print() + raise UserAbort(title) + + +def hard_stop(title, details, how_to_fix): + """必填项/配置错误:直接停止(供其它模块在启动检查之外调用).""" + _stop(title, details, how_to_fix) + + +def _confirm(title, details, how_to_fix): + """可继续项:必须人工确认,默认 N.""" + print() + print(LINE) + print(" ⚠️ " + title) + print(LINE) + print(details) + print() + print(" 怎么解决:") + print(how_to_fix) + print() + if _ask_yes(" 你已了解以上情况,仍要继续运行吗?"): + print(" → 已确认,继续运行。") + print() + return + raise UserAbort("用户未确认: " + title) + + +# 各答题方式需要的配置项:(provider, 需要的键, 缺失时怎么说明) +_PROVIDER_REQUIREMENTS = { + "AI": ("key", "DeepSeek API Key", "https://platform.deepseek.com/ 创建"), + "SiliconFlow": ("siliconflow_key", "硅基流动 API Key", "https://cloud.siliconflow.cn/account/ak 获取"), + "TikuYanxi": ("tokens", "言溪题库 token", "https://tk.enncy.cn/ 购买"), + "TikuAdapter": ("url", "TikuAdapter 服务地址", "自行部署 tikuAdapter 后填写地址"), +} + +# 不需要额外配置的答题方式 +_PROVIDER_NO_CONFIG = {"TikuGo", "TikuManual"} + + +def _quiz_degraded_confirmed(): + """用户是否已经确认过"不做测验,只刷非测验部分".""" + try: + cfg, _broken = read_config_file(paths.config_path()) + if not cfg.has_section("cx"): + return False + return (cfg.get("cx", "quiz_degraded", fallback="") or "").strip() == "yes" + except Exception: + return False + + +def _check_answer_provider(tiku_config): + """按实际选择的答题方式检查配置,返回需要人工确认的问题列表.""" + provider_str = (tiku_config.get("provider") or "").strip() + + # 没选答题方式:用户明确选了"不答题",或配置缺失 + if not provider_str: + # 用户在引导里已经确认过"不做测验,只刷非测验部分" -> 不再重复询问 + if _quiz_degraded_confirmed(): + return [] + return [{ + "title": "没有配置答题方式(章节测验会被跳过)", + "details": " 所有章节测验都不会真的作答,这些任务点会显示未完成。\n" + " 需要答题解锁的章节会卡住刷不下去。", + "fix": " 运行 cx setup 选择答题方式(推荐第 1 项 DeepSeek AI)", + }] + + providers = [p.strip() for p in provider_str.split(",") if p.strip()] + problems = [] + missing = [] + + for name in providers: + # 手动答题 / GO题:不需要额外配置 + if name in _PROVIDER_NO_CONFIG: + continue + + if name not in _PROVIDER_REQUIREMENTS: + missing.append(f"{name}(未知的答题方式)") + continue + + key_name, label, how = _PROVIDER_REQUIREMENTS[name] + if not (tiku_config.get(key_name) or "").strip(): + missing.append(f"{label}({how})") + + if missing: + detail_lines = "\n".join(" · " + m for m in missing) + problems.append({ + "title": "答题方式缺少必要的配置", + "details": " 当前答题方式:" + provider_str + "\n" + " 缺少以下配置:\n" + detail_lines + "\n" + " 缺少时相关章节测验无法作答,需要解锁的章节会卡住。", + "fix": " 运行 cx setup 重新配置答题方式", + }) + + return problems + + +def check_before_run(common_config, tiku_config, notification_config, config_path, + skip_confirm=False): + """启动前检查.""" + # skip_confirm=True(--yes)只对"可继续项"生效;必填项缺失永远停止。 + hard = [] # 必填项缺失 -> 一律停止 + soft = [] # 需要人工确认 + + # ---- 1. 账号(必填,无"跳过") ---- + username = (common_config.get("username") or "").strip() + password = (common_config.get("password") or "").strip() + use_cookies = common_config.get("use_cookies", False) + if not use_cookies and (not username or not password): + hard.append({ + "title": "没有填写登录账号(手机号 / 密码是必填项)", + "details": " 程序需要账号才能登录学习通,这一项不能跳过。", + "fix": " 运行 cx setup 填写", + }) + + # ---- 2. 课程 ID(必填,不自动全刷) ---- + course_list = common_config.get("course_list") + if not course_list: + hard.append({ + "title": "没有填写要刷的课程 ID", + "details": " 为避免误刷你账号下的全部课程,必须明确指定要刷哪些课。", + "fix": " 运行 cx setup 填写", + }) + + # ---- 3. 配置文件不存在 ---- + # 只有"明确指定了 -c 配置文件但文件不在"才算致命。 + # 纯命令行模式(python main.py -u 手机号 -p 密码 -l 课程ID)本来就不需要配置文件, + # 不能因为没传 -c 就拦死(#567)。 + if config_path and not os.path.exists(config_path): + hard.append({ + "title": "没有找到配置文件 " + str(config_path), + "details": " 你指定了 -c 参数,但这个文件不存在,账号/课程设置读不到。", + "fix": " 运行 cx setup 生成,或去掉 -c 用命令行参数运行", + }) + + # ---- 4. 答题方式检查(可继续,但需确认) ---- + soft.extend(_check_answer_provider(tiku_config or {})) + + # 必填项缺失:无条件停止(--yes 也不能绕过) + for p in hard: + _stop(p["title"], p["details"], p["fix"]) + + if not soft: + print(" ✔ 启动检查通过") + return + + if skip_confirm: + print() + print(LINE) + print(" ⚠️ 以下情况因 --yes 被视为已确认:") + for p in soft: + print(" · " + p["title"]) + print(LINE) + print() + return + + for p in soft: + _confirm(p["title"], p["details"], p["fix"]) diff --git a/api/interrupt.py b/api/interrupt.py new file mode 100644 index 000000000..0d5f38527 --- /dev/null +++ b/api/interrupt.py @@ -0,0 +1,201 @@ +# -*- coding: utf-8 -*- +"""刷课过程中的一键终止.""" +# +# 刷课时后台起一个线程监听键盘,用户按 q 或 Ctrl+C,立即终止程序。 +# +# 实现方式:termios + select,不依赖任何第三方库。 +# 只有在真正的终端里才启用;非交互环境(定时任务/管道)自动跳过。 +# +# **让出 stdin**:提交确认要调用 input() 时,必须先把监听线程停下来、把终端恢复成 +# 行缓冲 + 回显,否则两者同抢 stdin——实测逐字输入 "yes" 会被吃成 "ye"/"ys"(按取消 +# 处理),甚至让 input() 永久挂住、用户还看不到自己敲了什么。 +# 用 stdin_for_prompt() 包住提示即可。 + +import os +import sys +import threading +from contextlib import contextmanager +from api.logger import logger + +# 全局终止标志 +_stop_event = threading.Event() +_watcher_started = False +_watcher_alive = False +_lock = threading.Lock() +# 轮次编号:避免上一轮的监听线程影响新一轮 +_generation = 0 + +# 让出 stdin 的开关与回执 +_pause = threading.Event() +_pause_ack = threading.Event() + + +def should_stop(): + """外部查询:是否已被要求终止.""" + return _stop_event.is_set() + + +def request_stop(reason=""): + """请求终止(也可由别的模块调用).""" + _stop_event.set() + + +def reset(): + """开始新一轮刷课前调用:清除终止标志、允许重新启动监听.""" + # + # 没有这一步的话,用户上一次按 q 终止后,标志一直是 set 状态, + # 下一次刷课会立刻停止。 + global _watcher_started, _generation + with _lock: + _stop_event.clear() + _generation += 1 + _watcher_started = False + # 上一轮如果停在"让出 stdin"的状态,别把它带进新一轮 + _pause.clear() + _pause_ack.set() + + +def _set_terminal_mode(fd, old=None): + """Restore normal input or enter immediate-key mode when supported.""" + import termios + import tty + try: + if old is None: + tty.setcbreak(fd) + else: + termios.tcsetattr(fd, termios.TCSADRAIN, old) + except Exception as exc: + logger.debug("终端模式调整失败: {}", type(exc).__name__) + + +def _watcher_pause_state(fd, old, paused_here): + """Yield stdin to prompts and acknowledge its restored input mode.""" + import time + if _pause.is_set(): + if not paused_here: + _set_terminal_mode(fd, old) + _pause_ack.set() + time.sleep(0.05) + return True, True + if paused_here: + _set_terminal_mode(fd) + _pause_ack.clear() + return False, False + + +def _read_terminal_key(fd): + """Read one available key or signal that the input stream has ended.""" + import select + try: + readable, _, _ = select.select([fd], [], [], 0.3) + if not readable: + return True, None + char = os.read(fd, 1) + if not char: + return False, None + return True, char.decode("utf-8", "ignore").lower() + except Exception as exc: + logger.debug("终端输入不可用: {}", type(exc).__name__) + return False, None + + +def _watch_stdin(my_generation): + """后台线程:读键盘,遇到 q 或 Ctrl+C 就请求终止.""" + # + # _pause 置位时让出 stdin:先把终端属性恢复成普通行缓冲 + 回显, + # 再停止读取,让 input()(提交确认)拿到完整、能看见的输入。 + global _watcher_alive + import termios + import tty + + fd = sys.stdin.fileno() + try: + old = termios.tcgetattr(fd) + except Exception: + _watcher_alive = False + _pause_ack.set() + return + + paused_here = False + try: + tty.setcbreak(fd) # 按键立即到达程序,不用等回车 + while not _stop_event.is_set() and my_generation == _generation: + paused_here, waiting = _watcher_pause_state(fd, old, paused_here) + if waiting: + continue + active, c = _read_terminal_key(fd) + if not active: + break + if c is None: + continue + if c == "q" or c == chr(3): + _stop_event.set() + print() + print() + print(" >>> 收到退出指令,正在终止刷课...") + print() + break + finally: + _set_terminal_mode(fd, old) + _watcher_alive = False + _pause_ack.set() + + +def pause_watcher(timeout=2.0): + """暂停键盘监听并等它真的让出 stdin;返回是否已经让出.""" + # + # 没有监听线程时(非交互终端、或还没 start_watcher)直接返回 True。 + if not _watcher_alive: + return True + _pause.set() + return _pause_ack.wait(timeout if timeout and timeout > 0 else 0.01) + + +def resume_watcher(): + """恢复键盘监听(确认提示结束后调用).""" + _pause.clear() + + +@contextmanager +def stdin_for_prompt(): + """确认提示期间把 stdin 让给 input():先暂停监听线程,结束后再恢复.""" + paused = pause_watcher() + try: + yield paused + finally: + resume_watcher() + + +def start_watcher(): + """启动键盘监听(只在交互终端里生效,重复调用无副作用).""" + global _watcher_started, _watcher_alive + with _lock: + if _watcher_started: + return False + _watcher_started = True + + try: + if not sys.stdin.isatty(): + return False + except Exception: + return False + + if os.name == "nt": + return False + + _pause.clear() + _pause_ack.clear() + _watcher_alive = True + t = threading.Thread(target=_watch_stdin, args=(_generation,), daemon=True) + t.start() + return True + + +def wait_stop(timeout=None): + """等待终止信号(给需要阻塞的地方用).""" + return _stop_event.wait(timeout) + + +def print_hint(): + """刷课前提示怎么退出(一行,不画横幅).""" + print(" 随时按 q 停止(立即生效,不用回车);也可以 Ctrl + C。") diff --git a/api/live.py b/api/live.py index 581d36d30..03f881b49 100644 --- a/api/live.py +++ b/api/live.py @@ -9,6 +9,7 @@ class Live: def __init__(self, attachment: dict, defaults: dict, course_id: str): + """Initialize configuration and runtime state.""" self.attachment = attachment self.defaults = defaults # 包含用户ID、课程ID等信息 self.course_id = course_id # 课程ID @@ -19,7 +20,7 @@ def __init__(self, attachment: dict, defaults: dict, course_id: str): }) def do_finish(self): - """提交直播观看时长(核心方法)""" + """提交直播观看时长(核心方法).""" # 从直播信息中提取关键参数 stream_name = self.attachment.get("property", {}).get("streamName") vdoid = self.attachment.get("property", {}).get("vdoid") @@ -44,7 +45,7 @@ def do_finish(self): return False def get_status(self) -> dict | None: - """获取直播状态(总时长等信息)""" + """获取直播状态(总时长等信息).""" live_id = self.attachment.get("property", {}).get("liveId") user_id = self.defaults.get("userid") clazz_id = self.defaults.get("clazzId") diff --git a/api/live_process.py b/api/live_process.py index bd9dde9ae..fa8f4c9a8 100644 --- a/api/live_process.py +++ b/api/live_process.py @@ -1,5 +1,6 @@ import time +from api import interrupt from api.live import Live from api.logger import logger @@ -7,41 +8,39 @@ class LiveProcessor: @staticmethod def run_live(live: Live, speed: float = 1.0): - """循环提交直播时长,直到达到总时长""" - # 获取直播状态(包含总时长) + """按真实时间提交直播时长,直到达到总时长.""" + # + # 直播是实时流:这里强制 1 倍速(忽略配置倍速),并响应 q 终止; + # 任何一次时长提交失败都会返回 False,不再无条件报成功。 live_status = live.get_status() if not live_status: logger.error("直播状态获取失败,无法继续") return False - # 解析直播总时长(单位:秒) try: duration = live_status.get("temp", {}).get("data", {}).get("duration", 0) if not duration: logger.warning("无法获取直播总时长,默认按30分钟处理") - duration = 30 * 60 # 默认30分钟 + duration = 30 * 60 except Exception as e: logger.error(f"解析直播时长失败: {str(e)}") return False - # 根据播放速度调整所需时间 - adjusted_duration = duration / speed - total_minutes = (int(adjusted_duration) + 59) // 60 # 转换为分钟(向上取整) - logger.info(f"开始刷取直播'{live.name}',总时长{total_minutes}分钟(已根据倍速调整)") + total_minutes = (int(duration) + 59) // 60 + logger.info(f"开始刷取直播'{live.name}',总时长{total_minutes}分钟(真实时间)") - # 循环提交时长(每59秒一次,模拟持续观看) for i in range(total_minutes): + if interrupt.should_stop(): + logger.warning(f"直播'{live.name}'已被用户终止,本次不计为完成") + return False logger.info(f"直播'{live.name}'已观看{i + 1}/{total_minutes}分钟") - success = live.do_finish() # 提交当前时长 - if not success: - logger.warning(f"第{i + 1}分钟时长提交失败,将重试") - # 失败重试一次 + if not live.do_finish(): + logger.warning(f"第{i + 1}分钟时长提交失败,5 秒后重试一次") time.sleep(5) - live.do_finish() - - # 根据倍速调整间隔时间 - sleep_time = 59 / speed - time.sleep(sleep_time) + if not live.do_finish(): + logger.error(f"直播'{live.name}'时长提交连续失败,本次不计为完成") + return False + time.sleep(59) logger.success(f"直播'{live.name}'时长刷取完成") return True diff --git a/api/llm.py b/api/llm.py new file mode 100644 index 000000000..44e3c4444 --- /dev/null +++ b/api/llm.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- +"""大模型调用的统一策略层(thinking 模式自适应).""" +# +# 不同模型可能返回正文、推理正文或空响应,需要按实际响应降级。 +# +# 策略(thinking = auto/on/off,默认 auto): +# auto: 按模型默认行为调用;正文为空但有 reasoning 时用 reasoning 兜底; +# 两者都空 → 再试一次 thinking=disabled。 +# on : 显式开启;若接口不支持该参数 → 去掉参数重试。 +# off : 显式关闭;正文仍为空 → 去掉参数重试。 + +import re +from typing import Any, Optional + +THINKING_MODES = ("auto", "on", "off") + + +def normalize_thinking(value: Any) -> str: + """只接受 auto/on/off,其它值一律回到 auto.""" + mode = str(value or "auto").strip().lower() + return mode if mode in THINKING_MODES else "auto" + + +def thinking_payload(mode: str) -> dict: + """该模式要附加到请求体里的 thinking 字段(auto 不加).""" + if mode == "on": + return {"thinking": {"type": "enabled"}} + if mode == "off": + return {"thinking": {"type": "disabled"}} + return {} + + +def thinking_steps(mode: str) -> list: + """按顺序尝试的模式列表:主模式失败后回退到更保守的一档.""" + mode = normalize_thinking(mode) + if mode == "on": + return ["on", "auto"] + if mode == "off": + return ["off", "auto"] + return ["auto", "off"] + + +def extract_text(message: Any) -> tuple: + """从响应 message 里取 (content, reasoning_content),兼容 SDK 对象与 dict.""" + if isinstance(message, dict): + content = message.get("content") or "" + reasoning = message.get("reasoning_content") or "" + else: + content = getattr(message, "content", "") or "" + reasoning = getattr(message, "reasoning_content", "") or "" + return str(content).strip(), str(reasoning).strip() + + +def is_thinking_param_error(exc: BaseException) -> bool: + """接口不认 thinking 参数时(400/422 + 关键字)返回 True.""" + text = str(exc).lower() + if "thinking" not in text: + return False + return any(key in text for key in ( + "unsupported", "unknown", "invalid", "not support", "unrecognized", + "extra_forbidden", "unexpected keyword", "400", "422", + )) + + +def strip_code_fence(text: str) -> str: + """去掉三反引号(可带 json 标注)包裹的代码块.""" + matched = re.match(r"^\s*\`\`\`(?:json)?\s*(.*?)\s*\`\`\`\s*$", str(text or ""), re.DOTALL) + return matched.group(1).strip() if matched else str(text or "").strip() + + +def create_completion(client, *, model: str, messages: list, thinking: str = "auto", + allow_reasoning_fallback: bool = False, **kwargs) -> str: + """调一次 chat.completions,按 thinking 策略自动降级.""" + # + # allow_reasoning_fallback=True 时(答题链路),正文为空则用 reasoning_content 兜底 + # (推理内容里通常也包含最终答案);写作链路必须为 False,避免把思维链当正文交出去。 + steps = thinking_steps(thinking) + last_error: Optional[BaseException] = None + for index, step in enumerate(steps): + extra = thinking_payload(step) + call_kwargs = dict(kwargs) + if extra: + call_kwargs["extra_body"] = extra + try: + response = client.chat.completions.create( + model=model, messages=messages, **call_kwargs + ) + except BaseException as exc: # noqa: BLE001 - 需要区分参数不支持与其它错误 + last_error = exc + if extra and is_thinking_param_error(exc) and index + 1 < len(steps): + continue + raise + content, reasoning = extract_text(response.choices[0].message) + if content: + return content + if reasoning and allow_reasoning_fallback: + return reasoning + if last_error is not None: + raise last_error + return "" diff --git a/api/logger.py b/api/logger.py index 42728ae53..f337672e4 100644 --- a/api/logger.py +++ b/api/logger.py @@ -1,7 +1,9 @@ +import os import sys from loguru import logger from tqdm import tqdm +from api.privacy import patch_record tqdm_stream = sys.stderr @@ -9,6 +11,77 @@ log_buffer = [] MAX_LOG_BUFFER_SIZE = 1000 +# 刷课期间的控制台静音开关。 +# 刷课时打开:控制台只显示 WARNING 及以上,避免 TRACE/DEBUG 刷屏; +# 日志文件默认记 DEBUG(够排查且不刷屏),需要逐请求排查时用 +# 环境变量 CX_LOG_LEVEL=TRACE 打开全量。 +_quiet = False + + +def set_quiet(enabled: bool): + """刷课期间开启/关闭控制台静音.""" + global _quiet + _quiet = bool(enabled) + + +def is_quiet() -> bool: + return _quiet + + +def _console_filter(record) -> bool: + """静音时过滤掉 WARNING 以下的日志(文件日志不受影响).""" + # 用 log_file_only() 发的日志只进文件,控制台由 print 统一输出,避免同一句话出现两遍 + if record["extra"].get("file_only"): + return False + try: + if _quiet: + # 刷课期间:只留 WARNING 以上 + return record["level"].no >= logger.level("WARNING").no + # 非刷课阶段:控制台只显示 INFO 以上,DEBUG/TRACE 只进日志文件 + return record["level"].no >= logger.level("INFO").no + except Exception: + return True + + +def _console_format(record) -> str: + """控制台输出格式:去掉时间戳、模块名、行号,只保留可读信息.""" + # + # 非刷课阶段: 消息内容 + # 刷课阶段: ⚠ 警告 / ✘ 错误(且只显示 WARNING 及以上) + # + # 【重要】loguru 会把这里返回的字符串再当成模板做一次 format_map, + # 因此消息里原生的 { } 必须转义,否则会抛 KeyError(例如 API 返回的 + # JSON 报错里带 {'error': ...} 就会让日志线程崩溃)。 + level = record["level"].name + msg = str(record["message"]).rstrip() + + if _quiet: + # 刷课阶段:极简格式,只可能出现警告和错误 + icon = "⚠" if level == "WARNING" else "✘" + text = " " + icon + " " + msg + elif level in ("ERROR", "CRITICAL"): + text = " ✘ " + msg + elif level == "WARNING": + text = " ⚠ " + msg + else: + text = " " + msg + + # 转义花括号,交给 loguru 的 format_map 还原成字面量 + text = text.replace("{", "{{").replace("}", "}}") + return text + chr(10) + + +def log_file_only(message, level="ERROR"): + """只写日志文件,不在控制台显示.""" + # + # 控制台的提示语统一用 print 输出(顺序确定、排版可控), + # 日志文件里再留一份记录,避免同一句话在屏幕上出现两遍。 + try: + logger.bind(file_only=True).log(level, message) + except Exception: + # Logging may be unavailable during shutdown; do not recurse into the logger. + return None + def tqdm_sink(msg): manual_locked = False @@ -34,5 +107,20 @@ def tqdm_sink(msg): logger.remove() -logger.add(tqdm_sink, colorize=True, enqueue=True) -logger.add("chaoxing.log", rotation="10 MB", level="TRACE") +logger.configure(patcher=patch_record) +logger.add(tqdm_sink, colorize=False, enqueue=True, filter=_console_filter, + format=_console_format, diagnose=False) + +# 日志文件放在用户数据目录,升级代码不会丢掉历史日志 +try: + from api import paths as _paths + _LOG_FILE = _paths.log_path() +except Exception: + _LOG_FILE = "chaoxing.log" +logger.add(_LOG_FILE, rotation="10 MB", + level=(os.environ.get("CX_LOG_LEVEL") or "DEBUG").strip().upper(), + diagnose=False) +try: + os.chmod(_LOG_FILE, 0o600) +except OSError: + pass diff --git a/api/notification.py b/api/notification.py index f68c95d9f..19091ca62 100644 --- a/api/notification.py +++ b/api/notification.py @@ -1,7 +1,5 @@ -""" -通知服务模块,用于向外部服务发送通知消息。 -支持多种通知服务,如ServerChan、Qmsg和Bark。 -""" +"""通知服务模块,用于向外部服务发送通知消息.""" +# 支持多种通知服务,如ServerChan、Qmsg和Bark。 import configparser from abc import ABC, abstractmethod @@ -9,19 +7,21 @@ import requests +from api import paths from api.logger import logger +from api.privacy import register_config, redact class NotificationService(ABC): - """ - 通知服务基类,定义通知服务的公共接口和实现。 - 所有具体的通知服务类应继承此类并实现必要的方法。 - """ + """通知服务基类,定义通知服务的公共接口和实现.""" - CONFIG_PATH = "config.ini" + # 所有具体的通知服务类应继承此类并实现必要的方法。 + + # 默认配置文件:用户数据目录下的 config.ini + CONFIG_PATH = paths.config_path() def __init__(self): - """初始化通知服务""" + """初始化通知服务.""" self.name = self.__class__.__name__ self.url = "" self.tg_chat_id = "" @@ -29,32 +29,31 @@ def __init__(self): self.disabled = False def config_set(self, config: Dict[str, str]) -> None: - """ - 设置通知服务的配置 - - Args: - config: 包含配置参数的字典 - """ + """设置通知服务的配置.""" + # + # Args: + # config: 包含配置参数的字典 self._conf = config + register_config(config) def _load_config_from_file(self) -> Optional[Dict[str, str]]: - """ - 从配置文件中加载通知服务的配置 - - Returns: - 成功返回配置字典,失败返回None - """ + """从配置文件中加载通知服务的配置.""" + # + # Returns: + # 成功返回配置字典,失败返回None try: config = configparser.ConfigParser() config.read(self.CONFIG_PATH, encoding="utf8") - return config['notification'] + result = dict(config['notification']) + register_config(result) + return result except (KeyError, FileNotFoundError): logger.info("未找到notification配置,已忽略外部通知功能") self.disabled = True return None def init_notification(self) -> None: - """初始化通知服务,加载配置并进行必要的设置""" + """初始化通知服务,加载配置并进行必要的设置.""" if not self._conf: self._conf = self._load_config_from_file() @@ -63,48 +62,38 @@ def init_notification(self) -> None: @abstractmethod def _init_service(self) -> None: - """ - 初始化特定的通知服务,由子类实现 - """ + """初始化特定的通知服务,由子类实现.""" pass @abstractmethod def _send(self, message: str) -> None: - """ - 发送通知消息,由子类实现 - - Args: - message: 要发送的消息内容 - """ + """发送通知消息,由子类实现.""" + # + # Args: + # message: 要发送的消息内容 pass def send(self, message: str) -> None: - """ - 发送通知消息的公共接口 - - Args: - message: 要发送的消息内容 - """ + """发送通知消息的公共接口.""" + # + # Args: + # message: 要发送的消息内容 if not self.disabled: - self._send(message) + self._send(redact(message)) class NotificationFactory: - """ - 通知服务工厂类,用于创建和获取通知服务实例 - """ + """通知服务工厂类,用于创建和获取通知服务实例.""" @staticmethod def create_service(config: Optional[Dict[str, str]] = None) -> NotificationService: - """ - 根据配置创建通知服务实例 - - Args: - config: 通知服务的配置,如果为None则从配置文件加载 - - Returns: - 通知服务实例 - """ + """根据配置创建通知服务实例.""" + # + # Args: + # config: 通知服务的配置,如果为None则从配置文件加载 + # + # Returns: + # 通知服务实例 service = DefaultNotification() if config: @@ -118,9 +107,7 @@ def create_service(config: Optional[Dict[str, str]] = None) -> NotificationServi class DefaultNotification(NotificationService): - """ - 默认通知服务,当未配置任何通知服务时使用 - """ + """默认通知服务,当未配置任何通知服务时使用.""" def _init_service(self) -> None: pass @@ -129,12 +116,10 @@ def _send(self, message: str) -> None: pass def get_notification_from_config(self) -> NotificationService: - """ - 根据配置创建具体的通知服务实例 - - Returns: - 通知服务实例 - """ + """根据配置创建具体的通知服务实例.""" + # + # Returns: + # 通知服务实例 if not self._conf: self._conf = self._load_config_from_file() @@ -165,27 +150,23 @@ def get_notification_from_config(self) -> NotificationService: class ServerChan(NotificationService): - """ - Server酱通知服务 - """ + """Server酱通知服务.""" def _init_service(self) -> None: - """初始化Server酱服务""" + """初始化Server酱服务.""" if not self._conf or not self._conf.get('url'): self.disabled = True - logger.info("未找到Server酱url配置,已忽略该通知服务") + logger.debug("未找到Server酱url 配置,已忽略该通知服务") return self.url = self._conf['url'] - logger.info(f"已初始化Server酱通知服务,URL: {self.url}") + logger.info("已初始化Server酱通知服务") def _send(self, message: str) -> None: - """ - 通过Server酱发送通知 - - Args: - message: 要发送的消息内容 - """ + """通过Server酱发送通知.""" + # + # Args: + # message: 要发送的消息内容 params = { 'text': message, # 兼容两个版本的Server酱 'desp': message, @@ -206,27 +187,23 @@ def _send(self, message: str) -> None: class Qmsg(NotificationService): - """ - Qmsg酱通知服务 - """ + """Qmsg酱通知服务.""" def _init_service(self) -> None: - """初始化Qmsg酱服务""" + """初始化Qmsg酱服务.""" if not self._conf or not self._conf.get('url'): self.disabled = True - logger.info("未找到Qmsg酱url配置,已忽略该通知服务") + logger.debug("未找到Qmsg酱url 配置,已忽略该通知服务") return self.url = self._conf['url'] - logger.info(f"已初始化Qmsg酱通知服务,URL: {self.url}") + logger.info("已初始化Qmsg酱通知服务") def _send(self, message: str) -> None: - """ - 通过Qmsg酱发送通知 - - Args: - message: 要发送的消息内容 - """ + """通过Qmsg酱发送通知.""" + # + # Args: + # message: 要发送的消息内容 params = {'msg': message} headers = {'Content-Type': 'application/json;charset=utf-8'} @@ -242,27 +219,23 @@ def _send(self, message: str) -> None: class Bark(NotificationService): - """ - Bark通知服务 - """ + """Bark通知服务.""" def _init_service(self) -> None: - """初始化Bark服务""" + """初始化Bark服务.""" if not self._conf or not self._conf.get('url'): self.disabled = True - logger.info("未找到Bark的url配置,已忽略该通知服务") + logger.debug("未找到Bark的url 配置,已忽略该通知服务") return self.url = self._conf['url'] - logger.info(f"已初始化Bark通知服务,URL: {self.url}") + logger.info("已初始化Bark通知服务") def _send(self, message: str) -> None: - """ - 通过Bark发送通知 - - Args: - message: 要发送的消息内容 - """ + """通过Bark发送通知.""" + # + # Args: + # message: 要发送的消息内容 params = {'body': message} try: @@ -277,27 +250,23 @@ def _send(self, message: str) -> None: class Telegram(NotificationService): - """ - 通过Telegram发送通知 - """ + """通过Telegram发送通知.""" def _init_service(self) -> None: - """初始化Telegram服务""" + """初始化Telegram服务.""" if not self._conf or not self._conf.get('url') or not self._conf.get('tg_chat_id'): self.disabled = True - logger.info("未找到Telegram的url或tg_chat_id配置,已忽略该通知服务") + logger.debug("未找到Telegram的url 配置,已忽略该通知服务") return self.tg_chat_id = self._conf['tg_chat_id'] self.url = self._conf['url'] - logger.info(f"已初始化Telegram通知服务,Chat_id: {self.tg_chat_id} URL: {self.url}") + logger.info("已初始化Telegram通知服务") def _send(self, message: str) -> None: - """ - 通过Telegram发送通知 - - Args: - message: 要发送的消息内容 - """ + """通过Telegram发送通知.""" + # + # Args: + # message: 要发送的消息内容 params = { 'chat_id': self.tg_chat_id, 'text': message, diff --git a/api/paths.py b/api/paths.py new file mode 100644 index 000000000..6c10754b6 --- /dev/null +++ b/api/paths.py @@ -0,0 +1,151 @@ +# -*- coding: utf-8 -*- +"""数据目录统一管理.""" +# +# 用户数据(配置、账号、cookie)存放在用户主目录,而不是项目目录。 +# 这样升级代码、git 操作、清理项目目录都不会影响用户配置。 +# +# 默认位置:~/.chaoxing/ +# 可用环境变量 CX_DATA_HOME 覆盖。 +# +# 首次使用时会自动从项目目录迁移旧文件(config.ini / accounts/ / cookies.txt)。 + +import os +import shutil + +PROJECT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + + +def data_dir(): + """用户数据根目录(不存在则创建).""" + d = os.environ.get("CX_DATA_HOME") or os.path.join( + os.path.expanduser("~"), ".chaoxing" + ) + os.makedirs(d, exist_ok=True) + try: + os.chmod(d, 0o700) + except OSError: + if os.name != "nt": + raise + return d + + +def config_path(): + return os.path.join(data_dir(), "config.ini") + + +def accounts_dir(): + d = os.path.join(data_dir(), "accounts") + os.makedirs(d, exist_ok=True) + return d + + +def cookies_dir(): + d = os.path.join(accounts_dir(), "cookies") + os.makedirs(d, exist_ok=True) + return d + + +def legacy_cookies_path(): + return os.path.join(data_dir(), "cookies.txt") + + +def reviews_dir(): + """AI 生成内容的复核记录目录(Markdown + JSONL 索引).""" + return os.path.join(data_dir(), "reviews") + + +def submissions_path(): + """已提交任务点记录:用于本地去重,避免平台完成状态延迟导致重复提交.""" + return os.path.join(data_dir(), "submissions.json") + + +def log_path(): + return os.path.join(data_dir(), "chaoxing.log") + + +def cache_path(): + """题库答案缓存文件.""" + return os.path.join(data_dir(), "cache.json") + + +def backups_dir(): + """配置备份目录.""" + d = os.path.join(data_dir(), "backups") + os.makedirs(d, exist_ok=True) + return d + + +def backup_config(keep=15): + """写入配置前先备份,保留最近 keep 份.""" + # 这样即使被误覆盖(比如被测试脚本写坏),也能从 backups/ 恢复。 + try: + import time + src = config_path() + if not os.path.exists(src): + return None + dst = os.path.join(backups_dir(), "config-" + time.strftime("%Y%m%d-%H%M%S") + ".ini") + # 同一秒内多次写入只保留第一份,避免刷屏 + if os.path.exists(dst): + return dst + shutil.copy2(src, dst) + + # 清理多余的旧备份 + files = sorted( + (f for f in os.listdir(backups_dir()) if f.startswith("config-")), + reverse=True, + ) + for old in files[keep:]: + try: + os.remove(os.path.join(backups_dir(), old)) + except OSError as exc: + from api.logger import logger + logger.debug("旧配置备份清理失败({})", type(exc).__name__) + return dst + except Exception: + return None + + +def _migrate_once(): + """把项目目录里的旧数据搬到数据目录(只搬一次,不覆盖已有).""" + try: + # config.ini + old_cfg = os.path.join(PROJECT_DIR, "config.ini") + new_cfg = config_path() + if os.path.exists(old_cfg) and not os.path.exists(new_cfg): + shutil.copy2(old_cfg, new_cfg) + + # accounts/ 整个目录 + old_acc = os.path.join(PROJECT_DIR, "accounts") + new_acc = accounts_dir() + if os.path.isdir(old_acc): + for item in os.listdir(old_acc): + src = os.path.join(old_acc, item) + dst = os.path.join(new_acc, item) + if os.path.exists(dst): + continue + if os.path.isdir(src): + shutil.copytree(src, dst) + else: + shutil.copy2(src, dst) + + # 旧 cookies.txt + old_ck = os.path.join(PROJECT_DIR, "cookies.txt") + new_ck = legacy_cookies_path() + if os.path.exists(old_ck) and not os.path.exists(new_ck): + shutil.copy2(old_ck, new_ck) + + # 旧答案缓存 cache.json + old_cache = os.path.join(PROJECT_DIR, "cache.json") + new_cache = cache_path() + if os.path.exists(old_cache) and not os.path.exists(new_cache): + shutil.copy2(old_cache, new_cache) + except (OSError, shutil.Error) as exc: + from api.logger import logger + logger.debug("旧配置迁移失败({})", type(exc).__name__) + + +def init(): + """启动时调用:确保数据目录存在并完成一次迁移.""" + d = data_dir() + _migrate_once() + return d diff --git a/api/privacy.py b/api/privacy.py new file mode 100644 index 000000000..e18954f4e --- /dev/null +++ b/api/privacy.py @@ -0,0 +1,75 @@ +"""Redaction shared by console logs, file logs and local review records.""" + +import re +import threading +from urllib.parse import urlsplit + +_secrets = set() +_lock = threading.RLock() +_fields = r"(?:password|passwd|pwd|cookies?|authorization|api[_-]?key|key|token|[a-z_]*token|enc|aienc|urltoken|username|account|_?uid|fid|cpi|clazzid|classid|courseid|chat_id|tg_chat_id)" +_assignment = re.compile( + rf"(?i)([\"']?\b{_fields}[\"']?\s*[:=]\s*)(?:\"[^\"]*\"|'[^']*'|[^\s,;&}}\]]+)") +_url = re.compile(r"https?://[^\s<>\"']+", re.I) +_phone = re.compile(r"(?= 4: + with _lock: + _secrets.add(str(value)) + + +def register_config(config): + for key, value in (config or {}).items(): + if isinstance(value, dict): + register_config(value) + elif re.fullmatch(_fields, str(key), re.I) or str(key).lower() in {"url", "tokens"}: + for item in value if isinstance(value, (list, tuple)) else [value]: + register_secret(item) + if str(key).lower() == "tokens": + for token in re.split(r"[,;\s]+", str(item)): + register_secret(token) + + +def redact(value): + text = str(value) + with _lock: + secrets = sorted(_secrets, key=len, reverse=True) + for secret in secrets: + text = text.replace(secret, "[redacted]") + text = re.sub(r"", "[redacted cookies]", text, flags=re.S) + text = re.sub(r"(?i)\bBearer\s+[^\s,;\"']+", "Bearer [redacted]", text) + # Headers and cookie containers can contain several unnamed credentials. + text = re.sub(r"(?is)([\"']?\b(?:set-cookie|cookies?)[\"']?\s*[:=]\s*).*", lambda m: m.group(1) + "[redacted cookies]", text) + text = re.sub(rf"(?is)([\"']?\b{_fields}[\"']?\s*[:=]\s*)[{{\[].*", lambda m: m.group(1) + "[redacted container]", text) + text = _assignment.sub(lambda m: m.group(1) + "[redacted]", text) + # Notification keys can be in path segments, userinfo or arbitrary query keys. + def hide_url(match): + try: + host = urlsplit(match.group()).hostname or "service" + return "https://" + host + "/[redacted]" + except ValueError: + return "[redacted URL]" + text = _url.sub(hide_url, text) + return _phone.sub("[redacted account]", text) + + +def _safe_extra(value): + if isinstance(value, dict): + return {key: "[redacted]" if re.fullmatch(_fields, str(key), re.I) else _safe_extra(item) for key, item in value.items()} + if isinstance(value, (list, tuple)): + return [_safe_extra(item) for item in value] + return redact(value) if isinstance(value, str) else value + + +def patch_record(record): + record["message"] = redact(record["message"]) + record["extra"] = {key: ("[redacted]" if re.fullmatch(_fields, key, re.I) + else _safe_extra(value)) + for key, value in record["extra"].items()} + if record.get("exception"): + # Tracebacks can expose request URLs and locals even with a safe message. + exc = record["exception"] + record["message"] += " | " + redact(str(exc.value)) + record["exception"] = None diff --git a/api/process.py b/api/process.py index 50a46b49c..f8d5cd5d6 100644 --- a/api/process.py +++ b/api/process.py @@ -5,15 +5,13 @@ def sec2time(seconds: int) -> str: - """ - 将秒数转换为时分秒格式的字符串。 - - Args: - seconds: 要转换的秒数 - - Returns: - 格式化的时间字符串,格式为 "h:mm:ss" 或 "mm:ss",如果秒数为0则返回"--:--" - """ + """将秒数转换为时分秒格式的字符串.""" + # + # Args: + # seconds: 要转换的秒数 + # + # Returns: + # 格式化的时间字符串,格式为 "h:mm:ss" 或 "mm:ss",如果秒数为0则返回"--:--" hours = int(seconds / 3600) minutes = int(seconds % 3600 / 60) secs = int(seconds % 60) @@ -27,19 +25,17 @@ def sec2time(seconds: int) -> str: def show_progress(task_name: str, start_position: int, duration: int, total_length: int, speed: float) -> None: - """ - 显示任务进度条,模拟任务进度。 - - Args: - task_name: 当前执行的任务名称 - start_position: 起始位置(以秒为单位) - duration: 任务持续时间(以秒为单位) - total_length: 任务总长度(以秒为单位) - speed: 任务执行速度 - - Returns: - None - """ + """显示任务进度条,模拟任务进度.""" + # + # Args: + # task_name: 当前执行的任务名称 + # start_position: 起始位置(以秒为单位) + # duration: 任务持续时间(以秒为单位) + # total_length: 任务总长度(以秒为单位) + # speed: 任务执行速度 + # + # Returns: + # None start_time = time.time() expected_end_time = start_time + (duration / speed) @@ -64,16 +60,14 @@ def show_progress(task_name: str, start_position: int, duration: int, def increase_learning_count_for_course(chaoxing, course, config): - """ - 为单个课程增加章节学习次数。 - - 遍历课程的所有章节,轮询调用 studentstudyAjax,直到总次数达到 target_count。 - - Args: - chaoxing: Chaoxing 实例 - course: 课程信息字典 - config: 配置字典,需包含 target_count 字段 - """ + """为单个课程增加章节学习次数.""" + # + # 遍历课程的所有章节,轮询调用 studentstudyAjax,直到总次数达到 target_count。 + # + # Args: + # chaoxing: Chaoxing 实例 + # course: 课程信息字典 + # config: 配置字典,需包含 target_count 字段 target_count = config.get("target_count", 100) logger.info(f"开始为课程 [{course['title']}] 增加章节学习次数, 目标总次数: {target_count}") diff --git a/api/review.py b/api/review.py new file mode 100644 index 000000000..5085f5f4b --- /dev/null +++ b/api/review.py @@ -0,0 +1,240 @@ +# -*- coding: utf-8 -*- +"""AI 生成内容复核(留痕 + 查阅).""" +# +# 刷课过程中由 AI 生成、最终提交给平台的"实质性文字"——章节测验简答、作业简答、 +# 主题讨论回复、AI 实践作答——都会在这里留一份可读记录: +# +# ~/.chaoxing/reviews/YYYY-MM-DD.md 人读(Markdown,可直接打开看) +# ~/.chaoxing/reviews/index.jsonl 机读(cx review 用它做翻阅) +# +# 设计原则: +# * 只记录"会被平台看到的文字";客观题的字母答案没有复核价值,不记; +# * 记录失败阻止本项提交,其他任务可以继续; +# * 不含账号、密码、cookie 等敏感信息,只有课程名 / 任务名 / 时间 / 正文 / 平台状态。 + +import json +import os +import textwrap +import time +import threading +from uuid import uuid4 +from typing import List, Optional + +from api import paths +from api.logger import logger +from api.privacy import redact + +KIND_QUIZ = "测验简答" +KIND_HOMEWORK = "作业简答" +KIND_DISCUSSION = "讨论回复" +KIND_PRACTICE = "AI实践作答" + +_INDEX_NAME = "index.jsonl" +_write_lock = threading.RLock() + + +def index_path() -> str: + return os.path.join(paths.reviews_dir(), _INDEX_NAME) + + +def markdown_path(day: Optional[str] = None) -> str: + return os.path.join(paths.reviews_dir(), (day or _today()) + ".md") + + +def _now() -> str: + return time.strftime("%Y-%m-%d %H:%M:%S") + + +def _today() -> str: + return time.strftime("%Y-%m-%d") + + +def record(kind: str, text: str, course: str = "", task: str = "", + status: str = "待提交", extra: Optional[dict] = None) -> Optional[dict]: + """留一条痕。返回记录;失败返回 None,调用方必须阻止本项提交.""" + body = redact(str(text or "").strip()) + if not body: + return None + item = { + "ts": _now(), + "day": _today(), + "kind": str(kind or "AI 生成"), + "course": redact(course or ""), + "task": redact(task or ""), + "status": str(status or ""), + "chars": len(body), + "text": body, + "submission_id": str((extra or {}).get("submission_id") or uuid4().hex), + } + try: + with _write_lock: + os.makedirs(paths.reviews_dir(), exist_ok=True) + os.chmod(paths.reviews_dir(), 0o700) + for path, content in ( + (markdown_path(item["day"]), _markdown_block(item)), + (index_path(), json.dumps(item, ensure_ascii=False) + "\n"), + ): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600) + with os.fdopen(fd, "a", encoding="utf-8") as fp: + os.chmod(path, 0o600) + fp.write(content) + fp.flush() + os.fsync(fp.fileno()) + except Exception as e: # 调用方必须在 None 时阻止提交 + logger.warning("复核记录写入失败,本项不得提交: {}", e) + return None + logger.debug("已留痕待复核: {} · {}", item["kind"], item["task"]) + return item + + +def update(item: Optional[dict], status: str) -> Optional[dict]: + """Append an honest status event; never erase the pre-request record.""" + if not item: + return None + return record(item["kind"], item["text"], course=item["course"], task=item["task"], + status=status, extra={"submission_id": item["submission_id"]}) + + +def _markdown_block(item: dict) -> str: + lines = [ + "", + "## " + item["ts"] + " · " + item["kind"], + "", + "- 课程:" + (item["course"] or "—"), + "- 任务:" + (item["task"] or "—"), + "- 状态:" + (item["status"] or "—") + "(" + str(item["chars"]) + " 字)", + "", + ] + lines.append(textwrap.fill(item["text"], width=76)) + lines.append("") + return "\n".join(lines) + + +def load(days: Optional[int] = None, limit: Optional[int] = None) -> List[dict]: + """读取留痕(新的在前)。days=N 只看最近 N 天.""" + items: List[dict] = [] + path = index_path() + if not os.path.exists(path): + return items + try: + with open(path, encoding="utf-8") as fp: + for line in fp: + line = line.strip() + if not line: + continue + try: + items.append(json.loads(line)) + except ValueError: + continue + except OSError: + return items + latest = {} + for number, item in enumerate(items): + latest[item.get("submission_id") or "legacy-" + str(number)] = item + items = list(reversed(list(latest.values()))) + if days: + edge = time.strftime("%Y-%m-%d", time.localtime(time.time() - (int(days) - 1) * 86400)) + items = [i for i in items if str(i.get("day") or "") >= edge] + if limit: + items = items[: int(limit)] + return items + + +def count_today() -> int: + return len([i for i in load() if i.get("day") == _today()]) + + +def _wrap(text: str, width: int = 62, indent: str = " ") -> str: + return textwrap.fill(str(text or ""), width=width, + initial_indent=indent, subsequent_indent=indent) + + +def render_index(items: List[dict]) -> str: + """列表视图:每条两行,一眼扫过.""" + if not items: + return "\n 还没有可复核的内容。刷课过程中 AI 写的文字会自动记到这里。\n" + out = [""] + for idx, item in enumerate(items, 1): + when = str(item.get("ts") or "")[11:16] + kind = str(item.get("kind") or "") + meta = " · ".join([x for x in (str(item.get("course") or ""), + str(item.get("task") or "")) if x]) + chars = item.get("chars", 0) + status = str(item.get("status") or "") + out.append(f" {idx:>2}. {kind} {meta}") + out.append(f" {when} · {chars} 字 · {status}") + out.append("") + return "\n".join(out) + +def render_item(item: dict, position: str = "") -> str: + """单条视图:正文按 62 列折行,适合终端阅读.""" + lines = [ + " " + "─" * 46, + " " + (position + " " if position else "") + str(item.get("kind", "")) + + " · " + (str(item.get("course") or "") or "—"), + " 任务 " + (str(item.get("task") or "") or "—"), + " 时间 " + str(item.get("ts", "")), + " 状态 " + str(item.get("status", "")) + "(" + str(item.get("chars", 0)) + " 字)", + " " + "─" * 46, + _wrap(item.get("text", "")), + " " + "─" * 46, + ] + return "\n".join(lines) + + +def _ask(prompt: str) -> str: + try: + return input(prompt).strip() + except (EOFError, KeyboardInterrupt): + return "q" + + +def review_cli(argv: Optional[List[str]] = None) -> int: + """Cx review 的入口:翻阅 AI 生成过的文字.""" + argv = list(argv or []) + days = None + limit = None + if "--all" in argv: + days = None + else: + days = 1 + for i, arg in enumerate(argv): + if arg in ("--days", "-d") and i + 1 < len(argv): + try: + days = int(argv[i + 1]) + except ValueError: + days = 1 + if arg in ("--last", "-n") and i + 1 < len(argv): + try: + limit = int(argv[i + 1]) + except ValueError: + limit = None + + items = load(days=days, limit=limit) + scope = "今天" if days == 1 else (f"最近 {days} 天" if days else "全部") + print() + print(" 复核 · AI 生成内容") + print(" " + "─" * 46) + print(f" {scope} {len(items)} 条 · 记录文件 {markdown_path()}") + print(render_index(items)) + if not items or "--list" in argv: + return 0 + + print(" 输入序号看全文(n 下一条 · q 退出)") + cursor = 0 + while True: + raw = _ask(" ▶ ") + if raw.lower() in ("q", "quit", "exit", ""): + return 0 + if raw.lower() == "n": + cursor = (cursor + 1) % len(items) + elif raw.isdigit() and 1 <= int(raw) <= len(items): + cursor = int(raw) - 1 + else: + print(" ✘ 没有这个选项") + continue + print() + print(render_item(items[cursor], f"[{cursor + 1}/{len(items)}]")) + print() + print(" n 下一条 · q 退出") + print() diff --git a/api/scan.py b/api/scan.py new file mode 100644 index 000000000..904c20f51 --- /dev/null +++ b/api/scan.py @@ -0,0 +1,183 @@ +# -*- coding: utf-8 -*- +"""开始刷课前的自动扫描(默认开启,无需用户勾选).""" +# +# 每次开始刷课前跑一遍,把"漏刷"的东西一次说清楚: +# * 章节:共多少节 · 已完成 · 待刷(从哪一节接着刷); +# * 教学任务:已完成 / 可学待完成 / 未解锁 / 暂不支持; +# * 需要人管的:作业等批改、时长类文档平台不计入、新版情景对话未适配。 +# +# 设计原则: +# * 全程只读,不提交任何东西; +# * 失败软着陆:扫描出错只记日志,绝不挡住刷课; +# * 输出控制在几行以内(结论先行,细节看运行日志)。 + +from typing import List, Optional + +from api.logger import logger + + +def chapter_row(course: dict, all_points: Optional[list], error: str = "") -> dict: + """一门课的章节扫描结果(纯计算,不发请求).""" + points = list(all_points or []) + finished = [p for p in points if p.get("has_finished")] + pending = [p for p in points if not p.get("has_finished")] + return { + "title": str(course.get("title") or ""), + "total": len(points), + "finished": len(finished), + "pending": len(pending), + "first": str((pending[0].get("title") if pending else "") or "")[:20], + "error": error, + } + + +def scan_task_center(chaoxing, courses: list, config: dict) -> List[dict]: + """只读扫描任务中心:每门课的分组 / 任务点状态分类.""" + from api.task_center import (TaskCenter, SUPPORTED_PLAN_TYPES, + plan_type_name) + rows = [] + try: + tc = TaskCenter(chaoxing, config) + except Exception as e: + logger.debug("任务中心扫描初始化失败: {}", e) + return rows + for course in courses: + row = {"title": str(course.get("title") or ""), "tasks": 0, "plans": 0, "done": 0, + "todo": 0, "locked": 0, "unsupported": [], "by_type": {}, + "locked_by_type": {}, "error": ""} + try: + tasks = tc.get_course_tasks(course) or [] + row["tasks"] = len(tasks) + for task in tasks: + info = tc.open_task(task) + if not info: + continue + groups = tc.get_groups(info.get("encryTaskUserId", "")) or [] + for group in groups: + plans = tc.get_plans(info.get("encryTaskUserId", ""), + group.get("encryptGroupId", "")) or [] + unlocked = bool(group.get("groupAllowStudy")) + for plan in plans: + row["plans"] += 1 + if tc.plan_finished(plan): + row["done"] += 1 + continue + ptype = int(plan.get("planType") or -1) + name = plan_type_name(ptype) + if ptype not in SUPPORTED_PLAN_TYPES: + if name not in row["unsupported"]: + row["unsupported"].append(name) + continue + if unlocked: + row["todo"] += 1 + row["by_type"][name] = row["by_type"].get(name, 0) + 1 + else: + row["locked"] += 1 + row["locked_by_type"][name] = row["locked_by_type"].get(name, 0) + 1 + except Exception as e: + row["error"] = str(e)[:80] + logger.debug("任务中心扫描失败: {}", e) + rows.append(row) + return rows + + +def _type_text(by_type: dict) -> str: + order = ["作业", "主题讨论", "视频", "文档", "AI实践", "章节"] + parts = [] + for name in order: + if by_type.get(name): + parts.append(f"{name} {by_type[name]}") + for name, count in by_type.items(): + if name not in order: + parts.append(f"{name} {count}") + return " · ".join(parts) + + +def _task_row_warnings(row, only_discussion, discussion_mode): + """Explain pending task types and locked work without implying completion.""" + lines = [] + for name in row.get("unsupported") or []: + lines.append(" 提醒 · " + str(name) + " 暂不支持,需要手动完成") + todo_types = row.get("by_type") or {} + if todo_types.get("作业"): + if only_discussion: + lines.append(" 提醒 · " + str(todo_types["作业"]) + + " 个作业没做(本次只刷讨论,作业要另外选「任务中心」才刷)") + else: + lines.append(" 提醒 · " + str(todo_types["作业"]) + + " 个作业没做,本次会自动完成(简答题要等老师批改)") + if todo_types.get("主题讨论"): + if discussion_mode == "board": + lines.append(" 提醒 · " + str(todo_types["主题讨论"]) + + " 个任务里的主题讨论未做(本次改在讨论区里自己挑)") + elif only_discussion: + lines.append(" 提醒 · " + str(todo_types["主题讨论"]) + + " 个讨论还没回复,本次会自动回复") + else: + lines.append(" 提醒 · " + str(todo_types["主题讨论"]) + + " 个讨论还没回复,本次会一起回复") + if row.get("locked_by_type") and not only_discussion: + lines.append(" 提醒 · 还有 " + _type_text(row["locked_by_type"]) + + " 被前面的分组锁着,完成前面的任务后会自动解锁") + return lines + + +def render(chapter_rows: list, tc_rows: list, chapters_enabled: bool, + task_center_enabled: bool, only_discussion: bool = False, + discussion_mode: str = "task") -> str: + """扫描报告:结论先行,几行说完.""" + lines = [" 开始前扫描", " " + "─" * 46] + for row in chapter_rows or []: + title = str(row.get("title") or "") + if row.get("error"): + lines.append(" " + title + ":章节读取失败,稍后会自动重试") + continue + tail = (",从「" + str(row.get("first")) + "」接着刷") if row.get("first") else "" + lines.append(" " + title) + lines.append(" 章节 " + str(row.get("total")) + " 节 · 已完成 " + + str(row.get("finished")) + " · 待刷 " + str(row.get("pending")) + tail) + for row in tc_rows or []: + title = str(row.get("title") or "") + if row.get("error"): + lines.append(" " + title + ":教学任务读取失败,稍后会自动重试") + continue + if not row.get("tasks"): + continue + lines.append(" " + title) + head = (" 教学任务 " + str(row.get("tasks")) + " 个 · 任务点 " + + str(row.get("plans")) + " 个(已完成 " + str(row.get("done")) + + " · 待完成 " + str(row.get("todo"))) + if row.get("locked"): + head += " · 未解锁 " + str(row.get("locked")) + head += ")" + lines.append(head) + detail = _type_text(row.get("by_type") or {}) + if detail: + lines.append(" 待完成 " + detail) + if only_discussion: + if discussion_mode == "board": + lines.append(" 本次只刷 讨论区(自己挑帖子,逐条确认后发送)") + else: + lines.append(" 本次只刷 任务里的主题讨论(自动,其它类型跳过)") + elif discussion_mode == "board": + lines.append(" 讨论 走讨论区模式(任务里的主题讨论本次跳过)") + lines.extend(_task_row_warnings(row, only_discussion, discussion_mode)) + lines.append(" " + "─" * 46) + return "\n".join(lines) + +def run(chaoxing, courses: list, config: dict, chapter_rows: list, + chapters_enabled: bool, task_center_enabled: bool, + only_discussion: bool = False, discussion_mode: str = "task") -> str: + """执行扫描并返回可直接 print 的报告文本(永不抛异常).""" + tc_rows = [] + if task_center_enabled: + try: + tc_rows = scan_task_center(chaoxing, courses, config) + except Exception as e: + logger.debug("任务中心扫描整体失败: {}", e) + try: + return render(chapter_rows, tc_rows, chapters_enabled, + task_center_enabled, only_discussion, discussion_mode) + except Exception as e: + logger.debug("扫描报告渲染失败: {}", e) + return "" diff --git a/api/task_center.py b/api/task_center.py new file mode 100644 index 000000000..0b2580883 --- /dev/null +++ b/api/task_center.py @@ -0,0 +1,2507 @@ +# -*- coding: utf-8 -*- +"""任务中心「教学任务」支持(task.chaoxing.com 任务引擎).""" +# +# 【为什么需要单独一套逻辑】 +# 新版泛雅课程首页的「任务中心」里,老师可以发布"教学任务"。它和「章节」是 +# 两套互相独立的学习入口: +# * 章节 -> mooc1.chaoxing.com/mooc-ans/knowledge/cards(老接口) +# * 教学任务 -> task.chaoxing.com 的任务引擎,任务点按"分组"解锁, +# 完成上一组才允许学下一组 +# +# 教学任务的每个任务点(plan)有自己的类型: +# 4 作业 8 章节 9 思考题 10 视频 +# 11 文档 14 主题讨论 15 AI实践 +# 本模块能自动完成其中的 视频 / 文档 / AI实践 / 作业;章节同步见 main.py 的编排: +# * 视频:任务引擎自带播放器,上报接口 /videoDataLog/dataLog/{总时长}/{当前秒}/{状态} +# 有"观看时长"要求(enableVideoWatchDuration + N 分钟)时按 1 倍速真实播放, +# 不够就回看;只要求"播完"时可用配置倍速。 +# * 文档:阅读器每 30 秒向 data-xxt 上报一次 readPoint,服务端据此累计阅读时长, +# 凑够 documentWatchDuration 分钟后按需调 /documentStudy/readEnd。 +# * 章节:任务点里带 knowledgeId,但通过平台返回的 stuJobInfo 同步完成状态。 +# * 作业:任务引擎的学习页是 mooc2/work/dowork(新版结构),提交接口 +# addStudentWorkNewWeb;选择题/判断题/填空题走题库,简答题走 ai_writer, +# 提交前走统一确认门禁(章节测验的 api/work 接口对课程级作业返回 403,不能复用)。 +# * 主题讨论:groupweb 话题详情页 → 读已有回复做风格参考 → ai_writer 生成回复 → +# POST /pc/invitation/{topicUuid}/addReplys;文本有硬伤(编造经历等)直接不提交。 +# 其余类型(思考题)目前不做,会明确写日志提示手动完成,绝不会假装成功。 +# +# 接口全部是只读探测出来的,任何一步失败都只影响该任务点,不会影响章节刷课。 + +import hashlib +import json +import os +import re +import sys +import time +from enum import Enum +from typing import Any, Optional +from urllib.parse import parse_qs, quote, unquote, urlparse +from uuid import uuid4 + +from api import interrupt, paths, review +from api.display import answer_line, answers_header, clip, emit, emit_block +from api.ai_writer import HumanLikeWriter +from api.base import ( + SessionManager, + best_option_by_similarity, + build_completion_fields, + build_multiple_answer, + clean_res, + is_subsequence, + multi_cut, + random_answer, +) +from api.decode import decode_homework_page +from api.logger import logger + +# 任务引擎 / 泛雅课程页 +TASK_BASE = "https://task.chaoxing.com" +MOOC_BASE = "https://mooc2-ans.chaoxing.com" +# 主题讨论在 groupweb(话题详情页 + 回复列表/发回复接口) +DISCUSSION_BASE = "https://groupweb.chaoxing.com" +CHAPTER_SCORE_URL = f"{TASK_BASE}/userStudyPlan/autoPullChapterScore" + +# 任务点类型 +PLAN_TYPE_HOMEWORK = 4 +PLAN_TYPE_CHAPTER = 8 +PLAN_TYPE_QUESTION = 9 +PLAN_TYPE_VIDEO = 10 +PLAN_TYPE_DOCUMENT = 11 +PLAN_TYPE_DISCUSS = 14 +PLAN_TYPE_AI = 15 + +PLAN_TYPE_NAMES = { + PLAN_TYPE_HOMEWORK: "作业", + PLAN_TYPE_CHAPTER: "章节", + PLAN_TYPE_QUESTION: "思考题", + PLAN_TYPE_VIDEO: "视频", + PLAN_TYPE_DOCUMENT: "文档", + PLAN_TYPE_DISCUSS: "主题讨论", + PLAN_TYPE_AI: "AI实践", +} + +# 目前能自动完成且能由任务中心状态复查的类型。 +# 章节类型现在能打通:刷 mooc 章节时带 courseEngineInfo,平台下发 stuJobInfo 后 +# 调 autoPullChapterScore,最后用 isFinish 复查。 +# 作业: 读取学习页与提交表单(mooc2/work/dowork + +# addStudentWorkNewWeb),按"接口业务成功 + 任务中心状态复查"接入。 +# 思考题暂不支持,不能按完成处理。 +SUPPORTED_PLAN_TYPES = { + PLAN_TYPE_CHAPTER, PLAN_TYPE_VIDEO, PLAN_TYPE_DOCUMENT, PLAN_TYPE_AI, + PLAN_TYPE_HOMEWORK, PLAN_TYPE_DISCUSS, +} + +# 同一任务点提交后的本地去重窗口(秒)。 +# 平台完成状态有延迟, +# 重复运行不能因此把同一份作业/讨论再提交一遍。 +SUBMISSION_LEDGER_TTL = 6 * 3600 + +# 文档任务点尝试记录窗口(秒)。平台可能不认可文档时长报告, +# 24 小时内不重复消耗真实阅读时间;如果平台之后计入了,任务状态复查会直接通过。 +DOCUMENT_ATTEMPT_TTL = 24 * 3600 + +# 视频打点的间隔(秒)。和任务引擎网页播放器保持一致:每 6 秒一个点。 +VIDEO_DOT_INTERVAL = 6 + +# 文档阅读打点:阅读器每 30 秒向 data-xxt 上报一次阅读点,服务端按它累计阅读时长 +READ_POINT_URL = "https://data-xxt.aichaoxing.com/analysis/ac_mark" +READ_POINT_INTERVAL = 30 +# addPoint.js 的 ac_mark 签名盐(由已脱敏的浏览器样例复核)。 +READ_POINT_ENC_SALT = "NrRzLDpWB2JkeodIVAn4" +# 浏览器从 pan-yz 跨域发起 XHR 时会带的最小请求头。data-xxt 对没有来源的 +# 请求仍可能返回 HTTP 200,但不一定把它计入阅读时长,因此不能只依赖状态码。 +READ_POINT_HEADERS = { + "Accept": "*/*", + "Referer": "https://pan-yz.chaoxing.com/", +} +# 任务中心前端 request.js 对章节成绩同步使用 JSON 请求体。 +CHAPTER_SCORE_HEADERS = { + "Accept": "application/json, text/plain, */*", + "Content-Type": "application/json; charset=UTF-8", +} + +# AI 实践(思维阶梯)接口。入口页会 302 到带 aiEnc 的 SPA,后续接口必须使用 +# SPA 地址里的 aiEnc;不能从课程或任务 ID 自行推导。 +AI_INIT_URL = f"{MOOC_BASE}/mooc2-ans/ai-evaluate/v2/answer/init" +AI_LOAD_DATA_URL = f"{MOOC_BASE}/mooc2-ans/ai-evaluate/v2/answer/load-data" +AI_SUBMIT_URL = f"{MOOC_BASE}/mooc2-ans/ai-evaluate/v2/answer/submit" +AI_TALK_URL = f"{MOOC_BASE}/ai-ans/ai-evaluate/think/main-talk" +# 提交之后平台**不会自动评估**:成绩是学生点"学习质量评估报告"时由这个接口现算的。 +# 提交后需要 end-report 触发评分,不能只等待 answerRecords。 +AI_END_REPORT_URL = f"{MOOC_BASE}/ai-ans/ai-evaluate/think/end-report" +AI_FORM_HEADERS = { + "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", +} +AI_STREAM_HEADERS = { + "Accept": "text/event-stream", + "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", +} + +# SessionManager 有一个较短的默认超时;AI 对话首包和流式回答可能更久, +# 这里显式给任务中心请求设置上限,避免把正常的 SSE 等待误判成平台失败。 +TASK_CENTER_TIMEOUT = 20 +AI_STREAM_TIMEOUT = (10, 180) + +SUBMIT_MODES = ("confirm", "auto") + + +class TaskOutcome(str, Enum): + """任务中心任务点的明确状态,避免把跳过/等待显示成完成.""" + + COMPLETED = "completed" + WAITING_CONFIRMATION = "waiting_confirmation" + LOCKED = "locked" + UNSUPPORTED = "unsupported" + FAILED = "failed" + + +def normalize_submit_mode(value: Any) -> str: + """提交模式只允许 confirm/auto;默认 auto(后台自动提交),错误值也回到 auto.""" + # + # auto = 作答完成后直接提交(适合挂后台刷课,用户要求默认值); + # confirm = 提交前显示预览并询问(需要人工盯着时显式配置)。 + mode = str(value or "auto").strip().lower() + return mode if mode in SUBMIT_MODES else "auto" + + +def _api_success(value: Any) -> bool: + """兼容泛雅接口常见的 true / 1 / "1" 成功表示,拒绝任意非空字符串.""" + if value is True or value == 1: + return True + return isinstance(value, str) and value.strip().lower() in {"1", "true", "yes"} + + +def _browser_timestamp(now: Optional[float] = None) -> str: + """生成阅读器使用的本地时间戳:yyyyMMddHHmmssSSS.""" + if now is None: + now = time.time() + second_part = time.strftime("%Y%m%d%H%M%S", time.localtime(now)) + millis = int(now * 1000) % 1000 + return f"{second_part}{millis:03d}" + + +def _encode_uri_component(value: str) -> str: + """等价于浏览器的 encodeURIComponent(包括其安全字符集合).""" + return quote(value, safe="-_.!~*'()") + + +def _read_point_enc(params: dict) -> str: + """按云盘阅读器 addPoint.js 的规则计算 ac_mark.enc.""" + # + # 浏览器先对 d 做 encodeURIComponent,再按参数名排序拼接所有字符串参数, + # 最后追加固定盐并取 MD5。requests 收到未编码的 d 后会在发送时编码一次, + # 因而这里不能把已编码的 d 再放回 params,否则会在网络层双重编码。 + values = { + key: (_encode_uri_component(value) if key == "d" else value) + for key, value in params.items() + if key != "enc" and isinstance(value, str) + } + material = "".join(values[key] for key in sorted(values)) + return hashlib.md5((material + READ_POINT_ENC_SALT).encode("utf-8"), usedforsecurity=False).hexdigest() + + +def _extract_json_object(text: str, marker: str) -> Optional[dict]: + """从网页里抠出 "const xxx = {...}" 这种内嵌 JSON(页面里往往一整个对象都在).""" + start = text.find(marker) + if start < 0: + return None + brace = text.find("{", start) + if brace < 0: + return None + try: + + obj, _ = json.JSONDecoder().raw_decode(text[brace:]) + return obj if isinstance(obj, dict) else None + except Exception: + return None + + +def _extract_discussion_topic(page_html: str) -> dict: + """从话题详情页里取 urlToken / 标题 / 正文.""" + # + # window.obj.topic 是 JS 字面量(不是严格 JSON,带注释和未加引号的键), + # 所以先定位 topic:{ 片段再用正则取字段,不做整段 JSON 解析。 + info = dict.fromkeys(("url_token", "title", "content", "user_puid"), str()) + matched = re.search(r"urlToken\s*:\s*['\"]([^'\"]+)['\"]", page_html or "") + if matched: + info["url_token"] = matched.group(1) + matched = re.search(r"user:\{[^}]*?\"puid\"\s*:\s*\"?(\d+)\"?", page_html or "") + if matched: + info["user_puid"] = matched.group(1) + index = (page_html or "").find("topic:{") + blob = page_html[index:index + 4000] if index >= 0 else (page_html or "") + for key in ("title", "content"): + matched = re.search(r'"%s"\s*:\s*"((?:[^"\\]|\\.)*)"' % key, blob) + if not matched: + continue + try: + info[key] = json.loads('"' + matched.group(1) + '"') + except ValueError: + info[key] = matched.group(1) + return info + + +def _sse_events(lines, report=False): + """Yield JSON events while accepting report events split across lines.""" + pending = "" + for raw_line in lines: + line = raw_line.decode("utf-8", errors="replace") if isinstance(raw_line, bytes) else str(raw_line) + line = line.strip() + if not line or (not report and not line.startswith("data:")): + continue + payload = line[5:].strip() if line.startswith("data:") else line + if payload == "[DONE]": + if report: + break + continue + payload = pending + payload if report else payload + if not payload: + continue + try: + event = json.loads(payload) + except (TypeError, ValueError): + pending = payload if report else "" + continue + pending = "" + if isinstance(event, dict): + yield event + + +def _sse_content(event): + """Normalize event content without dropping numeric or structured values.""" + content = event.get("content", "") + if content is None: + return "" + return content if isinstance(content, str) else json.dumps(content, ensure_ascii=False) + + +class TaskCenter: + """任务中心客户端:读取教学任务 + 完成任务点.""" + + # + # ``study_video`` / ``study_document`` 保持历史 bool 返回值,供旧调用方继续使用。 + # 新增任务类型会同时更新 ``last_outcome``,编排层据此区分失败、锁定和等待确认。 + # ``writer`` 与 ``confirm_callback`` 可注入,既方便离线测试,也避免把提交确认和 + # 具体终端耦合在网络客户端里。 + + def __init__( + self, + chaoxing: Any, + config: Optional[dict] = None, + writer: Optional[HumanLikeWriter] = None, + confirm_callback=None, + ): + """Initialize configuration and runtime state.""" + self.chaoxing = chaoxing + self.config = config or {} + try: + speed = float(self.config.get("speed", 1.0) or 1.0) + except (TypeError, ValueError): + speed = 1.0 + # 任务引擎的视频倍速不高于页面可选的 2 倍 + self.speed = max(1.0, min(2.0, speed)) + self.submit_mode = normalize_submit_mode(self.config.get("task_center_submit_mode")) + try: + self.ai_practice_min_score = float( + self.config.get("ai_practice_min_score", 85) or 85 + ) + except (TypeError, ValueError): + self.ai_practice_min_score = 85.0 + self.ai_practice_min_score = max(0.0, min(100.0, self.ai_practice_min_score)) + try: + self.ai_practice_max_rounds = int( + float(self.config.get("ai_practice_max_rounds", 5) or 5) + ) + except (TypeError, ValueError): + self.ai_practice_max_rounds = 5 + self.ai_practice_max_rounds = max(1, min(20, self.ai_practice_max_rounds)) + writer_config = self.config.get("tiku_config") or self.config.get("_tiku_config") + self.writer = writer if writer is not None else HumanLikeWriter(writer_config) + self.confirm_callback = ( + confirm_callback + if confirm_callback is not None + else self.config.get("task_center_confirm") + ) + self.last_outcome = TaskOutcome.FAILED + self.waiting_confirmation = False + self.last_read_failed = False + self.last_plan_read_failed = False + self.session = SessionManager.get_session() + + def _set_outcome(self, outcome: TaskOutcome): + self.last_outcome = outcome + if outcome == TaskOutcome.WAITING_CONFIRMATION: + self.waiting_confirmation = True + + def confirm_submission(self, kind: str, preview: str = "") -> bool: + """提交前的统一门禁.""" + # + # confirm 模式在无交互终端中直接安全停止;只有明确输入 y/yes 才会继续。 + # 该门禁只用于会改变课程记录的提交动作,视频/文档打点和状态读取不受影响。 + if self.submit_mode == "auto": + return True + + preview = str(preview or "").strip() + if len(preview) > 600: + preview = preview[:600] + "…" + + if callable(self.confirm_callback): + try: + allowed = bool(self.confirm_callback(kind, preview)) + except Exception as e: + logger.warning("{}提交确认回调失败,按取消处理: {}", kind, e) + allowed = False + if not allowed: + self._set_outcome(TaskOutcome.WAITING_CONFIRMATION) + return allowed + + is_tty = getattr(sys.stdin, "isatty", lambda: False)() + if not is_tty: + logger.warning( + "{}需要人工确认,但当前不是交互终端;为安全起见不提交。", + kind, + ) + self._set_outcome(TaskOutcome.WAITING_CONFIRMATION) + return False + + print("\n ── 任务中心提交确认 ──") + print(f" 类型:{kind}") + if preview: + print(" 内容预览:" + preview.replace("\n", " ")) + try: + # 键盘监听线程(api/interrupt.py)一直在读 stdin:不先让它让开, + # input() 会收到被吃掉字符的碎片(实测 "yes" → "ye"/"ys" 被当取消), + # 甚至永久挂住;而且终端还在 cbreak 模式,用户看不到自己敲了什么。 + with interrupt.stdin_for_prompt(): + answer = input(" 确认提交?输入 y/yes 继续,其他输入取消:") + except (EOFError, KeyboardInterrupt): + answer = "" + if str(answer).strip().lower() in {"y", "yes"}: + return True + logger.info("{}提交已取消,本次不记为完成。", kind) + self._set_outcome(TaskOutcome.WAITING_CONFIRMATION) + return False + + # ------------------------------------------------------------------ 读取 + + def get_course_tasks(self, course: dict) -> list: + """课程的教学任务列表(任务中心 -> 教学任务).""" + self.last_read_failed = False + params = { + "courseId": course.get("courseId", ""), + "clazzId": course.get("clazzId", ""), + "cpi": course.get("cpi", ""), + } + try: + resp = self.session.get( + f"{MOOC_BASE}/mooc2-ans/fanya3/s/taskSignupList", params=params, + timeout=TASK_CENTER_TIMEOUT, + ) + if getattr(resp, "status_code", 0) != 200: + logger.warning( + "《{}》教学任务列表读取失败: HTTP {}", + course.get("title", "?"), getattr(resp, "status_code", "?"), + ) + self.last_read_failed = True + return [] + data = resp.json() + except Exception as e: + logger.warning("教学任务列表读取失败: {} - {}", course.get("title", "?"), e) + self.last_read_failed = True + return [] + + if not isinstance(data, dict) or not _api_success(data.get("status")): + self.last_read_failed = True + if not isinstance(data, dict): + logger.warning("《{}》教学任务列表返回结构异常", course.get("title", "?")) + return [] + msg = str(data.get("msg", "")) + if "无权限" in msg: + logger.info( + "《{}》没有教学任务或当前账号无权限(课程可能不属于该账号)", + course.get("title", "?"), + ) + else: + logger.warning("《{}》教学任务列表读取失败: {}", course.get("title", "?"), msg) + return [] + items = data.get("data") + if not isinstance(items, list): + self.last_read_failed = True + logger.warning("《{}》教学任务列表 data 不是列表,按失败处理", course.get("title", "?")) + return [] + return items + + def open_task(self, task: dict) -> Optional[dict]: + """进入教学任务,拿到 encryTaskUserId / encryTaskId(后续接口都要带).""" + try: + resp = self.session.get( + f"{TASK_BASE}/api/v1/middlePageApi/jumpStudyPlanList", + params={"taskId": task.get("id", "")}, + timeout=TASK_CENTER_TIMEOUT, + ) + except Exception as e: + logger.warning("教学任务打开失败: {} - {}", task.get("name", "?"), e) + self._set_outcome(TaskOutcome.FAILED) + return None + if resp.status_code != 200: + logger.warning("教学任务打开失败: {} HTTP {}", task.get("name", "?"), resp.status_code) + self._set_outcome(TaskOutcome.FAILED) + return None + user_id = re.search(r'const eTaskUserId\s*=\s*"([^"]+)"', resp.text) + if not user_id: + logger.warning("教学任务页面结构变化,未取到 encryTaskUserId: {}", task.get("name", "?")) + self._set_outcome(TaskOutcome.FAILED) + return None + task_id = re.search(r'const encryTaskId\s*=\s*"([^"]+)"', resp.text) + return { + "encryTaskUserId": user_id.group(1), + "encryTaskId": task_id.group(1) if task_id else "", + } + + def get_groups(self, encry_task_user_id: str) -> Optional[list]: + """任务分组:只有 groupAllowStudy=True 的分组才允许学习(顺序解锁).""" + try: + resp = self.session.post( + f"{TASK_BASE}/userStudyPlan/getGroupData", + params={"encryTaskUserId": encry_task_user_id}, + timeout=TASK_CENTER_TIMEOUT, + ) + if getattr(resp, "status_code", 0) != 200: + logger.warning("教学任务分组读取失败: HTTP {}", getattr(resp, "status_code", "?")) + self._set_outcome(TaskOutcome.FAILED) + return None + data = resp.json() + except Exception as e: + logger.warning("教学任务分组读取失败: {}", e) + self._set_outcome(TaskOutcome.FAILED) + return None + if not isinstance(data, dict) or not _api_success(data.get("result")): + if not isinstance(data, dict): + logger.warning("教学任务分组返回结构异常") + self._set_outcome(TaskOutcome.FAILED) + return None + logger.warning("教学任务分组读取失败: {}", data.get("message")) + self._set_outcome(TaskOutcome.FAILED) + return None + items = data.get("data") + if not isinstance(items, list): + logger.warning("教学任务分组 data 不是列表,按失败处理") + self._set_outcome(TaskOutcome.FAILED) + return None + return items + + def get_plans(self, encry_task_user_id: str, encry_group_id: str) -> list: + """分组里的任务点.""" + self.last_plan_read_failed = False + try: + resp = self.session.post( + f"{TASK_BASE}/userStudyPlan/getPlanDataByGroupId", + params={ + "encryTaskUserId": encry_task_user_id, + "encryGroupId": encry_group_id, + }, + timeout=TASK_CENTER_TIMEOUT, + ) + if getattr(resp, "status_code", 0) != 200: + logger.warning("教学任务点读取失败: HTTP {}", getattr(resp, "status_code", "?")) + self.last_plan_read_failed = True + self._set_outcome(TaskOutcome.FAILED) + return [] + data = resp.json() + except Exception as e: + logger.warning("教学任务点读取失败: {}", e) + self.last_plan_read_failed = True + self._set_outcome(TaskOutcome.FAILED) + return [] + if not isinstance(data, dict) or not _api_success(data.get("result")): + self.last_plan_read_failed = True + if not isinstance(data, dict): + logger.warning("教学任务点返回结构异常") + self._set_outcome(TaskOutcome.FAILED) + return [] + logger.warning("教学任务点读取失败: {}", data.get("message")) + self._set_outcome(TaskOutcome.FAILED) + return [] + items = data.get("data") + if not isinstance(items, list): + self.last_plan_read_failed = True + logger.warning("教学任务点 data 不是列表,按失败处理") + self._set_outcome(TaskOutcome.FAILED) + return [] + return items + + def get_study_url(self, encry_task_user_id: str, encrypt_plan_id: str) -> Optional[str]: + """任务点的学习地址;未解锁时接口会返回「任务点未解锁,不允许学习」.""" + try: + resp = self.session.post( + f"{TASK_BASE}/userStudyPlan/getToStudyUrl", + params={ + "encryptPlanId": encrypt_plan_id, + "encryTaskUserId": encry_task_user_id, + "studyJumpType": 0, + "isInterface": "false", + }, + timeout=TASK_CENTER_TIMEOUT, + ) + if getattr(resp, "status_code", 0) != 200: + logger.warning("任务点学习地址获取失败: HTTP {}", getattr(resp, "status_code", "?")) + self._set_outcome(TaskOutcome.FAILED) + return None + data = resp.json() + except Exception as e: + logger.warning("任务点学习地址获取失败: {}", e) + self._set_outcome(TaskOutcome.FAILED) + return None + if not isinstance(data, dict) or not _api_success(data.get("result")): + if not isinstance(data, dict): + logger.warning("任务点学习地址返回结构异常") + self._set_outcome(TaskOutcome.FAILED) + return None + message = str(data.get("message", "")) + if "未解锁" in message or "不允许学习" in message: + self._set_outcome(TaskOutcome.LOCKED) + else: + self._set_outcome(TaskOutcome.FAILED) + logger.info("任务点暂不可学(多半是上一组还没完成): {}", message) + return None + result = data.get("data") + if not isinstance(result, dict): + logger.warning("任务点学习地址 data 不是对象,按失败处理") + self._set_outcome(TaskOutcome.FAILED) + return None + url = result.get("url") + if not url: + self._set_outcome(TaskOutcome.FAILED) + return url + + @staticmethod + def plan_finished(plan: dict) -> bool: + """任务点是否已完成.""" + if not isinstance(plan, dict): + return False + if _api_success(plan.get("isFinish")): + return True + plan_user = plan.get("planUser") + return isinstance(plan_user, dict) and _api_success(plan_user.get("finish")) + + def is_plan_finished( + self, encry_task_user_id: str, encry_group_id: str, plan_id: Any + ) -> bool: + """重新拉一次任务点,确认是否真的完成了.""" + for plan in self.get_plans(encry_task_user_id, encry_group_id): + if str(plan.get("planId")) == str(plan_id): + return self.plan_finished(plan) + return False + + @staticmethod + def chapter_sync_payload(encry_task_user_id: str, chapter_data: dict) -> dict: + """按任务中心网页格式组装章节成绩同步请求体.""" + # + # 任务中心页面在查询参数里会使用编码后的变量,但 + # ``autoPullChapterScore`` 的 JSON 体实际使用原始 ``eTaskUserId``。 + # 这里必须保留 ``open_task`` 返回的原值;requests 会负责 HTTP 层编码。 + return { + "encryTaskUserId": str(encry_task_user_id or ""), + "uid": chapter_data.get("uid", ""), + "finishCount": chapter_data.get("finishCount", 0), + "clazzId": chapter_data.get("clazzId", ""), + "enc": chapter_data.get("enc", ""), + "time": chapter_data.get("time", 0), + "jobCount": chapter_data.get("jobCount", 0), + "knowledgeId": chapter_data.get("knowledgeId", ""), + } + + def sync_chapter_plan(self, encry_task_user_id: str, chapter_data: dict) -> bool: + """把已完成的章节成绩交给任务引擎.""" + # + # HTTP 200 只代表请求到达服务器;只有 JSON 明确返回 ``result=true`` + # 才算同步请求被接受。任务点最终是否完成仍必须由调用方重新读取确认。 + payload = self.chapter_sync_payload(encry_task_user_id, chapter_data) + try: + resp = self.session.post( + CHAPTER_SCORE_URL, + json=payload, + headers=CHAPTER_SCORE_HEADERS, + timeout=TASK_CENTER_TIMEOUT, + ) + except Exception as e: + logger.warning("章节成绩同步失败: {}", e) + return False + if resp.status_code != 200: + logger.warning("章节成绩同步失败: HTTP {}", resp.status_code) + return False + try: + data = resp.json() + except Exception as e: + logger.warning("章节成绩同步返回非 JSON,按失败处理: {}", e) + return False + if not isinstance(data, dict) or data.get("result") is not True: + logger.warning( + "章节成绩同步未被接受: {}", + data.get("message", "返回结果不明确") if isinstance(data, dict) else data, + ) + return False + return True + + def wait_plan_finished( + self, + encry_task_user_id: str, + encry_group_id: str, + plan_id: Any, + tries: int = 6, + interval: float = 5.0, + ) -> bool: + """完成动作之后服务端可能有一点延迟(阅读/观看时长要等它结算),等一下再确认.""" + for i in range(max(1, tries)): + if self.is_plan_finished(encry_task_user_id, encry_group_id, plan_id): + return True + if i < tries - 1: + time.sleep(interval) + return False + + # ------------------------------------------------------------------ 完成 + + def _video_dot(self, encry_id: str, duration: int, current_time: int, status: int) -> bool: + """视频打点:status 0=开始 1=心跳 2=暂停/结束.""" + url = f"{TASK_BASE}/videoDataLog/dataLog/{int(duration)}/{int(current_time)}/{int(status)}" + try: + resp = self.session.get( + url, params={"encryId": encry_id}, timeout=TASK_CENTER_TIMEOUT + ) + if resp.status_code != 200: + logger.warning("视频打点失败: HTTP {}", resp.status_code) + return False + data = resp.json() + except Exception as e: + logger.warning("视频打点失败: {}", e) + return False + if not isinstance(data, dict): + logger.warning("视频打点返回结构异常,按失败处理") + return False + if "result" in data and not _api_success(data.get("result")): + logger.warning("视频打点被拒绝: {}", data.get("message", "")) + return False + if "result" not in data: + logger.warning("视频打点缺少业务成功标记,按失败处理") + return False + return True + + def _save_schedule(self, encry_id: str, current_time: int): + """记录播放位置(网页播放器每 30 秒一次的进度保存).""" + try: + self.session.get( + f"{TASK_BASE}/planUserSchedule/lastCurrentTime/{int(current_time)}", + params={"encryId": encry_id}, + timeout=TASK_CENTER_TIMEOUT, + ) + except Exception as exc: + logger.debug("播放位置保存失败({})", type(exc).__name__) + + @staticmethod + def need_seconds(plan: Optional[dict], enable_key: str, value_key: str) -> int: + """任务点的"时长型"完成条件(读 planBreakthroughSet).""" + # + # 平台把它写成"开关 + 分钟数",例如: + # enableVideoWatchDuration=1 + videoWatchDuration=2.0 -> 要看够 2 分钟 + # enableDocumentWatchDuration=1 + documentWatchDuration=5.0 -> 要读够 5 分钟 + # 返回需要的秒数;没有该要求时返回 0。 + bt = (plan or {}).get("planBreakthroughSet") or {} + try: + enabled = int(bt.get(enable_key) or 0) + except (TypeError, ValueError): + enabled = 0 + if not enabled: + return 0 + try: + minutes = float(bt.get(value_key) or 0) + except (TypeError, ValueError): + minutes = 0.0 + return int(round(minutes * 60)) if minutes > 0 else 0 + + def _task_page(self, study_url, label): + """Load an engine task page and require a successful HTTP response.""" + try: + resp = self.session.get(study_url, timeout=TASK_CENTER_TIMEOUT) + except Exception as exc: + logger.warning("{}任务页打开失败: {}", label, exc) + return None + if resp.status_code != 200: + logger.warning("{}任务页打开失败: HTTP {}", label, resp.status_code) + return None + return resp + + def _video_task_metadata(self, study_url): + """Validate video metadata before starting the paced playback loop.""" + try: + resp = self.session.get(study_url, timeout=TASK_CENTER_TIMEOUT) + except Exception as e: + logger.warning("视频任务页打开失败: {}", e) + return None + if resp.status_code != 200: + logger.warning("视频任务页打开失败: HTTP {}", resp.status_code) + return None + vo = _extract_json_object(resp.text, "videoLearnVo") + if not vo: + logger.warning("视频任务页结构变化,未取到 videoLearnVo") + return None + encry_id = vo.get("encryId") + info = vo.get("videoInfo") or {} + try: + duration = int(info.get("duration") or 0) + except (TypeError, ValueError): + duration = 0 + if not encry_id or duration <= 0: + logger.warning("视频任务信息不完整(encryId/duration 缺失),跳过") + return None + + return vo, encry_id, info, duration + + def study_video(self, study_url: str, plan: Optional[dict] = None) -> bool: + """按真实播放节奏完成任务引擎的视频任务点.""" + # + # 完成条件有两种: + # * enableVideoComplated=1 -> 播完就行 + # * enableVideoWatchDuration=1 + N 分钟 -> 要累计观看够 N 分钟 + # + # 有"观看时长"要求时必须按 1 倍速真实播放:服务端按真实时间判定有效观看 + # 时长(实测 2 倍速打点只算一半、原地心跳不算),一遍不够就回看一遍。 + metadata = self._video_task_metadata(study_url) + if metadata is None: + return False + vo, encry_id, info, duration = metadata + + required = self.need_seconds(plan, "enableVideoWatchDuration", "videoWatchDuration") + # 有时长要求 -> 1 倍速,保证"有效观看时长"和真实时间一致 + speed = 1.0 if required else self.speed + try: + watched = int(vo.get("farthestTimeValue") or vo.get("currentTime") or 0) + except (TypeError, ValueError): + watched = 0 + current = max(0, min(watched, duration)) + + logger.info( + "任务中心视频:{}(时长 {} 秒,已看 {} 秒,{} 倍速{})", + info.get("videoName", ""), duration, current, speed, + f",需要观看 {required} 秒" if required else "", + ) + # 长视频给一行用户可见提示(控制台刷课期间只显示 print 和 WARNING) + if duration >= 180 or required >= 180: + minutes = max(1, int((required or duration) // 60)) + print(f" · 播放视频:{info.get('videoName', '')}(约 {minutes} 分钟)") + + effective = 0.0 + passes = 0 + max_passes = max(2, required // max(1, duration) + 2) if required else 1 + while True: + passes += 1 + start = current if passes == 1 else 0 + if not self._video_dot(encry_id, duration, start, 0): + return False + current = start + while current < duration: + if interrupt.should_stop(): + self._video_dot(encry_id, duration, current, 2) + return False + # 按 6 秒视频时间打一个点;倍速只影响真实的等待时间 + time.sleep(VIDEO_DOT_INTERVAL / speed) + current = min(duration, current + VIDEO_DOT_INTERVAL) + effective += VIDEO_DOT_INTERVAL / speed + if not self._video_dot(encry_id, duration, current, 1): + return False + self._save_schedule(encry_id, current) + + if not self._video_dot(encry_id, duration, duration, 2): + return False + self._save_schedule(encry_id, duration) + + if not required or effective >= required or passes >= max_passes: + break + logger.info( + "需要累计观看 {} 秒,当前有效 {:.0f} 秒,回看一遍(第 {} 遍)", + required, effective, passes + 1, + ) + time.sleep(2) + logger.info("任务中心视频完成: {}(播放 {} 秒)", info.get("videoName", ""), duration) + return True + + @staticmethod + def _parse_reader_mark(html: str) -> Optional[dict]: + """从云盘阅读器页面取出打点信息 markDataStr(资源ID、页数、ext 等).""" + matched = re.search(r'id="markDataStr"[^>]*>(.*?)

', html, re.S) + if not matched: + return None + try: + data = json.loads(matched.group(1).strip()) + except (ValueError, TypeError): + return None + return data + + def _send_read_point(self, mark: dict, seq: int) -> bool: + """上报一个阅读点(真实阅读器每 30 秒一次).""" + # + # 请求形态和签名与阅读器 addPoint.js 对齐:d 在 params 中保留原始 JSON, + # 交给 requests 在网络层编码一次;enc 则使用 d 的 encodeURIComponent 形式计算。 + payload = { + "r": mark.get("resourceID", ""), + "t": mark.get("resourceType", "doc"), + "l": mark.get("location", 1), + "f": mark.get("from", 4), + "p": mark.get("curPage", 1), + # addPoint.js 使用 markDataStr.totalPage;页面里的 pagenum 是另一套展示变量。 + "tp": mark.get("totalPage") or 1, + "wc": 0, + "ic": 2, + "v": 2, + # addPoint.js 的首报状态为 1,后续阅读心跳固定为 2;seq 仅用于本地日志。 + "s": 1 if seq == 1 else 2, + "h": 0, + "ext": mark.get("ext", ""), + } + body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")) + params = { + "f": "readPoint", + "u": mark.get("passportUID", ""), + "d": body, + "t": _browser_timestamp(), + } + # addPoint.js 只把值为字符串的可选参数放进查询串;当前文档 mark 通常没有它们。 + for key in ("pid", "s"): + value = mark.get(key) + if isinstance(value, str): + params[key] = value + params["enc"] = _read_point_enc(params) + try: + resp = self.session.get( + READ_POINT_URL, + params=params, + headers=READ_POINT_HEADERS, + timeout=TASK_CENTER_TIMEOUT, + ) + return resp.status_code == 200 + except Exception as e: + logger.warning("文档阅读打点失败: {}", e) + return False + + def _read_document_points(self, mark: dict, required_seconds: int) -> bool: + """按真实时间打点,凑够任务点要求的阅读时长.""" + started = time.time() + seq = 0 + total_points = max(1, int(required_seconds / READ_POINT_INTERVAL)) + while True: + seq += 1 + if not self._send_read_point(mark, seq): + logger.warning("文档阅读打点未被接受,本次不计为完成") + return False + elapsed = time.time() - started + logger.info( + "文档阅读打点 {}/{}:已阅读 {:.0f}/{:.0f} 秒", + seq, total_points, elapsed, required_seconds, + ) + if elapsed >= required_seconds: + return True + if interrupt.should_stop(): + return False + time.sleep(min(READ_POINT_INTERVAL, max(1.0, required_seconds - elapsed))) + + def study_document(self, study_url: str, plan: Optional[dict] = None) -> bool: + """完成任务引擎的文档任务点.""" + # + # 文档的完成条件是"阅读时长 >= N 分钟"(planBreakthroughSet.documentWatchDuration), + # 阅读时长由云盘阅读器的 readPoint 打点累计,所以流程是: + # 1. 打开任务引擎文档页,取出云盘阅读器地址 + # 2. 打开阅读器页,取出打点信息 markDataStr + # 3. 每 30 秒打一个点,凑够要求的分钟数 + # 4. 页面明确要求"完成阅读"(enableCompleteRead)时再调 readEnd + resp = self._task_page(study_url, "文档") + if resp is None: + return False + page = resp.text + matched = re.search(r'encryPlanUserId\s*=\s*"([^"]+)"', page) + required = self.need_seconds(plan, "enableDocumentWatchDuration", "documentWatchDuration") + + mark = None + reader_info = _extract_json_object(page, "docStudyUrlInfo") or {} + reader_url = reader_info.get("yunPanUrl") + if reader_url: + try: + reader_resp = self.session.get(reader_url, timeout=TASK_CENTER_TIMEOUT) + if reader_resp.status_code == 200: + mark = self._parse_reader_mark(reader_resp.text) + except Exception as e: + logger.warning("文档阅读器打开失败: {}", e) + + if required: + if self._recently_submitted(plan, kind="document", ttl=DOCUMENT_ATTEMPT_TTL): + logger.info( + "文档任务 [{}] 24 小时内已尝试过且平台未计入,本次跳过(避免重复消耗真实阅读时间)", + (plan or {}).get("name") or "文档", + ) + return True + if not mark: + # 拿不到打点信息就没法证明阅读时长,不能假装完成 + logger.warning("文档任务需要阅读 {} 秒,但没取到阅读器打点信息,本次跳过", required) + return False + label = (plan or {}).get("name") or reader_info.get("name") or "文档" + logger.info("任务中心文档:{}(需要阅读约 {:.0f} 分钟)", label, required / 60) + print(f" · 阅读文档:{label}(约 {required / 60:.0f} 分钟,请勿关闭窗口)") + if not self._read_document_points(mark, required): + return False + self._mark_submitted(plan, kind="document") + + if matched and self._breakthrough_enabled(plan, "enableCompleteRead"): + try: + end_resp = self.session.get( + f"{TASK_BASE}/documentStudy/readEnd", + params={"encryPlanUserId": matched.group(1)}, + timeout=TASK_CENTER_TIMEOUT, + ) + if end_resp.status_code != 200: + logger.warning("文档任务标记失败: HTTP {}", end_resp.status_code) + return False + data = end_resp.json() + if not isinstance(data, dict) or not _api_success(data.get("result")): + message = data.get("message", "") if isinstance(data, dict) else "返回结构异常" + logger.warning("文档任务标记失败: {}", message) + return False + except Exception as e: + logger.warning("文档任务标记失败: {}", e) + return False + return True + + @staticmethod + def _breakthrough_enabled(plan: Optional[dict], key: str) -> bool: + """读取 planBreakthroughSet 中的开关,拒绝把非空字符串当成功.""" + breakthrough = (plan or {}).get("planBreakthroughSet") or {} + if not isinstance(breakthrough, dict): + return False + try: + value = breakthrough.get(key) + return int(value or 0) == 1 + except (TypeError, ValueError): + return _api_success(breakthrough.get(key)) + + # ------------------------------------------------------------ AI 实践 + + @staticmethod + def _ai_page_params(url: str, html: str = "") -> Optional[dict]: + """从 AI 实践 302 后的 SPA 地址取出平台实际发给接口的参数.""" + parsed = urlparse(url or "") + query = { + key: values[-1] + for key, values in parse_qs(parsed.query, keep_blank_values=True).items() + if values + } + lowered = {key.lower(): value for key, value in query.items()} + + def pick(*names): + for name in names: + value = query.get(name) + if value is None: + value = lowered.get(name.lower()) + if value not in (None, ""): + return unquote(str(value)) + # 某些入口把参数写进内嵌脚本;这里只接受明确的键值,不猜算法或 ID。 + for name in names: + pattern = ( + r"(?:[?&]" + + re.escape(name) + + r"=|[\"']?" + + re.escape(name) + + r"[\"']?\s*[:=]\s*[\"'])([^&\"'\s<]+)" + ) + matched = re.search(pattern, html or "", re.I) + if matched: + return unquote(matched.group(1)) + return "" + + params = { + "courseid": pick("courseid", "courseId"), + "clazzid": pick("clazzid", "clazzId"), + "cpi": pick("cpi"), + "publishRelationUuid": pick("publishRelationUuid"), + "aiEnc": pick("aiEnc", "ai_enc"), + "isPreview": pick("isPreview") or "0", + } + required = ("courseid", "clazzid", "cpi", "publishRelationUuid", "aiEnc") + if any(not params[key] for key in required): + return None + return params + + @staticmethod + def _ai_query(params: dict, record_uuid: Optional[str] = None) -> dict: + query = { + key: params.get(key, "") + for key in ("courseid", "clazzid", "cpi", "publishRelationUuid") + } + if record_uuid: + query["recordUuid"] = str(record_uuid) + return query + + @staticmethod + def _ai_talk_query(params: dict, record_uuid: str) -> dict: + return { + "courseId": params.get("courseid", ""), + "clazzId": params.get("clazzid", ""), + "cpi": params.get("cpi", ""), + "aiEnc": params.get("aiEnc", ""), + "recordUuid": str(record_uuid or ""), + "isPreview": params.get("isPreview", "0"), + "newAnswerView": "true", + } + + @staticmethod + def _response_json(resp, label: str) -> Optional[dict]: + if getattr(resp, "status_code", 0) != 200: + logger.warning("{}失败: HTTP {}", label, getattr(resp, "status_code", "?")) + return None + try: + data = resp.json() + except Exception as e: + logger.warning("{}返回非 JSON,按失败处理: {}", label, e) + return None + if not isinstance(data, dict): + logger.warning("{}返回结构异常,按失败处理", label) + return None + return data + + def _ai_load_data(self, params: dict, record_uuid: Optional[str] = None) -> Optional[dict]: + query = self._ai_query(params, record_uuid) + try: + resp = self.session.get( + AI_LOAD_DATA_URL, params=query, timeout=TASK_CENTER_TIMEOUT + ) + except Exception as e: + logger.warning("AI实践状态读取失败: {}", e) + return None + data = self._response_json(resp, "AI实践状态读取") + if data is None or not _api_success(data.get("status")): + logger.warning("AI实践状态读取未被接受: {}", data.get("msg", "") if data else "") + return None + result = data.get("data") + if not isinstance(result, dict): + logger.warning("AI实践状态读取缺少 data,按失败处理") + return None + return result + + def _ai_init(self, params: dict) -> Optional[dict]: + """初始化一次新的作答;已存在未完成记录时返回空字典,交给调用方续接.""" + # + # 前端 helper 会把该 POST 序列化成 form-urlencoded,而不是 JSON。 + payload = { + "type": 2, + "courseid": params.get("courseid", ""), + "clazzid": params.get("clazzid", ""), + "cpi": params.get("cpi", ""), + "publishRelationUuid": params.get("publishRelationUuid", ""), + } + try: + resp = self.session.post( + AI_INIT_URL, + data=payload, + headers=AI_FORM_HEADERS, + timeout=TASK_CENTER_TIMEOUT, + ) + except Exception as e: + logger.warning("AI实践作答初始化失败: {}", e) + return None + data = self._response_json(resp, "AI实践作答初始化") + if data is None: + return None + if not _api_success(data.get("status")): + text = " ".join( + str(data.get(key, "")) + for key in ("msg", "message", "errorCode", "code") + ) + if "4601" in text or "已存在未完成" in text: + logger.info("AI实践已有未完成记录,改为续接,不重复初始化") + return {} + logger.warning("AI实践作答初始化未被接受: {}", text.strip()) + return None + result = data.get("data") + if not isinstance(result, dict): + logger.warning("AI实践作答初始化缺少 data,按失败处理") + return None + if not result.get("recordUuid") or not result.get("answerUuid"): + logger.warning("AI实践作答初始化缺少 recordUuid/answerUuid,按失败处理") + return None + return result + + @staticmethod + def parse_ai_sse(lines) -> dict: + """解析 main-talk 的 SSE 行,保留前端使用的题目字段和特殊标记.""" + result = { + "content": "", + "preAppendContent": "", + "questionType": "", + "questionTypeInt": "", + "dimension": "", + "knowledgePoint": "", + "questionStem": "", + "options": [], + "special_marks": [], + "had_data": False, + "stream_closed": False, + "error": "", + } + option_map = {} + try: + for event in _sse_events(lines): + result["had_data"] = True + if "status" in event and not _api_success(event.get("status")): + result["error"] = str(event.get("msg") or event.get("message") or "SSE业务失败") + continue + content = _sse_content(event) + if content: + result["content"] += content + + if any(marker in content for marker in ( + "RightMark", "QuestionTip", "SummaryTopic", "TopicTest", + "SonQuestion", "showTipBtn", + )): + result["special_marks"].append(content) + + event_type = str(event.get("type") or "") + if event_type in {"preAppendContent", "questionType", "questionTypeInt", + "dimension", "knowledgePoint", "questionStem"}: + result[event_type] += content + elif event_type.startswith("option-"): + option = event_type.split("-", 1)[1].strip().upper() + if option: + option_map[option] = option_map.get(option, "") + content + except Exception as e: + result["error"] = str(e) + return result + + result["options"] = [ + {"option": option, "optionContent": content} + for option, content in option_map.items() + ] + result["stream_closed"] = True + return result + + @staticmethod + def parse_ai_report_sse(lines) -> dict: + """解析"学习质量评估报告"的 SSE:成绩是 id=score 的那条事件.""" + # + # 平台**不会**在提交后自动评估:提交后 answerRecords 里可能仍然没有分数, + # 必须请求 end-report(页面上就是"学习质量评估报告"按钮)才会现算成绩。 + # 这个流会把同一条 JSON 拆到多行(中文 key 更长),所以按"拼接后能解析就算一条"处理。 + result = { + "score": None, + "sections": {}, + "had_data": False, + "stream_closed": False, + "error": "", + } + try: + for event in _sse_events(lines, report=True): + result["had_data"] = True + content = _sse_content(event) + key = str(event.get("id") or "").strip() + if key: + result["sections"][key] = result["sections"].get(key, "") + content + except Exception as e: + result["error"] = str(e) + return result + + result["stream_closed"] = True + matched = re.search(r"\d+(?:\.\d+)?", result["sections"].get("score", "")) + if matched: + try: + result["score"] = float(matched.group(0)) + except ValueError: + result["score"] = None + return result + + def _ai_end_report(self, params: dict, record_uuid: str) -> Optional[float]: + """请求"学习质量评估报告",让平台把这一局的成绩算出来.""" + query = { + "courseId": params.get("courseid", ""), + "clazzId": params.get("clazzid", ""), + "cpi": params.get("cpi", ""), + "aiEnc": params.get("aiEnc", ""), + "recordUuid": str(record_uuid or ""), + } + if not query["recordUuid"] or not query["aiEnc"]: + logger.warning("AI实践质量评估报告缺少 recordUuid/aiEnc,跳过") + return None + try: + resp = self.session.post( + AI_END_REPORT_URL, + params=query, + data={}, + headers=AI_STREAM_HEADERS, + stream=True, + timeout=AI_STREAM_TIMEOUT, + ) + except Exception as e: + logger.warning("AI实践质量评估报告请求失败: {}", e) + return None + try: + result = self.parse_ai_report_sse(resp.iter_lines(decode_unicode=True)) + except Exception as e: + logger.warning("AI实践质量评估报告读取失败: {}", e) + return None + finally: + close = getattr(resp, "close", None) + if callable(close): + close() + if result.get("error"): + logger.warning("AI实践质量评估报告流异常: {}", result["error"]) + if not result.get("had_data") or not result.get("stream_closed"): + logger.warning("AI实践质量评估报告没有完整数据,按失败处理") + return None + if result.get("score") is None: + logger.warning("AI实践质量评估报告里没有成绩,按失败处理") + return None + logger.info("AI实践质量评估报告成绩:{:.1f}", result["score"]) + return float(result["score"]) + + def _ai_stream(self, params: dict, record_uuid: str, user_message: str) -> Optional[dict]: + query = self._ai_talk_query(params, record_uuid) + payload = {"userMessage": str(user_message or "")} + try: + resp = self.session.post( + AI_TALK_URL, + params=query, + data=payload, + headers=AI_STREAM_HEADERS, + stream=True, + timeout=AI_STREAM_TIMEOUT, + ) + except Exception as e: + logger.warning("AI实践对话请求失败: {}", e) + return None + try: + iterator = resp.iter_lines(decode_unicode=False) + result = self.parse_ai_sse(iterator) + except Exception as e: + logger.warning("AI实践 SSE 读取失败: {}", e) + return None + finally: + close = getattr(resp, "close", None) + if callable(close): + close() + if not result.get("had_data") or not result.get("stream_closed"): + logger.warning("AI实践 SSE 没有完整有效数据,按失败处理") + return None + if result.get("error"): + logger.warning("AI实践 SSE 业务失败: {}", result["error"]) + return None + return result + + def _ai_submit(self, params: dict, record_uuid: str, preview: str = "") -> bool: + if not self.confirm_submission("AI实践", preview): + return False + try: + resp = self.session.post( + AI_SUBMIT_URL, + params=self._ai_query(params, record_uuid), + data={}, + headers=AI_FORM_HEADERS, + timeout=TASK_CENTER_TIMEOUT, + ) + except Exception as e: + logger.warning("AI实践提交失败: {}", e) + self._set_outcome(TaskOutcome.FAILED) + return False + data = self._response_json(resp, "AI实践提交") + if data is None or not _api_success(data.get("status")) or not data.get("data"): + logger.warning("AI实践提交未被接受: {}", data.get("msg", "") if data else "") + self._set_outcome(TaskOutcome.FAILED) + return False + return True + + @staticmethod + def _ai_message_payload(message: dict) -> Optional[dict]: + if not isinstance(message, dict): + return None + payload = message.get("contentJson") + if not isinstance(payload, dict): + payload = message.get("content") + if isinstance(payload, str): + try: + payload = json.loads(payload) + except (TypeError, ValueError): + return None + return payload if isinstance(payload, dict) else None + + @staticmethod + def _ai_options(raw) -> list: + if isinstance(raw, str): + try: + raw = json.loads(raw) + except (TypeError, ValueError): + raw = [] + if isinstance(raw, dict): + raw = [ + {"option": key, "optionContent": value} + for key, value in raw.items() + ] + if not isinstance(raw, list): + return [] + options = [] + for item in raw: + if isinstance(item, dict): + option = str(item.get("option") or item.get("key") or "").strip().upper() + content = item.get("optionContent") or item.get("content") or "" + else: + option = "" + content = item + if option: + options.append({"option": option, "optionContent": str(content)}) + return options + + @classmethod + def _ai_turn_from_payload(cls, payload: Optional[dict]) -> Optional[dict]: + if not isinstance(payload, dict): + return None + turn = { + "content": str(payload.get("content") or ""), + "preAppendContent": str(payload.get("preAppendContent") or ""), + "questionType": str(payload.get("questionType") or ""), + "questionTypeInt": str(payload.get("questionTypeInt") or ""), + "dimension": str(payload.get("dimension") or ""), + "knowledgePoint": str(payload.get("knowledgePoint") or ""), + "questionStem": str(payload.get("questionStem") or ""), + "options": cls._ai_options( + payload.get("questionOptions") or payload.get("options") + ), + "special_marks": [], + } + return turn if cls._ai_turn_has_question(turn) else None + + @staticmethod + def _ai_turn_has_question(turn: Optional[dict]) -> bool: + if not isinstance(turn, dict): + return False + stem = str(turn.get("questionStem") or "").strip() + options = turn.get("options") or [] + return bool(stem or options) + + # 平台结束一局时,最后一条是"知识点解析/小结"这类总结,而不是题目 + AI_SUMMARY_MARKS = ("知识点解析", "小结", "本局结束", "本轮结束", "练习结束", "继续加油") + + # 同一道题最多试几个答案:平台判分是它自己的大模型,偶尔会把标准答案 + # 判错并反复推回同一题。 + # 试满一轮选项还不够,就带着本轮已有作答直接提交,不再空转。 + AI_MAX_TRIES_PER_QUESTION = 4 + # 连续几次作答都没让平台的 messageList 变长,说明这一局其实已经结束、 + # 平台只是在把最后一道题推回来(实测"错/对"来回换了十几次仍在空转)。 + AI_STALL_LIMIT = 2 + + @classmethod + def _ai_pending_turn(cls, data: dict) -> Optional[dict]: + """取当前还没作答的题.""" + # + # 注意:从后往前扫时,一旦先遇到平台的结束总结,就必须返回 None。 + # 实测踩过坑:总结之后还留着上一条题目,旧实现会把那条**过期题目**当成 pending, + # 于是对着它反复作答、平台根本不再收录,一路空转到轮数上限(23 分钟白跑)。 + messages = data.get("messageList") or [] + if not isinstance(messages, list): + return None + for message in reversed(messages): + if not isinstance(message, dict): + continue + role = str(message.get("role") or "") + if role != "2": + continue + payload = cls._ai_message_payload(message) + if isinstance(payload, dict): + plain = str(payload.get("content") or "") + if not payload.get("questionStem") and any( + mark in plain for mark in cls.AI_SUMMARY_MARKS): + return None + turn = cls._ai_turn_from_payload(payload) + if turn: + return turn + return None + + @staticmethod + def _ai_completion_state(data: dict) -> Optional[bool]: + """返回 True=明确完成、False=明确未完成、None=平台未给出足够证据.""" + if not isinstance(data, dict): + return None + pending = data.get("unCompleteTopic") + if isinstance(pending, (list, tuple, set)): + return not bool(pending) + if isinstance(pending, dict): + if "isDone" in pending: + return _api_success(pending.get("isDone")) + return False + if isinstance(pending, str): + return pending.strip().lower() in {"", "0", "false", "[]", "{}", "null"} + + dimensions = data.get("dimensionList") + if isinstance(dimensions, list) and dimensions: + topics_found = False + for dimension in dimensions: + topics = dimension.get("topicList") if isinstance(dimension, dict) else None + for topic in topics or []: + if isinstance(topic, dict) and not topic.get("diy"): + topics_found = True + if not _api_success(topic.get("isDone")): + return False + if topics_found: + return True + return None + + def _ai_wait_for_score(self, params: dict, record_uuid: str, + tries: int = 20, interval: float = 30.0): + """提交后等平台出评估结果.""" + # + # 平台不是立刻出分:实测提交后要几分钟,`answerRecords` 里才会出现 + # statusMsg=已评估。这里轮询 load-data,等到就返回分数。 + data = None + for attempt in range(max(1, tries)): + if interrupt.should_stop(): + return None, data + data = self._ai_load_data(params, record_uuid) + if data is not None: + for record in data.get("answerRecords") or []: + if not isinstance(record, dict): + continue + if str(record.get("recordUuid")) != str(record_uuid): + continue + # 平台只把评估过的记录放进 answerRecords;拿到本条记录才算真出分, + # 不能用顶层的 answerScore(那是上一次练习的旧分数) + score = self._ai_score(data, record_uuid) + if score is not None: + logger.info( + "AI实践第 {} 次轮询拿到评估成绩: {}({})", + attempt + 1, score, record.get("statusMsg") or "", + ) + return score, data + if attempt < tries - 1: + time.sleep(interval) + return None, data + + @staticmethod + def _ai_score(data: dict, record_uuid: Optional[str] = None) -> Optional[float]: + records = [r for r in (data or {}).get("answerRecords") or [] if isinstance(r, dict)] + if record_uuid: + # 问"这一条记录考了多少分"时,**只能**用这条记录自己的分数。 + # 旧实现会回落到顶层 answerScore(那是上一次练习的成绩), + # 一旦本条还没评估,就会把上一次的分数当成本次的成绩。 + for record in records: + if str(record.get("recordUuid")) == str(record_uuid): + try: + if record.get("score") not in (None, ""): + return float(record.get("score")) + except (TypeError, ValueError): + return None + return None + return None + candidates = [ + data.get("answerScore"), + (data.get("reportData") or {}).get("score") + if isinstance(data.get("reportData"), dict) else None, + ] + candidates.extend(record.get("score") for record in records) + for candidate in candidates: + try: + if candidate not in (None, ""): + return float(candidate) + except (TypeError, ValueError): + continue + return None + + @staticmethod + def _ai_record_scores(data: dict) -> list: + """平台已经评估过的每一次练习成绩(answerRecords).""" + scores = [] + for record in (data or {}).get("answerRecords") or []: + if not isinstance(record, dict): + continue + try: + if record.get("score") not in (None, ""): + scores.append(float(record.get("score"))) + except (TypeError, ValueError): + continue + return scores + + @classmethod + def _ai_average_score(cls, data: dict) -> Optional[float]: + """练习平均分.""" + # + # 页面上写的达标口径是"学生多次练习平均分达到 N 分",所以历史低分记录会拖后腿; + # 单次满分并不等于这项练习的最终成绩够看。 + scores = cls._ai_record_scores(data) + return sum(scores) / len(scores) if scores else None + + @staticmethod + def _ai_question_key(turn: dict) -> str: + """同一道题(含追问)在平台里是同一段题干,用它来记住试过哪些答案.""" + stem = str((turn or {}).get("questionStem") or (turn or {}).get("content") or "") + return re.sub(r"\s+", "", stem)[:100] + + @staticmethod + def _ai_answer_core(answer: str) -> str: + """从作答文本里取出"核心答案"(选项字母 / 对错),用于判断这题试过什么.""" + text = str(answer or "").strip() + matched = re.match(r"选\s*([A-Ea-e]+)", text) + if matched: + return matched.group(1).upper() + if text in {"对", "错"}: + return text + return text[:40] + + def _ai_answer(self, turn: dict, data: dict, exclude=None) -> str: + stem = str(turn.get("questionStem") or turn.get("content") or "").strip() + options = self._ai_options(turn.get("options")) + question_type = self._ai_answer_type(turn, options) + requirement = str(data.get("requirement") or "").strip() + # 客观题只需要"维度/知识点"这种题干上下文;平台反馈另算一份, + # **只用于选择题/判断题的内部判据**。开放题的正文绝不能带平台判分话术, + # 否则"回答正确/本题考核知识点"就会被写进交给老师的答案里。 + context = ";".join( + value for value in ( + str(turn.get("dimension") or "").strip(), + str(turn.get("knowledgePoint") or "").strip(), + ) if value + ) + choice_context = context + if str(turn.get("preAppendContent") or "").strip(): + choice_context = (choice_context + ";" if choice_context else "") + \ + re.sub(r"\s+", " ", str(turn.get("preAppendContent")))[:200] + feedback = getattr(self.writer, "_recent_feedback", None) + if callable(feedback): + try: + hints = feedback(data) + except Exception: + hints = "" + if hints: + choice_context = (choice_context + ";平台判据:" + hints) if choice_context \ + else ("平台判据:" + hints) + + if question_type in {"0", "1"} and options: + return self._ai_choice_answer(stem, options, question_type, choice_context, exclude) + + if question_type == "3": + judge = getattr(self.writer, "choose_judgement", None) + if not callable(judge): + raise RuntimeError("当前写作器不支持 AI 实践判断题") + try: + answer = judge(stem, context=choice_context, exclude=exclude) + except TypeError: + answer = judge(stem, context=choice_context) + answer = str(answer).strip() + if answer not in {"对", "错"}: + raise RuntimeError("AI 实践判断题没有得到有效答案") + return answer + + answerer = getattr(self.writer, "practice_answer", None) + if callable(answerer): + answer = answerer(stem, requirement=requirement, context=context) + else: + answer = self.writer.answer(stem, requirement=requirement, max_chars=500) + answer = str(answer or "").strip() + if not answer: + raise RuntimeError("AI 实践简答没有生成内容") + return answer[:2000] + + @staticmethod + def _ai_turn_type(turn: dict) -> str: + raw = (turn or {}).get("questionTypeInt") + label = str((turn or {}).get("questionType") or "").strip() + value = str(raw) if raw is not None else label + if value in {"0", "1", "3"}: + return {"0": "single", "1": "multiple", "3": "judgement"}[value] + if "判断" in label: + return "judgement" + if "多选" in label: + return "multiple" + if "单选" in label or (turn or {}).get("options"): + return "single" + return "shortanswer" + + @staticmethod + def _ai_turn_title(turn: dict) -> str: + for key in ("questionStem", "stem", "question", "title", "content"): + value = str((turn or {}).get(key) or "").strip() + if value: + return value + return "" + + @staticmethod + def _ai_record_submitted(data: dict) -> bool: + try: + return int(data.get("recordStatus") or 0) in {1, 2} + except (TypeError, ValueError): + return str(data.get("recordStatus") or "") in {"1", "2"} + + # -------------------------------------------------------------- 主题讨论 + + def _load_discussion_replies(self, bbsid: str, topic_uuid: str, user_puid: str = "", + limit: int = 8) -> tuple: + """读讨论已有回复.""" + # + # 返回 (回复正文列表, 自己是否已经回复过)。 + # 正文供 ai_writer 模仿语气;"已回复过"用来避免重复运行同一任务时反复发帖。 + # 读取失败就当没有参考、也没回复过(上层仍会走正常的提交路径)。 + try: + resp = self.session.get( + f"{DISCUSSION_BASE}/pc/invitation/getReplyList", + params={"bbsid": bbsid, "uuid": topic_uuid, "tag": "", "order": 2, + "lastValue": "", "lastAuxValue": ""}, + timeout=TASK_CENTER_TIMEOUT, + ) + data = resp.json() + except Exception as e: + logger.debug("读取讨论已有回复失败(不参考风格继续): {}", e) + return [], False + items = data.get("datas") if isinstance(data, dict) else None + if not isinstance(items, list): + return [], False + texts = [] + has_replied = False + for item in items: + if not isinstance(item, dict): + continue + if user_puid and str(item.get("createrPuid") or item.get("puid") or "") == str(user_puid): + has_replied = True + content = str(item.get("content") or "").strip() + if content and len(texts) < limit: + texts.append(content) + return texts, has_replied + + def study_discussion(self, study_url: str, plan: Optional[dict] = None, + course: Optional[dict] = None) -> bool: + """完成「任务中心 -> 主题讨论」任务点(planType=14).""" + # + # 真实接口(groupweb.chaoxing.com,): + # * 话题详情页:GET study_url(302 到 .../replysList?courseId=&classId=), + # 页面里的 window.obj 带 urlToken / topic.title / topic.content; + # * 已有回复:GET /pc/invitation/getReplyList?bbsid=&uuid=&order=2; + # * 发回复:POST /pc/invitation/{topicUuid}/addReplys + # (replyId=-1 一级回复、topic_content=encodeURIComponent(正文)、urlToken、bbsid)。 + # + # 回复文本统一走 api/ai_writer.HumanLikeWriter.discussion(模仿已有回复、去 AI 味); + # 生成器判定有硬伤(编造个人经历/平台话术)时直接放弃,不提交。 + # 是否算完成仍由上层 wait_plan_finished 复查任务引擎状态裁定。 + name = (plan or {}).get("name") or "主题讨论" + query = parse_qs(urlparse(study_url).query) + bbsid = (query.get("bbsid") or [""])[0] + topic_uuid = (query.get("uuid") or [""])[0] + if not bbsid or not topic_uuid: + logger.warning("主题讨论学习地址缺少 bbsid/uuid,本次不提交: {}", name) + return False + return self.reply_topic(bbsid, topic_uuid, course=course, name=name, + referer=study_url) + + def reply_topic(self, bbsid: str, topic_uuid: str, course: Optional[dict] = None, + name: str = "", referer: str = "") -> bool: + """模式 1:任务里的主题讨论——生成草稿后按提交模式提交.""" + draft = self.draft_reply(bbsid, topic_uuid, course=course, name=name, referer=referer) + if draft is None: + return False + if draft.get("has_replied"): + return True + name = name or "主题讨论" + if not self.confirm_submission("主题讨论", draft["title"] + "\n" + draft["reply"]): + return False + return self.submit_reply(bbsid, topic_uuid, course=course, name=name, + topic_info=draft["topic_info"], reply=draft["reply"], + referer=draft["referer"]) + + @staticmethod + def _topic_detail_url(bbsid: str, topic_uuid: str, course: Optional[dict] = None) -> str: + """帖子详情页地址(讨论区模式没有现成的 study_url 时用它).""" + course = course or {} + class_id = str(course.get("classId") or course.get("clazzId") or "") + return (f"{DISCUSSION_BASE}/pc/topic/jumpToTopicDetail?bbsid={quote(str(bbsid))}" + f"&uuid={quote(str(topic_uuid))}&classId={quote(class_id)}") + + def draft_reply(self, bbsid: str, topic_uuid: str, course: Optional[dict] = None, + name: str = "", referer: str = "", revision_hint: str = "", + previous_reply: str = "") -> Optional[dict]: + """只生成回复草稿,**不提交**.""" + # + # 讨论区模式(自己挑帖子)要先给用户看草稿、确认之后再发,所以拆出这一步。 + # 返回 {topic_info, title, reply, has_replied, referer};失败返回 None。 + course = course or {} + name = name or "主题讨论" + study_url = referer or self._topic_detail_url(bbsid, topic_uuid, course) + + try: + resp = self.session.get( + study_url, timeout=TASK_CENTER_TIMEOUT, allow_redirects=True + ) + except Exception as e: + logger.warning("主题讨论页打开失败: {} - {}", name, e) + return None + if getattr(resp, "status_code", 0) != 200: + logger.warning("主题讨论页打开失败: {} HTTP {}", name, getattr(resp, "status_code", "?")) + return None + + topic_info = _extract_discussion_topic(resp.text or "") + if not topic_info["url_token"]: + logger.warning("主题讨论页没取到 urlToken(登录失效或页面改版),本次不提交: {}", name) + return None + + writer = getattr(self, "writer", None) + if writer is None or not getattr(writer, "available", False): + logger.warning("主题讨论需要 AI 写作器,当前不可用,本次不提交: {}", name) + return None + + existing, has_replied = self._load_discussion_replies( + bbsid, topic_uuid, topic_info.get("user_puid", "") + ) + if has_replied: + # 已经回复过就不再发一条(重复运行不能刷屏讨论区) + logger.info("主题讨论已经回复过,本次不重复发帖: {}", name) + return {"topic_info": topic_info, "title": topic_info["title"], "reply": "", + "has_replied": True, "referer": study_url} + + topic = (topic_info["title"] + "\n" + topic_info["content"]).strip() + try: + # 保持普通主题讨论的原调用形态;只有用户明确要求重写时才传新上下文。 + # 这样第三方/旧版写作器仍能继续用于原有的自动讨论流程。 + if revision_hint or previous_reply: + reply = writer.discussion( + topic, existing_posts=existing, max_chars=180, + revision_hint=str(revision_hint or "").strip()[:120], + previous_reply=str(previous_reply or "").strip()[:360], + ) + else: + reply = writer.discussion(topic, existing_posts=existing, max_chars=180) + except Exception as e: + logger.warning( + "主题讨论生成回复失败(AI 味/编造内容反复出现),本次不提交: {} - {}", name, e + ) + return None + reply = str(reply or "").strip() + if not reply: + logger.warning("主题讨论没有生成内容,本次不提交: {}", name) + return None + logger.debug("主题讨论回复草稿({} 字):{}", len(reply), reply) + return {"topic_info": topic_info, "title": topic_info["title"], "reply": reply, + "has_replied": False, "referer": study_url} + + def submit_reply(self, bbsid: str, topic_uuid: str, course: Optional[dict] = None, + name: str = "", topic_info: Optional[dict] = None, reply: str = "", + referer: str = "", echo: bool = True) -> bool: + """把已经确认的草稿提交给平台(含实时留痕与复核记录).""" + course = course or {} + name = name or "主题讨论" + topic_info = topic_info or {} + reply = str(reply or "").strip() + if not reply: + logger.warning("主题讨论没有可提交的正文: {}", name) + return False + study_url = referer or self._topic_detail_url(bbsid, topic_uuid, course) + payload = { + "courseId": str(course.get("courseId") or ""), + "classId": str(course.get("classId") or course.get("clazzId") or ""), + "replyId": -1, + "uuid": uuid4().hex, + # 网页端先 encodeURIComponent 一次,jQuery 再编码一次;这里保持一致 + "topic_content": quote(reply, safe="!'()*-._~"), + "files_url": "", + "files_attr": "", + "anonymous": "", + "urlToken": topic_info.get("url_token", ""), + "bbsid": bbsid, + } + if echo: + emit_block(f"讨论 · {clip(name, 24)}", reply) + item = review.record(review.KIND_DISCUSSION, reply, course=course.get("title", ""), + task=name, status="待提交") + if not item: + logger.warning("讨论复核记录写入失败,本次不提交") + return False + status = "请求失败或平台未确认" + try: + post_url = f"{DISCUSSION_BASE}/pc/invitation/{quote(str(topic_uuid))}/addReplys" + try: + posted = self.session.post( + post_url, + data=payload, + timeout=TASK_CENTER_TIMEOUT, + headers={ + "X-Requested-With": "XMLHttpRequest", + "Accept": "application/json, text/javascript, */*; q=0.01", + "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", + "Origin": DISCUSSION_BASE, + "Referer": study_url, + }, + ) + except Exception as e: + logger.warning("主题讨论提交请求失败: {} - {}", name, e) + return False + if getattr(posted, "status_code", 0) != 200: + logger.warning("主题讨论提交失败: {} HTTP {}", name, getattr(posted, "status_code", "?")) + return False + try: + data = posted.json() + except ValueError: + logger.warning("主题讨论提交返回的不是 JSON,本次不判定成功: {}", name) + return False + if not isinstance(data, dict) or not data.get("status"): + logger.warning("主题讨论提交被平台拒绝: {} -> {}", name, str(data)[:200]) + return False + if not data.get("datas"): + logger.info("主题讨论已提交,平台提示需要审核: {}", name) + else: + logger.info("主题讨论已回复(等待任务中心状态复查): {}", name) + status = "平台已接受,等待任务状态复查" if data.get("datas") else "平台已接受,待审核" + return True + + finally: + review.update(item, status) + + # ------------------------------------------------------------ 提交去重 + + @staticmethod + def _ledger_key(plan: Optional[dict], kind: str) -> str: + plan_id = str((plan or {}).get("planId") or "") + return f"{kind}:{plan_id}" if plan_id else "" + + def _recently_submitted(self, plan: Optional[dict], kind: str = "homework", + ttl: Optional[float] = None) -> bool: + """本地台账里这个任务点最近提交/尝试过吗(避免状态延迟导致重复提交).""" + key = self._ledger_key(plan, kind) + if not key: + return False + try: + with open(paths.submissions_path(), encoding="utf-8") as fp: + data = json.load(fp) + except Exception: + return False + if not isinstance(data, dict): + return False + try: + submitted_at = float(data.get(key) or 0) + except (TypeError, ValueError): + return False + window = SUBMISSION_LEDGER_TTL if ttl is None else ttl + return submitted_at > 0 and (time.time() - submitted_at) < window + + def _mark_submitted(self, plan: Optional[dict], kind: str = "homework") -> None: + """记下"这个任务点刚提交/尝试过";写失败不影响本次提交.""" + key = self._ledger_key(plan, kind) + if not key: + return + path = paths.submissions_path() + try: + try: + with open(path, encoding="utf-8") as fp: + data = json.load(fp) + except Exception: + data = {} + if not isinstance(data, dict): + data = {} + data[key] = time.time() + if len(data) > 200: + for key in sorted(data, key=lambda k: data[k])[:len(data) - 200]: + data.pop(key, None) + os.makedirs(os.path.dirname(path), exist_ok=True) + tmp = path + ".tmp" + with open(tmp, "w", encoding="utf-8") as fp: + json.dump(data, fp) + os.replace(tmp, path) + except Exception as e: + logger.debug("提交记录写入失败(不影响本次提交): {}", e) + + # ---------------------------------------------------------------- 作业 + + def _fill_homework_answers(self, questions: list, course: Optional[dict] = None, + task_name: str = "") -> Optional[str]: + """给作业题目填答案(选择题/判断题/填空题走题库,简答题走去 AI 味写作器).""" + # + # 返回 None 表示全部填好;返回字符串表示失败原因(此时绝不提交)。 + tiku = getattr(self.chaoxing, "tiku", None) + if tiku is None or getattr(tiku, "DISABLE", False): + return "没有可用题库,选择题/判断题无法作答" + + answers = tiku.query_all(questions, query_delay=0) + if not isinstance(answers, list): + answers = [None] * len(questions) + elif len(answers) != len(questions): + answers = list(answers) + [None] * (len(questions) - len(answers)) + answers = answers[:len(questions)] + + random_count = 0 + emit(answers_header(task_name or "作业", len(questions))) + for _qi, (q, res) in enumerate(zip(questions, answers), 1): + q_type = q.get("type") + answer = "" + if q_type == "shortanswer" or (q_type == "unknown" and not q.get("options")): + # 简答题必须走去 AI 味写作器;拿不到正文就不提交 + writer = getattr(self, "writer", None) + if writer is None or not getattr(writer, "available", False): + return f"简答题需要 AI 写作器,当前不可用:{str(q.get('title'))[:40]}" + try: + answer = writer.answer(str(q.get("title") or "")) + except Exception as exc: + return "简答题未通过检查:" + str(exc) + answer = str(answer or "").strip() + if not answer: + return f"简答题没有生成内容:{str(q.get('title'))[:40]}" + item = review.record( + review.KIND_HOMEWORK, answer, + course=(course or {}).get("title", ""), + task=task_name or "", + status="待确认", + ) + if not item: + return "简答题复核记录写入失败" + q["_review_item"] = item + emit_block(f"简答 {_qi}", answer) + else: + answer = self._homework_objective_answer(q, res, tiku) + + if not answer and q_type not in ("shortanswer", "unknown"): + answer = random_answer(q.get("options", ""), q_type) + if answer: + random_count += 1 + logger.debug("题库没匹配到答案,已随机作答: {}", str(q.get("title"))[:40]) + q.setdefault("answerField", {})[f"answer{q['id']}"] = answer + emit(answer_line(_qi, q_type, answer, q.get("title"))) + if random_count: + logger.info("作业有 {} 题没搜到答案,已随机作答", random_count) + return None + + def study_homework(self, study_url: str, plan: Optional[dict] = None, + course: Optional[dict] = None) -> bool: + """完成「任务中心 -> 作业」任务点(planType=4).""" + # + # 与章节测验的区别:学习页是新版 mooc2/work/dowork,提交接口是 + # addStudentWorkNewWeb(表单 action 自带 token / totalQuestionNum); + # 章节测验用的 mooc-ans/api/work 对课程级作业返回 403,不能复用。 + # + # 这里只负责"作答并被接口接受";是否算完成由上层 wait_plan_finished + # 重新读任务引擎状态裁定,接口 200 / status=true 单独不算完成。 + name = (plan or {}).get("name") or "作业" + + if self._recently_submitted(plan): + logger.info("作业 [{}] 最近已提交过,等平台同步,本次不重复提交", name) + return True + + try: + resp = self.session.get( + study_url, timeout=TASK_CENTER_TIMEOUT, allow_redirects=True + ) + except Exception as e: + logger.warning("作业学习页打开失败: {} - {}", name, e) + return False + if getattr(resp, "status_code", 0) != 200: + logger.warning("作业学习页打开失败: {} HTTP {}", name, getattr(resp, "status_code", "?")) + return False + + page = decode_homework_page(resp.text or "") + questions = page.get("questions") or [] + if not questions: + logger.warning("作业页没有解析到题目(登录失效或页面改版),本次不提交: {}", name) + return False + logger.info("任务中心作业:{},共 {} 题", name, len(questions)) + + failure = self._fill_homework_answers(questions, course=course, task_name=name) + if failure: + for question in questions: + review.update(question.get("_review_item"), "生成或复核失败,未提交") + logger.warning("作业 [{}] 未提交:{}", name, failure) + return False + + review_items = [q["_review_item"] for q in questions if q.get("_review_item")] + review_status = "请求失败或平台未确认" + try: + if not self.confirm_submission("作业", f"{name}:共 {len(questions)} 题"): + review_status = "用户取消,未提交" + return False + + action = str(page.get("form_action") or "").strip() + if not action: + logger.warning("作业页没有提交地址,本次不提交: {}", name) + return False + if action.startswith("/"): + action = "https://mooc1.chaoxing.com" + action + + payload = self._homework_payload(page, questions) + + sep = "&" if "?" in action else "?" + submit_url = action + sep + "pyFlag=&ua=pc&formType=post&saveStatus=1&version=1" + if not self._post_homework(submit_url, payload, study_url, name): + return False + + review_status = "平台已接受,等待任务状态复查" + self._mark_submitted(plan) + logger.info("作业已提交(等待任务中心状态复查): {}", name) + return True + + finally: + for item in review_items: + review.update(item, review_status) + + def study_ai_practice(self, study_url: str, plan: Optional[dict] = None) -> bool: + """续接/完成一次 AI 实践,并在达到最低分后才返回 True.""" + # + # 对话请求本身不是最终提交;只有确认模式通过后调用 ``answer/submit``, + # 并且提交后的 load-data 读回分数,才会进入完成状态。任务中心的 isFinish + # 仍由上层 ``wait_plan_finished`` 再次确认。 + self._set_outcome(TaskOutcome.FAILED) + try: + page = self.session.get( + study_url, allow_redirects=True, timeout=TASK_CENTER_TIMEOUT + ) + except Exception as e: + logger.warning("AI实践入口页打开失败: {}", e) + return False + if getattr(page, "status_code", 0) != 200: + logger.warning("AI实践入口页打开失败: HTTP {}", getattr(page, "status_code", "?")) + return False + final_url = getattr(page, "url", None) or study_url + params = self._ai_page_params(final_url, getattr(page, "text", "")) + if not params: + if "situationalDialogue" in final_url or "situationalDialogue" in (getattr(page, "text", "") or ""): + # 新版"情景对话"是另一套接口(/mobile/situationalDialogue/*),与思维阶梯不通用 + logger.warning( + "该 AI 实践是新版「情景对话」(situationalDialogue),暂未适配,本次跳过" + ) + print(" · 该 AI 实践是新版「情景对话」,暂不支持,请到学习通 App 手动完成") + else: + logger.warning( + "AI实践入口页缺少 courseid/clazzid/cpi/publishRelationUuid/aiEnc(最终地址: {})", + final_url, + ) + return False + + data = self._ai_load_data(params) + if data is None: + return False + + for attempt in range(self.ai_practice_max_rounds): + if interrupt.should_stop(): + return False + + round_data = self._ai_round_data(params, data, attempt) + if round_data is None: + return False + data, record_uuid = round_data + + existing = self._ai_existing_result(data, record_uuid, attempt) + if existing == "retry": + continue + if existing == "complete": + return True + + dialogue = self._ai_run_dialogue(params, record_uuid, data, plan, attempt) + if dialogue is None: + return False + data, preview = dialogue + if not self._ai_submit(params, record_uuid, preview): + return False + result, data = self._ai_round_result(params, record_uuid, data, attempt) + if result is not None: + return result + + return False + + @staticmethod + def _ai_answer_type(turn, options): + """Classify objective turns conservatively when option data is present.""" + question_type = str(turn.get("questionTypeInt") if turn.get("questionTypeInt") is not None else "").strip() + if not question_type: + question_label = str(turn.get("questionType") or "") + if "多选" in question_label: + question_type = "1" + elif "单选" in question_label: + question_type = "0" + elif "判断" in question_label: + question_type = "3" + if question_type not in {"0", "1", "3"} and options: + # 平台偶尔只给中文 questionType、或者给一个没见过的 questionTypeInt 编码, + # 但题目带了选项。此时按最常见的单选处理:**绝不能**因为题型没认出来 + # 就把客观题当简答写一段小作文(实测被平台判"没有按题目要求作答"; + # 独立审计也用 questionTypeInt="2" + A/B 选项复现过)。 + question_type = "0" + return question_type + + def _ai_choice_answer(self, stem, options, question_type, choice_context, exclude): + """Choose and validate objective option letters.""" + chooser = getattr(self.writer, "choose_options", None) + if not callable(chooser): + raise RuntimeError("当前写作器不支持 AI 实践选择题") + try: + answer = chooser(stem, options, multiple=question_type == "1", + context=choice_context, exclude=exclude) + except TypeError: + # 兼容旧写作器/测试替身:不接受 exclude 参数 + answer = chooser(stem, options, multiple=question_type == "1", + context=choice_context) + valid = {item["option"] for item in options} + chosen = [] + for letter in re.findall(r"[A-E]", str(answer).upper()): + if letter in valid and letter not in chosen: + chosen.append(letter) + if not chosen: + raise RuntimeError("AI 实践选择题没有得到有效选项") + if question_type == "0": + # 选择题就发选项字母本身(和真人在页面上点选项一样), + # 不要拼"选 X,因为……"这种解释性长句:既不是平台的作答格式, + # 也一眼就能看出是机器在答。 + return chosen[0] + order = {letter: index for index, letter in enumerate("ABCDE")} + return "".join(sorted(chosen, key=lambda letter: order.get(letter, 99))) + + + def _homework_objective_answer(self, q, res, tiku): + """Normalize homework objective answers without generating prose.""" + q_type = q.get("type") + answer = "" + if not res: + answer = random_answer(q.get("options", ""), q_type) + elif q_type == "multiple": + answer = build_multiple_answer(res, q.get("options", "")) + elif q_type == "single": + options_list = multi_cut(q.get("options", "")) + if options_list: + t_res = clean_res(res) + for option in options_list: + if t_res and is_subsequence(t_res[0], option): + answer = option[:1] + break + if not answer and t_res: + answer = best_option_by_similarity(t_res[0], options_list, threshold=0.8) + elif q_type == "judgement": + answer = "true" if tiku.judgement_select(res) else "false" + elif q_type == "completion": + if isinstance(res, list): + answer = "#".join(str(x).strip() for x in res if str(x).strip()) + elif isinstance(res, str): + answer = res + else: + answer = res if isinstance(res, str) else "" + + return answer + + + def _homework_payload(self, page, questions): + """Build homework fields using the chapter completion protocol.""" + payload = { + key: value for key, value in page.items() + if key not in ("questions", "form_action", "form_method") + } + payload["answerwqbid"] = page.get("answerwqbid", "") + payload["pyFlag"] = "" + for question in questions: + answer_field = question.get("answerField") or {} + payload[f"answer{question['id']}"] = answer_field.get(f"answer{question['id']}", "") + payload[f"answertype{question['id']}"] = answer_field.get( + f"answertype{question['id']}", "" + ) + # 填空题按空提交(answerEditor{id}{n} + tiankongsize{id}),与章节测验同一规则 + for question in questions: + build_completion_fields(payload, question) + + return payload + + + def _post_homework(self, submit_url, payload, study_url, name): + """Return success only after a valid platform acceptance response.""" + try: + submitted = self.session.post( + submit_url, + data=payload, + timeout=TASK_CENTER_TIMEOUT, + headers={ + "X-Requested-With": "XMLHttpRequest", + "Accept": "application/json, text/javascript, */*; q=0.01", + "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8", + "Origin": "https://mooc1.chaoxing.com", + "Referer": study_url, + }, + ) + except Exception as e: + logger.warning("作业提交请求失败: {} - {}", name, e) + return False + if getattr(submitted, "status_code", 0) != 200: + logger.warning("作业提交失败: {} HTTP {}", name, getattr(submitted, "status_code", "?")) + return False + try: + data = submitted.json() + except ValueError: + logger.warning("作业提交返回的不是 JSON,本次不判定成功: {}", name) + return False + if not isinstance(data, dict) or not data.get("status"): + logger.warning("作业提交被平台拒绝: {} -> {}", name, str(data)[:200]) + return False + + return True + + + def _ai_run_dialogue(self, params, record_uuid, data, plan, attempt): + """Run a bounded dialogue and require completion evidence before submission.""" + state = {"data": data} + state['completion'] = self._ai_completion_state(state['data']) + state['turn'] = self._ai_pending_turn(state['data']) + state['last_answer'] = "" + state['turn_count'] = 0 + state['summary_seen'] = False + topic_count = sum( + len(dimension.get("topicList") or []) + for dimension in state['data'].get("dimensionList") or [] + if isinstance(dimension, dict) + ) + # 平台的判分是它自己的大模型,同一道题会反复追问;知识点多的时候 + # 一局可能要答几十题, + # 这里给足余量,但仍有上限避免死循环。 + max_turns = max(30, min(200, topic_count * 8 + 30)) + + if state['turn'] is None and state['completion'] is not True: + # 与前端 iniQuestion 一致:已有记录但没有 messageList 时发送空消息, + # 让平台生成第一道题;这不是提交动作。 + state['turn'] = self._ai_stream(params, record_uuid, "") + if state['turn'] is None: + return None + + # 平台已经给出总结、且快照里没有待答题目:这一局已经结束了。 + # 旧实现会再发一条空消息"让平台出第一题",平台就继续生成新题, + # 于是对着一个已经结束的局空转到轮数上限。 + ready_to_submit = state['turn'] is None and state['completion'] is True + if ready_to_submit: + logger.info("AI实践这一局平台已经结束,直接提交本轮成绩") + + # 平台是拿自己的大模型判分的:同一道题同一个答案会被反复判错。 + # 记下每道题已经试过的答案,重试时换一个,才可能跳出死循环。 + tried_answers: dict = {} + attempts: dict = {} + state['stalled'] = 0 + while not ready_to_submit and state['turn_count'] < max_turns: + action = self._ai_dialogue_step(params, record_uuid, plan, tried_answers, attempts, state) + if action == "fail": + return None + if action == "break": + break + + else: + # 只有"真的答满了轮数还没结束"才算失败;ready_to_submit 是跳过作答直接提交 + if not ready_to_submit: + logger.warning("AI实践对话超过安全轮数上限,按失败处理") + return None + + if state['completion'] is not True and not state['summary_seen']: + logger.warning("AI实践对话结束但没有明确完成证据,不提交") + return None + + preview = ( + f"第 {attempt + 1} 轮,共回答 {state['turn_count']} 个问题;" + f"最后回答:{state['last_answer'][:220]}" + ) + + return state["data"], preview + + + def _ai_dialogue_step(self, params, record_uuid, plan, tried_answers, attempts, state): + """Advance one dialogue turn without bypassing pending questions.""" + if interrupt.should_stop(): + return "fail" + if not self._ai_turn_has_question(state['turn']): + state['summary_seen'] = any( + "SummaryTopic" in mark for mark in (state['turn'] or {}).get("special_marks", []) + ) + # SSE 这一帧没带问题不代表练完了:平台的状态快照里可能还有 pending 题, + # 这时候提交会拿到一个"没答完"的低分 + pending_turn = self._ai_pending_turn(state['data']) + if pending_turn is not None: + state['turn'] = pending_turn + return "continue" + if state['completion'] is True or state['summary_seen']: + return "break" + logger.warning("AI实践 SSE 没有下一道可回答的问题,按失败处理") + return "fail" + + question_key = self._ai_question_key(state['turn']) + used = tried_answers.setdefault(question_key, set()) + attempts[question_key] = attempts.get(question_key, 0) + 1 + next_turn = self._ai_send_answer(params, record_uuid, plan, question_key, used, state) + if next_turn is None: + return "fail" + + refreshed = self._ai_load_data(params, record_uuid) + if refreshed is None: + return "fail" + state['data'] = refreshed + state['completion'] = self._ai_completion_state(state['data']) + if len((state['data'] or {}).get("messageList") or []) > state["before_msgs"]: + state['stalled'] = 0 + else: + state['stalled'] += 1 + # 知识点答完之后,平台还会把最后一道题推回来:它既不再收录我们的 + # 作答(messageList 不再增长),也不会主动结束这一局。实测会一直空转, + # 甚至"错/对"来回换十几次。这时候收手提交才是对的。 + if state['completion'] is True and ( + attempts.get(question_key, 0) >= self.AI_MAX_TRIES_PER_QUESTION + or state['stalled'] >= self.AI_STALL_LIMIT + ): + logger.info( + "AI实践平台已判定答完(同一道题作答 {} 次、连续 {} 次无新消息),直接提交本轮", + attempts.get(question_key, 0), state['stalled'], + ) + return "break" + if self._ai_turn_has_question(next_turn): + state['turn'] = next_turn + return "continue" + state['summary_seen'] = any( + "SummaryTopic" in mark for mark in next_turn.get("special_marks", []) + ) + pending_turn = self._ai_pending_turn(state['data']) + if pending_turn is not None: + state['turn'] = pending_turn + return "continue" + if state['completion'] is True or state['summary_seen']: + return "break" + # 服务端偶尔先落库再返回下一题,尝试从状态快照续接一次;仍无题就失败。 + state['turn'] = self._ai_pending_turn(state['data']) + if state['turn'] is None: + logger.warning("AI实践未得到完成证据或下一道题,按失败处理") + return "fail" + return "continue" + + + def _ai_send_answer(self, params, record_uuid, plan, question_key, used, state): + """Record substantive text before sending and preserve truthful review status.""" + try: + answer = self._ai_answer(state['turn'], state['data'], exclude=used) + item = None + if self._ai_turn_type(state['turn']) == "shortanswer": + item = review.record( + review.KIND_PRACTICE, answer, + course="", task=(plan or {}).get("name") or "", + status="待发送给平台评分", + ) + if not item: + logger.warning("AI实践复核记录写入失败,本次不发送") + return None + except Exception as e: + logger.warning("AI实践生成答案失败: {}", e) + return None + used.add(self._ai_answer_core(answer)) + state['last_answer'] = answer + state['turn_count'] += 1 + emit(answer_line(state['turn_count'], self._ai_turn_type(state['turn']), answer, + self._ai_turn_title(state['turn']))) + if self._ai_turn_type(state['turn']) == "shortanswer": + emit_block(f"AI实践简答 {state['turn_count']}", answer) + if state['turn_count'] > 1: + time.sleep(1.0) + state["before_msgs"] = len((state['data'] or {}).get("messageList") or []) + try: + next_turn = self._ai_stream(params, record_uuid, answer) + except Exception: + review.update(item, "请求失败或平台未确认") + raise + review.update(item, "平台返回对话响应" if next_turn is not None else "请求失败或平台未确认") + if next_turn is None: + return None + + return next_turn + + + def _ai_round_data(self, params, data, attempt): + """Resume an unfinished record or initialize the next allowed attempt.""" + # 第一次优先续接服务端已有的未完成记录;后续低分重答才初始化新记录。 + if attempt > 0 or self._ai_record_submitted(data) or not data.get("recordUuid"): + init_data = self._ai_init(params) + if init_data is None: + return None + record_uuid = str(init_data.get("recordUuid") or data.get("recordUuid") or "") + data = self._ai_load_data(params, record_uuid) or self._ai_load_data(params) + if data is None: + return None + record_uuid = str(data.get("recordUuid") or "") + if not record_uuid: + logger.warning("AI实践状态缺少 recordUuid,按失败处理") + return None + + return data, record_uuid + + + def _ai_existing_result(self, data, record_uuid, attempt): + """Use verified existing scores without duplicating a submitted record.""" + if self._ai_record_submitted(data): + score = self._ai_score(data, record_uuid) + if score is not None and score >= self.ai_practice_min_score: + average = self._ai_average_score(data) + if (average is not None and average < self.ai_practice_min_score + and attempt + 1 < self.ai_practice_max_rounds): + logger.info( + "AI实践已有 {:.1f} 分的记录,但练习平均分 {:.1f} 低于目标 {:.1f},开新一轮补答", + score, average, self.ai_practice_min_score, + ) + # 必须直接开新一轮:这一条记录已经提交过,落下去会把同一条 + # 记录再 submit 一次(平台可能直接拒绝,白跑一轮还报失败)。 + time.sleep(1.0) + return "retry" + logger.info("AI实践已有有效成绩 {:.1f},无需重复提交", score) + self._set_outcome(TaskOutcome.COMPLETED) + return "complete" + + return "dialogue" + + + def _ai_round_result(self, params, record_uuid, data, attempt): + """Request the score report, verify scores and enforce retry limits.""" + # 平台不会自己评估:必须请求一次质量评估报告,成绩才算出来并回填, + # 否则 answerRecords 会一直停在"未评估"。 + report_score = self._ai_end_report(params, record_uuid) + if report_score is not None: + # 报告已经给了成绩:读一次状态(remainAnswerCount 等)就走人, + # 不再空等状态接口回填(旧实现固定轮询 19 次×30s≈10 分钟)。 + refreshed = self._ai_load_data(params, record_uuid) + if refreshed is not None: + data = refreshed + score = report_score + else: + # 报告没给成绩(平台偶发):退回状态接口轮询 + score, data = self._ai_wait_for_score(params, record_uuid) + if score is None or data is None: + logger.warning("AI实践提交后平台还没出评估结果,本次不算完成") + return False, data + logger.info( + "AI实践第 {}/{} 轮提交成绩:{:.1f}(目标 {:.1f})", + attempt + 1, self.ai_practice_max_rounds, score, self.ai_practice_min_score, + ) + average = self._ai_average_score(data) + logger.info( + "AI实践练习记录:{} | 平均 {:.1f} | 本轮 {:.1f} | 目标 {:.1f}", + "、".join(f"{value:.0f}" for value in self._ai_record_scores(data)) or "无", + average if average is not None else score, + score, + self.ai_practice_min_score, + ) + if score >= self.ai_practice_min_score and ( + average is None or average >= self.ai_practice_min_score + ): + self._set_outcome(TaskOutcome.COMPLETED) + return True, data + + try: + remain = int(float(data.get("remainAnswerCount"))) + except (TypeError, ValueError): + remain = 1 + if attempt + 1 >= self.ai_practice_max_rounds or remain <= 0: + if score >= self.ai_practice_min_score: + # 本轮已经达标,只是历史低分把平均分拖下来了;重答次数用尽就 + # 如实汇报,不再空转(平台自己的成绩字段已含本轮的分)。 + logger.warning( + "AI实践本轮 {:.1f} 已达标,但练习平均分 {:.1f} 未到目标 {:.1f},重答次数已用尽", + score, average if average is not None else score, + self.ai_practice_min_score, + ) + self._set_outcome(TaskOutcome.COMPLETED) + return True, data + logger.warning("AI实践成绩 {:.1f} 未达到目标,重答次数已用尽", score) + return False, data + logger.info("AI实践成绩未达标,准备开始第 {} 轮重答", attempt + 2) + time.sleep(1.0) + + return None, data + + + +def plan_type_name(plan_type: Any) -> str: + try: + return PLAN_TYPE_NAMES.get(int(plan_type), f"未知类型{plan_type}") + except (TypeError, ValueError): + return f"未知类型{plan_type}" diff --git a/config_template.ini b/config_template.ini index b8a48d23e..13ac655a3 100644 --- a/config_template.ini +++ b/config_template.ini @@ -15,7 +15,7 @@ course_list = xxx,xxx,xxx speed = 1 ; 同时进行的章节数量 -jobs = 4 +jobs = 2 ; 遇到关闭任务点时的行为: retry-重试(默认), continue-继续 notopen_action = retry @@ -35,6 +35,50 @@ add_learning_count = false ; 章节学习次数的目标总次数(所有章节轮询访问,每访问一次计1次) target_count = 100 +; 是否刷「章节(目录)」 +; 章节和「任务中心 -> 教学任务」是两套互相独立的学习入口,记录不互通: +; 只刷任务中心时把这项设为 false;命令行可用 --no-chapters 临时关掉,--chapters 强制打开。 +; 注意:chapter_study 和 task_center 不能同时为 false,否则没有可刷的内容。 +chapter_study = true + +; 是否刷「任务中心 -> 教学任务」 +; 新版泛雅课程首页可以把学习内容发布成"教学任务",它和"章节"是两套互相独立的学习入口: +; 任务点按分组顺序解锁,完成上一组才能学下一组。 +; 目前已接入 视频 / 文档 / AI实践;章节同步、作业、思考题、主题讨论仍按真实平台证据逐项适配。 +; 命令行可用 --no-task-center 临时关掉,--task-center 强制打开。 +task_center = true + +; 只刷讨论(任务里的主题讨论),其它类型本次跳过;向导里选第 4 项时会自动打开 +only_discussion = false + +; 讨论怎么刷:task = 任务里的主题讨论(自动,按课程要求的顺序); +; board = 讨论区(自己挑帖子回复,逐条给草稿、确认后发送) +discussion_mode = task + +; 任务中心涉及作业、讨论、AI实践的最终提交模式: +; auto(默认)= 作答完成后自动提交,适合挂后台刷课; +; confirm = 每次提交前显示内容并询问(需要人工盯着时才用)。 +task_center_submit_mode = auto + +; AI实践的最低目标分数与单次运行最多重答轮数 +ai_practice_min_score = 85 +ai_practice_max_rounds = 5 + +; 每门课最多刷几个任务点(章节),0 = 全部刷完 +; 例如填 3,就是每门课只刷前 3 个还没完成的章节 +max_points_per_course = 0 + +; 每门课最多刷几个教学任务(任务中心 -> 教学任务),0 = 全部推进 +; 例如填 3,就是每门课只推进前 3 个还没完成的教学任务 +; 也支持按课程指定:2151141:3,189191:0 +max_tasks_per_course = 0 + +; 视频是否一个一个按顺序刷(串行) +; false(默认) = 按上面 jobs 的数量并发,速度快 +; true = 同一时间只播一个视频;如果遇到"刷完了又变回没刷/进度被回退", +; 改成 true 可以明显降低被平台判异常的概率(代价是慢一些) +serial_video = false + [tiku] ; 可选项 : ; 1. TikuYanxi(言溪题库 https://tk.enncy.cn/) @@ -101,6 +145,15 @@ key= model= ; 请求间隔时间 min_interval_seconds=3 + +; 大模型 thinking(推理)策略:auto(默认)= 让模型自己决定。 +; DeepSeek V4.1 flash 默认带推理,正确率明显更高;老版本模型出现"正文为空"时会自动降级重试。 +; on = 强制开启推理,off = 强制关闭(更快但更容易答错)。 +thinking=auto + +; 客观题(单选/多选)采样投票次数:同一题问 N 次取多数答案,降低偶发看错选项。 +; 1 = 关闭投票(最快);3 = 推荐;最多 5。 +objective_votes=3 ; 可选配置请求大模型时使用的代理,填写示例:http://examples.com http_proxy= @@ -139,4 +192,4 @@ url= ; https://api.day.app/**************/ Bark的高级用法请自行查阅app与其文档的说明(高级用法不一定能行,没测试过) ; https://api.telegram.org/bot**********:***********************/sendMessage Telegram(具体用法请查阅Telegram官方API文档) ; Telegram推送时使用的chat_id -tg_chat_id=XXXXXX \ No newline at end of file +tg_chat_id=XXXXXX diff --git a/cx b/cx new file mode 100755 index 000000000..b8b84e12d --- /dev/null +++ b/cx @@ -0,0 +1,55 @@ +#!/usr/bin/env bash +# cx —— 超星刷课(多用户) +# +# cx 启动:已配置则直接选用户->登录->选课->刷课 +# cx setup 重新配置(答题方式 / 通知) +# cx discuss 浏览讨论区、自己挑帖子回复 +# cx review 复核 AI 生成并提交过的文字 +# cx --yes 跳过确认(自动化用) +# cx <参数...> 直接用上次的配置运行 main.py + +set -o pipefail + +# 定位项目目录(支持软链接,可从任意目录调用) +src="${BASH_SOURCE[0]}" +while [ -L "$src" ]; do + dir="$(cd -P "$(dirname "$src")" && pwd)" + src="$(readlink "$src")" + case "$src" in /*) ;; *) src="$dir/$src" ;; esac +done +APP_DIR="${CX_HOME:-$(cd -P "$(dirname "$src")" && pwd)}" +cd "$APP_DIR" || exit 1 + +if [ -x "$APP_DIR/.venv/bin/python" ]; then + PY="$APP_DIR/.venv/bin/python" +elif command -v python3 >/dev/null 2>&1; then + PY="$(command -v python3)" +else + echo "cx: 找不到 python3" >&2 + exit 1 +fi + +# cx setup -> 重新配置 +if [ "${1:-}" = "setup" ]; then + shift + exec "$PY" "$APP_DIR/setup_wizard.py" --setup "$@" +fi + +# cx discuss -> 浏览讨论区、自己挑帖子回复(模式 2) +if [ "${1:-}" = "discuss" ] || [ "${1:-}" = "topics" ]; then + shift + exec "$PY" "$APP_DIR/main.py" --discuss "$@" +fi + +# cx review -> 复核 AI 生成过的文字(测验简答 / 作业简答 / 讨论回复 / AI实践作答) +if [ "${1:-}" = "review" ]; then + shift + exec "$PY" "$APP_DIR/main.py" --review "$@" +fi +# 无参数 或 --yes -> 正常流程(已配置则不再重复询问配置) +if [ "${1:-}" = "" ] || [ "${1:-}" = "--yes" ] || [ "${1:-}" = "-y" ]; then + exec "$PY" "$APP_DIR/setup_wizard.py" "$@" +fi + +# 其它参数 -> 直接用上次的配置运行 main.py +exec "$PY" "$APP_DIR/main.py" "$@" diff --git a/main.py b/main.py index d284e29e7..7b7b6d5c4 100644 --- a/main.py +++ b/main.py @@ -1,22 +1,44 @@ # -*- coding: utf-8 -*- import argparse -import configparser import enum +import os +import re import sys import threading import time import traceback from dataclasses import dataclass -from typing import Any +from typing import Any, Optional from tqdm import tqdm from api.answer import Tiku from api.base import Chaoxing, Account, StudyResult from api.exceptions import LoginError, InputFormatError -from api.logger import logger +from api.configfile import read_config_file +from api.guard import check_before_run, hard_stop, UserAbort +from api import interrupt, scan +from api import paths +from api.display import ChapterProgress, course_plan_summary, safe_console +from api.logger import set_quiet as set_console_quiet +from api.logger import log_file_only, logger +from api.privacy import redact +from requests import RequestException from api.notification import Notification from api.live import Live from api.live_process import LiveProcessor from api.process import increase_learning_count_for_course +from api.task_center import ( + TaskCenter, + PLAN_TYPE_CHAPTER, + PLAN_TYPE_DOCUMENT, + PLAN_TYPE_AI, + PLAN_TYPE_VIDEO, + PLAN_TYPE_HOMEWORK, + PLAN_TYPE_DISCUSS, + SUPPORTED_PLAN_TYPES, + TaskOutcome, + normalize_submit_mode, + plan_type_name, +) try: from queue import PriorityQueue, ShutDown @@ -41,20 +63,72 @@ def wrapper(*args, **kwargs): func(*args, **kwargs) except BaseException as e: logger.error(f"Error in thread {threading.current_thread().name}: {e}") - traceback.print_exception(type(e), e, e.__traceback__) + logger.error(redact(traceback.format_exc())) raise return wrapper +class NetworkRetryFailed(Exception): + """网络问题重试多次仍然失败(不是用户配置错误).""" + + +def with_network_retry(func, *args, what="请求", times=3, delay=2.0, **kwargs): + """主流程的网络请求重试.""" + # + # 登录 / 取课表 / 取章节这几步以前一次网络抖动就整轮崩掉(#124 #166 #192 #226 #228), + # 这里对连接类异常重试几次;仍然失败就抛 NetworkRetryFailed, + # 由 main() 统一给一句人话提示,而不是甩一堆 traceback。 + last_error = None + for attempt in range(1, times + 1): + try: + return func(*args, **kwargs) + except RequestException as e: + last_error = e + if attempt < times: + logger.warning(f"{what}失败(第 {attempt}/{times} 次):{e},{int(delay)} 秒后重试") + time.sleep(delay) + raise NetworkRetryFailed(f"{what}失败:{last_error}") + + def str_to_bool(value): if isinstance(value, bool): return value return str(value).strip().lower() in {"1", "true", "yes", "y", "on"} +def safe_float(value, default, low=None, high=None): + """安全地把配置值转成浮点数.""" + # 配置里写错("abc")或超范围时用默认值,绝不让程序崩溃。 + try: + num = float(str(value).strip()) + except (TypeError, ValueError): + return default + if low is not None and num < low: + return low + if high is not None and num > high: + return high + return num + + +def safe_int(value, default, low=None, high=None): + """安全地把配置值转成整数;写错或超范围时用默认值.""" + try: + num = int(float(str(value).strip())) + except (TypeError, ValueError): + return default + if low is not None and num < low: + return low + if high is not None and num > high: + return high + return num + + +NOTOPEN_ACTIONS = ("retry", "ask", "continue") + + def parse_args(): - """解析命令行参数""" + """解析命令行参数.""" parser = argparse.ArgumentParser( description="Samueli924/chaoxing", formatter_class=argparse.ArgumentDefaultsHelpFormatter, @@ -62,6 +136,11 @@ def parse_args(): parser.add_argument("--use-cookies", action="store_true", help="使用cookies登录") + parser.add_argument( + "--yes", "-y", action="store_true", + help="跳过启动前的确认(用于已确认过的自动化/定时任务;默认必须人工确认)" + ) + parser.add_argument( "-c", "--config", type=str, default=None, help="使用配置文件运行程序" ) @@ -76,6 +155,14 @@ def parse_args(): parser.add_argument( "-j", "--jobs", type=int, default=4, help="同时进行的章节数 (默认4, 如果一个章节有多个任务点,不会限制同时处理任务点的数量)" ) + parser.add_argument( + "-n", "--max-points", type=int, default=0, + help="每门课最多刷几个任务点(章节), 0 或留空=全部刷完" + ) + parser.add_argument( + "--max-tasks", type=int, default=0, + help="每门课最多刷几个教学任务(任务中心), 0 或留空=全部" + ) parser.add_argument( "-v", @@ -90,10 +177,46 @@ def parse_args(): help="遇到关闭任务点时的行为: retry-重试, ask-询问, continue-继续" ) - parser.add_argument("--auto-sign", action="store_true", help="自动签到") + parser.add_argument( + "--task-center", dest="task_center", action="store_true", default=None, + help="刷任务中心的教学任务(默认跟随配置,配置里默认开启)" + ) + parser.add_argument( + "--no-task-center", dest="task_center", action="store_false", default=None, + help="只刷章节,不刷任务中心的教学任务" + ) + parser.add_argument( + "--task-center-submit-mode", dest="task_center_submit_mode", + choices=["confirm", "auto"], default=None, + help="任务中心作业/讨论/AI实践提交模式;confirm 逐次确认,auto 自动提交" + ) + parser.add_argument( + "--chapters", dest="chapter_study", action="store_true", default=None, + help="刷章节(目录)任务点(默认跟随配置,配置里默认开启)" + ) + parser.add_argument( + "--no-chapters", dest="chapter_study", action="store_false", default=None, + help="只刷任务中心的教学任务,跳过章节(目录)" + ) parser.add_argument( "--retry-interval", type=float, default=1.0, help="重试等待时间, 单位秒 (默认1.0)" ) + parser.add_argument( + "--only-discussion", action="store_true", + help="只刷讨论(任务里的主题讨论),其它类型本次跳过", + ) + parser.add_argument( + "--course-id", type=str, default=None, + help="指定课程 ID(cx discuss 浏览哪门课的讨论区)", + ) + parser.add_argument( + "--discuss", action="store_true", + help="浏览课程讨论区,自己挑帖子回复(模式 2),不进刷课流程", + ) + parser.add_argument( + "--list-topics", action="store_true", + help="只列出讨论区帖子(不交互、不回复),配合 --discuss 使用", + ) parser.add_argument( "-lc", @@ -118,9 +241,10 @@ def parse_args(): def load_config_from_file(config_path): - """从配置文件加载设置""" - config = configparser.ConfigParser() - config.read(config_path, encoding="utf8") + """从配置文件加载设置.""" + config, broken = read_config_file(config_path) + if broken: + logger.warning(f"配置文件 {config_path} 内容有损坏,已跳过异常行并尽量沿用其余设置") common_config: dict[str, Any] = {} tiku_config: dict[str, Any] = {} @@ -129,27 +253,24 @@ def load_config_from_file(config_path): # 检查并读取common节 if config.has_section("common"): common_config = dict(config.items("common")) + # 处理course_list,将字符串转换为列表 if "course_list" in common_config and common_config["course_list"]: common_config["course_list"] = [item.strip() for item in common_config["course_list"].split(",") if item.strip()] - # 处理speed,将字符串转换为浮点数 + + # 下面这些数值都用 safe_* 解析: + # 用户在配置里写错(比如 speed=abc)时用默认值兜底,而不是让程序崩溃。 if "speed" in common_config: - common_config["speed"] = float(common_config["speed"]) + common_config["speed"] = safe_float(common_config["speed"], 1.0, low=1.0, high=2.0) if "jobs" in common_config: - common_config["jobs"] = int(common_config["jobs"]) - # 处理notopen_action,设置默认值为retry - if "notopen_action" not in common_config: - common_config["notopen_action"] = "retry" + common_config["jobs"] = safe_int(common_config["jobs"], 4, low=1, high=8) if "retry_interval" in common_config: - common_config["retry_interval"] = float(common_config["retry_interval"]) + common_config["retry_interval"] = safe_float(common_config["retry_interval"], 1.0, low=0.0) else: common_config["retry_interval"] = 1.0 if "work_max_retries" in common_config: - try: - common_config["work_max_retries"] = int(common_config["work_max_retries"]) - except ValueError: - common_config["work_max_retries"] = 3 + common_config["work_max_retries"] = safe_int(common_config["work_max_retries"], 3, low=0, high=10) else: common_config["work_max_retries"] = 3 if "work_redo_enabled" in common_config: @@ -158,8 +279,31 @@ def load_config_from_file(config_path): common_config["use_cookies"] = str_to_bool(common_config["use_cookies"]) if "add_learning_count" in common_config: common_config["add_learning_count"] = str_to_bool(common_config["add_learning_count"]) + if "task_center" in common_config: + common_config["task_center"] = str_to_bool(common_config["task_center"]) + if "chapter_study" in common_config: + common_config["chapter_study"] = str_to_bool(common_config["chapter_study"]) + common_config["task_center_submit_mode"] = normalize_submit_mode( + common_config.get("task_center_submit_mode", "auto") + ) + common_config["ai_practice_min_score"] = safe_float( + common_config.get("ai_practice_min_score", 85), 85.0, low=0.0, high=100.0 + ) + common_config["ai_practice_max_rounds"] = safe_int( + common_config.get("ai_practice_max_rounds", 5), 5, low=1, high=20 + ) if "target_count" in common_config: - common_config["target_count"] = int(common_config["target_count"]) + common_config["target_count"] = safe_int(common_config["target_count"], 100, low=1, high=9999) + + # notopen_action 只接受三个合法值,写错就用默认的 continue(最省事) + action = str(common_config.get("notopen_action", "")).strip().lower() + common_config["notopen_action"] = action if action in NOTOPEN_ACTIONS else "continue" + # max_points_per_course 支持两种格式,必须保持字符串原样交给 + # _parse_max_points 解析: + # 3 全部课程都刷 3 个 + # 2151141:3,189191:0 按课程分别指定 + # 注意:不要在这里做 int() 转换,否则 "2151141:3" 会抛 ValueError + # 被静默改成 0,导致"按课程指定"完全失效、退化成全部刷完。 if "username" in common_config and common_config["username"] is not None: common_config["username"] = common_config["username"].strip() if "password" in common_config and common_config["password"] is not None: @@ -168,10 +312,10 @@ def load_config_from_file(config_path): # 检查并读取tiku节 if config.has_section("tiku"): tiku_config = dict(config.items("tiku")) - # 处理数值类型转换 - for key in ["delay", "cover_rate"]: + # 处理数值类型转换(写错时用默认值兜底,不让程序崩溃) + for key, default in (("delay", 1.0), ("cover_rate", 0.8)): if key in tiku_config: - tiku_config[key] = float(tiku_config[key]) + tiku_config[key] = safe_float(tiku_config[key], default, low=0.0) # 检查并读取notification节 if config.has_section("notification"): @@ -180,8 +324,28 @@ def load_config_from_file(config_path): return common_config, tiku_config, notification_config +def _load_default_tiku_and_notification(): + """命令行模式(不带 -c)下,题库和通知设置仍然从用户配置里读.""" + # + # 运行时 Tiku 本来就会去读 ~/.chaoxing/config.ini 的 [tiku] 段, + # 如果启动检查看不到它,就会出现"参数都填了却被拦下来问答题方式"的矛盾。 + # 只取题库和通知两段:账号 / 课程 / 刷课参数一律以命令行参数为准。 + try: + default_config = paths.config_path() + except Exception: + return {}, {} + if not os.path.exists(default_config): + return {}, {} + try: + _common, tiku_config, notification_config = load_config_from_file(default_config) + return tiku_config, notification_config + except Exception as e: + logger.warning(f"读取配置文件失败,将忽略其中的答题/通知设置: {e}") + return {}, {} + + def build_config_from_args(args): - """从命令行参数构建配置""" + """从命令行参数构建配置.""" common_config = { "use_cookies": args.use_cookies, "username": args.username, @@ -193,23 +357,43 @@ def build_config_from_args(args): "retry_interval": args.retry_interval or 1.0, "add_learning_count": args.add_learning_count, "target_count": args.target_count, + "max_points_per_course": getattr(args, "max_points", 0) or 0, + "max_tasks_per_course": getattr(args, "max_tasks", 0) or 0, + "task_center": getattr(args, "task_center", None), + "task_center_submit_mode": getattr(args, "task_center_submit_mode", None), + "chapter_study": getattr(args, "chapter_study", None), + "ai_practice_min_score": 85.0, + "ai_practice_max_rounds": 5, } - return common_config, {}, {} + tiku_config, notification_config = _load_default_tiku_and_notification() + return common_config, tiku_config, notification_config def init_config(): - """初始化配置""" + """初始化配置.""" args = parse_args() if args.config: common_config, tiku_config, notification_config = load_config_from_file(args.config) else: common_config, tiku_config, notification_config = build_config_from_args(args) - return common_config, tiku_config, notification_config, args.config + # 明确提供的开关/提交模式始终覆盖配置文件;未提供时保留配置,避免 --yes + # 或普通命令行启动意外改变提交门禁。 + if getattr(args, "chapter_study", None) is not None: + common_config["chapter_study"] = bool(args.chapter_study) + if getattr(args, "task_center", None) is not None: + common_config["task_center"] = bool(args.task_center) + if getattr(args, "task_center_submit_mode", None) is not None: + common_config["task_center_submit_mode"] = normalize_submit_mode( + args.task_center_submit_mode + ) + # 仅供任务中心的写作器使用;不会写回配置文件,也不会改变章节答题配置。 + common_config["_tiku_config"] = tiku_config + return common_config, tiku_config, notification_config, args.config, args def init_chaoxing(common_config, tiku_config, config_path=None): - """初始化超星实例""" + """初始化超星实例.""" username = common_config.get("username", "") password = common_config.get("password", "") use_cookies = common_config.get("use_cookies", False) @@ -234,20 +418,39 @@ def init_chaoxing(common_config, tiku_config, config_path=None): if any(name in ['AI', 'SiliconFlow'] for name in provider_list): check_connection = tiku_config.get('check_llm_connection', 'true').lower() == 'true' if check_connection: - logger.info(f'正在验证大模型配置 (provider={provider})...') + logger.debug(f'正在验证大模型配置 (provider={provider})...') if not tiku.check_llm_connection(): logger.error('大模型连接检查失败') - choice = input('大模型连接检查失败,无法准确答题,是否继续运行?(Y/n): ').strip().lower() - # 直接回车默认继续运行 - if choice not in ('', 'y', 'yes'): - raise RuntimeError('用户取消运行') - logger.info('用户选择继续运行...') + + # 没有终端可交互时,不能自己决定继续,直接停止 + if not sys.stdin.isatty(): + raise RuntimeError( + 'DeepSeek API Key 校验失败,且当前无法交互确认,已停止运行。\n' + ' 请检查 config.ini 里的 key(或运行 cx setup 重新填写)。' + ) + + print() + print(" ✘ 答题用的 API Key 没通过验证,章节测验这次不能自动作答(运行 cx setup 可以改)") + print(" 可能原因:填错了、已失效、或账户余额不足。") + print(" 建议先运行 cx 重新填写;这里选停止更安全。") + print() + try: + choice = input(" 仍然继续刷课吗?(y/n) > ").strip().lower() + except (EOFError, KeyboardInterrupt): + print() + choice = "" + # 默认不继续(安全默认),必须明确输入 y + if choice not in ("y", "yes", "是"): + raise RuntimeError("API Key 校验失败,用户选择停止") + logger.warning("用户确认在 API Key 异常的情况下继续运行") query_delay = tiku_config.get("delay", 0) # 章节检测答错后允许的最大重做次数(答错时反馈给AI并重新提交,直到全部正确) work_max_retries = common_config.get("work_max_retries", 3) + # 视频是否串行:默认并发(快);遇到"刷完又变回没刷"可以打开 + serial_video = str_to_bool(common_config.get("serial_video", False)) # 是否允许自动重做(默认false: 仅检查并记录成绩, 适用于只允许作答一次的课程) work_redo_enabled = common_config.get("work_redo_enabled", False) @@ -257,34 +460,42 @@ def init_chaoxing(common_config, tiku_config, config_path=None): tiku=tiku, query_delay=query_delay, work_max_retries=work_max_retries, + serial_video=serial_video, work_redo_enabled=work_redo_enabled, ) return chaoxing -def process_job(chaoxing: Chaoxing, course: dict, job: dict, job_info: dict, speed: float) -> StudyResult: - """处理单个任务点""" +def process_job(chaoxing: Chaoxing, course: dict, job: dict, job_info: dict, speed: float, + engine_info: bool = False) -> StudyResult: + """处理单个任务点.""" + # + # engine_info=True 表示这次是任务引擎的"章节"任务点在刷 mooc 章节, + # 打点/文档完成请求要带 courseEngineInfo,平台才会下发 stuJobInfo。 # 视频任务 if job["type"] == "video": logger.trace(f"识别到视频任务, 任务章节: {course['title']} 任务ID: {job['jobid']}") # 超星的接口没有返回当前任务是否为Audio音频任务 video_result = chaoxing.study_video( - course, job, job_info, _speed=speed, _type="Video" + course, job, job_info, _speed=speed, _type="Video", engine_info=engine_info ) - if video_result.is_failure(): - logger.warning("当前任务非视频任务, 正在尝试音频任务解码") + if video_result == StudyResult.ERROR: + # 只有"读不到视频信息"(多半其实是音频任务)才回退音频。 + # 403 风控时不能立刻再跑一遍音频 —— 那等于连续撞风控, + # 而且会把剩余时长整段再"播放"一次,反而更容易被判定异常(#445 #473 #488)。 + logger.info("当前任务非视频任务, 正在尝试音频任务解码") video_result = chaoxing.study_video( - course, job, job_info, _speed=speed, _type="Audio") + course, job, job_info, _speed=speed, _type="Audio", engine_info=engine_info) if video_result.is_failure(): logger.warning( - f"出现异常任务 -> 任务章节: {course['title']} 任务ID: {job['jobid']}, 已跳过" + f"任务点异常已跳过: {job.get('name', job['jobid'])}(详情见日志)" ) return video_result # 文档任务 elif job["type"] == "document": logger.trace(f"识别到文档任务, 任务章节: {course['title']} 任务ID: {job['jobid']}") - return chaoxing.study_document(course, job) + return chaoxing.study_document(course, job, engine_info=engine_info) # 测验任务 elif job["type"] == "workid": logger.trace(f"识别到章节检测任务, 任务章节: {course['title']}") @@ -311,14 +522,10 @@ def process_job(chaoxing: Chaoxing, course: dict, job: dict, job_info: dict, spe course_id=course.get("courseId") ) - # 启动直播处理线程 - thread = threading.Thread( - target=LiveProcessor.run_live, - args=(live, speed), - daemon=True - ) - thread.start() - thread.join() # 等待直播处理完成 + # 直播按真实时间跑(不看倍速),并尊重中断;拿不到成功结果就不算完成 + if not LiveProcessor.run_live(live, speed): + logger.warning(f"直播任务未完成: {job.get('name', '?')}") + return StudyResult.ERROR return StudyResult.SUCCESS except Exception as e: logger.error(f"处理直播任务时出错: {str(e)}") @@ -344,7 +551,8 @@ def __lt__(self, other): class JobProcessor: - def __init__(self, chaoxing: Chaoxing, tasks: list[ChapterTask], config: dict[str, Any]): + def __init__(self, chaoxing: Chaoxing, tasks: list[ChapterTask], config: dict[str, Any], + progress=None): """初始化任务处理器.""" if "jobs" not in config or not config["jobs"]: config["jobs"] = 4 @@ -361,6 +569,7 @@ def __init__(self, chaoxing: Chaoxing, tasks: list[ChapterTask], config: dict[st self.worker_num = config["jobs"] self.config = config self.retry_interval = config.get("retry_interval", 1.0) + self.progress = progress def run(self): for task in self.tasks: @@ -373,7 +582,27 @@ def run(self): threading.Thread(target=self.retry_thread, daemon=True).start() - self.task_queue.join() + # 等待所有任务完成。 + # 不用 task_queue.join():如果工作线程意外全部退出,join() 会永久挂起 + # (表现为程序变成僵尸进程,既不报错也不退出)。这里加看门狗。 + while True: + try: + if self.task_queue.unfinished_tasks == 0: + break + except AttributeError: + break + if interrupt.should_stop(): + logger.warning("收到终止指令,停止等待剩余任务") + break + alive = [t for t in self.threads if t.is_alive()] + if not alive: + remaining = getattr(self.task_queue, "unfinished_tasks", 0) + logger.error( + "所有工作线程已退出,但仍有 {} 个任务未完成,停止等待", remaining + ) + break + time.sleep(0.3) + time.sleep(0.5) if hasattr(self.task_queue, "shutdown"): self.task_queue.shutdown() @@ -381,32 +610,53 @@ def run(self): @log_error def worker_thread(self): while True: + # 用户按 q 要求终止 -> 立刻停止领取新任务 + if interrupt.should_stop(): + return try: task = self.task_queue.get() except ShutDown: logger.info("Queue shut down") return - task.result = process_chapter(self.chaoxing, task.course, task.point, self.speed) + # 关键:单个章节的异常不能让线程退出,否则任务永远不会 task_done, + # 主线程会永久等待。异常统一转成 ERROR,交给下面的重试逻辑处理。 + try: + task.result = process_chapter(self.chaoxing, task.course, task.point, self.speed) + except BaseException as e: + logger.error( + "处理章节时发生异常: {} - {} -> {}: {}", + task.course.get("title", "?"), task.point.get("title", "?"), + type(e).__name__, e + ) + logger.debug(traceback.format_exc()) + task.result = ChapterResult.ERROR match task.result: case ChapterResult.SUCCESS: logger.debug("Task success: {} - {}", task.course["title"], task.point["title"]) + if self.progress: + self.progress.chapter_done(task.point.get("title", "")) self.task_queue.task_done() logger.debug(f"unfinished task: {self.task_queue.unfinished_tasks}") case ChapterResult.NOT_OPEN: if self.config["notopen_action"] == "continue": - logger.warning("章节未开启: {} - {}, 正在跳过", task.course["title"], task.point["title"]) + # 进度行已用 ⤼ 标记,这里只写日志文件,不刷屏 + logger.info("章节未开启,已跳过: {} - {}", task.course["title"], task.point["title"]) + if self.progress: + self.progress.chapter_skipped(task.point.get("title", ""), "未开放") self.task_queue.task_done() continue task.tries += 1 if task.tries >= self.max_tries: - logger.error( - "章节未开启: {} - {} 可能由于上一章节的章节检测未完成, 也可能由于该章节因为时效已关闭," - "请手动检查完成并提交再重试。或者在配置中配置(自动跳过关闭章节/开启题库并启用提交)" + logger.info( + "章节未开启(重试已达上限): {} - {} 可能由于上一章节的章节检测未完成, " + "或该章节因时效已关闭,请手动检查完成并提交再重试。" , task.course["title"], task.point["title"]) + if self.progress: + self.progress.chapter_skipped(task.point.get("title", ""), "(未开放)") self.task_queue.task_done() continue @@ -415,12 +665,16 @@ def worker_thread(self): case ChapterResult.ERROR: task.tries += 1 - logger.warning("重试任务 {} - {} ({}/{} 次尝试)", task.course["title"], task.point["title"], - task.tries, - self.max_tries) + # 重试过程写日志文件即可,控制台由进度行体现 + logger.info("重试任务 {} - {} ({}/{} 次尝试)", task.course["title"], task.point["title"], + task.tries, + self.max_tries) if task.tries >= self.max_tries: - logger.error("任务重试次数达到上限: {} - {}", task.course["title"], task.point["title"]) + # 进度行已用 ✗ 标记 + logger.info("任务重试次数达到上限: {} - {}", task.course["title"], task.point["title"]) self.failed_tasks.append(task) + if self.progress: + self.progress.chapter_failed(task.point.get("title", "")) self.task_queue.task_done() continue self.retry_queue.put(task) @@ -444,8 +698,15 @@ def retry_thread(self): pass -def process_chapter(chaoxing: Chaoxing, course: dict[str, Any], point: dict[str, Any], speed: float) -> ChapterResult: - """处理单个章节""" +def process_chapter(chaoxing: Chaoxing, course: dict[str, Any], point: dict[str, Any], speed: float, + engine_info: bool = False) -> ChapterResult: + """处理单个章节.""" + # + # engine_info=True:这次章节是任务引擎的"章节"任务点,打点要带引擎标记, + # 完成后由调用方用平台下发的 stuJobInfo 做 autoPullChapterScore 同步。 + # 用户已要求终止:不再开始新章节 + if interrupt.should_stop(): + return ChapterResult.ERROR logger.info(f'当前章节: {point["title"]}') if point["has_finished"]: logger.info(f'章节:{point["title"]} 已完成所有任务点') @@ -458,6 +719,13 @@ def process_chapter(chaoxing: Chaoxing, course: dict[str, Any], point: dict[str, job_info = None jobs, job_info = chaoxing.get_job_list(course, point) + # jobs 为 None = 任务点没读到(登录失效 / 风控 / 页面结构变化)。 + # 这时绝不能返回 SUCCESS:那会让这一章在进度里被打勾, + # 整门课都这样时还会报"全部完成",其实一个任务点都没做(#223 / #357)。 + if jobs is None: + logger.error("章节任务点读取失败,稍后重试: {}", point.get("title", "")) + return ChapterResult.ERROR + # 发现未开放章节, 根据配置处理 if job_info.get("notOpen", False): return ChapterResult.NOT_OPEN @@ -468,7 +736,7 @@ def process_chapter(chaoxing: Chaoxing, course: dict[str, Any], point: dict[str, job_results: list[StudyResult] = [] for job in jobs: - result = process_job(chaoxing, course, job, job_info, speed) + result = process_job(chaoxing, course, job, job_info, speed, engine_info=engine_info) job_results.append(result) for result in job_results: @@ -479,7 +747,7 @@ def process_chapter(chaoxing: Chaoxing, course: dict[str, Any], point: dict[str, def process_course(chaoxing: Chaoxing, course: dict[str, Any], config: dict): - """处理单个课程""" + """处理单个课程.""" logger.info(f"开始学习课程: {course['title']}") # 获取当前课程的所有章节 @@ -491,46 +759,162 @@ def process_course(chaoxing: Chaoxing, course: dict[str, Any], config: dict): _old_format_sizeof = tqdm.format_sizeof tqdm.format_sizeof = format_time + try: + tasks = [] + for i, point in enumerate(point_list["points"]): + task = ChapterTask(point=point, index=i, course=course) + tasks.append(task) + p = JobProcessor(chaoxing, tasks, config) + p.run() + finally: + # 无论成功、失败还是被中断,都要把 tqdm 的全局格式恢复回去 + tqdm.format_sizeof = _old_format_sizeof - tasks = [] - for i, point in enumerate(point_list["points"]): - task = ChapterTask(point=point, index=i, course=course) - tasks.append(task) - p = JobProcessor(chaoxing, tasks, config) - p.run() +def _parse_max_points(raw): + """解析 max_points_per_course 配置.""" + # + # 支持: + # 3 -> ({}, 3, []) 全部课程都刷 3 个 + # 2151141:3,189191:0 -> ({'2151141':3, ...}, 0, []) + # 0 或空 -> ({}, 0, []) 全部刷完 + # 返回 (每课程字典, 默认值, 无法识别的片段) + # + # 第三个返回值很重要:如果用户填了东西却一个都认不出来, + # 必须停下来提醒,绝不能默默当成"全部刷完"。 + if raw is None: + return {}, 0, [] + text = str(raw).strip() + if not text: + return {}, 0, [] + + per_course = {} + default = None + bad = [] + + for item in re.split(r"[,,、;;\s]+", text): + item = item.strip() + if not item: + continue + if ":" in item or ":" in item: + # 课程ID:数量 + parts = re.split(r"[::]", item, maxsplit=1) + cid = parts[0].strip() + try: + num = int(parts[1].strip()) + except (ValueError, IndexError): + bad.append(item) + continue + if not cid: + bad.append(item) + continue + per_course[cid] = max(0, num) + else: + # 单个数字 = 全局默认 + try: + default = max(0, int(item)) + except ValueError: + bad.append(item) + continue + + if default is None: + default = 0 + return per_course, default, bad + + +def select_points_for_course(all_points, max_points=0): + """把一门课的章节分成"已完成"和"待刷"两部分,并算出本次要刷哪些.""" + # + # 已完成(has_finished)的章节直接跳过,不再排进任务队列 —— + # 否则每节都会闪过一行"预计 1 秒",看起来像是要把前面几章重刷一遍。 + # + # 返回 (已完成, 待刷, 本次要刷) + all_points = list(all_points or []) + finished = [p for p in all_points if p.get("has_finished")] + pending = [p for p in all_points if not p.get("has_finished")] + if max_points and max_points > 0: + selected = pending[:max_points] + else: + selected = pending + return finished, pending, selected - tqdm.format_sizeof = _old_format_sizeof + +def _format_course_table(all_course): + """格式化课程列表,供用户选择或报错时展示.""" + lines = ["*" * 10 + "课程列表" + "*" * 10] + for course in all_course: + lines.append(f"ID: {course['courseId']} 班级ID: {course['clazzId']} 课程名: {course['title']}") + lines.append("*" * 28) + return "\n".join(lines) + + +def _parse_course_ids(raw): + """解析用户输入的课程ID,兼容中文逗号 / 空格 / 换行 / 全角数字等常见误输入.""" + # 返回去重后的 ID 列表。 + if raw is None: + return [] + # 已经是列表(例如配置里解析后的 course_list)则逐个处理,避免 str(list) 变成 "['111']" + if isinstance(raw, (list, tuple, set)): + candidates = [str(x) for x in raw] + else: + # 中文逗号、顿号、分号、空格、换行统一成英文逗号 + candidates = re.sub(r"[,、;;\s]+", ",", str(raw).strip()).split(",") + parts = [] + for item in candidates: + item = item.strip().strip('"').strip("'") + # 全角数字转半角 + item = item.translate(str.maketrans("0123456789", "0123456789")) + if item: + parts.append(item) + return list(dict.fromkeys(parts)) def filter_courses(all_course, course_list): - """过滤要学习的课程""" - if not course_list: - # 手动输入要学习的课程ID列表 - print("*" * 10 + "课程列表" + "*" * 10) - for course in all_course: - print(f"ID: {course['courseId']} 班级ID: {course['clazzId']} 课程名: {course['title']}") - print("*" * 28) - print("提示: 同一 courseId 下若存在多个班级, 将分别完成。") - try: - course_list = input( - "请输入想要学习的课程列表,以逗号分隔,例: 2151141,189191,198198\n" - ).split(",") - except Exception as e: - raise InputFormatError("输入格式错误") from e + """过滤要学习的课程.""" + # + # 规则(严格模式): + # 必须明确指定要刷的课程 ID。 + # - 匹配成功 -> 只刷这些课程 + # - 一个都没匹配上 -> 报错停止,绝不回退全刷 + # - 没有指定(空) -> 报错停止,绝不自动刷全部课程 + # + # 历史上这里有个"没指定就刷全部课程"的兜底逻辑,曾导致用户只想刷 1 门课 + # 却把 12 门课全部刷了。该兜底已移除。 + if not all_course: + raise InputFormatError("登录成功但没读到任何课程,请检查账号是否有课程") + + # 没有配置课程 ID:打印课程表并停止,由用户明确指定 + wanted = _parse_course_ids(course_list) + if not wanted: + raise InputFormatError( + "没有指定要刷的课程 ID,为避免误刷全部课程已停止运行。\n" + "请把你想要刷的课程 ID 填到 config.ini 的 course_list,或运行 cx setup。\n" + + _format_course_table(all_course) + ) - # 筛选需要学习的课程 course_task = [] seen_keys = set() + matched_ids = set() for course in all_course: key = (course["courseId"], course["clazzId"]) - if course["courseId"] in course_list and key not in seen_keys: + if str(course["courseId"]) in wanted and key not in seen_keys: course_task.append(course) seen_keys.add(key) - - # 如果没有指定课程,则学习所有课程 + matched_ids.add(str(course["courseId"])) + if not course_task: - course_task = all_course + raise InputFormatError( + "配置的 course_list 没有匹配到任何课程,为避免误刷已停止运行。\n" + f"你填写的: {', '.join(wanted)}\n" + "请从下面的课程列表里复制正确的 ID 后重试:\n" + + _format_course_table(all_course) + ) + + missing = [cid for cid in wanted if cid not in matched_ids] + if missing: + logger.warning( + "以下课程ID未匹配到任何课程, 已忽略: {}", ", ".join(missing) + ) return course_task @@ -547,20 +931,652 @@ def format_time(num, suffix='', divisor=''): return f"{mins:02d}:{sec:02d}" +# ---------------------------------------------------------------- 任务中心 + +# 一个教学任务最多交替推进几轮(每完成一组,下一组才会解锁) +TASK_CENTER_MAX_ROUNDS = 6 + + +def _task_center_enabled(common_config: dict, args) -> bool: + """任务中心开关:命令行 > 配置文件 > 默认开启.""" + cli = getattr(args, "task_center", None) + if cli is not None: + return bool(cli) + value = common_config.get("task_center", True) + if value is None: + return True + if isinstance(value, str): + return str_to_bool(value) + return bool(value) + + +def _chapter_study_enabled(common_config: dict, args) -> bool: + """章节(目录)开关:命令行 > 配置文件 > 默认开启.""" + cli = getattr(args, "chapter_study", None) + if cli is not None: + return bool(cli) + value = common_config.get("chapter_study", True) + if value is None: + return True + if isinstance(value, str): + return str_to_bool(value) + return bool(value) + + +def _discussion_mode_for_run(common_config: dict, task_center_enabled: bool, + only_discussion: bool) -> str: + """把讨论处理方式约束在本轮的任务中心范围内.""" + # + # 向导每轮都会重写范围,但旧账号配置、手改配置或 CLI 覆盖仍可能留下 board。 + # 当本轮不跑任务中心时,把它降为 none,确保章节流程没有讨论区分派或提示。 + if not (task_center_enabled or only_discussion): + return "none" + mode = str(common_config.get("discussion_mode", "") or "task").strip().lower() + return mode if mode in ("task", "board") else "task" + + +def _teaching_task_finished(task: dict) -> bool: + """教学任务在列表里的完成进度(1.0 = 全部刷完).""" + try: + return float(task.get("taskStudyProgress") or 0) >= 1.0 + except (TypeError, ValueError): + return False + + +def _load_course_point_map(chaoxing: Chaoxing, course: dict) -> dict: + """Map knowledgeId values to chapter records.""" + try: + point_list = chaoxing.get_course_point( + course["courseId"], course["clazzId"], course["cpi"] + ) + except Exception as e: + logger.warning( + "读取《{}》章节失败,教学任务里的章节类任务点这次先跳过: {}", + course.get("title", "?"), e, + ) + return {} + points = (point_list or {}).get("points") or [] + return {str(point.get("id")): point for point in points} + + +def _study_task_chapter(tc, chaoxing, course, plan, info, config, point_map, name): + """Study a chapter and synchronize only platform-provided completion data.""" + # 章节类型:任务点带 knowledgeId,直接复用章节刷课逻辑。 + # 与普通章节刷课的唯一区别是要带任务引擎标记,并在刷完后把平台 + # 下发的 stuJobInfo 交给 autoPullChapterScore(任务引擎才认账)。 + knowledge_id = str(plan.get("externalDataId") or "") + point = point_map.get(knowledge_id) + if point is None: + logger.warning("教学任务里的章节在目录中找不到: {}(knowledgeId={})", name, knowledge_id) + return False + if hasattr(chaoxing, "last_student_job_info"): + chaoxing.last_student_job_info = None + logger.info("任务中心章节任务点: {}(knowledgeId={})", name, knowledge_id) + result = process_chapter(chaoxing, course, point, config["speed"], engine_info=True) + if result != ChapterResult.SUCCESS: + logger.info("教学任务中的章节未完成: {} -> {}", name, result) + return False + job_info = getattr(chaoxing, "last_student_job_info", None) + if isinstance(job_info, dict) and job_info: + logger.info("教学任务章节刷完,正在同步给任务引擎: {}", name) + if not tc.sync_chapter_plan(info["encryTaskUserId"], job_info): + # 同步请求没被接受时不能继续等:引擎不认这一章的完成 + logger.warning("章节成绩同步未被接受,本次不计完成: {}", name) + return False + else: + # 平台没下发同步数据(常见于章节本来就已经刷完):不伪造 enc, + # 交给下面的 wait_plan_finished 复查,完成与否只认引擎状态。 + logger.info("章节已完成但平台未下发同步数据(stuJobInfo),等待任务引擎更新: {}", name) + return True + + +def _study_task_media(tc, course, plan, info, plan_type, name, type_name): + """Dispatch a supported engine task without losing cancellation outcomes.""" + study_url = tc.get_study_url(info["encryTaskUserId"], plan.get("encryptPlanId", "")) + if not study_url: + return False + method_name, label, needs_course = { + PLAN_TYPE_VIDEO: ("study_video", "视频", False), + PLAN_TYPE_DOCUMENT: ("study_document", "文档", False), + PLAN_TYPE_HOMEWORK: ("study_homework", "作业", True), + PLAN_TYPE_DISCUSS: ("study_discussion", "主题讨论", True), + PLAN_TYPE_AI: ("study_ai_practice", "AI 实践", False), + }[plan_type] + method = getattr(tc, method_name, None) + if not callable(method): + logger.info("教学任务点类型暂不支持,需要手动完成: [{}] {}", type_name, name) + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.UNSUPPORTED + return None + logger.info("任务中心{}任务点: {}", label, name) + args = (study_url, plan, course) if needs_course else (study_url, plan) + if method(*args): + return True + if (plan_type != PLAN_TYPE_AI and hasattr(tc, "last_outcome") + and tc.last_outcome != TaskOutcome.WAITING_CONFIRMATION): + tc.last_outcome = TaskOutcome.FAILED + logger.warning("任务中心{}任务未完成: {}", label, name) + return False + + +def _complete_teaching_plan(tc: TaskCenter, chaoxing: Chaoxing, course: dict, plan: dict, + info: dict, config: dict, point_map: dict): + """完成一个教学任务点.""" + # + # 返回 True(已完成) / False(没完成) / None(类型不支持)。 + # 新任务中心客户端会额外写入 ``last_outcome``,旧的 FakeTC/调用方仍可只看 bool。 + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.FAILED + try: + plan_type = int(plan.get("planType")) + except (TypeError, ValueError): + plan_type = -1 + name = plan.get("name", "?") + type_name = plan_type_name(plan_type) + + if plan_type not in SUPPORTED_PLAN_TYPES: + logger.info("教学任务点类型暂不支持,需要手动完成: [{}] {}", type_name, name) + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.UNSUPPORTED + return None + + if plan_type == PLAN_TYPE_CHAPTER: + result = _study_task_chapter(tc, chaoxing, course, plan, info, config, point_map, name) + else: + result = _study_task_media(tc, course, plan, info, plan_type, name, type_name) + if result is not True: + return result + + if tc.wait_plan_finished( + info["encryTaskUserId"], plan.get("encryptGroupId", ""), plan.get("planId") + ): + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.COMPLETED + return True + # 动作发出去了但任务中心还没显示完成:不算成功,下次运行会重试 + logger.info("任务点已执行,但任务中心暂未显示完成(可能还在同步): {}", name) + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.FAILED + return False + + +def _recheck_task_completion(tc, task, only_discussion, skip_discussion, unsupported): + """Determine completion from a final fresh group/plan readback.""" + # 收尾复查:可能最后几个任务点刚同步完成 + info = tc.open_task(task) + if info: + remaining = 0 + locked_remaining = 0 + groups = tc.get_groups(info["encryTaskUserId"]) + if not isinstance(groups, list) or not groups: + return False, unsupported + saw_plan_data = False + for group in groups: + plans = tc.get_plans( + info["encryTaskUserId"], group.get("encryptGroupId", "") + ) + if getattr(tc, "last_plan_read_failed", False): + return False, unsupported + if plans: + saw_plan_data = True + if not group.get("groupAllowStudy"): + locked_remaining += sum(1 for plan in plans if not tc.plan_finished(plan)) + continue + for plan in plans: + if tc.plan_finished(plan): + continue + plan_type = int(plan.get("planType") or -1) + if only_discussion and plan_type != PLAN_TYPE_DISCUSS: + continue + if skip_discussion and plan_type == PLAN_TYPE_DISCUSS: + continue + remaining += 1 + if remaining == 0 and locked_remaining == 0 and saw_plan_data: + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.COMPLETED + return True, unsupported + if locked_remaining and hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.LOCKED + return False, unsupported + + +def _advance_task_plan(tc, chaoxing, course, plan, info, config, point_map, + only_discussion, skip_discussion, stats, state, + failed_plans, skipped_other_ids, unsupported): + """Advance one eligible plan while preserving cancellation and failures.""" + if interrupt.should_stop(): + return False + plan_key = str(plan.get("planId")) + plan_type = int(plan.get("planType") or -1) + skip_this = (only_discussion and plan_type != PLAN_TYPE_DISCUSS) or ( + skip_discussion and plan_type == PLAN_TYPE_DISCUSS) + if skip_this: + if plan_key not in skipped_other_ids: + skipped_other_ids.add(plan_key) + if stats is not None: + stats["skipped_other"] = stats.get("skipped_other", 0) + 1 + return True + if plan_key in failed_plans: + state["failed"] += 1 + return True + state["allowed"] += 1 + result = _complete_teaching_plan(tc, chaoxing, course, plan, info, config, point_map) + if result is True: + state["progressed"] = True + elif result is None: + unsupported.add(plan_type_name(plan.get("planType"))) + failed_plans.add(plan_key) + elif getattr(tc, "last_outcome", None) == TaskOutcome.WAITING_CONFIRMATION: + return False + else: + failed_plans.add(plan_key) + return True + + +def _advance_task_group(tc, chaoxing, course, group, info, config, point_map, + only_discussion, skip_discussion, stats, state, + failed_plans, skipped_other_ids, unsupported): + """Read one group and only advance its unlocked unfinished plans.""" + plans = tc.get_plans(info["encryTaskUserId"], group.get("encryptGroupId", "")) + if getattr(tc, "last_plan_read_failed", False): + logger.warning("教学任务点状态读取失败,本次不判定为完成") + return False + if plans: + state["saw_plans"] = True + unfinished = [plan for plan in plans if not tc.plan_finished(plan)] + if not group.get("groupAllowStudy"): + state["locked"] += len(unfinished) + return True + for plan in unfinished: + if not _advance_task_plan(tc, chaoxing, course, plan, info, config, point_map, + only_discussion, skip_discussion, stats, state, + failed_plans, skipped_other_ids, unsupported): + return False + return True + + +def _process_teaching_task(tc: TaskCenter, chaoxing: Chaoxing, course: dict, task: dict, + config: dict, point_map: dict, + only_discussion: bool = False, stats: dict = None, + skip_discussion: bool = False) -> tuple: + """按分组顺序推进一个教学任务.""" + # + # 任务引擎是"通关式"的:只有 groupAllowStudy=True 的分组能学, + # 上一组全部完成之后,下一组才会解锁,所以要反复重新读取分组状态。 + logger.debug("教学任务:{} - {}", course.get("title", "?"), task.get("name", "?")) + print(f" ▸ 教学任务:{task.get('name', '?')}") + unsupported = set() + # 本次运行里已经失败过的任务点:不再重试。 + # 任务引擎的重试轮次是为"上一组刚完成、下一组还没解锁"准备的, + # 拿它去重试一个真的失败的任务点只会白烧时间(AI实践重试一次就是好几分钟)。 + failed_plans = set() + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.FAILED + if hasattr(tc, "waiting_confirmation"): + tc.waiting_confirmation = False + + skipped_other_ids = set() # 只刷讨论时,同一计划多轮扫描只计一次 + for _ in range(TASK_CENTER_MAX_ROUNDS): + if interrupt.should_stop(): + return False, unsupported + info = tc.open_task(task) + if not info: + return False, unsupported + groups = tc.get_groups(info["encryTaskUserId"]) + if not isinstance(groups, list) or not groups: + return False, unsupported + + state = {"allowed": 0, "locked": 0, "failed": 0, + "progressed": False, "saw_plans": False} + for group in groups: + if not _advance_task_group(tc, chaoxing, course, group, info, config, + point_map, only_discussion, skip_discussion, stats, state, + failed_plans, skipped_other_ids, unsupported): + return False, unsupported + allowed_left, locked_left, skipped_failed = state["allowed"], state["locked"], state["failed"] + progressed, saw_plan_data = state["progressed"], state["saw_plans"] + + if allowed_left == 0 and locked_left == 0 and skipped_failed == 0 and saw_plan_data: + # 所有任务点都已经完成:这是"完成",不是"失败"。 + # 之前这里直接 return,last_outcome 还停在开头的 FAILED, + # 调用方(或读日志的人)会把一次成功的跳过看成失败。 + if hasattr(tc, "last_outcome"): + tc.last_outcome = TaskOutcome.COMPLETED + return True, unsupported + if not progressed: + if allowed_left == 0 and locked_left: + # 上一组刚完成,解锁要等任务引擎同步一下,再读一次分组 + tc.last_outcome = TaskOutcome.LOCKED + time.sleep(3) + continue + break + + return _recheck_task_completion(tc, task, only_discussion, skip_discussion, unsupported) + + +def _record_task_outcome(tc, stats, ok, unsupported): + """Count and display the actual result of a teaching task.""" + if ok: + stats["done"] += 1 + print(" ✓ 完成") + else: + stats["failed"] += 1 + outcome = getattr(tc, "last_outcome", TaskOutcome.FAILED) + if outcome == TaskOutcome.WAITING_CONFIRMATION: + stats["waiting_confirmation"] += 1 + print(" ⏸ 等待确认(未提交,稍后可继续)") + elif unsupported: + # 当前组有暂不支持的任务点时,即使后续组也处于锁定状态, + # 先报告真正阻塞解锁的原因,避免把“暂不支持”模糊成“未解锁”。 + stats["unsupported"] += 1 + print( + " ⤼ 跳过(含暂不支持的任务点:" + + "、".join(sorted(unsupported)) + ",需要手动完成)" + ) + elif outcome == TaskOutcome.LOCKED: + stats["locked"] += 1 + print(" ⤼ 还没轮到(要先完成前面的任务)") + else: + print(" ✗ 未完成(可能要先完成前面的任务)") + +def run_task_center_phase(chaoxing: Chaoxing, course_task: list, config: dict, + max_tasks=None, only_discussion: bool = False, + skip_discussion: bool = False) -> dict: + """任务中心 -> 教学任务.""" + # + # 和"章节"互相独立:章节全刷完的课程也可能还有教学任务, + # 所以这一步在章节之后单独跑,失败只影响它自己。 + # + # max_tasks: (每课程字典, 默认值),来自 max_tasks_per_course; + # 不传时从 config 里现解析(0 = 全部)。只限制要处理的教学任务个数, + # 不会把"被限制没刷"当成失败。 + if max_tasks is None: + max_tasks_map, max_tasks_default, _bad = _parse_max_points( + config.get("max_tasks_per_course") + ) + else: + max_tasks_map, max_tasks_default = max_tasks + tc = TaskCenter(chaoxing, config) + stats = { + "courses": 0, + "tasks": 0, + "done": 0, + "failed": 0, + "unsupported": 0, + "waiting_confirmation": 0, + "locked": 0, + "read_failed": 0, + "limited": 0, + "skipped_other": 0, # 只刷讨论时被跳过的其它类型 + "only_discussion": bool(only_discussion), + "empty": 0, # 没有教学任务的课程数 + } + + for course in course_task: + if interrupt.should_stop(): + break + try: + tasks = tc.get_course_tasks(course) + except Exception as e: + logger.warning("读取《{}》教学任务失败: {}", course.get("title", "?"), e) + stats["read_failed"] += 1 + continue + if getattr(tc, "last_read_failed", False): + stats["read_failed"] += 1 + logger.warning("读取《{}》教学任务失败,本次不判定为完成", course.get("title", "?")) + print(f" ✗ {course.get('title', '?')}:任务中心状态读取失败,无法判断是否完成") + continue + if not tasks: + stats["empty"] += 1 + print(f" {course.get('title', '?')}:没有找到教学任务(可能还没发布)") + continue + + stats["courses"] += 1 + pending_all = [t for t in tasks if not _teaching_task_finished(t)] + limit = max_tasks_map.get(str(course.get("courseId")), max_tasks_default) + pending = pending_all[:limit] if limit and limit > 0 else pending_all + print() + print( + " " + course.get("title", "?") + ":任务中心共 " + + str(len(tasks)) + " 个教学任务" + + (f",待完成 {len(pending_all)} 个" if pending_all else ",已全部完成") + ) + if limit and limit > 0 and len(pending_all) > len(pending): + stats["limited"] += len(pending_all) - len(pending) + print(f" 本次按设置只刷前 {limit} 个待完成教学任务,其余下次继续") + logger.debug("任务中心《{}》:{} 个教学任务,待完成 {} 个,本次处理 {} 个", + course.get("title", "?"), len(tasks), len(pending_all), len(pending)) + if not pending: + continue + + point_map = _load_course_point_map(chaoxing, course) + for task in pending: + if interrupt.should_stop(): + break + stats["tasks"] += 1 + try: + ok, unsupported = _process_teaching_task( + tc, chaoxing, course, task, config, point_map, + only_discussion=only_discussion, stats=stats, + skip_discussion=skip_discussion, + ) + except Exception as e: + logger.error("处理教学任务出错: {} - {}: {}", task.get("name", "?"), + type(e).__name__, e) + logger.debug(traceback.format_exc()) + ok, unsupported = False, set() + _record_task_outcome(tc, stats, ok, unsupported) + + return stats + + +def _board_result_text(result: Optional[dict]) -> str: + """讨论区结果一句话(失败/一条没发时绝不写"已发送").""" + result = result or {} + sent = int(result.get("sent") or 0) + skipped = int(result.get("skipped") or 0) + if sent: + return f"讨论区:发送 {sent} 条 · 跳过 {skipped} 条" + if skipped: + return f"讨论区:本次没有发送任何回复(跳过 {skipped} 条)" + reason = str(result.get("reason") or "没有可发送的内容") + return f"讨论区:本次没有发送任何回复({reason})" + + +def _print_board_result(result: Optional[dict]) -> None: + """控制台汇报:发送了就说发送,没发送就说没发送.""" + result = result or {} + sent = int(result.get("sent") or 0) + if sent: + print(" ✔ " + _board_result_text(result)) + else: + print(" ⚠ " + _board_result_text(result)) + + +def _run_discussion_board(chaoxing: Chaoxing, config: dict, courses: list) -> dict: + """讨论区模式(discussion_mode=board):列帖子 → 自己挑 → 草稿 → 确认 → 逐条发送.""" + # + # 返回 discuss_cli 的结果字典,调用方据此汇报——一条都没发时绝不能说"已发送"。 + from api import discussion + try: + return discussion.discuss_cli(chaoxing, None, config, courses=courses) + except Exception as e: + logger.warning("讨论区模式出错: {}: {}", type(e).__name__, e) + logger.debug(traceback.format_exc()) + print(f" ⚠ 讨论区模式出错(不影响已完成的刷课):{e}") + return {"ok": False, "sent": 0, "skipped": 0, "reason": f"{type(e).__name__}: {e}"} + + +def _print_review_hint(): + """刷完后提示可以复核 AI 生成的文字(有留痕才提示,保持界面干净).""" + try: + from api import review + count = review.count_today() + if count: + print(f" AI 写的 {count} 条内容已经记下来 · 运行 ./cx review 可以查看和复核") + except Exception: + pass + + +def _start_interrupt(hint_shown: bool) -> bool: + """启动 q 键监听;提示语整次运行只打一遍,避免每个阶段重复刷屏.""" + if not hint_shown: + interrupt.print_hint() + interrupt.start_watcher() + return True + + +def _run_task_center_quiet(chaoxing: Chaoxing, course_task: list, config: dict, + max_tasks=None, only_discussion: bool = False, + skip_discussion: bool = False) -> dict: + """任务中心阶段包一层控制台静音.""" + # + # 这一段的内部日志(任务点读取、逐页解析、题库明细)只写日志文件, + # 控制台只保留用户能看懂的 print 结果行和 WARNING 以上。 + set_console_quiet(True) + try: + return run_task_center_phase(chaoxing, course_task, config, max_tasks, + only_discussion=only_discussion, + skip_discussion=skip_discussion) + finally: + set_console_quiet(False) + + +def _print_task_center_summary(stats: dict): + """任务中心处理结果:一条一条列,超过 76 列自动折行(别撑爆终端).""" + if not stats or (not stats.get("courses") and not stats.get("read_failed") + and not stats.get("empty")): + return + if stats.get("empty") and not stats.get("done") and not stats.get("failed"): + print(" 任务中心:没有找到教学任务(这门课可能还没发布,或都在未解锁的分组里)") + return + parts = [f"教学任务完成 {stats.get('done', 0)} 个"] + if stats.get("failed"): + item = f"未完成 {stats['failed']} 个" + if stats.get("unsupported"): + item += f"(其中暂不支持 {stats['unsupported']} 个)" + parts.append(item) + if stats.get("waiting_confirmation"): + parts.append(f"等待确认 {stats['waiting_confirmation']} 个") + if stats.get("locked"): + parts.append(f"未解锁 {stats['locked']} 个") + if stats.get("read_failed"): + parts.append(f"读取失败 {stats['read_failed']} 门课") + if stats.get("limited"): + parts.append(f"按设置跳过 {stats['limited']} 个(下次继续)") + if stats.get("skipped_other"): + if stats.get("only_discussion"): + parts.append(f"只刷讨论:跳过其它类型 {stats['skipped_other']} 个") + else: + parts.append(f"讨论走讨论区模式:跳过主题讨论 {stats['skipped_other']} 个") + text = " 任务中心:" + " · ".join(parts) + import textwrap + for line in textwrap.wrap(text, width=76, subsequent_indent=" ") or [text]: + print(line) + + +def configure_console(): + """Keep Chinese CLI output usable with Windows redirected/frozen streams.""" + if sys.platform == "win32": + for stream in (sys.stdout, sys.stderr): + if stream is not None and hasattr(stream, "reconfigure"): + stream.reconfigure(encoding="utf-8", errors="replace") + + def main(): + configure_console() """主程序入口""" + # cx discuss / cx topics 需要登录:没显式给 -c 时用最近使用的账号配置 + if ("--discuss" in sys.argv[1:] or "--list-topics" in sys.argv[1:]) \ + and not any(a in sys.argv[1:] for a in ("-c", "--config")): + from api import accounts + latest = accounts.latest_run_config() + if latest: + sys.argv.extend(["-c", latest]) + + # cx review:翻阅 AI 生成过的文字,不进入刷课流程 + if "--review" in sys.argv[1:]: + from api import review + return review.review_cli([a for a in sys.argv[1:] if a != "--review"]) + + _old_format_sizeof = None # tqdm 全局格式补丁的恢复兜底(见 finally) + hint_shown = False # q 键提示整次运行只打一遍 try: # 初始化配置 - common_config, tiku_config, notification_config, config_path = init_config() + common_config, tiku_config, notification_config, config_path, args = init_config() # 强制播放按照配置文件调节 common_config["speed"] = min(2.0, max(1.0, common_config.get("speed", 1.0))) common_config["notopen_action"] = common_config.get("notopen_action", "retry") - + # 初始化增加章节学习次数配置 add_learning_count = str_to_bool(common_config.get("add_learning_count", False)) target_count = int(common_config.get("target_count", 100)) - + + # 刷课范围:章节(目录)和任务中心可以各自关闭,但不能两个都关 + chapters_enabled = _chapter_study_enabled(common_config, args) + # 只刷讨论(任务中心里的主题讨论,planType=14):默认关闭,可在向导里选第 4 项 + only_discussion = bool(getattr(args, "only_discussion", False)) or str( + common_config.get("only_discussion", "") or "" + ).strip().lower() in ("1", "true", "yes", "on") + task_center_enabled = _task_center_enabled(common_config, args) + if only_discussion: + chapters_enabled = False + # 只刷讨论走的是任务中心那条链路:这里强制打开,避免"两个都关"被启动检查拦下 + common_config["task_center"] = "true" + task_center_enabled = True + # 讨论的两种刷法只在任务中心范围内有效;纯章节轮必须是 none。 + discussion_mode = _discussion_mode_for_run( + common_config, task_center_enabled, only_discussion + ) + board_mode = discussion_mode == "board" + # 讨论走讨论区模式时,任务中心里不再自动刷主题讨论(改由讨论区流程处理) + skip_discussion = board_mode + if only_discussion: + print(" 本次只刷讨论(" + ("讨论区挑帖" if board_mode else "任务里的主题讨论") + ")") + if not chapters_enabled and not task_center_enabled: + hard_stop( + "章节和任务中心都被关掉了,没有可以刷的内容", + " 当前配置:chapter_study = false、task_center = false", + " 运行 cx 重新选择刷什么,或至少加一个开关:--chapters / --task-center", + ) + + # ===== 启动前人工确认门禁 ===== + # 配置缺失/将要降级运行时,必须人工确认;用户不确认就停止,绝不静默降级 + check_before_run(common_config, tiku_config, notification_config, config_path, + skip_confirm=getattr(args, "yes", False)) + + # 每门课最多刷几个任务点(0 或空 = 全部) + # 支持两种格式: + # max_points_per_course = 3 全部课程都刷 3 个 + # max_points_per_course = 2151141:3,189191:0 按课程分别指定(0=全部) + # 一个都认不出来时必须停在原地提醒,绝不能默默退化成"全部刷完"。 + _raw_points = common_config.get("max_points_per_course") + max_points_map, max_points_default, _bad_points = _parse_max_points(_raw_points) + if _bad_points: + hard_stop( + "要刷的任务点数量填错了,无法识别", + f" 当前填写:{_raw_points}\n" + f" 认不出的部分:{'、'.join(_bad_points)}\n" + " 正确写法:3 → 每门课刷 3 个任务点\n" + " 2151141:3,189191:0 → 指定课程刷 3 个,189191 刷完全部", + " 运行 cx 重新选择要刷的任务点数量,或直接修改配置文件", + ) + + # 每门课最多刷几个教学任务(任务中心,0 = 全部) + # 语法与 max_points_per_course 相同,同样不能把写错的当成"全部"。 + _raw_tasks = common_config.get("max_tasks_per_course") + max_tasks_map, max_tasks_default, _bad_tasks = _parse_max_points(_raw_tasks) + if _bad_tasks: + hard_stop( + "任务中心要刷的教学任务数量填错了,无法识别", + f" 当前填写:{_raw_tasks}\n" + f" 认不出的部分:{'、'.join(_bad_tasks)}\n" + " 正确写法:3 → 每门课刷 3 个教学任务\n" + " 2151141:3,189191:0 → 指定课程刷 3 个,189191 刷完全部", + " 运行 cx 重新选择要刷的教学任务数量,或直接修改配置文件", + ) + # 初始化超星实例 chaoxing = init_chaoxing(common_config, tiku_config, config_path=config_path) @@ -570,66 +1586,394 @@ def main(): notification = notification.get_notification_from_config() notification.init_notification() - # 检查当前登录状态 - _login_state = chaoxing.login(login_with_cookies=common_config.get("use_cookies", False)) + # 检查当前登录状态(网络抖动自动重试,不再一次就整轮崩) + _login_state = with_network_retry( + chaoxing.login, + login_with_cookies=common_config.get("use_cookies", False), + what="登录", + ) if not _login_state["status"]: raise LoginError(_login_state["msg"]) # 获取所有的课程列表 - all_course = chaoxing.get_course_list() + all_course = with_network_retry(chaoxing.get_course_list, what="读取课程列表") # 过滤要学习的课程 course_task = filter_courses(all_course, common_config.get("course_list")) + # cx discuss / cx topics:讨论区浏览 + 挑帖子回复(模式 2),不进刷课流程 + if getattr(args, "discuss", False) or getattr(args, "list_topics", False): + from api import discussion + result = discussion.discuss_cli( + chaoxing, None, common_config, + list_only=bool(getattr(args, "list_topics", False)), + course_id=getattr(args, "course_id", None), + courses=all_course or course_task, + ) + return 0 if result.get("ok") else 1 + # 开始学习 - logger.info(f"课程列表过滤完毕, 当前课程任务数量: {len(course_task)}") + logger.trace(f"课程列表过滤完毕, 当前课程任务数量: {len(course_task)}") _old_format_sizeof = tqdm.format_sizeof tqdm.format_sizeof = format_time + # 任务点数量已在启动检查时解析并校验(见上面的 max_points_map / max_points_default) tasks = [] - for course in course_task: - logger.info(f"正在读取课程章节: {course['title']}") - point_list = chaoxing.get_course_point( - course["courseId"], course["clazzId"], course["cpi"] + # 一个章节都没读到的课程:不能当成"已经刷完",否则解析出问题时会误报"无需刷课" + unreadable_courses = [] + scan_rows = [] # 开始前扫描:章节侧数据(复用这里已读到的章节) + if not chapters_enabled: + logger.info("chapter_study=false:跳过章节(目录)") + if only_discussion: + print(" 只刷讨论:跳过章节(目录)") + else: + print(" 已选择只刷任务中心:跳过章节(目录)") + print() + # 只刷任务中心时连章节列表都不用读,省掉一次请求,也不会误报"读不到章节" + for course in (course_task if chapters_enabled else []): + logger.trace(f"正在读取课程章节: {course['title']}") + point_list = with_network_retry( + chaoxing.get_course_point, + course["courseId"], course["clazzId"], course["cpi"], + what=f"读取《{course['title']}》的章节", ) - for i, point in enumerate(point_list["points"]): + all_points = point_list.get("points") or [] + + if not all_points: + unreadable_courses.append(course["title"]) + scan_rows.append(scan.chapter_row(course, [], error="读不到章节")) + logger.error("课程[{}] 没有读到任何章节", course["title"]) + print(" ⚠ " + course["title"] + ":没有读到任何章节(可能是页面结构变化或网络异常)") + continue + + # 已经刷完的章节不再排进任务队列:整段跳过,只给一行汇总说明 + cid = str(course["courseId"]) + max_points = max_points_map.get(cid, max_points_default) + finished, pending, selected = select_points_for_course(all_points, max_points) + + logger.debug( + "课程[{}] 共 {} 节, 已完成 {} 节, 待刷 {} 节, 本次刷 {} 节", + course["title"], len(all_points), len(finished), len(pending), len(selected) + ) + print(" " + course["title"] + ":" + course_plan_summary(finished, pending, len(selected))) + scan_rows.append(scan.chapter_row(course, all_points)) + + for i, point in enumerate(selected): task = ChapterTask(point=point, index=i, course=course) tasks.append(task) + # ---- 开始前扫描(默认开启、无需勾选):把漏刷的东西一次说清楚 ---- + try: + print() + report = scan.run( + chaoxing, course_task, common_config, scan_rows, + chapters_enabled, _task_center_enabled(common_config, args), + only_discussion=only_discussion, discussion_mode=discussion_mode, + ) + if report: + print(report) + print() + except Exception as e: + logger.debug("开始前扫描失败(不影响刷课): {}", e) + + # 所有课程都已经刷完:不用再走后面的刷课流程,也不用让用户白等 + if not tasks: + tqdm.format_sizeof = _old_format_sizeof + print() + if unreadable_courses: + # 读不到章节 ≠ 刷完了。宁可报错让人来看,也不能骗用户说"已全部完成" + print(" ✘ 有课程没能读到章节,无法判断是否已刷完:" + "、".join(unreadable_courses)) + print(" 可能是平台页面结构变化或网络异常,请稍后重试;如果一直这样请反馈。") + print() + try: + notification.send( + "超星刷课:读取失败\n以下课程没有读到章节:" + "、".join(unreadable_courses) + ) + except Exception: + pass + sys.exit(4) + # 章节刷完了不代表任务中心刷完了:教学任务是独立的一套学习入口 + tc_stats = {"courses": 0, "done": 0, "failed": 0, "unsupported": 0, + "waiting_confirmation": 0, "locked": 0, "read_failed": 0} + board_result = None + if _task_center_enabled(common_config, args) and not (only_discussion and board_mode): + hint_shown = _start_interrupt(hint_shown) + print() + if chapters_enabled: + print(" 章节已全部完成,继续检查任务中心的教学任务…") + elif only_discussion and board_mode: + print(" 下面进入讨论区(自己挑帖子回复)…") + elif only_discussion: + print(" 继续检查任务里的主题讨论…") + else: + print(" 继续检查任务中心的教学任务…") + try: + tc_stats = _run_task_center_quiet( + chaoxing, course_task, common_config, + (max_tasks_map, max_tasks_default), + only_discussion=only_discussion, + skip_discussion=skip_discussion, + ) + _print_task_center_summary(tc_stats) + except Exception as e: + # 与主流程一致:任务中心整段软着陆,章节记录已经落库 + logger.error("任务中心处理出错: {}: {}", type(e).__name__, e) + logger.debug(traceback.format_exc()) + print(f" ⚠ 任务中心处理出错(章节不受影响):{type(e).__name__}: {e}") + tc_stats["read_failed"] = tc_stats.get("read_failed", 0) + 1 + if board_mode and not interrupt.should_stop(): + board_result = _run_discussion_board(chaoxing, common_config, + course_task or all_course) + if interrupt.should_stop(): + # 在任务中心阶段被终止:绝不能走到下面的"全部完成"分支 + print() + print(" 已终止刷课。已完成的任务点会保留,下次运行会自动跳过。") + try: + notification.send("超星刷课:已手动终止\n任务中心未全部完成,下次运行会接着刷") + except Exception: + pass + return + _print_review_hint() + if board_mode: + _print_board_result(board_result) + elif tc_stats["failed"] or tc_stats.get("read_failed"): + if chapters_enabled: + print(" ✔ 章节任务点已完成;任务中心仍有未完成教学任务") + else: + print(" ✔ 任务中心仍有未完成教学任务") + elif tc_stats.get("empty") and not tc_stats.get("done"): + print(" · 没有找到教学任务(这门课可能还没发布,或都在未解锁的分组里)") + elif chapters_enabled: + print(" ✔ 所有课程的任务点都已刷完,没有需要重刷的内容") + else: + print(" ✔ 任务中心的教学任务都已刷完") + print() + try: + if tc_stats["failed"] or tc_stats.get("read_failed"): + notification.send( + "超星刷课:任务中心有未完成\n" + f"教学任务未完成:{tc_stats['failed']} 个,读取失败:{tc_stats.get('read_failed', 0)} 门课" + f"(含暂不支持类型 {tc_stats['unsupported']} 个)" + ) + elif chapters_enabled: + notification.send("超星刷课:无需刷课\n所有课程的任务点都已刷完") + else: + notification.send("超星刷课:无需刷课\n任务中心的教学任务都已刷完") + except Exception: + pass + return + + # 刷课开始:提示如何退出,并启动键盘监听(按 q 立即终止) + hint_shown = _start_interrupt(hint_shown) + + # 记录开始时间 + 通知开始 + run_started_at = time.time() + total_points = len(tasks) + course_names = "、".join(c["title"] for c in course_task) + log_file_only(f"开始刷课:{len(course_task)} 门课,共 {total_points} 个任务点", "INFO") + notification.send( + "超星刷课:已开始\n" + f"课程({len(course_task)} 门):{course_names}\n" + f"任务点:{total_points} 个" + ) + + # 打开控制台静音:刷课期间只显示 WARNING 及以上 + 进度行, + # 避免 TRACE/DEBUG 刷屏(日志文件仍然记录全量) + set_console_quiet(True) + print() + print(f" 开始刷课 · {len(course_task)} 门课 · 章节任务点 {total_points} 个") + print(" ✓ 完成 · ⤼ 跳过 · ✗ 失败") + print(" " + "─" * 46) + print() + + progress = ChapterProgress(total_points) + # 全局并发执行所有课程的任务点 - p = JobProcessor(chaoxing, tasks, common_config) - p.run() + # 用 try/finally 保证无论成功、中断还是异常,控制台都会恢复非静音 + try: + p = JobProcessor(chaoxing, tasks, common_config, progress=progress) + p.run() + finally: + progress.summary() + set_console_quiet(False) + + if interrupt.should_stop(): + logger.warning("刷课已被用户终止") + print() + print(" 已终止刷课。已完成的任务点会保留,下次运行会自动跳过。") + print() + used = int(time.time() - run_started_at) + try: + notification.send( + "超星刷课:已手动终止\n" + f"课程({len(course_task)} 门):{course_names}\n" + f"任务点:{total_points} 个(未刷完)\n" + f"已运行:{used // 60} 分 {used % 60} 秒" + ) + except Exception: + pass + return tqdm.format_sizeof = _old_format_sizeof - logger.info("所有课程学习任务已完成") - notification.send("chaoxing : 所有课程学习任务已完成") + # 任务中心:教学任务和章节是两套独立入口,章节跑完后再单独跑一遍 + tc_stats = { + "courses": 0, "done": 0, "failed": 0, "unsupported": 0, + "waiting_confirmation": 0, "locked": 0, "read_failed": 0, + } + if _task_center_enabled(common_config, args): + logger.info("章节处理完毕,开始处理任务中心的教学任务...") + try: + tc_stats = _run_task_center_quiet( + chaoxing, course_task, common_config, + (max_tasks_map, max_tasks_default), + only_discussion=only_discussion, + skip_discussion=skip_discussion, + ) + _print_task_center_summary(tc_stats) + except Exception as e: + # 任务中心整段软着陆:章节记录已经落库,不能因为这里的意外异常 + # 把后面的统计、学习次数都跳过(更不该让整次运行看起来崩了)。 + logger.error("任务中心处理出错: {}: {}", type(e).__name__, e) + logger.debug(traceback.format_exc()) + print(f" ⚠ 任务中心处理出错(章节不受影响):{type(e).__name__}: {e}") + tc_stats["read_failed"] = tc_stats.get("read_failed", 0) + 1 + + if board_mode and not interrupt.should_stop(): + board_result = _run_discussion_board(chaoxing, common_config, + course_task or all_course) + + _print_review_hint() + + if interrupt.should_stop(): + # 终止发生在任务中心阶段:不能报"全部完成"(铁律 1) + print() + print(" 已终止刷课。已完成的任务点会保留,下次运行会自动跳过。") + try: + notification.send("超星刷课:已手动终止\n已完成的任务点会保留,下次运行会自动跳过") + except Exception: + pass + return + + used = int(time.time() - run_started_at) + used_text = (f"{used // 60} 分 {used % 60} 秒" if used >= 60 else f"{used} 秒") + + # 有任务点没刷成功就不能说"全部完成":否则用户以为已经刷完, + # 实际上还差几节(#618)。这里按实际失败数量分开报。 + failed_points = getattr(progress, "failed", 0) or 0 + if failed_points or unreadable_courses or tc_stats["failed"] or tc_stats.get("read_failed"): + # 一行汇总:细节在日志和通知里,控制台不刷屏 + parts = [] + if failed_points: + parts.append(f"章节失败 {failed_points} 个") + if unreadable_courses: + parts.append(f"读不到章节 {len(unreadable_courses)} 门") + if tc_stats["failed"]: + detail = [] + if tc_stats["unsupported"]: + detail.append(f"暂不支持 {tc_stats['unsupported']}") + if tc_stats.get("waiting_confirmation"): + detail.append(f"等待确认 {tc_stats['waiting_confirmation']}") + if tc_stats.get("locked"): + detail.append(f"未解锁 {tc_stats['locked']}") + parts.append( + "教学任务未完成 " + str(tc_stats["failed"]) + + ("(" + "、".join(detail) + ")" if detail else "") + ) + if tc_stats.get("read_failed"): + parts.append(f"任务中心读取失败 {tc_stats['read_failed']} 门") + summary_line = " · ".join(parts) + logger.warning("本次未全部完成:" + summary_line) + print() + print(" ⚠ 本次没全部完成:" + summary_line + "(下次运行会自动继续)") + print(flush=True) + unreadable_text = ("\n读不到章节的课程:" + "、".join(unreadable_courses)) if unreadable_courses else "" + tc_text = "" + if tc_stats["failed"]: + tc_text = f"\n任务中心:教学任务未完成 {tc_stats['failed']} 个" + if tc_stats["unsupported"]: + tc_text += f"(含暂不支持类型 {tc_stats['unsupported']} 个)" + if tc_stats.get("waiting_confirmation"): + tc_text += f"(等待确认 {tc_stats['waiting_confirmation']} 个)" + if tc_stats.get("read_failed"): + tc_text += f"\n任务中心:课程状态读取失败 {tc_stats['read_failed']} 门" + notification.send( + "超星刷课:部分完成(有失败)\n" + f"课程({len(course_task)} 门):{course_names}\n" + f"任务点:成功 {max(0, total_points - failed_points)} 个 · 失败 {failed_points} 个\n" + f"耗时:{used_text}" + f"{unreadable_text}" + f"{tc_text}" + ) + else: + logger.info("所有课程学习任务已完成") + tc_text = f"\n任务中心:教学任务完成 {tc_stats['done']} 个" if tc_stats["done"] else "" + board_text = ("\n" + _board_result_text(board_result)) if board_mode else "" + if board_mode: + _print_board_result(board_result) + notification.send( + "超星刷课:全部完成\n" + f"课程({len(course_task)} 门):{course_names}\n" + f"任务点:{total_points} 个\n" + f"耗时:{used_text}" + f"{tc_text}" + f"{board_text}" + ) # 刷课完成后,如果开启了增加章节学习次数,则执行 - if add_learning_count: + # (只刷任务中心时跳过:这是章节功能,没有章节可刷) + if add_learning_count and chapters_enabled: logger.info("刷课完成,开始增加章节学习次数...") common_config["target_count"] = target_count for course in course_task: increase_learning_count_for_course(chaoxing, course, common_config) logger.info("所有课程章节学习次数增加完成") - notification.send("chaoxing : 所有课程章节学习次数增加完成") - + notification.send("超星刷课:章节学习次数已刷完") + + except UserAbort as e: + # 用户未确认/选择停止:不是程序错误,但用非 0 退出码,方便脚本判断"没跑成" + logger.warning(f"已停止: {e}") + sys.exit(3) except SystemExit as e: if e.code != 0: logger.error(f"错误: 程序异常退出, 返回码: {e.code}") sys.exit(e.code) except KeyboardInterrupt as e: logger.error(f"错误: 程序被用户手动中断, {e}") + except (LoginError, InputFormatError, NetworkRetryFailed) as e: + # 登录失败 / 网络不稳 / 输入格式错,都是用户自己处理一下就能解决的问题。 + # 只给一行清晰提示 + 处理办法,不打印一堆 traceback 吓人。 + log_file_only(str(e)) + print() + print(" ✘ " + redact(e)) + if isinstance(e, NetworkRetryFailed): + print(" 网络不太稳定,请检查网络 / 代理后重试。") + else: + print(" 请检查手机号 / 密码是否正确,或运行 cx setup 重新配置。") + print(flush=True) + try: + notification.send(f"超星刷课:启动失败\n{e}") + except Exception: + pass + sys.exit(2) except BaseException as e: logger.error(f"错误: {type(e).__name__}: {e}") logger.error(traceback.format_exc()) try: - notification.send(f"chaoxing : 出现错误 {type(e).__name__}: {e}\n{traceback.format_exc()}") + notification.send( + f"超星刷课:出现错误\n" + f"{type(e).__name__}: {e}" + ) except Exception: pass # 如果通知发送失败,忽略异常 - raise e + raise RuntimeError(redact(f"{type(e).__name__}: {e}")) from None + finally: + # 兜底恢复 tqdm 全局格式:中途 return / sys.exit / 异常都不能把它留在补丁状态 + if _old_format_sizeof is not None: + tqdm.format_sizeof = _old_format_sizeof if __name__ == "__main__": + safe_console() main() diff --git a/pyproject.toml b/pyproject.toml index ad5c9e322..bf1ff16af 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,14 +1,26 @@ +[build-system] +requires = ["setuptools>=68"] +build-backend = "setuptools.build_meta" + [project] name = "chaoxing" version = "3.1.3" -description = "超星学习通/超星尔雅/泛雅超星全自动无人值守完成任务点" +description = "Command-line automation for Chaoxing (Xuexitong / Fanya): chapters and the Task Center" readme = "README.md" license = { file = "LICENSE" } requires-python = ">=3.13,<4.0" dynamic = ["dependencies"] [tool.setuptools] -py-modules = [] +py-modules = ["main", "setup_wizard"] +packages = ["api"] + +[tool.setuptools.data-files] +"share/chaoxing" = ["config_template.ini", "resource/font_map_table.json"] + +[project.scripts] +chaoxing = "main:main" +chaoxing-setup = "setup_wizard:main" [tool.setuptools.dynamic] dependencies = {file=["requirements.txt"]} diff --git a/requirements.txt b/requirements.txt index 5d3926229..4e2c1f2cc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -2,15 +2,11 @@ requests>=2.32.5 pyaes>=1.6.1 beautifulsoup4>=4.14.2 lxml -argparse>=1.4.0 loguru>=0.7.3 -celery>=5.5.3 -flask>=3.1.2 fonttools>=4.60.1 openai>=1.109.1 tqdm>=4.67.1 httpx[socks]>=0.28.1 urllib3>=2.5.0 -chardet>=3.0.2,<6.0.0 ddddocr>=1.6.1 -tenacity>=8.2.0 \ No newline at end of file +tenacity>=8.2.0 diff --git a/setup_wizard.py b/setup_wizard.py new file mode 100644 index 000000000..e0a27f588 --- /dev/null +++ b/setup_wizard.py @@ -0,0 +1,1290 @@ +# -*- coding: utf-8 -*- +"""超星刷课 · 统一多用户入口.""" +# +# 启动流程: +# 1. 检查/配置 DeepSeek API Key(实时验证有效性) +# 2. 显示用户列表:选一个直接开始,或加入新账号,或管理账号 +# 3. 登录(用保存的账密,不用重输) +# 4. 选刷什么:章节(目录)/ 任务中心·教学任务(两套独立入口) +# 5. 选课(每次都手动选,不沿用上次) +# 6. 逐门课程设置本次范围:章节前几个 / 教学任务前几个(不刷的那类不问) +# 7. 开始刷课 +# +# 安全设计: +# 任何时候输入 q / quit / exit 都能立即退出,防止刷错课。 +# Ctrl+C 同样安全退出。 +# +# 每个用户的账号、cookie 都互相隔离,不会串号。 + +import configparser +import os +import sys + +BASE = os.path.dirname(os.path.abspath(__file__)) +sys.path.insert(0, BASE) + +from api import accounts, interrupt, paths +from api.configfile import read_config_file +from api.cxsecret_font import resource_path +from api.display import safe_console + +# 模板在项目目录;用户配置在数据目录(~/.chaoxing/config.ini), +# 这样升级代码不会影响用户的配置。 +TEMPLATE = resource_path("config_template.ini") +paths.init() # 确保数据目录存在,并完成一次旧数据迁移 +CONFIG = paths.config_path() + +DEEPSEEK_ENDPOINT = "https://api.deepseek.com/v1" +DEEPSEEK_MODEL = "deepseek-flash" + +# 视觉规范: +# title() 用一条细横线做小标题,只在关键节点使用 +# 正文缩进 2 空格;说明文字尽量一行说完,不堆叠空行 +# 输入提示保持在单行,避免每次都占两行 +RULE = "─" * 46 + +# 输入这些字符 = 立即退出 +QUIT_WORDS = {"q", "quit", "exit", "退出", "取消"} + + +class UserQuit(Exception): + """用户主动一键退出.""" + + +def quit_now(reason="用户主动退出"): + """统一的安全退出:清理后终止进程.""" + raise UserQuit(reason) + + +def _pad(text, width): + """按终端显示宽度右侧补空格(中文占 2 列).""" + try: + import unicodedata + cur = 0 + for ch in str(text): + cur += 2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 + except Exception: + cur = len(str(text)) + gap = width - cur + return str(text) + (" " * gap if gap > 0 else "") + + +def title(text): + """小标题:空行 + 标题 + 细横线.""" + print() + print(" " + text) + print(" " + RULE) + + +def ask_choice(prompt, valid, default="", max_tries=5): + """反复问,直到拿到合法选项.""" + # + # 非交互输入(管道/重定向)反复给不出合法值时按默认继续,绝不卡死—— + # 向导里任何一个选择题都不该让整个流程停在那里。 + options = " / ".join(sorted(valid)) + for _ in range(max_tries): + raw = ask(prompt, default=default or None) + if raw in valid: + return raw + print(" ✘ 只能填 " + options + "。") + fallback = default or sorted(valid)[0] + print(" · 没收到有效选择,按默认 " + fallback + " 继续") + return fallback + + +def _read_line(prompt, tip): + """读一行输入(提示和输入在同一行,省掉多余的空行).""" + # q/exit 立即退出,Ctrl+C 安全退出。 + try: + return input("▶ " + prompt + tip + " > ").strip() + except (EOFError, KeyboardInterrupt): + print() + print(" 已退出。") + raise UserQuit("cancelled") + + +def ask(prompt, default=None, allow_empty=False): + """读取必填项。留空会一直追问.""" + # 输入 q / quit / exit 立即退出。 + for _ in range(5): + if default is not None: + tip = " [回车=" + str(default) + ",q 退出]" + elif allow_empty: + tip = " [回车跳过,q 退出]" + else: + tip = " (q 退出)" + val = _read_line(prompt, tip) + + if val.lower() in QUIT_WORDS: + print() + print(" 已退出,不会执行任何刷课操作。") + raise UserQuit("user quit") + + if val: + return val + if default is not None: + return str(default) + if allow_empty: + return "" + print(" ✘ 这一项不能为空。") + print() + print(" · 连续多次没有收到有效输入,已退出向导(重新运行 cx 即可)。") + sys.exit(1) + + +def ask_yes_no(prompt, default_no=True): + # 把默认值写进提示:回车 = 默认(危险动作默认不继续) + tip = " [y/n · 回车=" + ("否" if default_no else "是") + " · q 退出]" + ans = _read_line(prompt, tip).lower() + + if ans in QUIT_WORDS: + print() + print(" 已退出,不会执行任何刷课操作。") + raise UserQuit("user quit") + + if not ans: + return not default_no + return ans in ("y", "yes", "是", "1") + + +def replace_value(content, section, key, value): + """在 ini 文本里替换 key=value,保留注释.""" + out = [] + cur = None + done = False + for line in content.splitlines(): + stripped = line.strip() + if stripped.startswith("[") and stripped.endswith("]"): + cur = stripped[1:-1] + if cur == section and not done: + core = stripped.split(";")[0].strip() + if "=" in core and core.split("=")[0].strip() == key: + out.append(key + " = " + value) + done = True + continue + out.append(line) + if done: + return chr(10).join(out) + res = [] + inserted = False + cur = None + for line in out: + stripped = line.strip() + if stripped.startswith("[") and stripped.endswith("]"): + if cur == section and not inserted: + res.append(key + " = " + value) + inserted = True + cur = stripped[1:-1] + res.append(line) + if cur == section and not inserted: + res.append(key + " = " + value) + inserted = True + + # 整个文件里都没有这个节 -> 直接追加一个新节 + if not inserted: + res.append("") + res.append("[" + section + "]") + res.append(key + " = " + value) + return chr(10).join(res) + + +# ==================== DeepSeek API Key ==================== + +def short_err(err, limit=60): + """把冗长的 API 报错压缩成一句人话.""" + # 例如:Error code: 401 - {'error': {'message': 'Authentication Fails...'}} + # -> 认证失败:API Key 无效 + text = str(err) + try: + import re as _re + # 兼容单引号和双引号的 message 字段 + m = _re.search(r"['\"]message['\"]\s*:\s*['\"]([^'\"]+)['\"]", text) + if m: + text = m.group(1) + except (TypeError, ValueError): + text = str(err) + + # 用【原始】报错判断类型(精简后的文本可能已经不含 401 等关键字) + low = str(err).lower() + if "401" in low or "authentication" in low or "invalid" in low or "unauthorized" in low: + return "API Key 无效或已失效" + if "402" in low or "insufficient" in low or "balance" in low or "quota" in low: + return "账户余额不足" + if "429" in low or "rate limit" in low: + return "请求过于频繁,请稍后再试" + if "timeout" in low or "timed out" in low: + return "连接超时,请检查网络" + if "connection" in low or "unreachable" in low: + return "网络连接失败" + + text = text.strip() + return text if len(text) <= limit else text[:limit - 1] + "…" + + +def verify_deepseek_key(api_key): + """联网验证 Key 是否真的可用.""" + try: + from openai import OpenAI + client = OpenAI(base_url=DEEPSEEK_ENDPOINT, api_key=api_key) + resp = client.chat.completions.create( + model=DEEPSEEK_MODEL, + messages=[{"role": "user", "content": "回复:ok"}], + max_tokens=10, + extra_body={"thinking": {"type": "disabled"}}, + ) + if resp.choices: + return True, "" + return False, "没有收到有效响应" + except Exception as e: + return False, str(e)[:200] + + +def read_config(): + """读取 config.ini(不存在则返回空;内容损坏时尽量沿用其余设置).""" + if not os.path.exists(CONFIG): + return configparser.ConfigParser() + cfg, broken = read_config_file(CONFIG) + if broken: + print(f" ⚠ 配置文件内容有损坏,已跳过异常行并尽量沿用其余设置:{CONFIG}") + return cfg + + +def _read_config_text(): + """读取 config.ini 原文(还没配置过就用模板),保留注释和排版.""" + path = CONFIG if os.path.exists(CONFIG) else TEMPLATE + if not os.path.exists(path): + raise UserQuit(f"找不到配置文件模板:{path}") + with open(path, encoding="utf8", errors="replace") as f: + return f.read() + + +def update_config(mapping): + """更新 config.ini 的若干项,保留注释.""" + # mapping: {(section, key): value} + # + # 写入前会自动备份,误覆盖也能恢复(见 ~/.chaoxing/backups/)。 + paths.backup_config() + + text = _read_config_text() + + for (section, key), value in mapping.items(): + text = replace_value(text, section, key, str(value)) + + with open(CONFIG, "w", encoding="utf8") as f: + f.write(text) + return CONFIG + + + + + +# 通知服务说明 +NOTIFY_SERVICES = { + "1": ("Bark", "https://api.day.app/你的key/", "iPhone 推送到 Bark App,最简单"), + "2": ("ServerChan", "https://sctapi.ftqq.com/你的key.send", "Server酱,微信推送"), + "3": ("Telegram", "https://api.telegram.org/bot/sendMessage", "需要额外填 chat_id"), + "4": ("Qmsg", "https://qmsg.zendee.cn/send/你的key", "QQ 推送"), +} + + +def setup_notification(existing=None): + """配置完成通知(可跳过);返回 (provider, url, tg_chat_id).""" + if existing is None: + existing = read_config() + + cur_provider = "" + cur_url = "" + cur_tg = "" + if existing.has_section("notification"): + cur_provider = (existing.get("notification", "provider", fallback="") or "").strip() + cur_url = (existing.get("notification", "url", fallback="") or "").strip() + cur_tg = (existing.get("notification", "tg_chat_id", fallback="") or "").strip() + + title("完成通知(可选)") + print(" 刷课开始 / 完成 / 被中断 / 出错时,推送到手机。") + if cur_provider and cur_url: + print(" 当前已配置:" + cur_provider) + print() + print(" 1. Bark iPhone,最简单") + print(" 2. Server酱 微信") + print(" 3. Telegram 需额外填 chat_id") + print(" 4. Qmsg酱 QQ") + print(" 0. 不用通知") + print() + + choice = ask("请选择", allow_empty=True) + if not choice or choice == "0": + return cur_provider, cur_url, cur_tg + + if choice not in NOTIFY_SERVICES: + print(" ✘ 没有这个选项,本次跳过。") + return cur_provider, cur_url, cur_tg + + provider, example, _desc = NOTIFY_SERVICES[choice] + print(" 格式参考:" + example) + url = ask("推送地址") + tg_chat_id = "" + if provider == "Telegram": + tg_chat_id = ask("chat_id") + + print(" 发送测试通知...") + ok, err = test_notification(provider, url, tg_chat_id) + if ok: + print(" ✔ 已发送,请检查手机是否收到") + else: + print(" ✘ 发送失败:" + err + "(可能是地址填错)") + if not ask_yes_no(" 仍然保存吗?", default_no=True): + return cur_provider, cur_url, cur_tg + + return provider, url, tg_chat_id + + +def test_notification(provider, url, tg_chat_id=""): + """发一条测试通知,返回 (是否成功, 错误信息).""" + try: + import requests + msg = "超星刷课:这是一条测试通知,收到说明配置成功。" + if provider == "Bark": + r = requests.post(url.rstrip("/") + "/" + requests.utils.quote(msg), timeout=10) + elif provider == "ServerChan": + r = requests.post(url, data={"title": "超星刷课", "desp": msg}, timeout=10) + elif provider == "Qmsg": + r = requests.post(url, data={"msg": msg}, timeout=10) + elif provider == "Telegram": + r = requests.post(url, data={"chat_id": tg_chat_id, "text": msg}, timeout=10) + else: + return False, "未知的通知服务" + if r.status_code == 200: + return True, "" + return False, "HTTP " + str(r.status_code) + " " + r.text[:120] + except Exception as e: + return False, str(e)[:150] + + +def ask_deepseek_key(existing_key=""): + """让用户填一个可用的 DeepSeek Key(会联网验证).""" + print(" 地址与模型已预设(" + DEEPSEEK_MODEL + "),只需粘贴 Key。") + print(" 获取:https://platform.deepseek.com/ → API Keys") + print() + + while True: + key = ask("DeepSeek API Key") + print(" 验证中...") + ok, err = verify_deepseek_key(key) + if ok: + print(" ✔ 验证通过") + return key + + # 验证失败:当场给出两条路,不必退出重走 setup + print(" ✘ " + short_err(err)) + print() + print(" 1. 重新粘贴 Key") + print(" 2. 不做测验,只刷视频 / 文档等部分") + print() + choice = ask("请选择") + if choice == "2": + return "" # 空字符串 = 用户放弃答题,转为降级模式 + # 选 1 或其它 -> 继续循环重新粘贴 + + +# 每种答题方式在 config 里必须存在的字段 +ANSWER_MODE_REQUIREMENTS = { + "AI": "key", + "SiliconFlow": "siliconflow_key", + "TikuYanxi": "tokens", + "TikuAdapter": "url", +} + +# 答题方式选项(顺序即展示顺序) +ANSWER_MODES = [ + ("1", "AI", "DeepSeek AI", "推荐 · 什么题都能答,无需额外购买", True), + ("2", "TikuYanxi", "言溪题库", "答案准 · 需 token(tk.enncy.cn)", False), + ("3", "TikuGo", "GO 题", "答案准 · 可选 authorization", False), + ("4", "TikuYanxi,AI", "言溪 + AI 兜底", "更准 · 需言溪 token", True), + ("5", "TikuGo,AI", "GO题 + AI 兜底", "更准 · 可选 authorization", True), + ("6", "TikuManual", "手动答题", "每题手动输入,最慢", False), + ("0", "", "不答题", "跳过测验 · 解锁章节会卡住", False), +] + + +def is_answer_mode_configured(cfg): + """答题方式是否已经配置过(且必要字段齐全).""" + # + # 两种判定,任一成立即视为已配置: + # 1. 有 [cx] answer_mode_done = yes 标记(新配置走这条路) + # 2. 没有标记,但 [tiku] 里的字段是齐全的(兼容旧配置) + # + # 这样升级后不会让用户重新填一遍。 + if not cfg.has_section("tiku"): + return False + + provider = (cfg.get("tiku", "provider", fallback="") or "").strip() + providers = [p.strip() for p in provider.split(",") if p.strip()] + + if providers: + # 检查每种答题方式需要的字段是否都有值 + for name in providers: + need = ANSWER_MODE_REQUIREMENTS.get(name) + if need and not (cfg.get("tiku", need, fallback="") or "").strip(): + return False + return True + + # provider 为空 = "不答题",这种需要显式标记才算配置过 + if not cfg.has_section("cx"): + return False + return (cfg.get("cx", "answer_mode_done", fallback="") or "").strip() == "yes" + + +def _configured_answer_mode(cfg): + """Return the existing provider configuration without prompting for secrets.""" + provider = (cfg.get("tiku", "provider", fallback="") or "").strip() + existing = {"provider": provider, "_ran": False} + cur_degraded = (cfg.get("cx", "quiz_degraded", fallback="") or "").strip() if cfg.has_section("cx") else "" + existing["_degraded"] = (cur_degraded == "yes") + for name in [p.strip() for p in provider.split(",") if p.strip()]: + need = ANSWER_MODE_REQUIREMENTS.get(name) + if need: + existing[need] = (cfg.get("tiku", need, fallback="") or "").strip() + label = "、".join( + m[2] for m in ANSWER_MODES + if m[1] == provider + ) or (provider or "不答题") + print(f" 答题方式:{label}(已配置,如需修改请运行 cx setup)") + return provider, existing + + +def setup_answer_mode(force=False): + """选择答题方式。返回 (provider字符串, 需要的配置字典).""" + # + # 已经配置过且字段齐全时,直接沿用,不再打扰用户。 + # 需要重新配置请用 cx setup(force=True)。 + cfg = read_config() + + # 已配置 -> 直接沿用(_ran=False 表示没有重新配置,不要覆盖已有标记) + if not force and is_answer_mode_configured(cfg): + return _configured_answer_mode(cfg) + + cur_key = cfg.get("tiku", "key", fallback="") if cfg.has_section("tiku") else "" + + title("选择答题方式") + print(" 章节测验要答对才能继续往下刷,选一种答题方式:") + print() + for num, _p, label, desc, _need_ai in ANSWER_MODES: + print(" " + num + ". " + _pad(label, 16) + desc) + print() + + while True: + choice = ask("请填序号") + hit = [m for m in ANSWER_MODES if m[0] == choice] + if hit: + break + print(" ✘ 没有这个序号,请重新填。") + + # 表结构是 (序号, provider, 名称, 说明, 是否需要 AI);顺序错会让题库模式也被追问 Key + _num, provider, label, _desc, need_ai = hit[0] + + result = {"provider": provider} + + # 不需要任何东西 + if not provider: + print() + print(" 已选择:不答题(章节测验会被跳过)") + return provider, result + + # 手动模式 + if provider == "TikuManual": + print() + print(" 已选择:手动答题(每条题目都会停下来让你输入答案)") + return provider, result + + # 需要 token 的题库 + if "TikuYanxi" in provider: + print() + print(" 言溪题库(别人整理好的答案库)需要 token,登录 https://tk.enncy.cn/ 获取") + print(" 有多个 token 可以用英文逗号分隔。") + print() + tokens = ask("言溪 token") + result["tokens"] = tokens + + if "TikuGo" in provider: + print() + print(" GO 题可不填 authorization 直接使用(可能限流)。") + print(" 如需解除限流,可在公众号「一之哥哥」申请后填入。") + print() + go_auth = ask("GO题 authorization(可留空)", allow_empty=True) + result["go_authorization"] = go_auth + + # 需要 AI 兜底 + if need_ai: + if cur_key: + print(" 检测到已保存的 Key,正在验证...") + ok, err = verify_deepseek_key(cur_key) + if ok: + print(" ✔ 已保存的 Key 有效,无需重新填写") + result["key"] = cur_key + else: + print(" ✘ 已保存的 Key 失效了:" + short_err(err)) + result["key"] = ask_deepseek_key() + else: + result["key"] = ask_deepseek_key() + + # 用户在填 Key 时选择了"不做测验" + if not result.get("key"): + tokens = result.get("tokens") or "" + go_auth = result.get("go_authorization") or "" + if tokens or go_auth: + # 已经填好题库了:只去掉 AI 兜底,不要把用户刚填的 token 丢掉 + plain = "TikuYanxi" if "TikuYanxi" in provider else "TikuGo" + print(" 已切换为「只用题库、不加 AI 兜底」:" + plain) + return plain, {"provider": plain, "tokens": tokens, + "go_authorization": go_auth} + print(" 已切换为「不做测验」模式。") + return "", {"provider": "", "degraded": True, "_ran": True} + + result["_ran"] = True + return provider, result + + +def _provider_needs_ai(provider): + """这个答题方式是否需要 DeepSeek.""" + names = [p.strip() for p in (provider or "").split(",") if p.strip()] + return any(n in ("AI", "SiliconFlow") for n in names) + + +def resolve_invalid_api_key(provider, current_key): + """API Key 失效时的处理:当场让用户重填,而不是把他踢出去重走 setup.""" + # + # 返回 (处理结果, 新key): + # ("fixed", 新key) -> 用户重新填了有效的 Key + # ("degraded", "") -> 用户确认:不做测验,只刷视频/文档 + # ("abort", "") -> 用户放弃 + while True: + title("DeepSeek API Key 无法使用") + print(" 可能原因:填错了、已失效、或账户余额不足。") + print(" 没有可用的 Key,章节测验就无法作答。") + print() + print(" 1. 重新填写 API Key") + print(" 2. 不做测验,只刷视频 / 文档等部分") + print() + + choice = ask("请选择") + + if choice == "1": + new_key = ask_deepseek_key() + if new_key: + return "fixed", new_key + # 用户在重填过程中选择了"不做测验" + return "degraded", "" + + if choice == "2": + print(" 确认:只刷「视频 / 文档 / 阅读」等部分,所有测验都会跳过。") + print(" 需要答题才能解锁的章节会卡住,刷不下去。") + if ask_yes_no(" 确认这样做吗?", default_no=True): + return "degraded", "" + continue + + return "abort", "" + + +def ensure_api_key(force=False): + """确保答题方式已配置好,并验证 Key 是否真的可用.""" + # + # 已配置时不再重复询问;但会验证 Key —— 失效时当场让用户重填, + # 或确认降级为"只刷非测验部分",不需要重走整个 setup。 + provider, conf = setup_answer_mode(force=force) + + degraded = False + + # ---- 验证 AI Key ---- + if conf.get("degraded"): + # setup_answer_mode 里已经确认过不做测验,不要再问 + degraded = True + provider = "" + conf = {"provider": ""} + elif _provider_needs_ai(provider): + key = (conf.get("key") or "").strip() + + if key: + # 已有保存的 Key -> 验证;失效时当场处理,不必重走 setup + print() + print(" 正在验证 API Key...") + while True: + ok, err = verify_deepseek_key(key) + if ok: + print(" ✔ 有效") + break + + print(" ✘ " + short_err(err)) + action, new_key = resolve_invalid_api_key(provider, key) + if action == "fixed": + key = new_key + continue + if action == "degraded": + degraded = True + provider = "" + conf = {"provider": ""} + print(" 已切换为「不做测验」模式。") + break + raise UserQuit("API Key 不可用,用户选择退出") + + # 【关键】把最终生效的 Key 写回 conf。 + # 之前漏了这一步:重填的新 Key 只存在局部变量里, + # 保存时用的还是 conf["key"](旧值),导致"校验通过但保存的是旧 Key"。 + if not degraded: + conf["key"] = key + else: + # 没有 Key -> 让用户填(ask_deepseek_key 内部已验证,不用重复验证) + key = ask_deepseek_key() + if not key: + degraded = True + provider = "" + conf = {"provider": ""} + print(" 已切换为「不做测验」模式。") + else: + conf["key"] = key + + mapping = { + ("tiku", "provider"): provider, + ("tiku", "endpoint"): DEEPSEEK_ENDPOINT, + ("tiku", "model"): DEEPSEEK_MODEL, + ("tiku", "submit"): "true", + ("tiku", "cover_rate"): "0.9", + } + if "key" in conf: + mapping[("tiku", "key")] = conf["key"] + if "tokens" in conf: + mapping[("tiku", "tokens")] = conf["tokens"] + if "go_authorization" in conf: + mapping[("tiku", "go_authorization")] = conf["go_authorization"] + + # 记下"答题方式已配置过",下次直接沿用 + mapping[("cx", "answer_mode_done")] = "yes" + + # 是否"已确认不做测验":只在真正走过配置流程时才更新, + # 否则普通启动会把上次的 yes 覆盖成 no(导致每次都被重新询问)。 + if conf.get("_ran", True): + mapping[("cx", "quiz_degraded")] = "yes" if degraded else "no" + + update_config(mapping) + return conf.get("key", "") + + +# ==================== 全局偏好 ==================== + +# 推荐刷课配置:不再逐项询问用户,直接用最稳的一套。 +# 有观看时长要求的视频在代码里会自动 1 倍速,所以这里的 2x 只影响"播完即可"的视频。 +RECOMMENDED_PREFS = { + "speed": "2", + "jobs": "2", + "notopen_action": "continue", + "work_max_retries": "3", + "add_learning_count": "false", + "target_count": "100", + "task_center_submit_mode": "auto", +} + + +def prefs_summary() -> str: + """一行显示本次生效的推荐配置(只在启动时显示一遍,不询问).""" + return ( + " 推荐配置:" + RECOMMENDED_PREFS["speed"] + " 倍速 · 同时刷 " + + RECOMMENDED_PREFS["jobs"] + " 个 · 未开放跳过 · 答错重做 " + + RECOMMENDED_PREFS["work_max_retries"] + " 次 · 自动提交" + ) + + +def ensure_global_prefs(force=False): + """全局设置:直接用推荐默认,不再逐项询问.""" + # + # 首次运行写入推荐配置;之后每次启动只显示一遍当前配置。 + # force=True(cx setup)同样不问刷课参数,只保留可选的通知配置。 + cfg = read_config() + done = cfg.get("cx", "prefs_done", fallback="") if cfg.has_section("cx") else "" + + if done == "yes" and not force: + # 一次性迁移(v2):并发从 4 降到 2——4 个任务并行更容易触发验证码/403 + version = cfg.get("cx", "prefs_version", fallback="1") if cfg.has_section("cx") else "1" + if version != "2": + if (cfg.get("common", "jobs", fallback="") or "").strip() == "4": + update_config({("common", "jobs"): RECOMMENDED_PREFS["jobs"]}) + print(" · 同时刷的任务数已从 4 调整为 2(更稳,能明显减少验证码)") + update_config({("cx", "prefs_version"): "2"}) + print(prefs_summary()) + return + + provider, url, tg = "", "", "" + if force or done != "yes": + # "完成通知"是可选项:第一次运行也问一次(直接回车=不用),之后不再打扰 + provider, url, tg = setup_notification(cfg) + + update_config({ + ("tiku", "check_llm_connection"): "true", + ("common", "speed"): RECOMMENDED_PREFS["speed"], + ("common", "jobs"): RECOMMENDED_PREFS["jobs"], + ("common", "notopen_action"): RECOMMENDED_PREFS["notopen_action"], + ("common", "work_max_retries"): RECOMMENDED_PREFS["work_max_retries"], + ("common", "add_learning_count"): RECOMMENDED_PREFS["add_learning_count"], + ("common", "target_count"): RECOMMENDED_PREFS["target_count"], + ("common", "task_center_submit_mode"): RECOMMENDED_PREFS["task_center_submit_mode"], + ("cx", "prefs_done"): "yes", + ("cx", "prefs_version"): "2", + ("notification", "provider"): provider or "", + ("notification", "url"): url or "", + ("notification", "tg_chat_id"): tg or "XXXXXX", + }) + + title("全局设置已保存(推荐配置)") + print(prefs_summary()) + print() + + +# ==================== 登录 ==================== + +def do_login(username, password): + """登录;返回 (chaoxing实例, 昵称) 或 (None, 错误信息).""" + print() + print(" 正在登录 " + username + "...") + try: + from api.base import Chaoxing, Account + from api import cookies + cookies.set_current_account(username) + account = Account(username, password) + cx = Chaoxing(account=account) + result = cx.login(login_with_cookies=False) + except Exception as e: + return None, str(e)[:150] + + if not result.get("status"): + return None, str(result.get("msg", "未知原因")) + + name = "" + try: + name = cx.get_name() + except Exception as exc: + from api.logger import logger + logger.debug("账号昵称读取失败({})", type(exc).__name__) + return cx, name + + +def add_new_account(): + """加入新账号:登录成功后保存.""" + title("加入新账号") + print(" 输入手机号和密码,登录成功后自动保存,下次可直接选用。") + print() + + while True: + username = ask("手机号") + password = ask("密码") + cx, name = do_login(username, password) + if cx: + print(" ✔ 登录成功" + (",欢迎 " + name if name else "")) + accounts.save_account(username, password, name) + print(" ✔ 已保存,下次可直接选用") + return username, password, cx, name + print(" ✘ 登录失败:" + name) + print() + if not ask_yes_no(" 重新输入吗?", default_no=False): + sys.exit(1) + + +def use_existing(acc): + """用已保存的账号登录(不重输密码,除非失败).""" + label = acc.get("name") or acc["username"] + title("登录 " + label) + print(" 账号:" + acc["username"] + "(已保存密码,无需重输)") + + username = acc["username"] + password = acc["password"] + + while True: + cx, name = do_login(username, password) + if cx: + print(" ✔ 登录成功" + (",欢迎 " + name if name else "")) + accounts.save_account(username, password, name or acc.get("name", "")) + return username, password, cx, name + print(" ✘ 登录失败:" + name) + print(" 可能是密码改了,或账号被冻结。") + print() + if not ask_yes_no(" 重新输入密码吗?", default_no=False): + sys.exit(1) + password = ask("密码") + + +# ==================== 账号管理 ==================== + +def manage_accounts(): + """删除账号等管理操作.""" + while True: + saved = accounts.list_accounts() + title("管理账号") + if not saved: + print(" 没有已保存的账号") + return + for i, a in enumerate(saved, 1): + print(" [" + str(i) + "] " + (a.get("name") or "(昵称未知)") + " " + a["username"]) + print() + print(" [0] 返回") + print() + raw = ask_choice("要删除哪个账号的序号", + {"0"} | {str(i) for i in range(1, len(saved) + 1)}, default="0") + if raw == "0": + return + target = saved[int(raw) - 1] + print() + if not ask_yes_no(" 确定删除 " + (target.get("name") or target["username"]) + " 吗?", default_no=True): + continue + accounts.delete_account(target["username"]) + from api import cookies + cookies.clear_cookies(target["username"]) + print(" ✔ 已删除该账号(连同它的登录状态)") + + +# ==================== 刷课范围 / 选课 ==================== + +# 选项 -> (刷章节, 刷任务中心) +STUDY_SCOPES = { + "1": (True, True, False), + "2": (True, False, False), + "3": (False, True, False), + "4": (False, False, True), # 只刷讨论(模式在下一步单独问) +} + +DISCUSSION_MODES = { + "1": "task", # 任务里的主题讨论:自动,按课程要求的顺序 + "2": "board", # 讨论区帖子:先列出来,自己挑 +} + + +def choose_study_scope(): + """选择这次刷什么.""" + # + # 学习通里「章节(目录)」和「任务中心 · 教学任务」是两套互相独立的学习入口, + # 记录不互通,所以这里必须明确选一次,不能让配置文件里的默认值替用户决定。 + # + # 返回 (chapters_enabled, task_center_enabled)。 + title("刷什么内容") + print(" 章节(目录)和任务中心的教学任务是两套独立记录,要分开刷。") + print(" 一个「任务点」就是课程里的一个视频 / 文档 / 测验 / 讨论。") + print() + print(" 1. 章节 + 任务中心 ✓推荐") + print(" 2. 只刷章节(目录)") + print(" 3. 只刷任务中心(教学任务)") + print(" 4. 只刷讨论(讨论区)") + print() + + raw = ask_choice("请选择", set(STUDY_SCOPES), default="1") + + chapters, task_center, only_discussion = STUDY_SCOPES[raw] + if only_discussion: + print(" → 只刷讨论") + elif chapters and task_center: + print(" → 章节 + 任务中心") + elif chapters: + print(" → 只刷章节") + else: + print(" → 只刷任务中心") + + # 讨论怎么刷:任务里的主题讨论(自动)还是讨论区(自己挑帖子) + discussion_mode = "" + if only_discussion or task_center: + discussion_mode = choose_discussion_mode(required=only_discussion) + return chapters, task_center, only_discussion, discussion_mode + + +def choose_discussion_mode(required=False): + """讨论的两种刷法:自动跟任务,或进讨论区自己挑帖子.""" + title("讨论怎么刷") + if not required: + print(" 教学任务里本来就包含主题讨论,这里选它怎么刷。") + print() + print(" 1. 任务里的主题讨论(自动,按课程要求的顺序做) ✓推荐") + print(" 2. 讨论区(自己挑帖子回复)") + print() + raw = ask_choice("请选择", set(DISCUSSION_MODES), default="1") + mode = DISCUSSION_MODES[raw] + if mode == "task": + print(" → 任务里的主题讨论(自动)") + else: + print(" → 讨论区(自己挑帖子,逐条给草稿、确认后发送)") + return mode + + +def _ask_count(prompt): + """读一个"刷几个"的数量.""" + # + # 数字 = 只刷前几个未完成的;all / 全部 / 0(或直接回车)= 全部。 + # 返回 0 表示全部。 + for _ in range(5): + raw = ask(prompt, default="all") + low = raw.strip().lower() + if low in ("all", "全部", "0"): + return 0 + try: + n = int(low) + if n < 0: + raise ValueError + return n + except ValueError: + print(" ✘ 请填数字(如 3),或填 all 表示全部。") + print(" · 没收到有效数字,按「全部」继续") + return 0 + + +def _choose_course_entries(courses): + """Read valid course indices/IDs with a bounded number of invalid inputs.""" + chosen = None + tries = 0 + while chosen is None: + tries += 1 + raw = ask("要刷哪几门?填序号,如 1,3") + parts = [p.strip() for p in raw.replace(",", ",").replace("、", ",").split(",") if p.strip()] + picked, bad = [], [] + for p in parts: + if p.isdigit() and 1 <= int(p) <= len(courses): + picked.append(courses[int(p) - 1]) + else: + hit = [c for c in courses if str(c["courseId"]) == p] + if hit: + picked.append(hit[0]) + else: + bad.append(p) + if bad: + print(" ✘ 没认出来:" + ", ".join(bad)) + if tries >= 5: + # 非交互输入(管道/重定向)反复给不出有效序号时干净退出,绝不卡死 + print(" · 连续多次没认出课程,已退出向导(重新运行 cx 即可)。") + sys.exit(1) + continue + uniq, seen2 = [], set() + for c in picked: + if c["courseId"] not in seen2: + seen2.add(c["courseId"]) + uniq.append(c) + chosen = uniq + + return chosen + + +def choose_courses(cx, ask_points=True, ask_tasks=True, only_discussion=False, + discussion_mode=""): + title("选择课程") + print(" 正在读取课程列表...") + + try: + all_course = cx.get_course_list() + except Exception as e: + print(" ✘ 读取失败:" + short_err(e)) + sys.exit(1) + + if not all_course: + print(" ✘ 这个账号下没有课程") + sys.exit(1) + + seen, courses = set(), [] + for c in all_course: + key = (str(c["courseId"]), str(c["clazzId"])) + if key not in seen: + seen.add(key) + courses.append(c) + + print() + for i, c in enumerate(courses, 1): + print(" " + str(i).rjust(2) + ". " + c["title"]) + print() + + chosen = _choose_course_entries(courses) + + print(" 已选:" + "、".join(c["title"] for c in chosen)) + + # 只刷讨论:不设数量,直接说明这次会怎么刷(模式在上一步已经问过) + if only_discussion: + title("这次怎么刷讨论") + if discussion_mode == "board": + print(" 进入讨论区后先列出帖子,你自己挑要回复哪几条;逐条给草稿、确认后发送。") + else: + print(" 自动刷任务里的主题讨论:按课程要求的顺序,每条读已有回复后写一条普通回复。") + print(" 讨论不按数量限制(有任务/帖子就会处理)。") + return [(c, 0, 0) for c in chosen] + + # 两类都不刷的课程不存在;只刷一类时另一类就别问了 + if not ask_points and not ask_tasks: + return [(c, 0, 0) for c in chosen] + + title("每门课刷多少") + print(" 数字 = 本次刷多少个「还没完成」的,已完成的自动跳过、不会重刷。") + print(" 例:共 300 节、前 150 节已完成,填 150 = 把后面 150 节刷完。") + print(" all 或直接回车 = 没完成的全部刷完。") + if ask_points and ask_tasks: + print(" 章节和教学任务各算各的,互不影响。") + print() + + plan = [] + for c in chosen: + print(" " + c["title"]) + chapter_n = 0 + task_n = 0 + if ask_points: + chapter_n = _ask_count("章节:本次刷多少个(只算没完成的)") + print(" → " + ("没完成的章节全部刷完" if chapter_n == 0 + else ("从第一节未完成开始,往后刷 " + str(chapter_n) + + " 个(已完成的自动跳过)"))) + if ask_tasks: + task_n = _ask_count("教学任务:本次刷多少个(只算没完成的)") + print(" → " + ("没完成的教学任务全部刷完" if task_n == 0 + else ("从第一个未完成的教学任务开始,往后刷 " + + str(task_n) + " 个(已完成的自动跳过)"))) + plan.append((c, chapter_n, task_n)) + + return plan + + +# ==================== 主流程 ==================== + +def build_config(username, password, plan, chapters_enabled=True, task_center_enabled=True, + only_discussion=False, discussion_mode="task"): + """写出本次要用的配置(用账号专属文件,不污染全局配置).""" + paths.backup_config() + text = _read_config_text() + + course_ids = ",".join(str(c["courseId"]) for c, *_ in plan) + mp = ",".join(str(c["courseId"]) + ":" + str(chapter_n) for c, chapter_n, _ in plan) + mt = ",".join(str(c["courseId"]) + ":" + str(task_n) for c, _, task_n in plan) + + text = replace_value(text, "common", "username", username) + text = replace_value(text, "common", "password", password) + text = replace_value(text, "common", "course_list", course_ids) + text = replace_value(text, "common", "notopen_action", "continue") + # 刷课参数用推荐值:向导不再逐项询问(用户要求"直接按默认最优") + text = replace_value(text, "common", "speed", RECOMMENDED_PREFS["speed"]) + text = replace_value(text, "common", "jobs", RECOMMENDED_PREFS["jobs"]) + text = replace_value(text, "common", "work_max_retries", RECOMMENDED_PREFS["work_max_retries"]) + text = replace_value(text, "common", "task_center_submit_mode", + RECOMMENDED_PREFS["task_center_submit_mode"]) + # 刷课范围:向导里选了什么就写什么,不再吃全局配置的默认值 + # 只刷讨论也走任务中心链路:必须写成 true,否则启动检查会以为"两个入口都关了" + text = replace_value(text, "common", "task_center", + "true" if (task_center_enabled or only_discussion) else "false") + text = replace_value(text, "common", "chapter_study", "true" if chapters_enabled else "false") + text = replace_value(text, "common", "only_discussion", + "true" if only_discussion else "false") + # 没有任务中心的本轮不存在讨论处理方式。显式写 none,避免上一轮的讨论区选择 + # 在下一轮「只刷章节」时被误读成仍要进讨论区。 + mode = discussion_mode if (task_center_enabled or only_discussion) else "none" + text = replace_value(text, "common", "discussion_mode", mode or "task") + text = replace_value(text, "common", "max_points_per_course", mp) + text = replace_value(text, "common", "max_tasks_per_course", mt) + text = replace_value(text, "common", "use_cookies", "false") + # 保留 check_llm_connection=true:main.py 启动时会再验证一次 Key。 + # 本流程虽然刚验证过,但保持这道兜底更安全 —— 万一是旧配置/Key 中途失效, + # 也能在"开始刷课之前"就拦住,而不是刷到测验时才发现(那样会一堆报错)。 + text = replace_value(text, "tiku", "check_llm_connection", "true") + # 注意:通知配置必须原样保留,不能清空(之前这里会覆盖掉用户配好的通知) + + # 每个用户一份独立配置,避免多用户互相覆盖 + os.makedirs(accounts.ACCOUNTS_DIR, exist_ok=True) + user_config = os.path.join(accounts.ACCOUNTS_DIR, "run_" + accounts._safe_name(username) + ".ini") + with open(user_config, "w", encoding="utf8") as f: + f.write(text) + try: + os.chmod(user_config, 0o600) + except OSError: + if os.name != "nt": + raise + return user_config + + +def pick_user(): + """选择用户:返回 (username, password, cx, name).""" + # 没有账号时会引导加入新账号。 + saved = accounts.list_accounts() + + if not saved: + print(" 还没有保存过用户,先加入一个账号。") + return add_new_account() + + title("选择用户") + for i, a in enumerate(saved, 1): + label = a.get("name") or "(昵称未知)" + when = (a.get("last_used") or "")[5:16] # 只留 月-日 时:分 + print(" " + str(i) + ". " + _pad(label, 12) + _pad(a["username"], 13) + when) + print() + print(" " + str(len(saved) + 1) + ". 加入新账号") + print(" " + str(len(saved) + 2) + ". 管理账号(删除)") + print() + + idx_add = len(saved) + 1 + idx_mgr = len(saved) + 2 + + raw = ask_choice("请选择", {str(i) for i in range(1, idx_mgr + 1)}, default="1") + idx = int(raw) + if idx == idx_mgr: + manage_accounts() + return pick_user() + if idx == idx_add: + return add_new_account() + return use_existing(saved[idx - 1]) + + +def ask_after_run(label, cancelled=False): + """一轮结束后问用户下一步做什么.""" + # 返回 "again"(同账号继续)/ "switch"(换账号)/ "exit"(退出) + # + # cancelled=True 表示用户在上一步取消了刷课(此时不能说"刷课结束")。 + title("接下来做什么") + if cancelled: + print(" 本次没有刷课(你在确认时取消了)。") + else: + print(" 刚刷完的账号:" + label) + print() + print(" 1. 继续刷这个账号的其他课程") + print(" 2. 换个账号刷") + print(" 3. 退出程序") + print() + + choice = ask_choice("请选择", {"1", "2", "3"}, default="3") + return {"1": "again", "2": "switch", "3": "exit"}[choice] + + +def _show_run_confirmation(label, username, plan, chapters_enabled, + task_center_enabled, only_discussion, discussion_mode): + """Display the exact account, courses and scope selected for this run.""" + if only_discussion: + scope_text = "只刷讨论" + elif chapters_enabled and task_center_enabled: + scope_text = "章节 + 任务中心" + elif chapters_enabled: + scope_text = "只刷章节" + else: + scope_text = "只刷任务中心" + title("请确认") + account_text = label or username or "已保存的账号" + if username and username != account_text: + account_text = account_text + "(" + username + ")" + print(" 账号 " + account_text) + print(" 范围 " + scope_text) + if discussion_mode: + print(" 讨论 " + ("讨论区(自己挑帖子,逐条确认后发送)" + if discussion_mode == "board" + else "任务里的主题讨论(自动)")) + print(" 课程") + for c, chapter_n, task_n in plan: + cp = "章节全部" if chapter_n == 0 else ("章节 " + str(chapter_n) + " 个未完成") + tp = "教学任务全部" if task_n == 0 else ("教学任务 " + str(task_n) + " 个未完成") + if only_discussion: + detail = "" # 上面"讨论"那一行已经说清楚了,这里不再重复 + elif chapters_enabled and task_center_enabled: + detail = cp + " · " + tp + elif chapters_enabled: + detail = cp + else: + detail = tp + print((" " + _pad(c["title"], 24) + detail).rstrip()) + print() + + +def _main_inner(force_setup=False): + title("超星刷课") + print() + print(" 提示:程序会一步步问你(刷什么、刷哪门、刷多少),有默认值的直接回车就行。") + print(" 在本向导里输入 q 再回车可随时退出,不会刷任何课。") + + # cx --yes:跳过向导最后的人工确认,并把 --yes 传给 main.py 的启动检查 + auto_yes = any(a in ("--yes", "-y") for a in sys.argv[1:]) + + # 1. 答题方式:已配置则静默沿用,只有 cx setup 才会重新询问 + ensure_api_key(force=force_setup) + + # 1.5 首次使用或还没配过通知/偏好时,问一次全局设置(存到 config.ini,以后不再问) + ensure_global_prefs(force=force_setup) + + # 2. 选用户 -> 选课 -> 刷课;刷完再问下一步 + from main import main as run_main + + current = None # 当前登录的 (username, password, cx, name) + round_no = 0 # 第几轮 + + while True: + # ---- 选用户(换了账号或第一轮时) ---- + if current is None: + current = pick_user() + username, password, cx, name = current + label = name or username + + # 同一账号继续刷时,明确告诉用户当前是谁 + if round_no > 0: + title("继续刷课") + print(" 当前账号:" + label + "(" + username + ")") + + # ---- 选刷课范围:章节(目录)/ 任务中心·教学任务 ---- + chapters_enabled, task_center_enabled, only_discussion, discussion_mode = \ + choose_study_scope() + + # ---- 选课 + 逐门设置本次范围(不刷的那一类不问) ---- + plan = choose_courses(cx, ask_points=chapters_enabled, ask_tasks=task_center_enabled, + only_discussion=only_discussion, + discussion_mode=discussion_mode) + + # ---- 写该用户专属配置 ---- + user_config = build_config(username, password, plan, + chapters_enabled, task_center_enabled, only_discussion, + discussion_mode) + + # ---- 最终确认 ---- + _show_run_confirmation(label, username, plan, chapters_enabled, + task_center_enabled, only_discussion, discussion_mode) + if auto_yes: + print(" (--yes:跳过确认,直接开始)") + elif not ask_yes_no("开始刷课吗?", default_no=True): + print(" 已取消,本次不会刷任何课。") + # 取消了不直接退出,问用户下一步 + action = ask_after_run(label, cancelled=True) + if action == "again": + round_no += 1 + continue + if action == "switch": + current = None + round_no += 1 + continue + break + + # ---- 开刷 ---- + # 关键:清掉上一轮可能残留的终止标志,否则新一轮会立刻停止 + interrupt.reset() + sys.argv = ["main.py", "-c", user_config] + (["--yes"] if auto_yes else []) + run_main() + + # ---- 刷完问下一步 ---- + round_no += 1 + action = ask_after_run(label) + if action == "again": + continue + if action == "switch": + current = None + continue + break + + return 0 + + +def main(force_setup=False): + """统一入口:把一键退出/中断处理成干净退出.""" + try: + return _main_inner(force_setup=force_setup) + except UserQuit: + print() + print(" 已安全退出。") + print() + return 0 + except KeyboardInterrupt: + print() + print() + print(" 已安全退出(Ctrl+C)。") + print() + return 0 + + +if __name__ == "__main__": + safe_console() + # cx setup -> 重新配置;cx -> 已配置则直接开始 + _force = "--setup" in sys.argv or "setup" in sys.argv + sys.exit(main(force_setup=_force)) diff --git a/tests/__init__.py b/tests/__init__.py index e69de29bb..c558c48e9 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -0,0 +1,9 @@ +# -*- coding: utf-8 -*- +"""测试包入口:先隔离数据目录,任何测试都不得碰真实 ~/.chaoxing/.""" +# +# 注意:这里用直接赋值而不是 setdefault——单跑某个测试文件、乱序跑或 CI 并行跑时, +# 都不能继承真实 HOME。 +import os +import tempfile + +os.environ["CX_DATA_HOME"] = tempfile.mkdtemp(prefix="cx-test-") diff --git a/tests/test_ai_writer.py b/tests/test_ai_writer.py new file mode 100644 index 000000000..202c4b417 --- /dev/null +++ b/tests/test_ai_writer.py @@ -0,0 +1,289 @@ +# -*- coding: utf-8 -*- +"""去 AI 味文案生成器的离线测试(不联网).""" +import json +import os +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-test-")) + +from api.ai_writer import HumanLikeWriter # noqa: E402 + + +class CleanTestCase(unittest.TestCase): + def test_strips_ai_smell(self): + raw = "首先,我们要明白战略管理的意义。其次,它很重要。\n\n总而言之,谢谢。" + out = HumanLikeWriter.clean(raw) + for word in ("首先", "其次", "总而言之"): + self.assertNotIn(word, out) + self.assertIn("战略管理的意义", out) + + def test_strips_markdown_noise(self): + raw = "下面是回答:\n\n" + chr(96) * 3 + "python\ncode\n" + chr(96) * 3 + "\n- 第一条\n1. 第二条\n## 小标题" + out = HumanLikeWriter.clean(raw) + self.assertNotIn(chr(96), out) + self.assertNotIn("##", out) + self.assertIn("第一条", out) + + def test_style_reference(self): + text = HumanLikeWriter.style_reference([ + {"content": "我觉得战略就是取舍"}, + "先活下去再谈发展", + ]) + self.assertIn("1. 我觉得战略就是取舍", text) + self.assertIn("2. 先活下去再谈发展", text) + + +class WriterTestCase(unittest.TestCase): + def setUp(self): + self.writer = HumanLikeWriter({"endpoint": "https://example.com/v1", + "key": "sk-test", "model": "test-model"}) + + def test_available(self): + self.assertTrue(self.writer.available) + self.assertFalse(HumanLikeWriter({}).available) + + def test_answer_prompt_includes_question_and_refs(self): + captured = {} + + def fake_chat(system, user, **kwargs): + captured["system"] = system + captured["user"] = user + return "首先,我觉得战略管理就是帮公司在不确定里做选择。总之就这样。" + + with mock.patch.object(self.writer, "_chat", side_effect=fake_chat): + out = self.writer.answer("什么是战略管理?", requirement="结合实际", + references=[{"content": "战略是取舍"}]) + self.assertIn("战略管理", captured["user"]) + self.assertIn("战略是取舍", captured["user"]) + self.assertIn("不能有 AI 腔", captured["system"]) + self.assertNotIn("首先", out) + self.assertNotIn("总之", out) + + def test_discussion_uses_existing_posts(self): + captured = {} + + def fake_chat(system, user, **kwargs): + captured["user"] = user + return "我赞同前面同学的看法,使命是长期方向,愿景更像目标画面。" + + posts = [{"content": "我认为使命是长期方向"}, {"content": "愿景更像是目标画面"}] + with mock.patch.object(self.writer, "_chat", side_effect=fake_chat): + out = self.writer.discussion("企业使命与愿景的区别", existing_posts=posts) + self.assertIn("我认为使命是长期方向", captured["user"]) + # 用户要求:讨论回复必须是"班里中等水平"的普通回复,不许抖机灵/写成小论文 + self.assertIn("中等水平", captured["user"]) + self.assertIn("不要写巧妙的类比", captured["user"]) + self.assertIn("不要编造个人经历", captured["user"]) + self.assertTrue(out.startswith("我赞同")) + + def test_practice_answer_uses_context(self): + captured = {} + + def fake_chat(system, user, **kwargs): + captured["user"] = user + return "我觉得这个选择要看企业的资源和外部环境。" + + with mock.patch.object(self.writer, "_chat", side_effect=fake_chat): + out = self.writer.practice_answer( + "企业应该如何选择战略?", requirement="结合案例", context="竞争优势" + ) + self.assertIn("竞争优势", captured["user"]) + self.assertIn("结合案例", captured["user"]) + self.assertEqual(out, "我觉得这个选择要看企业的资源和外部环境。") + + def test_choose_options_returns_normalized_letters(self): + with mock.patch.object(self.writer, "_chat", return_value="答案是 C、A"): + self.assertEqual( + self.writer.choose_options( + "哪项属于战略选择?", + [{"option": "A", "optionContent": "方向"}, + {"option": "B", "optionContent": "颜色"}, + {"option": "C", "optionContent": "取舍"}], + multiple=True, + ), + "AC", + ) + + def test_choose_judgement_is_strict(self): + with mock.patch.object(self.writer, "_chat", return_value="对"): + self.assertEqual(self.writer.choose_judgement("战略需要取舍"), "对") + with mock.patch.object(self.writer, "_chat", return_value="这个说法错"): + self.assertEqual(self.writer.choose_judgement("战略没有成本"), "错") + + def test_no_config_raises(self): + writer = HumanLikeWriter({}) + with self.assertRaises(RuntimeError): + writer.answer("问题") + + +class ThinkingPolicyPayloadTestCase(unittest.TestCase): + """Thinking 策略.""" + + # auto(默认)= 第一次请求不带 thinking,让 V4.1 flash 自己推理; + # 正文为空才自动降级成 thinking=disabled 再试一次。 + + @staticmethod + def _fake_response(content): + class R: + """Provide a synthetic test dependency.""" + + status_code = 200 + def raise_for_status(self): + return None + def json(self): + return {"choices": [{"message": {"content": content}}]} + return R() + + def test_auto_keeps_thinking_untouched(self): + writer = HumanLikeWriter({"endpoint": "https://api.deepseek.com/v1", + "key": "sk-test", "model": "deepseek-flash"}) + captured = {} + + def fake_post(url, headers=None, json=None, **kwargs): + captured["payload"] = json + return self._fake_response("拿到正文了") + + with mock.patch("api.ai_writer.requests.post", side_effect=fake_post): + out = writer._chat("system", "user", max_tokens=64) + self.assertEqual(out, "拿到正文了") + self.assertNotIn("thinking", captured["payload"]) + + def test_empty_content_falls_back_to_thinking_disabled(self): + writer = HumanLikeWriter({"endpoint": "https://api.deepseek.com/v1", + "key": "sk-test", "model": "deepseek-flash"}) + payloads = [] + + def fake_post(url, headers=None, json=None, **kwargs): + payloads.append(dict(json or {})) # 复制快照:payload 会被原地复用 + if len(payloads) == 1: + return self._fake_response("") # 老版本:正文为空 + return self._fake_response("第二次拿到正文") + + with mock.patch("api.ai_writer.requests.post", side_effect=fake_post), \ + mock.patch("api.ai_writer.time.sleep", return_value=None): + out = writer._chat("system", "user", max_tokens=64) + self.assertEqual(out, "第二次拿到正文") + self.assertNotIn("thinking", payloads[0]) + self.assertEqual(payloads[1]["thinking"], {"type": "disabled"}) + + def test_off_mode_disables_thinking_first(self): + writer = HumanLikeWriter({"endpoint": "https://api.deepseek.com/v1", + "key": "sk-test", "model": "deepseek-flash", + "thinking": "off"}) + captured = {} + + def fake_post(url, headers=None, json=None, **kwargs): + captured["payload"] = json + return self._fake_response("ok") + + with mock.patch("api.ai_writer.requests.post", side_effect=fake_post): + writer._chat("system", "user", max_tokens=64) + self.assertEqual(captured["payload"]["thinking"], {"type": "disabled"}) + + def test_empty_content_raises_after_retry(self): + writer = HumanLikeWriter({"endpoint": "https://api.deepseek.com/v1", + "key": "sk-test", "model": "deepseek-flash"}) + calls = {"n": 0} + + def fake_post(url, headers=None, json=None, **kwargs): + calls["n"] += 1 + return self._fake_response("") + + with mock.patch("api.ai_writer.requests.post", side_effect=fake_post), \ + mock.patch("api.ai_writer.time.sleep", return_value=None): + with self.assertRaises(RuntimeError): + writer._chat("system", "user", max_tokens=64) + self.assertEqual(calls["n"], 2) + + +class ExamPromptTestCase(unittest.TestCase): + """AI 实践的选择/判断题要按“先判断再给答案”的格式解析,避免误读推理过程里的字母.""" + + def _writer(self): + return HumanLikeWriter({"endpoint": "https://api.deepseek.com/v1", + "key": "sk-test", "model": "deepseek-flash"}) + + def test_extract_letters_prefers_answer_marker(self): + raw = "B 项说的是职能层,C 项把公司层和业务层混在一起了。\n答案:AC" + self.assertEqual(HumanLikeWriter._extract_letters(raw, {"A", "B", "C"}), + ["A", "C"]) + + def test_extract_letters_falls_back_to_last_line(self): + raw = "这题考查公司层战略。\nB" + self.assertEqual(HumanLikeWriter._extract_letters(raw, {"A", "B"}), ["B"]) + + def test_choose_options_keeps_single_letter(self): + w = self._writer() + with mock.patch.object(w, "_chat", return_value="先排除 B、D。\n答案:C"): + self.assertEqual( + w.choose_options("关于公司层战略的说法正确的是?", + [{"option": "A", "optionContent": "x"}, + {"option": "C", "optionContent": "y"}]), + "C", + ) + + def test_choose_judgement_reads_marker(self): + w = self._writer() + with mock.patch.object(w, "_chat", return_value="这句话把两个概念混在一起。\n答案:错"): + self.assertEqual(w.choose_judgement("公司层战略就是业务层战略。"), "错") + + def test_choose_judgement_rejects_vague_output(self): + w = self._writer() + with mock.patch.object(w, "_chat", return_value="这道题要看具体情况。"): + with self.assertRaises(ValueError): + w.choose_judgement("公司层战略就是业务层战略。") + + + + def test_recent_feedback_extracts_platform_explanation(self): + data = {"messageList": [ + {"role": 2, "content": json.dumps({"questionStem": "q1", "preAppendContent": "回答正确!本题考核公司层战略。"})}, + {"role": 1, "content": json.dumps({"content": "B"})}, + {"role": 2, "content": json.dumps({"questionStem": "q2", + "preAppendContent": "真遗憾,回答错误了呢。公司层战略是企业最高管理层制定的面向企业整体的总体战略,核心是确定经营领域。"})}, + ]} + hints = HumanLikeWriter._recent_feedback(data) + self.assertIn("公司层战略", hints) + self.assertIn("真遗憾", hints) + + def test_recent_feedback_ignores_non_feedback(self): + data = {"messageList": [{"role": 2, "content": json.dumps({"questionStem": "只有题目"})}]} + self.assertEqual(HumanLikeWriter._recent_feedback(data), "") + + def test_choice_vote_takes_majority(self): + w = self._writer() + outputs = iter(["答案:A", "答案:B", "答案:A", "答案:A"]) + with mock.patch.object(w, "_chat", side_effect=lambda *a, **k: next(outputs)): + self.assertEqual( + w.choose_options("关于公司层战略的说法正确的是?", + [{"option": "A", "optionContent": "x"}, + {"option": "B", "optionContent": "y"}]), + "A", + ) + + def test_judgement_vote_takes_majority(self): + w = self._writer() + outputs = iter(["答案:对", "答案:错", "答案:对", "答案:对"]) + with mock.patch.object(w, "_chat", side_effect=lambda *a, **k: next(outputs)): + self.assertEqual(w.choose_judgement("公司层战略就是业务层战略。"), "对") + + def test_vote_survives_partial_failures(self): + w = self._writer() + calls = {"n": 0} + + def flaky(*a, **k): + calls["n"] += 1 + if calls["n"] == 1: + raise RuntimeError("网络抖动") + return "答案:错" + + with mock.patch.object(w, "_chat", side_effect=flaky): + self.assertEqual(w.choose_judgement("这句话对吗?"), "错") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_audit_fixes.py b/tests/test_audit_fixes.py new file mode 100644 index 000000000..ab5e7eb84 --- /dev/null +++ b/tests/test_audit_fixes.py @@ -0,0 +1,222 @@ +# -*- coding: utf-8 -*- +"""审计修复的离线回归.""" +# +# * 直播任务失败/被终止时不再报成功 +# * 没有题库的章节测验不再被记为完成(返回 ERROR) +# * 向导确认页回车 = 取消(安全默认) +# * main() 在任务中心阶段被终止时不会走到"全部完成" +import os +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-audit-")) + +from api import base as base_mod # noqa: E402 +from api import task_center as tc_mod # noqa: E402 +from api.task_center import TaskCenter # noqa: E402 +from api import interrupt # noqa: E402 +from api.live_process import LiveProcessor # noqa: E402 +import setup_wizard as wizard # noqa: E402 + + +class FakeLive: + def __init__(self, status=True, duration=60, finish=True): + """Initialize configuration and runtime state.""" + self.name = "测试直播" + self._status = status + self._duration = duration + self._finish = finish + self.calls = 0 + + def get_status(self): + if not self._status: + return None + return {"temp": {"data": {"duration": self._duration}}} + + def do_finish(self): + self.calls += 1 + return self._finish + + +class LiveProcessorTestCase(unittest.TestCase): + def test_failed_status_is_not_success(self): + self.assertFalse(LiveProcessor.run_live(FakeLive(status=False), speed=1.0)) + + def test_failed_submit_is_not_success(self): + live = FakeLive(finish=False) + with mock.patch("api.live_process.time.sleep", return_value=None): + self.assertFalse(LiveProcessor.run_live(live, speed=1.0)) + self.assertGreaterEqual(live.calls, 2) # 失败会重试一次,但仍返回失败 + + def test_interrupt_stops_and_reports_failure(self): + live = FakeLive() + with mock.patch.object(interrupt, "should_stop", return_value=True): + self.assertFalse(LiveProcessor.run_live(live, speed=1.0)) + self.assertEqual(live.calls, 0) + + def test_success_only_after_all_minutes(self): + live = FakeLive(duration=60) + with mock.patch("api.live_process.time.sleep", return_value=None): + self.assertTrue(LiveProcessor.run_live(live, speed=2.0)) # 倍速被忽略,仍按真实时间 + + +class NoTikuQuizTestCase(unittest.TestCase): + def test_no_tiku_returns_error(self): + cx = base_mod.Chaoxing() + cx.tiku = mock.Mock(DISABLE=True) + result = cx.study_work({"title": "测试课"}, {"name": "章节测验"}, {}) + self.assertEqual(result, base_mod.StudyResult.ERROR) + + +class ConfirmDefaultTestCase(unittest.TestCase): + def test_enter_cancels_by_default(self): + with mock.patch.object(wizard, "_read_line", return_value=""), \ + mock.patch("builtins.print"): + self.assertFalse(wizard.ask_yes_no("确认开始刷课吗?")) + + def test_y_confirms(self): + with mock.patch.object(wizard, "_read_line", return_value="y"), \ + mock.patch("builtins.print"): + self.assertTrue(wizard.ask_yes_no("确认开始刷课吗?")) + + def test_default_yes_variant(self): + with mock.patch.object(wizard, "_read_line", return_value=""), \ + mock.patch("builtins.print"): + self.assertTrue(wizard.ask_yes_no("重新输入吗?", default_no=False)) + + +class SituationalDialogueTestCase(unittest.TestCase): + """新版 AI 实践(情景对话)要明确报"暂不支持",不能只说参数缺失.""" + + def test_detected_as_unsupported_subtype(self): + tc = TaskCenter(object(), {}) + + class Resp: + """Provide a synthetic test dependency.""" + + status_code = 200 + url = "https://mooc2-ans.chaoxing.com/mooc2-ans-vue/situationalDialogue?courseid=1" + text = "situationalDialogue" + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, **kwargs): + return Resp() + + tc.session = Sess() + messages = [] + with mock.patch.object(tc_mod.logger, "warning", + side_effect=lambda msg, *a, **k: messages.append(str(msg))), \ + mock.patch("builtins.print"): + ok = tc.study_ai_practice("https://mooc2-ans.chaoxing.com/ai-evaluate/v2/answer?x=1") + self.assertFalse(ok) + self.assertTrue(any("情景对话" in m for m in messages), messages) + + +class NoFakeSuccessTestCase(unittest.TestCase): + """独立审计新发现的"可能假完成"路径:一律不能返回成功(铁律 1).""" + + def test_unknown_card_type_is_collected(self): + from api.decode import _process_attachment_cards + jobs, unknown = _process_attachment_cards( + [{"job": {"id": 1}, "type": "weird-new-type", "property": {}}] + ) + self.assertEqual(jobs, []) + self.assertEqual(unknown, ["weird-new-type"]) + + def test_get_job_list_fails_on_unknown_card_types(self): + cx = base_mod.Chaoxing() + + class Resp: + """Provide a synthetic test dependency.""" + + status_code = 200 + text = "" + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, *args, **kwargs): + return Resp() + + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()), \ + mock.patch.object(base_mod, "decode_course_card", + return_value=([], {"unknownCardTypes": ["weird"]})): + jobs, info = cx.get_job_list( + {"courseId": "1", "clazzId": "2", "cpi": "3"}, + {"id": "9", "title": "第1章"}, + ) + self.assertIsNone(jobs) + self.assertEqual(info.get("unknownCardTypes"), ["weird"]) + + def test_chapter_document_result_false_is_error(self): + cx = base_mod.Chaoxing() + + class Resp: + """Provide a synthetic test dependency.""" + + status_code = 200 + text = "{}" + + def json(self): + return {"result": False, "msg": "任务未完成"} + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, *args, **kwargs): + return Resp() + + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()): + result = cx.study_document( + {"courseId": "1", "clazzId": "2"}, + {"jobid": "1", "otherinfo": "nodeId_9-cpi_1", "jtoken": "t"}, + ) + self.assertEqual(result, base_mod.StudyResult.ERROR) + + def test_read_non_json_is_error(self): + cx = base_mod.Chaoxing() + + class Resp: + """Provide a synthetic test dependency.""" + + status_code = 200 + text = "login" + + def json(self): + raise ValueError("not json") + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, *args, **kwargs): + return Resp() + + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()): + result = cx.study_read( + {"courseId": "1", "clazzId": "2"}, + {"jobid": "1", "jtoken": "t"}, + {"knowledgeid": "9"}, + ) + self.assertEqual(result, base_mod.StudyResult.ERROR) + + +class TerminationGuardTestCase(unittest.TestCase): + def test_stop_branch_exists_before_completion_notice(self): + source = open( + os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "main.py"), + encoding="utf-8", + ).read() + stop_idx = source.rfind("已终止刷课") + done_idx = source.rfind("超星刷课:全部完成") + self.assertGreater(stop_idx, 0) + self.assertGreater(done_idx, 0) + self.assertLess(stop_idx, done_idx, "终止分支必须出现在'全部完成'通知之前") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_console.py b/tests/test_console.py new file mode 100644 index 000000000..59f93bc3e --- /dev/null +++ b/tests/test_console.py @@ -0,0 +1,15 @@ +import io +import sys +import unittest +from unittest import mock +import main + +class ConsoleTest(unittest.TestCase): + def test_windows_redirected_output_preserves_chinese(self): + raw = io.BytesIO() + output = io.TextIOWrapper(raw, encoding="cp1252", newline="\n") + with mock.patch.object(sys, "platform", "win32"), mock.patch.object(sys, "stdout", output), mock.patch.object(sys, "stderr", output): + main.configure_console() + print("中文帮助") + output.flush() + self.assertEqual(raw.getvalue().decode("utf-8"), "中文帮助\n") diff --git a/tests/test_discussion.py b/tests/test_discussion.py new file mode 100644 index 000000000..ae839fe9a --- /dev/null +++ b/tests/test_discussion.py @@ -0,0 +1,196 @@ +# -*- coding: utf-8 -*- +"""任务中心「主题讨论」(planType=14)离线回归.""" +# +# 覆盖: +# * 话题页解析(urlToken/标题/正文,window.obj.topic 是 JS 字面量) +# * study_discussion:读已有回复 → 写作器生成 → 提交 addReplys(参数与网页端一致) +# * 失败不假装成功:缺 urlToken / 写作器不可用 / 生成器报错 / 平台拒绝 / confirm 无终端 +# 全部离线,不联网、不碰真实数据。 +import os +import sys +import tempfile +import unittest +from unittest import mock +from urllib.parse import unquote + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-discuss-")) + +from api import task_center as tc_mod # noqa: E402 +from api.task_center import TaskCenter # noqa: E402 + +STUDY_URL = ("https://groupweb.chaoxing.com/pc/topic/jumpToTopicDetail" + "?bbsid=bbs-1&uuid=topic-uuid-1&classId=1000002") + +DISCUSS_PAGE = """ +话题详情 + + +""" + +NO_TOKEN_PAGE = DISCUSS_PAGE.replace("urlToken:'token-abc',", "") + +REPLIES = { + "status": True, + "datas": [ + {"uuid": "r1", "content": "我觉得普通员工也需要了解,不然方向对不上。"}, + {"uuid": "r2", "content": "知道一点有用,但不用背下来。"}, + ], +} +POST_OK = {"status": True, "msg": "回复成功", "datas": {"urlToken": "new-token"}} + + +class FakeResponse: + def __init__(self, status_code=200, text="", payload=None): + """Initialize configuration and runtime state.""" + self.status_code = status_code + self.text = text + self._payload = payload + + def json(self): + if self._payload is None: + raise ValueError("not json") + return self._payload + + +class FakeSession: + def __init__(self, routes): + """Initialize configuration and runtime state.""" + self.routes = routes + self.calls = [] + self.kwargs_calls = [] + + def _dispatch(self, method, url, **kwargs): + self.calls.append((method, url)) + self.kwargs_calls.append(kwargs) + for key, resp in self.routes: + if key in url: + return resp + return FakeResponse(status_code=404) + + def get(self, url, **kwargs): + return self._dispatch("get", url, **kwargs) + + def post(self, url, **kwargs): + return self._dispatch("post", url, **kwargs) + + +class FakeWriter: + available = True + + def __init__(self): + """Initialize configuration and runtime state.""" + self.existing = None + self.error = None + + def discussion(self, topic, requirement="", existing_posts=None, max_chars=160): + self.existing = existing_posts + if self.error: + raise RuntimeError(self.error) + return "使命和愿景写在官网上是一回事,员工知不知道是另一回事,我先说说自己的理解。" + + +class DiscussionDecodeTestCase(unittest.TestCase): + def test_extracts_token_title_content(self): + info = tc_mod._extract_discussion_topic(DISCUSS_PAGE) + self.assertEqual(info["url_token"], "token-abc") + self.assertEqual(info["title"], "讨论任务B") + self.assertIn("普通员工需要了解", info["content"]) + + def test_missing_token_is_empty(self): + info = tc_mod._extract_discussion_topic(NO_TOKEN_PAGE) + self.assertEqual(info["url_token"], "") + + +class StudyDiscussionTestCase(unittest.TestCase): + def _tc(self, page=DISCUSS_PAGE, submit_mode="auto", writer=None, post=None): + cx = mock.Mock() + writer = writer if writer is not None else FakeWriter() + tc = TaskCenter(cx, {"task_center_submit_mode": submit_mode}, writer=writer) + tc.session = FakeSession([ + ("jumpToTopicDetail", FakeResponse(text=page)), + ("getReplyList", FakeResponse(payload=REPLIES)), + ("addReplys", FakeResponse(payload=post or POST_OK)), + ]) + return tc, writer + + def test_replies_with_reference_and_correct_payload(self): + tc, writer = self._tc() + ok = tc.study_discussion(STUDY_URL, {"name": "讨论任务B"}, + {"courseId": "1000001", "clazzId": "1000002"}) + self.assertTrue(ok) + self.assertEqual(writer.existing, [r["content"] for r in REPLIES["datas"]]) + posts = [kw for method, _url in tc.session.calls + for kw in tc.session.kwargs_calls if "data" in kw] + payload = posts[-1]["data"] + self.assertEqual(payload["replyId"], -1) + self.assertEqual(payload["bbsid"], "bbs-1") + self.assertEqual(payload["urlToken"], "token-abc") + self.assertEqual(payload["courseId"], "1000001") + self.assertEqual(payload["classId"], "1000002") + # 网页端先 encodeURIComponent 一次,requests 再编码一次 + self.assertIn("使命和愿景", unquote(payload["topic_content"])) + post_urls = [url for method, url in tc.session.calls if method == "post"] + self.assertIn("/pc/invitation/topic-uuid-1/addReplys", post_urls[0]) + + def test_already_replied_does_not_post_again(self): + """自己已经回复过:不再重复发帖(重复运行不能刷讨论区).""" + replies = { + "status": True, + "datas": [ + {"uuid": "mine", "createrPuid": 100000001, "content": "我之前的回复。"}, + {"uuid": "r1", "createrPuid": 999, "content": "同学的回复。"}, + ], + } + cx = mock.Mock() + writer = FakeWriter() + tc = TaskCenter(cx, {"task_center_submit_mode": "auto"}, writer=writer) + tc.session = FakeSession([ + ("jumpToTopicDetail", FakeResponse(text=DISCUSS_PAGE)), + ("getReplyList", FakeResponse(payload=replies)), + ("addReplys", FakeResponse(payload=POST_OK)), + ]) + self.assertTrue(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_missing_token_does_not_submit(self): + tc, _writer = self._tc(page=NO_TOKEN_PAGE) + self.assertFalse(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_writer_unavailable_does_not_submit(self): + writer = mock.Mock() + writer.available = False + tc, _writer = self._tc(writer=writer) + self.assertFalse(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_writer_hard_failure_does_not_submit(self): + writer = FakeWriter() + writer.error = "生成内容里仍在编造个人经历" + tc, _writer = self._tc(writer=writer) + self.assertFalse(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_platform_rejects_reply(self): + tc, _writer = self._tc(post={"status": False, "msg": "该话题你最多回复N条"}) + self.assertFalse(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + + def test_confirm_mode_without_tty_does_not_submit(self): + tc, _writer = self._tc(submit_mode="confirm") + with mock.patch.object(sys.stdin, "isatty", return_value=False): + self.assertFalse(tc.study_discussion(STUDY_URL, {"name": "讨论"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.WAITING_CONFIRMATION) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_discussion_board.py b/tests/test_discussion_board.py new file mode 100644 index 000000000..1b4ebab49 --- /dev/null +++ b/tests/test_discussion_board.py @@ -0,0 +1,427 @@ +# -*- coding: utf-8 -*- +"""讨论区浏览(模式 2)回归:列表解析、渲染、板块解析、只列不回复.""" +# +# 模式 1(任务里的主题讨论)在 tests/test_discussion.py 里;两者共用 +# TaskCenter.reply_topic,所以这里的重点是"能不能把讨论区的帖子列出来并选中"。 + +import contextlib +import io +import os +import sys +import tempfile +import unittest +from uuid import uuid4 +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-board-")) + +from api import discussion # noqa: E402 + + +class FakeResp: + def __init__(self, payload, status=200): + """Initialize configuration and runtime state.""" + self.status_code = status + self._payload = payload + self.text = "{}" + + def json(self): + if isinstance(self._payload, Exception): + raise self._payload + return self._payload + + +class FakeSession: + def __init__(self, payload): + """Initialize configuration and runtime state.""" + self.payload = payload + self.calls = [] + + def get(self, url, **kwargs): + self.calls.append((url, kwargs)) + return FakeResp(self.payload) + + +def _topic_item(**over): + item = { + "uuid": "uuid-1", + "id": 711682418, + "title": "", + "content": "企业外部环境存在机会,是否就代表企业一定可以抓住机会?", + "createrName": "张三", + "reply_count": 1, + "ftime": "2小时前", + "lastReply": {"name": "张三", "formattime": "2小时前"}, + } + item.update(over) + return item + + +class NormalizeTopicTestCase(unittest.TestCase): + def test_title_falls_back_to_content(self): + topic = discussion.normalize_topic(_topic_item()) + self.assertIn("企业外部环境", topic["title"]) + self.assertEqual(topic["author"], "张三") + self.assertEqual(topic["reply_count"], 1) + + def test_real_title_wins(self): + topic = discussion.normalize_topic(_topic_item(title="这是标题")) + self.assertEqual(topic["title"], "这是标题") + + +class FetchTopicsTestCase(unittest.TestCase): + def test_parses_topic_list(self): + payload = {"status": True, "datas": [_topic_item(), _topic_item(uuid="uuid-2")]} + session = FakeSession(payload) + topics = discussion.fetch_topics(session, "bbs-1", page=1) + self.assertEqual(len(topics), 2) + self.assertEqual(topics[0]["uuid"], "uuid-1") + url, kwargs = session.calls[0] + self.assertIn("/pc/topic/topiclist/bbs-1/getTopicList", url) + self.assertEqual(kwargs["params"]["page"], 1) + + def test_platform_rejection_returns_empty(self): + topics = discussion.fetch_topics(FakeSession({"status": False, "msg": "无权访问"}), "bbs-1") + self.assertEqual(topics, []) + + def test_non_json_returns_empty(self): + topics = discussion.fetch_topics(FakeSession(ValueError("not json")), "bbs-1") + self.assertEqual(topics, []) + + def test_items_without_uuid_are_skipped(self): + payload = {"status": True, "datas": [{"content": "没有 uuid"}, _topic_item()]} + topics = discussion.fetch_topics(FakeSession(payload), "bbs-1") + self.assertEqual([t["uuid"] for t in topics], ["uuid-1"]) + + +class RenderTopicsTestCase(unittest.TestCase): + def test_list_view_has_numbers_and_body(self): + topics = [discussion.normalize_topic(_topic_item()), + discussion.normalize_topic(_topic_item(uuid="u2", createrName="李四"))] + out = discussion.render_topics(topics, page=1) + self.assertIn("第 1 页", out) + self.assertIn("1.", out) + self.assertIn("张三", out) + self.assertIn("企业外部环境", out) + + def test_empty_page_is_friendly(self): + self.assertIn("没有帖子", discussion.render_topics([], page=3)) + + +class FakeTaskCenter: + def __init__(self, session, bbsid="2a4b2fff0f67dd5b88099bcd5c2a941e"): + """Initialize configuration and runtime state.""" + self.session = session + self._bbsid = bbsid + + def get_course_tasks(self, course): + return [{"name": "第1章"}] + + def open_task(self, task): + return {"encryTaskUserId": "u1"} + + def get_groups(self, encry): + return [{"encryptGroupId": "g1"}] + + def get_plans(self, encry, group): + return [{"planType": 14, "encryptPlanId": "p1"}] + + def get_study_url(self, encry, plan_id): + return ("https://groupweb.chaoxing.com/pc/topic/jumpToTopicDetail?" + "bbsid=" + self._bbsid + "&uuid=topic-uuid") + + +class ResolveBbsidTestCase(unittest.TestCase): + def test_bbsid_from_task_center(self): + tc = FakeTaskCenter(FakeSession({"status": True, "datas": []})) + self.assertEqual(discussion.resolve_bbsid(tc, {"title": "课"}), + "2a4b2fff0f67dd5b88099bcd5c2a941e") + + def test_direct_bbsid_wins(self): + tc = FakeTaskCenter(FakeSession({"status": True, "datas": []})) + self.assertEqual(discussion.resolve_bbsid(tc, {"bbsid": "direct"}), "direct") + + def test_missing_board_returns_empty(self): + class EmptyTC: + """Provide a synthetic test dependency.""" + + def get_course_tasks(self, course): + return [] + self.assertEqual(discussion.resolve_bbsid(EmptyTC(), {"title": "课"}), "") + + +class DiscussCliListOnlyTestCase(unittest.TestCase): + def test_list_only_prints_topics_and_returns_zero(self): + payload = {"status": True, "datas": [_topic_item()]} + session = FakeSession(payload) + tc = FakeTaskCenter(session) + chaoxing = mock.Mock() + chaoxing.get_course_list.return_value = [{"courseId": "1", "title": "示例课程"}] + buf = io.StringIO() + with contextlib.redirect_stdout(buf): + result = discussion.discuss_cli(chaoxing, tc, {}, list_only=True) + self.assertTrue(result["ok"]) + self.assertEqual(result["sent"], 0) + out = buf.getvalue() + self.assertIn("讨论区 · 示例课程", out) + self.assertIn("企业外部环境", out) + + def test_course_without_board_falls_through_to_next(self): + payload = {"status": True, "datas": [_topic_item()]} + session = FakeSession(payload) + tc = FakeTaskCenter(session) + + class Chaoxing: + """Provide a synthetic test dependency.""" + + def get_course_list(self): + return [{"courseId": "1", "title": "没讨论区的课"}, + {"courseId": "2", "title": "示例课程"}] + + calls = [] + + def fake_resolve(tc_, course): + calls.append(course.get("title")) + return "2a4b2fff0f67dd5b88099bcd5c2a941e" if course.get("courseId") == "2" else "" + + with mock.patch.object(discussion, "resolve_bbsid", side_effect=fake_resolve): + buf = io.StringIO() + with contextlib.redirect_stdout(buf): + result = discussion.discuss_cli(Chaoxing(), tc, {}, list_only=True) + self.assertTrue(result["ok"]) + self.assertEqual(calls[:2], ["没讨论区的课", "示例课程"]) + self.assertIn("示例课程", buf.getvalue()) + + + +class ParseSelectionTestCase(unittest.TestCase): + """用户挑帖子:支持 1,3,5 / 1-3 / all.""" + + def test_commas_and_ranges(self): + self.assertEqual(discussion.parse_selection("1,3,5", 10), [1, 3, 5]) + self.assertEqual(discussion.parse_selection("1-3", 10), [1, 2, 3]) + self.assertEqual(discussion.parse_selection("3-1", 10), [1, 2, 3]) + self.assertEqual(discussion.parse_selection("1,2、4", 10), [1, 2, 4]) + + def test_all_and_dedup(self): + self.assertEqual(discussion.parse_selection("all", 3), [1, 2, 3]) + self.assertEqual(discussion.parse_selection("1,1,2", 5), [1, 2]) + + def test_out_of_range_and_invalid(self): + self.assertEqual(discussion.parse_selection("9", 3), None) + self.assertIsNone(discussion.parse_selection("abc", 3)) + self.assertIsNone(discussion.parse_selection("", 3)) + + +class FetchAllTopicsTestCase(unittest.TestCase): + def test_stops_at_short_page(self): + pages = { + 1: [_topic_item(uuid="u%d" % i) for i in range(discussion.DEFAULT_PAGE_SIZE)], + 2: [_topic_item(uuid="last")], + } + + class Sess: + """Provide a synthetic test dependency.""" + + def __init__(self): + """Initialize configuration and runtime state.""" + self.calls = [] + + def get(self, url, **kwargs): + page = kwargs["params"]["page"] + self.calls.append(page) + return FakeResp({"status": True, "datas": pages.get(page, [])}) + + session = Sess() + topics, capped = discussion.fetch_all_topics(session, "bbs") + self.assertEqual(len(topics), discussion.DEFAULT_PAGE_SIZE + 1) + self.assertFalse(capped) + self.assertEqual(session.calls, [1, 2]) + + def test_reports_capped_when_page_limit_reached(self): + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, **kwargs): + return FakeResp({"status": True, + "datas": [_topic_item(uuid="u%d" % kwargs["params"]["page"])] + * discussion.DEFAULT_PAGE_SIZE}) + + topics, capped = discussion.fetch_all_topics(Sess(), "bbs", max_pages=2) + self.assertTrue(capped) + self.assertEqual(len(topics), discussion.DEFAULT_PAGE_SIZE * 2) + + +class FakeBoardTaskCenter: + def __init__(self, draft): + """Initialize configuration and runtime state.""" + self.session = FakeSession({"status": True, "datas": []}) + self._draft = draft + self.drafts = [] + self.submitted = [] + + def get_course_tasks(self, course): + return [{"name": "第1章"}] + + def open_task(self, task): + return {"encryTaskUserId": "u1"} + + def get_groups(self, encry): + return [{"encryptGroupId": "g1"}] + + def get_plans(self, encry, group): + return [{"planType": 14, "encryptPlanId": "p1"}] + + def get_study_url(self, encry, plan_id): + return ("https://groupweb.chaoxing.com/pc/topic/jumpToTopicDetail?" + "bbsid=2a4b2fff0f67dd5b88099bcd5c2a941e&uuid=topic-uuid") + + def draft_reply(self, bbsid, topic_uuid, course=None, name="", referer="", + revision_hint="", previous_reply=""): + self.drafts.append((topic_uuid, name, revision_hint, previous_reply)) + if revision_hint: + revised = dict(self._draft) + revised["reply"] = "按要求重写后的回复。" + return revised + return self._draft + + def submit_reply(self, bbsid, topic_uuid, **kwargs): + self.submitted.append(topic_uuid) + return True + + +class DiscussCliInteractiveTestCase(unittest.TestCase): + """挑帖 → 草稿 → 确认 → 逐条发送.""" + + def _run(self, inputs, draft=None, auto_yes=False): + payload = {"status": True, "datas": [_topic_item(uuid="u1"), _topic_item(uuid="u2")]} + tc = FakeBoardTaskCenter(draft or { + "topic_info": {"url_token": uuid4().hex}, "title": "标题", + "reply": "我觉得吧,机会和能不能抓住是两回事。", "has_replied": False, + "referer": "https://groupweb.chaoxing.com/pc/topic/jumpToTopicDetail?x=1", + }) + tc.session = FakeSession(payload) + chaoxing = mock.Mock() + chaoxing.get_course_list.return_value = [{"courseId": "1", "title": "示例课程"}] + answers = list(inputs) + + def fake_input(prompt=""): + return answers.pop(0) if answers else "q" + + buf = io.StringIO() + with mock.patch("builtins.input", fake_input), contextlib.redirect_stdout(buf): + code = discussion.discuss_cli(chaoxing, tc, {}, auto_yes=auto_yes) + return code, tc, buf.getvalue() + + def test_confirm_yes_sends_one(self): + result, tc, out = self._run(["1", "y"]) + self.assertEqual(result["sent"], 1) + self.assertEqual(tc.submitted, ["u1"]) + self.assertIn("我觉得吧", out) # 草稿给用户看了 + self.assertIn("发送 1 条", out) + + def test_confirm_no_skips(self): + _result, tc, out = self._run(["1", "n"]) + self.assertEqual(tc.submitted, []) + self.assertIn("已跳过这条", out) + + def test_multi_select_sends_one_by_one(self): + _result, tc, out = self._run(["1-2", "y", "y"]) + self.assertEqual(tc.submitted, ["u1", "u2"]) + self.assertIn("[1/2]", out) + self.assertIn("[2/2]", out) + + def test_already_replied_is_skipped(self): + draft = {"topic_info": {"url_token": uuid4().hex}, "title": "标题", "reply": "", + "has_replied": True, "referer": ""} + _result, tc, out = self._run(["1", "y"], draft=draft) + self.assertEqual(tc.submitted, []) + self.assertIn("已经回复过", out) + + def test_auto_yes_does_not_auto_send(self): + """--yes 只跳过启动确认;把 AI 回复发到公开讨论区必须逐条确认.""" + result, tc, _out = self._run(["1"], auto_yes=True) + self.assertEqual(tc.submitted, []) + self.assertEqual(result["sent"], 0) + + def test_rewrite_with_hint_previews_new_draft_before_send(self): + result, tc, out = self._run(["1", "r", "更短一点,别举案例", "y"]) + self.assertEqual(result["sent"], 1) + self.assertEqual(tc.submitted, ["u1"]) + self.assertIn("按要求重写后的回复", out) + self.assertIn("已按你的方向重写", out) + self.assertEqual(tc.drafts[1][2], "更短一点,别举案例") + self.assertIn("机会和能不能抓住", tc.drafts[1][3]) + + def test_rewrite_never_submits_original_when_user_skips(self): + result, tc, out = self._run(["1", "r", "语气更平实", "n"]) + self.assertEqual(result["sent"], 0) + self.assertEqual(tc.submitted, []) + self.assertIn("按要求重写后的回复", out) + + def test_revision_hint_is_capped(self): + result, tc, out = self._run(["1", "r", "很" * 130, "n"]) + self.assertEqual(result["sent"], 0) + self.assertEqual(len(tc.drafts[1][2]), discussion.MAX_REVISION_HINT_LENGTH) + self.assertIn("优化方向过长", out) + + +class DraftSubmitSplitTestCase(unittest.TestCase): + """模式 2 的草稿/提交拆分:草稿不提交,提交才发请求.""" + + def _tc(self): + from api.task_center import TaskCenter + tc = TaskCenter(object(), {}) + + class Sess: + """Provide a synthetic test dependency.""" + + def __init__(self): + """Initialize configuration and runtime state.""" + self.posts = [] + + def get(self, url, **kwargs): + return FakeResp({"status": True}) + + def post(self, url, **kwargs): + self.posts.append(url) + return FakeResp({"status": True, "datas": [{"id": 1}]}) + + tc.session = Sess() + tc.writer = mock.Mock(available=True) + tc.writer.discussion.return_value = "先说观点:机会不等于结果,能不能抓住看自身资源。" + return tc + + def test_draft_does_not_post(self): + tc = self._tc() + info = {"url_token": uuid4().hex, "title": "标题", "content": "正文", "user_puid": "1"} + with mock.patch("api.task_center._extract_discussion_topic", return_value=info), \ + mock.patch.object(type(tc), "_load_discussion_replies", return_value=([], False)): + draft = tc.draft_reply("bbs", "uuid", course={"title": "课"}, name="帖子") + self.assertEqual(tc.session.posts, []) + self.assertIn("机会不等于结果", draft["reply"]) + + def test_redraft_passes_hint_and_previous_reply_to_writer(self): + tc = self._tc() + info = {"url_token": uuid4().hex, "title": "标题", "content": "正文", "user_puid": "1"} + with mock.patch("api.task_center._extract_discussion_topic", return_value=info), \ + mock.patch.object(type(tc), "_load_discussion_replies", return_value=([], False)): + tc.draft_reply("bbs", "uuid", course={"title": "课"}, name="帖子", + revision_hint="更简洁", previous_reply="原稿") + self.assertEqual(tc.writer.discussion.call_args.kwargs["revision_hint"], "更简洁") + self.assertEqual(tc.writer.discussion.call_args.kwargs["previous_reply"], "原稿") + + def test_submit_posts_and_records(self): + tc = self._tc() + with mock.patch("api.task_center.review.record") as recorder: + ok = tc.submit_reply("bbs", "uuid", course={"title": "课"}, name="帖子", + topic_info={"url_token": uuid4().hex}, reply="正文内容", + referer="https://x/y", echo=False) + self.assertTrue(ok) + self.assertEqual(len(tc.session.posts), 1) + self.assertTrue(recorder.called) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_homework.py b/tests/test_homework.py new file mode 100644 index 000000000..f17865a72 --- /dev/null +++ b/tests/test_homework.py @@ -0,0 +1,273 @@ +# -*- coding: utf-8 -*- +"""任务中心作业任务点(planType=4)离线回归.""" +# +# 覆盖: +# * 新版作业页(mooc2/work/dowork)解析:题型、题干、选项、表单字段、提交地址 +# * study_homework:选择题/填空题作答 + 提交表单字段 + 填空题按空提交 +# * 失败不假装成功:页面无题目 / 简答题无写作器 / confirm 模式无终端 +# * get_job_list 多页解析:num>=1 无 mArg 时按预期跳过,仍能读出 num=0 的任务点 +# 全部离线,不联网、不碰真实数据。 +import os +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-hw-")) + +from api import base as base_mod # noqa: E402 +from api import decode as decode_mod # noqa: E402 +from api.task_center import TaskCenter # noqa: E402 + +HOMEWORK_PAGE = """ +作业作答 +
+ + + + + + + + + + +
+

(多选题)

以下属于战略管理特征的有哪些?

+ + +
+
A
+
B
+
+
+
+

环境分析的内容有___、___。

+ + +
+ + +
+
+
+""" + +HOMEWORK_URL = "https://mooc1.chaoxing.com/mooc-ans/mooc2/work/task?workId=54765819" + +SHORTANSWER_PAGE = ( + HOMEWORK_PAGE + .replace('typeName="填空题"', 'typeName="简答题"') + .replace('id="answertypeq2" name="answertypeq2" value="2"', + 'id="answertypeq2" name="answertypeq2" value="4"') +) + + +class FakeResponse: + def __init__(self, status_code=200, text="", payload=None): + """Initialize configuration and runtime state.""" + self.status_code = status_code + self.text = text + self._payload = payload + + def json(self): + if self._payload is None: + raise ValueError("not json") + return self._payload + + +class FakeSession: + def __init__(self, routes): + """Initialize configuration and runtime state.""" + self.routes = routes + self.calls = [] + self.kwargs_calls = [] + + def _dispatch(self, method, url, **kwargs): + self.calls.append((method, url)) + self.kwargs_calls.append(kwargs) + for key, resp in self.routes: + if key in url: + return resp + return FakeResponse(status_code=404) + + def get(self, url, **kwargs): + return self._dispatch("get", url, **kwargs) + + def post(self, url, **kwargs): + return self._dispatch("post", url, **kwargs) + + +class FakeTiku: + DISABLE = False + + def __init__(self, answers): + """Initialize configuration and runtime state.""" + self.answers = answers + + def query_all(self, questions, query_delay=0.0): + return list(self.answers) + + def judgement_select(self, answer): + return str(answer).strip().lower() in ("对", "正确", "true", "1", "是") + + +class HomeworkDecodeTestCase(unittest.TestCase): + def test_title_survives_invalid_h3_nesting(self): + """真实页面把

嵌在

里,lxml 会提前闭合 h3;题干不能丢.""" + page = decode_mod.decode_homework_page(HOMEWORK_PAGE) + self.assertIn("以下属于战略管理特征的有哪些?", page["questions"][0]["title"]) + self.assertIn("环境分析的内容有", page["questions"][1]["title"]) + + def test_parses_questions_and_form_fields(self): + page = decode_mod.decode_homework_page(HOMEWORK_PAGE) + self.assertEqual([q["id"] for q in page["questions"]], ["q1", "q2"]) + self.assertEqual(page["questions"][0]["type"], "multiple") + self.assertEqual(page["questions"][1]["type"], "completion") + self.assertIn("A 战略管理具有全局性", page["questions"][0]["options"]) + self.assertEqual(page["answerwqbid"], "q1,q2,") + self.assertTrue(page["form_action"].startswith("/mooc-ans/work/addStudentWorkNewWeb")) + self.assertEqual(page["workRelationId"], "54765819") + self.assertEqual(page["cpi"], "1000003") + + def test_missing_form_is_not_parsed_as_finished(self): + page = decode_mod.decode_homework_page("请登录") + self.assertEqual(page["questions"], []) + self.assertEqual(page["answerwqbid"], "") + + +class StudyHomeworkTestCase(unittest.TestCase): + def _tc(self, page, answers, submit_mode="auto", writer=None): # noqa: D102 + cx = mock.Mock() + cx.tiku = FakeTiku(answers) + tc = TaskCenter(cx, {"task_center_submit_mode": submit_mode}, writer=writer) + tc.session = FakeSession([ + ("mooc2/work/task", FakeResponse(text=page)), + ("addStudentWorkNewWeb", FakeResponse(payload={"status": True, "msg": "提交成功"})), + ]) + return tc + + def test_submits_objective_and_completion_answers(self): + # 题库对多选题返回字母串,对填空题返回按空拆分的列表 + tc = self._tc(HOMEWORK_PAGE, ["AB", ["水", "土"]]) + ok = tc.study_homework( + "https://mooc1.chaoxing.com/mooc-ans/mooc2/work/task?workId=54765819", + {"name": "第1章作业"}, + ) + self.assertTrue(ok) + data = [kw["data"] for kw in tc.session.kwargs_calls if "data" in kw][-1] + self.assertEqual(data["answerq1"], "AB") + self.assertEqual(data["answertypeq1"], "1") + self.assertEqual(data["answerEditorq21"], "水") + self.assertEqual(data["answerEditorq22"], "土") + self.assertNotIn("answerq2", data) # 填空题按空提交 + self.assertEqual(data["pyFlag"], "") + self.assertEqual(data["workRelationId"], "54765819") + self.assertEqual(data["answerwqbid"], "q1,q2,") + post_urls = [url for method, url in tc.session.calls if method == "post"] + self.assertEqual(len(post_urls), 1) + self.assertIn("addStudentWorkNewWeb", post_urls[0]) + self.assertIn("pyFlag=&ua=pc", post_urls[0]) + + def test_submit_rejected_by_platform_is_not_success(self): + cx = mock.Mock() + cx.tiku = FakeTiku(["AB", ["水", "土"]]) + tc = TaskCenter(cx, {"task_center_submit_mode": "auto"}) + tc.session = FakeSession([ + ("mooc2/work/task", FakeResponse(text=HOMEWORK_PAGE)), + ("addStudentWorkNewWeb", FakeResponse(payload={"status": False, "msg": "重复提交"})), + ]) + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "作业"})) + + def test_recent_submission_is_not_repeated(self): + """本地台账里有近期提交记录:不再重复提交(平台状态有延迟).""" + tc = self._tc(HOMEWORK_PAGE, ["AB", ["水", "土"]]) + plan = {"name": "第1章作业", "planId": "plan-ledger-1"} + tc._mark_submitted(plan) + self.assertTrue(tc._recently_submitted(plan)) + self.assertTrue(tc.study_homework(HOMEWORK_URL, plan)) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_other_plan_is_not_affected(self): + tc = self._tc(HOMEWORK_PAGE, ["AB", ["水", "土"]]) + tc._mark_submitted({"planId": "plan-a"}) + self.assertFalse(tc._recently_submitted({"planId": "plan-b"})) + + def test_page_without_questions_does_not_submit(self): + tc = self._tc("
", []) + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "作业"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_shortanswer_without_writer_does_not_submit(self): + writer = mock.Mock() + writer.available = False + tc = self._tc(SHORTANSWER_PAGE, [None], writer=writer) + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "作业"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + def test_confirm_mode_without_tty_does_not_submit(self): + tc = self._tc(HOMEWORK_PAGE, ["AB", ["水", "土"]], submit_mode="confirm") + with mock.patch.object(sys.stdin, "isatty", return_value=False): + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "作业"})) + self.assertFalse(any(method == "post" for method, _ in tc.session.calls)) + + +class JobListParseTestCase(unittest.TestCase): + CARD_PAGE = ( + 'mArg={"attachments":[{"type":"workid","jobid":"w-1","enc":"e2","job":{"a":1}}],' + '"defaults":{"ktoken":"k","cpi":"3","knowledgeid":"9"}};' + ) + + def _run(self, pages): + cx = base_mod.Chaoxing() + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, params=None, **kwargs): + num = str((params or {}).get("num", "")) + return FakeResponse(text=pages.get(num, "")) + + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()): + return cx.get_job_list( + {"clazzId": "1", "courseId": "2", "cpi": "3"}, {"id": "9", "title": "t"} + ) + + def test_reads_jobs_when_later_pages_have_no_marg(self): + pages = {"0": self.CARD_PAGE} + for num in "123456": + pages[num] = "mArg = $mArg;" + jobs, info = self._run(pages) + self.assertEqual([j["jobid"] for j in jobs], ["w-1"]) + self.assertEqual(info.get("knowledgeid"), "9") + + def test_all_pages_without_marg_is_read_failure(self): + jobs, info = self._run({"0": "no json here"}) + self.assertIsNone(jobs) + self.assertTrue(info.get("parseError")) + + def test_missing_pages_are_summarized_once(self): + """逐页无 mArg 不再逐条刷日志,每章汇总成一条.""" + pages = {"0": self.CARD_PAGE} + for num in "123456": + pages[num] = "mArg = $mArg;" + messages = [] + sink_id = base_mod.logger.add( + lambda message: messages.append(message.record["message"]), level="DEBUG" + ) + try: + jobs, _info = self._run(pages) + finally: + base_mod.logger.remove(sink_id) + self.assertEqual([j["jobid"] for j in jobs], ["w-1"]) + self.assertFalse([m for m in messages if "找不到 mArg" in m], messages) + self.assertEqual(len([m for m in messages if "无 mArg" in m]), 1, messages) + + def test_duplicate_jobids_across_pages_are_deduped(self): + jobs, _info = self._run({"0": self.CARD_PAGE, "1": self.CARD_PAGE}) + self.assertEqual(len(jobs), 1) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_human_likeness.py b/tests/test_human_likeness.py new file mode 100644 index 000000000..7ef0f6ef0 --- /dev/null +++ b/tests/test_human_likeness.py @@ -0,0 +1,226 @@ +# -*- coding: utf-8 -*- +"""真人化回归:任何"提交给平台"的文本都不能露出 AI/机器痕迹(不联网).""" +# +# 需要防止的错误格式:AI实践选择题被拼成 +# "选 D。D:……。依据:回答正确!……平台判据:……" —— 既不是人的作答格式, +# 又把平台自己的判分反馈回显了出来。 +import json +import os +import sys +import tempfile +import unittest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-test-")) + +from api.ai_writer import HumanLikeWriter # noqa: E402 +from api.task_center import TaskCenter # noqa: E402 + +sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "tools", "audit")) +import importlib.util # noqa: E402 + +_AUDIT_PATH = os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), + "tools", "audit", "01_human_likeness_audit.py", +) +_spec = importlib.util.spec_from_file_location("human_audit", _AUDIT_PATH) +human_audit = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(human_audit) + + +class ObjectiveAnswerTestCase(unittest.TestCase): + """选择题/判断题只提交字母或对错,不能带解释、不能回显平台反馈.""" + + class Writer: + """Provide a synthetic test dependency.""" + + def __init__(self, choice="D", judge="对"): + """Initialize configuration and runtime state.""" + self.choice = choice + self.judge = judge + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + return self.choice + + def choose_judgement(self, question, context="", exclude=None): + return self.judge + + def _turn(self, qtype, options): + return { + "questionStem": "关于公司层战略的说法正确的是?", + "questionTypeInt": qtype, + "options": options, + "preAppendContent": "真遗憾,回答错误了呢。本题考核知识点为公司层战略。", + } + + def test_single_choice_returns_bare_letter(self): + tc = TaskCenter(object(), {}, writer=self.Writer(choice="D")) + answer = tc._ai_answer( + self._turn("0", [{"option": "C", "optionContent": "c"}, {"option": "D", "optionContent": "d"}]), + {"messageList": []}, + ) + self.assertEqual(answer, "D") + + def test_single_choice_retry_still_bare_letter(self): + tc = TaskCenter(object(), {}, writer=self.Writer(choice="D")) + answer = tc._ai_answer( + self._turn("0", [{"option": "C", "optionContent": "c"}, {"option": "D", "optionContent": "d"}]), + {"messageList": []}, + exclude={"D"}, + ) + self.assertRegex(answer, r"^[A-E]$") + + def test_multiple_choice_returns_letters_only(self): + tc = TaskCenter(object(), {}, writer=self.Writer(choice="BD")) + answer = tc._ai_answer( + self._turn("1", [{"option": "A", "optionContent": "a"}, + {"option": "B", "optionContent": "b"}, + {"option": "D", "optionContent": "d"}]), + {"messageList": []}, + ) + self.assertRegex(answer, r"^[A-E]+$") + + def test_no_platform_feedback_leaks_into_answer(self): + tc = TaskCenter(object(), {}, writer=self.Writer(choice="D")) + answer = tc._ai_answer( + self._turn("0", [{"option": "D", "optionContent": "d"}]), + {"messageList": [{"role": 2, "content": json.dumps( + {"preAppendContent": "回答正确!本题考核知识点为公司层战略。"})}]}, + ) + for word in ("依据", "回答正确", "考核知识点", "平台判据"): + self.assertNotIn(word, answer) + + +class AuditToolTestCase(unittest.TestCase): + def test_flags_the_real_incident(self): + bad = [{ + "kind": "AI实践客观题", + "text": "选 D。D:职能层战略需要支撑企业总体战略。依据:回答正确!", + }] + self.assertGreater(human_audit.audit_all(bad)["problems"], 0) + + def test_clean_text_passes(self): + good = [{ + "kind": "主题讨论", + "text": "使命和考核对不上,墙上那句话很快就没人提了,这个反差课下聊起来挺有意思。", + }] + self.assertEqual(human_audit.audit_all(good)["problems"], 0) + + def test_flags_fabricated_resume(self): + """在校学生的"我实习那家公司"没有可验证的素材支持.""" + bad = [{"kind": "主题讨论", + "text": "我之前实习那家公司就这样,使命写得挺响,实际考核全是拉新和续费。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("编造的个人琐事", rules) + self.assertTrue(HumanLikeWriter.style_problems( + "我之前实习那家公司就这样,使命写得挺响,实际考核全是拉新和续费。")) + + def test_flags_fabricated_part_time_job(self): + """实测模型会写"我在奶茶店做过兼职"——同样是没有依据的个人经历.""" + text = "我在奶茶店做过兼职,店长从来不提什么使命,但排班先照顾谁心里有数。" + rules = {rule for item in human_audit.audit_all( + [{"kind": "主题讨论", "text": text}])["items"] for rule, _ in item["issues"]} + self.assertIn("编造的个人琐事", rules) + self.assertTrue(HumanLikeWriter.style_problems(text)) + + def test_flags_ai_connectors_and_markdown(self): + bad = [{ + "kind": "思考题", + "text": "首先,使命很重要。其次,愿景也很重要。\n- 第一点\n- 第二点", + }] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("AI 腔", rules) + self.assertIn("排版痕迹", rules) + + def test_flags_closing_cliche(self): + bad = [{"kind": "思考题", + "text": "课上讲了不少,我觉得关键还是先把概念分清楚,真正难的是让下面的人知道明天改什么。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("金句", rules) + + def test_flags_unsourced_specifics(self): + bad = [{"kind": "主题讨论", + "text": "上学期我们小组做过一个校园二手平台的案例分析,三个月只成交几十单,后来才慢慢跑起来。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("无来源的假具体", rules) + + def test_flags_uniform_habits(self): + bad = [{"kind": "思考题", + "text": "我觉得这块挺重要的,其实老师上课讲过,反正考试大概率会考,可能还是要记一下。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("口癖分布过密", rules) + + def test_single_sample_does_not_trigger_batch_rules(self): + one = [{"kind": "主题讨论", + "text": "使命和考核对不上,墙上那句话很快就没人提了,这个反差课下聊起来挺有意思。"}] + self.assertEqual(human_audit.audit_all(one)["problems"], 0) + + def test_flags_batch_level_fingerprint(self): + batch = [ + {"kind": "思考题", "text": "我觉得这门课挺有用的,其实老师讲过好几个例子。"}, + {"kind": "作业简答", "text": "我觉得重点是环境分析,其实课上举过不少例子。"}, + ] + rules = {rule for item in human_audit.audit_all(batch)["items"] for rule, _ in item["issues"]} + self.assertIn("整批口癖雷同", rules) + + def test_flags_structure_cliche(self): + bad = [{"kind": "思考题", + "text": "课上讲过这几层的关系。使命管的是为什么干,愿景管的是干成什么样,目标管的是今年先干什么。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("三层排比/对偶", rules) + + def test_flags_fake_personal_anecdote(self): + bad = [{"kind": "作业简答", + "text": "我上个月注册一个App,光隐私协议就弹了三次,说明合规成本确实在涨。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("编造的个人琐事", rules) + + def test_flags_dangling_reference_without_context(self): + bad = [{"kind": "主题讨论", + "text": "奶茶店那个例子挺直观的。我觉得使命和愿景确实容易混。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("引用不存在的前文", rules) + + def test_dangling_reference_ok_only_with_real_refs(self): + ok = [{"kind": "主题讨论", + "context_refs": ["我觉得奶茶店那个例子挺直观的,使命就是让大家喝到便宜好喝的奶茶。"], + "text": "奶茶店那个例子挺直观的。我觉得使命和愿景确实容易混着说。"}] + rules = {rule for item in human_audit.audit_all(ok)["items"] for rule, _ in item["issues"]} + self.assertNotIn("引用不存在的前文", rules) + + def test_context_flag_alone_is_not_enough(self): + """光声明 has_context 不行:必须真带上被引用的原文.""" + bad = [{"kind": "主题讨论", "has_context": True, + "text": "奶茶店那个例子挺直观的。我觉得使命和愿景确实容易混着说。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("引用不存在的前文", rules) + + def test_flags_weak_ending_tic(self): + bad = [{"kind": "思考题", + "text": "课上讲过这三者的关系。使命是企业存在的理由,愿景是将来变成什么样。不过这块我其实没太想明白。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("示弱收尾口癖", rules) + + def test_flags_claimed_community_experience(self): + bad = [{"kind": "主题讨论", + "text": "使命和愿景容易混。我们小组上次讨论时也卡在这里,有人觉得愿景要写长一点。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("认领共同经历", rules) + + def test_flags_missing_course_anchor(self): + bad = [{"kind": "思考题", + "text": "使命是企业存在的理由,回答的是为什么要做这件事。愿景是往远处看的一个画面,说清楚将来想变成什么样子。目标则更落地,把愿景拆成一段时间内能做到的事。"}] + rules = {rule for item in human_audit.audit_all(bad)["items"] for rule, _ in item["issues"]} + self.assertIn("没有课程锚点", rules) + + def test_batch_structure_repetition(self): + batch = [ + {"kind": "思考题", "text": "先说使命。使命管的是为什么干,愿景管的是干成什么样,目标管的是今年干什么。"}, + {"kind": "作业简答", "text": "换个说法。使命管的是为什么要做,愿景管的是做到什么程度,目标管的是当下先做什么。"}, + ] + rules = {rule for item in human_audit.audit_all(batch)["items"] for rule, _ in item["issues"]} + self.assertIn("整批结构雷同", rules) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_llm.py b/tests/test_llm.py new file mode 100644 index 000000000..c23566503 --- /dev/null +++ b/tests/test_llm.py @@ -0,0 +1,167 @@ +# -*- coding: utf-8 -*- +"""大模型调用策略(api/llm.py)与答题解析/投票回归.""" +# +# 背景:DeepSeek flash 不同版本的 thinking 行为不同——旧版正文为空、新版默认带推理。 +# 代码不能再写死"永远关 thinking"(会降低正确率),也不能假设一定有 content。 +# 全部离线,不联网。 +import os +import sys +import tempfile +import threading +import unittest + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-llm-")) + +from api import llm # noqa: E402 +from api.answer import AI, parse_answer_text # noqa: E402 + + +class FakeMessage: + def __init__(self, content="", reasoning=""): + """Initialize configuration and runtime state.""" + self.content = content + self.reasoning_content = reasoning + + +class FakeChoice: + def __init__(self, message): + """Initialize configuration and runtime state.""" + self.message = message + + +class FakeResponse: + def __init__(self, message): + """Initialize configuration and runtime state.""" + self.choices = [FakeChoice(message)] + + +class FakeClient: + """按脚本依次返回响应或抛错.""" + + def __init__(self, script): + """Initialize configuration and runtime state.""" + self.script = list(script) + self.calls = [] + outer = self + + class Completions: + """Provide a synthetic test dependency.""" + + def create(self, **kwargs): + outer.calls.append(kwargs) + item = outer.script.pop(0) if outer.script else FakeResponse(FakeMessage("")) + if isinstance(item, BaseException): + raise item + return item + + self.chat = type("Chat", (), {"completions": Completions()})() + + +class ThinkingPolicyTestCase(unittest.TestCase): + def test_normalize(self): + self.assertEqual(llm.normalize_thinking(None), "auto") + self.assertEqual(llm.normalize_thinking("ON"), "on") + self.assertEqual(llm.normalize_thinking("off"), "off") + self.assertEqual(llm.normalize_thinking("bogus"), "auto") + + def test_steps(self): + self.assertEqual(llm.thinking_steps("auto"), ["auto", "off"]) + self.assertEqual(llm.thinking_steps("on"), ["on", "auto"]) + self.assertEqual(llm.thinking_steps("off"), ["off", "auto"]) + + def test_extract_text(self): + self.assertEqual(llm.extract_text(FakeMessage(" a ", " b ")), ("a", "b")) + self.assertEqual(llm.extract_text({"content": "x"}), ("x", "")) + + def test_thinking_param_error(self): + self.assertTrue(llm.is_thinking_param_error(Exception("Unsupported parameter: thinking"))) + self.assertFalse(llm.is_thinking_param_error(Exception("timeout"))) + + +class CreateCompletionTestCase(unittest.TestCase): + def test_returns_content(self): + client = FakeClient([FakeResponse(FakeMessage('{"Answer": ["A"]}'))]) + out = llm.create_completion(client, model="m", messages=[], thinking="auto") + self.assertEqual(out, '{"Answer": ["A"]}') + self.assertNotIn("extra_body", client.calls[0]) # auto 不显式指定 thinking + + def test_reasoning_fallback_only_for_answer_path(self): + client = FakeClient([FakeResponse(FakeMessage("", "答案是 A"))]) + self.assertEqual( + llm.create_completion(client, model="m", messages=[], + allow_reasoning_fallback=True), + "答案是 A", + ) + client2 = FakeClient([FakeResponse(FakeMessage("", "答案是 A")), + FakeResponse(FakeMessage("正常正文"))]) + self.assertEqual(llm.create_completion(client2, model="m", messages=[]), "正常正文") + + def test_empty_content_falls_back_to_thinking_off(self): + client = FakeClient([FakeResponse(FakeMessage("")), FakeResponse(FakeMessage("ok"))]) + out = llm.create_completion(client, model="m", messages=[], thinking="auto") + self.assertEqual(out, "ok") + self.assertEqual(client.calls[0].get("extra_body"), None) + self.assertEqual(client.calls[1].get("extra_body"), {"thinking": {"type": "disabled"}}) + + def test_param_error_retries_without_thinking(self): + client = FakeClient([Exception("400 Unsupported parameter: thinking"), + FakeResponse(FakeMessage("ok"))]) + out = llm.create_completion(client, model="m", messages=[], thinking="off") + self.assertEqual(out, "ok") + self.assertNotIn("extra_body", client.calls[1]) + + +class ParseAnswerTestCase(unittest.TestCase): + def test_variants(self): + self.assertEqual(parse_answer_text('{"Answer": ["A"]}'), "A") + self.assertEqual(parse_answer_text('\u0060\u0060\u0060json\n{"Answer": ["A","C"]}\n\u0060\u0060\u0060'), "A\nC") + self.assertEqual(parse_answer_text('["A", "B"]'), "A\nB") + self.assertEqual(parse_answer_text("答案:A"), "A") + self.assertEqual(parse_answer_text("A"), "A") + self.assertEqual(parse_answer_text(""), "") + + +class VotingTestCase(unittest.TestCase): + def _ai(self, script, votes=3): + tiku = AI.__new__(AI) + tiku.name = "AI大模型答题" + tiku.model = "test-model" + tiku.thinking = "auto" + tiku.objective_votes = votes + tiku.min_interval_seconds = 0 + tiku.last_request_time = None + tiku._lock = threading.Lock() + tiku.work_feedback = None + tiku._wait_for_interval = lambda: None + tiku._build_work_feedback_text = lambda: "" + seq = iter(script) + + def fake_complete(messages, **kwargs): + item = next(seq) + if isinstance(item, BaseException): + raise item + return item + + tiku._complete = fake_complete + return tiku + + def test_majority_wins(self): + tiku = self._ai(["A", '{"Answer": ["A", "C"]}', "A、C"]) + out = tiku._query_locked({"type": "multiple", "title": "t", "options": "A x\nB y\nC z"}) + self.assertEqual(out, "A\nC") + + def test_single_question_uses_one_vote(self): + tiku = self._ai(["B"], votes=3) + out = tiku._query_locked({"type": "single", "title": "t", "options": "A x\nB y"}) + self.assertEqual(out, "B") + + def test_all_calls_failed_returns_none(self): + tiku = self._ai([Exception("boom"), Exception("boom"), Exception("boom")]) + self.assertIsNone( + tiku._query_locked({"type": "multiple", "title": "t", "options": "A x"}) + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_platform_fixes.py b/tests/test_platform_fixes.py new file mode 100644 index 000000000..3a4f6385c --- /dev/null +++ b/tests/test_platform_fixes.py @@ -0,0 +1,772 @@ +# -*- coding: utf-8 -*- +"""离线回归测试:平台文本 / 填空题提交 / 大模型连接检查 / 视频并发开关.""" +# +# 对应上游 issue: +# #602 课程名含  ( ) 时控制台编码崩溃 +# #615 #575 填空题答案保存后为空 +# #603 思考模型连接检查误判失败 +# #588 视频并发导致进度回退(提供串行开关) +# 全部测试不联网、不读写用户真实数据。 +import json +import os +import sys +import tempfile +import threading +import time +import unittest +from uuid import uuid4 + +import requests +from bs4 import BeautifulSoup + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +# 必须在导入 api 之前指定数据目录,避免碰到用户真实配置 +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-test-")) + +import main # noqa: E402 +from api import answer as answer_mod # noqa: E402 +from api import guard # noqa: E402 +from api import paths # noqa: E402 +from api.answer import CacheDAO # noqa: E402 +from api.base import ( # noqa: E402 + Account, + Chaoxing, + StudyResult, + _parse_progress_passed, + answers_equal, + build_completion_fields, + build_multiple_answer, + clean_res, + evaluate_work_detail, + split_completion_answer, +) +from requests import RequestException # noqa: E402 +from api.decode import ( # noqa: E402 + _get_question_type, + clean_text, + decode_course_card, + decode_course_folder, + decode_course_list, + decode_course_point, + decode_questions_info, + _extract_choices, +) + + +class CleanTextTestCase(unittest.TestCase): + """#602:特殊空白字符在 GBK 控制台会直接把程序打崩.""" + + def test_nbsp_becomes_space(self): + self.assertEqual(clean_text("数据\xa0结构"), "数据 结构") + + def test_exotic_spaces_and_zero_width(self): + self.assertEqual(clean_text("a\u3000b"), "a b") + self.assertEqual(clean_text("a\u200bb"), "ab") + + def test_none_and_blank(self): + self.assertEqual(clean_text(None), "") + self.assertEqual(clean_text(" "), "") + + def test_normal_text_kept(self): + self.assertEqual(clean_text("第一章 绪论"), "第一章 绪论") + + def test_course_title_is_cleaned(self): + html = ( + '
' + '' + '' + '' + '

' + ) + courses = decode_course_list(html) + self.assertEqual(courses[0]["title"], "数据结构 与算法") + + +class DecodeRobustnessTestCase(unittest.TestCase): + """平台改版导致字段缺失时不能直接崩(#58 / #293 / #392 / #593 这类报错).""" + + GOOD_COURSE = ( + '
' + '' + '' + '' + '

' + ) + + def test_course_list_skips_broken_entries(self): + broken = [ + # 缺 input + '
', + # 缺 cpi + '
' + '
', + # 缺标题 + '
' + '
', + ] + courses = decode_course_list(self.GOOD_COURSE + "".join(broken)) + self.assertEqual(len(courses), 1) + self.assertEqual(courses[0]["courseId"], "8") + + def test_course_list_empty_html(self): + self.assertEqual(decode_course_list(""), []) + + def test_course_point_keeps_valid_and_skips_broken(self): + html = ( + '
' + ) + points = decode_course_point(html)["points"] + self.assertEqual(len(points), 2) + self.assertEqual(points[0]["title"], "1.1 绪论") + self.assertEqual(points[0]["jobCount"], "2") + # 标题缺失时用占位名字,不能是 None + self.assertEqual(points[1]["title"], "未命名章节") + + def test_course_point_empty_html(self): + self.assertEqual(decode_course_point("")["points"], []) + + def test_course_folder_skips_broken_entries(self): + html = ('
    ' + '
  • ' + '
  • 缺 rename-input
  • ' + '
  • ' + '
') + folders = decode_course_folder(html) + self.assertEqual([f["id"] for f in folders], ["111"]) + self.assertEqual(folders[0]["rename"], "我的文件夹") + self.assertEqual(decode_course_folder(""), []) + + def test_course_card_invalid_marg_json(self): + # mArg 片段不是合法 JSON 时按读取失败处理,不能抛异常(#313 / #417 附带项) + for html in ("mArg={bad json;", 'mArg={{"x":1};'): + jobs, info = decode_course_card(html) + self.assertEqual(jobs, []) + self.assertTrue(info.get("parseError"), info) + + def test_course_card_without_marg_marks_parse_error(self): + # 登录页 / 空页面取不到 mArg,必须标记 parseError, + # 让上层按"读取失败"重试,而不是当成"这个章节没有任务点"(#223 / #357) + for html in ("", "登录页", "403"): + jobs, info = decode_course_card(html) + self.assertEqual(jobs, []) + self.assertTrue(info.get("parseError"), info) + + def test_course_card_with_empty_marg_is_empty_chapter(self): + # mArg 存在但为空 = 这一章确实没有卡片,走正常的"空章节"流程 + jobs, info = decode_course_card("mArg={};") + self.assertEqual(jobs, []) + self.assertFalse(info.get("parseError"), info) + + def test_quiz_page_without_form(self): + # 接口返回登录页 / 空页面时不能抛 NoneType 异常(#593) + for html in ("", "请登录", "
题目
"): + result = decode_questions_info(html) + self.assertEqual(result.get("questions"), []) + + def test_question_block_without_timu(self): + html = ('
' + '
题目
') + result = decode_questions_info(html) + self.assertIsInstance(result.get("questions"), list) + + +class AnswerEqualityTestCase(unittest.TestCase): + """#627:判断题/多选题/填空题的答案写法不同,不能被判成答错.""" + + def test_identical(self): + self.assertTrue(answers_equal("A", "A")) + + def test_judgement_variants(self): + for mine, right in (("对", "正确"), ("对", "√"), ("√", "正确"), ("错", "×"), ("错误", "不正确")): + self.assertTrue(answers_equal(mine, right, "判断题"), f"{mine} vs {right}") + self.assertFalse(answers_equal("对", "错", "判断题")) + + def test_multiple_choice_order_and_separators(self): + self.assertTrue(answers_equal("ABD", "A,B,D", "多选题")) + self.assertTrue(answers_equal("ABD", "b,a,d", "多选题")) + self.assertFalse(answers_equal("AB", "A", "多选题")) + self.assertFalse(answers_equal("AB", "ABD", "多选题")) + + def test_completion_separators(self): + self.assertTrue(answers_equal("并发#线程", "并发;线程", "填空题")) + self.assertTrue(answers_equal("并发#线程", "并发 线程", "填空题")) + self.assertFalse(answers_equal("并发", "并发 线程", "填空题")) + + def test_hash_is_not_dropped(self): + # 分隔符不能直接删掉,否则 "C#" 和 "C" 会被判成一样 + self.assertFalse(answers_equal("C#", "C", "填空题")) + + def test_fullwidth_and_html(self): + self.assertTrue(answers_equal("A", "A")) + self.assertTrue(answers_equal("A B", "A B")) + self.assertTrue(answers_equal("A", "A")) + + def test_empty_values(self): + self.assertTrue(answers_equal("", "")) + self.assertFalse(answers_equal("", "A")) + + +class MultipleChoiceAnswerTestCase(unittest.TestCase): + """#427 #502:题库返回字母串("AC"/"ABD")时不能漏选或退化成随机.""" + + OPTIONS = "A 甲选项\nB 乙选项\nC 丙选项\nD 丁选项" + + def test_letter_run_is_kept_whole(self): + self.assertEqual(clean_res("AC"), ["AC"]) + self.assertEqual(clean_res("ABD"), ["ABD"]) + self.assertEqual(clean_res("A"), ["A"]) + # "B. 选项内容" 这种前缀仍然要去掉(单个字母的答案不受影响) + self.assertEqual(clean_res("B. 某个选项"), ["某个选项"]) + self.assertEqual(clean_res("B"), ["B"]) + + def test_build_multiple_answer(self): + cases = [ + ("AC", "AC"), + ("ABD", "ABD"), + ("A,B,D", "ABD"), + ("A、B、D", "ABD"), + ("b,a,d", "ABD"), + ("C", "C"), + ("甲选项#丙选项", "AC"), + ("完全无关的答案", ""), + ] + for raw, expected in cases: + self.assertEqual(build_multiple_answer(raw, self.OPTIONS), expected, raw) + + +class OptionImageTestCase(unittest.TestCase): + """#457:选项本身是图片时要把图片地址带上,否则题库只看到一串字母.""" + + def test_image_option_keeps_url(self): + element = BeautifulSoup('
  • ', "lxml").li + result = _extract_choices(element) + self.assertTrue(result.startswith("A")) + self.assertIn("', "lxml").li + self.assertIn("', "lxml").li + self.assertEqual(_extract_choices(element), "B 某个文字选项") + + def test_mixed_option_keeps_text(self): + element = BeautifulSoup('
  • ', "lxml").li + self.assertEqual(_extract_choices(element), "C 看图作答") + + +class WorkDetailEvaluationTestCase(unittest.TestCase): + """#627:页面没渲染出「我的答案」时判定不可信,不能当成答错去重做.""" + + def test_empty_my_answer_is_unjudgeable(self): + detail = [{"title": "题1", "type_label": "判断题", "my_answer": "", "correct_answer": "√"}] + result = evaluate_work_detail(detail) + self.assertFalse(result["all_correct"]) + self.assertTrue(result["unjudgeable"]) + + def test_same_meaning_counts_as_correct(self): + detail = [{"title": "题1", "type_label": "判断题", "my_answer": "对", "correct_answer": "√"}] + result = evaluate_work_detail(detail) + self.assertTrue(result["all_correct"]) + self.assertFalse(result["unjudgeable"]) + + def test_real_wrong_answer_is_judged(self): + detail = [{"title": "题1", "type_label": "判断题", "my_answer": "错", "correct_answer": "√"}] + result = evaluate_work_detail(detail) + self.assertFalse(result["all_correct"]) + self.assertFalse(result["unjudgeable"]) + self.assertEqual(len(result["feedback"]), 1) + + def test_partial_wrong_still_judged(self): + detail = [ + {"title": "题1", "type_label": "判断题", "my_answer": "错", "correct_answer": "√"}, + {"title": "题2", "type_label": "判断题", "my_answer": "", "correct_answer": "√"}, + ] + result = evaluate_work_detail(detail) + self.assertFalse(result["all_correct"]) + self.assertFalse(result["unjudgeable"]) + + +class CompletionAnswerTestCase(unittest.TestCase): + """#615 / #575:填空题必须按空提交,否则网页端显示答案为空.""" + + def test_split_two_blanks(self): + self.assertEqual(split_completion_answer("并发#线程", 2), ["并发", "线程"]) + + def test_single_blank_keeps_hash(self): + # 只有一个空时不能按 # 拆,否则 "C# 语言" 会被切坏 + self.assertEqual(split_completion_answer("C# 语言", 1), ["C# 语言"]) + + def test_unknown_count_splits_by_hash(self): + self.assertEqual(split_completion_answer("a#b", 0), ["a", "b"]) + + def test_more_expected_than_answers(self): + self.assertEqual(split_completion_answer("a#b#c", 2), ["a", "b#c"]) + + def test_list_answer(self): + self.assertEqual(split_completion_answer(["a", "b"], 2), ["a", "b"]) + + def test_empty_inputs(self): + self.assertEqual(split_completion_answer(None, 2), []) + self.assertEqual(split_completion_answer("", 2), []) + + @staticmethod + def _question(qid="42", qtype="completion", atype="2", source="cover"): + return { + "id": qid, + "type": qtype, + "answerField": {f"answer{qid}": "", f"answertype{qid}": atype}, + f"answerSource{qid}": source, + } + + def test_completion_fields_built(self): + form = {"workId": "1", "tiankongsize42": "2", "answer42": "并发#线程"} + build_completion_fields(form, self._question()) + self.assertEqual(form["answerEditor421"], "并发") + self.assertEqual(form["answerEditor422"], "线程") + self.assertEqual(form["tiankongsize42"], 2) + self.assertNotIn("answer42", form) + + def test_single_blank_payload(self): + form = {"tiankongsize42": "1", "answer42": "C# 语言"} + build_completion_fields(form, self._question()) + self.assertEqual(form["answerEditor421"], "C# 语言") + self.assertEqual(form["tiankongsize42"], 1) + + def test_missing_declared_count(self): + form = {"answer42": "a#b"} + build_completion_fields(form, self._question()) + self.assertEqual(form["answerEditor421"], "a") + self.assertEqual(form["answerEditor422"], "b") + self.assertEqual(form["tiankongsize42"], 2) + + def test_empty_answer_still_reports_blanks(self): + form = {"tiankongsize42": "2", "answer42": ""} + build_completion_fields(form, self._question(source="random")) + self.assertEqual(form["answerEditor421"], "") + self.assertEqual(form["answerEditor422"], "") + self.assertEqual(form["tiankongsize42"], 2) + + def test_type_code_10_is_completion(self): + self.assertEqual(_get_question_type("10"), "completion") + form = {"tiankongsize42": "1", "answer42": "x"} + build_completion_fields(form, self._question(atype="10")) + self.assertEqual(form["answerEditor421"], "x") + + def test_other_types_untouched(self): + form = {"answer42": "A", "answertype42": "0"} + build_completion_fields(form, self._question(qtype="single", atype="0")) + self.assertEqual(form["answer42"], "A") + self.assertNotIn("tiankongsize42", form) + + +class _FakeResponse: + status_code = 200 + text = "ok" + + def __init__(self, payload): + """Initialize configuration and runtime state.""" + self._payload = payload + + def json(self): + return self._payload + + +class VideoProgressParseTestCase(unittest.TestCase): + """#175 #298:视频进度上报接口返回非 JSON 时不能抛异常打断整章.""" + + class _Resp: + """Provide a synthetic test dependency.""" + + def __init__(self, payload=None, raw=False): + """Initialize configuration and runtime state.""" + self._payload = payload + self._raw = raw + + def json(self): + if self._raw: + raise ValueError("Expecting value: line 1 column 1") + return self._payload + + def test_is_passed_variants(self): + self.assertTrue(_parse_progress_passed(self._Resp({"isPassed": True}))) + self.assertFalse(_parse_progress_passed(self._Resp({"isPassed": False}))) + self.assertFalse(_parse_progress_passed(self._Resp({"other": 1}))) + self.assertFalse(_parse_progress_passed(self._Resp(raw=True))) + self.assertFalse(_parse_progress_passed(self._Resp([1, 2]))) + + +class ChapterReadFailureTestCase(unittest.TestCase): + """#223 #357:任务点读取失败不能被当成"章节已完成"静默打勾.""" + + class _Cx: + """Provide a synthetic test dependency.""" + + class _Limiter: + """Provide a synthetic test dependency.""" + + @staticmethod + def limit_rate(**kwargs): + return None + + rate_limiter = _Limiter() + + def get_job_list(self, course, point): + return None, {} + + class _CxEmpty(_Cx): + """Provide a synthetic test dependency.""" + + def get_job_list(self, course, point): + return [], {"notOpen": False} + + POINT = {"title": "1.1 章节", "has_finished": False} + + def test_read_failure_returns_error(self): + result = main.process_chapter(self._Cx(), {"title": "课"}, self.POINT, 1.0) + self.assertEqual(result, main.ChapterResult.ERROR) + + def test_empty_chapter_still_succeeds(self): + result = main.process_chapter(self._CxEmpty(), {"title": "课"}, self.POINT, 1.0) + self.assertEqual(result, main.ChapterResult.SUCCESS) + + +class LlmConnectionTestCase(unittest.TestCase): + """#603:思考模型只返回 reasoning_content 时不能误判为连接失败.""" + + def setUp(self): + self._orig_post = answer_mod.requests.post + + def tearDown(self): + answer_mod.requests.post = self._orig_post + + def _provider(self): + provider = answer_mod.SiliconFlow() + provider.config_set({ + "siliconflow_key": "k", + "siliconflow_model": "m", + "siliconflow_endpoint": "http://example.invalid", + }) + provider._init_tiku() + provider.min_interval = 0 + return provider + + def test_reasoning_content_counts_as_success(self): + answer_mod.requests.post = lambda *a, **kw: _FakeResponse( + {"choices": [{"message": {"content": "", "reasoning_content": "1+1=2"}}]} + ) + self.assertTrue(self._provider().check_llm_connection()) + + def test_malformed_response_does_not_raise(self): + answer_mod.requests.post = lambda *a, **kw: _FakeResponse({}) + self.assertFalse(self._provider().check_llm_connection()) + + def test_400_has_readable_message(self): + message = answer_mod.brief_error(Exception("Error code: 400 - bad request")) + self.assertIn("400", message) + + +class CacheDAOTestCase(unittest.TestCase): + """#552:CacheDAO 每次查询都新建实例,锁必须是类级的,否则并发写会互相覆盖.""" + + def setUp(self): + self.path = os.path.join(tempfile.mkdtemp(prefix="cx-cache-"), "cache.json") + CacheDAO(self.path) + + def test_concurrent_writes_do_not_lose_entries(self): + threads = [ + threading.Thread(target=lambda i=i: CacheDAO(self.path).add_cache(f"q_{i}", f"a_{i}")) + for i in range(40) + ] + for t in threads: + t.start() + for t in threads: + t.join() + with open(self.path, encoding="utf8") as fp: + data = json.load(fp) + self.assertEqual(len(data), 40) + + def test_non_dict_cache_is_ignored(self): + with open(self.path, "w", encoding="utf8") as fp: + fp.write("[1, 2, 3]") + dao = CacheDAO(self.path) + self.assertIsNone(dao.get_cache("q_1")) + dao.add_cache("q_new", "a") + self.assertEqual(CacheDAO(self.path).get_cache("q_new"), "a") + + def test_null_cache_does_not_crash(self): + with open(self.path, "w", encoding="utf8") as fp: + fp.write("null") + self.assertIsNone(CacheDAO(self.path).get_cache("x")) + + +class StartupGuardTestCase(unittest.TestCase): + """#567:纯命令行模式没有 -c 配置文件,不能被启动检查拦死.""" + + CONFIG = {"username": "13800000000", "password": uuid4().hex, "course_list": ["111"]} + TIKU = {"provider": "TikuManual"} + + def test_cli_mode_without_config_file_is_allowed(self): + guard.check_before_run(dict(self.CONFIG), self.TIKU, {}, None, skip_confirm=True) + + def test_explicit_missing_config_file_still_stops(self): + missing = os.path.join(tempfile.mkdtemp(prefix="cx-cfg-"), "not-exist.ini") + with self.assertRaises(guard.UserAbort): + guard.check_before_run(dict(self.CONFIG), self.TIKU, {}, missing, skip_confirm=True) + + +class CliModeConfigTestCase(unittest.TestCase): + """命令行模式(不带 -c)也要能读到用户配置里的题库设置,否则会被误拦.""" + + def test_reads_tiku_from_default_config(self): + config_path = paths.config_path() + original = None + if os.path.exists(config_path): + with open(config_path, encoding="utf8") as fp: + original = fp.read() + try: + with open(config_path, "w", encoding="utf8") as fp: + fp.write("[common]\nusername = 13800000000\n\n" + "[tiku]\nprovider = TikuManual\ncheck_llm_connection = false\n") + tiku_config, notification_config = main._load_default_tiku_and_notification() + self.assertEqual(tiku_config.get("provider"), "TikuManual") + self.assertIsInstance(notification_config, dict) + finally: + if original is None: + if os.path.exists(config_path): + os.remove(config_path) + else: + with open(config_path, "w", encoding="utf8") as fp: + fp.write(original) + + +class NetworkRetryTestCase(unittest.TestCase): + """#124 #166 #192 #226:主流程网络抖动要重试,重试耗尽给友好提示.""" + + def test_retries_then_succeeds(self): + state = {"n": 0} + + def flaky(): + state["n"] += 1 + if state["n"] < 3: + raise RequestException("网络抖动") + return "ok" + + self.assertEqual(main.with_network_retry(flaky, what="测试", delay=0), "ok") + self.assertEqual(state["n"], 3) + + def test_exhausted_retries_raise_friendly_error(self): + def always_fail(): + raise RequestException("一直失败") + + with self.assertRaises(main.NetworkRetryFailed): + main.with_network_retry(always_fail, what="测试", times=2, delay=0) + + +class LoginRobustnessTestCase(unittest.TestCase): + """#163 #164 #220:登录接口没超时 / 返回非 JSON 时不能崩或挂死.""" + + class _FakeResponse: + """Provide a synthetic test dependency.""" + + status_code = 200 + text = "blocked" + + def __init__(self, payload=None, raw=False): + """Initialize configuration and runtime state.""" + self._payload = payload + self._raw = raw + + def json(self): + if self._raw: + raise ValueError("Expecting value: line 1 column 1") + return self._payload + + def setUp(self): + self._orig_post = requests.Session.post + self.cx = Chaoxing(account=Account("13800000000", "pw"), tiku=None) + + def tearDown(self): + requests.Session.post = self._orig_post + + def test_non_json_response(self): + # 注意:第一个参数是 Session 实例,别用 self 命名(会遮住测试用例的 self) + fake = self._FakeResponse + requests.Session.post = lambda session, *a, **kw: fake(raw=True) + result = self.cx.login() + self.assertFalse(result["status"]) + self.assertTrue(result["msg"]) + + def test_missing_msg2(self): + fake = self._FakeResponse + requests.Session.post = lambda session, *a, **kw: fake({"status": False}) + result = self.cx.login() + self.assertFalse(result["status"]) + self.assertTrue(result["msg"]) + + def test_network_timeout(self): + def boom(self, *a, **kw): + raise RequestException("连接超时") + + requests.Session.post = boom + result = self.cx.login() + self.assertFalse(result["status"]) + self.assertIn("网络", result["msg"]) + + +class VideoSerialTestCase(unittest.TestCase): + """#588:serial_video = true 时同一个进程一次只播一个视频.""" + + def setUp(self): + self._orig = Chaoxing._study_video + self.counter = {"now": 0, "max": 0} + self._lock = threading.Lock() + + counter = self.counter + lock = self._lock + + # 注意:第一个参数是被替换方法里的 Chaoxing 实例,别用 self 命名,免得遮住测试用例 + def fake_play(chaoxing_self, _course, _job, _job_info, _speed=1.0, _type="Video"): + with lock: + counter["now"] += 1 + counter["max"] = max(counter["max"], counter["now"]) + time.sleep(0.05) + with lock: + counter["now"] -= 1 + return StudyResult.SUCCESS + + Chaoxing._study_video = fake_play + + def tearDown(self): + Chaoxing._study_video = self._orig + + def _run(self, serial, workers=4): + cx = Chaoxing(account=None, tiku=None, serial_video=serial) + threads = [ + threading.Thread(target=cx.study_video, args=({}, {}, {})) + for _ in range(workers) + ] + for t in threads: + t.start() + for t in threads: + t.join() + + def test_serial_mode_runs_one_video(self): + self._run(True) + self.assertEqual(self.counter["max"], 1) + + def test_default_mode_allows_concurrency(self): + self._run(False) + self.assertGreater(self.counter["max"], 1) + + +class VideoReplayTestCase(unittest.TestCase): + """进度已到结尾但平台未通过时,必须从头回看(决 D3:不够就回看).""" + + def test_full_but_unpassed_video_replays_from_start(self): + from unittest import mock + from api import base as base_mod + + cx = base_mod.Chaoxing() + recorded = [] + state = {"calls": 0} + + def fake_log(session, course, job, job_info, dtoken, duration, playing, + _type="Video", **kwargs): + recorded.append(playing) + state["calls"] += 1 + # 第 1 次是"瞬间完成"检查;回看后的第一次心跳就让它通过 + return state["calls"] >= 2, 200 + + class Sess: + """Provide a synthetic test dependency.""" + + cookies = {} + + def get(self, url, **kwargs): + class R: + """Provide a synthetic test dependency.""" + + status_code = 200 + + @staticmethod + def json(): + return {"status": "success", "dtoken": "d", "duration": 100} + + return R() + + job = {"jobid": "j", "objectid": "o", "otherinfo": "nodeId_k", + "videoFaceCaptureEnc": "", "attDuration": "", "attDurationEnc": "", + "rt": "1", "playTime": 100000, "name": "测试视频"} + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()), \ + mock.patch.object(cx, "video_progress_log", side_effect=fake_log), \ + mock.patch.object(base_mod.random, "uniform", return_value=0), \ + mock.patch.object(base_mod.time, "sleep", return_value=None): + result = cx._study_video( + {"clazzId": "1", "courseId": "2", "cpi": "3"}, job, {}, 1.0 + ) + + self.assertEqual(result, base_mod.StudyResult.SUCCESS) + self.assertEqual(recorded[0], 100) + self.assertTrue( + any(p < 100 for p in recorded[1:]), + "回看后必须从更早的位置重新上报,实际序列: %s" % recorded, + ) + + def test_video_not_at_end_keeps_normal_playback(self): + from unittest import mock + from api import base as base_mod + + cx = base_mod.Chaoxing() + recorded = [] + state = {"calls": 0} + + def fake_log(session, course, job, job_info, dtoken, duration, playing, + _type="Video", **kwargs): + recorded.append(playing) + state["calls"] += 1 + return state["calls"] >= 2, 200 + + class Sess: + """Provide a synthetic test dependency.""" + + cookies = {} + + def get(self, url, **kwargs): + class R: + """Provide a synthetic test dependency.""" + + status_code = 200 + + @staticmethod + def json(): + return {"status": "success", "dtoken": "d", "duration": 100} + + return R() + + job = {"jobid": "j", "objectid": "o", "otherinfo": "nodeId_k", + "videoFaceCaptureEnc": "", "attDuration": "", "attDurationEnc": "", + "rt": "1", "playTime": 30000, "name": "测试视频"} + with mock.patch.object(base_mod.SessionManager, "get_session", return_value=Sess()), \ + mock.patch.object(cx, "video_progress_log", side_effect=fake_log), \ + mock.patch.object(base_mod.random, "uniform", return_value=0), \ + mock.patch.object(base_mod.time, "sleep", return_value=None): + result = cx._study_video( + {"clazzId": "1", "courseId": "2", "cpi": "3"}, job, {}, 1.0 + ) + self.assertEqual(result, base_mod.StudyResult.SUCCESS) + # 没有到结尾:第一次心跳仍然是原始进度(30s),不触发回看 + self.assertEqual(recorded[0], 100) + self.assertEqual(recorded[1], 30) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_privacy.py b/tests/test_privacy.py new file mode 100644 index 000000000..42780294b --- /dev/null +++ b/tests/test_privacy.py @@ -0,0 +1,92 @@ +"""Canary secrets must never reach either log sink or review files.""" + +import io +from pathlib import Path +import tempfile +import unittest +from unittest import mock +from uuid import uuid4 + +from api import privacy, review +from api.logger import logger + + +class PrivacyTest(unittest.TestCase): + def test_console_and_file_sinks_redact_fields_urls_and_exceptions(self): + secret = uuid4().hex + privacy.register_secret(secret) + console = io.StringIO() + with tempfile.TemporaryDirectory() as directory: + path = Path(directory, "run.log") + console_sink = logger.add(console, format="{message}") + file_sink = logger.add(str(path), format="{message}") + try: + logger.info("Cookie: {} | password='{}' | https://notify.invalid/{}/push?uid=123", secret, secret, secret) + try: + raise ValueError("unlabeled " + secret) + except ValueError: + logger.exception("request failed") + finally: + logger.remove(console_sink) + logger.remove(file_sink) + for output in (console.getvalue(), path.read_text()): + self.assertNotIn(secret, output) + self.assertNotIn("/push?uid=123", output) + self.assertIn("redacted", output) + + def test_cookiejar_and_identity_fields_are_redacted(self): + text = privacy.redact("]> username=13912345678 dtoken='synthetic-token' Authorization: Bearer synthetic-bearer") + for value in ("synthetic-secret", "13912345678", "synthetic-token", "synthetic-bearer"): + self.assertNotIn(value, text) + + def test_unregistered_cookie_headers_and_containers(self): + for value in ('Cookie: synthetic_sid=alpha-demo; synthetic_auth=beta-demo', + 'cookies={"synthetic_sid":"alpha-demo"}', + 'Set-Cookie: synthetic_sid=alpha-demo; Path=/'): + self.assertNotIn("alpha-demo", privacy.redact(value)) + self.assertNotIn("beta-demo", privacy.redact(value)) + for value in ('payload={"token": ["alpha-demo", "beta-demo"]}', + 'payload={"authorization": {"primary": "alpha-demo", "secondary": "beta-demo"}}'): + self.assertNotIn("alpha-demo", privacy.redact(value)) + self.assertNotIn("beta-demo", privacy.redact(value)) + value = '{"token": [\n "alpha-demo",\n "beta-demo"\n]}' + self.assertNotIn("alpha-demo", privacy.redact(value)) + self.assertNotIn("beta-demo", privacy.redact(value)) + record = {"message": "safe", "extra": {"request": {"cookies": {"sid": "alpha-demo"}}}} + privacy.patch_record(record) + self.assertNotIn("alpha-demo", str(record)) + + def test_review_is_private_durable_and_uses_last_status(self): + with tempfile.TemporaryDirectory() as directory, mock.patch.dict("os.environ", {"CX_DATA_HOME": directory}): + item = review.record(review.KIND_DISCUSSION, "正文 password=synthetic-private", extra={"cookie": "must-not-persist"}) + self.assertIsNotNone(item) + review.update(item, "用户取消,未提交") + records = review.load() + self.assertEqual(len(records), 1) + self.assertEqual(records[0]["status"], "用户取消,未提交") + for path in (Path(review.index_path()), Path(review.markdown_path())): + self.assertNotIn("synthetic-private", path.read_text()) + self.assertNotIn("must-not-persist", path.read_text()) + self.assertEqual(path.stat().st_mode & 0o777, 0o600) + + +class CurlConfigTest(unittest.TestCase): + def test_headers_and_cookies_cannot_inject_curl_options(self): + from api.base import _curl_get, _curl_config_value + import requests + self.assertEqual(_curl_config_value('a\\b"c'), 'a\\\\b\\"c') + session = requests.Session() + with mock.patch("shutil.which", return_value="/usr/bin/curl"), mock.patch("subprocess.run") as run: + for field in ("X-Test", "X-Test\noutput"): + self.assertIsNone(_curl_get(session, "https://example.invalid/", {}, + {field: "value\noutput = stolen"})) + session.cookies.set("sid", "value\noutput = stolen") + self.assertIsNone(_curl_get(session, "https://example.invalid/", {})) + run.assert_not_called() + + @unittest.skipIf(__import__("os").name == "nt", "POSIX permission checks") + def test_private_data_directory_permission_failure_is_reported(self): + from api.paths import data_dir + with tempfile.TemporaryDirectory() as directory, mock.patch.dict("os.environ", {"CX_DATA_HOME": directory}), mock.patch("os.chmod", side_effect=PermissionError): + with self.assertRaises(PermissionError): + data_dir() diff --git a/tests/test_publication.py b/tests/test_publication.py new file mode 100644 index 000000000..e932c6123 --- /dev/null +++ b/tests/test_publication.py @@ -0,0 +1,27 @@ +"""Publication regression checks use synthetic repository contents.""" + +import importlib.util +from pathlib import Path +import tempfile +import unittest + +_path = Path(__file__).resolve().parents[1] / "tools/audit/publication_guard.py" +_spec = importlib.util.spec_from_file_location("publication_guard", _path) +guard = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(guard) + + +class PublicationTest(unittest.TestCase): + def test_private_files_are_rejected_even_if_contents_are_sanitized(self): + paths = ["docs/handoff/notes.md", "docs/artifacts/example.json", "AGENTS.md", + "docs/SESSION-LOG.md", "private/notes.md", "capture_sample.txt", "sample.har"] + self.assertEqual(len(guard.audit_paths("/nonexistent", paths)), len(paths)) + + def test_public_usage_and_synthetic_tests_are_allowed(self): + self.assertEqual(guard.audit_paths("/nonexistent", ["README.md", "LICENSE", + "docs/RUNBOOK.md", "tests/test_private_paths.py", ".env.example"]), []) + + def test_internal_records_cannot_be_renamed_into_public_docs(self): + with tempfile.TemporaryDirectory() as directory: + Path(directory, "README.md").write_text("本轮新增:内部任务进度\n", encoding="utf-8") + self.assertTrue(guard.audit_paths(directory, ["README.md"])) diff --git a/tests/test_resources.py b/tests/test_resources.py new file mode 100644 index 000000000..e8bba3b16 --- /dev/null +++ b/tests/test_resources.py @@ -0,0 +1,27 @@ +import os +import tempfile +import unittest +from unittest import mock +from pathlib import Path +from api import cxsecret_font +from api.cxsecret_font import FontHashDAO + +class ResourceTest(unittest.TestCase): + def test_font_mapping_loads_outside_repository(self): + previous = os.getcwd() + try: + with tempfile.TemporaryDirectory() as directory: + os.chdir(directory) + FontHashDAO() + finally: + os.chdir(previous) + + def test_user_installation_resources_load_outside_prefix(self): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + data = root / "user/share/chaoxing" + data.mkdir(parents=True) + (data / "font_map_table.json").write_text('{"example": "synthetic-hash"}') + with mock.patch.object(cxsecret_font, "__file__", str(root / "site/api/module.py")), mock.patch.object(cxsecret_font.sys, "prefix", str(root / "prefix")), mock.patch.object(cxsecret_font.site, "getuserbase", return_value=str(root / "user")): + dao = FontHashDAO() + self.assertEqual(dao.find_char("synthetic-hash"), "example") diff --git a/tests/test_review.py b/tests/test_review.py new file mode 100644 index 000000000..862914875 --- /dev/null +++ b/tests/test_review.py @@ -0,0 +1,164 @@ +# -*- coding: utf-8 -*- +"""复核环节(api/review.py)回归:留痕、列表、正文渲染,以及写作钩子.""" +# +# 留痕必须落盘可查,且写失败/空内容不能污染记录;钩子要真的把 +# "会被平台看到的文字"记下来(简答题/讨论/实践作答)。 +import os +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-review-")) + +from api import review # noqa: E402 + + +class ReviewLogTestCase(unittest.TestCase): + def test_record_and_load_roundtrip(self): + item = review.record("讨论回复", "我觉得波特五力里最难判断的是替代品。", + course="示例课程", task="讨论任务A") + self.assertIsNotNone(item) + items = review.load() + self.assertTrue(items) + latest = items[0] + self.assertEqual(latest["kind"], "讨论回复") + self.assertEqual(latest["course"], "示例课程") + self.assertIn("替代品", latest["text"]) + self.assertEqual(latest["chars"], len(latest["text"])) + + def test_markdown_file_keeps_human_readable_copy(self): + review.record("作业简答", "我倾向于先把主业做扎实,再考虑多元化。", + course="示例课程", task="总体战略对比分析") + path = review.markdown_path() + self.assertTrue(os.path.exists(path)) + body = open(path, encoding="utf-8").read() + self.assertIn("总体战略对比分析", body) + self.assertIn("先把主业做扎实", body) + + def test_empty_text_is_not_recorded(self): + before = len(review.load()) + self.assertIsNone(review.record("讨论回复", " ")) + self.assertEqual(len(review.load()), before) + + def test_render_index_lists_items(self): + review.record("测验简答", "企业应该根据自身资源做权变选择。", + course="示例课程", task="1.2 章节测验") + text = review.render_index(review.load(limit=1)) + self.assertIn("测验简答", text) + self.assertIn("示例课程", text) + + def test_render_item_wraps_and_shows_meta(self): + long_text = "这是一段比较长的回答。" * 12 + review.record("AI实践作答", long_text, course="示例课程", task="AI实践任务A") + text = review.render_item(review.load(limit=1)[0], "[1/1]") + self.assertIn("AI实践任务A", text) + self.assertIn("AI实践作答", text) + for line in text.splitlines(): + self.assertLessEqual(len(line), 80) + + def test_empty_state_is_friendly(self): + text = review.render_index([]) + self.assertIn("还没有可复核的内容", text) + + def test_count_today_counts_todays_records(self): + before = review.count_today() + review.record("讨论回复", "随便说两句,凑个字数。") + self.assertEqual(review.count_today(), before + 1) + + def test_cli_list_mode_returns_zero(self): + with mock.patch("builtins.print"): + self.assertEqual(review.review_cli(["--list"]), 0) + + +class FakeTiku: + DISABLE = False + + def query_all(self, questions, query_delay=0): + return [None] * len(questions) + + +class FakeWriter: + available = True + + def __init__(self): + """Initialize configuration and runtime state.""" + self.calls = [] + + def answer(self, question, **kwargs): + self.calls.append(question) + return "我觉得专业化更稳一些,先把主业做扎实。" + + +class HomeworkShortAnswerHookTestCase(unittest.TestCase): + def test_short_answer_is_recorded(self): + from api.task_center import TaskCenter + tc = TaskCenter(object(), {}) + tc.chaoxing = type("CX", (), {"tiku": FakeTiku()})() + tc.writer = FakeWriter() + questions = [{"id": 7, "type": "shortanswer", "title": "你更支持哪种战略?", + "options": "", "answerField": {}}] + with mock.patch("api.task_center.review.record") as recorder: + failure = tc._fill_homework_answers(questions, course={"title": "示例课程"}, + task_name="总体战略对比分析") + self.assertIsNone(failure) + self.assertTrue(recorder.called) + args, kwargs = recorder.call_args + self.assertEqual(args[0], "作业简答") + self.assertIn("专业化", args[1]) + self.assertEqual(kwargs.get("course"), "示例课程") + self.assertEqual(kwargs.get("task"), "总体战略对比分析") + + +class LiveTraceTestCase(unittest.TestCase): + """运行中实时留痕:控制台看得到、普通运行日志也留一份.""" + + def test_answer_line_formats_letters_and_types(self): + from api.display import answer_line, answers_header + self.assertEqual(answers_header("总体战略对比分析", 4), " 作答 · 总体战略对比分析(4 题)") + line = answer_line(1, "single", "A", "以下属于波特五力的是") + self.assertIn("1. 选择", line) + self.assertIn("A", line) + + def test_long_answer_is_clipped_with_char_count(self): + from api.display import answer_line + long_text = "我觉得应该先把主业做扎实再考虑多元化。" * 5 + line = answer_line(3, "shortanswer", long_text) + self.assertIn("字)", line) + self.assertLessEqual(len(line), 80) + + def test_emit_writes_console_and_run_log(self): + """留痕要同时进控制台和运行日志(这里校验调用契约,避免异步写盘抖动).""" + import contextlib + import io + from api import display + from api import logger as logger_mod + buf = io.StringIO() + with mock.patch.object(logger_mod, "log_file_only") as file_log, \ + contextlib.redirect_stdout(buf): + display.emit("留痕测试:第 1 题选择 A") + self.assertIn("留痕测试", buf.getvalue()) + file_log.assert_called_once() + self.assertIn("留痕测试:第 1 题选择 A", file_log.call_args.args[0]) + + def test_homework_emits_one_line_per_question(self): + from api.task_center import TaskCenter + tc = TaskCenter(object(), {}) + tc.chaoxing = type("CX", (), {"tiku": FakeTiku()})() + tc.writer = FakeWriter() + questions = [ + {"id": 1, "type": "shortanswer", "title": "你更支持哪种战略?", + "options": "", "answerField": {}}, + ] + with mock.patch("api.task_center.emit") as emitter: + failure = tc._fill_homework_answers(questions, course={"title": "示例课程"}, + task_name="总体战略对比分析") + self.assertIsNone(failure) + printed = [str(c.args[0]) for c in emitter.call_args_list if c.args] + self.assertTrue(any("作答 · 总体战略对比分析" in line for line in printed)) + self.assertTrue(any("简答" in line for line in printed)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_scan.py b/tests/test_scan.py new file mode 100644 index 000000000..f802e4e07 --- /dev/null +++ b/tests/test_scan.py @@ -0,0 +1,184 @@ +# -*- coding: utf-8 -*- +"""开始前扫描 + 刷课数量语义 + 只刷讨论 的离线回归.""" +# +# 数量语义(用户最关心的): +# 数字 = 本次刷多少个「还没完成」的任务点,已完成的自动跳过,不会重刷。 + +import os +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-scan-")) + +import main as main_mod # noqa: E402 +from api import scan # noqa: E402 + + +class CountSemanticsTestCase(unittest.TestCase): + """共 300 节、前 150 节已完成:填 150 应该是把后 150 节刷完.""" + + @staticmethod + def _points(): + return [{"title": "第%d节" % i, "has_finished": i <= 150} for i in range(1, 301)] + + def test_number_means_next_unfinished_points(self): + finished, pending, selected = main_mod.select_points_for_course(self._points(), 150) + self.assertEqual(len(finished), 150) + self.assertEqual(len(pending), 150) + self.assertEqual(len(selected), 150) + self.assertEqual(selected[0]["title"], "第151节") + self.assertEqual(selected[-1]["title"], "第300节") + self.assertTrue(all(not p["has_finished"] for p in selected)) + + def test_number_larger_than_pending_means_all(self): + _finished, _pending, selected = main_mod.select_points_for_course(self._points(), 500) + self.assertEqual(len(selected), 150) + + def test_zero_means_all_pending(self): + _finished, _pending, selected = main_mod.select_points_for_course(self._points(), 0) + self.assertEqual(len(selected), 150) + + +class FakeTaskCenter: + """最小可用的任务中心替身.""" + + def __init__(self, groups, plans_by_group, finished_ids=()): + """Initialize configuration and runtime state.""" + self._groups = groups + self._plans = plans_by_group + self._finished = set(finished_ids) + + def get_course_tasks(self, course): + return [{"name": "第1章", "id": 1}] + + def open_task(self, task): + return {"encryTaskUserId": "u1"} + + def get_groups(self, encry): + return self._groups + + def get_plans(self, encry, group_id): + return self._plans.get(group_id, []) + + def plan_finished(self, plan): + return str(plan.get("planId")) in self._finished + + +class ScanRenderTestCase(unittest.TestCase): + def test_chapter_row_counts(self): + row = scan.chapter_row({"title": "示例课程"}, + [{"has_finished": True, "title": "1.1"}, + {"has_finished": False, "title": "2.1"}]) + self.assertEqual(row["total"], 2) + self.assertEqual(row["finished"], 1) + self.assertEqual(row["pending"], 1) + self.assertEqual(row["first"], "2.1") + + def test_report_mentions_missing_items(self): + chapter_rows = [scan.chapter_row({"title": "示例课程"}, + [{"has_finished": True, "title": "1.1"}, + {"has_finished": False, "title": "2.1"}])] + tc_rows = [{ + "title": "示例课程", "tasks": 3, "done": 1, "todo": 1, "locked": 1, + "by_type": {"作业": 1}, "locked_by_type": {"主题讨论": 1}, + "unsupported": ["思考题"], "error": "", + }] + out = scan.render(chapter_rows, tc_rows, True, True) + self.assertIn("开始前扫描", out) + self.assertIn("待刷 1", out) + self.assertIn("作业 1", out) + self.assertIn("思考题 暂不支持", out) + self.assertIn("被前面的分组锁着", out) + + def test_scan_task_center_classifies(self): + groups = [{"encryptGroupId": "g1", "groupAllowStudy": True}] + plans = {"g1": [ + {"planId": 1, "planType": 4, "name": "作业"}, + {"planId": 2, "planType": 14, "name": "讨论"}, + {"planId": 3, "planType": 9, "name": "思考题"}, + ]} + fake = FakeTaskCenter(groups, plans, finished_ids=["1"]) + with mock.patch("api.task_center.TaskCenter", return_value=fake): + rows = scan.scan_task_center(object(), [{"title": "示例课程"}], {}) + row = rows[0] + self.assertEqual(row["done"], 1) + self.assertEqual(row["todo"], 1) # 只有讨论是可学的待完成 + self.assertIn("思考题", row["unsupported"]) + self.assertEqual(row["by_type"].get("主题讨论"), 1) + + def test_scan_failure_is_soft(self): + with mock.patch("api.task_center.TaskCenter", side_effect=RuntimeError("boom")): + rows = scan.scan_task_center(object(), [{"title": "课"}], {}) + self.assertEqual(rows, []) + with mock.patch.object(scan, "scan_task_center", side_effect=RuntimeError("boom")): + out = scan.run(object(), [{"title": "课"}], {}, [], True, True) + self.assertIn("开始前扫描", out) + + +class OnlyDiscussionTestCase(unittest.TestCase): + """只刷讨论:其它类型的任务点本次跳过,并且不判失败.""" + + def test_non_discussion_plans_are_skipped(self): + groups = [{"encryptGroupId": "g1", "groupAllowStudy": True}] + plans = {"g1": [ + {"planId": 1, "planType": 4, "name": "作业"}, + {"planId": 2, "planType": 14, "name": "讨论"}, + ]} + fake = FakeTaskCenter(groups, plans) + stats = {"skipped_other": 0} + handled = [] + + def fake_complete(tc, chaoxing, course, plan, info, config, point_map): + handled.append(int(plan.get("planType"))) + fake._finished.add(str(plan.get("planId"))) # 处理后即完成,避免无限循环 + return True + + with mock.patch.object(main_mod, "_complete_teaching_plan", side_effect=fake_complete), \ + mock.patch.object(main_mod, "_load_course_point_map", return_value={}): + main_mod._process_teaching_task( + fake, object(), {"title": "课", "courseId": "1"}, {"name": "第1章"}, + {}, {}, only_discussion=True, stats=stats, + ) + self.assertEqual(handled, [14]) + self.assertEqual(stats["skipped_other"], 1) + + + + def test_skip_discussion_skips_task_discussions(self): + """Board 模式:任务中心里跳过主题讨论(之前 skip_discussion 未定义直接 NameError).""" + groups = [{"encryptGroupId": "g1", "groupAllowStudy": True}] + plans = {"g1": [ + {"planId": 1, "planType": 14, "name": "讨论"}, + {"planId": 2, "planType": 4, "name": "作业"}, + ]} + fake = FakeTaskCenter(groups, plans) + stats = {"skipped_other": 0} + handled = [] + + def fake_complete(tc, chaoxing, course, plan, info, config, point_map): + handled.append(int(plan.get("planType"))) + fake._finished.add(str(plan.get("planId"))) + return True + + with mock.patch.object(main_mod, "_complete_teaching_plan", side_effect=fake_complete), \ + mock.patch.object(main_mod, "_load_course_point_map", return_value={}): + main_mod._process_teaching_task( + fake, object(), {"title": "课", "courseId": "1"}, {"name": "第1章"}, + {}, {}, skip_discussion=True, stats=stats, + ) + self.assertEqual(handled, [4]) + self.assertEqual(stats["skipped_other"], 1) + + def test_main_assigns_skip_discussion(self): + """Main() 里必须有 skip_discussion 赋值,否则任务中心阶段每次 NameError.""" + source = open(os.path.join( + os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "main.py"), + encoding="utf-8").read() + self.assertIn("skip_discussion = board_mode", source) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_study_scope.py b/tests/test_study_scope.py new file mode 100644 index 000000000..58ddd12e1 --- /dev/null +++ b/tests/test_study_scope.py @@ -0,0 +1,468 @@ +# -*- coding: utf-8 -*- +"""刷课范围(章节 / 任务中心)回归.""" +# +# - main.py 的 chapter_study 开关(命令行 > 配置文件 > 默认开启) +# - 向导里的「刷什么内容」选择与写出的账号配置 +# +# 不联网、不碰真实用户数据(CX_DATA_HOME 指向临时目录)。 + +import configparser +import os +import sys +import tempfile +import unittest +from unittest import mock + +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-scope-")) + +import main as main_mod # noqa: E402 +import setup_wizard as wizard # noqa: E402 + + +class ChapterStudyFlagTestCase(unittest.TestCase): + """Chapter_study:命令行 > 配置文件 > 默认开启.""" + + def test_default_on(self): + args = mock.Mock(chapter_study=None) + self.assertTrue(main_mod._chapter_study_enabled({}, args)) + self.assertTrue(main_mod._chapter_study_enabled({"chapter_study": None}, args)) + + def test_config_values(self): + args = mock.Mock(chapter_study=None) + self.assertFalse(main_mod._chapter_study_enabled({"chapter_study": "false"}, args)) + self.assertFalse(main_mod._chapter_study_enabled({"chapter_study": False}, args)) + self.assertTrue(main_mod._chapter_study_enabled({"chapter_study": "true"}, args)) + + def test_cli_overrides_config(self): + self.assertFalse( + main_mod._chapter_study_enabled({"chapter_study": True}, mock.Mock(chapter_study=False)) + ) + self.assertTrue( + main_mod._chapter_study_enabled({"chapter_study": "false"}, mock.Mock(chapter_study=True)) + ) + + def test_cli_flags_parse(self): + with mock.patch.object(sys, "argv", ["main.py", "--no-chapters"]): + self.assertFalse(main_mod.parse_args().chapter_study) + with mock.patch.object(sys, "argv", ["main.py", "--chapters"]): + self.assertTrue(main_mod.parse_args().chapter_study) + with mock.patch.object(sys, "argv", ["main.py"]): + self.assertIsNone(main_mod.parse_args().chapter_study) + + def test_config_file_parses_flag(self): + with tempfile.TemporaryDirectory() as tmp: + path = os.path.join(tmp, "config.ini") + with open(path, "w", encoding="utf8") as f: + f.write( + "[common]\nusername = 13800000000\npassword = pw\n" + "course_list = 1\nchapter_study = false\ntask_center = true\n" + ) + common, _tiku, _notify = main_mod.load_config_from_file(path) + self.assertFalse(common["chapter_study"]) + self.assertTrue(common["task_center"]) + + +class TaskCountConfigTestCase(unittest.TestCase): + """Max_tasks_per_course 复用 max_points_per_course 的解析规则.""" + + def test_per_course_format(self): + mapping, default, bad = main_mod._parse_max_points("1:2,3:0") + self.assertEqual(mapping, {"1": 2, "3": 0}) + self.assertEqual(default, 0) + self.assertEqual(bad, []) + + def test_plain_number_and_empty(self): + self.assertEqual(main_mod._parse_max_points("3"), ({}, 3, [])) + self.assertEqual(main_mod._parse_max_points(None), ({}, 0, [])) + self.assertEqual(main_mod._parse_max_points(""), ({}, 0, [])) + + def test_bad_value_is_flagged_not_defaulted(self): + mapping, default, bad = main_mod._parse_max_points("abc") + self.assertEqual(mapping, {}) + self.assertEqual(default, 0) + self.assertEqual(bad, ["abc"]) + + +class WizardScopeTestCase(unittest.TestCase): + """向导里的范围选择与写出的账号配置.""" + + def test_scope_table(self): + self.assertEqual(wizard.STUDY_SCOPES["1"], (True, True, False)) + self.assertEqual(wizard.STUDY_SCOPES["2"], (True, False, False)) + self.assertEqual(wizard.STUDY_SCOPES["3"], (False, True, False)) + self.assertEqual(wizard.STUDY_SCOPES["4"], (False, False, True)) # 只刷讨论 + + def test_choose_scope_mapping(self): + cases = [ + ("1", "1", (True, True, False, "task")), # 章节 + 任务中心 + 讨论自动 + ("1", "2", (True, True, False, "board")), # 章节 + 任务中心 + 讨论区挑帖 + ("2", "", (True, False, False, "")), # 只刷章节:不问讨论 + ("3", "1", (False, True, False, "task")), # 只刷任务中心 + ("4", "2", (False, False, True, "board")), # 只刷讨论:讨论区挑帖 + ("4", "1", (False, False, True, "task")), # 只刷讨论:任务讨论自动 + ] + for scope, mode, expect in cases: + answers = [scope] + ([mode] if mode else []) + with mock.patch.object(wizard, "ask", + side_effect=lambda *a, **k: answers.pop(0) if answers else "1"), \ + mock.patch("builtins.print"): + self.assertEqual(wizard.choose_study_scope(), expect, (scope, mode)) + + def test_choose_scope_reprompts_on_bad_input(self): + answers = iter(["9", "2"]) + with mock.patch.object(wizard, "ask", + side_effect=lambda *a, **k: next(answers)), \ + mock.patch("builtins.print"): + self.assertEqual(wizard.choose_study_scope(), (True, False, False, "")) + + + def test_only_discussion_keeps_task_center_enabled(self): + """只刷讨论必须写成 task_center = true,否则启动检查会拦下.""" + plan = [({"courseId": 1, "clazzId": 2, "title": "测试课"}, 0, 0)] + path = wizard.build_config("13800000000", "pw", plan, + chapters_enabled=False, task_center_enabled=False, + only_discussion=True, discussion_mode="board") + text = open(path, encoding="utf-8").read() + self.assertIn("task_center = true", text) + self.assertIn("chapter_study = false", text) + self.assertIn("only_discussion = true", text) + self.assertIn("discussion_mode = board", text) + + @staticmethod + def _empty_cfg(): + cfg = configparser.ConfigParser() + cfg.add_section("tiku") + return cfg + + def test_question_bank_mode_does_not_ask_ai_key(self): + """选言溪题库不该被追问 DeepSeek Key(表结构解包顺序回归).""" + with mock.patch.object(wizard, "read_config", return_value=self._empty_cfg()), \ + mock.patch.object(wizard, "ask", side_effect=["2", "tok-123"]), \ + mock.patch.object(wizard, "ask_deepseek_key") as key_ask, \ + mock.patch.object(wizard, "update_config"), \ + mock.patch("builtins.print"): + provider, result = wizard.setup_answer_mode(force=True) + self.assertEqual(provider, "TikuYanxi") + self.assertEqual(result.get("tokens"), "tok-123") + key_ask.assert_not_called() + + def test_key_step_downgrade_keeps_question_bank_tokens(self): + """在 Key 步骤选「不做测验」时,不能把刚填好的题库 token 丢掉.""" + with mock.patch.object(wizard, "read_config", return_value=self._empty_cfg()), \ + mock.patch.object(wizard, "ask", side_effect=["4", "tok-9"]), \ + mock.patch.object(wizard, "ask_deepseek_key", return_value=""), \ + mock.patch.object(wizard, "update_config"), \ + mock.patch("builtins.print"): + provider, result = wizard.setup_answer_mode(force=True) + self.assertEqual(provider, "TikuYanxi") + self.assertEqual(result.get("tokens"), "tok-9") + + def test_choose_courses_skips_points_for_task_center_only(self): + course = {"courseId": 1, "clazzId": 2, "title": "测试课"} + cx = mock.Mock() + cx.get_course_list.return_value = [course] + with mock.patch.object(wizard, "ask", return_value="1"), \ + mock.patch("builtins.print"): + plan = wizard.choose_courses(cx, ask_points=False, ask_tasks=False) + self.assertEqual(plan, [(course, 0, 0)]) + + def test_choose_courses_asks_both_counts(self): + """章节 + 任务中心都刷时,每门课分别问两个数量.""" + course = {"courseId": 1, "clazzId": 2, "title": "测试课"} + cx = mock.Mock() + cx.get_course_list.return_value = [course] + answers = iter(["1", "2", "3"]) # 选课 / 章节前 2 个 / 教学任务前 3 个 + with mock.patch.object(wizard, "ask", side_effect=lambda *a, **k: next(answers)), \ + mock.patch("builtins.print"): + plan = wizard.choose_courses(cx) + self.assertEqual(plan, [(course, 2, 3)]) + + def test_ask_count_all_alias(self): + for raw, expect in (("all", 0), ("全部", 0), ("0", 0), ("5", 5)): + with mock.patch.object(wizard, "ask", return_value=raw), \ + mock.patch("builtins.print"): + self.assertEqual(wizard._ask_count("x"), expect) + + def test_ask_count_empty_input_uses_all_default(self): + """回车走 ask 的默认值 all(mock 里模拟 ask 的默认值行为).""" + with mock.patch.object( + wizard, "ask", + side_effect=lambda prompt, default=None: str(default), + ) as m, mock.patch("builtins.print"): + self.assertEqual(wizard._ask_count("x"), 0) + self.assertEqual(m.call_args.kwargs.get("default"), "all") + + def test_ask_count_reprompts_on_bad_input(self): + answers = iter(["abc", "-1", "4"]) + with mock.patch.object(wizard, "ask", + side_effect=lambda *a, **k: next(answers)), \ + mock.patch("builtins.print"): + self.assertEqual(wizard._ask_count("x"), 4) + + def test_build_config_writes_scope(self): + plan = [({"courseId": 1, "clazzId": 2, "title": "测试课"}, 0, 0)] + path = wizard.build_config("13800000000", "pw", plan, + chapters_enabled=False, task_center_enabled=True) + cfg = configparser.ConfigParser() + cfg.read(path, encoding="utf8") + self.assertEqual(cfg.get("common", "chapter_study"), "false") + self.assertEqual(cfg.get("common", "task_center"), "true") + + def test_chapters_only_clears_previous_discussion_mode(self): + """连续下一轮只刷章节时,绝不能把上一轮 board 留在运行配置里.""" + plan = [({"courseId": 1, "clazzId": 2, "title": "测试课"}, 1, 0)] + path = wizard.build_config("13800000003", "pw", plan, + chapters_enabled=True, task_center_enabled=False, + discussion_mode="board") + cfg = configparser.ConfigParser() + cfg.read(path, encoding="utf8") + self.assertEqual(cfg.get("common", "discussion_mode"), "none") + + +class DiscussionScopeIsolationTestCase(unittest.TestCase): + """运行时也必须隔离旧配置,而不仅依赖向导正确写文件.""" + + def test_chapter_only_ignores_stale_board_setting(self): + self.assertEqual( + main_mod._discussion_mode_for_run({"discussion_mode": "board"}, False, False), + "none", + ) + + def test_task_center_keeps_explicit_board_setting(self): + self.assertEqual( + main_mod._discussion_mode_for_run({"discussion_mode": "board"}, True, False), + "board", + ) + + def test_invalid_discussion_mode_falls_back_to_task(self): + self.assertEqual( + main_mod._discussion_mode_for_run({"discussion_mode": "unexpected"}, True, False), + "task", + ) + + def test_build_config_uses_recommended_defaults(self): + """向导不再逐项问配置:写出的运行配置直接用推荐值.""" + plan = [({"courseId": 1, "clazzId": 2, "title": "测试课"}, 3, 2)] + path = wizard.build_config("13800000002", "pw", plan) + cfg = configparser.ConfigParser() + cfg.read(path, encoding="utf8") + common = cfg["common"] + self.assertEqual(common["speed"], "2") + self.assertEqual(common["jobs"], "2") + self.assertEqual(common["work_max_retries"], "3") + self.assertEqual(common["notopen_action"], "continue") + self.assertEqual(common["task_center_submit_mode"], "auto") + + def test_prefs_do_not_ask(self): + """已经配置过:正常启动不再问任何东西.""" + cfg = configparser.ConfigParser() + cfg.add_section("cx") + cfg.set("cx", "prefs_done", "yes") + cfg.set("cx", "prefs_version", "2") + with mock.patch.object(wizard, "read_config", return_value=cfg), \ + mock.patch.object(wizard, "setup_notification", + side_effect=AssertionError("不该问通知")), \ + mock.patch.object(wizard, "ask", + side_effect=AssertionError("不该问刷课参数")), \ + mock.patch("builtins.print"): + wizard.ensure_global_prefs(force=False) + + def test_first_run_asks_optional_notification(self): + """第一次运行会问一次可选的通知设置(直接回车=不用).""" + cfg = configparser.ConfigParser() + cfg.add_section("cx") + with mock.patch.object(wizard, "read_config", return_value=cfg), \ + mock.patch.object(wizard, "setup_notification", + return_value=("", "", "")) as notify, \ + mock.patch.object(wizard, "update_config"), \ + mock.patch("builtins.print"): + wizard.ensure_global_prefs(force=False) + self.assertTrue(notify.called) + + def test_setup_only_asks_notification(self): + """Cx setup 也只问可选的通知,不问刷课参数.""" + with mock.patch.object(wizard, "setup_notification", + return_value=("", "", "")) as notify, \ + mock.patch.object(wizard, "ask", + side_effect=AssertionError("不该问刷课参数")), \ + mock.patch("builtins.print"): + wizard.ensure_global_prefs(force=True) + notify.assert_called_once() + + def test_prefs_summary_is_short(self): + line = wizard.prefs_summary() + self.assertLessEqual(WizardDisplayTestCase._width(line), 76) + self.assertIn("自动提交", line) + + def test_build_config_defaults_both_on(self): + plan = [({"courseId": 1, "clazzId": 2, "title": "测试课"}, 3, 2)] + path = wizard.build_config("13800000001", "pw", plan) + cfg = configparser.ConfigParser() + cfg.read(path, encoding="utf8") + self.assertEqual(cfg.get("common", "chapter_study"), "true") + self.assertEqual(cfg.get("common", "task_center"), "true") + self.assertEqual(cfg.get("common", "max_points_per_course"), "1:3") + self.assertEqual(cfg.get("common", "max_tasks_per_course"), "1:2") + + +class WizardDisplayTestCase(unittest.TestCase): + """向导页面展示回归:简洁(不超宽、不双空行)且关键信息在.""" + + @staticmethod + def _width(text): + import unicodedata + return sum(2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 for ch in text) + + def _render(self, inputs): + import io + from contextlib import redirect_stdout + course = {"courseId": 1, "clazzId": 2, "title": "示例课程"} + answers = iter(inputs) + + def fake_input(prompt=""): + try: + val = next(answers) + except StopIteration: + val = "3" + print(prompt + val) + return val + + cx = mock.Mock() + cx.get_course_list.return_value = [course] + buf = io.StringIO() + with mock.patch.object(wizard, "ensure_api_key"), \ + mock.patch.object(wizard, "ensure_global_prefs"), \ + mock.patch.object(wizard, "pick_user", + return_value=("13800000000", "pw", cx, "测试用户")), \ + mock.patch.object(wizard, "build_config", return_value=os.path.join(tempfile.gettempdir(), 'cx-ui-test.ini')), \ + mock.patch.object(wizard, "ask_after_run", return_value="exit"), \ + mock.patch("builtins.input", fake_input), \ + redirect_stdout(buf): + wizard._main_inner() + return buf.getvalue() + + def test_pages_stay_concise(self): + # 只刷任务中心 / 讨论自动 / 课程 1 / 教学任务 3 个 / 取消 + out = self._render(["3", "1", "1", "3", "n", "3"]) + for line in out.splitlines(): + self.assertLessEqual(self._width(line), 76, f"页面行超过 76 列: {line!r}") + self.assertNotIn("\n\n\n", out, "不要连续两个空行") + + def test_key_information_is_shown(self): + # 章节 + 任务中心 / 讨论自动 / 课程 1 / 章节 2 / 教学任务全部 / 取消 + out = self._render(["1", "1", "1", "2", "all", "n", "3"]) + self.assertIn("刷什么内容", out) + self.assertIn("数字 = 本次刷多少个「还没完成」的,已完成的自动跳过、不会重刷。", out) + self.assertIn("all 或直接回车 = 没完成的全部刷完。", out) + self.assertIn("范围 章节 + 任务中心", out) + self.assertIn("章节 2 个未完成 · 教学任务全部", out) + self.assertIn("讨论怎么刷", out) + self.assertIn("任务里的主题讨论(自动,按课程要求的顺序做)", out) + self.assertIn("讨论区(自己挑帖子回复)", out) + + +class WizardFlowTestCase(unittest.TestCase): + """登录后先问范围、再选课;只刷任务中心时不问任务点数,--yes 透传给 main.py.""" + + def _run_flow(self, argv, scope, submit_answer=None): + course = {"courseId": 1, "clazzId": 2, "title": "测试课"} + seen = {} + + def fake_choose_courses(cx, ask_points=True, ask_tasks=True, only_discussion=False, + discussion_mode=""): + seen["ask_points"] = ask_points + seen["ask_tasks"] = ask_tasks + seen["only_discussion"] = only_discussion + seen["discussion_mode"] = discussion_mode + return [(course, 0, 0)] + + def fake_build_config(username, password, plan, + chapters_enabled=True, task_center_enabled=True, + only_discussion=False, discussion_mode="task"): + seen["scope"] = (chapters_enabled, task_center_enabled, only_discussion) + seen["discussion_mode"] = discussion_mode + return os.path.join(tempfile.gettempdir(), 'cx-test-run.ini') + + def fake_run_main(): + seen["argv"] = list(sys.argv) + + with mock.patch.object(wizard, "ensure_api_key"), \ + mock.patch.object(wizard, "ensure_global_prefs"), \ + mock.patch.object(wizard, "pick_user", + return_value=("13800000000", "pw", mock.Mock(), "测试用户")), \ + mock.patch.object(wizard, "choose_study_scope", return_value=scope), \ + mock.patch.object(wizard, "choose_courses", side_effect=fake_choose_courses), \ + mock.patch.object(wizard, "build_config", side_effect=fake_build_config), \ + mock.patch.object(wizard, "ask_after_run", return_value="exit"), \ + mock.patch.object(wizard, "ask_yes_no", return_value=submit_answer), \ + mock.patch.object(sys, "argv", argv), \ + mock.patch.dict(sys.modules, {"main": mock.Mock(main=fake_run_main)}): + self.assertEqual(wizard._main_inner(), 0) + return seen + + def test_task_center_only_forwards_yes(self): + seen = self._run_flow(["setup_wizard.py", "--yes"], (False, True, False, "task")) + self.assertFalse(seen["ask_points"]) + self.assertTrue(seen["ask_tasks"]) + self.assertEqual(seen["scope"], (False, True, False)) + self.assertEqual(seen["argv"], ["main.py", "-c", os.path.join(tempfile.gettempdir(), 'cx-test-run.ini'), "--yes"]) + + def test_chapters_and_task_center_without_yes(self): + seen = self._run_flow(["setup_wizard.py"], (True, True, False, "task"), submit_answer=True) + self.assertTrue(seen["ask_points"]) + self.assertTrue(seen["ask_tasks"]) + self.assertEqual(seen["scope"], (True, True, False)) + self.assertEqual(seen["argv"], ["main.py", "-c", os.path.join(tempfile.gettempdir(), 'cx-test-run.ini')]) + + def test_chapters_only_does_not_ask_tasks(self): + seen = self._run_flow(["setup_wizard.py"], (True, False, False, ""), submit_answer=True) + self.assertTrue(seen["ask_points"]) + self.assertFalse(seen["ask_tasks"]) + + def test_cancel_does_not_run_main(self): + seen = self._run_flow(["setup_wizard.py"], (True, False, False, ""), submit_answer=False) + self.assertNotIn("argv", seen) + + def test_continue_after_board_round_uses_fresh_chapter_only_scope(self): + """“继续刷其他课程”必须重新取本轮范围,不能沿用上一轮讨论区模式.""" + course = {"courseId": 1, "clazzId": 2, "title": "测试课"} + scopes = iter([(False, False, True, "board"), (True, False, False, "")]) + actions = iter(["again", "exit"]) + written = [] + ran = [] + + def fake_choose_courses(cx, **kwargs): + return [(course, 0, 0)] + + def fake_build_config(username, password, plan, chapters_enabled=True, + task_center_enabled=True, only_discussion=False, + discussion_mode="task"): + written.append((chapters_enabled, task_center_enabled, + only_discussion, discussion_mode)) + return os.path.join(tempfile.gettempdir(), 'cx-test-run.ini') + + def fake_run_main(): + ran.append(list(sys.argv)) + + with mock.patch.object(wizard, "ensure_api_key"), \ + mock.patch.object(wizard, "ensure_global_prefs"), \ + mock.patch.object(wizard, "pick_user", + return_value=("13800000000", "pw", mock.Mock(), "测试用户")), \ + mock.patch.object(wizard, "choose_study_scope", side_effect=lambda: next(scopes)), \ + mock.patch.object(wizard, "choose_courses", side_effect=fake_choose_courses), \ + mock.patch.object(wizard, "build_config", side_effect=fake_build_config), \ + mock.patch.object(wizard, "ask_after_run", side_effect=lambda *a, **k: next(actions)), \ + mock.patch.object(wizard, "ask_yes_no", return_value=True), \ + mock.patch.object(sys, "argv", ["setup_wizard.py"]), \ + mock.patch.dict(sys.modules, {"main": mock.Mock(main=fake_run_main)}): + self.assertEqual(wizard._main_inner(), 0) + + self.assertEqual(written, [ + (False, False, True, "board"), + (True, False, False, ""), + ]) + self.assertEqual(len(ran), 2) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_submission_safety.py b/tests/test_submission_safety.py new file mode 100644 index 000000000..ef95aa2a5 --- /dev/null +++ b/tests/test_submission_safety.py @@ -0,0 +1,102 @@ +"""Submission ordering, cancellation and validation must be observable offline.""" + +import tempfile +import unittest +from unittest import mock + +from api.ai_writer import HumanLikeWriter +from api import review +from api.task_center import TaskCenter +from tests.test_homework import FakeSession, FakeResponse, FakeTiku, SHORTANSWER_PAGE, HOMEWORK_URL + + +class SubmissionSafetyTest(unittest.TestCase): + def setUp(self): + self.directory = tempfile.TemporaryDirectory() + self.addCleanup(self.directory.cleanup) + self.env = mock.patch.dict("os.environ", {"CX_DATA_HOME": self.directory.name}) + self.env.start() + self.addCleanup(self.env.stop) + + def test_discussion_is_durable_before_request(self): + session = mock.Mock() + def post(*args, **kwargs): + items = review.load() + self.assertEqual(len(items), 1) + self.assertEqual(items[0]["status"], "待提交") + return FakeResponse(payload={"status": True, "datas": {"id": "test"}}) + session.post.side_effect = post + tc = TaskCenter(object(), {}) + tc.session = session + self.assertTrue(tc.submit_reply("test-board", "test-topic", reply="概念要和具体问题联系起来。", echo=False)) + self.assertIn("平台已接受", review.load()[0]["status"]) + + def test_failed_review_prevents_discussion_request(self): + session = mock.Mock() + tc = TaskCenter(object(), {}) + tc.session = session + with mock.patch("api.task_center.review.record", return_value=None): + self.assertFalse(tc.submit_reply("test-board", "test-topic", reply="待审核正文", echo=False)) + session.post.assert_not_called() + + def _homework(self): + session = FakeSession([(HOMEWORK_URL, FakeResponse(text=SHORTANSWER_PAGE))]) + writer = mock.Mock(available=True) + writer.answer.return_value = "专业化可以先把现有业务做好。" + cx = type("CX", (), {"tiku": FakeTiku([None])})() + tc = TaskCenter(cx, {"task_center_submit_mode": "confirm"}, writer=writer) + tc.session = session + return tc + + def test_cancelled_homework_is_not_marked_submitted(self): + tc = self._homework() + with mock.patch.object(tc, "confirm_submission", return_value=False): + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "测试作业"})) + self.assertEqual(review.load()[0]["status"], "用户取消,未提交") + self.assertFalse(any(method == "post" for method, url in tc.session.calls)) + + def test_homework_review_failure_blocks_request(self): + tc = self._homework() + with mock.patch("api.task_center.review.record", return_value=None): + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "测试作业"})) + self.assertFalse(any(method == "post" for method, url in tc.session.calls)) + + def test_later_generation_failure_finishes_earlier_draft(self): + tc = self._homework() + questions = [ + {"id": 1, "type": "shortanswer", "title": "第一题", "options": "", "answerField": {}}, + {"id": 2, "type": "shortanswer", "title": "第二题", "options": "", "answerField": {}}, + ] + tc.writer.answer.side_effect = ["专业化先做好已有业务。", RuntimeError("无法生成")] + tc.chaoxing.tiku = FakeTiku([None, None]) + with mock.patch("api.task_center.decode_homework_page", return_value={"questions": questions}): + self.assertFalse(tc.study_homework(HOMEWORK_URL, {"name": "测试作业"})) + self.assertEqual(review.load()[0]["status"], "生成或复核失败,未提交") + self.assertFalse(any(method == "post" for method, url in tc.session.calls)) + + def test_invented_experience_and_source_fail_after_all_retries(self): + for text in ("我们小组上次讨论过这个问题。", "老师提过这个例子。", "教材上写过这个例子。", + "老师在课堂中强调控制成本。", "根据教材第三章的论述,企业要控制成本。", + "我们小组曾经做过成本调查。", "我去年参加过企业培训。", + "教材第二章明确写道,成本需要分摊。", "我参加过一次企业培训。", "我理解这个问题,是因为曾经参加过企业培训。", + "我认为去年参加的企业培训很有帮助。", "教授在授课时明确提及固定成本不会随产量变化。", + "本章原文写道,固定成本不会随产量变化。", + "我认为亲自经营过店铺以后,更能理解成本。", + "讲义中将固定成本定义为不随产量变化的成本。"): + writer = HumanLikeWriter({}) + with mock.patch.object(writer, "_chat", return_value=text) as chat: + with self.assertRaises(RuntimeError): + writer.answer("解释一个概念") + self.assertEqual(chat.call_count, 3) + + def test_final_truncated_text_is_checked(self): + writer = HumanLikeWriter({}) + with mock.patch.object(writer, "_chat", return_value="老师提过这个例子。" * 20): + with self.assertRaises(RuntimeError): + writer._generate_text("解释概念", 20) + + def test_ai_numeric_types_and_stem_agree(self): + for value, expected in ((0, "single"), (1, "multiple"), (3, "judgement"), (4, "shortanswer")): + turn = {"questionTypeInt": value, "questionStem": "测试题干"} + self.assertEqual(TaskCenter._ai_turn_type(turn), expected) + self.assertEqual(TaskCenter._ai_turn_title(turn), "测试题干") diff --git a/tests/test_task_center.py b/tests/test_task_center.py new file mode 100644 index 000000000..432306042 --- /dev/null +++ b/tests/test_task_center.py @@ -0,0 +1,1953 @@ +# -*- coding: utf-8 -*- +"""任务中心(教学任务)离线测试.""" +# +# 覆盖: +# * 教学任务列表 / 分组 / 任务点的解析与失败处理 +# * 任务引擎视频打点节奏(0=开始 / 1=心跳 / 2=结束) +# * 文档任务 readEnd +# * 分组顺序解锁:上一组完成后才继续下一组 +# * 不支持的类型(作业/思考题/讨论/未完成证据的章节)不会被假装成已完成 +# +# 全部测试不联网、不读写用户真实数据。 +import json +import os +from contextlib import contextmanager +import sys +import tempfile +import unittest +from unittest import mock + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +# 必须在导入 api 之前指定数据目录,避免碰到用户真实配置 +os.environ.setdefault("CX_DATA_HOME", tempfile.mkdtemp(prefix="cx-test-")) + +import main # noqa: E402 +from api import task_center as tc_mod # noqa: E402 +from api.task_center import TaskCenter # noqa: E402 + + +class FakeResponse: + def __init__(self, status_code=200, text="", payload=None, url=None, lines=None): + """Initialize configuration and runtime state.""" + self.status_code = status_code + self.text = text + self._payload = payload + self.url = url + self._lines = lines + + def json(self): + if self._payload is None: + raise ValueError("not json") + return self._payload + + def iter_lines(self, decode_unicode=False): + if self._lines is None: + raise AttributeError("not a stream response") + return iter(self._lines) + + +class FakeSession: + """按 URL 关键字路由的假 session,记录所有请求.""" + + def __init__(self, routes): + """Initialize configuration and runtime state.""" + self.routes = routes + self.calls = [] + self.kwargs_calls = [] + + def _dispatch(self, method, url, params=None, **kwargs): + self.calls.append((method, url, params or {})) + self.kwargs_calls.append(kwargs) + for key, handler in self.routes: + if key in url: + if callable(handler): + return handler(method, url, params or {}) + return handler + return FakeResponse(status_code=404) + + def get(self, url, params=None, **kwargs): + return self._dispatch("get", url, params, **kwargs) + + def post(self, url, params=None, **kwargs): + return self._dispatch("post", url, params, **kwargs) + + +LEARN_PAGE = ( + '' + '' +) + + +def make_task_center(routes, config=None): + tc = TaskCenter(chaoxing=object(), config=config or {"speed": 1.0}) + tc.session = FakeSession(routes) + return tc + + +class CourseTasksTestCase(unittest.TestCase): + def setUp(self): + main.logger.remove() + + def test_reads_task_list(self): + tc = make_task_center([ + ("taskSignupList", FakeResponse(payload={"status": True, "data": [{"id": 1, "name": "开学第一课"}]})), + ]) + tasks = tc.get_course_tasks({"courseId": "1", "clazzId": "2", "cpi": "3"}) + self.assertEqual([t["id"] for t in tasks], [1]) + + def test_no_permission_returns_empty(self): + tc = make_task_center([ + ("taskSignupList", FakeResponse(payload={"status": False, "msg": "无权限"})), + ]) + self.assertEqual(tc.get_course_tasks({"courseId": "1"}), []) + + def test_network_error_returns_empty(self): + def boom(method, url, params): + raise RuntimeError("boom") + + tc = make_task_center([("taskSignupList", boom)]) + self.assertEqual(tc.get_course_tasks({"courseId": "1"}), []) + self.assertTrue(tc.last_read_failed) + + def test_http_failure_returns_empty_and_is_marked(self): + tc = make_task_center([ + ("taskSignupList", FakeResponse(status_code=503, payload={"status": True, "data": []})), + ]) + self.assertEqual(tc.get_course_tasks({"courseId": "1"}), []) + self.assertTrue(tc.last_read_failed) + + def test_non_list_task_data_returns_empty(self): + tc = make_task_center([ + ("taskSignupList", FakeResponse(payload={"status": True, "data": {}})), + ]) + self.assertEqual(tc.get_course_tasks({"courseId": "1"}), []) + self.assertTrue(tc.last_read_failed) + + def test_plan_read_business_failure_is_distinguishable_from_empty_group(self): + tc = make_task_center([ + ("getPlanDataByGroupId", FakeResponse(payload={"result": False, "message": "拒绝"})), + ]) + self.assertEqual(tc.get_plans("task", "group"), []) + self.assertTrue(tc.last_plan_read_failed) + + def test_group_http_failure_is_not_an_empty_group(self): + tc = make_task_center([ + ("getGroupData", FakeResponse(status_code=502, payload={"result": True, "data": []})), + ]) + self.assertIsNone(tc.get_groups("task-user")) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.FAILED) + + +class ChapterSyncTestCase(unittest.TestCase): + def setUp(self): + main.logger.remove() + + def test_payload_matches_task_page_shape(self): + payload = TaskCenter.chapter_sync_payload( + "TASK@USER+1", + { + "uid": "U1", + "finishCount": 2, + "clazzId": "C1", + "enc": "E1", + "time": 123, + "jobCount": "3", + "knowledgeId": "K1", + }, + ) + self.assertEqual(payload["encryTaskUserId"], "TASK@USER+1") + self.assertEqual( + list(payload), + [ + "encryTaskUserId", "uid", "finishCount", "clazzId", "enc", + "time", "jobCount", "knowledgeId", + ], + ) + + def test_sync_requires_explicit_result_true(self): + tc = make_task_center([ + ("autoPullChapterScore", FakeResponse(payload={"result": True})), + ]) + self.assertTrue( + tc.sync_chapter_plan( + "TASK@USER", + {"uid": "U1", "clazzId": "C1", "knowledgeId": "K1"}, + ) + ) + + def test_sync_does_not_treat_http_200_as_success(self): + tc = make_task_center([ + ("autoPullChapterScore", FakeResponse(payload={"code": 200})), + ]) + self.assertFalse( + tc.sync_chapter_plan( + "TASK@USER", + {"uid": "U1", "clazzId": "C1", "knowledgeId": "K1"}, + ) + ) + + +class VideoTestCase(unittest.TestCase): + def setUp(self): + main.logger.remove() + + def test_reports_full_duration(self): + route_handler = {} + + def data_log(method, url, params): + route_handler.setdefault("dots", []).append(url.rsplit("/", 3)[-3:]) + return FakeResponse(payload={"result": True}) + + tc = make_task_center([ + ("videoStudy/learnPage", FakeResponse(text=LEARN_PAGE)), + ("videoDataLog/dataLog", data_log), + ("planUserSchedule", FakeResponse(payload={"result": True})), + ]) + with mock.patch("time.sleep", return_value=None): + self.assertTrue(tc.study_video("https://task.chaoxing.com/videoStudy/learnPage?x=1")) + + dots = route_handler["dots"] + # 0=开始, 1=心跳, 2=结束;最后一条必须是完整时长 12 秒 + self.assertEqual(dots[0], ["12", "0", "0"]) + self.assertEqual(dots[-1], ["12", "12", "2"]) + self.assertIn(["12", "6", "1"], dots) + + def test_rejected_dot_fails(self): + tc = make_task_center([ + ("videoStudy/learnPage", FakeResponse(text=LEARN_PAGE)), + ("videoDataLog/dataLog", FakeResponse(payload={"result": False, "message": "no"})), + ]) + with mock.patch("time.sleep", return_value=None): + self.assertFalse(tc.study_video("https://task.chaoxing.com/videoStudy/learnPage?x=1")) + + def test_rejected_end_dot_does_not_finish(self): + def data_log(method, url, params): + status = int(url.rsplit("/", 1)[-1]) + return FakeResponse(payload={"result": status != 2}) + + tc = make_task_center([ + ("videoStudy/learnPage", FakeResponse(text=LEARN_PAGE)), + ("videoDataLog/dataLog", data_log), + ]) + with mock.patch("time.sleep", return_value=None): + self.assertFalse(tc.study_video("https://task.chaoxing.com/videoStudy/learnPage?x=1")) + + def test_broken_page_fails(self): + tc = make_task_center([("videoStudy/learnPage", FakeResponse(text="login"))]) + self.assertFalse(tc.study_video("https://task.chaoxing.com/videoStudy/learnPage?x=1")) + + +class DocumentTestCase(unittest.TestCase): + def setUp(self): + main.logger.remove() + + def test_calls_read_end(self): + doc_page = '' + tc = make_task_center([ + ("documentStudy/learnPage", FakeResponse(text=doc_page)), + ("documentStudy/readEnd", FakeResponse(payload={"result": True})), + ]) + plan = {"planBreakthroughSet": {"enableCompleteRead": 1}} + self.assertTrue(tc.study_document("https://task.chaoxing.com/documentStudy/learnPage?x=1", plan)) + read_end = [c for c in tc.session.calls if "readEnd" in c[1]] + self.assertEqual(read_end[0][2]["encryPlanUserId"], "BEDC@abc") + + def test_does_not_call_read_end_without_completion_flag(self): + doc_page = '' + tc = make_task_center([ + ("documentStudy/learnPage", FakeResponse(text=doc_page)), + ("documentStudy/readEnd", FakeResponse(payload={"result": True})), + ]) + self.assertTrue(tc.study_document( + "https://task.chaoxing.com/documentStudy/learnPage?x=1", + {"planBreakthroughSet": {"enableCompleteRead": 0}}, + )) + self.assertFalse(any("readEnd" in c[1] for c in tc.session.calls)) + + def test_read_end_rejected(self): + doc_page = '' + tc = make_task_center([ + ("documentStudy/learnPage", FakeResponse(text=doc_page)), + ("documentStudy/readEnd", FakeResponse(payload={"result": False, "message": "未读完"})), + ]) + self.assertFalse(tc.study_document( + "https://task.chaoxing.com/documentStudy/learnPage?x=1", + {"planBreakthroughSet": {"enableCompleteRead": 1}}, + )) + + +class FakeGroupEngine: + """Simulate sequential group unlocks without contacting a server.""" + + def __init__(self, plans_by_group): + """Initialize configuration and runtime state.""" + self.plans_by_group = plans_by_group + self.finished = set() + self.studied = [] + self.round = 0 + self.last_outcome = None + self.waiting_confirmation = False + + def open_task(self, task): + self.round += 1 + return {"encryTaskUserId": "u", "encryTaskId": "t"} + + def get_groups(self, etui): + groups = [] + for index in range(len(self.plans_by_group)): + allow = index == 0 or all( + p["planId"] in self.finished for p in self.plans_by_group[index - 1] + ) + groups.append({ + "encryptGroupId": f"g{index}", + "groupAllowStudy": allow, + "taskGroup": {"id": index, "name": f"分组{index}"}, + }) + return groups + + def get_plans(self, etui, group_id): + index = int(group_id[1:]) + return self.plans_by_group[index] + + def plan_finished(self, plan): + return plan["planId"] in self.finished + + def get_study_url(self, etui, encrypt_plan_id): + return f"https://task.chaoxing.com/videoStudy/learnPage?enc={encrypt_plan_id}" + + def _finish(self, url): + """按 encryptPlanId 找到对应任务点并标记完成(模拟服务端同步).""" + enc = url.rsplit("=", 1)[-1] + for plans in self.plans_by_group: + for plan in plans: + if plan["encryptPlanId"] == enc: + self.studied.append(plan["planId"]) + self.finished.add(plan["planId"]) + + def study_video(self, url, plan=None): + self._finish(url) + return True + + def study_document(self, url, plan=None): + self._finish(url) + return True + + def study_ai_practice(self, url, plan=None): + self._finish(url) + return True + + def study_homework(self, url, plan=None, course=None): + self._finish(url) + return True + + def study_discussion(self, url, plan=None, course=None): + self._finish(url) + return True + + def wait_plan_finished(self, etui, group_id, plan_id, tries=3, interval=2.0): + return plan_id in self.finished + + +class GroupUnlockTestCase(unittest.TestCase): + """任务点按分组解锁:只有做完当前组,下一组才会允许学习.""" + + def setUp(self): + main.logger.remove() + + def _make_fake_tc(self, plans_by_group): + return FakeGroupEngine(plans_by_group) + + def test_cancelled_homework_stops_before_next_plan(self): + """A cancelled submission cannot continue with another task in the group.""" + tc = self._make_fake_tc([[{ + "planId": "p1", "planType": 4, "name": "作业", + "encryptPlanId": "e1", "encryptGroupId": "g0", + }, { + "planId": "p2", "planType": 10, "name": "视频", + "encryptPlanId": "e2", "encryptGroupId": "g0", + }]]) + def cancel(*args, **kwargs): + tc.last_outcome = tc_mod.TaskOutcome.WAITING_CONFIRMATION + return False + tc.study_homework = cancel + with mock.patch.object(main.interrupt, "should_stop", return_value=False): + ok, _ = main._process_teaching_task(tc, object(), self._course(), + {"name": "教学任务"}, {"speed": 1}, {}) + self.assertFalse(ok) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.WAITING_CONFIRMATION) + self.assertEqual(tc.studied, []) + + def _course(self): + return {"title": "示例课程", "courseId": "1", "clazzId": "2", "cpi": "3"} + + def test_runs_all_groups_in_order(self): + plans = [ + [{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}], + [{"planId": "p2", "planType": 11, "name": "文档1", "encryptPlanId": "e2", + "encryptGroupId": "g1", "isFinish": False}], + ] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(fake.studied, ["p1", "p2"]) + + def _two_task_case(self, config): + plans = [ + [{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}], + ] + fake = self._make_fake_tc(plans) + fake_tasks = [ + {"id": 1, "name": "第1章", "taskStudyProgress": 0.0}, + {"id": 2, "name": "第2章", "taskStudyProgress": 0.0}, + ] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + return main.run_task_center_phase(object(), [self._course()], config) + + def test_max_tasks_limits_pending_teaching_tasks(self): + """Max_tasks_per_course=1:只刷第 1 个待完成教学任务,其余不算失败.""" + stats = self._two_task_case({"speed": 1.0, "max_tasks_per_course": 1}) + self.assertEqual(stats["tasks"], 1) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(stats["limited"], 1) + + def test_max_tasks_zero_means_all(self): + stats = self._two_task_case({"speed": 1.0, "max_tasks_per_course": 0}) + self.assertEqual(stats["tasks"], 2) + self.assertEqual(stats["limited"], 0) + + def test_max_tasks_supports_per_course_format(self): + stats = self._two_task_case({"speed": 1.0, "max_tasks_per_course": "1:1"}) + self.assertEqual(stats["tasks"], 1) + self.assertEqual(stats["limited"], 1) + # 别的课程没被指定时用默认值 0 = 全部 + stats_other = self._two_task_case({"speed": 1.0, "max_tasks_per_course": "999:1"}) + self.assertEqual(stats_other["tasks"], 2) + self.assertEqual(stats_other["limited"], 0) + + def test_homework_plan_runs_through_orchestration(self): + """PlanType=4 必须走 study_homework,并在引擎复查通过后才算完成.""" + plans = [[{"planId": "p1", "planType": 4, "name": "第1章作业", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}]] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(fake.studied, ["p1"]) + + def test_task_center_phase_quiets_console(self): + """任务中心阶段的内部日志只进文件,控制台交还给 print 的结果行.""" + calls = [] + with mock.patch("main.set_console_quiet", side_effect=calls.append), \ + mock.patch("main.run_task_center_phase", return_value={"ok": 1}) as inner: + result = main._run_task_center_quiet(object(), [], {}, None) + self.assertEqual(calls, [True, False]) + self.assertEqual(result, {"ok": 1}) + inner.assert_called_once() + + def test_unsupported_plan_is_not_retried(self): + """暂不支持的 task point 只尝试一次,不跟着解锁轮次反复重试/刷日志.""" + plans = [ + [{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}], + [{"planId": "p2", "planType": 9, "name": "思考题", "encryptPlanId": "e2", + "encryptGroupId": "g1", "isFinish": False}], + [{"planId": "p3", "planType": 8, "name": "章节", "encryptPlanId": "e3", + "encryptGroupId": "g2", "isFinish": False}], + ] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}), \ + mock.patch("main.time.sleep", return_value=None), \ + mock.patch.object(main, "_complete_teaching_plan", + wraps=main._complete_teaching_plan) as spy: + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["unsupported"], 1) + self.assertEqual(spy.call_count, 2) # p1 + p2 各一次;p2 不跟着轮次重试 + + def test_result_lines_are_concise(self): + """结果行不再重复教学任务名(名字已在 ▸ 行展示).""" + plans = [[{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}]] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + printed = [] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}), \ + mock.patch("builtins.print", + side_effect=lambda *a, **k: printed.append(" ".join(str(x) for x in a))): + main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertIn(" ✓ 完成", printed) + self.assertFalse([line for line in printed if "✓ 完成:" in line]) + + def test_discussion_plan_runs_through_orchestration(self): + """PlanType=14 必须走 study_discussion,并在引擎复查通过后才算完成.""" + plans = [[{"planId": "p1", "planType": 14, "name": "主题讨论", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}]] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第2章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(fake.studied, ["p1"]) + + def test_already_finished_task_is_reported_as_completed(self): + """全部任务点都已完成时是"完成",last_outcome 不能停在 FAILED.""" + plans = [[{"planId": "p1", "planType": 15, "name": "AI实践", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": True}]] + fake = self._make_fake_tc(plans) + fake.finished.add("p1") + fake.last_outcome = None + fake_tasks = [{"id": 1, "name": "开学第一课", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(fake.last_outcome, tc_mod.TaskOutcome.COMPLETED) + self.assertEqual(fake.studied, []) + + def test_locked_groups_are_reported_as_locked(self): + plans = [ + [{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}], + ] + fake = self._make_fake_tc(plans) + fake.get_groups = lambda etui: [{ + "encryptGroupId": "g0", "groupAllowStudy": False, + "taskGroup": {"id": 0, "name": "锁定分组"}, + }] + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}), \ + mock.patch("main.time.sleep", return_value=None): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 1) + self.assertEqual(stats["locked"], 1) + self.assertEqual(fake.last_outcome, tc_mod.TaskOutcome.LOCKED) + + def test_unsupported_type_is_not_faked(self): + plans = [ + [{"planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}], + # 9 思考题是目前唯一还不支持的类型;AI实践(15)/主题讨论(14)都已支持, + # 拿它们当反例会让套件在支持被摘掉时依然全绿。 + [{"planId": "p2", "planType": 9, "name": "思考题", "encryptPlanId": "e2", + "encryptGroupId": "g1", "isFinish": False}], + ] + fake = self._make_fake_tc(plans) + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}), \ + mock.patch("time.sleep", return_value=None): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 1) + self.assertEqual(stats["unsupported"], 1) + self.assertNotIn("p2", fake.studied) + + def _run_task_case(self, fake): + fake_tasks = [{"id": 1, "name": "开学第一课", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}), \ + mock.patch("main.time.sleep", return_value=None): + return main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + + def test_ai_practice_plan_runs_through_orchestration(self): + """PlanType=15 必须真的走 study_ai_practice,并在引擎复查通过后才算完成.""" + plans = [[{"planId": "p1", "planType": 15, "name": "AI实践", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}]] + fake = self._make_fake_tc(plans) + stats = self._run_task_case(fake) + self.assertEqual(stats["done"], 1) + self.assertEqual(stats["failed"], 0) + self.assertEqual(fake.studied, ["p1"]) + self.assertEqual(fake.last_outcome, tc_mod.TaskOutcome.COMPLETED) + + def test_failed_plan_is_not_retried_within_run(self): + """同一个任务点失败后不再借"等解锁"的轮次反复重试(AI实践一局要几分钟).""" + plans = [[ + {"planId": "p1", "planType": 15, "name": "AI实践", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False}, + {"planId": "p2", "planType": 10, "name": "视频1", "encryptPlanId": "e2", + "encryptGroupId": "g0", "isFinish": False}, + ]] + fake = self._make_fake_tc(plans) + calls = [] + + def fail_ai(url, plan=None): + calls.append(url) + return False + + fake.study_ai_practice = fail_ai + stats = self._run_task_case(fake) + self.assertEqual(len(calls), 1) + self.assertEqual(stats["failed"], 1) + self.assertEqual(stats["done"], 0) + self.assertEqual(fake.studied, ["p2"]) + + def _chapter_plan(self): + return { + "planId": "p1", "planType": 8, "name": "章节1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "externalDataId": "k1", "isFinish": False, + } + + def _run_chapter_case(self, fake, point_map, chaoxing=None, side_effect=None): + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + chaoxing = chaoxing if chaoxing is not None else object() + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value=point_map), \ + mock.patch("main.process_chapter", side_effect=side_effect): + return main.run_task_center_phase(chaoxing, [self._course()], {"speed": 1.0}) + + def test_chapter_type_target_missing_is_failed_not_unsupported(self): + """章节点在目录里找不到对应章节:算失败,不能算"暂不支持"或假装完成.""" + fake = self._make_fake_tc([[self._chapter_plan()]]) + stats = self._run_chapter_case(fake, point_map={}) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 1) + self.assertEqual(stats["unsupported"], 0) + self.assertEqual(fake.studied, []) + + def test_chapter_type_syncs_platform_stujobinfo(self): + """章节刷完 + 平台下发 stuJobInfo → 必须调 sync_chapter_plan 且带引擎标记.""" + fake = self._make_fake_tc([[self._chapter_plan()]]) + synced = [] + stu_job_info = { + "knowledgeId": "k1", "uid": "100000001", "finishCount": 3, "clazzId": "2", + "enc": "17414ced7cd27f99c3ffcb39fbccdc3d", "time": 1789612363218, "jobCount": 3, + } + + class FakeChaoxing: + """Provide a synthetic test dependency.""" + + last_student_job_info = None + + chaoxing = FakeChaoxing() + seen = {} + + def fake_process_chapter(cx, course, point, speed, engine_info=False): + seen["engine_info"] = engine_info + seen["point"] = point + cx.last_student_job_info = dict(stu_job_info) + fake.finished.add("p1") + return main.ChapterResult.SUCCESS + + fake.sync_chapter_plan = ( + lambda etui, data: synced.append((etui, dict(data))) or True + ) + stats = self._run_chapter_case( + fake, point_map={"k1": {"id": "k1", "title": "章节1"}}, + chaoxing=chaoxing, side_effect=fake_process_chapter, + ) + self.assertTrue(seen.get("engine_info")) + self.assertEqual(seen.get("point", {}).get("id"), "k1") + self.assertEqual(len(synced), 1) + self.assertEqual(synced[0][0], "u") + self.assertEqual( + {k: synced[0][1].get(k) for k in + ("uid", "finishCount", "clazzId", "enc", "time", "jobCount", "knowledgeId")}, + {k: stu_job_info.get(k) for k in + ("uid", "finishCount", "clazzId", "enc", "time", "jobCount", "knowledgeId")}, + ) + self.assertEqual(stats["done"], 1) + + def test_chapter_type_without_stujobinfo_does_not_fake_sync(self): + """平台没下发同步数据:不能自己拼 enc,也不能报完成.""" + fake = self._make_fake_tc([[self._chapter_plan()]]) + synced = [] + fake.sync_chapter_plan = lambda etui, data: synced.append(data) or True + + class FakeChaoxing: + """Provide a synthetic test dependency.""" + + last_student_job_info = None + + def fake_process_chapter(cx, course, point, speed, engine_info=False): + # 不设置 last_student_job_info:模拟平台没有下发 + return main.ChapterResult.SUCCESS + + stats = self._run_chapter_case( + fake, point_map={"k1": {"id": "k1", "title": "章节1"}}, + chaoxing=FakeChaoxing(), side_effect=fake_process_chapter, + ) + self.assertEqual(synced, []) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 1) + self.assertEqual(stats["unsupported"], 0) + + def test_plan_finished_reads_both_fields(self): + self.assertTrue(TaskCenter.plan_finished({"isFinish": True})) + self.assertTrue(TaskCenter.plan_finished({"planUser": {"finish": 1}})) + self.assertFalse(TaskCenter.plan_finished({"isFinish": False, "planUser": {"finish": 0}})) + self.assertFalse(TaskCenter.plan_finished({"isFinish": "false", "planUser": {"finish": "0"}})) + self.assertFalse(TaskCenter.plan_finished(None)) + + def test_task_list_read_failure_is_not_reported_as_completion(self): + class FailedTC: + """Provide a synthetic test dependency.""" + + last_read_failed = True + + def get_course_tasks(self, course): + return [] + + with mock.patch("main.TaskCenter", return_value=FailedTC()): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 0) + self.assertEqual(stats["read_failed"], 1) + + def test_plan_read_failure_is_not_reported_as_completion(self): + plans = [[{ + "planId": "p1", "planType": 10, "name": "视频1", "encryptPlanId": "e1", + "encryptGroupId": "g0", "isFinish": False, + }]] + fake = self._make_fake_tc(plans) + fake.last_plan_read_failed = True + fake_tasks = [{"id": 1, "name": "第1章", "taskStudyProgress": 0.0}] + with mock.patch.object(fake, "get_course_tasks", lambda course: fake_tasks, create=True), \ + mock.patch("main.TaskCenter", return_value=fake), \ + mock.patch("main._load_course_point_map", return_value={}): + stats = main.run_task_center_phase(object(), [self._course()], {"speed": 1.0}) + self.assertEqual(stats["done"], 0) + self.assertEqual(stats["failed"], 1) + + +class SwitchTestCase(unittest.TestCase): + def setUp(self): + main.logger.remove() + + def test_cli_overrides_config(self): + args = mock.Mock(task_center=False) + self.assertFalse(main._task_center_enabled({"task_center": True}, args)) + args = mock.Mock(task_center=True) + self.assertTrue(main._task_center_enabled({"task_center": "false"}, args)) + + def test_config_and_default(self): + self.assertTrue(main._task_center_enabled({}, mock.Mock(task_center=None))) + self.assertTrue(main._task_center_enabled({"task_center": None}, mock.Mock(task_center=None))) + self.assertFalse(main._task_center_enabled({"task_center": "false"}, mock.Mock(task_center=None))) + self.assertTrue(main._task_center_enabled({"task_center": "true"}, mock.Mock(task_center=None))) + + def test_task_finished_flag(self): + self.assertTrue(main._teaching_task_finished({"taskStudyProgress": 1.0})) + self.assertFalse(main._teaching_task_finished({"taskStudyProgress": 0.0})) + self.assertFalse(main._teaching_task_finished({"taskStudyProgress": "oops"})) + + def test_cli_submit_mode_overrides_config_file(self): + args = type("Args", (), { + "config": os.path.join(tempfile.gettempdir(), 'config.ini'), + "task_center": None, + "task_center_submit_mode": "auto", + })() + with mock.patch.object(main, "parse_args", return_value=args), \ + mock.patch.object( + main, "load_config_from_file", + return_value=({"task_center_submit_mode": "confirm"}, {}, {}), + ): + common, _tiku, _notification, _path, _args = main.init_config() + self.assertEqual(common["task_center_submit_mode"], "auto") + + +class VideoWatchDurationTestCase(unittest.TestCase): + """有时长要求的视频:按 1 倍速播完还不够时要回看.""" + + def setUp(self): + main.logger.remove() + + def test_replays_until_watch_duration_met(self): + dots = [] + + def data_log(method, url, params): + dots.append(url.rsplit("/", 3)[-3:]) + return FakeResponse(payload={"result": True}) + + tc = make_task_center([ + ("videoStudy/learnPage", FakeResponse(text=LEARN_PAGE)), + ("videoDataLog/dataLog", data_log), + ("planUserSchedule", FakeResponse(payload={"result": True})), + ], config={"speed": 2.0}) + plan = {"planBreakthroughSet": {"enableVideoWatchDuration": 1, "videoWatchDuration": 0.4}} + with mock.patch.object(tc_mod.time, "sleep", lambda s: None): + ok = tc.study_video("https://task.chaoxing.com/videoStudy/learnPage?x=1", plan) + self.assertTrue(ok) + starts = [d for d in dots if d[2] == "0"] + # 12 秒的视频要 24 秒时长 -> 必须回看一遍 + self.assertEqual(len(starts), 2) + self.assertEqual(dots[0], ["12", "0", "0"]) + self.assertEqual(dots[-1], ["12", "12", "2"]) + + def test_need_seconds_parsing(self): + self.assertEqual( + TaskCenter.need_seconds({"planBreakthroughSet": {"enableDocumentWatchDuration": 1, + "documentWatchDuration": 5.0}}, + "enableDocumentWatchDuration", "documentWatchDuration"), + 300, + ) + self.assertEqual( + TaskCenter.need_seconds({"planBreakthroughSet": {"enableDocumentWatchDuration": 0, + "documentWatchDuration": 5.0}}, + "enableDocumentWatchDuration", "documentWatchDuration"), + 0, + ) + self.assertEqual(TaskCenter.need_seconds(None, "enableVideoWatchDuration", "videoWatchDuration"), 0) + + +DOC_LEARN_PAGE = ( + '' + '' +) +DOC_READER_PAGE = ( + '' + '' +) + + +class DocumentWatchDurationTestCase(unittest.TestCase): + """文档:按阅读时长打点,凑够时间再收尾.""" + + def setUp(self): + main.logger.remove() + + def _make(self): + return make_task_center([ + ("documentStudy/learnPage", FakeResponse(text=DOC_LEARN_PAGE)), + ("pan-yz.chaoxing.com/screen/v2", FakeResponse(text=DOC_READER_PAGE)), + ("data-xxt.aichaoxing.com/analysis/ac_mark", FakeResponse(text="")), + ("documentStudy/readEnd", FakeResponse(payload={"result": True})), + ]) + + def test_pings_until_required_seconds(self): + tc = self._make() + clock = type("Clock", (), {"t": 0.0, + "now": lambda self: self.t, + "sleep": lambda self, s: setattr(self, "t", self.t + s)})() + plan = {"name": "案例文档", "planBreakthroughSet": { + "enableDocumentWatchDuration": 1, + "documentWatchDuration": 0.1, + "enableCompleteRead": 1, + }} + with mock.patch.object(tc_mod.time, "time", clock.now), \ + mock.patch.object(tc_mod.time, "sleep", clock.sleep): + ok = tc.study_document("https://task.chaoxing.com/documentStudy/learnPage?x=1", plan) + self.assertTrue(ok) + pings = [c for c in tc.session.calls if "ac_mark" in c[1]] + self.assertGreaterEqual(len(pings), 2) + self.assertEqual(pings[0][2]["f"], "readPoint") + self.assertEqual(pings[0][2]["u"], "123") + self.assertIn("rwyq_doc", pings[0][2]["d"]) + self.assertEqual(json.loads(pings[0][2]["d"])["s"], 1) + self.assertEqual(json.loads(pings[1][2]["d"])["s"], 2) + self.assertEqual([c for c in tc.session.calls if "readEnd" in c[1]][0][2]["encryPlanUserId"], "BEDC@planuser") + + def test_requires_reader_mark(self): + """拿不到打点信息时不能假装完成.""" + tc = make_task_center([ + ("documentStudy/learnPage", FakeResponse(text='')), + ("documentStudy/readEnd", FakeResponse(payload={"result": True})), + ]) + plan = {"planBreakthroughSet": {"enableDocumentWatchDuration": 1, "documentWatchDuration": 5.0}} + self.assertFalse(tc.study_document("https://task.chaoxing.com/documentStudy/learnPage?x=1", plan)) + + def test_rejected_read_point_does_not_finish_document(self): + tc = make_task_center([ + ("documentStudy/learnPage", FakeResponse(text=DOC_LEARN_PAGE)), + ("pan-yz.chaoxing.com/screen/v2", FakeResponse(text=DOC_READER_PAGE)), + ("data-xxt.aichaoxing.com/analysis/ac_mark", FakeResponse(status_code=403)), + ("documentStudy/readEnd", FakeResponse(payload={"result": True})), + ]) + plan = {"planBreakthroughSet": {"enableDocumentWatchDuration": 1, "documentWatchDuration": 0.1}} + with mock.patch.object(tc_mod.time, "time", side_effect=[0.0, 0.0]): + self.assertFalse(tc.study_document("https://task.chaoxing.com/documentStudy/learnPage?x=1", plan)) + self.assertFalse(any("readEnd" in c[1] for c in tc.session.calls)) + + def test_enc_matches_synthetic_known_answer(self): + """Only synthetic identifiers are needed for the protocol digest fixture.""" + sample = {"f": "readPoint", "u": "test-user", "d": "test-document", + "t": "20000101000000000"} + self.assertEqual(tc_mod._read_point_enc(sample), "9b94f9c71e8f85c82f316cafbdbe129f") + + def test_timestamp_and_enc_are_generated_together(self): + tc = make_task_center([]) + mark = { + "resourceID": "OBJ1", + "resourceType": "doc", + "from": 4, + "passportUID": "123", + "location": 1, + "curPage": 1, + "totalPage": 2, + "ext": "{\"rwyq_doc\":1}", + } + with mock.patch.object(tc_mod.time, "time", return_value=1_757_000_123.456): + self.assertFalse(tc._send_read_point(mark, 1)) + params = tc.session.calls[0][2] + self.assertRegex(params["t"], r"^\d{17}$") + self.assertEqual(params["enc"], tc_mod._read_point_enc(params)) + + def test_read_point_uses_browser_origin_headers(self): + tc = make_task_center([]) + seen = {} + + class HeaderSession: + """Provide a synthetic test dependency.""" + + def get(self, url, params=None, **kwargs): + seen.update(kwargs) + return FakeResponse(status_code=403) + + tc.session = HeaderSession() + self.assertFalse(tc._send_read_point({"resourceID": "OBJ1"}, 1)) + self.assertEqual(seen["headers"], tc_mod.READ_POINT_HEADERS) + + +class SubmitModeTestCase(unittest.TestCase): + def test_default_mode_is_auto(self): + """默认自动提交(挂后台刷课);只有显式 confirm 才逐次询问.""" + self.assertEqual(tc_mod.normalize_submit_mode(None), "auto") + self.assertEqual(tc_mod.normalize_submit_mode(""), "auto") + self.assertEqual(tc_mod.normalize_submit_mode("unexpected"), "auto") + self.assertEqual(tc_mod.normalize_submit_mode("AUTO"), "auto") + self.assertEqual(tc_mod.normalize_submit_mode("confirm"), "confirm") + + def test_confirm_mode_without_tty_does_not_submit(self): + tc = make_task_center([], config={"task_center_submit_mode": "confirm"}) + with mock.patch.object(sys.stdin, "isatty", return_value=False): + self.assertFalse(tc._ai_submit( + { + "courseid": "c", + "clazzid": "z", + "cpi": "p", + "publishRelationUuid": "r", + }, + "record", + "预览内容", + )) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.WAITING_CONFIRMATION) + self.assertFalse(any("answer/submit" in call[1] for call in tc.session.calls)) + + +class ConfirmPromptStdinTestCase(unittest.TestCase): + """确认提示必须先让键盘监听让出 stdin.""" + + # + # 终端并发约束:章节阶段起的键盘监听线程会把终端设成 + # cbreak 并一直 os.read(stdin,1),与 input() 抢字符——逐字敲 "yes" 会被 + # 吃成 "ye"/"ys"(按取消处理),甚至让 input() 永久挂住且看不到回显。 + + def test_confirm_prompt_runs_inside_stdin_guard(self): + events = [] + + @contextmanager + def fake_guard(): + events.append("pause") + try: + yield True + finally: + events.append("resume") + + class FakeTTY: + """Provide a synthetic test dependency.""" + + def isatty(self): + return True + + tc = TaskCenter(object(), {"task_center_submit_mode": "confirm"}) + with mock.patch.object(tc_mod.sys, "stdin", FakeTTY()), \ + mock.patch.object(tc_mod.interrupt, "stdin_for_prompt", fake_guard), \ + mock.patch("builtins.input", side_effect=lambda prompt="": (events.append("input"), "y")[1]): + self.assertTrue(tc.confirm_submission("AI实践", "预览")) + self.assertEqual(events, ["pause", "input", "resume"]) + + def test_paused_watcher_leaves_stdin_for_input(self): + """暂停期间监听线程不再消费 stdin;恢复后又能按 q 终止.""" + import select as _select + import termios as _termios + import time as _time + + if os.name == "nt": + self.skipTest("termios 只测 POSIX") + try: + import pty + except ImportError: + self.skipTest("没有 pty") + + master, slave = pty.openpty() + # 关掉回显:pty 的 master 端没人读,回显会把输出缓冲写满, + # 之后 termios 改属性(等输出排空)和 close 都会永久阻塞。 + attrs = _termios.tcgetattr(slave) + attrs[3] = attrs[3] & ~_termios.ECHO + _termios.tcsetattr(slave, _termios.TCSANOW, attrs) + fake_stdin = os.fdopen(os.dup(slave), "rb", buffering=0) + old_stdin = sys.stdin + sys.stdin = fake_stdin + try: + self.assertTrue(tc_mod.interrupt.start_watcher()) + self.assertTrue(tc_mod.interrupt.pause_watcher(2.0)) + # 监听让开以后,写进终端的内容应该原样被读到 + os.write(master, b"hello\n") + ready, _, _ = _select.select([slave], [], [], 2.0) + self.assertTrue(ready, "暂停期间 stdin 仍被监听线程消费") + with os.fdopen(os.dup(slave), "rb", buffering=0) as reader: + self.assertEqual(reader.readline(), b"hello\n") + # 恢复监听后按 q 依旧能终止 + tc_mod.interrupt.resume_watcher() + _time.sleep(0.2) + os.write(master, b"q") + deadline = _time.time() + 3.0 + while _time.time() < deadline and not tc_mod.interrupt.should_stop(): + _time.sleep(0.05) + self.assertTrue(tc_mod.interrupt.should_stop(), "恢复后按 q 没有生效") + finally: + sys.stdin = old_stdin + tc_mod.interrupt.reset() + fake_stdin.close() + os.close(master) + os.close(slave) + + +class AIPracticeTestCase(unittest.TestCase): + PAGE_URL = ( + "https://mooc2-ans-vue.example/think-ladder/answer/pc-index?" + "courseid=c1&clazzid=z1&cpi=p1&publishRelationUuid=pub1&aiEnc=enc1" + ) + + @staticmethod + def _event(content, event_type=None): + event = {"content": content} + if event_type: + event["type"] = event_type + return b"data:" + json.dumps(event, ensure_ascii=False).encode("utf-8") + + def test_sse_parser_keeps_fields_and_special_marks(self): + lines = [ + b": heartbeat", + self._event("单选题", "questionType"), + self._event("0", "questionTypeInt"), + self._event("企业战略", "dimension"), + self._event("战略选择", "knowledgePoint"), + self._event("题目内容", "questionStem"), + self._event("选项一", "option-A"), + self._event("补充", "option-A"), + self._event("选项二", "option-B"), + self._event("SonQuestion"), + b"data: [DONE]", + ] + result = TaskCenter.parse_ai_sse(lines) + self.assertTrue(result["had_data"]) + self.assertTrue(result["stream_closed"]) + self.assertEqual(result["questionTypeInt"], "0") + self.assertEqual(result["questionStem"], "题目内容") + self.assertEqual(result["options"][0]["optionContent"], "选项一补充") + self.assertIn("SonQuestion", result["special_marks"]) + + def test_ai_practice_submits_only_after_status_and_score_readback(self): + state = {"loads": 0, "streams": 0} + + def load_data(method, url, params): + state["loads"] += 1 + if state["loads"] == 1: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + "answerUuid": "answer-1", + "unCompleteTopic": ["topic-1"], + } + elif state["loads"] == 2: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + "answerUuid": "answer-1", + "unCompleteTopic": [], + } + else: + payload = { + "recordStatus": 2, + "recordUuid": "record-1", + "answerUuid": "answer-1", + "answerScore": 90, + "answerRecords": [{"recordUuid": "record-1", "score": 90}], + "unCompleteTopic": [], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def talk(method, url, params): + state["streams"] += 1 + if state["streams"] == 1: + lines = [ + self._event("单选题", "questionType"), + self._event("0", "questionTypeInt"), + self._event("题目:战略的核心是什么?", "questionStem"), + self._event("方向", "option-A"), + self._event("规模", "option-B"), + ] + else: + lines = [self._event("SummaryTopic")] + return FakeResponse(lines=lines) + + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context=""): + return "A" + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 1}, + writer=Writer(), + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL, text="")), + ("load-data", load_data), + ("main-talk", talk), + ("answer/submit", FakeResponse(payload={"status": True, "data": 2})), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + self.assertTrue(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + submit_calls = [call for call in tc.session.calls if "answer/submit" in call[1]] + self.assertEqual(len(submit_calls), 1) + submit_index = [i for i, call in enumerate(tc.session.calls) if "answer/submit" in call[1]][0] + self.assertEqual(tc.session.kwargs_calls[submit_index]["data"], {}) + stream_indexes = [i for i, call in enumerate(tc.session.calls) if "main-talk" in call[1]] + self.assertEqual(tc.session.kwargs_calls[stream_indexes[0]]["data"], {"userMessage": ""}) + stream_index = stream_indexes[-1] + self.assertEqual(tc.session.kwargs_calls[stream_index]["data"], {"userMessage": "A"}) + self.assertEqual(tc.session.kwargs_calls[stream_index]["headers"], tc_mod.AI_STREAM_HEADERS) + self.assertEqual(tc.session.kwargs_calls[stream_index]["timeout"], tc_mod.AI_STREAM_TIMEOUT) + self.assertTrue(tc.session.kwargs_calls[stream_index]["stream"]) + self.assertEqual( + tc.session.kwargs_calls[submit_index]["headers"], tc_mod.AI_FORM_HEADERS + ) + + def test_ai_practice_rejects_http_200_without_business_success(self): + tc = TaskCenter(object(), {"task_center_submit_mode": "auto"}) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL)), + ("load-data", FakeResponse(payload={"status": False, "msg": "拒绝"})), + ]) + self.assertFalse(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.FAILED) + + def test_ai_submit_rejects_http_200_without_business_success(self): + tc = TaskCenter(object(), {"task_center_submit_mode": "auto"}) + tc.session = FakeSession([ + ("answer/submit", FakeResponse(payload={"status": True, "data": 0})), + ]) + self.assertFalse(tc._ai_submit({ + "courseid": "c", "clazzid": "z", "cpi": "p", "publishRelationUuid": "r", + }, "record")) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.FAILED) + + def test_ai_practice_retries_low_score_with_new_record(self): + state = {"loads": 0, "streams": 0, "inits": 0, "submits": 0} + + def load_data(method, url, params): + state["loads"] += 1 + if state["loads"] in {1, 4}: + record = "record-1" if state["loads"] == 1 else "record-2" + return FakeResponse(payload={ + "status": True, + "data": { + "recordStatus": 0, + "recordUuid": record, + "answerUuid": "answer-" + record[-1], + "unCompleteTopic": ["topic-1"], + }, + }) + if state["loads"] == 2: + data = { + "recordStatus": 0, + "recordUuid": "record-1", + "answerUuid": "answer-1", + "unCompleteTopic": [], + } + elif state["loads"] == 3: + data = { + "recordStatus": 2, + "recordUuid": "record-1", + "answerUuid": "answer-1", + "answerScore": 40, + "answerRecords": [{"recordUuid": "record-1", "score": 40}], + "remainAnswerCount": 1, + "unCompleteTopic": [], + } + elif state["loads"] == 5: + data = { + "recordStatus": 0, + "recordUuid": "record-2", + "answerUuid": "answer-2", + "unCompleteTopic": [], + } + else: + data = { + "recordStatus": 2, + "recordUuid": "record-2", + "answerUuid": "answer-2", + "answerScore": 90, + "answerRecords": [{"recordUuid": "record-2", "score": 90}], + "remainAnswerCount": 0, + "unCompleteTopic": [], + } + return FakeResponse(payload={"status": True, "data": data}) + + def init_data(method, url, params): + state["inits"] += 1 + return FakeResponse(payload={ + "status": True, + "data": {"recordUuid": "record-2", "answerUuid": "answer-2"}, + }) + + def talk(method, url, params): + state["streams"] += 1 + if state["streams"] % 2: + lines = [ + self._event("单选题", "questionType"), + self._event("0", "questionTypeInt"), + self._event("题目:战略的核心是什么?", "questionStem"), + self._event("方向", "option-A"), + self._event("规模", "option-B"), + ] + else: + lines = [self._event("SummaryTopic")] + return FakeResponse(lines=lines) + + def submit(method, url, params): + state["submits"] += 1 + return FakeResponse(payload={"status": True, "data": state["submits"]}) + + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context=""): + return "A" + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 2}, + writer=Writer(), + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL)), + ("load-data", load_data), + ("answer/init", init_data), + ("main-talk", talk), + ("answer/submit", submit), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + self.assertTrue(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(state["inits"], 1) + self.assertEqual(state["submits"], 2) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + + +class ChapterEngineInfoTestCase(unittest.TestCase): + """任务引擎「章节」上下文:打点带 courseEngineInfo,平台的 stuJobInfo 要暂存.""" + + def setUp(self): + main.logger.remove() + + def _chaoxing(self): + from api import base as base_mod + cx = base_mod.Chaoxing() + cx.video_log_limiter = base_mod.RateLimiter(0) + cx.get_uid = lambda: "100000001" + cx.get_fid = lambda: "1336" + return cx + + @staticmethod + def _job(): + return { + "jobid": "1548984627901674", + "objectid": "011155377179e72459aae8a97edbfbe8", + "otherinfo": "nodeId_100001-cpi_1000003-rt_d-ds_0-ff_1-be_0_0-vt_1-v_6-enc_c64478", + "videoFaceCaptureEnc": "", + "attDuration": "", + "attDurationEnc": "", + "rt": "0.9", + "name": "测试视频", + } + + def _run_log(self, cx, engine_info, payload): + calls = [] + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, params=None, **kwargs): + calls.append(dict(params or {})) + return FakeResponse(payload=payload) + + passed, state = cx.video_progress_log( + Sess(), {"clazzId": "1000002", "courseId": "1000001", "cpi": "1000003"}, + self._job(), {}, "dtoken-x", 696, 696, "Video", headers={}, + engine_info=engine_info, + ) + return passed, state, calls + + def test_engine_info_adds_course_engine_info_param(self): + cx = self._chaoxing() + stu = {"knowledgeId": 100001, "uid": "100000001", "finishCount": 3, + "clazzId": 1000002, "enc": "17414ced", "time": 1, "jobCount": 3} + passed, state, calls = self._run_log( + cx, True, {"isPassed": True, "stuJobInfo": stu} + ) + self.assertTrue(passed) + self.assertEqual(state, 200) + self.assertEqual(calls[0].get("courseEngineInfo"), "true") + self.assertEqual(cx.last_student_job_info, stu) + + def test_forbidden_request_falls_back_to_curl(self): + """Requests 被客户端指纹拦截(403)时,用 curl 原样重放并采用其结果.""" + from api import base as base_mod + cx = self._chaoxing() + calls = [] + + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, params=None, **kwargs): + calls.append(dict(params or {})) + return FakeResponse(status_code=403, text="403 错误页") + + with mock.patch.object(base_mod, "_curl_get", + return_value=base_mod._CurlResponse( + 200, '{"isPassed": true}', "https://x/log")): + passed, state = cx.video_progress_log( + Sess(), {"clazzId": "1000002", "courseId": "1000001", "cpi": "1000003"}, + self._job(), {}, "dtoken-x", 696, 696, "Video", headers={}, + engine_info=True, + ) + self.assertTrue(passed) + self.assertEqual(state, 200) + + def test_curl_replay_parses_body_and_status(self): + from api import base as base_mod + + class FakeProc: + """Provide a synthetic test dependency.""" + + stdout = '{"isPassed": true}\n200' + returncode = 0 + + class FakeSession: + """Provide a synthetic test dependency.""" + + cookies = {} + + with mock.patch("shutil.which", return_value="/usr/bin/curl"), \ + mock.patch("subprocess.run", return_value=FakeProc()): + res = base_mod._curl_get(FakeSession(), "https://x/y", {"a": 1}, + {"Referer": "https://r"}) + self.assertEqual(res.status_code, 200) + self.assertTrue(res.json()["isPassed"]) + + def test_plain_log_has_no_engine_param_and_no_capture(self): + cx = self._chaoxing() + passed, _state, calls = self._run_log( + cx, False, {"isPassed": True, "stuJobInfo": {"enc": "不应被暂存"}} + ) + self.assertTrue(passed) + self.assertNotIn("courseEngineInfo", calls[0]) + self.assertIsNone(cx.last_student_job_info) + + +class EngineDocumentSyncTestCase(unittest.TestCase): + """文档在任务引擎上下文里:完成后要请求 /mooc-ans/job/document 并暂存 stuJobInfo.""" + + def setUp(self): + main.logger.remove() + + def _sess(self, calls, stu): + class Sess: + """Provide a synthetic test dependency.""" + + def get(self, url, params=None, **kwargs): + calls.append((url, dict(params or {}))) + if "mooc-ans/job/document" in url: + return FakeResponse(payload={"status": True, "msg": "考核点已经完成", + "stuJobInfo": stu}) + return FakeResponse(payload={"status": True}) + + return Sess() + + def test_study_document_engine_context_captures_stujobinfo(self): + from api import base as base_mod + calls = [] + stu = {"knowledgeId": 100001, "uid": "100000001", "finishCount": 3, + "clazzId": 1000002, "enc": "17414ced", "time": 1, "jobCount": 3} + cx = base_mod.Chaoxing() + with mock.patch.object(base_mod.SessionManager, "get_session", + return_value=self._sess(calls, stu)): + result = cx.study_document( + {"courseId": "1000001", "clazzId": "1000002"}, + {"jobid": "10001", + "otherinfo": "nodeId_100001-cpi_1000003", + "jtoken": "test-document-token"}, + engine_info=True, + ) + self.assertEqual(result, base_mod.StudyResult.SUCCESS) + engine_calls = [c for c in calls if "mooc-ans/job/document" in c[0]] + self.assertEqual(len(engine_calls), 1) + self.assertEqual(engine_calls[0][1].get("courseEngineInfo"), "true") + self.assertEqual(engine_calls[0][1].get("checkMicroTopic"), "true") + self.assertEqual(engine_calls[0][1].get("knowledgeid"), "100001") + self.assertEqual(cx.last_student_job_info, stu) + + def test_study_document_without_engine_context_keeps_old_behavior(self): + from api import base as base_mod + calls = [] + cx = base_mod.Chaoxing() + with mock.patch.object(base_mod.SessionManager, "get_session", + return_value=self._sess(calls, {"enc": "不应被暂存"})): + result = cx.study_document( + {"courseId": "1000001", "clazzId": "1000002"}, + {"jobid": "10001", + "otherinfo": "nodeId_100001-cpi_1000003", + "jtoken": "jtoken-x"}, + ) + self.assertEqual(result, base_mod.StudyResult.SUCCESS) + self.assertFalse([c for c in calls if "mooc-ans/job/document" in c[0]]) + self.assertIsNone(cx.last_student_job_info) + +class AIPendingTurnTestCase(unittest.TestCase): + """过期题目不能当成 pending:平台出总结后,局已经结束.""" + + def _msg(self, role, payload): + return {"role": role, "content": json.dumps(payload, ensure_ascii=False)} + + def test_summary_after_question_means_done(self): + data = {"messageList": [ + self._msg("2", {"questionStem": "旧题", "questionTypeInt": "0", + "questionOptions": [{"option": "A", "optionContent": "a"}]}), + self._msg("1", {"content": "D"}), + self._msg("2", {"content": "# 怎样才能具备CEO的思维和能力知识点解析\n\n## 一、战略管理"}), + ]} + self.assertIsNone(TaskCenter._ai_pending_turn(data)) + + def test_question_after_answer_is_pending(self): + data = {"messageList": [ + self._msg("2", {"questionStem": "新题", "questionTypeInt": "0", + "questionOptions": [{"option": "A", "optionContent": "a"}]}), + ]} + turn = TaskCenter._ai_pending_turn(data) + self.assertIsNotNone(turn) + self.assertEqual(turn["questionStem"], "新题") + + +class AIReportScoreTestCase(unittest.TestCase): + """成绩是"学习质量评估报告"现算出来的:提交后必须请求它,否则永远不出分.""" + + PAGE_URL = AIPracticeTestCase.PAGE_URL + + def test_report_sse_parses_score_from_split_lines(self): + lines = [ + 'data:{"id":"score","content":"92"}', + 'data:{"id":"学习怎样成为一个中层管理者","content":"亮点"}', + 'data:{"id":"学习怎样成为一个中层管理者', + '","content":"表现:答得好"}', + "data:[DONE]", + ] + result = TaskCenter.parse_ai_report_sse(lines) + self.assertTrue(result["had_data"]) + self.assertTrue(result["stream_closed"]) + self.assertEqual(result["score"], 92.0) + self.assertIn("亮点", result["sections"]["学习怎样成为一个中层管理者"]) + + def test_report_sse_without_score_is_not_a_score(self): + result = TaskCenter.parse_ai_report_sse(['data:{"id":"other","content":"x"}']) + self.assertIsNone(result["score"]) + + def test_ai_practice_uses_report_score_when_state_is_not_backfilled(self): + state = {"loads": 0, "streams": 0, "submitted": False} + + def load_data(method, url, params): + state["loads"] += 1 + if state["submitted"]: + # 平台状态接口回填慢:这里故意永远不把本条记录放进 answerRecords + payload = { + "recordStatus": 1, + "recordUuid": "record-1", + "answerScore": 30, + "answerRecords": [{"recordUuid": "old", "score": 30}], + "unCompleteTopic": [], + } + elif state["loads"] == 1: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + "unCompleteTopic": ["topic-1"], + } + else: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + "unCompleteTopic": [], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def talk(method, url, params): + state["streams"] += 1 + if state["streams"] == 1: + lines = [ + AIPracticeTestCase._event("单选题", "questionType"), + AIPracticeTestCase._event("0", "questionTypeInt"), + AIPracticeTestCase._event("题目:战略的核心是什么?", "questionStem"), + AIPracticeTestCase._event("方向", "option-A"), + AIPracticeTestCase._event("规模", "option-B"), + ] + else: + lines = [AIPracticeTestCase._event("SummaryTopic")] + return FakeResponse(lines=lines) + + def report(method, url, params): + self.assertEqual(params.get("recordUuid"), "record-1") + return FakeResponse(lines=['data:{"id":"score","content":"92"}', "data:[DONE]"]) + + def submit(method, url, params): + state["submitted"] = True + return FakeResponse(payload={"status": True, "data": 1}) + + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + return "A" + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 1}, + writer=Writer(), + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL, text="")), + ("load-data", load_data), + ("main-talk", talk), + ("answer/submit", submit), + ("end-report", report), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + self.assertTrue(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + report_calls = [call for call in tc.session.calls if "end-report" in call[1]] + self.assertEqual(len(report_calls), 1) + # 报告已经给了成绩:提交后最多再读一次状态,不能固定轮询 19 次×30s + submit_index = [i for i, call in enumerate(tc.session.calls) + if "answer/submit" in call[1]][0] + loads_after_submit = [ + i for i, call in enumerate(tc.session.calls) + if "load-data" in call[1] and i > submit_index + ] + self.assertLessEqual(len(loads_after_submit), 2) + submit_index = [i for i, call in enumerate(tc.session.calls) if "answer/submit" in call[1]][0] + report_index = [i for i, call in enumerate(tc.session.calls) if "end-report" in call[1]][0] + self.assertGreater(report_index, submit_index) + + +class AIObjectiveAnswerTestCase(unittest.TestCase): + """客观题必须有客观题的作答形态:平台没给题型也不能写成小作文.""" + + def test_options_without_type_are_answered_as_choice(self): + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + return "B" + + def answer(self, *args, **kwargs): + raise AssertionError("带选项的题目不能走简答") + + tc = TaskCenter(object(), {}, writer=Writer()) + turn = { + "questionStem": "公司层战略的核心特征是什么?", + "questionType": "未知题型", + "questionTypeInt": "", + "options": [ + {"option": "A", "optionContent": "单一业务板块的运营流程优化"}, + {"option": "B", "optionContent": "业务领域选择与业务组合管理"}, + ], + } + self.assertEqual(tc._ai_answer(turn, {}), "B") + + def test_unknown_numeric_type_with_options_is_still_choice(self): + """题型编码没见过(如 "2")但题目给了选项:按客观题作答,不写小作文.""" + + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + return "A" + + def answer(self, *args, **kwargs): + raise AssertionError("带选项的题目不能走简答") + + tc = TaskCenter(object(), {}, writer=Writer()) + turn = { + "questionStem": "下列哪项正确?", + "questionType": "单选题", + "questionTypeInt": "2", + "options": [ + {"option": "A", "optionContent": "甲"}, + {"option": "B", "optionContent": "乙"}, + ], + } + self.assertEqual(tc._ai_answer(turn, {}), "A") + + def test_chinese_judgement_label_answers_with_dui_cuo(self): + class Writer: + """Provide a synthetic test dependency.""" + + def choose_judgement(self, question, context="", exclude=None): + return "错" + + tc = TaskCenter(object(), {}, writer=Writer()) + turn = { + "questionStem": "中层管理者只需要做执行,不需要战略分析。", + "questionType": "判断题", + "questionTypeInt": "", + "options": [ + {"option": "A", "optionContent": "正确"}, + {"option": "B", "optionContent": "错误"}, + ], + } + self.assertEqual(tc._ai_answer(turn, {}), "错") + + +class AIPracticeLoopGuardTestCase(unittest.TestCase): + """平台拿自己的大模型判分,会把标准答案判错并反复推回同一题.""" + + # + # 同一题重复出现时,知识点答完后应及时结束,避免无效循环。 + + PAGE_URL = AIPracticeTestCase.PAGE_URL + QUESTION = [ + b'data:' + json.dumps({"content": "单选题", "type": "questionType"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "0", "type": "questionTypeInt"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "公司层战略的核心特征是什么?", "type": "questionStem"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "单一业务板块运营优化", "type": "option-A"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "业务领域选择与组合管理", "type": "option-B"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "细分市场营销方案", "type": "option-C"}, + ensure_ascii=False).encode("utf-8"), + b'data:' + json.dumps({"content": "部门绩效考核", "type": "option-D"}, + ensure_ascii=False).encode("utf-8"), + ] + + def _run(self, state, load_data, talk, submit): + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + banned = {str(item).upper() for item in (exclude or [])} + for letter in "ABCD": + if letter not in banned: + return letter + raise AssertionError("同一道题不该有第五次作答") + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 1}, + writer=Writer(), + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL, text="")), + ("load-data", load_data), + ("main-talk", talk), + ("answer/submit", submit), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + ok = tc.study_ai_practice(self.PAGE_URL) + answers = [ + tc.session.kwargs_calls[index]["data"]["userMessage"] + for index, call in enumerate(tc.session.calls) + if "main-talk" in call[1] + ] + return tc, ok, answers + + def test_rejected_question_is_not_retried_forever(self): + """平台每答一次都记一条消息(messageList 变长)但继续推回同一题:按次数收手.""" + state = {"loads": 0, "msgs": 0, "submitted": False} + + def load_data(method, url, params): + state["loads"] += 1 + if state["submitted"]: + payload = { + "recordStatus": 2, + "recordUuid": "record-1", + "answerScore": 90, + "answerRecords": [ + {"recordUuid": "record-1", "score": 90, "statusMsg": "已评估"} + ], + "unCompleteTopic": [], + } + else: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + "messageList": [{"role": "1", "content": "{}"}] * state["msgs"], + "unCompleteTopic": ["topic-1"] if state["loads"] == 1 else [], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def talk(method, url, params): + state["msgs"] += 2 + return FakeResponse(lines=self.QUESTION) + + def submit(method, url, params): + state["submitted"] = True + return FakeResponse(payload={"status": True, "data": 1}) + + tc, ok, answers = self._run(state, load_data, talk, submit) + self.assertTrue(ok) + # 一次空消息开题 + 每题最多试满一轮选项(4 个),然后直接提交 + self.assertEqual(answers, ["", "A", "B", "C", "D"]) + submit_calls = [call for call in tc.session.calls if "answer/submit" in call[1]] + self.assertEqual(len(submit_calls), 1) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + + def test_stale_question_after_last_topic_is_not_answered_forever(self): + """知识点答完后平台把最后一道题推回来、又不收录作答:连续两次无新消息就收手.""" + # + # 真实踩坑:一整局 9 道题都答对了、unCompleteTopic 也空了,平台却继续把 + # 最后那道判断题推回来,本地"错/对"来回换了十几次,记录里一条都没多。 + SUMMARY = b'data:' + json.dumps( + {"content": "# 知识点解析\n\n## 一、战略管理"}, ensure_ascii=False + ).encode("utf-8") + state = {"loads": 0, "submitted": False} + + def load_data(method, url, params): + state["loads"] += 1 + if state["submitted"]: + payload = { + "recordStatus": 2, "recordUuid": "record-1", "answerScore": 88, + "answerRecords": [{"recordUuid": "record-1", "score": 88, + "statusMsg": "已评估"}], + "unCompleteTopic": [], + } + else: + payload = { + "recordStatus": 0, + "recordUuid": "record-1", + # 平台快照一直停在"9 题 + 总结",不再增长 + "messageList": [{"role": "2", "content": json.dumps( + {"content": "# 知识点解析\n"}, ensure_ascii=False)}] * 19, + "unCompleteTopic": ["topic-1"] if state["loads"] == 1 else [], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def talk(method, url, params): + return FakeResponse(lines=self.QUESTION + [SUMMARY]) + + def submit(method, url, params): + state["submitted"] = True + return FakeResponse(payload={"status": True, "data": 1}) + + tc, ok, answers = self._run(state, load_data, talk, submit) + self.assertTrue(ok) + self.assertEqual(answers[:2], ["", "A"]) + self.assertLessEqual(len(answers), 4) + submit_calls = [call for call in tc.session.calls if "answer/submit" in call[1]] + self.assertEqual(len(submit_calls), 1) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + + +class AIAverageScoreTestCase(unittest.TestCase): + """页面写的达标口径是"多次练习平均分":单次满分不够,历史低分要补回来.""" + + PAGE_URL = AIPracticeTestCase.PAGE_URL + + def test_reports_average_and_keeps_answering_for_low_history(self): + QUESTION = AIPracticeLoopGuardTestCase.QUESTION + state = { + "records": [ + {"recordUuid": "old-1", "score": 30}, + {"recordUuid": "old-2", "score": 60}, + ], + "submitted": False, + "round": 0, + "answered": 0, + "current": "record-1", + } + + def load_data(method, url, params): + ru = str(params.get("recordUuid") or state["current"]) + payload = { + "recordStatus": 2 if state["submitted"] else 0, + "recordUuid": ru, + "answerRecords": list(state["records"]), + "messageList": [], + "unCompleteTopic": [] if state["answered"] else ["topic-1"], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def talk(method, url, params): + if params and params.get("recordUuid") == state["current"] and state["answered"]: + return FakeResponse(lines=[b'data:{"content":"SummaryTopic"}']) + state["answered"] = 1 + return FakeResponse(lines=QUESTION) + + def init(method, url, params): + state["round"] += 1 + state["submitted"] = False + state["answered"] = 0 + state["current"] = f"record-{state['round'] + 1}" + return FakeResponse(payload={"status": True, "data": { + "recordUuid": state["current"], "answerUuid": "answer-1"}}) + + def submit(method, url, params): + state["submitted"] = True + state["records"] = state["records"] + [ + {"recordUuid": state["current"], "score": 95} + ] + return FakeResponse(payload={"status": True, "data": 1}) + + def report(method, url, params): + return FakeResponse(lines=['data:{"id":"score","content":"95"}', "data:[DONE]"]) + + class Writer: + """Provide a synthetic test dependency.""" + + def choose_options(self, question, options, multiple=False, context="", exclude=None): + return "A" + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 2}, + writer=Writer(), + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL, text="")), + ("answer/init", init), + ("load-data", load_data), + ("main-talk", talk), + ("answer/submit", submit), + ("end-report", report), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + self.assertTrue(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + # 第一轮 95 分但历史平均只有 61.7:补第二轮;第二轮后平均 70 仍未达标, + # 但本轮已达标且重答次数用尽,按"完成 + 如实告警"处理。 + self.assertEqual(len([c for c in tc.session.calls if "answer/submit" in c[1]]), 2) + self.assertEqual(len([c for c in tc.session.calls if "end-report" in c[1]]), 2) + + def test_already_submitted_record_is_never_submitted_twice(self): + """平台把同一条已提交记录再交回来时,绝不能对同一条记录二次 submit.""" + records = [ + {"recordUuid": "old-1", "score": 30}, + {"recordUuid": "old-2", "score": 60}, + {"recordUuid": "record-1", "score": 95}, + ] + + def load_data(method, url, params): + payload = { + "recordStatus": 2, + "recordUuid": "record-1", + "answerRecords": list(records), + "messageList": [], + "unCompleteTopic": [], + } + return FakeResponse(payload={"status": True, "data": payload}) + + def init(method, url, params): + # 平台拒绝开新记录,把已提交的那条交回来 + return FakeResponse(payload={"status": True, "data": { + "recordUuid": "record-1", "answerUuid": "answer-1"}}) + + tc = TaskCenter( + object(), + {"task_center_submit_mode": "auto", "ai_practice_min_score": 85, + "ai_practice_max_rounds": 2}, + ) + tc.session = FakeSession([ + ("pc-index", FakeResponse(url=self.PAGE_URL, text="")), + ("answer/init", init), + ("load-data", load_data), + ("main-talk", FakeResponse(lines=[b'data:{"content":"SummaryTopic"}'])), + ("answer/submit", FakeResponse(payload={"status": True, "data": 1})), + ("end-report", FakeResponse(lines=['data:{"id":"score","content":"95"}'])), + ]) + with mock.patch.object(tc_mod.interrupt, "should_stop", return_value=False), \ + mock.patch.object(tc_mod.time, "sleep", return_value=None): + self.assertTrue(tc.study_ai_practice(self.PAGE_URL)) + self.assertEqual(tc.last_outcome, tc_mod.TaskOutcome.COMPLETED) + self.assertEqual( + [c for c in tc.session.calls if "answer/submit" in c[1]], [] + ) + + def test_score_never_falls_back_to_another_record(self): + """问"这一条记录多少分"时,本条还没评估就必须返回 None,不能拿旧分顶替.""" + data = { + "answerScore": 90, + "answerRecords": [{"recordUuid": "old", "score": 90}], + } + self.assertIsNone(TaskCenter._ai_score(data, "record-1")) + self.assertEqual(TaskCenter._ai_score(data), 90.0) + self.assertEqual( + TaskCenter._ai_score( + {"answerRecords": [{"recordUuid": "record-1", "score": 77}]}, "record-1" + ), + 77.0, + ) + + def test_average_score_ignores_missing_values(self): + data = {"answerRecords": [ + {"recordUuid": "a", "score": 90}, + {"recordUuid": "b", "score": None}, + {"recordUuid": "c", "score": "70"}, + "junk", + ]} + self.assertEqual(TaskCenter._ai_record_scores(data), [90.0, 70.0]) + self.assertEqual(TaskCenter._ai_average_score(data), 80.0) + self.assertIsNone(TaskCenter._ai_average_score({})) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/audit/01_human_likeness_audit.py b/tools/audit/01_human_likeness_audit.py new file mode 100644 index 000000000..d0cdf8218 --- /dev/null +++ b/tools/audit/01_human_likeness_audit.py @@ -0,0 +1,342 @@ +# -*- coding: utf-8 -*- +"""真人化审计:检查"发给老师/同学看"的文本与作答行为是否像真人.""" +# +# 协议约束: +# 为了"提高判分通过率",AI实践的选择题被拼成了 +# "选 D。D:……。依据:回答正确!你的回答正确。本题考核知识点为业务层战略……" +# —— 选择题本该只回选项字母,而且把平台的反馈原文当"依据"回显, +# 既是自曝 AI,也确实不像人在答题。这个审计器就是防止同类问题再出现。 +# +# 用法: +# python tools/audit/01_human_likeness_audit.py # 审计内置样例文件 +# python tools/audit/01_human_likeness_audit.py --samples x.json # 审计指定样例 +# python tools/audit/01_human_likeness_audit.py --selftest # 只跑规则自检 +# +# 样例 JSON:[{"kind": "思考题|作业简答|主题讨论|AI实践开放题|AI实践客观题", "prompt": "...", "text": "..."}] +import argparse +import json +import os +import re +import statistics +import sys + +# ---------------------------------------------------------------- 规则 + +# 1) 模板腔 / AI 腔 +AI_PHRASES = [ + "首先", "其次", "再次", "最后", "总之", "总而言之", "综上所述", "总的来说", + "值得注意的是", "不难看出", "由此可见", "希望对你有所帮助", "作为一名学生", + "让我们一起来看看", "在当今社会", "随着社会的发展", "具有重要意义", +] +# 2) 把平台反馈/判分回显进作答(最严重:直接暴露在对话里) +LEAK_PHRASES = [ + "回答正确", "回答错误", "真遗憾", "本题考核知识点", "平台判据", "依据:", + "已评估", "答案解析", "参考答案", +] +# 3) markdown / 排版痕迹 +TEMPLATE_PATTERNS = [ + (r"^\s*[-*•]\s", "列表符号"), + (r"^\s*\d+[.、]\s", "编号列表"), + (r"\*\*", "markdown 加粗"), + (r"```", "代码块"), + (r"^\s*#+\s", "markdown 标题"), + (r"[\U0001F300-\U0001FAFF\u2600-\u27BF]", "emoji"), +] +# 4) 口语/个人痕迹(长文本至少要有几个,否则像说明文) +COLLOQUIAL = ["我觉得", "感觉", "其实", "反正", "可能", "大概", "挺", "有点", "吧", "呢", "哦"] +# 5) 具体性(要有例子,不能只讲概念) +SPECIFIC = ["比如", "例如", "像", "课", "身边", "上次", "之前", "小组", "案例", + "平台", "品牌", "公司", "门店", "客户", "宿舍", "同学", "老师", "群", "楼"] +# 6) 结尾金句收束:每篇都交一句"可被引用的结论"是最强的机器指纹(第二遍独立审计提出) +CLOSING_CLICHE = [ + (r"不是[^。!?]{0,24}而是", "「不是……而是……」式对照收尾"), + (r"并非[^。!?]{0,24}而是", "「并非……而是……」式收尾"), + (r"真正(难|重要|关键)的是", "「真正难的是……」式金句"), + (r"说到底", "「说到底」式总结"), + (r"这才是", "「这才是」式收尾"), + (r"归根到底", "「归根到底」式总结"), +] +# 7) 无来源的"假具体":既模糊又当事实用,老师一问就穿(第二遍独立审计提出) +UNSOURCED_SPECIFIC = [ + (r"某(个|家|一)?(公司|企业|品牌|区域|城市|行业|领域|产线)", "「某公司/某领域」式虚构"), + (r"多少(小时|天|单|人)", "「多少小时/多少单」式虚构"), + (r"几十(单|万|个)", "「几十单」式圆整数据"), + (r"近(三|两)年(的)?(数据|指标)", "「近三年数据」式无来源数字"), + (r"(一些|不少|部分)(做|的)?[^,。;]{0,10}(品牌|企业|公司|商家|机构)", "「一些/不少+主体」无来源断言"), + (r"之前(看过|了解过|刷到过)[^,。;]{0,12}(案例|例子|新闻)", "「之前看过一个案例」无出处"), + (r"(往往|通常|多半|一般都会)[^。!?]{0,24}(总部|客户|一线|市场|财务|生意|老板|公司)", + "「往往……」式无来源断言"), +] +# 7.5) 有标记的口癖("吧/呢/哦"这类语气词不算,它们本来就是口语) +MARKED_HABIT = ["我觉得", "其实", "反正", "可能", "感觉", "挺", "有点"] +# 7.6) 三层递进/对偶收尾:同一账号多篇用同一套结构,是最容易被看出的破绽 +STRUCTURE_CLICHE = [ + (r"从[^,。;]{0,14}到[^,。;]{0,14}再到", "「从……到……再到……」排比"), + (r"[^,。;]{0,12}管的是[^,。;]{0,14},[^,。;]{0,12}(管|是)的是", "「A 管……B 管……」三段式"), + (r"[^,。;]{0,10}管[^,。;]{0,8},[^,。;]{0,10}管[^,。;]{0,8},[^,。;]{0,10}管", "「A 管X,B 管Y,C 管Z」三段式"), + (r"先[^,。;]{0,10}再[^,。;]{0,10}(最后|才能|然后)", "「先……再……」递进"), + (r"不是[^,。;]{0,14},(而)?是[^,。;]{0,16}", "「不是……而是……」对偶(含段中)"), +] +# 7.7) 编造的第一人称琐事 +FAKE_PERSONAL = [ + (r"我(上个月|上上个月|前几天|上周|最近|上次|昨天)(注册|下载|买了|报名|参加|去|跟|面)", + "编造的个人琐事"), + (r"我(一个|有个)(朋友|同学|亲戚)(跟|在|做|说)", "编造的朋友/同学经历"), + # 编造履历:这份工具是替一个在校学生写作业,本人不会有"我实习/我上班"的真实素材 + (r"我(之前|以前|原来|上家|上一家|曾经)?[^,。;]{0,6}(实习|上班|就职|入职)", + "编造的个人履历(实习/工作)"), + # 兼职/打工同样是编的(实测模型会写"我在奶茶店做过兼职") + (r"我(在|曾经在)[^,。;]{0,8}(兼职|打工|上班|实习)", + "编造的个人履历(兼职/打工)"), + (r"我(做|干|打)过[^,。;]{0,4}(兼职|暑假工|临时工|小时工)", + "编造的个人履历(兼职/打工)"), + (r"我们(公司|单位|企业)(里|的|在|要求|规定|考核)", "认领在职经历(我们公司/单位)"), +] +# 7.8) 引用不存在的前文(讨论区里"楼上/那个例子"必须真的存在) +DANGLING_REFERENCE = r"(楼上|前面(的|那位|同学)|刚才那位|那个例子|有同学说|接上一个)" +# 7.9) 认领共同经历:没有素材就是编的 +CLAIMED_COMMUNITY = [ + (r"我们(小组|班|社团|团队)(上次|之前|课上|讨论|做|在)", "认领小组/社团经历"), + (r"课上(讲|说|提)(过|的)", "声称课上讲过(除非真有课程材料)"), +] +# 7.10) 示弱收尾口癖(防"金句收尾"引出的同构替换品) +WEAK_ENDING = [ + (r"(没太想明白|没完全(想|搞)明白|还在(琢磨|想)|也说不好|没搞懂|没想清楚)[。?!]*$", + "用\"我没想明白\"收尾"), +] +# 7.11) 普适经验断言 +UNIVERSAL_CLAIM = [ + (r"(往往|通常|多半|一般都会)[^。!?]{0,24}(总部|客户|一线|市场|财务|生意|老板|公司)", + "\"往往……\"式无来源断言"), +] +# 7.12) 课程锚点 +COURSE_ANCHOR = ["课上", "教材", "老师", "这门课", "本章", "课本"] +# 8) 真实犹豫:长文至少要有一处,否则过于顺滑 +HESITATION = ["说不好", "记不清", "没太想明白", "不太确定", "可能吧", "也说不准", + "没完全", "有点乱", "?", "?", "大概是", "好像", "应该", "印象里", + "之类", "吧", "呢", "估计"] + +OBJECTIVE_KINDS = {"AI实践客观题"} +CHOICE_RE = re.compile(r"^[A-E]{1,5}$") +JUDGE_RE = re.compile(r"^[对错]$") + + +def _first_pattern_issue(text, patterns, category): + """Return the first matching warning in a pattern category.""" + for pattern, name in patterns: + if re.search(pattern, text): + return [(category, name)] + return [] + + +def audit_sample(sample: dict) -> list: + kind = str(sample.get("kind") or "") + text = str(sample.get("text") or "") + issues = [] + + if kind in OBJECTIVE_KINDS: + # 选择题/判断题就该是"字母/对错",多余的解释性文字本身就是破绽 + if not (CHOICE_RE.match(text.strip()) or JUDGE_RE.match(text.strip())): + issues.append(("客观题格式", "客观题应只回选项字母或对错,实际: " + text[:40])) + return issues + + for phrase in AI_PHRASES: + if phrase in text: + issues.append(("AI 腔", f"出现模板词「{phrase}」")) + for phrase in LEAK_PHRASES: + if phrase in text: + issues.append(("回显平台判分", f"出现「{phrase}」")) + for pattern, name in TEMPLATE_PATTERNS: + if re.search(pattern, text, re.M): + issues.append(("排版痕迹", f"出现{name}")) + + 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: + issues.append(("句子过于整齐", "全是长度接近的长句,像模板生成")) + # 口癖分布:不是"用得太多"才算,均匀撒不同口癖同样是机器特征 + habit = {word: text.count(word) for word in MARKED_HABIT if text.count(word)} + habit_limit = max(2, len(text) // 120) + if len(habit) > habit_limit or any(count >= 3 for count in habit.values()): + issues.append(("口癖分布过密", f"不同口癖 {len(habit)} 种 > 上限 {habit_limit}: {habit}")) + # 金句:全篇扫描("说到底"在首句、比喻收尾都要算) + issues.extend(_first_pattern_issue(text, CLOSING_CLICHE, '金句')) + # 无来源的假具体 + issues.extend(_first_pattern_issue(text, UNSOURCED_SPECIFIC, '无来源的假具体')) + # 编造的第一人称琐事 + issues.extend(_first_pattern_issue(text, FAKE_PERSONAL, '编造的个人琐事')) + # 三层排比/对偶:全篇扫描(只看结尾会被"金句位移"绕过,第四、五轮审计都指出) + issues.extend(_first_pattern_issue(text, STRUCTURE_CLICHE, '三层排比/对偶')) + # 讨论里引用前文:必须真的带上了被引用的原文(context_refs 是列表), + # 之前用 has_context=True 就整条跳过是个后门——生成侧自己申报可不算数 + refs = sample.get("context_refs") + has_refs = isinstance(refs, list) and any(str(r).strip() for r in refs) + if kind == "主题讨论" and not has_refs and re.search(DANGLING_REFERENCE, text): + issues.append(("引用不存在的前文", "没有提供被引用的原文,孤立提交时会露馅")) + # 认领共同经历:context_refs 只能豁免"引用已有回复",豁免不了新的共同经历声明 + issues.extend(_first_pattern_issue(text, CLAIMED_COMMUNITY, '认领共同经历')) + # 示弱收尾口癖 + issues.extend(_first_pattern_issue(text.strip(), WEAK_ENDING, '示弱收尾口癖')) + # 普适经验断言 + issues.extend(_first_pattern_issue(text, UNIVERSAL_CLAIM, '普适经验断言')) + # 思考题/作业简答要有课程锚点(题目常写"结合课程内容") + if kind in {"思考题", "作业简答"} and len(text) >= 60 \ + and not any(word in text for word in COURSE_ANCHOR): + issues.append(("没有课程锚点", "题目要求结合课程内容,通篇没提课/教材/老师")) + return issues + + +def audit_warnings(sample: dict) -> list: + """软提醒:不构成"一眼假",但独立审计时值得看的信号.""" + kind = str(sample.get("kind") or "") + text = str(sample.get("text") or "") + warnings = [] + sentences = [s for s in re.split(r"[。!?!?\n]", text) if s.strip()] + # 犹豫词不再算"人味"证据:提示词里就要求过,审计再拿它当证据是自我验证 + human_marker = (any(word in text for word in COLLOQUIAL) + or any(len(s) <= 12 for s in sentences)) + if len(text) >= 200 and not human_marker: + warnings.append(("缺少人味", "200 字以上没有口语/犹豫/短句,像说明文")) + if len(text) >= 100 and not any(word in text for word in SPECIFIC): + warnings.append(("缺少具体例子", "通篇概念,没有具体的人/公司/场景")) + limit = 200 if kind == "主题讨论" else (560 if kind == "AI实践开放题" else 700) + if len(text) > limit: + warnings.append(("偏长", f"{len(text)} 字,{kind} 一般写得更短")) + return warnings + + +# 开头骨架:把"课上…讲过"这类归一化后再统计,避免换个知识点就绕过雷同检测 +OPENING_SKELETON = re.compile(r"^(课上|我们课上|这门课|课堂上)[^,。;]{0,20}(讲|说|提|把|拆)") + + +def _pattern_counts(samples, patterns, window): + """Count matching patterns in each sample's final characters.""" + counts = {} + for sample in samples: + tail = str(sample.get("text") or "").strip()[-window:] + for pattern, name in patterns: + if re.search(pattern, tail): + counts[name] = counts.get(name, 0) + 1 + return counts + + +def _batch_audit(report, samples, skeleton_hits): + """Add warnings for structures repeated across an entire batch.""" + # 跨样例指纹:同一批次里结尾都是同一种收束/同一个口癖,整批就很可疑 + ending_hits = _pattern_counts(samples, CLOSING_CLICHE, 30) + habit_hits = {word: sum(word in str(sample.get("text") or "") for sample in samples) + for word in MARKED_HABIT} + total = max(1, len(samples)) + for name, count in ending_hits.items(): + if count >= max(2, total // 2 + 1): + report["items"][0]["issues"].append( + ("整批收尾雷同", f"{count}/{total} 条都用「{name}」收尾")) + # 跨篇结构雷同:同一套排比/递进公式在多篇里复用 + structure_hits = _pattern_counts(samples, STRUCTURE_CLICHE, 80) + for name, count in structure_hits.items(): + if count >= 2: + report["items"][0]["issues"].append( + ("整批结构雷同", f"{count}/{total} 条共用「{name}」")) + if len(skeleton_hits) >= 2: + report["items"][0]["issues"].append( + ("整批开头骨架雷同", f"{len(skeleton_hits)}/{total} 条都用「课上+讲/把+知识点」开头")) + repeated = {word: count for word, count in habit_hits.items() if total >= 2 and count >= total} + if repeated: + report["items"][0]["issues"].append( + ("整批口癖雷同", f"每条都用了 {list(repeated.keys())}")) + + +def audit_all(samples: list) -> dict: + report = {"samples": len(samples), "items": []} + openings = {} + skeleton_hits = [] + texts = [] + for sample in samples: + issues = audit_sample(sample) + warnings = audit_warnings(sample) + text = str(sample.get("text") or "") + opening = text[:12] + if opening: + openings[opening] = openings.get(opening, 0) + 1 + if OPENING_SKELETON.match(text.strip()): + skeleton_hits.append(sample.get("kind")) + for other in texts: + if text and text == other: + issues.append(("重复内容", "与另一条样例完全相同")) + break + texts.append(text) + report["items"].append({ + "kind": sample.get("kind"), + "prompt": str(sample.get("prompt") or "")[:60], + "text": text[:120], + "issues": issues, + "warnings": warnings, + }) + for opening, count in openings.items(): + if count > 1: + for item in report["items"]: + if str(item.get("text") or "").startswith(opening): + item["issues"].append(("开头雷同", f"有 {count} 条样例用同样的开头")) + _batch_audit(report, samples, skeleton_hits) + report["problems"] = sum(len(item["issues"]) for item in report["items"]) + report["warnings_total"] = sum(len(item.get("warnings") or []) for item in report["items"]) + return report + + +def print_report(report: dict) -> None: + print(f"审计样例 {report['samples']} 条,硬伤 {report['problems']} 处," + f"软提醒 {report.get('warnings_total', 0)} 处") + print("(硬伤必须改;软提醒交给第二遍独立审计判断,不能只看这一份报告)") + for item in report["items"]: + flag = "✗" if item["issues"] else "✓" + print(f" {flag} [{item['kind']}] {item['text'][:60]}") + for rule, detail in item["issues"]: + print(f" - 硬伤/{rule}: {detail}") + for rule, detail in item.get("warnings") or []: + print(f" · 提醒/{rule}: {detail}") + + +def selftest() -> int: + bad = [ + {"kind": "AI实践客观题", "text": "选 D。D:职能层战略需要支撑企业总体战略。依据:回答正确!"}, + {"kind": "思考题", "text": "首先,使命很重要。其次,愿景很重要。最后,目标也很重要。"}, + {"kind": "主题讨论", "text": "**我觉得**这个问题的答案是" + "好的。" * 30}, + ] + good = [ + {"kind": "AI实践客观题", "text": "D"}, + {"kind": "主题讨论", "text": "使命和考核对不上,墙上那句话很快就没人提了,这个反差课下聊起来挺有意思。"}, + ] + bad_report = audit_all(bad) + good_report = audit_all(good) + ok = bad_report["problems"] >= 3 and good_report["problems"] == 0 + print("自检:", "通过" if ok else "失败", "| 反例问题数", bad_report["problems"], "| 正例问题数", good_report["problems"]) + return 0 if ok else 1 + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--samples", help="JSON samples to audit") + parser.add_argument("--report", help="Optional JSON report destination") + parser.add_argument("--selftest", action="store_true") + args = parser.parse_args() + if args.selftest: + return selftest() + if not args.samples: + parser.error("--samples is required unless --selftest is selected") + if not os.path.exists(args.samples): + print("找不到样例文件:", args.samples) + return 2 + with open(args.samples, encoding="utf-8") as source: + samples = json.load(source) + report = audit_all(samples) + print_report(report) + if args.report: + with open(args.report, "w", encoding="utf-8") as destination: + json.dump(report, destination, ensure_ascii=False, indent=1) + return 1 if report["problems"] else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/tools/audit/publication_guard.py b/tools/audit/publication_guard.py new file mode 100644 index 000000000..11fa85c2e --- /dev/null +++ b/tools/audit/publication_guard.py @@ -0,0 +1,59 @@ +"""Reject private development material from public Git contributions.""" + +import argparse +from pathlib import Path, PurePosixPath +import re +import shutil +import subprocess # nosec B404: invokes only Git with an argument list, never a shell +import sys + + +def audit_paths(root, paths): + problems = [] + for name in paths: + path = PurePosixPath(name) + lower = name.lower() + filename = path.name.lower() + if (lower.startswith(("docs/handoff/", "docs/artifacts/", "private/", "accounts/")) + or filename in {"agents.md", "claude.md", "tasks.yaml", "cookies.txt", "config.ini"} + or filename.startswith(("session-log", "handoff", "audit-report")) + or filename.endswith((".har", ".log")) + or ("capture" in filename and filename.endswith(".txt")) + or (filename.startswith(".env") and filename != ".env.example")): + problems.append(name + ": private file type") + continue + source = Path(root) / name + if not source.is_file() or source.is_symlink(): + continue + if source.suffix.lower() == ".md" and name not in {"CONTRIBUTING.md", "SECURITY.md"}: + text = source.read_text(encoding="utf-8") + for number, line in enumerate(text.splitlines(), 1): + if re.search(r"docs/(?:handoff|artifacts)/|SESSION-LOG|TASKS\.yaml|本轮新增|上一轮 Agent|开发进度|/Users/[^/]+/", line): + problems.append(f"{name}:{number}: private development record") + if source.suffix.lower() in {".py", ".ini", ".json", ".yaml", ".yml", ".md"}: + text = source.read_text(encoding="utf-8") + for number, line in enumerate(text.splitlines(), 1): + if re.search(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----|\bsk-[A-Za-z0-9]{20,}\b|\bgh[pousr]_[A-Za-z0-9]{30,}\b", line): + problems.append(f"{name}:{number}: credential-like value") + return problems + + +def main(argv=None): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", default=str(Path(__file__).resolve().parents[2])) + args = parser.parse_args(argv) + executable = shutil.which("git") + if executable is None: + parser.error("Git is required to audit tracked files") + root = str(Path(args.root).resolve()) + paths = subprocess.check_output([executable, "-C", root, "ls-files", "-z"]).decode().split("\0") # nosec B603: fixed Git subcommand; root is a separate argument + problems = audit_paths(args.root, [name for name in paths if name]) + for problem in problems: + print(problem) + if not problems: + print("Publication guard passed") + return int(bool(problems)) + + +if __name__ == "__main__": + sys.exit(main())