]> dreyeck.freedombox.rocks Git - topic-maps.git/blob - scripts/check-references.py
Add source-preserving TMDM Map content import with atomic preflight
[topic-maps.git] / scripts / check-references.py
1 #!/usr/bin/env python3
2 """Check observed TMDM graphs against original baselines, independent of Lisp/CXTM code."""
3 import collections
4 import json
5 import pathlib
6 import re
7 import sys
8 import xml.etree.ElementTree as ET
9
10 root = pathlib.Path(__file__).resolve().parent.parent
11 report = json.loads(pathlib.Path(sys.argv[1]).read_text())
12 assert report['kind'] == 'topic-reference-evidence' and report['failed'] == 0
13 assert report['passed'] == len(report['checks']) == len(set(report['checks']))
14 expected_counters = dict(zip([
15 'wildcard', 'wildcard-named', 'wildcard-named2', 'wildcard-named-merge',
16 'association-scope-embedded', 'association-scope-embedded2',
17 'association-type-embedded', 'association-type-embedded-merge',
18 'embedded-semicolon', 'name-scope-embedded', 'name-scope-embedded2', 'name-type-embedded', 'nested-twice',
19 'occurrence-scope-embedded', 'occurrence-scope-embedded2', 'occurrence-type-embedded',
20 'role-player-embedded', 'role-type-embedded', 'subject-identifier-embedded',
21 'variant-scope-embedded', 'variant-scope-embedded2'],
22 [1, 1, 3, 1, 2, 3, 1, 2, 1, 2, 3, 1, 2, 2, 3, 1, 1, 1, 1, 3, 4]))
23 assert [c['id'] for c in report['cases']] == ['ctm/in/' + n + '.ctm' for n in expected_counters]
24 properties = ['itemIdentifiers', 'subjectIdentifiers', 'subjectLocators']
25 for case in report['cases']:
26 name = pathlib.Path(case['id']).stem
27 assert case['ctmSource'] == (root / 'vendor/cxtm' / case['id']).read_bytes().decode('utf-8')
28 assert case['documentIRI'] == case['wildcardIRI']
29 assert case['finalCounter'] == expected_counters[name]
30 baseline = ET.parse(root / 'vendor/cxtm/ctm/baseline' / (name + '.ctm.cxtm')).getroot()
31 def absolute(value):
32 return case['documentIRI'] + value if value.startswith('#') else value
33 expected_keys = {t.attrib['number']: tuple(tuple(sorted(absolute(v.text) for v in t.findall(p + '/locator')))
34 for p in properties) for t in baseline.findall('topic')}
35 def topic_keys(snapshot):
36 return {str(t['ordinal']): tuple(tuple(sorted(t[p])) for p in properties) for t in snapshot['topics']}
37 actual = case['scopedObjects']
38 actual_keys = topic_keys(actual)
39 assert actual_keys == topic_keys(case['nameObjects'])
40 assert collections.Counter(expected_keys.values()) == collections.Counter(actual_keys.values()), name
41 def scope(keys, refs):
42 assert len(refs) == len(set(refs))
43 return tuple(sorted(keys[str(r)] for r in refs))
44 def xml_scope(item):
45 return scope(expected_keys, [t.attrib['topicref'] for t in item.findall('scope/scopingTopic')])
46 expected_items = []
47 expected_names = []
48 for owner in baseline.findall('topic'):
49 for kind in ['name', 'occurrence']:
50 for i in owner.findall(kind):
51 key = expected_keys[owner.attrib['number']]
52 item_type = expected_keys[i.find('type').attrib['topicref']]
53 expected_items.append((kind, key, item_type, i.findtext('value'), i.findtext('datatype'), xml_scope(i), ()))
54 if kind == 'name':
55 expected_names.append((key, i.findtext('value'), item_type, xml_scope(i), tuple(sorted(
56 (v.findtext('value'), v.findtext('datatype'), xml_scope(v)) for v in i.findall('variant')))))
57 for i in baseline.findall('association'):
58 roles = tuple(sorted((expected_keys[r.find('type').attrib['topicref']], expected_keys[r.find('player').attrib['topicref']])
59 for r in i.findall('role')))
60 expected_items.append(('association', 'map', expected_keys[i.find('type').attrib['topicref']], None, None, xml_scope(i), roles))
61 observed = []
62 for i in actual['items']:
63 assert all(r['parentIsAssociation'] for r in i['roles'])
64 observed.append((i['kind'], 'map' if i['parent'] == 'map' else actual_keys[str(i['parent'])],
65 actual_keys[str(i['typeTopicOrdinal'])], i['value'], i['datatype'],
66 scope(actual_keys, i['scopeTopicOrdinals']), tuple(sorted(
67 (actual_keys[str(r['typeTopicOrdinal'])], actual_keys[str(r['playerTopicOrdinal'])]) for r in i['roles']))))
68 assert collections.Counter(expected_items) == collections.Counter(observed), name
69 observed_names = []
70 for n in case['nameObjects']['names']:
71 for v in n['variants']:
72 assert v['parentIsName'] and v['rawParentIsName']
73 assert set(n['scope']) < set(v['scope'])
74 observed_names.append((actual_keys[str(n['owner'])], n['value'], actual_keys[str(n['type'])],
75 scope(actual_keys, n['scope']), tuple(sorted(
76 (v['value'], v['datatype'], scope(actual_keys, v['scope'])) for v in n['variants']))))
77 assert collections.Counter(expected_names) == collections.Counter(observed_names), name
78 generated = [iri for key in actual_keys.values() for iri in key[0] if iri.startswith(case['wildcardIRI'] + '#$__')]
79 assert len(generated) == len(set(generated)) == case['finalCounter']
80 numbers = [int(re.fullmatch(re.escape(case['wildcardIRI']) + r'#\$__(\d+)(?:\..+)?', iri).group(1)) for iri in generated]
81 assert sorted(numbers) == list(range(1, case['finalCounter'] + 1)), name
82
83 print('REFERENCES-INDEPENDENT-PASS: 21 original model graphs; identity categories, generated locators/counters, Parent/Type/Player/Scope/Variant relations')