133 lines
7.3 KiB
Python
133 lines
7.3 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] if len(ref_list)>1 else '')) 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=')
|
|
report['save_project_calls'] = text.count('save_requested job=')
|
|
report['whole_page_native_captures'] = text.count('stage=native_snapshot_verified')
|
|
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 = {}
|
|
for row in actual.components:
|
|
key = (row.schematic_name, row.sheet_number, row.refdes)
|
|
by_key.setdefault(key, []).append(row)
|
|
comparisons = []
|
|
for target in inventory:
|
|
matches = by_key[(target.schematic_name, target.sheet_number, target.refdes)]
|
|
assert len(matches) == 1, 'measurement requires unique scoped reference designators'
|
|
row = matches[0]
|
|
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())
|