Files
quality_analyse/verification/test_analysis_visuals.py
T
lyun bc19475b29 修复:DSH 自主查询、图片直显与报告稳定性
允许 Agent 在循环中查目录、修正查询和提问,保留实时权限检查及模型原始回答。
统一相同查询证据与图表资源;排名补齐阶段指标,修正 OR 重量筛选,并限制模型明细输入。
增加运行恢复、图表自适应坐标轴与两位小数,修复报告主图选择、重复图及边缘标签。

验证:独立副本通过 162 项 Python、73 项前端及 21 项后端测试,前端构建通过。
线上已用原 8 题复测,并追加两轮双期对比;TOP100 与组合筛选分别核对 100 行和 20 行。
2026-11-12 16:14:20 +08:00

929 lines
59 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import json
import unittest
from scripts.analysis_visuals import MAX_BODY_BYTES, build_visuals
def evidence(result, *, ref="Q1234ABCD", release_id="r-1"):
return {
"tool": "quality_data",
"mode": "compare",
"releaseId": release_id,
"evidenceRef": ref,
"result": {
"release": {"id": release_id},
"releaseId": release_id,
**result,
},
}
def comparison_result(**overrides):
result = {
"kind": "quality_comparison",
"releaseId": "r-1",
"filterBinding": {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
"current": {
"period": {"year": 2026, "month": 9},
"compositeRate": 0.98,
"black": {"rate": 0.97, "scrapWeight": 12.0},
"bright": {"rate": 0.99, "scrapWeight": 5.0},
},
"comparison": {
"period": {"year": 2026, "month": 8},
"compositeRate": 0.96,
"black": {"rate": 0.95, "scrapWeight": 10.0},
"bright": {"rate": 0.98, "scrapWeight": 7.0},
},
"delta": {"available": True, "percentagePoints": 2.0},
"stageRateChangesPP": {"black": 2.0, "bright": 1.0},
}
result.update(overrides)
return result
def decomposed_comparison_result(**overrides):
result = comparison_result(
current={
"period": {"year": 2026, "month": 9}, "compositeRate": 0.9556,
"black": {"rate": 0.947, "scrapWeight": 12.0,
"defects": [{"name": "责废", "weight": 12.0}, {"name": "料废", "weight": 8.0}, {"name": "外废", "weight": 2.0}]},
"bright": {"rate": 0.978, "scrapWeight": 5.0,
"defects": [{"name": "镀废", "weight": 5.0}, {"name": "材料废", "weight": 3.0},
{"name": "加工废", "weight": 2.0}, {"name": "扩散废", "weight": 1.0}]},
},
comparison={
"period": {"year": 2026, "month": 8}, "compositeRate": 0.96,
"black": {"rate": 0.95, "scrapWeight": 10.0,
"defects": [{"name": "责废", "weight": 10.0}, {"name": "料废", "weight": 7.0}, {"name": "外废", "weight": 1.0}]},
"bright": {"rate": 0.98, "scrapWeight": 7.0,
"defects": [{"name": "镀废", "weight": 6.0}, {"name": "材料废", "weight": 3.5},
{"name": "加工废", "weight": 2.0}, {"name": "扩散废", "weight": 1.5}]},
},
delta={"available": True, "rate": -0.0044, "percentagePoints": -0.44},
stageRateChangesPP={"black": -0.3, "bright": -0.2},
stageDecomposition={"status": "available", "blackContributionToCompositePP": -0.3,
"brightContributionToCompositePP": -0.14, "sumPP": -0.44},
)
result.update(overrides)
return result
def changes_result(**overrides):
result = {
"kind": "quality_changes",
"releaseId": "r-1",
"filters": {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
"dimension": "product",
"stage": "black",
"category": None,
"currentPeriod": {"year": 2026, "month": 9},
"comparisonPeriod": {"year": 2026, "month": 8},
"sort": "scrap_delta",
"rows": [
{"rank": 1, "key": "p-1", "label": "规格一", "scrapDelta": 4.0, "current": {"scrapWeight": 8.0}},
{"rank": 2, "key": "p-2", "label": "规格二", "scrapDelta": -2.0, "current": {"scrapWeight": 3.0}},
],
"totalRows": 8,
"returnedRows": 2,
"truncated": True,
}
result.update(overrides)
return result
def metric_result(period, composite_rate, *, release_id="r-1", filters=None):
return {
"kind": "quality_metrics",
"releaseId": release_id,
"period": period,
"filters": filters or {"department": "电机部", "includeUnassigned": False, "extraFilters": {}},
"view": "overall",
"summary": {"compositeRate": composite_rate, "black": {"rate": composite_rate - 0.01},
"bright": {"rate": composite_rate + 0.01}},
}
def fine_field(key, category):
return {"key": key, "label": key, "category": category, "sourceField": key}
class AnalysisVisualsTest(unittest.TestCase):
def test_frozen_followup_scope_selects_same_comparison_as_text(self):
import inspect
global_result=comparison_result(filterBinding={})
local=comparison_result(filterBinding={'group':'组A'})
local['current']['compositeRate']=.80
docs=[evidence(global_result,ref='Q00000001'),evidence(local,ref='Q00000002')]
kwargs={'context':{'year':2026,'month':9,'group':'组A'}} if 'context' in inspect.signature(build_visuals).parameters else {}
charts=build_visuals(docs,'比较本期综合率变化','turn-bound-followup',**kwargs)['visuals']
overview=[c for c in charts if c.get('metric')=='composite_rate']
self.assertEqual(len(overview),1)
self.assertEqual(overview[0]['scope'].get('group'),'组A')
self.assertEqual(overview[0]['series'][0]['values'],[.96,.80])
def test_frozen_period_excludes_other_period_comparison_and_defects(self):
import inspect
selected=comparison_result(filterBinding={})
older=comparison_result(filterBinding={})
older['current']['period']={'year':2026,'month':7};older['comparison']['period']={'year':2026,'month':6}
kwargs={'context':{'year':2026,'month':9}} if 'context' in inspect.signature(build_visuals).parameters else {}
charts=build_visuals([evidence(selected,ref='Q00000001'),evidence(older,ref='Q00000002')],
'比较综合率变化','turn-bound-period',**kwargs)['visuals']
self.assertTrue(charts)
self.assertTrue(all(c.get('period',{}).get('month')==9 for c in charts))
def test_available_requested_stage_is_drawn_when_other_stage_blocks_composite(self):
result=comparison_result(delta={'available':False,'reason':'缺少黑片来源'},stageRateChangesPP={'black':None,'bright':1})
result['current']['black']['rate']=1
charts=build_visuals([evidence(result)],'比较亮片合格率变化','turn-stage-only')['visuals']
self.assertEqual([c['metric'] for c in charts],['bright_rate'])
scoped=build_visuals([evidence(result)],'比较本期变化','turn-stage-context',context={'year':2026,'month':9,'stage':'bright'})['visuals']
self.assertEqual([c['metric'] for c in scoped],['bright_rate'])
def test_formal_comparison_emits_safe_single_metric_chart_with_zero_and_null(self):
result = comparison_result(
current={"period": {"year": 2026, "month": 9}, "compositeRate": 0.0,
"black": {"rate": None}, "bright": {"rate": 0.99}},
comparison={"period": {"year": 2026, "month": 8}, "compositeRate": None,
"black": {"rate": 0.95}, "bright": {"rate": 0.98}},
stageRateChangesPP={"black": None, "bright": 1.0},
)
output = build_visuals([evidence(result)], "请比较8月和9月综合合格率", "turn-01")
self.assertEqual(output["visualState"], "ready")
chart = output["visuals"][0]
self.assertEqual(chart["metric"], "composite_rate")
self.assertEqual(chart["unit"], "ratio")
self.assertEqual(chart["series"][0]["values"], [None, 0.0])
self.assertNotIn("stage", chart)
self.assertEqual(chart["scope"]["releaseId"], "r-1")
self.assertEqual(chart["originTurnId"], "turn-01")
self.assertEqual(chart["type"], "column")
def test_comparison_skips_mismatched_period_or_release(self):
bad_period = comparison_result()
bad_period["current"]["period"] = {"year": 2026, "month": 8}
self.assertEqual(build_visuals([evidence(bad_period)], "比较两个期间变化", "turn-01")["visualState"], "not_requested")
self.assertEqual(build_visuals([evidence(comparison_result(), release_id="other")], "比较两个期间变化", "turn-01")["visualState"], "not_requested")
def test_negative_or_nonfinite_rate_is_never_clamped_or_drawn(self):
for invalid in (-.01, float('nan'), float('inf')):
with self.subTest(invalid=invalid):
result = comparison_result()
result["current"]["compositeRate"] = invalid
output = build_visuals([evidence(result)], "比较综合合格率变化", "turn-01")
self.assertEqual(output["visualState"], "not_requested")
self.assertEqual(output["visuals"], [])
def test_broad_cause_analysis_adds_three_rates_math_waterfall_and_both_category_deltas(self):
output = build_visuals([evidence(decomposed_comparison_result())], "分析整体合格率下降原因", "turn-broad-chapters")
charts = output["visuals"]
self.assertEqual(output["visualState"], "ready")
by_section = {}
for chart in charts:
by_section.setdefault(chart["sectionKey"], []).append(chart)
self.assertEqual(len(by_section["overview"]), 2)
self.assertEqual({chart["metric"] for chart in by_section["stage"]}, {"black_rate", "bright_rate"})
waterfall = next(chart for chart in charts if chart["type"] == "waterfall")
self.assertEqual(waterfall["metric"], "composite_impact_pp")
self.assertEqual(waterfall["series"][0]["values"], [-0.3, -0.14, -0.44])
self.assertEqual(waterfall["requiredFields"], [
"black_good_weight", "black_total_weight", "bright_good_weight", "bright_total_weight"
])
self.assertIn("拆解", waterfall["note"])
self.assertNotIn("数学", waterfall["note"])
self.assertNotIn("生产根因", waterfall["title"])
self.assertEqual({chart["sectionKey"] for chart in charts if chart["sectionKey"].startswith("category_")},
{"category_black", "category_bright"})
black_categories = next(chart for chart in charts if chart["sectionKey"] == "category_black")
self.assertEqual(black_categories["series"][0]["values"], [2.0, 1.0, 1.0])
self.assertEqual(black_categories["dimension"], "category")
def test_followup_product_comparisons_do_not_crowd_out_main_chapters(self):
docs = [evidence(decomposed_comparison_result(filterBinding={}), ref="Q00000001")]
for index in range(6):
docs.append(evidence(decomposed_comparison_result(filterBinding={"product": f"规格-{index}"}), ref=f"Q{index+2:08X}"))
for index, dimension in enumerate(("department", "group", "product")):
docs.append(evidence(changes_result(filters={}, dimension=dimension), ref=f"Q{index+20:08X}"))
for index, stage in enumerate(("black", "bright")):
docs.append(evidence(changes_result(filters={}, dimension="department", stage=stage), ref=f"Q{index+30:08X}"))
field, category = ("责废其他重量", "责废") if stage == "black" else ("加工磕边重量", "加工废")
docs.append(evidence({"kind":"quality_fine_defects","dimension":"defect","grain":"source_defect_weight","stage":stage,"filters":{},
"period":{"year":2026,"month":9},"comparisonPeriod":{"year":2026,"month":8},
"coverage":{"available":True},"comparisonCoverage":{"available":True},
"sourceFields":[fine_field(field,category)],"comparisonSourceFields":[fine_field(field,category)],
"pairedRows":[{"key":field,"current":{"label":field,"category":category,"weight":3},"comparison":{"label":field,"category":category,"weight":2},"deltaWeight":1,"deltaAvailable":True}],
"pairedTotalRows":1,"pairedTruncated":False,"pairedRankingComplete":True,"sort":"scrap_delta"},ref=f"Q{index+40:08X}"))
charts = build_visuals(docs, "分析整体变化,覆盖产业部、业务分组、重点产品与报废类别", "turn-balanced")["visuals"]
self.assertEqual(len(charts), 12)
self.assertTrue({"department", "group", "product", "category_black", "category_bright", "defect_black", "defect_bright"}.issubset({c["sectionKey"] for c in charts}))
self.assertFalse(charts[0]["scope"].get("product"))
self.assertEqual({c["metric"] for c in charts if c["sectionKey"] == "stage" and not c["scope"].get("product")}, {"black_rate", "bright_rate"})
def test_waterfall_requires_exact_finite_decomposition_that_matches_service_delta(self):
valid = decomposed_comparison_result()
bad_cases = []
mismatch_delta = json.loads(json.dumps(valid))
mismatch_delta["delta"]["percentagePoints"] = -0.5
bad_cases.append(mismatch_delta)
mismatch_sum = json.loads(json.dumps(valid))
mismatch_sum["stageDecomposition"]["sumPP"] = -0.5
bad_cases.append(mismatch_sum)
missing_stage = json.loads(json.dumps(valid))
missing_stage["stageDecomposition"]["brightContributionToCompositePP"] = None
bad_cases.append(missing_stage)
non_finite = json.loads(json.dumps(valid))
non_finite["stageDecomposition"]["blackContributionToCompositePP"] = float("inf")
bad_cases.append(non_finite)
for index, result in enumerate(bad_cases):
output = build_visuals([evidence(result)], "画瀑布图解释整体合格率下降原因", f"turn-waterfall-invalid-{index}")
self.assertEqual(output["visualState"], "unavailable")
self.assertEqual(output["visuals"], [])
def test_formal_category_delta_requires_matching_complete_category_sets(self):
result = decomposed_comparison_result()
chart = next(chart for chart in build_visuals(
[evidence(result)], "分析两阶段正式报废类别增减", "turn-category-delta"
)["visuals"] if chart["sectionKey"] == "category_bright")
self.assertEqual(chart["metric"], "source_defect_delta_weight")
self.assertEqual(chart["stage"], "bright")
self.assertEqual(chart["series"][0]["values"], [-1.0, -0.5, 0.0, -0.5])
self.assertEqual(chart["coverage"], {"totalRows": 4, "returnedRows": 4, "truncated": False})
partial = json.loads(json.dumps(result))
partial["current"]["bright"]["defects"].pop()
output = build_visuals([evidence(partial)], "分析两阶段正式报废类别增减", "turn-category-delta-partial")
self.assertFalse(any(chart.get("sectionKey") == "category_bright" for chart in output["visuals"]))
zero_only = json.loads(json.dumps(result))
for side in ("current", "comparison"):
for item in zero_only[side]["black"]["defects"]:
item["weight"] = 0
output = build_visuals([evidence(zero_only)], "分析黑片正式报废类别增减", "turn-category-delta-zero")
self.assertFalse(any(chart.get("sectionKey") == "category_black" for chart in output["visuals"]))
def test_scoped_defect_charts_keep_separate_chapter_scope_from_global_chart(self):
def fine_result(filters):
return {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "black", "filters": filters,
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
"sourceFields": [fine_field("责废其他重量", "责废")],
"comparisonSourceFields": [fine_field("责废其他重量", "责废")],
"pairedRows": [{
"key": "责废其他重量",
"current": {"label": "责废其他重量", "category": "责废", "weight": 3.0},
"comparison": {"label": "责废其他重量", "category": "责废", "weight": 2.0},
"deltaWeight": 1.0, "deltaAvailable": True,
}],
"sort": "scrap_delta", "pairedTotalRows": 1, "pairedTruncated": False,
"pairedRankingComplete": True,
}
docs = [
evidence(fine_result({"extraFilters": {}}), ref="Q00000031"),
evidence(fine_result({"group": "汽车交通-国内", "extraFilters": {}}), ref="Q00000032"),
]
charts = build_visuals(docs, "画图看黑片来源具体缺陷增减", "turn-scoped-defects")["visuals"]
self.assertEqual(len(charts), 2)
self.assertEqual({chart["sectionKey"] for chart in charts}, {"defect_black"})
self.assertEqual({chart["dimension"] for chart in charts}, {"defect"})
self.assertEqual({chart["scope"].get("group") for chart in charts}, {None, "汽车交通-国内"})
self.assertEqual(len({chart["id"] for chart in charts}), 2)
scoped_chart = next(chart for chart in charts if chart["scope"].get("group"))
self.assertIn("范围 业务分组:汽车交通-国内", scoped_chart["subtitle"])
many_scopes = [evidence(fine_result({"group": f"业务组-{index}", "extraFilters": {}}),
ref=f"Q{index:08X}") for index in range(13)]
bounded = build_visuals(many_scopes, "画图看黑片来源具体缺陷增减", "turn-12-limit")
self.assertEqual(len(bounded["visuals"]), 12)
self.assertEqual(len({chart["id"] for chart in bounded["visuals"]}), 12)
self.assertLess(len(json.dumps(bounded, ensure_ascii=False).encode("utf-8")), MAX_BODY_BYTES)
def test_change_chart_preserves_signed_values_and_returned_order(self):
rows = changes_result()["rows"]
rows[0]["scrapDelta"] = -1.0
rows[1]["scrapDelta"] = 5.0
output = build_visuals([evidence(changes_result(rows=rows))], "画图比较产品报废增量", "turn-02")
chart = output["visuals"][0]
self.assertEqual(chart["metric"], "scrap_delta")
self.assertEqual(chart["stage"], "black")
self.assertEqual(chart["series"][0]["values"], [-1.0, 5.0])
self.assertEqual([row["key"] for row in chart["categories"]], ["p-1", "p-2"])
self.assertTrue(chart["coverage"]["truncated"])
self.assertEqual(chart["coverage"]["totalRows"], 8)
def test_rate_drop_is_signed_and_converted_to_percentage_points(self):
result = changes_result(sort="rate_drop", rows=[
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": 0.025},
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": -0.04},
])
chart = build_visuals([evidence(result)], "画图比较产品合格率降幅", "turn-03")["visuals"][0]
self.assertEqual(chart["metric"], "rate_drop_pp")
self.assertEqual(chart["unit"], "pp")
self.assertEqual(chart["series"][0]["values"], [-2.5, 4.0])
self.assertEqual([row["key"] for row in result["rows"]], ["p-1", "p-2"])
self.assertEqual([item["key"] for item in chart["categories"]], ["p-1", "p-2"])
self.assertIn("率降幅线索", chart["title"])
self.assertIn("本期减比较期", chart["note"])
self.assertIn("仍按率降幅排序", chart["note"])
self.assertIn("未纳入投入规模", chart["note"])
def test_broad_product_focus_omits_rate_only_ranking_chart(self):
rate = changes_result(stage=None, sort="rate_drop", returnedRows=1, rows=[
{"rank": 1, "key": "tiny", "label": "小量规格", "rateDrop": 0.9943,
"scrapDelta": 6.74, "current": {"blackInputWeight": 7.1, "brightInputWeight": 39.66}},
])
scrap = changes_result(stage=None, sort="scrap_delta", returnedRows=1, rows=[
{"rank": 1, "key": "large", "label": "报废增量规格", "scrapDelta": 758.76},
])
charts = build_visuals(
[evidence(rate, ref="Q00000001"), evidence(scrap, ref="Q00000002")],
"分析下近期要关注的重点产品", "turn-product-focus",
)["visuals"]
self.assertEqual([chart["metric"] for chart in charts], ["scrap_delta"])
raw_only = build_visuals(
[evidence(rate)], "分析下近期要关注的重点产品", "turn-product-focus-raw-only",
)
self.assertEqual(raw_only["visualState"], "not_requested")
self.assertEqual(raw_only["visuals"], [])
mixed = build_visuals(
[evidence(rate)], "分析重点产品的合格率下降和报废占比", "turn-product-focus-mixed",
)
self.assertEqual(mixed["visuals"], [])
def test_rank_metadata_must_match_order_and_zero_is_preserved(self):
result = changes_result(rows=[
{"rank": 2, "key": "p-1", "label": "规格一", "scrapDelta": 0.0},
{"rank": 1, "key": "p-2", "label": "规格二", "scrapDelta": 3.0},
])
self.assertEqual(build_visuals([evidence(result)], "画图比较产品报废增量", "turn-04")["visualState"], "unavailable")
def test_change_chart_requires_stage_and_matching_filter_shape(self):
no_stage = changes_result(stage=None)
output = build_visuals([evidence(no_stage)], "画图比较产品报废增量", "turn-05")
chart = output["visuals"][0]
self.assertEqual(chart["metric"], "scrap_delta")
self.assertNotIn("stage", chart)
self.assertNotIn("stage", chart["scope"])
self.assertEqual(chart["requiredFields"], ["black_scrap_weight", "bright_scrap_weight"])
secret_filter = changes_result(filters={"department": "电机部", "apiKey": "secret-value"})
self.assertEqual(build_visuals([evidence(secret_filter)], "画图比较产品报废增量", "turn-05")["visualState"], "unavailable")
def test_overall_rate_drop_uses_canonical_two_stage_fields(self):
result = changes_result(stage=None, sort="rate_drop", rows=[
{"rank": 1, "key": "p-1", "label": "规格一", "rateDrop": 0.02},
{"rank": 2, "key": "p-2", "label": "规格二", "rateDrop": -0.01},
])
chart = build_visuals([evidence(result)], "画产品综合合格率变化", "turn-05b")["visuals"][0]
self.assertEqual(chart["metric"], "rate_drop_pp")
self.assertEqual(chart["requiredFields"], [
"black_good_weight", "black_total_weight", "bright_good_weight", "bright_total_weight"
])
self.assertEqual(chart["series"][0]["values"], [-2.0, 1.0])
self.assertIn("负值为下降,正值为上升", chart["note"])
self.assertIn("本期减比较期", chart["note"])
def test_quality_top_uses_ranked_weights_and_never_share(self):
result = {
"kind": "quality_top", "releaseId": "r-1", "stage": "black", "dimension": "product",
"period": {"year": 2026, "month": 9},
"filters": {"department": "电机部", "extraFilters": {}},
"rankingCoverage": {"groups": 12, "complete": False},
"rows": [
{"rank": index + 1, "key": f"p-{index}", "label": f"产品{index}",
"weight": index + 0.5, "share": 0.99 - index * 0.01}
for index in range(12)
],
}
chart = build_visuals([evidence(result)], "哪些产品报废最多", "turn-top") ["visuals"][0]
self.assertEqual(chart["metric"], "current_scrap_weight")
self.assertEqual(chart["requiredFields"], ["black_scrap_weight"])
self.assertEqual(chart["series"][0]["values"], [index + 0.5 for index in range(12)])
self.assertEqual(chart["coverage"], {"totalRows": 12, "returnedRows": 12, "truncated": False})
self.assertNotIn("share", json.dumps(chart, ensure_ascii=False))
def test_quality_top_categories_require_stage_canonical_source_fields(self):
result = {
"kind": "quality_top", "releaseId": "r-1", "stage": "bright", "dimension": "category",
"period": {"year": 2026, "month": 9}, "filters": {"extraFilters": {}},
"rankingCoverage": {"groups": 3, "complete": True},
"cumulativeThresholdApplied": False,
"rows": [
{"rank": 1, "key": "加工废", "label": "加工废", "weight": 3.0},
{"rank": 2, "key": "材料废", "label": "材料废", "weight": 2.0},
{"rank": 3, "key": "扩散废", "label": "扩散废", "weight": 1.0},
],
}
chart = build_visuals([evidence(result)], "分析亮片报废类别排名", "turn-cat")["visuals"][0]
self.assertEqual(chart["metric"], "source_defect_weight")
self.assertEqual([item["key"] for item in chart["categories"]], [
"bright_processing_scrap", "bright_material_scrap", "bright_diffusion_scrap"
])
self.assertEqual(chart["requiredFields"], [
"bright_diffusion_scrap", "bright_material_scrap", "bright_processing_scrap"
])
result["rows"][0]["label"] = "VCM总计"
self.assertEqual(build_visuals([evidence(result)], "分析亮片报废类别排名", "turn-cat")["visualState"], "not_requested")
def test_real_category_top_shape_without_ranking_coverage_requires_endpoint_denominator_proof(self):
denominator = 7118.885021
weights = [3421.516018, 2812.668772, 868.241231, 16.459]
labels = ["加工废", "镀废", "材料废", "扩散废"]
result = {
"kind": "quality_top", "releaseId": "r-1", "stage": "bright", "dimension": "category",
"period": {"year": 2026, "month": 9},
"filters": {"department": "工业电机产业部", "includeUnassigned": False},
"rankingCoverage": None,
"denominator": denominator,
"shareBasis": "所选筛选条件下选中原报废分类的重量总和",
"cumulativeThresholdApplied": False,
"rows": [
{"rank": index + 1, "key": label, "label": label, "weight": weight,
"denominator": denominator, "share": weight / denominator}
for index, (label, weight) in enumerate(zip(labels, weights))
],
}
doc = evidence(result)
doc["apiSource"] = {"calls": [
{"method": "GET", "path": "/api/releases", "params": {}},
{"method": "GET", "path": "/api/analytics/top", "params": {
"releaseId": "r-1", "stage": "bright", "dimension": "category", "limit": 10,
"year": 2026, "month": 9, "department": "工业电机产业部", "includeUnassigned": False,
}},
]}
donut = build_visuals([doc], "亮片已列报废类别用环状图展示构成", "turn-real-category-donut")["visuals"][0]
self.assertEqual(donut["type"], "donut")
self.assertEqual(donut["series"][0]["values"], weights)
self.assertEqual(donut["coverage"], {
"totalRows": 4, "returnedRows": 4, "truncated": False, "shareBasis": "displayed_categories"
})
pareto = build_visuals([doc], "亮片报废类别画柏拉图", "turn-real-category-pareto")["visuals"][0]
self.assertEqual(pareto["type"], "pareto")
self.assertEqual(pareto["series"][0]["values"], weights)
subset = json.loads(json.dumps(result))
subset["rows"] = result["rows"][:3]
subset["denominator"] = sum(weights[:3])
for row in subset["rows"]:
row["denominator"] = subset["denominator"]
row["share"] = row["weight"] / subset["denominator"]
subset_doc = evidence(subset)
subset_doc["apiSource"] = doc["apiSource"]
self.assertEqual(build_visuals([subset_doc], "亮片类别环状构成", "turn-authorized-subset")["visualState"], "ready")
invalid_cases = []
low_limit = json.loads(json.dumps(doc))
low_limit["apiSource"]["calls"][1]["params"]["limit"] = 3
invalid_cases.append(low_limit)
wrong_denominator = json.loads(json.dumps(doc))
wrong_denominator["result"]["denominator"] += 1
invalid_cases.append(wrong_denominator)
threshold = json.loads(json.dumps(doc))
threshold["result"]["cumulativeThresholdApplied"] = True
invalid_cases.append(threshold)
narrowed = json.loads(json.dumps(doc))
narrowed["apiSource"]["calls"][1]["params"]["category"] = "加工废"
invalid_cases.append(narrowed)
mismatched_filter = json.loads(json.dumps(doc))
mismatched_filter["apiSource"]["calls"][1]["params"]["department"] = "其他部门"
invalid_cases.append(mismatched_filter)
for index, invalid_doc in enumerate(invalid_cases):
self.assertEqual(build_visuals([invalid_doc], "亮片类别环状构成", f"turn-category-invalid-{index}")["visualState"], "unavailable")
def test_candidate_priority_keeps_comparison_product_and_fine_defect_charts_separate(self):
comparison = evidence(comparison_result(), ref="Q00000011")
changes = evidence(changes_result(stage=None), ref="Q00000012")
fine_result = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "bright", "filters": {"department": "其他部门"},
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
"sourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废"), fine_field("材料隐裂重量", "材料废")],
"comparisonSourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废"), fine_field("材料隐裂重量", "材料废")],
"pairedRows": [
{"key": "晶界扩散其他缺陷重量", "current": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 3},
"comparison": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 2}, "deltaWeight": 1, "deltaAvailable": True},
{"key": "材料隐裂重量", "current": {"label": "材料隐裂重量", "category": "材料废", "weight": 2},
"comparison": {"label": "材料隐裂重量", "category": "材料废", "weight": 1}, "deltaWeight": 1, "deltaAvailable": True},
],
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
"pairedRankingComplete": True,
}
fine = evidence(fine_result, ref="Q00000013")
output = build_visuals([fine, changes, comparison], "分析本期变化并绘制综合对比、产品报废增量和来源缺陷图", "turn-priority")
self.assertEqual([chart["metric"] for chart in output["visuals"]], [
"composite_rate", "scrap_delta", "source_defect_delta_weight"
])
self.assertEqual(output["visuals"][2]["scope"]["department"], "其他部门")
self.assertEqual(output["visuals"][2]["requiredFields"], ["晶界扩散其他缺陷重量", "材料隐裂重量"])
scoped = build_visuals([fine, changes, comparison],
"展示正式综合合格率、重点产品报废增量和亮片具体缺陷增量", "turn-priority-stage")
self.assertEqual([chart["metric"] for chart in scoped["visuals"]], [
"composite_rate", "scrap_delta", "source_defect_delta_weight"
])
def test_fine_defects_use_paired_rows_and_do_not_turn_totals_only_into_zero(self):
result = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "bright",
"filters": {"department": "电机部", "extraFilters": {}},
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
"sourceRows": 4,
"sourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废")],
"comparisonSourceFields": [fine_field("晶界扩散其他缺陷重量", "扩散废")],
"pairedRows": [
{"key": "晶界扩散其他缺陷重量", "current": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 0.0},
"comparison": {"label": "晶界扩散其他缺陷重量", "category": "扩散废", "weight": 1.0}, "deltaWeight": -1.0, "deltaAvailable": True},
],
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
"pairedRankingComplete": True,
"categoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
"expectedTotalsOnly": {"rows": 1}}],
"comparisonCategoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
"expectedTotalsOnly": {"rows": 0}}],
}
output = build_visuals([evidence(result)], "画图比较亮片来源具体缺陷增量", "turn-06")
chart = output["visuals"][0]
self.assertEqual(chart["metric"], "source_defect_delta_weight")
self.assertEqual(chart["stage"], "bright")
self.assertEqual(chart["categories"], [{"key": "晶界扩散其他缺陷重量", "label": "晶界扩散其他缺陷重量"}])
self.assertEqual(chart["series"][0]["values"], [-1.0])
self.assertNotIn("VCM", chart["note"])
self.assertEqual(chart["requiredFields"], ["晶界扩散其他缺陷重量"])
def test_fine_defect_missing_delta_stays_null_and_unavailable_coverage_skips(self):
result = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "black", "filters": {},
"period": {"year": 2026, "month": 9}, "comparisonPeriod": {"year": 2026, "month": 8},
"coverage": {"available": True}, "comparisonCoverage": {"available": True},
"sourceFields": [fine_field("责废尺寸重量", "责废"), fine_field("责废其他重量", "责废")],
"comparisonSourceFields": [fine_field("责废尺寸重量", "责废"), fine_field("责废其他重量", "责废")],
"pairedRows": [
{"key": "责废尺寸重量", "current": {"label": "责废尺寸重量", "category": "责废", "weight": 2},
"comparison": None, "deltaWeight": None, "deltaAvailable": False},
{"key": "责废其他重量", "current": {"label": "责废其他重量", "category": "责废", "weight": 3},
"comparison": {"label": "责废其他重量", "category": "责废", "weight": 1}, "deltaWeight": 2, "deltaAvailable": True},
],
"sort": "scrap_delta", "pairedTotalRows": 2, "pairedTruncated": False,
"pairedRankingComplete": False,
}
output = build_visuals([evidence(result)], "画图比较黑片来源缺陷增量", "turn-07")
self.assertEqual(output["visuals"][0]["series"][0]["values"], [None, 2.0])
result["coverage"] = {"available": False}
self.assertEqual(build_visuals([evidence(result)], "画图比较黑片来源缺陷增量", "turn-07")["visualState"], "unavailable")
def test_fine_defects_authorize_only_real_source_fields_and_bind_category_scope(self):
result = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "bright",
"filters": {"department": "电机部", "extraFilters": {"项目类型": ["VCM"]}},
"category": "加工废",
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 3},
"sourceRows": 3, "sourceFields": [fine_field("加工尺寸超差重量", "加工废")],
"rows": [{"key": "加工尺寸超差重量", "label": "加工尺寸超差重量", "category": "加工废", "weight": 0}],
"totalRows": 1, "truncated": False, "rankingComplete": True,
}
chart = build_visuals([evidence(result)], "画图看亮片来源具体缺陷重量", "turn-real-shape")["visuals"][0]
self.assertEqual(chart["categories"], [{"key": "加工尺寸超差重量", "label": "加工尺寸超差重量"}])
self.assertEqual(chart["requiredFields"], ["加工尺寸超差重量"])
self.assertEqual(chart["series"][0]["values"], [0.0])
self.assertEqual(chart["scope"]["category"], "加工废")
self.assertEqual(chart["scope"]["extraFilters"], {"项目类型": ["VCM"]})
result["rows"][0]["key"] = "未授权缺陷重量"
result["rows"][0]["label"] = "未授权缺陷重量"
self.assertEqual(build_visuals([evidence(result)], "画图看亮片来源具体缺陷重量", "turn-real-shape")["visualState"], "unavailable")
def test_fine_defect_partial_totals_only_keeps_valid_mixed_rows_and_full_totals_only_is_not_zero(self):
mixed = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "bright", "filters": {},
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 4},
"sourceRows": 4, "sourceFields": [fine_field("晶界扩散外观异常重量", "扩散废")],
"rows": [{"key": "晶界扩散外观异常重量", "label": "晶界扩散外观异常重量",
"category": "扩散废", "weight": 2.5}],
"categoryReconciliation": [{"category": "扩散废", "sourceRows": 4,
"expectedTotalsOnly": {"rows": 1},
"reconciliationStatus": "DIFF"}],
"totalRows": 1, "truncated": False, "rankingComplete": True,
}
chart = build_visuals([evidence(mixed)], "画图看亮片来源具体缺陷排名", "turn-mixed")["visuals"][0]
self.assertEqual(chart["series"][0]["values"], [2.5])
self.assertNotIn("VCM", chart.get("note", ""))
all_totals = dict(mixed)
all_totals["rows"] = [{"key": "晶界扩散外观异常重量", "label": "晶界扩散外观异常重量",
"category": "扩散废", "weight": None}]
all_totals["categoryReconciliation"] = [{"category": "扩散废", "sourceRows": 4,
"expectedTotalsOnly": {"rows": 4},
"reconciliationStatus": "EXPECTED_TOTALS_ONLY"}]
self.assertEqual(build_visuals([evidence(all_totals)], "画图看亮片来源具体缺陷排名", "turn-mixed")["visualState"], "unavailable")
paired_totals = dict(all_totals)
paired_totals["comparisonPeriod"] = {"year": 2026, "month": 8}
paired_totals["comparisonCoverage"] = {"available": True, "sourceRows": 4}
paired_totals["comparisonSourceFields"] = [fine_field("晶界扩散外观异常重量", "扩散废")]
paired_totals["comparisonCategoryReconciliation"] = list(all_totals["categoryReconciliation"])
paired_totals["sort"] = "scrap_delta"
paired_totals["pairedRows"] = [{
"key": "晶界扩散外观异常重量",
"current": {"label": "晶界扩散外观异常重量", "category": "扩散废", "weight": None},
"comparison": {"label": "晶界扩散外观异常重量", "category": "扩散废", "weight": None},
"deltaWeight": None, "deltaAvailable": False,
}]
paired_totals["pairedTotalRows"] = 1
paired_totals["pairedTruncated"] = False
paired_totals["pairedRankingComplete"] = True
self.assertEqual(build_visuals([evidence(paired_totals)], "画图比较亮片来源具体缺陷增量", "turn-mixed")["visualState"], "unavailable")
def test_fine_defect_chart_keeps_requested_rows_and_authorizes_only_displayed_fields(self):
keys = ["责废尺寸重量", "责废缺角重量", "责废垂直度重量", "责废刀丝重量", "责废烂毛重量",
"责废开裂重量", "责废其他重量", "料废尺寸重量", "料废缺角重量", "料废开裂重量",
"料废烂毛重量", "料废其他重量"]
result = {
"kind": "quality_fine_defects", "releaseId": "r-1", "dimension": "defect",
"grain": "source_defect_weight", "stage": "black", "filters": {},
"period": {"year": 2026, "month": 9}, "coverage": {"available": True, "sourceRows": 2},
"sourceRows": 2, "sourceFields": [fine_field(key, "责废" if key.startswith("责废") else "料废") for key in keys],
"rows": [{"key": key, "label": key, "category": "责废" if key.startswith("责废") else "料废",
"weight": float(index + 1)} for index, key in enumerate(keys)],
"totalRows": len(keys), "truncated": False, "rankingComplete": True,
}
chart = build_visuals([evidence(result)], "画图看黑片来源具体缺陷排名", "turn-ten")["visuals"][0]
self.assertEqual(len(chart["categories"]), 12)
self.assertEqual(chart["coverage"], {"totalRows": 12, "returnedRows": 12, "truncated": False})
self.assertEqual(chart["requiredFields"], [item["key"] for item in chart["categories"]])
def test_multi_query_trend_requires_same_release_and_filters_and_keeps_gaps_null(self):
docs = [
evidence(metric_result({"year": 2026, "month": 1}, 0.91), ref="Q00000001"),
evidence(metric_result({"year": 2026, "month": 3}, 0.93), ref="Q00000002"),
evidence(metric_result({"year": 2026, "month": 4}, 0.94), ref="Q00000003"),
]
charts = build_visuals(docs, "画综合合格率趋势图", "turn-08")["visuals"]
chart = next(item for item in charts if item["metric"] == "composite_rate")
self.assertEqual([item["key"] for item in chart["categories"]], ["2026-01", "2026-02", "2026-03", "2026-04"])
self.assertEqual(chart["series"][0]["values"], [0.91, None, 0.93, 0.94])
annual = {'year': 2026, 'department': '电机部', 'trendGranularity': 'month'}
bounded = build_visuals(docs, '画综合合格率趋势图', 'turn-annual', context=annual)['visuals']
self.assertEqual(bounded[0]['series'][0]['values'], [0.91, None, 0.93, 0.94])
unrelated = [evidence(metric_result({'year':2025,'month':12},0.50),ref='Q00000009'),
evidence(metric_result({'year':2026,'month':2},0.10,filters={'department':'其他'}),ref='Q00000010')]
filtered = build_visuals(docs+unrelated, '画综合合格率趋势图', 'turn-filtered-year', context=annual)['visuals']
self.assertEqual(filtered[0]['series'][0]['values'], [0.91, None, 0.93, 0.94])
quarter_docs = docs + [evidence(metric_result({'year':2026,'month':2},0.92),ref='Q00000011')]
quarter = build_visuals(quarter_docs, '画综合合格率趋势图', 'turn-quarter', context={**annual,'quarter':1})['visuals']
self.assertEqual(quarter[0]['series'][0]['values'], [0.91, 0.92, 0.93])
single_month = build_visuals(docs, '画综合合格率趋势图', 'turn-month', context={**annual,'month':3})
self.assertEqual(single_month['visualState'], 'unavailable')
mismatch = [docs[0], docs[1], evidence(metric_result({"year": 2026, "month": 4}, 0.94, filters={"department": "其他"}), ref="Q00000004")]
self.assertEqual(build_visuals(mismatch, "画综合合格率趋势图", "turn-08")["visualState"], "unavailable")
mixed_release = [docs[0], docs[1], evidence(metric_result({"year": 2026, "month": 4}, 0.94, release_id="r-2"), ref="Q00000005", release_id="r-2")]
self.assertEqual(build_visuals(mixed_release, "画综合合格率趋势图", "turn-08")["visualState"], "unavailable")
def test_trend_uses_the_same_unique_comparison_scope_as_the_text(self):
scoped = comparison_result(filterBinding={'group':'A'},
current={'period':{'year':2026},'compositeRate':.98,'black':{'rate':.99},'bright':{'rate':.99}},
comparison={'period':{'year':2025},'compositeRate':.97,'black':{'rate':.98},'bright':{'rate':.99}})
global_docs = [evidence(metric_result({'year':2026,'month':m},.90+m/100,filters={}),ref=f'Q0000000{m}') for m in (1,3,4)]
charts = build_visuals([evidence(scoped)]+global_docs,'比较今年变化并画趋势图','turn-root-trend',context={'year':2026})['visuals']
self.assertFalse(any(chart.get('sectionKey')=='trend' for chart in charts))
local_docs = [evidence(metric_result({'year':2026,'month':m},.95+m/100,filters={'group':'A'}),ref=f'Q0000001{m}') for m in (1,3,4)]
charts = build_visuals([evidence(scoped)]+global_docs+local_docs,'比较今年变化并画趋势图','turn-root-trend-ok',context={'year':2026})['visuals']
trend = next(chart for chart in charts if chart.get('sectionKey')=='trend')
self.assertEqual(trend['scope']['group'], 'A')
self.assertEqual(trend['series'][0]['values'], [.96, None, .98, .99])
def test_native_trend_is_sorted_and_bounded(self):
result = metric_result({"year": 2026, "month": 9}, 0.93)
result.update({
"trend": [
{"period": "2026-03", "compositeRate": 0.93, "black": {"rate": 0.92}, "bright": {"rate": 0.94}},
{"period": "2026-01", "compositeRate": 0.91, "black": {"rate": 0.90}, "bright": {"rate": 0.92}},
{"period": "2026-04", "compositeRate": 0.94, "black": {"rate": 0.93}, "bright": {"rate": 0.95}},
],
"trendCount": 3,
"trendTruncated": False,
})
chart = build_visuals([evidence(result)], "画合格率趋势图", "turn-09")["visuals"][0]
self.assertEqual(chart["metric"], "composite_rate")
self.assertEqual([item["key"] for item in chart["categories"]], ["2026-01", "2026-02", "2026-03", "2026-04"])
self.assertEqual(chart["series"][0]["values"], [0.91, None, 0.93, 0.94])
result["trendTruncated"] = True
self.assertEqual(build_visuals([evidence(result)], "画合格率趋势图", "turn-09")["visualState"], "unavailable")
def test_explicit_heatmap_and_area_are_real_period_trends_only(self):
result = metric_result({"year": 2026, "month": 12}, 0.93)
result.update({
"trend": [
{"period": f"2026-{month:02d}", "compositeRate": 0.8 + month / 100,
"black": {"rate": 0.79 + month / 100, "scrapWeight": month},
"bright": {"rate": 0.81 + month / 100, "scrapWeight": month / 2}}
for month in range(1, 13)
],
"trendCount": 12,
"trendTruncated": False,
})
ordinary = build_visuals([evidence(result)], "查看综合合格率月度趋势", "turn-usual-trend")["visuals"][0]
self.assertEqual(ordinary["type"], "line")
heatmap = build_visuals([evidence(result)], "用热力图展示综合合格率趋势", "turn-heatmap")["visuals"][0]
self.assertEqual(heatmap["type"], "heatmap")
self.assertEqual(len(heatmap["categories"]), 12)
self.assertEqual(len(heatmap["series"]), 1)
result["trend"] = result["trend"][:4]
result["trendCount"] = 4
area = build_visuals([evidence(result)], "画亮片报废重量面积趋势图", "turn-area")["visuals"][0]
self.assertEqual(area["type"], "area")
self.assertEqual(area["stage"], "bright")
self.assertEqual(area["metric"], "current_scrap_weight")
self.assertTrue(all(value is None or value >= 0 for value in area["series"][0]["values"]))
result["trend"] = result["trend"][:2]
result["trendCount"] = 2
self.assertEqual(build_visuals([evidence(result)], "画面积图", "turn-area-invalid")["visualState"], "unavailable")
def test_formal_summary_produces_guarded_donut_and_pareto(self):
defects = [
{"name": "镀废", "weight": 3.0},
{"name": "材料废", "weight": 5.0},
{"name": "加工废", "weight": 0.0},
{"name": "扩散废", "weight": 2.0},
]
result = metric_result({"year": 2026, "month": 9}, 0.93)
result["summary"]["bright"] = {"defects": defects}
doc = evidence(result)
donut = build_visuals([doc], "用环状图展示亮片已列正式报废类别构成", "turn-donut")["visuals"][0]
self.assertEqual(donut["type"], "donut")
self.assertEqual(donut["metric"], "source_defect_weight")
self.assertEqual(donut["series"][0]["values"], [3.0, 5.0, 0.0, 2.0])
self.assertEqual(donut["coverage"], {
"totalRows": 4, "returnedRows": 4, "truncated": False, "shareBasis": "displayed_categories"
})
self.assertEqual(donut["requiredFields"], [
"bright_plating_scrap", "bright_material_scrap", "bright_processing_scrap", "bright_diffusion_scrap"
])
self.assertIn("占比按本图已列类别重量合计", donut["note"])
pareto = build_visuals([doc], "绘制亮片柏拉图并标注报废类别", "turn-pareto")["visuals"][0]
self.assertEqual(pareto["type"], "pareto")
self.assertEqual(pareto["series"][0]["values"], [5.0, 3.0, 2.0, 0.0])
self.assertEqual([category["key"] for category in pareto["categories"]], [
"bright_material_scrap", "bright_plating_scrap", "bright_diffusion_scrap", "bright_processing_scrap"
])
self.assertNotEqual(donut["id"], pareto["id"])
comparison = comparison_result()
comparison["current"]["bright"] = {"defects": defects, "rate": 0.99, "scrapWeight": 5.0}
current_donut = build_visuals([evidence(comparison)], "亮片当前已列类别构成环状图", "turn-comparison-donut")["visuals"][0]
self.assertEqual(current_donut["type"], "donut")
self.assertEqual(current_donut["period"], {"year": 2026, "month": 9})
self.assertNotIn("comparisonPeriod", current_donut)
def test_summary_and_complete_category_top_only_make_share_charts_when_complete(self):
result = metric_result({"year": 2026, "month": 9}, 0.93)
result["summary"]["black"] = {"defects": [
{"name": "责废", "weight": 1.0}, {"name": "料废", "weight": 2.0}, {"name": "外废", "weight": 3.0}
]}
result["summary"]["black"]["defects"][1]["weight"] = -2.0
self.assertEqual(build_visuals([evidence(result)], "黑片环状图展示构成", "turn-negative")["visualState"], "unavailable")
result["summary"]["black"]["defects"][1]["weight"] = 0.0
result["summary"]["black"]["defects"][2]["weight"] = 0.0
result["summary"]["black"]["defects"][0]["weight"] = 0.0
self.assertEqual(build_visuals([evidence(result)], "黑片环状图展示构成", "turn-zero")["visualState"], "unavailable")
result["summary"]["black"]["defects"][0]["weight"] = 1.0
filtered = dict(result)
filtered["filters"] = {"category": "责废", "extraFilters": {}}
self.assertEqual(build_visuals([evidence(filtered)], "黑片环状图展示构成", "turn-filtered-category")["visualState"], "unavailable")
top = {
"kind": "quality_top", "releaseId": "r-1", "stage": "black", "dimension": "category",
"period": {"year": 2026, "month": 9}, "filters": {"extraFilters": {}},
"rankingCoverage": {"groups": 3, "complete": True},
"cumulativeThresholdApplied": False,
"rows": [
{"rank": 1, "key": "责废", "label": "责废", "weight": 8.0},
{"rank": 2, "key": "料废", "label": "料废", "weight": 4.0},
{"rank": 3, "key": "外废", "label": "外废", "weight": 1.0},
],
}
chart = build_visuals([evidence(top)], "黑片柏拉图按正式类别", "turn-pareto-top")["visuals"][0]
self.assertEqual(chart["type"], "pareto")
self.assertEqual(chart["series"][0]["values"], [8.0, 4.0, 1.0])
top["rankingCoverage"]["complete"] = False
self.assertEqual(build_visuals([evidence(top)], "黑片柏拉图按正式类别", "turn-pareto-incomplete")["visualState"], "unavailable")
def test_colloquial_quality_analysis_requests_generate_bound_charts(self):
questions = [
'查一下消费电子美洲近期质量下滑严重的产品',
'看看电机部合格率下跌的规格', '电机部质量走低的产品',
'电机部合格率回落的产品', '电机部合格率降低的产品',
'查查电机部质量变差的产品', '查查电机部质量变坏的产品',
'查查电机部质量变糟的产品', '找出电机部降幅大的规格',
'查电机部跌幅大的产品', '电机部质量最差的产品',
'电机部质量较差的产品', '电机部合格率偏低的规格',
'查查电机部质量不理想的产品', '电机部表现不佳的产品',
'电机部质量不稳定的产品', '电机部质量波动大的产品',
'电机部报废突然变多的产品', '电机部报废突增的规格',
'电机部报废激增的产品', '近期值得关注的规格',
'近期重点产品', '电机部质量好转的规格',
'电机部合格率提升的产品', '电机部合格率回升的产品',
'电机部报废减少的产品', '电机部质量环比怎么样',
'电机部与上月差异', '电机部质量异常的产品',
'电机部质量不好的产品', '电机部质量不佳的产品',
'电机部质量差的产品', '电机部质量糟糕的产品',
'电机部合格率变低的规格', '电机部质量退步的产品',
'电机部质量不达标的产品', '电机部合格率低于目标的规格',
'电机部质量降得厉害的产品', '电机部合格率掉得多的规格',
]
doc = evidence(comparison_result())
context = {'releaseId': 'r-1', 'filters': {'department': '电机部'}}
for question in questions:
with self.subTest(question=question):
output = build_visuals([doc], question, 'turn-colloquial', context=context)
self.assertEqual(output['visualState'], 'ready')
self.assertTrue(output['visuals'])
self.assertTrue(all(v['scope'].get('department') == '电机部' for v in output['visuals']))
self.assertTrue(all(v['evidenceRefs'] == ['Q1234ABCD'] for v in output['visuals']))
def test_colloquial_requests_keep_text_only_and_no_evidence_guards(self):
question = '查一下近期质量下滑严重的产品'
doc = evidence(comparison_result())
for suffix in ['只要文字', '仅需文本', '仅用文字', '只返回数值', '不用画图', '不需要配图', '不要图表', '只需要文字', '仅输出数字', '仅文字', '无需图', '不必画图']:
with self.subTest(suffix=suffix):
self.assertEqual(build_visuals([doc], question + ',' + suffix, 'turn-text-only')['visuals'], [])
for simple in ['综合合格率是多少', '黑片合格率多少', '产品名称是什么', '查一下数据源文件名']:
with self.subTest(simple=simple):
self.assertEqual(build_visuals([doc], simple, 'turn-simple')['visuals'], [])
self.assertEqual(build_visuals([], question, 'turn-no-evidence')['visuals'], [])
wrong_scope = {'releaseId': 'r-1', 'filters': {'department': '无关部门'}}
labelled = build_visuals([doc], question, 'turn-wrong-scope', context=wrong_scope)['visuals']
self.assertTrue(all(v['scope'].get('department') == '电机部' for v in labelled))
def test_simple_text_and_negative_visual_request_override(self):
doc = evidence(comparison_result())
self.assertEqual(build_visuals([doc], "综合合格率是多少", "turn-10")["visualState"], "not_requested")
self.assertEqual(build_visuals([doc], "不要图,只要文字,比较两个期间", "turn-10")["visualState"], "not_requested")
self.assertEqual(build_visuals([doc], "不要绘图,只要文本,比较两个期间", "turn-10")["visualState"], "not_requested")
self.assertEqual(build_visuals([], "重新分析重点产品并写出降幅", "turn-followup", context={})["visualState"], "not_requested")
self.assertEqual(build_visuals([], "画图比较重点产品降幅", "turn-followup", context={})["visualState"], "unavailable")
column = build_visuals([doc], "不要环状图,用柱状图比较两期综合合格率", "turn-negative-style-column")["visuals"][0]
self.assertEqual(column["type"], "column")
self.assertEqual(build_visuals([doc], "不用柏拉图,显示条形图比较两期综合合格率", "turn-negative-style-bar")["visuals"][0]["type"], "bar")
def test_explicit_composite_trend_does_not_add_unrequested_stages_or_plot_missing_as_perfect(self):
result = metric_result({"year": 2026}, 0.93)
result.update({"trend": [
{"period": "2026-01", "compositeRate": 0.91},
{"period": "2026-02", "compositeRate": 1.0, "coverage": {"blackRows": 0, "brightRows": 0}},
{"period": "2026-03", "compositeRate": 0.93},
{"period": "2026-04", "compositeRate": 0.94},
{"period": "2026-05", "compositeRate": 1.0, "monthStatus": "future"},
], "trendCount": 5, "trendTruncated": False})
charts = build_visuals([evidence(result)], "只展示综合合格率趋势图", "turn-nodata")["visuals"]
self.assertEqual([chart["metric"] for chart in charts], ["composite_rate"])
self.assertEqual(charts[0]["series"][0]["values"], [0.91, None, 0.93, 0.94, None])
def test_requeried_evidence_keeps_image_address_but_changed_data_does_not(self):
first = build_visuals([evidence(comparison_result(), ref='Q1234ABCD')], '比较两个期间变化', 'turn-stable')['visuals'][0]
second = build_visuals([evidence(comparison_result(), ref='Q9876ABCD')], '比较两个期间变化', 'turn-stable')['visuals'][0]
self.assertEqual(first['id'], second['id'])
self.assertNotEqual(first['evidenceRefs'], second['evidenceRefs'])
changed = comparison_result(); changed['current']['compositeRate'] = .97
third = build_visuals([evidence(changed)], '比较两个期间变化', 'turn-stable')['visuals'][0]
self.assertNotEqual(first['id'], third['id'])
def test_ids_are_stable_per_semantics_and_output_is_isolated(self):
doc = evidence(comparison_result())
doc["absoluteEvidencePath"] = "/Users/alice/private/source.json"
first = build_visuals([doc], "比较两个期间变化", "turn-11")
second = build_visuals([doc], "比较两个期间变化", "turn-11")
self.assertEqual(first["visuals"][0]["id"], second["visuals"][0]["id"])
self.assertNotIn("absoluteEvidencePath", json.dumps(first, ensure_ascii=False))
self.assertNotIn("/Users/alice", json.dumps(first, ensure_ascii=False))
self.assertLess(len(json.dumps(first, ensure_ascii=False).encode("utf-8")), MAX_BODY_BYTES)
changed_turn = build_visuals([doc], "比较两个期间变化", "turn-12")
self.assertNotEqual(first["visuals"][0]["id"], changed_turn["visuals"][0]["id"])
def test_malformed_evidence_and_large_rankings_fail_softly(self):
malformed = evidence(changes_result(rows=[{"rank": True, "key": "p-1", "label": "x", "scrapDelta": 1}]))
self.assertEqual(build_visuals([malformed], "画产品报废增量排名", "turn-13")["visualState"], "unavailable")
result = changes_result(rows=[
{"rank": index + 1, "key": f"p-{index}", "label": f"规格{index}", "scrapDelta": index}
for index in range(15)
], totalRows=15, returnedRows=15, truncated=False)
chart = build_visuals([evidence(result)], "画产品报废增量排名", "turn-13")["visuals"][0]
self.assertEqual(len(chart["categories"]), 15)
self.assertFalse(chart["coverage"]["truncated"])
self.assertEqual(chart["series"][0]["values"], list(map(float, range(15))))
if __name__ == "__main__":
unittest.main()