429 lines
23 KiB
Python
429 lines
23 KiB
Python
"""统计口径独立对账。
|
||
|
||
后端自检只校验了 `code == 0` 和「返回非空」，口径算错了它发现不了。
|
||
这里把每个统计接口的结果，和**用 Python 直接从原始列重算一遍**的值对比，
|
||
其中年龄/标准差/就业率/及格率都在 Python 侧独立实现，不借用被测代码的 SQL 表达式。
|
||
|
||
用法：
|
||
python verify/statistics_crosscheck.py [--base http://127.0.0.1:8010]
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import argparse
|
||
import statistics
|
||
import sys
|
||
from datetime import date
|
||
from pathlib import Path
|
||
|
||
import httpx
|
||
from sqlalchemy import text
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
|
||
from app.core.database import engine # noqa: E402
|
||
|
||
PASS: list[str] = []
|
||
FAIL: list[str] = []
|
||
BASE = "http://127.0.0.1:8010"
|
||
|
||
|
||
def check(title: str, ok: bool, detail: str = "") -> None:
|
||
if ok:
|
||
PASS.append(title)
|
||
print(f" [PASS] {title}" + (f" {detail}" if detail else ""))
|
||
else:
|
||
FAIL.append(f"{title} — {detail}")
|
||
print(f" [FAIL] {title} {detail}")
|
||
|
||
|
||
def section(name: str) -> None:
|
||
print(f"\n== {name} ==")
|
||
|
||
|
||
def today() -> date:
|
||
return date.today()
|
||
|
||
|
||
def full_years(birth: date, ref: date) -> int:
|
||
"""完整周岁数：生日还没到就减一。这是「年龄」的正确算法。"""
|
||
return ref.year - birth.year - ((ref.month, ref.day) < (birth.month, birth.day))
|
||
|
||
|
||
# ============================================================ 原始数据
|
||
def load_raw() -> dict:
|
||
"""注意：MySQL 的 DECIMAL 列取回来是 Decimal，跟 float 混算会 TypeError，
|
||
这里在入口统一转成 float，后面的比较就干净了。"""
|
||
with engine.connect() as c:
|
||
classes = [dict(r._mapping) for r in c.execute(text(
|
||
"SELECT id, class_no, name, capacity, status FROM clazz WHERE is_del=0"))]
|
||
students = [dict(r._mapping) for r in c.execute(text(
|
||
"SELECT id, stu_no, name, gender, birth_date, class_id, status FROM student WHERE is_del=0"))]
|
||
scores = [dict(r._mapping) for r in c.execute(text(
|
||
"SELECT id, stu_id, exam_seq, score, flag FROM score WHERE is_del=0"))]
|
||
emps = [dict(r._mapping) for r in c.execute(text(
|
||
"SELECT id, stu_id, class_id, open_date, offer_date, salary FROM employment WHERE is_del=0"))]
|
||
|
||
for s in scores:
|
||
s["score"] = float(s["score"])
|
||
for e in emps:
|
||
e["salary"] = float(e["salary"]) if e["salary"] is not None else None
|
||
return {"classes": classes, "students": students, "scores": scores, "emps": emps}
|
||
|
||
|
||
def main() -> None:
|
||
global BASE
|
||
parser = argparse.ArgumentParser()
|
||
parser.add_argument("--base", default=BASE)
|
||
args = parser.parse_args()
|
||
BASE = args.base
|
||
|
||
raw = load_raw()
|
||
students, scores, emps, classes = raw["students"], raw["scores"], raw["emps"], raw["classes"]
|
||
stu_by_id = {s["id"]: s for s in students}
|
||
cls_by_id = {c["id"]: c for c in classes}
|
||
|
||
http = httpx.Client(base_url=BASE, timeout=60)
|
||
tok = http.post("/auth/login", json={"username": "admin", "password": "admin123"}).json()["data"]["access_token"]
|
||
H = {"Authorization": f"Bearer {tok}"}
|
||
|
||
def api(path: str):
|
||
b = http.get(path, headers=H).json()
|
||
assert b.get("code") == 0, f"{path} 返回 code={b.get('code')} {b.get('msg')}"
|
||
return b["data"]
|
||
|
||
# ---------------- 年龄 ----------------
|
||
section("2.6.1 动态年龄查询（Python 独立算年龄对账）")
|
||
age_expected = {}
|
||
for s in students:
|
||
age_expected[s["id"]] = full_years(s["birth_date"], today()) if s["birth_date"] else None
|
||
|
||
for op, val, val2 in [("gte", 25, None), ("gt", 25, None), ("lt", 22, None),
|
||
("lte", 22, None), ("eq", 24, None), ("between", 23, 26)]:
|
||
q = f"/statistics/students/by-age?operator={op}&value={val}&page_size=1"
|
||
if val2 is not None:
|
||
q += f"&value2={val2}"
|
||
d = api(q)
|
||
if op == "between":
|
||
lo, hi = min(val, val2), max(val, val2)
|
||
exp = sum(1 for a in age_expected.values() if a is not None and lo <= a <= hi)
|
||
else:
|
||
fn = {"gte": lambda a: a >= val, "gt": lambda a: a > val, "lt": lambda a: a < val,
|
||
"lte": lambda a: a <= val, "eq": lambda a: a == val}[op]
|
||
exp = sum(1 for a in age_expected.values() if a is not None and fn(a))
|
||
check(f"age {op} {val}{('/' + str(val2)) if val2 else ''} 命中数一致",
|
||
d["total"] == exp, f"接口 {d['total']} / 独立算 {exp}")
|
||
|
||
# 逐条核对返回行里的 age 字段
|
||
d = api("/statistics/students/by-age?operator=gte&value=18&page_size=200")
|
||
bad = [r for r in d["items"] if r.get("age") != age_expected.get(r["id"])]
|
||
check("返回行里的 age 与 Python 周岁算法逐一一致", not bad,
|
||
f"{len(d['items'])} 行中有 {len(bad)} 行不符" + (f" 例：{bad[0]['name']} 接口={bad[0].get('age')} 应为={age_expected[bad[0]['id']]}" if bad else ""))
|
||
|
||
# ---------------- 班级性别分布 ----------------
|
||
section("2.6.1 班级人数与性别分布")
|
||
ov = api("/statistics/classes/overview")
|
||
check("班级数与库一致", len(ov) == len(classes), f"接口 {len(ov)} / 库 {len(classes)}")
|
||
for row in ov:
|
||
mine = [s for s in students if s["class_id"] == row["class_id"]]
|
||
exp_total = len(mine)
|
||
exp_male = sum(1 for s in mine if s["gender"] == 1)
|
||
exp_female = sum(1 for s in mine if s["gender"] == 2)
|
||
exp_other = exp_total - exp_male - exp_female
|
||
ok = (row["total"], row["male"], row["female"], row["other"]) == (exp_total, exp_male, exp_female, exp_other)
|
||
check(f"「{row['class_name']}」总/男/女/未填 一致", ok,
|
||
f"接口 {row['total']}/{row['male']}/{row['female']}/{row['other']} vs 独立 {exp_total}/{exp_male}/{exp_female}/{exp_other}")
|
||
check(f"「{row['class_name']}」男+女+未填 == 总数",
|
||
row["male"] + row["female"] + row["other"] == row["total"])
|
||
check("全库男女人数之和 == 学生总数",
|
||
sum(r["male"] + r["female"] + r["other"] for r in ov) == len(students),
|
||
f"分布合计 {sum(r['male'] + r['female'] + r['other'] for r in ov)} / 学生 {len(students)}")
|
||
|
||
# ---------------- 年龄分布 ----------------
|
||
section("年龄分布直方图")
|
||
dist = api("/statistics/students/age-distribution")
|
||
hist: dict[int, int] = {}
|
||
for a in age_expected.values():
|
||
if a is not None:
|
||
hist[a] = hist.get(a, 0) + 1
|
||
check("直方图各桶计数与独立统计一致",
|
||
{r["age"]: r["count"] for r in dist} == hist,
|
||
f"接口 {len(dist)} 桶 / 独立 {len(hist)} 桶")
|
||
check("直方图人数合计 == 学生总数", sum(r["count"] for r in dist) == len(students),
|
||
f"{sum(r['count'] for r in dist)} / {len(students)}")
|
||
|
||
# ---------------- 每次考核都达标 ----------------
|
||
section("2.6.2 每次考核都在分数线以上")
|
||
TH = 80.0
|
||
above = api(f"/statistics/scores/all-above?threshold={TH}")
|
||
per_stu: dict[int, list[float]] = {}
|
||
for sc in scores:
|
||
per_stu.setdefault(sc["stu_id"], []).append(sc["score"])
|
||
exp_ids = {sid for sid, vals in per_stu.items() if vals and min(vals) >= TH}
|
||
got_ids = {r["stu_id"] for r in above}
|
||
check(f"{TH:g} 分以上（每次考核都达标）学生集合完全一致", got_ids == exp_ids,
|
||
f"接口 {len(got_ids)} 人 / 独立 {len(exp_ids)} 人"
|
||
+ (f" 差集 {got_ids ^ exp_ids}" if got_ids != exp_ids else ""))
|
||
bad = []
|
||
for r in above:
|
||
vals = per_stu[r["stu_id"]]
|
||
if r["exam_count"] != len(vals) or abs(r["min_score"] - min(vals)) > 1e-6 or abs(r["avg_score"] - sum(vals) / len(vals)) > 0.01:
|
||
bad.append(r["name"])
|
||
check("每人考核次数/最低分/平均分 一致", not bad, f"不符：{bad[:3]}")
|
||
|
||
# ---------------- 多次不及格 ----------------
|
||
section("2.6.2 不及格次数达到 N 次")
|
||
LINE, MIN_T = 60.0, 2
|
||
fails = api(f"/statistics/scores/failures?threshold={LINE}&min_times={MIN_T}")
|
||
exp_fail = {sid: [v for v in vals if v < LINE] for sid, vals in per_stu.items()}
|
||
exp_fail = {sid: v for sid, v in exp_fail.items() if len(v) >= MIN_T}
|
||
got_fail = {r["stu_id"]: r for r in fails}
|
||
check("不及格学生集合完全一致", set(got_fail) == set(exp_fail),
|
||
f"接口 {len(got_fail)} 人 / 独立 {len(exp_fail)} 人"
|
||
+ (f" 差集 {set(got_fail) ^ set(exp_fail)}" if set(got_fail) != set(exp_fail) else ""))
|
||
bad = [r["name"] for r in fails if r["fail_times"] != len(exp_fail.get(r["stu_id"], []))]
|
||
check("每人不及格次数一致", not bad, f"不符：{bad[:3]}")
|
||
bad = [r["name"] for r in fails
|
||
if len(r["fail_details"]) != r["fail_times"]
|
||
or any(x["score"] >= LINE for x in r["fail_details"])]
|
||
check("不及格明细条数正确且每条都低于红线", not bad, f"不符：{bad[:3]}")
|
||
|
||
# ---------------- 班级平均分 ----------------
|
||
section("2.6.2 每场考核每个班级的平均分")
|
||
ca = api("/statistics/scores/class-average?order=desc")
|
||
exp_groups: dict[tuple[int, int], list[float]] = {}
|
||
for sc in scores:
|
||
stu = stu_by_id.get(sc["stu_id"])
|
||
if not stu or stu["class_id"] is None:
|
||
continue
|
||
exp_groups.setdefault((sc["exam_seq"], stu["class_id"]), []).append(sc["score"])
|
||
check("(场次 × 班级) 组合数一致", len(ca) == len(exp_groups),
|
||
f"接口 {len(ca)} / 独立 {len(exp_groups)}")
|
||
bad = []
|
||
for row in ca:
|
||
key = (row["exam_seq"], row["class_id"])
|
||
vals = exp_groups.get(key)
|
||
if vals is None:
|
||
bad.append(f"多余 {key}")
|
||
continue
|
||
exp_avg = round(sum(vals) / len(vals), 2)
|
||
exp_pass = round(sum(1 for v in vals if v >= 60) / len(vals) * 100, 1)
|
||
if abs(row["avg_score"] - exp_avg) > 0.011 or row["max_score"] != max(vals) \
|
||
or row["min_score"] != min(vals) or row["student_count"] != len(vals) \
|
||
or abs(row["pass_rate"] - exp_pass) > 0.11:
|
||
bad.append(f"{row['class_name']} 第{row['exam_seq']}次 接口({row['avg_score']}/{row['max_score']}"
|
||
f"/{row['min_score']}/{row['student_count']}/{row['pass_rate']}) 独立({exp_avg}/{max(vals)}"
|
||
f"/{min(vals)}/{len(vals)}/{exp_pass})")
|
||
check("每组的 均分/最高/最低/人数/及格率 全部一致", not bad, f"问题 {len(bad)} 组；例：{bad[:1]}")
|
||
avgs = [r["avg_score"] for r in ca]
|
||
check("默认按平均分降序排列", avgs == sorted(avgs, reverse=True), f"前 5：{avgs[:5]}")
|
||
asc = api("/statistics/scores/class-average?order=asc")
|
||
avgs_asc = [r["avg_score"] for r in asc]
|
||
check("order=asc 时升序排列", avgs_asc == sorted(avgs_asc), f"前 5：{avgs_asc[:5]}")
|
||
|
||
# 回归守卫：曾经 ORDER BY 把 exam_seq 放在主位，导致「按平均分排序」只在每个场次内部生效，
|
||
# 选「全部场次 + 从高到低」看到的不是排名而是 5 个分块。这里专门盯住这个坑。
|
||
all_avgs = sorted({r["avg_score"] for r in ca}, reverse=True)
|
||
check("降序时第一名就是全局最高平均分", ca[0]["avg_score"] == all_avgs[0],
|
||
f"实际首行 {ca[0]['avg_score']}（{ca[0]['class_name']} 第{ca[0]['exam_seq']}次） / 全局最高 {all_avgs[0]}")
|
||
seqs = [r["exam_seq"] for r in ca]
|
||
check("降序列表里场次是交叉出现的（说明场均分是主导键，不是按场次分块）",
|
||
len(set(seqs[:4])) > 1, f"前 4 行场次：{seqs[:4]}")
|
||
# 不做「互为逆序」的严格断言：平均分相同的组之间，SQL 不保证次序，
|
||
# 这种断言迟早会 flaky。只钉住「集合相同 + 各自单调」。
|
||
key_of = lambda rs: sorted((r["exam_seq"], r["class_id"]) for r in rs) # noqa: E731
|
||
check("升降序返回的是同一组数据（只是方向不同）",
|
||
key_of(ca) == key_of(asc) and len(ca) == len(asc),
|
||
f"desc {len(ca)} 行 / asc {len(asc)} 行")
|
||
check("降序非递增、升序非递减",
|
||
all(avgs[i] >= avgs[i + 1] for i in range(len(avgs) - 1))
|
||
and all(avgs_asc[i] <= avgs_asc[i + 1] for i in range(len(avgs_asc) - 1)))
|
||
|
||
one = api("/statistics/scores/class-average?exam_seq=1")
|
||
check("exam_seq=1 只返回第 1 次考试", all(r["exam_seq"] == 1 for r in one) and len(one) == len(classes),
|
||
f"{len(one)} 行，场次 {sorted({r['exam_seq'] for r in one})}")
|
||
|
||
# ---------------- 薪资 Top N ----------------
|
||
section("2.6.3 就业薪资 Top N")
|
||
with_offer = [e for e in emps if e["offer_date"] and e["salary"] is not None]
|
||
exp_top = sorted(with_offer, key=lambda e: (-e["salary"], e["id"]))[:5]
|
||
top = api("/statistics/employment/top-salary?top_n=5")
|
||
check("Top5 条数正确", len(top) == 5, f"{len(top)} 条")
|
||
check("Top5 薪资与独立排序完全一致",
|
||
[r["salary"] for r in top] == [e["salary"] for e in exp_top],
|
||
f"接口 {[r['salary'] for r in top]} vs 独立 {[e['salary'] for e in exp_top]}")
|
||
check("Top5 学生与独立排序一致",
|
||
[r["stu_id"] for r in top] == [e["stu_id"] for e in exp_top])
|
||
check("名次从 1 开始连续", [r["rank"] for r in top] == [1, 2, 3, 4, 5])
|
||
check("薪资降序", [r["salary"] for r in top] == sorted([r["salary"] for r in top], reverse=True))
|
||
bad = [r["name"] for r in top
|
||
if abs(r["salary_wan"] - round(r["salary"] / 10000, 2)) > 0.011]
|
||
check("薪资(万) 换算正确", not bad, f"不符：{bad[:3]}")
|
||
|
||
# ---------------- 每人就业时长 ----------------
|
||
section("2.6.3 每个学生的就业时长")
|
||
durs = api("/statistics/employment/durations")
|
||
check("条数 == 就业记录数", len(durs) == len(emps), f"接口 {len(durs)} / 库 {len(emps)}")
|
||
emp_by_stu = {e["stu_id"]: e for e in emps}
|
||
bad, missing = [], []
|
||
for r in durs:
|
||
e = emp_by_stu.get(r["stu_id"])
|
||
if e is None:
|
||
missing.append(r["stu_id"])
|
||
continue
|
||
if e["offer_date"] and e["open_date"]:
|
||
exp = (e["offer_date"] - e["open_date"]).days # Python 直接算天数
|
||
if r["duration_days"] != exp:
|
||
bad.append(f"{r['name']} 接口 {r['duration_days']} 应 {exp}")
|
||
elif r["duration_days"] is not None:
|
||
bad.append(f"{r['name']} 无 offer 却有时长 {r['duration_days']}")
|
||
check("每人时长 == offer 日 - 开放日（Python 独立算）", not bad and not missing,
|
||
f"不符 {len(bad)} 条，缺 {len(missing)} 条；例：{bad[:2]}")
|
||
|
||
# ---------------- 班级平均就业时长 ----------------
|
||
section("2.6.3 每个班级的平均就业时长")
|
||
cad = api("/statistics/employment/class-avg-duration")
|
||
check("班级数一致", len(cad) == len(classes), f"{len(cad)} / {len(classes)}")
|
||
bad = []
|
||
for row in cad:
|
||
mine = [e for e in emps if e["class_id"] == row["class_id"]]
|
||
cls_students = [s for s in students if s["class_id"] == row["class_id"]]
|
||
with_d = [e for e in mine if e["open_date"] and e["offer_date"]]
|
||
exp_avg = round(sum((e["offer_date"] - e["open_date"]).days for e in with_d) / len(with_d), 1) if with_d else None
|
||
probs = []
|
||
if row["student_count"] != len(cls_students):
|
||
probs.append(f"人数 {row['student_count']}≠{len(cls_students)}")
|
||
if row["offer_count"] != len(with_d):
|
||
probs.append(f"offer数 {row['offer_count']}≠{len(with_d)}")
|
||
if exp_avg is not None and (row["avg_duration_days"] is None or abs(row["avg_duration_days"] - exp_avg) > 0.06):
|
||
probs.append(f"均时长 {row['avg_duration_days']}≠{exp_avg}")
|
||
if probs:
|
||
bad.append(f"{row['class_name']}: " + "；".join(probs))
|
||
check("每班 人数/offer数/平均时长 全部一致", not bad, f"问题 {len(bad)} 个班；例：{bad[:1]}")
|
||
|
||
# ---------------- 成绩波动 ----------------
|
||
section("2.7.2 成绩波动 Top N")
|
||
mult = {sid: vals for sid, vals in per_stu.items() if len(vals) >= 2}
|
||
exp_std = {sid: statistics.pstdev(vals) for sid, vals in mult.items()} # 总体标准差
|
||
exp_rng = {sid: max(vals) - min(vals) for sid, vals in mult.items()}
|
||
|
||
vol = api("/statistics/scores/volatility?top_n=5&metric=stddev")
|
||
order = sorted(exp_std, key=lambda sid: (-exp_std[sid], sid))[:5]
|
||
check("标准差 Top5 人数正确", len(vol) == 5, f"{len(vol)} 条")
|
||
check("标准差 Top5 排序一致",
|
||
[r["stu_id"] for r in vol] == order,
|
||
f"接口 {[r['stu_id'] for r in vol]} vs 独立 {order}")
|
||
bad = [f"{r['name']} {r['stddev']}≠{round(exp_std[r['stu_id']], 2)}"
|
||
for r in vol if abs(r["stddev"] - exp_std[r["stu_id"]]) > 0.011]
|
||
check("标准差数值与 Python pstdev 一致（总体标准差）", not bad, f"不符：{bad[:3]}")
|
||
|
||
volr = api("/statistics/scores/volatility?top_n=5&metric=range")
|
||
order_r = sorted(exp_rng, key=lambda sid: (-exp_rng[sid], sid))[:5]
|
||
check("最大分差 Top5 排序一致", [r["stu_id"] for r in volr] == order_r,
|
||
f"接口 {[r['stu_id'] for r in volr]} vs 独立 {order_r}")
|
||
bad = [f"{r['name']} {r['score_range']}≠{round(exp_rng[r['stu_id']], 2)}"
|
||
for r in volr if abs(r["score_range"] - exp_rng[r["stu_id"]]) > 0.011]
|
||
check("最大分差数值一致", not bad, f"不符：{bad[:3]}")
|
||
|
||
# 趋势方向：接口用「对考核序次做最小二乘拟合」的斜率，阈值 ±1 分/场
|
||
# 这里用另一条代数路径算斜率（nΣxy − ΣxΣy）/（nΣx² − (Σx)²），避开均值形式，
|
||
# 这样才构成真正的独立对账，而不是把同一个公式再抄一遍。
|
||
def lsq_slope(vals: list[float]) -> float:
|
||
n = len(vals)
|
||
if n < 2:
|
||
return 0.0
|
||
sx, sy = n * (n - 1) / 2, sum(vals)
|
||
sxy = sum(i * v for i, v in enumerate(vals))
|
||
sxx = sum(i * i for i in range(n))
|
||
den = n * sxx - sx * sx
|
||
return (n * sxy - sx * sy) / den if den else 0.0
|
||
|
||
# 关键不变量：出参里的 trend 必须与出参里的 trend_slope 自洽。
|
||
# 前端会把「标签 + 斜率」并排显示，出现「基本持平 +1.0/场」这种组合就是自相矛盾。
|
||
def label_from(s: float, n: int) -> str:
|
||
if n < 2:
|
||
return "数据不足"
|
||
return "上升" if s >= 1.0 else ("下降" if s <= -1.0 else "基本持平")
|
||
|
||
bad = []
|
||
allvol = api("/statistics/scores/volatility?top_n=50&metric=stddev")
|
||
for r in allvol:
|
||
vals = [x for _, x in sorted(
|
||
(s["exam_seq"], s["score"]) for s in scores if s["stu_id"] == r["stu_id"])]
|
||
exp_slope = round(lsq_slope(vals), 2)
|
||
if abs(r["trend_slope"] - exp_slope) > 0.011:
|
||
bad.append(f"{r['name']} 斜率 {r['trend_slope']} ≠ 独立算 {exp_slope}")
|
||
elif r["trend"] != label_from(r["trend_slope"], len(vals)):
|
||
bad.append(f"{r['name']} 标签 {r['trend']} 与自身斜率 {r['trend_slope']} 不自洽（应为 "
|
||
f"{label_from(r['trend_slope'], len(vals))}）")
|
||
check("趋势斜率与独立最小二乘一致，且标签与斜率自洽", not bad, f"不符：{bad[:3]}")
|
||
check("波动榜里若出现上升/下降，斜率方向必须与标签同号",
|
||
all((r["trend"] == "上升") == (r["trend_slope"] > 0) or r["trend"] == "基本持平"
|
||
for r in allvol))
|
||
|
||
# ---------------- 就业漏斗 ----------------
|
||
section("2.7.2 班级就业漏斗")
|
||
funnel = api("/statistics/employment/funnel")
|
||
check("班级数一致", len(funnel) == len(classes), f"{len(funnel)} / {len(classes)}")
|
||
bad = []
|
||
for row in funnel:
|
||
cls_students = [s for s in students if s["class_id"] == row["class_id"]]
|
||
stu_ids = {s["id"] for s in cls_students}
|
||
got_offer = [e for e in emps if e["stu_id"] in stu_ids and e["offer_date"]]
|
||
with_sal = [e["salary"] for e in got_offer if e["salary"] is not None]
|
||
exp_rate = round(len(got_offer) / len(cls_students) * 100, 1) if cls_students else 0.0
|
||
probs = []
|
||
if row["total"] != len(cls_students):
|
||
probs.append(f"总数 {row['total']}≠{len(cls_students)}")
|
||
if row["employed"] != len(got_offer):
|
||
probs.append(f"就业 {row['employed']}≠{len(got_offer)}")
|
||
if abs(row["employment_rate"] - exp_rate) > 0.06:
|
||
probs.append(f"就业率 {row['employment_rate']}≠{exp_rate}")
|
||
if with_sal and abs(row["avg_salary"] - round(sum(with_sal) / len(with_sal), 2)) > 0.02:
|
||
probs.append(f"均薪 {row['avg_salary']}≠{round(sum(with_sal)/len(with_sal),2)}")
|
||
if probs:
|
||
bad.append(f"{row['class_name']}: " + "；".join(probs))
|
||
check("每班 总数/就业数/就业率/平均薪资 一致", not bad, f"问题 {len(bad)} 个班；例：{bad[:1]}")
|
||
rates = [r["employment_rate"] for r in funnel]
|
||
check("按就业率降序", rates == sorted(rates, reverse=True), f"{rates}")
|
||
check("就业率都在 0~100", all(0 <= r <= 100 for r in rates))
|
||
|
||
# ---------------- 总览 ----------------
|
||
section("仪表盘总览")
|
||
ovw = api("/statistics/overview")
|
||
check("学生总数", ovw["student_total"] == len(students), f"{ovw['student_total']} / {len(students)}")
|
||
check("班级总数", ovw["class_total"] == len(classes), f"{ovw['class_total']} / {len(classes)}")
|
||
exp_emp_total = len([e for e in emps if e["offer_date"]])
|
||
check("就业总数（只算已拿 offer）", ovw["employment_total"] == exp_emp_total,
|
||
f"{ovw['employment_total']} / {exp_emp_total}")
|
||
exp_rate = round(exp_emp_total / len(students) * 100, 1)
|
||
check("整体就业率", abs(ovw["employment_rate"] - exp_rate) < 0.06,
|
||
f"{ovw['employment_rate']} / {exp_rate}")
|
||
sal = [e["salary"] for e in emps if e["salary"] is not None]
|
||
check("平均薪资", abs(ovw["avg_salary"] - round(sum(sal) / len(sal), 2)) < 0.02,
|
||
f"{ovw['avg_salary']} / {round(sum(sal)/len(sal),2)}")
|
||
check("成绩记录总数", ovw["score_record_total"] == len(scores), f"{ovw['score_record_total']} / {len(scores)}")
|
||
exp_avg = round(sum(s["score"] for s in scores) / len(scores), 2)
|
||
check("全部成绩平均分", abs(ovw["score_avg"] - exp_avg) < 0.011, f"{ovw['score_avg']} / {exp_avg}")
|
||
exp_warn = len({s["stu_id"] for s in scores if s["score"] < 60})
|
||
check("红线预警学生数（至少一次低于红线）", ovw["warning_student_count"] == exp_warn,
|
||
f"{ovw['warning_student_count']} / {exp_warn}")
|
||
bad = [r["class_name"] for r in ovw["top_classes"]
|
||
if r["employed"] > r["total"]]
|
||
check("top_classes 就业数不超过班级总人数", not bad, f"异常：{bad}")
|
||
check("student_by_status 合计 == 学生总数",
|
||
sum(ovw["student_by_status"].values()) == len(students),
|
||
f"{sum(ovw['student_by_status'].values())} / {len(students)}")
|
||
|
||
# ---------------- 收尾 ----------------
|
||
print("\n" + "=" * 66)
|
||
print(f"统计口径对账：通过 {len(PASS)} 项，失败 {len(FAIL)} 项")
|
||
if FAIL:
|
||
print("\n失败明细：")
|
||
for i, f in enumerate(FAIL, 1):
|
||
print(f" {i}. {f}")
|
||
sys.exit(1 if FAIL else 0)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|