mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-22 10:51:59 +00:00
合入期 4 期 3 收尾:核查缺口分「核查未通过」「核查未完成」两组,时间线认得核查类日志代码;双盲复算写目录的预告和真写逐字一致(被目录挡下的那一边也说清原因,几个指标落到同一项时按组合预告);反方审稿说清「根本没反查」和「到底降不降档」;字段叫法挪到 labels.py;记录页的核查工件有名字和说明
This commit is contained in:
@@ -36,10 +36,11 @@ is_test = 0、is_valid = 1、deleted_at IS NULL);只涉及一张表。拿不
|
||||
也不写。
|
||||
|
||||
**预告。** 审批卡上要让审核人看得出选了之后会往目录里写什么(preview):按发起审批时的目录,选原流程、选盲算各会
|
||||
写什么、不写的为什么。和真写是同一套判断(derive 认事实、_plan 对目录、_revives 认驳回),所以只在两处可能和最后写
|
||||
的不一样:审批停下期间目录被人改了;同一次裁决里几个指标落到同一项上(上一段)——写进去的是合起来的说法,预告说会
|
||||
写的也可能因为说法互相矛盾、和已有条件的关系拿不准、合起来又成了驳回过的说法而不写。反过来不会:预告说不写的,
|
||||
不会因为和别的指标并成一项被写进去。
|
||||
写什么、不写的为什么。认出了事实、只是被目录挡下(已确认、驳回过、和已有条件合不起来)的那一边也带上写到哪张表的
|
||||
哪一项、本来要写什么,卡上才认得出它和别的指标是不是落到同一项上。同一次裁决里几个指标落到同一项上时,写进去的是
|
||||
合起来的说法(上一段),单个指标的预告说不准:preview_joint 把这几个指标各自选哪一边的每种组合都按真写的办法算一遍
|
||||
(_merged 归拢、_screen 拿掉驳回的、_plan 对目录),卡上按各指标当前的选择取对应的那一种。和真写是同一套判断、同一句
|
||||
原因,只有审批停下期间目录被人改了时才会和最后写的不一样。组合太多的(JOINT_LIMIT)那一项不预告,卡上有条件地说。
|
||||
|
||||
catalog.save_patch 不收备注,这里用它的同一套原料(read_entry、apply_patch、write_entry 的乐观锁)写,只多把备注放进项里。
|
||||
"""
|
||||
@@ -73,6 +74,10 @@ ASPECT_LABEL = {
|
||||
_VERB = {"count": "计数", "sum": "求和", "avg": "求平均"}
|
||||
#: 写入时版本对不上(别人刚改过这张表)最多重试几次
|
||||
_RETRIES = 2
|
||||
#: 同一次裁决里几个指标落到同一项上时,这一项最多预告多少种组合(preview_joint,每一项各算各的,不共用额度)。
|
||||
#: 每个指标两边都落在这一项上时近于 3 的指标数次方:四个指标 72 种还在里面,再多的那一项不预告,审批卡回到按其余指标
|
||||
#: 当前的选择有条件地说。组合数先算出来再比(_combos),不把组合列出来比:二十个指标就是几十亿种
|
||||
JOINT_LIMIT = 128
|
||||
|
||||
#: 无效记录的取值:被排除的取值(或码值表里它的意思)里有这些词,才算在排除无效记录
|
||||
_INVALID_WORDS = frozenset({
|
||||
@@ -94,7 +99,7 @@ class Fact:
|
||||
"""要写进目录的一项:哪个数据源的哪张表、哪一项、写什么。metric、choice 只用来写备注和说明;sql、dialect 是被采纳
|
||||
那一边的写法和方言,有效记录条件和目录里已有的条件合并时要看它还按哪些条件筛了。同一次裁决里几个指标落到同一项上
|
||||
时并成一项:members 是并进来的每个指标各自的那一项(各带自己的说法,审批卡上各自的预告就是按它算的),value 是
|
||||
合起来之后的说法;单个指标的 members 为空。"""
|
||||
合起来之后的说法;单个指标的 members 为空。metric_id 是指标 ID:几个指标并成一项时,预告按它说清每个指标的结果。"""
|
||||
|
||||
source: str
|
||||
table: str
|
||||
@@ -105,6 +110,7 @@ class Fact:
|
||||
sql: str = ""
|
||||
dialect: str | None = None
|
||||
members: tuple[Fact, ...] = ()
|
||||
metric_id: str = ""
|
||||
|
||||
|
||||
def _members(fact: Fact) -> tuple[Fact, ...]:
|
||||
@@ -160,7 +166,8 @@ def derive(candidate: Mapping[str, Any], schema_cache: Mapping[str, Any] | None,
|
||||
dialect = candidate.get("dialect")
|
||||
return Fact(source=str(candidate.get("source") or ""), table=resolved, item=key, value=value, metric=name,
|
||||
choice=str(side), sql=str(sql.get(side) or ""),
|
||||
dialect=dialect if isinstance(dialect, str) else None), None
|
||||
dialect=dialect if isinstance(dialect, str) else None,
|
||||
metric_id=str(candidate.get("metric_id") or "")), None
|
||||
|
||||
|
||||
def _business_date(item: Mapping[str, Any], side: str) -> tuple[tuple[str, str, Any] | None, str | None]:
|
||||
@@ -631,33 +638,35 @@ def _rejected_text(fact: Fact, rejected: Any, members: Sequence[Fact]) -> str:
|
||||
"的选择相反,未写入。如需更改,请到数据目录中修改")
|
||||
|
||||
|
||||
def _screen(notes: Mapping[str, Any], fact: Fact) -> tuple[Fact | None, list[str]]:
|
||||
"""几个指标并成的一项,先拿掉自己采纳的说法曾被人工驳回的指标:(剩下的重新并成的一项, 拿掉的为什么不写),一个
|
||||
都不剩时前者为 None。单个指标的、这一项没被驳回过的原样返回,由 _plan 照常判断。
|
||||
def _screen(notes: Mapping[str, Any], fact: Fact) -> tuple[Fact | None, list[Fact], list[str]]:
|
||||
"""几个指标并成的一项,先拿掉自己采纳的说法曾被人工驳回的指标:(剩下的重新并成的一项, 拿掉的指标, 没写的原因),
|
||||
一个都不剩、或者剩下的又合不起来时前者为 None;原因先是拿掉的那几个的(一条),剩下的合不起来时再跟一条。单个指标
|
||||
的、这一项没被驳回过的原样返回,由 _plan 照常判断。
|
||||
|
||||
审批卡上每个指标的预告是按它自己的说法单独算的(preview → _plan),在那里被驳回检查拦下、卡上写着「不写」的,
|
||||
并进来以后也得拦下。只拿合起来的整句去比,「status <> 'refunded'」和别的条件 AND 在一起就不再等于驳回的那句,
|
||||
会被写成人工确认,和卡上说的正相反。拿掉的指标照实说原因(和它的预告同一句话),其余的照写,也和各自的预告一致。"""
|
||||
rejected, said = _rejected(notes, fact.item)
|
||||
if not rejected or not fact.members:
|
||||
return fact, []
|
||||
return fact, [], []
|
||||
out: list[Fact] = []
|
||||
kept: list[Fact] = []
|
||||
for member in fact.members:
|
||||
(out if _revives(member, said) else kept).append(member)
|
||||
if not out:
|
||||
return fact, []
|
||||
return fact, [], []
|
||||
reasons = [_rejected_text(fact, said, out)]
|
||||
if not kept:
|
||||
return None, reasons
|
||||
return None, out, reasons
|
||||
narrowed, why = _merged(kept)
|
||||
return narrowed, reasons if why is None else [*reasons, why]
|
||||
return narrowed, out, reasons if why is None else [*reasons, why]
|
||||
|
||||
|
||||
async def record_choices(candidates: list[Mapping[str, Any]], *, run_id: str, node_title: str,
|
||||
actor: str | None) -> dict[str, list[dict[str, Any]]]:
|
||||
"""把审核人的选择写进数据目录:{written: [{source, table, item}], skipped: [{reason}]}。永远不抛:数据源没了、
|
||||
目录写不进去,都落在 skipped 里照实说。
|
||||
"""把审核人的选择写进数据目录:{written: [{source, table, item, value}], skipped: [{reason}]}。value 是真写进去的
|
||||
说法(和已有条件合起来的就是合起来的整句),审批卡上的预告说「会记为」的就是它。永远不抛:数据源没了、目录写不
|
||||
进去,都落在 skipped 里照实说。
|
||||
|
||||
先把每个候选认成目录项,再按(数据源、表、项)归拢成一项(_merged:说法一样的、有效记录条件合起来写,说法
|
||||
不同的整组不写),逐项写(_write:按读到的目录先拿掉各自带回驳回说法的指标,其余的照写)。"""
|
||||
@@ -690,24 +699,25 @@ async def record_choices(candidates: list[Mapping[str, Any]], *, run_id: str, no
|
||||
if fact is None:
|
||||
skipped.append({"reason": why})
|
||||
continue
|
||||
done, reasons = await _record(fact, run_id=run_id, node_title=node_title, actor=actor)
|
||||
if done:
|
||||
written.append({"source": fact.source, "table": fact.table, "item": fact.item})
|
||||
value, reasons = await _record(fact, run_id=run_id, node_title=node_title, actor=actor)
|
||||
if value is not None:
|
||||
written.append({"source": fact.source, "table": fact.table, "item": fact.item, "value": value})
|
||||
skipped += [{"reason": r} for r in reasons]
|
||||
return {"written": written, "skipped": skipped}
|
||||
|
||||
|
||||
async def _record(fact: Fact, *, run_id: str, node_title: str, actor: str | None) -> tuple[bool, list[str]]:
|
||||
"""写一项:(写了没有, 没写的原因)。几个指标并成的一项可能写了、同时有几个指标被拿出来没写,原因照样交回。"""
|
||||
async def _record(fact: Fact, *, run_id: str, node_title: str, actor: str | None) -> tuple[Any, list[str]]:
|
||||
"""写一项:(写进去的说法,没写为 None, 没写的原因)。几个指标并成的一项可能写了、同时有几个指标被拿出来没写,原因
|
||||
照样交回。"""
|
||||
try:
|
||||
async with SessionLocal() as session:
|
||||
row = (await session.execute(select(DataSource).where(DataSource.name == fact.source))).scalar_one_or_none()
|
||||
if row is None:
|
||||
return False, [f"数据源「{fact.source}」已不存在,指标{_names(_members(fact))}的选择未写入数据目录"]
|
||||
return None, [f"数据源「{fact.source}」已不存在,指标{_names(_members(fact))}的选择未写入数据目录"]
|
||||
return await _write(session, row, fact, run_id=run_id, node_title=node_title, actor=actor)
|
||||
except Exception: # noqa: BLE001 - 目录写不进去不能毁掉审批的结果:缺口照样按选择记
|
||||
logger.exception("双盲复算的选择写入数据目录失败(数据源 %s)", fact.source)
|
||||
return False, [f"指标{_names(_members(fact))}的选择写入数据目录时出错,未写入"]
|
||||
return None, [f"指标{_names(_members(fact))}的选择写入数据目录时出错,未写入"]
|
||||
|
||||
|
||||
def _plan(notes: Mapping[str, Any], fact: Fact, tables: Mapping[str, Any] | None) -> tuple[Any, str | None]:
|
||||
@@ -767,7 +777,9 @@ def preview(candidate: Mapping[str, Any], schema_cache: Mapping[str, Any] | None
|
||||
|
||||
candidate 同 derive(choice 不用给);notes 是这个数据源的目录({表名: notes})。返回 {a: …, b: …},每边是
|
||||
{write: true, source, table, item, value}(value 是真要写进去的说法:和目录里已有的有效记录条件合起来的,是合起来
|
||||
之后的整句)或 {write: false, reason}。和恢复后真写是同一套判断,只在模块说明里说的两处可能不一样。永远不抛。"""
|
||||
之后的整句)或 {write: false, reason};认出了事实、只是被目录挡下的不写,照样带上 source、table、item 和本来要写
|
||||
的 value(这个指标自己的说法)——卡上据此认出几个指标落到同一项上。这个指标单独落在这一项上时,reason 和真写时
|
||||
跳过的原因一字不差;和别的指标落到同一项上时看 preview_joint。永远不抛。"""
|
||||
notes = notes or {}
|
||||
tables = schema_cache.get("tables") if isinstance(schema_cache, Mapping) else None
|
||||
out: dict[str, dict[str, Any]] = {}
|
||||
@@ -780,15 +792,98 @@ def preview(candidate: Mapping[str, Any], schema_cache: Mapping[str, Any] | None
|
||||
except Exception: # noqa: BLE001 - 预告算不出来不能拦住审批:照实说,以写入后的结果为准
|
||||
logger.exception("双盲复算预告数据目录的写入失败(指标 %s)", candidate.get("metric"))
|
||||
fact, why = None, f"指标「{candidate.get('metric')}」的选择核对数据目录时出错,无法预告是否写入"
|
||||
out[side] = {"write": True, "source": fact.source, "table": fact.table, "item": fact.item, "value": value} \
|
||||
if fact is not None and why is None else {"write": False, "reason": why}
|
||||
if fact is None:
|
||||
out[side] = {"write": False, "reason": why}
|
||||
continue
|
||||
where = {"source": fact.source, "table": fact.table, "item": fact.item}
|
||||
out[side] = {"write": True, **where, "value": value} if why is None else \
|
||||
{"write": False, **where, "value": fact.value, "reason": why}
|
||||
return out
|
||||
|
||||
|
||||
def _joint_outcome(notes: Mapping[str, Any], members: list[Fact], tables: Mapping[str, Any] | None
|
||||
) -> dict[str, dict[str, Any]]:
|
||||
"""几个指标落到同一项上、各按自己的选择并成一项时,每个指标的结果:{指标 ID: {write: true, value} 或 {write: false,
|
||||
reason}}。和 record_choices 逐步一样:_merged 归拢(说法不同的整组不写),_screen 拿掉带回驳回说法的(它们说驳回
|
||||
那一句,剩下的合不起来时说合不起来的那一句),剩下的按 _plan 对目录(写的是同一个值,不写的是同一句原因)。"""
|
||||
fact, why = _merged(members)
|
||||
if fact is None:
|
||||
return {m.metric_id: {"write": False, "reason": why} for m in members}
|
||||
kept, out, reasons = _screen(notes, fact)
|
||||
result = {m.metric_id: {"write": False, "reason": reasons[0]} for m in out}
|
||||
rest = [m for m in members if m.metric_id not in result]
|
||||
if kept is None:
|
||||
result.update({m.metric_id: {"write": False, "reason": reasons[-1]} for m in rest})
|
||||
return result
|
||||
value, why = _plan(notes, kept, tables)
|
||||
result.update({m.metric_id: {"write": False, "reason": why} if why is not None else {"write": True, "value": value}
|
||||
for m in rest})
|
||||
return result
|
||||
|
||||
|
||||
def _combos(sides: Sequence[int], limit: int) -> int:
|
||||
"""几个指标落到同一项上时有几种组合(至少两个指标落上来的):每个指标要么没落上来、要么落上来的那几边之一,
|
||||
∏(1 + k) − 1 − Σk(k 是这个指标落到这一项上的边数,减去一个都没有、只有一个的)。连乘到超过 limit 能确定的地方
|
||||
就停,返回 limit + 1:只用来和上限比,不需要真算出几十亿。"""
|
||||
total, cap = 1, limit + 1 + sum(sides)
|
||||
for k in sides:
|
||||
total *= 1 + k
|
||||
if total > cap:
|
||||
return limit + 1
|
||||
return total - 1 - sum(sides)
|
||||
|
||||
|
||||
def preview_joint(candidates: Sequence[Mapping[str, Any]],
|
||||
catalogs: Mapping[str, tuple[Mapping[str, Any] | None, Mapping[str, Mapping[str, Any]]]]
|
||||
) -> list[dict[str, Any]]:
|
||||
"""同一次裁决里几个指标落到同一项上时的预告:[{source, table, item, members: [{metric_id, choice}], outcomes:
|
||||
{指标 ID: {write: true, value} 或 {write: false, reason}}}],每条是一种组合(members 是按各自的选择落到这一项上的
|
||||
指标,照候选的先后,至少两个)。
|
||||
|
||||
candidates 照节点交给真写的先后(不一致的指标的先后),带 metric_id,不带 choice;catalogs 是 {数据源名: (表结构,
|
||||
{表名: notes})},同 preview 的两个参数。每个指标的两边先各按 derive 认出落到哪一项(同 preview),落到同一项上的
|
||||
几个指标,每种「谁选了哪一边」的组合按 _joint_outcome 算一遍:真写时这几个指标就是这样被归拢、写或不写的。
|
||||
|
||||
上限按每一项算:一项的组合数(_combos,先算个数,不先列出来)超过 JOINT_LIMIT 的,这一项整项不预告,别的项照常
|
||||
预告,几项之间不共用额度。一项不超过 JOINT_LIMIT 种、每个指标最多落到两项上,总的计算量和指标数成正比。
|
||||
永远不抛:算不出来的那一项不预告。"""
|
||||
from itertools import product
|
||||
|
||||
landed: dict[tuple[str, str, str], dict[int, list[tuple[str, Fact]]]] = {}
|
||||
for index, candidate in enumerate(candidates):
|
||||
schema, notes = catalogs.get(str(candidate.get("source") or ""), (None, {}))
|
||||
for side in SIDE_LABEL:
|
||||
try:
|
||||
fact, _ = derive({**candidate, "choice": side}, schema, notes)
|
||||
except Exception: # noqa: BLE001 - 认不出就当这一边落不到任何一项上,同 preview 照实不说
|
||||
fact = None
|
||||
if fact is not None:
|
||||
landed.setdefault((fact.source, fact.table, fact.item), {}).setdefault(index, []).append((side, fact))
|
||||
out: list[dict[str, Any]] = []
|
||||
for (source, table, item), by_metric in landed.items():
|
||||
if len(by_metric) < 2 or _combos([len(sides) for sides in by_metric.values()], JOINT_LIMIT) > JOINT_LIMIT:
|
||||
continue
|
||||
options = [[None, *sides] for _, sides in sorted(by_metric.items())]
|
||||
combos = [[c for c in combo if c is not None] for combo in product(*options)]
|
||||
combos = [c for c in combos if len(c) >= 2]
|
||||
schema, notes = catalogs.get(source, (None, {}))
|
||||
tables = schema.get("tables") if isinstance(schema, Mapping) else None
|
||||
try:
|
||||
entries = [{"source": source, "table": table, "item": item,
|
||||
"members": [{"metric_id": fact.metric_id, "choice": side} for side, fact in combo],
|
||||
"outcomes": _joint_outcome((notes or {}).get(table) or {}, [fact for _, fact in combo], tables)}
|
||||
for combo in combos]
|
||||
except Exception: # noqa: BLE001 - 预告算不出来不能拦住审批:这一项不预告,卡上有条件地说
|
||||
logger.exception("双盲复算预告几个指标落到同一项上的写入失败(%s 的 %s)", table, item)
|
||||
continue
|
||||
out.extend(entries)
|
||||
return out
|
||||
|
||||
|
||||
async def _write(session: Any, row: DataSource, fact: Fact, *, run_id: str, node_title: str,
|
||||
actor: str | None) -> tuple[bool, list[str]]:
|
||||
"""写一项:(写了没有, 没写的原因)。几个指标并成的一项先按读到的目录拿掉各自带回驳回说法的指标(_screen),写什么、
|
||||
写不写再由 _plan 定;备注只列真写进去的指标。版本对不上(别人刚改过)重读再来。"""
|
||||
actor: str | None) -> tuple[Any, list[str]]:
|
||||
"""写一项:(写进去的说法,没写为 None, 没写的原因)。几个指标并成的一项先按读到的目录拿掉各自带回驳回说法的指标
|
||||
(_screen),写什么、写不写再由 _plan 定;备注只列真写进去的指标。版本对不上(别人刚改过)重读再来。"""
|
||||
label = catalog.TABLE_FIELD_LABEL.get(fact.item, fact.item)
|
||||
tables = (row.schema_cache or {}).get("tables") if isinstance(row.schema_cache, dict) else None
|
||||
reasons: list[str] = []
|
||||
@@ -796,19 +891,19 @@ async def _write(session: Any, row: DataSource, fact: Fact, *, run_id: str, node
|
||||
entry = await catalog.read_entry(session, row.id, fact.table)
|
||||
notes = entry.notes if entry else {}
|
||||
version = entry.version if entry else 0
|
||||
kept, reasons = _screen(notes, fact)
|
||||
kept, _, reasons = _screen(notes, fact)
|
||||
if kept is None:
|
||||
return False, reasons
|
||||
return None, reasons
|
||||
value, why = _plan(notes, kept, tables)
|
||||
if why is not None:
|
||||
return False, [*reasons, why]
|
||||
return None, [*reasons, why]
|
||||
note = note_of(kept, run_id=run_id, node_title=node_title)
|
||||
at = catalog.now_iso()
|
||||
try:
|
||||
merged = catalog.apply_patch(notes, [{"path": kept.item, "value": value, "reason": note}],
|
||||
table=kept.table, tables=tables, at=at)
|
||||
except catalog.CatalogInvalid as e:
|
||||
return False, [*reasons, f"「{kept.table}」的{label}未写入数据目录:{e}"]
|
||||
return None, [*reasons, f"「{kept.table}」的{label}未写入数据目录:{e}"]
|
||||
# 不论原来是谁提的:这一项现在出自人的选择,记为人工填写、已确认,备注写明出处
|
||||
merged[kept.item] = catalog.make_item(value, "human", "confirmed", note=note, at=at)
|
||||
try:
|
||||
@@ -817,9 +912,9 @@ async def _write(session: Any, row: DataSource, fact: Fact, *, run_id: str, node
|
||||
await session.rollback()
|
||||
continue
|
||||
except catalog.CatalogInvalid as e:
|
||||
return False, [*reasons, f"「{kept.table}」的{label}未写入数据目录:{e}"]
|
||||
return True, reasons
|
||||
return False, [*reasons, f"「{fact.table}」的数据目录正被修改,{label}未能写入,请稍后在数据目录中确认"]
|
||||
return None, [*reasons, f"「{kept.table}」的{label}未写入数据目录:{e}"]
|
||||
return value, reasons
|
||||
return None, [*reasons, f"「{fact.table}」的数据目录正被修改,{label}未能写入,请稍后在数据目录中确认"]
|
||||
|
||||
|
||||
__all__ = ["FACT_ITEMS", "Fact", "derive", "note_of", "preview", "record_choices"]
|
||||
__all__ = ["FACT_ITEMS", "JOINT_LIMIT", "Fact", "derive", "note_of", "preview", "preview_joint", "record_choices"]
|
||||
|
||||
@@ -66,6 +66,24 @@ FIELD_LABEL: dict[str, str] = {
|
||||
"defaults": "工作流默认设置",
|
||||
}
|
||||
|
||||
#: 双盲复算节点各配置项的叫法(lib/terms.ts 的 DUAL_CHECK_TEXT.field,check-verify 逐项比对)。模型两项照结论句裁判
|
||||
#: 「裁判模型 · 接入」「裁判模型」的写法
|
||||
DUAL_CHECK_FIELD_LABEL: dict[str, str] = {
|
||||
"card": "口径卡", "metrics": "复算的指标", "definitions": "口径说明", "provider": "盲算模型 · 接入",
|
||||
"model": "盲算模型", "tolerance": "允许的相对误差", "on_reject": "未采用原流程时", "enabled": "启用双盲复算",
|
||||
}
|
||||
#: 「未采用原流程时」两个取值的短说法:检查器下拉的选项以它开头(DUAL_CHECK_TEXT.onReject),后面可以带一句用途
|
||||
DUAL_CHECK_ON_REJECT_LABEL: dict[str, str] = {"degrade": "计入缺口、出具降档", "fail": "判为失败"}
|
||||
#: 反方审稿节点各配置项的叫法(lib/terms.ts 的 CHALLENGE_TEXT.field,check-challenge 逐项比对)
|
||||
CHALLENGE_LABEL: dict[str, str] = {
|
||||
"report": "要审的报告", "max_claims": "最多审几句", "max_queries": "每句最多查询次数",
|
||||
"timeout_s": "每句时长上限(秒)", "provider": "反方模型 · 接入", "model": "反方模型",
|
||||
"on_refuted": "结论被推翻时", "enabled": "启用",
|
||||
}
|
||||
#: 「结论被推翻时」三个取值的叫法:和检查器下拉(CHALLENGE_TEXT.onRefuted)一致,只去掉「(默认)」。报错让人去改
|
||||
#: 某一项时,人在下拉里找得到这个名字
|
||||
CHALLENGE_ON_REFUTED_LABEL: dict[str, str] = {"degrade": "出具降档", "flag": "只标注", "fail": "报错并停止运行"}
|
||||
|
||||
_FIELD_BY_TYPE: dict[str, dict[str, str]] = {
|
||||
"input": {"fields": "输入字段"},
|
||||
"agent": {"prompt": "任务"},
|
||||
@@ -81,6 +99,8 @@ _FIELD_BY_TYPE: dict[str, dict[str, str]] = {
|
||||
"stop_on_reject": "驳回即终止运行"},
|
||||
"validate": {"source": "待校验内容", "fail_fast": "校验失败即中断"},
|
||||
"merge": {"inputs": "输入", "sql": "合并 SQL"},
|
||||
"dual_check": DUAL_CHECK_FIELD_LABEL,
|
||||
"challenge": CHALLENGE_LABEL,
|
||||
}
|
||||
|
||||
#: 出具契约里的键(canvas/issues.ts 的 CONTRACT_KEYS、SUB_KEYS)
|
||||
@@ -114,6 +134,8 @@ _OPTION_LABEL: dict[str, dict[str, str]] = {
|
||||
"incomparable": "标注与历史不可比"},
|
||||
"isolation": {"strict": "严格:microVM", "fast": "快速:系统沙箱"},
|
||||
"thinking": {"summarized": "开启并显示摘要", "adaptive": "开启但不显示", "off": "关闭"},
|
||||
"on_reject": DUAL_CHECK_ON_REJECT_LABEL,
|
||||
"on_refuted": CHALLENGE_ON_REFUTED_LABEL,
|
||||
}
|
||||
#: 让人在几个取值之间选时的完整选项文字(发布前修复的候选),和检查器下拉一致,只去掉「(默认)」
|
||||
CHOICE_LABEL: dict[str, dict[str, str]] = {
|
||||
|
||||
@@ -22,8 +22,11 @@
|
||||
没审全(这两个代码还不在期 3 约定的日志代码表里,界面认不得时照原话显示)
|
||||
5. 处置:被推翻的按 on_refuted 处置。degrade(默认)在产出里写 issuance_gaps,成果节点的出具契约照单收进缺口、
|
||||
出具降档(nodes/io.py 的 _upstream_issuance_gaps,所以反方审稿要接在成果节点上游,画布校验会提醒);fail 判节点
|
||||
失败;flag 只记录。产出和审批卡里的 on_refuted 是实际生效的那一种(只有 degrade / flag,见 _finish)。审批卡
|
||||
(human.py 的 _reviewed_reports)附上审稿概况
|
||||
失败;flag 只记录。产出和审批卡里的 on_refuted 是实际生效的那一种(只有 degrade / flag,见 _finish);degrades
|
||||
说被推翻的到底会不会让出具降档(按降档处置、又接在带出具契约的成果节点上游),unreviewed 是未能反查的句数(核查
|
||||
模型不可用、触顶没给出结论、数据源不在了、报告没有引用数据库查询……这几句记为无法判断,但反查没有完成,触顶的
|
||||
可能已经查过几次)。每一句都记为无法判断,所以 unreviewed 不会大于 counts 里的 inconclusive。审批卡(human.py 的
|
||||
_reviewed_reports)附上审稿概况,据这两项说「出具会降档」「N 句未能反查」
|
||||
|
||||
上限:句数、每句查询次数、每句时长、全局每日金额(核查和裁判各记各的账,engine/spend.py)。都按发起时快照的核查
|
||||
设置(run.options["verify"]),节点上写了的盖过它:审批停下期间改了设置,恢复、接着跑仍按发起时的那份。没有快照
|
||||
@@ -55,8 +58,8 @@ from app.engine.evidence import ENTITY_KINDS, iter_units, ledger_enabled, next_e
|
||||
from app.engine.judge import _usd
|
||||
from app.engine.merge_query import MERGE_SOURCE
|
||||
from app.engine.replay import _in_graph
|
||||
from app.engine.schema import CHALLENGE_LABEL, CHALLENGE_ON_REFUTED_LABEL, GraphSpec, NodeType, challenge_problems, \
|
||||
challenge_report
|
||||
from app.engine.labels import CHALLENGE_LABEL, CHALLENGE_ON_REFUTED_LABEL
|
||||
from app.engine.schema import GraphSpec, NodeType, _ancestors, challenge_problems, challenge_report
|
||||
from app.engine.state import GraphState
|
||||
from app.engine.verify_agent import RATIONALE, VerifyOutcome, run_verify_agent
|
||||
from app.tools.datasource import run_versions
|
||||
@@ -466,9 +469,15 @@ def _named(claims: list[dict[str, Any]]) -> str:
|
||||
return names + ("等" if len(claims) > _NAMED else "")
|
||||
|
||||
|
||||
def _refuted_gap(claims: list[dict[str, Any]]) -> str:
|
||||
"""出具缺口里的那句:「推翻了 N 句结论:「…」」。不带节点名也不带「反方审稿」:出具契约统一加「反方审稿「节点名」:」
|
||||
(没改名的节点只加「反方审稿:」),正文再说一遍就成了「反方审稿:反方审稿推翻了……」。"""
|
||||
return f"推翻了 {len(claims)} 句结论:{_named(claims)}"
|
||||
|
||||
|
||||
def _refuted_words(claims: list[dict[str, Any]]) -> str:
|
||||
"""出具缺口、时间线、报错里的那句:「反方审稿推翻了 N 句结论:「…」」。不带节点名:出具契约统一加前缀。"""
|
||||
return f"反方审稿推翻了 {len(claims)} 句结论:{_named(claims)}"
|
||||
"""时间线、报错里的那句:「反方审稿推翻了 N 句结论:「…」」。它们不经出具契约加前缀,主语得自己带上。"""
|
||||
return f"反方审稿{_refuted_gap(claims)}"
|
||||
|
||||
|
||||
def pick_items(claims: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
@@ -616,6 +625,9 @@ class _Review:
|
||||
unreviewed.append(why)
|
||||
|
||||
counts = {v: sum(1 for c in claims if c["verdict"] == v) for v in VERDICTS}
|
||||
# 没能反查的句数:没派出去、派出去却没查成的(unreviewed 里各有原因),加上触顶时没能给出结论的。都记为无法判断,
|
||||
# 可「无法判断 2 句」既可能是查了、数据不够,也可能是根本没查:审批卡要分开说
|
||||
missed = len(unreviewed) + sum(skipped for _, skipped in hit.values())
|
||||
artifact = await self._store({"report": self.report_id, "doc_artifact": self.doc_artifact, "claims": claims,
|
||||
"model": model})
|
||||
for limit, (touched, skipped) in hit.items():
|
||||
@@ -645,7 +657,7 @@ class _Review:
|
||||
ctx.emit(EventType.LOG, level="warn", code="challenge_refuted",
|
||||
items=[{"unit": c["unit"], "text": c["text"]} for c in refuted[:ITEMS_MAX]],
|
||||
message=_refuted_words(refuted))
|
||||
return {"artifact": artifact, "counts": counts, "usage": usage,
|
||||
return {"artifact": artifact, "counts": counts, "usage": usage, "unreviewed": missed,
|
||||
"claims": [{k: c[k] for k in ("unit", "text", "verdict")} for c in claims]}
|
||||
|
||||
async def _store(self, record: dict[str, Any]) -> str | None:
|
||||
@@ -674,9 +686,13 @@ def _finish(ctx: NodeContext, state: GraphState, outcome: dict[str, Any], *, on_
|
||||
f"「{CHALLENGE_LABEL['on_refuted']}」改为「{CHALLENGE_ON_REFUTED_LABEL['flag']}」")
|
||||
on_refuted = "degrade" if refuted else "flag"
|
||||
result: dict[str, Any] = {"challenge_artifact": outcome.get("artifact"), "counts": outcome.get("counts") or {},
|
||||
"items": pick_items(claims), "on_refuted": on_refuted}
|
||||
"items": pick_items(claims), "on_refuted": on_refuted,
|
||||
"degrades": on_refuted == "degrade" and feeds_issuance(ctx.run.spec, ctx.node.id)}
|
||||
# checkpoint 里升级前审的结果没有这一项:不知道就不写,审批卡照旧不说
|
||||
if isinstance(outcome.get("unreviewed"), int):
|
||||
result["unreviewed"] = outcome["unreviewed"]
|
||||
if refuted and on_refuted == "degrade":
|
||||
result["issuance_gaps"] = [_refuted_words(refuted)]
|
||||
result["issuance_gaps"] = [_refuted_gap(refuted)]
|
||||
updates: dict[str, Any] = {"nodes": {ctx.node.id: result}}
|
||||
spent = outcome.get("usage") or {}
|
||||
if spent.get("calls"):
|
||||
@@ -694,10 +710,19 @@ def _finish(ctx: NodeContext, state: GraphState, outcome: dict[str, Any], *, on_
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
|
||||
def feeds_issuance(spec: GraphSpec, node_id: str) -> bool:
|
||||
"""这个节点在不在某个带出具契约的成果节点上游。成果节点的出具契约只收上游报上来的缺口(nodes/io.py 的
|
||||
_upstream_issuance_gaps):接在侧枝上、或者在成果之后,被推翻的结论记了缺口也进不了出具。认法同画布校验
|
||||
(schema._check_challenge 的「不在成果节点上游」警告)。"""
|
||||
return any(node_id in _ancestors(spec, n.id) for n in spec.nodes
|
||||
if n.type == NodeType.OUTPUT and n.config.get("contract"))
|
||||
|
||||
|
||||
def challenge_summary(spec: GraphSpec, outputs: dict[str, Any], report_id: str) -> dict[str, Any] | None:
|
||||
"""审批卡上这份报告的反方审稿概况 {counts, items, artifact, on_refuted}:审它的、已经审完的反方审稿节点给的。
|
||||
没有(没加反方审稿、还没审到、直通了)返回 None,审批卡不加这个键。几个反方审稿节点审同一份报告时取画布上
|
||||
靠后的那个。只看图和状态:重放时算出来的一样。"""
|
||||
"""审批卡上这份报告的反方审稿概况 {counts, items, artifact, on_refuted, unreviewed, degrades}:审它的、已经审完的
|
||||
反方审稿节点给的。没有(没加反方审稿、还没审到、直通了)返回 None,审批卡不加这个键。几个反方审稿节点审同一份报告
|
||||
时取画布上靠后的那个。只看图和状态:重放时算出来的一样。unreviewed、degrades 是期 4 加的:升级前的产出没有,
|
||||
概况也不带(审批卡按旧规则说)。"""
|
||||
found: dict[str, Any] | None = None
|
||||
for node in spec.nodes:
|
||||
result = outputs.get(node.id)
|
||||
@@ -707,8 +732,12 @@ def challenge_summary(spec: GraphSpec, outputs: dict[str, Any], report_id: str)
|
||||
continue
|
||||
found = {"counts": dict(result["counts"]), "items": list(result.get("items") or [])[:ITEMS_MAX],
|
||||
"artifact": result.get("challenge_artifact"), "on_refuted": result.get("on_refuted") or "degrade"}
|
||||
if isinstance(result.get("unreviewed"), int) and not isinstance(result["unreviewed"], bool):
|
||||
found["unreviewed"] = result["unreviewed"]
|
||||
if isinstance(result.get("degrades"), bool):
|
||||
found["degrades"] = result["degrades"]
|
||||
return found
|
||||
|
||||
|
||||
__all__ = ["CHALLENGE_SYSTEM", "ITEMS_MAX", "VERDICTS", "challenge_summary", "claim_sources", "mark_original",
|
||||
"pick_claims", "pick_items", "run_challenge", "with_note"]
|
||||
__all__ = ["CHALLENGE_SYSTEM", "ITEMS_MAX", "VERDICTS", "challenge_summary", "claim_sources", "feeds_issuance",
|
||||
"mark_original", "pick_claims", "pick_items", "run_challenge", "with_note"]
|
||||
|
||||
@@ -21,7 +21,8 @@ SQL,就跟着差异说明进了审批卡、对照工件和目录日志。完
|
||||
缺口;b、neither、没选的写进产出的 issuance_gaps,成果节点的出具契约据此降档(on_reject 为 fail 时节点直接失败)。
|
||||
两边只差一个方面、又对得上数据目录事实的,选择写进数据目录(engine/dual_check_facts.py,指标自己的筛选范围不写)。
|
||||
选了会怎样要在卡上看得出:payload 在约定的几项之外带上实际生效的 on_reject,摘要里每个指标带 catalog——选 a、选 b
|
||||
按发起审批时的目录各会往目录里写什么、不写的为什么(dual_check_facts.preview,和真写同一套判断)。
|
||||
按发起审批时的目录各会往目录里写什么、不写的为什么(dual_check_facts.preview,和真写同一套判断);几个指标落到目录
|
||||
同一项上时每种选择组合合起来会怎样写(preview_joint),放在对照工件的 catalog_joint 里。
|
||||
盲算触顶、出错、交不出数,或者输入本身没法单独复算的指标按「无法复算」记缺口,发 dual_check_unchecked。
|
||||
|
||||
**产出的状态。** 全部一致是 agreed;没有不一致、但有无法复算的:一个都没核成是 unchecked,核成了一部分是 partial;
|
||||
@@ -57,12 +58,13 @@ from app.db.models import DataSource
|
||||
from app.engine import recompute
|
||||
from app.engine.approval import read_decision
|
||||
from app.engine.context import NodeContext, NodeError
|
||||
from app.engine.dual_check_facts import preview, record_choices
|
||||
from app.engine.dual_check_facts import preview, preview_joint, record_choices
|
||||
from app.engine.evidence import build_catalog, is_number, next_exec
|
||||
from app.engine.expressions import ExpressionError, _cell_call, _chain_root, cell_value, column_kind, numeric_text, \
|
||||
parse_expression
|
||||
from app.engine.replay import _in_graph, ask, once
|
||||
from app.engine.schema import DUAL_CHECK_FIELD_LABEL, DUAL_CHECK_ON_REJECT, NodeType, dual_check_card
|
||||
from app.engine.labels import DUAL_CHECK_FIELD_LABEL, DUAL_CHECK_ON_REJECT_LABEL
|
||||
from app.engine.schema import DUAL_CHECK_ON_REJECT, NodeType, dual_check_card
|
||||
from app.engine.state import GraphState
|
||||
|
||||
#: 节点产出的状态:跳过、全部一致、核成了一部分(其余无法复算)、一个都没核成、人已裁决
|
||||
@@ -109,10 +111,11 @@ SAME_SQL_ASPECT = "data"
|
||||
DIFF_TIMEOUT = "两条 SQL 比较超时,未能归纳成具体差异,请对照原文"
|
||||
DIFF_FAILED = "两条 SQL 比较时出错,未能归纳成具体差异,请对照原文"
|
||||
NO_SQL = "有一边没有可比较的 SQL,请对照原文"
|
||||
#: 交给成果节点的缺口(不带节点名:出具契约统一加「双盲复算「节点名」:」)
|
||||
GAP_BLIND = "指标「{name}」双盲复算不一致,审核人选择了盲算结果"
|
||||
GAP_NEITHER = "指标「{name}」双盲复算不一致,审核人判断两边都不对"
|
||||
GAP_UNANSWERED = "指标「{name}」双盲复算不一致,审核人没有作出选择"
|
||||
#: 交给成果节点的缺口。不带节点名,也不再说「双盲复算」:出具契约统一加「双盲复算「节点名」:」(没改名的节点只加
|
||||
#: 「双盲复算:」),正文再说一遍就成了「双盲复算:指标「X」双盲复算不一致……」
|
||||
GAP_BLIND = "指标「{name}」两路结果不一致,审核人选择了盲算结果"
|
||||
GAP_NEITHER = "指标「{name}」两路结果不一致,审核人判断两边都不对"
|
||||
GAP_UNANSWERED = "指标「{name}」两路结果不一致,审核人没有作出选择"
|
||||
GAP_UNCHECKED = "指标「{name}」无法复算:{reason}"
|
||||
|
||||
BLIND_SYSTEM = (
|
||||
@@ -208,7 +211,7 @@ async def run_dual_check(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
|
||||
# 目录照样写了:审核人的选择是对数据的判断,和这次运行停不停无关
|
||||
names = "、".join(f"「{r['name']}」" for r in rejected[:5])
|
||||
raise NodeError(ctx.node.id, f"双盲复算不一致,审核人没有采用原流程的结果(指标{names})。"
|
||||
f"「{DUAL_CHECK_FIELD_LABEL['on_reject']}」设为「判为失败」,运行已停止;"
|
||||
f"「{DUAL_CHECK_FIELD_LABEL['on_reject']}」设为「{DUAL_CHECK_ON_REJECT_LABEL['fail']}」,运行已停止;"
|
||||
"请按审核意见修正取数或口径后重新运行")
|
||||
return _finish(state, ctx, card_id, card, checked, status=RESOLVED, gaps=gaps, choices=choices, note=note,
|
||||
artifact=review["card_artifact"], catalog=catalog)
|
||||
@@ -805,6 +808,8 @@ def _slim(outcome: Any) -> dict[str, Any]:
|
||||
"row": cell.get("row"), "column": cell.get("column"), "eid": cell.get("eid"),
|
||||
"sql": query.get("sql"), "source": query.get("source"),
|
||||
"rationale": (outcome.result or {}).get("rationale") or "",
|
||||
# 理由组装成的文档(evidence.compose_doc):数字有出处的挂着盲算自己查询的格子,裸数字已标出。审批卡照它画理由
|
||||
"rationale_doc": outcome.rationale if isinstance(outcome.rationale, dict) else None,
|
||||
"queries": [{k: q.get(k) for k in ("alias", "artifact", "sql", "row_count", "truncated", "source")}
|
||||
for q in outcome.queries],
|
||||
"notes": list(outcome.notes),
|
||||
@@ -964,7 +969,8 @@ async def _review(state: GraphState, ctx: NodeContext, checked: dict[str, Any],
|
||||
{"path": i["path"], "value": (results.get(i["key"]) or {}).get("value"),
|
||||
"sql": (results.get(i["key"]) or {}).get("sql"), "source": (results.get(i["key"]) or {}).get("source"),
|
||||
"alias": (results.get(i["key"]) or {}).get("alias"),
|
||||
"rationale": (results.get(i["key"]) or {}).get("rationale") or ""}
|
||||
"rationale": (results.get(i["key"]) or {}).get("rationale") or "",
|
||||
"rationale_doc": (results.get(i["key"]) or {}).get("rationale_doc")}
|
||||
for i in row["inputs"]]},
|
||||
"diff": {"equivalent": merged["equivalent"],
|
||||
"items": [{"aspect": i.get("aspect"), "text": i.get("text")} for i in merged["items"]],
|
||||
@@ -989,6 +995,13 @@ async def _review(state: GraphState, ctx: NodeContext, checked: dict[str, Any],
|
||||
"catalog": preview(facts[row["metric_id"]], info.get("schema"), info.get("notes")),
|
||||
})
|
||||
content = {"metrics": metrics, "model": checked.get("model"), "same_model": bool(checked.get("same_model"))}
|
||||
# 同一次裁决里几个指标落到数据目录的同一项上时,按各自的选择合起来写(dual_check_facts._merged):每个指标单独的
|
||||
# 预告说不准,把每种组合的结果都算好放进对照工件(payload 里放不下,审批卡打开时就取工件),卡上按当前的选择取
|
||||
catalogs = {name: (info.get("schema"), info.get("notes") or {}) for name, info in infos.items()}
|
||||
joint = await asyncio.to_thread(preview_joint, [facts[r["metric_id"]] for r in rows if r["metric_id"] in facts],
|
||||
catalogs)
|
||||
if joint:
|
||||
content["catalog_joint"] = joint
|
||||
try:
|
||||
artifact = await artifact_store.put_json(content, kind="dual_check", run_id=ctx.run.run_id,
|
||||
node_id=ctx.node.id, meta={"metrics": len(metrics)})
|
||||
|
||||
@@ -322,7 +322,8 @@ def _upstream_issuance_gaps(state: GraphState, ctx: NodeContext) -> list[str]:
|
||||
这是给「把关类」节点留的通用口子:节点觉得这次的结论不该完整出具(双盲复算两路对不上、
|
||||
反方审稿的反驳没有回应),在自己的产出里写 issuance_gaps,成果节点的出具契约照单收进缺口,
|
||||
出具随之降档。写的时候不用带节点名,这里统一加上「双盲复算「复核销售额」:」这样的前缀,
|
||||
和别的缺口一样读得出是谁报的。
|
||||
和别的缺口一样读得出是谁报的。节点名就是类型的叫法(拖进画布没改名)时只写一次:「反方审稿:」,
|
||||
不写成「反方审稿「反方审稿」:」。缺口正文也不必再提节点类型,前缀已经说了。
|
||||
|
||||
只认这个成果节点的上游:另一条支路上的节点管不到这份成果。不是字符串、空白的条目跳过——
|
||||
这个键谁都能写(数据整形的 JSON 模板也行),写坏了只当没写,不能让出具崩掉。
|
||||
@@ -340,7 +341,8 @@ def _upstream_issuance_gaps(state: GraphState, ctx: NodeContext) -> list[str]:
|
||||
reported = payload.get("issuance_gaps")
|
||||
if not isinstance(reported, list):
|
||||
continue
|
||||
prefix = f"{type_label(node.type)}「{node.title}」:"
|
||||
kind = type_label(node.type)
|
||||
prefix = f"{kind}:" if node.title == kind else f"{kind}「{node.title}」:"
|
||||
out.extend(prefix + gap.strip() for gap in reported if isinstance(gap, str) and gap.strip())
|
||||
return out
|
||||
|
||||
|
||||
@@ -111,6 +111,23 @@ WARN_CODES: dict[str, tuple[str, str]] = {
|
||||
# 估不出裁判的金额、裁判和写作是同一个模型:配置上的提醒,答案本身没受影响
|
||||
"judge_unpriced": ("judge_unpriced", BENIGN),
|
||||
"judge_same_model": ("judge_same_model", BENIGN),
|
||||
# 双盲复算、反方审稿的核查模型和被核查的模型相同:同 judge_same_model,只关乎独立性,结论本身没受影响
|
||||
"dual_check_same_model": ("dual_check_same_model", BENIGN),
|
||||
"challenge_same_model": ("challenge_same_model", BENIGN),
|
||||
# 核查 agent(engine/verify_agent.py,双盲复算、反方审稿共用)估不出金额:同 judge_unpriced,配置上的提醒
|
||||
"verify_unpriced": ("verify_unpriced", BENIGN),
|
||||
# 核查没做完、没通过:盲算触顶、两路不一致、指标无法复算;反方审稿触顶、推翻了结论、有句子没能反查、只查了
|
||||
# 部分数据源。答案照常交付(出具契约另按缺口降档),是缺口不是断裂,按各自的 kind 记,界面说得清是哪一种
|
||||
"dual_check_limit": ("dual_check_limit", DEGRADED),
|
||||
"dual_check_disagreed": ("dual_check_disagreed", DEGRADED),
|
||||
"dual_check_unchecked": ("dual_check_unchecked", DEGRADED),
|
||||
"challenge_limit": ("challenge_limit", DEGRADED),
|
||||
"challenge_refuted": ("challenge_refuted", DEGRADED),
|
||||
"challenge_unreviewed": ("challenge_unreviewed", DEGRADED),
|
||||
"challenge_sources_lost": ("challenge_sources_lost", DEGRADED),
|
||||
# 核查 agent 自己触顶、按已有结果收尾:多半和节点自己的 *_limit 说的是同一次触顶,照样是缺口,记成它自己的 kind,
|
||||
# 不落成笼统的 warn——步数上限(max_steps)只有它说
|
||||
"verify_limit": ("verify_limit", DEGRADED),
|
||||
}
|
||||
|
||||
# 这些 kind 重跑一次大概率能好:原因说得清,且不是「问题本身没问明白」。
|
||||
|
||||
@@ -9,6 +9,13 @@ from typing import Any, Iterable, Literal
|
||||
from pydantic import BaseModel, Field, field_validator, model_validator
|
||||
|
||||
from app.engine.labels import TYPE_LABEL, field_label, judge_label, option_label, q, type_label # noqa: F401
|
||||
# 双盲复算、反方审稿的叫法在 labels.py;校验、执行器和老的调用方照旧从这里取
|
||||
from app.engine.labels import ( # noqa: F401
|
||||
CHALLENGE_LABEL,
|
||||
CHALLENGE_ON_REFUTED_LABEL,
|
||||
DUAL_CHECK_FIELD_LABEL,
|
||||
DUAL_CHECK_ON_REJECT_LABEL,
|
||||
)
|
||||
|
||||
|
||||
class NodeType(StrEnum):
|
||||
@@ -425,15 +432,9 @@ def _check_report_sources(node: GraphNode, spec: GraphSpec, result: ValidationRe
|
||||
node_id=node.id, field="metrics_from", code=code)
|
||||
|
||||
|
||||
#: 双盲复算节点各配置项在检查器上的叫法(前端 nodeDefs 的 dual_check 字段)。按 labels.py 的规矩应放在那里,
|
||||
#: 那个文件不归双盲复算的工作包,先放在校验旁边,节点执行时报错也从这里取
|
||||
DUAL_CHECK_FIELD_LABEL = {
|
||||
"card": "口径卡", "metrics": "复算的指标", "definitions": "口径说明", "provider": "盲算模型 · 接入",
|
||||
"model": "盲算模型", "tolerance": "允许的相对误差", "on_reject": "未采用原流程时", "enabled": "启用双盲复算",
|
||||
}
|
||||
#: 审核人没有采用原流程的结果(选了盲算,或者判断两边都不对)时:degrade 计入缺口、出具降档(默认)/ fail 判为失败
|
||||
#: 审核人没有采用原流程的结果(选了盲算,或者判断两边都不对)时:degrade 计入缺口、出具降档(默认)/ fail 判为失败。
|
||||
#: 各配置项和这两个取值的叫法(DUAL_CHECK_FIELD_LABEL、DUAL_CHECK_ON_REJECT_LABEL)在 labels.py
|
||||
DUAL_CHECK_ON_REJECT = ("degrade", "fail")
|
||||
DUAL_CHECK_ON_REJECT_LABEL = {"degrade": "计入缺口、出具降档", "fail": "判为失败"}
|
||||
|
||||
|
||||
def dual_check_card(spec: GraphSpec, node: GraphNode) -> tuple[str | None, str | None]:
|
||||
@@ -721,17 +722,9 @@ def _check_report_from(node: GraphNode, report_from: Any, spec: GraphSpec,
|
||||
# 反方审稿节点(engine/nodes/challenge.py):审哪份报告、各项配置
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
#: 反方审稿节点各项配置在界面上的叫法:报错写叫法,不写键名
|
||||
CHALLENGE_LABEL = {
|
||||
"report": "要审的报告", "max_claims": "最多审几句", "max_queries": "每句最多查询次数",
|
||||
"timeout_s": "每句时长上限(秒)", "provider": "反方模型 · 接入", "model": "反方模型",
|
||||
"on_refuted": "结论被推翻时", "enabled": "启用",
|
||||
}
|
||||
#: 结论被推翻时怎么办:degrade 计入出具缺口、出具降档(默认)/ flag 只标注 / fail 判节点失败、运行停止
|
||||
#: 结论被推翻时怎么办:degrade 计入出具缺口、出具降档(默认)/ flag 只标注 / fail 判节点失败、运行停止。
|
||||
#: 各项配置和这三个取值在界面上的叫法(CHALLENGE_LABEL、CHALLENGE_ON_REFUTED_LABEL)在 labels.py:报错写叫法,不写键名
|
||||
CHALLENGE_ON_REFUTED = ("degrade", "flag", "fail")
|
||||
#: 选项的叫法和检查器下拉一致(lib/terms.ts 的 CHALLENGE_TEXT.onRefuted),只去掉「(默认)」:报错让人去改某一项时,
|
||||
#: 人在下拉里找得到这个名字
|
||||
CHALLENGE_ON_REFUTED_LABEL = {"degrade": "出具降档", "flag": "只标注", "fail": "报错并停止运行"}
|
||||
|
||||
|
||||
def _challenge_field(key: str) -> str:
|
||||
|
||||
Reference in New Issue
Block a user