Files
dxdesigner-part-replacement/tools/measure_project_session.py
T

126 lines
6.9 KiB
Python

"""Run native replacements on a prepared disposable project, then independently read back.
The inventory must come from native discovery of the same source project. This
runner refuses a project outside --output; prepare copies before invoking it.
"""
import argparse
from dataclasses import asdict
import json
import inspect
import os
from pathlib import Path
import sys
from threading import Event
import time
import traceback
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--project', type=Path, required=True)
parser.add_argument('--inventory', type=Path, required=True)
parser.add_argument('--source-root', type=Path, default=Path(__file__).resolve().parents[1])
parser.add_argument('--mode', choices=('baseline', 'reuse'), required=True)
parser.add_argument('--old', default='4100-CA0000-T7')
parser.add_argument('--new', default='4100-CA0000-T0')
parser.add_argument('--refs', default='R32A8,R39A8,RG47')
parser.add_argument('--observe-desktop', action='store_true')
args = parser.parse_args()
output, project = args.output.resolve(), args.project.resolve()
if not project.is_relative_to(output) or not project.is_file():
parser.error('project must be a disposable copy inside output')
sys.path.insert(0, str(args.source_root.resolve() / 'src'))
os.environ['PYTHONPATH'] = str(args.source_root.resolve() / 'src') + os.pathsep + os.environ.get('PYTHONPATH', '')
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
source = json.loads(args.inventory.read_text(encoding='utf-8'))
sheets = tuple(tuple(sheet) for sheet in source['sheets'])
inventory = tuple(ComponentTarget(project, row['schematic_name'], row['sheet_number'],
row['uid'], row['refdes'], row['old_part_number'], row['old_value']) for row in source['components'])
ref_list = args.refs.split(',')
selected = set(ref_list)
assert selected <= {row.refdes for row in inventory}
output.mkdir(parents=True, exist_ok=True)
report = {'mode': args.mode, 'project': str(project), 'source_root': str(args.source_root),
'selected': sorted(selected), 'sheets': len(sheets)}
store = TaskStore(output / 'tasks.db')
preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets)
service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer)
try:
import win32com.client
try:
app = win32com.client.GetActiveObject('Viewdraw.Application')
except Exception:
app = None
if app is not None and app.GetProjectData().GetProjectFilePath():
raise RuntimeError('save and close existing CAD project before native measurement')
task = service.create_project_tasks(project.parent)[0]
service.add_rule(task.task_id, args.old, args.new)
store.record_target_inventory(task.task_id, inventory)
rows = tuple(TargetPlanRow(target, target.refdes in selected, args.new,
sync_nc=target.refdes != ref_list[1]) for target in inventory)
service.replace_target_plan(task.task_id, rows)
report['task_id'] = task.task_id
progress = service.quick_run_progress(task.task_id)
expected = (str(progress.next_project_path), progress.next_old_part_number,
progress.next_new_part_number, 'preserve')
print('native_start', args.mode, task.task_id, flush=True)
started = time.perf_counter()
if args.observe_desktop:
from private_desktop_observer import PrivateDesktopObserver
observer = PrivateDesktopObserver(output)
observer.__enter__()
else:
observer = None
session_option = ({'reuse_project_session': args.mode == 'reuse'}
if 'reuse_project_session' in inspect.signature(service.execute_quick_run_queue).parameters else {})
if args.mode == 'reuse' and not session_option:
raise RuntimeError('selected source does not implement project session reuse')
result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event(),
**session_option)
report['queue_seconds'] = time.perf_counter() - started
report['result'] = asdict(result)
print('native_result', args.mode, report['queue_seconds'], result.progress, flush=True)
assert result.progress.queue_complete and result.progress.failed_items == 0
evidence = output / 'data' / 'tasks' / task.task_id / 'quick-run'
text = (evidence / 'quick-part-replace.log').read_text(encoding='utf-8')
report['worker_starts'] = len(tuple(evidence.glob('monitor-*.ready')))
report['open_project_calls'] = text.count('stage=open_project target=')
events = [json.loads(line) for line in service.tail_log(task.task_id, limit=None)]
report['timings'] = [event for event in events if event['operation'] in {'execution_timing', 'quick_run_executed'}]
reader = QuickRunPreparer(output / 'independent-read')
started = time.perf_counter()
actual = reader._discover_project_sheets(project, (args.old, args.new), collect_components=True)
report['readback_seconds'] = time.perf_counter() - started
by_key = {(row.schematic_name, row.sheet_number, row.uid): row for row in actual.components}
comparisons = []
for target in inventory:
row = by_key[(target.schematic_name, target.sheet_number, target.uid)]
expected_part = args.new if target.refdes in selected else target.old_part_number
comparisons.append({'refdes': target.refdes, 'sheet': target.sheet_number,
'expected': expected_part, 'actual': row.old_part_number})
assert row.refdes == target.refdes and row.old_part_number == expected_part
report['comparisons'] = comparisons
report['verified'] = True
except Exception as error:
report['error'] = str(error)
traceback.print_exc()
finally:
if 'observer' in locals() and observer is not None:
try:
observer.__exit__(None, None, None)
except Exception as error:
report['observer_error'] = str(error)
report['verified'] = False
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
store.close()
return 0 if report.get('verified') else 1
if __name__ == '__main__':
raise SystemExit(main())