yilunjiang/AgentLab
1
0
Fork 0
mirror of https://github.com/ThearchyHelios/AgentLab.git synced 2026-11-15 02:01:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

运行对比加固（第 3 轮）：单格要是同一个区域的同一行；归因按哪组维度说就按哪组维度核对；快照里行和列对不上的说不清；补单格反方向、行段只差最后一行、精确性一侧等变红测试

Browse Source 
- 单格（数组字段的一个元素）引用的那一行两次是同一个区域，还要是它同样的那一行：按查询结果的先后，排在这一行前面的、它的行数两边一样。区域 × 日期的结果东区少了一天，第 3 行从南区的第一天变成第二天，原来报成只数据变、南区少了 5（同一天的南区其实多了 10，正负号反了），同一处引用换成一行的行段却说不清；按金额排的第 2 行从东区第二高的那天变成最高的那天、取第二个元素的也一样。只比排在前面的行数，不比外面还有没有它的行：东区两天还是一天、第 1 行都是东区第一天的照常是数据变化
- 行段核对引用的是不是同一批维度值时，按两边整份结果认出的维度核对一遍，再按归因用的维度（引用的那段行上认出的）核对一遍，两组都切在同一处才算同一处。渠道在引用的行里两边都只有「线上」、归因按区域说：南区第二天走了线下、挤到第 5 行，原来只按（区域, 渠道）核对，报成只数据变、南区 -100%，和「南区真的只有一天」一字不差，反方向也是；区域 × 渠道取前 2 行、南区新开的线下排第 3，归因 300 → 280，快照里南区是 300 → 480。只按归因用的那组也不够（只引用一行的认不出维度；引用的行两边都只有东区、只有整份结果分得出区域的也要核对）。取行的规则抽成 _attributed_rows，归因和核对共用
- 快照里有的行和列对不上、认不出各行是哪个维度值：原来退回按行号认、报成只数据变，现在和快照读不出来一样说不清，说清是哪一边
- 新测试：单格同一区域换了一行（两个方向、按金额排、取第二个元素、排在前面 2 行对 1 行、只有一行的行段同样说不清、同一行的对照）；按归因用的维度核对（渠道挤出、反方向、新开线下，各带对照，占比之和为 1；只引用一行时仍按整份结果的维度核对）；行和列对不上（两个方向）；单格反方向（这次取的区域在基准运行里，只是不在这一行）；行段只差最后一行；精确性一侧（第 4 名每周不同、后面剩的行数不同，仍是数据变化）；排在前面的行数 2 对 1、位置说明里的行数、两边都只引用一部分但行数不同、基准一行都没引用时说哪一边；引用的行两边都只有东区时按整份结果认区域；金额列存成文本时也不当维度；只在一次运行的图里有的下游节点；不归因时整体说明照样提遮罩
- test_an_element_only_needs_the_same_region_on_its_row 改名 test_an_element_does_not_mind_other_rows_of_its_region：单格不再只看区域，原名和说明都不对了
This commit is contained in:
ThearchyHelios
2026-10-05 15:52:51 +08:00
parent 44e4597037
commit eea098e975
2 changed files with 393 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app/engine/compare.py
+69 -23
View File
@@ -26,9 +26,11 @@
不是的算换了；行号相同、都不是整份结果的，按维度值数两边各引用了它几行、引用的行外面还有没有它的行：引用过的
每个维度值两边要被切在同一处——都整个被引用（一边的快照里根本没有它的，那一边算整个被引用），或者都只引用了
它同样的那几行（排在引用的行前面的行数、引用的行数都一样）——否则也算换了：取前几名时名次变了、按区域排序时
多了一个区域、区域 × 日期的结果里一个区域有一天被挤出引用的行、一个区域多了一天却只引用了前几天；单格只看引用
的那一行两次是不是同一个维度值；单格引用的那一边快照读不出来、核对不了是不是同一个维度值的，和行段一样说不清）：
取哪一列、哪几行是 Agent 每次运行时定的，换了就不是同一个数
多了一个区域、区域 × 日期的结果里一个区域有一天被挤出引用的行、一个区域多了一天却只引用了前几天。维度按两边
整份结果认一组、按归因用的行（引用的那段行）再认一组，两组都要切在同一处——归因按哪组维度说，就按哪组核对；
单格引用的那一行两次要是同一个维度值，还要是它同样的那一行（排在这一行前面的、它的行数一样）；快照读不出来、
有的行和列对不上，核对不了是不是同一批维度值的，说不清）：取哪一列、哪几行是 Agent 每次运行时定的，换了就不是
同一个数
- 不落在快照上的：模型、人交出的值（Agent 没按出处交、模型调用、人工审批……）没有出处，值变了说不清是数据还是它
本身的差异；代码、数据整形这类节点看它自己查过的库，不查库的看它的配置和画布上的全部上游；记不出写入者的看
口径卡之前可能执行过的节点（口径卡自己、只在它下游的不算）。上游的查询结果两次一模一样、值却变了的同样说不清；
@@ -1078,8 +1080,9 @@ class _Compare:
"""Agent 按出处交来的字段两次引用的是不是同一处：同一列（对象数组是同一组列）、同一行或同一段行。两边引用的都是
整份结果的算同一处（这次多了几行也是）；行段相同、一边是整份结果一边不是的不算——没引用的那几行还在这次的快照
里，按维度配对会把它们算成「数据没了」。行号相同、都不是整份结果的，还要引用同一批维度值（_left_out）：行段
要把引用过的每个维度值切在同一处（两边都整个被引用，或者都只引用了它同样的那几行），单格要引用同一个维度值。
不是同一处、核对不了是不是同一处的，返回说明。"""
要把引用过的每个维度值切在同一处（两边都整个被引用，或者都只引用了它同样的那几行），单格要引用同一个维度值的
同一行。行段的起止行有一个不同就不是同一处（只差最后一行也是：多引用的那一行改变了合计）。不是同一处、核对
不了是不是同一处的，返回说明。"""
name = f"Agent「{self.title(agent)}」" if agent else "Agent"
lb, lt = _locator(b), _locator(t)
cb, ct = lb.get("column") or lb.get("columns"), lt.get("column") or lt.get("columns")
@@ -1111,7 +1114,7 @@ class _Compare:
def _left_out(self, name: str, what: str, b: Any, t: Any, qb: _Query, qt: _Query, column: Any) -> _Change | None:
"""行号相同、都不是整份结果的引用，引用的是不是同一批维度值（区域……）。按维度键分别数两边引用了它几行、引用
的行外面还有没有它的行：
的行外面还有没有它的行（_cut 按一组维度核对）：
- 行段（口径卡按引用的几行一起算）：引用过的每个维度值，两边要被切在同一处——都整个被引用（引用的行外面没有
它的行；那一边的快照里根本没有它的，也算整个被引用，没什么可漏的），或者都只引用了它同样的那几行（按查询
@@ -1121,10 +1124,14 @@ class _Compare:
部分）；北区这次新出现，三天里只引用了两天；引用的行不从第 1 行开始，东区两次都只引用了一行，基准运行是它
金额第二高的那天、这次是最高的那天。按维度配对会把还在快照里、只是没被引用的行算成数据变化，和真的少了、
真的多了分不出来，正负号都可能反。只比引用的行数查不出后三种，只看「引用的行里有没有这个键」连挤出一部分都
查不出。
- 单格（数组字段里的一个元素）：只看引用的那一行两次是不是同一个维度值；不是的，一边引用的那个维度值在另一边的
快照里、只是不在这一行，取的不是同一个数。单格只有一行，没有切法可比：东区两天还是一天，第 1 行都是东区的
第一天。
查不出。引用的行后面还剩它几行不进切法：两次都只引用了南区的第一天，后面剩一天还是两天，引用的都是同一天。
- 单格（数组字段里的一个元素）：引用的那一行两次要是同一个维度值，还要是它同样的那一行——按查询结果的先后，
排在这一行前面的、它的行数两边一样（两次都是南区的第一天）。区域 × 日期的结果东区少了一天，第 3 行从南区的
第一天变成了第二天；按金额排，第 2 行从东区第二高的那天变成了最高的那天：区域没变，取的却不是同一个数（同一处
引用换成只有一行的行段也说不清），按行号认会把南区第一天的 50 和第二天的 45 当成同一个数，同一天的南区其实
是 50 → 60，正负号都反了。只比排在前面的行数，不比「它在这一行外面还有没有行」：单格只有一行，口径卡不按它
算这个区域的合计，东区两天还是一天，第 1 行都是东区的第一天。不是同一个维度值的，一边引用的那个维度值在另一
边的快照里、只是不在这一行，取的不是同一个数。
- 一边引用了、另一边快照里没有的，是真的没有了（或者这次才有），照常比。快照被截断的按取回的行比，和引用整份
结果时一样（系统的行数上限当作查询的一部分，像 SQL 里的 LIMIT）：挤到截断点后面的行看不到，和真的没有了
分不出来——截断的快照不做归因，_attribute 写明截断。
@@ -1132,20 +1139,40 @@ class _Compare:
说明里说的是引用的行外面有它的那一边（两边都有的，是引用得少的那一边；行数一样、只是引用的不是它同样那几行
的，两边排在前面的行数都写出来）；几个维度值切法都不同的，说基准运行引用的行里先出现的那个。
维度按两边整份结果认（和归因同一个规则，_dimensions）：遮罩列不当维度，只用没遮的列认、说明里写的也只有没遮的
列的值和行号，遮住的值不进说明；分不出维度（没有不是数值的列、维度列都设了遮罩）、行的形状不对的，只能按行号
认，返回 None。快照读不出来的说不清：只有单格会走到这里（行段在 _citation 里先核对整份结果，读不出来的已经
说不清），那一行两次是不是同一个维度值核对不了，和行段一样不按行号当成同一处。"""
按哪组维度核对（_dimensions，遮罩列不当维度）：两边整份结果认出的那组，加上归因用的那组（_attributed_rows：数组
字段只在它引用的那段行上认），两组不同时两组都核对，都是同一处才算同一处。归因只在引用的行上认维度：渠道在引用
的行里两边都只有「线上」，不当维度，归因按区域说南区的变化；只按整份结果的（区域, 渠道）核对，南区 / 线上两边
都整个被引用、南区 / 线下两边都没被引用，看着都切在同一处，按区域看南区这次却有一行（线下）在引用的行外面，
归因说的南区就不是同一组数——归因按哪组维度说，就要按哪组维度核对。只按归因用的那组也不够：只引用了一行的，
引用的行里每列都只有一个值，认不出维度；整份结果里分得清的维度（区域, 渠道）也要切在同一处。
遮罩列只用没遮的列认，说明里写的也只有没遮的列的值和行号，遮住的值不进说明；两组都分不出维度（没有不是数值的
列、维度列都设了遮罩）的，只能按行号认，返回 None。快照读不出来的说不清：只有单格会走到这里（行段在 _citation
里先核对整份结果，读不出来的已经说不清），那一行两次是不是同一个维度值核对不了，和行段一样不按行号当成同一处。
快照里有的行和列对不上（格数不对、不是一行）的，认不出各行是哪个维度值，同样说不清。"""
if qb.snap is None or qt.snap is None:
side = "基准运行" if qb.snap is None else "这次运行"
return _Change("unknown", f"{side}的查询快照无法读取，无法核对 {name}两次引用的{_rows_text(t)}"
"是不是同一个维度值")
rb, rt = _records(qb.snap, None), _records(qt.snap, None)
if rb is None or rt is None:
return None
dims, _ = _dimensions(qb.snap, qt.snap, rb, rt, column if isinstance(column, str) else "", self._hidden(b, t))
if not dims:
return None
side = "基准运行" if rb is None else "这次运行"
return _Change("unknown", f"{side}的查询快照里有的行和列对不上，无法核对 {name}两次引用的{_rows_text(t)}"
f"是不是同一{'个' if b.row is not None else '批'}维度值")
measure, hidden = column if isinstance(column, str) else "", self._hidden(b, t)
whole, _ = _dimensions(qb.snap, qt.snap, rb, rt, measure, hidden)
# 整份结果的行没问题，引用的那段行（它的一部分）也读得出来；单格的归因用整份结果，和 whole 是同一组
used, _ = _dimensions(qb.snap, qt.snap, _attributed_rows(qb.snap, b) or [], _attributed_rows(qt.snap, t) or [],
measure, hidden)
for dims in dict.fromkeys(tuple(d) for d in (whole, used) if d):
if (found := self._cut(name, what, b, t, rb, rt, list(dims))) is not None:
return found
return None
def _cut(self, name: str, what: str, b: Any, t: Any, rb: list[tuple[int, dict[str, Any]]],
rt: list[tuple[int, dict[str, Any]]], dims: list[str]) -> _Change | None:
"""按 dims 这组维度核对两边引用的是不是同一批维度值（规则见 _left_out）：是返回 None，不是返回说明。rb、rt 是
两边整份结果的行。"""
def split(records: list[tuple[int, dict[str, Any]]], inp: Any) -> tuple[dict[Any, int], dict[Any, list[int]]]:
"""{维度键: 引用的行里有几行}，{维度键: [引用的行外面的行号]}。一个键可能占几行（去掉日期这类每期都不同的
@@ -1165,18 +1192,29 @@ class _Compare:
single = b.row is not None # 和 t.row 一样（_citation 只在两边行号相同时走到这里）
cited, first = _rows_text(t), _cited(t, len(rt))[0]
def ahead(outside: list[int]) -> int:
"""它排在引用的行前面的行数：按查询结果的先后，引用的是它的第几行起。两边行号相同，first 是同一个。"""
return sum(1 for i in outside if i < first)
def cut(inside: int, outside: list[int]) -> tuple[int, int] | None:
"""行段切在这个维度值的哪儿：引用的行外面没有它的行记 None（整个被引用；快照里根本没有它的也是 None）；
有的记（它排在引用的行前面的行数, 引用了它几行）——按查询结果的先后，引用的是它的第几行到第几行。"""
return (sum(1 for i in outside if i < first), inside) if outside else None
return (ahead(outside), inside) if outside else None
for key in dict.fromkeys([*in_b, *in_t]): # 只看引用过的：两边都没引用的不进这个数
nb, nt = in_b.get(key, 0), in_t.get(key, 0)
ob, ot = out_b.get(key, []), out_t.get(key, [])
if single:
# 两边那一行是同一个维度值，是同一处；不是的，看只在一边被引用的它在另一边的快照里还有没有——有（只是
# 不在这一行）是换了一个数，没有是真的没有了、这次才有
if nb == nt or not (ot if nb > nt else ob):
if nb == nt:
# 那一行两次都是它（单格只有一行，nb、nt 都是 1）：还要是它同样的那一行，排在前面的行数一样
if ahead(ob) == ahead(ot):
continue
return _Change("unknown", f"{name}两次都引用{cited}，两次都是{_key_text(key)}，可不是它同样的那一行"
f"（它排在这一行前面的，基准运行有 {ahead(ob)} 行，这次有 {ahead(ot)} 行），"
f"取的不是{what}")
# 不是同一个维度值：看只在一边被引用的它在另一边的快照里还有没有——有（只是不在这一行）是换了一个数，
# 没有是真的没有了、这次才有
if not (ot if nb > nt else ob):
continue
else:
cb, ct = cut(nb, ob), cut(nt, ot)
@@ -1549,7 +1587,7 @@ class _Compare:
self.masked_seen = True
if measure.lower() in hidden:
return {**empty, "note": MASKED_MEASURE.format(column=measure)}
rb, rt = _records(sb, b.rows), _records(st, t.rows)
rb, rt = _attributed_rows(sb, b), _attributed_rows(st, t)
if rb is None or rt is None:
return None
values = (_input_total(b), _input_total(t))
@@ -1751,6 +1789,14 @@ def _records(snap: dict[str, Any], span: tuple[int, int] | None) -> list[tuple[i
return out
def _attributed_rows(snap: dict[str, Any], inp: Any) -> list[tuple[int, dict[str, Any]]] | None:
"""归因用的行（_attribute 在这些行上认维度、按维度汇总）：数组字段是它引用的那一段行，单格是整份结果（单格按
整份结果归因，取的是合计行那一格时再去掉合计行）。_left_out 在同样这些行上再认一遍维度、按它核对引用的是不是同一
批维度值：归因按哪组维度说，就按哪组维度核对，两处取行的规则只写在这里。单格核对的是那一行本身，归因不把它和别的
行合在一起算，去不去合计行不影响核对。"""
return _records(snap, inp.rows)
def _kind(snap: dict[str, Any], column: str) -> str | None:
types = snap.get("column_types")
kind = types.get(column) if isinstance(types, dict) else None
backend/tests/test_compare_engine.py
+324 -19
View File
@@ -10,12 +10,15 @@ SQL，Agent 节点 bot 自己再查一次、把各区域的金额作为数组字
- 遮罩列的值绝不出现在结果里（只有一边的快照遮了也算遮了）；用到遮罩列的指标不拆分
- 模板对比：新增、删除的节点，配置有变化的节点和配置项名
- 输入的出处：合并查询追到它的上游查询；Agent 按出处交的字段还要引用同一列、同一段行（行段相同、一边是整份结果
一边不是的不算；都不是整份结果的，引用过的每个区域两边要被切在同一处——都整个被引用（一边没有这个区域的算整个
被引用），或者都只引用了它同样的那几行（排在引用的行前面的行数、引用的行数都一样）——区域整个挪出去、区域 ×
日期的结果里有一天被挤出去、多了一天却只引用了前几天都不算；维度有几列的按几列一起认；单格只看那一行是不是同一个
区域，那一边快照读不出来的说不清）；没按出处交的数、上游数据没变数却变了的、上游的 Agent 两次交出的结果不同的，
说不清变化从哪来（incomparable），记不出写入者的只看口径卡之前可能执行过的节点（循环回边连回来的算在它之前，严格
拆分也照这个范围核对）；图里写死的字面量改了、连线变了、读到的默认设置变了都算模板变化
一边不是的不算，起止行有一个不同的不算；都不是整份结果的，引用过的每个区域两边要被切在同一处——都整个被引用（一边
没有这个区域的算整个被引用），或者都只引用了它同样的那几行（排在引用的行前面的行数、引用的行数都一样，后面剩几行
不管）——区域整个挪出去、区域 × 日期的结果里有一天被挤出去、多了一天却只引用了前几天都不算，两边都没引用的区域
不管；维度有几列的按几列一起认，归因只按引用的行里分得出的那几列说，就按那几列再核对一遍；单格那一行要是同一个
区域的同一行（排在它前面的、这个区域的行数一样）；快照读不出来、有的行和列对不上的说不清）；没按出处交的数、上游
数据没变数却变了的、上游的 Agent 两次交出的结果不同的，说不清变化从哪来（incomparable），记不出写入者的只看口径卡
之前可能执行过的节点（循环回边连回来的算在它之前，只在一次运行的图里有的节点按两次的图合起来认先后，严格拆分也照
这个范围核对）；图里写死的字面量改了、连线变了、读到的默认设置变了都算模板变化；不归因的指标用到遮罩列也在整体
说明里提一句
"""
from __future__ import annotations
@@ -564,6 +567,20 @@ def test_a_masked_measure_is_not_attributed():
assert "1200.5" not in json.dumps(east["inputs"]) and "800.0" not in json.dumps(result)
def test_a_masked_input_is_noted_even_without_attribution():
"""取数的 SQL 这次加了筛选（结构变了，不做归因），指标的输入取自遮罩列：整体说明照样提一句有列设了遮罩——输入的值
不给，看的人要知道是遮掉了，不是没有。只在归因时才记，不归因的指标就漏了这一句。"""
def masked(run):
run.masked = {a: frozenset({"gmv"}) for a in run.queries}
return run
result = run_compare(masked(week("r1")), masked(week("r2", NEXT_ROWS, sql=region_sql(extra=" AND paid = 1"))))
metrics = by_id(result)
assert {m["classification"] for m in metrics.values()} == {"sql_changed"}
assert all(m["attribution"] is None for m in metrics.values())
assert metrics["east"]["inputs"][0]["masked"] is True and metrics["east"]["inputs"][0]["base"] is None
assert compare.MASKED_NOTE in result["notes"]
# --------------------------------------------------------------------------
# 对不上具体查询的输入、运行输入、一边才有的指标
# --------------------------------------------------------------------------
@@ -821,6 +838,29 @@ def test_a_split_with_an_unknown_writer_leaves_out_the_card_and_what_follows_it(
assert calc["decomposition_note"] is None
def test_a_node_after_the_card_in_one_run_only_is_still_after_it():
"""记不出 vars.adj 是哪个节点写的，口径卡下游的写周报只在一次运行的图里有（这次删掉了，或者这次才加上）：按两次
运行合起来的图，它在口径卡之后执行，写不了口径卡读到的值，不点名、不挡住数据变化。只按这次的图认先后，删掉的写周报
在这次的图里没有连线，就成了「和口径卡不在一条线上」，被说成来源；只按基准运行的图，这次才加上的也一样。"""
def make(run_id, rows, value, with_report):
nodes = [node("start", "input", "开始"),
node("fetch", "tool", "区域取数", tool=TOOL, args={"sql": region_sql()}),
node("calc", "code", "调整", code="x", assign_to="adj"),
node("card", "metrics", "周报口径卡", caliber="周报口径", caliber_version="v1"),
*([node("write", "report", "写周报")] if with_report else []),
node("out", "output", "成果")]
run = Fake(run_id, graph=chain(*nodes))
run.tool("fetch", region_sql(), rows=rows)
run.code("calc", value, "adj")
run.card([metric("calc", "vars.adj * 2", value * 2, [scalar_in("vars.adj", value, None, "state")])])
return run
for label, base, target in (("这次删掉了写周报", make("r1", BASE_ROWS, 10, True), make("r2", NEXT_ROWS, 12, False)),
("这次才加上写周报", make("r1", BASE_ROWS, 10, False), make("r2", NEXT_ROWS, 12, True))):
calc = by_id(run_compare(base, target))["calc"]
assert (calc["classification"], calc["reasons"]) == ("data_only", [compare.DATA_FROM_UPSTREAM_SCOPED]), label
def test_a_run_input_upstream_of_a_code_node_is_a_parameter_change():
"""代码节点上游查到的数据两次一模一样，只有运行输入变了：它交的数变了算参数变化。"""
def make(run_id, goal, value):
@@ -1173,6 +1213,16 @@ def test_an_agent_citing_other_rows_is_not_a_data_change():
total = by_id(run_compare(cited("r1"), cited("r2", span=(1, 2))))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert any("行" in r for r in total["reasons"]), total["reasons"]
# 起始行一样、只差最后一行（按金额取前 3 改成前 4，多引用的那一行是这次新出现的北区）：同样不是同一组数。只比起始行
# 会走到按区域核对，北区只在这次有、算两边都整个被引用，就报成北区多了 400、占比 67%
top = region_sql().replace("ORDER BY region", "ORDER BY gmv DESC")
total = by_id(run_compare(
cited("r1", [["东区", 1200.5, 100.0], ["南区", 800.0, 50.0], ["西区", 600.0, 0.0], ["中区", 30.0, 0.0]],
span=(0, 2), sql=top),
cited("r2", [["东区", 1500.5, 120.0], ["南区", 700.0, 40.0], ["西区", 600.0, 10.0], ["北区", 400.0, 0.0],
["中区", 35.0, 0.0]], span=(0, 3), sql=top)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」引用的行由第 1 至 3 行改为第 1 至 4 行，取的不是同一组数"]
# 两边引用的都是整份结果（这次多了一个区域）：照常是数据变化
total = by_id(run_compare(cited("r1"), cited("r2", [*NEXT_ROWS, ["北区", 90.0, 0.0]])))["total"]
assert total["classification"] == "data_only" and total["attribution"]["rows"]
@@ -1231,6 +1281,16 @@ def test_the_same_rows_are_not_the_same_citation_when_a_cited_region_moved_out_o
(["北区"], None, 700.0, 7.0), (["西区"], 600.0, None, -6.0), (["东区"], 1200.0, 1200.0, 0.0),
(["南区"], 800.0, 800.0, 0.0)]
assert sum(exact(r["share"]) for r in rows) == 1
# 对照：前 3 名还是那三个区域，只有排在引用的行后面的第 4 名每周不同（中区换成北区）——两边都没引用的区域不进
# 核对，照常是数据变化（最常见的取前几名；连它也核对，每周的对比就都说不清了）
tail = [["东区", 1300.0, 0.0], ["南区", 700.0, 0.0], ["西区", 650.0, 0.0], ["北区", 20.0, 0.0]]
total = by_id(run_compare(cited("r1", before, span=(0, 2), sql=top),
cited("r2", tail, span=(0, 2), sql=top)))["total"]
assert (total["classification"], total["reasons"]) == ("data_only", [compare.DATA_FROM_QUERIES])
rows = total["attribution"]["rows"]
assert [(r["key"], r["base"], r["target"], r["share"]) for r in rows] == [
(["东区"], 1200.0, 1300.0, 2.0), (["南区"], 800.0, 700.0, -2.0), (["西区"], 600.0, 650.0, 1.0)]
assert sum(exact(r["share"]) for r in rows) == 1
# 区域列设了遮罩：不拿它认是哪一区，只能按行号认，遮住的区域名不出现在结果里
def masked(run):
@@ -1310,18 +1370,18 @@ def test_cited_rows_on_an_unreadable_snapshot_are_not_taken_as_the_same():
assert total["reasons"] == ["Agent「区域分析」引用的行由第 1 至 3 行改为第 2 至 3 行，取的不是同一组数"]
def element(run_id, rows, span, *, sql=None, columns=COLUMNS, types=TYPES):
"""口径卡取 Agent 数组字段 amounts 的第一个元素（vars.kpi.amounts[0]）：落在快照上的是 Agent 交的行段的第一行。
sql、columns、types 换查询的形状（默认是按区域汇总的那条）。"""
def element(run_id, rows, span, *, index=0, sql=None, columns=COLUMNS, types=TYPES):
"""口径卡取 Agent 数组字段 amounts 的第 index 个元素（默认 vars.kpi.amounts[0]）：落在快照上的是 Agent 交的行段的
第 span[0] + index 行。sql、columns、types 换查询的形状（默认是按区域汇总的那条）。指标的 id 总是 first。"""
run = Fake(run_id)
sql = sql or region_sql()
run.tool("fetch", sql, columns, rows, types=types)
bot = run.agent("bot", sql, columns, rows, types=types, span=span)
row, at = span[0], columns.index("gmv")
item = {"path": "vars.kpi.amounts[0]", "value": rows[row][at], "node_id": "bot", "via": "agent_field",
"field": "amounts[0]", "ref": f"Q1.r{row}.gmv", "artifact": bot,
row, at = span[0] + index, columns.index("gmv")
item = {"path": f"vars.kpi.amounts[{index}]", "value": rows[row][at], "node_id": "bot", "via": "agent_field",
"field": f"amounts[{index}]", "ref": f"Q1.r{row}.gmv", "artifact": bot,
"locator": {"row": row, "column": "gmv"}, "eid": f"ev:cell:{bot[:8]}:{row}:gmv", "status": "verified"}
run.card([metric("first", "vars.kpi.amounts[0]", rows[row][at], [item])])
run.card([metric("first", f"vars.kpi.amounts[{index}]", rows[row][at], [item])])
return run
@@ -1339,6 +1399,14 @@ def test_an_element_of_a_cited_array_follows_its_row():
assert first["classification"] == "incomparable"
assert first["reasons"] == ["Agent「区域分析」两次都引用第 1 行，「东区」这次仍在查询结果第 2 行，不在引用的行里，"
"取的不是同一个数"]
# 反方向：基准运行北区排在第 1 行、东区在第 2 行，这次北区没了、东区到了第 1 行。这次取的东区在基准运行的快照里，
# 只是不在这一行，同样不是同一个数（只查「基准运行取的北区这次还在不在」，北区这次没了，会把北区 90 和东区
# 1500.5 当成同一个数报成数据变化）
first = by_id(run_compare(element("r1", [["北区", 90.0, 0.0], *BASE_ROWS], (0, 3)),
element("r2", NEXT_ROWS, (0, 2))))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 1 行，「东区」在基准运行中位于查询结果第 2 行，不在引用的"
"行里，取的不是同一个数"]
def test_an_element_on_an_unreadable_snapshot_is_not_taken_as_the_same():
@@ -1358,6 +1426,22 @@ def test_an_element_on_an_unreadable_snapshot_is_not_taken_as_the_same():
assert first["reasons"] == ["基准运行的查询快照无法读取，无法核对 Agent「区域分析」两次引用的第 1 行是不是同一个维度值"]
def test_cited_rows_on_a_snapshot_with_misshapen_rows_are_not_taken_as_the_same():
"""有一边的快照里有一行的格数和列对不上（引用的行外面那一行少了一格）：认不出各行是哪个区域，引用的是不是同一批
区域核对不了，和快照读不出来一样说不清，不退回按行号认（这次北区排进了前 3，西区挪到了第 4 行，按行号认会把西区
算成「数据没了」）。两个方向都是。"""
with_middle = [["东区", 1200.5, 100.0], ["南区", 800.0, 50.0], ["西区", 600.0, 0.0], ["中区", 30.0, 0.0]]
broken = [*WITH_NORTH[:3], ["西区", 600.0]]
total = by_id(run_compare(cited("r1", with_middle, span=(0, 2)), cited("r2", broken, span=(0, 2))))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["这次运行的查询快照里有的行和列对不上，无法核对 Agent「区域分析」两次引用的第 1 至 3 行"
"是不是同一批维度值"]
total = by_id(run_compare(cited("r1", broken, span=(0, 2)), cited("r2", with_middle, span=(0, 2))))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["基准运行的查询快照里有的行和列对不上，无法核对 Agent「区域分析」两次引用的第 1 至 3 行"
"是不是同一批维度值"]
#: 区域 × 日期的结果：日期按设计不当维度（每期都不同，见 _dimensions），一个区域占几行
BY_DAY_SQL = "SELECT region, day, SUM(amount) AS gmv FROM orders GROUP BY region, day ORDER BY region, day"
BY_DAY_COLUMNS = ["region", "day", "gmv"]
@@ -1521,6 +1605,35 @@ def test_a_region_cut_at_the_same_place_on_both_sides_is_the_same_citation():
assert [(r["key"], r["base"], r["target"], r["share"]) for r in rows] == [
(["东区"], 200.0, 230.0, 1.5), (["南区"], 50.0, 40.0, -0.5)]
assert sum(exact(r["share"]) for r in rows) == 1
# 切在哪儿只看排在引用的行前面的行数、引用的行数，不看后面还剩几行：南区这次多了一天、排在引用的行后面（后面
# 剩两天，基准运行剩一天），引用的仍是南区的第一天，照常是数据变化
longer = after[:4] + [["南区", "2026-09-10", 60.0]] + after[4:]
total = by_id(run_compare(by_day("r1", before, span=(0, 2)), by_day("r2", longer, span=(0, 2))))["total"]
assert (total["classification"], total["reasons"]) == ("data_only", [compare.DATA_FROM_QUERIES])
rows = total["attribution"]["rows"]
assert [(r["key"], r["base"], r["target"], r["share"]) for r in rows] == [
(["东区"], 200.0, 230.0, 1.5), (["南区"], 50.0, 40.0, -0.5)]
# 两边都只引用了南区的一部分、后面都剩一天，引用的行数却不同（基准运行两天，这次东区少了一天、南区引用了三天）：
# 切在了不同处。两边都有一行在外面，说引用得少的基准运行
base3 = [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 100.0], ["南区", "2026-09-01", 50.0],
["南区", "2026-09-02", 50.0], ["南区", "2026-09-03", 500.0], ["西区", "2026-09-01", 30.0]]
now3 = [["东区", "2026-09-08", 100.0], ["南区", "2026-09-07", 50.0], ["南区", "2026-09-08", 50.0],
["南区", "2026-09-09", 50.0], ["南区", "2026-09-10", 500.0], ["西区", "2026-09-08", 30.0]]
total = by_id(run_compare(by_day("r1", base3), by_day("r2", now3)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 4 行，「南区」在基准运行中有 1 行位于查询结果第 5 行，"
"不在引用的行里，取的不是同一组数"]
# 南区在基准运行里一行都没被引用（两天都在外面），这次引用了两天、还有一天在外面：说引用得少的基准运行，写它在
# 外面的那两行
east4 = [["东区", f"2026-09-0{d}", 100.0] for d in range(1, 5)] + [["南区", "2026-09-01", 50.0],
["南区", "2026-09-02", 50.0]]
south3 = [["东区", "2026-09-08", 100.0], ["东区", "2026-09-09", 100.0], ["南区", "2026-09-08", 50.0],
["南区", "2026-09-09", 50.0], ["南区", "2026-09-10", 50.0]]
total = by_id(run_compare(by_day("r1", east4), by_day("r2", south3)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 4 行，「南区」在基准运行中位于查询结果第 5、6 行，不在"
"引用的行里，取的不是同一组数"]
# 东区这次少了一天，南区引用了两天、第三天在第 4 行；基准运行只引用了南区一天、第二天在第 4 行：基准引用得少
more = [["东区", "2026-09-08", 100.0], ["南区", "2026-09-07", 50.0], ["南区", "2026-09-08", 50.0],
@@ -1563,6 +1676,28 @@ def test_a_region_cut_on_other_rows_of_it_is_not_the_same_citation():
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 2 至 4 行，两次都引用了「东区」的 1 行，可不是它同样的"
"那几行（它排在引用的行前面的，基准运行有 1 行，这次有 0 行），取的不是同一组数"]
# 排在前面的行数要数清，不只看有没有：基准运行引用的是东区第三高的那天（前面有 2 行），这次是第二高的那天（前面
# 有 1 行）
third = [["东区", "2026-09-01", 300.0], ["东区", "2026-09-02", 280.0], ["东区", "2026-09-03", 250.0],
["南区", "2026-09-01", 200.0], ["西区", "2026-09-01", 50.0]]
second = [["东区", "2026-09-08", 320.0], ["西区", "2026-09-08", 300.0], ["东区", "2026-09-09", 260.0],
["南区", "2026-09-08", 210.0], ["东区", "2026-09-10", 100.0]]
total = by_id(run_compare(by_day("r1", third, span=(2, 3), sql=top),
by_day("r2", second, span=(2, 3), sql=top)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 3 至 4 行，两次都引用了「东区」的 1 行，可不是它同样的"
"那几行（它排在引用的行前面的，基准运行有 2 行，这次有 1 行），取的不是同一组数"]
# 说明里的「引用了它几行」是引用的行里的行数，不是它在外面的行数：基准运行东区在外面有两行（前一后一），引用的
# 仍是一行
around = [["东区", "2026-09-01", 300.0], ["东区", "2026-09-02", 250.0], ["南区", "2026-09-01", 200.0],
["东区", "2026-09-03", 100.0]]
shifted = [["西区", "2026-09-08", 400.0], ["东区", "2026-09-08", 300.0], ["南区", "2026-09-08", 250.0],
["东区", "2026-09-09", 200.0]]
total = by_id(run_compare(by_day("r1", around, span=(1, 2), sql=top),
by_day("r2", shifted, span=(1, 2), sql=top)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 2 至 3 行，两次都引用了「东区」的 1 行，可不是它同样的"
"那几行（它排在引用的行前面的，基准运行有 1 行，这次有 0 行），取的不是同一组数"]
# 对照：两次都是东区第二高的那天被引用（最高的那天都排在前面）
same = [["东区", "2026-09-08", 320.0], ["东区", "2026-09-09", 260.0], ["南区", "2026-09-08", 210.0],
["南区", "2026-09-09", 140.0], ["西区", "2026-09-08", 60.0]]
@@ -1657,14 +1792,120 @@ def test_dimension_values_are_told_apart_by_every_dimension_column():
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 2 行，「东区」这次有 2 行在查询结果第 3、4 行，不在"
"引用的行里，取的不是同一组数"]
# 引用的行两边都只有东区、只有这次的整份结果里多了北区：区域要按两边整份结果认（只看基准运行的行，或者只看引用的
# 行，都认不出区域，退回按行号认）。基准运行东区三天只引用了前两天，这次东区两天都被引用，切法不同
east3 = [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 90.0], ["东区", "2026-09-03", 80.0]]
east2 = [["东区", "2026-09-08", 100.0], ["东区", "2026-09-09", 95.0], ["北区", "2026-09-08", 85.0]]
total = by_id(run_compare(by_day("r1", east3, span=(0, 1)), by_day("r2", east2, span=(0, 1))))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 2 行，「东区」在基准运行中有 1 行位于查询结果第 3 行，"
"不在引用的行里，取的不是同一组数"]
def test_an_element_only_needs_the_same_region_on_its_row():
"""口径卡取 Agent 数组字段的第一个元素（单格）：只看引用的那一行两次是不是同一个区域。区域 × 日期的结果里，基准
运行东区两天（第二天在引用的行外面）、这次只有一天：第 1 行两次都是东区的第一天，是同一个数，照常是数据变化。行段
要看每个区域被切成什么样（整个、还是只有一部分），因为口径卡按引用的几行一起算；单格只有一行，东区还有没有别的行
不改变它取的是哪个数。第 1 行的东区这次真的没有了（换成了北区，东区不在这次的快照里）也照常比；东区还在快照里、
只是不在第 1 行的说不清（test_an_element_of_a_cited_array_follows_its_row）。"""
def test_the_cited_column_is_never_a_dimension_even_when_stored_as_text():
"""金额列在库里是文本类型（存的是数字文本，查询层记的类型是 text）：Agent 引用的这一列是度量，不拿来认维度。拿来认，
每个（区域, 金额）都成了只在一边有的维度值，算「真的没有了、这次才有」，南区的第二天挤出引用的行（东区多了一天）
就查不出来，报成只数据变。"""
types = {**BY_DAY_TYPES, "gmv": "text"}
def make(run_id, rows):
shown = [[region, day, str(gmv)] for region, day, gmv in rows]
run = Fake(run_id)
run.tool("fetch", BY_DAY_SQL, BY_DAY_COLUMNS, shown, types=types)
bot = run.agent("bot", BY_DAY_SQL, BY_DAY_COLUMNS, shown, types=types, span=(0, 3))
run.card([metric("total", "sum(vars.kpi.amounts)", sum(r[2] for r in rows[:4]),
[amounts_in(bot, shown, span=(0, 3))])])
return run
before = [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 100.0], ["南区", "2026-09-01", 50.0],
["南区", "2026-09-02", 40.0], ["西区", "2026-09-01", 30.0]]
after = [["东区", "2026-09-07", 100.0], ["东区", "2026-09-08", 100.0], ["东区", "2026-09-09", 100.0],
["南区", "2026-09-08", 60.0], ["南区", "2026-09-09", 45.0], ["西区", "2026-09-08", 30.0]]
total = by_id(run_compare(make("r1", before), make("r2", after)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 4 行，「南区」这次有 1 行在查询结果第 5 行，不在引用"
"的行里，取的不是同一组数"]
#: 区域 × 渠道 × 日期（日期不当维度），按区域、日期排序
BY_CHANNEL_DAY = {"sql": "SELECT region, channel, day, SUM(amount) AS gmv FROM orders GROUP BY region, channel, day "
"ORDER BY region, day",
"columns": ["region", "channel", "day", "gmv"],
"types": {"region": "text", "channel": "text", "day": "date", "gmv": "number"}}
def test_cited_rows_are_checked_by_the_dimensions_the_attribution_uses():
"""归因只在引用的行上认维度（_attribute）：渠道在引用的行里两边都只有「线上」，不当维度，归因按区域说。核对引用的
是不是同一批区域也要按区域核对一遍——只按整份结果认维度（区域, 渠道），南区 / 线上两边都整个被引用、南区 / 线下
两边都没被引用，看着都切在同一处，按区域看南区这次却有一行在引用的行外面，归因说的南区就不是同一组数。
区域 × 渠道 × 日期，两次都引用第 1 至 4 行：东区这次多了一天，南区的第二天这次走的是线下，排到第 5 行（还在快照
里）。按引用的行归因，南区是 100 → 50（占比 -100%），和「南区这次真的只有一天」的输出一字不差；反方向也是。区域 ×
渠道按金额取前 2 行：南区这次新开了线下（200），排第 3——快照里南区是 300 → 480，按引用的行归因却是 300 → 280，
正负号都反了。对照：南区真的只有引用的那几行的，照常是数据变化，按区域归因，占比之和为 1。"""
base = [["东区", "线上", "2026-09-01", 100.0], ["东区", "线上", "2026-09-02", 100.0],
["南区", "线上", "2026-09-01", 50.0], ["南区", "线上", "2026-09-02", 50.0],
["西区", "线上", "2026-09-01", 30.0], ["西区", "线上", "2026-09-02", 30.0]]
this = [["东区", "线上", "2026-09-07", 100.0], ["东区", "线上", "2026-09-08", 100.0],
["东区", "线上", "2026-09-09", 100.0], ["南区", "线上", "2026-09-08", 50.0],
["南区", "线下", "2026-09-09", 50.0], ["西区", "线上", "2026-09-08", 30.0],
["西区", "线上", "2026-09-09", 30.0]]
total = by_id(run_compare(by_day("r1", base, **BY_CHANNEL_DAY), by_day("r2", this, **BY_CHANNEL_DAY)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 4 行，「南区」这次有 1 行在查询结果第 5 行，不在引用"
"的行里，取的不是同一组数"]
total = by_id(run_compare(by_day("r1", this, **BY_CHANNEL_DAY), by_day("r2", base, **BY_CHANNEL_DAY)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 4 行，「南区」在基准运行中有 1 行位于查询结果第 5 行，"
"不在引用的行里，取的不是同一组数"]
# 对照：南区这次真的只有一天（没有线下那一行）
gone = [r for r in this if r[1] != "线下"]
total = by_id(run_compare(by_day("r1", base, **BY_CHANNEL_DAY), by_day("r2", gone, **BY_CHANNEL_DAY)))["total"]
assert (total["classification"], total["reasons"]) == ("data_only", [compare.DATA_FROM_QUERIES])
attribution = total["attribution"]
assert attribution["columns"] == ["region"]
assert [(r["key"], r["base"], r["target"], r["share"]) for r in attribution["rows"]] == [
(["东区"], 200.0, 300.0, 2.0), (["南区"], 100.0, 50.0, -1.0)]
assert sum(exact(r["share"]) for r in attribution["rows"]) == 1
# 区域 × 渠道按金额取前 2 行：南区这次新开了线下，排第 3
before = [["东区", "线上", 500.0], ["南区", "线上", 300.0], ["西区", "线上", 100.0]]
after = [["东区", "线上", 600.0], ["南区", "线上", 280.0], ["南区", "线下", 200.0], ["西区", "线上", 120.0]]
total = by_id(run_compare(by_day("r1", before, span=(0, 1), **BY_CHANNEL),
by_day("r2", after, span=(0, 1), **BY_CHANNEL)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 1 至 2 行，「南区」这次有 1 行在查询结果第 3 行，不在引用"
"的行里，取的不是同一组数"]
# 对照：南区真的只有线上（这次多出来的北区排在最后，两边都没引用）
only_online = [["东区", "线上", 600.0], ["南区", "线上", 280.0], ["西区", "线上", 120.0], ["北区", "线上", 10.0]]
total = by_id(run_compare(by_day("r1", before, span=(0, 1), **BY_CHANNEL),
by_day("r2", only_online, span=(0, 1), **BY_CHANNEL)))["total"]
assert (total["classification"], total["reasons"]) == ("data_only", [compare.DATA_FROM_QUERIES])
rows = total["attribution"]["rows"]
assert [(r["key"], r["base"], r["target"], r["share"]) for r in rows] == [
(["东区"], 500.0, 600.0, 1.25), (["南区"], 300.0, 280.0, -0.25)]
assert sum(exact(r["share"]) for r in rows) == 1
# 只按归因用的那组也不够：只引用了一行的，引用的行里每列都只有一个值，认不出维度（也不归因）。按金额排的第 2 行，
# 基准运行是东区第二高的那天，这次是东区最高的那天——按整份结果认出的区域照样核对，说不清
top = BY_DAY_SQL.replace("ORDER BY region, day", "ORDER BY gmv DESC")
ranked_before = [["东区", "2026-09-01", 300.0], ["东区", "2026-09-02", 250.0], ["南区", "2026-09-01", 200.0]]
ranked_after = [["南区", "2026-09-08", 350.0], ["东区", "2026-09-08", 300.0], ["东区", "2026-09-09", 100.0]]
total = by_id(run_compare(by_day("r1", ranked_before, span=(1, 1), sql=top),
by_day("r2", ranked_after, span=(1, 1), sql=top)))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
assert total["reasons"] == ["Agent「区域分析」两次都引用第 2 至 2 行，两次都引用了「东区」的 1 行，可不是它同样的"
"那几行（它排在引用的行前面的，基准运行有 1 行，这次有 0 行），取的不是同一组数"]
def test_an_element_does_not_mind_other_rows_of_its_region():
"""口径卡取 Agent 数组字段的第一个元素（单格）：不套行段的切法，只看引用的那一行两次是不是同一个区域的同一行（排在
它前面的、这个区域的行数一样，见 test_an_element_on_another_row_of_the_same_region_is_not_the_same_number），不看这个
区域在这一行外面还有没有行。区域 × 日期的结果里，基准运行东区两天（第二天在引用的行外面）、这次只有一天：第 1 行
两次都是东区的第一天，是同一个数，照常是数据变化。行段要看每个区域被切成什么样（整个、还是只有一部分），因为口径卡
按引用的几行一起算；单格只有一行，东区还有没有别的行不改变它取的是哪个数。第 1 行的东区这次真的没有了（换成了
北区，东区不在这次的快照里）也照常比；东区还在快照里、只是不在第 1 行的说不清
（test_an_element_of_a_cited_array_follows_its_row）。"""
day = {"sql": BY_DAY_SQL, "columns": BY_DAY_COLUMNS, "types": BY_DAY_TYPES}
before = [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 90.0], ["南区", "2026-09-01", 50.0],
["西区", "2026-09-01", 30.0]]
@@ -1678,6 +1919,70 @@ def test_an_element_only_needs_the_same_region_on_its_row():
assert (first["classification"], first["reasons"]) == ("data_only", [compare.DATA_FROM_QUERIES])
def test_an_element_on_another_row_of_the_same_region_is_not_the_same_number():
"""单格引用的那一行两次是同一个区域，还要是它同样的那一行：按查询结果的先后，排在这一行前面的、它的行数两边一样。
区域 × 日期的结果里，Agent 两次都交第 3 至 5 行，口径卡取第一个元素（第 3 行）：基准运行那是南区的第一天（50）；
这次东区真的少了一天，第 3 行成了南区的第二天（45），南区的第一天（60）在第 2 行。只看「是不是南区」会报成南区
少了 5，同一天的南区其实多了 10，正负号都反了。同一处引用换成只有一行的行段（第 3 至 3 行）说不清，单格也说不清。
按金额排的取第 2 行（基准运行是东区第二高的那天，这次是最高的那天）、取第二个元素的也一样。
只比排在前面的行数、不比「它在这一行外面还有没有行」：东区两天还是一天，第 1 行都是东区的第一天，照常是数据变化
（test_an_element_does_not_mind_other_rows_of_its_region）。"""
day = {"sql": BY_DAY_SQL, "columns": BY_DAY_COLUMNS, "types": BY_DAY_TYPES}
before = [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 90.0], ["南区", "2026-09-01", 50.0],
["南区", "2026-09-02", 40.0], ["西区", "2026-09-01", 30.0]]
after = [["东区", "2026-09-08", 110.0], ["南区", "2026-09-08", 60.0], ["南区", "2026-09-09", 45.0],
["西区", "2026-09-08", 30.0], ["西区", "2026-09-09", 20.0]]
first = by_id(run_compare(element("r1", before, (2, 4), **day), element("r2", after, (2, 4), **day)))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 3 行，两次都是「南区」，可不是它同样的那一行（它排在这一行"
"前面的，基准运行有 0 行，这次有 1 行），取的不是同一个数"]
first = by_id(run_compare(element("r1", after, (2, 4), **day), element("r2", before, (2, 4), **day)))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 3 行，两次都是「南区」，可不是它同样的那一行（它排在这一行"
"前面的，基准运行有 1 行，这次有 0 行），取的不是同一个数"]
# 同样的两份结果，只有一行的行段：同样说不清，单格不比它松
total = by_id(run_compare(by_day("r1", before, span=(2, 2)), by_day("r2", after, span=(2, 2))))["total"]
assert total["classification"] == "incomparable" and total["attribution"] is None
# 按金额排，取 Agent 交的第 2 至 3 行的第一个元素：基准运行是东区第二高的那天（250），这次是东区最高的那天（300）
top = {**day, "sql": BY_DAY_SQL.replace("ORDER BY region, day", "ORDER BY gmv DESC")}
ranked_before = [["东区", "2026-09-01", 300.0], ["东区", "2026-09-02", 250.0], ["南区", "2026-09-01", 200.0]]
ranked_after = [["南区", "2026-09-08", 350.0], ["东区", "2026-09-08", 300.0], ["东区", "2026-09-09", 100.0]]
first = by_id(run_compare(element("r1", ranked_before, (1, 2), **top),
element("r2", ranked_after, (1, 2), **top)))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 2 行，两次都是「东区」，可不是它同样的那一行（它排在这一行"
"前面的，基准运行有 1 行，这次有 0 行），取的不是同一个数"]
# 排在前面的行数要数清，不只看有没有：第 3 行基准运行是东区第三高的那天（前面有 2 行），这次是第二高的那天（前面
# 有 1 行）
third = [["东区", "2026-09-01", 300.0], ["东区", "2026-09-02", 280.0], ["东区", "2026-09-03", 250.0],
["南区", "2026-09-01", 200.0]]
second = [["东区", "2026-09-08", 320.0], ["西区", "2026-09-08", 300.0], ["东区", "2026-09-09", 260.0],
["南区", "2026-09-08", 210.0], ["东区", "2026-09-10", 100.0]]
first = by_id(run_compare(element("r1", third, (2, 3), **top), element("r2", second, (2, 3), **top)))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 3 行，两次都是「东区」，可不是它同样的那一行（它排在这一行"
"前面的，基准运行有 2 行，这次有 1 行），取的不是同一个数"]
# 取第二个元素（Agent 交第 1 至 3 行，落在第 2 行）：基准运行是东区的第二天，这次北区排到第 1 行，第 2 行是东区的
# 第一天
first = by_id(run_compare(
element("r1", [["东区", "2026-09-01", 100.0], ["东区", "2026-09-02", 90.0], ["南区", "2026-09-01", 50.0]],
(0, 2), index=1, **day),
element("r2", [["北区", "2026-09-08", 70.0], ["东区", "2026-09-08", 95.0], ["南区", "2026-09-08", 55.0]],
(0, 2), index=1, **day)))["first"]
assert first["classification"] == "incomparable" and first["attribution"] is None
assert first["reasons"] == ["Agent「区域分析」两次都引用第 2 行，两次都是「东区」，可不是它同样的那一行（它排在这一行"
"前面的，基准运行有 1 行，这次有 0 行），取的不是同一个数"]
# 对照：第 3 行两次都是南区的第一天（排在它前面的南区行两边都是 0），照常是数据变化：50 → 60
same = [["东区", "2026-09-08", 110.0], ["东区", "2026-09-09", 100.0], ["南区", "2026-09-08", 60.0],
["南区", "2026-09-09", 45.0], ["西区", "2026-09-08", 30.0]]
first = by_id(run_compare(element("r1", before, (2, 4), **day), element("r2", same, (2, 4), **day)))["first"]
assert (first["classification"], first["reasons"], first["delta"]) == ("data_only", [compare.DATA_FROM_QUERIES],
10.0)
def test_no_split_when_an_old_leaf_now_cites_another_column():
"""口径变了（v1 → v2），旧口径用到的 Agent 字段这次引用的是退款列：说不清它只是数据变了，不拆，说明为什么。"""
def make(run_id, column, expression, factor, version):