]> dreyeck.freedombox.rocks Git - topic-maps.git/blob - scripts/validate-slice-21n.py
Add XTM Variant reification and qualify Slice 21O originals
[topic-maps.git] / scripts / validate-slice-21n.py
1 #!/usr/bin/env python3
2 """Validate XTM three already supported Name-Reification originals through the existing ASDF/Case Record harness.
3
4 The driver checks and retains execution evidence; Lisp performs all parsing,
5 model construction and conformance classification. Historical reports are inputs.
6 """
7 import argparse
8 import datetime
9 import hashlib
10 import importlib.util
11 import json
12 import os
13 from pathlib import Path
14 import re
15 import shutil
16 import subprocess
17 import sys
18 import tempfile
19
20 sys.dont_write_bytecode = True
21 ROOT = Path(__file__).resolve().parents[1]
22 EVIDENCE = ROOT / 'reports/slice-21n'
23 PRIOR = ROOT / 'reports/slice-21m'
24 BASE = '9daceb816dbd75446ecb8ec0ef4cb5413d381588'
25 POLICY = '(version 1)(allow default)(deny network*)(deny file-write* (subpath "' + str(ROOT) + '"))'
26 ALLOWED = {'tests/xtm-identity.lisp', 'topic-maps.asd'}
27 CTM = {'pass': 262, 'fail': 4, 'unsupported': 0, 'not-run': 7}
28 TARGETS = ['xtm2/in/name-duplicate-reified' + n + '.xtm' for n in ['2', '3', '4']]
29
30
31 def read(p):
32 return json.loads(p.read_text())
33
34
35 def save(p, v):
36 p.write_text(json.dumps(v, indent=2, ensure_ascii=False) + '\n')
37
38
39 def sha(p):
40 return hashlib.sha256(p.read_bytes()).hexdigest()
41
42
43 def command(args):
44 return subprocess.check_output(args, cwd=ROOT, text=True).strip()
45
46
47 def prepare_pinned(target):
48 spec = importlib.util.spec_from_file_location('slice21g', ROOT / 'scripts/validate-slice-21m.py')
49 module = importlib.util.module_from_spec(spec)
50 spec.loader.exec_module(module)
51 return module.prepare_pinned(target)
52
53
54 def main():
55 parser = argparse.ArgumentParser(description=__doc__)
56 parser.add_argument('--sbcl', default=os.environ.get('SBCL', 'sbcl'))
57 parser.add_argument('--output', type=Path)
58 parser.add_argument('--prepare', type=Path)
59 args = parser.parse_args()
60 if args.prepare:
61 print(json.dumps(prepare_pinned(args.prepare)))
62 return
63 runtime = shutil.which(args.sbcl)
64 assert runtime and command([runtime, '--version']) == 'SBCL 2.5.4'
65 subprocess.run(['git', 'merge-base', '--is-ancestor', BASE, 'HEAD'], cwd=ROOT, check=True)
66 output = args.output.resolve() if args.output else Path(tempfile.mkdtemp(prefix='topic-maps-21n-'))
67 assert not output.is_relative_to(ROOT)
68 output.mkdir(parents=True, exist_ok=True)
69 assert not (output / 'execution.json').exists(), 'Choose an unused output directory.'
70 tracked = command(['git', 'ls-tree', '-r', '--name-only', BASE]).splitlines()
71 assert set(command(['git', 'diff', '--name-only', BASE]).splitlines()) & set(tracked) <= ALLOWED
72 protected = {p: sha(ROOT / p) for p in tracked if p not in ALLOWED}
73 historical = {p: h for p, h in protected.items() if p.startswith('reports/')}
74 sources = {p: sha(ROOT / p) for p in [*sorted(ALLOWED), 'tests/xtm-name-reification-originals.lisp', 'scripts/validate-slice-21n.py',
75 *['reports/slice-21n/' + p for p in ['candidate-inventory.json', 'api-preflight.lisp', 'failure-controls.lisp', 'diagnostics.lisp',
76 'before-diagnostics.json', 'baseline-xtm.json', 'baseline-execution.json', 'baseline-ctm.validation.json']]]}
77 previous = read(PRIOR / 'xtm.json')
78 assert read(EVIDENCE / 'baseline-xtm.json') == previous
79 assert previous['statuses'] == {'pass': 65, 'fail': 0, 'unsupported': 0, 'not-run': 0}
80 assert previous['otherCorpusInputs'] == {'positiveUnexecuted': 56, 'negativeUnregisteredUnexecuted': 3}
81 assert read(PRIOR / 'ctm.validation.json')['statuses'] == CTM
82 assert read(EVIDENCE / 'baseline-execution.json')['acceptancePassed']
83 assert read(EVIDENCE / 'baseline-ctm.validation.json') == read(PRIOR / 'ctm.validation.json')
84 candidate = read(EVIDENCE / 'candidate-inventory.json')
85 assert [c['id'] for c in candidate['candidates']] == TARGETS
86 assert [c['sourceBytes'] for c in candidate['candidates']] == [397, 286, 286]
87 assert [c['baselineBytes'] for c in candidate['candidates']] == [701, 497, 497]
88 assert not set(TARGETS) & {c['id'] for c in previous['cases']}
89 assert read(EVIDENCE / 'before-diagnostics.json') == read(PRIOR / 'after-diagnostics.json')
90 started = datetime.datetime.now(datetime.timezone.utc).isoformat()
91 runs = []
92
93 def run(label, invocation, env, expected_exit=0):
94 invocation = ['/usr/bin/sandbox-exec', '-p', POLICY] + invocation
95 entry = {'label': label, 'command': invocation, 'network': 'denied', 'repositoryWrites': 'denied',
96 'freshProcess': True, 'startedAtUTC': datetime.datetime.now(datetime.timezone.utc).isoformat()}
97 result = subprocess.run(invocation, cwd=ROOT, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=300)
98 (output / (label + '.log')).write_bytes(result.stdout)
99 entry.update(exitCode=result.returncode, expectedExitCode=expected_exit,
100 finishedAtUTC=datetime.datetime.now(datetime.timezone.utc).isoformat())
101 runs.append(entry)
102 assert result.returncode == expected_exit, f'{label}: see {output / (label + ".log")}'
103 return result.stdout.decode()
104
105 retained = output / 'retained'
106 retained.mkdir()
107 env = {k: v for k, v in os.environ.items() if not k.startswith('TOPIC_MAPS_')}
108 env.update(PYTHONDONTWRITEBYTECODE='1', GIT_OPTIONAL_LOCKS='0', SBCL=runtime)
109 with tempfile.TemporaryDirectory(prefix='topic-maps-21n-sources-') as temp_name:
110 provenance = json.loads(run('source-preparation', ['python3', str(Path(__file__)), '--prepare', temp_name + '/sources'], env))
111 save(output / 'source-preparation.json', provenance)
112 env.update(CL_SOURCE_REGISTRY=provenance['sourceRegistry'], TOPIC_MAPS_REPORT=str(retained / 'core.json'),
113 TOPIC_MAPS_XTM_REPORT=str(output / 'xtm.json'), TOPIC_MAPS_XTM_MERGEMAP_REPORT=str(retained / 'xtm-mergemap'),
114 TOPIC_MAPS_REGISTERED_ORIGINALS_REPORT=str(retained / 'slice20a'), TOPIC_MAPS_REGISTERED_NEGATIVES_REPORT=str(retained / 'slice20b'),
115 TOPIC_MAPS_PROLOG_REPORT=str(retained / 'slice20c'), TOPIC_MAPS_EMPTY2_REPORT=str(retained / 'slice20e'),
116 TOPIC_MAPS_CTM_INTEGER_REPORT=str(retained / 'slice20f'), TOPIC_MAPS_TRIPLE_REPORT=str(retained / 'slice20g'),
117 TOPIC_MAPS_ENCODING_REPORT=str(output / 'ctm'))
118 prefix = [runtime, '--noinform', '--no-sysinit', '--no-userinit', '--script']
119 xml = run('xml', prefix + ['tests/cxml-probe.lisp'], env)
120 xml_labels = re.findall(r'^CXML-CHECK-PASS (.+)$', xml, re.M)
121 assert len(xml_labels) == len(set(xml_labels)) == 146 and 'CXML-SUMMARY 146 PASS 0 FAIL' in xml
122 api_probe = run('name-reifier-api-preflight', prefix + [str(EVIDENCE / 'api-preflight.lisp')], env)
123 assert 'NAME-REIFIER-API-PREFLIGHT-PASS:' in api_probe
124 xtm_log = run('xtm', prefix + ['scripts/fresh-xtm.lisp'], env)
125 xtm = read(output / 'xtm.json')
126 labels = re.findall(r'^XTM-CHECK-PASS (.+)$', xtm_log, re.M)
127 assert labels == xtm['checks'] and len(labels) == len(set(labels))
128 rename = {}
129 control_retargets = []
130 retained_labels = previous['checks']
131 assert set(retained_labels) <= set(labels)
132 assert [label for label in labels if label in set(retained_labels)] == retained_labels
133 assert f'XTM-SUMMARY {len(labels)} PASS 0 FAIL; 60 original CXTM PASS; 8 negative originals PASS' in xtm_log
134 assert xtm['statuses'] == {'pass': 68, 'fail': 0, 'unsupported': 0, 'not-run': 0}
135 assert xtm['otherCorpusInputs'] == {'positiveUnexecuted': 53, 'negativeUnregisteredUnexecuted': 3}
136 assert xtm['cases'][:65] == previous['cases']
137 for field, value in previous.items():
138 if field not in ['scope', 'statuses', 'otherCorpusInputs', 'checks', 'cases']:
139 assert xtm[field] == value, field
140 assert len(xtm['cases']) == len({c['id'] for c in xtm['cases']}) == 68
141 assert [c['id'] for c in xtm['cases'][65:]] == TARGETS
142 assert all(c['status'] == 'pass' and c['actualOutcome'] == 'cxtm-match' for c in xtm['cases'][65:])
143 assert len(xtm['nameFollowupOriginals']) == 3
144 regression = run('regression', [str(ROOT / 'scripts/test.sh')], env)
145 run('diagnostics', prefix + [str(EVIDENCE / 'diagnostics.lisp')],
146 dict(env, TOPIC_MAPS_21N_ROOT=str(ROOT), TOPIC_MAPS_21N_DIAGNOSTICS=str(output / 'after-diagnostics.json')))
147 fault_controls = []
148 positive_modes = [('mismatch', 'cxtm-mismatch'), ('xml', 'execution-error'), ('unsupported', 'unsupported'), ('tmdm', 'execution-error')]
149 negative_modes = [('accepted', 'ctm-acceptance'), ('xml', 'execution-error'), ('unsupported', 'unsupported'), ('wrong-cause', 'execution-error')]
150 families = {'positive': positive_modes + [('xtm', 'execution-error')], 'negative': negative_modes,
151 'name': positive_modes, 'scope': positive_modes, 'iid': positive_modes, 'variant': positive_modes,
152 'variant-negative': negative_modes + [('tmdm', 'execution-error')],
153 'merge-variant': positive_modes + [('xtm', 'execution-error')],
154 'resource-ref': positive_modes + [('xtm', 'execution-error')],
155 'resource-ref-relative': positive_modes + [('xtm', 'execution-error')],
156 'uri-data': positive_modes + [('xtm', 'execution-error')],
157 'variant-iid': positive_modes + [('xtm', 'execution-error')],
158 'variant-iid-duplicate': positive_modes + [('xtm', 'execution-error')],
159 'map-reifier': positive_modes + [('xtm', 'execution-error')],
160 'map-reifier-condition': [('wrong-cause', 'foreign-reifier-rejected-as-wrong-condition')],
161 'name-reifier': positive_modes + [('xtm', 'execution-error')],
162 'name-reifier-duplicate': positive_modes + [('xtm', 'execution-error')],
163 'name-reifier-condition': [('wrong-cause', 'foreign-reifier-rejected-as-wrong-condition')],
164 'name-followup2': positive_modes + [('xtm', 'execution-error')],
165 'name-followup3': positive_modes + [('xtm', 'execution-error')],
166 'name-followup4': positive_modes + [('xtm', 'execution-error')]}
167 for family, modes in families.items():
168 for mode, outcome in modes:
169 label = family + '-control-' + mode
170 run(label, prefix + [str(EVIDENCE / 'failure-controls.lisp')],
171 dict(env, TOPIC_MAPS_XTM_REPORT=str(output / (label + '.json')), TOPIC_MAPS_21N_FAMILY=family, TOPIC_MAPS_21N_FAULT=mode), expected_exit=1)
172 result = read(output / (label + '.json'))
173 retained_count = {'positive': 0, 'negative': 26, 'name': 33, 'scope': 43, 'iid': 48, 'variant': 50, 'variant-negative': 55, 'merge-variant': 56, 'resource-ref': 57, 'resource-ref-relative': 58, 'uri-data': 59, 'variant-iid': 60, 'variant-iid-duplicate': 61, 'map-reifier': 62, 'map-reifier-condition': 63, 'name-reifier': 63, 'name-reifier-duplicate': 64, 'name-reifier-condition': 65, 'name-followup2': 65, 'name-followup3': 66, 'name-followup4': 67}[family]
174 assert result['statuses']['pass'] == retained_count
175 if family in ['map-reifier-condition', 'name-reifier-condition']:
176 assert len(result['cases']) == retained_count
177 is_name = family == 'name-reifier-condition'
178 wrong_label = 'name:native-reuse-reifier' if is_name else 'reuse-reifier'
179 wrong = next(row for row in result['nameReifierControls' if is_name else 'mapReifierControls'] if row['label'] == wrong_label)
180 assert wrong['expectedCode'] == 'reifier-conflict'
181 assert wrong['condition']['class'] == 'REIFICATION-ERROR' and wrong['condition']['code'] == 'foreign-reifier'
182 assert wrong['atomicNativeOperation']
183 assert result['checks'][-1] == 'map-reifier-error:' + wrong_label + ':specific-class-code'
184 else:
185 assert len(result['cases']) == retained_count + 1 and result['cases'][-1]['actualOutcome'] == outcome
186 assert result['cases'][:retained_count] == xtm['cases'][:retained_count]
187 if family in ['map-reifier', 'name-reifier', 'name-reifier-duplicate', 'name-followup2', 'name-followup3', 'name-followup4'] and mode == 'tmdm':
188 outputs = result['nameFollowupOriginals'] if family.startswith('name-followup') else (result['mapReifierOriginals'] if family == 'map-reifier' else result['nameReifierOriginals'])
189 actual_condition = next(row for row in outputs if row['id'] == result['cases'][-1]['id'])['condition']
190 assert actual_condition['class'] == 'REIFICATION-ERROR' and actual_condition['code'] == 'reifier-conflict'
191 fault_controls.append({'family': family, 'mode': mode, 'actualOutcome': outcome,
192 'expectedASDFFailureObserved': True, 'retainedOriginalPasses': retained_count, 'faultCountedAsPass': False})
193
194 verified = []
195 for old in sorted((PRIOR / 'retained').glob('*.json')):
196 assert read(old) == read(retained / old.name), str(old)
197 verified.append(str(old.relative_to(ROOT)))
198 for suffix in ['validation', 'cxtm', 'encoding']:
199 old = PRIOR / f'ctm.{suffix}.json'
200 assert read(old) == read(output / f'ctm.{suffix}.json'), str(old)
201 verified.append(str(old.relative_to(ROOT)))
202 totals = read(ROOT / 'reports/slice-19d1/regression-execution.json')['regressionChecks']
203 stages = read(PRIOR / 'execution.json')['stageChecks']
204 assert sum(totals.values()) == 12100
205 for marker, count in dict(totals, **stages).items():
206 assert int(re.search(r'(?m)^' + marker + r'-PASS: (\d+)', regression).group(1)) == count
207 assert 'Ran 2 tests' in regression and 'NFC-ORACLE-PASS: 16294' in regression
208 assert read(output / 'ctm.validation.json')['statuses'] == CTM
209 comparisons = []
210 (output / 'actual').mkdir()
211 for candidate_case, result in zip(candidate['candidates'], xtm['nameFollowupOriginals']):
212 assert result['id'] == candidate_case['id'] and result['condition'] is None and result['status'] == 'pass'
213 source = ROOT / 'vendor/cxtm' / result['id']
214 baseline = ROOT / 'vendor/cxtm/xtm2/baseline' / (source.name + '.cxtm')
215 raw, actual = source.read_bytes(), result['actualCXTM'].encode('utf-8')
216 assert raw == bytes.fromhex(result['sourceHex']) == result['sourceText'].encode('utf-8')
217 assert sha(source) == candidate_case['sourceSHA256'] and len(raw) == result['sourceBytes'] == candidate_case['sourceBytes']
218 assert actual == result['expectedCXTM'].encode('utf-8') == baseline.read_bytes()
219 assert len(actual) == result['actualBytes'] == result['expectedBytes'] == candidate_case['baselineBytes']
220 assert sha(baseline) == candidate_case['baselineSHA256'] and result['firstDifferentByte'] is None
221 assert result['documentIRI'] == candidate_case['documentIRI'] and result['sourceKey'] == result['id']
222 model = result['model']
223 identity = model['identity']['nameModel']['identity']
224 assert model['canonicalNameReifierInverseEQ'] and model['mapReifierTopic'] is None
225 assert model['nameReifierTopics'] == [3]
226 number = TARGETS.index(result['id']) + 2
227 assert result['sourceNameCount'] == 2 and result['primaryQualifiedParserCalls'] == 1
228 assert result['sourceNameIIPositions'] == ([] if number == 2 else [number - 2])
229 assert result['reifierLocator'] == result['documentIRI'] + '#reifier1'
230 expected_topics = [
231 {'ordinal': 1, 'itemIdentifiers': [result['documentIRI'] + '#topic'], 'subjectIdentifiers': [], 'subjectLocators': []},
232 {'ordinal': 2, 'itemIdentifiers': [], 'subjectIdentifiers': ['http://psi.topicmaps.org/iso13250/model/topic-name'], 'subjectLocators': []},
233 {'ordinal': 3, 'itemIdentifiers': [result['reifierLocator']], 'subjectIdentifiers': [], 'subjectLocators': []}]
234 if number == 2:
235 expected_topics.append({'ordinal': 4, 'itemIdentifiers': [result['documentIRI'] + '#ahwell'], 'subjectIdentifiers': [], 'subjectLocators': []})
236 assert identity['topicCount'] == len(expected_topics) and identity['associationCount'] == 0 and identity['topics'] == expected_topics
237 assert model['topicReifiedNames'] == ([None, None, 1, None] if number == 2 else [None, None, 1])
238 assert model['identity']['nameModel']['mapItemIdentifiers'] == []
239 assert model['identity']['nameModel']['names'] == [{'value': 'Topic', 'parent': 1, 'type': 2, 'scope': [],
240 'itemIdentifiers': [] if number == 2 else [result['documentIRI'] + '#name'], 'variantCount': 1 if number == 2 else 0}]
241 assert model['identity']['variants'] == ([{'value': 'topic', 'datatype': 'http://www.w3.org/2001/XMLSchema#string',
242 'parentName': 1, 'scope': [4], 'itemIdentifiers': [], 'reifier': None}] if number == 2 else [])
243 trace = result['stagedNormalizationTrace']
244 assert trace['firstAndSecondNameReturnsEQ'] and trace['retainedReifierEQ'] and trace['afterSecondName'] == model
245 assert trace['afterFirstName']['identity']['nameModel']['names'][0]['itemIdentifiers'] == ([result['documentIRI'] + '#name'] if number == 3 else [])
246 assert trace['firstVariantPreservedEQ'] is (True if number == 2 else None)
247 (output / 'actual' / baseline.name).write_bytes(actual)
248 comparisons.append(dict(result, sourceSHA256=sha(source), baselineSHA256=sha(baseline),
249 actualSHA256=hashlib.sha256(actual).hexdigest(), executedInASDFTestOp=True))
250 before, after = read(EVIDENCE / 'before-diagnostics.json'), read(output / 'after-diagnostics.json')
251 assert len(before) == len(after) == 124
252 assert [c['id'] for c in before] == [c['id'] for c in after]
253 changes = [{'id': a['id'], 'before': b, 'after': a} for b, a in zip(before, after) if b != a]
254 save(output / 'diagnostic-changes.json', changes)
255 assert not changes and before == after == read(PRIOR / 'after-diagnostics.json'), 'Unexpected Reader diagnostic change: inspect diagnostic-changes.json before evaluation.'
256 assert comparisons[1]['actualCXTM'] == comparisons[2]['actualCXTM']
257 pending_negative = ['xtm2/invalid/' + stem + '.xtm' for stem in
258 ['reifier-collision', 'role-duplicate-reified', 'topicref-no-fragment-id']]
259 assert not set(pending_negative) & {case['id'] for case in xtm['cases']}
260 save(output / 'diagnostic-changes.json', changes)
261 lock = read(ROOT / 'references/corpus-lock.json')
262 for entry in lock['files']:
263 p = ROOT / 'vendor/cxtm' / entry['path']
264 assert p.stat().st_size == entry['size'] and sha(p) == entry['sha256']
265 for snapshot in [protected, historical, sources]:
266 assert snapshot == {p: sha(ROOT / p) for p in snapshot}
267 assert set(command(['git', 'diff', '--name-only', BASE]).splitlines()) & set(tracked) <= ALLOWED
268 save(output / 'name-followup-originals.json', {'kind': 'executed-existing-language-name-reifier-original-registration', 'cases': comparisons})
269 save(output / 'diagnostics.json', {'kind': 'read-only-observations-no-extra-registration',
270 'originalObservations': 124, 'unchangedOriginalObservations': 124 - len(changes),
271 'diagnosticChanges': changes, 'registeredCases': TARGETS, 'negativeOriginalsRemainingNotRun': pending_negative,
272 'all124ObservationsUnchanged': True, 'alreadySuccessfulDiagnosticsNewlyRegistered': TARGETS})
273 save(output / 'failure-controls.json', {'kind': 'executor-fault-controls-not-corpus-results', 'controls': fault_controls})
274 save(output / 'integrity.json', {'protectedBaseFilesSHA256': protected, 'historicalReportsSHA256': historical, 'executionSourcesSHA256': sources})
275 statuses = dict(xtm['statuses'], **{'not-run': sum(xtm['otherCorpusInputs'].values())})
276 save(output / 'execution.json', {'kind': 'xtm-name-reifier-followup-original-registration-validation', 'baseCommit': BASE,
277 'branch': command(['git', 'branch', '--show-current']), 'runtime': 'SBCL 2.5.4', 'startedAtUTC': started,
278 'finishedAtUTC': datetime.datetime.now(datetime.timezone.utc).isoformat(), 'runs': runs,
279 'sourcePreparation': 'source-preparation.json', 'retainedLispChecks': 12100, 'retainedChecks': totals,
280 'stageChecks': stages, 'xmlQualificationChecks': 146, 'nativeNameReifierAPIPreflightPassed': True, 'standaloneXTMChecks': len(labels),
281 'retainedXTMChecks': len(previous['checks']), 'retargetedUnsupportedCheckNames': rename,
282 'newXTMChecks': len(labels) - len(previous['checks']), 'retargetedUnsupportedControlRows': control_retargets,
283 'retainedOriginals': 65, 'retainedOriginalResultsUnchanged': True, 'newPositiveOriginals': 3,
284 'originalByteComparisons': [{'id': c['id'], 'actual': c['actualBytes'], 'baseline': c['expectedBytes'], 'firstDifferentByte': None} for c in comparisons], 'faultControls': len(fault_controls),
285 'diagnosticOriginalObservations': 124, 'diagnosticChangedOriginals': [c['id'] for c in changes],
286 'xtmStatusesBefore': {'pass': 65, 'fail': 0, 'unsupported': 0, 'not-run': 59}, 'xtmStatusesAfter': statuses,
287 'xtmStatusChanges': [{'id': id, 'before': 'not-run', 'after': 'pass', 'actualOutcome': 'cxtm-match'} for id in TARGETS],
288 'ctmStatusesBefore': CTM, 'ctmStatusesAfter': CTM, 'ctmStatusChanges': [],
289 'knownFailuresUnchanged': [c['id'] for c in read(output / 'ctm.validation.json')['cases'] if c['status'] == 'fail'],
290 'pythonUnitTests': 2, 'nfcOracleComparisons': 16294, 'allRetainedNonXTMReportsIdenticalToSlice21M': verified,
291 'historicalReportFilesVerified': len(historical), 'protectedBaseFilesVerified': len(protected), 'pinnedCorpusFilesVerified': len(lock['files']),
292 'historicalReportsUnchanged': True, 'originalSourcesAndBaselinesUnchanged': True, 'productionCodeUnchanged': True, 'protectedSubsystemsUnchanged': ['XTM Reader', 'TMDM', 'CTM', 'CXTM', 'XML'],
293 'newDependencyDownloads': 0, 'persistentLispImagesTouched': False,
294 'executionAuthorization': 'Regular require_escalated approval; tests additionally deny network and repository writes; no symlink/configuration changes.',
295 'fullOfflineNixRebuild': 'NOT-RUN; fresh SBCL loads with verified pinned local sources and existing XML patches.', 'acceptancePassed': True})
296 print(json.dumps({'acceptancePassed': True, 'xtm': statuses, 'ctm': CTM, 'checks': len(labels), 'output': str(output)}))
297
298
299 if __name__ == '__main__':
300 main()