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

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

567 lines
37 KiB
Python

"""Native NAO reads through immutable, server-issued exploration scopes."""
from __future__ import annotations
import copy
import hashlib
import json
import time
from pathlib import Path
from nao_quality_tools import QualityTools, QualityToolError, SourceCoverageUnavailable, normalize_filters
from nao_query_contract import canonical_filters
def _proofs(value):
if not isinstance(value, dict):
return []
result = value.get('protocolEvidence')
# Never alias the signed response list. Callers use this helper while
# filtering immutable evidence documents; extending the source list with
# nested current/comparison proofs changes the proof count seen later by
# strict scope validation.
proofs = [result] if isinstance(result, dict) else list(result) if isinstance(result, list) else []
for side in ('current', 'comparison'):
if isinstance(value.get(side), dict):
proofs.extend(_proofs(value[side]))
return list({p['queryId']: p for p in proofs
if isinstance(p, dict) and isinstance(p.get('queryId'), str)}.values())
def native_model_view(result, *, compact=False, task=None):
"""The full signed response stays in evidence; omit transport duplication."""
def project(value):
if isinstance(value, list): return [project(item) for item in value]
if not isinstance(value, dict): return value
return {key:project(item) for key,item in value.items()
if key not in ('protocolEvidence','evidencePath','apiSource')
and not (key == 'meaning' and value.get('basis') == 'official_composite')}
view = project(result)
# Presentation only: raw signed values and proofs remain untouched. A
# stage's own rate change and its contribution to composite have different
# roles even though both use pp.
from nao_native_contract import MASS_FIELDS, formal_display_metadata
formal=result.get('kind') in ('quality_comparison','quality_metrics','quality_changes','quality_weight_ranking')
fine=result.get('kind')=='quality_fine_defects' and result.get('unit')=='kg'
def displays(node,path=()):
if isinstance(node,list):
for item in node:displays(item,path)
elif isinstance(node,dict):
metadata={}
for key,value in list(node.items()):
if isinstance(value,(dict,list)):displays(value,(*path,key));continue
stage='黑片' if 'black' in path or key.startswith('black') else '亮片' if 'bright' in path or key.startswith('bright') else None
field=unit=None
if (formal or fine) and key in MASS_FIELDS:field,unit=key,'kg'
elif 'stageDecomposition' in path and key.endswith('ContributionToCompositePP'):field,unit='stageContribution','pp'
elif 'stageRateChangesPP' in path:field,unit='rateChange','pp';stage={'black':'黑片','bright':'亮片'}.get(key)
if field:
display=formal_display_metadata(value,field,unit,stage,signed=unit=='pp')
if display:metadata[key]=display
if metadata:node['formalDisplay']=metadata
displays(view)
if formal:
def category_shares(node):
if isinstance(node,list):
for item in node:category_shares(item)
elif isinstance(node,dict):
categories=node.get('defects')
if isinstance(categories,list) and any(isinstance(item,dict) and 'rate' in item for item in categories):
# The official API's category rate uses listed category
# weights, which may not equal formal stage scrap weight.
# Name that denominator explicitly in the model view only.
node['categoryShareBasis']='sum_of_listed_category_weights'
for item in categories:
if isinstance(item,dict) and 'rate' in item:
item['shareOfListedCategoryWeight']=item.pop('rate')
for item in list(node.values()):category_shares(item)
category_shares(view)
if result.get('kind') == 'quality_changes' and isinstance(result.get('prioritySignals'),dict):
rows = {row.get('key'):row for row in result.get('rows',[]) if isinstance(row,dict)}
signals = {}
for name, entries in result['prioritySignals'].items():
projected = []
for item in entries if isinstance(entries,list) else []:
row = rows.get(item.get('key')) if isinstance(item,dict) else None
if row is not None and all(key in row and row[key] == value for key,value in item.items()):
projected.append({'key':item['key'], 'label':item.get('label',item['key']),
'sameAsReturnedRow':item['key']})
else:
projected.append(project(item))
signals[name] = projected
view['prioritySignals'] = signals
if compact:
from dsh_model_input import compact_tool_result
return compact_tool_result(view, task=task)
return view
def _source_field_binding(source_catalog, stage, selected_fields, expected_release_id=None):
"""Resolve only exact, stage-compatible values from the current catalog."""
if not isinstance(source_catalog, dict) or not isinstance(source_catalog.get('sourceFields'), list):
raise QualityToolError('请先读取当前发布版本catalog;没有已签发的原表字段目录,不能选择source字段。')
if not isinstance(expected_release_id, str) or not expected_release_id.strip():
raise QualityToolError('当前原件调查缺少冻结releaseId;不能绑定source字段。')
if source_catalog.get('releaseId') != expected_release_id:
raise QualityToolError('原表字段目录不属于当前releaseId;未注册或读取任何原件。')
if not isinstance(stage, str) or stage not in ('black', 'bright'):
raise QualityToolError('原表字段选择需要明确的黑片或亮片阶段。')
if not isinstance(selected_fields, list) or not 1 <= len(selected_fields) <= 32:
raise QualityToolError('原表fields须是1到32个当前catalog授权字段。')
catalog_rows = source_catalog['sourceFields']
by_key = {}
for row in catalog_rows:
if not isinstance(row, dict):
raise QualityToolError('当前catalog原表字段目录结构无效;请重新读取catalog。')
key = row.get('key')
if not isinstance(key, str) or not key.strip() or key in by_key:
raise QualityToolError('当前catalog原表字段stable key缺失或重复;不能绑定source字段。')
by_key[key] = row
keys, columns = [], []
for raw in selected_fields:
if not isinstance(raw, str) or not raw.strip():
raise QualityToolError('原表fields只能使用当前catalog中的stable key、唯一label或唯一原列名。')
row = by_key.get(raw)
if row is None:
candidates = []
for candidate in catalog_rows:
stages = candidate.get('stages')
column_map = candidate.get('columns')
column = column_map.get(stage) if isinstance(column_map, dict) else None
if (isinstance(stages, list) and stage in stages and isinstance(column, str) and column.strip()
and raw in (candidate.get('label'), column)):
candidates.append(candidate)
if len(candidates) > 1:
raise QualityToolError('原表字段label/原列名在当前阶段不唯一;请使用catalog返回的stable key。')
row = candidates[0] if candidates else None
if row is None:
raise QualityToolError('原表字段不在当前releaseId的catalog授权目录;未注册或读取任何原件。')
stages = row.get('stages')
column_map = row.get('columns')
column = column_map.get(stage) if isinstance(column_map, dict) else None
if not isinstance(stages, list) or stage not in stages or not isinstance(column, str) or not column.strip():
raise QualityToolError('原表字段不支持所选阶段;未扩大阶段或字段范围。')
key = row['key']
if key in keys:
raise QualityToolError('原表fields含重复字段;请使用唯一的catalog字段列表。')
keys.append(key)
columns.append(column)
return keys, columns
def _current_source_catalog(state, release_id):
cache = state.get('cache') if isinstance(state, dict) else None
candidates = [value for key, value in (cache.items() if isinstance(cache, dict) else [])
if isinstance(key, str) and key.startswith('catalog-')
and isinstance(value, dict) and value.get('releaseId') == release_id
and isinstance(value.get('sourceFields'), list)]
if not candidates:
raise QualityToolError('请先读取当前releaseId的catalog;原表字段未由当前发布版本授权。')
signatures = {json.dumps(value['sourceFields'], ensure_ascii=False, sort_keys=True,
separators=(',', ':')) for value in candidates}
if len(signatures) != 1:
raise QualityToolError('当前releaseId的catalog原表字段目录不一致;请重新读取完整目录后再调查。')
return candidates[-1]
def prepare_step(arguments, task, state, *, source_catalog=None):
"""Make a proposal, never an authorization. The server resolves every scope."""
args = copy.deepcopy(arguments)
agent_driven = task.get('agentDriven') is True
if agent_driven:
# 意图提示不锁定实际查询;每个新范围仍须由服务端签发。
task = copy.deepcopy(task)
task['filters'] = {}
task['stages'] = []
# Some providers encode object arguments as JSON strings. Decode only the
# declared period objects before comparing them with the authorized frame.
for key in ('period', 'comparisonPeriod'):
if isinstance(args.get(key), str):
try:
args[key] = json.loads(args[key])
except (ValueError, TypeError):
raise QualityToolError(key+'必须是期间对象,例如{year:2026,month:10}。', code='invalid_arguments') from None
if not isinstance(args[key], dict):
raise QualityToolError(key+'必须是期间对象。', code='invalid_arguments')
if agent_driven:
for key in ('period', 'comparisonPeriod'):
if key in args:
task[key] = args[key]
if 'groupBy' in args:
args['view'] = args.pop('groupBy')
if agent_driven and args.get('mode') == 'query' and args.get('comparisonPeriod') is not None:
args['mode'] = 'compare'
mode = args.get('mode')
if mode == 'details':
# The native protocol records complete, pageable investigation responses;
# the older sample-details endpoint cannot supply that proof.
args.update(mode='investigate', action='rows')
mode = 'investigate'
root = canonical_filters(task.get('filters') or {})
if isinstance(args.get('filters'), dict):
args['filters'] = {key: value for key, value in args['filters'].items()
if not (key in ('department','group','product','projectGroup')
and value in ('__ALL__','all','全部','全公司'))}
columns = root.pop('columnFilters', None)
supplied = canonical_filters(args.get('filters') or {})
supplied_columns = supplied.pop('columnFilters', columns)
for key, value in root.items():
if key in supplied and supplied[key] != value:
raise QualityToolError('调查不能改变已确认条件;修改条件请在新一轮提出。')
filters, _ = normalize_filters(args.get('scope'), {**root, **supplied},
scope_was_explicit='scope' in args)
if not root.get('includeUnassigned') and filters.get('includeUnassigned') is False:
filters.pop('includeUnassigned', None)
if not agent_driven and (supplied_columns != columns or ('columnFilters' in args and args['columnFilters'] != (columns or []))):
raise QualityToolError('调查不能修改已确认原表列条件。')
if columns is not None:
filters['columnFilters'] = columns
args['columnFilters'] = copy.deepcopy(columns)
elif agent_driven and supplied_columns is not None:
filters['columnFilters'] = supplied_columns
args['columnFilters'] = copy.deepcopy(supplied_columns)
args.pop('scope', None)
for key in ('period', 'comparisonPeriod'):
required = task.get(key)
if key == 'comparisonPeriod' and mode not in ('compare', 'changes', 'defects', 'investigate'):
continue
if required is not None:
if not agent_driven and key in args and args[key] != required:
from nao_period import normalize_period, expected_months
try:
supplied_period = normalize_period(args[key])
required_period = normalize_period(required)
except (ValueError, TypeError):
raise QualityToolError('期间格式无效;可省略period与comparisonPeriod以使用本轮已确认期间。', code='invalid_arguments') from None
if (not supplied_period or not required_period or supplied_period['year'] != required_period['year']
or expected_months(supplied_period) != expected_months(required_period)):
raise QualityToolError('调查期间必须沿用已确认任务。')
args[key] = copy.deepcopy(required)
args['filters'] = filters
allowed = task.get('stages') or ['black', 'bright']
stage = args.get('stage')
if stage is not None and stage not in allowed:
raise QualityToolError('调查阶段超出已确认范围。')
if len(allowed) == 1 and mode in ('defects', 'rank', 'top', 'investigate', 'details', 'changes'):
args.setdefault('stage', allowed[0])
stage = args['stage']
if args.get('releaseId') not in (None, state['releaseId']):
raise QualityToolError('调查不能切换数据版本。')
args['releaseId'] = state['releaseId']
parent_ids = []
parent_filters = root | ({'columnFilters': columns} if columns is not None else {})
# A verified earlier parent scope can supply more than one inherited filter.
candidates = [entry for entry in state.get('scopes', [])
if entry.get('queryIds') and all(filters.get(k) == v for k, v in entry['filters'].items())]
if candidates and not agent_driven:
parent = max(candidates, key=lambda entry: len(entry['filters']))
if len(parent['filters']) > len(parent_filters):
parent_filters = parent['filters']
parent_ids = parent['queryIds']
extras = {k: v for k, v in filters.items() if k not in parent_filters}
if agent_driven:
extras = {}
parent_ids = []
if set(extras) - {'department', 'group', 'product', 'projectGroup'} or len(extras) > 1:
raise QualityToolError('请先取得父范围证据,再沿授权目录逐层下钻;不能一次增加未核验的多层条件。')
selector = {'kind': 'base'}
if extras:
dimension, name = next(iter(extras.items()))
selector = {'kind': 'catalog_members', 'dimension': dimension, 'names': [name]}
node = {'nodeId': 'explore', 'selector': selector, 'visualPreference': task.get('visualPreference', 'auto'),
'visualType': None, 'comparisonRequired': False}
if mode in ('query', 'compare'):
# Overall endpoints already return both stages; this argument is a
# redundant selector, not permission to change the root stage frame.
args.pop('stage', None)
view = args.get('view', 'overall')
if mode == 'query':
args['view'] = view
if view not in ('overall','department','group','product') or mode == 'compare' and view != 'overall':
raise QualityToolError('query支持overall总体、department产业部、group业务分组、product产品批量汇总;compare只比较总体。')
if mode == 'compare':
args.pop('view', None)
node.update(purpose='trend' if mode == 'query' and task.get('trendRequired') else 'metrics',
fields=list(task.get('fields') or ['rate']), stages=list(task.get('stages') or []),
comparisonRequired=mode == 'compare')
if agent_driven and 'fields' in args:
selected = args.pop('fields')
if (not isinstance(selected, list) or not selected
or any(field not in ('rate','scrapRate','totalWeight','scrapWeight') for field in selected)):
raise QualityToolError('query.fields只能选择rate/scrapRate/totalWeight/scrapWeight,请修正后继续。',code='invalid_arguments')
node['fields'] = list(dict.fromkeys(selected))
if not node['stages'] and node['fields'] != ['rate']:
node['stages'] = ['black', 'bright']
if mode == 'query' and view != 'overall':
batch_limit = 500 if view == 'product' or task.get('aggregateSelection') else 100
node.update(purpose='metrics', dimension=view, limit=batch_limit)
args['limit'] = batch_limit # Page size, not the requested Top-N display count.
elif mode == 'changes':
node.update(purpose='changes', dimension=args.get('dimension'),
fields=['rate', 'totalWeight', 'scrapWeight'], stages=[stage] if stage else [],
comparisonRequired=True, sort=args.get('sort', 'scrap_delta'), limit=min(args.get('limit', 5), 100))
args['limit'] = node['limit']
elif mode in ('rank', 'defects'):
if mode == 'rank' and args.get('metric') not in ('totalWeight', 'scrapWeight'):
raise QualityToolError('rank缺少metric或值无效:投入/生产重量用totalWeight,报废重量用scrapWeight;请明确metric后重试,不能省略或猜测。')
if mode == 'rank' and args.get('limit', 10) > 100:
raise QualityToolError('原生排名单次最多100项。')
# A single exact product already fixes the object. With no defect
# field, the meaningful defect view is that product's defect breakdown.
if (mode == 'defects' and args.get('dimension') == 'product' and not args.get('defect')
and isinstance(filters.get('product'),str) and filters['product']
and not filters['product'].startswith('~qv1~')):
args['dimension'] = 'defect'
if mode == 'defects' and args.get('category') is not None:
from nao_quality_tools import _normalize_category
args['category'] = _normalize_category(stage, args['category'])
node.update(purpose='ranking' if mode == 'rank' else 'defects',
dimension=args.get('dimension', 'defect'), fields=[args['metric']] if mode == 'rank' else ['scrapWeight'],
stages=[stage] if stage else [], limit=args.get('limit', 10),
comparisonRequired=mode == 'defects' and bool(args.get('comparisonPeriod')))
if mode == 'rank' and agent_driven:
selected = args.pop('fields', [])
if not isinstance(selected, list) or any(field not in ('rate','totalWeight','scrapWeight') for field in selected):
raise QualityToolError('rank.fields仅支持rate/totalWeight/scrapWeight。',code='invalid_arguments')
if mode == 'rank' and stage:
node['fields'] = list(dict.fromkeys([*node['fields'],
*[field for field in task.get('fields', []) if field in ('totalWeight', 'scrapWeight')]]))
args['limit'] = node['limit']
for key in ('category', 'defect'):
if key in args: node[key] = args[key]
if mode == 'defects':
args.setdefault('dimension', 'defect')
# A report-wide composition hint is not the type of every child
# chart. Fine source Top lists use their actual weight bars.
node['visualType'] = 'bar'
elif mode in ('investigate', 'details'):
purpose = 'records' if mode == 'details' or args.get('action') == 'rows' else 'source'
action = args.get('action', 'overview')
if action not in ('source', 'rows'):
raise QualityToolError('自主协议原件调查只支持action=source或rows;正式概览用query,字段目录从当前releaseId的catalog读取。')
if not task.get('fullDetails' if purpose == 'records' else 'verifySource'):
raise QualityToolError('原始记录或原件核验需要用户明确要求,普通原因分析不能自动读取。')
if args.get('category') is not None:
if purpose == 'source':
raise QualityToolError('action=source不支持category筛选;请在相同已确认范围内核验原件,并读取响应中的categoryReconciliation。未丢弃该类别条件或扩大授权。')
raise QualityToolError('action=rows不支持category筛选;请使用已确认筛选或授权的具体字段,不会静默丢弃类别条件。')
if args.get('sourceRevisionId') is not None:
raise QualityToolError('自主协议原件scope未签发sourceRevisionId;不能切换或补充原件版本。')
if args.get('fields'):
field_keys, _ = _source_field_binding(source_catalog, stage, args['fields'], state.get('releaseId'))
args['fields'] = field_keys
if purpose == 'records':
args.update(action='rows', recordFilter='all')
args.setdefault('offset', 0)
args['limit'] = min(args.get('limit', 100), 100)
else:
args.update(action='source', limit=100)
args.pop('offset', None)
args.pop('recordFilter', None)
node.update(purpose=purpose, fields=[], stages=[stage] if stage else [],
visualPreference='none', comparisonRequired=bool(args.get('comparisonPeriod')))
if args.get('fields'):
node['sourceFields'] = {stage: copy.deepcopy(args['fields'])}
else:
raise QualityToolError('自主调查使用compare/query/changes/rank/defects;先读catalog了解能力。')
scope_arguments = copy.deepcopy(args)
if node['purpose'] == 'records':
# Pages are parts of one authorized record snapshot, not new scopes.
# Response caching below still uses the complete page arguments.
scope_arguments.pop('offset', None)
scope_arguments.pop('limit', None)
if agent_driven:
scope_arguments = {'arguments': scope_arguments, 'fields': node.get('fields'), 'stages': node.get('stages')}
request_key = hashlib.sha256(json.dumps(scope_arguments, sort_keys=True, ensure_ascii=False).encode()).hexdigest()
node['nodeId'] = 'e' + request_key[:24]
proposal = {'requestKey': request_key, 'node': node, 'parentQueryIds': parent_ids}
if agent_driven:
proposal['frame'] = {key: copy.deepcopy(args[key]) for key in ('period','comparisonPeriod','filters') if key in args}
return args, proposal
class NativeExplorationTools:
def __init__(self, *, delegated, evidence_dir, task, identity, state_path, directory=None):
self.delegated, self.evidence_dir, self.task = delegated, Path(evidence_dir), task
self.identity, self.state_path = identity, Path(state_path)
self.directory = copy.deepcopy(directory or {})
def observation_coverage(self, result):
snapshot = self.delegated.call('/api/analysis/protocol/queries', payload={}, method='POST')
pairs = {(p.get('nodeId'),p.get('scopeId')) for p in _proofs(result)}
rows = [row for row in snapshot.get('scopeCoverage', [])
if (row.get('nodeId'),row.get('scopeId')) in pairs]
def bounded(items):
return list(dict.fromkeys(str(item)[:600] for item in items if item))[:12]
return {**result, 'investigationCoverage': {
'scopeComplete': bool(rows) and all(row.get('complete') is True for row in rows),
'missingEvidence': bounded(gap for row in rows for gap in row.get('missingEvidence', [])),
'rootGoalGaps': [] if self.task.get('agentDriven') else bounded(snapshot.get('rootGoalGaps', [])),
'meaning': '正式结论须使用完整范围证据;未完整细项可换为明确已提供的具体字段查询,不能把缺失值当零。'}}
def quality_data(self, arguments):
from nao_quality_runtime import _atomic_json, _read_json, _require_private_regular_file, _file_lock
from nao_protocol_execution import ScopedApi
if not isinstance(arguments, dict):
raise QualityToolError('quality_data参数必须是对象。')
arguments = copy.deepcopy(arguments)
fresh = arguments.pop('freshQuery', False)
if type(fresh) is not bool:
raise QualityToolError('freshQuery必须是布尔值,仅明确重查时使用。')
# A published release is immutable within this execution. A model's
# refresh flag cannot produce newer data; a new turn has its own cache.
if self.task.get('agentDriven'):
fresh = False
# Even an in-turn cache hit must reauthorize the current turn.
self.delegated.call('/api/analysis/model-authorization', method='GET')
with _file_lock(self.state_path.with_suffix('.lock'), blocking=True):
state = _read_json(self.state_path) if _require_private_regular_file(self.state_path) else {}
if state.get('executionId') != self.identity['executionId']:
state = {'executionId': self.identity['executionId'], 'releaseId': self.identity['releaseId'],
'cache': {}, 'scopes': [], 'noProgress': 0, 'readCount': 0}
if state.get('halted') and not self.task.get('agentDriven'):
raise QualityToolError('连续三次未取得新证据,已停止调查并保留已核实结果。')
scoped = None
try:
if arguments.get('mode') == 'catalog':
key = 'catalog-' + hashlib.sha256(json.dumps(arguments, sort_keys=True).encode()).hexdigest()
if key in state['cache'] and not fresh:
return {**copy.deepcopy(state['cache'][key]), 'reusedEvidence': True}
if arguments.get('dimension') in ('product','department','group','projectGroup'):
dimension = arguments['dimension']
search = arguments.get('search', '')
limit = arguments.get('limit', 100)
if not isinstance(search, str) or len(search)>256 or type(limit) is not int or not 1<=limit<=100:
raise QualityToolError('catalog的search为短文本,limit为1到100整数。',code='invalid_arguments')
directory = self.delegated.call('/api/options?releaseId='+state['releaseId'],method='GET')
from nao_product_identification import _normalized, identify_products
match = identify_products(search, directory).get('productMatch', {}) if dimension=='product' and search else {}
candidates = [item['name'] for item in match.get('candidates', [])]
if not candidates:
candidates = [name for name in directory.get({'product':'products','department':'departments','group':'groups','projectGroup':'projectGroups'}[dimension], [])
if isinstance(name,str) and _normalized(search) in _normalized(name)]
result = {'kind':'quality_catalog_members','releaseId':state['releaseId'],'dimension':dimension,
'search':search,'candidateCount':len(candidates),'truncated':len(candidates)>limit,
'items':[{'name':name} for name in candidates[:limit]],
'guidance':'候选均来自当前账号可访问目录;多个不同完整规格时向用户提问,不猜选或合并。'}
state['cache'][key] = copy.deepcopy(result)
return result
result = QualityTools(api_factory=lambda: self.delegated,
evidence_dir=self.evidence_dir,
catalog_metadata_only=True).quality_data(arguments)
state['cache'][key] = copy.deepcopy(result)
return result
needs_source_catalog = (arguments.get('mode') in ('investigate', 'details')
and bool(arguments.get('fields')))
source_catalog = _current_source_catalog(state, state['releaseId']) if needs_source_catalog else None
args, proposal = prepare_step(arguments, self.task, state, source_catalog=source_catalog)
QualityTools(api_factory=lambda: self.delegated,
evidence_dir=self.evidence_dir)._validate_arguments(args)
cache_frame = {'arguments': args,
'fields': sorted(proposal['node'].get('fields', [])),
'stages': sorted(proposal['node'].get('stages', []))}
key = hashlib.sha256(json.dumps(cache_frame, sort_keys=True, ensure_ascii=False).encode()).hexdigest()
if key in state['cache'] and not fresh:
if state['cache'][key].get('status') == 'no_data':
return {**copy.deepcopy(state['cache'][key]), 'reusedEvidence':True}
state['noProgress'] += 1
state['halted'] = state['noProgress'] >= 3 and not self.task.get('agentDriven')
return self.active_result({**self.observation_coverage(copy.deepcopy(state['cache'][key])), 'reusedEvidence': True,
'investigationNotice': '复用本轮相同查询证据;请依据结果换调查方向或结束答复。'})
registrations = state.setdefault('registrations', {})
registered = registrations.get(proposal['requestKey'])
if registered is None:
registered = self.delegated.call('/api/analysis/protocol/exploration/steps', payload=proposal, method='POST')
registrations[proposal['requestKey']] = copy.deepcopy(registered)
scope = registered['scope']
child = registered['task']
selected_source_fields = proposal['node'].get('sourceFields')
if selected_source_fields:
selected_stage = args.get('stage')
expected_keys, expected_columns = _source_field_binding(
source_catalog, selected_stage, selected_source_fields.get(selected_stage),
state.get('releaseId'))
if selected_source_fields != {selected_stage: expected_keys}:
raise QualityToolError('待签发sourceFields与当前catalog不一致;原件范围未执行。')
if child.get('sourceFields') != selected_source_fields:
raise QualityToolError('服务端签发的sourceFields与请求不一致;原件范围未执行。')
if child.get('investigationFields') != {selected_stage: expected_columns}:
raise QualityToolError('服务端签发的原列映射与当前catalog不一致;原件范围未执行。')
args['fields'] = copy.deepcopy(expected_columns)
scoped = ScopedApi(self.delegated, registered['nodeId'], registered['scopeId'])
scoped.read_count = state['readCount']
tools = QualityTools(api_factory=lambda: scoped, evidence_dir=self.evidence_dir,
query_contract={'task': child, 'releaseId': state['releaseId'],
'exactScope': True, 'nodeId': registered['nodeId'],
'scopeId': registered['scopeId']})
tools._bulk_changes = True
started = time.monotonic()
result = tools.quality_data(args)
result['status'] = 'success'
state['queryElapsedMs'] = state.get('queryElapsedMs', 0) + round((time.monotonic() - started) * 1000)
proof_ids = [p['queryId'] for p in _proofs(result)]
if not proof_ids:
raise QualityToolError('查询未返回执行证明,不能作为自主调查证据。')
previous_result = state['cache'].get(key)
same_content = bool(previous_result and sorted(p.get('responseHash') for p in _proofs(previous_result))
== sorted(p.get('responseHash') for p in _proofs(result)))
state['cache'][key] = copy.deepcopy(result)
state['scopes'].append({'nodeId': registered['nodeId'], 'scopeId': registered['scopeId'],
'filters': child['filters'], 'queryIds': proof_ids})
state['noProgress'] = state['noProgress'] + 1 if same_content else 0
state['halted'] = state['noProgress'] >= 3 and not self.task.get('agentDriven')
if same_content:
result['investigationNotice'] = '已明确重查,但正式响应没有新增内容;请依据已有结果换调查方向或结束。'
return self.active_result(self.observation_coverage(result))
except SourceCoverageUnavailable as error:
# A successful authorized read with no published rows is a
# business outcome. Never invent zero metrics or an MCP error.
raw = error.response or {}
if (not isinstance(raw.get('coverage',{}).get('sourceMonths'),list)
or not raw.get('protocolEvidence',{}).get('queryId')):
raise QualityToolError('查询缺少来源覆盖或执行凭据,不能判作暂无数据。',code='unavailable') from None
result = {'kind':'quality_no_data','status':'no_data','message':str(error),
'releaseId':state['releaseId'],'period':copy.deepcopy(error.period),
'filters':copy.deepcopy(args.get('filters',{})), 'view':args.get('view','overall'),
'summary':None,'rows':[], 'coverage':raw.get('coverage',{}),
'protocolEvidence':raw.get('protocolEvidence',{})}
from nao_quality_tools import _json_safe
result = _json_safe(result)
evidence_id, evidence_path = tools._write_evidence(result, args['mode'])
result.update(evidenceId=evidence_id,evidenceRef=tools._evidence_ref(evidence_id),evidencePath=evidence_path)
state['cache'][key] = copy.deepcopy(result)
return result
except Exception as error:
state['noProgress'] += 1
state['halted'] = state['noProgress'] >= 3 and not self.task.get('agentDriven')
from nao_quality_runtime import RuntimeErrorSafe
safe = str(error)[:600] if isinstance(error, (RuntimeErrorSafe, QualityToolError, ValueError)) else type(error).__name__
state.setdefault('errors', []).append({'type': type(error).__name__, 'message': safe})
state['errors'] = state['errors'][-12:]
if isinstance(error, RuntimeErrorSafe):
code = ('forbidden' if error.http_status in (401,403) else
'invalid_arguments' if error.http_status in (400,409,422) else 'unavailable')
wrapped = QualityToolError(safe, code=code)
wrapped.http_status = error.http_status
raise wrapped from None
raise
finally:
if scoped is not None: state['readCount'] = scoped.read_count
_atomic_json(self.state_path, state)
def active_result(self, result):
"""Only the model projection omits inactive organizations; proofs stay intact."""
directory_key = {'department':'departments','group':'groups'}.get(result.get('view'))
if not directory_key or not self.directory.get(directory_key):
return result
visible = copy.deepcopy(result)
allowed = set(self.directory[directory_key])
rows = visible.get('rows',[])
visible['rows'] = [row for row in rows if row.get('key',row.get('label')) in allowed]
visible['rowsReturned'] = len(visible['rows'])
visible['rowCount'] = len(visible['rows']) if not visible.get('rowsTruncated') else visible.get('rowCount')
visible['organizationCoverage'] = {'activeOnly':True,'omittedInactiveCount':len(rows)-len(visible['rows']),
'summaryBasis':'正式总体汇总保持原口径,分组仅展示有效组织,不根据可见分组重新计算总体指标。'}
return visible