Coverage for python/pyshacl_turbo/conformance.py: 100.0%

1"""DASH expected-result adapters. SPARQL execution remains in the Rust engine.""" 

2 

3from io import StringIO (empty)

4 

5from rdflib import BNode, Graph, Literal, Namespace (empty)

6from rdflib.compare import isomorphic (empty)

7from rdflib.namespace import OWL, RDF, RDFS, SH (empty)

8from rdflib.query import Result (empty)

9 

10from . import _native (empty)

11from .rdf import input_graph, union (empty)

12 

13DASH = Namespace("http://datashapes.org/dash#") (empty)

14 

15 

16def query_prefixes(graph, node): (empty)

17 prefixes = dict(graph.namespaces()) 27 ctx1cmnMNpJabqrstuvwxyzABCDEFGH

18 pending, seen = list(graph.objects(node, SH.prefixes)), set() 27 ctx1cmnMNpJabqrstuvwxyzABCDEFGH

19 if pending: 27 ctx1cmnMNpJabqrstuvwxyzABCDEFGH

20 pending.extend(graph.subjects(RDF.type, OWL.Ontology)) 3 ctx1MNp

21 pending.append(graph.identifier) 3 ctx1MNp

22 while pending: 27 ctx1cmnMNpJabqrstuvwxyzABCDEFGH

23 resource = pending.pop() 3 ctx1MNp

24 if resource in seen: 3 ctx1MNp

25 continue 1 ctx1p

26 seen.add(resource) 3 ctx1MNp

27 pending.extend(graph.objects(resource, OWL.imports)) 3 ctx1MNp

28 for declaration in graph.objects(resource, SH.declare): 3 ctx1MNp

29 prefix = graph.value(declaration, SH.prefix, any=False) 3 ctx1MNp

30 namespace = graph.value(declaration, SH.namespace, any=False) 3 ctx1MNp

31 if prefix is None or namespace is None: 3 ctx1MNp

32 raise ValueError("Incomplete sh:declare") 2 ctx1MN

33 prefixes[str(prefix)] = namespace 1 ctx1p

34 return "".join(f"PREFIX {p}: <{ns}>\n" for p, ns in sorted(prefixes.items())) 25 ctx1cmnpJabqrstuvwxyzABCDEFGH

35 

36 

37def extract_query_and_expected_result(test_case, graph, log=None): (empty)

38 text = graph.value(test_case, SH.select, any=False) 25 ctx1cJWXUabqrstuvwxyzABCDEFGH

39 expected = graph.value(test_case, DASH.expectedResult, any=False) 25 ctx1cJWXUabqrstuvwxyzABCDEFGH

40 if text is None or expected is None: 25 ctx1cJWXUabqrstuvwxyzABCDEFGH

41 raise RuntimeError("QueryTestCase requires sh:select and dash:expectedResult") 2 ctx1WX

42 result = Result.parse(StringIO(str(expected)), format="json") 23 ctx1cJUabqrstuvwxyzABCDEFGH

43 if result.type != "SELECT": 23 ctx1cJUabqrstuvwxyzABCDEFGH

44 raise RuntimeError("QueryTestCase expected result must be SELECT") 1 ctx1U

45 return query_prefixes(graph, test_case) + str(text), result 22 ctx1cJabqrstuvwxyzABCDEFGH

46 

47 

48def evaluate_query_testcase(query_graph, test_case, log=None): (empty)

49 query, expected = extract_query_and_expected_result(test_case, query_graph, log) 22 ctx1cJabqrstuvwxyzABCDEFGH

50 snapshot = input_graph(query_graph) 22 ctx1cJabqrstuvwxyzABCDEFGH

51 actual = Result.parse( 22 ctx1cJabqrstuvwxyzABCDEFGH

52 StringIO(_native.query(snapshot.source, snapshot.format, query)), format="json" 

53 ) 

54 if actual.type != "SELECT": 21 ctx1JabqrstuvwxyzABCDEFGH

55 raise RuntimeError("QueryTestCase query must return SELECT results") 1 ctx1J

56 matches = set(actual.vars) == set(expected.vars) and [row.asdict() for row in actual] == [ 20 ctx1abqrstuvwxyzABCDEFGH

57 row.asdict() for row in expected 

58 ] 

59 return matches, None if matches else "SPARQL SELECT result differs from dash:expectedResult" 20 ctx1abqrstuvwxyzABCDEFGH

60 

61 

62def report_subgraph(graph, root, messages, details): (empty)

63 result, seen, pending = Graph(), set(), [root] 3 ctx1dKI

64 while pending: 3 ctx1dKI

65 node = pending.pop() 3 ctx1dKI

66 if node in seen: 3 ctx1dKI

67 continue 1 ctx1I

68 seen.add(node) 3 ctx1dKI

69 for _, predicate, value in graph.triples((node, None, None)): 3 ctx1dKI

70 if ( 

71 (predicate == RDF.type and value == RDFS.Resource) 

72 or (predicate == SH.resultMessage and not messages) 

73 or (predicate == SH.detail and not details) 

74 ): 

75 continue 3 ctx1dKI

76 result.add((node, predicate, value)) 3 ctx1dKI

77 if isinstance(value, BNode): 3 ctx1dKI

78 pending.append(value) 3 ctx1dKI

79 return result 3 ctx1dKI

80 

