Files

187 lines
11 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.
"""Multi-project regression with real storage/BOM/queues and a simulated CAD worker.
This measures software overhead, never native CAD replacement throughput.
"""
from __future__ import annotations
import argparse
import csv
from dataclasses import asdict
import json
from pathlib import Path
import subprocess
import sys
from threading import Event
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.bom_plan import write_bom_template
from dx_productivity.trial_task_center.inventory import HEADER
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer, _decode_vbs_field, _encode_vbs_field
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.target_plan import ComponentTarget
from dx_productivity.trial_task_center.task_queue import execute_task_queue
from dx_productivity.trial_task_center.ui.messages import _format_task_log_lines
def run_scenario(output: Path, *, projects=3, sheets=2, rules=2, behavior='success') -> dict:
output = Path(output).resolve()
output.mkdir(parents=True, exist_ok=False)
started = time.perf_counter()
timings, calls, targets, model = [], [], {}, {}
stop = Event()
def measured(phase, action):
tick = time.perf_counter()
value = action()
timings.append({'layer': 'workflow', 'phase': phase, 'elapsed_seconds': time.perf_counter() - tick})
return value
def write_tsv(path, header, rows):
path.write_text('\t'.join(header) + '\n' + ''.join(
'\t'.join(_encode_vbs_field(str(value)) for value in row) + '\n' for row in rows), encoding='utf-8')
root = output / 'projects'
for index in range(projects):
path = root / f'board-{index:03}' / 'board.prj'
path.parent.mkdir(parents=True)
path.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n')
inventory = tuple(ComponentTarget(path, 'MAIN', str(sheet), f'{sheet}-{part}-{ref}',
f'R{part * 3 + ref}', f'OLD-{part}', '10K/NC' if ref == 1 else '10K')
for sheet in range(1, sheets + 1) for part in range(rules) for ref in range(1, 4))
targets[str(path).casefold()] = inventory
model.update({target.key: target.old_part_number for target in inventory})
def worker(command, timeout):
evidence = Path(command[3])
with (evidence / ('current-command.tsv' if (evidence / 'current-command.tsv').exists() else 'command.tsv')).open(encoding='utf-8-sig') as stream:
item = next(csv.DictReader(stream, delimiter='\t'))
path = Path(item['project_path'])
inventory = targets[str(path).casefold()]
if (evidence / 'sheet-discovery.request').exists():
write_tsv(evidence / 'sheets.tsv', ('project_path', 'schematic_name', 'sheet_number'),
((path, 'MAIN', s) for s in range(1, sheets + 1)))
write_tsv(evidence / 'inventory.tsv', ('project_path', 'schematic_name', 'sheet_number', 'old_part'),
((path, 'MAIN', s, f'OLD-{p}') for s in range(1, sheets + 1) for p in range(rules)))
write_tsv(evidence / 'components.tsv', HEADER,
((path, t.schematic_name, t.sheet_number, t.uid, t.refdes, t.old_part_number, t.old_value) for t in inventory))
return subprocess.CompletedProcess(command, 0, '', '')
assert item['target_scope'] == 'targets'
selected = [entry.split('\x1f') for entry in _decode_vbs_field(item['target_selectors']).split('\x1e')]
matched = [t for t in inventory if t.sheet_number == item['sheet_number'] and t.uid in {s[0] for s in selected}]
assert len(matched) == 2
assert {(t.uid, t.refdes, t.old_value) for t in matched} == {tuple(s) for s in selected}
assert all(model[t.key] == item['old_part'] for t in matched)
state = 'saved_ok'
if not calls and behavior in {'failure_continue', 'uncertain_stop'}:
state = 'batch_failed' if behavior == 'failure_continue' else 'batch_saved_unverified'
if state == 'saved_ok':
for target in matched:
model[target.key] = item['new_part']
job = command[-1]
assert item['job_id'] == job
assert job not in {call['job_id'] for call in calls}
calls.append({'job_id': job, 'project': path.parent.name, 'task_id': item['task_id'],
'sheet': item['sheet_number'], 'old': item['old_part'], 'new': item['new_part'],
'refdes': [t.refdes for t in matched], 'state': state})
message = ('Native replacement and parameter readback passed on current sheet. Replacements: '
+ '; '.join(f'{t.refdes} {item["old_part"]} -> {item["new_part"]}' for t in matched)
+ ' Display verified: attributes=2. Saved, reopened for readback, and closed.')
if state != 'saved_ok':
message = 'Injected worker failure for regression; no native CAD operation.'
with (evidence / 'status.tsv').open('a', encoding='utf-8') as stream:
# failure_continue models a preflight rejection before any
# native mutation. Awaiting + missing native evidence must stop.
if state != 'batch_failed':
stream.write(f'{job}\tawaiting_native_replace\t\tcaptured\n')
stream.write(f'{job}\t{state}\tbatch_closed\t{message}\n')
if behavior == 'pause_resume' and len(calls) == 2:
stop.set()
return subprocess.CompletedProcess(command, 0, '', '')
store = TaskStore(output / 'tasks.db')
service = TaskCenterService(store, configure_logging(output / 'data'),
quick_run_preparer=QuickRunPreparer(output / 'data', process_runner=worker,
cscript_resolver=lambda: Path('simulated-cscript'),
sheet_discoverer=lambda _: tuple(('MAIN', str(s)) for s in range(1, sheets + 1))))
try:
tasks = measured('create_tasks', lambda: service.create_project_tasks(root))
assert len(tasks) == projects
for part in range(rules):
service.add_rule(tasks[0].task_id, f'OLD-{part}', f'NEW-{part}')
for task in tasks:
rows = measured('collect_inventory', lambda: service.collect_target_inventory(task.task_id))
assert len(rows) == sheets * rules * 3
bom = output / f'{task.task_id}.xlsx'
records = []
for sheet in range(1, sheets + 1):
for part in range(rules):
records.append({'old_part_number': f'OLD-{part}', 'new_part_number': f'NEW-{part}',
'refdes': f'R{part * 3 + 1}, R{part * 3 + 2}', 'schematic_name': 'MAIN',
'sheet_number': str(sheet), 'sync_nc': part % 2 == 0})
measured('write_bom', lambda: write_bom_template(bom, records))
preview = measured('import_bom', lambda: service.preview_bom_plan(task.task_id, bom))
measured('save_plan', lambda: service.replace_target_plan(task.task_id, preview))
ids = tuple(task.task_id for task in tasks)
result = measured('queue_wall', lambda: execute_task_queue(service, ids, stop_event=stop))
if behavior == 'pause_resume':
assert result.paused and len(calls) == 2
stop.clear()
result = measured('queue_resume_wall', lambda: execute_task_queue(service, ids, stop_event=stop, queue_id=result.queue_id))
expected_steps = projects * sheets * rules
assert len(calls) == (1 if behavior == 'uncertain_stop' else expected_steps)
if behavior == 'uncertain_stop':
assert result.paused and result.entries[0].state == 'blocked'
assert all(entry.state == 'pending' for entry in result.entries[1:])
else:
assert not result.paused
assert [entry.state for entry in result.entries] == ['failed' if behavior == 'failure_continue' and i == 0 else 'completed' for i in range(projects)]
# Every task runs contiguously and each unselected RefDes keeps its baseline.
order = [call['task_id'] for call in calls]
assert order == sorted(order, key=ids.index)
changed = sum(model[t.key] != t.old_part_number for inventory in targets.values() for t in inventory)
assert changed == sum(call['state'] == 'saved_ok' for call in calls) * 2
assert all(model[t.key] == t.old_part_number for inventory in targets.values() for t in inventory if int(t.uid.split('-')[-1]) == 3)
for task in tasks:
events = [json.loads(line) for line in service.tail_log(task.task_id, limit=None)]
timings.extend(event['details'] | {'layer': 'execution', 'task_id': task.task_id, 'project': service.projects(task.task_id)[0].path.parent.name}
for event in events if event['operation'] == 'execution_timing')
timings.extend(event['details']['timing'] | {'layer': 'execution', 'task_id': task.task_id,
'project': service.projects(task.task_id)[0].path.parent.name}
for event in events if event['operation'] == 'quick_run_executed' and 'timing' in event['details'])
executed = [event for event in events if event['operation'] == 'quick_run_executed']
own = [call for call in calls if call['task_id'] == task.task_id]
assert len(executed) == len(own)
rendered = '\n'.join(_format_task_log_lines(tuple(json.dumps(event) for event in executed)))
for call in own:
if call['state'] == 'saved_ok':
assert all(f'位号 {ref}:{call["old"]} → {call["new"]}' in rendered for ref in call['refdes'])
report = {'mode': 'simulated_cad_worker_real_storage_bom_and_queue', 'behavior': behavior,
'projects': projects, 'sheets_per_project': sheets, 'rules_per_sheet': rules,
'executed_steps': len(calls), 'changed_components': changed,
'unselected_components_preserved': projects * sheets * rules,
'elapsed_seconds': time.perf_counter() - started, 'result': asdict(result),
'calls': calls, 'timings': timings, 'checks': 'passed'}
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
fields = sorted({key for row in timings for key in row})
with (output / 'timings.csv').open('w', newline='', encoding='utf-8-sig') as stream:
writer = csv.DictWriter(stream, fieldnames=fields); writer.writeheader(); writer.writerows(timings)
return report
finally:
store.close()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--projects', type=int, default=3)
parser.add_argument('--sheets', type=int, default=2)
parser.add_argument('--rules', type=int, default=2)
parser.add_argument('--behavior', choices=('success', 'failure_continue', 'uncertain_stop', 'pause_resume'), default='success')
args = parser.parse_args()
result = run_scenario(args.output, projects=args.projects, sheets=args.sheets, rules=args.rules, behavior=args.behavior)
print(json.dumps({key: result[key] for key in ('mode', 'behavior', 'projects', 'executed_steps', 'elapsed_seconds', 'checks')}))