src/rdflib/plugins/parsers/trix.py
1"""
2A TriX parser for RDFLib
3"""
4
5from __future__ import annotations
6
7from typing import TYPE_CHECKING, Any, Dict, List, NoReturn, Optional, Tuple
8from xml.sax import handler, make_parser
9from xml.sax.handler import ErrorHandler
10
11from rdflib.exceptions import ParserError
12from rdflib.graph import Graph
13from rdflib.namespace import Namespace
14from rdflib.parser import InputSource, Parser
15from rdflib.store import Store
16from rdflib.term import BNode, Identifier, Literal, URIRef
17
18if TYPE_CHECKING:
19 # from xml.sax.expatreader import ExpatLocator
20 from xml.sax.xmlreader import AttributesImpl, Locator, XMLReader
21
22__all__ = ["create_parser", "TriXHandler", "TriXParser"]
23
24
25TRIXNS = Namespace("http://www.w3.org/2004/03/trix/trix-1/")
26XMLNS = Namespace("http://www.w3.org/XML/1998/namespace")
27
28
29class TriXHandler(handler.ContentHandler):
30 """An Sax Handler for TriX. See http://sw.nokia.com/trix/"""
31
32 lang: Optional[str]
33 datatype: Optional[str]
34
35 def __init__(self, store: Store):
36 self.store = store
37 self.preserve_bnode_ids = False
38 self.reset()
39
40 def reset(self) -> None:
41 self.bnode: Dict[str, BNode] = {}
42 self.graph: Optional[Graph] = None
43 self.triple: Optional[List[Identifier]] = None
44 self.state = 0
45 self.lang = None
46 self.datatype = None
47
48 # ContentHandler methods
49
50 def setDocumentLocator(self, locator: Locator):
51 self.locator = locator
52
53 def startDocument(self) -> None:
54 pass
55
56 def startPrefixMapping(self, prefix: Optional[str], namespace: str) -> None:
57 pass
58
59 def endPrefixMapping(self, prefix: Optional[str]) -> None:
60 pass
61
62 def startElementNS(
63 self, name: Tuple[Optional[str], str], qname, attrs: AttributesImpl
64 ) -> None:
65 if name[0] != str(TRIXNS):
66 self.error(
67 "Only elements in the TriX namespace are allowed. %s!=%s"
68 % (name[0], TRIXNS)
69 )
70
71 if name[1].lower() == "trix":
72 if self.state == 0:
73 self.state = 1
74 else:
75 self.error("Unexpected TriX element")
76
77 elif name[1] == "graph":
78 if self.state == 1:
79 self.state = 2
80 else:
81 self.error("Unexpected graph element")
82
83 elif name[1] == "uri":
84 if self.state == 2:
85 # the context uri
86 self.state = 3
87 elif self.state == 4:
88 # part of a triple
89 pass
90 else:
91 self.error("Unexpected uri element")
92
93 elif name[1] == "triple":
94 if self.state == 2:
95 if self.graph is None:
96 # anonymous graph, create one with random bnode id
97 self.graph = Graph(store=self.store)
98 # start of a triple
99 self.triple = []
100 self.state = 4
101 else:
102 self.error("Unexpected triple element")
103
104 elif name[1] == "typedLiteral":
105 if self.state == 4:
106 # part of triple
107 self.lang = None
108 self.datatype = None
109
110 try:
111 self.lang = attrs.getValue((str(XMLNS), "lang")) # type: ignore[arg-type, unused-ignore]
112 except Exception:
113 # language not required - ignore
114 pass
115 try:
116 self.datatype = attrs.getValueByQName("datatype") # type: ignore[arg-type, unused-ignore]
117 except KeyError:
118 self.error("No required attribute 'datatype'")
119 else:
120 self.error("Unexpected typedLiteral element")
121
122 elif name[1] == "plainLiteral":
123 if self.state == 4:
124 # part of triple
125 self.lang = None
126 self.datatype = None
127 try:
128 # type error: Argument 1 to "getValue" of "AttributesImpl" has incompatible type "Tuple[str, str]"; expected "str"
129 self.lang = attrs.getValue((str(XMLNS), "lang")) # type: ignore[arg-type, unused-ignore]
130 except Exception:
131 # language not required - ignore
132 pass
133
134 else:
135 self.error("Unexpected plainLiteral element")
136
137 elif name[1] == "id":
138 if self.state == 2:
139 # the context uri
140 self.state = 3
141
142 elif self.state == 4:
143 # part of triple
144 pass
145 else:
146 self.error("Unexpected id element")
147
148 else:
149 self.error("Unknown element %s in TriX namespace" % name[1])
150
151 self.chars = ""
152
153 def endElementNS(self, name: Tuple[Optional[str], str], qname) -> None:
154 if TYPE_CHECKING:
155 assert self.triple is not None
156 if name[0] != str(TRIXNS):
157 self.error(
158 "Only elements in the TriX namespace are allowed. %s!=%s"
159 % (name[0], TRIXNS)
160 )
161
162 if name[1] == "uri":
163 if self.state == 3:
164 self.graph = Graph(
165 store=self.store, identifier=URIRef(self.chars.strip())
166 )
167 self.state = 2
168 elif self.state == 4:
169 self.triple += [URIRef(self.chars.strip())]
170 else:
171 self.error(
172 "Illegal internal self.state - This should never "
173 + "happen if the SAX parser ensures XML syntax correctness"
174 )
175
176 elif name[1] == "id":
177 if self.state == 3:
178 self.graph = Graph(
179 self.store, identifier=self.get_bnode(self.chars.strip())
180 )
181 self.state = 2
182 elif self.state == 4:
183 self.triple += [self.get_bnode(self.chars.strip())]
184 else:
185 self.error(
186 "Illegal internal self.state - This should never "
187 + "happen if the SAX parser ensures XML syntax correctness"
188 )
189
190 elif name[1] == "plainLiteral" or name[1] == "typedLiteral":
191 if self.state == 4:
192 self.triple += [
193 Literal(self.chars, lang=self.lang, datatype=self.datatype)
194 ]
195 else:
196 self.error(
197 "This should never happen if the SAX parser "
198 + "ensures XML syntax correctness"
199 )
200
201 elif name[1] == "triple":
202 if self.state == 4:
203 if len(self.triple) != 3:
204 self.error(
205 "Triple has wrong length, got %d elements: %s"
206 % (len(self.triple), self.triple)
207 )
208 # type error: Item "None" of "Optional[Graph]" has no attribute "add"
209 # type error: Argument 1 to "add" of "Graph" has incompatible type "List[Identifier]"; expected "Tuple[Node, Node, Node]"
210 self.graph.add(self.triple) # type: ignore[union-attr, arg-type]
211 # self.store.store.add(self.triple,context=self.graph)
212 # self.store.addN([self.triple+[self.graph]])
213 self.state = 2
214 else:
215 self.error(
216 "This should never happen if the SAX parser "
217 + "ensures XML syntax correctness"
218 )
219
220 elif name[1] == "graph":
221 self.graph = None
222 self.state = 1
223
224 elif name[1].lower() == "trix":
225 self.state = 0
226
227 else:
228 self.error("Unexpected close element")
229
230 def get_bnode(self, label: str) -> BNode:
231 if self.preserve_bnode_ids:
232 bn = BNode(label)
233 else:
234 if label in self.bnode:
235 bn = self.bnode[label]
236 else:
237 bn = BNode(label)
238 self.bnode[label] = bn
239 return bn
240
241 def characters(self, content: str) -> None:
242 self.chars += content
243
244 def ignorableWhitespace(self, content) -> None:
245 pass
246
247 def processingInstruction(self, target, data) -> None:
248 pass
249
250 def error(self, message: str) -> NoReturn:
251 locator = self.locator
252 info = "%s:%s:%s: " % (
253 locator.getSystemId(),
254 locator.getLineNumber(),
255 locator.getColumnNumber(),
256 )
257 raise ParserError(info + message)
258
259
260def create_parser(store: Store) -> XMLReader:
261 parser = make_parser()
262 try:
263 # Workaround for bug in expatreader.py. Needed when
264 # expatreader is trying to guess a prefix.
265 # type error: "XMLReader" has no attribute "start_namespace_decl"
266 parser.start_namespace_decl("xml", "http://www.w3.org/XML/1998/namespace") # type: ignore[attr-defined]
267 except AttributeError:
268 pass # Not present in Jython (at least)
269 parser.setFeature(handler.feature_namespaces, 1)
270 trix = TriXHandler(store)
271 parser.setContentHandler(trix)
272 parser.setErrorHandler(ErrorHandler())
273 return parser
274
275
276class TriXParser(Parser):
277 """A parser for TriX. See http://sw.nokia.com/trix/"""
278
279 def __init__(self):
280 pass
281
282 def parse(self, source: InputSource, sink: Graph, **args: Any) -> None:
283 assert (
284 sink.store.context_aware
285 ), "TriXParser must be given a context aware store."
286
287 self._parser = create_parser(sink.store)
288 content_handler = self._parser.getContentHandler()
289 preserve_bnode_ids = args.get("preserve_bnode_ids", None)
290 if preserve_bnode_ids is not None:
291 # type error: ContentHandler has no attribute "preserve_bnode_ids"
292 content_handler.preserve_bnode_ids = preserve_bnode_ids # type: ignore[attr-defined, unused-ignore]
293 # We're only using it once now
294 # content_handler.reset()
295 # self._parser.reset()
296 self._parser.parse(source)