979 lines
56 KiB
Python
979 lines
56 KiB
Python
"""Seeded, disposable real-project acceptance; actual Qt mouse/keyboard UI only.
|
|
|
|
Prepare does not start CAD. Run requires the exclusive CAD slot. This deliberately
|
|
records a single engineering family; twenty tasks do not imply twenty designs.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
from collections import Counter
|
|
from datetime import datetime
|
|
import hashlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import random
|
|
import re
|
|
import secrets
|
|
import shutil
|
|
import sqlite3
|
|
import sys
|
|
import time
|
|
import traceback
|
|
|
|
|
|
def write(path, value):
|
|
path.write_text(json.dumps(value, ensure_ascii=False, indent=2), encoding='utf-8')
|
|
|
|
|
|
def fingerprint(directory):
|
|
return {p.relative_to(directory).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest()
|
|
for p in sorted(directory.rglob('*')) if p.is_file()}
|
|
|
|
|
|
def has_nc_marker(value):
|
|
return '/' in value and re.search(r'(?:^|/)\s*NC\s*(?:$|/)', value, re.I) is not None
|
|
|
|
|
|
def code_fingerprint(directory):
|
|
"""Fingerprint source/assets without installed dependencies or bytecode caches."""
|
|
result = {}
|
|
for current, directories, files in os.walk(directory):
|
|
directories[:] = sorted(name for name in directories if name not in {'node_modules', '__pycache__', '.git'})
|
|
for name in sorted(files):
|
|
path = Path(current) / name
|
|
if path.suffix != '.pyc':
|
|
result[path.relative_to(directory).as_posix()] = hashlib.sha256(path.read_bytes()).hexdigest()
|
|
return result
|
|
|
|
|
|
def prepare(root, source, graph, target_parts, *, seed=None, count=20, cells=(), supplemental='', part_prefixes=('4100',)):
|
|
root, source = Path(root).resolve(), Path(source).resolve(strict=True)
|
|
if root.exists() or root.is_relative_to(source.parent) or source.is_relative_to(root):
|
|
raise ValueError('Output must be a new directory outside the original project ancestry')
|
|
if (count < 20 and not supplemental) or not target_parts:
|
|
raise ValueError('At least20 cases and compatible target parts required')
|
|
if supplemental == 'rule_mode' and (count != 1 or list(target_parts) != ['4100-CA0000-T0']):
|
|
raise ValueError('rule_mode requires count=1 and target 4100-CA0000-T0')
|
|
root.mkdir(parents=True)
|
|
system_seed = seed is None
|
|
seed = secrets.randbits(128) if system_seed else seed
|
|
write(root / 'seed.json', {'seed': seed, 'created_ns': time.time_ns(), 'system_seed': system_seed})
|
|
rng = random.Random(seed)
|
|
candidates = sorted((c for c in graph['components'].values()
|
|
if c['refdes'] and c['attributes'].get('Part Number', '').startswith(tuple(part_prefixes))),
|
|
key=lambda c: c['refdes'])
|
|
if supplemental in {'rule_mode', 'pon_root'}:
|
|
if count != 1:
|
|
raise ValueError('Root supplemental requires count=1')
|
|
part_counts = Counter(c['attributes'].get('Part Number', '').casefold() for c in graph['components'].values())
|
|
ref_counts = Counter(c['refdes'].casefold() for c in graph['components'].values() if c['refdes'])
|
|
source_uids = Counter(c.get('source_uid', uid) for uid,c in graph['components'].items())
|
|
unique_source = {id(c): source_uids[c.get('source_uid',uid)] == 1 for uid,c in graph['components'].items()}
|
|
candidates = [c for c in candidates if not c.get('instance_path') and not c.get('source_refdes') and not c.get('ambiguous_attributes')
|
|
and c['attributes']['Part Number'].startswith('4100-')
|
|
and c['attributes']['Part Number'].casefold() not in {p.casefold() for p in target_parts}
|
|
and part_counts[c['attributes']['Part Number'].casefold()] == 1
|
|
and ref_counts[c['refdes'].casefold()] == 1 and len(c['pins']) == 2 and unique_source[id(c)]]
|
|
if not candidates:
|
|
raise ValueError('Root supplemental needs a globally unique root resistor Part Number')
|
|
elif len(candidates) < 2:
|
|
raise ValueError('Need two authentic compatible source resistor references')
|
|
kinds = ([supplemental] * count if supplemental else
|
|
['normal'] * (count - 9) + ['already_target'] * 2 + ['unknown_ref'] * 2 + ['stale_old'] * 2 + ['invalid_part', 'corrupt_database', 'pause_resume'])
|
|
rng.shuffle(kinds)
|
|
cases = []
|
|
for index, kind in enumerate(kinds):
|
|
nested = rng.choice(('项目', 'nested/工程', 'ASCII/boards'))
|
|
directory = root / 'projects' / f'{index+1:02d}-{kind}-{rng.randrange(10000,99999)}' / nested
|
|
directory.parent.mkdir(parents=True, exist_ok=True)
|
|
shutil.copytree(source.parent, directory)
|
|
project = directory / source.name
|
|
selected = rng.sample(candidates, 1 if kind in {'rule_mode','pon_root'} else rng.randint(1, 2))
|
|
requests = []
|
|
for comp in selected:
|
|
old = comp['attributes']['Part Number']
|
|
new = rng.choice(target_parts)
|
|
mode = rng.choice(('preserve', 'part_label', 'part_number', 'custom'))
|
|
request = {'refdes': comp['refdes'], 'old_part_number': old, 'new_part_number': new,
|
|
'value_mode': mode, 'custom_value': f'{rng.randrange(10000,99999)}Ω-验收',
|
|
'sync_nc': rng.choice((True, False)), 'enabled': True}
|
|
if kind == 'rule_mode':
|
|
request.update(value_mode='preserve', custom_value='', sync_nc=True)
|
|
elif kind == 'already_target':
|
|
request.update(old_part_number=new, new_part_number=old, value_mode='preserve')
|
|
elif kind == 'unknown_ref':
|
|
request['refdes'] = f'R_UNKNOWN_{rng.randrange(1000000)}'
|
|
elif kind == 'stale_old':
|
|
request['old_part_number'] = f'STALE-{rng.randrange(1000000)}'
|
|
elif kind == 'invalid_part':
|
|
request['new_part_number'] = f'NOT-IN-LIBRARY-{rng.randrange(1000000)}'
|
|
requests.append(request)
|
|
if kind == 'corrupt_database':
|
|
databases = [p for p in directory.rglob('*') if p.name == 'icdb.dat' and p.is_file()]
|
|
if len(databases) != 1:
|
|
raise ValueError('Expected one self-copied database to corrupt')
|
|
assert databases[0].resolve().is_relative_to((root / 'projects').resolve())
|
|
databases[0].write_bytes(b'RANDOM-ACCEPTANCE-CORRUPT-' + str(seed).encode())
|
|
cases.append({'id': index+1, 'kind': kind, 'project': str(project), 'requests': requests,
|
|
'target_cell': rng.choice(cells) if kind == 'valid_cell' and cells else '',
|
|
'fault': {'stage': 'native_replace', 'delay_seconds': rng.randint(3, 12)} if kind == 'force_stop' else None,
|
|
'input_hashes': fingerprint(directory)})
|
|
manifest = {'seed': seed, 'source': str(source), 'source_hashes': fingerprint(source.parent),
|
|
'family_limit': 'One ordinary authentic resistor engineering design; task semantics vary, project family does not.',
|
|
'target_parts': list(target_parts), 'part_prefixes': list(part_prefixes), 'available_cells': list(cells), 'cases': cases,
|
|
'source_code_hashes': code_fingerprint(Path(__file__).resolve().parents[1] / 'src'),
|
|
'integration_hashes': code_fingerprint(Path(__file__).resolve().parents[1] / 'integration'),
|
|
'code_fingerprint_exclusions': ['node_modules', '__pycache__', '.git', '*.pyc']}
|
|
write(root / 'manifest.json', manifest)
|
|
return manifest
|
|
|
|
|
|
def prepare_baseline(root):
|
|
from dx_productivity.trial_task_center.native_netlist import capture_project, export_netlist
|
|
manifest = json.loads((root / 'manifest.json').read_text(encoding='utf-8'))
|
|
result = export_netlist(capture_project(Path(manifest['source']), root / 'baseline-capture'), root / 'baseline-export')
|
|
if not result['complete']:
|
|
raise AssertionError(result)
|
|
match = re.search(r'^KEY CentralLibrary "([^"]+)"', Path(manifest['source']).read_text(encoding='utf-8'), re.M)
|
|
if match:
|
|
library = Path(match[1])
|
|
manifest['library'] = {'path': str(library), 'sha256': hashlib.sha256(library.read_bytes()).hexdigest(), 'bytes': library.stat().st_size}
|
|
manifest['baseline'] = str(root / 'baseline-export/graph.json')
|
|
write(root / 'manifest.json', manifest)
|
|
print(json.dumps({'baseline': result['status'], 'components': len(result['graph']['components'])}), flush=True)
|
|
|
|
|
|
def workbook(root, manifest):
|
|
from openpyxl import Workbook
|
|
headers = ['project_name', 'project_path', 'old_part_number', 'new_part_number', 'refdes',
|
|
'schematic_name', 'sheet_number', 'uid', 'enabled', 'custom_value', 'sync_nc', 'value_mode']
|
|
book = Workbook()
|
|
sheet = book.active
|
|
sheet.append(headers)
|
|
for case in manifest['cases']:
|
|
for request in case['requests']:
|
|
row = dict(request, project_name=Path(case['project']).stem, project_path=case['project'])
|
|
sheet.append([row.get(h, '') for h in headers])
|
|
book.save(root / 'random-bom.xlsx')
|
|
book.close()
|
|
|
|
|
|
def database(root, sql):
|
|
with sqlite3.connect((root / 'data/task-center.db').as_uri() + '?mode=ro', uri=True) as conn:
|
|
conn.row_factory = sqlite3.Row
|
|
return [dict(row) for row in conn.execute(sql)]
|
|
|
|
|
|
def import_timing(root):
|
|
lines = (root / 'data/logs/application.log').read_text(encoding='utf-8').splitlines()
|
|
starts, spans, import_started, import_seconds = {}, [], None, None
|
|
for line in lines:
|
|
match = re.search(r'operation_(start|complete)=(\w+) task_id=(\S*) at=(\S+)', line)
|
|
if not match:
|
|
continue
|
|
phase, operation, task_id, timestamp = match.groups()
|
|
stamp = datetime.fromisoformat(timestamp)
|
|
if operation == 'import_bom_drafts' and phase == 'start':
|
|
starts, spans, import_started = {}, [], stamp
|
|
if import_started is None:
|
|
continue
|
|
if operation == 'refresh_bound_project':
|
|
if phase == 'start':
|
|
starts[task_id] = stamp
|
|
elif task_id in starts:
|
|
spans.append((stamp-starts.pop(task_id)).total_seconds())
|
|
if operation == 'import_bom_drafts' and phase == 'complete':
|
|
import_seconds = (stamp-import_started).total_seconds()
|
|
import_started = None
|
|
result = {'import_total_seconds': import_seconds, 'metadata_refresh_count': len(spans),
|
|
'metadata_refresh_seconds_sum': sum(spans),
|
|
'note': 'Import total includes routing/metadata refresh and workbook I/O; it is not Excel parse time.'}
|
|
write(root / 'import-timing.json', result)
|
|
return result
|
|
|
|
|
|
def run_ui(root, *, pause=True, prepare_only=False):
|
|
"""Source-run visible windows; no service import/create/execute shortcut."""
|
|
from PySide6.QtCore import Qt, QTimer
|
|
from PySide6.QtTest import QTest
|
|
from PySide6.QtWidgets import QApplication, QDialogButtonBox, QFileDialog, QLineEdit, QMessageBox, QPushButton
|
|
from dx_productivity.trial_task_center.logging_setup import configure_logging
|
|
from dx_productivity.trial_task_center.store import TaskStore
|
|
from dx_productivity.trial_task_center.service import TaskCenterService
|
|
from dx_productivity.trial_task_center.ui import TrialTaskCenterWindow
|
|
|
|
manifest = json.loads((root / 'manifest.json').read_text(encoding='utf-8'))
|
|
pause = pause and len(manifest['cases']) > 1 and any(case['kind'] == 'pause_resume' for case in manifest['cases'])
|
|
assert fingerprint(Path(manifest['source']).parent) == manifest['source_hashes']
|
|
assert all(Path(c['project']).resolve().is_relative_to(root / 'projects') for c in manifest['cases'])
|
|
QApplication.setAttribute(Qt.ApplicationAttribute.AA_DontUseNativeDialogs)
|
|
app = QApplication.instance() or QApplication([])
|
|
logging = configure_logging(root / 'data')
|
|
store = TaskStore(root / 'data/task-center.db')
|
|
service = TaskCenterService(store, logging, supervised=True)
|
|
window = TrialTaskCenterWindow(service)
|
|
window.resize(1450, 1000)
|
|
window.show()
|
|
stamp = str(time.time_ns())
|
|
history = root / 'ui-history'
|
|
history.mkdir(exist_ok=True)
|
|
prior = root / 'ui-report.json'
|
|
if prior.exists():
|
|
shutil.copyfile(prior, history / (stamp + '-prior.json'))
|
|
results = {'mode': 'source Qt QTest visible mouse/keyboard UI, real supervised Mentor', 'started_ns': time.time_ns(), 'steps': [], 'failures': []}
|
|
shots = root / 'screenshots' / stamp
|
|
shots.mkdir(parents=True, exist_ok=True)
|
|
|
|
def record(step, **details):
|
|
results['steps'].append(dict(step=step, ns=time.time_ns(), **details))
|
|
write(root / 'ui-report.json', results)
|
|
window.grab().save(str(shots / f'{len(results["steps"]):02d}-{step}.png'))
|
|
print(json.dumps(results['steps'][-1], ensure_ascii=False), flush=True)
|
|
|
|
def wait(check, timeout=1200):
|
|
deadline = time.monotonic()+timeout
|
|
while time.monotonic() < deadline:
|
|
app.processEvents()
|
|
if check():
|
|
return
|
|
QTest.qWait(100)
|
|
raise TimeoutError('UI condition exceeded deadline')
|
|
|
|
def click(widget):
|
|
assert widget.isEnabled(), widget.objectName()
|
|
QTest.mouseClick(widget, Qt.MouseButton.LeftButton)
|
|
|
|
def text(widget, value):
|
|
widget.setFocus()
|
|
QTest.keyClick(widget, Qt.Key.Key_A, Qt.KeyboardModifier.ControlModifier)
|
|
app.clipboard().setText(str(value))
|
|
QTest.keyClick(widget, Qt.Key.Key_V, Qt.KeyboardModifier.ControlModifier)
|
|
|
|
def directory_dialog():
|
|
dialog = app.activeModalWidget()
|
|
if dialog is None or dialog.windowTitle() != '从目录创建工程任务':
|
|
QTimer.singleShot(100, directory_dialog)
|
|
return
|
|
text(dialog.findChild(QLineEdit, 'taskDirectory'), root / 'projects')
|
|
click(dialog.findChild(QPushButton, 'readTaskProjects'))
|
|
def create():
|
|
button = dialog.findChild(QDialogButtonBox).button(QDialogButtonBox.StandardButton.Ok)
|
|
if not button.isEnabled():
|
|
QTimer.singleShot(100, create)
|
|
return
|
|
record('directory-scanned')
|
|
click(button)
|
|
QTimer.singleShot(100, create)
|
|
|
|
def choose_bom():
|
|
dialog = app.activeModalWidget()
|
|
if not isinstance(dialog, QFileDialog):
|
|
QTimer.singleShot(100, choose_bom)
|
|
return
|
|
edit = dialog.findChild(QLineEdit, 'fileNameEdit')
|
|
text(edit, root / 'random-bom.xlsx')
|
|
QTest.keyClick(edit, Qt.Key.Key_Return)
|
|
|
|
def add_cell_rule(request, cell):
|
|
# Real rule dialog: load actual library choices, navigate the dropdown.
|
|
bar = window.mapping_tabs.tabBar()
|
|
QTest.mouseClick(bar, Qt.MouseButton.LeftButton, pos=bar.tabRect(0).center())
|
|
def fill():
|
|
dialog = app.activeModalWidget()
|
|
if dialog is None or dialog.windowTitle() != '替换规则':
|
|
QTimer.singleShot(100, fill)
|
|
return
|
|
text(dialog.old_edit, request['old_part_number'])
|
|
text(dialog.new_edit, request['new_part_number'])
|
|
click(dialog.cell_load_button)
|
|
def select():
|
|
if not dialog.cell_load_button.isEnabled():
|
|
QTimer.singleShot(100, select)
|
|
return
|
|
combo = dialog.cell_combo
|
|
index = combo.findData(cell)
|
|
if index < 0:
|
|
record('cell-choice-unavailable', expected=cell, status=dialog.cell_status.text())
|
|
click(dialog.buttons.button(QDialogButtonBox.StandardButton.Cancel))
|
|
return
|
|
combo.setFocus()
|
|
QTest.keyClick(combo, Qt.Key.Key_Home)
|
|
for _ in range(index):
|
|
QTest.keyClick(combo, Qt.Key.Key_Down)
|
|
record('cell-rule-selected', cell=combo.currentData(), refdes=request['refdes'])
|
|
click(dialog.buttons.button(QDialogButtonBox.StandardButton.Ok))
|
|
QTimer.singleShot(100, select)
|
|
QTimer.singleShot(100, fill)
|
|
click(window.add_mapping_button)
|
|
wait(lambda: not window._workers)
|
|
assert any(row['target_cell'] == cell for row in database(root, 'select * from rules'))
|
|
QTest.mouseClick(bar, Qt.MouseButton.LeftButton, pos=bar.tabRect(1).center())
|
|
|
|
try:
|
|
record('opened')
|
|
if window.auto_intervention_check.isChecked():
|
|
click(window.auto_intervention_check)
|
|
record('automatic-ai-disabled-for-independent-ui-acceptance')
|
|
if not database(root, 'select * from tasks'):
|
|
QTimer.singleShot(100, directory_dialog)
|
|
click(window.task_list.new_button)
|
|
wait(lambda: len(database(root, 'select * from tasks')) == len(manifest['cases']))
|
|
record('tasks-created', count=len(manifest['cases']))
|
|
wait(lambda: window.task_list.list.count() == len(manifest['cases']))
|
|
first = window.task_list.list.item(0)
|
|
QTest.mouseClick(window.task_list.list.viewport(), Qt.MouseButton.LeftButton,
|
|
pos=window.task_list.list.visualItemRect(first).center())
|
|
wait(window.plan_panel.import_bom_button.isEnabled)
|
|
cell_cases = [case for case in manifest['cases'] if case['target_cell']]
|
|
if cell_cases:
|
|
assert len(manifest['cases']) == 1, 'Cell supplemental UI uses one standalone task'
|
|
unique_rules = {(r['old_part_number'], r['new_part_number']): r for r in cell_cases[0]['requests']}
|
|
for request in unique_rules.values():
|
|
add_cell_rule(request, cell_cases[0]['target_cell'])
|
|
QTimer.singleShot(100, choose_bom)
|
|
click(window.plan_panel.import_bom_button)
|
|
wait(lambda: window.plan_panel._active_bom_import is None and window.plan_panel.last_bom_report is not None)
|
|
record('bom-imported', report=window.plan_panel.report_text, timings=import_timing(root))
|
|
if prepare_only:
|
|
record('prepare-only-finished')
|
|
return results
|
|
results['execution_source_hashes'] = code_fingerprint(Path(__file__).resolve().parents[1] / 'src')
|
|
results['execution_integration_hashes'] = code_fingerprint(Path(__file__).resolve().parents[1] / 'integration')
|
|
# Execute performs the single actual Save -> range confirmation UI flow.
|
|
def confirm():
|
|
dialog = app.activeModalWidget()
|
|
if not isinstance(dialog, QMessageBox):
|
|
QTimer.singleShot(100, confirm)
|
|
return
|
|
record('execution-confirmation', title=dialog.windowTitle(), text=dialog.text())
|
|
yes = dialog.button(QMessageBox.StandardButton.Yes)
|
|
if yes is None:
|
|
raise AssertionError('Unexpected modal instead of execution confirmation')
|
|
click(yes)
|
|
QTimer.singleShot(100, confirm)
|
|
button = window.findChild(QPushButton, 'executeProjectTasks')
|
|
wait(button.isEnabled)
|
|
click(button)
|
|
wait(lambda: bool(list((root / 'data/task-queues').glob('*.json'))))
|
|
record('execution-started')
|
|
last = None
|
|
paused_once = False
|
|
resumed = False
|
|
saved_before_resume = None
|
|
fault = next((case['fault'] for case in manifest['cases'] if case.get('fault')), None)
|
|
fault_stage_seen = None
|
|
forced = recovered = False
|
|
deadline = time.monotonic()+14400
|
|
while time.monotonic() < deadline:
|
|
app.processEvents()
|
|
tasks = database(root, 'select task_id,name,status,error_id from tasks order by group_position')
|
|
status = [(t['task_id'], t['status']) for t in tasks]
|
|
if status != last:
|
|
record('task-state', tasks=tasks)
|
|
last = status
|
|
queues_live = [json.loads(p.read_text(encoding='utf-8')) for p in (root / 'data/task-queues').glob('*.json')]
|
|
has_pause_window = any(
|
|
any(e['state'] == 'completed' for e in q['entries'].values())
|
|
and any(e['state'] == 'running' for e in q['entries'].values())
|
|
for q in queues_live)
|
|
if fault and not forced:
|
|
frames = [json.loads(p.read_text(encoding='utf-8')) for p in (root / 'data/tasks').glob('*/quick-run/worker-progress.json')]
|
|
in_stage = any(frame.get('stage') == fault['stage'] for frame in frames)
|
|
if in_stage and fault_stage_seen is None:
|
|
fault_stage_seen = time.monotonic()
|
|
if (in_stage and fault_stage_seen is not None
|
|
and time.monotonic()-fault_stage_seen >= fault['delay_seconds']
|
|
and window.run_panel.force_stop_button.isEnabled()):
|
|
QTimer.singleShot(100, confirm)
|
|
click(window.run_panel.force_stop_button)
|
|
forced = True
|
|
results['fault_injected'] = {'trigger': fault, 'frames': frames}
|
|
record('real-ui-force-stop-requested', fault=fault)
|
|
if pause and not paused_once and has_pause_window:
|
|
stop = window.run_panel.stop_queue_button
|
|
if stop.isEnabled():
|
|
click(stop)
|
|
paused_once = True
|
|
record('pause-requested')
|
|
if not window._workers:
|
|
queues = [json.loads(p.read_text(encoding='utf-8')) for p in (root / 'data/task-queues').glob('*.json')]
|
|
record('queue-idle', queues=queues)
|
|
if forced and not recovered:
|
|
for dialog in app.topLevelWidgets():
|
|
if dialog is not window and dialog.isVisible() and '替换结果' in dialog.windowTitle():
|
|
QTest.keyClick(dialog, Qt.Key.Key_Escape)
|
|
if window.run_panel.recover_button.isEnabled():
|
|
QTimer.singleShot(100, confirm)
|
|
click(window.run_panel.recover_button)
|
|
recovered = True
|
|
record('real-ui-recovery-requested')
|
|
QTest.qWait(500)
|
|
continue
|
|
record('force-stop-requires-manual-verification', message=window.run_panel.operator_band.text())
|
|
if paused_once and not resumed and window._project_queues:
|
|
saved_before_resume = saved_uids(root)
|
|
# Close actual result dialog to expose the same batch resume button.
|
|
for dialog in app.topLevelWidgets():
|
|
if dialog is not window and dialog.isVisible() and '替换结果' in dialog.windowTitle():
|
|
QTest.keyClick(dialog, Qt.Key.Key_Escape)
|
|
wait(button.isEnabled, timeout=30)
|
|
QTimer.singleShot(100, confirm)
|
|
click(button)
|
|
resumed = True
|
|
record('resume-confirmed', saved_uids=saved_before_resume)
|
|
QTest.qWait(500)
|
|
continue
|
|
break
|
|
QTest.qWait(500)
|
|
else:
|
|
raise TimeoutError('Actual execution still active; preserve process for observation')
|
|
results['tasks'] = database(root, 'select * from tasks')
|
|
if fault:
|
|
results['force_stop_actual'] = forced
|
|
results['recovery_actual'] = recovered
|
|
if saved_before_resume:
|
|
after = saved_uids(root)
|
|
assert all(after.get(key) == count for key, count in saved_before_resume.items()), 'Saved UID replayed on resume'
|
|
results['resume_saved_uid_no_replay'] = True
|
|
results['finished_ns'] = time.time_ns()
|
|
record('run-finished')
|
|
except BaseException:
|
|
results['failures'].append(traceback.format_exc())
|
|
write(root / 'ui-report.json', results)
|
|
raise
|
|
finally:
|
|
write(root / 'ui-report.json', results)
|
|
write(history / (stamp + '.json'), results)
|
|
# Keep Qt alive until owned workers release resources; never kill on timeout.
|
|
return results
|
|
|
|
|
|
def saved_uids(root):
|
|
events = []
|
|
for path in (root / 'data/tasks').glob('*/events.jsonl'):
|
|
for line in path.read_text(encoding='utf-8').splitlines():
|
|
event = json.loads(line)
|
|
if event.get('operation') == 'quick_run_executed' and event.get('details', {}).get('state') == 'saved_ok':
|
|
events.append((path.parent.name, event))
|
|
if not events:
|
|
return {}
|
|
try:
|
|
operations = database(root, '''SELECT o.task_id,o.command_json,o.receipt_json
|
|
FROM execution_operations o JOIN execution_rounds r
|
|
ON r.task_id=o.task_id AND r.round_id=o.round_id''')
|
|
bindings = {}
|
|
for row in operations:
|
|
receipt = json.loads(row['receipt_json'] or '{}')
|
|
if receipt.get('native_state') == 'saved_ok' and receipt.get('job_id'):
|
|
key = (row['task_id'], receipt['job_id'])
|
|
bindings.setdefault(key, []).append((json.loads(row['command_json']), receipt))
|
|
counts = Counter()
|
|
for task_id, event in events:
|
|
job = event['details']['timing']['job_id']
|
|
if not job or event.get('task_id', task_id) != task_id:
|
|
raise ValueError('Saved event task/job identity is missing or inconsistent')
|
|
command, receipt = bindings[(task_id, job)][0]
|
|
if len(bindings[(task_id, job)]) != 1:
|
|
raise ValueError('Saved event job is bound to multiple operations')
|
|
for uid in _saved_operation_uids(root, task_id, command, receipt):
|
|
counts[task_id + ':' + uid] += 1
|
|
return dict(counts)
|
|
except (OSError, sqlite3.Error, KeyError, TypeError, ValueError, IndexError) as error:
|
|
raise ValueError('Acceptance evidence insufficient: saved event job/UID binding: ' + str(error)) from error
|
|
|
|
|
|
def _saved_operation_uids(root, task_id, command, receipt):
|
|
if command.get('target_scope') == 'targets':
|
|
selectors = [selector.split('\x1f') for selector in command['target_selectors'].split('\x1e')]
|
|
if any(len(fields) != 3 or not re.fullmatch(r'\$\d+I\d+', fields[0]) for fields in selectors):
|
|
raise ValueError('Frozen target selectors lack exact native UIDs')
|
|
uids = [fields[0] for fields in selectors]
|
|
if len(set(uids)) != len(uids):
|
|
raise ValueError('Duplicate frozen selector UID')
|
|
return uids
|
|
if command.get('target_scope', 'all') != 'all' or command.get('target_selectors'):
|
|
raise ValueError('Unsupported saved operation scope')
|
|
from dx_productivity.trial_task_center.native_helper import read_snapshot, require_resumable_transaction
|
|
files = {Path(item['path']).resolve(strict=True): item['sha256'] for item in receipt['proof']['files']}
|
|
uids = set()
|
|
for path in files:
|
|
if not path.name.endswith('.native.json'):
|
|
continue
|
|
snapshot = Path(str(path).removesuffix('.native.json'))
|
|
owner = (root / 'data/tasks' / task_id).resolve()
|
|
if (not path.is_relative_to(owner) or snapshot not in files
|
|
or any(hashlib.sha256(p.read_bytes()).hexdigest() != files[p] for p in (path, snapshot))):
|
|
raise ValueError('Native receipt snapshot proof is missing, foreign or changed')
|
|
report = json.loads(path.read_text(encoding='utf-8'))
|
|
attempt = report['batch_attempt']
|
|
metadata, records = read_snapshot(snapshot)
|
|
if (report.get('ok') is not True or report.get('stage') != 'native_replace_verified'
|
|
or attempt['task_id'] != task_id or attempt['job_id'] != receipt['job_id']
|
|
or Path(metadata[1]).resolve() != Path(command['project_path']).resolve()
|
|
or [part.casefold() for part in metadata[2:4]] != [command['old_part'].casefold(), command['new_part'].casefold()]
|
|
or metadata[4] != command['schematic_name'] + ':' + command['sheet_number']):
|
|
raise ValueError('Native receipt does not bind this saved rule operation')
|
|
binding = require_resumable_transaction(snapshot, report, metadata, records)
|
|
uids.update(binding['source_uids'])
|
|
if not uids:
|
|
raise ValueError('Saved rule operation lacks proven native UIDs')
|
|
return sorted(uids)
|
|
|
|
|
|
def raw_attributes(path):
|
|
"""Independent tiny ASCII attribute reader, deliberately outside graph compare."""
|
|
result, ref = {}, None
|
|
raw = path.read_bytes()
|
|
try:
|
|
text = raw.decode('utf-8')
|
|
except UnicodeDecodeError:
|
|
text = raw.decode('mbcs')
|
|
for line in text.splitlines():
|
|
match = re.match(r' Symbol .+\tref des ([^\t]*)\tpage ', line)
|
|
if match:
|
|
ref = match[1]
|
|
if ref:
|
|
if ref in result:
|
|
raise ValueError('Independent acceptance requires unique root references')
|
|
result[ref] = {}
|
|
elif ref and line.startswith('\tProp '):
|
|
for name in ('Part Number', 'Part Label', 'Cell Name', 'Value'):
|
|
prefix = '\tProp ' + name + ' '
|
|
if line.startswith(prefix):
|
|
if name in result[ref]:
|
|
raise ValueError('Ambiguous raw attribute')
|
|
result[ref][name] = line[len(prefix):]
|
|
return result
|
|
|
|
|
|
def raw_identity_attributes(path):
|
|
"""Independent ASCII property multisets, retaining every gate and instance."""
|
|
data=path.read_bytes()
|
|
try:
|
|
text=data.decode('utf-8')
|
|
except UnicodeDecodeError:
|
|
text=data.decode('mbcs')
|
|
records=[]
|
|
current=None
|
|
for line in text.splitlines():
|
|
match=re.match(r' Symbol (.+?)\tref des ([^\t]*)\tpage ',line)
|
|
if match:
|
|
current={'source_uid':match[1],'refdes':match[2],'instance_path':'','properties':[], 'symbol':''}
|
|
records.append(current)
|
|
elif line.startswith((' Net ','Block ')):
|
|
current=None
|
|
elif current is not None:
|
|
if line.startswith('\tPath '):
|
|
value=line[6:].strip()
|
|
current['instance_path']='' if value in {'','root'} else value
|
|
elif line.startswith('\tProp '):
|
|
current['properties'].append(line[6:])
|
|
elif line.startswith('\tSymbol name '):
|
|
current['symbol']=line[13:]
|
|
if not records:
|
|
raise ValueError('Independent raw identity report contains no symbols')
|
|
return records
|
|
|
|
|
|
def unselected_raw_identities(records, selected_root_uids):
|
|
return Counter((row['source_uid'],row['instance_path'],row['refdes'],row['symbol'],tuple(sorted(row['properties'])))
|
|
for row in records if row['instance_path'] or row['source_uid'] not in selected_root_uids)
|
|
|
|
|
|
def selected_root_attributes(records, selected_root_uids):
|
|
result={}
|
|
found=set()
|
|
for row in records:
|
|
if row['instance_path'] or row['source_uid'] not in selected_root_uids:
|
|
continue
|
|
if row['source_uid'] in found or not row['refdes'] or row['refdes'] in result:
|
|
raise ValueError('Selected root UID/reference is not unique in independent ASCII')
|
|
found.add(row['source_uid'])
|
|
attrs={}
|
|
for prop in row['properties']:
|
|
for name in ('Part Number','Part Label','Cell Name','Value'):
|
|
if prop.startswith(name+' '):
|
|
if name in attrs:
|
|
raise ValueError('Selected root has ambiguous raw attribute: '+name)
|
|
attrs[name]=prop[len(name)+1:]
|
|
result[row['refdes']]=attrs
|
|
if found != selected_root_uids:
|
|
raise ValueError('Selected root UID is absent from independent ASCII')
|
|
return result
|
|
|
|
|
|
def force_recovery_evidence(root, *, expected_stage='native_replace', ui_report=None):
|
|
path=root/(ui_report or 'packaged-ui-report.json')
|
|
if ui_report is not None:
|
|
assert path.resolve().is_relative_to(root.resolve()) and path.is_file()
|
|
if path.exists():
|
|
report=json.loads(path.read_text(encoding='utf-8'))
|
|
assert report['stage']=='execute' and report.get('passed') is True
|
|
assert report['mode'].startswith('frozen EXE external Windows UIA')
|
|
assert Path(report['root']).resolve()==root.resolve()
|
|
session=json.loads((root/'ui-session.json').read_text(encoding='utf-8'))
|
|
assert report['pid']==session['pid'] and report['exe_sha256']==session['exe_sha256']
|
|
assert Path(report['exe']).resolve()==Path(session['executable']).resolve()
|
|
assert hashlib.sha256(Path(report['exe']).read_bytes()).hexdigest()==report['exe_sha256']
|
|
steps=[step['step'] for step in report['steps']]
|
|
assert 'real-ui-force-confirmed' in steps and 'real-ui-recovery-finished' in steps
|
|
assert steps.index('real-ui-force-confirmed') < steps.index('real-ui-recovery-finished')
|
|
forced=next(step for step in report['steps'] if step['step']=='real-ui-force-confirmed')
|
|
active=[frame for frame in forced['frames'] if frame.get('stage')==expected_stage]
|
|
assert active and all(re.fullmatch('[0-9a-f]{32}',frame.get('token',''))
|
|
and frame.get('job_id') and type(frame.get('sequence')) is int and frame['sequence']>0 for frame in active)
|
|
else:
|
|
path=root/'ui-report.json'
|
|
report=json.loads(path.read_text(encoding='utf-8'))
|
|
assert report.get('force_stop_actual') and report.get('recovery_actual')
|
|
return {'force_stop_actual':True,'recovery_observed':True,'ui_evidence':str(path),
|
|
'ui_evidence_sha256':hashlib.sha256(path.read_bytes()).hexdigest()}
|
|
|
|
|
|
def native_value_observation(text, *, job, uid, old, new):
|
|
"""Read count-complete raw COM groups; never derive baseline from reopened Value."""
|
|
decode = lambda value: re.sub(r'%([0-9a-fA-F]{4})', lambda m: chr(int(m[1], 16)), value)
|
|
groups, current, previous_sequence = [], None, 0
|
|
for line in text.lstrip('\ufeff').splitlines():
|
|
fields = [decode(field) for field in line.split('\t')]
|
|
if fields[0] == 'O':
|
|
if current is not None or len(fields) != 7 or fields[1] != job:
|
|
raise ValueError('Legacy, incomplete or foreign observation group')
|
|
sequence = int(fields[5])
|
|
if (sequence <= previous_sequence or (previous_sequence and sequence != previous_sequence+1)
|
|
or not 0 <= float(fields[4].replace(',', '.')) < 86400
|
|
or fields[6] not in {'before_native', 'pre_restore', 'restoring', 'save_pending', 'saved_readback'}):
|
|
raise ValueError('Invalid observation sequence or time')
|
|
current = {'job': fields[1], 'uid': fields[2], 'stage': fields[3], 'sequence': sequence,
|
|
'window': fields[6], 'attributes': {}}
|
|
elif fields[0] == 'E':
|
|
if (current is None or len(fields) != 7 or fields[1] != current['uid']
|
|
or int(fields[2]) != len(current['attributes']) or fields[6] != 'unknown'
|
|
or fields[3].casefold() in current['attributes']):
|
|
raise ValueError('Invalid attribute identity, ordinal or duplicate name')
|
|
current['attributes'][fields[3].casefold()] = fields[5] or fields[4]
|
|
elif fields[0] == 'Z_OBS':
|
|
if (current is None or len(fields) != 7
|
|
or fields[1:4] != [current['job'], current['uid'], current['stage']]
|
|
or int(fields[4]) != current['sequence'] or int(fields[5]) != len(current['attributes'])
|
|
or fields[6] != current['window']):
|
|
raise ValueError('Observation completion identity/count mismatch')
|
|
current['count'] = int(fields[5])
|
|
groups.append(current)
|
|
previous_sequence = current['sequence']
|
|
current = None
|
|
else:
|
|
raise ValueError('Unknown observation record')
|
|
if current is not None:
|
|
raise ValueError('Observation group has no completion marker')
|
|
selected = [group for group in groups if group['uid'] == uid]
|
|
seen_old, candidate = False, None
|
|
for index, group in enumerate(selected):
|
|
part = group['attributes'].get('part number')
|
|
if part == old and candidate is None and group['window'] == 'before_native':
|
|
seen_old = True
|
|
elif part == new and candidate is None:
|
|
if not seen_old or group['window'] != 'pre_restore':
|
|
raise ValueError('First target observation is outside the native pre-restoration window')
|
|
if not any(g['window'] in {'restoring', 'save_pending', 'saved_readback'} for g in selected[index+1:]):
|
|
raise ValueError('Native observation has no later restoration/save boundary')
|
|
candidate = group
|
|
elif part not in {old, new} or (candidate is not None and part != new):
|
|
raise ValueError('Observation Part Number differs from bound transaction')
|
|
if candidate is None:
|
|
raise ValueError('Bound native intermediate observation is missing')
|
|
reopened = next((g for g in reversed(selected) if g['sequence'] > candidate['sequence']
|
|
and g['window'] == 'saved_readback'), None)
|
|
result = {'sequence': candidate['sequence'], 'count': candidate['count'], 'stage': candidate['stage'],
|
|
'window': candidate['window'],
|
|
'value': candidate['attributes'].get('value', ''), 'present': 'value' in candidate['attributes'],
|
|
'part_label': candidate['attributes'].get('part label'), 'uid': uid, 'job': job}
|
|
if reopened is not None:
|
|
result.update(reopened_present='value' in reopened['attributes'], reopened_value=reopened['attributes'].get('value', ''),
|
|
reopened_sequence=reopened['sequence'], reopened_count=reopened['count'])
|
|
return result
|
|
|
|
|
|
def bound_native_observation(root, task_id, uid, request):
|
|
work = root / 'data/tasks' / task_id / 'quick-run'
|
|
matches = []
|
|
for path in work.glob('snapshot-*.tsv.native.json'):
|
|
record = json.loads(path.read_text(encoding='utf-8'))
|
|
transaction, attempt = record.get('transaction', {}), record.get('batch_attempt', {})
|
|
if uid not in transaction.get('source_uids', ()):
|
|
continue
|
|
snapshot = Path(record['snapshot']).resolve(strict=True)
|
|
if (not snapshot.is_relative_to(work.resolve()) or not record.get('ok')
|
|
or record.get('stage') != 'native_replace_verified' or attempt.get('task_id') != task_id
|
|
or transaction.get('old_part_number') != request['old_part_number']
|
|
or transaction.get('new_part_number') != request['new_part_number']
|
|
or hashlib.sha256(snapshot.read_bytes()).hexdigest() != transaction.get('snapshot_sha256')
|
|
or not record.get('native_options', {}).get('1700', {}).get('checked')):
|
|
raise ValueError('Native intermediate transaction binding is invalid')
|
|
library_row = record.get('library_row', ())
|
|
if len(library_row) != 7 or library_row[1] != request['new_part_number']:
|
|
raise ValueError('Raw selected library row does not match target Part Number')
|
|
job = attempt['job_id']
|
|
observations = work / ('attribute-observations-' + job + '.tsv')
|
|
result = native_value_observation(observations.read_text(encoding='utf-8-sig'), job=job, uid=uid,
|
|
old=request['old_part_number'], new=request['new_part_number'])
|
|
result.update(raw_observation=str(observations), native_transaction=str(path),
|
|
observation_sha256=hashlib.sha256(observations.read_bytes()).hexdigest(),
|
|
transaction_sha256=hashlib.sha256(path.read_bytes()).hexdigest(), library_row=list(library_row))
|
|
matches.append(result)
|
|
if len(matches) != 1:
|
|
raise ValueError('Native intermediate transaction is absent or ambiguous')
|
|
return matches[0]
|
|
|
|
|
|
def rule_netlist_evidence(root, task, entry, case, before):
|
|
"""Require the application's frozen rule -> native UID -> whole-graph result."""
|
|
assert not task['target_plan_mode'] and not task['copy_part_number_to_value']
|
|
request, = case['requests']
|
|
uid, = [uid for uid, comp in before['components'].items() if comp['refdes'] == request['refdes']]
|
|
assert not before['components'][uid].get('instance_path')
|
|
assert before['components'][uid]['attributes']['Part Number'] == request['old_part_number']
|
|
path = Path(entry['netlist_verification']['report_path']).resolve(strict=True)
|
|
assert path.is_relative_to((root / 'data/tasks' / task['task_id'] / 'netlist-checks').resolve())
|
|
report = json.loads(path.read_text(encoding='utf-8'))
|
|
plan_path = path.with_name('plan.json')
|
|
plan = json.loads(plan_path.read_text(encoding='utf-8'))
|
|
assert plan['rows'] == [] and plan['copy_value'] is False
|
|
assert Path(plan['project_path']).resolve() == Path(case['project']).resolve()
|
|
assert plan['rules'] == [{'old_part': request['old_part_number'].casefold(),
|
|
'new_part': request['new_part_number'].casefold(), 'value_mode': 'preserve',
|
|
'custom_value': '', 'sync_nc': '1', 'target_cell': ''}]
|
|
assert report['status'] == 'verified' and report['verified'] is True
|
|
assert all(report[side]['status'] == 'success' and report[side]['complete'] is True for side in ('before', 'after'))
|
|
scope, = report['rule_scopes']
|
|
assert scope['source_uids'] == [uid] and scope['schematic_name'] and scope['sheet_number']
|
|
assert Path(scope['project_path']).resolve() == Path(case['project']).resolve()
|
|
assert scope['old_part'].casefold() == request['old_part_number'].casefold()
|
|
assert scope['new_part'].casefold() == request['new_part_number'].casefold()
|
|
assert set(report['expected_changes']) == {uid}
|
|
return {'bound_uid': uid, 'rule_scope': scope, 'verification_report': str(path),
|
|
'verification_sha256': hashlib.sha256(path.read_bytes()).hexdigest(),
|
|
'frozen_plan': str(plan_path), 'plan_sha256': hashlib.sha256(plan_path.read_bytes()).hexdigest()}
|
|
|
|
|
|
def queue_entries(root, *, queue_id=None):
|
|
result = {}
|
|
directory = root / 'data/task-queues'
|
|
if queue_id is not None:
|
|
if not isinstance(queue_id, str) or not re.fullmatch('[0-9a-f]{32}', queue_id):
|
|
raise ValueError('Invalid explicit queue identity')
|
|
paths = [directory / (queue_id + '.json')]
|
|
else:
|
|
paths = directory.glob('*.json')
|
|
for path in paths:
|
|
queue = json.loads(path.read_text(encoding='utf-8'))
|
|
reports = queue.get('netlist_verification', {})
|
|
for task_id, entry in queue.get('entries', {}).items():
|
|
result[task_id] = dict(entry)
|
|
if task_id in reports:
|
|
result[task_id]['netlist_verification'] = reports[task_id]
|
|
return result
|
|
|
|
|
|
def verify(root, *, queue_id=None, force_ui_report=None):
|
|
"""Fresh native CLI exports, independent comparisons, no Mentor fallback."""
|
|
from dx_productivity.trial_task_center.native_netlist import capture_project, export_netlist
|
|
manifest = json.loads((root / 'manifest.json').read_text(encoding='utf-8'))
|
|
before = json.loads(Path(manifest['baseline']).read_text(encoding='utf-8'))
|
|
references=Counter(c['refdes'] for c in before['components'].values() if c['refdes'])
|
|
complex_graph=(any(count>1 for count in references.values())
|
|
or any(c.get('instance_path') or c.get('ambiguous_attributes') for c in before['components'].values()))
|
|
original_identities=raw_identity_attributes(Path(manifest['baseline']).with_name('effective.txt')) if complex_graph else None
|
|
original_raw = {} if complex_graph else raw_attributes(Path(manifest['baseline']).with_name('effective.txt'))
|
|
tasks = database(root, 'select * from tasks')
|
|
projects = database(root, 'select * from projects')
|
|
entries = queue_entries(root, queue_id=queue_id)
|
|
stamp = str(time.time_ns())
|
|
if (root / 'independent-report.json').exists():
|
|
archive = root / 'independent-report-history'
|
|
archive.mkdir(exist_ok=True)
|
|
shutil.copyfile(root / 'independent-report.json', archive / (stamp + '.json'))
|
|
report = {'reader': 'Fresh native ASCII+Keyin CLI export; independent raw attributes and pin/net comparison',
|
|
'started_ns': int(stamp), 'preserve_contract': 'Preserve native Replace Part result, not old component Value.',
|
|
'cases': [], 'passed': False}
|
|
for case in manifest['cases']:
|
|
project = Path(case['project'])
|
|
row = next(p for p in projects if Path(p['path']).resolve() == project.resolve())
|
|
task = next(t for t in tasks if t['task_id'] == row['task_id'])
|
|
entry = entries.get(task['task_id'], {})
|
|
item = {'id': case['id'], 'kind': case['kind'], 'task_id': task['task_id'], 'task_status': task['status'], 'queue_entry': entry, 'passed': False}
|
|
try:
|
|
if case['kind'] == 'rule_mode':
|
|
item['rule_mode_evidence'] = rule_netlist_evidence(root, task, entry, case, before)
|
|
if entry.get('state') in {None, 'pending', 'running'}:
|
|
raise AssertionError('Whole-flow task has not reached a terminal acceptance state; do not count it')
|
|
expected_negative = case['kind'] in {'unknown_ref', 'stale_old', 'invalid_part', 'corrupt_database'}
|
|
if case['kind'] == 'corrupt_database':
|
|
assert entry.get('state') == 'failed'
|
|
assert hashlib.sha256((project.parent / 'database/icdb.dat').read_bytes()).hexdigest() == case['input_hashes']['database/icdb.dat']
|
|
item.update(passed=True, unchanged_corrupt_database=True)
|
|
else:
|
|
start = time.monotonic()
|
|
destination = root / 'independent' / stamp / f'{case["id"]:02d}'
|
|
output = export_netlist(capture_project(project, destination / 'capture'), destination / 'export')
|
|
assert output['complete'], output.get('reason')
|
|
after = output['graph']
|
|
selected = {request['refdes']: request for request in case['requests']}
|
|
if complex_graph:
|
|
selected_uids={uid for uid,c in before['components'].items() if c['refdes'] in selected}
|
|
if not expected_negative and case['kind'] != 'already_target':
|
|
assert len(selected_uids)==len(selected) and all(not before['components'][uid].get('instance_path') for uid in selected_uids)
|
|
preserved=set() if expected_negative or case['kind']=='already_target' else selected_uids
|
|
raw_identities=raw_identity_attributes(destination/'export/effective.txt')
|
|
assert unselected_raw_identities(original_identities,preserved)==unselected_raw_identities(raw_identities,preserved), 'Unselected raw instance/gate/property multiset changed'
|
|
original_raw=selected_root_attributes(original_identities,selected_uids)
|
|
raw=selected_root_attributes(raw_identities,selected_uids)
|
|
else:
|
|
raw = raw_attributes(destination / 'export/effective.txt')
|
|
# Physical endpoints and every unselected component must stay identical.
|
|
assert before['nets'] == after['nets'], 'Physical net endpoints changed'
|
|
assert before['components'].keys() == after['components'].keys(), 'Symbol identity coverage changed'
|
|
checks = []
|
|
for uid, old in before['components'].items():
|
|
new = after['components'][uid]
|
|
assert old['pins'] == new['pins'], f'Pins changed: {uid}'
|
|
ref = old['refdes']
|
|
if expected_negative or case['kind'] == 'already_target' or ref not in selected:
|
|
assert old == new, f'Unintended symbol modification: {ref or uid}'
|
|
if ref and not complex_graph:
|
|
assert original_raw[ref] == raw[ref], f'Unintended raw attribute modification: {ref}'
|
|
continue
|
|
request = selected[ref]
|
|
attrs = raw[ref]
|
|
if case['kind'] == 'force_stop' and task['status'] != 'completed':
|
|
assert attrs.get('Part Number') in {request['old_part_number'], request['new_part_number']}
|
|
checks.append({'refdes': ref, 'observed': attrs, 'requires_verification': True})
|
|
continue
|
|
assert attrs['Part Number'] == request['new_part_number']
|
|
if case['target_cell']:
|
|
assert attrs.get('Cell Name') == case['target_cell'], (ref, attrs)
|
|
mode = request['value_mode']
|
|
native = None
|
|
if mode in {'preserve', 'part_label'}:
|
|
try:
|
|
native = bound_native_observation(root, task['task_id'], uid, request)
|
|
except (OSError, KeyError, ValueError) as error:
|
|
checks.append({'refdes': ref, 'part_number': attrs['Part Number'], 'value': attrs.get('Value'),
|
|
'mode': mode, 'value_check': 'native_' + mode + '_not_independently_proven',
|
|
'reason': str(error)})
|
|
continue
|
|
expected_value = {'custom': request['custom_value'], 'part_number': request['new_part_number'],
|
|
'part_label': native['part_label'] if native else None,
|
|
'preserve': native['value'] if native else None}[mode]
|
|
if mode == 'part_label':
|
|
assert attrs.get('Part Label') == native['part_label'] == native['library_row'][5]
|
|
expected_present = native['present'] if mode == 'preserve' else True
|
|
if request['sync_nc'] and has_nc_marker(original_raw[ref].get('Value', '')) and not has_nc_marker(expected_value or ''):
|
|
expected_value = expected_value.rstrip('/') + '/NC'
|
|
expected_present = True
|
|
assert attrs.get('Value', '') == expected_value, (ref, attrs, expected_value)
|
|
check = {'refdes': ref, 'part_number': attrs['Part Number'], 'value': attrs.get('Value'), 'mode': mode,
|
|
'value_check': 'fresh_ascii_text_matches_declared_policy'}
|
|
if native:
|
|
check['native_intermediate'] = native
|
|
if 'reopened_present' in native:
|
|
assert native['reopened_present'] == expected_present
|
|
assert native['reopened_value'] == expected_value
|
|
check['presence_check'] = 'count_complete_raw_reopened_COM_observation'
|
|
else:
|
|
check['presence_check'] = 'not_proven_by_ASCII_absent_empty_serialization'
|
|
checks.append(check)
|
|
if case['kind'] == 'force_stop':
|
|
item.update(force_recovery_evidence(root,expected_stage=case['fault']['stage'],ui_report=force_ui_report))
|
|
assert entry.get('state') in {'paused', 'blocked', 'failed','completed'}, entry
|
|
assert all(count == 1 for count in saved_uids(root).values()), 'Saved UID replayed after interruption'
|
|
item['unknown_outcome_not_claimed_success'] = task['status'] != 'completed'
|
|
else:
|
|
expected_state = 'failed' if expected_negative else 'skipped' if case['kind'] == 'already_target' else 'completed'
|
|
assert entry.get('state') == expected_state, (task, entry, expected_state)
|
|
item.update(passed=True, physical_nets_unchanged=True, unselected_unchanged=True,
|
|
raw_attribute_checks=checks, seconds=time.monotonic()-start)
|
|
if any(check.get('value_check', '').endswith('_not_independently_proven') for check in checks):
|
|
item.update(passed=False, structural_and_part_number_passed=True,
|
|
unverified_reason='Native preserve intermediate was not independently observed; old Value is not its contract.')
|
|
except Exception:
|
|
item['failure'] = traceback.format_exc()
|
|
report['cases'].append(item)
|
|
write(root / 'independent-report.json', report)
|
|
print(json.dumps(item, ensure_ascii=False), flush=True)
|
|
assert fingerprint(Path(manifest['source']).parent) == manifest['source_hashes']
|
|
if manifest.get('library'):
|
|
assert hashlib.sha256(Path(manifest['library']['path']).read_bytes()).hexdigest() == manifest['library']['sha256']
|
|
if manifest.get('origin') == 'user':
|
|
for name in ('source_workbook', 'working_workbook'):
|
|
assert hashlib.sha256(Path(manifest[name]['path']).read_bytes()).hexdigest() == manifest[name]['sha256']
|
|
if manifest.get('expected_no_cad'):
|
|
from accept_random_packaged_ui import verify_no_cad_fixture
|
|
report['no_op_validation'] = verify_no_cad_fixture(root, manifest)
|
|
resource_errors = []
|
|
for path in (root / 'data/batch-resources').glob('*/session.json'):
|
|
record = json.loads(path.read_text(encoding='utf-8'))
|
|
cleanup = {} if record.get('cleanup') is None else record['cleanup']
|
|
if record.get('state') != 'released' or not isinstance(cleanup, dict) or cleanup.get('errors'):
|
|
resource_errors.append({'path': str(path), 'record': record})
|
|
for path in (root / 'data/tasks').glob('*/quick-run-history/native-inventory-*/native-inventory.json'):
|
|
record = json.loads(path.read_text(encoding='utf-8'))
|
|
if record.get('backend') != 'native_cli' or record.get('state') == 'fallback':
|
|
resource_errors.append({'path': str(path), 'reason': 'Inventory fallback or wrong backend'})
|
|
if record.get('cleanup', {}).get('errors') or Path(record['workspace']).exists():
|
|
resource_errors.append({'path': str(path), 'reason': 'Inventory resources not released'})
|
|
observation_path = root / 'desktop-observation.json'
|
|
if observation_path.exists():
|
|
observation = json.loads(observation_path.read_text(encoding='utf-8'))
|
|
if (observation['observer_errors'] or observation['owned_cad_became_foreground']
|
|
or observation['owned_cad_on_input_desktop']
|
|
or not all(observation['cad_exit_confirmed'].values())
|
|
or not all(observation['desktop_absent'].values())):
|
|
resource_errors.append({'path': str(observation_path), 'reason': 'Independent desktop/process observation failed'})
|
|
report.update(passed=all(c['passed'] for c in report['cases']) and not resource_errors,
|
|
source_unchanged=True, library_unchanged=True, resource_errors=resource_errors)
|
|
if queue_id is not None:
|
|
report['verified_queue_id'] = queue_id
|
|
write(root / 'independent-report.json', report)
|
|
return report
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--root', type=Path, required=True)
|
|
parser.add_argument('--source', type=Path)
|
|
parser.add_argument('--graph', type=Path)
|
|
parser.add_argument('--target-part', action='append')
|
|
parser.add_argument('--part-prefix', action='append', default=[])
|
|
parser.add_argument('--cell', action='append', default=[])
|
|
parser.add_argument('--seed', type=int)
|
|
parser.add_argument('--count', type=int, default=20)
|
|
parser.add_argument('--supplemental', choices=('valid_cell', 'force_stop', 'rule_mode','pon_root'), default='')
|
|
parser.add_argument('--run-ui', action='store_true')
|
|
parser.add_argument('--ui-prepare-only', action='store_true')
|
|
parser.add_argument('--verify', action='store_true')
|
|
args = parser.parse_args()
|
|
if args.verify:
|
|
verify(args.root.resolve(strict=True))
|
|
elif args.run_ui:
|
|
root = args.root.resolve(strict=True)
|
|
if args.ui_prepare_only:
|
|
run_ui(root, prepare_only=True)
|
|
else:
|
|
from private_desktop_observer import PrivateDesktopObserver
|
|
with PrivateDesktopObserver(root):
|
|
run_ui(root)
|
|
else:
|
|
if not args.source or not args.graph or not args.target_part:
|
|
parser.error('Prepare needs --source, --graph and --target-part')
|
|
manifest = prepare(args.root, args.source, json.loads(args.graph.read_text(encoding='utf-8')),
|
|
args.target_part, seed=args.seed, count=args.count, cells=args.cell, supplemental=args.supplemental,
|
|
part_prefixes=args.part_prefix or ('4100',))
|
|
workbook(args.root.resolve(), manifest)
|
|
print(json.dumps({'root': str(args.root.resolve()), 'seed': manifest['seed'], 'count': len(manifest['cases'])}))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|