优化:未分类连续维护与柏拉图预汇总,同步已发布修复
This commit is contained in:
@@ -0,0 +1,246 @@
|
||||
import copy
|
||||
import sys
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
from pathlib import Path
|
||||
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts')]
|
||||
from nao_weight_ranking import rank_response, ranking_report, ranking_chart
|
||||
from nao_native_answer import _validate_blocks, _binding_inventory, _bind_literal_measures
|
||||
|
||||
|
||||
def fixture():
|
||||
rows = []
|
||||
for i, (black, bright) in enumerate([(5, 60), (40, 1), (30, 30), (1, 40), (20, 10)], 1):
|
||||
rows.append({'key': f'product-{i}', 'label': f'规格{i}',
|
||||
'black': {'scrapWeight': black, 'totalWeight': 100},
|
||||
'bright': {'scrapWeight': bright, 'totalWeight': 100},
|
||||
'compositeRate': .8 + i / 100,
|
||||
'coverage': {'blackRows': 1, 'brightRows': 1}})
|
||||
return {'rows': rows, 'summary': {'black': {'scrapWeight': 96}, 'bright': {'scrapWeight': 141}},
|
||||
'context': {'rowCount': 5}, 'coverage': {'sourceMonths': [
|
||||
{'year': 2026, 'month': 9, 'blackRows': 5, 'brightRows': 5}]}}
|
||||
|
||||
|
||||
class CombinedRankingTests(unittest.TestCase):
|
||||
def test_combined_contract_survives_task_normalization_and_execution_arguments(self):
|
||||
from nao_agent_task import normalize_task
|
||||
from nao_protocol_execution import _scoped_arguments
|
||||
value={'goal':'产品不良TOP5,报废合计与综合率','kind':'analysis','fields':['rate','scrapWeight'],
|
||||
'dimensions':['product'],'dimensionStages':{'product':[]},'stages':[],
|
||||
'period':{'year':2026,'month':9},'comparisonPeriod':None,'comparisonRequired':False,
|
||||
'trendRequired':False,'freshQuery':True,'verifySource':False,'fullDetails':False,
|
||||
'needsClarification':False,'filterUpdates':{},'queryPlan':[{
|
||||
'nodeId':'rank','purpose':'ranking','fields':['rate','scrapWeight'],'stages':[],
|
||||
'dimension':'product','limit':5,'selector':{'kind':'base'},'visualType':'bar',
|
||||
'visualPreference':'auto','comparisonRequired':False}]}
|
||||
task=normalize_task(value,'产品不良TOP5',{'_protocol':{'version':1}})
|
||||
self.assertEqual(task['stages'],[])
|
||||
args=_scoped_arguments({'releaseId':'release-a'},{'task':task},task['queryPlan'][0])
|
||||
self.assertEqual(len(args),1)
|
||||
self.assertIsNone(args[0]['stage'])
|
||||
self.assertEqual(args[0]['metric'],'scrapWeight')
|
||||
from nao_plan_recovery import repair_summary
|
||||
redundant=copy.deepcopy(value);redundant['stages']=['black','bright']
|
||||
repaired,changes=repair_summary(redundant,{'_protocol':{'version':1}})
|
||||
self.assertEqual(repaired['stages'],[])
|
||||
self.assertEqual(repaired['queryPlan'],value['queryPlan'])
|
||||
from nao_query_plan import normalize_query_plan
|
||||
follow={'nodeId':'selected','purpose':'metrics','fields':['rate'],'stages':[],
|
||||
'selector':{'kind':'ranking_top','sourceNodeId':'rank','stage':'overall','metric':'scrapWeight','count':2},
|
||||
'comparisonRequired':False,'visualType':'bar','visualPreference':'auto'}
|
||||
compound=copy.deepcopy(value);compound['queryPlan'].append(follow)
|
||||
self.assertEqual(len(normalize_task(compound,'产品不良TOP5及前两项综合率',{'_protocol':{'version':1}})['queryPlan']),2)
|
||||
def result(self):
|
||||
return rank_response(fixture(), {'id': 'release-a'}, {'year': 2026, 'month': 9}, {},
|
||||
'product', None, 'scrapWeight', 5)
|
||||
|
||||
def test_sum_both_stages_before_top_cut_and_keep_formal_rate(self):
|
||||
result = self.result()
|
||||
self.assertEqual([row['key'] for row in result['rows']],
|
||||
['product-1', 'product-3', 'product-2', 'product-4', 'product-5'])
|
||||
self.assertEqual(result['totalWeight'], 237)
|
||||
self.assertEqual(result['rows'][0]['weight'], 65)
|
||||
self.assertEqual(result['rows'][0]['compositeRate'], .81)
|
||||
self.assertIsNone(result['stage'])
|
||||
|
||||
def test_formal_composite_survives_either_single_source_direction(self):
|
||||
for absent in ('black', 'bright'):
|
||||
with self.subTest(absent=absent):
|
||||
source = fixture()
|
||||
row = source['rows'][0]
|
||||
source['summary'][absent]['scrapWeight'] -= row[absent]['scrapWeight']
|
||||
row[absent] = {'scrapWeight': 0, 'totalWeight': 0, 'rate': 1}
|
||||
row['coverage'][absent + 'Rows'] = 0
|
||||
result = rank_response(source, {'id': 'release-a'}, {'year': 2026, 'month': 9},
|
||||
{}, 'product', None, 'scrapWeight', 5)
|
||||
selected = next(item for item in result['rows'] if item['key'] == row['key'])
|
||||
self.assertEqual(selected['compositeRate'], row['compositeRate'])
|
||||
|
||||
def test_month_coverage_accepts_either_formal_source_without_faking_missing_months(self):
|
||||
from nao_weight_ranking import ranking_gaps
|
||||
for absent in ('black', 'bright'):
|
||||
with self.subTest(absent=absent):
|
||||
source = fixture()
|
||||
source['summary'][absent]['scrapWeight'] = 0
|
||||
source['coverage']['sourceMonths'][0][absent + 'Rows'] = 0
|
||||
for row in source['rows']:
|
||||
row[absent] = {'scrapWeight': 0, 'totalWeight': 0, 'rate': 1}
|
||||
row['coverage'][absent + 'Rows'] = 0
|
||||
result = rank_response(source, {'id': 'release-a'}, {'year': 2026, 'month': 9},
|
||||
{}, 'product', None, 'scrapWeight', 5)
|
||||
task = {'period': result['period'], 'filters': {}, 'dimensions': ['product'],
|
||||
'dimensionStages': {'product': []}, 'stages': [],
|
||||
'fields': ['rate', 'scrapWeight'], 'periodCoverage': 'complete'}
|
||||
self.assertTrue(result['periodCoverage']['complete'])
|
||||
self.assertEqual(ranking_gaps([{'result': result, 'evidenceRef': 'Q00000001'}],
|
||||
task, {'releaseId': 'release-a'}), [])
|
||||
|
||||
def test_missing_or_unknown_row_source_cannot_validate_default_composite(self):
|
||||
from nao_quality_tools import QualityTools
|
||||
for coverage in ({'blackRows': 0, 'brightRows': 0}, {'blackRows': 1}, None):
|
||||
with self.subTest(coverage=coverage):
|
||||
row = {**fixture()['rows'][0], 'coverage': coverage, 'compositeRate': 1}
|
||||
self.assertIsNone(QualityTools._row_rate(row, None))
|
||||
|
||||
def test_top5_all_reach_narration_and_combined_chart(self):
|
||||
result = self.result()
|
||||
task = {'period': result['period'], 'filters': {}, 'dimensions': ['product'],
|
||||
'dimensionStages': {'product': []}, 'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'visualType': 'bar', 'periodCoverage': 'available'}
|
||||
doc = {'result': result, 'evidenceRef': 'Q00000001'}
|
||||
report = ranking_report([doc], task, {'releaseId': 'release-a'})
|
||||
self.assertEqual(len([f for f in report['facts'] if f.get('rank')]), 5)
|
||||
self.assertIn('综合合格率', report['sections'][0])
|
||||
chart = ranking_chart(doc, 'turn-a', task)
|
||||
self.assertEqual(chart['series'][0]['values'], [65, 60, 41, 41, 30])
|
||||
self.assertEqual(chart['metric'], 'current_scrap_weight')
|
||||
|
||||
def test_missing_auto_combined_ranking_chart_is_reported(self):
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
result = self.result()
|
||||
task = {'kind': 'analysis', 'period': result['period'], 'filters': {},
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
||||
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'visualType': 'bar', 'visualPreference': 'auto'}
|
||||
scope = {'nodeId': 'rank', 'scopeId': 'scope', 'purpose': 'ranking', 'task': task}
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
visuals = protocol_visual_result([], [scope], '产品不良Top5', 'turn',
|
||||
release_id='release-a')
|
||||
self.assertTrue(visuals['missingEvidence'])
|
||||
|
||||
def test_observed_zero_scrap_completes_without_inventing_top_shares_or_a_chart(self):
|
||||
from nao_weight_ranking import ranking_gaps, missing_ranking_visuals
|
||||
source = fixture()
|
||||
for stage in ('black', 'bright'):
|
||||
source['summary'][stage]['scrapWeight'] = 0
|
||||
for row in source['rows']:
|
||||
row[stage]['scrapWeight'] = 0
|
||||
for stage in (None, 'black', 'bright'):
|
||||
with self.subTest(stage=stage):
|
||||
result = rank_response(source, {'id': 'release-a'}, {'year': 2026, 'month': 9},
|
||||
{}, 'product', stage, 'scrapWeight', 5)
|
||||
task = {'kind': 'analysis', 'period': result['period'], 'filters': {},
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': [] if stage is None else [stage]},
|
||||
'stages': [] if stage is None else [stage],
|
||||
'fields': ['rate', 'scrapWeight'] if stage is None else ['scrapWeight'],
|
||||
'visualType': 'bar', 'visualPreference': 'auto'}
|
||||
doc = {'result': result, 'evidenceRef': 'Q00000001'}
|
||||
self.assertEqual(result['rows'], [])
|
||||
self.assertEqual(result['totalWeight'], 0)
|
||||
self.assertEqual(result['emptyReason'], 'no_positive_scrap')
|
||||
self.assertEqual(ranking_gaps([doc], task, {'releaseId': 'release-a'}), [])
|
||||
self.assertEqual(missing_ranking_visuals(task, [], [doc]), [])
|
||||
report = ranking_report([doc], task, {'releaseId': 'release-a'})
|
||||
self.assertTrue(report['coverageSufficient'])
|
||||
self.assertIn('0.00', report['facts'][0]['text'])
|
||||
self.assertIsNone(ranking_chart(doc, 'turn', task))
|
||||
|
||||
def test_missing_source_is_not_an_observed_zero_and_no_fake_rate(self):
|
||||
source = fixture()
|
||||
source['rows'][0]['bright'] = {'scrapWeight': None, 'totalWeight': None}
|
||||
with self.assertRaises(ValueError):
|
||||
rank_response(source, {'id': 'release-a'}, {'year': 2026, 'month': 9}, {}, 'product', None, 'scrapWeight', 5)
|
||||
|
||||
def test_table_ordinals_are_not_business_measurements(self):
|
||||
facts = [{'id': f'F{i}', 'kind': 'product', 'rank': i, 'label': f'规格甲{chr(64+i)}',
|
||||
'text': f'报废重量{10*i}.00 kg。', 'evidenceRef': 'Q00000001'} for i in range(1, 6)]
|
||||
parsed = {'blocks': [{'role': 'core', 'text': '已列出重点规格。', 'factIds': ['F1']},
|
||||
{'role': 'key_evidence', 'text': '### 报废排名\n\n| 排名 | 报废总重 |\n| --- | --- |\n' +
|
||||
'\n'.join(f'| {i} | {10*i}.00 kg |' for i in range(1, 6)),
|
||||
'factIds': [f'F{i}' for i in range(1, 6)]}]}
|
||||
tokens = _binding_inventory(facts)
|
||||
parsed = _bind_literal_measures(copy.deepcopy(parsed), tokens, {})
|
||||
blocks, _ = _validate_blocks(parsed, facts, tokens)
|
||||
self.assertIn('| 5 | 50.00 kg |', blocks[1]['text'])
|
||||
|
||||
def test_verified_alphanumeric_organization_names_are_not_kpi_literals(self):
|
||||
from nao_native_answer import _bind_exact_identifiers
|
||||
facts = [{'id': 'F1', 'kind': 'product', 'label': 'P1+A', 'rank': 1,
|
||||
'text': 'P1+A报废24.50 kg;综合合格率95.00%。', 'evidenceRef': 'Q00000001',
|
||||
'scope': {'period': {'year': 2026, 'month': 9},
|
||||
'filters': {'department': '器件事业部', 'group': '器件-X7'}}}]
|
||||
tokens = _binding_inventory(facts)
|
||||
for name in ('器件事业部-器件-X7', 'X7业务分组'):
|
||||
with self.subTest(name=name):
|
||||
parsed = {'blocks': [{'role': 'core', 'text': name+'中P1+A报废24.50 kg,为TOP1。',
|
||||
'factIds': ['F1']}]}
|
||||
parsed = _bind_exact_identifiers(parsed, tokens, {})
|
||||
parsed = _bind_literal_measures(parsed, tokens, {})
|
||||
blocks, _ = _validate_blocks(parsed, facts, tokens)
|
||||
self.assertIn(name, blocks[0]['text'])
|
||||
unsupported = {'blocks': [{'role': 'core', 'text': 'X9业务分组报废24.50 kg。', 'factIds': ['F1']}]}
|
||||
unsupported = _bind_exact_identifiers(unsupported, tokens, {})
|
||||
unsupported = _bind_literal_measures(unsupported, tokens, {})
|
||||
with self.assertRaises(ValueError):
|
||||
_validate_blocks(unsupported, facts, tokens)
|
||||
|
||||
def test_inline_rank_number_must_belong_to_the_named_verified_product(self):
|
||||
from nao_native_answer import _bind_exact_identifiers
|
||||
facts = [{'id': 'F'+str(i), 'kind': 'product', 'label': '规格'+label, 'rank': i,
|
||||
'text': '规格'+label+'报废30.00 kg。', 'evidenceRef': 'Q00000001'}
|
||||
for i, label in [(3, '丙'), (4, '丁')]]
|
||||
tokens = _binding_inventory(facts)
|
||||
good = {'blocks': [{'role': 'core', 'text': '3号规格丙与4号规格丁值得关注。', 'factIds': ['F3', 'F4']}]}
|
||||
bound = _bind_exact_identifiers(good, tokens, {})
|
||||
self.assertEqual(_validate_blocks(bound, facts, tokens)[0][0]['text'], good['blocks'][0]['text'])
|
||||
bad = {'blocks': [{'role': 'core', 'text': '4号规格丙值得关注。', 'factIds': ['F3']}]}
|
||||
with self.assertRaises(ValueError):
|
||||
_validate_blocks(_bind_exact_identifiers(bad, tokens, {}), facts, tokens)
|
||||
|
||||
def test_reviewed_clause_removal_does_not_leave_an_orphan_colon(self):
|
||||
from nao_native_answer import _review_supported_remainder
|
||||
facts = [{'id': 'F1', 'kind': 'product', 'label': '规格甲',
|
||||
'text': '规格甲报废30.00 kg。', 'evidenceRef': 'Q00000001'}]
|
||||
result = _review_supported_remainder(
|
||||
{'text': '错误的统计概括:规格甲报废30.00 kg。', 'factIds': ['F1']},
|
||||
{'unsupportedClauses': ['错误的统计概括'], 'remainingClaimsSupported': True,
|
||||
'remainingStatisticalClaimsSupported': True}, facts)
|
||||
self.assertIsNotNone(result)
|
||||
self.assertEqual(result['text'], '规格甲报废30.00 kg。')
|
||||
|
||||
def test_complete_ranking_survives_unrequested_uncited_optional_detail(self):
|
||||
from test_native_answer import invoke, response, request_phase
|
||||
facts=[{'id':f'F{i}','kind':'product','rank':i,'label':f'规格{chr(64+i)}',
|
||||
'text':f'规格{chr(64+i)}报废重量{10*i}.00 kg。','evidenceRef':'Q00000001'} for i in range(1,6)]
|
||||
report={'facts':facts,'requiredFactIds':[f['id'] for f in facts],'priorityFactIds':[],
|
||||
'scopes':[],'missingEvidence':[],'rejectedEvidenceRefs':[]}
|
||||
def provider(request,timeout):
|
||||
if request_phase(request)=='evidence_review':
|
||||
return response({'reviews':[{'index':i,'supported':True,'statisticalClaimsSupported':True} for i in range(3)],'missingGoalDescriptions':[]})
|
||||
return response({'blocks':[
|
||||
{'role':'core','text':'本轮TOP5已列出。','factIds':[f['id'] for f in facts]},
|
||||
{'role':'key_evidence','text':'### 排名\n\n| 排名 | 报废重量 |\n| --- | --- |\n'+
|
||||
'\n'.join(f'| {i} | {10*i}.00 kg |' for i in range(1,6)),'factIds':[f['id'] for f in facts]},
|
||||
{'role':'key_evidence','text':'本轮TOP5中,规格A报废重量为10.00 kg。','factIds':[f['id'] for f in facts]},
|
||||
{'role':'detail','text':'未提供本轮没有要求的阶段拆分。','factIds':[]}]})
|
||||
with patch('nao_native_answer.build_native_report',return_value=report):
|
||||
final=invoke(provider)
|
||||
self.assertTrue(final['evidenceSufficient'],final['missingEvidence'])
|
||||
self.assertNotIn('未提供本轮没有要求的阶段拆分',final['answer'])
|
||||
self.assertEqual(final['compositionDiagnostics']['omittedUncitedOptionalDetails'],[3])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -166,12 +166,14 @@ class AnalysisVisualsTest(unittest.TestCase):
|
||||
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_invalid_rate_is_never_clamped_or_drawn(self):
|
||||
result = comparison_result()
|
||||
result["current"]["compositeRate"] = 1.01
|
||||
output = build_visuals([evidence(result)], "比较综合合格率变化", "turn-01")
|
||||
self.assertEqual(output["visualState"], "not_requested")
|
||||
self.assertEqual(output["visuals"], [])
|
||||
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")
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Comparison boundaries are predicates, never rounded observed values."""
|
||||
import io,json,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_agent_answer import evidence
|
||||
from nao_native_answer import _bind_literal_measures,_binding_inventory,_validate_blocks,NativeCompositionError,_native_strict_bound
|
||||
|
||||
class ComparisonBoundPipelineTests(unittest.TestCase):
|
||||
def report(self,second='95.83'):
|
||||
facts=[]
|
||||
for i,name,value,raw in [(1,'规格甲','95.01','95.00708964391122'),(2,'规格乙',second,second)]:
|
||||
facts.append({'id':'F'+str(i),'kind':'product','label':name,'text':name+';综合合格率'+value+'%。',
|
||||
'evidenceRef':'Q00000001','scope':{'filters':{},'period':{'year':2026,'month':8},'dimension':'product'},
|
||||
'validity':{'verified':True,'scopeApplicable':True,'basis':'quality_weight_ranking'},
|
||||
'verifiedComparisonValues':[{'metricField':'rate','unit':'%','stageHint':'综合','rawValue':raw,'displayValue':value+'%'}]})
|
||||
return {'facts':facts,'requiredFactIds':[],'priorityFactIds':[],'missingEvidence':[],'rejectedEvidenceRefs':[], 'notices':[], 'sections':[]}
|
||||
|
||||
def invoke(self,text,*,second='95.83',native=False):
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);payload=json.loads(body['messages'][1]['content']);calls.append(body)
|
||||
if 'draftBlocks' in payload:
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':['F1','F2'],'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']], 'missingGoalDescriptions':[]}
|
||||
elif body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
value={'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]}
|
||||
else:value={'blocks':[{'role':'core','text':text,'factIds':['F1','F2']}]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value)}}]}).encode())
|
||||
with patch('nao_native_answer.build_native_report',return_value=self.report(second)):
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='比较两规格',
|
||||
evidence=evidence(),context={'_agentTask':{'kind':'analysis','period':{'year':2026,'month':8}}},
|
||||
cancel_event=threading.Event(),opener=provider,native_answer=text if native else None)
|
||||
return final,calls
|
||||
|
||||
def test_point_display_and_collective_boundary_remain_distinct(self):
|
||||
for native in (False,True):
|
||||
final,_=self.invoke('规格甲与规格乙的综合合格率均在95%以上。',native=native)
|
||||
self.assertTrue(final['bodyEvidenceSufficient'],final['compositionDiagnostics']['issues'])
|
||||
self.assertIn('95%以上',final['answer']);self.assertNotIn('95.01%以上',final['answer'])
|
||||
point,_=self.invoke('规格甲综合合格率95.01%。',native=native)
|
||||
self.assertTrue(point['bodyEvidenceSufficient']);self.assertIn('95.01%',point['answer'])
|
||||
|
||||
def test_each_explicit_subject_must_pass_the_unrounded_relation(self):
|
||||
for native in (False,True):
|
||||
for text,second in [('规格甲与规格乙的综合合格率均在95.01%以上。','95.83'),
|
||||
('规格甲与规格乙的综合合格率均在95%以上。','94.99'),
|
||||
('规格甲与规格乙的综合合格率均低于95%。','95.83')]:
|
||||
final,_=self.invoke(text,second=second,native=native)
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
good,_=self.invoke('规格甲与规格乙的综合合格率均不低于95%。',native=native)
|
||||
self.assertTrue(good['bodyEvidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
|
||||
def test_other_typed_units_never_canonicalize_a_comparison_boundary(self):
|
||||
for value,unit,boundary in [('1155.4834','kg','1155'),('0.30416066','pp','0.30')]:
|
||||
facts=[{'id':'F1','text':'正式数值'+value+unit+'。','evidenceRef':'Q00000001'}]
|
||||
for text in ('超过'+boundary+unit+'。',boundary+unit+'以上。'):
|
||||
tokens=_binding_inventory(facts)
|
||||
parsed=_bind_literal_measures({'blocks':[{'text':text,'factIds':['F1']}]},tokens,{})
|
||||
self.assertEqual(parsed['blocks'][0]['text'],text)
|
||||
with self.assertRaises(NativeCompositionError):_validate_blocks(parsed,facts,tokens)
|
||||
self.assertTrue(_native_strict_bound(text,text.index(boundary)))
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,30 @@
|
||||
import unittest
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
|
||||
from nao_protocol_execution import query_evidence_bindings
|
||||
|
||||
|
||||
class EvidenceBindingsTests(unittest.TestCase):
|
||||
def test_random_reference_keeps_signed_current_and_comparison_queries(self):
|
||||
proofs = [{'queryId': 'now'}, {'queryId': 'before'}]
|
||||
documents = [{'evidenceRef': 'QAB12CD34', 'result': {
|
||||
'current': {'protocolEvidence': proofs[0]},
|
||||
'comparison': {'protocolEvidence': proofs[1]}}}]
|
||||
self.assertEqual(query_evidence_bindings(documents, proofs), [
|
||||
{'evidenceRef': 'QAB12CD34', 'queryIds': ['before', 'now']}])
|
||||
|
||||
def test_unsigned_or_cross_execution_queries_cannot_bind_a_chart(self):
|
||||
self.assertEqual(query_evidence_bindings([
|
||||
{'evidenceRef': 'QAB12CD34', 'result': {}}], []), [])
|
||||
with self.assertRaisesRegex(ValueError, '不属于本轮'):
|
||||
query_evidence_bindings([{'evidenceRef': 'QAB12CD34', 'result': {
|
||||
'protocolEvidence': {'queryId': 'foreign'}}}], [{'queryId': 'current'}])
|
||||
|
||||
def test_reference_cannot_change_its_query_binding(self):
|
||||
proofs = [{'queryId': 'a'}, {'queryId': 'b'}]
|
||||
documents = [{'evidenceRef': 'QAB12CD34', 'result': {'protocolEvidence': p}}
|
||||
for p in proofs]
|
||||
with self.assertRaisesRegex(ValueError, '不能绑定不同'):
|
||||
query_evidence_bindings(documents, proofs)
|
||||
@@ -0,0 +1,60 @@
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts'), str(Path(__file__).parent)]
|
||||
from nao_quality_tools import QualityTools, _valid_composite_rate_reference, symmetric_stage_decomposition
|
||||
from nao_evidence_report import _display_rate
|
||||
from nao_weight_ranking import rank_response, ranking_report
|
||||
from analysis_visuals import build_visuals
|
||||
from test_agent_visuals import evidence, context_for
|
||||
|
||||
|
||||
def formal_row():
|
||||
return {'key': 'synthetic', 'label': '修正分母规格', 'compositeRate': 1.08,
|
||||
'black': {'totalWeight': 100, 'qualifiedWeight': 120, 'scrapWeight': 2, 'rate': 1.2},
|
||||
'bright': {'totalWeight': 100, 'qualifiedWeight': 90, 'scrapWeight': 10, 'rate': .9},
|
||||
'coverage': {'blackRows': 1, 'brightRows': 1}}
|
||||
|
||||
|
||||
class FormalRateReferenceTests(unittest.TestCase):
|
||||
def test_official_adjusted_denominator_rate_remains_citable_above_one(self):
|
||||
row = formal_row()
|
||||
period = {'year': 2026, 'month': 9}
|
||||
snapshot = {**row, 'period': period, 'coverage': {'sourceMonths': [
|
||||
{**period, 'blackRows': 1, 'brightRows': 1}]}}
|
||||
self.assertTrue(_valid_composite_rate_reference(snapshot, period)[0])
|
||||
self.assertEqual(float(QualityTools._row_rate(row, None)), 1.08)
|
||||
self.assertEqual(_display_rate(snapshot, 'black'), 1.2)
|
||||
|
||||
def test_combined_ranking_retains_published_rate_and_formats_108_percent(self):
|
||||
row = formal_row()
|
||||
raw = {'rows': [row], 'summary': row, 'coverage': {'sourceMonths': [
|
||||
{'year': 2026, 'month': 9, 'blackRows': 1, 'brightRows': 1}]}}
|
||||
result = rank_response(raw, {'id': 'release'}, {'year': 2026, 'month': 9},
|
||||
{}, 'product', None, 'scrapWeight', 5)
|
||||
task = {'period': result['period'], 'filters': {}, 'dimensions': ['product'],
|
||||
'stages': [], 'dimensionStages': {'product': []}, 'fields': ['rate', 'scrapWeight']}
|
||||
self.assertEqual(result['rows'][0]['compositeRate'], 1.08)
|
||||
report = ranking_report([{'result': result, 'evidenceRef': 'Q11111111'}], task, {'releaseId': 'release'})
|
||||
self.assertIn('108.00%', report['facts'][0]['text'])
|
||||
|
||||
def test_comparison_chart_preserves_the_same_official_values(self):
|
||||
doc = evidence()
|
||||
doc['result']['current'].update(formal_row())
|
||||
doc['result']['comparison'].update({'compositeRate': .9,
|
||||
'black': {'rate': 1.0, 'totalWeight': 100, 'qualifiedWeight': 100},
|
||||
'bright': {'rate': .9, 'totalWeight': 100, 'qualifiedWeight': 90}})
|
||||
doc['result']['delta'] = {'available': True, 'percentagePoints': 18}
|
||||
doc['result']['stageRateChangesPP'] = {'black': 20, 'bright': 0}
|
||||
question = '核对正式综合合格率变化'
|
||||
result = build_visuals([doc], question, 'turn', context=context_for(question, fields=['rate']))
|
||||
chart = next(v for v in result['visuals'] if v['metric'] == 'composite_rate')
|
||||
self.assertEqual(chart['series'][0]['values'], [.9, 1.08])
|
||||
|
||||
def test_decomposition_still_reconciles_with_the_official_delta(self):
|
||||
result = symmetric_stage_decomposition(1.2, .9, 1.0, .9, .18,
|
||||
black_current_total_weight=100, bright_current_total_weight=100,
|
||||
black_comparison_total_weight=100, bright_comparison_total_weight=100)
|
||||
self.assertEqual(result['status'], 'available')
|
||||
self.assertAlmostEqual(float(result['blackPP']), 18)
|
||||
@@ -0,0 +1,54 @@
|
||||
"""Hidden metricCode types a generic value cell without becoming a display column."""
|
||||
import copy,sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_history_report import _validate_section,_history_section_markdown,HistorySnapshotError
|
||||
|
||||
class HistoryMetricRowMetadataTests(unittest.TestCase):
|
||||
def section(self):
|
||||
return {'title':'正式指标汇总','sourceTurnId':'confirmed-source','period':{'year':2026,'month':9},'filters':{},
|
||||
'columns':[{'key':'stage','label':'阶段'},{'key':'field','label':'指标'},{'key':'value','label':'正式值'}],
|
||||
'rows':[{'stage':'综合','field':'合格率','metricCode':'rate','value':0.9512973521079284},
|
||||
{'stage':'黑片','field':'报废率','metricCode':'scrapRate','value':0.027276306425167},
|
||||
{'stage':'黑片','field':'投入重量','metricCode':'totalWeight','value':1407111.7961},
|
||||
{'stage':'黑片','field':'报废重量','metricCode':'scrapWeight','value':38375.28067}]}
|
||||
def test_known_metadata_is_preserved_and_types_only_value_cell(self):
|
||||
section=self.section();before=copy.deepcopy(section)
|
||||
_validate_section(section,{'confirmed-source'})
|
||||
text=_history_section_markdown({'visuals':[{'unit':'kg','period':section['period'],'scope':{},
|
||||
'originTurnId':'confirmed-source','metric':'scrap_delta'}]},section)
|
||||
self.assertEqual(section,before);self.assertNotIn('metricCode',text)
|
||||
self.assertIn('95.13%',text);self.assertIn('2.73%',text)
|
||||
self.assertIn('1,407,111.7961 kg',text);self.assertIn('38,375.28067 kg',text)
|
||||
self.assertNotIn('0.951297',text)
|
||||
def test_unknown_metadata_and_wrong_types_remain_rejected(self):
|
||||
for key,value in [('metricCode','not_a_metric'),('metricCode',None),('metricCode',1),('metricCode',True),
|
||||
('metricCode',['rate']),('extraUnknown',1),('value',True),('value',{}),('value','0.95')]:
|
||||
with self.subTest(key=key,value=value):
|
||||
section=self.section();section['rows'][0][key]=value
|
||||
with self.assertRaises(HistorySnapshotError):_validate_section(section,{'confirmed-source'})
|
||||
def test_missing_observation_is_not_zero_and_metadata_is_never_a_public_column(self):
|
||||
section=self.section();section['rows'][0]['value']=None
|
||||
section['columns'].append({'key':'metricCode','label':'内部类型'})
|
||||
_validate_section(section,{'confirmed-source'})
|
||||
text=_history_section_markdown({'visuals':[]},section)
|
||||
self.assertIn('| 综合 | 合格率 | — |',text);self.assertNotIn('内部类型',text);self.assertNotIn('metricCode',text)
|
||||
|
||||
def test_weight_units_ignore_ratio_chart_and_unknown_period_stays_original_unit(self):
|
||||
section=self.section();rate={'originTurnId':'confirmed-source','period':section['period'],'scope':{},'metric':'composite_rate','unit':'ratio'}
|
||||
mass={**rate,'metric':'scrap_delta','unit':'kg'}
|
||||
text=_history_section_markdown({'visuals':[rate,mass]},section)
|
||||
self.assertIn('38,375.28067 kg',text);self.assertNotIn(' ratio',text);self.assertIn('95.13%',text)
|
||||
earlier=copy.deepcopy(section);earlier['period']={'year':2026,'month':8}
|
||||
text=_history_section_markdown({'visuals':[rate,mass]},earlier)
|
||||
self.assertIn('38,375.28067(原单位)',text);self.assertNotIn(' kg',text)
|
||||
|
||||
def test_chart_unit_cannot_cross_source_scope_or_explicit_stage(self):
|
||||
section=self.section();section['rows']=section['rows'][2:]
|
||||
chart={'originTurnId':'confirmed-source','period':section['period'],'scope':{},'metric':'scrap_delta','unit':'kg'}
|
||||
for change in ({'originTurnId':'other-source'},{'scope':{'department':'其他范围'}},{'stage':'bright'}):
|
||||
with self.subTest(change=change):
|
||||
text=_history_section_markdown({'visuals':[{**chart,**change}]},section)
|
||||
self.assertIn('38,375.28067(原单位)',text);self.assertNotIn(' kg',text)
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,68 @@
|
||||
"""History-only aliases must be attested by their own signed source task."""
|
||||
import copy,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
import nao_native_answer as n
|
||||
from nao_history_report import _history_title_source_goals,_history_title_is_scope_safe
|
||||
|
||||
class HistoryTitleSourceAliasTests(unittest.TestCase):
|
||||
def fixture(self,component='3C'):
|
||||
filters={'department':'消费电子产业部','group':'消费电子-'+component}
|
||||
task={'question':'9月'+component+'不良Top5','goal':'2026年9月消费电子-'+component+'产品规格不良排名',
|
||||
'period':{'year':2026,'month':9},'filters':filters}
|
||||
sections=[{'sourceTurnId':'sep','period':task['period'],'filters':filters},
|
||||
{'sourceTurnId':'aug','period':{'year':2026,'month':8},'filters':{}}]
|
||||
snapshot={'sections':sections,'historySources':[{'turnId':'sep','available':True,'status':'COMPLETED','taskContext':task},
|
||||
{'turnId':'aug','available':True,'status':'COMPLETED','taskContext':{'question':'8月全公司Top3','period':sections[1]['period'],'filters':{}}}]}
|
||||
return snapshot
|
||||
def check(self,snapshot,title):
|
||||
report={'facts':[{'id':'F'+str(i),'kind':'product','label':'规格','text':'历史事实',
|
||||
'scope':s,'validity':{'verified':True,'basis':'protocol_history_snapshot'}} for i,s in enumerate(snapshot['sections'],1)]}
|
||||
context={'_historyTitleExcludedScopeLiterals':['消费电子产业部',snapshot['sections'][0]['filters'].get('group','')],
|
||||
'_historySourceGoals':_history_title_source_goals(snapshot)}
|
||||
return n._verified_content_title(title,report,'生成报告',n._content_title_guide(report,context))
|
||||
def test_source_task_component_alias_is_period_bound_not_a_specific_word(self):
|
||||
for component in ('3C','AB'):
|
||||
snapshot=self.fixture(component);title='9月'+component+'与8月全公司规格报废Top榜单'
|
||||
self.assertEqual(self.check(snapshot,title),title)
|
||||
self.assertEqual(_history_title_is_scope_safe(title,snapshot,'生成报告'),title)
|
||||
def test_unattested_component_wrong_period_and_partial_report_are_rejected(self):
|
||||
for question in ('9月消费电子-AB不良Top5','9月消费电子AB不良Top5'):
|
||||
snapshot=self.fixture('AB');snapshot['historySources'][0]['taskContext']['question']=question
|
||||
self.assertIsNone(self.check(snapshot,'9月AB与8月全公司报废榜单'))
|
||||
self.assertIsNone(_history_title_is_scope_safe('9月AB与8月全公司报废榜单',snapshot,'生成报告'))
|
||||
snapshot=self.fixture()
|
||||
for title in ('8月3C与9月全公司报废榜单','9月3C报废榜单','8—9月3C报废榜单'):
|
||||
self.assertIsNone(self.check(snapshot,title))
|
||||
def test_same_period_ambiguous_alias_cannot_choose_an_owner(self):
|
||||
snapshot=self.fixture('AB');other=copy.deepcopy(snapshot['sections'][0]);other.update(sourceTurnId='other',filters={'group':'汽车交通-AB','department':'汽车交通产业部'})
|
||||
snapshot['sections'].append(other);snapshot['historySources'].append({'turnId':'other','available':True,'status':'COMPLETED',
|
||||
'taskContext':{'question':'9月AB不良','period':other['period'],'filters':other['filters']}})
|
||||
self.assertIsNone(self.check(snapshot,'9月AB与8月全公司报废榜单'))
|
||||
def test_no_customer_spec_or_raw_source_results_alias_authority(self):
|
||||
for field in ('product','extraFilters'):
|
||||
snapshot=self.fixture();filters={'product':'规格-3C'} if field=='product' else {'extraFilters':{'客户':['客户-3C']}}
|
||||
snapshot['sections'][0]['filters']=filters;snapshot['historySources'][0]['taskContext']['filters']=filters
|
||||
self.assertIsNone(self.check(snapshot,'9月3C与8月全公司报废榜单'))
|
||||
snapshot=self.fixture();task=snapshot['historySources'][0].pop('taskContext');snapshot['sourceResults']=[{'sourceTurnId':'sep','task':task}]
|
||||
self.assertEqual(len(_history_title_source_goals(snapshot)),1)
|
||||
self.assertIsNone(self.check(snapshot,'9月3C与8月全公司报废榜单'))
|
||||
def test_wrong_source_filters_and_period_cannot_register_the_component(self):
|
||||
for key,value in (('period',{'year':2026,'month':8}),('filters',{'group':'别的-3C'})):
|
||||
snapshot=self.fixture();snapshot['historySources'][0]['taskContext'][key]=value
|
||||
self.assertIsNone(self.check(snapshot,'9月3C与8月全公司报废榜单'))
|
||||
def test_actual_history_adapter_forwards_visible_source_question_to_title_registry(self):
|
||||
from verification.test_nao_history_report import ranking_history_snapshot,report_task,authority,RELEASE,TURN
|
||||
snapshot=ranking_history_snapshot();section=snapshot['sections'][0]
|
||||
snapshot['historySources'][0]['taskContext']={'question':'9月3C不良Top5','period':section['period'],'filters':section['filters']}
|
||||
seen=[]
|
||||
def inspect(**kwargs):
|
||||
guide=n._content_title_guide(kwargs['report'],kwargs['context']);seen.append(guide)
|
||||
return {'titleValid':False}
|
||||
with patch.object(n,'_synthesize_verified_report',side_effect=inspect):
|
||||
n.synthesize_history_snapshot(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='生成报告',
|
||||
snapshot=snapshot,task=report_task(),authority=authority(),release_id=RELEASE,request_turn_id=TURN,cancel_event=threading.Event())
|
||||
self.assertEqual(seen[0]['scopeContexts'][0]['aliases']['3C'],'消费电子-3C')
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Formal role labels become business text only after all evidence guards."""
|
||||
import copy,io,json,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import nao_native_answer as n
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_agent_answer import evidence
|
||||
|
||||
class MetricRolePresentationTests(unittest.TestCase):
|
||||
def test_role_translation_preserves_identifiers_placeholders_and_numbers(self):
|
||||
product='ContributionPp-正式型号'
|
||||
facts=[{'id':'F1','kind':'product','label':product,'text':product+'正式质量事实。'}]
|
||||
blocks=[{'text':'阶段拆解(正式 ContributionPp,区别于阶段自身率变化)。'+product+':{{I1}} {{N1}} -0.2977pp。','factIds':['F1']}]
|
||||
original=copy.deepcopy(blocks);shown=n._present_metric_roles(blocks,facts)
|
||||
self.assertIn('对综合合格率变化的贡献',shown[0]['text']);self.assertIn(product,shown[0]['text'])
|
||||
self.assertIn('{{I1}} {{N1}} -0.2977pp',shown[0]['text']);self.assertEqual(blocks,original)
|
||||
self.assertEqual(n._present_metric_roles([{'text':'NotContributionPpAlias'}],[])[0]['text'],'NotContributionPpAlias')
|
||||
def test_native_answer_and_reading_summary_share_post_review_business_labels(self):
|
||||
seen=[]
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);seen.append(payload)
|
||||
result={'reviews':[{'sourceId':b['sourceId'],'role':'core' if i==0 else 'key_evidence',
|
||||
'factIds':['F1'],'supported':True,'statisticalClaimsSupported':True} for i,b in enumerate(payload['draftBlocks'])],
|
||||
'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(result,ensure_ascii=False)}}]}).encode())
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='解释质量',
|
||||
evidence=evidence(),context={'_agentTask':{'executionMode':'native_agent'}},cancel_event=threading.Event(),
|
||||
native_answer='综合合格率95.00%。\n\n阶段拆解(正式 ContributionPp,区别于阶段自身率变化)。',opener=provider)
|
||||
self.assertTrue(final['bodyEvidenceSufficient']);self.assertIn('ContributionPp',seen[0]['draftBlocks'][1]['text'])
|
||||
self.assertNotIn('ContributionPp',final['answer']);self.assertNotIn('ContributionPp',json.dumps(final['readingSummary']))
|
||||
self.assertIn('95.00%',final['answer']);self.assertEqual(len(seen),1)
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -213,7 +213,8 @@ class MinimalQueryTests(unittest.TestCase):
|
||||
self.assertEqual(len(api.reads),1)
|
||||
self.assertEqual(len(result['protocolEvidence']),1)
|
||||
self.assertNotIn('没有取得', result['answer'])
|
||||
self.assertIn('## 统计数据附录',result['answer'])
|
||||
self.assertNotIn('统计数据附录',result['answer'])
|
||||
self.assertEqual(result['answer'].count('| 1 | 组甲 | 96.00% | 97.00% |'), 1)
|
||||
self.assertIn('| 序号 | 对象 |',result['answer'])
|
||||
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import copy
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
@@ -220,6 +221,77 @@ class AgentTaskTest(unittest.TestCase):
|
||||
self.assertEqual(planned['fields'],['totalWeight','scrapRate'])
|
||||
self.assertTrue(planned['trendRequired'])
|
||||
|
||||
def test_stage_weight_top_with_same_stage_rate_uses_ranking_top_child(self):
|
||||
from unittest.mock import patch
|
||||
cases = [
|
||||
('black','scrapWeight','黑片','报废重量',3),
|
||||
('bright','totalWeight','亮片','投入重量',2),
|
||||
]
|
||||
for stage, metric, stage_label, metric_label, count in cases:
|
||||
with self.subTest(stage=stage,metric=metric,count=count):
|
||||
question = (f'按{stage_label}{metric_label}排名前{count}个规格,'
|
||||
f'并显示同批规格的{stage_label}合格率')
|
||||
plan = [
|
||||
{'nodeId':'rank','purpose':'ranking','dimension':'product','limit':count,
|
||||
'fields':[metric],'stages':[stage],'selector':{'kind':'base'},
|
||||
'visualType':'bar','visualPreference':'auto','comparisonRequired':False},
|
||||
{'nodeId':'top_rate','purpose':'metrics','fields':['rate'],'stages':[stage],
|
||||
'selector':{'kind':'ranking_top','sourceNodeId':'rank','stage':stage,
|
||||
'metric':metric,'count':count},
|
||||
'visualType':None,'visualPreference':'none','comparisonRequired':False},
|
||||
]
|
||||
invalid_plan = copy.deepcopy(plan)
|
||||
invalid_plan[1]['selector'].pop('count')
|
||||
invalid = task_value(goal=question,kind='analysis',queryPlan=invalid_plan,
|
||||
dimensions=['product'],fields=[metric,'rate'],stages=[stage],
|
||||
dimensionStages={'product':[stage]},trendRequired=False,comparisonRequired=False,
|
||||
period={'year':2026,'month':9},visualPreference='auto')
|
||||
valid = {**invalid,'queryPlan':plan}
|
||||
review = {**semantic_ok(),'requiresTrend':False,'requiresComparison':False}
|
||||
with patch('nao_agent_task._model_json',side_effect=[invalid,valid,review]) as call:
|
||||
planned = plan_task(base_url='https://offline.invalid/v1',api_key='synthetic',model='m',
|
||||
question=question,context={'_protocol':{'version':1}},
|
||||
cancel_event=threading.Event())
|
||||
|
||||
self.assertEqual(planned['goal'],question)
|
||||
self.assertEqual(planned['rootGoal'],question)
|
||||
self.assertEqual(planned['kind'],'analysis')
|
||||
self.assertEqual(planned['dimensions'],['product'])
|
||||
self.assertEqual(set(planned['fields']),{metric,'rate'})
|
||||
self.assertEqual(planned['stages'],[stage])
|
||||
self.assertEqual(planned['dimensionStages'],{'product':[stage]})
|
||||
self.assertFalse(planned['trendRequired'])
|
||||
self.assertFalse(planned['comparisonRequired'])
|
||||
self.assertEqual(len(planned['queryPlan']),2)
|
||||
rank, rate = planned['queryPlan']
|
||||
self.assertEqual((rank['purpose'],rank['fields'],rank['stages'],rank['limit']),
|
||||
('ranking',[metric],[stage],count))
|
||||
self.assertEqual(rank['selector'],{'kind':'base'})
|
||||
self.assertEqual(rank['visualPreference'],'auto')
|
||||
self.assertEqual(rate['purpose'],'metrics')
|
||||
self.assertEqual(rate['fields'],['rate'])
|
||||
self.assertEqual(rate['stages'],[stage])
|
||||
self.assertEqual(rate['selector'],{'kind':'ranking_top','sourceNodeId':'rank',
|
||||
'stage':stage,'metric':metric,'count':count})
|
||||
self.assertIsNone(rate['visualType'])
|
||||
self.assertEqual(rate['visualPreference'],'none')
|
||||
self.assertNotIn('defect',planned['dimensions'])
|
||||
|
||||
system = call.call_args_list[0].kwargs['system']
|
||||
self.assertIn('这批对象同阶段rate',system)
|
||||
self.assertIn('rate节点只查rate',system)
|
||||
review_system = call.call_args_list[2].kwargs['system']
|
||||
self.assertIn('source/stage/metric/count与重量ranking一致',review_system)
|
||||
retry = call.call_args_list[1].kwargs['payload']
|
||||
self.assertIn('ranking_top for the same objects',
|
||||
retry['requiredShapes']['queryPlanRankingTopStageRate'])
|
||||
self.assertIn('保持ranking重量选择与ranking_top rate子查询',
|
||||
retry['repairInstructions'])
|
||||
|
||||
from nao_native_planning import NATIVE_ROOT_PROMPT, STATIC_NODE_CONTRACT
|
||||
self.assertIn('按一个阶段的totalWeight或scrapWeight选产品Top N',NATIVE_ROOT_PROMPT)
|
||||
self.assertIn('selector={\"kind\":\"ranking_top\"',STATIC_NODE_CONTRACT)
|
||||
|
||||
def test_query_plan_prompt_explains_selector_objects_and_root_stage_union(self):
|
||||
from unittest.mock import patch
|
||||
nodes = [
|
||||
@@ -550,6 +622,63 @@ class AgentTaskTest(unittest.TestCase):
|
||||
self.assertEqual(task['historyMode'],'first')
|
||||
self.assertEqual(task['planRecovery']['modelAttempts'],2)
|
||||
|
||||
def test_history_report_allows_null_period_fields_after_previous_report_retry(self):
|
||||
from unittest.mock import patch
|
||||
# A previous report can itself be PARTIAL and have no receipt. Its
|
||||
# summary task remains useful conversation context, but it must not
|
||||
# turn an explicit null date in the next report proposal into a fresh
|
||||
# scope change or become the source set for the report.
|
||||
previous = task_value(goal='整合会话已确认结果', kind='report', historyMode='all',
|
||||
freshQuery=False, dimensions=[], dimensionStages={}, fields=[], stages=[],
|
||||
comparisonRequired=False, trendRequired=False, filterUpdates={},
|
||||
period=None, comparisonPeriod=None, visualPreference='none',
|
||||
periodCoverage='complete')
|
||||
previous['question'] = '基于本会话已完成的结果生成综合报告,按各轮实际期间和范围组织。'
|
||||
previous.update(historySelectionHash='a' * 64,
|
||||
historySourceTurnIds=['completed-1', 'completed-2', 'completed-3'])
|
||||
context = {
|
||||
'year': 2026, 'month': 9, 'view': 'overall', 'filters': {},
|
||||
'_agentTask': previous,
|
||||
'_serverHistory': [
|
||||
{'turnId': 'completed-1', 'status': 'COMPLETED'},
|
||||
{'turnId': 'completed-2', 'status': 'COMPLETED'},
|
||||
{'turnId': 'completed-3', 'status': 'COMPLETED'},
|
||||
{'turnId': 'partial-report-no-receipt', 'status': 'PARTIAL'},
|
||||
],
|
||||
'_serverQuestions': [
|
||||
{'turnId': 'completed-1', 'question': '9月3C规格Top5', 'status': 'COMPLETED'},
|
||||
{'turnId': 'completed-2', 'question': '9月Top产品', 'status': 'COMPLETED'},
|
||||
{'turnId': 'completed-3', 'question': '清除筛选后查看8月全公司Top3', 'status': 'COMPLETED'},
|
||||
{'turnId': 'partial-report-no-receipt', 'question': '整合会话结果', 'status': 'PARTIAL'},
|
||||
],
|
||||
'_protocol': {'version': 1, 'autonomousEnabled': True, 'previousTask': previous},
|
||||
}
|
||||
proposal = task_value(goal='基于已完成的会话结果生成报告', kind='report',
|
||||
historyMode='all', freshQuery=False, dimensions=[], dimensionStages={}, fields=[],
|
||||
stages=[], comparisonRequired=False, trendRequired=False, filterUpdates={},
|
||||
period=None, comparisonPeriod=None)
|
||||
with patch('nao_agent_task._model_json', return_value=proposal):
|
||||
task = plan_task(base_url='https://offline.invalid/v1', api_key='synthetic', model='m',
|
||||
question='基于本会话已完成的结果生成报告,不查询新数据。', context=context,
|
||||
previous=previous, cancel_event=threading.Event())
|
||||
self.assertEqual(task['kind'], 'report')
|
||||
self.assertEqual(task['historyMode'], 'all')
|
||||
self.assertFalse(task['freshQuery'])
|
||||
self.assertIsNone(task['period'])
|
||||
self.assertIsNone(task['comparisonPeriod'])
|
||||
self.assertEqual(task['filters'], {})
|
||||
self.assertNotIn('historySourceTurnIds', task)
|
||||
self.assertNotIn('historySelectionHash', task)
|
||||
for scope_change in (
|
||||
{'period': {'year': 2026, 'month': 9}},
|
||||
{'comparisonPeriod': {'year': 2026, 'month': 8}},
|
||||
{'filterUpdates': {'group': '消费电子-3C'}},
|
||||
):
|
||||
with self.subTest(scope_change=scope_change), self.assertRaises(TaskUnavailable) as error:
|
||||
normalize_task({**proposal, **scope_change},
|
||||
'基于本会话已完成的结果生成报告,不查询新数据。', context)
|
||||
self.assertEqual(error.exception.field, 'freshQuery')
|
||||
|
||||
def test_selection_completes_pending_empty_metric_intent_without_erasing_scope(self):
|
||||
from unittest.mock import patch
|
||||
original='2026年9月18X15X4合格率是多少,不含18X15X4.1'
|
||||
|
||||
@@ -0,0 +1,416 @@
|
||||
import json
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / 'scripts'))
|
||||
|
||||
from nao_quality_tools import QualityToolError, QualityTools
|
||||
from nao_protocol_execution import _scoped_arguments
|
||||
|
||||
|
||||
RELEASE = 'release-test'
|
||||
PERIOD = {'year': 2026, 'month': 9}
|
||||
ZERO_SCRAP_PRODUCT = '(0.795+0.937)X1.498X7'
|
||||
SINGLE_BLACK_PRODUCT = '07394-L0.323XR28.96XR28.96X5.398X8.11+R+Z'
|
||||
_NOT_SET = object()
|
||||
|
||||
|
||||
def _product_snapshot(product, source_stage, *, unknown_absent_coverage=False):
|
||||
if source_stage == 'bright':
|
||||
row = {
|
||||
'key': product, 'product': product, 'label': product,
|
||||
'compositeRate': 1.0,
|
||||
'black': {'rate': 1.0},
|
||||
'bright': {'qualifiedWeight': 3.17, 'scrapWeight': 0.0,
|
||||
'totalWeight': 3.17, 'rate': 1.0},
|
||||
'coverage': {'blackRows': 0, 'brightRows': 3},
|
||||
}
|
||||
else:
|
||||
row = {
|
||||
'key': product, 'product': product, 'label': product,
|
||||
'compositeRate': 0.8646003262642741,
|
||||
'black': {'qualifiedWeight': 5.3, 'scrapWeight': 0.83,
|
||||
'totalWeight': 6.13, 'rate': 0.8646003262642741},
|
||||
'bright': {'rate': 1.0},
|
||||
'coverage': {'blackRows': 2, 'brightRows': 0},
|
||||
}
|
||||
counts = dict(row['coverage'])
|
||||
if unknown_absent_coverage:
|
||||
counts.pop(('blackRows' if source_stage == 'bright' else 'brightRows'))
|
||||
row['coverage'] = {'blackRows': 2, 'brightRows': 0} if source_stage == 'black' else {
|
||||
'blackRows': 0, 'brightRows': 3}
|
||||
row['coverage'].pop('blackRows' if source_stage == 'bright' else 'brightRows')
|
||||
absent = 'black' if source_stage == 'bright' else 'bright'
|
||||
source_month = {'year': PERIOD['year'], 'month': PERIOD['month'], **counts}
|
||||
if unknown_absent_coverage:
|
||||
source_month.pop(absent + 'Rows', None)
|
||||
summary = {**row, 'coverage': dict(row['coverage'])}
|
||||
coverage = {
|
||||
'rawRows': sum(v for k, v in counts.items() if k.endswith('Rows')),
|
||||
'includedRows': sum(v for k, v in counts.items() if k.endswith('Rows')),
|
||||
'excludedBlankRows': 0, 'unmappedRows': 0,
|
||||
'projectGroupUnconfiguredRows': 0,
|
||||
'missingStages': [{'year': PERIOD['year'], 'month': PERIOD['month'], 'stage': absent}],
|
||||
'sourceMonths': [source_month],
|
||||
}
|
||||
return {
|
||||
'release': {'id': RELEASE, 'name': '验证版本', 'status': 'PUBLISHED'},
|
||||
'context': {'year': PERIOD['year'], 'month': PERIOD['month'], 'quarter': None,
|
||||
'monthStart': None, 'monthEnd': None, 'view': 'product',
|
||||
'department': None, 'group': None, 'product': product,
|
||||
'projectGroup': None, 'includeUnassigned': False,
|
||||
'extraFilters': {}, 'exclusions': {}},
|
||||
'summary': summary, 'rows': [row], 'coverage': coverage,
|
||||
}
|
||||
|
||||
|
||||
class ProductMetricsApi:
|
||||
def __init__(self, product, source_stage, *, unknown_absent_coverage=False,
|
||||
absent_scrap_weight=_NOT_SET):
|
||||
self.current_release_id = RELEASE
|
||||
self.product = product
|
||||
self.snapshot = _product_snapshot(product, source_stage,
|
||||
unknown_absent_coverage=unknown_absent_coverage)
|
||||
if absent_scrap_weight is not _NOT_SET:
|
||||
absent_stage = 'black' if source_stage == 'bright' else 'bright'
|
||||
for block in (self.snapshot['summary'][absent_stage], self.snapshot['rows'][0][absent_stage]):
|
||||
block.update({
|
||||
'qualifiedWeight': None,
|
||||
'scrapWeight': absent_scrap_weight,
|
||||
'totalWeight': None,
|
||||
'headquartersScrapWeight': None,
|
||||
'scrapRate': None,
|
||||
'rateWithoutHeadquartersScrap': 1.0,
|
||||
'defects': [],
|
||||
})
|
||||
self.metric_requests = []
|
||||
|
||||
def login(self):
|
||||
return self
|
||||
|
||||
def call(self, path, payload=None, method=None):
|
||||
parsed = urlsplit(path)
|
||||
if parsed.path == '/api/releases':
|
||||
return {'currentReleaseId': RELEASE,
|
||||
'items': [{'id': RELEASE, 'name': '验证版本', 'status': 'PUBLISHED'}]}
|
||||
if parsed.path == '/api/analysis/tools/catalog':
|
||||
return {'kind': 'analysis_catalog', 'visibleWeightFields': [],
|
||||
'visibleDefectFields': [], 'dimensions': [{'key': 'product'}],
|
||||
'topDimensions': ['product'], 'grouping': ['product'],
|
||||
'scope': '当前授权范围', 'limitations': []}
|
||||
if parsed.path == '/api/metrics':
|
||||
self.metric_requests.append(parse_qs(parsed.query))
|
||||
return self.snapshot
|
||||
raise AssertionError(f'unexpected API path: {parsed.path}')
|
||||
|
||||
|
||||
def _rank_arguments(product, *, kind, limit):
|
||||
task = {
|
||||
'kind': kind, 'fields': ['rate', 'scrapWeight'], 'period': PERIOD,
|
||||
'filters': {'product': product}, 'dimensions': ['product'],
|
||||
'dimensionStages': {'product': []}, 'stages': [],
|
||||
'queryPlan': [{'nodeId': 'rank', 'purpose': 'ranking',
|
||||
'dimension': 'product', 'fields': ['rate', 'scrapWeight'],
|
||||
'stages': [], 'limit': limit, 'selector': {'kind': 'base'}}],
|
||||
}
|
||||
node = task['queryPlan'][0]
|
||||
return _scoped_arguments({'releaseId': RELEASE}, {'task': task, 'limit': limit}, node)[0]
|
||||
|
||||
|
||||
class CombinedMissingStageTests(unittest.TestCase):
|
||||
def _query(self, product, source_stage, *, kind='analysis', limit=5, unknown_absent_coverage=False,
|
||||
absent_scrap_weight=_NOT_SET):
|
||||
api = ProductMetricsApi(product, source_stage,
|
||||
unknown_absent_coverage=unknown_absent_coverage,
|
||||
absent_scrap_weight=absent_scrap_weight)
|
||||
with tempfile.TemporaryDirectory() as evidence_dir:
|
||||
tools = QualityTools(api_factory=lambda: api, evidence_dir=evidence_dir)
|
||||
result = tools.quality_data(_rank_arguments(product, kind=kind, limit=limit))
|
||||
self.assertEqual(api.metric_requests[0].get('product'), [product])
|
||||
self.assertEqual(api.metric_requests[0].get('view'), ['product'])
|
||||
return result
|
||||
|
||||
def test_real_product_scoped_combined_rank_accepts_one_stage_without_inventing_its_weight(self):
|
||||
cases = [
|
||||
(ZERO_SCRAP_PRODUCT, 'bright', 0.0, 1.0, False, 'analysis', 5),
|
||||
(SINGLE_BLACK_PRODUCT, 'black', 0.83, 0.8646003262642741, True, 'metrics', 1),
|
||||
]
|
||||
for product, source_stage, expected_weight, expected_rate, has_positive_rank, kind, limit in cases:
|
||||
with self.subTest(product=product):
|
||||
result = self._query(product, source_stage, kind=kind, limit=limit)
|
||||
self.assertEqual(result['totalWeight'], expected_weight)
|
||||
self.assertIsNone(result['stage'])
|
||||
if has_positive_rank:
|
||||
self.assertEqual(result['rows'][0]['weight'], expected_weight)
|
||||
self.assertEqual(result['rows'][0]['compositeRate'], expected_rate)
|
||||
self.assertIsNone(result['rows'][0]['brightScrapWeight'])
|
||||
else:
|
||||
self.assertEqual(result['rows'], [])
|
||||
self.assertEqual(result['emptyReason'], 'no_positive_scrap')
|
||||
self.assertEqual(result.get('compositeRate'), expected_rate)
|
||||
from nao_combined_ranking import combined_report
|
||||
task = {'kind': kind, 'period': PERIOD, 'filters': {'product': product},
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
||||
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'periodCoverage': 'available'}
|
||||
report = combined_report([{'result': result, 'evidenceRef': result['evidenceRef']}],
|
||||
task, {'releaseId': RELEASE})
|
||||
rate_facts = [fact for fact in report['facts'] if fact.get('kind') == 'rate']
|
||||
self.assertEqual(len(rate_facts), 1)
|
||||
self.assertEqual(rate_facts[0]['value'], expected_rate)
|
||||
|
||||
@staticmethod
|
||||
def _scalar_report_task(product):
|
||||
return {'kind': 'metrics', 'period': PERIOD, 'filters': {'product': product},
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
||||
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'trendRequired': False, 'comparisonRequired': False,
|
||||
'periodCoverage': 'available'}
|
||||
|
||||
def test_single_object_metrics_project_values_without_rank_or_scope_share(self):
|
||||
from nao_combined_ranking import combined_report
|
||||
product = SINGLE_BLACK_PRODUCT
|
||||
result = self._query(product, 'black', kind='metrics', limit=1)
|
||||
report = combined_report([{'result': result, 'evidenceRef': result['evidenceRef']}],
|
||||
self._scalar_report_task(product), {'releaseId': RELEASE})
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('0.83 kg', visible)
|
||||
self.assertIn('86.46%', visible)
|
||||
self.assertNotIn('排名', visible)
|
||||
self.assertNotIn('Top', visible)
|
||||
self.assertNotIn('占比', visible)
|
||||
self.assertNotIn('占全部报废', visible)
|
||||
self.assertEqual(len(report['facts']), 2)
|
||||
self.assertTrue(all(fact['kind'] == 'overall' for fact in report['facts']))
|
||||
|
||||
def test_single_object_zero_metrics_keep_zero_and_formal_rate_without_no_rank_claim(self):
|
||||
from nao_combined_ranking import combined_report
|
||||
product = ZERO_SCRAP_PRODUCT
|
||||
result = self._query(product, 'bright', kind='metrics', limit=1)
|
||||
report = combined_report([{'result': result, 'evidenceRef': result['evidenceRef']}],
|
||||
self._scalar_report_task(product), {'releaseId': RELEASE})
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('0.00 kg', visible)
|
||||
self.assertIn('100.00%', visible)
|
||||
self.assertNotIn('排名', visible)
|
||||
self.assertNotIn('无需', visible)
|
||||
self.assertEqual(report['rawMetrics'][0]['emptyReason'], 'no_positive_scrap')
|
||||
self.assertEqual(len(report['facts']), 2)
|
||||
|
||||
def test_analysis_ranking_still_projects_the_population_share(self):
|
||||
from nao_combined_ranking import combined_report
|
||||
product = SINGLE_BLACK_PRODUCT
|
||||
result = self._query(product, 'black', kind='analysis', limit=5)
|
||||
task = {**self._scalar_report_task(product), 'kind': 'analysis'}
|
||||
report = combined_report([{'result': result, 'evidenceRef': result['evidenceRef']}],
|
||||
task, {'releaseId': RELEASE})
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('排名', visible)
|
||||
self.assertIn('占全部报废', visible)
|
||||
self.assertIn('100.00%', visible)
|
||||
|
||||
def _protocol_scalar_fixture(self, product, source_stage, *, root_kind='metrics', limit=1,
|
||||
preference='auto'):
|
||||
result = self._query(product, source_stage, kind='metrics', limit=1)
|
||||
root = {**self._scalar_report_task(product), 'kind': root_kind,
|
||||
'visualPreference': preference,
|
||||
'question': '查询单一规格的综合合格率和合计报废重量',
|
||||
'queryPlan': [{'nodeId': 'scalar', 'purpose': 'ranking', 'dimension': 'product',
|
||||
'limit': limit, 'fields': ['rate', 'scrapWeight'], 'stages': [],
|
||||
'selector': {'kind': 'base'}, 'comparisonRequired': False,
|
||||
'visualType': 'bar', 'visualPreference': preference}]}
|
||||
proof = {'nodeId': 'scalar', 'scopeId': 'scope-scalar', 'queryId': 'query-scalar'}
|
||||
result = {**result, 'protocolEvidence': proof}
|
||||
document = {'mode': 'rank', 'releaseId': RELEASE, 'evidenceRef': 'Q1234ABCD', 'result': result}
|
||||
child = {**self._scalar_report_task(product), 'kind': 'analysis',
|
||||
'version': 1, 'question': root['question'],
|
||||
'visualPreference': preference, 'visualType': 'bar'}
|
||||
scope = {'purpose': 'ranking', 'nodeId': 'scalar', 'scopeId': 'scope-scalar', 'task': child}
|
||||
context = {'releaseId': RELEASE, '_agentTask': root,
|
||||
'_protocolScopes': {'scopes': [scope], 'pending': [], 'gaps': []}}
|
||||
return document, scope, context
|
||||
|
||||
def _native_report_for_protocol_scalar(self, product, source_stage, *, root_kind='metrics', limit=1):
|
||||
from nao_native_answer import build_native_report
|
||||
document, scope, context = self._protocol_scalar_fixture(
|
||||
product, source_stage, root_kind=root_kind, limit=limit)
|
||||
root = context['_agentTask']
|
||||
return build_native_report([document], context, root['question'])
|
||||
|
||||
def test_confirmed_scalar_pair_auto_does_not_require_a_ranking_chart(self):
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
for product, source_stage in [(SINGLE_BLACK_PRODUCT, 'black'), (ZERO_SCRAP_PRODUCT, 'bright')]:
|
||||
with self.subTest(product=product):
|
||||
document, scope, context = self._protocol_scalar_fixture(product, source_stage)
|
||||
original = json.loads(json.dumps([document, scope, context]))
|
||||
result = protocol_visual_result([document], [scope], '查询规格指标', 'turn',
|
||||
release_id=RELEASE, base_context=context)
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
self.assertEqual(result['visualState'], 'not_requested')
|
||||
self.assertEqual(result['visuals'], [])
|
||||
self.assertEqual([document, scope, context], original)
|
||||
|
||||
def test_scalar_pair_explicit_required_still_builds_and_checks_chart(self):
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
document, scope, context = self._protocol_scalar_fixture(
|
||||
SINGLE_BLACK_PRODUCT, 'black', preference='required')
|
||||
result = protocol_visual_result([document], [scope], '用图展示规格指标', 'turn',
|
||||
release_id=RELEASE, base_context=context)
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
self.assertEqual(result['visualState'], 'ready')
|
||||
self.assertEqual(len(result['visuals']), 1)
|
||||
self.assertEqual(result['visuals'][0]['series'][0]['values'], [0.83])
|
||||
|
||||
def test_scalar_chart_omission_cannot_be_borrowed_by_ranking_or_unbound_scope(self):
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
for mismatch in ['analysis', 'multi-limit', 'no-root', 'foreign-proof', 'compare']:
|
||||
with self.subTest(mismatch=mismatch):
|
||||
document, scope, context = self._protocol_scalar_fixture(SINGLE_BLACK_PRODUCT, 'black')
|
||||
if mismatch == 'analysis': context['_agentTask']['kind'] = 'analysis'
|
||||
elif mismatch == 'multi-limit': context['_agentTask']['queryPlan'][0]['limit'] = 2
|
||||
elif mismatch == 'no-root': context.pop('_agentTask')
|
||||
elif mismatch == 'foreign-proof': document['result']['protocolEvidence']['scopeId'] = 'foreign'
|
||||
else: context['_agentTask']['comparisonRequired'] = True
|
||||
result = protocol_visual_result([document], [scope], '查看规格', 'turn',
|
||||
release_id=RELEASE, base_context=context)
|
||||
self.assertTrue(result['missingEvidence'], result)
|
||||
|
||||
def test_scalar_gate_decodes_the_actual_multi_selection_wire_contract(self):
|
||||
import base64
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
from nao_weight_ranking import protocol_scalar_metrics_scope
|
||||
def encoded(values):
|
||||
return '~qv1~' + base64.urlsafe_b64encode(json.dumps(values).encode()).decode().rstrip('=')
|
||||
for wire, allowed in [(encoded([SINGLE_BLACK_PRODUCT]), True),
|
||||
(encoded([SINGLE_BLACK_PRODUCT, ZERO_SCRAP_PRODUCT]), False),
|
||||
('~qv1~broken!', False), (encoded([]), False)]:
|
||||
with self.subTest(allowed=allowed, wire=wire):
|
||||
document, scope, context = self._protocol_scalar_fixture(SINGLE_BLACK_PRODUCT, 'black')
|
||||
for target in [context['_agentTask'], scope['task'], document['result']]:
|
||||
target['filters'] = {'product': wire}
|
||||
self.assertEqual(protocol_scalar_metrics_scope(context['_agentTask'], context, document), allowed)
|
||||
result = protocol_visual_result([document], [scope], '查看指标', 'turn',
|
||||
release_id=RELEASE, base_context=context)
|
||||
self.assertEqual(result['missingEvidence'] == [], allowed)
|
||||
|
||||
def test_root_or_node_required_cannot_borrow_child_auto_scalar_chart_omission(self):
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
for level in ['root', 'node']:
|
||||
document, scope, context = self._protocol_scalar_fixture(SINGLE_BLACK_PRODUCT, 'black')
|
||||
target = context['_agentTask'] if level == 'root' else context['_agentTask']['queryPlan'][0]
|
||||
target['visualPreference'] = 'required'
|
||||
result = protocol_visual_result([document], [scope], '用图展示指标', 'turn',
|
||||
release_id=RELEASE, base_context=context)
|
||||
self.assertTrue(result['missingEvidence'], (level, result))
|
||||
|
||||
def test_native_finite_query_uses_root_scalar_intent_in_its_report_frame(self):
|
||||
report = self._native_report_for_protocol_scalar(SINGLE_BLACK_PRODUCT, 'black')
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('0.83 kg', visible)
|
||||
self.assertIn('86.46%', visible)
|
||||
self.assertNotIn('占全部报废', visible)
|
||||
self.assertNotIn('全部来源', visible)
|
||||
self.assertNotIn('排名', visible)
|
||||
|
||||
def test_native_finite_zero_metric_does_not_claim_no_ranking_is_needed(self):
|
||||
report = self._native_report_for_protocol_scalar(ZERO_SCRAP_PRODUCT, 'bright')
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('0.00 kg', visible)
|
||||
self.assertIn('100.00%', visible)
|
||||
self.assertNotIn('无需', visible)
|
||||
self.assertNotIn('没有正报废', visible)
|
||||
self.assertNotIn('排名', visible)
|
||||
|
||||
def test_native_analysis_top_scope_keeps_ranking_projection(self):
|
||||
report = self._native_report_for_protocol_scalar(
|
||||
SINGLE_BLACK_PRODUCT, 'black', root_kind='analysis', limit=5)
|
||||
visible = '\n'.join([*report['sections'], *(fact['text'] for fact in report['facts'])])
|
||||
self.assertIn('排名', visible)
|
||||
self.assertIn('占全部报废', visible)
|
||||
|
||||
def test_native_scalar_frame_requires_the_current_exact_root_scope_and_proof(self):
|
||||
from nao_weight_ranking import protocol_scalar_metrics_scope
|
||||
product = SINGLE_BLACK_PRODUCT
|
||||
result = self._query(product, 'black', kind='metrics', limit=1)
|
||||
proof = {'nodeId': 'scalar', 'scopeId': 'scope-scalar', 'queryId': 'query-scalar'}
|
||||
document = {'mode': 'rank', 'releaseId': RELEASE, 'evidenceRef': 'Q1234ABCD',
|
||||
'result': {**result, 'protocolEvidence': proof}}
|
||||
child = {**self._scalar_report_task(product), 'kind': 'analysis'}
|
||||
scope = {'purpose': 'ranking', 'nodeId': 'scalar', 'scopeId': 'scope-scalar', 'task': child}
|
||||
root = {**self._scalar_report_task(product), 'queryPlan': [{
|
||||
'nodeId': 'scalar', 'purpose': 'ranking', 'dimension': 'product', 'limit': 1,
|
||||
'fields': ['rate', 'scrapWeight'], 'stages': [], 'selector': {'kind': 'base'},
|
||||
'comparisonRequired': False}]}
|
||||
context = {'releaseId': RELEASE, '_agentTask': root,
|
||||
'_protocolScopes': {'scopes': [scope], 'pending': [], 'gaps': []}}
|
||||
original = json.loads(json.dumps(document))
|
||||
self.assertTrue(protocol_scalar_metrics_scope(root, context, document))
|
||||
self.assertEqual(document, original)
|
||||
self.assertFalse(protocol_scalar_metrics_scope({**root, 'kind': 'analysis'}, context, document))
|
||||
foreign = {**context, '_protocolScopes': {'scopes': [{**scope, 'scopeId': 'foreign'}],
|
||||
'pending': [], 'gaps': []}}
|
||||
self.assertFalse(protocol_scalar_metrics_scope(root, foreign, document))
|
||||
no_proof = {**document, 'result': {**result, 'protocolEvidence': None}}
|
||||
self.assertFalse(protocol_scalar_metrics_scope(root, context, no_proof))
|
||||
self.assertEqual(document, original)
|
||||
|
||||
def test_actual_null_weight_blocks_are_allowed_only_with_proven_zero_stage_coverage(self):
|
||||
cases = [
|
||||
(ZERO_SCRAP_PRODUCT, 'bright', 0.0, 'analysis', 5),
|
||||
(SINGLE_BLACK_PRODUCT, 'black', 0.83, 'metrics', 1),
|
||||
]
|
||||
for product, source_stage, expected_weight, kind, limit in cases:
|
||||
with self.subTest(source_stage=source_stage):
|
||||
result = self._query(product, source_stage, kind=kind, limit=limit,
|
||||
absent_scrap_weight=None)
|
||||
self.assertEqual(result['totalWeight'], expected_weight)
|
||||
if expected_weight:
|
||||
self.assertEqual(result['rows'][0]['weight'], expected_weight)
|
||||
self.assertIsNone(result['rows'][0]['brightScrapWeight'] if source_stage == 'black'
|
||||
else result['rows'][0]['blackScrapWeight'])
|
||||
else:
|
||||
self.assertEqual(result['rows'], [])
|
||||
self.assertEqual(result['emptyReason'], 'no_positive_scrap')
|
||||
self.assertEqual(result['compositeRate'], 1.0)
|
||||
|
||||
def test_absent_stage_nonzero_invalid_or_negative_weight_still_rejects(self):
|
||||
for value in (0.5, 'not-a-number', -0.5):
|
||||
with self.subTest(value=value):
|
||||
api = ProductMetricsApi(SINGLE_BLACK_PRODUCT, 'black', absent_scrap_weight=value)
|
||||
with tempfile.TemporaryDirectory() as evidence_dir:
|
||||
tools = QualityTools(api_factory=lambda: api, evidence_dir=evidence_dir)
|
||||
with self.assertRaises(QualityToolError):
|
||||
tools.quality_data(_rank_arguments(SINGLE_BLACK_PRODUCT, kind='metrics', limit=1))
|
||||
|
||||
def test_zero_counts_for_both_stages_do_not_create_a_combined_ranking(self):
|
||||
from nao_combined_ranking import combined_response
|
||||
response = _product_snapshot(SINGLE_BLACK_PRODUCT, 'black')
|
||||
response['summary']['coverage'] = {'blackRows': 0, 'brightRows': 0}
|
||||
response['coverage']['sourceMonths'] = [
|
||||
{'year': PERIOD['year'], 'month': PERIOD['month'], 'blackRows': 0, 'brightRows': 0}]
|
||||
response['coverage']['missingStages'] = [
|
||||
{'year': PERIOD['year'], 'month': PERIOD['month'], 'stage': 'black'},
|
||||
{'year': PERIOD['year'], 'month': PERIOD['month'], 'stage': 'bright'}]
|
||||
response['rows'][0]['coverage'] = {'blackRows': 0, 'brightRows': 0}
|
||||
response['summary']['black']['scrapWeight'] = None
|
||||
response['summary']['bright']['scrapWeight'] = None
|
||||
response['rows'][0]['black']['scrapWeight'] = None
|
||||
response['rows'][0]['bright']['scrapWeight'] = None
|
||||
with self.assertRaises(QualityToolError):
|
||||
combined_response(response, {'id': RELEASE}, PERIOD, {'product': SINGLE_BLACK_PRODUCT},
|
||||
'product', 1)
|
||||
|
||||
def test_unknown_absent_stage_source_still_rejects_missing_weight(self):
|
||||
api = ProductMetricsApi(ZERO_SCRAP_PRODUCT, 'bright', unknown_absent_coverage=True)
|
||||
with tempfile.TemporaryDirectory() as evidence_dir:
|
||||
tools = QualityTools(api_factory=lambda: api, evidence_dir=evidence_dir)
|
||||
with self.assertRaises(QualityToolError):
|
||||
tools.quality_data(_rank_arguments(ZERO_SCRAP_PRODUCT, kind='analysis', limit=5))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -61,6 +61,26 @@ class HistoryReportTaskTest(unittest.TestCase):
|
||||
self.assertFalse(task['trendRequired'])
|
||||
self.assertFalse(task['verifySource'])
|
||||
self.assertFalse(task['fullDetails'])
|
||||
self.assertEqual(task['visualPreference'], 'auto')
|
||||
|
||||
def test_history_report_preserves_the_requested_saved_chart_display_preference(self):
|
||||
for preference in ('auto', 'required', 'none'):
|
||||
with self.subTest(preference=preference):
|
||||
task = normalize_task(history_plan(visualPreference=preference),
|
||||
'基于本会话已完成结果整理历史报告',
|
||||
{'_protocol': {'version': 1}})
|
||||
self.assertEqual(task['visualPreference'], preference)
|
||||
self.assertIsNone(task['visualType'])
|
||||
omitted = history_plan()
|
||||
omitted.pop('visualPreference')
|
||||
task = normalize_task(omitted, '整理已完成历史报告并保留图表',
|
||||
{'_protocol': {'version': 1}})
|
||||
self.assertEqual(task['visualPreference'], 'auto')
|
||||
|
||||
def test_explicit_text_only_history_report_keeps_none(self):
|
||||
task = normalize_task(history_plan(visualPreference='none'),
|
||||
'基于已完成历史结果整理报告,只要文字和数字,不要图表',
|
||||
{'_protocol': {'version': 1}})
|
||||
self.assertEqual(task['visualPreference'], 'none')
|
||||
|
||||
def test_new_filter_period_and_refresh_intent_cannot_be_silently_dropped(self):
|
||||
@@ -118,6 +138,7 @@ class HistoryReportTaskTest(unittest.TestCase):
|
||||
self.assertEqual(task['historyMode'], 'all')
|
||||
|
||||
def test_protocol_planner_prompt_exposes_bounded_history_report_contract(self):
|
||||
from nao_native_planning import NATIVE_ROOT_PROMPT
|
||||
replies = [history_plan(), {
|
||||
'aligned': True, 'requiresEvidence': True,
|
||||
'requiresSourceVerification': False, 'requiresAllSourceRows': False,
|
||||
@@ -138,6 +159,11 @@ class HistoryReportTaskTest(unittest.TestCase):
|
||||
self.assertIn('historyMode=last或all、freshQuery=false', calls[0]['system'])
|
||||
self.assertIn('previousVerifiedTurns为空或缺失不表示会话没有已分析来源', calls[0]['system'])
|
||||
self.assertIn('用户说不重新查询、不要重查、无需重新查时是复用历史', calls[0]['system'])
|
||||
self.assertIn('历史报告的visualPreference只控制已授权历史图表的展示', calls[0]['system'])
|
||||
self.assertIn('不查询新数据不等于隐藏历史图表', calls[0]['system'])
|
||||
self.assertIn('明确要求必须有图时用required', calls[0]['system'])
|
||||
self.assertIn('明确只要文字或数字时用none', calls[0]['system'])
|
||||
self.assertIn('不新查不等于隐藏已保存图表', NATIVE_ROOT_PROMPT)
|
||||
self.assertEqual(calls[0]['payload']['previousVerifiedTurns'], [])
|
||||
self.assertIn('不能据此判断历史数据不存在', calls[1]['system'])
|
||||
self.assertEqual(calls[1]['payload']['previousVerifiedTurns'], [])
|
||||
|
||||
@@ -12,7 +12,8 @@ from unittest.mock import MagicMock, patch
|
||||
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
import nao_quality_runtime as runtime
|
||||
from nao_protocol_execution import execute
|
||||
from nao_protocol_execution import (execute, _controlled_failure_diagnostic,
|
||||
_private_failure_diagnostic, _private_module_provenance)
|
||||
from nao_agent_task import normalize_task, bind_task
|
||||
from test_nao_agent_task import task_value
|
||||
from test_nao_quality_tools import FakeApi, RELEASE
|
||||
@@ -85,6 +86,85 @@ class BoundRankingApi(BoundApi):
|
||||
return result
|
||||
|
||||
class ProtocolExecutionTests(unittest.TestCase):
|
||||
def test_controlled_failure_diagnostics_classify_without_copying_exception_text(self):
|
||||
from nao_quality_tools import QualityToolError, SourceCoverageUnavailable
|
||||
source = _controlled_failure_diagnostic(
|
||||
SourceCoverageUnavailable({'year': 2026, 'month': 9}), node_id='rank', purpose='ranking')
|
||||
self.assertEqual(source['failureKind'], 'source_coverage')
|
||||
self.assertEqual(source['nodeId'], 'rank')
|
||||
self.assertNotIn('message', source)
|
||||
|
||||
upstream = runtime.RuntimeErrorSafe('token=secret SELECT * FROM private_table',
|
||||
retryable=True, http_status=503)
|
||||
transient = _controlled_failure_diagnostic(upstream, node_id='rank', purpose='ranking')
|
||||
self.assertEqual(transient['failureKind'], 'transient_http')
|
||||
self.assertEqual(transient['httpStatus'], 503)
|
||||
self.assertTrue(transient['retryable'])
|
||||
self.assertNotIn('secret', str(transient))
|
||||
self.assertNotIn('private_table', str(transient))
|
||||
|
||||
denied = _controlled_failure_diagnostic(
|
||||
runtime.RuntimeErrorSafe('upstream detail must not escape', retryable=False, http_status=403),
|
||||
node_id='rank', purpose='ranking')
|
||||
self.assertEqual(denied['failureKind'], 'http_error')
|
||||
self.assertEqual(denied['httpStatus'], 403)
|
||||
self.assertFalse(denied['retryable'])
|
||||
self.assertNotIn('upstream detail', str(denied))
|
||||
|
||||
rejected = _controlled_failure_diagnostic(QualityToolError('scope=private-value'),
|
||||
node_id='metrics', purpose='metrics')
|
||||
self.assertEqual(rejected['failureKind'], 'formal_query_rejected')
|
||||
self.assertNotIn('private-value', str(rejected))
|
||||
|
||||
product = '07394-L0.323XR28.96XR28.96X5.398X8.11+R+Z'
|
||||
import nao_weight_ranking
|
||||
import nao_combined_ranking
|
||||
error = QualityToolError('正式指标接口未确认 filters.product;结果已拒绝。' + product)
|
||||
try:
|
||||
raise error
|
||||
except QualityToolError as captured:
|
||||
captured._quality_private_rank_trace = {
|
||||
'queryId': 'private-query-id',
|
||||
'coverageSourceMonths': [{'year': 2026, 'month': 9, 'blackRows': 2, 'brightRows': 15}],
|
||||
'summaryCoverage': {'blackRows': 2, 'brightRows': 0},
|
||||
}
|
||||
error = captured
|
||||
public = _controlled_failure_diagnostic(error, node_id='rank', purpose='ranking')
|
||||
private = _private_failure_diagnostic(error, public, {'filters': {'product': product}}, {
|
||||
'mode': 'rank', 'dimension': 'product', 'metric': 'scrapWeight',
|
||||
'stage': None, 'limit': 1, 'filters': {'product': product},
|
||||
})
|
||||
self.assertNotIn('errorSummary', public)
|
||||
self.assertNotIn('queryInput', public)
|
||||
self.assertNotIn('rankResponseTrace', public)
|
||||
self.assertIn('正式指标接口未确认 filters.product', private['errorSummary'])
|
||||
self.assertNotIn(product, private['errorSummary'])
|
||||
self.assertEqual(private['rankResponseTrace']['queryId'], 'private-query-id')
|
||||
self.assertEqual(private['rankResponseTrace']['summaryCoverage'], {'blackRows': 2, 'brightRows': 0})
|
||||
self.assertTrue(any(frame['function'] == 'test_controlled_failure_diagnostics_classify_without_copying_exception_text'
|
||||
and frame['file'] == 'test_nao_protocol_execution.py'
|
||||
for frame in private['exceptionFrames']))
|
||||
self.assertNotIn('exceptionFrames', public)
|
||||
self.assertEqual(private['queryInput'], {
|
||||
'mode': 'rank', 'dimension': 'product', 'metric': 'scrapWeight',
|
||||
'stage': None, 'limit': 1,
|
||||
})
|
||||
provenance = private['moduleProvenance']
|
||||
self.assertNotIn('moduleProvenance', public)
|
||||
for module_name, function_name in (
|
||||
('nao_weight_ranking', 'rank_response'),
|
||||
('nao_combined_ranking', 'combined_response')):
|
||||
with self.subTest(module=module_name):
|
||||
module = provenance['modules'][module_name]
|
||||
self.assertTrue(module['loaded'])
|
||||
self.assertTrue(module['file'].endswith('/scripts/' + module_name + '.py'))
|
||||
self.assertEqual(len(module['functions'][function_name]), 64)
|
||||
|
||||
unsafe = _private_failure_diagnostic(
|
||||
QualityToolError('SELECT * FROM private_table; token=secret'), public, {})
|
||||
self.assertEqual(unsafe['errorSummary'], '受控查询校验失败;详细内容已隐藏。')
|
||||
self.assertNotIn('private_table', unsafe['errorSummary'])
|
||||
|
||||
def test_comparison_returns_both_proofs_and_the_confirmed_comparison_context(self):
|
||||
value=task_value(kind='metrics',dimensions=[],stages=['black'],fields=['rate'],trendRequired=False,
|
||||
comparisonRequired=True,period={'year':2026,'month':9},comparisonPeriod={'year':2026,'month':8},visualPreference='none')
|
||||
|
||||
@@ -8,6 +8,7 @@ import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
from unittest.mock import patch
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "scripts"))
|
||||
@@ -17,6 +18,7 @@ from nao_quality_mcp import MCPServer, serve
|
||||
from nao_quality_tools import (
|
||||
QualityToolError,
|
||||
QualityTools,
|
||||
_private_rank_response_trace,
|
||||
normalize_filters,
|
||||
symmetric_stage_decomposition,
|
||||
tool_definition,
|
||||
@@ -219,6 +221,63 @@ class QualityToolsTests(unittest.TestCase):
|
||||
def tearDown(self):
|
||||
self.temp.cleanup()
|
||||
|
||||
def test_rank_failure_attaches_only_bounded_private_snapshot_shape(self):
|
||||
class MissingScopedStageApi(FakeApi):
|
||||
def call(inner, path, payload=None, method=None):
|
||||
result = super().call(path, payload, method)
|
||||
if urlsplit(path).path != "/api/metrics":
|
||||
return result
|
||||
if parse_qs(urlsplit(path).query).get("view") != ["product"]:
|
||||
return result
|
||||
row = FakeApi._product_row("private-product-key", "PRIVATE-PRODUCT", 0.83, 0.0)
|
||||
row["coverage"] = {"blackRows": 2, "brightRows": 0}
|
||||
row["bright"].pop("scrapWeight", None)
|
||||
result["rows"] = [row]
|
||||
result["context"]["rowCount"] = 1
|
||||
result["summary"]["black"]["scrapWeight"] = 0.83
|
||||
result["summary"]["bright"].pop("scrapWeight", None)
|
||||
result["summary"]["coverage"] = {"blackRows": 2, "brightRows": 0}
|
||||
# Monthly source counts can describe the published source month,
|
||||
# while the chosen product's scoped coverage is zero for bright.
|
||||
result["coverage"]["sourceMonths"] = [
|
||||
{"year": 2026, "month": 9, "blackRows": 2, "brightRows": 15}]
|
||||
result["coverage"]["missingStages"] = [
|
||||
{"year": 2026, "month": 9, "stage": "bright"}]
|
||||
result["protocolEvidence"] = {
|
||||
"queryId": "private-query-id", "responseHash": "b" * 64}
|
||||
return result
|
||||
|
||||
api = MissingScopedStageApi()
|
||||
tools = QualityTools(api_factory=lambda: api, evidence_dir=self.temp.name)
|
||||
arguments = {"mode": "rank", "releaseId": RELEASE,
|
||||
"period": {"year": 2026, "month": 9},
|
||||
"filters": {"product": "PRIVATE-PRODUCT"},
|
||||
"dimension": "product", "metric": "scrapWeight",
|
||||
"stage": None, "limit": 1}
|
||||
with patch("nao_weight_ranking.rank_response", side_effect=QualityToolError("trace fixture")):
|
||||
with self.assertRaisesRegex(QualityToolError, "trace fixture") as raised:
|
||||
tools.quality_data(arguments)
|
||||
trace = raised.exception._quality_private_rank_trace
|
||||
self.assertEqual(trace["queryId"], "private-query-id")
|
||||
self.assertEqual(trace["coverageSourceMonths"], [
|
||||
{"year": 2026, "month": 9, "blackRows": 2, "brightRows": 15,
|
||||
"countStates": {"blackRows": "known", "brightRows": "known"}}])
|
||||
self.assertEqual(trace["coverageMissingStages"], [
|
||||
{"year": 2026, "month": 9, "stage": "bright", "stageState": "known"}])
|
||||
self.assertEqual(trace["summaryCoverage"], {"blackRows": 2, "brightRows": 0})
|
||||
self.assertEqual(trace["summaryStages"]["black"]["values"]["scrapWeight"], "0.83")
|
||||
self.assertIsNone(trace["summaryStages"]["bright"]["values"].get("scrapWeight"))
|
||||
self.assertEqual(trace["rows"]["count"], 1)
|
||||
self.assertEqual(trace["rows"]["sample"][0]["coverage"], {"blackRows": 2, "brightRows": 0})
|
||||
self.assertEqual(trace["rows"]["sample"][0]["coverageStates"], {
|
||||
"blackRows": "known", "brightRows": "known"})
|
||||
self.assertNotIn("PRIVATE-PRODUCT", json.dumps(trace))
|
||||
self.assertNotIn("private-product-key", json.dumps(trace))
|
||||
unknown = _private_rank_response_trace({
|
||||
"coverage": {"sourceMonths": [{"year": 2026, "month": 9, "blackRows": 2}]}})
|
||||
self.assertIsNone(unknown["coverageSourceMonths"][0]["brightRows"])
|
||||
self.assertEqual(unknown["coverageSourceMonths"][0]["countStates"]["brightRows"], "missing")
|
||||
|
||||
def test_schema_has_one_tool_and_modes(self):
|
||||
definition = tool_definition()
|
||||
self.assertEqual(definition["name"], "quality_data")
|
||||
@@ -631,7 +690,7 @@ class QualityToolsTests(unittest.TestCase):
|
||||
"black": {"rate": 0.96, "totalWeight": 4, "qualifiedWeight": 3},
|
||||
"bright": {"rate": 0.99, "totalWeight": 0, "qualifiedWeight": 0},
|
||||
"coverage": {"blackRows": 3, "brightRows": 0}}
|
||||
self.assertIsNone(QualityTools._row_rate(row, None))
|
||||
self.assertAlmostEqual(float(QualityTools._row_rate(row, None)), 0.95)
|
||||
self.assertAlmostEqual(float(QualityTools._row_rate(row, "black")), 0.96)
|
||||
self.assertIsNone(QualityTools._row_rate(row, "bright"))
|
||||
self.assertIsNone(QualityTools._row_rate({**row, "coverage": None}, "black"))
|
||||
|
||||
@@ -145,6 +145,16 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
else:
|
||||
with self.assertRaises(NativeCompositionError): _validate_blocks(parsed, report['facts'], tokens)
|
||||
self.assertEqual(wire, wire_copy)
|
||||
# A compact wire response with an actual Top 2 must not silently become
|
||||
# Top 1 just because the presentation projection omitted result.rows.
|
||||
complete_wire = copy.deepcopy(wire)
|
||||
complete_wire.update(rowsReturned=2, truncated=False)
|
||||
report = build_native_report([document(complete_wire)], context={'releaseId': RELEASE,
|
||||
'_agentTask': {'executionMode': 'native_agent'}})
|
||||
self.assertFalse(report['missingEvidence'])
|
||||
paired_facts = [fact for fact in report['facts'] if fact['kind'] == 'defect' and '来源细项'+str(fact['label'])+':' in fact['text']]
|
||||
self.assertEqual([fact['label'] for fact in paired_facts], ['责废尺寸重量', '责废缺角重量'])
|
||||
self.assertFalse(any(fact['kind'] == 'defect_context' for fact in report['facts']))
|
||||
|
||||
def test_exact_changes_raw_alias_matches_formal_display_without_precision_guessing(self):
|
||||
facts = [{'id': 'F1', 'kind': 'product', 'label': '规格甲', 'text': '规格甲合格率95.00%。', 'scrapDelta': 758.7594,
|
||||
@@ -586,8 +596,10 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
report = {'facts': facts, 'requiredFactIds': [], 'priorityFactIds': [], 'scopes': [], 'missingEvidence': [], 'rejectedEvidenceRefs': []}
|
||||
for phrase in ('均未达到0.59 kg', '均未达0.59 kg', '相等'):
|
||||
for verdict in (None, False):
|
||||
phases = []
|
||||
def provider(request, timeout):
|
||||
if request_phase(request) == 'evidence_review':
|
||||
phases.append(request_phase(request))
|
||||
if phases[-1] == 'evidence_review':
|
||||
self.assertTrue(fixture_payload(request)['blocks'][0]['statisticalClaimsReviewRequired'])
|
||||
row = {'supported': True}
|
||||
if verdict is not None: row['statisticalClaimsSupported'] = verdict
|
||||
@@ -597,7 +609,23 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
with self.subTest(phrase=phrase, verdict=verdict), patch('nao_native_answer.build_native_report', return_value=report):
|
||||
result = invoke(provider)
|
||||
self.assertNotIn(phrase, result['answer'])
|
||||
self.assertEqual(result['compositionDiagnostics']['rejectedStatisticalBlockIndexes'], [0])
|
||||
diagnostics = result['compositionDiagnostics']
|
||||
if phrase == '均未达0.59 kg':
|
||||
# The recognized strict boundary is now rejected
|
||||
# before semantic review: 0.59 is not below itself.
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertFalse(result['bodyEvidenceSufficient'])
|
||||
self.assertEqual(phases, ['native_synthesis', 'native_synthesis'])
|
||||
self.assertTrue(diagnostics['formatRepairAttempted'])
|
||||
self.assertFalse(diagnostics['evidenceReviewAttempted'])
|
||||
self.assertNotIn('rejectedStatisticalBlockIndexes', diagnostics)
|
||||
self.assertEqual(len(diagnostics['issues']), 2)
|
||||
self.assertTrue(all(issue.startswith('NativeCompositionError:') and '0.59' in issue
|
||||
for issue in diagnostics['issues']))
|
||||
else:
|
||||
self.assertEqual(phases, ['native_synthesis', 'evidence_review'])
|
||||
self.assertTrue(diagnostics['evidenceReviewAttempted'])
|
||||
self.assertEqual(diagnostics['rejectedStatisticalBlockIndexes'], [0])
|
||||
|
||||
def test_strict_comparison_threshold_is_not_replaced_by_rounded_source_value(self):
|
||||
for source_unit, suffix in (('kg', ' kg'), ('source_weight', '')):
|
||||
@@ -636,8 +664,10 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
{'id': 'F3', 'text': '规格丙报废重量0.34 kg。', 'evidenceRef': 'Q00000001'}]
|
||||
report = {'facts': facts, 'requiredFactIds': [], 'priorityFactIds': [], 'scopes': [], 'missingEvidence': [], 'rejectedEvidenceRefs': []}
|
||||
for claim_type, statistical_support in (('hypothesis', None), ('hypothesis', False), ('observation', False)):
|
||||
phases = []
|
||||
def provider(request, timeout):
|
||||
if request_phase(request) == 'evidence_review':
|
||||
phases.append(request_phase(request))
|
||||
if phases[-1] == 'evidence_review':
|
||||
payload = fixture_payload(request)
|
||||
self.assertEqual(payload['blocks'][0]['statisticalClaimsReviewRequired'], claim_type == 'hypothesis')
|
||||
row = {'index': 0, 'supported': True}
|
||||
@@ -650,7 +680,18 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
self.assertNotIn('其中较高', result['answer'])
|
||||
self.assertNotIn('均不足', result['answer'])
|
||||
self.assertIn('报废重量2.52 kg', result['answer'])
|
||||
self.assertEqual(result['compositionDiagnostics']['rejectedStatisticalBlockIndexes'], [0])
|
||||
# Keep the original false comparison. Its strict threshold
|
||||
# fails the deterministic gate, so no semantic verdict exists.
|
||||
diagnostics = result['compositionDiagnostics']
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertFalse(result['bodyEvidenceSufficient'])
|
||||
self.assertEqual(phases, ['native_synthesis', 'native_synthesis'])
|
||||
self.assertTrue(diagnostics['formatRepairAttempted'])
|
||||
self.assertFalse(diagnostics['evidenceReviewAttempted'])
|
||||
self.assertNotIn('rejectedStatisticalBlockIndexes', diagnostics)
|
||||
self.assertEqual(len(diagnostics['issues']), 2)
|
||||
self.assertTrue(all(issue.startswith('NativeCompositionError:') and '0.59' in issue
|
||||
for issue in diagnostics['issues']))
|
||||
|
||||
def test_history_source_overall_and_stage_baselines_are_protected_before_exploratory_rows(self):
|
||||
scope = {'filters': {'department': '原调查部门'}, 'period': {'year': 2026, 'month': 9}}
|
||||
@@ -676,6 +717,36 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
with self.assertRaisesRegex(NativeCompositionError, '单位'):
|
||||
_validate_blocks({'blocks': [{'text': '{{'+key+'}} kg', 'factIds': ['F1']}]}, facts, tokens)
|
||||
|
||||
def test_source_weight_rounding_uses_bounded_precision_and_skips_unsafe_literals(self):
|
||||
official = '123456789012345678901234567890.12345'
|
||||
facts = [{'id': 'F1', 'text': '来源重量' + official + '。', 'evidenceRef': 'history:weight',
|
||||
'verifiedDisplayValues': [{'metricCode': 'weight', 'unit': 'source_weight', 'displayValue': official}]}]
|
||||
tokens = _binding_inventory(facts)
|
||||
|
||||
diagnostics = {}
|
||||
accepted = _bind_literal_measures({'blocks': [{'text': '来源重量123456789012345678901234567890.1235。',
|
||||
'factIds': ['F1']}]}, tokens, diagnostics)
|
||||
self.assertIn('{{N', accepted['blocks'][0]['text'])
|
||||
self.assertEqual(len(diagnostics['literalBindings']), 1)
|
||||
|
||||
rejected_diagnostics = {}
|
||||
rejected = _bind_literal_measures({'blocks': [{'text': '来源重量123456789012345678901234567890.1236。',
|
||||
'factIds': ['F1']}]}, tokens, rejected_diagnostics)
|
||||
self.assertIn('123456789012345678901234567890.1236', rejected['blocks'][0]['text'])
|
||||
self.assertFalse(rejected_diagnostics.get('literalBindings'))
|
||||
|
||||
oversized = '7.' + ('0' * 300) + '1'
|
||||
oversized_facts = [{'id': 'F2', 'text': '来源重量' + oversized + '。', 'evidenceRef': 'history:oversized',
|
||||
'verifiedDisplayValues': [{'metricCode': 'weight', 'unit': 'source_weight',
|
||||
'displayValue': oversized}]}]
|
||||
oversized_tokens = _binding_inventory(oversized_facts)
|
||||
oversized_diagnostics = {}
|
||||
oversized_result = _bind_literal_measures({'blocks': [{'text': '来源重量' + oversized + '。',
|
||||
'factIds': ['F2']}]},
|
||||
oversized_tokens, oversized_diagnostics)
|
||||
self.assertIn(oversized, oversized_result['blocks'][0]['text'])
|
||||
self.assertFalse(oversized_diagnostics.get('literalBindings'))
|
||||
|
||||
def test_summary_selection_rejects_unknown_and_nonpriority_core_and_normalizes_redundancy(self):
|
||||
blocks = [{'text': '最低率规格甲', 'bindingFactIds': ['F1']}, {'text': '高报废规格乙', 'bindingFactIds': ['F2']}]
|
||||
for choice in ({'leadIndex': True, 'evidenceIndexes': []}, {'leadIndex': 0, 'evidenceIndexes': [2]},
|
||||
@@ -1226,7 +1297,7 @@ class NativeAnswerTests(unittest.TestCase):
|
||||
return response({'blocks': [{'text': '本期综合合格率为' + token(payload, '95.00%')
|
||||
+ ',低于基期的' + token(payload, '96.00%') + ',统计表现有所下降,需结合阶段指标核查。',
|
||||
'factIds': ['F1'], 'claimType': 'inference', 'evidenceRefs': ['Q00000001']}]})
|
||||
result = invoke(provider, draft='设备导致99%的下降(尚未核验的草稿)')
|
||||
result = invoke(provider)
|
||||
self.assertEqual(phases, ['native_synthesis', 'evidence_review'])
|
||||
self.assertIn('统计表现有所下降', result['answer'])
|
||||
self.assertIn('95.00%', result['readingSummary']['lead'])
|
||||
|
||||
@@ -28,10 +28,15 @@ class NativeAnswerGateTests(unittest.TestCase):
|
||||
body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))
|
||||
owner.calls.append(body)
|
||||
reviewing = body['messages'][0]['content'].startswith('逐句核验证据')
|
||||
payload = json.loads(body['messages'][1]['content'])
|
||||
content = ({'reviews': [{'index': 0, 'supported': True}]} if reviewing else
|
||||
{'blocks': [{'text': '本期正式率低于基期,需要继续核查阶段差异。',
|
||||
'factIds': ['F1'], 'claimType': 'inference'}],
|
||||
'summarySelection': {'leadIndex': 0, 'evidenceIndexes': []}})
|
||||
if 'draftBlocks' in payload:
|
||||
content = {'reviews': [{'sourceId': block['sourceId'], 'role': 'core',
|
||||
'factIds': ['F1'], 'supported': True, 'statisticalClaimsSupported': True}
|
||||
for block in payload['draftBlocks']], 'missingGoalDescriptions': [], 'visualIds': []}
|
||||
if owner.malformed_synthesis and not reviewing:
|
||||
content = 'invalid composition'
|
||||
data = json.dumps({'model': 'fixture-model', 'choices': [{'finish_reason': 'stop',
|
||||
@@ -70,10 +75,20 @@ class NativeAnswerGateTests(unittest.TestCase):
|
||||
self.provider.server_close()
|
||||
self.thread.join(timeout=1)
|
||||
|
||||
def synthesize(self):
|
||||
def synthesize(self, draft=None):
|
||||
# No mocked opener: the finalizer, HTTP gate and upstream all run.
|
||||
return synthesize_native(base_url=self.base, api_key='fixture-gate-key', model='fixture-model',
|
||||
question='解释质量变化', evidence=evidence(), cancel_event=self.cancelled)
|
||||
question='解释质量变化', evidence=evidence(), cancel_event=self.cancelled, native_answer=draft)
|
||||
|
||||
def test_finished_draft_is_reviewed_once_with_same_thinking_and_authorization(self):
|
||||
result = self.synthesize('综合合格率95.00%,低于基期96.00%。')
|
||||
self.assertTrue(result['evidenceSufficient'], result['missingEvidence'])
|
||||
self.assertEqual(len(self.calls), 1)
|
||||
self.assertEqual(result['compositionDiagnostics']['modelPhases'], ['native_draft_review'])
|
||||
self.assertEqual(self.calls[0]['thinking'], {'type': 'enabled'})
|
||||
self.assertEqual(self.calls[0]['reasoning_effort'], 'high')
|
||||
self.assertEqual(self.gate.rejected_stale_requests, 0)
|
||||
self.assertEqual({event['phase'] for event in self.events}, {'finalizing'})
|
||||
|
||||
def test_synthesis_and_review_use_authorized_finalizing_phase_without_native_marker(self):
|
||||
result = self.synthesize()
|
||||
|
||||
@@ -0,0 +1,304 @@
|
||||
"""Typed edits bind original spans to formal values, never to arbitrary prose."""
|
||||
import copy
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts'), str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from nao_native_answer import (_comparison_weight_changes, _attach_native_source_numbers,
|
||||
_native_atomic_inventory, _native_number_match, _native_changes_weight_context, _metric_facts,
|
||||
_native_black_category_share_context, _native_changes_decomposition)
|
||||
from nao_native_answer import build_native_report
|
||||
from test_agent_answer import evidence
|
||||
|
||||
|
||||
class NativeAtomicBindingTests(unittest.TestCase):
|
||||
def report(self):
|
||||
return {'facts': [{'id':'F'+str(i),'kind':'product','label':label,
|
||||
'text':label+'合格率95.00%,报废重量10.25 kg。','evidenceRef':'Q00000001',
|
||||
'period':{'year':2026,'month':9},'scope':{'period':{'year':2026,'month':9},'dimension':'product','filters':{'product':label}}}
|
||||
for i,label in [(1,'规格甲'),(2,'规格乙')]],'requiredFactIds':[],'priorityFactIds':[],
|
||||
'missingEvidence':[],'rejectedEvidenceRefs':[],'sections':[],'notices':[]}
|
||||
|
||||
def invoke(self,draft,selector=None,report=None):
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);calls.append(payload)
|
||||
rows=[]
|
||||
for block in payload['draftBlocks']:
|
||||
row={'sourceId':block['sourceId'],'role':'core','factIds':['F1'],'supported':True,'statisticalClaimsSupported':True}
|
||||
if selector: row.update(selector(payload,block))
|
||||
rows.append(row)
|
||||
raw={'reviews':rows,'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(raw,ensure_ascii=False)}}]}).encode())
|
||||
with patch('nao_native_answer.build_native_report',return_value=report or self.report()):
|
||||
result=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量',
|
||||
evidence=evidence(),context={'_agentTask':{'executionMode':'native_agent'}},native_answer=draft,
|
||||
cancel_event=threading.Event(),opener=provider)
|
||||
return result,calls
|
||||
|
||||
def binding(self,payload,span,owner='F1'):
|
||||
key=next(key for key,value in payload['bindingCatalog'].items() if key.startswith('N') and value['factId']==owner and value.get('unit')=='kg')
|
||||
return {'bindings':[{'span':span,'tokenId':key}]}
|
||||
|
||||
def test_bare_weight_and_bold_table_are_typed_once(self):
|
||||
draft='规格甲报废为**10.25**。\n\n| 产品 | 9月报废 |\n|---|---|\n| 规格甲 | **10.25** |'
|
||||
result,calls=self.invoke(draft)
|
||||
self.assertTrue(result['evidenceSufficient'],result['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),1)
|
||||
self.assertIn('10.25 kg',result['answer'])
|
||||
|
||||
def test_atomic_span_uses_exact_source_and_qualified_token(self):
|
||||
result,calls=self.invoke('规格甲报废10.25。',lambda p,b:self.binding(p,'10.25'))
|
||||
self.assertTrue(result['evidenceSufficient'])
|
||||
self.assertEqual(len(calls),1)
|
||||
for draft,selector in [('规格甲报废10.25。',lambda p,b:self.binding(p,'10.25','F2')),
|
||||
('规格甲报废10.25吨。',lambda p,b:self.binding(p,'10.25')),
|
||||
('规格甲数量10.25件。',lambda p,b:self.binding(p,'10.25')),
|
||||
('规格甲报废10.26。',lambda p,b:self.binding(p,'10.26')),
|
||||
('规格甲A10.25质量。',lambda p,b:self.binding(p,'10.25')),
|
||||
('| 序号 | 产品 |\n|---|---|\n| 10.25 | 规格甲 |',lambda p,b:self.binding(p,'10.25')),
|
||||
('规格甲报废10.25。',lambda p,b:self.binding(p,'不存在的原文'))]:
|
||||
with self.subTest(draft=draft):
|
||||
bad,calls=self.invoke(draft,selector);self.assertFalse(bad['evidenceSufficient']);self.assertEqual(len(calls),2)
|
||||
|
||||
def test_repeated_span_requires_occurrence_and_wrong_month_is_rejected(self):
|
||||
bad,_=self.invoke('规格甲报废10.25,复核10.25。',lambda p,b:self.binding(p,'10.25'))
|
||||
self.assertFalse(bad['evidenceSufficient'])
|
||||
report=self.report();report['facts'][0]['period']={'year':2026,'month':8}
|
||||
bad,_=self.invoke('规格甲质量。\n\n| 产品 | 2026年9月报废 |\n|---|---|\n| 规格甲 | 10.25 |',report=report)
|
||||
self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_formal_weight_differences_use_unrounded_values_and_missing_is_not_zero(self):
|
||||
compare={'current':{'period':{'year':2026,'month':9},'black':{'scrapWeight':'38375.282'},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':9,'blackRows':2}]}},
|
||||
'comparison':{'period':{'year':2026,'month':8},'black':{'scrapWeight':'32375.0762'},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':8,'blackRows':2}]}}}
|
||||
changes=_comparison_weight_changes(compare,'black')
|
||||
item=next(item for item in changes if item['metricCode']=='scrapWeightDelta')
|
||||
self.assertEqual(item['rawValue'],'6000.2058');self.assertEqual(item['displayValue'],'+6,000.21')
|
||||
compare['comparison']['black']['scrapWeight']=None
|
||||
self.assertFalse(any(item['metricCode']=='scrapWeightDelta' for item in _comparison_weight_changes(compare,'black')))
|
||||
compare['comparison']['black']['scrapWeight']='32375.0762'
|
||||
compare['comparison']['coverage']['sourceMonths'][0]['blackRows']=0
|
||||
self.assertEqual(_comparison_weight_changes(compare,'black'),[])
|
||||
|
||||
def precision_report(self, *, rate=False):
|
||||
before={'period':{'year':2026,'month':8},'black':{'rate':'0.9758','defects':[{'name':'外废','weight':'684.474'}]},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':8,'blackRows':2}]}}
|
||||
now={'period':{'year':2026,'month':9},'black':{'rate':'0.9727','defects':[{'name':'外废','weight':'615.249'}]},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':9,'blackRows':2}]}}
|
||||
result={'kind':'quality_comparison','comparison':before,'current':now,'stageRateChangesPP':{'black':'-0.30416066564718'}}
|
||||
fact={'id':'F1','kind':'stage' if rate else 'category','label':'黑片合格率' if rate else '黑片·外废',
|
||||
'text':'黑片合格率:97.58%→97.27%,下降0.30个百分点。' if rate else '黑片外废:684.47→615.25 kg,增减-69.23 kg。',
|
||||
'evidenceRef':'Q00000001','scope':{'period':now['period'],'comparisonPeriod':before['period'],'filters':{}}}
|
||||
_attach_native_source_numbers(fact,result)
|
||||
return {'facts':[fact],'requiredFactIds':[],'priorityFactIds':[],'missingEvidence':[],
|
||||
'rejectedEvidenceRefs':[],'sections':[],'notices':[]}
|
||||
|
||||
def test_native_raw_precision_does_not_double_round_or_accept_neighbour(self):
|
||||
report=self.precision_report()
|
||||
tokens=_native_atomic_inventory(report['facts'])
|
||||
token=next(value for value in tokens.values() if value.get('rawValue')=='615.249')
|
||||
self.assertTrue(_native_number_match('615.2',token))
|
||||
self.assertFalse(_native_number_match('615.3',token))
|
||||
self.assertFalse(_native_number_match('615.24',token))
|
||||
good,calls=self.invoke('黑片外废报废615.2 kg。',report=report)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),1);self.assertIn('615.25',good['answer'])
|
||||
for draft in ('黑片外废报废615.3 kg。','黑片外废报废-615.2 kg。','黑片外废数量615.2件。',
|
||||
'黑片外废报废615.2吨。','亮片外废报废615.2 kg。',
|
||||
'2026年8月黑片外废报废615.2 kg。',
|
||||
'| 类别 | 2026年8月报废(kg) |\n|---|---|\n| 黑片外废 | 615.2 |'):
|
||||
with self.subTest(draft=draft):
|
||||
bad,_=self.invoke(draft,report=report);self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_native_three_decimal_pp_uses_formal_raw_signed_value(self):
|
||||
report=self.precision_report(rate=True)
|
||||
token=next(value for value in _native_atomic_inventory(report['facts']).values() if value.get('nativeSignedChange'))
|
||||
self.assertEqual(token['rawValue'],'-0.30416066564718')
|
||||
self.assertTrue(_native_number_match('-0.304',token));self.assertFalse(_native_number_match('-0.305',token))
|
||||
self.assertFalse(_native_number_match('+0.304',token))
|
||||
good,calls=self.invoke('黑片合格率变化-0.304个百分点。',report=report)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
for draft in ('黑片合格率变化-0.305个百分点。','黑片合格率变化+0.304个百分点。','黑片合格率变化-0.304%。'):
|
||||
with self.subTest(draft=draft):
|
||||
bad,_=self.invoke(draft,report=report);self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_changes_stage_weight_delta_stays_same_row_and_never_fills_missing(self):
|
||||
result={'kind':'quality_changes','currentPeriod':{'year':2026,'month':9},'comparisonPeriod':{'year':2026,'month':8},
|
||||
'rows':[{'label':'产业部甲','present':{'current':True,'comparison':True},
|
||||
'current':{'black':{'scrapWeight':'26650.2387'},'bright':{'scrapWeight':'15045.38117'}},
|
||||
'comparison':{'black':{'scrapWeight':'20372.4643'},'bright':{'scrapWeight':'15011.77401'}}}]}
|
||||
fact={'id':'F1','kind':'supporting','label':'产业部甲规模依据','text':'产业部甲规模依据。','evidenceRef':'Q00000001'}
|
||||
projected=_native_changes_weight_context(fact,result)
|
||||
self.assertEqual([x['rawValue'] for x in projected['verifiedWeightChanges']],['6277.7744','33.60716'])
|
||||
self.assertEqual(fact['text'],'产业部甲规模依据。')
|
||||
result['rows'][0]['comparison']['bright']['scrapWeight']=None
|
||||
self.assertEqual(len(_native_changes_weight_context(fact,result)['verifiedWeightChanges']),1)
|
||||
result['rows'][0]['present']['comparison']=False
|
||||
self.assertNotIn('verifiedWeightChanges',_native_changes_weight_context(fact,result))
|
||||
|
||||
def test_narrow_metric_row_keeps_its_own_raw_value_not_same_rounded_parent(self):
|
||||
row={'period':{'year':2026,'month':9},'black':{'rate':'0.95129','totalWeight':100},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':9,'blackRows':2}]}}
|
||||
parent={'kind':'quality_metrics','period':row['period'],'summary':{'black':{'rate':'0.95126'}},'coverage':row['coverage']}
|
||||
fact=next(f for f in _metric_facts(row,'2026年9月;规格甲','Q00000001') if f['label']=='黑片正式指标')
|
||||
fact.update(id='F1');_attach_native_source_numbers(fact,parent)
|
||||
token=next(v for v in _native_atomic_inventory([fact]).values() if v.get('unit')=='%')
|
||||
self.assertEqual(token['rawValue'],'95.12900')
|
||||
self.assertTrue(_native_number_match('95.129',token));self.assertFalse(_native_number_match('95.126',token))
|
||||
|
||||
def test_nested_scrap_rate_is_measured_formal_value_with_own_period_and_unit(self):
|
||||
row={'label':'规格甲','present':{'current':True,'comparison':True},'comparison':{},
|
||||
'current':{'black':{'scrapRate':'0.13192884159534718','totalWeight':'9384.42','scrapWeight':'1238.08'},
|
||||
'rateSupport':{'blackMeasured':True}}}
|
||||
result={'kind':'quality_changes','dimension':'product','currentPeriod':{'year':2026,'month':9},
|
||||
'comparisonPeriod':{'year':2026,'month':8},'rows':[row]}
|
||||
base={'id':'F1','kind':'supporting','label':'规格甲规模依据','text':'规格甲规模依据。','evidenceRef':'Q00000001',
|
||||
'scope':{'period':result['currentPeriod'],'dimension':'product','filters':{'product':'规格甲'}}}
|
||||
fact=_attach_native_source_numbers(_native_changes_weight_context(base,result),result)
|
||||
token=next(value for value in _native_atomic_inventory([fact]).values() if value.get('metricField')=='scrapRate' and value.get('unit')=='%')
|
||||
self.assertEqual(token['rawValue'],'13.19288415953471800');self.assertEqual(token['unit'],'%')
|
||||
report={**self.report(),'facts':[fact]}
|
||||
good,calls=self.invoke('规格甲9月黑片正式报废率13.19%。',report=report)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
for text in ('规格甲8月黑片正式报废率13.19%。','规格甲9月亮片正式报废率13.19%。','规格甲9月黑片正式报废率13.19个百分点。'):
|
||||
bad,_=self.invoke(text,report=report);self.assertFalse(bad['evidenceSufficient'])
|
||||
row['current']['rateSupport']['blackMeasured']=False
|
||||
self.assertNotIn('verifiedStageScrapRates',_native_changes_weight_context(base,result))
|
||||
|
||||
def test_black_share_requires_formal_denominator_and_never_borrows_bright_basis(self):
|
||||
side={'period':{'year':2026,'month':9},'black':{'scrapWeight':100,'defects':[
|
||||
{'name':'责废','weight':60,'rate':'0.6'},{'name':'料废','weight':40,'rate':'0.4'}]},
|
||||
'coverage':{'sourceMonths':[{'year':2026,'month':9,'blackRows':2}]}}
|
||||
result={'kind':'quality_comparison','current':side,'comparison':{}}
|
||||
base={'id':'F1','kind':'category','label':'黑片·责废','text':'黑片责废:60.00 kg。','evidenceRef':'Q00000001',
|
||||
'scope':{'period':side['period'],'filters':{}}}
|
||||
fact=_attach_native_source_numbers(_native_black_category_share_context(base,result),result)
|
||||
report={**self.report(),'facts':[fact]}
|
||||
good,calls=self.invoke('9月黑片责废占正式报废60.0%。',report=report)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
bad,_=self.invoke('9月黑片料废占正式报废60.0%。',report=report);self.assertFalse(bad['evidenceSufficient'])
|
||||
side['black']['scrapWeight']=101
|
||||
self.assertNotIn('verifiedCategoryShares',_native_black_category_share_context(base,result))
|
||||
side['black']['scrapWeight']=100
|
||||
self.assertNotIn('verifiedCategoryShares',_native_black_category_share_context({**base,'label':'亮片·加工废'},result))
|
||||
|
||||
def test_changes_decomposition_owns_query_aggregate_scope_not_ranked_row(self):
|
||||
period={'year':2026,'month':9};previous={'year':2026,'month':8}
|
||||
def snapshot(selected):return {'period':selected,'black':{'rate':'.97','totalWeight':100},
|
||||
'bright':{'rate':'.98','totalWeight':100},'coverage':{'sourceMonths':[{'year':2026,'month':selected['month'],'blackRows':2,'brightRows':2}]}}
|
||||
result={'kind':'quality_changes','current':snapshot(period),'comparison':snapshot(previous),
|
||||
'stageDecomposition':{'status':'available','blackContributionToCompositePP':'-0.36330259939709003',
|
||||
'brightContributionToCompositePP':'-0.2318568021276503'}}
|
||||
scope={'period':period,'comparisonPeriod':previous,'filters':{'department':'新能源汽车磁钢'},'dimension':'group'}
|
||||
fact=_native_changes_decomposition(result,'Q00000001',scope,'2026年9月;新能源汽车磁钢')
|
||||
fact['id']='F1';_attach_native_source_numbers(fact,result)
|
||||
self.assertEqual(fact['scope']['filters'],{'department':'新能源汽车磁钢'});self.assertIsNone(fact['scope']['dimension'])
|
||||
self.assertEqual([v['rawValue'] for v in fact['verifiedNativeNumericValues']],['-0.36330259939709003','-0.2318568021276503'])
|
||||
good,calls=self.invoke('新能源汽车磁钢黑片贡献-0.363个百分点,亮片贡献-0.232个百分点。',report={**self.report(),'facts':[fact]})
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
result['current']['coverage']['sourceMonths'][0]['blackRows']=0
|
||||
self.assertIsNone(_native_changes_decomposition(result,'Q00000001',scope,'范围'))
|
||||
|
||||
|
||||
class NativeAtomicFullPipelineGuards(unittest.TestCase):
|
||||
"""Build real formal facts; mock only the independent review transport."""
|
||||
def documents(self, *, rising=False):
|
||||
docs=evidence();result=docs[0]['result']
|
||||
for side,weight,rate in [('comparison','684.474','.9727' if rising else '.9758'),
|
||||
('current','615.249','.9758' if rising else '.9727')]:
|
||||
result[side]['black']={'rate':rate,'scrapWeight':weight,'totalWeight':'10000','qualifiedWeight':'9000',
|
||||
'defects':[{'name':'外废','weight':weight}]}
|
||||
result['stageRateChangesPP']={'black':'.30416066564718' if rising else '-.30416066564718'}
|
||||
return docs
|
||||
|
||||
def invoke(self,draft,*,rising=False,owner='黑片·外废'):
|
||||
docs=self.documents(rising=rising);context={'_agentTask':{'executionMode':'native_agent'}}
|
||||
report=build_native_report(docs,context);self.assertEqual(report['missingEvidence'],[])
|
||||
fact=next(f for f in report['facts'] if f.get('label')==owner);calls=[]
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);calls.append(payload)
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':[fact['id']],
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']],
|
||||
'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value)}}]}).encode())
|
||||
result=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量',
|
||||
evidence=docs,context=context,native_answer=draft,cancel_event=threading.Event(),opener=provider)
|
||||
return result,calls
|
||||
|
||||
def test_derived_decrease_cannot_escape_wrong_stage_through_later_binder(self):
|
||||
bad,_=self.invoke('亮片外废减少69.225 kg。')
|
||||
self.assertFalse(bad['evidenceSufficient']);self.assertNotIn('亮片外废减少69.23',bad['answer'])
|
||||
good,calls=self.invoke('黑片外废减少69.225 kg。')
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
self.assertIn('黑片外废减少69.23 kg',good['answer'])
|
||||
|
||||
def test_table_recovery_cannot_escape_stage_or_period_authorization(self):
|
||||
for label,header in [('亮片','变化(个百分点)'),('黑片','2026年7月变化(个百分点)'),('黑片','2026年8月变化(个百分点)')]:
|
||||
draft='黑片质量对比。\n\n| 阶段 | '+header+' |\n|---|---|\n| '+label+' | +0.30 |'
|
||||
with self.subTest(label=label,header=header):
|
||||
bad,_=self.invoke(draft,rising=True,owner='黑片合格率');self.assertFalse(bad['evidenceSufficient'])
|
||||
for header in ('变化(个百分点)','2026年9月变化(个百分点)'):
|
||||
good,calls=self.invoke('黑片质量对比。\n\n| 阶段 | '+header+' |\n|---|---|\n| 黑片 | +0.30 |',
|
||||
rising=True,owner='黑片合格率')
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
|
||||
def test_comparison_dates_keep_current_and_baseline_roles(self):
|
||||
for owner,positive,negative in [
|
||||
('黑片·外废','9月黑片外废较8月减少69.225 kg。','8月黑片外废较9月减少69.225 kg。'),
|
||||
('黑片合格率','9月黑片合格率较8月下降0.304个百分点。','8月黑片合格率较9月下降0.304个百分点。')]:
|
||||
good,calls=self.invoke(positive,owner=owner)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
bad,_=self.invoke(negative,owner=owner);self.assertFalse(bad['evidenceSufficient'])
|
||||
good,calls=self.invoke('黑片外废与8月相比减少69.225 kg。')
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
bad,_=self.invoke('9月黑片外废较7月减少69.225 kg。');self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_native_repair_never_issues_identifier_numeric_fragments(self):
|
||||
name='R127.985X57.516X15.786X75.485X32.232°X5.5'
|
||||
fact={'id':'F1','kind':'product','label':name,'text':name+'报废重量10.25 kg。','evidenceRef':'Q00000001',
|
||||
'scope':{'period':{'year':2026,'month':9},'filters':{'product':name}}}
|
||||
unused={**fact,'id':'F2','label':'其他规格甲','text':'其他规格甲报废重量9.99 kg。','scope':{'filters':{'product':'其他规格甲'}}}
|
||||
report={'facts':[fact,unused],'requiredFactIds':[],'priorityFactIds':[],'missingEvidence':[],
|
||||
'rejectedEvidenceRefs':[],'sections':[],'notices':[]};requests=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);payload=json.loads(body['messages'][1]['content']);requests.append(body)
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':['F1'],
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']],'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value)}}]}).encode())
|
||||
with patch('nao_native_answer.build_native_report',return_value=report):
|
||||
out=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量',
|
||||
evidence=evidence(),context={'_agentTask':{'executionMode':'native_agent'}},native_answer='R127.985规格报废10.25 kg。',
|
||||
cancel_event=threading.Event(),opener=provider)
|
||||
self.assertFalse(out['evidenceSufficient']);self.assertEqual(len(requests),2)
|
||||
catalog=json.loads(requests[0]['messages'][1]['content'])['bindingCatalog']
|
||||
self.assertTrue(any(key.startswith('I') and value['value']=='其他规格甲' for key,value in catalog.items()))
|
||||
self.assertFalse(any(key.startswith('N') and value['value']=='127.985' for key,value in catalog.items()))
|
||||
self.assertNotIn('应替换为{{N',requests[1]['messages'][-1]['content'])
|
||||
self.assertIn('标识',requests[1]['messages'][-1]['content'])
|
||||
|
||||
def test_strict_bound_requires_exact_raw_and_preserves_boundary(self):
|
||||
for operator in ('不足','不到','低于','高于','少于','多于','小于','大于','超过','至少','至多','上限','下限','<','>','<=','>=','≤','≥'):
|
||||
with self.subTest(operator=operator):
|
||||
result,_=self.invoke('黑片外废报废'+operator+'615.2 kg。')
|
||||
# The formal current value is 615.249. A true threshold need
|
||||
# not itself be an observed point, and must stay 615.2.
|
||||
if operator in ('高于','多于','大于','超过','至少','>','>=','≥'):
|
||||
self.assertTrue(result['evidenceSufficient'],result['compositionDiagnostics']['issues'])
|
||||
self.assertIn('615.2 kg',result['answer']);self.assertNotIn('615.25 kg',result['answer'])
|
||||
else:self.assertFalse(result['evidenceSufficient'])
|
||||
for text,number in [('黑片外废报废低于684.474 kg。','684.474'),('黑片外废报废至多615.249 kg。','615.249')]:
|
||||
good,calls=self.invoke(text)
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
self.assertIn(number+' kg',good['answer'])
|
||||
good,calls=self.invoke('黑片外废报废615.2 kg。')
|
||||
self.assertTrue(good['evidenceSufficient']);self.assertEqual(len(calls),1);self.assertIn('615.25 kg',good['answer'])
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,235 @@
|
||||
"""Content titles share existing finalization calls and stay metadata-only."""
|
||||
import io
|
||||
import copy
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts'), str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from nao_native_answer import synthesize_history_snapshot, _report_title_required
|
||||
from test_agent_answer import evidence
|
||||
|
||||
|
||||
def response(value):
|
||||
return io.BytesIO(json.dumps({'choices': [{'finish_reason': 'stop', 'message': {
|
||||
'content': json.dumps(value, ensure_ascii=False)}}]}).encode())
|
||||
|
||||
|
||||
class NativeContentTitleTests(unittest.TestCase):
|
||||
def invoke(self, title, *, draft=True, report=None):
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
body = json.loads(request.data); calls.append(body)
|
||||
payload = json.loads(body['messages'][1]['content'])
|
||||
if 'draftBlocks' in payload:
|
||||
result = {'reviews': [{'sourceId': block['sourceId'], 'role': 'core', 'factIds': ['F1'],
|
||||
'supported': True, 'statisticalClaimsSupported': True} for block in payload['draftBlocks']],
|
||||
'missingGoalDescriptions': [], 'reportTitle': title}
|
||||
elif body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
result = {'reviews': [{'supported': True, 'statisticalClaimsSupported': True}], 'missingGoalDescriptions': []}
|
||||
else:
|
||||
result = {'blocks': [{'role': 'core', 'text': '综合合格率95.00%。', 'factIds': ['F1']}], 'reportTitle': title}
|
||||
return response(result)
|
||||
kwargs = dict(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='为什么合格率下降', evidence=evidence(), cancel_event=threading.Event(),
|
||||
context={'_agentTask': {'executionMode': 'native_agent'}}, opener=provider,
|
||||
native_answer='综合合格率95.00%。' if draft else None)
|
||||
if report:
|
||||
with patch('nao_native_answer.build_native_report', return_value=report): result = synthesize_native(**kwargs)
|
||||
else: result = synthesize_native(**kwargs)
|
||||
return result, calls
|
||||
|
||||
def test_content_title_is_kept_without_another_call_in_both_paths(self):
|
||||
for draft, count in ((True, 1), (False, 2)):
|
||||
with self.subTest(draft=draft):
|
||||
result, calls = self.invoke('2026年8—9月合格率变化', draft=draft)
|
||||
self.assertEqual(len(calls), count)
|
||||
self.assertEqual(result['reportTitle'], '2026年8—9月合格率变化')
|
||||
self.assertTrue(result['titleGeneratedByModel'])
|
||||
self.assertTrue(result['titleValid'])
|
||||
self.assertEqual(result['titleSource'], 'model_verified_content')
|
||||
self.assertTrue(result['evidenceSufficient'])
|
||||
|
||||
def test_invalid_title_falls_back_without_poisoning_verified_body_or_retry(self):
|
||||
for title in (None, '质量数据分析', '为什么合格率下降', '2027年9月质量变化',
|
||||
'2026年10月质量变化', 'QABCDEF12质量分析', 'QABCDEFAB质量分析', 'history-fact:F1汇总',
|
||||
'scope-1质量分析', '<b>合格率变化</b>', '合格率95.00%质量分析'):
|
||||
with self.subTest(title=title):
|
||||
result, calls = self.invoke(title)
|
||||
self.assertEqual(len(calls), 1)
|
||||
self.assertFalse(result.get('titleValid', True))
|
||||
self.assertFalse(result['titleGeneratedByModel'])
|
||||
self.assertEqual(result['reportTitle'], '质量数据分析')
|
||||
self.assertTrue(result['evidenceSufficient'])
|
||||
|
||||
def test_numeric_business_spec_is_allowed_but_kpi_cannot_supply_a_date(self):
|
||||
spec = '16.33X15.5X3.75+T'
|
||||
fact = {'id': 'F1', 'kind': 'product', 'label': spec,
|
||||
'text': spec + '综合合格率95.00%,投入重量10.00 kg。', 'evidenceRef': 'Q00000001',
|
||||
'scope': {'period': {'year': 2026, 'month': 9}, 'filters': {'product': spec}}}
|
||||
report = {'facts': [fact], 'requiredFactIds': [], 'priorityFactIds': [], 'missingEvidence': [],
|
||||
'rejectedEvidenceRefs': [], 'notices': [], 'sections': []}
|
||||
result, _ = self.invoke('规格' + spec + '质量表现', report=report)
|
||||
self.assertTrue(result['titleGeneratedByModel'])
|
||||
self.assertEqual(result['reportTitle'], '规格' + spec + '质量表现')
|
||||
result, _ = self.invoke('2026年10月质量表现', report=report)
|
||||
self.assertFalse(result.get('titleValid', True))
|
||||
|
||||
def test_title_top_count_requires_actual_contiguous_ranking(self):
|
||||
facts = [{'id': 'F' + str(i), 'kind': 'product', 'label': '规格' + chr(64+i), 'rank': i,
|
||||
'text': '第' + str(i) + '项规格' + chr(64+i) + '合格率95.00%。', 'evidenceRef': 'Q00000001',
|
||||
'scope': {'period': {'year': 2026, 'month': 9}, 'dimension': 'product', 'filters': {}}}
|
||||
for i in range(1, 6)]
|
||||
report = {'facts': facts, 'requiredFactIds': [], 'priorityFactIds': [], 'missingEvidence': [],
|
||||
'rejectedEvidenceRefs': [], 'notices': [], 'sections': []}
|
||||
result, calls = self.invoke('2026年9月产品Top5观察', report=report)
|
||||
self.assertTrue(result['titleValid'])
|
||||
self.assertEqual(len(calls), 1)
|
||||
result, _ = self.invoke('2026年9月产品Top6观察', report=report)
|
||||
self.assertFalse(result['titleValid'])
|
||||
|
||||
def test_aggregate_year_or_quarter_does_not_invent_a_narrow_month_title(self):
|
||||
fact = {'id': 'F1', 'kind': 'overall', 'label': '综合合格率',
|
||||
'text': '2026年9月综合合格率95.00%。', 'evidenceRef': 'Q00000001',
|
||||
'scope': {'period': {'year': 2026}, 'filters': {}}}
|
||||
report = {'facts': [fact], 'requiredFactIds': [], 'priorityFactIds': [], 'missingEvidence': [],
|
||||
'rejectedEvidenceRefs': [], 'notices': [], 'sections': []}
|
||||
for aggregate in ({'year': 2026}, {'year': 2026, 'quarter': 3}):
|
||||
fact['scope']['period'] = aggregate
|
||||
result, _ = self.invoke('2026年9月合格率观察', report=report)
|
||||
self.assertFalse(result['titleValid'])
|
||||
result, _ = self.invoke('2026年合格率观察', report=report)
|
||||
self.assertTrue(result['titleValid'])
|
||||
|
||||
def test_native_history_keeps_same_response_title_instead_of_overwriting(self):
|
||||
from test_nao_history_report import snapshot, report_task, authority, RELEASE, TURN
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
body = json.loads(request.data); calls.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews': [{'supported': True, 'statisticalClaimsSupported': True}], 'missingGoalDescriptions': []})
|
||||
return response({'reportTitle': '2025至2026年多范围报废表现', 'blocks': [{'role': 'core',
|
||||
'text': '历史来源期间和筛选分别适用,应分别解读报废重量。', 'factIds': ['F1', 'F2']}]})
|
||||
result = synthesize_history_snapshot(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='汇总历史', snapshot=snapshot(), task=report_task(), authority=authority(),
|
||||
release_id=RELEASE, request_turn_id=TURN, cancel_event=threading.Event(), opener=provider)
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertEqual(result['reportTitle'], '2025至2026年多范围报废表现')
|
||||
self.assertTrue(result['titleValid'])
|
||||
self.assertEqual(result['titleSource'], 'model_verified_content')
|
||||
self.assertTrue(result['titleRequired'])
|
||||
|
||||
def test_title_required_uses_confirmed_task_or_trusted_history_path(self):
|
||||
history=[{'validity':{'verified':True,'basis':'protocol_history_snapshot'}}]
|
||||
native=[{'validity':{'verified':True,'basis':'quality_comparison'}}]
|
||||
self.assertTrue(_report_title_required({'_reportTitleRequired':True},history))
|
||||
self.assertFalse(_report_title_required({'_reportTitleRequired':True},native))
|
||||
self.assertTrue(_report_title_required({'_agentTask':{'kind':'report'}},native))
|
||||
self.assertFalse(_report_title_required({'question':'生成报告','_agentTask':{'kind':'analysis'}},native))
|
||||
self.assertFalse(_report_title_required({'_agentTask':{'kind':'metrics'}},native))
|
||||
|
||||
def test_actual_history_caller_requires_title_when_presentation_loses_kind(self):
|
||||
import nao_native_answer as composer
|
||||
from test_nao_history_report import snapshot,report_task,authority,RELEASE,TURN
|
||||
original=composer._synthesize_verified_report;seen=[]
|
||||
def forward(**kwargs):
|
||||
seen.append(kwargs['context'].get('_reportTitleRequired'))
|
||||
kwargs['context']=copy.deepcopy(kwargs['context']);kwargs['context']['_agentTask'].pop('kind',None)
|
||||
return original(**kwargs)
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})
|
||||
self.assertTrue(json.loads(body['messages'][1]['content'])['reportTitleGuide']['required'])
|
||||
return response({'reportTitle':'2025至2026年多范围报废表现','blocks':[{'role':'core',
|
||||
'text':'历史来源期间和筛选分别适用,应分别解读报废重量。','factIds':['F1','F2']}]})
|
||||
with patch('nao_native_answer._synthesize_verified_report',side_effect=forward):
|
||||
result=synthesize_history_snapshot(base_url='https://offline.invalid',api_key='fixture',model='fixture',
|
||||
question='汇总历史',snapshot=snapshot(),task=report_task(),authority=authority(),release_id=RELEASE,
|
||||
request_turn_id=TURN,cancel_event=threading.Event(),opener=provider)
|
||||
self.assertEqual(seen,[True]);self.assertTrue(result['titleRequired']);self.assertTrue(result['titleValid'])
|
||||
|
||||
def required_report(self, provider, *, draft=False, required=True):
|
||||
return synthesize_native(base_url='https://offline.invalid/v1',api_key='fixture',model='fixture',
|
||||
question='汇总合格率变化',evidence=evidence(),cancel_event=threading.Event(),
|
||||
context={'_agentTask':{'kind':'report' if required else 'analysis','executionMode':'native_agent'}},
|
||||
native_answer='综合合格率95.00%。' if draft else None,opener=provider)
|
||||
|
||||
def test_report_schema_and_combined_repair_both_require_report_title(self):
|
||||
requests=[];generation=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);requests.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})
|
||||
generation.append(body)
|
||||
return response({'blocks':[{'role':'core','text':'综合合格率99.99%。' if len(generation)==1 else '综合合格率95.00%。','factIds':['F1']}],
|
||||
**({'reportTitle':'2026年8—9月合格率变化'} if len(generation)>1 else {})})
|
||||
result=self.required_report(provider)
|
||||
self.assertEqual(len(requests),3);self.assertEqual(len(generation),2)
|
||||
self.assertIn('输出结构:{"reportTitle":',requests[0]['messages'][0]['content'])
|
||||
self.assertIn('reportTitle',generation[1]['messages'][-1]['content'])
|
||||
self.assertNotIn('仍只返回blocks JSON',generation[1]['messages'][-1]['content'])
|
||||
self.assertTrue(result['titleValid']);self.assertTrue(result['bodyEvidenceSufficient']);self.assertEqual(result['titleMissingEvidence'],[])
|
||||
|
||||
def test_title_only_bounded_repair_reuses_body_without_rewriting(self):
|
||||
for draft in (False,True):
|
||||
requests=[];generation=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);requests.append(body);payload=json.loads(body['messages'][1]['content'])
|
||||
if 'draftBlocks' not in payload and body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})
|
||||
generation.append(body)
|
||||
if len(generation)>1:return response({'reportTitle':'2026年8—9月合格率变化'})
|
||||
if draft:return response({'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':['F1'],
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']],'missingGoalDescriptions':[]})
|
||||
return response({'blocks':[{'role':'core','text':'综合合格率95.00%。','factIds':['F1']}]})
|
||||
with self.subTest(draft=draft):
|
||||
result=self.required_report(provider,draft=draft)
|
||||
self.assertEqual(len(requests),2 if draft else 3)
|
||||
self.assertEqual(len(generation),2)
|
||||
self.assertIn('titleMetadataOnlyRepair',generation[1]['messages'][-1]['content'])
|
||||
self.assertTrue(result['bodyEvidenceSufficient']);self.assertTrue(result['titleValid'])
|
||||
self.assertIn('95.00%',result['answer']);self.assertTrue(result['readingSummary'])
|
||||
|
||||
def test_required_title_failure_preserves_verified_body_and_separate_gap(self):
|
||||
requests=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);requests.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})
|
||||
return response({'blocks':[{'role':'core','text':'综合合格率95.00%。','factIds':['F1']}]})
|
||||
result=self.required_report(provider)
|
||||
self.assertEqual(len(requests),3);self.assertTrue(result['titleRequired']);self.assertFalse(result['titleValid'])
|
||||
self.assertTrue(result['evidenceSufficient']);self.assertTrue(result['bodyEvidenceSufficient'])
|
||||
self.assertEqual(result['missingEvidence'],[]);self.assertEqual(result['bodyMissingEvidence'],[])
|
||||
self.assertTrue(result['titleMissingEvidence']);self.assertIn('95.00%',result['answer'])
|
||||
self.assertNotIn('格式未通过',result['answer'])
|
||||
|
||||
def test_optional_chat_title_never_retries_or_poisons_body(self):
|
||||
requests=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);requests.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})
|
||||
return response({'blocks':[{'role':'core','text':'综合合格率95.00%。','factIds':['F1']}]})
|
||||
result=self.required_report(provider,required=False)
|
||||
self.assertEqual(len(requests),2);self.assertFalse(result['titleRequired'])
|
||||
self.assertTrue(result['bodyEvidenceSufficient']);self.assertEqual(result['titleMissingEvidence'],[])
|
||||
|
||||
def test_title_failure_never_marks_rejected_body_sufficient(self):
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews':[{'supported':False,'statisticalClaimsSupported':False}],
|
||||
'missingGoalDescriptions':['尚未覆盖所需比较关系。']})
|
||||
return response({'blocks':[{'role':'core','text':'综合合格率95.00%。','factIds':['F1']}]})
|
||||
result=self.required_report(provider)
|
||||
self.assertFalse(result['bodyEvidenceSufficient']);self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertTrue(result['bodyMissingEvidence']);self.assertTrue(result['titleMissingEvidence'])
|
||||
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
@@ -0,0 +1,147 @@
|
||||
"""Display magnitudes and ordered source fields retain formal role identity."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import nao_native_answer as n
|
||||
|
||||
|
||||
class NativeDirectionSourceRoleTests(unittest.TestCase):
|
||||
context={'_agentTask':{'period':{'year':2026,'month':9},'comparisonPeriod':{'year':2026,'month':8},'filters':{}}}
|
||||
|
||||
def test_positive_decline_magnitude_is_not_a_positive_signed_change(self):
|
||||
text='| 指标 | 变化 |\n|---|---|\n| 黑片合格率 | 自身下降0.30个百分点 |\n| 黑片对综合率贡献 | +0.30个百分点 |'
|
||||
facts={'F1':{'id':'F1','label':'黑片合格率','text':'黑片合格率下降0.30个百分点。','scope':{'period':{'year':2026,'month':9}}},
|
||||
'F2':{'id':'F2','label':'阶段影响拆解','text':'黑片对综合率贡献+0.30个百分点。','scope':{'period':{'year':2026,'month':9}}}}
|
||||
base={'value':'0.30','rawValue':'0.30416066564718','unit':'pp','stageHint':'黑片','ownerScope':{},
|
||||
'period':{'year':2026,'month':9},'nativeAtomicOnly':True,'nativeCatalogIssued':True}
|
||||
own={**base,'factId':'F1','metricField':'rateChange','metricRole':'OwnStageRateChangePp','displayDirection':'decrease'}
|
||||
contribution={**base,'factId':'F2','metricField':'stageContribution','metricRole':'ContributionPp'}
|
||||
tokens={'N1':own,'N2':contribution};start=text.index('0.30')
|
||||
good=n._native_resolve_span(text,start,start+4,own,facts,tokens,context=self.context)
|
||||
self.assertIsNotNone(good)
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+4,contribution,facts,tokens,context=self.context))
|
||||
wrong=text.replace('自身下降','自身上升');position=wrong.index('0.30')
|
||||
self.assertIsNone(n._native_resolve_span(wrong,position,position+4,own,facts,tokens,context=self.context))
|
||||
|
||||
def sources(self):
|
||||
facts={};tokens={}
|
||||
for i,field,raw in [(1,'责废缺角重量','2719.3174'),(2,'料废缺角重量','2729.5848')]:
|
||||
fid='F'+str(i);facts[fid]={'id':fid,'kind':'defect','label':field,'text':field+'增减'+raw+' kg。',
|
||||
'scope':{'filters':{'department':'部门甲'},'period':{'year':2026,'month':9},'stage':'black'}}
|
||||
tokens['N'+str(i)]={'factId':fid,'value':'+2,719.32' if i==1 else '+2,729.58','rawValue':raw,'unit':'kg',
|
||||
'metricField':'deltaWeight','metricRole':'deltaWeight','stageHint':'黑片','sourceField':field,
|
||||
'period':{'year':2026,'month':9},
|
||||
'ownerScope':{'department':'部门甲'},'nativeAtomicOnly':True,'nativeCatalogIssued':True}
|
||||
facts['F3']={'id':'F3','label':'黑片·料废','text':'料废增量2,719.32 kg。','scope':{'filters':{'department':'部门甲'}}}
|
||||
tokens['N3']={**tokens['N1'],'factId':'F3','sourceField':None,'categoryHint':'料废','categoryNames':['料废']}
|
||||
return facts,tokens
|
||||
|
||||
def resolve(self,text,literal,token_id):
|
||||
facts,tokens=self.sources();start=text.index(literal)
|
||||
return n._native_resolve_span(text,start,start+len(literal),tokens[token_id],facts,tokens,
|
||||
context={**self.context,'_nativeDocumentScope':{'department':'部门甲'}})
|
||||
|
||||
def test_ordered_field_identity_precedes_category_and_never_uses_value_to_select(self):
|
||||
text='在部门甲内部,责废缺角、料废缺角增量分别达到2,719.32 kg和2,729.58 kg。'
|
||||
self.assertIsNotNone(self.resolve(text,'2,719.32','N1'))
|
||||
self.assertIsNotNone(self.resolve(text,'2,729.58','N2'))
|
||||
self.assertIsNone(self.resolve(text,'2,719.32','N3'))
|
||||
reversed_fields=text.replace('责废缺角、料废缺角','料废缺角、责废缺角')
|
||||
self.assertIsNone(self.resolve(reversed_fields,'2,719.32','N1'))
|
||||
self.assertIsNone(self.resolve(text.replace('责废缺角、','缺角、'),'2,719.32','N1'))
|
||||
self.assertIsNone(self.resolve(text.replace('部门甲','全公司'),'2,719.32','N1'))
|
||||
self.assertIsNone(self.resolve(text.replace('分别达到','分别在8月达到'),'2,719.32','N1'))
|
||||
|
||||
def test_source_delta_list_inherits_only_an_explicit_governing_property(self):
|
||||
facts,tokens=self.sources();text='- 责废缺角重量:+2,719.32 kg';start=text.index('+2,719.32')
|
||||
context={**self.context,'_nativeDocumentScope':{'department':'部门甲'}}
|
||||
for intro,supported in [('来源细项增幅如下:',True),('来源细项当前值如下:',False),('',False)]:
|
||||
result=n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,
|
||||
context={**context,'_nativeAncestors':(intro,) if intro else ()})
|
||||
self.assertEqual(result is not None,supported)
|
||||
|
||||
def test_local_point_property_overrides_the_ancestor_delta_default(self):
|
||||
facts,tokens=self.sources();context={**self.context,'_nativeDocumentScope':{'department':'部门甲'},
|
||||
'_nativeAncestors':('来源细项增幅如下:',)}
|
||||
point={**tokens['N1'],'metricField':'sourceWeight','metricRole':'sourceWeight'}
|
||||
other_field={**point,'factId':'F2','sourceField':'料废缺角重量'}
|
||||
for property_name in ('当前值','本期值'):
|
||||
text='- 责废缺角重量'+property_name+':+2,719.32 kg';start=text.index('+2,719.32')
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,context=context))
|
||||
self.assertIsNotNone(n._native_resolve_span(text,start,start+9,point,facts,tokens,context=context))
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+9,other_field,facts,tokens,context=context))
|
||||
wrong=text.replace('+2,719.32','+2,719.33')
|
||||
self.assertIsNone(n._native_resolve_span(wrong,start,start+9,point,facts,tokens,context=context))
|
||||
|
||||
|
||||
class NativeTableIdentityTests(NativeDirectionSourceRoleTests):
|
||||
def group_fixture(self):
|
||||
facts,tokens=self.sources()
|
||||
owner={'group':'汽车交通-国内','department':'新能源汽车磁钢'}
|
||||
tokens={'N1':{**tokens['N1'],'sourceField':None,'metricField':'scrapWeightDelta',
|
||||
'metricRole':'scrapWeightDelta','ownerScope':owner}}
|
||||
facts['F1']['scope']['filters']=owner
|
||||
context={**self.context,'_nativeScopeCatalog':[{'group':'汽车交通-国内'},owner]}
|
||||
return facts,tokens,context
|
||||
|
||||
def test_unique_nonempty_formal_parent_is_not_competed_by_unspecified_parent(self):
|
||||
facts,tokens,context=self.group_fixture()
|
||||
text='| 范围 | 黑片报废增量 |\n|---|---:|\n| 汽车交通-国内 | +2,719.32 kg |'
|
||||
start=text.index('+2,719.32')
|
||||
self.assertIsNotNone(n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,context=context))
|
||||
context['_nativeScopeCatalog'].append({'group':'汽车交通-国内','department':'另一个部门'})
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,context=context))
|
||||
|
||||
def test_explicit_wrong_parent_and_absent_parent_are_not_inferred_from_value(self):
|
||||
facts,tokens,context=self.group_fixture()
|
||||
text='| 范围 | 黑片报废增量 |\n|---|---:|\n| 汽车交通-国内 | +2,719.32 kg |';start=text.index('+2,719.32')
|
||||
context['_nativeDocumentScope']={'department':'另一个部门'}
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,context=context))
|
||||
context.pop('_nativeDocumentScope');context['_nativeScopeCatalog']=[{'group':'汽车交通-国内'}]
|
||||
self.assertIsNone(n._native_resolve_span(text,start,start+9,tokens['N1'],facts,tokens,context=context))
|
||||
|
||||
def test_source_field_in_same_row_precedes_generic_weight_header(self):
|
||||
text='| 范围/阶段 | 来源缺陷字段 | 报废增量 |\n|---|---|---:|\n| 部门甲黑片 | 责废缺角重量 | +2,719.32 kg |'
|
||||
self.assertIsNotNone(self.resolve(text,'+2,719.32','N1'))
|
||||
self.assertIsNone(self.resolve(text,'+2,719.32','N3'))
|
||||
for changed in (text.replace('责废缺角重量','料废缺角重量'),text.replace('部门甲黑片','部门甲亮片'),
|
||||
text.replace('责废缺角重量','责废缺角'),text.replace('报废增量','8月报废增量'),
|
||||
text.replace('报废增量','投入增量'),text.replace('报废增量','报废率变化')):
|
||||
self.assertIsNone(self.resolve(changed,'+2,719.32','N1'))
|
||||
|
||||
def test_multiple_field_cells_or_future_field_do_not_authorize_current_cell(self):
|
||||
ambiguous='| 范围/阶段 | 字段一 | 字段二 | 报废增量 |\n|---|---|---|---:|\n| 部门甲黑片 | 责废缺角重量 | 料废缺角重量 | +2,719.32 kg |'
|
||||
future='| 范围/阶段 | 报废增量 | 字段 |\n|---|---:|---|\n| 部门甲黑片 | +2,719.32 kg | 责废缺角重量 |'
|
||||
self.assertIsNone(self.resolve(ambiguous,'+2,719.32','N1'))
|
||||
self.assertIsNone(self.resolve(future,'+2,719.32','N1'))
|
||||
|
||||
|
||||
class NativeTargetQuantityTests(unittest.TestCase):
|
||||
def resolve(self,text,role='CompositeRateChangePp',stage='综合'):
|
||||
fact={'id':'F1','text':'综合合格率下降0.44个百分点。','scope':{'period':{'year':2026,'month':9}}}
|
||||
token={'factId':'F1','value':'0.44','rawValue':'0.4440936835838','unit':'pp',
|
||||
'metricField':'rateChange','metricRole':role,'stageHint':stage,'ownerScope':{},
|
||||
'period':{'year':2026,'month':9},'displayDirection':'decrease','nativeCatalogIssued':True}
|
||||
start=text.index('0.44');end=start+4
|
||||
if start and text[start-1] in '+-':start-=1
|
||||
return n._native_resolve_span(text,start,end,token,{'F1':fact},{'N1':token},
|
||||
context=NativeDirectionSourceRoleTests.context)
|
||||
|
||||
def test_target_quantity_is_not_the_contribution_operand(self):
|
||||
text='不是对总体0.44个百分点的正式贡献分解。'
|
||||
self.assertIsNotNone(self.resolve(text))
|
||||
for contributor in ('黑片','亮片'):
|
||||
self.assertIsNotNone(self.resolve(contributor+'对总体0.44个百分点的正式贡献分解。'))
|
||||
self.assertIsNone(self.resolve(contributor+'对总体0.44个百分点的正式贡献分解。',stage=contributor))
|
||||
self.assertIsNone(self.resolve(text,'ContributionPp'))
|
||||
self.assertIsNone(self.resolve(text,stage='黑片'))
|
||||
|
||||
def test_direction_sign_and_unqualified_alias_are_not_relaxed(self):
|
||||
for text in ('对总体+0.44个百分点的贡献分解。','对总体上升0.44个百分点的贡献分解。',
|
||||
'对总体下降+0.44个百分点的贡献分解。',
|
||||
'对总体0.44个百分点上升的贡献分解。','总体变化0.44个百分点。',
|
||||
'黑片对综合率贡献0.44个百分点。','对总体投入0.44个百分点的贡献分解。'):
|
||||
with self.subTest(text=text):self.assertIsNone(self.resolve(text))
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,213 @@
|
||||
"""A finished native draft is independently reviewed once, never rewritten."""
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts'), str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_agent_answer import evidence
|
||||
|
||||
|
||||
def response(value):
|
||||
return io.BytesIO(json.dumps({'choices': [{'finish_reason': 'stop', 'message': {
|
||||
'content': value if isinstance(value, str) else json.dumps(value, ensure_ascii=False)}}]}).encode())
|
||||
|
||||
|
||||
class NativeDraftFinalizationTests(unittest.TestCase):
|
||||
def invoke(self, draft, provider, **kwargs):
|
||||
return synthesize_native(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='为什么合格率下降', evidence=evidence(), cancel_event=threading.Event(),
|
||||
context={'_agentTask': {'executionMode': 'native_agent'}}, native_answer=draft, opener=provider, **kwargs)
|
||||
|
||||
def verdict(self, payload, **change):
|
||||
return {'reviews': [{'sourceId': block['sourceId'], 'role': 'core' if i == 0 else 'key_evidence',
|
||||
'factIds': ['F1'], 'supported': True, 'statisticalClaimsSupported': True, **change}
|
||||
for i, block in enumerate(payload['draftBlocks'])], 'missingGoalDescriptions': [], 'visualIds': []}
|
||||
|
||||
def test_finished_native_draft_has_one_review_and_preserves_markdown(self):
|
||||
calls = []
|
||||
draft = '本期综合合格率95.00%,低于基期96.00%。\n\n## 对比\n\n| 期间 | 综合合格率 |\n|---|---|\n| 本期 | 95.00% |\n| 基期 | 96.00% |'
|
||||
def provider(request, timeout):
|
||||
body = json.loads(request.data); calls.append(body)
|
||||
payload = json.loads(body['messages'][1]['content'])
|
||||
if 'draftBlocks' not in payload:
|
||||
return response({'blocks': [{'role': 'core', 'text': '本期综合合格率95.00%。', 'factIds': ['F1']}]})
|
||||
return response(self.verdict(payload))
|
||||
result = self.invoke(draft, provider)
|
||||
self.assertEqual(len(calls), 1)
|
||||
self.assertTrue(result['evidenceSufficient'], result['missingEvidence'])
|
||||
self.assertIn('| 本期 | 95.00% |', result['answer'])
|
||||
self.assertIn('## 对比', result['answer'])
|
||||
self.assertEqual(result['compositionDiagnostics']['modelPhases'], ['native_draft_review'])
|
||||
|
||||
def test_reviewer_cannot_supply_replacement_prose(self):
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
calls.append(1); payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
if 'draftBlocks' not in payload: return response({'blocks': []})
|
||||
return response(self.verdict(payload, text='设备故障造成下降。'))
|
||||
result = self.invoke('本期综合合格率95.00%。', provider)
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertNotIn('设备故障', result['answer'])
|
||||
|
||||
def test_exact_unsupported_clause_is_deleted_without_second_model(self):
|
||||
calls = []
|
||||
draft = '本期综合合格率95.00%。设备故障造成下降。'
|
||||
def provider(request, timeout):
|
||||
calls.append(1); payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
if 'draftBlocks' not in payload: return response({'blocks': []})
|
||||
return response(self.verdict(payload, supported=False, statisticalClaimsSupported=False,
|
||||
unsupportedClauses=['设备故障造成下降。'], remainingClaimsSupported=True,
|
||||
remainingStatisticalClaimsSupported=True))
|
||||
result = self.invoke(draft, provider)
|
||||
self.assertEqual(len(calls), 1)
|
||||
self.assertTrue(result['evidenceSufficient'], result['missingEvidence'])
|
||||
self.assertNotIn('设备故障', result['answer'])
|
||||
self.assertIn('95.00%', result['answer'])
|
||||
|
||||
def test_unbound_number_stays_gap_after_one_bounded_repair(self):
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
calls.append(1); payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
if 'draftBlocks' not in payload: return response({'blocks': []})
|
||||
return response(self.verdict(payload))
|
||||
result = self.invoke('本期综合合格率99.99%。', provider)
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertNotIn('99.99%', result['answer'])
|
||||
|
||||
def test_typed_markdown_cells_keep_units_direction_and_original_rank(self):
|
||||
fact = {'id': 'F1', 'kind': 'product', 'label': '规格甲', 'rank': 1,
|
||||
'text': '第1项:规格甲;综合合格率96.00%→95.00%,下降1.00个百分点;投入重量100.00 kg。',
|
||||
'evidenceRef': 'Q00000001', 'scope': {'dimension': 'product', 'filters': {}}}
|
||||
report = {'facts': [fact], 'requiredFactIds': [], 'priorityFactIds': [], 'missingEvidence': [],
|
||||
'rejectedEvidenceRefs': [], 'notices': [], 'sections': []}
|
||||
draft = ('规格甲合格率95.00%。\n\n## 对比\n\n'
|
||||
'| 序号 | 产品 | 投入(kg) | 变化(个百分点) |\n|---|---|---|---|\n'
|
||||
'| 1 | 规格甲 | 100.00 | -1.00 |')
|
||||
def provider(request, timeout):
|
||||
payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
return response(self.verdict(payload))
|
||||
with patch('nao_native_answer.build_native_report', return_value=report):
|
||||
result = self.invoke(draft, provider)
|
||||
self.assertTrue(result['evidenceSufficient'], result['compositionDiagnostics']['issues'])
|
||||
self.assertIn('| 1 |', result['answer'])
|
||||
self.assertIn('100.00 kg', result['answer'])
|
||||
self.assertIn('-1.00个百分点', result['answer'])
|
||||
for invalid in (draft.replace('| 1 |', '| 9 |'), draft.replace('投入(kg)', '投入(吨)'),
|
||||
draft.replace('-1.00 |', '-9.00 |'), draft.replace('-1.00 |', '+1.00 |')):
|
||||
with self.subTest(invalid=invalid), patch('nao_native_answer.build_native_report', return_value=report):
|
||||
bad = self.invoke(invalid, provider)
|
||||
self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_invalid_support_and_unknown_source_ids_cannot_skip_review(self):
|
||||
for change in ({'sourceId': 'D999'}, {'supported': 'true'}, {'factIds': ['F999']}):
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
calls.append(1); payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
return response(self.verdict(payload, **change))
|
||||
result = self.invoke('综合合格率95.00%。', provider)
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
|
||||
def test_goal_gap_remains_authoritative(self):
|
||||
def provider(request, timeout):
|
||||
payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
value = self.verdict(payload)
|
||||
value['missingGoalDescriptions'] = ['重点规格尚未回答。']
|
||||
return response(value)
|
||||
result = self.invoke('综合合格率95.00%。', provider)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertIn('重点规格尚未回答。', result['missingEvidence'])
|
||||
|
||||
def test_complete_optional_table_rejection_does_not_create_a_new_goal(self):
|
||||
calls=[]
|
||||
draft='综合合格率95.00%。\n\n| 分组 | 变化 |\n|---|---|\n| 未知组甲 | -9.999个百分点 |\n| 未知组乙 | -8.888个百分点 |'
|
||||
def provider(request,timeout):
|
||||
calls.append(1);payload=json.loads(json.loads(request.data)['messages'][1]['content']);value=self.verdict(payload)
|
||||
value['reviews'][1].update(supported=False,statisticalClaimsSupported=False,
|
||||
factIds=[],unsupportedClauses=['| 未知组甲 | -9.999个百分点 |','| 未知组乙 | -8.888个百分点 |'])
|
||||
return response(value)
|
||||
result=self.invoke(draft,provider)
|
||||
self.assertEqual(len(calls),1);self.assertTrue(result['evidenceSufficient'],result['missingEvidence'])
|
||||
self.assertFalse(result['compositionDiagnostics']['formatRepairAttempted'])
|
||||
self.assertNotIn('9.999',result['answer'])
|
||||
|
||||
def test_only_core_wholly_rejected_is_business_gap_without_format_retry(self):
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
calls.append(1);payload=json.loads(json.loads(request.data)['messages'][1]['content']);value=self.verdict(payload)
|
||||
for row,source in zip(value['reviews'],payload['draftBlocks']):
|
||||
row.update(supported=False,statisticalClaimsSupported=False,unsupportedClauses=[source['text']])
|
||||
return response(value)
|
||||
result=self.invoke('综合合格率95.00%。',provider)
|
||||
self.assertEqual(len(calls),1);self.assertFalse(result['evidenceSufficient'])
|
||||
self.assertFalse(result['compositionDiagnostics']['formatRepairAttempted'])
|
||||
self.assertEqual(result['compositionDiagnostics']['issues'],[])
|
||||
self.assertTrue(any('核心分析' in gap for gap in result['missingEvidence']))
|
||||
self.assertFalse(any('格式未通过' in gap for gap in result['missingEvidence']))
|
||||
|
||||
def test_complete_optional_multisentence_rejection_needs_no_remainder_flags(self):
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
calls.append(1);payload=json.loads(json.loads(request.data)['messages'][1]['content']);value=self.verdict(payload)
|
||||
value['reviews'][1].update(role='detail',supported=False,statisticalClaimsSupported=False,
|
||||
unsupportedClauses=['未知指标99.99%。','设备故障导致下降。'])
|
||||
return response(value)
|
||||
result=self.invoke('综合合格率95.00%。\n\n未知指标99.99%。设备故障导致下降。',provider)
|
||||
self.assertEqual(len(calls),1);self.assertTrue(result['evidenceSufficient'],result['missingEvidence'])
|
||||
self.assertNotIn('设备故障',result['answer'])
|
||||
|
||||
def test_uncited_optional_layout_does_not_force_full_review_retry(self):
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
calls.append(1);payload=json.loads(json.loads(request.data)['messages'][1]['content']);value=self.verdict(payload)
|
||||
value['reviews'][1].update(role='detail',factIds=[])
|
||||
return response(value)
|
||||
result=self.invoke('综合合格率95.00%。\n\n### 结论\n\n数据支持的优先排查方向是:',provider)
|
||||
self.assertEqual(len(calls),1);self.assertTrue(result['evidenceSufficient'],result['missingEvidence'])
|
||||
self.assertEqual(result['compositionDiagnostics']['omittedDraftLayoutBlocks'],['D2'])
|
||||
|
||||
def test_whole_optional_unsupported_block_is_removed_but_core_is_a_gap(self):
|
||||
calls = []
|
||||
def provider(request, timeout):
|
||||
calls.append(1); payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
value = self.verdict(payload)
|
||||
value['reviews'][1].update(role='detail', supported=False, statisticalClaimsSupported=False,
|
||||
unsupportedClauses=[payload['draftBlocks'][1]['text']])
|
||||
return response(value)
|
||||
result = self.invoke('综合合格率95.00%。\n\n未知指标99.99%。', provider)
|
||||
self.assertEqual(len(calls), 1)
|
||||
self.assertTrue(result['evidenceSufficient'], result['missingEvidence'])
|
||||
self.assertNotIn('99.99%', result['answer'])
|
||||
def unsupported_core(request, timeout):
|
||||
payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
return response(self.verdict(payload, supported=False, statisticalClaimsSupported=False))
|
||||
result = self.invoke('综合合格率95.00%。', unsupported_core)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
|
||||
def test_cancellation_prevents_any_draft_review(self):
|
||||
from nao_evidence_finalizer import FinalizationUnavailable
|
||||
cancelled = threading.Event(); cancelled.set()
|
||||
with self.assertRaises(FinalizationUnavailable):
|
||||
synthesize_native(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='质量变化', evidence=evidence(), cancel_event=cancelled,
|
||||
native_answer='综合合格率95.00%。', opener=lambda *args, **kwargs: self.fail('model called'))
|
||||
|
||||
def test_citation_format_is_normalized_only_when_bound_to_real_source(self):
|
||||
def provider(request, timeout):
|
||||
payload = json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
return response(self.verdict(payload))
|
||||
result = self.invoke('综合合格率95.00%。[Q00000001]', provider)
|
||||
self.assertTrue(result['evidenceSufficient'])
|
||||
self.assertEqual(result['answer'].count('[Q00000001]'), 1)
|
||||
result = self.invoke('综合合格率95.00%。[Q99999999]', provider)
|
||||
self.assertFalse(result['evidenceSufficient'])
|
||||
|
||||
|
||||
if __name__ == '__main__': unittest.main()
|
||||
@@ -0,0 +1,81 @@
|
||||
"""A preceding measure may dominate examples, never a token's own field."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
from nao_native_contract import native_span_structure
|
||||
|
||||
class ExamplePredicateStructureTests(unittest.TestCase):
|
||||
def locate(self,text,token):
|
||||
start=text.index(token);return native_span_structure(text).locate(start,start+len(token))
|
||||
|
||||
def test_actual_repair_example_inherits_only_the_measure(self):
|
||||
text=('- 9月Top名单各规格亮片报废重量均高于黑片,例如 {{I13}} 为亮片 {{N115}} kg、黑片 {{N114}} kg,'
|
||||
'{{I8}} 为亮片 {{N65}} kg、黑片 {{N64}} kg;8月Top名单中 {{I11}} 则以黑片 {{N82}} kg 高于亮片 {{N83}} kg。')
|
||||
for token,stage in [('N115','bright'),('N114','black'),('N65','bright'),('N64','black'),('N82','black'),('N83','bright')]:
|
||||
location=self.locate(text,'{{'+token+'}}')
|
||||
self.assertEqual(location['metricFamily'],'scrap')
|
||||
self.assertEqual(location['ownerStage'],stage)
|
||||
self.assertEqual(location['fieldAssociation']['kind'],'governing_predicate')
|
||||
self.assertEqual(location['fieldAssociation']['label'],'报废重量')
|
||||
self.assertNotIn('9月',location['fieldAssociation']['label'])
|
||||
self.assertNotIn('亮片',location['fieldAssociation']['label'])
|
||||
self.assertIn('8月',self.locate(text,'{{N82}}')['prefix'])
|
||||
|
||||
def test_actual_initial_sort_frame_governs_the_following_observation(self):
|
||||
text='**2026年9月 / 消费电子产业部 / 消费电子-3C** 按规格合计报废重量排序,{{I1}} 以 {{N9}} kg 居首,综合合格率 {{N10}}。'
|
||||
location=self.locate(text,'{{N9}}')
|
||||
self.assertEqual(location['metricFamily'],'scrap')
|
||||
self.assertEqual(location['fieldAssociation']['label'],'报废重量')
|
||||
self.assertNotIn('消费电子',location['fieldAssociation']['label'])
|
||||
self.assertIsNone(location['ownerStage'])
|
||||
self.assertEqual(self.locate(text,'{{N10}}')['metricFamily'],'rate')
|
||||
|
||||
def test_explicit_period_and_stage_do_not_inherit_from_field_frame(self):
|
||||
text='9月亮片报废重量较高,8月{{I1}}黑片{{N1}} kg。'
|
||||
location=self.locate(text,'{{N1}}')
|
||||
self.assertEqual(location['metricFamily'],'scrap')
|
||||
self.assertEqual(location['ownerStage'],'black')
|
||||
self.assertNotIn('9月',location['predicateContext'])
|
||||
self.assertNotIn('亮片',location['predicateContext'])
|
||||
|
||||
def test_local_nonmass_fields_bar_the_prior_mass_frame(self):
|
||||
for label,family in [('报废率','scrap_rate'),('报废重量占比','share'),('记录数','count')]:
|
||||
text='报废重量排序,'+label+'另述,{{I1}}以{{N1}} kg居首。'
|
||||
self.assertEqual(self.locate(text,'{{N1}}')['metricFamily'],family)
|
||||
|
||||
def test_rank_table_exposes_original_cells_and_zero_based_column(self):
|
||||
text='| 排名 | 规格 | 综合报废重量 | 综合合格率 |\n|---|---|---|---|\n| 1 | {{I1}} | {{N9}} kg | {{N10}} |'
|
||||
location=self.locate(text,'{{N9}}')
|
||||
self.assertEqual(location['columnIndex'],2)
|
||||
self.assertEqual(location['rowLabel'],'1')
|
||||
self.assertEqual([cell['text'].strip() for cell in location['rowCells']],['1','{{I1}}','{{N9}} kg','{{N10}}'])
|
||||
for cell in location['rowCells']:
|
||||
self.assertEqual(cell['text'],text[cell['start']:cell['end']])
|
||||
self.assertEqual(location['metricFamily'],'scrap')
|
||||
|
||||
def test_cells_expose_ambiguity_without_inventing_a_subject_or_field(self):
|
||||
text='| 排名 | 规格 | 其他规格 | 综合合格率 |\n|---|---|---|---|\n| 1 | {{I1}} | {{I2}} | {{N1}} |'
|
||||
location=self.locate(text,'{{N1}}')
|
||||
self.assertEqual(location['columnIndex'],3)
|
||||
self.assertEqual(location['rowLabel'],'1')
|
||||
self.assertEqual(location['metricFamily'],'rate')
|
||||
self.assertEqual(location['ownerStage'],'overall')
|
||||
self.assertEqual([cell['text'].strip() for cell in location['rowCells']][1:3],['{{I1}}','{{I2}}'])
|
||||
|
||||
def test_explicit_new_field_overrides_and_future_text_cannot_authorize(self):
|
||||
text='报废重量较高,例如{{I1}}为黑片{{N1}} kg,投入重量较低,例如{{I2}}为亮片{{N2}} kg。'
|
||||
self.assertEqual(self.locate(text,'{{N1}}')['metricFamily'],'scrap')
|
||||
self.assertEqual(self.locate(text,'{{N2}}')['metricFamily'],'input')
|
||||
future='例如{{I1}}为黑片{{N1}} kg,后面另述报废重量较高。'
|
||||
self.assertIsNone(self.locate(future,'{{N1}}')['metricFamily'])
|
||||
stopped='报废重量较高。另段例如{{I1}}为黑片{{N1}} kg。'
|
||||
self.assertIsNone(self.locate(stopped,'{{N1}}')['metricFamily'])
|
||||
|
||||
def test_rate_share_and_new_list_are_not_mass_antecedents(self):
|
||||
for label in ('报废率','报废重量占比','报废份额','记录数'):
|
||||
text=label+'较高,例如{{I1}}为黑片{{N1}} kg。'
|
||||
self.assertNotEqual(self.locate(text,'{{N1}}')['metricFamily'],'scrap')
|
||||
text='- 报废重量较高,例如{{I1}}为黑片{{N1}} kg。\n- 另述例如{{I2}}为亮片{{N2}} kg。'
|
||||
self.assertIsNone(self.locate(text,'{{N2}}')['metricFamily'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -66,8 +66,16 @@ class NativeExplorationTests(unittest.TestCase):
|
||||
'prioritySignals':{'scale':[{'key':'甲','label':'甲','current':copy.deepcopy(row['current']),
|
||||
'comparison':copy.deepcopy(row['comparison'])},{'key':'乙','current':{'rate':0.9}}]},
|
||||
'evidenceRef':'Q12345678','protocolEvidence':{'queryId':'private'},'evidencePath':'private/path'}
|
||||
view=native_model_view(source)
|
||||
self.assertEqual(view['rows'],[row]);self.assertEqual(view['totalRows'],9)
|
||||
original=copy.deepcopy(source);view=native_model_view(source)
|
||||
def without_display(value):
|
||||
if isinstance(value,list):return [without_display(item) for item in value]
|
||||
if isinstance(value,dict):return {key:without_display(item) for key,item in value.items() if key!='formalDisplay'}
|
||||
return value
|
||||
self.assertEqual(without_display(view['rows']),[row]);self.assertEqual(view['totalRows'],9)
|
||||
self.assertNotIn('formalDisplay',view['rows'][0]['current']) # Unknown is not zero.
|
||||
self.assertEqual(view['rows'][0]['comparison']['formalDisplay']['scrapWeight'],
|
||||
{'rawValue':'0','displayValue':'0.00','unit':'kg','metricRole':'scrapWeight','rawUnit':'kg','measureKind':'mass'})
|
||||
self.assertEqual(source,original)
|
||||
self.assertEqual(view['prioritySignals']['scale'][0]['sameAsReturnedRow'],'甲')
|
||||
self.assertEqual(view['prioritySignals']['scale'][1],source['prioritySignals']['scale'][1])
|
||||
self.assertNotIn('protocolEvidence',view);self.assertNotIn('evidencePath',view)
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
"""Complete Native finalizer seams for stable display, protection and omission."""
|
||||
import copy, io, json, sys, threading, unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_native_answer import build_native_report, _prepare_native_draft, _native_atomic_inventory
|
||||
from nao_native_contract import clause_catalog, selected_clause_spans, mass_display_match
|
||||
from nao_native_exploration import native_model_view
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_native_atomic_binding import NativeAtomicFullPipelineGuards
|
||||
|
||||
class GroundedNativeContractTests(unittest.TestCase):
|
||||
def fixture(self):
|
||||
docs=NativeAtomicFullPipelineGuards().documents()
|
||||
context={'_agentTask':{'executionMode':'native_agent','period':{'year':2026,'month':9},
|
||||
'comparisonPeriod':{'year':2026,'month':8},'filters':{}}}
|
||||
return docs,context
|
||||
|
||||
def invoke(self,draft,mutate=None,*,fixture=None):
|
||||
docs,context=fixture or self.fixture();calls=[]
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);calls.append(payload)
|
||||
fact=next(f['id'] for f in payload['facts'] if '黑片外废' in f['text'])
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core' if i==0 else 'key_evidence',
|
||||
'factIds':[fact],'supported':True,'statisticalClaimsSupported':True} for i,b in enumerate(payload['draftBlocks'])],
|
||||
'missingGoalDescriptions':[]}
|
||||
if mutate:mutate(value,payload)
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value,ensure_ascii=False)}}]}).encode())
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量变化',
|
||||
evidence=docs,context=context,native_answer=draft,cancel_event=threading.Event(),opener=provider)
|
||||
return final,calls
|
||||
|
||||
def test_formal_mass_normalized_before_clause_catalog_and_review(self):
|
||||
final,calls=self.invoke('9月黑片外废报废重量0.6152吨。')
|
||||
self.assertTrue(final['evidenceSufficient'],final['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),1);block=calls[0]['draftBlocks'][0]
|
||||
self.assertNotIn('吨',block['text']);self.assertIn('615.25 kg',block['text'])
|
||||
self.assertTrue(block['protectedBindings']);self.assertTrue(block['clauseCatalog'])
|
||||
self.assertTrue(all(c.get('text',block['text']) in block['text'] for c in block['clauseCatalog']))
|
||||
self.assertIn('615.25 kg',final['answer'])
|
||||
|
||||
def test_clauses_use_ids_and_semantics_can_reject_protected_numbers(self):
|
||||
def reject(value,payload):
|
||||
row=value['reviews'][0];node=next(c for c in payload['draftBlocks'][0]['clauseCatalog'] if c.get('text')=='设备故障造成下降。')
|
||||
row.update(supported=False,statisticalClaimsSupported=False,unsupportedClauseIds=[node['clauseId']],
|
||||
remainingClaimsSupported=True,remainingStatisticalClaimsSupported=True)
|
||||
final,calls=self.invoke('9月黑片外废报废重量0.6152吨。设备故障造成下降。',reject)
|
||||
self.assertTrue(final['evidenceSufficient'],final['missingEvidence']);self.assertEqual(len(calls),1)
|
||||
self.assertNotIn('设备故障',final['answer'])
|
||||
def veto(value,payload):
|
||||
row=value['reviews'][0];row.update(supported=False,statisticalClaimsSupported=False,
|
||||
unsupportedClauseIds=[next(c['clauseId'] for c in payload['draftBlocks'][0]['clauseCatalog'] if c['kind']=='block')])
|
||||
final,calls=self.invoke('9月黑片外废报废重量0.6152吨。',veto)
|
||||
self.assertFalse(final['evidenceSufficient']);self.assertEqual(len(calls),1)
|
||||
|
||||
def test_review_cannot_swap_protected_numeric_binding(self):
|
||||
def swap(value,payload):
|
||||
protected=payload['draftBlocks'][0]['protectedBindings'][0]
|
||||
other=next(key for key,item in payload['bindingCatalog'].items() if key.startswith('N') and item['factId']!=protected['factId'])
|
||||
value['reviews'][0]['bindings']=[{'span':protected['span'],'tokenId':other}]
|
||||
final,calls=self.invoke('9月黑片外废报废重量0.6152吨。',swap)
|
||||
self.assertFalse(final['evidenceSufficient']);self.assertEqual(len(calls),2)
|
||||
|
||||
def test_explicit_company_scope_never_inherits_a_department_root(self):
|
||||
docs,context=self.fixture();context['_agentTask']['filters']={'department':'部门甲'}
|
||||
docs[0]['result']['filterBinding']={'department':'部门甲'}
|
||||
for owner in ('全公司','全厂'):
|
||||
final,_=self.invoke('9月'+owner+'黑片外废报废重量0.6152吨。',fixture=(docs,context))
|
||||
self.assertFalse(final['evidenceSufficient']);self.assertNotIn(owner+'黑片外废报废重量615.25',final['answer'])
|
||||
final,calls=self.invoke('9月部门甲黑片外废报废重量0.6152吨。',fixture=(docs,context))
|
||||
self.assertTrue(final['evidenceSufficient'],final['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
|
||||
def test_fixed_nodes_allow_structural_aliases_not_inner_substrings(self):
|
||||
text='- 黑片报废615.25 kg。\n**阶段说明**(黑片下降0.3pp,亮片贡献错误):'
|
||||
nodes=clause_catalog('D1',text)
|
||||
self.assertIsNotNone(selected_clause_spans(text,{'unsupportedClauses':['黑片报废615.25 kg。']},nodes))
|
||||
self.assertIsNotNone(selected_clause_spans(text,{'unsupportedClauses':['(黑片下降0.3pp,亮片贡献错误)']},nodes))
|
||||
self.assertIsNone(selected_clause_spans(text,{'unsupportedClauses':['亮片贡献错误']},nodes))
|
||||
self.assertIsNone(selected_clause_spans(text,{'unsupportedClauseIds':['D1-forged-C1']},nodes))
|
||||
|
||||
def test_display_schema_preserves_physical_authority_and_role(self):
|
||||
raw={'kind':'quality_comparison','current':{'black':{'scrapWeight':'615.249'}},
|
||||
'stageRateChangesPP':{'bright':'-0.2382081452'},'stageDecomposition':{'brightContributionToCompositePP':'-0.2318568021'}}
|
||||
original=copy.deepcopy(raw);view=native_model_view(raw);self.assertEqual(raw,original)
|
||||
self.assertEqual(view['current']['black']['formalDisplay']['scrapWeight']['displayValue'],'615.25')
|
||||
self.assertEqual(view['stageRateChangesPP']['formalDisplay']['bright']['metricRole'],'OwnStageRateChangePp')
|
||||
self.assertEqual(view['stageDecomposition']['formalDisplay']['brightContributionToCompositePP']['metricRole'],'ContributionPp')
|
||||
token={'rawValue':'1000','value':'1,000.00','unit':'kg','metricField':'sourceWeight','rawUnit':'kg','measureKind':'mass'}
|
||||
self.assertIsNotNone(mass_display_match(token,'1','ton'))
|
||||
for change in ({'rawUnit':None},{'measureKind':None},{'metricField':'quantity'}):
|
||||
self.assertIsNone(mass_display_match({**token,**change},'1','ton'))
|
||||
|
||||
def test_unknown_units_quantity_wrong_stage_dates_and_boundaries_stay_gaps(self):
|
||||
for draft in ('9月亮片外废报废重量0.6152吨。','8月黑片外废报废重量0.6152吨。',
|
||||
'9月黑片外废数量0.6152件。','9月黑片外废报废低于0.6152吨。',
|
||||
'9月黑片外废报废重量0.6153吨。'):
|
||||
with self.subTest(draft=draft):
|
||||
final,_=self.invoke(draft);self.assertFalse(final['evidenceSufficient'])
|
||||
equal_bound,_=self.invoke('9月黑片外废报废低于0.615249吨。')
|
||||
self.assertFalse(equal_bound['evidenceSufficient'])
|
||||
final,calls=self.invoke('9月黑片外废报废至多0.615249吨。')
|
||||
self.assertTrue(final['evidenceSufficient'],final['compositionDiagnostics']['issues'])
|
||||
self.assertIn('0.615249吨',final['answer']);self.assertEqual(len(calls),1)
|
||||
|
||||
def test_whole_column_normalization_is_transactional(self):
|
||||
docs,context=self.fixture();report=build_native_report(docs,context)
|
||||
good='9月黑片报废。\n\n| 阶段 | 9月报废(吨) |\n|---|---|\n| 黑片 | 0.6152 |'
|
||||
blocks,meta=_prepare_native_draft(good,report['facts'],context)
|
||||
table=blocks[1]['text'];self.assertIn('(kg)',table);self.assertIn('615.25',table);self.assertNotIn('吨',table)
|
||||
bad=good+'\n| 亮片 | 99.999 |'
|
||||
blocks,_=_prepare_native_draft(bad,report['facts'],context)
|
||||
self.assertIn('(吨)',blocks[1]['text']);self.assertIn('0.6152',blocks[1]['text'])
|
||||
|
||||
def test_wrong_pp_role_never_borrows_own_stage_change(self):
|
||||
docs,context=self.fixture();report=build_native_report(docs,context)
|
||||
base={'id':'F100','text':'亮片自身合格率下降0.24个百分点。','kind':'stage','label':'亮片合格率',
|
||||
'evidenceRef':'Q00000001','scope':{'period':context['_agentTask']['period'],
|
||||
'comparisonPeriod':context['_agentTask']['comparisonPeriod'],'filters':{}},
|
||||
'verifiedNativeNumericValues':[{'sourceOrdinal':0,'displayValue':'0.24','unit':'pp','rawValue':'0.2382081452',
|
||||
'period':context['_agentTask']['period'],'metricField':'rateChange','stageHint':'亮片','ownerScope':{},'metricRole':'OwnStageRateChangePp'}]}
|
||||
contribution=copy.deepcopy(base);contribution.update(id='F101',text='亮片对综合的贡献-0.23个百分点。',label='阶段拆解')
|
||||
contribution['verifiedNativeNumericValues']=[{**base['verifiedNativeNumericValues'][0],'displayValue':'-0.23',
|
||||
'rawValue':'-0.2318568021','metricField':'stageContribution','metricRole':'ContributionPp'}]
|
||||
facts=[base,contribution]
|
||||
blocks,meta=_prepare_native_draft('9月亮片对综合合格率贡献-0.24个百分点。',facts,context)
|
||||
self.assertEqual(meta['protectedMetricSpans'],0)
|
||||
blocks,meta=_prepare_native_draft('9月亮片对综合合格率贡献-0.23个百分点。',facts,context)
|
||||
self.assertEqual(meta['protectedMetricSpans'],1)
|
||||
# Full finalizer still rejects a semantic review that approves the
|
||||
# wrong role. Only the provider is mocked, not the atomic validator.
|
||||
report.update(facts=facts,requiredFactIds=[],priorityFactIds=[])
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content'])
|
||||
result={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':['F100','F101'],
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']], 'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(result)}}]}).encode())
|
||||
for value,expected in [('-0.24',False),('-0.23',True)]:
|
||||
with patch('nao_native_answer.build_native_report',return_value=report):
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量',
|
||||
evidence=docs,context=context,native_answer='9月亮片对综合合格率贡献'+value+'个百分点。',
|
||||
cancel_event=threading.Event(),opener=provider)
|
||||
self.assertEqual(final['evidenceSufficient'],expected,final['compositionDiagnostics']['issues'])
|
||||
with patch('nao_native_answer.build_native_report',return_value=report):
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量',
|
||||
evidence=docs,context=context,native_answer='9月亮片对黑片合格率贡献-0.23个百分点。',
|
||||
cancel_event=threading.Event(),opener=provider)
|
||||
self.assertFalse(final['evidenceSufficient'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,25 @@
|
||||
"""Nonsemantic Markdown layout cannot consume a semantic-review source slot."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
from nao_native_answer import _native_draft_blocks,NativeCompositionError
|
||||
|
||||
class NativeLayoutCapacityTests(unittest.TestCase):
|
||||
def test_thematic_breaks_preserve_markdown_order_without_source_slots(self):
|
||||
parts=['## 正式分析']
|
||||
for i in range(21):parts.extend(['第'+str(i)+'段正式业务内容。',('---','* * *','___')[i%3]])
|
||||
draft='\n\n'.join(parts);blocks=_native_draft_blocks(draft)
|
||||
self.assertEqual(len(blocks),21)
|
||||
self.assertEqual([b['sourceId'] for b in blocks],['D'+str(i+1) for i in range(21)])
|
||||
self.assertEqual('\n\n'.join(b['text'] for b in blocks),draft)
|
||||
def test_table_separator_and_actual_semantic_capacity_remain_strict(self):
|
||||
table='| 项目 | 数值 |\n|---|---:|\n| 正式值 | 1.23 |'
|
||||
self.assertEqual(_native_draft_blocks(table)[0]['text'],table)
|
||||
for draft in ('\n\n'.join('正文'+str(i) for i in range(25)), '正文'+'字'*2200,
|
||||
'\n\n'.join('-*-' for _ in range(25))):
|
||||
with self.subTest(draft=draft[:30]):
|
||||
with self.assertRaises(NativeCompositionError):_native_draft_blocks(draft)
|
||||
def test_layout_only_cannot_become_a_business_answer(self):
|
||||
with self.assertRaises(NativeCompositionError):_native_draft_blocks('## 标题\n\n---\n\n* * *')
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,72 @@
|
||||
"""History display mirrors cannot issue values or replace authorization scopes."""
|
||||
import copy
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
from nao_native_answer import (_model_fact_view,_model_history_source_goals,_binding_inventory,
|
||||
_bind_literal_measures,_validate_blocks,_review_blocks,NativeCompositionError)
|
||||
|
||||
|
||||
class NativeModelPresentationTests(unittest.TestCase):
|
||||
def fact(self):
|
||||
return {'id':'F1','label':'已确认历史事实','kind':'history','evidenceRef':'Q00000001',
|
||||
'text':'原始报废重量10.00 kg。','scope':{'period':{'year':2026,'month':9},'filters':{'department':'产业部甲'},
|
||||
'stage':'black','dimension':'group','sourceTurnId':'private-owner','metricContextId':'metric-context-1'},
|
||||
'validity':{'verified':True,'basis':'protocol_history_snapshot'},
|
||||
'modelText':'2026年9月 / 产业部 产业部甲:报废重量10.00 kg。',
|
||||
'modelScope':{'displayScope':'产业部 产业部甲','stageLabel':'黑片','dimensionLabel':'业务分组'}}
|
||||
|
||||
def test_verified_mirror_changes_only_model_view(self):
|
||||
fact=self.fact();original=copy.deepcopy(fact)
|
||||
views,scopes=_model_fact_view([fact])
|
||||
self.assertEqual(views[0]['text'],fact['modelText']);self.assertEqual(scopes[0]['displayScope'],'产业部 产业部甲')
|
||||
self.assertNotIn('filters',scopes[0]);self.assertNotIn('sourceTurnId',scopes[0]);self.assertEqual(fact,original)
|
||||
self.assertEqual(scopes[0]['metricContextId'],'metric-context-1')
|
||||
fact['modelText']='报废重量999.00 kg。'
|
||||
with self.assertRaises(NativeCompositionError):
|
||||
_validate_blocks(_bind_literal_measures({'blocks':[{'role':'core','text':'报废重量999.00 kg。','factIds':['F1']}]},
|
||||
_binding_inventory([fact]),{}),[fact],_binding_inventory([fact]))
|
||||
|
||||
def test_unsigned_or_wrong_scope_mirror_cannot_replace_authority(self):
|
||||
for change in ({'validity':{'verified':False,'basis':'protocol_history_snapshot'}},
|
||||
{'validity':{'verified':True,'basis':'quality_comparison'}},
|
||||
{'modelScope':{'displayScope':'全公司'}},
|
||||
{'modelScope':{'displayScope':'产业部甲','filters':{'department':'全公司'}}}):
|
||||
with self.subTest(change=change):
|
||||
fact={**self.fact(),**change};views,scopes=_model_fact_view([fact])
|
||||
self.assertEqual(views[0]['text'],fact['text']);self.assertEqual(scopes[0]['filters'],{'department':'产业部甲'})
|
||||
fact=self.fact();fact['modelScope'].update(period={'year':2025},stageLabel='亮片',scopeId='forged')
|
||||
_,scopes=_model_fact_view([fact])
|
||||
self.assertEqual(scopes[0]['period'],{'year':2026,'month':9});self.assertEqual(scopes[0]['stageLabel'],'黑片')
|
||||
self.assertEqual(scopes[0]['scopeId'],'scope-1')
|
||||
other=copy.deepcopy(fact);other.update(id='F2');other['scope']['sourceTurnId']='other-private-owner'
|
||||
views,scopes=_model_fact_view([fact,other]);self.assertEqual(len(scopes),2)
|
||||
self.assertNotEqual(views[0]['scopeId'],views[1]['scopeId'])
|
||||
|
||||
def test_native_without_mirror_has_identical_model_scope_and_text(self):
|
||||
fact=self.fact();fact.pop('modelText');fact.pop('modelScope');fact['validity']['basis']='quality_comparison'
|
||||
views,scopes=_model_fact_view([fact])
|
||||
self.assertEqual(views[0]['text'],fact['text']);self.assertEqual(scopes[0],{'scopeId':'scope-1',**fact['scope']})
|
||||
|
||||
def test_review_uses_sanitized_history_goals_without_mutating_internal_goals(self):
|
||||
fact=self.fact();raw=[{'goal':'汇总历史','filters':{'department':'产业部甲'}}]
|
||||
displayed=[{'goal':'汇总历史','scopeLabel':'产业部 产业部甲'}]
|
||||
context={'_autonomousAnswer':True,'_historySourceGoals':copy.deepcopy(raw),'_historyModelSourceGoals':displayed}
|
||||
captured=[]
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);captured.append(payload)
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps({
|
||||
'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]})}}]}).encode())
|
||||
_review_blocks([{'index':0,'text':'报废重量10.00 kg。','factIds':['F1'],'evidenceRefs':['Q00000001'],'verbatim':False,'claimType':'observation'}],
|
||||
[fact],connection=('https://offline.invalid','fixture','fixture'),cancel_event=threading.Event(),opener=provider,
|
||||
raw_responses=[],usages=[],diagnostics={'issues':[]},context=context)
|
||||
self.assertEqual(captured[0]['historySourceGoals'],displayed);self.assertEqual(context['_historySourceGoals'],raw)
|
||||
unsigned=copy.deepcopy(fact);unsigned['validity']['verified']=False
|
||||
self.assertEqual(_model_history_source_goals(context,[unsigned]),raw)
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,99 @@
|
||||
"""No-draft formatting preserves real Markdown structure and scoped rank counts."""
|
||||
import copy
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
sys.path[:0] = [str(Path(__file__).resolve().parents[1] / 'scripts'), str(Path(__file__).parent)]
|
||||
from nao_native_answer import NativeCompositionError, _validate_blocks
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_agent_answer import evidence
|
||||
from test_native_content_title import response
|
||||
|
||||
|
||||
class NoDraftStructureTests(unittest.TestCase):
|
||||
def test_short_lead_with_later_markdown_survives_full_composition_and_summary(self):
|
||||
for detail in ['\n'.join(['- 各组织分别保留正式期间、业务范围和重点表格。'] * 18),
|
||||
'\n\n'.join(['各组织分别保留正式期间、业务范围和重点表格。'] * 18)]:
|
||||
calls = []
|
||||
text = '综合合格率95.00%。\n\n' + detail
|
||||
def provider(request, timeout):
|
||||
body = json.loads(request.data); calls.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews': [{'supported': True, 'statisticalClaimsSupported': True}],
|
||||
'missingGoalDescriptions': []})
|
||||
return response({'blocks': [{'role': 'core', 'text': text, 'factIds': ['F1']}]})
|
||||
result = synthesize_native(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='合格率分析', evidence=evidence(), cancel_event=threading.Event(), opener=provider,
|
||||
context={'_agentTask': {'kind': 'analysis', 'executionMode': 'native_agent'}})
|
||||
self.assertTrue(result['evidenceSufficient'], result['compositionDiagnostics'])
|
||||
self.assertEqual(len(calls), 2)
|
||||
self.assertFalse(result['compositionDiagnostics']['formatRepairAttempted'])
|
||||
self.assertIn(detail, result['answer'])
|
||||
|
||||
def test_lead_limit_checks_the_first_paragraph_and_keeps_later_list(self):
|
||||
facts = [{'id': 'F1', 'text': '已确认的正式结果。', 'kind': 'overall',
|
||||
'label': '正式结果', 'evidenceRef': 'Q00000001'}]
|
||||
for separator in ['\n\n', '\n']:
|
||||
text = '各范围的报废表现应分别解读。' + separator + '\n'.join(
|
||||
['- 保留各自期间、组织范围和正式口径,重点表格紧随对应结论。'] * 15)
|
||||
with self.subTest(separator=separator):
|
||||
blocks, selected = _validate_blocks({'blocks': [{'role': 'core', 'text': text,
|
||||
'factIds': ['F1']}]}, facts, {})
|
||||
self.assertEqual(blocks[0]['text'], text)
|
||||
self.assertEqual(selected, ['F1'])
|
||||
with self.assertRaisesRegex(NativeCompositionError, '首段过长'):
|
||||
_validate_blocks({'blocks': [{'role': 'core', 'text': '结论' * 170,
|
||||
'factIds': ['F1']}]}, facts, {})
|
||||
|
||||
def test_top_count_uses_the_verified_group_without_combining_other_scopes(self):
|
||||
facts = [{'id': 'F' + str(i), 'text': '已确认规格表现。', 'kind': 'product',
|
||||
'label': '规格' + chr(64 + i), 'evidenceRef': 'history-row-' + str(i),
|
||||
'rank': i, 'rankGroupKey': 'source-a/section-0'} for i in range(1, 6)]
|
||||
def validate(count, selected=facts):
|
||||
return _validate_blocks({'blocks': [{'role': 'core', 'text': '保留产品Top' + str(count) + '。',
|
||||
'factIds': [fact['id'] for fact in selected]}]}, selected, {})
|
||||
self.assertEqual(validate(5)[0][0]['text'], '保留产品Top5。')
|
||||
with self.assertRaises(NativeCompositionError): validate(6)
|
||||
mismatched = copy.deepcopy(facts)
|
||||
mismatched[-1]['rankGroupKey'] = 'source-b/section-0'
|
||||
with self.assertRaises(NativeCompositionError): validate(5, mismatched)
|
||||
other = [{**fact, 'id': 'F' + str(index + 6), 'rankGroupKey': 'source-b/section-0',
|
||||
'evidenceRef': 'other-history-row-' + str(index)} for index, fact in enumerate(facts)]
|
||||
full_pool = facts + other
|
||||
with self.assertRaises(NativeCompositionError):
|
||||
_validate_blocks({'blocks': [{'role': 'core', 'text': '本次产品Top5依次如下。',
|
||||
'factIds': ['F1', 'F2', 'F8', 'F9', 'F10']}]}, full_pool, {})
|
||||
|
||||
def test_partial_scope_title_joins_bounded_metadata_repair_and_keeps_verified_body(self):
|
||||
calls, generation = [], []
|
||||
def provider(request, timeout):
|
||||
body = json.loads(request.data); calls.append(body)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
return response({'reviews': [{'supported': True, 'statisticalClaimsSupported': True}],
|
||||
'missingGoalDescriptions': []})
|
||||
generation.append(body)
|
||||
guide = json.loads(body['messages'][1]['content'])['reportTitleGuide']
|
||||
self.assertEqual(guide['excludedScopeLabels'], ['产业部甲'])
|
||||
if len(generation) == 2:
|
||||
self.assertIn('titleMetadataOnlyRepair', body['messages'][-1]['content'])
|
||||
return response({'reportTitle': '2026年8—9月合格率变化'})
|
||||
return response({'reportTitle': '产业部甲质量变化', 'blocks': [{'role': 'core',
|
||||
'text': '综合合格率95.00%。', 'factIds': ['F1']}]})
|
||||
result = synthesize_native(base_url='https://offline.invalid/v1', api_key='fixture', model='fixture',
|
||||
question='汇总合格率变化', evidence=evidence(), cancel_event=threading.Event(), opener=provider,
|
||||
context={'_agentTask': {'kind': 'report', 'executionMode': 'native_agent'},
|
||||
'_historyTitleExcludedScopeLiterals': ['产业部甲']})
|
||||
self.assertEqual(len(calls), 3)
|
||||
self.assertEqual(len(generation), 2)
|
||||
self.assertTrue(result['bodyEvidenceSufficient'])
|
||||
self.assertTrue(result['titleValid'])
|
||||
self.assertTrue(result['evidenceSufficient'])
|
||||
self.assertEqual(result['reportTitle'], '2026年8—9月合格率变化')
|
||||
self.assertIn('95.00%', result['answer'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,29 @@
|
||||
"""The original issued binding input is internal, fixed and connection-free."""
|
||||
import io,json,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from test_agent_answer import evidence
|
||||
|
||||
class PrivateBindingInputTests(unittest.TestCase):
|
||||
def test_original_token_ordinals_are_frozen_without_connection_or_context(self):
|
||||
captured=[];secret='must-not-copy-connection-secret'
|
||||
def provider(request,timeout):
|
||||
payload=json.loads(json.loads(request.data)['messages'][1]['content']);captured.append(payload)
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':['F1'],
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']], 'missingGoalDescriptions':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value)}}]}).encode())
|
||||
final=synthesize_native(base_url='https://'+secret+'.invalid',api_key=secret,model='fixture',question='分析',
|
||||
evidence=evidence(),context={'_agentTask':{'executionMode':'native_agent'},'authority':{'credential':secret}},
|
||||
native_answer='综合合格率95.00%。',cancel_event=threading.Event(),opener=provider)
|
||||
private=final['_privateBindingInput']
|
||||
self.assertEqual(set(private),{'facts','bindingInventory','requiredFactIds','priorityFactIds','modelScopes'})
|
||||
self.assertNotIn(secret,json.dumps(private,ensure_ascii=False))
|
||||
for key,item in captured[0]['bindingCatalog'].items():
|
||||
self.assertEqual(private['bindingInventory'][key]['value'],item['value'])
|
||||
self.assertEqual(private['bindingInventory'][key]['factId'],item['factId'])
|
||||
self.assertFalse(any(token.get('nativeAtomicAuthorized') for token in private['bindingInventory'].values()))
|
||||
self.assertNotIn('_privateBindingInput',final['compositionDiagnostics'])
|
||||
self.assertNotIn('_privateBindingInput',final.get('readingSummary') or {})
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,50 @@
|
||||
"""Pre-issuance packing preserves required identities and never raises budgets."""
|
||||
import copy,json,sys,unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
import nao_native_answer as n
|
||||
|
||||
class NativeReviewPackingTests(unittest.TestCase):
|
||||
def report(self):
|
||||
facts=[{'id':'F'+str(i),'label':'事实对象','kind':'product','text':'正式事实'+chr(64+i),'evidenceRef':'Q'+str(i).zfill(8),
|
||||
'scope':{'period':{'year':2026,'month':9},'filters':{}}} for i in range(1,8)]
|
||||
return {'facts':facts,'requiredFactIds':[],'priorityFactIds':[],'scopes':[],'sections':[],
|
||||
'notices':[],'missingEvidence':[],'rejectedEvidenceRefs':[]}
|
||||
def fit(self,report,retained):
|
||||
def messages(sources,facts,*args):return [{'role':'user','content':'x'*(100+150*len(facts))}]
|
||||
with patch.object(n,'_native_present_sources',return_value=[]),patch.object(n,'_native_draft_review_messages',side_effect=messages):
|
||||
return n._fit_native_review_pool(report,report['facts'],[],'分析',{}, {},retained,max_input=1000,repair_reserve=200)
|
||||
def test_measured_size_removes_only_optional_tail_and_keeps_full_input_immutable(self):
|
||||
report=self.report();original=copy.deepcopy(report)
|
||||
selected,metadata=self.fit(report,{'F1','F2','F4'})
|
||||
self.assertEqual([f['id'] for f in selected['facts']],['F1','F2','F3','F4'])
|
||||
self.assertTrue(metadata['fitsWithRepairReserve']);self.assertTrue(metadata['protectedAndRequiredRetained'])
|
||||
self.assertEqual(metadata['messageChars'],700);self.assertEqual(report,original)
|
||||
def test_required_set_over_capacity_is_reported_not_dropped(self):
|
||||
report=self.report();selected,metadata=self.fit(report,{f['id'] for f in report['facts']})
|
||||
self.assertFalse(metadata['fitsWithRepairReserve']);self.assertEqual(selected['facts'],report['facts'])
|
||||
self.assertTrue(metadata['protectedAndRequiredRetained'])
|
||||
def test_selector_retains_required_priority_proven_root_and_each_scope(self):
|
||||
report=self.report();report['facts']=report['facts'][:5]
|
||||
report['facts'][0].update(kind='overall',label='综合合格率')
|
||||
report['facts'][3]['scope']={'period':{'year':2026,'month':8},'filters':{'department':'部门甲'}}
|
||||
report['facts'][4]['scope']=copy.deepcopy(report['facts'][3]['scope'])
|
||||
report['requiredFactIds']=['F2'];report['priorityFactIds']=['F3'];seen=[]
|
||||
def fit(report,full,sources,question,context,aliases,retained):
|
||||
seen.append(retained);return report,{'fitsWithRepairReserve':True}
|
||||
with patch.object(n,'_fit_native_review_pool',side_effect=fit):
|
||||
selected,full,metadata=n._select_fact_pool(report,'分析',{'_agentTask':{'filters':{}}},
|
||||
[{'sourceId':'D1','text':'草稿正文'}],['F5'])
|
||||
self.assertTrue({'F1','F2','F3','F5'}<=seen[0]);self.assertEqual(len(full),5)
|
||||
def test_model_diagnostic_compaction_preserves_internal_reason_and_full_policy(self):
|
||||
facts=self.report()['facts'][:1];sources=n._native_draft_blocks('尚无来源的值98765 kg。')
|
||||
catalog=n._native_binding_catalog(facts,sources);internal=n._native_binding_issues(sources,catalog,facts)
|
||||
messages=n._native_draft_review_messages(sources,facts,'分析',{},n.METRIC_SEMANTICS)
|
||||
shown=json.loads(messages[1]['content'])['bindingIssues']
|
||||
self.assertEqual([(x['sourceId'],x['span']) for x in shown],[(x['sourceId'],x['span']) for x in internal])
|
||||
self.assertEqual(set(shown[0]),set(internal[0]));self.assertLess(len(shown[0]['issue']),len(internal[0]['issue']))
|
||||
self.assertEqual(internal[0]['issue'],n._NATIVE_TYPED_VALUE_GAP)
|
||||
self.assertIn('Decimal固定1000',messages[0]['content']);self.assertIn('比较阈值须逐主体按正式原值',messages[0]['content'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -43,6 +43,24 @@ def document(ref, *proofs):
|
||||
|
||||
|
||||
class NativeRunTests(unittest.TestCase):
|
||||
def test_optional_scope_notice_is_shown_once_without_internal_visual_diagnostics(self):
|
||||
child = {**self.task, 'stages': ['bright']}
|
||||
self.snapshot['scopes'].append({'nodeId': 'bright-detail', 'scopeId': 'bright-detail',
|
||||
'purpose': 'defects', 'label': '基础范围', 'task': child})
|
||||
self.snapshot['scopeCoverage'].append({'nodeId': 'bright-detail', 'scopeId': 'bright-detail',
|
||||
'complete': False})
|
||||
self.snapshot['explorationWarnings'] = ['基础范围来源细分缺陷尚未完整覆盖所选阶段和期间']
|
||||
self.visuals.return_value = {'visualState': 'ready', 'visuals': [{'id': 'main-chart'}],
|
||||
'missingEvidence': ['节点bright-detail范围基础范围缺少bright来源具体缺陷重量图。']}
|
||||
result = self.invoke()
|
||||
self.assertEqual(result['status'], 'COMPLETED')
|
||||
self.assertEqual(result['readingSummary']['notices'],
|
||||
['亮片细分缺陷尚未完整核实:当前范围;未用于已核实结论。'])
|
||||
self.assertNotIn('调查局限', result['answer'])
|
||||
self.assertNotIn('bright', result['answer'])
|
||||
stored = json.loads((self.actor_root / 'private/native-warning-diagnostics.json').read_text())
|
||||
self.assertIn('bright', stored['visualWarnings'][0])
|
||||
|
||||
def test_full_facts_remain_private_instead_of_being_appended_to_the_business_answer(self):
|
||||
self.final['fullEvidenceFacts'] = [{'text': '后台保留的完整统计事实', 'evidenceRef': 'Q00000001'}]
|
||||
result = self.invoke()
|
||||
@@ -51,6 +69,17 @@ class NativeRunTests(unittest.TestCase):
|
||||
stored = json.loads((self.actor_root / 'private/native-full-evidence-facts.json').read_text())
|
||||
self.assertEqual(stored, self.final['fullEvidenceFacts'])
|
||||
|
||||
def test_issued_binding_catalog_remains_private_for_exact_replay(self):
|
||||
issued = {'bindingInventory': {'N17': {'factId': 'F2', 'value': '493.9966', 'unit': 'kg'}},
|
||||
'facts': [{'id': 'F2', 'rawValue': '493.99660000'}]}
|
||||
self.final['_privateBindingInput'] = issued
|
||||
result = self.invoke()
|
||||
stored = json.loads((self.actor_root / 'private/native-composition.json').read_text())
|
||||
self.assertEqual(stored['bindingInput'], issued)
|
||||
self.assertNotIn('_privateBindingInput', result)
|
||||
self.assertNotIn('bindingInput', result)
|
||||
self.assertNotIn('bindingInventory', json.dumps(self.events, ensure_ascii=False))
|
||||
|
||||
def setUp(self):
|
||||
self.folder = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.folder.cleanup)
|
||||
@@ -253,7 +282,7 @@ class NativeRunTests(unittest.TestCase):
|
||||
self.synthesis.assert_not_called()
|
||||
self.visuals.assert_not_called()
|
||||
|
||||
def test_auto_visual_failure_stays_in_appendix_but_required_visual_failure_is_partial(self):
|
||||
def test_auto_visual_failure_has_one_business_notice_and_required_failure_remains_partial(self):
|
||||
self.visuals.return_value = {'visualState': 'failed', 'visuals': [],
|
||||
'missingEvidence': ['图表尚未完整生成,可独立恢复。',
|
||||
'queryPlan共有15张图表,超过12张呈现上限,已截取前12张;结果为部分完成。']}
|
||||
@@ -262,12 +291,14 @@ class NativeRunTests(unittest.TestCase):
|
||||
self.task['visualPreference'] = preference
|
||||
result = self.invoke()
|
||||
self.assertEqual(result['status'], expected)
|
||||
self.assertIn('图表尚未完整生成,可独立恢复。', result['answer'])
|
||||
if preference == 'auto':
|
||||
self.assertNotIn('图表尚未完整生成,可独立恢复。', result['readingSummary']['notices'])
|
||||
self.assertNotIn('图表尚未完整生成,可独立恢复。', result['answer'])
|
||||
self.assertNotIn('结果为部分完成', result['answer'])
|
||||
self.assertIn('共有15张图表', result['answer'])
|
||||
self.assertNotIn('共有15张图表', result['answer'])
|
||||
self.assertEqual(result['readingSummary']['notices'],
|
||||
['部分重点图表未能完整展示;已保留核实文字和表格。'])
|
||||
else:
|
||||
self.assertIn('图表尚未完整生成,可独立恢复。', result['answer'])
|
||||
self.assertIn('图表尚未完整生成,可独立恢复。', result['readingSummary']['notices'])
|
||||
self.assertIn('结果为部分完成', result['answer'])
|
||||
|
||||
|
||||
@@ -0,0 +1,146 @@
|
||||
"""Structural invariants, independently of numerical equality or model choice."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_native_contract import native_span_structure,native_document_ancestors,rebase_native_bindings,heading_subject
|
||||
from nao_native_answer import (_native_span_slots,_native_draft_candidate,NativeCompositionError,
|
||||
build_native_report,_prepare_native_draft,_native_present_sources,_native_atomic_inventory)
|
||||
from test_native_grounded_contract import GroundedNativeContractTests
|
||||
|
||||
class NativeStructureTests(unittest.TestCase):
|
||||
def locate(self,text,span):
|
||||
start=text.index(span);return native_span_structure(text).locate(start,start+len(span))
|
||||
|
||||
def test_future_siblings_never_change_earlier_owner_or_metric(self):
|
||||
before='黑片阶段(对综合率贡献-0.30pp,亮片约-0.15pp)'
|
||||
after=before+',组织集中在新能源汽车磁钢、汽车交通-国内。'
|
||||
for value in ('-0.30','-0.15'):
|
||||
first=self.locate(before,value);second=self.locate(after,value)
|
||||
for key in ('predicate','prefix','subjectText','inheritedText','periodRole'):
|
||||
self.assertEqual(first[key],second[key])
|
||||
self.assertNotIn('汽车交通',second['subjectText'])
|
||||
|
||||
def test_list_subject_target_and_change_parts_are_distinct_relations(self):
|
||||
text='- 黑片:率97%→96%(自身-1pp,对部门综合率贡献-0.8pp);投入10→20 kg(+10 kg),报废1→3 kg(+2 kg);其中责废+1.5 kg、料废+0.5 kg。'
|
||||
contribution=self.locate(text,'-0.8')
|
||||
self.assertEqual(contribution['ownerStage'],'black');self.assertEqual(contribution['metricTarget'],'部门综合率')
|
||||
for value in ('20','+2','+1.5','+0.5'):
|
||||
location=self.locate(text,value);self.assertEqual(location['ownerStage'],'black')
|
||||
self.assertEqual(self.locate(text,'+2')['fieldAssociation']['kind'],'change_of_pair')
|
||||
for value in ('+1.5','+0.5'):self.assertEqual(self.locate(text,value)['fieldAssociation']['kind'],'part_of_change')
|
||||
no_change=text.replace('(+2 kg)','')
|
||||
self.assertNotEqual((self.locate(no_change,'+1.5')['fieldAssociation'] or {}).get('kind'),'part_of_change')
|
||||
self.assertEqual(heading_subject('三、下钻:部门甲内部构成'),'部门甲')
|
||||
self.assertNotEqual(heading_subject('组织维度:下降集中在部门甲'),'部门甲')
|
||||
|
||||
def test_parent_predicates_and_enumerations_do_not_use_token_semantics(self):
|
||||
text='且其报废以黑片为主(黑片{{N82}}、亮片{{N83}}),投入规模为黑片{{N84}}、亮片{{N85}}'
|
||||
for token,family,stage in [('N82','scrap','black'),('N83','scrap','bright'),('N84','input','black'),('N85','input','bright')]:
|
||||
location=self.locate(text,'{{'+token+'}}')
|
||||
self.assertEqual((location['metricFamily'],location['ownerStage']),(family,stage))
|
||||
wrong=text.replace('投入规模为','报废重量为')
|
||||
self.assertEqual(self.locate(wrong,'{{N84}}')['metricFamily'],'scrap')
|
||||
self.assertEqual(self.locate(wrong,'{{N85}}')['metricFamily'],'scrap')
|
||||
|
||||
def test_ordered_header_and_from_to_bind_roles_without_using_value(self):
|
||||
table='| 部门 | 综合率(9月/8月) |\n|---|---|\n| 甲 | 95.31% / 95.90% |'
|
||||
self.assertEqual(self.locate(table,'95.31%')['periodText'],'9月')
|
||||
self.assertEqual(self.locate(table,'95.90%')['periodText'],'8月')
|
||||
reversed_header=table.replace('9月/8月','8月/9月')
|
||||
self.assertEqual(self.locate(reversed_header,'95.31%')['periodText'],'8月')
|
||||
for text in ('黑片投入从100 kg扩到200 kg。','黑片投入由100 kg降至200 kg。','黑片投入100 kg→200 kg。'):
|
||||
self.assertEqual(self.locate(text,'100')['periodRole'],'comparison')
|
||||
self.assertEqual(self.locate(text,'200')['periodRole'],'current')
|
||||
ambiguous=table.replace('95.90%','95.90% / 94.00%')
|
||||
self.assertIsNone(self.locate(ambiguous,'95.31%')['periodText'])
|
||||
|
||||
def test_only_structural_ordinals_are_masked(self):
|
||||
text='### 2. 对比2026年9月\n1. 规格127.985质量\n合格率95.2%。'
|
||||
masked=native_span_structure(text).mask_ordinals()
|
||||
self.assertNotIn('2. 对比',masked);self.assertNotIn('1. 规格',masked)
|
||||
for literal in ('2026年9月','127.985','95.2%'):self.assertIn(literal,masked)
|
||||
|
||||
def test_nearest_prior_subject_is_available_but_not_old_list(self):
|
||||
text='规格甲报废增量10 kg,另有线索:规格乙投入从100 kg到200 kg;规格丙率下降3 pp,投入50 kg。'
|
||||
located=self.locate(text,'100');self.assertNotIn('规格甲',located['inheritedText'])
|
||||
located=self.locate(text,'50');self.assertTrue(any('规格丙' in value for value in located['precedingPredicates']))
|
||||
self.assertFalse(any('规格乙' in value for value in located['precedingPredicates']))
|
||||
enumerated='规格甲(+10 kg)、规格乙(+20 kg)、规格丙(+30 kg)。'
|
||||
for name,value in [('甲','10'),('乙','20'),('丙','30')]:
|
||||
location=self.locate(enumerated,value)
|
||||
self.assertIn('规格'+name,location['inheritedText'])
|
||||
self.assertEqual(sum('规格'+other in location['inheritedText'] for other in '甲乙丙'),1)
|
||||
|
||||
def test_versions_and_explicit_ancestors_are_separate(self):
|
||||
blocks=[{'sourceId':'D1','text':'## 产业部:部门甲\n\n分组比较:'},
|
||||
{'sourceId':'D2','text':'| 分组 | 本期 |\n|---|---|\n| 分组乙 | 10 |'}]
|
||||
labels=native_document_ancestors(blocks)
|
||||
self.assertIn('产业部:部门甲',labels['D2']);self.assertIn('分组比较:',labels['D2'])
|
||||
first=native_span_structure('重量1吨。');second=native_span_structure('重量1,000.00 kg。')
|
||||
self.assertIsNot(first,second);self.assertEqual(second.locate(2,10)['prefix'],'重量')
|
||||
|
||||
def test_conflicting_authorized_parent_is_rejected_without_value_lookup(self):
|
||||
text='分组乙报废10 kg。';tokens={'N1':{'ownerScope':{'department':'部门乙','group':'分组乙'}}}
|
||||
context={'_agentTask':{'filters':{'department':'部门甲'},'period':{'year':2026,'month':9}},
|
||||
'_nativeScopeCatalog':[{'department':'部门乙','group':'分组乙'}]}
|
||||
slots=_native_span_slots(text,5,7,context,tokens,'kg')
|
||||
self.assertTrue(slots['scopeConflict'])
|
||||
|
||||
def test_deleted_bindings_are_removed_only_if_wholly_contained(self):
|
||||
text='本期95.16%。设备99.0异常。';removed=[(9,len(text))];remaining=text[:9]
|
||||
bindings=[{'span':'95.16%','tokenId':'N1'},{'span':'99.0','tokenId':'N2'}]
|
||||
self.assertEqual(rebase_native_bindings(text,remaining,bindings,removed),[{**bindings[0],'occurrence':1}])
|
||||
self.assertIsNone(rebase_native_bindings(text,remaining,[{'span':'不存在','tokenId':'N3'}],removed))
|
||||
self.assertIsNone(rebase_native_bindings(text,remaining,[{'span':'%。设备','tokenId':'N3'}],removed))
|
||||
source={'sourceId':'D1','text':text,'clauseCatalog':[]}
|
||||
row={'sourceId':'D1','role':'core','factIds':['F1'],'supported':True,'statisticalClaimsSupported':True,
|
||||
'unsupportedClauses':['设备99.0异常。'],'remainingClaimsSupported':True,'remainingStatisticalClaimsSupported':True,
|
||||
'bindings':[{'span':'99.0','tokenId':'N999'}]}
|
||||
with self.assertRaises(NativeCompositionError):_native_draft_candidate({'reviews':[row]},[source],{},tokens={'N1':{'nativeCatalogIssued':True}})
|
||||
repeated='数值10 kg。再述10 kg。'
|
||||
removed=[(0,8)];remaining=repeated[8:]
|
||||
self.assertIsNone(rebase_native_bindings(repeated,remaining,[{'span':'10','tokenId':'N1'}],removed))
|
||||
self.assertEqual(rebase_native_bindings(repeated,remaining,[{'span':'10','tokenId':'N1','occurrence':2}],removed),
|
||||
[{'span':'10','tokenId':'N1','occurrence':1}])
|
||||
|
||||
class NativeStructurePipelineTests(unittest.TestCase):
|
||||
def test_list_metrics_obey_owner_period_and_field_relationships(self):
|
||||
invoke=GroundedNativeContractTests().invoke
|
||||
draft='### 下钻:部门甲内部构成\n\n- 黑片:报废重量684.474 kg→615.249 kg(-69.225 kg);其中外废-69.225 kg。'
|
||||
docs,context=GroundedNativeContractTests().fixture();context['_agentTask']['filters']={'department':'部门甲'}
|
||||
docs[0]['result']['filterBinding']={'department':'部门甲'}
|
||||
good,calls=invoke(draft,fixture=(docs,context));self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),1)
|
||||
for wrong in (draft.replace('- 黑片:','- 亮片:'),draft.replace('684.474 kg→615.249','615.249 kg→684.474')):
|
||||
bad,_=invoke(wrong,fixture=(docs,context));self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_protected_bindings_remap_after_pool_reordering_by_fact_and_measure(self):
|
||||
docs,context=GroundedNativeContractTests().fixture();report=build_native_report(docs,context)
|
||||
sources,meta=_prepare_native_draft('9月黑片外废报废重量615.2 kg。',report['facts'],context)
|
||||
self.assertGreater(meta['protectedMetricSpans'],0)
|
||||
reordered=list(reversed(report['facts']));tokens=_native_atomic_inventory(reordered)
|
||||
presented=_native_present_sources(sources,reordered)
|
||||
for source in presented:
|
||||
self.assertEqual(len(source['protectedBindings']),len(source['_protected']) if '_protected' in source else meta['protectedMetricSpans'])
|
||||
for binding in source['protectedBindings']:
|
||||
token=tokens[binding['tokenId']]
|
||||
self.assertEqual(token['factId'],binding['factId'])
|
||||
self.assertEqual(token['metricField'],'categoryWeight');self.assertEqual(token['rawValue'],'615.249')
|
||||
|
||||
def test_ordered_table_and_prose_levels_keep_period_guards(self):
|
||||
invoke=GroundedNativeContractTests().invoke
|
||||
table='9月黑片外废报废。\n\n| 阶段 | 报废重量(9月/8月,kg) |\n|---|---|\n| 黑片外废 | 615.2 / 684.5 |'
|
||||
good,calls=invoke(table);self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),1)
|
||||
bad,_=invoke(table.replace('9月/8月','8月/9月'));self.assertFalse(bad['evidenceSufficient'])
|
||||
good,_=invoke('9月黑片外废报废重量从684.474 kg降至615.249 kg。')
|
||||
self.assertTrue(good['evidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
bad,_=invoke('9月黑片外废报废重量从615.249 kg降至684.474 kg。');self.assertFalse(bad['evidenceSufficient'])
|
||||
bad,_=invoke('8月黑片外废报废重量从684.474 kg降至615.249 kg。');self.assertFalse(bad['evidenceSufficient'])
|
||||
|
||||
def test_heading_ordinal_stays_visible_without_becoming_fact(self):
|
||||
final,calls=GroundedNativeContractTests().invoke('### 1. 关键报废\n\n9月黑片外废报废重量615.2 kg。')
|
||||
self.assertTrue(final['evidenceSufficient'],final['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
self.assertIn('### 1. 关键报废',final['answer'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,65 @@
|
||||
"""Rank/set references identify signed members before inspecting quantities."""
|
||||
import copy,sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import nao_native_answer as n
|
||||
import test_quantity_comparison_bounds as quantities
|
||||
|
||||
|
||||
class SignedSubjectReferenceTests(unittest.TestCase):
|
||||
def facts(self):
|
||||
facts=quantities.QuantityComparisonPipelineTests().history_report()['facts']
|
||||
for fact,raw,display in zip(facts,('0.9500708964391122','0.8245282495352184','0.9582524149985584'),('95.01%','82.45%','95.83%')):
|
||||
fact['text']+='综合合格率'+display+'。'
|
||||
fact['verifiedDisplayValues'].append({'metricCode':'compositeRate','rawValue':raw,'rawUnit':'ratio','unit':'percent','displayValue':display})
|
||||
return facts
|
||||
|
||||
def gate(self,text,*,facts=None,blocks=None):
|
||||
facts=facts or self.facts();tokens=n._binding_inventory(facts);diagnostics={}
|
||||
parsed={'blocks':blocks or [{'role':'core','text':text,'factIds':[fact['id'] for fact in facts]}]}
|
||||
parsed=n._complete_identifier_fact_bindings(parsed,facts,tokens,diagnostics)
|
||||
parsed=n._bind_comparison_bounds(parsed,facts,tokens,diagnostics)
|
||||
parsed=n._bind_exact_identifiers(parsed,tokens,diagnostics)
|
||||
parsed=n._bind_exact_periods(parsed,tokens,diagnostics)
|
||||
parsed=n._bind_literal_measures(parsed,tokens,diagnostics,facts=facts)
|
||||
result,_=n._validate_blocks(parsed,facts,tokens,diagnostics=diagnostics)
|
||||
return result,diagnostics
|
||||
|
||||
def test_rank_reference_uses_formal_rank_for_both_stage_values(self):
|
||||
text='### 2026年8月 / 全公司 Top3\n\n首位规格为亮片708.6324 kg、黑片446.851 kg。'
|
||||
result,_=self.gate(text)
|
||||
self.assertIn('亮片708.6324 kg、黑片446.851 kg',result[0]['text'])
|
||||
result,_=self.gate(text.replace('首位','第1位'))
|
||||
self.assertIn('第1位规格',result[0]['text'])
|
||||
|
||||
def test_complement_excludes_only_the_unambiguous_preceding_subject(self):
|
||||
text=('### 2026年8月 / 全公司 Top3\n\n规格乙综合合格率82.45%,'
|
||||
'且其黑片报废重量659.65 kg高于亮片446.4221 kg;另两项综合合格率均在95%以上。')
|
||||
result,diagnostics=self.gate(text)
|
||||
self.assertIn('另两项综合合格率均在95%以上',result[0]['text'])
|
||||
self.assertEqual(diagnostics['comparisonBoundBindings'][0]['owners'],['F1','F3'])
|
||||
changed=text+'后续规格乙另行核查。'
|
||||
_,again=self.gate(changed)
|
||||
self.assertEqual(again['comparisonBoundBindings'][0]['owners'],['F1','F3'])
|
||||
|
||||
def test_wrong_rank_stage_scope_and_explicit_name_are_not_rescued(self):
|
||||
for text in ('第4位规格为亮片708.6324 kg。','首位规格为亮片446.851 kg。',
|
||||
'首位规格规格乙为亮片446.4221 kg。','9月首位规格为亮片708.6324 kg。'):
|
||||
with self.subTest(text=text),self.assertRaises(n.NativeCompositionError):self.gate(text)
|
||||
|
||||
def test_complement_needs_a_complete_unique_antecedent_and_matching_count(self):
|
||||
for text in ('另两项综合合格率均在95%以上。',
|
||||
'规格甲综合合格率95.01%,规格乙综合合格率82.45%;另两项综合合格率均在95%以上。',
|
||||
'规格乙综合合格率82.45%;另三项综合合格率均在95%以上。'):
|
||||
with self.subTest(text=text),self.assertRaises(n.NativeCompositionError):self.gate(text)
|
||||
|
||||
def test_first_feedback_aggregates_literal_and_reference_gaps(self):
|
||||
facts=self.facts();ids=[fact['id'] for fact in facts]
|
||||
blocks=[{'role':'core','text':'另两项综合合格率均在95%以上。','factIds':ids},
|
||||
{'role':'key_evidence','text':'第4位规格为亮片708.6324 kg。','factIds':ids}]
|
||||
with self.assertRaises(n.NativeCompositionError) as caught:self.gate('',facts=facts,blocks=blocks)
|
||||
self.assertIn('blocks[0]',str(caught.exception));self.assertIn('blocks[1]',str(caught.exception))
|
||||
self.assertIn('rank_reference',str(caught.exception))
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,27 @@
|
||||
"""Deleting a signed data row preserves the surviving table's field axes."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import test_native_grounded_contract as grounded
|
||||
|
||||
class NativeTableRowDeletionTests(unittest.TestCase):
|
||||
def draft(self,header='变化(kg)',label='黑片外废',lead='9月黑片外废报废重量615.25 kg。'):
|
||||
return lead+'\n\n| 指标 | 9月报废(kg) | '+header+' |\n|---|---:|---:|\n| 不支持项 | 999 | +1 |\n| '+label+' | 615.25 | -69.23 |'
|
||||
def remove_row(self,value,payload):
|
||||
node=next(n for n in payload['draftBlocks'][1]['clauseCatalog'] if n.get('text','').startswith('| 不支持项 |'))
|
||||
value['reviews'][1].update(unsupportedClauseIds=[node['clauseId']],remainingClaimsSupported=True,remainingStatisticalClaimsSupported=True)
|
||||
def test_signed_row_deletion_keeps_point_and_delta_columns_bound(self):
|
||||
final,calls=grounded.GroundedNativeContractTests().invoke(self.draft(),self.remove_row)
|
||||
self.assertTrue(final['bodyEvidenceSufficient'],final['compositionDiagnostics']['issues']);self.assertEqual(len(calls),1)
|
||||
self.assertNotIn('不支持项',final['answer']);self.assertIn('-69.23',final['answer'])
|
||||
self.assertNotIn('|---|---:|---:|\n\n|',final['answer'])
|
||||
def test_wrong_field_period_stage_and_scope_still_reject_after_deletion(self):
|
||||
for draft in (self.draft('9月报废(kg)'),self.draft('8月变化(kg)'),self.draft(label='亮片外废')):
|
||||
with self.subTest(draft=draft):
|
||||
final,_=grounded.GroundedNativeContractTests().invoke(draft,self.remove_row);self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
fixture=grounded.GroundedNativeContractTests().fixture();fixture[1]['_agentTask']['filters']={'department':'部门甲'}
|
||||
fixture[0][0]['result']['filterBinding']={'department':'部门甲'}
|
||||
final,_=grounded.GroundedNativeContractTests().invoke(self.draft(label='全公司黑片外废',lead='9月部门甲黑片外废报废重量615.25 kg。'),self.remove_row,fixture=fixture)
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,37 @@
|
||||
"""The replay catalog is retained only in the private composition artifact."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
|
||||
from nao_protocol_execution import _save_composition
|
||||
|
||||
|
||||
class PrivateCompositionCaptureTests(unittest.TestCase):
|
||||
def test_issued_catalog_identity_is_preserved_without_connection_material(self):
|
||||
issued = {
|
||||
'facts': [{'id': 'F2', 'rawValue': '493.99660000'}],
|
||||
'bindingInventory': {'N17': {'factId': 'F2', 'value': '493.9966', 'unit': 'kg'}},
|
||||
'requiredFactIds': ['F2'],
|
||||
}
|
||||
final = {
|
||||
'rawModelResponses': ['{"blocks":[]}'],
|
||||
'_privateBindingInput': issued,
|
||||
'compositionDiagnostics': {'issues': []},
|
||||
'connection': {'apiKey': 'must-never-be-captured'},
|
||||
}
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
_save_composition(final, Path(directory), 'turn-test')
|
||||
raw = (Path(directory) / 'private' / 'answer-composition.json').read_text()
|
||||
captured = json.loads(raw)
|
||||
self.assertEqual(captured['bindingInput'], issued)
|
||||
self.assertEqual(captured['rawModelResponses'], final['rawModelResponses'])
|
||||
self.assertNotIn('must-never-be-captured', raw)
|
||||
self.assertNotIn('connection', captured)
|
||||
self.assertEqual(set(captured), {'turnId', 'rawModelResponses', 'compositionDiagnostics', 'bindingInput'})
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,180 @@
|
||||
import copy
|
||||
import sys
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'scripts'))
|
||||
from analysis_visual_evidence import protocol_visual_result
|
||||
from nao_native_exploration import _proofs
|
||||
from nao_query_plan import scope_documents
|
||||
|
||||
|
||||
def metric_scope(*, preference='auto', comparison=False, trend=False, fields=None):
|
||||
task = {
|
||||
'kind': 'metrics', 'fields': fields or ['rate'], 'stages': ['black'],
|
||||
'period': {'year': 2026, 'month': 9},
|
||||
'comparisonPeriod': {'year': 2026, 'month': 8} if comparison else None,
|
||||
'comparisonRequired': comparison, 'trendRequired': trend,
|
||||
'filters': {}, 'visualPreference': preference, 'visualType': 'bar',
|
||||
}
|
||||
return {'nodeId': 'support-rate', 'scopeId': 'scope-support-rate',
|
||||
'purpose': 'metrics', 'task': task}
|
||||
|
||||
|
||||
def ranking_scope():
|
||||
task = {
|
||||
'kind': 'analysis', 'fields': ['scrapWeight'], 'stages': ['black'],
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': ['black']},
|
||||
'period': {'year': 2026, 'month': 9}, 'filters': {},
|
||||
'comparisonRequired': False, 'trendRequired': False,
|
||||
'visualPreference': 'auto', 'visualType': 'bar',
|
||||
}
|
||||
return {'nodeId': 'main-ranking', 'scopeId': 'scope-main-ranking',
|
||||
'purpose': 'ranking', 'task': task}
|
||||
|
||||
|
||||
def ranking_chart():
|
||||
return {'metric': 'black_scrap_weight', 'type': 'bar', 'dimension': 'product',
|
||||
'stage': 'black', 'scope': {}, 'categories': [], 'series': []}
|
||||
|
||||
|
||||
class ProtocolVisualRequirementTests(unittest.TestCase):
|
||||
def test_native_proof_filter_keeps_comparison_root_chart_scope_selectable(self):
|
||||
scope = metric_scope(comparison=True)
|
||||
scope.update({'nodeId': 'root-rate', 'scopeId': 'scope-root-rate', 'purpose': 'metrics'})
|
||||
scope['task']['stages'] = []
|
||||
scope['task']['visualType'] = None
|
||||
current_proof = {'queryId': 'query-current', 'executionId': 'execution',
|
||||
'nodeId': 'root-rate', 'scopeId': 'scope-root-rate'}
|
||||
comparison_proof = {'queryId': 'query-comparison', 'executionId': 'execution',
|
||||
'nodeId': 'root-rate', 'scopeId': 'scope-root-rate'}
|
||||
doc = {
|
||||
'mode': 'compare', 'evidenceRef': 'Q1234ABCD',
|
||||
'result': {
|
||||
'kind': 'quality_comparison', 'releaseId': 'release',
|
||||
'filterBinding': {},
|
||||
'current': {'period': {'year': 2026, 'month': 9},
|
||||
'compositeRate': 0.9512973521079284,
|
||||
'protocolEvidence': current_proof},
|
||||
'comparison': {'period': {'year': 2026, 'month': 8},
|
||||
'compositeRate': 0.9557382889437664,
|
||||
'protocolEvidence': comparison_proof},
|
||||
'delta': {'available': True, 'rate': -0.004440936835838},
|
||||
'protocolEvidence': [current_proof, comparison_proof],
|
||||
},
|
||||
}
|
||||
original_doc = copy.deepcopy(doc)
|
||||
|
||||
# Native run filters accepted receipts with _proofs before visual scoping.
|
||||
proofs = _proofs(doc['result'])
|
||||
self.assertEqual(len(doc['result']['protocolEvidence']), 2)
|
||||
accepted = {proof['queryId'] for proof in proofs}
|
||||
self.assertEqual(accepted, {'query-current', 'query-comparison'})
|
||||
complete_scopes = {('root-rate', 'scope-root-rate')}
|
||||
selected_documents = [document for document in [doc]
|
||||
if _proofs(document.get('result', {}))
|
||||
and all(proof.get('executionId') == 'execution'
|
||||
and proof.get('queryId') in accepted
|
||||
and (proof.get('nodeId'), proof.get('scopeId')) in complete_scopes
|
||||
for proof in _proofs(document.get('result', {})))]
|
||||
self.assertEqual(selected_documents, [doc])
|
||||
self.assertEqual(scope_documents(selected_documents, scope, release_id='release'), [doc])
|
||||
self.assertEqual(doc, original_doc)
|
||||
self.assertEqual({proof['queryId'] for proof in _proofs(doc['result'])}, accepted)
|
||||
self.assertEqual(doc, original_doc)
|
||||
|
||||
result = protocol_visual_result(selected_documents, [scope], '9月份合格率下降原因', 'turn',
|
||||
release_id='release')
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
self.assertEqual([chart['metric'] for chart in result['visuals']], ['composite_rate'])
|
||||
self.assertEqual(result['visuals'][0]['series'][0]['values'],
|
||||
[0.9557382889437664, 0.9512973521079284])
|
||||
self.assertEqual(doc, original_doc)
|
||||
|
||||
def test_nested_proof_collection_is_idempotent_for_multiple_side_proofs(self):
|
||||
proofs = [
|
||||
{'queryId': f'query-{index}', 'nodeId': 'root', 'scopeId': 'scope'}
|
||||
for index in range(4)
|
||||
]
|
||||
response = {
|
||||
'protocolEvidence': proofs,
|
||||
'current': {'protocolEvidence': proofs[:2]},
|
||||
'comparison': {'protocolEvidence': proofs[2:]},
|
||||
}
|
||||
original = copy.deepcopy(response)
|
||||
|
||||
self.assertEqual({item['queryId'] for item in _proofs(response)},
|
||||
{item['queryId'] for item in proofs})
|
||||
self.assertEqual(response, original)
|
||||
self.assertEqual({item['queryId'] for item in _proofs(response)},
|
||||
{item['queryId'] for item in proofs})
|
||||
self.assertEqual(response, original)
|
||||
|
||||
def test_automatic_single_metric_support_can_remain_table_only(self):
|
||||
scope = metric_scope()
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
result = protocol_visual_result([], [scope], 'Top产品及其黑片率', 'turn',
|
||||
release_id='release')
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
self.assertEqual(result['visualState'], 'not_requested')
|
||||
|
||||
def test_explicit_required_and_comparison_metric_charts_remain_blocking(self):
|
||||
for scope in (metric_scope(preference='required'), metric_scope(comparison=True)):
|
||||
with self.subTest(scope=scope):
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
result = protocol_visual_result([], [scope], '查看指标', 'turn',
|
||||
release_id='release')
|
||||
self.assertTrue(result['missingEvidence'])
|
||||
self.assertEqual(result['visualState'], 'unavailable')
|
||||
exact_chart = {'metric': 'black_rate', 'stage': 'black', 'type': 'bar'}
|
||||
for scope in (metric_scope(preference='required'), metric_scope(comparison=True)):
|
||||
with self.subTest(fulfilled=scope):
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'ready', 'visuals': [exact_chart]}):
|
||||
result = protocol_visual_result([], [scope], '查看指标', 'turn',
|
||||
release_id='release')
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
|
||||
def test_scalar_support_does_not_poison_a_complete_main_ranking_chart(self):
|
||||
ranking = ranking_scope()
|
||||
support = metric_scope()
|
||||
with patch('analysis_visuals.build_visuals', side_effect=[
|
||||
{'visualState': 'ready', 'visuals': [ranking_chart()]},
|
||||
{'visualState': 'unavailable', 'visuals': []},
|
||||
]):
|
||||
result = protocol_visual_result([], [ranking, support], '黑片报废Top产品及其黑片率',
|
||||
'turn', release_id='release')
|
||||
self.assertEqual(result['visualState'], 'ready')
|
||||
self.assertEqual(result['missingEvidence'], [])
|
||||
self.assertEqual([chart['metric'] for chart in result['visuals']], ['black_scrap_weight'])
|
||||
|
||||
def test_a_chartable_ranking_without_its_chart_still_reports_a_gap(self):
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
result = protocol_visual_result([], [ranking_scope()], '黑片报废Top产品',
|
||||
'turn', release_id='release')
|
||||
self.assertTrue(result['missingEvidence'])
|
||||
self.assertEqual(result['visualState'], 'unavailable')
|
||||
|
||||
def test_required_trend_without_its_chart_still_reports_a_gap(self):
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
result = protocol_visual_result([], [metric_scope(trend=True)], '黑片率趋势',
|
||||
'turn', release_id='release')
|
||||
self.assertTrue(result['missingEvidence'])
|
||||
self.assertEqual(result['visualState'], 'unavailable')
|
||||
|
||||
def test_automatic_multimetric_visual_scope_keeps_its_chart_gap(self):
|
||||
with patch('analysis_visuals.build_visuals', return_value={
|
||||
'visualState': 'unavailable', 'visuals': []}):
|
||||
result = protocol_visual_result([], [metric_scope(fields=['rate', 'scrapWeight'])],
|
||||
'查看率和报废重量', 'turn', release_id='release')
|
||||
self.assertTrue(result['missingEvidence'])
|
||||
self.assertEqual(result['visualState'], 'unavailable')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,133 @@
|
||||
"""Typed comparison operands preserve their boundary, independently of units."""
|
||||
import io,json,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
from nao_evidence_finalizer import synthesize_native
|
||||
from nao_native_answer import _binding_inventory,_validate_blocks,NativeCompositionError
|
||||
from test_agent_answer import evidence
|
||||
|
||||
|
||||
class QuantityComparisonPipelineTests(unittest.TestCase):
|
||||
def report(self,second='1106.0721',*,unit='kg',stage='综合',field='scrapWeight'):
|
||||
facts=[]
|
||||
for i,name,raw in [(1,'规格甲','1155.4834'),(2,'规格乙',second)]:
|
||||
facts.append({'id':'F'+str(i),'kind':'product','label':name,
|
||||
'text':name+';'+stage+'报废重量'+raw+unit+'。', 'evidenceRef':'Q00000001',
|
||||
'scope':{'filters':{},'period':{'year':2026,'month':8},'dimension':'product','stage':'overall'},
|
||||
'validity':{'verified':True,'scopeApplicable':True,'basis':'quality_weight_ranking'},
|
||||
'verifiedComparisonValues':[{'metricField':field,'unit':unit,'stageHint':stage,
|
||||
'rawValue':raw,'displayValue':raw}]})
|
||||
return {'facts':facts,'requiredFactIds':[],'priorityFactIds':[],'missingEvidence':[],
|
||||
'rejectedEvidenceRefs':[],'notices':[],'sections':[]}
|
||||
|
||||
def invoke(self,text,*,native=False,second='1106.0721',report=None,cited=None):
|
||||
calls=[];report=report or self.report(second);fact_ids=cited or [fact['id'] for fact in report['facts']]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);payload=json.loads(body['messages'][1]['content']);calls.append(body)
|
||||
if 'draftBlocks' in payload:
|
||||
value={'reviews':[{'sourceId':b['sourceId'],'role':'core','factIds':fact_ids,
|
||||
'supported':True,'statisticalClaimsSupported':True} for b in payload['draftBlocks']], 'missingGoalDescriptions':[]}
|
||||
elif body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
value={'reviews':[{'supported':True,'statisticalClaimsSupported':True}],'missingGoalDescriptions':[]}
|
||||
else:value={'blocks':[{'role':'core','text':text,'factIds':fact_ids}]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value)}}]}).encode())
|
||||
with patch('nao_native_answer.build_native_report',return_value=report):
|
||||
final=synthesize_native(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='比较两规格',
|
||||
evidence=evidence(),context={'_agentTask':{'kind':'analysis','period':{'year':2026,'month':8}}},
|
||||
cancel_event=threading.Event(),opener=provider,native_answer=text if native else None)
|
||||
return final,calls
|
||||
|
||||
def test_mass_boundary_uses_each_raw_and_preserves_the_boundary(self):
|
||||
for native in (False,True):
|
||||
for text in ('规格甲与规格乙的综合报废重量均在1000 kg以上。','规格甲与规格乙的综合报废重量均超过1000 kg。',
|
||||
'规格甲与规格乙的综合报废重量均在1吨以上。'):
|
||||
final,_=self.invoke(text,native=native)
|
||||
self.assertTrue(final['bodyEvidenceSufficient'],final['compositionDiagnostics']['issues'])
|
||||
self.assertIn('1吨以上' if '吨' in text else '1000 kg',final['answer'])
|
||||
self.assertNotIn('1155.4834',final['answer'])
|
||||
|
||||
def test_relation_flip_and_one_failing_member_are_rejected(self):
|
||||
for native in (False,True):
|
||||
for text,second in [('规格甲与规格乙的综合报废重量均低于1000 kg。','1106.0721'),
|
||||
('规格甲与规格乙的综合报废重量均在1000 kg以上。','999.99'),
|
||||
('规格甲与规格乙的综合报废重量均超过1155.4834 kg。','1200')]:
|
||||
final,_=self.invoke(text,native=native,second=second)
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
|
||||
def test_unknown_unit_wrong_field_and_wrong_stage_are_rejected(self):
|
||||
for native in (False,True):
|
||||
for report in (self.report(unit='source_weight'),self.report(field='totalWeight'),self.report(stage='黑片')):
|
||||
final,_=self.invoke('规格甲与规格乙的综合报废重量均超过1000 kg。',native=native,report=report)
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
|
||||
def test_explicit_period_conflict_is_rejected(self):
|
||||
for native in (False,True):
|
||||
final,_=self.invoke('9月规格甲与规格乙的综合报废重量均超过1000 kg。',native=native)
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
|
||||
def test_an_explicit_second_member_cannot_be_ignored_when_uncited(self):
|
||||
report=self.report(second='999.99');report['facts'][1]['evidenceRef']='Q00000002'
|
||||
for native in (False,True):
|
||||
final,_=self.invoke('规格甲与规格乙的综合报废重量均超过1000 kg。',native=native,report=report,cited=['F1'])
|
||||
self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
|
||||
def test_native_typed_pp_uses_the_same_relation_and_field_role(self):
|
||||
report=self.report()
|
||||
for fact in report['facts']:
|
||||
fact['text']=fact['label']+';黑片对综合合格率贡献+0.30个百分点。'
|
||||
fact.pop('verifiedComparisonValues')
|
||||
fact['verifiedNativeNumericValues']=[{'sourceOrdinal':0,'displayValue':'+0.30','rawValue':'0.30416066',
|
||||
'unit':'pp','metricField':'stageContribution','stageHint':'黑片','period':{'year':2026,'month':8},
|
||||
'metricRole':'ContributionPp','ownerScope':{}}]
|
||||
good,_=self.invoke('规格甲与规格乙的黑片对综合合格率贡献均超过0.30个百分点。',native=True,report=report)
|
||||
self.assertTrue(good['bodyEvidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertIn('0.30个百分点',good['answer']);self.assertNotIn('0.30416066',good['answer'])
|
||||
bad,_=self.invoke('规格甲与规格乙的黑片对综合合格率贡献均低于0.30个百分点。',native=True,report=report)
|
||||
self.assertFalse(bad['bodyEvidenceSufficient'])
|
||||
for fact in report['facts']:
|
||||
fact['verifiedNativeNumericValues'][0].update(metricField='rateChange',metricRole='OwnStageRateChangePp')
|
||||
wrong_role,_=self.invoke('规格甲与规格乙的黑片对综合合格率贡献均超过0.30个百分点。',native=True,report=report)
|
||||
self.assertFalse(wrong_role['bodyEvidenceSufficient'])
|
||||
|
||||
def test_observation_tokens_cannot_bypass_a_suffix_boundary(self):
|
||||
facts=self.report()['facts'];tokens=_binding_inventory(facts)
|
||||
key=next(key for key,value in tokens.items() if value.get('factId')=='F1' and value.get('metricField')=='scrapWeight')
|
||||
for text in ('规格甲报废重量{{'+key+'}} kg以上。','规格甲报废重量超过{{'+key+'}} kg。'):
|
||||
with self.assertRaises(NativeCompositionError):
|
||||
_validate_blocks({'blocks':[{'text':text,'factIds':['F1']}]},facts,tokens)
|
||||
|
||||
def history_report(self,second='1106.07210000'):
|
||||
report=self.report();facts=report['facts']
|
||||
facts.append({**facts[0],'id':'F3','label':'规格丙'})
|
||||
raw_values=['1155.48340000',second,'1060.77910000']
|
||||
stage_values=[('446.851','708.6324'),('659.65','446.4221'),('538.905','521.8741')]
|
||||
scope={'filters':{},'period':{'year':2026,'month':8},'dimension':'product','stage':'overall'}
|
||||
collection={'verified':True,'complete':True,'rankGroupKey':'history-rank:fixture','memberFactIds':['F1','F2','F3'],
|
||||
'period':scope['period'],'scope':scope,'dimension':'product','metric':'scrapWeight','stage':'overall',
|
||||
'unit':'kg','requestedLimit':3,'returnedCount':3,'totalRows':10,'truncated':True}
|
||||
for rank,(fact,raw) in enumerate(zip(facts,raw_values),1):
|
||||
black,bright=stage_values[rank-1]
|
||||
fact.update(text=fact['label']+';综合报废重量'+raw+' kg;黑片报废重量'+black+' kg;亮片报废重量'+bright+' kg。',scope=scope,
|
||||
validity={'verified':True,'scopeApplicable':True,'basis':'protocol_history_snapshot'},
|
||||
rank=rank,rankGroupKey=collection['rankGroupKey'],historyCollection=collection,
|
||||
verifiedDisplayValues=[{'metricCode':code,'rawValue':value,'rawUnit':'source_weight','unit':'kg','displayValue':value}
|
||||
for code,value in [('scrapWeight',raw),('blackScrapWeight',black),('brightScrapWeight',bright)]])
|
||||
fact.pop('verifiedComparisonValues',None)
|
||||
return report
|
||||
|
||||
def test_captured_collective_sentence_uses_all_returned_members(self):
|
||||
# The unchanged original sentence and Decimal values; semantic review
|
||||
# is an explicit test fixture, not a fabricated captured model verdict.
|
||||
text='8月三款规格报废重量均在 1000 kg 以上。'
|
||||
for native in (False,True):
|
||||
good,_=self.invoke(text,native=native,report=self.history_report())
|
||||
self.assertTrue(good['bodyEvidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertIn('1000 kg',good['answer'])
|
||||
bad,_=self.invoke(text,native=native,report=self.history_report(second='999.99'))
|
||||
self.assertFalse(bad['bodyEvidenceSufficient'])
|
||||
reverse,_=self.invoke(text.replace('以上','以下'),native=native,report=self.history_report())
|
||||
self.assertFalse(reverse['bodyEvidenceSufficient'])
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,103 @@
|
||||
"""Only verified service tables reach presentation; the model owns explanation."""
|
||||
import copy,io,json,sys,tempfile,threading,unittest
|
||||
from unittest.mock import patch
|
||||
from pathlib import Path
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import nao_native_answer as n
|
||||
import test_native_grounded_contract as grounded
|
||||
from test_nao_history_report import ranking_history_snapshot,report_task,authority,FakeDelegated,RELEASE,TURN
|
||||
from nao_history_report import execute_history_report
|
||||
|
||||
class RecoveryDataPresentationTests(unittest.TestCase):
|
||||
def provider(self,calls,*,bad_prose=False,only_table=False):
|
||||
def respond(request,timeout):
|
||||
body=json.loads(request.data);p=json.loads(body['messages'][1]['content']);calls.append((body,p))
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
value={'reviews':[{'supported':True,'statisticalClaimsSupported':True} for _ in p['blocks']],'missingGoalDescriptions':[]}
|
||||
else:
|
||||
scopes={s['scopeId']:s for s in p['scopes']};periods={}
|
||||
for fact in p['facts']:
|
||||
periods.setdefault(json.dumps(scopes[fact['scopeId']].get('period'),sort_keys=True),fact['id'])
|
||||
ids=list(periods.values())
|
||||
blocks=[] if only_table else [{'role':'core','text':'报废重量999999 kg。' if bad_prose else '两个范围采用各自的期间,不能把两组排名直接视为同期变化。','factIds':ids}]
|
||||
blocks.append({'role':'key_evidence' if blocks else 'core','text':'| 规格 | 报废重量 |\n|---|---|\n| 伪型号 | 999999 kg |','factIds':ids})
|
||||
value={'reportTitle':'多范围规格报废分析','blocks':blocks,'visualIds':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value,ensure_ascii=False)}}]}).encode())
|
||||
return respond
|
||||
def invoke(self,**options):
|
||||
calls=[];snapshot=ranking_history_snapshot();original=copy.deepcopy(snapshot)
|
||||
final=n.synthesize_history_snapshot(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='汇总已有结果,不查询新数据',
|
||||
snapshot=snapshot,task=report_task(),authority=authority(),release_id=RELEASE,request_turn_id=TURN,
|
||||
cancel_event=threading.Event(),opener=self.provider(calls,**options))
|
||||
self.assertEqual(snapshot,original);return final,calls
|
||||
def test_model_numeric_table_is_not_authority_and_service_rows_are_exact(self):
|
||||
final,calls=self.invoke()
|
||||
self.assertTrue(final['bodyEvidenceSufficient'],final['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),2);self.assertNotIn('999999',final['answer']);self.assertNotIn('伪型号',final['answer'])
|
||||
self.assertIn('九月规格1',final['answer']);self.assertIn('八月规格1',final['answer'])
|
||||
self.assertIn('10.25',final['answer']);self.assertIn('Top 5',final['answer']);self.assertIn('Top 3',final['answer'])
|
||||
self.assertNotIn('999999',json.dumps(calls[1][1]['blocks'],ensure_ascii=False))
|
||||
self.assertTrue(final['readingSummary']);self.assertTrue(final['titleValid'])
|
||||
def test_bad_free_prose_is_still_rejected_and_table_only_is_not_an_explanation(self):
|
||||
for options in ({'bad_prose':True},{'only_table':True}):
|
||||
final,calls=self.invoke(**options);self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
self.assertLessEqual(len(calls),3)
|
||||
|
||||
def native(self,text,*,semantic=True):
|
||||
docs,context=grounded.GroundedNativeContractTests().fixture()
|
||||
context['_nativeExecutionId']='fixture-current-execution';context['_agentTask']['kind']='analysis'
|
||||
calls=[]
|
||||
def provider(request,timeout):
|
||||
body=json.loads(request.data);payload=json.loads(body['messages'][1]['content']);calls.append(body)
|
||||
self.assertNotIn('draftBlocks',payload)
|
||||
if body['messages'][0]['content'].startswith('逐句核验证据'):
|
||||
value={'reviews':[{'supported':semantic,'statisticalClaimsSupported':semantic} for _ in payload['blocks']],
|
||||
'missingGoalDescriptions':[]}
|
||||
else:
|
||||
fid=next(f['id'] for f in payload['facts'] if '黑片外废' in f['text'])
|
||||
value={'reportTitle':'阶段报废分析','blocks':[{'role':'core','text':text,'factIds':[fid]}],'visualIds':[]}
|
||||
return io.BytesIO(json.dumps({'choices':[{'finish_reason':'stop','message':{'content':json.dumps(value,ensure_ascii=False)}}]}).encode())
|
||||
final=n.synthesize_native_answer(base_url='https://offline.invalid',api_key='fixture',model='fixture',question='分析质量变化',
|
||||
evidence=docs,context=context,native_answer='内部未核验原稿 999999 kg',cancel_event=threading.Event(),opener=provider)
|
||||
self.assertLessEqual(len(calls),2)
|
||||
self.assertTrue(all(sum(len(m['content']) for m in c['messages'])<=90000 for c in calls))
|
||||
self.assertNotIn('内部未核验原稿',json.dumps(calls,ensure_ascii=False))
|
||||
return final,calls
|
||||
|
||||
def test_complex_native_reuses_atomic_guards_and_exact_service_table(self):
|
||||
good,calls=self.native('9月黑片外废报废重量615.249 kg。')
|
||||
self.assertTrue(good['bodyEvidenceSufficient'],good['compositionDiagnostics']['issues'])
|
||||
self.assertEqual(len(calls),2);self.assertTrue(good['compositionDiagnostics']['nativeAtomicBindings'])
|
||||
for text in ('9月亮片外废报废重量615.249 kg。','8月黑片外废报废重量615.249 kg。',
|
||||
'9月黑片外废数量615.249件。','9月黑片外废报废重量615.35 kg。',
|
||||
'9月黑片外废报废低于615.2 kg。'):
|
||||
with self.subTest(text=text):
|
||||
final,calls=self.native(text);self.assertFalse(final['bodyEvidenceSufficient'])
|
||||
self.assertEqual(len(calls),1)
|
||||
|
||||
def test_semantic_rejection_of_core_is_a_real_gap(self):
|
||||
final,calls=self.native('9月黑片外废报废重量615.249 kg。',semantic=False)
|
||||
self.assertFalse(final['bodyEvidenceSufficient']);self.assertEqual(len(calls),2)
|
||||
self.assertTrue(final['bodyMissingEvidence'])
|
||||
|
||||
def test_metrics_path_keeps_existing_native_draft_contract(self):
|
||||
docs,context=grounded.GroundedNativeContractTests().fixture()
|
||||
context.update(_nativeExecutionId='fixture-current-execution')
|
||||
context['_agentTask']['kind']='metrics'
|
||||
with patch.object(n,'_synthesize_verified_report',side_effect=lambda **kwargs:kwargs):
|
||||
routed=n.synthesize_native_answer(base_url='offline',api_key='fixture',model='fixture',question='查询指标',
|
||||
evidence=docs,context=context,native_answer='原有单值稿',cancel_event=threading.Event())
|
||||
self.assertEqual(routed['native_answer'],'原有单值稿')
|
||||
self.assertNotIn('presentationSections',routed['report'])
|
||||
|
||||
def test_recovery_uses_only_existing_signed_history_import(self):
|
||||
delegated=FakeDelegated(ranking_history_snapshot());calls=[]
|
||||
with tempfile.TemporaryDirectory() as folder, patch('nao_evidence_finalizer._open_model',side_effect=self.provider(calls)):
|
||||
result=execute_history_report(request={'releaseId':RELEASE,'turnId':TURN,'question':'汇总已有结果,不查询新数据','_autonomousAnswer':True},
|
||||
task=report_task(),authority=authority(),actor_root=Path(folder),delegated=delegated,
|
||||
connection=('https://offline.invalid','fixture','fixture'),cancel_event=threading.Event(),emit=lambda _:None,timings={})
|
||||
self.assertEqual([c[0] for c in delegated.calls],['/api/analysis/protocol/history'])
|
||||
self.assertEqual(result['status'],'COMPLETED');self.assertEqual(len(calls),2)
|
||||
self.assertIn('九月规格1',result['answer']);self.assertIn('八月规格1',result['answer'])
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Titles may name each signed period/scope without promoting a partial scope."""
|
||||
import sys,unittest
|
||||
from pathlib import Path
|
||||
sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'scripts'))
|
||||
import nao_native_answer as n
|
||||
from nao_history_report import _history_title_is_scope_safe
|
||||
|
||||
class ReportTitleScopeRoleTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.sections=[{'sourceTurnId':'sep','period':{'year':2026,'month':9},'filters':{'department':'消费电子产业部','group':'消费电子-3C'}},
|
||||
{'sourceTurnId':'aug','period':{'year':2026,'month':8},'filters':{}}]
|
||||
self.snapshot={'sections':self.sections,'historySources':[{'turnId':'sep'},{'turnId':'aug'}]}
|
||||
self.report={'facts':[{'id':'F'+str(i),'kind':'product','text':'正式报废排名事实','label':'产品',
|
||||
'scope':s,'validity':{'verified':True,'basis':'protocol_history_snapshot'}} for i,s in enumerate(self.sections,1)]}
|
||||
self.context={'_historyTitleExcludedScopeLiterals':['消费电子产业部','消费电子-3C']}
|
||||
def valid(self,title):
|
||||
return n._verified_content_title(title,self.report,'生成报告',n._content_title_guide(self.report,self.context))
|
||||
def test_period_scoped_full_organization_labels_can_omit_display_separators(self):
|
||||
for title in ('2026年8月全公司与9月消费电子3C产品不良Top规格报告',
|
||||
'2026年9月消费电子-3C与8月全公司产品不良规格报告'):
|
||||
with self.subTest(title=title):
|
||||
self.assertEqual(self.valid(title),title)
|
||||
self.assertEqual(_history_title_is_scope_safe(title,self.snapshot,'生成报告'),title)
|
||||
def test_partial_scope_cannot_be_promoted_or_attached_to_wrong_period(self):
|
||||
for title in ('2026年8—9月消费电子3C质量报告','2026年9月消费电子3C质量报告',
|
||||
'2026年9月全公司与8月消费电子3C质量报告','2026年8月全公司消费电子3C与9月质量报告',
|
||||
'2026年8月全公司与9月3C产品报告','2026年8月全公司与9月消费电子产业部报告'):
|
||||
with self.subTest(title=title):self.assertIsNone(self.valid(title))
|
||||
def test_generic_multi_scope_title_and_common_scope_still_work(self):
|
||||
self.assertTrue(self.valid('2026年8月及9月产品规格报废榜单汇总'))
|
||||
self.report['facts']=self.report['facts'][:1];self.snapshot['sections']=self.sections[:1];self.snapshot['historySources']=[{'turnId':'sep'}]
|
||||
self.context={'_historyTitleExcludedScopeLiterals':[]}
|
||||
self.assertTrue(self.valid('消费电子3C产品质量报告'))
|
||||
def test_product_identifier_characters_are_not_normalized_as_scope_aliases(self):
|
||||
self.sections[0]['filters']={'product':'型号3-C'};self.report['facts'][0]['verifiedIdentifiers']=[{'value':'型号3-C','field':'product'}]
|
||||
self.context={'_historyTitleExcludedScopeLiterals':['型号3-C']}
|
||||
self.assertIsNone(self.valid('2026年8月全公司与9月型号3C质量报告'))
|
||||
def test_native_nonhistory_guide_does_not_expand_scope_payload(self):
|
||||
self.assertNotIn('scopeContexts',n._content_title_guide(self.report,{}))
|
||||
def test_unavailable_scope_and_explicit_exclusion_cannot_gain_a_title_alias(self):
|
||||
self.context['_historyTitleExcludedScopeLiterals'].append('未提供范围')
|
||||
self.assertIsNone(self.valid('2026年8月全公司与9月未提供范围质量报告'))
|
||||
self.sections[0]['filters']['exclusions']={'department':['排除部门']}
|
||||
self.assertIsNone(self.valid('2026年8月全公司与9月排除部门质量报告'))
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,109 @@
|
||||
"""Review-only exact values and collection/condition roles stay distinct."""
|
||||
import copy,json,sys,threading,unittest
|
||||
from pathlib import Path
|
||||
from unittest.mock import patch
|
||||
sys.path[:0]=[str(Path(__file__).resolve().parents[1]/'scripts'),str(Path(__file__).parent)]
|
||||
import nao_native_answer as n
|
||||
import test_quantity_comparison_bounds as quantity_tests
|
||||
|
||||
|
||||
class SemanticReviewProjectionTests(unittest.TestCase):
|
||||
def report(self):
|
||||
report=quantity_tests.QuantityComparisonPipelineTests().history_report()
|
||||
for fact in report['facts']:
|
||||
fact['historyCollection'].update(denominator='62726.7476',shareBasis='all_scope_weight')
|
||||
return report
|
||||
|
||||
def bound_blocks(self,report):
|
||||
tokens=n._binding_inventory(report['facts']);diagnostics={}
|
||||
parsed={'blocks':[{'role':'core','text':'8月三款规格报废重量均在 1000 kg 以上。',
|
||||
'factIds':[f['id'] for f in report['facts']]}]}
|
||||
parsed=n._bind_comparison_bounds(parsed,report['facts'],tokens,diagnostics)
|
||||
parsed=n._bind_exact_periods(parsed,tokens,diagnostics)
|
||||
blocks,_=n._validate_blocks(parsed,report['facts'],tokens,diagnostics=diagnostics)
|
||||
return blocks,diagnostics
|
||||
|
||||
def test_display_default_is_unchanged_and_exact_values_are_review_only(self):
|
||||
facts=self.report()['facts'];original=copy.deepcopy(facts)
|
||||
display,_=n._model_fact_view(facts)
|
||||
self.assertEqual(set(display[0]['values'][0]),{'metricCode','unit','displayValue'})
|
||||
exact,_=n._model_fact_view(facts,include_exact=True)
|
||||
value=next(v for v in exact[0]['values'] if v.get('metricCode')=='scrapWeight')
|
||||
self.assertEqual(value['rawValue'],'1155.48340000')
|
||||
self.assertEqual(value['rawUnit'],'source_weight')
|
||||
self.assertEqual(value['metricField'],'scrapWeight')
|
||||
self.assertEqual(value['stageHint'],'综合')
|
||||
self.assertEqual(facts,original)
|
||||
|
||||
def test_actual_review_payload_has_raw_members_and_separate_metadata_roles(self):
|
||||
report=self.report();blocks,diagnostics=self.bound_blocks(report);messages=[]
|
||||
def request(**kwargs):
|
||||
messages.extend(kwargs['messages'])
|
||||
return json.dumps({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],
|
||||
'missingGoalDescriptions':[]}),{},'stop'
|
||||
with patch('nao_native_answer._request_model',side_effect=request):
|
||||
n._review_blocks(blocks,report['facts'],connection=('offline.invalid','fixture','fixture'),
|
||||
cancel_event=threading.Event(),opener=None,raw_responses=[],usages=[],diagnostics=diagnostics)
|
||||
self.assertEqual(len(messages),2)
|
||||
payload=json.loads(messages[1]['content']);collections=payload['historyCollections']
|
||||
self.assertEqual(len(collections),1)
|
||||
self.assertEqual(collections[0]['role'],'collection_metadata')
|
||||
self.assertEqual(collections[0]['memberFactIds'],['F1','F2','F3'])
|
||||
self.assertEqual(collections[0]['denominator']['role'],'scope_denominator')
|
||||
self.assertEqual(collections[0]['denominator']['rawValue'],'62726.7476')
|
||||
operand=payload['comparisonOperands'][0]
|
||||
self.assertEqual(operand['role'],'comparison_condition')
|
||||
self.assertEqual(operand['boundary'],'1000')
|
||||
self.assertEqual(operand['ownerFactIds'],['F1','F2','F3'])
|
||||
self.assertNotIn('supported',operand)
|
||||
self.assertTrue(all(any('rawValue' in v for v in fact['values']) for fact in payload['facts']))
|
||||
self.assertFalse(any(v.get('metricField')=='historyCollectionDenominator'
|
||||
for fact in payload['facts'] for v in fact['values']))
|
||||
self.assertNotIn('filters',json.dumps(collections))
|
||||
self.assertIn('观测点',messages[0]['content'])
|
||||
self.assertLess(sum(len(message['content']) for message in messages),90000)
|
||||
|
||||
def test_native_without_a_bound_keeps_display_projection(self):
|
||||
report=self.report();sources=n._native_draft_blocks('规格甲综合报废重量1155.48 kg。')
|
||||
messages=n._native_draft_review_messages(sources,report['facts'],'质量分析',{},n.METRIC_SEMANTICS)
|
||||
payload=json.loads(messages[1]['content'])
|
||||
self.assertFalse(any('rawValue' in value for fact in payload['facts'] for value in fact.get('values',[])))
|
||||
self.assertLess(sum(len(message['content']) for message in messages),90000)
|
||||
|
||||
def test_native_bound_adds_exact_values_only_for_its_actual_owners(self):
|
||||
report=self.report();sources=n._native_draft_blocks('规格甲与规格乙的综合报废重量均超过1000 kg。')
|
||||
messages=n._native_draft_review_messages(sources,report['facts'],'质量分析',{},n.METRIC_SEMANTICS)
|
||||
payload=json.loads(messages[1]['content'])
|
||||
self.assertEqual(payload['comparisonOperands'][0]['ownerFactIds'],['F1','F2'])
|
||||
self.assertTrue(any('rawValue' in value for value in payload['facts'][0]['values']))
|
||||
self.assertFalse(any('rawValue' in value for value in payload['facts'][2]['values']))
|
||||
self.assertLess(sum(len(message['content']) for message in messages),90000)
|
||||
|
||||
def test_unverified_collection_is_not_promoted_to_review_metadata(self):
|
||||
report=self.report();blocks,diagnostics=self.bound_blocks(report)
|
||||
for fact in report['facts']:fact['historyCollection']['verified']=False
|
||||
messages=[]
|
||||
def request(**kwargs):
|
||||
messages.extend(kwargs['messages'])
|
||||
return json.dumps({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],
|
||||
'missingGoalDescriptions':[]}),{},'stop'
|
||||
with patch('nao_native_answer._request_model',side_effect=request):
|
||||
n._review_blocks(blocks,report['facts'],connection=('offline.invalid','fixture','fixture'),
|
||||
cancel_event=threading.Event(),opener=None,raw_responses=[],usages=[],diagnostics=diagnostics)
|
||||
self.assertEqual(json.loads(messages[1]['content']).get('historyCollections',[]),[])
|
||||
|
||||
def test_removed_condition_does_not_export_stale_binding_diagnostics(self):
|
||||
report=self.report();blocks,diagnostics=self.bound_blocks(report)
|
||||
blocks[0]['text']='8月三款规格的报废重量见已确认表格。'
|
||||
messages=[]
|
||||
def request(**kwargs):
|
||||
messages.extend(kwargs['messages'])
|
||||
return json.dumps({'reviews':[{'supported':True,'statisticalClaimsSupported':True}],
|
||||
'missingGoalDescriptions':[]}),{},'stop'
|
||||
with patch('nao_native_answer._request_model',side_effect=request):
|
||||
n._review_blocks(blocks,report['facts'],connection=('offline.invalid','fixture','fixture'),
|
||||
cancel_event=threading.Event(),opener=None,raw_responses=[],usages=[],diagnostics=diagnostics)
|
||||
self.assertEqual(json.loads(messages[1]['content'])['comparisonOperands'],[])
|
||||
|
||||
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -78,6 +78,110 @@ class EchoColumnApi(FakeApi):
|
||||
|
||||
|
||||
class SourceColumnProtocolTests(unittest.TestCase):
|
||||
def test_single_product_combined_metric_uses_one_filtered_combined_ranking_node(self):
|
||||
product = 'PX-73X4.2XR26.4-VariantB'
|
||||
question = f'2026年9月{product}的综合合格率和黑片亮片合计报废总重是多少?只用文字回答。'
|
||||
plan = {
|
||||
'goal': '查询指定完整规格的综合合格率和黑片、亮片合计报废总重',
|
||||
'kind': 'metrics', 'filterUpdates': {'product': product},
|
||||
'period': {'year': 2026, 'month': 9}, 'comparisonPeriod': None,
|
||||
'comparisonRequired': False, 'trendRequired': False,
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
||||
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'freshQuery': True, 'verifySource': False, 'fullDetails': False,
|
||||
'needsClarification': False, 'clarification': '',
|
||||
'visualPreference': 'none', 'visualType': None,
|
||||
'queryPlan': [{
|
||||
'nodeId': 'single_product', 'purpose': 'ranking', 'dimension': 'product',
|
||||
'limit': 1, 'fields': ['rate', 'scrapWeight'], 'stages': [],
|
||||
'selector': {'kind': 'base'}, 'visualType': None,
|
||||
'visualPreference': 'none', 'comparisonRequired': False,
|
||||
}],
|
||||
}
|
||||
review = {'aligned': True, 'requiresEvidence': True,
|
||||
'requiresSourceVerification': False, 'requiresAllSourceRows': False,
|
||||
'requiresTrend': False, 'requiresComparison': False}
|
||||
for protocol, replies in (
|
||||
({'version': 1}, [plan, review]),
|
||||
({'version': 1, 'autonomousEnabled': True}, [plan])):
|
||||
with self.subTest(autonomous=protocol.get('autonomousEnabled', False)):
|
||||
context = {'_protocol': protocol}
|
||||
with patch('nao_agent_task._model_json', side_effect=replies) as model:
|
||||
task = plan_task(base_url='https://offline.invalid/v1', api_key='unused', model='m',
|
||||
question=question, context=context, cancel_event=threading.Event())
|
||||
self.assertEqual(task['kind'], 'metrics')
|
||||
self.assertEqual(task['filters']['product'], product)
|
||||
self.assertEqual(task['dimensions'], ['product'])
|
||||
self.assertEqual(task['fields'], ['rate', 'scrapWeight'])
|
||||
self.assertEqual(task['stages'], [])
|
||||
self.assertEqual(task['dimensionStages']['product'], [])
|
||||
self.assertEqual(len(task['queryPlan']), 1)
|
||||
node = task['queryPlan'][0]
|
||||
self.assertEqual((node['purpose'], node['dimension'], node['limit']),
|
||||
('ranking', 'product', 1))
|
||||
self.assertEqual(node['fields'], ['rate', 'scrapWeight'])
|
||||
self.assertEqual(node['stages'], [])
|
||||
self.assertEqual(node['visualPreference'], 'none')
|
||||
self.assertIn('limit=1', model.call_args_list[0].kwargs['system'])
|
||||
self.assertIn('合计算子', model.call_args_list[0].kwargs['system'])
|
||||
|
||||
from nao_protocol_execution import _scoped_arguments
|
||||
args = _scoped_arguments({'releaseId': 'release-test'}, {'task': task}, node)
|
||||
self.assertEqual(len(args), 1)
|
||||
self.assertIsNone(args[0]['stage'])
|
||||
self.assertEqual(args[0]['metric'], 'scrapWeight')
|
||||
|
||||
def test_unqualified_bad_top_stays_combined_product_ranking_under_exact_product_filter(self):
|
||||
product = 'DYN-SPEC-0.795+0.937X1.498X7'
|
||||
question = f'2026年9月只看规格{product}的不良TOP5。'
|
||||
plan = {
|
||||
'goal': '按用户给出的完整产品规格范围列出不良TOP5',
|
||||
'kind': 'analysis', 'filterUpdates': {'product': product},
|
||||
'period': {'year': 2026, 'month': 9}, 'comparisonPeriod': None,
|
||||
'comparisonRequired': False, 'trendRequired': False,
|
||||
'dimensions': ['product'], 'dimensionStages': {'product': []},
|
||||
'stages': [], 'fields': ['rate', 'scrapWeight'],
|
||||
'freshQuery': True, 'verifySource': False, 'fullDetails': False,
|
||||
'needsClarification': False, 'clarification': '',
|
||||
'visualPreference': 'auto', 'visualType': 'bar',
|
||||
'queryPlan': [{
|
||||
'nodeId': 'product_top', 'purpose': 'ranking', 'dimension': 'product',
|
||||
'limit': 5, 'fields': ['rate', 'scrapWeight'], 'stages': [],
|
||||
'selector': {'kind': 'base'}, 'visualType': 'bar',
|
||||
'visualPreference': 'auto', 'comparisonRequired': False,
|
||||
}],
|
||||
}
|
||||
review = {'aligned': True, 'requiresEvidence': True,
|
||||
'requiresSourceVerification': False, 'requiresAllSourceRows': False,
|
||||
'requiresTrend': False, 'requiresComparison': False}
|
||||
for protocol, replies in (
|
||||
({'version': 1}, [plan, review]),
|
||||
({'version': 1, 'autonomousEnabled': True}, [plan])):
|
||||
with self.subTest(autonomous=protocol.get('autonomousEnabled', False)):
|
||||
with patch('nao_agent_task._model_json', side_effect=replies) as model:
|
||||
task = plan_task(base_url='https://offline.invalid/v1', api_key='unused', model='m',
|
||||
question=question, context={'_protocol': protocol}, cancel_event=threading.Event())
|
||||
self.assertEqual(task['kind'], 'analysis')
|
||||
self.assertEqual(task['filters']['product'], product)
|
||||
self.assertEqual(task['dimensions'], ['product'])
|
||||
self.assertEqual(task['fields'], ['rate', 'scrapWeight'])
|
||||
self.assertEqual(task['stages'], [])
|
||||
self.assertEqual(task['dimensionStages']['product'], [])
|
||||
self.assertNotIn('缺陷', task['goal'])
|
||||
self.assertEqual(len(task['queryPlan']), 1)
|
||||
node = task['queryPlan'][0]
|
||||
self.assertEqual((node['purpose'], node['dimension'], node['limit']),
|
||||
('ranking', 'product', 5))
|
||||
self.assertEqual(node['stages'], [])
|
||||
self.assertNotIn('defects', [item['purpose'] for item in task['queryPlan']])
|
||||
self.assertIn('空榜', model.call_args_list[0].kwargs['system'])
|
||||
|
||||
from nao_protocol_execution import _scoped_arguments
|
||||
args = _scoped_arguments({'releaseId': 'release-test'}, {'task': task}, node)
|
||||
self.assertEqual(len(args), 1)
|
||||
self.assertIsNone(args[0]['stage'])
|
||||
self.assertEqual(args[0]['metric'], 'scrapWeight')
|
||||
|
||||
def test_final_answer_selector_preserves_the_confirmed_column_scope(self):
|
||||
from nao_evidence_finalizer import _agent_task_summary
|
||||
task=protocol_task()
|
||||
@@ -97,7 +201,7 @@ class SourceColumnProtocolTests(unittest.TestCase):
|
||||
catalog = {'sourceFields': [canonical_product, *SOURCE_FIELDS[1:]], 'departments': [], 'groups': []}
|
||||
task = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 3}, comparisonRequired=False, trendRequired=False,
|
||||
memberFields=['product'], columnFilters=[]), '列出客户规格清单',
|
||||
memberFields=['product'], columnFilters=[]), '列出产品清单',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
self.assertEqual(task['memberFields'], ['product'])
|
||||
self.assertEqual(task['sourceFieldLabels'], {'product': '产品'})
|
||||
@@ -110,6 +214,134 @@ class SourceColumnProtocolTests(unittest.TestCase):
|
||||
columnFilters=[{'field': 'product', 'stages': ['black'], 'operator': 'in', 'values': ['18X15X4']}]),
|
||||
'按产品筛选指标', {'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
|
||||
def test_member_fields_must_match_the_requested_entity_not_lookalike_or_filter_columns(self):
|
||||
canonical_product = {**SOURCE_FIELDS[0], 'type': 'dimension'}
|
||||
product_spec = source_field('src_dynamic_product_spec_0', '产品规格', '黑片规格', '亮片规格')
|
||||
drawing = source_field('src_dynamic_drawing_1', '产品图号', '图号-黑片', '图号-亮片')
|
||||
customer_code = source_field('src_dynamic_customer_2', '客户代码', '客户编码-黑片', '客户编码-亮片')
|
||||
customer_spec = source_field('src_dynamic_customer_spec_3', '客户规格', '客户规格-黑片', '客户规格-亮片')
|
||||
catalog = {'sourceFields': [canonical_product, product_spec, drawing, customer_code, customer_spec],
|
||||
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
||||
'departments': [], 'groups': []}
|
||||
context = {'_protocol': {'version': 1}, '_businessCatalog': catalog}
|
||||
question = '800001客户都有哪些规格?'
|
||||
wrong = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 9}, comparisonRequired=False, trendRequired=False,
|
||||
memberFields=[drawing['key'], customer_code['key']], columnFilters=[],
|
||||
filterUpdates={'extraFilters': {'customerCode': ['800001']}})
|
||||
with self.assertRaises(TaskUnavailable) as raised:
|
||||
normalize_task(wrong, question, context)
|
||||
self.assertEqual(raised.exception.field, 'memberFields')
|
||||
self.assertIn('产品规格', str(raised.exception))
|
||||
|
||||
correct = normalize_task({**wrong, 'memberFields': [product_spec['key']]}, question, context)
|
||||
self.assertEqual(correct['memberFields'], [product_spec['key']])
|
||||
self.assertEqual(correct['sourceFieldLabels'], {product_spec['key']: '产品规格'})
|
||||
self.assertEqual(correct['filters']['extraFilters'], {'customerCode': ['800001']})
|
||||
|
||||
drawing_task = {**wrong, 'memberFields': [drawing['key']]}
|
||||
drawing_result = normalize_task(drawing_task, '800001客户的产品图号有哪些?', context)
|
||||
self.assertEqual(drawing_result['memberFields'], [drawing['key']])
|
||||
|
||||
without_product_spec = {'sourceFields': [canonical_product, drawing, customer_code],
|
||||
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
||||
'departments': [], 'groups': []}
|
||||
missing = normalize_task(wrong, question,
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': without_product_spec})
|
||||
self.assertTrue(missing['needsClarification'])
|
||||
self.assertEqual(missing['memberFields'], [])
|
||||
self.assertIn('没有可用于', missing['clarification'])
|
||||
|
||||
customer_spec_task = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 9}, comparisonRequired=False, trendRequired=False,
|
||||
memberFields=[customer_spec['key']], columnFilters=[])
|
||||
customer_spec_result = normalize_task(customer_spec_task, '800001客户有哪些客户规格?', context)
|
||||
self.assertEqual(customer_spec_result['memberFields'], [customer_spec['key']])
|
||||
with self.assertRaises(TaskUnavailable) as rejected:
|
||||
normalize_task({**customer_spec_task, 'memberFields': [product_spec['key']]}, '800001客户有哪些客户规格?', context)
|
||||
self.assertEqual(rejected.exception.field, 'memberFields')
|
||||
|
||||
def test_ambiguous_member_spec_columns_force_clarification_without_a_query(self):
|
||||
primary = source_field('src_dynamic_product_spec_1', '产品规格', '规格-黑片', '规格-亮片')
|
||||
secondary = source_field('src_dynamic_finished_spec_2', '成品规格', '成品规格-黑片', '成品规格-亮片')
|
||||
material_spec = source_field('src_dynamic_material_spec_3', '原材料规格', '原料规格-黑片', '原料规格-亮片')
|
||||
version = source_field('src_dynamic_spec_version_4', '规格版本', '规格版本-黑片', '规格版本-亮片')
|
||||
catalog = {'sourceFields': [primary, secondary, material_spec, version], 'departments': [], 'groups': []}
|
||||
planned = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 9}, memberFields=[primary['key']], columnFilters=[]), '列出本期规格清单',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
self.assertTrue(planned['needsClarification'])
|
||||
self.assertEqual(planned['memberFields'], [])
|
||||
self.assertIn('多个', planned['clarification'])
|
||||
|
||||
explicit = normalize_task(task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 9}, memberFields=[secondary['key']], columnFilters=[]),
|
||||
'列出本期成品规格清单', {'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
self.assertFalse(explicit['needsClarification'])
|
||||
self.assertEqual(explicit['memberFields'], [secondary['key']])
|
||||
|
||||
def test_member_semantics_keep_multiple_requested_entities_and_ignore_lookalike_labels(self):
|
||||
product_spec = source_field('src_dynamic_product_spec_5', '产品规格', '产品规格-黑片', '产品规格-亮片')
|
||||
customer_spec = source_field('src_dynamic_customer_spec_6', '客户规格', '客户规格-黑片', '客户规格-亮片')
|
||||
material_spec = source_field('src_dynamic_material_spec_7', '原材料规格', '原料规格-黑片', '原料规格-亮片')
|
||||
spec_version = source_field('src_dynamic_version_8', '规格版本', '规格版本-黑片', '规格版本-亮片')
|
||||
catalog = {'sourceFields': [product_spec, customer_spec, material_spec, spec_version],
|
||||
'departments': [], 'groups': []}
|
||||
value = task_value(kind='members', dimensions=[], fields=[], stages=['black', 'bright'],
|
||||
period={'year': 2026, 'month': 9}, memberFields=[customer_spec['key'], product_spec['key']], columnFilters=[])
|
||||
planned = normalize_task(value, '列出成品规格,并显示客户规格',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
self.assertFalse(planned['needsClarification'])
|
||||
self.assertEqual(set(planned['memberFields']), {product_spec['key'], customer_spec['key']})
|
||||
|
||||
negated = normalize_task({**value, 'memberFields': [product_spec['key']]},
|
||||
'列出成品规格,不要显示客户规格',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': catalog})
|
||||
self.assertFalse(negated['needsClarification'])
|
||||
self.assertEqual(negated['memberFields'], [product_spec['key']])
|
||||
|
||||
raw_material = source_field('src_dynamic_raw_material_spec_9', '原材料规格', '原材料规格黑片', '原材料规格亮片')
|
||||
explicit_label_catalog = {'sourceFields': [product_spec, raw_material, spec_version],
|
||||
'departments': [], 'groups': []}
|
||||
raw_material_result = normalize_task({**value, 'memberFields': [raw_material['key']]},
|
||||
'列出原材料规格',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': explicit_label_catalog})
|
||||
self.assertFalse(raw_material_result['needsClarification'])
|
||||
self.assertEqual(raw_material_result['memberFields'], [raw_material['key']])
|
||||
|
||||
only_product_spec_catalog = {'sourceFields': [product_spec, material_spec, spec_version],
|
||||
'departments': [], 'groups': []}
|
||||
single = normalize_task({**value, 'memberFields': [product_spec['key']]}, '列出本期规格清单',
|
||||
{'_protocol': {'version': 1}, '_businessCatalog': only_product_spec_catalog})
|
||||
self.assertEqual(single['memberFields'], [product_spec['key']])
|
||||
|
||||
def test_member_semantic_repair_uses_this_turn_catalog_and_does_not_add_another_reviewer(self):
|
||||
canonical_product = {**SOURCE_FIELDS[0], 'type': 'dimension'}
|
||||
product_spec = source_field('src_run_product_spec_7', '产品规格', '产品规格黑片', '产品规格亮片')
|
||||
drawing = source_field('src_run_drawing_9', '产品图号', '图号-黑片', '图号-亮片')
|
||||
customer_code = source_field('src_run_code_8', '客户代码', '客户编码-黑片', '客户编码-亮片')
|
||||
catalog = {'sourceFields': [canonical_product, product_spec, drawing, customer_code],
|
||||
'extraFields': [{'key': 'customerCode', 'label': '客户代码'}],
|
||||
'departments': [], 'groups': []}
|
||||
question = '800001客户都有哪些规格?'
|
||||
context = {'_protocol': {'version': 1, 'autonomousEnabled': True}, '_businessCatalog': catalog}
|
||||
base = task_value(kind='members', goal='列出客户800001的产品规格清单', dimensions=[], fields=[],
|
||||
stages=['black', 'bright'], period={'year': 2026, 'month': 9}, comparisonRequired=False,
|
||||
trendRequired=False, memberFields=[drawing['key'], customer_code['key']], columnFilters=[],
|
||||
filterUpdates={'extraFilters': {'customerCode': ['800001']}}, visualPreference='none')
|
||||
repaired = {**base, 'memberFields': [product_spec['key']]}
|
||||
with patch('nao_agent_task._model_json', side_effect=[base, repaired]) as model:
|
||||
planned = plan_task(base_url='https://offline.invalid/v1', api_key='never-used', model='m',
|
||||
question=question, context=context, cancel_event=threading.Event())
|
||||
self.assertEqual(planned['memberFields'], [product_spec['key']])
|
||||
self.assertEqual(model.call_count, 2)
|
||||
repair_payload = model.call_args_list[1].kwargs['payload']
|
||||
self.assertEqual(repair_payload['validationDetails']['field'], 'memberFields')
|
||||
self.assertIn('产品图号', str(repair_payload['businessCatalog']['sourceFields']))
|
||||
self.assertIn('memberFields', model.call_args_list[0].kwargs['system'])
|
||||
self.assertIn('图号', model.call_args_list[0].kwargs['system'])
|
||||
self.assertIn('产品规格', model.call_args_list[0].kwargs['system'])
|
||||
|
||||
def test_column_filter_value_length_matches_backend_256_character_limit(self):
|
||||
rule = {'field': 'batchNumber', 'stages': ['black'], 'operator': 'in', 'values': ['X' * 256]}
|
||||
task = protocol_task(columnFilters=[rule])
|
||||
@@ -337,8 +569,11 @@ class SourceColumnProtocolTests(unittest.TestCase):
|
||||
catalog = {**CATALOG, 'extraFields': [{'key': 'customerCode'}]}
|
||||
context = bind_task({'_protocol': {'version': 1}, '_businessCatalog': catalog,
|
||||
'releaseId': RELEASE}, previous)
|
||||
product_spec = source_field('src_dynamic_new_task_spec', '产品规格', '产品规格黑片', '产品规格亮片')
|
||||
catalog['sourceFields'] = [*SOURCE_FIELDS, product_spec]
|
||||
context['_businessCatalog'] = catalog
|
||||
good = task_value(kind='members', dimensions=[], stages=['black', 'bright'], fields=[],
|
||||
memberFields=['product'], newTask=True, columnFilters=[],
|
||||
memberFields=[product_spec['key']], newTask=True, columnFilters=[],
|
||||
period={'year':2026,'month':9}, filterUpdates={'extraFilters':{'customerCode':['800001']}})
|
||||
bad = {**good, 'filterUpdates': {'customerCode':['800001']}}
|
||||
review = {'aligned':True, 'requiresEvidence':True, 'requiresSourceVerification':False,
|
||||
@@ -352,7 +587,7 @@ class SourceColumnProtocolTests(unittest.TestCase):
|
||||
self.assertTrue(repair['invalidPlan']['newTask'])
|
||||
self.assertEqual(planned['filters']['extraFilters'], {'customerCode':['800001']})
|
||||
self.assertEqual(planned['filters']['columnFilters'], [])
|
||||
self.assertEqual(planned['memberFields'], ['product'])
|
||||
self.assertEqual(planned['memberFields'], [product_spec['key']])
|
||||
self.assertEqual(planned['stages'], ['black','bright'])
|
||||
self.assertTrue(planned['newTask'])
|
||||
|
||||
|
||||
@@ -264,6 +264,9 @@ class WeightRankingTests(unittest.TestCase):
|
||||
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'})
|
||||
|
||||
Reference in New Issue
Block a user