优化:未分类连续维护与柏拉图预汇总,同步已发布修复

This commit is contained in:
2026-11-01 12:40:50 +08:00
parent 572873c6b8
commit 38290f5fec
135 changed files with 17613 additions and 663 deletions
+246
View File
@@ -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()
+8 -6
View File
@@ -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")
+64
View File
@@ -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()
+30
View File
@@ -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()
+2 -1
View File
@@ -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'])
+129
View File
@@ -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'], [])
+81 -1
View File
@@ -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')
+60 -1
View File
@@ -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"))
+76 -5
View File
@@ -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'])
+17 -2
View File
@@ -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()
+304
View File
@@ -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()
+235
View File
@@ -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()
+10 -2
View File
@@ -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()
+35 -4
View File
@@ -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'])
+146
View File
@@ -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()
+238 -3
View File
@@ -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'])
+3
View File
@@ -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'})