"""Verify the UI Part Label option and saved attributes on a disposable CAD copy.""" from __future__ import annotations import argparse import json import os from pathlib import Path import re import shutil import sys import time import traceback sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src')) def inspect_native(project, schematic, sheet, destination): import pythoncom import win32com.client from dx_productivity.trial_task_center.cad_identity import project_file_path, verify_application from dx_productivity.trial_task_center.native_helper import attach, attribute_value, components_on_sheet pythoncom.CoInitialize() try: app = win32com.client.GetActiveObject('Viewdraw.Application') verify_application(app, require_view=False) assert not project_file_path(app), 'independent reader cannot take over an open project' assert app.OpenProject(str(project)) assert Path(project_file_path(app)).resolve() == project.resolve() document = app.SchematicSheetDocuments().Open(schematic, sheet) document.Activate() app, api = attach() # Certify the active view's owned PID before reading. rows = [] for component in components_on_sheet(app, api): if str(component.Refdes) not in {'RV05', 'RV11'}: continue rows.append(dict(uid=str(component.UID), refdes=str(component.Refdes), part_number=attribute_value(component, 'Part Number'), part_label=attribute_value(component, 'Part Label'), value=attribute_value(component, 'Value'))) assert len(rows) == 2 document.Close(False, '') app.CloseProject() assert not project_file_path(app) destination.write_text(json.dumps(rows, ensure_ascii=False, indent=2), encoding='utf-8') finally: pythoncom.CoUninitialize() def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('--source', type=Path) parser.add_argument('--library', type=Path) parser.add_argument('--output', type=Path, required=True) parser.add_argument('--inspect-project', type=Path) parser.add_argument('--schematic') parser.add_argument('--sheet') parser.add_argument('--resume', action='store_true') args = parser.parse_args() if args.inspect_project: inspect_native(args.inspect_project, args.schematic, args.sheet, args.output) return 0 if not args.source or not args.library: parser.error('--source and --library are required for the live UI probe') os.environ.setdefault('QT_QPA_PLATFORM', 'offscreen') from openpyxl import load_workbook from PySide6.QtCore import QPoint, QThreadPool, Qt from PySide6.QtGui import QFont, QFontDatabase from PySide6.QtTest import QTest from PySide6.QtWidgets import QApplication, QCheckBox, QFileDialog from dx_productivity.trial_task_center.isolated_cad import IsolatedCadSession from dx_productivity.trial_task_center.legacy_paths import cleanup_worker_aliases from dx_productivity.trial_task_center.logging_setup import configure_logging from dx_productivity.trial_task_center.models import TaskStatus from dx_productivity.trial_task_center.service import TaskCenterService from dx_productivity.trial_task_center.store import TaskStore from dx_productivity.trial_task_center.ui.main_window import TrialTaskCenterWindow from private_desktop_observer import PrivateDesktopObserver from probe_bom_live_roundtrip import export_measurements, hashes output, source = args.output.resolve(), args.source.resolve(strict=True) assert not output.is_relative_to(source.parent) output.mkdir(parents=True, exist_ok=args.resume) source_hashes = hashes(source) if not args.resume: shutil.copytree(source.parent, output / 'project') project = output / 'project' / source.name text, count = re.subn(r'(?m)^KEY CentralLibrary .*$', lambda _: f'KEY CentralLibrary "{args.library.resolve(strict=True).as_posix()}"', project.read_text(encoding='utf-8-sig')) assert count == 1 if not args.resume: project.write_text(text, encoding='utf-8') store = TaskStore(output / 'tasks.db') service = TaskCenterService(store, configure_logging(output / 'data')) app = QApplication.instance() or QApplication([]) font_id = QFontDatabase.addApplicationFont(str(Path(os.environ['WINDIR']) / 'Fonts/msyh.ttc')) families = QFontDatabase.applicationFontFamilies(font_id) if families: app.setFont(QFont(families[0], 10)) window = TrialTaskCenterWindow(service, quick_run_confirmer=lambda *_: True, close_plan_confirmer=lambda: 'discard') report = (json.loads((output / 'report.json').read_text(encoding='utf-8')) if args.resume else {'source': str(source), 'project': str(project), 'steps': [], 'errors': []}) report.pop('error', None) report.pop('verified', None) def record(stage, started=None, **details): entry = {'stage': stage, **details} if started is not None: entry['seconds'] = time.perf_counter() - started report['steps'].append(entry) (output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8') print(json.dumps(entry, ensure_ascii=False, default=str), flush=True) def idle(): deadline = time.monotonic() + 900 while (window._workers or window._loading or window._task_query.busy or window._context_query.busy or window._log_presenter.query.busy or window._feedback_query.busy): if time.monotonic() > deadline: raise TimeoutError('live Part Label UI probe deadline exceeded') app.processEvents() time.sleep(.02) app.processEvents() def click(button): assert button.isEnabled(), button.objectName() if isinstance(button, QCheckBox): QTest.mouseClick(button, Qt.MouseButton.LeftButton, pos=QPoint(8, button.height() // 2)) else: QTest.mouseClick(button, Qt.MouseButton.LeftButton) original_error = window._show_error def error_received(error, **options): report['errors'].append(str(error)) original_error(error, **options) window._show_error = error_received template, filled = output / 'default-template.xlsx', output / 'part-label-bom.xlsx' original_open, original_save = QFileDialog.getOpenFileName, QFileDialog.getSaveFileName QFileDialog.getSaveFileName = lambda *_a, **_k: (str(template), 'Excel (*.xlsx)') QFileDialog.getOpenFileName = lambda *_a, **_k: (str(filled), 'Excel (*.xlsx)') try: window.show() idle() task = service.tasks()[0] if args.resume else service.create_project_tasks(project.parent)[0] report['task_id'] = task.task_id window.open_task(task.task_id) idle() window.mapping_tabs.setCurrentIndex(1) if not args.resume: click(window.plan_panel.export_bom_button) idle() book = load_workbook(template) worksheet = book.active headers = [cell.value for cell in worksheet[1]] scaffold = dict(zip(headers, next(worksheet.iter_rows(min_row=2, values_only=True)))) worksheet.delete_rows(2, worksheet.max_row) row = scaffold | dict(old_part_number='4100-CA0000-T7', new_part_number='4100-CA0000-T0', refdes='RV05', enabled=True, sync_nc=True) worksheet.append([row.get(header, '') for header in headers]) book.save(filled) book.close() with PrivateDesktopObserver(output): if not service.target_plan(task.task_id): started = time.perf_counter() click(window.plan_panel.import_bom_button) idle() result = window.plan_panel.last_bom_report assert result and result.preview and result.passed_rows == 1 and not result.failed_rows, report['errors'] record('import_bom', started, passed=result.passed_rows, failed=result.failed_rows) click(window.plan_panel.save_button) idle() before = service.target_plan(task.task_id) assert {row.target.refdes for row in before} == {'RV05', 'RV11'} assert sum(row.enabled for row in before) == 1 if not window.run_panel.copy_value_check.isChecked(): click(window.run_panel.copy_value_check) idle() assert window.run_panel.copy_value_check.isChecked() assert service.get_task(task.task_id).copy_part_number_to_value record('ui_part_label_copy_enabled') window.grab().save(str(output / '01-part-label-enabled.png')) started = time.perf_counter() did_execute = service.get_task(task.task_id).status is not TaskStatus.COMPLETED if did_execute: click(window.run_panel.quick_run_button) idle() assert service.get_task(task.task_id).status is TaskStatus.COMPLETED, report['errors'] if did_execute: record('native_replacement_saved_and_reopened', started) else: record('reuse_completed_task_for_readback') window.grab().save(str(output / '02-part-label-completed.png')) facade = service.for_project_task(task.task_id) command = facade._quick_run_preparer.data_root / 'quick-run/command.tsv' fields = command.read_text(encoding='utf-8-sig').splitlines() job = dict(zip(fields[0].split('\t'), fields[1].split('\t'))) assert job['value_mode'] == 'part_label' selected = next(row.target for row in before if row.enabled) reader = facade._quick_run_preparer.data_root / 'quick-run-history/sheet-discovery-partlabel-independent' reader.mkdir(parents=True, exist_ok=True) destination = output / 'independent-attributes.json' started = time.perf_counter() with IsolatedCadSession(reader) as session: process = session.start_worker((sys.executable, str(Path(__file__).resolve()), '--inspect-project', str(project), '--schematic', selected.schematic_name, '--sheet', selected.sheet_number, '--output', str(destination)), stdout=-1, stderr=-1) deadline = time.monotonic() + 150 while process.poll() is None and time.monotonic() < deadline: time.sleep(.1) if process.poll() is None: raise TimeoutError('independent Part Label read did not finish') stdout, stderr = process.stdout.read(), process.stderr.read() (reader / 'worker-output.txt').write_bytes(stdout + b'\n' + stderr) assert process.poll() == 0, stderr.decode('utf-8', errors='replace') actual = json.loads(destination.read_text(encoding='utf-8')) targets = {row['refdes']: row for row in actual} copied = targets['RV05'] assert copied['part_number'] == '4100-CA0000-T0' assert copied['part_label'] and copied['value'] == copied['part_label'] for row in before: after = targets[row.target.refdes] assert after['uid'] == row.target.uid if not row.enabled: assert after['part_number'] == row.target.old_part_number and after['value'] == row.target.old_value record('independent_saved_attributes', started, components=actual) observation = json.loads((output / 'desktop-observation.json').read_text(encoding='utf-8')) assert not observation['observer_errors'] assert observation['input_desktop_before'] == observation['input_desktop_after'] assert not observation['owned_cad_became_foreground'] and not observation['owned_cad_on_input_desktop'] assert all(observation['cad_exit_confirmed'].values()) and all(observation['desktop_absent'].values()) report['verified'] = True except Exception as error: report['error'] = str(error) traceback.print_exc() finally: idle() report['source_project_unchanged'] = hashes(source) == source_hashes QFileDialog.getOpenFileName, QFileDialog.getSaveFileName = original_open, original_save window.close() QThreadPool.globalInstance().waitForDone() store.close() report['alias_cleanup_errors'] = [str(error) for error in cleanup_worker_aliases()] report['measurements'] = str(export_measurements(output)) (output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8') print(json.dumps({key: report[key] for key in ('verified', 'error', 'source_project_unchanged') if key in report}), flush=True) return 0 if report.get('verified') and report['source_project_unchanged'] and not report['alias_cleanup_errors'] else 1 if __name__ == '__main__': raise SystemExit(main())