Files

332 lines
20 KiB
Python

import copy
import json
import sys
import tempfile
import threading
import unittest
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
from nao_quality_tools import QualityTools, QualityToolError
from test_nao_quality_tools import FakeApi, snapshot_period
from nao_agent_task import normalize_task, bind_task
from test_nao_agent_task import task_value
from analysis_visuals import build_visuals
from nao_evidence_finalizer import coverage_sufficient
from nao_protocol_execution import execute
from nao_weight_ranking import rank_response, ranking_chart, ranking_report, missing_ranking_visuals
QUESTION = '做几张26年的亮片生产重量柏拉图,产品级、产业部级'
ACTOR='11111111-1111-4111-8111-111111111111'
SESSION='22222222-2222-4222-8222-222222222222'
TURN='55555555-5555-4555-8555-555555555555'
def signed_response(positive_rows=872, unavailable_rows=167, *, top_weight=None, metric='totalWeight', stage='black'):
period={'year':2026,'monthStart':1,'monthEnd':9}
total=sum([top_weight] if top_weight is not None else [])
rows=[]
for index in range(positive_rows):
weight=(top_weight if index==0 and top_weight is not None else 1)
total+=weight if not (index==0 and top_weight is not None) else 0
rows.append({'key':f'product-{index:04d}','label':f'规格{index:04d}',
stage:{metric:weight},'coverage':{stage+'Rows':1}})
rows.append({'key':'mimo-negative','label':'mimo-negative',stage:{metric:-10.05},'coverage':{stage+'Rows':1}})
for index in range(unavailable_rows):
rows.append({'key':f'no-stage-{index:04d}','label':f'未覆盖{index:04d}',stage:{metric:None},
'coverage':{stage+'Rows':0}})
total-=10.05
months=[{'year':2026,'month':month,'blackRows':1 if stage=='black' else 0,
'brightRows':1 if stage=='bright' else 0} for month in range(1,10)]
summary={stage:{metric:total}}
return {'rows':rows,'context':{'rowCount':len(rows)},'summary':summary,
'coverage':{'rawRows':len(rows),'includedRows':len(rows),'sourceMonths':months}},period
class WeightApi(FakeApi):
def __init__(self, *, partial_year=True, hole=False, mismatch=False):
super().__init__()
self.partial_year, self.hole, self.mismatch = partial_year, hole, mismatch
self.metric_query = 0
def call(self, path, payload=None, method=None):
result = super().call(path, payload, method)
if path == '/api/analysis/tools/catalog':
result['sourceFields'] = [{'key':'customer_code','label':'客户编码','type':'source_value',
'stages':['bright'],'columns':{'bright':'客户编码'},'operators':['in']}]
if path.startswith('/api/metrics?'):
self.metric_query += 1
params = parse_qs(urlsplit(path).query)
for month in result['coverage']['sourceMonths']:month['brightRows']=12
rows = []
for label, weight, scrap in [('scrap-leader', 10, 9), ('production-leader', 80, 1), ('third', 60, 2)]:
row = self._product_row(label, label, 1, scrap)
row['bright']['totalWeight'] = weight
rows.append(row)
result['rows'] = rows
result['context']['rowCount'] = 3
result['summary']['bright']['totalWeight'] = 151 if self.mismatch else 150
result['summary']['bright']['scrapWeight'] = 12
if self.partial_year:
result['coverage']['sourceMonths'] = result['coverage']['sourceMonths'][:9]
result['coverage']['missingStages'] = [{'year':2026,'month':m,'stage':'bright'} for m in (10,11,12)]
if self.hole:
result['coverage']['sourceMonths'] = [m for m in result['coverage']['sourceMonths'] if m['month'] != 5]
if 'monthStart' in params:
result['context']['monthStart'] = int(params['monthStart'][0])
result['context']['monthEnd'] = int(params['monthEnd'][0])
if 'columnFilters' in params:
result['filters'] = {'columnFilters':json.loads(params['columnFilters'][0])}
result['protocolEvidence'] = {'queryId':f'rank-query-{self.metric_query}',
'attemptId':'attempt','sessionId':'session','turnId':'turn','revision':1,
'executionId':'execution','responseHash':'a'*64}
return result
class NegativeWeightApi(WeightApi):
def call(self, path, payload=None, method=None):
result=super().call(path,payload,method)
if path.startswith('/api/metrics?'):
params=parse_qs(urlsplit(path).query)
if params.get('view',[''])[0]=='product':
rows=[]
for key,label,weight in (('large','大重量规格',100),('small','小重量规格',1),('mimo','mimo修正',-10.05)):
row=self._product_row(key,label,1,1)
row['black']['totalWeight']=weight
rows.append(row)
result['rows']=rows;result['context']['rowCount']=3
result['summary']['black']['totalWeight']=90.95
for month in result['coverage']['sourceMonths']:month['blackRows']=1
result['protocolEvidence']={'attemptId':SESSION,'sessionId':ACTOR,'turnId':TURN,
'revision':3,'executionId':TURN,'queryId':'signed-rank-query','responseHash':'b'*64}
return result
def planned(**updates):
value={'dimensions':['product','department'],'stages':['bright'],'fields':['totalWeight'],
'period':{'year':2026},'visualPreference':'required','visualType':'pareto','periodCoverage':'available'}
value.update(updates)
return normalize_task(task_value(**value), QUESTION)
class WeightRankingTests(unittest.TestCase):
def run_rank(self, metric='totalWeight', **options):
api = WeightApi(**options)
with tempfile.TemporaryDirectory() as folder:
QualityTools(api_factory=lambda:api, evidence_dir=Path(folder)).quality_data({
'mode':'rank','releaseId':'release-a','period':{'year':2026},
'dimension':'product','stage':'bright','metric':metric,'limit':2})
doc = json.loads(next(Path(folder).glob('nao-quality-*.json')).read_text())
return doc, api
def test_ranks_all_products_by_requested_stage_weight_before_top_cut(self):
doc, api = self.run_rank()
result = doc['result']
self.assertEqual([row['label'] for row in result['rows']], ['production-leader','third'])
self.assertEqual(result['totalWeight'], 150)
self.assertEqual(result['rows'][0]['share'], 80/150)
self.assertAlmostEqual(result['rows'][-1]['cumulativeShare'], 140/150)
self.assertLess(result['rows'][-1]['cumulativeShare'], 1)
self.assertEqual(result['rankingCoverage']['groups'], 3)
self.assertFalse(any('rowLimit=' in path for _,path,_ in api.calls if path.startswith('/api/metrics')))
def test_black_total_weight_signed_reconciliation_keeps_all_absent_groups_auditable(self):
response,period=signed_response()
result=rank_response(response,{'id':'release-a','name':'A','status':'PUBLISHED'},period,{},
'product','black','totalWeight',10)
audit=result['rankingCoverage']
self.assertEqual(response['context']['rowCount'],1040)
self.assertEqual(audit['sourceGroups'],1040)
self.assertEqual(audit['groups'],873)
self.assertEqual(audit['unavailableGroups'],167)
self.assertEqual(audit['positiveGroups'],872)
self.assertEqual(audit['negativeGroups'],1)
self.assertEqual(audit['negativeWeight'],-10.05)
self.assertEqual(audit['negativeWeightMagnitude'],10.05)
self.assertEqual(result['totalWeight'],861.95)
self.assertEqual(result['rows'][0]['weight'],1)
self.assertTrue(all(row['weight']>0 for row in result['rows']))
self.assertAlmostEqual(result['rows'][0]['share'],1/861.95)
doc={'evidenceRef':'QSIGNED10','result':result}
task=planned(dimensions=['product'],stages=['black'],fields=['totalWeight'],period=period)
chart=ranking_chart(doc,'signed-black-total',task)
self.assertIsNotNone(chart)
self.assertIn('1项负向投入重量修正',chart['note'])
bad=copy.deepcopy(response);bad['summary']['black']['totalWeight']+=.1
with self.assertRaisesRegex(QualityToolError,'合计与同范围正式总量不一致'):
rank_response(bad,{'id':'release-a'},period,{},'product','black','totalWeight',10)
def test_negative_weights_remain_rejected_outside_black_total_weight(self):
for stage,metric in (('black','scrapWeight'),('bright','totalWeight'),('bright','scrapWeight')):
with self.subTest(stage=stage,metric=metric):
response={'rows':[{'key':'negative','label':'负值',stage:{metric:-1},'coverage':{stage+'Rows':1}}],
'context':{'rowCount':1},'summary':{stage:{metric:10}},
'coverage':{'sourceMonths':[{'year':2026,'month':month,'blackRows':1,'brightRows':1}
for month in range(1,10)]}}
with self.assertRaisesRegex(QualityToolError,'重量不能为负'):
rank_response(response,{'id':'release-a'},{'year':2026,'monthStart':1,'monthEnd':9},
{},'product',stage,metric,10)
def test_signed_black_total_reports_correction_and_blocks_over_100_chart_as_partial(self):
response,period=signed_response(positive_rows=2,unavailable_rows=0,top_weight=100)
result=rank_response(response,{'id':'release-a','name':'A','status':'PUBLISHED'},period,{},
'product','black','totalWeight',10)
self.assertEqual(result['totalWeight'],90.95)
self.assertEqual([row['label'] for row in result['rows']],['规格0000','规格0001'])
self.assertGreater(result['rows'][-1]['cumulativeShare'],1)
document={'evidenceRef':'QNEGATIVE1','result':result}
task=planned(dimensions=['product'],stages=['black'],fields=['totalWeight'],period=period,
visualPreference='required')
context=bind_task({'releaseId':'release-a'},task)
self.assertIsNone(ranking_chart(document,'negative-correction',task))
gap=missing_ranking_visuals(task,[],[document])
self.assertEqual(len(gap),1)
self.assertIn('负向修正使正重量Top合计超过黑片净总重',gap[0])
report=ranking_report([document],task,context)
self.assertIn('1项负向投入重量修正,净额-10.05 kg仍计入正式净总重分母',report['facts'][0]['text'])
section=report['sections'][0]
self.assertGreater(section.index('排名表只展示正重量Top'),section.index('| 1 |'))
def test_protocol_execution_keeps_signed_denominator_but_returns_partial_without_over_100_chart(self):
t=normalize_task(task_value(kind='analysis',dimensions=['product'],stages=['black'],
dimensionStages={'product':['black']},fields=['totalWeight'],period={'year':2026},
trendRequired=False,visualPreference='auto',visualType='pareto'),
'按产品查看黑片投入重量排名',{'_protocol':{'version':1}})
if t['filters'].get('columnFilters')==[]:t['filters'].pop('columnFilters')
api=NegativeWeightApi()
with tempfile.TemporaryDirectory() as folder,patch('nao_evidence_finalizer.synthesize',return_value={
'answer':'已核验黑片修正重量排名','evidenceSufficient':True,'missingEvidence':[],'usage':{}}):
root=Path(folder);(root/'evidence').mkdir();(root/'private').mkdir()
result=execute(request={'releaseId':'release-a','turnId':TURN,'question':t['question']},task=t,
authority={'attemptId':SESSION,'sessionId':ACTOR,'turnId':TURN,'revision':3,'executionId':TURN},
actor_root=root,delegated=api,connection=('offline','synthetic','model'),
cancel_event=threading.Event(),emit=lambda _:None)
doc=json.loads(next((root/'evidence').glob('nao-quality-*.json')).read_text())
self.assertEqual(doc['result']['totalWeight'],90.95)
self.assertEqual(doc['result']['rankingCoverage']['negativeGroups'],1)
self.assertEqual(doc['result']['rankingCoverage']['negativeWeight'],-10.05)
self.assertEqual(result['status'],'PARTIAL')
self.assertTrue(any('负向修正使正重量Top合计超过黑片净总重' in item
for item in result['evidenceCompletion']['missingEvidence']))
self.assertFalse(result['visuals'])
def test_rank_retains_column_filter_month_range_and_execution_proof(self):
api=WeightApi()
rule={'field':'customer_code','stages':['bright'],'operator':'in','values':['0012']}
with tempfile.TemporaryDirectory() as folder:
QualityTools(api_factory=lambda:api,evidence_dir=Path(folder)).quality_data({
'mode':'rank','releaseId':'release-a','period':{'year':2026,'monthStart':1,'monthEnd':9},
'filters':{},'columnFilters':[rule],'dimension':'product','stage':'bright',
'metric':'totalWeight','limit':2})
doc=json.loads(next(Path(folder).glob('nao-quality-*.json')).read_text())
result=doc['result']
self.assertEqual(result['filters']['columnFilters'],[rule])
self.assertEqual(result['period'],{'year':2026,'monthStart':1,'monthEnd':9})
self.assertEqual(result['periodCoverage']['availableMonths'],list(range(1,10)))
self.assertTrue(result['periodCoverage']['complete'])
self.assertEqual(result['protocolEvidence']['queryId'],'rank-query-1')
metrics_paths=[path for _,path,_ in api.calls if path.startswith('/api/metrics')]
self.assertEqual(len(metrics_paths),1)
self.assertIn('columnFilters=',metrics_paths[0])
self.assertNotIn('rowLimit=',metrics_paths[0])
self.assertNotIn('rowOffset=',metrics_paths[0])
def test_rank_only_allows_column_filter_parameter_and_other_modes_reject_it(self):
api=WeightApi()
with tempfile.TemporaryDirectory() as folder:
tools=QualityTools(api_factory=lambda:api,evidence_dir=Path(folder))
with self.assertRaisesRegex(QualityToolError,'query/compare/rank'):
tools.quality_data({'mode':'changes','releaseId':'release-a','period':{'year':2026},
'comparisonPeriod':{'year':2025},'dimension':'group','columnFilters':[]})
self.assertEqual(api.calls,[])
def test_ranking_chart_scope_preserves_exact_continuous_month_range(self):
from nao_weight_ranking import ranking_chart
doc,_=self.run_rank()
doc['result']['period']={'year':2026,'monthStart':3,'monthEnd':5}
t=planned();t['period']=doc['result']['period']
chart=ranking_chart(doc,'range-ranking-turn',t)
self.assertIsNotNone(chart)
self.assertEqual({key:chart['scope'][key] for key in ('year','monthStart','monthEnd')},t['period'])
def test_pareto_keeps_top_rows_but_binds_ratio_to_full_population(self):
doc, _ = self.run_rank()
task = planned()
context = bind_task({'releaseId':'release-a'},task)
output = build_visuals([doc],QUESTION,'turn-ranking',context=context)
self.assertEqual(output['visualState'],'ready')
chart = output['visuals'][0]
self.assertEqual(chart['type'],'pareto')
self.assertEqual(chart['coverage']['denominator'],150)
self.assertEqual(chart['coverage']['shareBasis'],'all_scope_weight')
self.assertIn('1—9月',chart['subtitle'])
self.assertEqual(len(chart['categories']),2)
self.assertEqual([category['key'] for category in chart['categories']],
[row['key'] for row in doc['result']['rows'][:2]],
'rank chart keys must bind the actual formal group keys, not presentation placeholders')
department=copy.deepcopy(doc);department['result']['dimension']='department';department['evidenceRef']='Q00000002'
output=build_visuals([doc,department],QUESTION,'turn-ranking',context=context)
self.assertEqual({v['dimension'] for v in output['visuals']},{'product','department'})
from nao_weight_ranking import missing_ranking_visuals
self.assertEqual(missing_ranking_visuals(task,output['visuals']),[])
self.assertTrue(missing_ranking_visuals(task,output['visuals'][:1]))
def test_pareto_emits_each_requested_weight_field_for_the_same_stage(self):
total_doc,_=self.run_rank()
scrap_doc,_=self.run_rank(metric='scrapWeight')
task=planned(fields=['totalWeight','scrapWeight'],dimensions=['product'],visualPreference='auto')
context=bind_task({'releaseId':'release-a'},task)
output=build_visuals([total_doc,scrap_doc],QUESTION,'two-field-ranking',context=context)
self.assertEqual(output['visualState'],'ready')
self.assertEqual({visual['metric'] for visual in output['visuals']},
{'bright_total_weight','bright_scrap_weight'})
from nao_weight_ranking import missing_ranking_visuals
self.assertEqual(missing_ranking_visuals(task,output['visuals']),[])
def test_missing_dimension_is_not_completion_and_year_data_is_not_called_absent(self):
doc, _ = self.run_rank()
task = planned()
context = bind_task({'releaseId':'release-a'},task)
self.assertFalse(coverage_sufficient([doc],QUESTION,context))
department = copy.deepcopy(doc)
department['result']['dimension'] = 'department'
department['evidenceRef'] = 'Q00000002'
self.assertTrue(coverage_sufficient([doc,department],QUESTION,context))
complete = planned(periodCoverage='complete')
self.assertFalse(coverage_sufficient([doc,department],QUESTION,bind_task({'releaseId':'release-a'},complete)))
def test_internal_month_holes_and_total_mismatch_do_not_pass_as_complete(self):
doc, _ = self.run_rank(hole=True)
context = bind_task({'releaseId':'release-a'},planned())
self.assertFalse(coverage_sufficient([doc],QUESTION,context))
with self.assertRaises(QualityToolError):self.run_rank(mismatch=True)
def test_enum_strings_are_normalized_without_guessing_business_intent(self):
task = normalize_task(task_value(dimensions='product,department',stages='bright',fields='totalWeight'),QUESTION)
self.assertEqual(task['dimensions'],['product','department'])
self.assertEqual(task['stages'],['bright'])
def test_each_ranking_dimension_uses_only_its_declared_stage(self):
doc, _ = self.run_rank()
department = copy.deepcopy(doc)
department['result'].update(dimension='department', stage='black')
department['evidenceRef'] = 'Q00000002'
task = planned()
task['stages'] = ['black', 'bright']
task['dimensionStages'] = {'product': ['bright'], 'department': ['black']}
context = bind_task({'releaseId': 'release-a'}, task)
self.assertTrue(coverage_sufficient([doc, department], QUESTION, context))
charts = build_visuals([doc, department], QUESTION, 'mixed-stage-ranking', context=context)['visuals']
self.assertEqual({(v['dimension'], v['stage']) for v in charts}, {('product', 'bright'), ('department', 'black')})
self.assertTrue(all(v['coverage']['denominator'] == 150 for v in charts))
from nao_weight_ranking import missing_ranking_visuals
self.assertEqual(missing_ranking_visuals(task, charts), [])
wrong = copy.deepcopy(department); wrong['result']['stage'] = 'bright'
self.assertFalse(coverage_sufficient([doc, wrong], QUESTION, context))
if __name__ == '__main__':unittest.main()