diff --git a/backend/app/api/evidence.py b/backend/app/api/evidence.py index b7747d75..8e16d786 100644 --- a/backend/app/api/evidence.py +++ b/backend/app/api/evidence.py @@ -22,11 +22,18 @@ options.mask_columns 里的列换成「已遮罩」,SQL 里给它们起了别 (_mask_sets,和可验证报告同一个函数,合并查询另按合并 SQL 认);用到这些列的指标,指标步骤的值、 证据图的标签也不给(_metric_masks,和推演同一个判断;报告撰写节点写作之前按同一个判断把这类指标在目录里写成「已遮罩」, withheld_metrics,只是遮罩列只认确定的那一套,和单元格引用的自查同一个口径;可验证报告认老文档也按这个口径, -certain_masks;转抄上游口径卡的指标在指标依赖图上一次认,_CopyGraph → recompute.masked_closure,推演的转抄输入按同一张图, -copied_inputs);SQL、合并警告里写着的遮罩值(这次运行里确定取自遮罩列的值) +certain_masks;转抄上游口径卡的指标在指标依赖图上一次认,_CopyGraph → recompute.masked_closure,按整张卡认:转抄的那张卡 +在这次运行的任何一次执行里有一个指标取自遮罩格,转抄出来的就不给,推演的转抄输入按同一张图,copied_inputs);SQL、合并 +警告里写着的遮罩值(这次运行里确定取自遮罩列的值) 展示时换掉。一份快照的遮罩分析、收到的值按快照工件记在进程里(_MEMO),之后的请求不再读盘、不再分析 ——在有身份体系之前,这只减少暴露,不是安全边界:知道工件 id 的人照样能取到整份快照。 +已知局限(遮罩只减少暴露、不是安全边界,可验证报告的真伪以服务端封存的清单哈希为准):认遮罩列只按 SQL 和列名认,写法的 +长尾认不全,取自那些列的指标、单元格在写作目录、报告文档、成果和可验证报告里照给。已知的有:先给遮罩列起别名、外层再套 +没起别名的表达式(SELECT * FROM (SELECT UPPER(p) FROM (SELECT phone AS p …)),列名「UPPER(p)」里没有遮罩列的名字)、 +一元加号这类认法本身漏掉的表达式(+phone,masking._derived_masks 的缺口)、Postgres 给没起别名的表达式起的列名(upper、 +?column?)、视图和别的表里换了名字存着的遮罩列、自己建的函数,以及数据整形把号码取出来再赋给变量(出处认不出)。 + 期 4 的核查状态同样只读封存范围内的东西:指标步骤带双盲复算的结果(_dual_check_of,读双盲复算节点的产出和台账 条目),句子带反方审稿的判断(_challenge_of,读反方审稿节点的产出和审稿记录)。它们是核查,不是证据:没有就不带这两个键。 证据图的每份报告另带一张被反方审过的句子 → 判断的表(_challenge_verdicts,和 _challenge_of 同一个读法),正文据此挂 @@ -992,8 +999,9 @@ async def _metric_masks(metric: dict[str, Any], card_node: str, artifact: str, s - 输入取自哪份结果的哪几列按 _InputMasks 认(recompute.input_origin 的 wide:下标不是字面量的、整行、整份结果都认) - 认不出出处的输入(数据整形算出来再赋给变量的一格),值就是这次运行查到过的遮罩值的,按值认(masks.run_secrets); 运行输入是发起运行的人自己填的,不认 - - 转抄上游口径卡的输入(nodes.<卡>.metrics[0].value、nodes.<卡>.text,recompute.card_input)按上游那几个指标认: - 在这次请求的指标依赖图上一次算出(_CopyGraph → recompute.masked_closure),不逐个往上递归 + - 转抄上游口径卡的输入(nodes.<卡>.metrics[0].value、nodes.<卡>.text、整张卡,recompute.card_input)按那张卡认:那张卡 + 在这次运行的任何一次执行里有一个指标不给,转抄出来的就不给(转抄的保守规则),在这次请求的指标依赖图上一次算出 + (_CopyGraph → recompute.masked_closure),不逐个往上递归 - 指标的值:取自遮罩列的一格、一行的不给;最外层的输入遮没遮核对不了的写「无法核对」;整份结果当输入、有认不出出处 的输入的,值里有遮罩值才不给(len(vars.res.rows) 照给) @@ -1012,12 +1020,10 @@ async def _metric_masks(metric: dict[str, Any], card_node: str, artifact: str, s def _copied_held(kind: str, columns: tuple[str, ...], reason: str | None) -> _Held: - """转抄上游口径卡的输入不给值的原因(recompute.Judged.copied 的一项):上游有指标不给的是 masked(整张卡转抄的是 - table,指标的值另按值认),写上游让它不给的遮罩列;上游有指标核对不了的核对不了(整张卡转抄的同 table、带原因)。""" + """转抄上游口径卡的输入不给值的原因(recompute.Judged.copied 的一项):转抄的那张卡有指标不给的是 masked(哪种写法都 + 一样),写那张卡让它不给的遮罩列;读到的上游指标核对不了的核对不了(整张卡转抄的同 table、带原因)。""" if kind == "masked": return _Held("masked", list(columns)) - if kind == "table": - return _Held("table", list(columns)) if kind == "table_unverified": return _Held("table", [], reason or CARD_UNVERIFIED) return _Held("unverified", [], reason or CARD_UNVERIFIED) @@ -1053,9 +1059,11 @@ class _CopyGraph: recompute.masked_closure 一次算出最小不动点。认过的指标记下来:证据图给每个指标认标签、同一次请求里别的指标转抄它, 都不再重认,工作量和图的大小成正比。 - 写作目录(output 给了:运行状态里每个节点最后一次的产出)里,循环中抄自己上一轮的卡指回自己,是一个环;封存之后 - (output 没给)按每次执行认:卡在这次执行之前读到的是自己上一次执行的产出(_card_outputs),一次一次往回连,连到 - 第一次为止。两种都只按图算,不按追了几层算:以前追够八层就按遮罩算,没设遮罩的循环累加也成了「已遮罩」。""" + 转抄的保守规则按整张卡认(recompute.CopyEdge.card):转抄一张卡时,把它在这次运行里每一次执行的指标集(_executions: + 封存之后按封存范围内的台账,写作时按运行状态里的台账)里的每个指标都放进图里,有一个不给,转抄出来的就不给。写作目录 + (output 给了:运行状态里每个节点最后一次的产出)里,循环中抄自己上一轮的卡读到的是它自己最后一次的产出,第一轮取过号码、 + 最后一轮没取的,以前就这么照给了;封存之后(output 没给)另按每次执行往回连:卡在这次执行之前读到的是自己上一次执行的 + 产出(_card_outputs)。两种都只按图算,不按追了几层算:以前追够八层就按遮罩算,没设遮罩的循环累加也成了「已遮罩」。""" def __init__(self, sealed: _Sealed, masks: _Masks, *, output: Callable[[Any], Any] | None, by_value: bool, sure: bool) -> None: @@ -1064,6 +1072,8 @@ class _CopyGraph: self._links: dict[Any, recompute.MetricLinks] = {} self._held: dict[Any, dict[str, _Held]] = {} self._judged: dict[Any, recompute.Judged] = {} + self._runs: dict[str, list[tuple[str, dict[str, Any]]]] = {} + self._owners: dict[str, str] | None = None def matches(self, sealed: _Sealed, output: Callable[[Any], Any] | None, by_value: bool, sure: bool) -> bool: return self.sealed is sealed and self.given is output and self.by_value == by_value and self.sure == sure @@ -1083,10 +1093,33 @@ class _CopyGraph: lambda: secrets)) return self._judged[key] + def _executions(self, node_id: str) -> list[tuple[str, dict[str, Any]]]: + """口径卡 node_id 在这次运行里每一次执行的指标集:[(工件, 内容)],按台账(sealed.entries 里的 metric_set 条目)认, + 读不出来、和哈希对不上的跳过(读到的那一次产出读不出来另有 CardInput.unreadable 兜着)。同一张卡只找一次。""" + if node_id not in self._runs: + found: list[tuple[str, dict[str, Any]]] = [] + for artifact in dict.fromkeys(str(e["artifact"]) for e in self.sealed.entries + if e.get("kind") == "metric_set" and e.get("artifact") + and str(e.get("node_id") or "") == node_id): + content, ok = self.masks.fetch(artifact) + if ok is True and isinstance(content, dict) and isinstance(content.get("metrics"), list): + found.append((artifact, content)) + self._runs[node_id] = found + return self._runs[node_id] + + def _owner(self, artifact: str) -> str | None: + """指标集工件 artifact 是哪张口径卡(节点 id)在这次运行里的产出,按台账认;认不出的是 None。""" + if self._owners is None: + self._owners = {} + for e in self.sealed.entries: + if e.get("kind") == "metric_set" and e.get("artifact") and e.get("node_id"): + self._owners.setdefault(str(e["artifact"]), str(e["node_id"])) + return self._owners.get(artifact) if artifact else None + async def _build(self, key: Any, card_node: str, artifact: str, metric: dict[str, Any]) -> list[Any]: - """认好 key 和顺着转抄的边够得着、还没认过的指标(转抄以外的输入,_links、_held),交回这一批新认的键。上游的 - 指标按上游那张卡那一次执行的产出认(_InputMasks 按 _card_outputs 找它当时读到的产出)。卡上没记输入的上游指标 - (写死的数、升级前的老卡)不连边:照给。""" + """认好 key 和顺着转抄的边够得着、还没认过的指标(转抄以外的输入,_links、_held),交回这一批新认的键。转抄一张卡时 + 它每一次执行的每个指标都放进来(_executions,转抄的保守规则按整张卡认);上游的指标按它那一次执行之前的产出认 + (_InputMasks 按 _card_outputs 找它当时读到的产出)。卡上没记输入的指标(写死的数、升级前的老卡)不放:照给。""" fresh: list[Any] = [] todo = [(key, card_node, artifact, metric)] while todo: @@ -1094,7 +1127,7 @@ class _CopyGraph: if key in self._links: continue hide = _InputMasks(self.sealed, self.masks, node, art, output=self.given, sure=self.sure) - links = recompute.MetricLinks(item_metric) + links = recompute.MetricLinks(item_metric, card=node or None) held: dict[str, _Held] = {} for item in item_metric.get("inputs") or []: if not isinstance(item, dict): @@ -1103,14 +1136,24 @@ class _CopyGraph: copied = hide.copied(item) if copied is not None: upstream: list[Any] = [] + # 转抄的是哪张卡:按读到的产出上记着的指标集认(经数据整形赋给变量、转了一道的也认得出是哪张卡), + # 认不出的按取值链上的那个节点 + owner = copied.node_id if copied.card is not None: + up_art = str(copied.card.get("artifact") or "") + owner = self._owner(up_art) or copied.node_id for index in copied.picked: up_metric = copied.card["metrics"][index] if isinstance(up_metric, dict) and up_metric.get("inputs"): up = (_card_key(copied.node_id, copied.card), index) upstream.append(up) - todo.append((up, copied.node_id, str(copied.card.get("artifact") or ""), up_metric)) - links.copies.append(recompute.CopyEdge(path, tuple(upstream), copied.whole, copied.unreadable)) + todo.append((up, owner, up_art, up_metric)) + for run_art, content in self._executions(owner): + for index, up_metric in enumerate(content["metrics"]): + if isinstance(up_metric, dict) and up_metric.get("inputs"): + todo.append(((run_art, index), owner, run_art, up_metric)) + links.copies.append(recompute.CopyEdge(path, tuple(upstream), copied.whole, copied.unreadable, + card=owner)) continue found, traced = await hide.check(item) if found is None and not traced: @@ -1151,12 +1194,17 @@ async def withheld_metrics(catalog: dict[str, Any], *, nodes: dict[str, Any], le 遮罩列只按确定的那一套认(sure,和单元格引用的自查同一个口径:_cited_masks):SQL 认不准、证据面板整份遮的快照里, 没确定取自遮罩列的普通金额、计数、只装着分档标签的列照给。以前跟着证据面板宁可多遮,WITH 写了列名表、VALUES 当表的 销售额也成了「已遮罩」,正式运行引用它就判失败;同一格按 [[v:…]] 引用却不报违规。转抄上游口径卡的指标 - (nodes.<卡>.metrics[0].value、nodes.<卡>.text)按上游那个指标认:运行状态里每张卡只有最后一次的产出,循环里抄自己 - 上一轮的卡指回自己,在依赖图上是一个环(_CopyGraph),环上没有别的输入取自遮罩格就照给。""" + (nodes.<卡>.metrics[0].value、nodes.<卡>.text、整张卡)按那张卡认(转抄的保守规则,_CopyGraph):运行状态里每张卡只有 + 最后一次的产出,那张卡每一次执行的指标集按台账(ledger 的 metric_set 条目)读回来,有一次执行里有一个指标取自遮罩格, + 转抄出来的就写「已遮罩」。以前只看最后一次的产出:循环里第一轮取号码、之后转抄上一轮的卡,最后一轮没碰号码列,写作目录 + 照给,号码进了正文和成果;封存之后按每次执行往回认才写「已遮罩」,同一个指标两样说法。循环里抄自己上一轮的卡指回自己, + 在依赖图上是一个环,那张卡哪一次执行都没有取自遮罩格的指标就照给。""" queries = {str(e["artifact"]): {k: e[k] for k in ("node_id", "tool", "source", "via", "call_id", "exec") if e.get(k) is not None} for e in ledger if isinstance(e, dict) and e.get("kind") == "query" and e.get("artifact")} - view = _Sealed(run_id="", graph={}, events=[], queries=queries, + # 每张口径卡每一次执行的指标集:转抄的保守规则按整张卡、每一次执行认(_CopyGraph._executions 从 entries 里找) + runs = [dict(e) for e in ledger if isinstance(e, dict) and e.get("kind") == "metric_set" and e.get("artifact")] + view = _Sealed(run_id="", graph={}, events=[], queries=queries, entries=runs, seal={"sealed": False, "ok": None, "manifest_seq": None, "legacy": False}) masks = _Masks(view) found: list[tuple[str, str, str, dict[str, Any], dict[str, Any]]] = [] @@ -1171,8 +1219,11 @@ async def withheld_metrics(catalog: dict[str, Any], *, nodes: dict[str, Any], le if not found: return [] # cell()、Agent 字段落在的快照先在线程里读好(读盘、复验哈希):在运行里认,不占着事件循环。转抄上游口径卡的指标要顺着 - # 上游卡的输入认,运行状态里每张口径卡的输入一并读好 + # 上游卡的输入认,运行状态里每张口径卡、台账里每一次执行的指标集连同它们的输入一并读好 + await masks.prefetch(str(e["artifact"]) for e in runs) cards = [card for card in nodes.values() if isinstance(card, dict) and card.get("kind") == "metric_set"] + cards += [content for e in runs for content, ok in [masks.fetch(str(e["artifact"]))] + if ok is True and isinstance(content, dict)] await masks.prefetch(str(item["artifact"]) for metric in [*(m for *_, m, _ in found), *(m for card in cards for m in card.get("metrics") or [])] if isinstance(metric, dict) for item in metric.get("inputs") or [] @@ -1250,7 +1301,7 @@ class _InputMasks: 的 sure,再按血缘排除值确实不取自遮罩列的),读不出来的按数据源现在设的列名。证据面板、推演照旧按 hidden 宁可多遮。 转抄上游口径卡的输入(recompute.card_input:nodes.<卡>.metrics[0].value、vars.<卡的 assign_to>.metrics[0].value、 - nodes.<卡>.text)这里只认出转抄了哪张卡的哪几个指标(copied),给不给按上游那几个指标在依赖图上认(_CopyGraph)。 + nodes.<卡>.text)这里只认出转抄了哪张卡的哪几个指标(copied),给不给按那张卡在依赖图上认(_CopyGraph)。 """ def __init__(self, sealed: _Sealed, masks: _Masks, card_node: str, artifact: str, *, diff --git a/backend/app/bundle/build.py b/backend/app/bundle/build.py index f6b3c446..bf5c83e5 100644 --- a/backend/app/bundle/build.py +++ b/backend/app/bundle/build.py @@ -13,8 +13,8 @@ 嵌入,别的不嵌内容、只给 id。口径卡上记着每个输入的值和代入式,有输入取自遮罩列(cell() 的格、Agent 字段、按位置 取的 vars.res.rows[0][2],SQL 里改了名字的遮罩列也算,SQL 认不出结果里哪一列取自哪一列的整份快照的列都算)的整张卡 同样只给 id,认法和证据面板、推演同一个(recompute.input_origin);有指标的值不给的(metric_word:值取自遮罩列的 - 一格、一行,整行、下标不是字面量的、转抄上游口径卡里这类指标的也算,转抄的在指标依赖图上一次认,recompute.masked_closure; - 遮罩列按这份文件宁可多遮的认法)、卡上记着的转抄来的值带遮罩的(_copies_masked)也一样;服务端 + 一格、一行,整行、下标不是字面量的、转抄的上游口径卡在任何一次执行里有这类指标的也算,转抄的在指标依赖图上一次认, + recompute.masked_closure;遮罩列按这份文件宁可多遮的认法)、卡上记着的转抄来的值带遮罩的(_copies_masked)也一样;服务端 文件被改过的卡照样按卡上记的输入认,解析不出一张卡的整张只给 id。报告文档的证据目录收着上游口径卡的全部指标,现在的 报告撰写节点把值不给的写成「已遮罩」;还写着原值的老文档(升级前生成的,或者生成之后数据源才设的遮罩)整份只给 id、 不附带它引用的工件——哪些指标的值不给和写作目录同一个判断(metric_word 的 sure:只按确定取自遮罩列的认,由调用方按 @@ -26,6 +26,15 @@ 它只证明「内部一致」:数字、文档、运行记录彼此对得上,而且没被改过。真伪要拿页面上的封存哈希和系统里这次 运行的封存核对(GET /api/runs/{id}/verify)对照,页面上醒目地写着这一点。 +已知局限,同样以服务端封存的清单哈希为准: +- 遮罩只减少暴露、不是安全边界。哪些列取自遮罩列按 SQL 和列名认,写法的长尾认不全(先给遮罩列起别名、外层再套没起别名的 + 表达式,+phone 这类认法本身漏掉的表达式,Postgres 给没起别名的表达式起的列名,视图、别的表里换了名字存着的遮罩列, + 自己建的函数,数据整形取出来再赋给变量的号码):取自它们的指标、快照在这份文件里照常附带,和证据面板、写作目录认法一致。 + 转抄上游口径卡的按整张卡认(转抄的那张卡在任何一次执行里有一个指标不给,转抄出来的就不给),宁可多挡 +- 显示文字的核对(verifier.js 的 checkLayout)只看紧挨着数字头尾的字:白名单、易混字的名单只是兜底,排版和易混字的花样 + 数不完(「(单位:万元)」这类隔着几个字的说明、x10 这类写法认不出)。核对页总览有一项无法核对就不是绿的,并写明去系统里 + 核对封存;全部通过也只说明文件内部一致 + 主体是纯函数:不碰数据库,工件经 read 取原字节,数据源现在设的遮罩由调用方查好传进来(source_masks),每份查询快照 里确定取自遮罩列的列、这次运行查到过的遮罩值也一样(sure_columns、sure_secrets)。 """ @@ -116,6 +125,8 @@ class _Store: self._card_outputs: dict[str, dict[str, str]] = {} self._docs: dict[str, bool] = {} self._sources: dict[str, str] | None = None + self._runs: dict[str, list[str]] | None = None + self._owners: dict[str, str] = {} def raw(self, artifact: str) -> bytes | None: if artifact not in self._raw: @@ -220,9 +231,10 @@ class _Store: return self._masked[key] def _copies_masked(self, card: str, metric: dict[str, Any]) -> bool: - """卡上这个指标转抄来的输入带不带遮罩(metric_word 认过之后才看得到):转抄的是不给、核对不了的上游指标,卡上记着的 - 就是那个值(嵌在下标里、指标的值照给时也一样);整张卡、清单文字转抄(table)的,记着的值(清单文字逐条写着「指标 - (名称)= 值」)里有这次运行查到过的遮罩值才算,记成「[3 项]」这种大概的不算。""" + """卡上这个指标转抄来的输入带不带遮罩(metric_word 认过之后才看得到):转抄的那张卡有指标不给(哪种写法都一样, + recompute.CopyEdge.card)、读到的上游指标核对不了,卡上记着的就是转抄来的值(嵌在下标里、指标的值照给时也一样); + 整张卡、清单文字转抄、读到的产出里有指标核对不了的(table_unverified),记着的值(清单文字逐条写着「指标(名称) + = 值」)里有这次运行查到过的遮罩值才算,记成「[3 项]」这种大概的不算。""" judged = self._graph(False).judged.get(_metric_key(card, metric, self.content(card))) if judged is None: return False @@ -238,8 +250,8 @@ class _Store: sure: bool = False) -> str | None: """口径卡 card 上一个指标的值给不给:None 照给;"masked" 不给(值取自遮罩列的一格、一行,或者整份结果里带着遮罩列、 值里就有这次运行查到过的遮罩值);"unverified" 遮没遮核对不了。和证据面板指标步骤的值同一个判断(api/evidence.py - 的 _metric_masks,by_value=False:输入的出处按 recompute.input_origin 的 wide 认,转抄上游口径卡的按上游那个指标 - 在依赖图上认,recompute.masked_closure,最后交给 recompute.withheld_value)。只按出处认:认不出出处的输入(写死的 + 的 _metric_masks,by_value=False:输入的出处按 recompute.input_origin 的 wide 认,转抄上游口径卡的按那张卡在依赖图上 + 认,recompute.masked_closure,最后交给 recompute.withheld_value)。只按出处认:认不出出处的输入(写死的 目标、数据整形算出来的数)值碰巧等于遮罩列里的某一格,不因此算——不然普通报告里的这种指标在文件里也核对不了, 老文档也整份只给哈希。 @@ -250,7 +262,8 @@ class _Store: sure_seen。和报告撰写节点写作时认的一样:现在的报告撰写节点照给的普通指标,老文档里写着它也照常附带 依赖图按 (指标集工件, 指标在卡上的位置) 认指标,两种认法各一张、构建里认过的记下来:卡转抄卡、循环里每一次执行都 - 转抄上一次的产出时,每个指标只认一次,和追了几层无关。""" + 转抄上一次的产出时,每个指标只认一次,和追了几层无关。转抄的保守规则按整张卡认(recompute.CopyEdge.card):转抄的 + 那张卡在封存范围内的任何一次执行里有一个指标不给,转抄出来的就不给,同写作目录。""" key = _metric_key(card, metric, self.content(card)) graph = self._graph(sure) if key not in graph.judged: @@ -267,15 +280,16 @@ class _Store: def _build(self, graph: "_Graph", key: Any, card: str, metric: dict[str, Any], events: Sequence[tuple[int, str, str | None, Any]], sure: bool) -> list[Any]: """认好 key 和顺着转抄的边够得着、还没认过的指标(转抄以外的输入),交回这一批新认的键,同 api/evidence.py 的 - _CopyGraph._build。上游的指标按上游那张卡那一次执行之前的产出认(_card_outputs);卡上没记输入的上游指标不连边。""" + _CopyGraph._build。转抄一张卡时它在封存范围内每一次执行的每个指标都放进来(_executions);上游的指标按上游那张卡 + 那一次执行之前的产出认(_card_outputs);卡上没记输入的指标不放。""" fresh: list[Any] = [] - todo = [(key, card, metric)] + todo = [(key, card, metric, self._owner(card))] while todo: - key, art, item_metric = todo.pop() + key, art, item_metric, owner = todo.pop() if key in graph.links: continue output = self._outputs_of(art, events) - links = MetricLinks(item_metric) + links = MetricLinks(item_metric, card=owner) for item in item_metric.get("inputs") or []: if not isinstance(item, dict): continue @@ -283,15 +297,24 @@ class _Store: copied = card_input(item, output) if copied is not None: upstream: list[Any] = [] + # 转抄的是哪张卡:按读到的产出上记着的指标集认(经数据整形赋给变量的也认得出),认不出的按取值链上的节点 + owner = copied.node_id if copied.card is not None: up_card = str(copied.card.get("artifact") or "") + owner = self._owner(up_card) or copied.node_id for index in copied.picked: up_metric = copied.card["metrics"][index] if isinstance(up_metric, dict) and up_metric.get("inputs"): up = (up_card or ("node", copied.node_id, id(copied.card)), index) upstream.append(up) - todo.append((up, up_card, up_metric)) - links.copies.append(CopyEdge(path, tuple(upstream), copied.whole, copied.unreadable)) + todo.append((up, up_card, up_metric, owner)) + for run_art in self._executions(owner): + content = self.content(run_art) + metrics = content.get("metrics") if isinstance(content, dict) else None + for index, up_metric in enumerate(metrics if isinstance(metrics, list) else []): + if isinstance(up_metric, dict) and up_metric.get("inputs"): + todo.append(((run_art, index), run_art, up_metric, owner)) + links.copies.append(CopyEdge(path, tuple(upstream), copied.whole, copied.unreadable, card=owner)) continue kind = self._input_kind(item, output, sure=sure) if kind is not None: @@ -300,6 +323,32 @@ class _Store: fresh.append(key) return fresh + def _executions(self, node_id: str) -> list[str]: + """口径卡 node_id 在封存范围内每一次执行的指标集工件(node.finished 台账里的 metric_set 条目),按先后。转抄的保守 + 规则按整张卡、每一次执行认(recompute.CopyEdge.card)。按解析出来的内容认、不看哈希(同 card_masked):被改过的文件 + 只会多认出不给的指标;读到的那一次产出读不出来另有 CardInput.unreadable 兜着。""" + self._index_runs() + return (self._runs or {}).get(str(node_id or ""), []) + + def _owner(self, card: str) -> str | None: + """指标集工件 card 是哪张口径卡(节点 id)的产出,按封存范围内的台账认;认不出的是 None。""" + self._index_runs() + return self._owners.get(card) + + def _index_runs(self) -> None: + if self._runs is not None: + return + runs: dict[str, list[str]] = {} + for _, etype, node_id, data in self._events: + if etype != EventType.NODE_FINISHED or not node_id or not isinstance(data, dict): + continue + for entry in data.get("evidence") or []: + if isinstance(entry, dict) and entry.get("kind") == "metric_set" \ + and isinstance(entry.get("artifact"), str) and entry["artifact"]: + runs.setdefault(str(node_id), []).append(entry["artifact"]) + self._owners.setdefault(entry["artifact"], str(node_id)) + self._runs = {node_id: list(dict.fromkeys(found)) for node_id, found in runs.items()} + def _outputs_of(self, card: str, events: Sequence[tuple[int, str, str | None, Any]]) -> Callable[[Any], Any]: """口径卡 card 那一次执行之前每个节点的产出(_card_outputs):节点 id → 读出来的内容,读不出来、和 id 对不上的是 None。同一张卡只找一次。""" diff --git a/backend/app/bundle/verifier.js b/backend/app/bundle/verifier.js index a17fea5e..376c8e1e 100644 --- a/backend/app/bundle/verifier.js +++ b/backend/app/bundle/verifier.js @@ -13,9 +13,10 @@ * render_number / render_cell:千分位、小数位、单位、万 / 亿换算、百分数,文字压成一行)把那个值渲染出来的字, * 两边都只去掉首尾空白。本页渲染不出来的写法判无法核对,不判通过。运行输入不随文件附带,照旧无法核对,但显示的字 * 照样拿引用的值核对,对不上判不通过。核对通过的字要原样显示在正文里(checkLayout):正文里根本不显示的判不通过, - * 紧挨着写着数字、小数点、负号(读者看到的是另一个数)的判不通过;画着删除线、后面接着量级单位、紧挨着像负号的短横、 - * 长得像数字的字母、显示成什么说不准的字,或者同一句里有改变文字方向的字,读起来可能不是这个值的判无法核对;列表 - * 缩进有上限、表格只排有格的列,伪造的缩进、列号挤不走核对过的数; + * 紧挨着写着数字、小数点、负号(读者看到的是另一个数)的判不通过;画着删除线、后面接着量级单位(含 bn、billion + * 这类英文写法)或乘号乘方再接数字、紧挨着像负号的短横(含 en dash)、长得像数字的字母、显示成什么说不准的字、 + * 常见写法名单以外的字,或者同一句里有改变文字方向的字,读起来可能不是这个值的判无法核对;列表缩进有上限、表格只排 + * 有格的列,伪造的缩进、列号挤不走核对过的数; * ⑥ 运行信息:运行结果、运行类别、出具档位拿封存范围内已核对的事件对照。工作流名、版本、起止时间、节点名称 * 绑不进封存,页面上写明它们取自运行记录。 * 每项给出通过 / 不通过 / 无法核对和原因。服务端导出时不会出现的状态(被引用的工件不在清单里、检索快照这类工件标着 @@ -193,6 +194,7 @@ shownTurned: '这一句里有从右往左书写的文字或改变文字方向的控制字符,显示出来的顺序可能和核对过的不一样', shownStruck: '这个数画着删除线,或者紧挨着画了删除线的文字,读的人可能以为它已作废、以旁边的数为准', shownScaled: '后面接着量级单位(万、亿、千、百、%、‰、k、M、B 这类)。系统显示这个数时不带它,读起来的数可能差了量级', + shownTimes: '后面紧接着乘号或乘方和数字(×10⁴、*10^4 这类),读起来的数可能差了量级', shownDash: '前面紧挨着一道像负号的短横,读起来可能是负数', shownLookalike: '紧挨着长得像数字的字母或符号(l、I、O、上标数字、圈码这类),读起来可能多出一位', shownOdd: '紧挨着这个数的字不在常见写法里,无法确认读者看到的数', @@ -842,15 +844,17 @@ // 紧挨着核对通过的数字、取值的字,按码点分几类(kindOf): // - digit:数字。Python 的 \d 认的全都算(全角的、数学字母区的、阿拉伯文的也是); // - minus:负号。只认真当负号用的三个:半角的连字符减号、数学减号「−」、全角的「-」; - // - dash:长得像负号、平时却不当负号用的短横:连字符、不断行连字符、数字宽的横线、小号的连字符减号、上下标负号、修饰 - // 字母负号、粗减号、别的文字里的连字符。不判不通过:紧挨着数字开头、前面又不是字母数字时,读起来可能是负数,判无法 - // 核对。破折号(——、—、–、―,小号的)、波浪线、汉字「一」、假名长音、制表符的横线不在这里,是正文里的普通写法 - // (「运费统一10元」「合计——7,036.50元」),在常见写法的名单里(COMMON); + // - dash:长得像负号、平时却不当负号用的短横:连字符、不断行连字符、数字宽的横线、en dash(「–」,最常见的负号替身, + // 页面上和「-」几乎一样)、小号的连字符减号、上下标负号、修饰字母负号、粗减号、别的文字里的连字符。不判不通过:紧挨着 + // 数字开头、前面又不是字母数字时,读起来可能是负数,判无法核对;前面是数字的是区间(「2025–2026」)。破折号(——、—、 + // ―,小号的)、波浪线、汉字「一」、假名长音、制表符的横线不在这里,是正文里的普通写法(「运费统一10元」「合计——7,036.50元」), + // 在常见写法的名单里(COMMON); // - sep:半角逗号、句点和长得一样的窄标点(低位单引号、单点前导符、小号的逗号句点这类,取自易混字符表):「1,」后面 // 接着数字也算紧挨着。全角的「,」「.」不算:字宽,中文里两个数之间本来就常用「,」隔开; // - unit:量级单位(万、亿、千、百、十、兆,繁体、大写的萬、億、拾、佰、仟,%、‰、‱,k、K、M、B,当「万」用的 w、W, // 全角写法也算):接在数字后面,读者看到的数差了量级。系统显示一个数时单位、万 / 亿换算都在核对过的那段字里,不会另接 - // 在后面,判无法核对; + // 在后面,判无法核对。英文的量级写法(T、G、m、b,bn、mn、tn,thousand、million、billion、trillion)另按紧接着的 + // 整串字母认(MAGNITUDE),「ms」「GB」这类别的单位不算; // - look:长得像数字、却不是数字的字:拉丁字母 l、I、O、o,竖线和长得像它们的字(|、丨、竖排的破折号、制表符的竖线、 // 别的文字里的 I、O,全角的也算),上下标数字、圈码、罗马数字、汉字「〇」、空心圆这类数字符号。紧挨着数字,读起来 // 可能多出一位(「l74,613.65元」),判无法核对; @@ -861,23 +865,29 @@ // 替换符,以及在 Chrome 的常用字体里量出来几乎不占宽度的几个字。各家浏览器、字体把它们显示成数字、横线还是什么都 // 不显示说不准:隔着它们照样往外找数字、负号;找不到的也判无法核对,原因另写; // - other:别的字。 - // 紧挨着数字头尾的那一个字(不越过 skip、blur)还要在常见写法的名单里(COMMON:汉字、中文标点、半角和全角空格、ASCII - // 字母和常用的半角标点、算式里的几个符号、上一轮放行的破折号写法),不在名单里的(别的文字系统的字母、制表换行和各种 - // 宽度的空格、零宽字符、全角拉丁字母、表情这类)判无法核对:伪造的写法换一个易混字、换一种空白就能绕开上面任何一条按 - // 字认的规则,名单以外的一律说不准。 + // 紧挨着数字头尾的那一个字(不越过 skip、blur)还要在常见写法的名单里(COMMON:汉字、中文标点、半角和全角空格、段内 + // 的换行(页面上显示成一个空格)、ASCII 字母和常用的半角标点、算式里的几个符号、金额前面的「¥」「¥」、上一轮放行的破折号 + // 写法),不在名单里的(别的文字系统的字母、制表符和各种宽度的空格、零宽字符、全角拉丁字母、表情、弯撇号、偏旁形的汉字 + // 这类)判无法核对:伪造的写法换一个易混字、换一种空白就能绕开上面任何一条按字认的规则,名单以外的一律说不准。 // 改变文字方向的控制字符(BIDI)和从右往左书写的文字(RTL:希伯来文、阿拉伯文这类)另算:它们能把一位数挪到数字的 // 另一边显示(逻辑上在数字后面的「5」显示在数字前面),按字的先后看不出来,同一句里出现就判无法核对 const DIGIT = unicode('^\\p{Nd}$') || /^[0-9\uff10-\uff19]$/ const MINUS = /^[-\u2212\uff0d]$/ // \p{Pd} 里去掉负号和正文里的破折号、波浪线(这几个另算),再加上码点不在 \p{Pd} 里的减号类符号 - const DASH = unicode('^(?![-\\u2013-\\u2015\\u2e3a\\u2e3b\\u301c\\u3030\\ufe31\\ufe32\\ufe58\\uff0d])' + const DASH = unicode('^(?![-\\u2014\\u2015\\u2e3a\\u2e3b\\u301c\\u3030\\ufe31\\ufe32\\ufe58\\uff0d])' + '[\\p{Pd}\\u02d7\\u207b\\u208b\\u2043\\u2796]$') - || /^[\u058a\u1400\u1806\u2010-\u2012\u2e17\u2e1a\u2e40\u30a0\ufe63\u02d7\u207b\u208b\u2043\u2796]$/ + || /^[\u058a\u1400\u1806\u2010-\u2013\u2e17\u2e1a\u2e40\u30a0\ufe63\u02d7\u207b\u208b\u2043\u2796]$/ const SEP = unicode('^[.,\\u00b8\\u201a\\u2024\\u2e12\\ua4f8\\ua4f9\\ua60e\\uabec\\ufe50\\ufe52\\u{16f53}\\u{1d16d}]$') || /^[.,\u00b8\u201a\u2024\u2e12\ua4f8\ua4f9\ua60e\uabec\ufe50\ufe52]$/ const UNIT = /^[万亿千百十兆萬億拾佰仟%\uff05\u2030\u2031kKMBwW\uff4b\uff2b\uff2d\uff22\uff57\uff37]$/ // 量级单位里本身就能接在数后面的那几个汉字:核对过的字以它们结尾(换算成万的「4.57万」),再接一个也差了量级(「4.57万亿」) const UNIT_HAN = /^[万亿千百兆萬億]$/ + // 英文的量级写法:紧接着(隔着空白、左括号也算)的整串 ASCII 字母就是它们才算(「45,678.5bn」「45,678.5 billion」), + // 单个字母只认 T、G、m、b(大小写照写),「ms」「GB」「kg」这类别的单位不算(k、K、M、B 打头的另按 unit 认,照旧) + const MAGNITUDE = /^(?:bn|mn|tn|thousands?|millions?|billions?|trillions?)$/i + const MAGNITUDE_LETTER = /^[TGmb]$/ + // 乘号、乘方:后面紧接着数字(「45,678.5×10⁴」「45,678.5*10^4」)读起来是另一个量级 + const TIMES = /^[\u00d7*^]$/ // 竖线一类:半角、全角的竖线,汉字「丨」,竖排的破折号,制表符的竖线,拉丁、西里尔、希腊字母里长得像 l、I 的;圆圈一类: // 西里尔、希腊的 O、o,空心圆 const LOOK_EXTRA = 'o\\uff4f|\\uff5c\\u4e28\\ufe31\\ufe32\\u2502\\u01c0\\u04c0\\u0406\\u0399\\u041e\\u043e\\u039f\\u03bf\\u25cb' @@ -891,14 +901,19 @@ const LEAD_IN = unicode('^[\\s\\p{Zs}(\\[{\\uff08\\uff3b\\uff5b\\u3008\\u300a\\u300c\\u300e\\u3010\\u3014\\u3016\\u3018' + '\\u301a\\u201c\\u2018]$') || /^[\s(\[{\uff08\uff3b\uff5b\u3008\u300a\u300c\u300e\u3010\u3014\u3016\u3018\u301a\u201c\u2018]$/ - // 常见写法的名单(紧挨着数字头尾的那一个字)。汉字只认表意文字(含「一」),去掉丨、丶、丿这类当笔画用的字;中文标点 - // 按全角的写;半角标点里不收撇号(有的地方拿它当千分位)、反斜杠、货币符号这类;逗号、句点、连字符另看上下文(usual)。 - // 破折号、波浪线、假名长音、制表符的横线是上一轮放行的写法 - const COMMON_REST = ' A-Za-z\\u3000\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301f\\u3030\\u30fc()\\[\\]{}:;!?"=+/~*#<>' - + '\\uff01-\\uff03\\uff08-\\uff0c\\uff0f\\uff1a-\\uff1f\\uff3b\\uff3d\\uff5b\\uff5d\\uff5e' - + '\\u2013-\\u2015\\u2018\\u2019\\u201c\\u201d\\u2026\\u2e3a\\u2e3b\\ufe58\\u2500\\u00d7\\u00f7\\u2248\\u2264\\u2265' + // 常见写法的名单(紧挨着数字头尾的那一个字)。汉字只认基本区、扩展 A 和兼容区的表意文字(含「一」),去掉丨、丶、丿这类 + // 当笔画用的字和刂、冫、氵这类偏旁形的字(刂 显示成两道竖线,紧挨着数字读起来像多了「11」;康熙部首、部首补充两个区块 + // 不是 \p{Lo},本来就不在里面,这里一并写明),扩展 B 区以后的字(𠄌、𠃑 这类笔画形的生僻字)也不收;中文标点按全角的写, + // 段内的换行在页面上显示成一个空格,收;半角标点里不收撇号和弯撇号(‘’,有的地方拿它们当千分位:1’234)、反斜杠, + // 货币符号只收金额前面常写的「¥」「¥」;逗号、句点、连字符另看上下文(usual)。破折号、波浪线、假名长音、制表符的横线 + // 是上一轮放行的写法 + const COMMON_REST = ' \\nA-Za-z\\u3000\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301f\\u3030\\u30fc()\\[\\]{}:;!?"=+/~*#<>' + + '\\uff01-\\uff03\\uff08-\\uff0c\\uff0f\\uff1a-\\uff1f\\uff3b\\uff3d\\uff5b\\uff5d\\uff5e\\u00a5\\uffe5' + + '\\u2013-\\u2015\\u201c\\u201d\\u2026\\u2e3a\\u2e3b\\ufe58\\u2500\\u00d7\\u00f7\\u2248\\u2264\\u2265' const STROKES = '\\u4e28\\u4e36\\u4e3f\\u4e40\\u4e41\\u4e5a\\u4e5b\\u4e85' - const COMMON = unicode(`^(?:(?![${STROKES}])(?=\\p{Script=Han})\\p{Lo}|[${COMMON_REST}])$`) + + '\\u5202\\u51ab\\u6c35\\u4ebb\\u961d\\u6274\\u5fc4\\u72ad\\u793b\\u8864\\u8ba0\\u9485\\u9963\\u7e9f\\u4e2c' + + '\\u2e80-\\u2eff\\u2f00-\\u2fdf' + const COMMON = unicode(`^(?:(?![${STROKES}\\u{20000}-\\u{3ffff}])(?=\\p{Script=Han})\\p{Lo}|[${COMMON_REST}])$`) || new RegExp(`^(?:(?![${STROKES}])[\\u3400-\\u4dbf\\u4e00-\\u9fff\\uf900-\\ufaff]|[${COMMON_REST}])$`) // 变体选择符只换前一个字的字形(文字样式还是表情样式),算 skip const VARIATION = unicode('^[\\u180b-\\u180d\\u180f\\ufe00-\\ufe0f\\u{e0100}-\\u{e01ef}]$') @@ -939,10 +954,12 @@ * 服务端组装的文档不这样排:两个数之间补空格(evidence._glue),写作者自己写在引用前面的字(「统一」「——」「SKU-」) * 都不在这几样里,原样导出照样通过。两个数之间的连字符是区间,不算负号; * - 这一句里有改变文字方向的字;核对过的字画着删除线,或者紧挨着画了删除线的字;后面接着量级单位(中间隔着空白、左括号 - * 也算);前面紧挨着像负号的短横;紧挨着长得像数字的字母、数字符号;紧挨着显示成什么说不准的字;紧挨着数字头尾的那一个 - * 字不在常见写法的名单里(COMMON,白名单:换一个易混字、换一种空白就能绕开按字认的规则,名单以外的一律说不准):读起来 - * 可能不是核对过的那个数,判无法核对,原因各自写明——真报告里也可能有,不能说成被改过。总览里有一项无法核对就不是绿色的 - * 通过(overallOf),下面写明去系统里核对封存。这几样不会把上一条的不通过降成无法核对。 + * 也算,英文的 T、bn、billion 这类按整串字母认);后面紧接着乘号、乘方再接数字(×10⁴、*10^4);前面紧挨着像负号的短横 + * (en dash 也算);紧挨着长得像数字的字母、数字符号;紧挨着显示成什么说不准的字;紧挨着数字头尾的那一个字不在常见写法的 + * 名单里(COMMON,白名单:换一个易混字、换一种空白就能绕开按字认的规则,名单以外的一律说不准):读起来可能不是核对过的 + * 那个数,判无法核对,原因各自写明——真报告里也可能有,不能说成被改过。总览里有一项无法核对就不是绿色的通过(overallOf), + * 下面写明去系统里核对封存。这几样不会把上一条的不通过降成无法核对。名单只是兜底:易混字、排版的花样数不完(「(单位: + * 万元)」这类隔着几个字的说明也认不出),这份文件的真伪以系统里封存的清单哈希为准 * 代码块按原文显示、不标数字,照旧 */ function checkLayout(doc, items) { @@ -1005,6 +1022,12 @@ const struck = (j) => j >= 0 && (chars[j][2] & BIT.strike) !== 0 // 前一个字算不算字母数字(只认 ASCII):负号前面是它的,是「SKU-12」这类编号的一部分 const wordy = (at) => at >= 0 && WORDY.test(chars[at][0]) + // 从 j 起紧接着的一整串 ASCII 字母是不是英文的量级写法(MAGNITUDE) + const magnitude = (j) => { + let word = '' + for (let k = j; k >= 0 && k < chars.length && /^[A-Za-z]$/.test(chars[k][0]); k++) word += chars[k][0] + return MAGNITUDE_LETTER.test(word) || MAGNITUDE.test(word) + } // 紧挨着数字头尾的那一个字(j,不越过看不见的字)在不在常见写法里。逗号、连字符另看上下文:走到这里,数字头前面的 // 连字符已是编号、区间的写法,逗号前面也不是数字(那两样判不通过);数字尾后面的是句末、区间。句点在数字头前面只认 // 前面是字母的缩写(NO.12),别的读起来像小数点 @@ -1038,10 +1061,13 @@ const exponent = tail && r1.at >= 0 && /^[eE]$/.test(chars[r1.at][0]) && (r2.kind === 'digit' || (signs(r2) && r3.kind === 'digit')) const after = tail && (r1.kind === 'digit' || (r1.kind === 'sep' && r2.kind === 'digit') || exponent) - // 后面的量级单位:中间隔着空白、左括号也算(「45,678.5 万」「45,678.5(万元)」) + // 后面的量级单位:中间隔着空白、左括号也算(「45,678.5 万」「45,678.5(万元)」「45,678.5 billion」) let ru = r1 while (ru.at >= 0 && LEAD_IN.test(chars[ru.at][0])) ru = look(ru.at, 1) - const scaled = (tail || UNIT_HAN.test(chars[last][0])) && ru.kind === 'unit' + const scaled = (tail || UNIT_HAN.test(chars[last][0])) && (ru.kind === 'unit' || magnitude(ru.at)) + // 后面紧接着乘号、乘方再接数字(「45,678.5×10⁴」读作四亿多)。后面那个数本身也核对过的是两个数相乘,不算 + const times = tail && r1.at >= 0 && TIMES.test(chars[r1.at][0]) && r2.kind === 'digit' + && !numeric(chars[r2.at][1]) const crossed = chars.slice(s0, s1 + 1).some((_, j) => struck(s0 + j)) || struck(l1.at) || struck(r1.at) const lookalike = (kinds[first] === 'digit' && l1.kind === 'look') || (tail && r1.kind === 'look') // 数字头尾紧挨着(或隔着一个逗号、句点)的是说不准的字:它本身就可能显示成数字、负号 @@ -1055,7 +1081,7 @@ // 降成无法核对 Object.assign(item, { result: FAIL, reason: T.numGlued }) } else { - const why = turned ? T.shownTurned : crossed ? T.shownStruck : scaled ? T.shownScaled + const why = turned ? T.shownTurned : crossed ? T.shownStruck : scaled ? T.shownScaled : times ? T.shownTimes : signed ? T.shownDash : lookalike ? T.shownLookalike : blurred ? T.shownBlurred : odd ? T.shownOdd : null if (why) Object.assign(item, { result: NA, reason: T.numShownUnknown(why) }) } diff --git a/backend/app/engine/recompute.py b/backend/app/engine/recompute.py index d3d008e2..78cd0e4b 100644 --- a/backend/app/engine/recompute.py +++ b/backend/app/engine/recompute.py @@ -17,8 +17,9 @@ - 遮罩列取来的输入不给值、也不拿来推演:改一个输入、排除一行,新值和原值一比就能算出遮住的那一格。vars.res.rows[0][2] 这种按位置取自查询结果的标量没有定位,顺着取值链认出是哪一列(positional_cell,证据面板的指标步骤用同一个认法); 下标不是字面量的(rows[vars.i][2])按列认,整行(rows[0])按整行的列认(wide)。 - 转抄上游口径卡的输入(nodes.<卡>.metrics[0].value、nodes.<卡>.text)按上游那几个指标认:调用方在指标依赖图上一次 - 认好(masked_closure,证据面板、写作目录、可验证报告同一个函数),交进来(Sources.copied),转抄的是取自遮罩格的指标就不给。 + 转抄上游口径卡的输入(nodes.<卡>.metrics[0].value、nodes.<卡>.text)按那张卡认:调用方在指标依赖图上一次认好 + (masked_closure,证据面板、写作目录、可验证报告同一个函数),交进来(Sources.copied),转抄的那张卡在这次运行的任何一次 + 执行里有一个指标取自遮罩格就不给。 指标本身的原值给不给(withheld_value,证据面板指标步骤的值同一个判断):用到了遮罩列的一格、一行,原值写「已遮罩」—— 指标的值可能就是那一格,输入里拿掉了、指标上照给,等于没遮;最外层的输入遮没遮核对不了,写「无法核对」。整份结果 当输入(len(vars.res.rows))、认不出出处的输入(数据整形算出来再赋给变量的一格),按值认:值里有这次运行查到过的 @@ -190,8 +191,8 @@ class _Input: traced: bool = False #: 认不出出处,值里却有这次运行查到过的遮罩值(按值认的遮罩) by_value: bool = False - #: 遮着的是一整份结果(或者值里有遮罩值的容器、整张转抄的口径卡):整个指标推演不了,可它不一定把遮罩值带进指标的值, - #: 指标的原值按值认(len(vars.res.rows) 照给) + #: 遮着的是一整份结果(或者值里有遮罩值的容器、整张转抄、读到的产出里有指标核对不了的口径卡):整个指标推演不了, + #: 可它不一定把遮罩值带进指标的值,指标的原值按值认(len(vars.res.rows) 照给) whole: bool = False #: 转抄上游口径卡(Sources.copied 里有它):给不给按依赖图认好了,不再按取值链、按值认 copy: bool = False @@ -432,13 +433,13 @@ def _restore(item: dict[str, Any], remaining: set[str], nested: set[str], store: def _copied(inp: _Input, kind: str | None, reason: str | None) -> None: - """转抄上游口径卡的输入(Sources.copied,和证据面板同一张依赖图认的):转抄的是取自遮罩格的指标,不给值、不推演 - (整张卡转抄的同整份结果,指标的原值另按值认);上游指标核对不了的,同读不出来的快照,不给值、不推演(整张卡转抄的 - 指标的原值同样另按值认);照给的照常推演。认得出出处,不再按值认:以前只按值认,转抄来的值不是够长的号码就照给、 - 还能改。""" + """转抄上游口径卡的输入(Sources.copied,和证据面板同一张依赖图认的):转抄的那张卡有指标取自遮罩格(哪种写法都一样, + masked_closure 的 CopyEdge.card),不给值、不推演,指标的原值也不给;读到的上游指标核对不了的,同读不出来的快照,不给值、 + 不推演(整张卡转抄的指标的原值另按值认);照给的照常推演。认得出出处,不再按值认:以前只按值认,转抄来的值不是够长的 + 号码就照给、还能改。""" inp.traced = inp.copy = True - if kind in ("masked", "table"): - inp.masked, inp.whole = True, kind == "table" + if kind == "masked": + inp.masked = True elif kind in ("unverified", "table_unverified"): inp.unreadable, inp.whole = True, kind == "table_unverified" inp.problem = inp.problem or reason or CARD_UNREADABLE @@ -617,7 +618,8 @@ CARD_UNREADABLE = "转抄的口径卡结果无法读取,核对不了这个值 class CardInput: """卡上的一个输入转抄了上游口径卡的产出(card_input):node_id 是那张卡的节点,card 是它当时的产出(指标集加清单 文字),picked 是这个输入带着值的那几个指标(在 card["metrics"] 里的位置)。whole:整张卡、整份指标列表、清单文字、 - 下标不是字面量的一个指标——不一定把哪个指标的值带进来,同整份查询结果(Origin.table)。 + 下标不是字面量的一个指标——说不准把哪个指标的值带进来。给不给不按 picked 细分:那张卡在这次运行的任何一次执行里有一个 + 指标不给,转抄它的输入就不给(masked_closure 的 CopyEdge.card)。 unreadable:那张卡当时的产出现在读不出来,card 为 None、picked 为空,这里写原因。卡上记着这个输入转抄来了值(不是空的), 算的时候产出是在的,现在读不出来只能是产出丢了或被改了:同按位置取的一格取值链上的产出读不出来(positional_cell 的 @@ -633,8 +635,8 @@ class CardInput: def card_input(item: dict[str, Any], output: Callable[[Any], Any]) -> CardInput | None: """卡上的一个输入是不是转抄上游口径卡的产出:nodes.<卡>.metrics[0].value、vars.<卡的 assign_to>.metrics[0].value、 nodes.<卡>.text(清单文字逐条写着「指标(名称)= 值」)、整张卡。是的话交回那张卡和带着值的那几个指标,值给不给按 - 那几个指标认(masked_closure:证据面板、写作目录、推演、可验证报告同一个判断):上游的指标取自遮罩格,转抄它的这个 - 指标同样取自遮罩格。 + 那张卡认(masked_closure:证据面板、写作目录、推演、可验证报告同一个判断):那张卡在这次运行里有一个指标取自遮罩格, + 转抄它的这个指标同样不给。 output 同 input_origin:节点 id → 那个节点当时的产出;nodes.X 是 X 的产出,vars.X 是写它的节点(输入记着的 node_id) 的产出——口径卡的 assign_to 交给变量的就是它的产出本身。产出不是指标集的(别的节点)交回 None;卡上记着这个输入出自 @@ -679,37 +681,49 @@ def card_input(item: dict[str, Any], output: Callable[[Any], Any]) -> CardInput @dataclass(frozen=True) class CopyEdge: - """指标依赖图上的一条转抄边(masked_closure):卡上路径为 path 的输入转抄了上游 upstream 那几个指标(键由调用方定, - 和 MetricLinks 的键同一套)。whole、unreadable 同 CardInput;读不出来的 upstream 为空。""" + """指标依赖图上的一条转抄边(masked_closure):卡上路径为 path 的输入转抄了上游口径卡的产出,upstream 是它读到的那一次 + 产出里带着值的那几个指标(键由调用方定,和 MetricLinks 的键同一套)。whole、unreadable 同 CardInput;读不出来的 + upstream 为空。 + + card:转抄的那张卡(节点 id)。转抄的保守规则按整张卡认:这张卡在这次运行的任何一次执行里有一个指标不给(调用方把它每一 + 次执行的每个指标都放进图里,MetricLinks.card 记着是哪张卡),转抄出来的这个输入就不给——不管下标是不是字面量、转抄的 + 是一个指标、整张卡还是清单文字,也不管读到的是哪一次执行的产出。以前按读到的那一次产出、带着值的那几个指标细分:写作 + 目录只有运行状态里最后一次的产出,循环里抄自己上一轮的卡最后一轮没碰号码列就照给,可它转抄来的正是第一轮的号码;整张 + 卡、清单文字只按值认,由遮罩格算出来的数(年薪 = 月薪 × 12)原样照给。没给 card 的只看 upstream。""" path: str upstream: tuple[Any, ...] whole: bool unreadable: str | None = None + card: Any = None @dataclass class MetricLinks: """指标依赖图上的一个指标(masked_closure 的输入):metric 是卡上的那个指标(认表达式的最外层引用、值);direct 是 转抄以外的输入里不给值的,路径 → (种类, 遮罩列),种类同 api/evidence.py 的 _Held(masked、table、unverified、value); - uncertain:有认不出出处、指标的值要按值认的输入;copies:转抄上游口径卡的输入。""" + uncertain:有认不出出处、指标的值要按值认的输入;copies:转抄上游口径卡的输入;card:这个指标所在的口径卡(节点 id), + 转抄这张卡的边按它认(CopyEdge.card)。""" metric: dict[str, Any] direct: dict[str, tuple[str, tuple[str, ...]]] = field(default_factory=dict) uncertain: bool = False copies: list[CopyEdge] = field(default_factory=list) + card: Any = None @dataclass(frozen=True) class Judged: """masked_closure 认出来的一个指标:word 是指标的值给不给(None 照给,masked 不给,unverified 核对不了,同 - withheld_value);copied 是每个转抄的输入:路径 → (种类, 遮罩列, 原因),种类 None 照给,masked、unverified 同直接的 - 输入,table 是整张卡转抄、上游有指标不给(同整份查询结果:指标的值另按值认),table_unverified 是整张卡转抄、上游有 - 指标核对不了,原因只在上游产出读不出来时有;columns 是让它不给的遮罩列,转抄它的输入上写这几列。""" + withheld_value);copied 是每个转抄的输入:路径 → (种类, 遮罩列, 原因),种类 None 照给,masked 是转抄的那张卡有指标 + 不给(哪种写法都一样),unverified 是读到的那几个指标核对不了,table_unverified 是整张卡转抄、读到的那次产出里有指标 + 核对不了(同整份查询结果:指标的值另按值认),原因只在上游产出读不出来时有;columns 是让它不给的遮罩列,转抄它的输入上 + 写这几列;card 同 MetricLinks.card,之后再认的指标转抄这张卡时按它算进去。""" word: str | None copied: Mapping[str, tuple[str | None, tuple[str, ...], str | None]] = field(default_factory=dict) columns: tuple[str, ...] = () + card: Any = None #: 指标的值给不给,从松到严:照给、核对不了、不给 @@ -721,25 +735,37 @@ def masked_closure(links: Mapping[Any, MetricLinks], known: Mapping[Any, Judged] """转抄上游口径卡的指标值给不给:在指标依赖图上一次算出的最小不动点。证据面板、写作目录、推演、可验证报告都按这一个 函数认(各自按自己的口径认好转抄以外的输入,见 MetricLinks.direct),不各写一套。 - 先按转抄以外的输入认每个指标(取自遮罩格的、核对不了的),再沿转抄的边往下游传:上游有一个指标不给,转抄它的输入就是 - masked(整张卡、清单文字、整份指标列表、下标不是字面量的是 table,指标的值另按值认);上游只是核对不了的,转抄它的 - 输入核对不了。一直传到不再变化。环(循环里一张卡抄自己上一轮的产出、几张卡互相转抄)本身不带来遮罩:从「都照给」 - 起往上收,环上没有哪个指标别的输入取自遮罩格,整个环照给;有一个取自遮罩格,整个环都不给。以前逐个往上递归、追够 - 八层就按遮罩算:没设任何遮罩的工作流里,循环里累加上一轮结果的口径卡也成了「已遮罩」,引用它的正式运行判失败; - 每个指标的护栏 nodes.acc 选中整张卡的全部指标,递归次数随指标个数指数增长,卡住事件循环。 + 先按转抄以外的输入认每个指标(取自遮罩格的、核对不了的),再沿转抄的边往下游传,一直传到不再变化: + - 转抄的保守规则(CopyEdge.card):转抄的那张卡在这次运行的任何一次执行里有一个指标不给,转抄它的输入就是 masked, + 字面量下标、下标不是字面量、整张卡、清单文字、整份指标列表都一样,读到的那次产出读不出来的也一样。那张卡一个不给的 + 指标都没有时照常 + - 读到的那几个指标(upstream)有不给的,同样 masked;只是核对不了的,转抄它的输入核对不了(整张卡、清单文字这类是 + table_unverified,指标的值另按值认) + 环(循环里一张卡抄自己上一轮的产出、几张卡互相转抄)本身不带来遮罩:从「都照给」起往上收,环上没有哪个指标别的输入取自 + 遮罩格,整个环照给;有一个取自遮罩格,整个环都不给。以前逐个往上递归、追够八层就按遮罩算:没设任何遮罩的工作流里, + 循环里累加上一轮结果的口径卡也成了「已遮罩」,引用它的正式运行判失败。 links:这次要认的指标(键 → MetricLinks),转抄的边指到的上游要么也在里面,要么在 known 里(之前认好的,结果不再变), - 都不在的(卡上没记输入的老指标、写死的数)照给。secrets 同 withheld_value,整张卡转抄、认不出出处的输入要按值认时才取。 - 每个指标的结论只会往严里变(最多两次),每变一次只重认转抄它的那几个:总的工作量和边数成正比。""" + 都不在的(卡上没记输入的老指标、写死的数)照给;一张卡的指标可以一部分在 known 里、一部分在 links 里,按 card 合起来认。 + secrets 同 withheld_value,整份结果当输入、认不出出处的输入要按值认时才取。每个指标的结论只会往严里变(最多两次),每张卡 + 「有指标不给」只会从无到有、遮罩列只增不减,每变一次只重认转抄它的那几个:总的工作量和边数成正比。""" known = known or {} words: dict[Any, str | None] = {key: None for key in links} columns: dict[Any, tuple[str, ...]] = {key: () for key in links} below: dict[Any, set[Any]] = {} + readers: dict[Any, set[Any]] = {} for key, node in links.items(): for edge in node.copies: for up in edge.upstream: if up in links: below.setdefault(up, set()).add(key) + if edge.card is not None: + readers.setdefault(edge.card, set()).add(key) + # 被转抄的卡里有指标不给的:卡 → 让它们不给的遮罩列(没有不给的卡不在里面)。之前认好的先算进去 + cards: dict[Any, tuple[str, ...]] = {} + for found in known.values(): + if found.word == "masked" and found.card is not None and found.card in readers: + cards[found.card] = tuple(dict.fromkeys((*cards.get(found.card, ()), *found.columns))) def state(key: Any) -> tuple[str | None, tuple[str, ...]]: if key in links: @@ -755,29 +781,27 @@ def masked_closure(links: Mapping[Any, MetricLinks], known: Mapping[Any, Judged] because = [c for kind, cols in node.direct.values() if kind in ("masked", "table") for c in cols] copied: dict[str, tuple[str | None, tuple[str, ...], str | None]] = {} for edge in node.copies: - if edge.unreadable is not None: + ups = [state(up) for up in edge.upstream] + if (edge.card is not None and edge.card in cards) or any(word == "masked" for word, _ in ups): + cols = (*cards.get(edge.card, ()), *(c for word, cs in ups if word == "masked" for c in cs)) + copied[edge.path] = ("masked", tuple(dict.fromkeys(cols)), None) + elif edge.unreadable is not None: copied[edge.path] = ("table_unverified" if edge.whole else "unverified", (), edge.unreadable) + elif any(word == "unverified" for word, _ in ups): + copied[edge.path] = ("table_unverified" if edge.whole else "unverified", (), None) else: - ups = [state(up) for up in edge.upstream] - if any(word == "masked" for word, _ in ups): - cols = tuple(dict.fromkeys(c for word, cs in ups if word == "masked" for c in cs)) - copied[edge.path] = ("table" if edge.whole else "masked", cols, None) - elif any(word == "unverified" for word, _ in ups): - copied[edge.path] = ("table_unverified" if edge.whole else "unverified", (), None) - else: - copied[edge.path] = (None, (), None) + copied[edge.path] = (None, (), None) kind, cols, _ = copied[edge.path] if kind == "masked": masked.append(edge.path) + because.extend(cols) elif kind == "unverified": unverified.append(edge.path) elif kind is not None: uncertain = True - if kind in ("masked", "table"): - because.extend(cols) word = withheld_value(node.metric, node.metric.get("value"), masked=masked, unverified=unverified, uncertain=uncertain, secrets=secrets) - return Judged(word, copied, tuple(dict.fromkeys(because)) if word == "masked" else ()) + return Judged(word, copied, tuple(dict.fromkeys(because)) if word == "masked" else (), node.card) queue = list(links) waiting = set(queue) @@ -788,16 +812,24 @@ def masked_closure(links: Mapping[Any, MetricLinks], known: Mapping[Any, Judged] # 只往严里收:withheld_value 先看取自遮罩格的、再看核对不了的,上游变严时这里也不会松回去 word = got.word if _STRICTNESS[got.word] >= _STRICTNESS[words[key]] else words[key] cols = tuple(dict.fromkeys((*columns[key], *got.columns))) if word == "masked" else () - if (word, cols) != (words[key], columns[key]): - words[key], columns[key] = word, cols - for down in below.get(key, ()): - if down not in waiting: - waiting.add(down) - queue.append(down) + if (word, cols) == (words[key], columns[key]): + continue + words[key], columns[key] = word, cols + downs = set(below.get(key, ())) + card = links[key].card + if word == "masked" and card is not None and card in readers: + merged = tuple(dict.fromkeys((*cards.get(card, ()), *cols))) + if card not in cards or cards[card] != merged: + cards[card] = merged + downs |= readers[card] + for down in downs: + if down not in waiting: + waiting.add(down) + queue.append(down) out: dict[Any, Judged] = {} for key in links: got = judge(key) - out[key] = Judged(words[key], got.copied, columns[key]) + out[key] = Judged(words[key], got.copied, columns[key], links[key].card) return out diff --git a/backend/tests/bundle_samples.py b/backend/tests/bundle_samples.py index cbc10cd0..f1a5d698 100644 --- a/backend/tests/bundle_samples.py +++ b/backend/tests/bundle_samples.py @@ -102,10 +102,11 @@ FORMATS = ("## 经营月报\n\n本月销售额 [[m:gmv]](约 [[m:gmv|万]]) "[[v:Q1.r0.region]]流水 [[v:Q1.r0.gmv]](约 [[v:Q1.r0.gmv|万]]),[[v:Q1.r1.region]]冲减 [[v:Q1.r1.gmv]]。" "最大一单的订单号 [[v:Q1.r0.order_no]],付款时间 [[v:Q1.r0.paid_at]]。[[see:Q1]]") #: 经营月报的另一种写法:写作者自己写在引用旁边的普通文字——「统一」后面紧跟数(汉字「一」不是负号)、破折号(——、—、 -#: –、―,小号的)后面紧跟数、编号「SKU-」「A-」后面紧跟数(连字符前面是字母,是编号的一部分)、「共…家」、全角括号、 -#: 「NO.」后面跟数、假名长音和制表符横线、粗体斜体包着的数。原样导出要全部通过、总览是绿的 -PROSE = ("## 正文\n\n全场运费统一[[m:orders]],消费合计——[[m:gmv]],退款—[[m:refund]],转化率–[[m:conv_rate]]," - "环比―[[m:growth]],客单价\ufe58[[m:avg]]。\n\n" +#: ―,小号的)后面紧跟数、段内软换行紧挨着数(页面上显示成一个空格)、金额前面的「¥」「¥」、编号「SKU-」「A-」后面紧跟数 +#: (连字符前面是字母,是编号的一部分)、「共…家」、全角括号、「NO.」后面跟数、假名长音和制表符横线、粗体斜体包着的数。 +#: 原样导出要全部通过、总览是绿的。en dash(–)紧挨在数前面读起来像负号,判无法核对,不在这里 +PROSE = ("## 正文\n\n全场运费统一[[m:orders]],消费合计——[[m:gmv]],退款—[[m:refund]],转化率\n[[m:conv_rate]]," + "环比―[[m:growth]],客单价\ufe58[[m:avg]],折合\uffe5[[m:avg]]、\u00a5[[m:avg|int]]。\n\n" "最大一单 SKU-[[v:Q1.r0.order_no]],编号A-[[m:orders]],共[[m:orders]]家,线上占比([[m:share|pct]])," "排名NO.[[m:orders]],出口额ー[[m:export]],年度─[[m:annual|亿]],**[[m:gmv]]**,*[[v:Q1.r0.gmv]]*。") #: 会员周报:Q3 是会员按地区汇总(没碰遮罩列),Q2 是选出了号码的会员消费 diff --git a/backend/tests/test_bundle_shown.py b/backend/tests/test_bundle_shown.py index 551e4a7a..af720153 100644 --- a/backend/tests/test_bundle_shown.py +++ b/backend/tests/test_bundle_shown.py @@ -850,6 +850,56 @@ def test_a_character_outside_the_common_writing_next_to_a_value_is_not_green(ref assert got["overall"]["result"] == ("fail" if result == "fail" else "partial"), got["overall"] +#: 后面紧接着乘号、乘方再接数字(×10⁴、*10^4) +TIMES = UNSURE + "后面紧接着乘号或乘方和数字(×10⁴、*10^4 这类),读起来的数可能差了量级" +#: 偏旁、部首形的汉字(刂冫氵亻阝扌忄犭礻衤讠钅饣纟丬):刂 显示成两道竖线,读起来像「11」 +RADICALS = "\u5202\u51ab\u6c35\u4ebb\u961d\u6274\u5fc4\u72ad\u793b\u8864\u8ba0\u9485\u9963\u7e9f\u4e2c" + + +@pytest.mark.parametrize("ref, change, reason", [ + # 弯撇号当千分位补一位数:1’74,613.65元 读作 174,613.65元(半角撇号本来就判无法核对) + ("m:gmv", _glue_before("s3", "1\u2019"), ODD), + ("m:gmv", _glue_before("s3", "1\u2018"), ODD), + ("v:Q1.r0.gmv", _glue_after("s34", "\u20195"), ODD), + # 偏旁形的汉字、康熙部首、部首补充、扩展 B 区里像竖线的字:前面补一个,读起来多出一两位 + *[("m:gmv", _glue_before("s3", c), ODD) for c in RADICALS], + *[("m:gmv", _glue_before("s3", chr(cp)), ODD) for cp in (0x2F01, 0x2F11, 0x2E88, 0x2E89, 0x2010C, 0x200D1)], + ("v:Q1.r0.gmv", _glue_after("s34", "\u51ab"), ODD), + # 乘号、乘方再接数字:45,678.5×10⁴ 读作四亿多 + *[("v:Q1.r0.gmv", _glue_after("s34", t), TIMES) for t in ("\u00d710\u2074", "*10^4", "^2", "\u00d710")], + # 英文的量级写法:紧接着或隔着空白、左括号 + *[("v:Q1.r0.gmv", _glue_after("s34", t), SCALED) + for t in ("T", "G", "m", "b", "bn", "Bn", "mn", "tn", " billion", " Billion", " million", " thousand", + " trillion", "(bn)")], + # en dash 紧挨在数字前面:转化率–2.35% 读作负数(前面是数字的区间见下面照常通过的一条) + ("m:conv_rate", lambda doc: by_id(doc, "s12").update(text="转化率\u2013"), DASHED), + ("m:conv_rate", _glue_before("s12", "\u2013"), DASHED), +]) +def test_lookalikes_named_by_the_third_review_are_not_green(ref, change, reason): + """复核第 3 轮点名的几类:弯撇号(U+2018、U+2019)紧挨着数字、偏旁形的汉字(刂、冫、氵这类,康熙部首、部首补充两个区块, + 扩展 B 区里像竖线的字)、后面紧接着乘号或乘方再接数字、后面接着英文的量级写法(T、G、bn、m、b、billion、million、 + thousand 这类,隔着空白也算)、en dash 紧挨在数字前面。只改相邻的普通文字、重算全部哈希,以前都是绿色的「全部通过」、 + 提示也不显示;现在判无法核对、写明原因,总览中性。""" + got = _only(ref, change, "na", reason) + assert got["overall"]["result"] == "partial", got["overall"] + + +def test_soft_breaks_currency_signs_formulas_and_ranges_still_pass(): + """常见的正常写法照常通过、总览全绿:段内软换行紧挨着数字(页面上显示成一个空格)、数字前面的「¥」「¥」、两个核对过的数 + 相乘(乘号后面紧跟的是另一个核对过的数)、en dash 连着的区间(前面是数)、数字后面跟着 ms、GB 这类不是量级的单位。""" + from tests.bundle_samples import formats_bundle + + text = ("## 写法\n\n本月销售额\n[[m:gmv]],客单价 \uffe5[[m:avg]],取整 \u00a5[[m:avg|int]]," + "流水乘订单号 [[v:Q1.r0.gmv]]\u00d7[[v:Q1.r0.order_no]]、[[v:Q1.r0.gmv]]*[[v:Q1.r0.order_no]]," + "订单 [[m:orders]],区间 [[v:Q1.r1.gmv]]\u2013[[v:Q1.r0.gmv]],耗时 [[v:Q1.r0.gmv]] ms、" + "容量 [[v:Q1.r0.gmv]]GB。") + got = verdicts(formats_bundle(text=text)) + assert len(got["numbers"]) == 12, got["numbers"] + assert all(n["result"] == "pass" and n["onPage"] == n["text"] for n in got["numbers"]), \ + [n for n in got["numbers"] if n["result"] != "pass"] + assert got["overall"]["result"] == "pass", got["overall"] + + def test_common_punctuation_next_to_checked_values_still_passes(): """常见的写法照常通过:等号、半角括号和冒号、加号、斜杠、百分比前面的加号、半角逗号和句点结句、约等号和乘号、编号后面的 句点(NO.)、全角的冒号括号顿号。""" @@ -866,13 +916,14 @@ def test_common_punctuation_next_to_checked_values_still_passes(): def test_ordinary_writing_next_to_checked_values_still_passes_as_exported(): - """正文里的普通写法照常通过,原样导出总览全绿:「统一」后面紧跟数(汉字「一」不是负号)、破折号(——、—、–、―, - 小号的)后面紧跟数、编号「SKU-」「A-」后面紧跟数(连字符前面是字母,是编号的一部分)、「共…家」、全角括号、区间、 - 「NO.」后面跟数、数后面跟「元」「单」这类单位以外的字、假名长音和制表符横线、粗体和斜体包着的数。""" + """正文里的普通写法照常通过,原样导出总览全绿:「统一」后面紧跟数(汉字「一」不是负号)、破折号(——、—、―,小号的) + 后面紧跟数、段内软换行紧挨着数、金额前面的「¥」「¥」、编号「SKU-」「A-」后面紧跟数(连字符前面是字母,是编号的一部分)、 + 「共…家」、全角括号、区间、「NO.」后面跟数、数后面跟「元」「单」这类单位以外的字、假名长音和制表符横线、粗体和斜体包着 + 的数。""" from tests.bundle_samples import PROSE, formats_bundle got = verdicts(formats_bundle(text=PROSE)) - assert len(got["numbers"]) == 15, got["numbers"] + assert len(got["numbers"]) == 17, got["numbers"] assert all(n["result"] == "pass" and n["onPage"] == n["text"] for n in got["numbers"]), \ [n for n in got["numbers"] if n["result"] != "pass"] assert got["overall"] == {"result": "pass", "text": "全部通过", "pass": got["overall"]["pass"], "fail": 0, "na": 0} diff --git a/backend/tests/test_report_masked_card_copies.py b/backend/tests/test_report_masked_card_copies.py index 5d5c1b23..c99e82d2 100644 --- a/backend/tests/test_report_masked_card_copies.py +++ b/backend/tests/test_report_masked_card_copies.py @@ -4,10 +4,11 @@ nodes.card.text(清单文字逐条写着「指标(名称)= 值」),取值链认不出出处(recompute.input_origin 只认查询结果),只按出处认 时直接照给:写作目录写着号码,文档的证据目录里值、渲染、标签都是号码,可验证报告里报告文档和卡 2 的节点完成事件都带着号码。 -现在转抄上游口径卡的输入按上游那几个指标认(recompute.card_input 认出转抄了哪张卡的哪几个指标,recompute.masked_closure -在指标依赖图上一次认,api/evidence.py 的 _CopyGraph、bundle/build.py 的 _Store.metric_word 各自按自己的口径认好转抄以外的 -输入交进去):上游的指标取自遮罩格,转抄它的这个指标同样写「已遮罩」;整张卡、清单文字同整份查询结果,值里有遮罩值才不给 -(数一数有几个指标的照给)。写作目录、报告自查、可验证报告同一个判断。 +现在转抄上游口径卡的输入按转抄的那张卡认(recompute.card_input 认出转抄了哪张卡,recompute.masked_closure 在指标依赖图上 +一次认,api/evidence.py 的 _CopyGraph、bundle/build.py 的 _Store.metric_word 各自按自己的口径认好转抄以外的输入交进去):那张 +卡在这次运行里有一个指标取自遮罩格,转抄它的指标就写「已遮罩」,转抄的是号码、客户数还是整张清单、数指标个数都一样(转抄的 +保守规则,复核第 3 轮:只按值认的写法漏过了由遮罩格算出来的数,见 test_report_masked_copy_any_run)。那张卡上没有取自遮罩格的 +指标时照常。写作目录、报告自查、可验证报告同一个判断。 真跑的部分用虚构的 SQLite 会员库(号码是编的),写作者是 MockChatModel 照剧本写。 """ @@ -39,7 +40,7 @@ CARD = [ {"id": "phone_raw", "name": "首位客户手机号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'phone')"}, {"id": "n_cust", "name": "客户数", "unit": "位", "format": "thousands", "expression": "len(vars.cust.rows)"}, ] -#: 卡 2:转抄卡 1 的几种写法;后两个只转抄客户数、数指标个数,值里没有号码 +#: 卡 2:转抄卡 1 的几种写法;后两个只转抄客户数、数指标个数,值里没有号码,可卡 1 上有取自号码列的指标,照样不给 COPIES = [ {"id": "p_nodes", "name": "转抄手机号", "format": "plain", "expression": "nodes.card.metrics[0].value"}, {"id": "p_vars", "name": "按变量转抄手机号", "format": "plain", "expression": "vars.kpi.metrics[0].value"}, @@ -48,8 +49,9 @@ COPIES = [ {"id": "n_metrics", "name": "卡 1 的指标个数", "unit": "个", "format": "thousands", "expression": "len(nodes.card.metrics)"}, ] -WITHHELD = ("m:p_nodes", "m:p_vars", "m:p_text") -CLEAN = "共有 [[m:n_copy]] 客户,首张口径卡记了 [[m:n_metrics]] 指标。" +WITHHELD = ("m:p_nodes", "m:p_vars", "m:p_text", "m:n_copy", "m:n_metrics") +#: 卡 1 自己的客户数照给、照常引用 +CLEAN = "共有 [[m:n_cust]] 客户。" @pytest.fixture @@ -80,21 +82,21 @@ def graph(copies: list[dict] | None = None, card: list[dict] | None = None, **wr async def test_the_writer_and_the_doc_see_masked_for_copied_masked_metrics(monkeypatch, vip): - """写作目录:转抄号码的三种写法都写「已遮罩」并说不要引用,转抄客户数、数指标个数的照给;整段写作目录里没有号码。文档的 - 证据目录同样写「已遮罩」,整份文档没有号码。""" + """写作目录:转抄卡 1 的五种写法(转抄号码、清单文字,也包括只转抄客户数、数指标个数的)都写「已遮罩」并说不要引用——卡 1 + 上有取自号码列的指标;卡 1 自己的客户数照给。整段写作目录里没有号码。文档的证据目录同样写「已遮罩」,整份文档没有号码。""" seen = script(monkeypatch, CLEAN) row = await finish(graph()) assert row.status == "succeeded", row.error lines = metric_lines(seen[0]) - for name in ("转抄手机号", "按变量转抄手机号", "转抄清单"): + for name in ("转抄手机号", "按变量转抄手机号", "转抄清单", "转抄客户数", "卡 1 的指标个数"): assert f"{name} = 已遮罩(取自设置了遮罩的列,不要引用)" in lines, lines - assert "转抄客户数 = 3位" in lines and "卡 1 的指标个数 = 2个" in lines, lines + assert "客户数 = 3位" in lines, lines assert leaks(lines) == [], lines doc = await doc_of(row.id) for alias in WITHHELD: entry = doc["catalog"][alias] assert (entry["value"], entry["rendered"], entry.get("masked")) == ("已遮罩", "已遮罩", True), entry - assert "masked" not in doc["catalog"]["m:n_copy"] and "masked" not in doc["catalog"]["m:n_metrics"] + assert "masked" not in doc["catalog"]["m:n_cust"] assert leaks(doc) == [] [checked] = [e.data for e in await events(row.id) if e.type == "report.checked"] assert checked["ok"] is True, checked @@ -113,8 +115,8 @@ async def test_citing_a_copied_masked_metric_is_a_masked_cell_violation(monkeypa async def test_the_bundle_carries_no_copied_number(client, monkeypatch, vip): """可验证报告:卡 2 只给 id、它的节点完成事件只给哈希,报告文档照常附带(目录里写的是「已遮罩」),整个文件没有号码; - 证据图的标签同样写「已遮罩」。""" - script(monkeypatch, CLEAN) + 证据图的标签同样写「已遮罩」(写作者坚持引用转抄来的客户数、标注照常产出),卡 1 自己的客户数照给。""" + script(monkeypatch, "共有 [[m:n_cust]] 客户,转抄的客户数 [[m:n_copy]]。") row = await finish(graph()) assert row.status == "succeeded", row.error resp = await client.get(f"/api/runs/{row.id}/bundle.html") @@ -128,7 +130,7 @@ async def test_the_bundle_carries_no_copied_number(client, monkeypatch, vip): assert cards["card2"].get("masked") is True and "b64" not in cards["card2"], cards body = (await client.get(f"/api/runs/{row.id}/evidence")).json() labels = {e["alias"]: e["label"] for e in body["evidence"] if e["kind"] == "metric"} - assert labels["m:n_copy"] == "转抄客户数 = 3位", labels + assert labels["m:n_cust"] == "客户数 = 3位" and labels["m:n_copy"] == "转抄客户数 = 已遮罩", labels assert leaks(body) == [], [e for e in body["evidence"] if leaks(e)] diff --git a/backend/tests/test_report_masked_copy_any_run.py b/backend/tests/test_report_masked_copy_any_run.py new file mode 100644 index 00000000..f76751e7 --- /dev/null +++ b/backend/tests/test_report_masked_copy_any_run.py @@ -0,0 +1,472 @@ +"""转抄上游口径卡的保守规则:上游那张卡在这次运行的任何一次执行里有一个指标取自遮罩格,转抄出来的指标就不给值。 + +复核第 3 轮(91aa34d)找到两处: +- 循环里卡转抄自己上一轮(nodes.acc.metrics[0].value if nodes.acc else cell(nodes.q, 0, 'v')),SQL 带模板,第一轮取号码、 + 第二轮取姓名。写作目录(withheld_metrics)只有运行状态里最后一次的产出,自引用在依赖图上成环,环上最后一轮没有直接取自 + 遮罩格的输入,照给:完整号码进了报告正文和成果,自查通过、正式运行成功;封存之后按每次执行往回认才写「已遮罩」。 +- 整张卡、清单文字、下标不是字面量的转抄(nodes.card.text、nodes.card.metrics[vars.idx].value)只按值认:上游由遮罩格算出来 + 的指标值(年薪 = 月薪 × 12)不会原样出现在查询结果里,写作目录、报告、成果、证据面板、可验证报告都带出来。 + +现在不再按「转抄的是哪一个指标、读到的是哪一次产出」细分:卡上的输入转抄上游口径卡(字面量下标、下标不是字面量、整张卡、 +清单文字、整份指标列表都算),只要那张卡在这次运行的任何一次执行里(按台账里每一次执行的指标集认,不只看最后一次)有一个 +指标不给,转抄出来的这个输入就不给(recompute.CopyEdge.card)。上游卡一个不给的指标都没有时照常:没设遮罩的工作流、循环 +里累加自己上一轮的卡照给。写作目录、报告自查、证据面板、推演、可验证报告同一个判断(recompute.masked_closure)。 + +真跑的部分用虚构的 SQLite 库(号码、月薪都是编的),写作者是 MockChatModel 照剧本写。 +""" +from __future__ import annotations + +import base64 +import json +import sqlite3 + +import pytest +from httpx import ASGITransport, AsyncClient +from sqlalchemy import select + +from app.data.engine import engines +from app.db.base import SessionLocal +from app.db.models import DataSource +from app.engine.evidence import iter_segments +from app.engine.runner import run_manager +from app.main import app +from tests.test_bundle_masked_metrics import data_of, event +from tests.test_report_masked_metrics import ( # noqa: F401 vip:号码设了遮罩的会员库 + doc_of, + events, + finish, + leaks, + metric_lines, + node, + script, + vip, +) + +MASKED_LINE = "= 已遮罩(取自设置了遮罩的列,不要引用)" + + +@pytest.fixture +async def engine_up(): + await run_manager.setup() + yield + await run_manager.shutdown() + + +@pytest.fixture +async def client(engine_up): + async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test") as c: + yield c + + +#: 虚构的员工表:月薪设了遮罩 +STAFF = [(1, "员工甲", 8123.25), (2, "员工乙", 9234.5)] +#: 首位员工的年薪(月薪 × 12):由遮罩格算出来的数,按值认不出 +ANNUAL = STAFF[0][2] * 12 + + +def annual_leaks(value) -> list[str]: + """写着首位员工年薪的地方(原样、两位小数、千分位都算)。""" + raw = value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, default=str) + flat = raw.replace(",", "") + return [n for n in (f"{ANNUAL:.1f}", f"{ANNUAL:.2f}", str(int(ANNUAL))) if n in flat] + + +@pytest.fixture +async def hr(tmp_path, engine_up): + path = tmp_path / "hr.db" + db = sqlite3.connect(path) + db.executescript("CREATE TABLE staff (id INTEGER PRIMARY KEY, name TEXT, salary REAL);") + db.executemany("INSERT INTO staff VALUES (?, ?, ?)", STAFF) + db.commit() + db.close() + async with SessionLocal() as session: + row = (await session.execute(select(DataSource).where(DataSource.name == "hr"))).scalar_one_or_none() + if row is None: + row = DataSource(name="hr", 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 = {"mask_columns": ["salary"]} + await session.commit() + source_id = row.id + await engines.invalidate(source_id) + yield path + await engines.invalidate(source_id) + + +def chain(*nodes: dict) -> dict: + return {"nodes": list(nodes), "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]} + + +async def export(client, run_id: str) -> tuple[str, dict]: + resp = await client.get(f"/api/runs/{run_id}/bundle.html") + assert resp.status_code == 200, resp.text + return resp.text, data_of(resp.text) + + +async def bundle_finds(client, run_id: str, find) -> dict: + """导出一份可验证报告:整页、每份附带的工件、带规范串的事件里 find 找得到的(事件按 序号:类型:节点 记)。""" + html, bundle = await export(client, run_id) + out: dict = {"html": find(html), "artifacts": {}, "events": {}} + for art in bundle["artifacts"]: + if "b64" in art and (found := find(base64.b64decode(art["b64"]).decode("utf-8", "replace"))): + out["artifacts"][f"{art['kind']}:{art.get('node_id')}"] = found + for item in bundle["events"]: + if "canonical" in item and (found := find(item["canonical"])): + out["events"][f"{item['seq']}:{item['type']}:{item['node_id']}"] = found + return out + + +CLEAN = {"html": [], "artifacts": {}, "events": {}} + + +# -------------------------------------------------------------------------- +# 最小不动点上的边规则(recompute.masked_closure,纯函数) +# -------------------------------------------------------------------------- + + +def _metric(expression: str, value=1.0) -> dict: + return {"id": "m", "name": "m", "value": value, "expression": expression} + + +def test_any_withheld_metric_on_the_copied_card_withholds_every_form_of_copy(): + """卡 x 跑了两次:第一次的指标取自号码列,第二次的照给。卡 y 转抄卡 x 第二次的产出,字面量下标、整张卡、清单文字、整份 + 指标列表四种写法,都不给,转抄的输入上写着让卡 x 不给的那一列。卡 z 转抄的卡 w 一个不给的指标都没有,照给;没说是哪张卡 + 的边(card 为空)照旧只看它读到的那几个指标。""" + from app.engine.recompute import CopyEdge, MetricLinks, masked_closure + + x1, x2, w1 = ("x1", 0), ("x2", 0), ("w1", 0) + links = { + x1: MetricLinks(_metric("cell(nodes.q, 0, 'v')"), direct={"cell(nodes.q, 0, 'v')": ("masked", ("v",))}, + card="x"), + x2: MetricLinks(_metric("cell(nodes.q, 0, 'v')"), card="x"), + w1: MetricLinks(_metric("cell(nodes.q, 0, 'v')"), card="w"), + } + forms = { + "nodes.x.metrics[0].value": False, "nodes.x": True, "nodes.x.text": True, "nodes.x.metrics": True, + } + for i, (path, whole) in enumerate(forms.items()): + links[("y", i)] = MetricLinks(_metric(path), copies=[CopyEdge(path, (x2,), whole, card="x")], card="y") + links[("z", 0)] = MetricLinks(_metric("nodes.w.text"), copies=[CopyEdge("nodes.w.text", (w1,), True, card="w")], + card="z") + links[("v", 0)] = MetricLinks(_metric("nodes.x.metrics[0].value"), + copies=[CopyEdge("nodes.x.metrics[0].value", (x2,), False)], card="v") + got = masked_closure(links, secrets=lambda: None) + assert (got[x1].word, got[x2].word, got[w1].word) == ("masked", None, None) + for i, path in enumerate(forms): + assert got[("y", i)].word == "masked", path + assert got[("y", i)].copied[path] == ("masked", ("v",), None), path + assert got[("y", i)].card == "y" + assert got[("z", 0)].word is None and got[("z", 0)].copied["nodes.w.text"] == (None, (), None) + assert got[("v", 0)].word is None + + +def test_a_card_copying_its_own_rounds_is_withheld_only_when_some_round_is(): + """卡 acc 跑三轮,每一轮转抄自己上一轮(字面量下标)、整张自己(护栏)。没有哪一轮取自遮罩格:照给(第 3 轮修好的那条); + 只有第一轮取自号码列:三轮都不给——第三轮读到的第二轮本身也只是转抄来的,按整张卡认,不看读到的是哪一次。""" + from app.engine.recompute import CopyEdge, MetricLinks, masked_closure + + def rounds(first_masked: bool) -> dict: + out = {} + for r in range(3): + direct = {"cell": ("masked", ("v",))} if first_masked and r == 0 else {} + prev = ((r - 1, 0),) if r else () + out[(r, 0)] = MetricLinks(_metric("nodes.acc.metrics[0].value if nodes.acc else cell"), direct=direct, + copies=[CopyEdge("nodes.acc.metrics[0].value", prev, False, card="acc"), + CopyEdge("nodes.acc", prev, True, card="acc")], card="acc") + return out + + assert {k: v.word for k, v in masked_closure(rounds(False), secrets=lambda: None).items()} == \ + {(0, 0): None, (1, 0): None, (2, 0): None} + assert {k: v.word for k, v in masked_closure(rounds(True), secrets=lambda: None).items()} == \ + {(0, 0): "masked", (1, 0): "masked", (2, 0): "masked"} + + +def test_metrics_judged_earlier_count_for_their_card(): + """之前认好的指标(known,结果不再变)照样算进它所在的卡:卡 x 有一个之前认好的不给的指标,这一次只认转抄卡 x 的 y,也不给; + 之前认好的是照给的,y 照给。""" + from app.engine.recompute import CopyEdge, Judged, MetricLinks, masked_closure + + y = ("y", 0) + links = {y: MetricLinks(_metric("nodes.x.metrics[1].value"), + copies=[CopyEdge("nodes.x.metrics[1].value", (("x", 1),), False, card="x")], card="y")} + known = {("x", 0): Judged("masked", {}, ("phone",), card="x"), ("x", 1): Judged(None, {}, (), card="x")} + got = masked_closure(links, known, secrets=lambda: None) + assert got[y].word == "masked" and got[y].copied["nodes.x.metrics[1].value"] == ("masked", ("phone",), None) + known[("x", 0)] = Judged(None, {}, (), card="x") + assert masked_closure(links, known, secrets=lambda: None)[y].word is None + + +def test_an_unreadable_copy_of_a_card_with_a_withheld_metric_is_withheld(): + """读到的那次产出读不出来(CopyEdge.unreadable),可卡 x 别的执行里有不给的指标:按整张卡认,不给(不只是核对不了)。""" + from app.engine.recompute import CopyEdge, MetricLinks, masked_closure + + why = "转抄的口径卡结果无法读取" + links = { + ("x", 0): MetricLinks(_metric("cell"), direct={"cell": ("masked", ("phone",))}, card="x"), + ("y", 0): MetricLinks(_metric("nodes.x.metrics[0].value"), + copies=[CopyEdge("nodes.x.metrics[0].value", (), False, why, card="x")], card="y"), + ("y", 1): MetricLinks(_metric("nodes.w.metrics[0].value"), + copies=[CopyEdge("nodes.w.metrics[0].value", (), False, why, card="w")], card="y"), + } + got = masked_closure(links, secrets=lambda: None) + assert got[("y", 0)].word == "masked", got[("y", 0)] + assert got[("y", 1)].word == "unverified" and got[("y", 1)].copied["nodes.w.metrics[0].value"][2] == why + + +# -------------------------------------------------------------------------- +# 写作目录:循环里转抄自己上一轮,更早一轮取过号码列 +# -------------------------------------------------------------------------- + +#: 第一轮取号码(phone AS v),之后转抄上一轮。护栏写法(nodes.acc 记成整张卡的输入)和只按字面量下标转抄的写法 +CARRY = [ + "nodes.acc.metrics[0].value if nodes.acc else cell(nodes.q, 0, 'v')", + "nodes.acc.metrics[0].value if vars.item == 'name' else cell(nodes.q, 0, 'v')", +] + + +def carry_loop(expression: str, items: str = '["phone", "name"]', *, after: list[dict] | None = None, + report: bool = True, **write) -> dict: + """入口 → 循环(foreach items:模板查询 SELECT {{ vars.item }} AS v → 卡 acc)→ 循环之后的卡(after)→ 报告 → 成果。""" + start = node("start", "input") + lp = node("lp", "loop", mode="foreach", items=items) + q = node("q", "tool", tool="db_query__vip", args={"sql": "SELECT {{ vars.item }} AS v FROM customers ORDER BY id"}) + acc = node("acc", "metrics", caliber="取值口径", caliber_version="v1", metrics=[ + {"id": "first", "name": "首位客户取值", "format": "plain", "expression": expression}]) + tail = [node(c["id"], "metrics", caliber=f"{c['id']} 口径", caliber_version="v1", metrics=c["metrics"]) + for c in after or []] + if report: + tail.append(node("write", "report", instructions="写一句", **{"on_violation": "fail", **write})) + out = node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}] if report + else [{"name": "说明", "value": "完成"}]) + edges = [{"source": "start", "target": "lp"}, {"source": "lp", "target": "q", "sourceHandle": "body"}, + {"source": "q", "target": "acc"}, {"source": "acc", "target": "lp"}] + rest = ["lp", *(n["id"] for n in tail), "out"] + edges += [{"source": a, "target": b, **({"sourceHandle": "done"} if a == "lp" else {})} + for a, b in zip(rest, rest[1:])] + return {"nodes": [start, lp, q, acc, *tail, out], "edges": edges} + + +@pytest.mark.parametrize("expression", CARRY) +async def test_a_loop_card_carrying_an_earlier_masked_round_is_withheld_when_writing(monkeypatch, vip, expression): + """复核者的探针:第一轮取号码、第二轮转抄第一轮。写作目录写「已遮罩」,引用它的正式运行判失败(masked_cell),整段写作 + 目录、报错里都没有号码。以前写作目录只看最后一次产出,写着号码,正文、成果都是号码,自查通过、运行成功。""" + seen = script(monkeypatch, "首位客户取值 [[m:first]]。") + row = await finish(carry_loop(expression)) + lines = metric_lines(seen[0]) + assert f"首位客户取值 {MASKED_LINE}" in lines and leaks(lines) == [], lines + assert row.status == "failed" and "m:first" in (row.error or "") and "遮罩" in row.error, row.error + assert leaks(row.error) == [] + [checked] = [e.data for e in await events(row.id) if e.type == "report.checked"][-1:] + assert [v["ref"] for v in checked["violations"] if v["code"] == "masked_cell"] == ["m:first"], checked + + +async def test_a_flagged_report_carrying_an_earlier_masked_round_leaks_nowhere(client, monkeypatch, vip): + """违规处置为标注:报告照常产出,可正文、文档、成果里都没有号码(写的是「已遮罩」);证据面板的标签写「已遮罩」;可验证报告 + 里没有号码,acc 每一轮的节点完成事件都只给哈希。""" + script(monkeypatch, "首位客户取值 [[m:first]]。") + row = await finish(carry_loop(CARRY[0], on_violation="flag")) + assert row.status == "succeeded", row.error + doc = await doc_of(row.id) + assert doc["catalog"]["m:first"]["masked"] is True and leaks(doc) == [], doc["catalog"]["m:first"] + assert leaks(row.output or {}) == [], row.output + body = (await client.get(f"/api/runs/{row.id}/evidence")).json() + labels = {e["alias"]: e["label"] for e in body["evidence"] if e["kind"] == "metric"} + assert labels["m:first"] == "首位客户取值 = 已遮罩", labels + assert await bundle_finds(client, row.id, leaks) == CLEAN + _, bundle = await export(client, row.id) + finished = [e for e in bundle["events"] if e["type"] == "node.finished" and e["node_id"] == "acc"] + assert len(finished) == 2 and not any("canonical" in e for e in finished), finished + + +async def test_a_loop_card_without_any_masked_round_is_shown(monkeypatch, vip): + """对照:两轮都只取姓名、编号(没碰号码列),转抄上一轮的照给,正式运行成功。""" + seen = script(monkeypatch, "首位客户取值 [[m:first]]。") + row = await finish(carry_loop(CARRY[0], items='["name", "id"]')) + assert row.status == "succeeded", row.error + assert "首位客户取值 = 客户甲" in metric_lines(seen[0]), metric_lines(seen[0]) + + +# -------------------------------------------------------------------------- +# 循环之后的卡转抄循环里的卡:最后一轮没碰号码列,更早一轮碰过 +# -------------------------------------------------------------------------- + +#: 循环之后的卡 pick 转抄 acc 最后一轮的产出(acc 每一轮只取当轮的 v,不转抄自己) +PICK = [{"id": "pick", "metrics": [{"id": "picked", "name": "转抄取值", "format": "plain", + "expression": "nodes.acc.metrics[0].value"}]}] + + +async def test_a_card_copying_the_last_round_of_a_card_that_once_took_a_masked_cell_is_withheld_everywhere( + client, monkeypatch, vip): + """acc 第一轮取号码、第二轮取姓名;循环之后的卡 pick 转抄 acc 最后一轮(姓名)。按整张卡、每一次执行认:acc 有一次执行的 + 指标取自号码列,pick 的指标就不给——写作目录写「已遮罩」、证据面板的标签写「已遮罩」、推演不给值也不让改、可验证报告里 + pick 只给 id。acc 最后一轮自己的指标(姓名)照给。四处是同一个判断。""" + seen = script(monkeypatch, "首位客户 [[m:first]]。") + row = await finish(carry_loop("cell(nodes.q, 0, 'v')", after=PICK, on_violation="flag")) + assert row.status == "succeeded", row.error + lines = metric_lines(seen[0]) + assert f"转抄取值 {MASKED_LINE}" in lines and "首位客户取值 = 客户甲" in lines, lines + body = (await client.get(f"/api/runs/{row.id}/evidence")).json() + labels = {e["alias"]: e["label"] for e in body["evidence"] if e["kind"] == "metric"} + assert labels["m:picked"] == "转抄取值 = 已遮罩" and labels["m:first"] == "首位客户取值 = 客户甲", labels + res = await client.post(f"/api/runs/{row.id}/evidence/whatif", json={"card": "pick"}) + assert res.status_code == 200, res.text + [picked] = res.json()["metrics"] + assert picked["withheld"] is True and picked["old"] == "已遮罩", picked + assert picked["inputs"][0]["editable"] is False and picked["inputs"][0]["old"] is None, picked["inputs"] + _, bundle = await export(client, row.id) + assert "canonical" not in event(bundle, "node.finished", "pick") + assert await bundle_finds(client, row.id, leaks) == CLEAN + + # 对照:两轮都没碰号码列,pick 照给、照常推演,节点完成事件带规范串 + seen = script(monkeypatch, "首位客户 [[m:first]]。") + row = await finish(carry_loop("cell(nodes.q, 0, 'v')", items='["id", "name"]', after=PICK, on_violation="flag")) + assert row.status == "succeeded", row.error + assert "转抄取值 = 客户甲" in metric_lines(seen[0]), metric_lines(seen[0]) + res = await client.post(f"/api/runs/{row.id}/evidence/whatif", json={"card": "pick"}) + [picked] = res.json()["metrics"] + assert picked.get("withheld") is not True and picked["old"] == "客户甲", picked + _, bundle = await export(client, row.id) + assert "canonical" in event(bundle, "node.finished", "pick") + + +async def test_the_bundle_alone_withholds_a_copy_of_a_card_that_once_took_a_masked_cell(client, monkeypatch, vip): + """可验证报告自己的判断(没有报告文档替它说「已遮罩」):同上的 acc、pick。没有报告节点的运行,pick 的节点完成事件只给 + 哈希,acc 第二轮(取姓名)的照常带规范串;写作前不认遮罩的老文档(这里把那一步换成什么都不认),证据目录里写着 pick 的 + 原值,文档整份只给哈希。两轮都没碰号码列的照常附带。""" + import app.api.evidence as evidence_api + + row = await finish(carry_loop("cell(nodes.q, 0, 'v')", after=PICK, report=False)) + assert row.status == "succeeded", row.error + _, bundle = await export(client, row.id) + assert "canonical" not in event(bundle, "node.finished", "pick") + acc = [e for e in bundle["events"] if e["type"] == "node.finished" and e["node_id"] == "acc"] + assert ["canonical" in e for e in acc] == [False, True], acc + + async def nothing(*_args, **_kwargs): + return [] + + monkeypatch.setattr(evidence_api, "withheld_metrics", nothing) + for items, withheld in (('["phone", "name"]', True), ('["id", "name"]', False)): + script(monkeypatch, "转抄取值 [[m:picked]]。") + row = await finish(carry_loop("cell(nodes.q, 0, 'v')", items=items, after=PICK, on_violation="flag")) + assert row.status == "succeeded", row.error + assert "masked" not in (await doc_of(row.id))["catalog"]["m:picked"], "老文档的证据目录里写着原值" + _, bundle = await export(client, row.id) + [art] = [a for a in bundle["artifacts"] if a["kind"] == "report_doc"] + assert (art.get("masked") is True and "b64" not in art) if withheld else ("b64" in art and "masked" not in art), \ + (items, art) + + +def held_graph(*, report: bool = True) -> dict: + """会员查询 → 卡 1(号码、客户编号)→ 数据整形把整张卡赋给变量 k2 → 卡 2 按变量转抄卡 1 的客户编号 → 报告 → 成果。""" + tail = [node("write", "report", instructions="写一句", on_violation="flag"), + node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}])] if report \ + else [node("out", "output", fields=[{"name": "说明", "value": "完成"}])] + return chain( + node("start", "input"), + node("q_cust", "tool", tool="db_query__vip", args={"sql": "SELECT id, name, phone FROM customers ORDER BY id"}), + node("card", "metrics", caliber="会员口径", caliber_version="v1", metrics=[ + {"id": "phone_raw", "name": "首位客户手机号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'phone')"}, + {"id": "first_id", "name": "首位客户编号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'id')"}]), + node("hold", "transform", expression="nodes.card", assign_to="k2"), + node("card2", "metrics", caliber="转抄口径", caliber_version="v1", metrics=[ + {"id": "id2", "name": "转抄编号", "format": "plain", "expression": "vars.k2.metrics[1].value"}]), + *tail, + ) + + +async def test_a_copy_through_a_variable_set_by_another_node_is_judged_on_the_card_itself(client, monkeypatch, vip): + """数据整形把整张卡赋给变量(nodes.card → vars.k2),卡 2 按变量转抄卡 1 的客户编号(没碰号码列):按卡 1 本身认(读到的 + 产出上记着的是卡 1 的指标集),卡 1 上有取自号码列的指标,写作目录、证据面板都写「已遮罩」;没有报告的运行里,可验证报告 + 同样只给卡 2 的哈希。以前按写变量的节点(数据整形)认,那个节点没有指标集,整张卡的规则落了空。""" + seen = script(monkeypatch, "转抄编号 [[m:id2]]。") + row = await finish(held_graph()) + assert row.status == "succeeded", row.error + assert f"转抄编号 {MASKED_LINE}" in metric_lines(seen[0]), metric_lines(seen[0]) + body = (await client.get(f"/api/runs/{row.id}/evidence")).json() + labels = {e["alias"]: e["label"] for e in body["evidence"] if e["kind"] == "metric"} + assert labels["m:id2"] == "转抄编号 = 已遮罩", labels + row = await finish(held_graph(report=False)) + assert row.status == "succeeded", row.error + _, bundle = await export(client, row.id) + assert "canonical" not in event(bundle, "node.finished", "card2") + + +# -------------------------------------------------------------------------- +# 整张卡、清单文字、下标不是字面量的转抄:上游的指标由遮罩格算出来 +# -------------------------------------------------------------------------- + +#: 卡 2 转抄卡 1(首位年薪 = 月薪 × 12,值按值认不出)的几种写法 +WHOLE_COPIES = [ + "nodes.card.metrics[vars.idx].value", + "nodes.card.text", + "len(nodes.card.text)", + "len(nodes.card.metrics)", + "nodes.card.metrics[0].value", +] + + +def annual_graph(expression: str, **write) -> dict: + """员工查询(选出月薪)→ 下标变量 idx = 0 → 卡 1(首位年薪)→ 卡 2(转抄卡 1)→ 报告 → 成果。""" + return chain( + node("start", "input"), + node("idx", "transform", expression="0", assign_to="idx"), + node("q", "tool", tool="db_query__hr", args={"sql": "SELECT id, name, salary FROM staff ORDER BY id"}), + node("card", "metrics", caliber="薪酬口径", caliber_version="v1", metrics=[ + {"id": "annual", "name": "首位年薪", "unit": "元", "decimals": 2, "format": "thousands", + "expression": "cell(nodes.q, 0, 'salary') * 12"}]), + node("card2", "metrics", caliber="转抄口径", caliber_version="v1", metrics=[ + {"id": "c2", "name": "抄录", "format": "plain", "expression": expression}]), + node("write", "report", instructions="写一句", **{"on_violation": "fail", **write}), + node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]), + ) + + +@pytest.mark.parametrize("expression", WHOLE_COPIES) +async def test_every_form_of_copying_a_derived_masked_metric_is_withheld_when_writing(monkeypatch, hr, expression): + """复核者的探针:卡 1 的年薪由月薪(设了遮罩)算出,卡 2 用五种写法转抄卡 1。写作目录都写「已遮罩」、整段写作目录里没有 + 年薪,引用它的正式运行判失败。以前下标不是字面量的、清单文字照给,写作目录、正文、成果都是年薪;数字数、数指标个数的 + 也照给(值是个数,可卡 2 上记着的清单文字里写着年薪)。""" + seen = script(monkeypatch, "抄录 [[m:c2]]。") + row = await finish(annual_graph(expression)) + lines = metric_lines(seen[0]) + assert f"抄录 {MASKED_LINE}" in lines and annual_leaks(lines) == [], lines + assert row.status == "failed" and "m:c2" in (row.error or "") and "遮罩" in row.error, row.error + assert annual_leaks(row.error) == [] + + +@pytest.mark.parametrize("expression", WHOLE_COPIES[:3]) +async def test_a_flagged_report_copying_a_derived_masked_metric_leaks_nowhere(client, monkeypatch, hr, expression): + """违规处置为标注:报告照常产出,文档、成果里没有年薪;证据面板的标签写「已遮罩」;可验证报告里卡 2 只给 id、它的节点完成 + 事件只给哈希,整个文件里没有年薪。以前卡 2 的指标集、报告文档、两个节点完成事件都带着年薪。""" + script(monkeypatch, "抄录 [[m:c2]]。") + row = await finish(annual_graph(expression, on_violation="flag")) + assert row.status == "succeeded", row.error + doc = await doc_of(row.id) + assert doc["catalog"]["m:c2"]["masked"] is True and annual_leaks(doc) == [], doc["catalog"]["m:c2"] + assert annual_leaks(row.output or {}) == [], row.output + body = (await client.get(f"/api/runs/{row.id}/evidence")).json() + labels = {e["alias"]: e["label"] for e in body["evidence"] if e["kind"] == "metric"} + assert labels["m:c2"] == "抄录 = 已遮罩", labels + seg = next(s for s in iter_segments(doc) if s.get("ref") == "m:c2") + chain_ = (await client.get(f"/api/runs/{row.id}/evidence/segments/{seg['id']}")).json()["chain"] + assert chain_[0]["value"] == "已遮罩" and annual_leaks(chain_) == [], chain_ + _, bundle = await export(client, row.id) + cards = {a["node_id"]: a for a in bundle["artifacts"] if a["kind"] == "metric_set"} + assert "card2" not in cards or (cards["card2"].get("masked") is True and "b64" not in cards["card2"]), cards + assert "canonical" not in event(bundle, "node.finished", "card2") + assert await bundle_finds(client, row.id, annual_leaks) == CLEAN + + +async def test_copying_a_card_whose_metrics_are_all_shown_is_unchanged(client, monkeypatch, hr): + """对照:卡 1 只有首位员工的编号(不碰月薪列),卡 2 数它的指标个数,照给、正式运行成功,可验证报告里卡 2 的节点完成事件 + 带规范串。""" + seen = script(monkeypatch, "抄录 [[m:c2]]。") + spec = annual_graph("len(nodes.card.metrics)") + spec["nodes"][3]["data"]["config"]["metrics"] = [ + {"id": "first_id", "name": "首位员工编号", "format": "plain", "expression": "cell(nodes.q, 0, 'id')"}] + row = await finish(spec) + assert row.status == "succeeded", row.error + assert "抄录 = 1" in metric_lines(seen[0]), metric_lines(seen[0]) + _, bundle = await export(client, row.id) + assert "canonical" in event(bundle, "node.finished", "card2") diff --git a/backend/tests/test_report_masked_copy_closure.py b/backend/tests/test_report_masked_copy_closure.py index 375ea6b0..6300412b 100644 --- a/backend/tests/test_report_masked_copy_closure.py +++ b/backend/tests/test_report_masked_copy_closure.py @@ -343,8 +343,8 @@ def test_a_cycle_on_its_own_brings_no_mask(): def test_one_masked_input_on_a_cycle_withholds_the_whole_cycle(): - """环上 b 另有一个输入取自遮罩格(phone):b、c 都不给,转抄它们的输入上写着 phone;只转抄 c 的整张卡、值是个数的 d - 照给(整张卡转抄同整份结果,指标的值另按值认),环外没连上的 e 照给。""" + """环上 b 另有一个输入取自遮罩格(phone):b、c 都不给,转抄它们的输入上写着 phone;转抄 c 的整份指标列表、值只是个数的 d + 同样不给(转抄的保守规则:上游有指标不给,哪种写法转抄都不给,不再按值认),环外没连上的 e 照给。""" from app.engine.recompute import CopyEdge, MetricLinks, masked_closure b, c, d, e = ("b", 0), ("c", 0), ("d", 0), ("e", 0) @@ -356,29 +356,28 @@ def test_one_masked_input_on_a_cycle_withholds_the_whole_cycle(): d: MetricLinks(_metric("len(nodes.c.metrics)", 1), copies=[CopyEdge("nodes.c.metrics", (c,), True)]), e: MetricLinks(_metric("nodes.e.metrics[0].value"), copies=[CopyEdge("nodes.e.metrics[0].value", (e,), False)]), }, secrets=lambda: None) - assert {k: v.word for k, v in got.items()} == {b: "masked", c: "masked", d: None, e: None} + assert {k: v.word for k, v in got.items()} == {b: "masked", c: "masked", d: "masked", e: None} assert got[c].copied["nodes.b.metrics[0].value"] == ("masked", ("phone",), None) assert got[b].copied["nodes.c.metrics[0].value"] == ("masked", ("phone",), None) - assert got[d].copied["nodes.c.metrics"] == ("table", ("phone",), None) + assert got[d].copied["nodes.c.metrics"] == ("masked", ("phone",), None) -def test_a_whole_copy_is_withheld_when_its_value_carries_a_masked_value(): - """整张卡、清单文字转抄(table):上游有指标不给时,指标的值里有这次运行查到过的遮罩值才不给。""" - from app.engine.masking import _Secrets +def test_a_whole_copy_of_a_card_with_a_withheld_metric_is_withheld_whatever_its_value(): + """整张卡、清单文字、整份指标列表转抄:上游有指标不给时,转抄出来的都不给,值里有没有遮罩值都一样(转抄的保守规则)。以前 + 整张卡转抄同整份结果、只按值认:上游的指标由遮罩格算出来(年薪 = 月薪 × 12)时值里认不出,清单文字原样照给。""" from app.engine.recompute import CopyEdge, MetricLinks, masked_closure - secrets = _Secrets() - secrets.add({"columns": ["phone"], "rows": [[PHONES[0]]]}, {"phone"}) up, text, count = ("up", 0), ("text", 0), ("count", 0) links = { - up: MetricLinks(_metric("cell(nodes.q, 0, 'phone')", PHONES[0]), - direct={"cell(nodes.q, 0, 'phone')": ("masked", ("phone",))}), - text: MetricLinks(_metric("nodes.up.text", f"- p(号码)= {PHONES[0]}"), + up: MetricLinks(_metric("cell(nodes.q, 0, 'salary') * 12", 97479.0), + direct={"cell(nodes.q, 0, 'salary')": ("masked", ("salary",))}), + text: MetricLinks(_metric("nodes.up.text", "- annual(首位年薪)= 97479.0元"), copies=[CopyEdge("nodes.up.text", (up,), True)]), count: MetricLinks(_metric("len(nodes.up.metrics)", 1), copies=[CopyEdge("nodes.up.metrics", (up,), True)]), } - got = masked_closure(links, secrets=lambda: secrets) - assert (got[up].word, got[text].word, got[count].word) == ("masked", "masked", None) + got = masked_closure(links, secrets=lambda: None) + assert (got[up].word, got[text].word, got[count].word) == ("masked", "masked", "masked") + assert got[text].copied["nodes.up.text"] == ("masked", ("salary",), None) def test_an_unreadable_upstream_cannot_be_checked(): @@ -495,8 +494,7 @@ def _within(seconds: float, work): def test_the_writer_catalog_judges_a_long_loop_of_copying_cards_within_a_second(monkeypatch, masked): """写作目录(withheld_metrics,运行状态里每张卡只有最后一次的产出):三张卡、各 8 个指标,循环十轮后互相转抄、护栏选中 整张卡,一秒以内认完,每个指标只认一次(同一张依赖图上认,转抄它的指标不再重认)。没碰号码列的全部照给;acc 的第一个 - 指标取号码列时,第一个指标所在的环(三张卡的 t0)都不给,别的指标照给(整张卡转抄、值是数的不因此不给)。以前四个指标 - 就要四十秒。""" + 指标取号码列时,三张卡在一个环上互相转抄,按整张卡认(转抄的保守规则),全部不给。以前四个指标就要四十秒。""" import app.api.evidence as evidence_api from app.api.evidence import withheld_metrics @@ -519,7 +517,7 @@ def test_the_writer_catalog_judges_a_long_loop_of_copying_cards_within_a_second( "locator": {"metric": f"t{i}"}, "value": seen[card]["metrics"][i]["value"]} for card in LOOP_CARDS for i in range(8)} got = _within(1.0, lambda: asyncio.run(withheld_metrics(catalog, nodes=seen, ledger=[]))) - assert sorted(got) == (sorted(f"m:{card}.t0" for card in LOOP_CARDS) if masked else []), got + assert sorted(got) == (sorted(catalog) if masked else []), got assert len(built) == 3 * 8, len(built) @@ -656,9 +654,10 @@ async def test_a_metric_from_an_unaliased_masked_expression_is_withheld_everywhe async def test_the_whatif_judges_copied_inputs_on_the_same_graph(client, monkeypatch, vip): - """卡 2 转抄卡 1 的两个指标:号码除以 1000 的余数(值是三位数,按值认不出,输入取自遮罩格)、客户编号。推演卡 2:转抄余数 - 的输入不给值、不能改,指标的原值写「已遮罩」,原因写「转抄的口径卡指标取自设置了遮罩的列」;转抄编号的照常推演。以前 - 推演只按值认,余数照给、还能改,改一下就看得出原值。证据面板点开卡 2 的指标同样写「已遮罩」。""" + """卡 2 转抄卡 1 的两个指标:号码除以 1000 的余数(值是三位数,按值认不出,输入取自遮罩格)、客户编号,另转抄卡 b 的客户 + 编号。推演卡 2:转抄卡 1 的两个输入都不给值、不能改,指标的原值写「已遮罩」,原因写「转抄的口径卡指标取自设置了遮罩的列」 + ——转抄编号的也一样,卡 1 上有取自遮罩格的指标(转抄的保守规则);转抄卡 b(没有取自遮罩格的指标)的照常推演。以前推演只 + 按值认,余数照给、还能改,改一下就看得出原值。证据面板点开卡 2 的指标同样写「已遮罩」。""" script(monkeypatch, "卡二的对照 [[m:ten]],余数 [[m:tail2]]。") row = await finish(chain( node("start", "input"), @@ -666,9 +665,12 @@ async def test_the_whatif_judges_copied_inputs_on_the_same_graph(client, monkeyp node("card", "metrics", caliber="会员口径", caliber_version="v1", metrics=[ {"id": "tail", "name": "号码尾数", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'phone') % 1000"}, {"id": "first", "name": "首位编号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'id')"}]), + node("card_b", "metrics", caliber="编号口径", caliber_version="v1", metrics=[ + {"id": "first_b", "name": "首位编号", "format": "plain", "expression": "cell(nodes.q_cust, 0, 'id')"}]), node("card2", "metrics", caliber="转抄口径", caliber_version="v1", metrics=[ {"id": "tail2", "name": "转抄尾数", "format": "plain", "expression": "nodes.card.metrics[0].value + 1"}, - {"id": "ten", "name": "编号十倍", "format": "plain", "expression": "nodes.card.metrics[1].value * 10"}]), + {"id": "first2", "name": "转抄编号", "format": "plain", "expression": "nodes.card.metrics[1].value + 1"}, + {"id": "ten", "name": "编号十倍", "format": "plain", "expression": "nodes.card_b.metrics[0].value * 10"}]), node("write", "report", instructions="写一句", on_violation="flag"), node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]), )) @@ -683,10 +685,14 @@ async def test_the_whatif_judges_copied_inputs_on_the_same_graph(client, monkeyp assert copied["masked"] is True and copied["old"] is None and copied["editable"] is False, copied assert {"metric": "tail2", "input": "nodes.card.metrics[0].value", "reason": "转抄的口径卡指标取自设置了遮罩的列,不能用于推演"} in body["unsupported"], body["unsupported"] + first = metrics["first2"] + assert (first["old"], first["withheld"]) == ("已遮罩", True) and first["inputs"][0]["editable"] is False, first + assert {"metric": "first2", "input": "nodes.card.metrics[1].value", + "reason": "转抄的口径卡指标取自设置了遮罩的列,不能用于推演"} in body["unsupported"], body["unsupported"] ten = metrics["ten"] assert ten["old"] == 10 and ten["inputs"][0]["editable"] is True and ten["inputs"][0]["old"] == 1, ten res = await client.post(f"/api/runs/{row.id}/evidence/whatif", - json={"card": "card2", "overrides": {"inputs": {"nodes.card.metrics[1].value": 5}}}) + json={"card": "card2", "overrides": {"inputs": {"nodes.card_b.metrics[0].value": 5}}}) assert res.status_code == 200, res.text assert {m["id"]: m for m in res.json()["metrics"]}["ten"]["new"] == 50 res = await client.post(f"/api/runs/{row.id}/evidence/whatif", @@ -700,8 +706,9 @@ async def test_the_whatif_judges_copied_inputs_on_the_same_graph(client, monkeyp async def test_a_card_recording_a_copied_list_with_a_number_is_not_embedded(client, monkeypatch, vip): - """卡 2 数卡 1 清单文字的字数(len(nodes.card.text)):指标的值是个数,照给、照常引用;可卡 2 上记着转抄来的清单文字 - 本身,里面写着号码,卡 2 只给 id,文件里没有号码。以前指标的值照给,卡 2 就原样附带了。""" + """卡 2 数卡 1 清单文字的字数(len(nodes.card.text)):指标的值只是个数,可卡 1 上有取自号码列的指标,转抄的保守规则下 + 同样写「已遮罩」(写作者坚持引用、标注照常产出);卡 2 上记着转抄来的清单文字本身,里面写着号码,卡 2 只给 id,文件里 + 没有号码。以前指标的值照给,卡 2 就原样附带了。""" script(monkeypatch, "清单字数 [[m:n_len]]。") row = await finish(chain( node("start", "input"), @@ -711,12 +718,12 @@ async def test_a_card_recording_a_copied_list_with_a_number_is_not_embedded(clie "expression": "cell(nodes.q_cust, 0, 'phone')"}]), node("card2", "metrics", caliber="转抄口径", caliber_version="v1", metrics=[ {"id": "n_len", "name": "清单字数", "unit": "字", "format": "thousands", "expression": "len(nodes.card.text)"}]), - node("write", "report", instructions="写一句", on_violation="fail"), + node("write", "report", instructions="写一句", on_violation="flag"), node("out", "output", fields=[{"name": "报告", "value": "{{ nodes.write.text }}"}]), )) assert row.status == "succeeded", row.error doc = await doc_of(row.id) - assert "masked" not in doc["catalog"]["m:n_len"] and doc["catalog"]["m:n_len"]["value"] > 0 + assert doc["catalog"]["m:n_len"]["masked"] is True and doc["catalog"]["m:n_len"]["value"] == "已遮罩" _, bundle = await export(client, row.id) cards = {a["node_id"]: a for a in cards_of(bundle)} assert cards["card2"].get("masked") is True and "b64" not in cards["card2"], cards diff --git a/scripts/check-bundle.mjs b/scripts/check-bundle.mjs index fb444be6..1b2644f5 100644 --- a/scripts/check-bundle.mjs +++ b/scripts/check-bundle.mjs @@ -29,7 +29,8 @@ // 读者看到的数」;后面接量级单位(万、亿元、%、k,订单号后面接万)、画上删除线另写一个数、长得像数字的字母(l、O)、 // 长得像负号的连字符、叠在空格上的横线、从右往左书写的字母把一位数挪到数字前面判无法核对、写明原因,总览不再是绿的; // 紧挨着数字头尾的字改成白名单:别的文字系统里长得像 I、O、M、K 的字母、数学字母、隔着细空格的一位数、隔着换行和 em -// 空格的「万」、「(万元)」判无法核对,负号前面是别的文字系统的字母、后面接 e 和数字判不通过), +// 空格的「万」、「(万元)」、弯撇号当千分位补的一位数、偏旁「刂」和扩展 B 区里像竖线的字、后面接「×10⁴」「bn」 +// 「 billion」、前面紧挨着 en dash 判无法核对,负号前面是别的文字系统的字母、后面接 e 和数字判不通过), // 读的人看到的数要就是核对过的那个;列表缩进写成十万级或负数、 // 表格的列号写成十万,核对通过的数字照样留在屏幕上(宽屏、窄屏都不横向溢出);在上面篡改 ④ // 引用链(换文档、拿掉报告、多一份没人引用的工件)、⑥ 运行信息(运行结果、类别、出具档位)、拿掉被引用的口径卡、把 @@ -847,12 +848,13 @@ await section('样本页:各种形状', async () => { check('formats-unit:点开销售额,注明与按显示规则渲染的结果一致,不另列「按显示规则应为」', detail.includes('与按显示规则渲染的结果一致') && !detail.includes('按显示规则应为'), detail.replace(/\s+/g, ' ').slice(0, 160)) }) - // 引用旁边是写作者自己写的普通文字(「运费统一10元」「合计——7,036.50元」「SKU-202…」「共12840单家」、破折号、全角括号、 - // 「NO.」、假名长音、制表符横线、粗体斜体包着的数):服务端组装的文档原样导出,全部通过,总览是绿的 + // 引用旁边是写作者自己写的普通文字(「运费统一10元」「合计——7,036.50元」「SKU-202…」「共12840单家」、破折号、段内软换行、 + // 金额前面的「¥」「¥」、全角括号、「NO.」、假名长音、制表符横线、粗体斜体包着的数):服务端组装的文档原样导出,全部通过, + // 总览是绿的 await sample('prose', async (s) => { check('prose:普通写法紧挨着核对过的数,原样导出「全部通过」,没有一项无法核对', s.overall === 'pass' && s.text === '全部通过' && !s.items.some((i) => i.result !== 'pass') && s.hint === '', `${s.overall}:${s.text}`) - check('prose:15 个数字和取值都显示成可点的数字、都通过', s.numberStates.pass === 15 && s.numbers === 15, + check('prose:17 个数字和取值都显示成可点的数字、都通过', s.numberStates.pass === 17 && s.numbers === 17, JSON.stringify(s.numberStates)) }) @@ -1218,6 +1220,15 @@ await section('样本页:篡改', async () => { ['数字后面隔着换行接「万」', 's34', (t) => `\n万${t}`, 's33', '后面接着量级单位'], ['数字后面隔着 em 空格接「万」', 's34', (t) => `${cp(0x2003)}万${t}`, 's33', '后面接着量级单位'], ['数字后面接「(万元)」', 's34', (t) => `(万元)${t}`, 's33', '后面接着量级单位'], + // 复核第 3 轮点名的几类:弯撇号当千分位补一位数、偏旁形的汉字和扩展 B 区里像竖线的字、乘号乘方再接数字、英文的量级写法、 + // en dash 当负号 + ['数字前面加「1」和弯撇号', 's3', (t) => `${t}1${cp(0x2019)}`, 's4', '紧挨着这个数的字不在常见写法里'], + ['数字前面加偏旁「刂」', 's3', (t) => `${t}${cp(0x5202)}`, 's4', '紧挨着这个数的字不在常见写法里'], + ['数字前面加扩展 B 区像竖线的字', 's3', (t) => `${t}${cp(0x2010c)}`, 's4', '紧挨着这个数的字不在常见写法里'], + ['数字后面接「×10⁴」', 's34', (t) => `${cp(0xd7)}10${cp(0x2074)}${t}`, 's33', '后面紧接着乘号或乘方和数字'], + ['数字后面接「bn」', 's34', (t) => `bn${t}`, 's33', '后面接着量级单位'], + ['数字后面隔着空格接「billion」', 's34', (t) => ` billion${t}`, 's33', '后面接着量级单位'], + ['数字前面紧挨着 en dash', 's12', () => `转化率${cp(0x2013)}`, 's13', '前面紧挨着一道像负号的短横'], ]) { await tamper(samples.formats, label, (data) => rewriteDoc(data, (doc) => { segById(doc, at).text = change(segById(doc, at).text)