"""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')}))