81 

82def compare_reports(actual, expected, expected_root): (empty)

83 actual_root = actual.value(None, RDF.type, SH.ValidationReport, any=False) 6 ctx1dKIYZ0

84 if ( 

85 actual_root is None 

86 or actual.value(actual_root, SH.conforms) is None 

87 or expected.value(expected_root, SH.conforms) is None 

88 ): 

89 raise RuntimeError("Expected and actual reports must declare sh:conforms") 3 ctx1YZ0

90 expected_results = list(expected.objects(expected_root, SH.result)) 3 ctx1dKI

91 messages = any(expected.value(node, SH.resultMessage) is not None for node in expected_results) 3 ctx1dKI

92 details = any(expected.value(node, SH.detail) is not None for node in expected_results) 3 ctx1dKI

93 return isomorphic( 3 ctx1dKI

94 report_subgraph(actual, actual_root, messages, details), 

95 report_subgraph(expected, expected_root, messages, details), 

96 ) 

97 

98 

99def _literal_matches(expected, actual): (empty)

100 if not isinstance(actual, Literal): 10 ctx1V1efghijkl

101 return False 1 ctx11

102 try: 9 ctx1Vefghijkl

103 return bool(expected.eq(actual)) 9 ctx1Vefghijkl

104 except (TypeError, NotImplementedError): 1 ctx1V

105 # Incomparable literal values are an expected-result mismatch. 

106 return False 1 ctx1V

107 

108 

109def check_dash_result(report, expected_graph, expanded_data): (empty)

110 expected = union(expected_graph) 21 ctx1dcSPQTROmnoabefghijkl

111 data = None 21 ctx1dcSPQTROmnoabefghijkl

112 checks = [] 21 ctx1dcSPQTROmnoabefghijkl

113 for case in expected.subjects(RDF.type, DASH.GraphValidationTestCase): 21 ctx1dcSPQTROmnoabefghijkl

114 root = expected.value(case, DASH.expectedResult, any=False) 2 ctx1dT

115 if root is None: 2 ctx1dT

116 raise RuntimeError("GraphValidationTestCase requires dash:expectedResult") 1 ctx1T

117 checks.append(compare_reports(report, expected, root)) 1 ctx1d

118 for case in expected.subjects(RDF.type, DASH.InferencingTestCase): 20 ctx1dcSPQROmnoabefghijkl

119 if data is None: 11 ctx1ROoefghijkl

120 from .rdf import load_from_source 11 ctx1ROoefghijkl

121 

122 data = union(load_from_source(expanded_data)) 11 ctx1ROoefghijkl

123 results = list(expected.objects(case, DASH.expectedResult)) 11 ctx1ROoefghijkl

124 if not results: 11 ctx1ROoefghijkl

125 raise RuntimeError("InferencingTestCase requires dash:expectedResult") 1 ctx1R

126 for result in results: 10 ctx1Ooefghijkl

127 triple = tuple( 10 ctx1Ooefghijkl

128 expected.value(result, p, any=False) 

129 for p in (RDF.subject, RDF.predicate, RDF.object) 

130 ) 

131 if None in triple: 10 ctx1Ooefghijkl

132 raise RuntimeError("InferencingTestCase requires complete reified triples") 1 ctx1O

133 subject, predicate, value = triple 9 ctx1oefghijkl

134 if isinstance(value, Literal): 9 ctx1oefghijkl

135 checks.append( 8 ctx1efghijkl

136 any( 

137 _literal_matches(value, actual) 

138 for actual in data.objects(subject, predicate) 

139 ) 

140 ) 

141 else: 

142 checks.append(triple in data) 1 ctx1o

143 for case in expected.subjects(RDF.type, DASH.QueryTestCase): 18 ctx1dcSPQmnoabefghijkl

144 try: 3 ctx1cab

145 matches, _ = evaluate_query_testcase(expected, case) 3 ctx1cab

146 except (ValueError, RuntimeError, KeyError, TypeError): 1 ctx1c

147 # DASH query cases intentionally test malformed queries/results. 

148 # This is the expected-result checker, never a validator fallback. 

149 matches = False 1 ctx1c

150 checks.append(matches) 3 ctx1cab

151 for case in expected.subjects(RDF.type, DASH.FunctionTestCase): 18 ctx1dcSPQmnoabefghijkl

152 expression = expected.value(case, DASH.expression, any=False) 4 ctx1PQmn

153 result = expected.value(case, DASH.expectedResult, any=False) 4 ctx1PQmn

154 if expression is None or result is None: 4 ctx1PQmn

155 raise RuntimeError("FunctionTestCase requires dash:expression and dash:expectedResult") 2 ctx1PQ

156 query = query_prefixes(expected, case) + f"SELECT ({expression} AS ?result) WHERE {{}}" 2 ctx1mn

157 snapshot = input_graph(expected) 2 ctx1mn

158 actual = Result.parse( 2 ctx1mn

159 StringIO(_native.query(snapshot.source, snapshot.format, query)), format="json" 

160 ) 

161 checks.append([row.asdict().get("result") for row in actual] == [result]) 2 ctx1mn

162 if not checks: 16 ctx1dcSmnoabefghijkl

163 raise RuntimeError("Expected graph contains no DASH test cases") 1 ctx1S

164 return all(checks) 15 ctx1dcmnoabefghijkl