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

验证:生产构建通过,320项前端回归通过;本轮仅同步Git,不再次部署。
2026-10-30 22:40:58 +08:00

601 lines
34 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Render verified single-period source-defect weights without inventing a comparison."""
from nao_evidence_report import _filters, _scope_label, number, shown, period, cell
from nao_agent_task import dimension_stages
import copy
def single_defect_task(task):
return bool(task and 'defect' in task.get('dimensions', []) and task.get('period')
and not task.get('comparisonPeriod') and not task.get('comparisonRequired'))
def matching_single_defects(evidence, task, context):
if not single_defect_task(task): return []
expected_release = (context or {}).get('releaseId')
matches = {}
for doc in evidence:
r = doc.get('result', {})
coverage = r.get('coverage') or {}
if (r.get('kind') != 'quality_fine_defects' or r.get('dimension') != 'defect'
or r.get('period') != task['period'] or r.get('comparisonPeriod') is not None
or expected_release is not None and r.get('releaseId') != expected_release
or _filters(r.get('filters')) != _filters(task.get('filters'))
or r.get('stage') not in dimension_stages(task, 'defect')
or r.get('category') is not None or r.get('defect') is not None
or coverage.get('available') is not True or coverage.get('hasValidWeights') is False
or not isinstance(r.get('sourceRows'), int) or r['sourceRows'] <= 0
or r.get('rankingComplete') is not True or not isinstance(r.get('rows'), list)):
continue
rows = r['rows']
if any(not isinstance(row, dict) or not isinstance(row.get('key'), str)
or number(row.get('weight')) is None or number(row['weight']) < 0 for row in rows):
continue
matches[r['stage']] = doc
return list(matches.values())
def build_single_defect_report(evidence, task, context):
docs = matching_single_defects(evidence, task, context)
if not docs: return None
facts, sections = [], []
covered = set()
for doc in docs:
r = doc['result']; stage = r['stage']; covered.add(stage)
label = '黑片' if stage == 'black' else '亮片'; ref = doc['evidenceRef']
table = ['| 序号 | 具体缺陷 | 大类 | 来源重量(kg) |', '| --- | --- | --- | --- |']
for index, row in enumerate(r['rows'], 1):
text = f'{label}具体缺陷{row.get("label") or row["key"]}:来源重量{shown(row["weight"])} kg;大类{row.get("category") or "未提供"}。'
facts.append({'id': 'F'+str(len(facts)+1), 'kind':'defect', 'label':row.get('label') or row['key'],
'text':text, 'evidenceRef':ref, 'stage':stage})
if index <= 5:
table.append('| ' + ' | '.join([str(index), cell(row.get('label') or row['key']), cell(row.get('category') or '未提供'), shown(row['weight'])]) + ' |')
if not r['rows']:
facts.append({'id':'F'+str(len(facts)+1),'kind':'defect','label':label,
'text':label+'当前范围没有可列出的有效具体缺陷排名。','evidenceRef':ref,'stage':stage})
sections.append('### '+period(task['period'])+' · '+label+'具体缺陷排名\n\n'+'\n'.join(table)+'\n\n['+ref+']')
missing = [('黑片' if stage == 'black' else '亮片')+'单期具体缺陷排名尚未取得同期间、范围的有效来源依据。'
for stage in dimension_stages(task, 'defect') if stage not in covered]
return {'headline':period(task['period'])+';'+_scope_label(task.get('filters') or {})+'。',
'facts':facts,'sections':sections,'missingEvidence':missing,'coverageSufficient':not missing,
'policy':'具体缺陷按来源字段分别统计,重量单位为kg;来源细分不等同于正式报废贡献,不据此判定生产根因,未提供的细分不补零。',
'rawMetrics':[]}
def _valid_defect_rows(rows, dimension, defect, source_fields, stage):
if not isinstance(rows, list) or not rows or not isinstance(source_fields, list):
return False
allowed_categories = ({'责废', '料废', '外废'} if stage == 'black'
else {'镀废', '材料废', '加工废', '扩散废'} if stage == 'bright' else set())
if not allowed_categories or len(source_fields) > 100:
return False
field_keys = set()
field_categories = {}
for item in source_fields:
key = item.get('key') if isinstance(item, dict) else None
if (not isinstance(item, dict) or not isinstance(item.get('key'), str)
or not item['key'].strip() or not item['key'].endswith('重量')
or item.get('sourceField', key) != key
or item.get('category') not in allowed_categories
or not isinstance(item.get('label', key), str) or not item.get('label', key).strip()
or item['key'] in field_keys):
return False
field_keys.add(item['key'])
field_categories[item['key']] = item['category']
if defect is not None and field_keys != {defect}:
return False
seen = set()
for row in rows:
if not isinstance(row, dict):
return False
key = row.get('key')
weight = number(row.get('weight'))
if not isinstance(key, str) or not key or key in seen or weight is None or weight < 0:
return False
seen.add(key)
if dimension == 'defect' and key not in field_keys:
return False
if dimension == 'defect' and row.get('category') != field_categories.get(key):
return False
if dimension == 'product':
if row.get('defect') != defect or row.get('category') != field_categories.get(defect):
return False
return True
def _defect_categories_reconciled(source_fields, reconciliation, requested_category=None, source_rows=None):
if not isinstance(source_fields, list) or not isinstance(reconciliation, list):
return False
selected_by_category = {}
for field in source_fields:
if (not isinstance(field, dict) or not isinstance(field.get('key'), str)
or not isinstance(field.get('category'), str)):
return False
selected_by_category.setdefault(field['category'], set()).add(field['key'])
expected = set(selected_by_category)
if requested_category is not None:
expected.add(requested_category)
if not expected:
return False
actual = {}
for item in reconciliation:
if isinstance(item, dict) and isinstance(item.get('category'), str):
if item['category'] in actual:
return False
actual[item['category']] = item
for category in expected:
item = actual.get(category)
selected = selected_by_category.get(category, set())
if not isinstance(item, dict) or not selected or type(item.get('isReconciled')) is not bool:
return False
item_source_rows = item.get('sourceRows')
if (type(item_source_rows) is not int or item_source_rows <= 0
or source_rows is not None and item_source_rows != source_rows):
return False
expected_fields = item.get('subitemFieldCount')
coverage = item.get('coverage')
components = item.get('components')
if (type(expected_fields) is not int or expected_fields < len(selected)
or not isinstance(coverage, dict) or type(coverage.get('total')) is not int
or coverage['total'] != expected_fields
or type(coverage.get('valid')) is not int or coverage['valid'] != len(selected)
or not isinstance(components, list)):
return False
component_by_key = {}
for component in components:
if not isinstance(component, dict) or not isinstance(component.get('key'), str):
return False
if component['key'] in component_by_key:
return False
component_by_key[component['key']] = component
# Java returns per-source-field row counts. Validate the requested
# field independently of the broader category add-back result.
if set(component_by_key) != selected:
return False
for component in component_by_key.values():
counts = [component.get(key) for key in
('sourceRows', 'presentRows', 'missingRows', 'invalidRows', 'negativeRows')]
if (any(type(count) is not int or count < 0 for count in counts)
or component['sourceRows'] != item_source_rows
or component['presentRows'] != item_source_rows
or component['missingRows'] != 0 or component['invalidRows'] != 0
or component['negativeRows'] != 0
or number(component.get('weight')) is None or number(component.get('weight')) < 0):
return False
selected_complete_category = len(selected) == expected_fields
if not selected_complete_category:
# A product/defect request may select one authorized raw field
# from a larger formal category. Java explicitly marks this as
# non-reconcilable; do not require a category add-back here.
reasons = item.get('reconciliationReasons')
if not isinstance(reasons, list) or not any(
reason in ('当前请求仅选了部分源缺陷字段,不能与大类完整回加',
'部分原始分项字段受授权限制,不能完整回加')
for reason in reasons):
return False
if item.get('isReconciled') is True:
return False
continue
# Compare the full category only when both sides have complete,
# comparable coverage. A valid numerical DIFF is reportable source
# evidence; it is not a missing-source condition or a formal KPI
# contribution. Reject only contradictory reconciliation flags.
formal_coverage = item.get('formalComponentCoverage')
formal_component = item.get('formalComponent')
formal_sum = number(item.get('formalComponentSum'))
diff = number(item.get('diff'))
formal_counts = ([formal_coverage.get(key) for key in
('sourceRows', 'presentRows', 'missingRows', 'invalidRows', 'negativeRows')]
if isinstance(formal_coverage, dict) else [])
formal_complete = (isinstance(formal_component, str) and bool(formal_component)
and formal_sum is not None and diff is not None
and len(formal_counts) == 5
and all(type(count) is int and count >= 0 for count in formal_counts)
and formal_counts[0] == item_source_rows and formal_counts[1] == item_source_rows
and formal_counts[2:] == [0, 0, 0])
if formal_complete:
reconciled_by_value = abs(diff) <= 0.000001
if item.get('isReconciled') is not reconciled_by_value:
return False
if item.get('isReconciled') is False and item.get('reconciliationStatus') != 'DIFF':
return False
elif item.get('isReconciled') is True:
return False
return True
def _defect_category_differences(source_fields, reconciliation):
"""Return full-category add-back differences for explicit source reporting."""
if not isinstance(source_fields, list) or not isinstance(reconciliation, list):
return []
selected_by_category = {}
for field in source_fields:
if isinstance(field, dict) and isinstance(field.get('category'), str) and isinstance(field.get('key'), str):
selected_by_category.setdefault(field['category'], set()).add(field['key'])
differences = []
for item in reconciliation:
if not isinstance(item, dict):
continue
category = item.get('category')
expected = item.get('subitemFieldCount')
selected = selected_by_category.get(category, set())
diff = number(item.get('diff'))
source_rows = item.get('sourceRows')
formal_coverage = item.get('formalComponentCoverage')
formal_counts = ([formal_coverage.get(key) for key in
('sourceRows', 'presentRows', 'missingRows', 'invalidRows', 'negativeRows')]
if isinstance(formal_coverage, dict) else [])
formal_complete = (isinstance(item.get('formalComponent'), str)
and bool(item.get('formalComponent'))
and number(item.get('formalComponentSum')) is not None
and type(source_rows) is int and source_rows > 0
and len(formal_counts) == 5
and all(type(value) is int for value in formal_counts)
and formal_counts[0] == source_rows and formal_counts[1] == source_rows
and formal_counts[2:] == [0, 0, 0])
if (type(expected) is int and expected > 0 and len(selected) == expected
and formal_complete and item.get('reconciliationStatus') == 'DIFF' and diff is not None):
differences.append({'category': category, 'diff': diff})
return differences
def _defect_partial_categories(source_fields, reconciliation):
if not isinstance(source_fields, list) or not isinstance(reconciliation, list):
return []
selected_by_category = {}
for field in source_fields:
if isinstance(field, dict) and isinstance(field.get('category'), str) and isinstance(field.get('key'), str):
selected_by_category.setdefault(field['category'], set()).add(field['key'])
partial = []
for item in reconciliation:
if not isinstance(item, dict):
continue
category = item.get('category')
expected = item.get('subitemFieldCount')
reasons = item.get('reconciliationReasons')
if (type(expected) is int and expected > len(selected_by_category.get(category, set()))
and isinstance(reasons, list)
and any(reason in ('当前请求仅选了部分源缺陷字段,不能与大类完整回加',
'部分原始分项字段受授权限制,不能完整回加')
for reason in reasons)):
partial.append(category)
return partial
def expand_defect_model_view(result, selected_defect=None):
"""Expand the lossless columnar form used in bounded evidence summaries."""
if not isinstance(result, dict):
return None
expanded = copy.deepcopy(result)
for reconciliation_key in ('categoryReconciliation', 'comparisonCategoryReconciliation'):
categories = expanded.get(reconciliation_key)
if categories is None:
continue
if not isinstance(categories, list):
return None
for category in categories:
if not isinstance(category, dict):
return None
has_columns = 'componentColumns' in category
has_values = 'componentValues' in category
if not has_columns and not has_values:
continue
if has_columns != has_values or 'components' in category:
return None
columns, values = category.get('componentColumns'), category.get('componentValues')
if (not isinstance(columns, list) or not columns
or any(not isinstance(column, str) or not column for column in columns)
or len(set(columns)) != len(columns)
or 'key' not in columns or not isinstance(values, list)):
return None
components = []
for row_values in values:
if not isinstance(row_values, list) or len(row_values) != len(columns):
return None
component = dict(zip(columns, row_values))
if not isinstance(component.get('key'), str) or not component['key']:
return None
components.append(component)
category.pop('componentColumns')
category.pop('componentValues')
category['components'] = components
if isinstance(expanded.get('pairedRows'), list):
return expanded
columns, values = expanded.get('defectColumns'), expanded.get('defectValues')
if not isinstance(columns, list) or not isinstance(values, list):
return expanded
if (len(set(columns)) != len(columns)
or not {'field', 'category', 'currentWeight', 'comparisonWeight', 'deltaWeight',
'currentPresent', 'comparisonPresent', 'deltaAvailable',
'deltaUnavailableReason'} <= set(columns)):
return None
positions = {name: index for index, name in enumerate(columns)}
coverage_keys = ('sourceRows', 'presentRows', 'missingRows', 'invalidRows', 'negativeRows')
paired, current_rows, seen = [], [], set()
for row_values in values:
if not isinstance(row_values, list) or len(row_values) != len(columns):
return None
row = dict(zip(columns, row_values))
key = row.get('field')
if not isinstance(key, str) or not key or key in seen:
return None
seen.add(key)
current = None
comparison = None
for side_name, present_key, weight_key in (
('current', 'currentPresent', 'currentWeight'),
('comparison', 'comparisonPresent', 'comparisonWeight')):
present = row.get(present_key)
if type(present) is not bool:
return None
if not present:
continue
side = {'key': key, 'label': key, 'category': row.get('category'),
'weight': row.get(weight_key)}
if isinstance(selected_defect, str):
side['defect'] = selected_defect
for field in coverage_keys:
stored = side_name + '_' + field
if stored in row:
side[field] = row[stored]
if side_name == 'current':
current = side
current_rows.append(side)
else:
comparison = side
delta_available = row.get('deltaAvailable')
if type(delta_available) is not bool:
return None
paired.append({'key': key, 'label': key, 'category': row.get('category'),
'present': {'current': row['currentPresent'],
'comparison': row['comparisonPresent']},
'current': current, 'comparison': comparison,
'deltaWeight': row.get('deltaWeight') if delta_available else None,
'deltaAvailable': delta_available,
'deltaUnavailableReason': row.get('deltaUnavailableReason')})
expanded['pairedRows'] = paired
expanded.setdefault('rows', current_rows)
if not isinstance(expanded.get('rows'), list):
expanded['rows'] = current_rows
# This row list exists only for structural evidence checks. Its count is
# tied to the restored current-side rows in the paired bounded result.
expanded['rowsReturned'] = len(expanded['rows'])
return expanded
def protocol_defect_report(evidence, task, release_id):
"""Build checked facts and a bounded table for one protocol defect scope."""
from nao_period import normalize_period
query = task.get('defectQuery') if isinstance(task, dict) else None
dimension = query.get('dimension') if isinstance(query, dict) else None
defect = query.get('defect') if isinstance(query, dict) else None
category = query.get('category') if isinstance(query, dict) else None
limit = query.get('limit') if isinstance(query, dict) else None
stages = task.get('stages') if isinstance(task, dict) else None
if (dimension not in ('defect', 'product') or type(limit) is not int or not 1 <= limit <= 100
or dimension == 'product' and not isinstance(defect, str)
or not isinstance(stages, list) or not stages):
return {'facts': [], 'sections': [], 'missingEvidence': ['服务器签发的缺陷查询范围无效。'],
'coverageSufficient': False, 'policy': '', 'rawMetrics': []}
try:
expected_period = normalize_period(task.get('period'))
expected_comparison = normalize_period(task.get('comparisonPeriod')) if task.get('comparisonRequired') else None
except (TypeError, ValueError):
expected_period = expected_comparison = None
if expected_period is None or task.get('comparisonRequired') and expected_comparison is None:
return {'facts': [], 'sections': [], 'missingEvidence': ['缺陷查询期间或比较期间无效。'],
'coverageSufficient': False, 'policy': '', 'rawMetrics': []}
expected_filters = _filters(task.get('filters'))
by_stage, missing = {}, []
for document in evidence if isinstance(evidence, list) else []:
raw_result = document.get('result') if isinstance(document, dict) else None
result = expand_defect_model_view(raw_result, defect) if isinstance(raw_result, dict) else None
stage = result.get('stage') if isinstance(result, dict) else None
if stage not in stages or stage in by_stage:
continue
if (document.get('mode') != 'defects' or result.get('kind') != 'quality_fine_defects'
or result.get('releaseId') != release_id or result.get('dimension') != dimension
or result.get('defect') != defect or result.get('category') != category
or _filters(result.get('filters')) != expected_filters):
continue
try:
if normalize_period(result.get('period')) != expected_period:
continue
if task.get('comparisonRequired'):
if normalize_period(result.get('comparisonPeriod')) != expected_comparison:
continue
elif result.get('comparisonPeriod') is not None:
continue
except (TypeError, ValueError):
continue
coverage = result.get('coverage')
rows = result.get('rows')
total = result.get('totalRows')
if (result.get('grain') != 'source_defect_weight'
or not isinstance(coverage, dict) or coverage.get('available') is not True
or coverage.get('hasValidWeights') is not True
or type(result.get('sourceRows')) is not int or result['sourceRows'] <= 0
or type(total) is not int or total < 0
or not isinstance(rows, list) or result.get('rowsReturned') != len(rows)
or not isinstance(result.get('truncated'), bool)
or result.get('rankingComplete') is not True
or not _valid_defect_rows(rows, dimension, defect, result.get('sourceFields'), stage)
or not _defect_categories_reconciled(result.get('sourceFields'),
result.get('categoryReconciliation'), category,
result.get('sourceRows'))
or any(not isinstance(row, dict) or not isinstance(row.get('category'), str)
or row.get('category') not in {'责废', '料废', '外废', '镀废', '材料废', '加工废', '扩散废'}
for row in rows)):
continue
if category is not None and not any(
isinstance(item, dict) and item.get('category') == category
for item in result.get('categoryReconciliation', [])):
continue
if task.get('comparisonRequired'):
paired = result.get('pairedRows')
compare_coverage = result.get('comparisonCoverage')
if (not isinstance(compare_coverage, dict) or compare_coverage.get('available') is not True
or compare_coverage.get('hasValidWeights') is not True
or type(compare_coverage.get('sourceRows')) is not int
or compare_coverage.get('sourceRows') <= 0
or result.get('pairingComplete') is not True
or result.get('pairedRankingComplete') is not True
or not isinstance(result.get('pairedTruncated'), bool)
or not isinstance(paired, list)
or not _defect_categories_reconciled(result.get('comparisonSourceFields'),
result.get('comparisonCategoryReconciliation'), category,
compare_coverage.get('sourceRows'))):
continue
seen, valid = set(), True
comparison_fields = result.get('comparisonSourceFields')
if not isinstance(comparison_fields, list):
valid = False
elif defect is not None and {item.get('key') for item in comparison_fields if isinstance(item, dict)} != {defect}:
valid = False
for row in paired:
if not isinstance(row, dict) or not isinstance(row.get('key'), str) or row['key'] in seen:
valid = False
break
seen.add(row['key'])
present = row.get('present')
if not isinstance(present, dict) or any(type(present.get(key)) is not bool for key in ('current', 'comparison')):
valid = False
break
for side_name in ('current', 'comparison'):
side = row.get(side_name)
if present[side_name]:
weight = number(side.get('weight')) if isinstance(side, dict) else None
if (not isinstance(side, dict) or side.get('key') != row['key'] or weight is None or weight < 0
or not _valid_defect_rows([side], dimension, defect,
comparison_fields if side_name == 'comparison'
else result.get('sourceFields'), stage)):
valid = False
break
elif side is not None:
valid = False
break
if not valid:
break
delta = row.get('deltaWeight')
if row.get('deltaAvailable') is True:
if not present['current'] or not present['comparison'] or number(delta) is None:
valid = False
break
elif delta is not None:
valid = False
break
if not valid:
continue
selected_document = copy.copy(document)
selected_document['result'] = result
by_stage[stage] = selected_document
facts, sections, required_fact_ids = [], [], []
for stage in stages:
document = by_stage.get(stage)
label = '黑片' if stage == 'black' else '亮片'
if document is None:
missing.append(label+'来源具体缺陷范围没有取得完整、同期间的正式细项证据。')
continue
result, ref = document['result'], document.get('evidenceRef')
paired = task.get('comparisonRequired') is True
shown_rows = (result.get('pairedRows') if paired else result.get('rows'))[:limit]
total = result.get('pairedTotalRows') if paired else result.get('totalRows')
top_text = f'返回Top {len(shown_rows)} 项 / 全范围 {total} 个分组'
if result.get('truncated') or paired and result.get('pairedTruncated'):
top_text += ';仅展示Top,不声称全名单或推断未返回分组的新进、退出'
if paired:
table = ['| 序号 | '+('具体缺陷' if dimension == 'defect' else '规格')+' | 对照期重量(kg) | 本期重量(kg) | 增减(kg) |',
'| --- | --- | ---: | ---: | ---: |']
caption = period(expected_comparison)+'→'+period(expected_period)
for index, row in enumerate(shown_rows, 1):
now, before = row.get('current'), row.get('comparison')
source = now if isinstance(now, dict) else before if isinstance(before, dict) else {}
row_label = source.get('label') or row.get('key')
now_value = shown(now.get('weight')) if isinstance(now, dict) else '未返回'
before_value = shown(before.get('weight')) if isinstance(before, dict) else '未返回'
delta = shown(row.get('deltaWeight'), signed=True) if row.get('deltaAvailable') is True else '不可比'
table.append('| '+' | '.join((str(index), cell(row_label), before_value, now_value, delta))+' |')
facts.append({'id':'F'+str(len(facts)+1),'kind':'defect','label':str(row_label),
'text':f'{label}来源细项{row_label}:{period(expected_comparison)}重量{before_value} kg,对照本期{period(expected_period)}重量{now_value} kg,增减{delta} kg。',
'evidenceRef':ref,'stage':stage})
if index <= 5:
required_fact_ids.append(facts[-1]['id'])
else:
table = ['| 序号 | '+('具体缺陷' if dimension == 'defect' else '规格')+' | 来源重量(kg) | 大类 |',
'| --- | --- | ---: | --- |']
caption = period(expected_period)
for index, row in enumerate(shown_rows, 1):
row_label, weight = row.get('label') or row.get('key'), shown(row.get('weight'))
table.append('| '+' | '.join((str(index), cell(row_label), weight, cell(row.get('category') or '未提供')))+' |')
facts.append({'id':'F'+str(len(facts)+1),'kind':'defect','label':str(row_label),
'text':f'{label}来源细项{row_label}:来源重量{weight} kg;大类{row.get("category") or "未提供"}。',
'evidenceRef':ref,'stage':stage})
if index <= 5:
required_fact_ids.append(facts[-1]['id'])
summary = {'id':'F'+str(len(facts)+1),'kind':'defect','label':label,
'text':f'{label}{"规格" if dimension == "product" else "具体缺陷"}来源重量Top:{top_text};期间{caption}。来源细项重量不等同于正式总体报废贡献。',
'evidenceRef':ref,'stage':stage}
facts.append(summary)
required_fact_ids.append(summary['id'])
table.extend(['',top_text+'。来源细项重量按原始字段分别统计,不作为正式scrapWeight贡献。'])
partial_categories = []
if paired:
partial_categories.extend(
('对照期', name) for name in _defect_partial_categories(
result.get('comparisonSourceFields'), result.get('comparisonCategoryReconciliation')))
partial_categories.extend(
('本期', name) for name in _defect_partial_categories(
result.get('sourceFields'), result.get('categoryReconciliation')))
else:
partial_categories.extend(
('本期', name) for name in _defect_partial_categories(
result.get('sourceFields'), result.get('categoryReconciliation')))
for period_label, partial_category in partial_categories:
partial_text = (f'{period_label}{partial_category}只查询了部分来源细项字段;'
'不与正式大类整体回加,来源细项重量与正式KPI分开解释。')
facts.append({'id':'F'+str(len(facts)+1),'kind':'defect',
'label':str(partial_category)+'部分来源字段口径',
'text':partial_text,'evidenceRef':ref,'stage':stage})
required_fact_ids.append(facts[-1]['id'])
table.append(partial_text)
category_differences = []
if paired:
category_differences.extend(
('对照期', item) for item in _defect_category_differences(
result.get('comparisonSourceFields'), result.get('comparisonCategoryReconciliation')))
category_differences.extend(
('本期', item) for item in _defect_category_differences(
result.get('sourceFields'), result.get('categoryReconciliation')))
else:
category_differences.extend(
('本期', item) for item in _defect_category_differences(
result.get('sourceFields'), result.get('categoryReconciliation')))
for period_label, difference_info in category_differences:
difference_text = (
f'{period_label}{difference_info["category"]}完整来源细项合计与正式大类口径相差 '
f'{shown(difference_info["diff"], signed=True)} kg(来源细项减正式大类);'
'这是两种口径的差异说明,不代表正式KPI贡献或已回加一致。')
facts.append({'id':'F'+str(len(facts)+1),'kind':'defect',
'label':str(difference_info['category'])+'来源与正式口径差异',
'text':difference_text,'evidenceRef':ref,'stage':stage})
required_fact_ids.append(facts[-1]['id'])
table.append(difference_text)
if ref:
table.append('['+str(ref)+']')
sections.append('### '+caption+' · '+label+'来源具体缺陷重量\n\n'+'\n'.join(table))
missing = list(dict.fromkeys(missing))
return {'headline':period(expected_period)+';'+_scope_label(expected_filters)+'。',
'facts':facts,'sections':sections,'missingEvidence':missing,
'coverageSufficient':bool(by_stage) and len(by_stage) == len(stages) and not missing,
'requiredFactIds':required_fact_ids,
'policy':'来源具体缺陷重量按原始字段分别聚合,不等同于正式报废重量或总体贡献;Top截断时不声称全名单,也不从未返回分组推断新增、退出。',
'rawMetrics':[]}