From ce4be9cc8fdd3c275e92a7a531d3fedc84f346a4 Mon Sep 17 00:00:00 2001 From: ThearchyHelios Date: Mon, 12 Oct 2026 10:48:19 +0800 Subject: [PATCH] =?UTF-8?q?M2=20=E5=A4=8D=E6=A0=B8=E7=AC=AC=202=20?= =?UTF-8?q?=E8=BD=AE=EF=BC=9A=E6=8A=A5=E5=91=8A=E8=87=AA=E6=9F=A5=E6=8C=89?= =?UTF-8?q?=E5=80=BC=E8=AE=A4=E5=87=BA=E6=AD=A3=E6=96=87=E9=87=8C=E5=86=99?= =?UTF-8?q?=E7=9D=80=E7=9A=84=E9=81=AE=E7=BD=A9=E5=80=BC=EF=BC=8C=E5=8F=AA?= =?UTF-8?q?=E6=95=B0=E4=B8=AA=E6=95=B0=E7=9A=84=E5=88=97=E4=B8=8D=E5=86=8D?= =?UTF-8?q?=E5=88=A4=E8=BF=9D=E8=A7=84=EF=BC=9B=E9=81=AE=E6=B2=A1=E9=81=AE?= =?UTF-8?q?=E6=A0=B8=E5=AF=B9=E4=B8=8D=E4=BA=86=E7=9A=84=E8=BE=93=E5=85=A5?= =?UTF-8?q?=E5=86=99=E3=80=8C=E6=97=A0=E6=B3=95=E6=A0=B8=E5=AF=B9=E3=80=8D?= =?UTF-8?q?=EF=BC=9B=E6=95=B4=E5=8F=A5=E9=9D=A2=E6=9D=BF=E6=8C=82=E7=9A=84?= =?UTF-8?q?=E4=BE=9D=E6=8D=AE=E6=8C=89=E8=AF=81=E6=8D=AE=E5=9B=BE=E7=9A=84?= =?UTF-8?q?=E6=A0=87=E7=AD=BE=E5=86=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 自查按值认(engine/evidence.py 的 masked_values,report.py 的 _MaskedCells):写作目录里确定取自遮罩列的值出现在正文里——照抄成文字(姓名这类文字列数字核对管不到)、写成数字(换了写法的长号码组装时被拆成几个数字片段,按整句认)、经指标带出来([[m:phone_raw]] 的值就是号码)——记一条 masked_cell(by_value),不带值,交回写作者时附上值换成「已遮罩」的那一句。只收确定取自遮罩列的列、不收分档标签;运行输入里写着的值是发起运行的人自己填的,不算。只读数据源现在设了遮罩的快照,认引用时读过的不再读,没设遮罩的运行一份都不读 - 时间线:日志 report_masked_cell 多带 written(其中按值认出的几处),标题分「引用了…格子」「写进了…值」「引用、写进了…」;缺口、日志按两种分别说;违规清单、CSV 的叫法改成「写进了遮罩列的值」 - 只数个数的列(COUNT(*) FILTER (WHERE phone IS NULL)、SUM(phone IS NULL)、AVG(phone IS NOT NULL)、SUM(amount) FILTER (WHERE phone IS NOT NULL)):认遮罩列的那一套把 FILTER 条件、汇总里的真假条件当成值的来历,数据质量报告引用「手机号缺失的人数」在正式运行里判失败。自查认之前先改写(_counted:FILTER 同 WHERE 去掉,汇总里的真假条件改成 CASE WHEN … THEN 1 ELSE 0 END),不判违规;证据面板、推演照可验证报告的认法多遮(只影响展示),根上的改法在 masking 里 - 证据面板:遮没遮核对不了的输入(快照、取值链上的产出读不出来),值和代入式里写「无法核对」,不写「已遮罩」,数据源可能根本没设遮罩 - 整句面板「挂的依据」不再直接读文档目录里的「名称 = 渲染值」:按证据图的标签写(服务端已把用到遮罩列的指标值换成「已遮罩」),证据图没回来时指标只写名字 - on_demand:当场裁判过、文档里却压根没有这句的判定时,不说「原因见判定」 - 测试:合并查询自查的用例补上拼接、upper、WITH;推演对整行、下标不是字面量的一格说「用到了遮罩列」(顺着取值链认出来的,不是按值猜的);计数指标 cnt 的原值照给;SQL 认不准、只数个数的反例 --- backend/app/api/evidence.py | 80 ++++- backend/app/engine/evidence.py | 62 ++++ backend/app/engine/nodes/report.py | 120 +++++-- backend/app/engine/recompute.py | 12 +- backend/tests/test_evidence_metric_masks.py | 9 +- .../tests/test_evidence_on_demand_formal.py | 8 +- backend/tests/test_masked_merge_queries.py | 2 +- backend/tests/test_masked_metric_values.py | 5 + backend/tests/test_report_masked_precision.py | 9 +- backend/tests/test_report_masked_values.py | 310 ++++++++++++++++++ backend/tests/test_whatif_api.py | 3 + frontend/src/lib/evidence.ts | 14 + frontend/src/lib/terms.ts | 15 +- frontend/src/run/EvidencePanel.tsx | 23 +- frontend/src/run/decode.ts | 7 +- scripts/check-decode.mjs | 40 ++- scripts/check-evidence.mjs | 16 +- 17 files changed, 657 insertions(+), 78 deletions(-) create mode 100644 backend/tests/test_report_masked_values.py diff --git a/backend/app/api/evidence.py b/backend/app/api/evidence.py index 5c498b1b..2bf99527 100644 --- a/backend/app/api/evidence.py +++ b/backend/app/api/evidence.py @@ -920,10 +920,10 @@ async def _metric_chain(seg: dict[str, Any], cite: dict[str, Any], entry: dict[s if (found := held.get(str(item.get("path")))) is not None: one = _withheld(one, found) inputs.append(one) - if withheld := {path for path, found in held.items() if found.kind != "table"}: - # 代入式里那几处同样写「已遮罩」:不然标签里遮着、代入式里亮着,同一个值换个地方照样看得到。整份结果当输入的 - # 不换:代入式里本来就只留着它的路径 - step["substituted"] = recompute.substituted_without(metric or {}, withheld, MASKED) + if withheld := {path: _held_word(found) for path, found in held.items() if found.kind != "table"}: + # 代入式里那几处同样写「已遮罩」(遮没遮核对不了的写「无法核对」):不然标签里遮着、代入式里亮着,同一个值换个 + # 地方照样看得到。整份结果当输入的不换:代入式里本来就只留着它的路径 + step["substituted"] = recompute.substituted_without(metric or {}, withheld) if step["value"] is not None and word is not None: # 指标的值本身也不给,和推演的原值同一个判断(_metric_masks):指标可能就是遮罩列的那一格(cell(nodes.q, 0, # 'phone')),输入里遮着、这里亮着等于没遮。报告上的字(rendered)是读者已经看到的,照旧 @@ -948,12 +948,12 @@ class _Held: def _withheld(step: dict[str, Any], held: _Held) -> dict[str, Any]: - """不给值的输入:值写「已遮罩」(本来就没有值的照旧是空的,缺输入还得看得出来),模型报的值、快照里的值一并拿掉。 - 取自遮罩列的,masked 写明是哪几列;遮没遮核对不了的、按值认出来的(_InputMasks),mask_unverified 写原因、不进 - masked——面板底下那句「这些列设置了遮罩」不能把它们也算进去。""" + """不给值的输入:值写「已遮罩」,遮没遮核对不了的写「无法核对」(_held_word;本来就没有值的照旧是空的,缺输入还得看得 + 出来),模型报的值、快照里的值一并拿掉。取自遮罩列的,masked 写明是哪几列;遮没遮核对不了的、按值认出来的 + (_InputMasks),mask_unverified 写原因、不进 masked——面板底下那句「这些列设置了遮罩」不能把它们也算进去。""" out = {k: v for k, v in step.items() if k not in ("model_value", "snapshot_value")} if out.get("value") is not None: - out["value"] = MASKED + out["value"] = _held_word(held) if held.reason is None: out["masked"] = held.columns else: @@ -961,6 +961,13 @@ def _withheld(step: dict[str, Any], held: _Held) -> dict[str, Any]: return out +def _held_word(held: _Held) -> str: + """不给值的输入写在值那里的字:遮没遮核对不了的(快照、取值链上的产出读不出来)写「无法核对」——数据源可能根本没设 + 遮罩,读的人不该以为这里遮着;别的(取自遮罩列的、按值认出来的)写「已遮罩」。代入式里那一处同一个字。""" + unverified = held.kind == "unverified" or (held.kind == "table" and held.reason is not None) + return UNVERIFIED_VALUE if unverified else MASKED + + async def _metric_masks(metric: dict[str, Any], card_node: str, artifact: str, sealed: _Sealed, masks: _Masks) -> tuple[dict[str, _Held], str | None]: """一个指标的输入里哪些不给值(路径 → _Held),指标本身的值给不给(None 照给,否则是写在值那里的字:「已遮罩」 @@ -1505,7 +1512,8 @@ def _sure(snap: dict[str, Any], base: set[str], kind: str | None, SQL 里指代遮罩列的名字(c.phone AS tel 的 tel、UPPER(phone) AS p 的 p)的算。认不准时那一套把整份的列都算上(派生 来源里没起别名的表达式、PIVOT、SQL 解析不了又写着遮罩列……):要遮的列盖住了全部结果列、名字却对不上这么多的,只认 名字对上的那几列——展示上多遮无妨,自查多算就是判失败,写作者也改不掉(最大的一笔订单金额被说成取自手机号)。 - 只装着分档标签的列(CASE WHEN phone IS NULL THEN '未留' ELSE '已留' END)格子里是 SQL 写死的字,不算。 + 只装着分档标签的列(CASE WHEN phone IS NULL THEN '未留' ELSE '已留' END)格子里是 SQL 写死的字,不算;只数个数的 + (COUNT(*) FILTER (WHERE phone IS NULL)、SUM(phone IS NULL))先改写成那一套认得出的样子再认(_counted)。 出了意外只认列名对上的。""" columns = {str(c).lower() for c in snap.get("columns") or []} direct = set(base) & columns @@ -1514,7 +1522,7 @@ def _sure(snap: dict[str, Any], base: set[str], kind: str | None, try: from app.engine.masking import _derived_hidden, _snapshot_labels - found, names = _derived_hidden(snap, set(base), kind, tables) + found, names = _derived_hidden(_counted(snap, kind), set(base), kind, tables) found &= columns named = (names & columns) | direct sure = named if columns <= found and not columns <= named else found | direct @@ -1525,6 +1533,45 @@ def _sure(snap: dict[str, Any], base: set[str], kind: str | None, return direct, {} +def _counted(snap: dict[str, Any], kind: str | None) -> dict[str, Any]: + """报告自查认确定取自遮罩列的列之前(_sure),把只决定算不算进来的写法改写成认遮罩列的那一套认得出的样子: + + - 汇总的 FILTER (WHERE …) 去掉:条件只决定这一行算不算进来,同写在 WHERE 里; + - 汇总里结果为真假的条件(SUM(phone IS NULL)、AVG(LENGTH(phone) = 11)、MAX(phone LIKE '199%'))改成 + CASE WHEN … THEN 1 ELSE 0 END:那一套认它只数个数(masking._band_only)。 + + COUNT(*) FILTER (WHERE phone IS NULL) 数的是没留号码的人数,值里没有号码;那一套把 FILTER 的条件、汇总里的条件当成 + 值的来历,自查跟着判违规,正式运行就因为一个人数判失败。只改自查用的这一份:证据面板、推演照可验证报告的认法多遮 + (展示上多遮无妨,可验证报告同样把它算作取自遮罩列),根上的改法在 masking 里。没有这些写法、改写不了的原样交回。""" + sql = snap.get("sql") + if not isinstance(sql, str) or not sql.strip(): + return snap + try: + from sqlglot import exp + + from app.data.sql_semantics import _parse, _read + + root, _ = _parse(sql, _read(kind)) + if root is None: + return snap + changed = False + for node in list(root.find_all(exp.Filter)): + node.replace(node.this) + changed = True + for agg in list(root.find_all(exp.AggFunc)): + arg = agg.this + while isinstance(arg, exp.Paren): + arg = arg.this + if not isinstance(agg, exp.Count) and isinstance(arg, (exp.Predicate, exp.Connector, exp.Not)): + agg.set("this", exp.Case(ifs=[exp.If(this=arg.copy(), true=exp.Literal.number(1))], + default=exp.Literal.number(0))) + changed = True + return {**snap, "sql": root.sql(dialect=_read(kind))} if changed else snap + except Exception: # noqa: BLE001 - 改写不了就照原样认(多算的那一边) + logger.warning("报告自查:改写只数个数的写法时出错,照原样认", exc_info=True) + return snap + + async def _mask_sets(snap: dict[str, Any] | None, source: Any, masks: _Masks, *, depth: int = 0) -> _MaskSets: """一份查询快照的遮罩(_MaskSets):证据面板的查询步骤、指标的输入、推演、报告自查(engine/nodes/report.py)都按这一个 函数认。 @@ -2649,6 +2696,8 @@ FORMAL_UNJUDGED = "这份报告开启了结论句裁判,但报告未通过核 FORMAL_ONLY = "正式运行的结论句只在报告撰写节点内裁判,不能按需裁判" #: 正式运行在节点里当场裁判过,可这句没判成(触顶、出错、格式不对、被截断,原因记在这句的判定里) FORMAL_INLINE_MISSED = "这份报告在报告撰写节点内裁判时,这句没有判成(原因见判定);正式运行的结论句不能按需裁判" +#: 同上,可文档里压根没有这句的判定(没有原因可看) +FORMAL_INLINE_NO_VERDICT = "这份报告在报告撰写节点内裁判过,但这句没有判定;正式运行的结论句不能按需裁判" #: 同上,按需裁判接口一次点了几句、其中有没判成的 FORMAL_INLINE_MISSED_SOME = ("这份报告在报告撰写节点内裁判时,所选的句子有的没有判成(原因见各句的判定);" "正式运行的结论句不能按需裁判") @@ -2789,7 +2838,10 @@ def _formal_message(doc: dict[str, Any] | None, claims: str | None, verdicts: li judge = doc.get("judge") if isinstance(judge, dict) and judge.get("mode") == "inline": if verdicts and any(not (isinstance(v, dict) and v.get("status") in SETTLED) for v in verdicts): - return FORMAL_INLINE_MISSED if len(verdicts) == 1 else FORMAL_INLINE_MISSED_SOME + if len(verdicts) > 1: + return FORMAL_INLINE_MISSED_SOME + # 文档里压根没记这句的判定:不说「原因见判定」,没有判定可看 + return FORMAL_INLINE_MISSED if isinstance(verdicts[0], dict) else FORMAL_INLINE_NO_VERDICT return FORMAL_JUDGED return FORMAL_UNJUDGED if claims == CLAIMS_JUDGE else FORMAL_NO_JUDGE @@ -3104,8 +3156,8 @@ GROUPS = (("cited", "有出处"), ("none", "无证据"), ("suspicious", "可疑 #: 文档本身对不上的违规:不管落在哪个片段上都单独列一行,不能被那个片段「有出处」的行盖住 _INTEGRITY = frozenset({"bad_schema", "segment_mismatch", "structural_text", "render_mismatch", "eid_mismatch", "state_mismatch"}) -#: 落在已经列出的片段上也单列一行的违规:文档对不上的,和引用了遮罩列的格子(masked_cell 落在的正是一个「有出处」的 -#: 单元格片段,不单列的话审计表、导出的 CSV 里只有一行普通的「有出处」) +#: 落在已经列出的片段上也单列一行的违规:文档对不上的,和写进了遮罩列的值的(masked_cell:引用的那一格落在的正是一个 +#: 「有出处」的单元格片段,经指标带出来的落在指标片段上,不单列的话审计表、导出的 CSV 里只有一行普通的「有出处」) _LISTED_ALWAYS = _INTEGRITY | {"masked_cell"} UNCITED_CLAIM = "这句结论没有附依据(既没有引用,也没有注明依据)" UNCITED_CLAIM_COUNTED = "这句结论没有附依据。本报告要求结论句附依据,出具时计入缺口" @@ -3145,7 +3197,7 @@ _CSV_LABELS: dict[str, dict[Any, str]] = { "issue": {"uncited_number": "没有出处的数字", "unresolved_ref": "引用无法解析", "unknown_entity": "疑似不存在的名称", "unverified_entity": "无法核实", "uncited_claim": "结论句未附依据", "no_candidate": "未找到候选", "contradicted_claim": "证据相矛盾", "insufficient_claim": "证据不足", "unsupported_claim": "证据不支持", - "masked_cell": "引用了遮罩列", + "masked_cell": "写进了遮罩列的值", **{code: "文档不一致" for code in _INTEGRITY}}, "evidence_kind": {"metric": "口径卡指标", "cell": "查询单元格", "input": "运行输入", "table": "表", "column": "字段", "quote": "知识库原话", "query": "查询结果"}, diff --git a/backend/app/engine/evidence.py b/backend/app/engine/evidence.py index 55f8c0d6..6193bbfb 100644 --- a/backend/app/engine/evidence.py +++ b/backend/app/engine/evidence.py @@ -3180,6 +3180,68 @@ def masked_cells(doc: dict[str, Any], catalog: dict[str, Any], masked: dict[str, return found +def _masked_value_message(ref: str | None) -> _Reason: + """违规 masked_cell(按值认出来的,by_value)的说法。不点名列:按值认只知道这个值在写作目录的遮罩列里出现过。经引用 + 带出来的(指标的值就是那一格)点名那处引用;写在正文里的,交回写作者时另附那一句(context,值换成「已遮罩」)。""" + if ref: + return _Reason( + f"引用 [[{ref}]] 的值与设置了遮罩的列中的值相同,值不应写进报告", + f"[[{ref}]] 的值就是证据目录里取自遮罩列的值(手机号、姓名这类),这个值不能以任何形式写进报告,引用、数字、" + "照抄的文字都不行:删掉这处引用和相应的内容", + ) + return _Reason( + "正文写着设置了遮罩的列中的值,值不应写进报告", + "正文里直接写着证据目录里取自遮罩列的值(手机号、姓名这类),这些值不能以任何形式写进报告,照抄的文字、数字都" + "不行:删掉这处文字,或者改成不含这个值的说法", + ) + + +def masked_values(doc: dict[str, Any], secrets: Any, + skip: set[str] | frozenset[str] = frozenset()) -> list[dict[str, Any]]: + """正文里直接写着的遮罩值,每处一条违规 masked_cell(带 by_value):写作者把号码、姓名照抄成文字、写成裸数字,或者 + 经指标、输入的引用带了出来([[m:phone_raw]] 的值就是号码)。masked_cells 只认 [[v:]] 引用的格子,这几种它认不出; + 数字核对管得到裸数字、管不到文字,「数字核对」关掉时数字也不管。 + + secrets 是写作目录里取自遮罩列的值(masking._Secrets),由报告节点按证据面板同一个函数算好交进来(report.py 的 + _MaskedCells:只收确定取自遮罩列的列,运行输入里写着的免);None 时一条都不记。skip 是已经按引用记过 masked_cell + 的片段:同一处不记两条。按整句认:换了写法的长号码(199-0000-0702)组装时被拆成好几个数字片段,一个片段里认不全, + 认出来的那一段落在哪几个片段上,就记在第一个上。 + + 违规不带值:context 是那一句,值换成「已遮罩」——交回写作者时据此找到那一处,进事件、日志也不再露一次。""" + if secrets is None: + return [] + skipped = {str(s) for s in skip} + found: list[dict[str, Any]] = [] + for _, unit in iter_units(doc): + placed: list[tuple[int, int, dict[str, Any]]] = [] + sentence = "" + for seg in unit.get("segments") or []: + text = seg.get("text") if isinstance(seg.get("text"), str) else "" + placed.append((len(sentence), len(sentence) + len(text), seg)) + sentence += text + hits = secrets.spans(sentence, loose=True) if sentence else [] + named: set[str] = set() + context: str | None = None + for start, end in hits: + owners = [(a, seg) for a, b, seg in placed if a < end and start < b] + if not owners or any(str(seg.get("id")) in skipped for _, seg in owners): + continue + first_at, first = owners[0] + if str(first.get("id")) in named: + continue + named.add(str(first.get("id"))) + context = context or secrets.scrub(sentence, loose=True).strip()[:120] + ref = next((str(seg["ref"]) for _, seg in owners if seg.get("ref")), None) + last_at, last = owners[-1] + head, tail = first.get("span"), last.get("span") + where = None + if all(isinstance(s, list) and len(s) == 2 for s in (head, tail)): + where = [head[0] + max(start - first_at, 0), tail[0] + min(end - last_at, len(last.get("text") or ""))] + found.append(_violation("masked_cell", _masked_value_message(ref), ref=ref, by_value=True, context=context, + span=where, segment=first.get("id"), unit=unit.get("id"))) + return found + + #: 引用查询结果的写法。只跟着目录里的查询出现(catalog_prompt):写作规则本身保持一期那份,升级前 #: 发起的运行跑到报告节点时提示一字不差;只有口径卡的目录也不该教写作者去引用不存在的 Q1 CELL_RULES = ( diff --git a/backend/app/engine/nodes/report.py b/backend/app/engine/nodes/report.py index 43f46fce..1cdd30e4 100644 --- a/backend/app/engine/nodes/report.py +++ b/backend/app/engine/nodes/report.py @@ -32,6 +32,7 @@ from __future__ import annotations import asyncio +import json import re import time from collections import Counter @@ -320,28 +321,36 @@ class _RenderedStream: class _MaskedCells: - """报告自查:正文引用了取自遮罩列的格子(evidence.masked_cells),记一条违规,和没有出处的数字一样交回写作者重写。 - 写作目录本身不遮(写作者要看得到数据),只拦写进报告的那几格。 + """报告自查:报告里写进了取自遮罩列的值,记一条违规 masked_cell,和没有出处的数字一样交回写作者重写。写作目录本身 + 不遮(写作者要看得到数据),只拦写进报告的。两种认法: - 哪几列算:和证据面板同一个函数(api/evidence.py 的 _mask_sets)认出来的「确定取自遮罩列」的那几列(sure)——列名 - 就是遮罩列的,SQL 里给遮罩列起了别名、套了函数、经子查询或 WITH 转一道的,合并查询按逐格来历和合并 SQL 认。证据 - 面板为了展示宁可多遮(SQL 认不准时整份的列都遮),自查不跟着多算:多算一列就是一次判失败,写作者也改不掉。 + - 引用(evidence.masked_cells):[[v:Q2.r0.tel]] 引用的那一列取自遮罩列。哪几列算:和证据面板同一个函数(api/evidence.py + 的 _mask_sets)认出来的「确定取自遮罩列」的那几列(sure)——列名就是遮罩列的,SQL 里给遮罩列起了别名、套了函数、经 + 子查询或 WITH 转一道的,合并查询按逐格来历和合并 SQL 认。证据面板为了展示宁可多遮(SQL 认不准时整份的列都遮),自查 + 不跟着多算:多算一列就是一次判失败,写作者也改不掉 + - 按值(evidence.masked_values):正文里直接写着这些列里的值——照抄成文字、写成数字,或者经指标带了出来([[m:phone_raw]] + 的值就是号码)。值从数据源现在设了遮罩的那几份查询快照里收,同样只收 sure 的列、不收只装着分档标签的格子;合并查询 + 的不收(它的值来自它的输入,输入是目录里另外几份快照)。protected 是运行输入(发起运行的人自己填的),里面写着的值 + 不算,和推演、证据面板一样 - 组装好一稿之后只给正文里引用到的那几份查询快照认(读盘复验哈希放进线程),认过的记下来,重写的稿子不再认。以前写作 - 之前就把目录里每份查询快照都读一遍,没设遮罩、没引用到的也一样。""" + 组装好一稿之后才认:引用只读正文引用到的那几份快照,按值只读数据源现在设了遮罩的那几份(读盘复验哈希放进线程),都只读 + 一次,重写的稿子不再读。没设遮罩的运行一份都不读。以前写作之前就把目录里每份查询快照都读一遍。""" - def __init__(self, catalog: dict[str, Any]) -> None: + def __init__(self, catalog: dict[str, Any], protected: list[str] | tuple[str, ...] = ()) -> None: from app.api.evidence import _Masks self._catalog = catalog self._masks = _Masks() + self._protected = [str(t) for t in protected if t] self._memo: dict[str, dict[str, list[str]]] = {} + #: 按值认之前已经读过的快照(为了认引用):收值时不再读第二遍,收完就放掉 + self._loaded: dict[str, tuple[dict[str, Any], Any]] = {} + self._secrets: Any = None + self._collected = False async def __call__(self, doc: dict[str, Any]) -> dict[str, Any]: - """把这一稿引用了遮罩列的格子记进 doc 的违规(接在最后,和 compose_doc 给了 masked 时一样),交回同一份文档。""" - from app.api.evidence import _mask_sets - from app.core.artifact_store import load - from app.engine.evidence import iter_segments, masked_cells + """把这一稿写进了遮罩列的值的地方记进 doc 的违规(接在最后,和 compose_doc 给了 masked 时一样),交回同一份文档。""" + from app.engine.evidence import iter_segments, masked_cells, masked_values wanted: dict[str, Any] = {} for seg in iter_segments(doc): @@ -352,16 +361,74 @@ class _MaskedCells: and artifact and artifact not in self._memo: wanted.setdefault(artifact, entry.get("source")) for artifact, source in wanted.items(): - try: - snap = await asyncio.to_thread(load, artifact) - except ValueError: - snap = None - sets = await _mask_sets(snap, source, self._masks) if isinstance(snap, dict) else None - self._memo[artifact] = {c: sorted(sets.base) for c in sets.sure} if sets is not None else {} - doc["violations"] = [*doc["violations"], - *masked_cells(doc, self._catalog, {a: m for a, m in self._memo.items() if m})] + await self._read(artifact, source) + cited = masked_cells(doc, self._catalog, {a: m for a, m in self._memo.items() if m}) + written = masked_values(doc, await self._values(), {str(v.get("segment")) for v in cited}) + doc["violations"] = [*doc["violations"], *cited, *written] return doc + async def _read(self, artifact: str, source: Any) -> tuple[dict[str, Any], Any] | None: + """读一份查询快照、认它的遮罩(_mask_sets),确定取自遮罩列的列记进 _memo。读不出来的为 None(引用它的格子本来就 + 解析不了)。""" + from app.api.evidence import _mask_sets + from app.core.artifact_store import load + + try: + snap = await asyncio.to_thread(load, artifact) + except ValueError: + snap = None + if not isinstance(snap, dict): + self._memo[artifact] = {} + return None + sets = await _mask_sets(snap, source, self._masks) + self._memo[artifact] = {c: sorted(sets.base) for c in sets.sure} + if not self._collected: + self._loaded[artifact] = (snap, sets) + return snap, sets + + async def _values(self) -> Any: + """写作目录里取自遮罩列的值(masking._Secrets),一个都没有为 None。只收一次。""" + if self._collected: + return self._secrets + self._collected = True + from app.engine.masking import _Secrets + from app.engine.merge_query import MERGE_SOURCE + + secrets = _Secrets() + seen: set[str] = set() + for entry in self._catalog.values(): + artifact = entry.get("artifact") if isinstance(entry, dict) and entry.get("kind") == "query" else None + source = entry.get("source") if isinstance(entry, dict) else None + if not isinstance(artifact, str) or not artifact or artifact in seen or not source \ + or source == MERGE_SOURCE or not (await self._masks.of(source))[0]: + continue + seen.add(artifact) + # 认引用时读过的不再读;读过、读不出来的(_memo 里有、_loaded 里没有)不再试 + found = self._loaded.get(artifact) + if found is None and artifact not in self._memo: + found = await self._read(artifact, source) + if found is not None: + snap, sets = found + secrets.add(snap, sets.sure, labels=sets.labels, base=sets.base) + self._loaded.clear() + secrets.protect(self._protected) + if secrets.strong: + secrets.prepare() + self._secrets = secrets + return self._secrets + + +def _masked_said(hits: list[dict[str, Any]]) -> str: + """报告写进了遮罩列的值的那几处在缺口、日志里怎么说:「引用了 2 处取自遮罩列的格子(「v:Q2.r0.tel」、…)」「写进了 1 处 + 设置了遮罩的列中的值」,两样都有时连起来。只点名引用,不写值。""" + cited = [v for v in hits if not v.get("by_value")] + written = [v for v in hits if v.get("by_value")] + parts = [f"引用了 {len(cited)} 处取自遮罩列的格子({_named(cited)})"] if cited else [] + if written: + named = _named(written) + parts.append(f"写进了 {len(written)} 处设置了遮罩的列中的值" + (f"({named})" if named else "")) + return ",".join(parts) + async def _run_class(run_id: str) -> str | None: """按运行记录上的 run_class 取:子图、审批之后续跑都是另起的执行上下文,只有运行记录靠得住。""" @@ -580,8 +647,9 @@ async def run_report(state: GraphState, ctx: NodeContext) -> dict[str, Any]: spec = ctx.run.spec catalog = report_catalog(state, spec, ctx.node) - # 正文引用了取自遮罩列的格子:自查记一条违规,和没有出处的数字一样交回写作者重写(_MaskedCells) - masked = _MaskedCells(catalog) + # 报告写进了取自遮罩列的值(引用了那一格、照抄成正文):自查记一条违规,和没有出处的数字一样交回写作者重写 + # (_MaskedCells)。运行输入里写着的值是发起运行的人自己填的,不算 + masked = _MaskedCells(catalog, protected=[json.dumps(state.get("input") or {}, ensure_ascii=False, default=str)]) allow = report_allowance(spec, ctx.node) cells = True # 结论句策略只对升级后发起的运行生效:升级前的运行(图里也不会有 claims)事件、产出一个字不加 @@ -684,10 +752,12 @@ async def run_report(state: GraphState, ctx: NodeContext) -> dict[str, Any]: # 设了出具契约、报告在它上游时照单收下、降档(io._upstream_issuance_gaps)。降不降档由出具那一行说:探索运行、 # 没有契约的成果不出具,这里不预告。只点名引用,不写那几格的值 tried = f"已要求模型重写 {repairs} 次仍未改掉" if repairs else "未要求重写" - refs = list(dict.fromkeys(str(v.get("ref") or "") for v in hits)) - gaps.append(f"报告引用了 {len(hits)} 处取自遮罩列的格子({_named(hits)}),{tried}:数据源设置了遮罩的列不应写进报告") + refs = list(dict.fromkeys(str(v["ref"]) for v in hits if v.get("ref"))) + gaps.append(f"报告{_masked_said(hits)},{tried}:数据源设置了遮罩的列不应写进报告") + # written:其中按值认出来的几处(正文里直接写着、经指标带出来的),时间线据此换说法 ctx.emit(EventType.LOG, level="warn", code="report_masked_cell", count=len(hits), refs=refs, - columns=list(dict.fromkeys(str(v.get("column") or "") for v in hits)), + written=sum(1 for v in hits if v.get("by_value")), + columns=list(dict.fromkeys(str(v["column"]) for v in hits if v.get("column"))), message=f"{gaps[0]}。报告照常产出,这几处已标注,已记为缺口。请在报告撰写节点的指令中去掉对这些列的引用") doc_artifact = await _store(doc, ctx) ctx.emit(EventType.REPORT_CHECKED, doc_artifact=doc_artifact, ok=not doc["violations"], diff --git a/backend/app/engine/recompute.py b/backend/app/engine/recompute.py index 66452218..f28ce514 100644 --- a/backend/app/engine/recompute.py +++ b/backend/app/engine/recompute.py @@ -1230,8 +1230,10 @@ def _unverified_word() -> str: return UNVERIFIED_VALUE -def substituted_without(metric: dict[str, Any], paths: Iterable[str], token: str) -> str | None: - """卡上的代入式,只把 paths 这几个输入代成 token(证据面板给取自遮罩列的输入写「已遮罩」),别的照卡上代。 +def substituted_without(metric: dict[str, Any], paths: Iterable[str] | Mapping[str, str], + token: str = "") -> str | None: + """卡上的代入式,只把 paths 这几个输入代成 token(证据面板给取自遮罩列的输入写「已遮罩」),别的照卡上代。paths 也可以 + 是 {路径: 代成的字},各写各的(遮没遮核对不了的那一处写「无法核对」)。 按卡上记的输入值重新代一遍:先核对一个都不换时代出来的和卡上记的一字不差,对不上(卡上记的不是原值、老卡的写法) 就整条不给,交回 None——宁可不显示代入式,也不能让遮着的值从对不上的那一处漏出来。卡上没代成字面量的(容器、太长的 @@ -1249,9 +1251,9 @@ def substituted_without(metric: dict[str, Any], paths: Iterable[str], token: str if isinstance(i, dict) and isinstance(i.get("path"), str) and i["path"] not in kept} if substitute(tree, values) != recorded: return None - hidden = set(paths) - swapped = ast.fix_missing_locations(_Bind({p: token for p in hidden}).visit(copy.deepcopy(tree))) - return substitute(swapped, {p: v for p, v in values.items() if p not in hidden}) + tokens = dict(paths) if isinstance(paths, Mapping) else {p: token for p in paths} + swapped = ast.fix_missing_locations(_Bind(tokens).visit(copy.deepcopy(tree))) + return substitute(swapped, {p: v for p, v in values.items() if p not in tokens}) # -------------------------------------------------------------------------- diff --git a/backend/tests/test_evidence_metric_masks.py b/backend/tests/test_evidence_metric_masks.py index f3e72094..ce01d00d 100644 --- a/backend/tests/test_evidence_metric_masks.py +++ b/backend/tests/test_evidence_metric_masks.py @@ -330,9 +330,10 @@ async def test_a_cell_on_a_snapshot_that_cannot_be_read_is_withheld(): "locator": {"row": 0, "column": "phone"}, "status": "verified"}]) chain = await hand_chain([metric], queries=[gone]) [step] = [s for s in chain if s["step"] == "input"] - assert step["value"] == "已遮罩" and "masked" not in step + # 遮没遮核对不了:值写「无法核对」,不写「已遮罩」(数据源可能根本没设遮罩),代入式里那一处同样 + assert step["value"] == "无法核对" and "masked" not in step assert step["mask_unverified"] == "查询快照无法读取,核对不了这一格是否取自设置了遮罩的列" - assert chain[0]["substituted"] == "len(已遮罩)" and said(chain) == [] + assert chain[0]["substituted"] == "len(无法核对)" and said(chain) == [] PARSED = {"columns": ["id", "phone"], "rows": [[1, "139-0000-0004"]]} @@ -354,8 +355,8 @@ async def test_a_positional_cell_that_cannot_be_traced_is_withheld(parsed, why): "status": "ok"}], value=26) chain = await hand_chain([metric], outputs={"parse": out}) [step] = [s for s in chain if s["step"] == "input"] - assert step["value"] == "已遮罩" and step["mask_unverified"] == why and "masked" not in step - assert chain[0]["substituted"] == "len(已遮罩) * 2" and said(chain) == [] + assert step["value"] == "无法核对" and step["mask_unverified"] == why and "masked" not in step + assert chain[0]["substituted"] == "len(无法核对) * 2" and said(chain) == [] async def test_a_reshaped_result_without_a_snapshot_or_a_source_is_shown_as_is(): diff --git a/backend/tests/test_evidence_on_demand_formal.py b/backend/tests/test_evidence_on_demand_formal.py index 528cff8f..c38cdd56 100644 --- a/backend/tests/test_evidence_on_demand_formal.py +++ b/backend/tests/test_evidence_on_demand_formal.py @@ -209,8 +209,12 @@ def test_an_inline_judged_report_that_did_not_judge_this_sentence_says_so(verdic seal={"sealed": True, "ok": True, "manifest_seq": 3, "legacy": False}) got = _on_demand(sealed, doc, first, verdict, claims="judge") assert got["available"] is False and got["reason"] == "formal", got - assert JUDGED_WORDS not in got["message"] and "这句没有判成" in got["message"], got["message"] - assert "原因见判定" in got["message"] and "不能按需裁判" in got["message"], got["message"] + assert JUDGED_WORDS not in got["message"] and "不能按需裁判" in got["message"], got["message"] + if verdict is None: + # 没有判定可看:不说「原因见判定」 + assert "这句没有判定" in got["message"] and "原因见判定" not in got["message"], got["message"] + else: + assert "这句没有判成" in got["message"] and "原因见判定" in got["message"], got["message"] # 判过的那一句照旧说已完成裁判 assert JUDGED_WORDS in _on_demand(sealed, doc, second, {"status": "supported"}, claims="judge")["message"] # 一次问几句(按需裁判接口):有一句没判成就照实说 diff --git a/backend/tests/test_masked_merge_queries.py b/backend/tests/test_masked_merge_queries.py index 6a7d86f9..1b004b85 100644 --- a/backend/tests/test_masked_merge_queries.py +++ b/backend/tests/test_masked_merge_queries.py @@ -181,7 +181,7 @@ async def test_the_query_step_and_the_rows_page_mask_a_column_derived_in_the_mer assert column in page["masked"] and leaks(page) == [], page["masked"] -@pytest.mark.parametrize("cust_sql, merge_sql, column", CASES[:3]) +@pytest.mark.parametrize("cust_sql, merge_sql, column", CASES) async def test_the_self_check_flags_a_cell_derived_in_the_merge_sql(monkeypatch, mall, cust_sql, merge_sql, column): """写作者直接引用合并结果里取自遮罩列的那一格:自查记 masked_cell,别的格照常。""" row = await finish(monkeypatch, merge_graph(cust_sql, merge_sql), diff --git a/backend/tests/test_masked_metric_values.py b/backend/tests/test_masked_metric_values.py index 724f407f..913ac37e 100644 --- a/backend/tests/test_masked_metric_values.py +++ b/backend/tests/test_masked_metric_values.py @@ -169,6 +169,11 @@ async def test_a_value_carrying_a_masked_value_is_withheld_in_both_places(client m = (await whatif(client, run.id))[metric] assert m["status"] == "masked" and m["old"] == m["rendered_old"] == "已遮罩" and m["withheld"] is True, m assert all(i["old"] is None for i in m["inputs"]), m["inputs"] + if metric in ("row0", "last"): + # 整行、下标不是字面量的一格顺着取值链认得出取自遮罩列(不是按值猜的):说用到了遮罩列 + from app.engine.recompute import MASKED_METRIC + + assert m["reason"] == MASKED_METRIC, m["reason"] step = await metric_step(client, run.id, metric) assert step["metric"]["value"] == "已遮罩", step["metric"] assert all(i["value"] == "已遮罩" for i in step["inputs"]), step["inputs"] diff --git a/backend/tests/test_report_masked_precision.py b/backend/tests/test_report_masked_precision.py index 9f011dfb..9dd426e0 100644 --- a/backend/tests/test_report_masked_precision.py +++ b/backend/tests/test_report_masked_precision.py @@ -236,7 +236,8 @@ async def test_the_rewrite_request_says_the_value_must_not_be_written_in_any_for async def test_only_the_cited_snapshots_are_read_and_each_only_once(engine_up, mall, monkeypatch): - """组装好一稿之后只读正文引用到的那几份快照,重写的稿子不再读同一份;没引用到的、没设遮罩的一份都不读。""" + """组装好一稿之后才读:引用到的那几份、数据源现在设了遮罩的那几份(按值认要收里面的值),每份只读一次,重写的稿子 + 不再读;没设遮罩的数据源上的一份都不读(test_report_masked_values)。""" from app.core import artifact_store as store from app.engine.nodes.report import _MaskedCells @@ -258,10 +259,10 @@ async def test_only_the_cited_snapshots_are_read_and_each_only_once(engine_up, m monkeypatch.setattr(store, "load", counting) check = _MaskedCells(catalog) first = await check(compose_doc("电话 [[v:Q1.r0.tel]]。", catalog, node_id="write", run_id="r1")) - assert masked_of(first["violations"]) == ["v:Q1.r0.tel"] and read == [cited], read + assert masked_of(first["violations"]) == ["v:Q1.r0.tel"] and sorted(read) == sorted([cited, other]), read second = await check(compose_doc("客户 [[v:Q1.r0.customer]],电话 [[v:Q1.r0.tel]]。", catalog, node_id="write", run_id="r1")) - assert masked_of(second["violations"]) == ["v:Q1.r0.tel"] and read == [cited], "同一份快照不再读第二遍" + assert masked_of(second["violations"]) == ["v:Q1.r0.tel"] and len(read) == 2, "同一份快照不再读第二遍" # -------------------------------------------------------------------------- @@ -279,4 +280,4 @@ async def test_the_audit_lists_a_masked_cell_on_its_own_row(client, monkeypatch, # 这一行自己不写值(所在的句子是报告原文,标注之后照常产出,读者本来就看得到) assert leaks([flagged[0][k] for k in ("text", "ref", "note")]) == [] csv = (await client.get(f"/api/runs/{row.id}/evidence/audit", params={"format": "csv"})).text - assert "引用了遮罩列" in csv + assert "写进了遮罩列的值" in csv diff --git a/backend/tests/test_report_masked_values.py b/backend/tests/test_report_masked_values.py new file mode 100644 index 00000000..507e022e --- /dev/null +++ b/backend/tests/test_report_masked_values.py @@ -0,0 +1,310 @@ +"""报告自查(第 2 轮):只数个数的列不算取自遮罩列;正文里直接写着的遮罩值按值认出来。 + +复核发现: +- 只数个数、只决定算不算进来的写法——COUNT(*) FILTER (WHERE phone IS NULL)、SUM(phone IS NULL)、AVG(phone IS NOT NULL)、 + SUM(amount) FILTER (WHERE phone IS NOT NULL)——值里没有号码,可认遮罩列的那一套(masking._value_columns)把 FILTER 的 + 条件、汇总里的真假条件当成值的来历,自查跟着判 masked_cell,正式运行(默认违规即失败)因此判失败。等价的 + SUM(CASE WHEN phone IS NULL THEN 1 ELSE 0 END) 本来就不算。现在自查认之前先把这几种写法改写成认得出的样子 + (api/evidence.py 的 _counted),证据面板、推演照可验证报告的认法多遮(展示上多遮无妨) +- 自查只认 [[v:]] 引用:写作者照着「删掉引用」把号码、姓名照抄成正文,或者经指标带出来([[m:phone_raw]] 的值就是号码), + 一条违规都没有。现在按值认一遍(engine/evidence.py 的 masked_values):写作目录里取自遮罩列的值(只认确定取自遮罩列的 + 列,整份算进来的不算)出现在正文里,记一条 masked_cell,不带值;运行输入里写着的值是发起运行的人自己填的,不算 + +真跑的部分用虚构的 SQLite 商城库(号码、姓名是编的),写作者是 MockChatModel 照剧本写。 +""" +from __future__ import annotations + +import asyncio +import json +import sqlite3 + +import pytest +from langchain_core.messages import AIMessage +from sqlalchemy import select + +from app.core import artifact_store +from app.data.engine import engines +from app.db.base import SessionLocal +from app.db.models import DataSource, Run, RunEvent +from app.engine.evidence import compose_doc, describe_violations +from app.engine.runner import run_manager + +CUSTOMERS = [(1, "陈思远", "19900000701"), (2, "林若溪", "19900000702"), (3, "周以宁", "19900000703")] +ORDERS = [(1, 1, 120.5), (2, 2, 300.0), (3, 2, 80.0), (4, 3, 210.25), (5, 1, 99.5)] +PHONES = [c[2] for c in CUSTOMERS] +NAMES = [c[1] for c in CUSTOMERS] + + +@pytest.fixture +async def engine_up(): + await run_manager.setup() + yield + await run_manager.shutdown() + + +async def set_source(path, options=None) -> str: + async with SessionLocal() as session: + row = (await session.execute(select(DataSource).where(DataSource.name == "mall"))).scalar_one_or_none() + if row is None: + row = DataSource(name="mall", kind="sqlite", database=str(path), readonly=True, enabled=True) + session.add(row) + row.database, row.kind, row.enabled, row.readonly = str(path), "sqlite", True, True + row.options = dict(options or {}) + await session.commit() + return row.id + + +@pytest.fixture +async def mall(tmp_path, engine_up): + path = tmp_path / "mall.db" + db = sqlite3.connect(path) + db.executescript("CREATE TABLE customers (id INTEGER PRIMARY KEY, name TEXT, phone TEXT);" + "CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER, amount REAL);") + db.executemany("INSERT INTO customers VALUES (?, ?, ?)", CUSTOMERS) + db.executemany("INSERT INTO orders VALUES (?, ?, ?)", ORDERS) + db.commit() + db.close() + source_id = await set_source(path, {"mask_columns": ["phone"]}) + await engines.invalidate(source_id) + yield path + await engines.invalidate(source_id) + + +def leaks(value) -> list[str]: + """写着的号码、姓名,按千分位写的(19,900,000,701)也算。""" + raw = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str) + return [p for p in [*PHONES, *NAMES] if p in raw or p in raw.replace(",", "")] + + +def masked_of(violations: list[dict]) -> list[dict]: + return [v for v in violations if v["code"] == "masked_cell"] + + +# -------------------------------------------------------------------------- +# 只数个数的列 +# -------------------------------------------------------------------------- + +#: 值里没有号码的写法:条件只决定这一行算不算进来,汇总里的真假条件只数个数 +COUNTING = [ + "SELECT COUNT(*) FILTER (WHERE phone IS NULL) AS missing FROM customers", + "SELECT SUM(phone IS NULL) AS missing FROM customers", + "SELECT AVG(phone IS NOT NULL) AS missing FROM customers", + "SELECT SUM(LENGTH(phone) = 11) AS missing FROM customers", + "SELECT MAX((phone LIKE '199%')) AS missing FROM customers", + "SELECT SUM(o.amount) FILTER (WHERE c.phone IS NOT NULL) AS missing FROM orders o " + "JOIN customers c ON c.id = o.customer_id", + "SELECT COUNT(*) FILTER (WHERE phone IS NULL) OVER () AS missing FROM customers", +] + + +@pytest.mark.parametrize("sql", COUNTING) +async def test_counting_columns_are_not_surely_masked(engine_up, mall, sql): + """自查不为它们判违规(sure 里没有);证据面板照可验证报告的认法多遮(hidden 里有,只影响展示)。""" + from app.api.evidence import _mask_sets, _Masks + + sets = await _mask_sets({"sql": sql, "columns": ["missing"], "rows": [[1]], "source": "mall"}, "mall", _Masks()) + assert sets.sure == set() and "missing" in sets.hidden, (sets.sure, sets.hidden) + + +@pytest.mark.parametrize("sql", [ + # 值本身取自遮罩列的汇总、逐行的函数照旧算 + "SELECT MAX(phone) AS missing FROM customers", + "SELECT SUBSTR(phone, 1, 3) AS missing FROM customers", + "SELECT MAX(phone) FILTER (WHERE id > 1) AS missing FROM customers", + # 逐行的真假条件(不汇总)照旧算:每一行是真是假本身就是这一行的信息,同逐行的 CASE + "SELECT phone IS NULL AS missing FROM customers", +]) +async def test_values_taken_from_the_masked_column_stay_surely_masked(engine_up, mall, sql): + from app.api.evidence import _mask_sets, _Masks + + sets = await _mask_sets({"sql": sql, "columns": ["missing"], "rows": [[1]], "source": "mall"}, "mall", _Masks()) + assert sets.sure == {"missing"}, sets.sure + + +@pytest.mark.parametrize("sql, columns", [ + # SQL 解析不了:认不出哪一列取自哪一列,面板整份遮,自查一列都不算(列名就是遮罩列的除外) + ("SELECT name, phone AS p FROM customers WHERE ((", ["name", "p"]), + # 派生来源里没起别名的表达式:认遮罩列的那一套整份算,自查同样一列都不算 + ("SELECT name, amount FROM (SELECT c.name, UPPER(c.phone), o.amount FROM customers c " + "JOIN orders o ON o.customer_id = c.id) t", ["name", "amount"]), +]) +async def test_columns_only_counted_because_the_sql_is_unclear_are_not_surely_masked(engine_up, mall, sql, columns): + from app.api.evidence import _mask_sets, _Masks + + sets = await _mask_sets({"sql": sql, "columns": columns, "rows": [], "source": "mall"}, "mall", _Masks()) + assert sets.sure == set() and set(columns) <= sets.hidden, (sets.sure, sets.hidden) + direct = await _mask_sets({"sql": "SELECT name, phone FROM customers WHERE ((", "columns": ["name", "phone"], + "rows": [], "source": "mall"}, "mall", _Masks()) + assert direct.sure == {"phone"}, direct.sure + + +def node(nid, ntype, **config): + return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0}, "data": {"label": nid, "config": config}} + + +def chain(*nodes) -> dict: + return {"nodes": list(nodes), "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]} + + +async def finish(monkeypatch, spec: dict, text: str, payload: dict | None = None) -> Run: + from app.providers import mock_model + + monkeypatch.setattr(mock_model.MockChatModel, "_decide", lambda self, messages: AIMessage(content=text)) + run_id = (await run_manager.start(graph=spec, input_payload=payload or {})).id + for _ in range(400): + await asyncio.sleep(0.05) + async with SessionLocal() as session: + row = await session.get(Run, run_id) + if row.status in ("succeeded", "failed") and row.manifest_seq is not None: + return row + raise AssertionError(f"运行 {run_id} 没跑完:{row.status}") + + +async def events(run_id: str) -> list[RunEvent]: + async with SessionLocal() as session: + q = select(RunEvent).where(RunEvent.run_id == run_id).order_by(RunEvent.seq) + return list((await session.execute(q)).scalars()) + + +def one_query(sql: str, **report) -> dict: + return chain(node("start", "input"), node("top", "tool", tool="db_query__mall", args={"sql": sql}), + node("write", "report", instructions="写一句", **report), + node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}])) + + +@pytest.mark.parametrize("sql", COUNTING[:2]) +async def test_a_formal_report_citing_a_count_of_missing_phones_succeeds(monkeypatch, mall, sql): + """违规即失败(正式运行的默认值):数据质量报告引用「手机号缺失的人数」照常出具,不判违规。""" + row = await finish(monkeypatch, one_query(sql, on_violation="fail"), "手机号缺失的客户有 [[v:Q1.r0.missing]] 位。") + assert row.status == "succeeded", row.error + checked = next(e.data for e in await events(row.id) if e.type == "report.checked") + assert masked_of(checked["violations"]) == [] and checked["ok"] is True, checked["violations"] + + +# -------------------------------------------------------------------------- +# 正文里直接写着的遮罩值 +# -------------------------------------------------------------------------- + + +async def masked_catalog(sql: str, columns: list[str], rows: list[list]) -> dict: + art = await artifact_store.put_json({"columns": columns, "rows": rows, "source": "mall", "sql": sql}, kind="query") + return {"Q1": {"alias": "Q1", "kind": "query", "artifact": art, "columns": columns, "rows": len(rows), + "node_id": "top", "source": "mall"}} + + +SQL_TOP = "SELECT c.name AS customer, c.phone AS tel, 1 AS spend FROM customers c" +TOP_ROWS = [[NAMES[1], PHONES[1], 380.0], [NAMES[0], PHONES[0], 220.0]] + + +@pytest.mark.parametrize("text", [ + f"消费最高的客户电话是 {PHONES[1]}。", + # 换了写法的号码也认 + "消费最高的客户电话是 199-0000-0702。", + f"消费最高的客户电话是 +86 {PHONES[1][:3]} {PHONES[1][3:7]} {PHONES[1][7:]}。", +]) +async def test_a_masked_value_copied_into_the_text_is_flagged(engine_up, mall, text): + """写作者把号码照抄成正文(没写成引用):记一条 masked_cell(按值认出来的),不带值;交回写作者的那句说清在哪一句、 + 值不能以任何形式写进报告,句子里的值换成「已遮罩」。""" + from app.engine.nodes.report import _MaskedCells + + catalog = await masked_catalog(SQL_TOP, ["customer", "tel", "spend"], TOP_ROWS) + doc = await _MaskedCells(catalog)(compose_doc(text, catalog, node_id="write", run_id="r1")) + [v] = masked_of(doc["violations"]) + assert v["by_value"] is True and v["segment"] and v["unit"] and "ref" not in v, v + assert "设置了遮罩的列中的值" in v["message"] and "不能以任何形式写进报告" in v["for_model"] + assert "已遮罩" in v["context"] and leaks(v) == [] and leaks(describe_violations([v])) == [] + + +async def test_a_text_masked_column_copied_as_text_is_flagged(engine_up, mall): + """文字类的遮罩列(姓名):数字核对管不到它,按值认才拦得住。""" + from app.engine.nodes.report import _MaskedCells + + await set_source(mall, {"mask_columns": ["name"]}) + catalog = await masked_catalog(SQL_TOP, ["customer", "tel", "spend"], TOP_ROWS) + doc = await _MaskedCells(catalog)(compose_doc(f"消费最高的是{NAMES[1]},花了 [[v:Q1.r0.spend]]。", catalog, + node_id="write", run_id="r1")) + [v] = masked_of(doc["violations"]) + assert v["by_value"] is True and leaks(v) == [], v + + +async def test_a_cited_masked_cell_is_not_counted_twice(engine_up, mall): + """[[v:Q1.r0.tel]] 已经按引用记过:同一处不再按值另记一条。""" + from app.engine.nodes.report import _MaskedCells + + catalog = await masked_catalog(SQL_TOP, ["customer", "tel", "spend"], TOP_ROWS) + doc = await _MaskedCells(catalog)(compose_doc("电话 [[v:Q1.r0.tel]]。", catalog, node_id="write", run_id="r1")) + [v] = masked_of(doc["violations"]) + assert v["ref"] == "v:Q1.r0.tel" and not v.get("by_value"), v + + +async def test_values_only_conservatively_masked_or_given_as_run_input_are_not_flagged(engine_up, mall): + """不算违规的:SQL 认不准、整份算进来的列(姓名没设遮罩,只是面板多遮);运行输入里写着的号码(发起运行的人自己填的); + 数据源没设遮罩。""" + from app.engine.nodes.report import _MaskedCells + + unsure = ("SELECT name, amount FROM (SELECT c.name, UPPER(c.phone), o.amount FROM customers c " + "JOIN orders o ON o.customer_id = c.id) t ORDER BY amount DESC") + catalog = await masked_catalog(unsure, ["name", "amount"], [[NAMES[1], 300.0]]) + doc = await _MaskedCells(catalog)(compose_doc(f"金额最大的一笔来自{NAMES[1]}。", catalog, node_id="write", run_id="r1")) + assert masked_of(doc["violations"]) == [] + + catalog = await masked_catalog(SQL_TOP, ["customer", "tel", "spend"], TOP_ROWS) + asked = _MaskedCells(catalog, protected=[json.dumps({"phone": PHONES[1]})]) + doc = await asked(compose_doc(f"号码 {PHONES[1]} 的客户消费最高。", catalog, node_id="write", run_id="r1")) + assert masked_of(doc["violations"]) == [] + + await set_source(mall, {}) + doc = await _MaskedCells(catalog)(compose_doc(f"电话 {PHONES[1]}。", catalog, node_id="write", run_id="r1")) + assert masked_of(doc["violations"]) == [] + + +async def test_snapshots_of_unmasked_sources_are_not_read_for_values(engine_up, mall, monkeypatch): + """按值认要读快照:数据源现在没设遮罩的一份都不读,没引用到格子的也不为引用去读。""" + from app.core import artifact_store as store + from app.engine.nodes.report import _MaskedCells + + await set_source(mall, {}) + catalog = await masked_catalog(SQL_TOP, ["customer", "tel", "spend"], TOP_ROWS) + read: list[str] = [] + real = store.load + monkeypatch.setattr(store, "load", lambda a: read.append(a) or real(a)) + await _MaskedCells(catalog)(compose_doc("一共三位客户。", catalog, node_id="write", run_id="r1")) + assert read == [], read + + +METRICS = [ + {"id": "phone_raw", "name": "首位客户手机号", "format": "plain", "expression": "cell(nodes.top, 0, 'tel')"}, + {"id": "id3", "name": "第三位客户编号", "format": "plain", "expression": "cell(nodes.top, 2, 'id')"}, +] + + +def card_graph(**report) -> dict: + return chain(node("start", "input"), + node("top", "tool", tool="db_query__mall", + args={"sql": "SELECT id, name AS customer, phone AS tel FROM customers ORDER BY id"}), + node("card", "metrics", caliber="遮罩对照", caliber_version="v1", metrics=METRICS), + node("write", "report", instructions="写一句", **report), + node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}])) + + +async def test_a_metric_whose_value_is_a_masked_value_is_flagged(monkeypatch, mall): + """[[m:phone_raw]] 的值就是号码:按值认出来,点名那处引用;取客户编号的 [[m:id3]] 照常。标注照常产出时,时间线那一行 + 说清有几处是正文里写着的值,缺口、日志都不写值。""" + row = await finish(monkeypatch, card_graph(on_violation="flag"), "第三位客户编号 [[m:id3]],首位客户电话 [[m:phone_raw]]。") + assert row.status == "succeeded", row.error + rows = await events(row.id) + checked = next(e.data for e in rows if e.type == "report.checked") + [v] = masked_of(checked["violations"]) + assert v["ref"] == "m:phone_raw" and v["by_value"] is True and "[[m:phone_raw]]" in v["message"], v + [log] = [e.data for e in rows if e.type == "log" and e.data.get("code") == "report_masked_cell"] + assert log["count"] == 1 and log["written"] == 1 and log["refs"] == ["m:phone_raw"], log + finished = next(e.data for e in rows if e.type == "node.finished" and e.node_id == "write") + [gap] = artifact_store.load(finished["artifact"])["issuance_gaps"] + assert "设置了遮罩的列中的值" in gap and leaks([checked["violations"], log, gap]) == [], (gap, log) + + +async def test_a_formal_report_copying_a_phone_fails_with_advice_about_the_instructions(monkeypatch, mall): + row = await finish(monkeypatch, card_graph(on_violation="fail", numbers="off"), + f"首位客户电话 {PHONES[0]},第三位客户编号 [[m:id3]]。") + assert row.status == "failed" and "设置了遮罩的列中的值" in row.error, row.error + assert "指令中去掉" in row.error and "指令遵循能力" not in row.error and leaks(row.error) == [], row.error diff --git a/backend/tests/test_whatif_api.py b/backend/tests/test_whatif_api.py index 680dd046..5307976f 100644 --- a/backend/tests/test_whatif_api.py +++ b/backend/tests/test_whatif_api.py @@ -364,6 +364,9 @@ async def test_masked_columns_are_neither_shown_nor_used(client, monkeypatch, sh # 三个指标都用到了遮罩列:不改动也照实说推演不了,不报「无变化」;什么都没改,下游不受影响 assert {k: (m["status"], m["changed"], m["rendered_new"]) for k, m in metrics.items()} == { k: ("masked", None, None) for k in ("amount5", "cnt", "per")} + # 原值:取自遮罩列的那一格不给;数行数的 cnt 照给(行数不是遮罩值,报告正文、证据面板的指标步骤也写 10 单) + assert metrics["amount5"]["old"] == metrics["amount5"]["rendered_old"] == "已遮罩" and metrics["amount5"]["withheld"] + assert (metrics["cnt"]["old"], metrics["cnt"]["rendered_old"]) == (10, "10单") and not metrics["cnt"].get("withheld") assert all(reasons[(k, None)] == metrics[k]["reason"] for k in metrics) and body["affected_cards"] == [] resp = await client.post(f"/api/runs/{row.id}/evidence/whatif", diff --git a/frontend/src/lib/evidence.ts b/frontend/src/lib/evidence.ts index 445d6b0d..d5614b1d 100644 --- a/frontend/src/lib/evidence.ts +++ b/frontend/src/lib/evidence.ts @@ -223,6 +223,20 @@ export function unitText(unit: Pick): string { return (unit.segments ?? []).filter((s) => s.kind !== 'structural').map((s) => s.text).join('') } +/** + * 整句面板「挂的依据」里一条依据的说明。证据图(/evidence)给的标签优先:服务端已把用到遮罩列的指标的值换成「已遮罩」 + * (报告只把首位客户的手机号挂作依据、正文里没有号码时,号码也不该从这里露出来)。证据图还没回来、取不到时,有运行的 + * 指标只写名字——文档目录里的标签是「名称 = 渲染值」,值可能就是遮罩列的那一格;没有运行的(预览)、别的依据照目录 + */ +export function citeLabel(alias: string, doc: Pick, graph: EvidenceGraph | undefined, + report: string | undefined, hasRun: boolean): string | undefined { + const sealed = graph?.evidence?.find((e) => e.alias === alias && (!report || !e.report || e.report === report))?.label + if (typeof sealed === 'string' && sealed) return sealed + const entry = doc.catalog?.[alias] + if (hasRun && entry?.kind === 'metric') return typeof entry.name === 'string' && entry.name ? entry.name : alias + return typeof entry?.label === 'string' ? entry.label : undefined +} + /** * 片段的来源说一句:「口径卡指标 环比增幅」「运行输入 week」「查询 Q3 · 第 6 行 · amount」。 * 单元格先看 cite 的种类:查询条目在目录里是 query,引用它的一格是 cell diff --git a/frontend/src/lib/terms.ts b/frontend/src/lib/terms.ts index 5cc7686c..bfbd379b 100644 --- a/frontend/src/lib/terms.ts +++ b/frontend/src/lib/terms.ts @@ -248,13 +248,18 @@ export const ABSENCE_CLAIM_TEXT = { } /** - * 报告直接引用了取自遮罩列的格子(报告自查的 masked_cell;c.phone AS tel 这种改了名字的也算),重写后仍在、 - * 「违规处置」为标注时照常产出:时间线上那一行(日志 report_masked_cell)和证据面板违规清单里的叫法。 + * 报告写进了取自遮罩列的值(报告自查的 masked_cell):直接引用了那一格([[v:Q2.r0.tel]],c.phone AS tel 这种改了名字的 + * 也算),或者按值认出正文里直接写着、经指标带出来的(违规带 by_value),重写后仍在、「违规处置」为标注时照常产出: + * 时间线上那一行(日志 report_masked_cell,written 是其中按值认出来的几处)和证据面板违规清单里的叫法。 * 只说记为缺口,不说出具:探索运行、没设出具契约的成果不出具,报告接在侧枝上时缺口也进不了出具,降不降档由出具那一行说 */ export const MASKED_CELL_TEXT = { - label: '引用了遮罩列', - title: (n?: number) => `报告引用了${n ? ` ${formatNumber(n)} 处` : ''}取自遮罩列的格子,已标注`, + label: '写进了遮罩列的值', + title: (n?: number, written = 0) => { + if (!written) return `报告引用了${n ? ` ${formatNumber(n)} 处` : ''}取自遮罩列的格子,已标注` + if (n && n > written) return `报告引用、写进了 ${formatNumber(n)} 处取自遮罩列的值,已标注` + return `报告写进了 ${formatNumber(written)} 处设置了遮罩的列中的值,已标注` + }, next: '数据源设置了遮罩的列不应写进报告,这几处已记为缺口。请在报告撰写节点的指令中去掉对这些列的引用后重新运行', } @@ -338,6 +343,8 @@ export const EVIDENCE_TEXT = { openSnapshot: '打开完整快照', snapshotTitle: (alias: string) => `查询 ${alias} · 完整快照`, masked: '已遮罩', + /** 遮没遮核对不了、不显示的值(快照、取值链上的产出读不出来):和「已遮罩」分开,数据源可能根本没设遮罩 */ + unverifiedValue: '无法核对', /** 面板底部:被遮罩的列 + 遮罩不是安全边界(用户拍板写明) */ maskNote: (cols: string[]) => `已遮罩的列:${cols.join('、')}。遮罩只减少暴露,不是安全边界:完整快照和原始工件中仍为原值`, diff --git a/frontend/src/run/EvidencePanel.tsx b/frontend/src/run/EvidencePanel.tsx index 03c32b98..5018773b 100644 --- a/frontend/src/run/EvidencePanel.tsx +++ b/frontend/src/run/EvidencePanel.tsx @@ -9,8 +9,8 @@ import clsx from 'clsx' import { ApiError } from '../api/client' import { Spinner, StatusBadge, isComposing } from '../components/ui' import { - EVIDENCE_KIND_STYLE, EVIDENCE_STATE, caliberSourceText, caliberUpgradeText, claimBasis, closestNames, docForeign, - entitySources, evidenceTrace, evidenceValue as valueText, graphDoc, inputSource, integrityFailures, isJudged, + EVIDENCE_KIND_STYLE, EVIDENCE_STATE, caliberSourceText, caliberUpgradeText, citeLabel, claimBasis, closestNames, + docForeign, entitySources, evidenceTrace, evidenceValue as valueText, graphDoc, inputSource, integrityFailures, isJudged, isJudgeLimit, judgeFlags, judgeLimitWords, judgeable, judgedVerdicts, limitOf, pointsToSettings, locatable, locatorText, notableInput, queryOf, queryWindow, quoteWhere, quoteWindow, reasonOf, rewriteOf, sealVerdict, segName, segmentKind, segmentState, sourceOf, unitText, unitVerdict, verdictMissing, verdictState, type ClaimBasis as Basis, @@ -121,7 +121,7 @@ function maskedOf(input: EvidenceInput): string[] { return Array.isArray(raw) ? raw.filter((c): c is string => typeof c === 'string' && !!c) : [] } -/** 遮没遮核对不了的输入(快照、取值链上的产出读不出来):值同样换成「已遮罩」,mask_unverified 是原因 */ +/** 遮没遮核对不了的输入(快照、取值链上的产出读不出来):值换成「无法核对」,mask_unverified 是原因 */ function unverifiedOf(input: EvidenceInput): string { const raw: unknown = input.mask_unverified return typeof raw === 'string' ? raw : '' @@ -607,7 +607,16 @@ function ClaimBody({ doc, artifact, runId, runClass, unit, block, mark }: { // 一整句没有「这一段的证据」可言:封存核对通过时只说报告文档封存了,节点里当场判的判定跟着一起封存 const sealLabel = sealed.status !== 'done' ? sealed.label : verdict && !late && isJudged(verdict) ? JUDGE_TEXT.sealedWithDoc : JUDGE_TEXT.sealedDoc - const cites = (unit.cites ?? []).map((alias) => ({ alias, label: doc.catalog?.[alias]?.label as string | undefined })) + // 挂的依据:说明按证据图(服务端已把用到遮罩列的指标的值换成「已遮罩」)写,不直接读文档目录里的「名称 = 渲染值」。 + // 有指标依据时才去取证据图(正文挂上时一般已经取过,取过的不再发) + const graphSlot = useEvidence((s) => (runId ? s.graphs[runId] : undefined)) + const loadGraph = useEvidence((s) => s.loadGraph) + const metricCite = (unit.cites ?? []).some((alias) => doc.catalog?.[alias]?.kind === 'metric') + useEffect(() => { + if (runId && metricCite) void loadGraph(runId) + }, [runId, metricCite, loadGraph]) + const graph = !foreign && graphSlot?.status === 'ok' ? graphSlot.data : undefined + const cites = (unit.cites ?? []).map((alias) => ({ alias, label: citeLabel(alias, doc, graph, report, !!runId) })) // 讲方法、讲结构的句子:SQL 和字段清单直接列在挂的依据下面。正文不是封存的那份时不列(链是另一份报告的) const basis = useMemo(() => (foreign ? null : claimBasis(unit, doc)), [foreign, unit, doc]) // 反方审稿对这一句的判断:服务端只认审的就是封存的这一份文档;正文不是那一份时不用。片段接口还没答、答不了时先按正文 @@ -1472,7 +1481,7 @@ function InputChip({ input, link }: { input: EvidenceInput; link?: InputLink }) const host = useEvidenceHost() const missing = input.status === 'missing' || input.value == null // 取自遮罩列(期 4):服务端已把值换成「已遮罩」,这里照查询表格里遮罩格的样子写,读着不像一个真值。遮没遮核对不了的 - // (快照读不出来)一样不显示值,悬停说明原因 + // (快照读不出来)一样不显示值,写「无法核对」,悬停说明原因 const unverified = unverifiedOf(input) const masked = !missing && (maskedOf(input).length > 0 || !!unverified) // Agent 交来、被截断切开的数组字段:对它计数、求和只算到了取回的那部分 @@ -1483,7 +1492,9 @@ function InputChip({ input, link }: { input: EvidenceInput; link?: InputLink }) cut && ` · ${EVIDENCE_TEXT.inputTruncated}`, masked && ` · ${unverified ? EVIDENCE_TEXT.unverifiedInput(unverified) : EVIDENCE_TEXT.maskedInput}`].filter(Boolean).join('') const style = missing || cut ? { color: 'var(--st-waiting)', borderColor: 'var(--st-waiting)' } : { color: 'var(--text)' } - const shown = masked ? EVIDENCE_TEXT.masked : valueText(input.value) + // 值那里的字照服务端写的(「已遮罩」,遮没遮核对不了的「无法核对」);认不出的一律写「已遮罩」,不把别的字当值显示 + const shown = !masked ? valueText(input.value) + : input.value === EVIDENCE_TEXT.unverifiedValue ? EVIDENCE_TEXT.unverifiedValue : EVIDENCE_TEXT.masked const body = ( {masked ? {shown} : shown} ← {input.path ?? NONE} diff --git a/frontend/src/run/decode.ts b/frontend/src/run/decode.ts index 07ac6e5c..98d299fb 100644 --- a/frontend/src/run/decode.ts +++ b/frontend/src/run/decode.ts @@ -874,12 +874,13 @@ function explainLog(code: string | undefined, message: string, d: Record 0 ? d.count : undefined + const written = typeof d.written === 'number' && d.written > 0 ? d.written : 0 const refs = strs(d.refs) return { - title: MASKED_CELL_TEXT.title(n), + title: MASKED_CELL_TEXT.title(n, written), sub: refs.length ? refs.map((r) => `[[${r}]]`).join('、') : undefined, next: MASKED_CELL_TEXT.next, } diff --git a/scripts/check-decode.mjs b/scripts/check-decode.mjs index 6c364106..dc9e7762 100644 --- a/scripts/check-decode.mjs +++ b/scripts/check-decode.mjs @@ -1377,12 +1377,14 @@ await section('报告核对 report.checked、口径卡的台账(可点击证 && !!rcAbsent?.detail?.includes('缺失断言') && !!rcAbsent?.detail?.includes('依据不足'), `${rcAbsent?.status} ${rcAbsent?.detail}`) }) -await section('报告引用了取自遮罩列的格子(report_masked_cell):标题说几处、已标注,副标题点名引用,不写那几格的值', async () => { - // 契约:data = {level: warn, code: report_masked_cell, message, count, refs, columns},重写后仍在、「违规处置」为标注时才发 +await section('报告写进了取自遮罩列的值(report_masked_cell):标题说几处、已标注,副标题点名引用,不写那几格的值', async () => { + // 契约:data = {level: warn, code: report_masked_cell, message, count, refs, written, columns},重写后仍在、「违规处置」 + // 为标注时才发。written 是其中按值认出来的几处(正文里直接写着的、经指标带出来的,违规带 by_value) const E = (seq, type, node_id, data = {}) => ({ seq, type, node_id, ts: 1790000000 + seq, data }) const reportPy = readFileSync(`${root}backend/app/engine/nodes/report.py`, 'utf8') - check('后端发引用了遮罩列的警告,带着 count、refs、columns', reportPy.includes('code="report_masked_cell"') - && reportPy.includes('count=len(hits), refs=refs') && reportPy.includes('columns=list(dict.fromkeys('), + check('后端发写进了遮罩列的值的警告,带着 count、refs、written、columns', reportPy.includes('code="report_masked_cell"') + && reportPy.includes('count=len(hits), refs=refs') && reportPy.includes('written=sum(') + && reportPy.includes('columns=list(dict.fromkeys('), '改了 report.py 的字段就同步改 decode.ts 的 explainLog 和这里的夹具') const MASKED = '报告引用了 2 处取自遮罩列的格子(「v:Q2.r0.tel」、「v:Q2.r1.tel」),已要求模型重写 1 次仍未改掉:' + '数据源设置了遮罩的列不应写进报告。报告照常产出,这几处已标注,已记为缺口。请在报告撰写节点的指令中去掉对这些列的引用' @@ -1411,6 +1413,36 @@ await section('报告引用了取自遮罩列的格子(report_masked_cell) .find((s) => s.code === 'report_masked_cell') check('……缺字段时标题照样说人话,不出 undefined', bare?.title === '报告引用了取自遮罩列的格子,已标注' && bare?.sub === undefined, `${bare?.title} / ${bare?.sub}`) + // 按值认出来的:正文里直接写着号码、姓名,或者经指标带了出来([[m:phone_raw]])。标题不说「引用了格子」 + const titleOf = (data) => flatten(mod.decodeRun([E(1, 'log', 'w', { level: 'warn', code: 'report_masked_cell', + message: '报告写进了遮罩列的值', ...data })])).find((s) => s.code === 'report_masked_cell') + const onlyWritten = titleOf({ count: 1, written: 1, refs: [] }) + check('……全是正文里直接写着的:标题说写进了几处遮罩列中的值,没有引用可点名就不写副标题', + onlyWritten?.title === '报告写进了 1 处设置了遮罩的列中的值,已标注' && onlyWritten?.sub === undefined, + `${onlyWritten?.title} / ${onlyWritten?.sub}`) + const viaMetric = titleOf({ count: 1, written: 1, refs: ['m:phone_raw'] }) + check('……经指标带出来的:副标题点名那处引用', viaMetric?.sub === '[[m:phone_raw]]', viaMetric?.sub) + const both = titleOf({ count: 3, written: 1, refs: ['v:Q2.r0.tel', 'v:Q2.r1.tel'] }) + check('……两样都有:标题说引用、写进了几处', both?.title === '报告引用、写进了 3 处取自遮罩列的值,已标注', both?.title) +}) + +await section('整句面板挂的依据:按证据图的标签写,不读文档目录里带值的标签(citeLabel)', async () => { + const ev = await import(await load('/src/lib/evidence.ts')) + const doc = { catalog: { + 'm:phone_raw': { kind: 'metric', name: '首位客户手机号', label: '首位客户手机号 = 19900000301' }, + Q1: { kind: 'query', label: 'db_query__shop · 3 行' }, + } } + const graph = { evidence: [{ alias: 'm:phone_raw', report: 'write', label: '首位客户手机号 = 已遮罩' }, + { alias: 'Q1', report: 'write', label: 'db_query__shop · 3 行' }] } + check('证据图有这条依据:用证据图的标签(服务端遮过)', ev.citeLabel('m:phone_raw', doc, graph, 'write', true) + === '首位客户手机号 = 已遮罩') + check('……证据图还没回来:指标只写名字,不写目录里的值', ev.citeLabel('m:phone_raw', doc, undefined, 'write', true) + === '首位客户手机号') + check('……查询这类不带值的依据照目录写', ev.citeLabel('Q1', doc, undefined, 'write', true) === 'db_query__shop · 3 行') + check('……证据图里是另一份报告的同名依据:不拿来用', ev.citeLabel('m:phone_raw', doc, + { evidence: [{ alias: 'm:phone_raw', report: 'other', label: '首位客户手机号 = 1' }] }, 'write', true) === '首位客户手机号') + check('……没有运行(预览):照目录写', ev.citeLabel('m:phone_raw', doc, undefined, undefined, false) + === '首位客户手机号 = 19900000301') }) await section('工具门控 tool.gated(工具信任三档)', async () => { diff --git a/scripts/check-evidence.mjs b/scripts/check-evidence.mjs index 93b60089..bef463b4 100644 --- a/scripts/check-evidence.mjs +++ b/scripts/check-evidence.mjs @@ -3362,10 +3362,10 @@ await section('verify', '期 4:指标步骤的双盲复算、取自遮罩列 body.redacted = { columns: ['order_cnt'], note: '这些列在数据源中设置了遮罩' } } if (id === 's23' && metric) { - // 遮没遮核对不了(快照读不出来):同样不显示值,原因是服务端写好的一句,不进遮罩列 + // 遮没遮核对不了(快照读不出来):同样不显示值,值那里写「无法核对」,原因是服务端写好的一句,不进遮罩列 for (const st of body.chain) { if (st.step === 'input' && st.path === 'vars.kpi.refund_cnt') { - Object.assign(st, { value: '已遮罩', mask_unverified: '查询快照无法读取,核对不了这一格是否取自设置了遮罩的列' }) + Object.assign(st, { value: '无法核对', mask_unverified: '查询快照无法读取,核对不了这一格是否取自设置了遮罩的列' }) } } } @@ -3444,13 +3444,17 @@ await section('verify', '期 4:指标步骤的双盲复算、取自遮罩列 && await p.locator('[data-ev-input="vars.kpi.gmv"]').getAttribute('data-ev-input-masked') === null) check('面板底下写明遮罩的列和遮罩不是安全边界', (await p.locator('[data-ev-mask-note]').innerText().catch(() => '')).includes('order_cnt')) await pg.keyboard.press('Escape') - // 遮没遮核对不了:同样写「已遮罩」,悬停说明原因(快照读不出来),不算进遮罩列 + // 遮没遮核对不了:不显示值,写「无法核对」(不写「已遮罩」:数据源可能根本没设遮罩),悬停说明原因(快照读不出来), + // 不算进遮罩列 await openSeg(pg, 's23', '[data-ev-substituted]') const unsure = p.locator('[data-ev-input="vars.kpi.refund_cnt"]') const unsureTitle = await unsure.getAttribute('title').catch(() => '') - check('遮没遮核对不了的输入:标签写「已遮罩」,悬停写明快照读不出来、不显示值', - await unsure.getAttribute('data-ev-input-masked') === '' && (await unsure.innerText()).includes('已遮罩') - && (unsureTitle ?? '').includes('查询快照无法读取,核对不了这一格是否取自设置了遮罩的列,不显示值'), unsureTitle ?? '') + const unsureText = await unsure.innerText().catch(() => '') + check('遮没遮核对不了的输入:标签写「无法核对」、不写「已遮罩」,悬停写明快照读不出来、不显示值', + await unsure.getAttribute('data-ev-input-masked') === '' && unsureText.includes('无法核对') + && !unsureText.includes('已遮罩') + && (unsureTitle ?? '').includes('查询快照无法读取,核对不了这一格是否取自设置了遮罩的列,不显示值'), + `${unsureText} / ${unsureTitle ?? ''}`) check('……面板底下的遮罩说明不把它算进遮罩列', await p.locator('[data-ev-mask-note]').count() === 0) await pg.keyboard.press('Escape') check('核查状态那几页没有运行时报错', r.errors.length === 0, r.errors.join(' | '))