"""分析期望:贡献(contribution)、判定(verdict)的算法和评分(docs/design/analysis-round/00-总方案.md §3.8)。 **期望怎么算。** 期望 SQL 在业务库上查一次(gold.py 的 SQL 探针,和别的期望同一份快照),在这份快照上用平台的算子 (app.analysis.run,和作答里的分析工具、分析卡同一个函数)算一次分析,判定就是期望: - 贡献:变化拆解(可加、比率、乘积),参数同分析工具(按维度 by、期次 period、基期 base、本期 target、度量 measure、分子 numerator、分母 denominator、乘积 product、因子 factors、叫法 label),另写 top_n(缺省 1):期望点名主要来源的前几段。 - 判定:波动基线、趋势判断、差异检验、可比性检查,参数同对应的分析工具。 算子要的输入只有这一份快照(编号 GOLD_REF),不写 query、两份快照、总数、下钻。参数里的文字可以带 {{ schedule.* }},按评测 的截至时间渲染(同期望 SQL);期望 SQL 只返回两期时可以不写基期、本期:先的一期是基期、后的一期是本期。阈值用这次评测的 设置快照(和作答的运行同一份,runner.py),不写在期望里;算不了的(历史不够、本期不完整……)这一项不能评分,原因照实写。 **判定类**(JUDGEMENTS):期望和答案里的分析结论都按判定码归到同一套类再比——贡献:source 主要来源(可加的 driver、 concentrated,乘积的 driver)、dispersed 分散、flat 基本持平、mix 主要来自结构变化、rate 主要来自各段自身的变化、mixed 两方面都有影响(比率、乘积的 both);判定:normal 常规波动(within_band)、anomaly 超出常规波动(outside_band、 far_outside_band,看方向)、rising / falling / no_trend、differs 差异站得住(看哪两组、方向)、no_evidence 不足以下结论、 comparable 可比(comparable、conditional)/ incomparable 不可比。 **评分**(score;沿用五种结论): - 对且可追溯:答案引用了([[a:]]、[[v:A…]]、[[table:A…]]、[[see:A…]])判定对得上的分析结论(同一个算子,变化拆解还要同一种 模式;主要来源要点名期望的那几段,方向一致;差异检验比的是同两组);引用它的那句话里的判断词却和期望对不上的不算。 - 对但没引用:没引用对得上的结论,但正文按说法表(engine/analysis_claims,同一套词表、同一套绑定规则)写对了:说法表认出的 这一类判断词,拿期望的那份分析结论核对得上(点名的段、方向、连续几期都核)。可比性不进说法表(说法核对不该打回「本周数据 不完整,不能直接比」这种谨慎的提醒),评分另用一张只给自己用的小词表(_INCOMPARABLE):期望是不可比的,正文明确说了两期 不能直接比(不能直接比、不可比、本期不完整、还没过完、只有几天、天数不同、口径不同……;分句里先有否定的、句子里先有假设 或疑问的、问句都不算)也算;期望是可比的只能靠引用。 - 错:引用的分析判定对不上、正文写的和期望相反(把常规波动说成异常、把上升说成下降、主要来源说成别的段),或者根本没做也 没说。 - 不能评分:期望算不了。 """ from __future__ import annotations import copy import re import unicodedata from collections.abc import Iterable, Mapping, Sequence from dataclasses import replace from typing import Any from app.analysis.contract import OP_LABELS, method_label #: 两种分析期望 ANALYSIS_KINDS = ("contribution", "verdict") #: 判定期望能用的分析(贡献恒为变化拆解) VERDICT_OPS = ("baseline", "trend", "differ", "comparable") #: 判定类,见模块说明。前六个是贡献的,后九个是判定的 JUDGEMENTS = ("source", "dispersed", "flat", "mix", "rate", "mixed", "normal", "anomaly", "rising", "falling", "no_trend", "differs", "no_evidence", "comparable", "incomparable") #: 分析的输入在算子里的名字(报错里照它说:「期望 SQL 里没有『地区』这一列」) GOLD_REF = "期望 SQL" #: 贡献期望最多点名前几段 TOP_N_MAX = 10 #: 期望里不写的参数:输入就是期望 SQL 这一份快照,没有两份快照、总数、下钻 _NOT_IN_EXPECTATION = frozenset({"query", "base_query", "target_query", "headline", "parent"}) #: 期望 SQL 只返回两期时,这几种分析可以不写基期、本期 _TWO_PERIODS = frozenset({"decompose", "differ", "comparable"}) #: 判定码 → 判定类(按算子、模式) _JUDGEMENT_OF: dict[tuple[str, str | None], dict[str, str]] = { ("decompose", "additive"): {"driver": "source", "concentrated": "source", "dispersed": "dispersed", "flat": "flat"}, ("decompose", "ratio"): {"mix_driven": "mix", "rate_driven": "rate", "both": "mixed", "flat": "flat"}, ("decompose", "factor"): {"driver": "source", "both": "mixed", "flat": "flat"}, ("baseline", None): {"within_band": "normal", "outside_band": "anomaly", "far_outside_band": "anomaly"}, ("trend", None): {"rising": "rising", "falling": "falling", "no_trend": "no_trend"}, ("differ", None): {"differs": "differs", "no_evidence": "no_evidence"}, ("comparable", None): {"comparable": "comparable", "conditional": "comparable", "incomparable": "incomparable"}, } #: 判定类要看方向的:主要来源、结构或自身为主、分散(总变化的涨跌)、超出常规波动(本期变化的涨跌)、差异站得住(A 相对 B) _DIRECTED = frozenset({"source", "mix", "rate", "mixed", "dispersed", "anomaly", "differs"}) #: 说法表的类(engine/analysis_claims 的 Claim.key)→ 它说出的判定类;「连续…」「趋势」看方向,见 _said_judgement _CLAIM_JUDGEMENT = {"source": "source", "dispersed": "dispersed", "mix": "mix", "anomaly": "anomaly", "normal": "normal", "no_trend": "no_trend", "differ": "differs", "no_diff": "no_evidence"} #: 期望是这一类时,正文里哪几类判断词算说出了它(别的类只看对不对得上:对不上算说反了) _AFFIRMS: dict[str, frozenset[str]] = { "source": frozenset({"source"}), "dispersed": frozenset({"dispersed"}), "mix": frozenset({"source", "mix"}), "rate": frozenset({"source"}), "mixed": frozenset({"mix"}), "flat": frozenset(), "normal": frozenset({"normal"}), "anomaly": frozenset({"anomaly"}), "rising": frozenset({"trend"}), "falling": frozenset({"trend"}), "no_trend": frozenset({"no_trend"}), "differs": frozenset({"differ"}), "no_evidence": frozenset({"no_diff"}), "comparable": frozenset(), "incomparable": frozenset(), } #: 判断词所在的句子最多留多少字给人看 _SNIPPET_MAX = 40 #: 数字(阿拉伯、全角、汉字)、期次、分句里的字(不跨句读)、比 _N = r"[0-90-9一二两三四五六七八九十]+" _PERIOD = "周|月|季|年|期|天|日" _IN_CLAUSE = r"[^,,;;。!?!?\n]" _COMPARE = "比较|对比|相比|比" #: 正文里明确说两期不能直接比的说法:直说不能比的,和说出不能直接比的原因的(本期不完整、还没过完、只有几天、天数不同、 #: 口径不同)。只给评分用,不进说法表(engine/analysis_claims):说法核对不该打回「本周数据不完整,不能直接比」这种谨慎的 #: 提醒 _INCOMPARABLE = re.compile( # 直说不能比:不能直接比、无法直接比较、不宜简单对比、难以比较……「无法比拟」「比不上」「比得上」不是 rf"(?:不能|不可以|无法|不宜|不应该?|不便|难以|很难|不好|没办法)(?:直接|简单)?地?(?:拿来|放在一起)?" rf"(?:{_COMPARE})(?![拟肩]|得上|不上)" # 「没法」要带「直接」「简单」,或者说「比较」「对比」:光说「没法比」多半是说差得远 rf"|没法(?:直接|简单)地?(?:拿来|放在一起)?(?:{_COMPARE})(?![拟肩]|得上|不上)|没法(?:比较|对比|相比)" # 不能直接拿本周和上周比 rf"|(?:不能|无法|不宜|不好|没法)(?:直接|简单)?(?:拿|把|将){_IN_CLAUSE}{{1,12}}?(?:和|跟|与|同){_IN_CLAUSE}{{1,12}}?" rf"(?:{_COMPARE})(?![拟肩]|得上|不上)" r"|不可比(?!拟)|不具备?可比性|没有可比性|缺乏可比性|可比性(?:不足|不够|存疑|较差|很差)" # 原因:本期不完整、还没过完、只有几天、差几天、不满一周、天数不同、口径不同 rf"|(?:数据|统计|{_PERIOD}){_IN_CLAUSE}{{0,4}}?(?:不完整|不全(?!是))" rf"|(?:{_PERIOD}){_IN_CLAUSE}{{0,4}}?(?:还|尚)?(?:没|未)(?:过完|结束|走完)" rf"|(?:只有|仅有|才有|只统计了|只算了|只过了|才过了|才过去|才)\s*{_N}\s*(?:天|日)" rf"|(?:还差|少了?|相差|差了?)\s*{_N}\s*(?:天|日)" r"|(?:不满|不足|不到)\s*(?:一|1)\s*整?(?:周|个?月|季度?|年)" r"|(?:天数|期长|时长|长度)也?(?:不同|不一样|不一致|不等|不相等|对不上|不足|不够)" r"|口径也?(?:不同|不一样|不一致|变了|有变|有变化|发生了?变化|调整过?|改过|改了|有调整)|(?:换了|改了|调整了)(?:统计)?口径" ) #: 可比性的说法前面(同一分句里)有否定的不算说了:「不是不能比」「并非不可比」 _INCOMPARABLE_DENIED = re.compile(r"不是|并非|并不|未必|不一定") #: 句子里在它前面有假设、疑问的不算说了:「如果口径不同,就不能直接比」「是不是不能直接比」 _INCOMPARABLE_SUPPOSED = re.compile(r"如果|假如|要是|倘若|假设|若是|是否|是不是|能不能|有没有") class ParamsInvalid(ValueError): """期望的分析参数写得不对(保存题目时、算期望时都可能)。message 给人看,key 是出错的那个参数。""" def __init__(self, message: str, key: str | None = None) -> None: super().__init__(message) self.message = message self.key = key # ========================================================================== # 参数:校验(cases.py 保存题目时)、组成分析请求(gold.py 算期望时) # ========================================================================== def param_names(op: str) -> list[str]: """期望里这种分析可以写的参数(分析工具的参数去掉输入、总数、下钻),按工具里的先后。""" from app.tools.builtin.analysis import param_names as tool_params return [k for k in tool_params(op) if k not in _NOT_IN_EXPECTATION] def op_text(op: str, mode: str | None = None) -> str: """「变化拆解(可加)」「波动基线」:叫法只取契约那一份。""" return method_label(op, mode) if mode else OP_LABELS.get(op, op) def template_texts(params: Mapping[str, Any]) -> Iterable[tuple[str, str]]: """参数里的文字(含列表、成对列表里的):(参数名, 文字)。{{ schedule.* }} 的校验、渲染按它走。""" for key, value in params.items(): if isinstance(value, str): yield key, value elif isinstance(value, list): for item in value: if isinstance(item, str): yield key, item elif isinstance(item, list): yield from ((key, x) for x in item if isinstance(x, str)) def check_params(op: str, mode: str | None, params: Any) -> dict[str, Any]: """参数的形状:只能写这种分析的参数,不能写阈值,类型照分析工具的参数定义。交回规范化的参数(去掉空值)。不对抛 ParamsInvalid。列在不在期望 SQL 的结果里要等试算才知道(算子按快照核)。""" from pydantic import ValidationError from app.analysis.contract import DEFAULTS, LABELS from app.tools.builtin.analysis import ARGS if params is None: params = {} if not isinstance(params, Mapping): raise ParamsInvalid("分析参数需要是一个对象") allowed = param_names(op) out: dict[str, Any] = {} for key, value in params.items(): if key in DEFAULTS: label = LABELS[key] if LABELS[key].startswith("「") else f"「{LABELS[key]}」" raise ParamsInvalid(f"参数里写了阈值{label}:阈值不写在期望里,评测按这次评测的分析设置算(和作答用同一份)", key) if key not in allowed: raise ParamsInvalid(f"参数里没有「{key}」,{op_text(op)}可以写:{'、'.join(allowed)}", key) if value is None or value == "" or value == []: continue out[key] = copy.deepcopy(value) probe = {**out, "query": GOLD_REF, **({"mode": mode} if mode else {})} try: ARGS[op].model_validate(probe) except ValidationError as e: error = e.errors()[0] key = str((error.get("loc") or ("",))[0]) field = ARGS[op].model_fields.get(key) said = (field.description or "") if field is not None else "" verb = "没写" if error.get("type") == "missing" else "写得不对" raise ParamsInvalid(f"参数「{key}」{verb}" + (f":{said}" if said else ""), key) from None return out def _render(value: Any, variables: Mapping[str, str]) -> Any: from app.eval.cases import render if isinstance(value, str): return render(value, variables) if isinstance(value, list): return [_render(v, variables) for v in value] return value def _two_periods(snapshot: Mapping[str, Any], period: str) -> tuple[Any, Any]: """期望 SQL 只返回两期时的基期、本期:按期次先后(periods.parse_compared 认得出的按它,否则按写法)。""" from app.analysis import periods columns = [str(c) for c in snapshot.get("columns") or []] hits = [i for i, c in enumerate(columns) if c == period] or \ [i for i, c in enumerate(columns) if c.lower() == period.lower()] if not hits: raise ParamsInvalid(f"期望 SQL 的结果里没有期次列「{period}」(结果的列:{'、'.join(columns) or '(没有)'})", "period") i = hits[0] values = list(dict.fromkeys(row[i] for row in snapshot.get("rows") or [] if isinstance(row, (list, tuple)) and i < len(row) and row[i] is not None)) if len(values) != 2: raise ParamsInvalid(f"期望 SQL 的期次列「{period}」里有 {len(values)} 期:不写基期、本期时,期望 SQL 只能返回两期" "(先的一期是基期、后的一期是本期)", "base") parsed = periods.parse_compared(values, str(snapshot.get("sql") or ""), columns[i], snapshot.get("dialect")) if parsed is not None: items, _ = parsed order = sorted(range(2), key=lambda k: items[k].ordinal) else: order = sorted(range(2), key=lambda k: str(values[k])) # 写成文字交给分析工具的参数(期次是数的也一样:算子按写出来的样子认期次列里的值) return str(values[order[0]]), str(values[order[1]]) def request_of(exp: Mapping[str, Any], variables: Mapping[str, str], snapshot: Mapping[str, Any]) -> dict[str, Any]: """一项分析期望 → 一次分析的请求(contract.AnalysisRequest):参数按截至时间渲染,输入是期望 SQL 这一份快照;只返回两期 又没写基期、本期的按两期补上。不对抛 ParamsInvalid。""" from pydantic import ValidationError from app.tools.builtin.analysis import ARGS, request_of as tool_request op, mode = str(exp.get("op")), exp.get("mode") params = {k: _render(v, variables) for k, v in (exp.get("params") or {}).items()} if op in _TWO_PERIODS and isinstance(params.get("period"), str) and params.get("base") in (None, "") \ and params.get("target") in (None, ""): params["base"], params["target"] = _two_periods(snapshot, params["period"]) params["query"] = GOLD_REF if mode: params["mode"] = mode try: args = ARGS[op].model_validate(params) except ValidationError as e: key = str((e.errors()[0].get("loc") or ("",))[0]) raise ParamsInvalid(f"参数「{key}」写得不对", key) from None return tool_request(op, args) # type: ignore[return-value] # ========================================================================== # 判定类 # ========================================================================== def judgement_code(op: Any, mode: Any, code: Any) -> str | None: """一份分析结论的判定码 → 判定类;没有对应的(拆解对不上总数)为 None。""" key = (str(op), str(mode) if op == "decompose" else None) return _JUDGEMENT_OF.get(key, {}).get(str(code)) if code else None def _segment(subject: Any) -> str: """判定点名的一段(维度键是一个列表,两列用「·」连,同判定语的写法)。""" from app.analysis.phrases import key_text return key_text(list(subject)) if isinstance(subject, (list, tuple)) else str(subject) def norm(name: Any) -> str: """比段名、因子名用的写法:全半角、大小写归一,去掉首尾空白。""" return unicodedata.normalize("NFKC", str(name or "")).casefold().strip() def expected(exp: Mapping[str, Any], result: Mapping[str, Any]) -> dict[str, Any]: """期望 SQL 上算出的那份分析结论 → 这一项的期望值(GoldSet.values 里的一项):判定类、点名的段、方向、判定语,连同整份 结论(评分时说法表按它核对正文;比较作答前后两次期望时去掉随运行当天、现查时刻变的几项,见 steady)。算不了的照实记。""" op, mode = result.get("op"), result.get("mode") out: dict[str, Any] = {"kind": exp.get("kind"), "status": result.get("status"), "op": op, "mode": mode, "method": op_text(str(op), mode), "phrase": result.get("phrase") or ""} if result.get("status") != "ok": out.update(reason_code=result.get("reason_code"), reason=result.get("reason") or "原因未知") out["result"] = copy.deepcopy(dict(result)) return out verdict = result.get("verdict") or {} judgement = judgement_code(op, mode, verdict.get("code")) subjects = [_segment(s) for s in verdict.get("subjects") or []] if judgement == "source": subjects = subjects[:int(exp.get("top_n") or 1)] elif judgement not in ("differs", "no_evidence"): subjects = [] out.update(verdict=verdict.get("code"), judgement=judgement, subjects=subjects, direction=verdict.get("direction") if judgement in _DIRECTED else None, criterion=result.get("criterion") or "") out["result"] = copy.deepcopy(dict(result)) return out def steady(value: Any) -> Any: """比较用的期望值:分析结论里随运行当天(params.today)、现查时刻(probes[*].at)、输入快照的工件(inputs[*].artifact, 快照里记着查询用时,同一份数据每次查出来工件也不同)变的几项去掉。别的期望原样。作答前后两次期望(gold._fingerprint)、 和上一次比的「数据变了」(runner.gold_key)都按它比。""" if not (isinstance(value, Mapping) and value.get("kind") in ANALYSIS_KINDS and isinstance(value.get("result"), Mapping)): return value result = copy.deepcopy(dict(value["result"])) if isinstance(result.get("params"), dict): result["params"].pop("today", None) for probe in result.get("probes") or []: if isinstance(probe, dict): probe.pop("at", None) for item in result.get("inputs") or []: if isinstance(item, dict): item.pop("artifact", None) return {**value, "result": result} def view(value: Mapping[str, Any]) -> dict[str, Any]: """评分结果里给人看的那一份(期望、答案各一份):判定类、点名的段、方向、判定语、哪一份结论(A 编号)。界面照原样写, 叫法在前端 termsEval。""" keys = ("judgement", "subjects", "direction", "phrase", "method", "alias", "status", "text") out = {k: copy.deepcopy(value[k]) for k in keys if value.get(k) not in (None, "", [])} if value.get("status") == "refused" and value.get("reason"): out["reason"] = value["reason"] return out # ========================================================================== # 答案里的分析结论 # ========================================================================== def record_of(result: Mapping[str, Any], *, artifact: str, info: Mapping[str, Any] | None = None) -> dict[str, Any]: """答案运行台账里的一份分析结论 → 评分用的那一份:算子、模式、判定类、点名的段、方向、判定语;输入(查询快照、上一层 结论的工件)给逐题 E1 找产出答案的查询。alias、cited 由读答案的地方填。""" verdict = result.get("verdict") or {} op, mode = result.get("op"), result.get("mode") out: dict[str, Any] = { "artifact": artifact, "op": op, "mode": mode, "method": op_text(str(op), mode), "status": result.get("status"), "verdict": verdict.get("code"), "judgement": judgement_code(op, mode, verdict.get("code")), "subjects": [_segment(s) for s in verdict.get("subjects") or []], "phrase": result.get("phrase") or "", "cited": [], "inputs": list((info or {}).get("inputs") or [i.get("artifact") for i in result.get("inputs") or [] if isinstance(i, Mapping) and i.get("artifact")]), } judgement = out["judgement"] out["direction"] = verdict.get("direction") if judgement in _DIRECTED else None if result.get("status") != "ok": out["reason"] = result.get("reason") or "原因未知" if (info or {}).get("node_id"): out["node_id"] = info["node_id"] return out def _same_family(want: Mapping[str, Any], record: Mapping[str, Any]) -> bool: """答案里的这份结论是不是这一项期望的同类分析:同一个算子;变化拆解还要同一种模式(可加、比率、乘积说的不是一回事)。""" if record.get("op") != want.get("op"): return False return want.get("op") != "decompose" or record.get("mode") == want.get("mode") def _names(items: Iterable[Any]) -> set[str]: return {norm(x) for x in items if norm(x)} def mismatch(want: Mapping[str, Any], got: Mapping[str, Any]) -> str | None: """答案里一份同类的分析结论和期望对不对得上:对得上为 None,否则是对不上的那一句(给人看)。""" if got.get("status") != "ok": return f"这份分析没有做成({got.get('reason') or '原因未知'})" judgement = want.get("judgement") if got.get("judgement") != judgement: return "判定和期望不是一类" if judgement in ("differs", "no_evidence"): mine, theirs = [norm(s) for s in got.get("subjects") or []], [norm(s) for s in want.get("subjects") or []] if len(theirs) == 2 and (len(mine) != 2 or set(mine) != set(theirs)): return f"比的是{'和'.join(got.get('subjects') or []) or '别的组'},期望比的是{'和'.join(want.get('subjects') or [])}" if judgement == "differs" and len(theirs) == 2 and want.get("direction") and got.get("direction"): same_order = mine == theirs if (got["direction"] == want["direction"]) != same_order: return "高低写反了" return None if judgement == "source": missing = [s for s in want.get("subjects") or [] if norm(s) not in _names(got.get("subjects") or [])] if missing: return f"主要来源是{'、'.join(got.get('subjects') or []) or '别的段'},不是{'、'.join(missing)}" if judgement in _DIRECTED and want.get("direction") and got.get("direction") \ and want["direction"] != got["direction"]: return "方向相反" return None # ========================================================================== # 正文里的判断词:按说法表认,拿期望的那份分析结论核对(engine/analysis_claims 同一套词表和绑定规则) # ========================================================================== _SENTENCE_END = re.compile(r"(?<=[。!?!?\n])") def _said_something(text: str) -> bool: """这句话里有没有评分要看的说法:说法表的判断词,或者明确说两期不能直接比(_INCOMPARABLE)。""" from app.engine import analysis_claims as said return bool(said.scan(text) or incomparable_spans(text)) def sentences_of_doc(doc: Mapping[str, Any], aliases: Iterable[str]) -> list[dict[str, Any]]: """报告文档里有判断词(或者明确说两期不能直接比)的句子:{text: 写作者自己写的字(引用渲染出来的值、判定语、引文涂成 \\x00), names: 点名用的样子(引用渲染出来的值留着), analyses: 这句挂的分析结论编号}。标题、代码块、表格不算(同说法 核对)。aliases 是文档目录里分析结论的编号。""" from app.engine import analysis_claims as said from app.engine.evidence import iter_units known = {a: {} for a in aliases} out: list[dict[str, Any]] = [] for block, unit in iter_units(dict(doc)): if block.get("type") in ("heading", "code", "table") or unit.get("kind") in ("heading", "code") \ or unit.get("loc") is not None: continue sentence = said._sentence(unit, unit.get("cites") or [], known) if sentence is not None and _said_something(sentence.text): out.append({"text": sentence.text, "names": sentence.names, "analyses": list(sentence.analyses)}) return out def sentences_of_text(text: str) -> list[dict[str, Any]]: """没有报告文档时(成果里的文字):按句末标点切开,有判断词(或者明确说两期不能直接比)的句子。""" out = [] for piece in _SENTENCE_END.split(text or ""): piece = piece.strip() if piece and _said_something(piece): out.append({"text": piece, "names": piece, "analyses": []}) return out def _snippet(names: str, start: int, end: int) -> str: """判断词连同它所在的分句(给人看)。""" from app.engine import analysis_claims as said left, right = said._clause(names, start, end) text = names[left:right].replace("\x00", "").strip() return text[:_SNIPPET_MAX] + ("…" if len(text) > _SNIPPET_MAX else "") def _said_judgement(claim: str, direction: str | None) -> str | None: if claim == "trend": return {"up": "rising", "down": "falling"}.get(direction or "") return _CLAIM_JUDGEMENT.get(claim) def said_in(want: Mapping[str, Any], sentences: Sequence[Mapping[str, Any]], *, only: Iterable[str] | None = None) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]: """正文里和这项期望同一类的判断词,拿期望的那份分析结论(want.result)按说法表的绑定规则核对:(说出了期望的那几处, 和期望对不上的那几处)。每处 {text: 所在分句, judgement: 它说出的判定类, subjects: 点名的段, reason: 对不上的原因}。 only 给了时只看挂了这几份结论的句子。 规则同 engine/analysis_claims.check_sentence(同一个 _check):因果词点名的是期望拆解里的段的按来源核;点名的段要在期望 点名的段里,拖累、拉动按那一段的涨跌核;「连续 N 期」按末尾连续同向的期数核。另外按期望的方向核主要来源那句话的涨跌 (「下降主要来自华东」)。""" from app.engine import analysis_claims as said gold = want.get("result") or {} op = want.get("op") affirms = _AFFIRMS.get(str(want.get("judgement")), frozenset()) lex = said.lexicon() wanted = set(only) if only is not None else None good: list[dict[str, Any]] = [] bad: list[dict[str, Any]] = [] for raw in sentences: if wanted is not None and not wanted & set(raw.get("analyses") or []): continue sentence = said.Sentence(text=str(raw.get("text") or ""), names=str(raw.get("names") or "")) for hit in said.scan(sentence.text): claim = lex.claim(hit.claim) left, right = said._clause(sentence.text, hit.start, hit.end) names = sentence.names[left:right] spans = said._object(sentence, hit, left, right) if claim.key == "causal": if op != "decompose": continue cause = said._cause(sentence, hit, left, right) if not said._named(gold, cause): continue hit, claim, spans = replace(hit, claim="source", side="cause"), lex.claim("source"), (cause,) if claim.op != op: continue miss = said._check(lex, hit, gold, names, spans=spans) reason = miss.human if miss is not None else None named = next((found for span in spans if (found := said._named(gold, span))), []) if reason is None and hit.claim == "source" and hit.side != "pull" and want.get("direction") \ and hit.direction and hit.direction != want["direction"]: reason = "涨跌写反了" item = {"text": _snippet(sentence.names, hit.start, hit.end), "judgement": _said_judgement(hit.claim, hit.direction), "subjects": named} if reason is not None: bad.append({**item, "reason": reason}) elif hit.claim in affirms: good.append(item) return good, bad def incomparable_spans(text: str) -> list[tuple[int, int]]: """一句话(写作者自己写的字)里明确说两期不能直接比的几处 [(起, 止)](_INCOMPARABLE)。同一分句里前面有否定的、 句子里前面有假设或疑问的不算,问句整句不算。""" from app.engine import analysis_claims as said if text.rstrip("\x00 ").endswith(("?", "?")): return [] out = [] for m in _INCOMPARABLE.finditer(text): left, _ = said._clause(text, m.start(), m.end()) if _INCOMPARABLE_DENIED.search(text[left:m.start()]) or _INCOMPARABLE_SUPPOSED.search(text[:m.start()]): continue out.append((m.start(), m.end())) return out def said_incomparable(sentences: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]: """正文里明确说两期不能直接比的几处(可比性的期望是不可比时,算说出了它):{text: 所在分句, judgement: incomparable}。""" out = [] for raw in sentences: text = str(raw.get("text") or "") names = str(raw.get("names") or text) for start, end in incomparable_spans(text): out.append({"text": _snippet(names, start, end), "judgement": "incomparable", "subjects": []}) return out def _covered(want: Mapping[str, Any], good: Sequence[Mapping[str, Any]]) -> list[str]: """主要来源期望点名的段里,正文说对的那几处一处都没点到的(top_n 要点名的前几段都要说到)。""" if want.get("judgement") != "source": return [] named = _names(s for item in good for s in item.get("subjects") or []) return [s for s in want.get("subjects") or [] if norm(s) not in named] # ========================================================================== # 评分 # ========================================================================== def score(exp: Mapping[str, Any], value: Mapping[str, Any], answer: Any) -> dict[str, Any]: """一项分析期望的结论(score.OUTCOMES 之一)。value 是期望值(expected 的形状),answer 是 score.Answer(analyses: 答案运行台账里的分析结论,cited 记着报告怎么引用了它;sentences:有判断词的句子)。纯计算。""" want = view(value) if value.get("status") != "ok": return {"outcome": "ungradable", "want": want, "reason": f"期望算不了:{value.get('reason') or '原因未知'}"} if value.get("judgement") is None: return {"outcome": "ungradable", "want": want, "reason": "期望的分析没有给出判定"} records = [r for r in getattr(answer, "analyses", None) or [] if _same_family(value, r)] cited = [r for r in records if r.get("cited") and r.get("alias")] sentences = list(getattr(answer, "sentences", None) or []) matched = [r for r in cited if mismatch(value, r) is None] if matched: found = matched[0] _, bad = said_in(value, sentences, only=[r["alias"] for r in matched]) if bad: return {"outcome": "wrong", "want": want, "found": view({**found, "text": bad[0]["text"]}), "reason": f"引用了 {found['alias']},同一句却写成「{bad[0]['text']}」:{bad[0]['reason']}"} return {"outcome": "traced", "want": want, "found": view(found)} good, bad = said_in(value, sentences) if value.get("judgement") == "incomparable": good += said_incomparable(sentences) if good: missing = _covered(value, good) if not missing: return {"outcome": "untraced", "want": want, "found": view(good[0])} return {"outcome": "wrong", "want": want, "found": view(good[0]), "reason": f"正文只点名了{'、'.join(s for g in good for s in g.get('subjects') or []) or '别的段'}," f"期望的主要来源还有{'、'.join(missing)}"} if cited: first = cited[0] return {"outcome": "wrong", "want": want, "found": view(first), "reason": f"答案引用的 {first['alias']}({first.get('phrase') or first.get('method')})" f"和期望对不上:{mismatch(value, first)}"} if bad: return {"outcome": "wrong", "want": want, "found": view(bad[0]), "reason": f"正文写的「{bad[0]['text']}」和期望对不上:{bad[0]['reason']}"} method = op_text(str(value.get("op")), value.get("mode")) if records: first = records[0] shown = f"({first['alias']})" if first.get("alias") else "" return {"outcome": "wrong", "want": want, "found": view(first), "reason": f"答案做了{method}{shown},但没有引用,正文里也没有写出这个判断"} return {"outcome": "wrong", "want": want, "reason": f"答案里没有做{method},正文里也没有写出这个判断"} __all__ = ["ANALYSIS_KINDS", "GOLD_REF", "JUDGEMENTS", "ParamsInvalid", "TOP_N_MAX", "VERDICT_OPS", "check_params", "expected", "incomparable_spans", "judgement_code", "mismatch", "norm", "op_text", "param_names", "record_of", "request_of", "said_in", "said_incomparable", "score", "sentences_of_doc", "sentences_of_text", "steady", "template_texts", "view"]