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

202 lines
12 KiB
Python

"""Replay an issue BOM through inspect_batch using only captured native reports.
All fixtures and the copied task database are created under --output. This tool
never opens CAD and refuses to create a desktop or persist a target plan.
"""
from __future__ import annotations
import argparse
from collections import defaultdict
from dataclasses import asdict
import hashlib
import json
from pathlib import Path
import sqlite3
import subprocess
import sys
from unittest.mock import patch
import zipfile
def digest(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(path, value):
Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--issue-root', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--repo', type=Path, default=Path(__file__).resolve().parents[1])
args = parser.parse_args()
issue, output, repo = args.issue_root.resolve(), args.output.resolve(), args.repo.resolve()
assert not output.is_relative_to(issue), 'Original evidence is read-only'
assert 'build' in output.parts, 'Replay output must stay inside a build directory'
output.mkdir(parents=True, exist_ok=False)
sys.path.insert(0, str(repo / 'src'))
from openpyxl import load_workbook
from dx_productivity.trial_task_center import isolated_cad, isolated_desktop, native_inventory
from dx_productivity.trial_task_center.batch_runtime import BatchCadRuntime
from dx_productivity.trial_task_center.bom_import_report import inspect_batch
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.native_inventory_protocol import read_ascii_discovery
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 ProjectIdentityResolver
identities = ProjectIdentityResolver()
expected = json.loads((issue / 'reported-row-replay.json').read_text(encoding='utf-8'))
replayed_rows = {row['excel_row'] for row in expected}
replayed_projects = {row['project'] for row in expected}
baseline_native = json.loads((issue / 'native-replay-report.json').read_text(encoding='utf-8'))
native_names = {row['evidence'] for row in baseline_native if row['status'] == 'ready'}
captured = defaultdict(list)
original_files = [issue / name for name in (
'reported-app.zip', 'reported-bom.xlsx', 'reported-row-replay.json', 'native-replay-report.json')]
for evidence in (issue / 'evidence/tasks').glob('*/quick-run-history/native-inventory-*'):
if evidence.name not in native_names:
continue
metadata = json.loads((evidence / 'native-inventory.json').read_text(encoding='utf-8'))
project = Path(metadata['project'])
if project.name not in replayed_projects:
continue
scope, effective = evidence / 'output/scope.txt', evidence / 'output/effective.txt'
assert scope.is_file() and effective.is_file()
captured[identities.project(project)].append(evidence)
original_files.extend((evidence / 'native-inventory.json', scope, effective))
assert len(captured) == len(replayed_projects) == 6
before_sources = {str(path): digest(path) for path in original_files}
database = output / 'app-copy/task-center.db'
database.parent.mkdir()
with zipfile.ZipFile(issue / 'reported-app.zip') as archive:
names = [name for name in archive.namelist() if name.endswith('/data/task-center.db')]
assert len(names) == 1
database.write_bytes(archive.read(names[0]))
connection = sqlite3.connect(database)
connection.row_factory = sqlite3.Row
source_counts = {'tasks': connection.execute('SELECT count(*) FROM tasks').fetchone()[0],
'target_plan': connection.execute('SELECT count(*) FROM target_plan').fetchone()[0]}
assert source_counts == {'tasks': 428, 'target_plan': 0}
project_rows = list(connection.execute('SELECT project_id,task_id,path FROM projects'))
remap, source_by_local, task_by_source = {}, {}, {}
for project_row in project_rows:
source = Path(project_row['path'])
local = output / 'projects' / project_row['project_id'] / source.name
local.parent.mkdir(parents=True)
local.write_text('KEY FrontEndSnapshot "DxD"\nKEY iCDBDir "database"\n', encoding='utf-8')
(local.parent / 'database').mkdir()
(local.parent / 'database/icdb.dat').write_bytes(b'captured read-only replay fixture')
source_key, local_key = identities.project(source), identities.project(local)
remap[source_key] = local
source_by_local[local_key] = source_key
task_by_source[source_key] = project_row['task_id']
connection.execute('UPDATE projects SET path=?,path_identity=?,discovery_root=? WHERE project_id=?',
(str(local), local_key, str(output / 'projects'), project_row['project_id']))
connection.execute('UPDATE tasks SET discovery_root=?', (str(output / 'projects'),))
connection.commit()
connection.close()
workbook = load_workbook(issue / 'reported-bom.xlsx', data_only=False)
sheet = workbook.active
assert len(workbook.worksheets) == 1
assert tuple(cell.value for cell in sheet[1]) == (
'project_name', 'project_path', 'old_part_number', 'new_part_number', 'refdes',
'schematic_name', 'sheet_number', 'uid', 'enabled', 'custom_value', 'sync_nc')
original_rows, replacement_rows, replacement_projects = sheet.max_row - 1, [], set()
for excel_row in range(2, sheet.max_row + 1):
source_path = sheet.cell(excel_row, 2).value
key = identities.project(source_path)
assert key in remap
sheet.cell(excel_row, 2, str(remap[key]))
has_replacement = any(sheet.cell(excel_row, column).value not in (None, '') for column in (3, 4, 5))
if has_replacement:
replacement_rows.append(excel_row)
replacement_projects.add(key)
if excel_row not in replayed_rows:
# Preserve row positions, routing columns, header and original cell
# styles. Uncaptured replacements are explicitly outside this replay.
for column in (3, 4, 5, 6, 7, 8, 10):
sheet.cell(excel_row, column).value = None
else:
assert key in captured and has_replacement
assert (original_rows, len(replacement_rows), len(replacement_projects)) == (763, 437, 102)
replay_file = output / 'captured-scope-original-format.xlsx'
workbook.save(replay_file)
workbook.close()
store = TaskStore(database)
service = TaskCenterService(store, configure_logging(output / 'data'))
loads, phases, forbidden_calls = [], [], []
def forbidden(name):
def fail(*args, **kwargs):
forbidden_calls.append(name)
raise AssertionError(f'Read-only replay attempted {name}')
return fail
for source_key, evidence_paths in captured.items():
child = service.for_project_task(task_by_source[source_key])
def captured_loader(project, parts, *, collect_components=False, _key=source_key,
_evidence=tuple(evidence_paths), **controls):
assert source_by_local[identities.project(project)] == _key
assert collect_components and controls.get('runtime') is not None
reads = [read_ascii_discovery(project, evidence / 'output/scope.txt', parts,
effective_report_path=evidence / 'output/effective.txt') for evidence in _evidence]
assert all(read == reads[0] for read in reads), 'Repeated native captures disagree'
loads.append({'project': str(project), 'original_project': _key, 'requested_parts': parts,
'components': len(reads[0].components), 'evidence': list(_evidence)})
return reads[0]
child._quick_run_preparer._discover_project_sheets = captured_loader
initial_dump = tuple(store._connection.iterdump())
with (patch.object(BatchCadRuntime, '_ensure_desktop', forbidden('batch desktop')),
patch.object(isolated_desktop.PrivateDesktop, '__enter__', forbidden('private desktop')),
patch.object(isolated_cad.IsolatedCadSession, '__enter__', forbidden('CAD')),
patch.object(native_inventory.NativeInventoryReader, 'read', forbidden('native process')),
patch.object(subprocess, 'Popen', forbidden('process launch')),
patch.object(store, 'record_target_inventory', forbidden('inventory persistence')),
patch.object(store, 'replace_target_plan', forbidden('target-plan persistence'))):
report = inspect_batch(service, task_by_source[next(iter(captured))], replay_file,
on_phase=lambda phase, message: phases.append({'phase': phase.value, 'message': message}))
assert tuple(store._connection.iterdump()) == initial_dump, 'Replay changed the copied task database'
assert not forbidden_calls
assert report.preview is None
assert len(loads) == len(captured) == 6
current = [{'excel_row': row.excel_row, 'project': Path(row.project_path).name,
'status': row.status, 'reason': row.reason} for row in report.rows]
expected_outcomes = [(row['excel_row'], row['project'], row['status']) for row in expected]
current_outcomes = [(row['excel_row'], row['project'], row['status']) for row in current]
assert current_outcomes == expected_outcomes
assert (report.total_rows, report.passed_rows, report.failed_rows, report.unchecked_rows) == (31, 20, 11, 0)
assert [row.excel_row for row in report.rows if row.status == 'failed'] == [3, 4, 6, 7, 11, 12, 13, 16, 17, 18, 19]
assert {str(path): digest(path) for path in original_files} == before_sources
save(output / 'report.json', asdict(report))
save(output / 'row-comparison.json', [{'original': old, 'current': new,
'row_project_status_equal': True, 'reason_text_equal': old['reason'] == new['reason']}
for old, new in zip(expected, current)])
save(output / 'captured-loads.json', loads)
save(output / 'source-hashes.json', before_sources)
save(output / 'phases.json', phases)
summary = {'source_repo': str(repo), 'source_commit': subprocess.check_output(
['git', 'rev-parse', 'HEAD'], cwd=repo, text=True).strip(),
'application_tasks': 428, 'original_bom_rows': original_rows,
'original_replacement_rows': len(replacement_rows), 'original_replacement_projects': 102,
'captured_projects': 6, 'captured_report_files': sum(map(len, captured.values())),
'replayed_rows': report.total_rows, 'passed_rows': report.passed_rows,
'failed_rows': report.failed_rows, 'unchecked_rows': report.unchecked_rows,
'unreplayed_replacement_rows': len(replacement_rows) - report.total_rows,
'unreplayed_projects': 96, 'row_project_status_equal': True,
'cad_desktop_or_process_creations': 0, 'target_plan_writes': 0,
'copied_database_unchanged_during_inspection': True, 'original_evidence_hashes_unchanged': True,
'limitations': 'Only the 31 rows covered by six captured project inventories were replayed. '
'Original and current reason wording can differ; Excel row/project/status match exactly.'}
save(output / 'summary.json', summary)
store.close()
print(json.dumps(summary, ensure_ascii=False, indent=2))
if __name__ == '__main__':
main()