同步:完善质量分析工作台并更新主题字体

同步已上线的智能分析执行协议、来源查询、图表报告与管理页面配套代码。
补齐数据库迁移、运行依赖和回归测试,保留原有指标计算口径。
统一午夜黑及其他主题的控件细节、中文和业务数字字体。
排除本地业务数据、凭据、预览、发布与验收产物。

验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
This commit is contained in:
2026-10-30 22:40:58 +08:00
parent edef747e3b
commit ff7bbe3e46
393 changed files with 62999 additions and 1783 deletions
+420
View File
@@ -0,0 +1,420 @@
"""Deterministic evidence contract for broad quality questions.
The contract is intentionally about queried business dimensions, not a claim
that source defect weights explain the formal composite rate. It never reads
unrelated turns or substitutes a different period, release, or filter scope.
"""
from __future__ import annotations
import re
from typing import Any
from nao_evidence_report import _filters, _same_periods, number, select_comparison_frames
from nao_product_defect_pairing import plan_missing_product_defect_stages
from nao_period import normalize_period
_BROAD = re.compile(r"整体|总体|全面分析|综合分析|公司质量|质量情况|质量怎么样")
_SIMPLE_NUMBER = re.compile(r"多少|几(?:%|个百分点|公斤|kg)|数值|是什么")
_ANALYSIS = re.compile(r"变化|分析|原因|关注|情况|下降|上升|趋势|怎么|如何")
_PRODUCT_PRIORITY = re.compile(r"重点(?:产品|规格)|关注.{0,8}(?:产品|规格)|哪些(?:产品|规格).{0,8}(?:最差|关注|重点)")
_FORMAL_FIELDS = {'rate': '合格率', 'scrapRate': '报废率',
'totalWeight': '投入重量', 'scrapWeight': '报废重量'}
def _period_equal(left, right):
try:
normalized_left, normalized_right = normalize_period(left), normalize_period(right)
except ValueError:
return False
return normalized_left is not None and normalized_left == normalized_right
def formal_metric_coverage(evidence: list[dict[str, Any]], question: str, context: Any = None) -> dict[str, Any] | None:
"""Bind a narrow explicit product/two-month request to formal stage fields.
Unrecognized language has no authoritative override. This contract never
infers a product, year, period, stage, or zero from an absent value.
"""
from nao_metric_request import metric_request
request = metric_request(question, context)
if not request: return None
product, periods, stages, fields = (request[key] for key in ('product', 'periods', 'stages', 'fields'))
contract = {'filters': request['filters'], 'periods': periods, 'stages': stages, 'fields': fields,
'metrics': [], 'missingEvidence': []}
requested_context = {**(context if isinstance(context, dict) else {}), 'filters': request['filters'],
'period': periods[0], 'comparisonPeriod': periods[1]}
roots, limitations = select_comparison_frames(evidence, requested_context)
root = roots[0] if len(roots) == 1 and not limitations else None
result = root['result'] if root else {}
expected_release = context.get('releaseId') if isinstance(context, dict) else None
actual_periods = [(result.get(side) or {}).get('period') for side in ('current', 'comparison')]
if (not root or not result.get('releaseId')
or expected_release is not None and result.get('releaseId') != expected_release
or _filters(result.get('filterBinding')) != contract['filters']
or any(period not in actual_periods for period in periods)):
contract['missingEvidence'] = ['缺少与本次明确规格、两期及数据版本一致的正式指标比较。']
return contract
from nao_quality_tools import (_valid_composite_rate_reference, _valid_stage_period_coverage,
_valid_stage_rate_reference, _valid_stage_scrap_rate_reference)
contract.update(evidenceRef=root['evidenceRef'], releaseId=result['releaseId'])
for side in ('current', 'comparison'):
snapshot = result[side]
for stage in stages:
metric_snapshot = {**snapshot, 'summary': {stage: snapshot.get(stage)}}
try:
source_ok, _ = _valid_stage_period_coverage(snapshot, snapshot['period'], stage)
rate_ok, _ = _valid_stage_rate_reference(metric_snapshot, snapshot['period'], stage)
scrap_rate_ok, _ = _valid_stage_scrap_rate_reference(metric_snapshot, snapshot['period'], stage)
except (KeyError, ValueError, TypeError):
source_ok = rate_ok = scrap_rate_ok = False
values = snapshot.get(stage) if isinstance(snapshot.get(stage), dict) else {}
for field in fields:
value = values.get(field)
numeric = number(value)
field_coverage = (rate_ok if field == 'rate' else
scrap_rate_ok if field == 'scrapRate' else source_ok)
covered = (field_coverage and numeric is not None
and not (field in ('scrapRate', 'scrapWeight') and numeric < 0))
contract['metrics'].append({'period': snapshot['period'], 'stage': stage, 'field': field,
'value': value, 'covered': covered, 'sourceCovered': source_ok})
if not covered:
period = snapshot['period']
label = '黑片' if stage == 'black' else '亮片'
contract['missingEvidence'].append(f'未取得规格{product}在{period["year"]}年{period["month"]}月{label}{_FORMAL_FIELDS[field]}的正式指标或来源覆盖。')
return contract
def resolve_proven_metric_gaps(contract: dict[str, Any] | None, missing: list[str]) -> tuple[list[str], list[str]]:
"""Refute only simple, fully understood claims of absent covered metrics.
Mixed explanations, row/detail requests, other products/periods, or unknown
wording remain missing. A server-wide coverage boolean is never sufficient.
"""
if not contract or contract['missingEvidence'] or not contract['metrics']:
return missing, []
retained, resolved = [], []
product = contract['filters']['product']
for item in missing:
text = item.replace(product, '该规格')
fields = [field for field, label in _FORMAL_FIELDS.items() if label in text]
stages = [stage for stage, label in (('black', '黑片'), ('bright', '亮片')) if label in text] or contract['stages']
# This intentionally small grammar does not interpret free-form model
# prose as a machine-readable coverage assertion.
simple = re.fullmatch(r'缺少(?:仅针对|针对|该规格|规格|分规格|两期|黑片|亮片|合格率|报废率|投入重量|报废重量|正式数据|数据|的|和|及|、|,|\s|[。;;])+', text)
if (simple and fields and set(fields) <= set(contract['fields'])
and set(stages) <= set(contract['stages'])
and all(row['covered'] for row in contract['metrics'] if row['stage'] in stages and row['field'] in fields)):
resolved.append(item)
else:
retained.append(item)
return retained, resolved
def _needs_broad_coverage(question: str) -> bool:
text = question if isinstance(question, str) else ""
return bool(_BROAD.search(text) and (not _SIMPLE_NUMBER.search(text) or _ANALYSIS.search(text)))
def is_coverage_question(question: str, context: Any = None) -> bool:
from nao_agent_task import task_from_context
task = task_from_context(context, question)
if task is not None:
return bool(task.get('dimensions'))
text = question if isinstance(question, str) else ''
return _needs_broad_coverage(text) or bool(_PRODUCT_PRIORITY.search(text))
def _same_scope(result: dict[str, Any], root: dict[str, Any]) -> bool:
return _filters(result.get('filters')) == _filters(root.get('filterBinding'))
def _matching(evidence: list[dict[str, Any]], root: dict[str, Any], kind: str, *,
dimension: str, stage: str | None = None) -> list[dict[str, Any]]:
return [doc['result'] for doc in evidence if isinstance(doc.get('result'), dict)
and doc['result'].get('kind') == kind
and doc['result'].get('releaseId') == root.get('releaseId')
and doc['result'].get('dimension') == dimension
and doc['result'].get('stage') == stage
and _same_periods(doc['result'], root)
and _same_scope(doc['result'], root)]
def _root(evidence: list[dict[str, Any]], context: Any) -> dict[str, Any] | None:
roots, limitations = select_comparison_frames(evidence, context)
return roots[0]['result'] if len(roots) == 1 and not limitations else None
def _requirements(evidence: list[dict[str, Any]], question: str, context: Any) -> list[tuple[str, str, str | None, str]]:
from nao_agent_task import task_from_context, dimension_stages
task = task_from_context(context, question)
if task is not None:
dimensions = task.get('dimensions', [])
requirements = []
for dimension, label in (('department', '产业部变化'), ('group', '业务分组变化'), ('product', '产品多维重点排序')):
if dimension in dimensions:
for stage in dimension_stages(task, dimension):
prefix = ('黑片' if stage == 'black' else '亮片') if dimension in task.get('dimensionStages', {}) and stage else ''
requirements.append(('quality_changes', dimension, stage, prefix + label))
if 'defect' in dimensions and task.get('defectScope', 'scope') in ('scope', 'both'):
requirements.extend(('quality_fine_defects', 'defect', selected,
('黑片' if selected == 'black' else '亮片') + '来源具体缺陷')
for selected in dimension_stages(task, 'defect'))
return requirements
stage = context.get('stage') if isinstance(context, dict) else None
if stage not in ('black', 'bright'):
stage = None
if not _needs_broad_coverage(question):
return ([('quality_changes', 'product', stage, '产品多维重点排序')]
if _PRODUCT_PRIORITY.search(question if isinstance(question, str) else '') else [])
stages = (stage,) if stage in ('black', 'bright') else ('black', 'bright')
requirements = [
('quality_changes', 'department', stage, '产业部变化'),
('quality_changes', 'group', stage, '业务分组变化'),
('quality_changes', 'product', stage, '产品多维重点排序'),
]
requirements.extend(('quality_fine_defects', 'defect', selected, ('黑片' if selected == 'black' else '亮片') + '来源具体缺陷')
for selected in stages)
return requirements
def _usable(rows: list[dict[str, Any]], kind: str, dimension: str) -> bool:
if kind == 'quality_changes':
return any(row.get('sort') in ('scrap_delta', 'current_scrap') for row in rows) if dimension == 'product' else bool(rows)
return any(row.get('coverage', {}).get('available') is True
and row.get('comparisonCoverage', {}).get('available') is True
and row.get('category') is None and row.get('defect') is None for row in rows)
def coverage_gaps(evidence: list[dict[str, Any]], question: str, context: Any = None) -> list[str]:
"""Return exact missing query dimensions; an unavailable source is not zero."""
gaps = []
from nao_agent_task import task_from_context
task = task_from_context(context, question)
if task is not None and task.get('trendRequired'):
from nao_agent_report import _build_trend_report
try:
trend = _build_trend_report(evidence, context, question)
if not trend.get('coverageSufficient'):
gaps.extend(trend.get('missingEvidence') or ['缺少本轮同期间、同范围的正式月度趋势。'])
except (KeyError, ValueError, TypeError):
gaps.append('本轮月度趋势依据未通过范围或完整性核验。')
if task is not None and task.get('period') and not task.get('comparisonPeriod') and not task.get('comparisonRequired'):
return list(dict.fromkeys([*gaps, *semantic_single_period_gaps(evidence, task, context)]))
if task is not None and task.get('comparisonRequired'):
if _root(evidence, context) is None:
gaps.append('尚无与本轮期间、范围一致的正式比较,不能判断变化。')
formal = formal_metric_coverage(evidence, question, context)
if formal:
gaps.extend(formal['missingEvidence'])
root = _root(evidence, context)
if task is not None and 'defect' in task.get('dimensions', []) and task.get('defectScope') in ('products', 'both'):
products = {}
if root is not None:
parent = _filters(root.get('filterBinding'))
from nao_agent_task import dimension_stages
stages = dimension_stages(task, 'defect')
for document in evidence:
result = document.get('result', {})
filters = _filters(result.get('filters'))
product = filters.pop('product', None)
if (not product or 'product' in parent or filters != parent or
result.get('kind') != 'quality_fine_defects' or result.get('dimension') != 'defect' or
result.get('releaseId') != root.get('releaseId') or not _same_periods(result, root) or
not _usable([result], 'quality_fine_defects', 'defect')):
continue
products.setdefault(product, set()).add(result.get('stage'))
complete = sum(set(stages) <= actual for actual in products.values())
else:
complete = 0
required = task.get('defectProductCount', 0)
if complete < required:
gaps.append(f'重点规格具体缺陷证据尚未覆盖要求的{required}项及对应阶段,当前完成{complete}项。')
if _requirements(evidence, question, context):
if root is None:
gaps.append('缺少同期间、同范围的正式比较,无法完成分析。')
else:
for kind, dimension, stage, label in _requirements(evidence, question, context):
rows = _matching(evidence, root, kind, dimension=dimension, stage=stage)
if not _usable(rows, kind, dimension):
gaps.append(f'未取得同期间、同范围的{label}证据。')
for args in plan_missing_product_defect_stages(evidence, question, context):
stage = '黑片' if args['stage'] == 'black' else '亮片'
product = args['filters']['product']
gaps.append(f'规格{product}缺少同期间、同范围的{stage}具体缺陷证据。')
return list(dict.fromkeys(gaps))
def semantic_single_period_gaps(evidence, task, context):
"""A single-period question is not forced into a two-period analysis."""
from nao_weight_ranking import ranking_task, ranking_gaps
if ranking_task(task): return ranking_gaps(evidence,task,context)
matches = []
expected = _filters(task['filters'])
for document in evidence:
result = document.get('result', {})
if context.get('releaseId') and result.get('releaseId') != context['releaseId']:
continue
filters = result.get('filterBinding') if result.get('kind') == 'quality_comparison' else result.get('filters')
period = (result.get('current') or {}).get('period') if result.get('kind') == 'quality_comparison' else result.get('period')
if _filters(filters) != expected or not _period_equal(period, task['period']):
continue
matches.append(result)
gaps = []
if not matches and task.get('freshQuery') and task['kind'] not in ('source_verify', 'details'):
gaps.append('未取得本轮指定期间、范围的正式统计。')
from nao_agent_task import dimension_stages
for dimension in task.get('dimensions', []):
for stage in dimension_stages(task, dimension):
candidates = [r for r in matches if (r.get('dimension') == dimension or r.get('view') == dimension)
and (r.get('stage') == stage if dimension in task.get('dimensionStages', {}) or stage is not None else True)]
if dimension == 'defect':
from nao_defect_report import matching_single_defects
candidates = [doc['result'] for doc in matching_single_defects(evidence, task, context)
if doc['result'].get('stage') == stage]
if not candidates:
gaps.append(f'未取得本轮指定期间、范围的{dimension}统计。')
return gaps
def semantic_metric_gaps(evidence, question, context):
"""Verify single/quarter/overall metric requests against formal snapshots."""
from nao_agent_task import task_from_context
from nao_evidence_report import _filters, number
from nao_quality_tools import (_valid_composite_rate_reference,
_valid_stage_period_coverage, _valid_stage_rate_reference,
_valid_stage_scrap_rate_reference)
task = task_from_context(context, question)
if task is None or task['kind'] != 'metrics': return []
snapshots = []
for document in evidence:
result = document.get('result', {})
if context.get('releaseId') and result.get('releaseId') != context['releaseId']: continue
filters = result.get('filterBinding') if result.get('kind') == 'quality_comparison' else result.get('filters')
if _filters(filters) != _filters(task['filters']): continue
if result.get('kind') == 'quality_comparison':
snapshots.extend(result.get(side, {}) for side in ('current', 'comparison'))
elif result.get('kind') == 'quality_metrics' and isinstance(result.get('summary'), dict):
snapshots.append({**result['summary'], 'period': result.get('period'), 'coverage': result.get('coverage')})
periods = [task[key] for key in ('period', 'comparisonPeriod') if task.get(key)]
if not periods:
# The model may resolve an omitted period from the actual data catalog.
periods = [s['period'] for s in snapshots if isinstance(s.get('period'), dict)]
if len({str(p) for p in periods}) > 1: return ['未明确绑定本轮指标的业务期间。']
periods = periods[:1]
if not periods: return ['未取得本轮指标的正式数据。']
gaps = []
for period in periods:
found = [s for s in snapshots if _period_equal(s.get('period'), period)]
for field in task['fields'] or ['rate']:
selected_stages = task['stages'] or (['black', 'bright'] if field == 'scrapRate' else [None])
for stage in selected_stages:
def covered(snapshot):
if stage is None and field == 'rate':
return _valid_composite_rate_reference(snapshot, period)[0]
if stage is None:
return False # No invented combined black/bright input denominator.
if field == 'rate':
return _valid_stage_rate_reference(snapshot, period, stage)[0]
if field == 'scrapRate':
return _valid_stage_scrap_rate_reference(snapshot, period, stage)[0]
if not _valid_stage_period_coverage(snapshot, period, stage)[0]:
return False
value = (snapshot.get(stage) or {}).get(field)
numeric = number(value)
return numeric is not None and not (field == 'scrapWeight' and numeric < 0)
if not any(covered(snapshot) for snapshot in found):
stage_label = {'black': '黑片', 'bright': '亮片'}.get(
stage, '各阶段' if field == 'scrapRate' else '综合')
field_label = _FORMAL_FIELDS.get(field, field)
gaps.append(f'未取得指定期间、范围的{stage_label}{field_label}正式指标或来源覆盖。')
return gaps
def plan_missing_source_queries(evidence: list[dict[str, Any]], task: dict[str, Any], context: Any = None) -> list[dict[str, Any]]:
"""Complete explicitly requested source checks in the exact parent frame."""
if not task.get('verifySource'): return []
from nao_evidence_finalizer import (_task_read_frame, _task_investigation_matches,
_task_side_matches, _source_proof_complete)
frame = _task_read_frame(evidence, task, context)
if frame is None: return []
stages = task.get('stages') or ['black', 'bright']
if any(stage not in ('black', 'bright') for stage in stages): return []
sides = ('current', 'comparison') if frame['comparisonPeriod'] is not None else ('current',)
planned = []
for stage in dict.fromkeys(stages):
found = {side:False for side in sides}
for document in evidence:
if not isinstance(document, dict): continue
result = document.get('result')
if (document.get('mode') != 'investigate' or not _task_investigation_matches(result, frame, stage)
or result.get('action') != 'source'): continue
for side in sides:
period = frame['currentPeriod'] if side == 'current' else frame['comparisonPeriod']
if _task_side_matches(result.get(side), frame, stage, period) and _source_proof_complete(result.get(side)):
found[side] = True
if all(found.values()): continue
query = {'mode':'investigate','action':'source','releaseId':frame['releaseId'],
'period':frame['currentPeriod'],'filters':frame['filters'], 'stage':stage,'limit':100}
if frame['comparisonPeriod'] is not None: query['comparisonPeriod'] = frame['comparisonPeriod']
planned.append(query)
return planned
def _missing_trend_query(evidence: list[dict[str, Any]], question: str, context: Any = None) -> list[dict[str, Any]]:
"""Query a missing trend only in the model-resolved, authorized exact frame."""
from nao_agent_task import task_from_context
task = task_from_context(context, question)
if not task or not task.get('trendRequired') or task.get('needsClarification'):
return []
period = task.get('period')
release = context.get('releaseId') if isinstance(context, dict) else None
filters = task.get('filters')
try:
period = normalize_period(period)
except ValueError:
return []
if (period is None or 'month' in period
or not isinstance(release, str) or not release.strip() or not isinstance(filters, dict)):
return []
allowed = {'department', 'group', 'product', 'projectGroup', 'extraFilters', 'includeUnassigned'}
if set(filters) - allowed:
return [] # Never silently drop an exclusion or another unsupported selector.
for document in evidence:
if not isinstance(document, dict) or document.get('mode') != 'query':
continue
result = document.get('result')
if (isinstance(result, dict) and result.get('kind') == 'quality_metrics'
and result.get('releaseId') == release and result.get('period') == period
and result.get('view') == 'overall' and _filters(result.get('filters')) == _filters(filters)):
return [] # Existing unavailable/truncated results are not repaired by guessing or looping.
return [{'mode': 'query', 'releaseId': release, 'period': dict(period),
'filters': dict(filters), 'view': 'overall'}]
def plan_missing_queries(evidence: list[dict[str, Any]], question: str, context: Any = None) -> list[dict[str, Any]]:
"""Plan only missing broad-analysis reads. Product-stage pairing has its own guard."""
trend_queries = _missing_trend_query(evidence, question, context)
root = _root(evidence, context)
if root is None:
return trend_queries
period = (root.get('current') or {}).get('period')
comparison = (root.get('comparison') or {}).get('period')
release = root.get('releaseId')
if not isinstance(period, dict) or not isinstance(comparison, dict) or not isinstance(release, str):
return trend_queries
allowed = ('department', 'group', 'product', 'projectGroup', 'extraFilters', 'includeUnassigned')
filters = {key: value for key, value in (root.get('filterBinding') or {}).items() if key in allowed}
planned = list(trend_queries)
for kind, dimension, stage, _ in _requirements(evidence, question, context):
rows = _matching(evidence, root, kind, dimension=dimension, stage=stage)
if _usable(rows, kind, dimension) or rows and kind == 'quality_fine_defects':
continue # A source reported unavailable; requerying cannot invent coverage.
common = {'releaseId': release, 'period': period, 'comparisonPeriod': comparison, 'filters': filters}
if kind == 'quality_changes':
planned.append({'mode': 'changes', **common, 'dimension': dimension,
**({'stage': stage} if stage else {}), 'sort': 'scrap_delta',
'limit': 100 if dimension in ('department', 'group') else 20})
else:
planned.append({'mode': 'defects', **common, 'dimension': 'defect',
'stage': stage, 'sort': 'current_scrap', 'limit': 20})
return planned