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

345 lines
19 KiB
Python

"""One-shot, two-project BOM/replace comparison on newly copied projects only.
The same tool imports either checkout via --repo. A failed run is retained and
cannot be resumed: completed writes are never automatically repeated.
"""
from __future__ import annotations
import argparse
from dataclasses import asdict
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys
from threading import Event
import time
import traceback
OLD, NEW = '4100-CA0000-T7', '4100-CA0000-T0'
NAMES = ('Audio_D2128', 'Audio_T605A')
def save(path, value):
path.write_text(json.dumps(value, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
def hashes(root):
return {str(path.relative_to(root)): hashlib.sha256(path.read_bytes()).hexdigest()
for path in root.rglob('*') if path.is_file()}
def inspect_native(spec_path):
"""Read the saved sheet directly, independently of the replacement snapshot."""
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
spec = json.loads(spec_path.read_text(encoding='utf-8'))
assert Path(spec['project']).resolve().is_relative_to(Path(__file__).resolve().parents[1] / 'build')
pythoncom.CoInitialize()
app = document = None
try:
app = win32com.client.GetActiveObject('Viewdraw.Application')
verify_application(app, require_view=False)
assert not project_file_path(app), 'reader must start with empty CAD'
assert app.OpenProject(spec['project'])
rows = {}
for schematic, sheet in spec['sheets']:
document = app.SchematicSheetDocuments().Open(schematic, sheet)
document.Activate()
app, api = attach()
assert Path(project_file_path(app)).resolve() == Path(spec['project']).resolve()
pins = {}
for item in app.ActiveView.Query(4096, 0):
pin = api.IVdCmpPin(item._oleobj_)
point = pin.GetLocation()
connection = pin.Connection
net = None if connection is None else connection.Net
assert connection is None or net is not None
pins.setdefault(str(pin.Component.UID), []).append(dict(number=str(pin.Number),
x=float(point.X), y=float(point.Y), net_uid=None if net is None else str(net.UID),
net_name=None if net is None else str(net.LogicalNetName)))
for component in components_on_sheet(app, api):
uid = str(component.UID)
point = component.GetLocation()
attributes = {}
for item in component.Attributes:
attr = api.IVdAttr(item._oleobj_)
location = attr.GetLocation()
attributes[str(attr.Name)] = dict(value=str(attr.Value or ''),
instance_value=str(attr.InstanceValue or ''), x=float(location.X), y=float(location.Y),
color=int(attr.Color), font=int(attr.Font), size=float(attr.Size),
orientation=int(attr.Orientation), visible=bool(attr.Visible))
rows[f'{schematic}:{sheet}:{uid}'] = dict(uid=uid, refdes=str(component.Refdes),
schematic=schematic, sheet=sheet, x=float(point.X), y=float(point.Y),
orientation=int(component.Orientation), scale=float(component.Scale), attributes=attributes,
part_number=attribute_value(component, 'Part Number'), value=attribute_value(component, 'Value'),
part_label=attribute_value(component, 'Part Label'),
pins=sorted(pins.get(uid, []), key=lambda pin: (pin['x'], pin['y'], pin['number'])))
document.Close(False, '')
document = None
app.CloseProject()
assert not project_file_path(app)
save(Path(spec['destination']), rows)
finally:
if document is not None:
document.Close(False, '')
if app is not None and project_file_path(app):
assert Path(project_file_path(app)).resolve() == Path(spec['project']).resolve()
app.CloseProject()
app = None
pythoncom.CoUninitialize()
def compare_saved(before, after):
assert set(before) == set(after), 'component identity set changed'
selected = 0
for key, old in before.items():
new = after[key]
if old['refdes'] != 'RV05':
assert old == new, f'non-target changed: {key}'
continue
selected += 1
assert old['part_number'] == OLD and new['part_number'] == NEW
assert new['part_label'] == '0R'
# This fixture uses the unchecked copy option. Its native target has no
# Value attribute; preserve means retaining that absence, not restoring
# OLD's Value. See the 2026-10-14 project-tasks design and the production
# QPVerifyValuePolicy existence/content check after native replacement.
assert new['value'] == '' and 'Value' not in new['attributes']
for field in ('uid', 'refdes', 'schematic', 'sheet', 'x', 'y', 'orientation', 'scale'):
assert old[field] == new[field], (key, field)
graph = lambda row: sorted((pin['x'], pin['y'], pin['net_uid'], pin['net_name']) for pin in row['pins'])
assert graph(old) == graph(new) and new['pins'], f'target connectivity changed: {key}'
assert all(pin['number'] for pin in new['pins']), f'unpromoted target pin: {key}'
assert selected == 1
return {'components': len(after), 'targets': selected, 'unchanged_components': len(after) - selected,
'pin_connections': sum(len(row['pins']) for row in after.values()),
'target_state': [{key: row[key] for key in ('uid', 'refdes', 'part_number', 'part_label', 'value')}
| {'value_attribute_exists': 'Value' in row['attributes']}
for row in after.values() if row['refdes'] == 'RV05']}
def verify_existing(repo, root):
"""Finish readback only; this branch has no task queue or replacement call."""
import sqlite3
import win32api
from dx_productivity.trial_task_center.isolated_cad import IsolatedCadSession
from private_desktop_observer import PrivateDesktopObserver
root = root.resolve(strict=True)
assert root.is_relative_to(Path(__file__).resolve().parents[1] / 'build')
original = json.loads((root / 'report.json').read_text(encoding='utf-8'))
with sqlite3.connect(root / 'tasks.db') as database:
assert database.execute('select count(*) from tasks where status="completed" and copy_part_number_to_value=0').fetchone()[0] == 2
verification = root / 'read-only-verification'
verification.mkdir(exist_ok=False)
report = {'mode': 'read_only_saved_verification', 'copy_part_number_to_value': False,
'value_policy': 'preserve native target Value; this target has no Value attribute', 'projects': []}
try:
with PrivateDesktopObserver(verification) as observer:
for raw_project in original['projects']:
project = Path(raw_project).resolve(strict=True)
assert project.is_relative_to(root / 'projects')
before = json.loads((root / f'before-{project.stem}.json').read_text(encoding='utf-8'))
destination = root / f'after-{project.stem}.json'
if not destination.exists():
evidence = verification / project.stem
evidence.mkdir()
spec = evidence / 'spec.json'
save(spec, {'project': str(project), 'sheets': sorted({(row['schematic'], row['sheet']) for row in before.values()}),
'destination': str(destination)})
with IsolatedCadSession(evidence) as cad:
observer.records[cad.desktop.name] = dict(cad.record)
observer.handles[cad.cad.pid] = win32api.OpenProcess(0x100000, False, cad.cad.pid)
process = cad.start_worker((sys.executable, str(Path(__file__).resolve()), '--repo', str(repo),
'--inspect-file', str(spec), '--run-native'), stdout=-1, stderr=-1)
try:
code = process.wait(timeout=180)
(evidence / 'worker-output.txt').write_bytes(process.stdout.read() + b'\n' + process.stderr.read())
assert code == 0, (evidence / 'worker-output.txt').read_text(errors='replace')
finally:
process.close()
after = json.loads(destination.read_text(encoding='utf-8'))
report['projects'].append({'project': str(project), **compare_saved(before, after)})
observation = json.loads((verification / '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['passed'] = True
finally:
save(verification / 'saved-verification.json', report)
print(json.dumps(report, ensure_ascii=False), flush=True)
return 0 if report.get('passed') else 1
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--repo', type=Path, required=True)
parser.add_argument('--source-root', type=Path)
parser.add_argument('--library', type=Path)
parser.add_argument('--output', type=Path)
parser.add_argument('--run-native', action='store_true', required=True)
parser.add_argument('--inspect-file', type=Path)
parser.add_argument('--verify-existing', type=Path, help='Read saved completed run only; never execute replacement')
args = parser.parse_args()
repo = args.repo.resolve(strict=True)
sys.path.insert(0, str(repo / 'src'))
sys.path.insert(0, str(repo / 'tools'))
if args.inspect_file:
inspect_native(args.inspect_file)
return 0
if args.verify_existing:
return verify_existing(repo, args.verify_existing)
assert args.output and args.source_root and args.library
output = args.output.resolve()
assert output.is_relative_to(Path(__file__).resolve().parents[1] / 'build')
output.mkdir(parents=True, exist_ok=False)
source_manifest = {'git_head': subprocess.check_output(['git', 'rev-parse', 'HEAD'], cwd=repo, text=True).strip(),
'files': {str(path.relative_to(repo)): hashlib.sha256(path.read_bytes()).hexdigest()
for folder, pattern in (('src', '*.py'), ('integration', '*.vbs'))
for path in (repo / folder).rglob(pattern)}}
save(output / 'source-under-test-manifest.json', source_manifest)
library = args.library.resolve(strict=True)
library_hash = hashlib.sha256(library.read_bytes()).hexdigest()
source_root = args.source_root.resolve(strict=True)
source_hashes, projects = {}, []
for name in NAMES:
source = source_root / name
assert (source / (name + '.prj')).is_file()
source_hashes[name] = hashes(source)
folder = output / 'projects' / name
shutil.copytree(source, folder)
project = folder / (name + '.prj')
text, count = re.subn(r'(?m)^KEY CentralLibrary .*$',
lambda _: f'KEY CentralLibrary "{library.as_posix()}"', project.read_text(encoding='utf-8-sig'))
assert count == 1
project.write_text(text, encoding='utf-8')
projects.append(project)
from dx_productivity.trial_task_center.bom_plan import write_bom_template
from dx_productivity.trial_task_center.isolated_cad import IsolatedCadSession
from dx_productivity.trial_task_center.isolated_desktop import PrivateDesktop
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.task_queue import execute_task_queue
from private_desktop_observer import PrivateDesktopObserver
report = {'repo': str(repo), 'library': str(library), 'source_root': str(source_root),
'projects': list(map(str, projects)), 'input': {'old': OLD, 'new': NEW, 'refdes': 'RV05',
'copy_part_number_to_value': False, 'value_mode': 'preserve'},
'steps': [], 'desktop_starts': [], 'cad_starts': [], 'source_hashes': source_hashes}
save(output / 'report.json', report)
phase = 'setup'
observer = PrivateDesktopObserver(output)
original_desktop_enter, original_cad_enter = PrivateDesktop.__enter__, IsolatedCadSession.__enter__
def enter_desktop(desktop):
started = time.monotonic()
try:
return original_desktop_enter(desktop)
finally:
report['desktop_starts'].append({'phase': phase, 'desktop': desktop.name,
'seconds': time.monotonic() - started})
def enter_cad(cad):
started = time.monotonic()
try:
return original_cad_enter(cad)
finally:
entry = {'phase': phase, 'desktop': cad.desktop.name, 'seconds': time.monotonic() - started,
'pid': None if cad.cad is None else cad.cad.pid}
report['cad_starts'].append(entry)
if entry['pid']:
import win32api
observer.records[entry['desktop']] = dict(cad.record)
try:
observer.handles[entry['pid']] = win32api.OpenProcess(0x100000, False, entry['pid'])
except Exception:
pass
PrivateDesktop.__enter__, IsolatedCadSession.__enter__ = enter_desktop, enter_cad
store = TaskStore(output / 'tasks.db')
service = TaskCenterService(store, configure_logging(output / 'data'))
def record(stage, started, **details):
entry = {'stage': stage, 'seconds': time.monotonic() - started, **details}
report['steps'].append(entry)
save(output / 'report.json', report)
print(json.dumps(entry, ensure_ascii=False, default=str), flush=True)
def independent(project, sheets, label):
name = project.stem
root = output / 'independent-read' / 'quick-run-history' / f'sheet-discovery-{label}-{name}'
root.mkdir(parents=True)
destination, spec = output / f'{label}-{name}.json', root / 'spec.json'
save(spec, {'project': str(project), 'sheets': sorted(sheets), 'destination': str(destination)})
with IsolatedCadSession(root) as cad:
process = cad.start_worker((sys.executable, str(Path(__file__).resolve()), '--repo', str(repo),
'--inspect-file', str(spec), '--run-native'), stdout=-1, stderr=-1)
try:
code = process.wait(timeout=180)
(root / 'worker-output.txt').write_bytes(process.stdout.read() + b'\n' + process.stderr.read())
assert code == 0, (root / 'worker-output.txt').read_text(errors='replace')
finally:
process.close()
return json.loads(destination.read_text(encoding='utf-8'))
started_all = time.monotonic()
try:
with observer:
tasks = service.create_project_tasks(output / 'projects', selected_paths=tuple(projects))
assert len(tasks) == 2
bom = write_bom_template(output / 'input.xlsx', ({'project_path': str(project),
'old_part_number': OLD, 'new_part_number': NEW, 'refdes': 'RV05', 'enabled': True,
'sync_nc': True} for project in projects))
phase = 'bom_import'
started = time.monotonic()
imported = service.inspect_bom_batch(tasks[0].task_id, bom, on_progress=lambda message: print(message, flush=True))
assert imported.passed_rows == 2 and imported.preview is not None and not imported.failed_rows
service.save_bom_batch(imported.preview, {item.task_id: item.rows for item in imported.preview.projects})
record(phase, started, passed_rows=imported.passed_rows)
phase = 'independent_before'
before = {}
for project in projects:
rows = next(item.rows for item in imported.preview.projects if item.project_path.resolve() == project.resolve())
sheets = {(row.target.schematic_name, row.target.sheet_number) for row in rows}
before[project.stem] = independent(project, sheets, 'before')
phase = 'queue_execution'
started = time.monotonic()
result = execute_task_queue(service, tuple(task.task_id for task in tasks), stop_event=Event())
assert all(entry.state == 'completed' for entry in result.entries), result
record(phase, started, result=asdict(result))
phase = 'independent_after'
for project in projects:
sheets = {(row['schematic'], row['sheet']) for row in before[project.stem].values()}
started = time.monotonic()
after = independent(project, sheets, 'after')
record(f'independent-{project.stem}', started, **compare_saved(before[project.stem], after))
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 BaseException as error:
report['error'] = f'{type(error).__name__}: {error}'
report['traceback'] = traceback.format_exc()
traceback.print_exc()
finally:
report['total_seconds_including_independent_reads'] = time.monotonic() - started_all
report['workflow_seconds'] = sum(step['seconds'] for step in report['steps'] if step['stage'] in {'bom_import', 'queue_execution'})
report['source_unchanged'] = all(hashes(source_root / name) == source_hashes[name] for name in NAMES)
report['library_lmc_unchanged'] = hashlib.sha256(library.read_bytes()).hexdigest() == library_hash
PrivateDesktop.__enter__, IsolatedCadSession.__enter__ = original_desktop_enter, original_cad_enter
store.close()
from dx_productivity.trial_task_center.legacy_paths import cleanup_worker_aliases
report['alias_cleanup_errors'] = list(map(str, cleanup_worker_aliases()))
save(output / 'report.json', report)
print(json.dumps({key: report.get(key) for key in ('verified', 'error', 'workflow_seconds', 'source_unchanged',
'library_lmc_unchanged', 'desktop_starts', 'cad_starts')}, ensure_ascii=False), flush=True)
return 0 if (report.get('verified') and report['source_unchanged'] and report['library_lmc_unchanged']
and not report['alias_cleanup_errors']) else 1
if __name__ == '__main__':
raise SystemExit(main())