]>
dreyeck.freedombox.rocks Git - topic-maps.git/blob - scripts/check-references.py
2 """Check observed TMDM graphs against original baselines, independent of Lisp/CXTM code."""
8 import xml
.etree
.ElementTree
as ET
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()
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
))
45 return scope(expected_keys
, [t
.attrib
['topicref'] for t
in item
.findall('scope/scopingTopic')])
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
), ()))
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
))
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
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
83 print('REFERENCES-INDEPENDENT-PASS: 21 original model graphs; identity categories, generated locators/counters, Parent/Type/Player/Scope/Variant relations')