src/rdflib/plugins/parsers/rdfxml.py
1"""
2An RDF/XML parser for RDFLib
3"""
4
5from __future__ import annotations
6
7from typing import TYPE_CHECKING, Any, Dict, List, NoReturn, Optional, Tuple
8from urllib.parse import urldefrag, urljoin
9from xml.sax import handler, make_parser, xmlreader
10from xml.sax.handler import ErrorHandler
11from xml.sax.saxutils import escape, quoteattr
12
13from rdflib.exceptions import Error, ParserError
14from rdflib.graph import Graph
15from rdflib.namespace import RDF, is_ncname
16from rdflib.parser import InputSource, Parser
17from rdflib.plugins.parsers.RDFVOC import RDFVOC
18from rdflib.term import BNode, Identifier, Literal, URIRef
19
20if TYPE_CHECKING:
21 # from xml.sax.expatreader import ExpatLocator
22 from xml.sax.xmlreader import AttributesImpl, Locator
23
24 from rdflib.graph import _ObjectType, _SubjectType, _TripleType
25
26__all__ = ["create_parser", "BagID", "ElementHandler", "RDFXMLHandler", "RDFXMLParser"]
27
28RDFNS = RDFVOC
29
30# http://www.w3.org/TR/rdf-syntax-grammar/#eventterm-attribute-URI
31# A mapping from unqualified terms to their qualified version.
32UNQUALIFIED = {
33 "about": RDFVOC.about,
34 "ID": RDFVOC.ID,
35 "type": RDFVOC.type,
36 "resource": RDFVOC.resource,
37 "parseType": RDFVOC.parseType,
38}
39
40# http://www.w3.org/TR/rdf-syntax-grammar/#coreSyntaxTerms
41CORE_SYNTAX_TERMS = [
42 RDFVOC.RDF,
43 RDFVOC.ID,
44 RDFVOC.about,
45 RDFVOC.parseType,
46 RDFVOC.resource,
47 RDFVOC.nodeID,
48 RDFVOC.datatype,
49]
50
51# http://www.w3.org/TR/rdf-syntax-grammar/#syntaxTerms
52SYNTAX_TERMS = CORE_SYNTAX_TERMS + [RDFVOC.Description, RDFVOC.li]
53
54# http://www.w3.org/TR/rdf-syntax-grammar/#oldTerms
55OLD_TERMS = [
56 URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEach"),
57 URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#aboutEachPrefix"),
58 URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#bagID"),
59]
60
61NODE_ELEMENT_EXCEPTIONS = (
62 CORE_SYNTAX_TERMS
63 + [
64 RDFVOC.li,
65 ]
66 + OLD_TERMS
67)
68NODE_ELEMENT_ATTRIBUTES = [RDFVOC.ID, RDFVOC.nodeID, RDFVOC.about]
69
70PROPERTY_ELEMENT_EXCEPTIONS = (
71 CORE_SYNTAX_TERMS
72 + [
73 RDFVOC.Description,
74 ]
75 + OLD_TERMS
76)
77PROPERTY_ATTRIBUTE_EXCEPTIONS = (
78 CORE_SYNTAX_TERMS + [RDFVOC.Description, RDFVOC.li] + OLD_TERMS
79)
80PROPERTY_ELEMENT_ATTRIBUTES = [RDFVOC.ID, RDFVOC.resource, RDFVOC.nodeID]
81
82XMLNS = "http://www.w3.org/XML/1998/namespace"
83BASE = (XMLNS, "base")
84LANG = (XMLNS, "lang")
85
86
87class BagID(URIRef):
88 __slots__ = ["li"]
89
90 def __init__(self, val):
91 # type error: Too many arguments for "__init__" of "object"
92 super(URIRef, self).__init__(val) # type: ignore[call-arg]
93 self.li = 0
94
95 def next_li(self):
96 self.li += 1
97 # type error: Type expected within [...]
98 return RDFNS["_%s" % self.li] # type: ignore[misc]
99
100
101class ElementHandler:
102 __slots__ = [
103 "start",
104 "char",
105 "end",
106 "li",
107 "id",
108 "base",
109 "subject",
110 "predicate",
111 "object",
112 "list",
113 "language",
114 "datatype",
115 "declared",
116 "data",
117 ]
118
119 def __init__(self):
120 self.start = None
121 self.char = None
122 self.end = None
123 self.li = 0
124 self.id = None
125 self.base = None
126 self.subject = None
127 self.object = None
128 self.list = None
129 self.language = None
130 self.datatype = None
131 self.declared = None
132 self.data = None
133
134 def next_li(self):
135 self.li += 1
136 return RDFVOC["_%s" % self.li]
137
138
139class RDFXMLHandler(handler.ContentHandler):
140 def __init__(self, store: Graph):
141 self.store = store
142 self.preserve_bnode_ids = False
143 self.reset()
144
145 def reset(self) -> None:
146 document_element = ElementHandler()
147 document_element.start = self.document_element_start
148 document_element.end = lambda name, qname: None
149 self.stack: List[Optional[ElementHandler]] = [
150 None,
151 document_element,
152 ]
153 self.ids: Dict[str, int] = {} # remember IDs we have already seen
154 self.bnode: Dict[str, Identifier] = {}
155 self._ns_contexts: List[Dict[str, Optional[str]]] = [
156 {}
157 ] # contains uri -> prefix dicts
158 self._current_context: Dict[str, Optional[str]] = self._ns_contexts[-1]
159
160 # ContentHandler methods
161
162 def setDocumentLocator(self, locator: Locator):
163 self.locator = locator
164
165 def startDocument(self) -> None:
166 pass
167
168 def startPrefixMapping(self, prefix: Optional[str], namespace: str) -> None:
169 self._ns_contexts.append(self._current_context.copy())
170 self._current_context[namespace] = prefix
171 self.store.bind(prefix, namespace or "", override=False)
172
173 def endPrefixMapping(self, prefix: Optional[str]) -> None:
174 self._current_context = self._ns_contexts[-1]
175 del self._ns_contexts[-1]
176
177 def startElementNS(
178 self, name: Tuple[Optional[str], str], qname, attrs: AttributesImpl
179 ) -> None:
180 stack = self.stack
181 stack.append(ElementHandler())
182 current = self.current
183 parent = self.parent
184 # type error: No overlaod for "get" of "AttributesImpl" mactches tuple (str, str)
185 base = attrs.get(BASE, None) # type: ignore[call-overload, unused-ignore]
186 if base is not None:
187 base, frag = urldefrag(base)
188 if parent and parent.base:
189 base = urljoin(parent.base, base)
190 else:
191 systemId = self.locator.getPublicId() or self.locator.getSystemId()
192 if systemId:
193 base = urljoin(systemId, base)
194 else:
195 if parent:
196 base = parent.base
197 if base is None:
198 systemId = self.locator.getPublicId() or self.locator.getSystemId()
199 if systemId:
200 base, frag = urldefrag(systemId)
201 current.base = base
202 # type error: No overlaod for "get" of "AttributesImpl" mactches tuple (str, str)
203 language = attrs.get(LANG, None) # type: ignore[call-overload, unused-ignore]
204 if language is None:
205 if parent:
206 language = parent.language
207 current.language = language
208 current.start(name, qname, attrs)
209
210 def endElementNS(self, name: Tuple[Optional[str], str], qname) -> None:
211 self.current.end(name, qname)
212 self.stack.pop()
213
214 def characters(self, content: str) -> None:
215 char = self.current.char
216 if char:
217 char(content)
218
219 def ignorableWhitespace(self, content) -> None:
220 pass
221
222 def processingInstruction(self, target, data) -> None:
223 pass
224
225 def add_reified(self, sid: Identifier, spo: _TripleType):
226 s, p, o = spo
227 self.store.add((sid, RDF.type, RDF.Statement))
228 self.store.add((sid, RDF.subject, s))
229 self.store.add((sid, RDF.predicate, p))
230 self.store.add((sid, RDF.object, o))
231
232 def error(self, message: str) -> NoReturn:
233 locator = self.locator
234 info = "%s:%s:%s: " % (
235 locator.getSystemId(),
236 locator.getLineNumber(),
237 locator.getColumnNumber(),
238 )
239 raise ParserError(info + message)
240
241 def get_current(self) -> Optional[ElementHandler]:
242 return self.stack[-2]
243
244 # Create a read only property called current so that self.current
245 # give the current element handler.
246 current = property(get_current)
247
248 def get_next(self) -> Optional[ElementHandler]:
249 return self.stack[-1]
250
251 # Create a read only property that gives the element handler to be
252 # used for the next element.
253 next = property(get_next)
254
255 def get_parent(self) -> Optional[ElementHandler]:
256 return self.stack[-3]
257
258 # Create a read only property that gives the current parent
259 # element handler
260 parent = property(get_parent)
261
262 def absolutize(self, uri: str) -> URIRef:
263 # type error: Argument "allow_fragments" to "urljoin" has incompatible type "int"; expected "bool"
264 result = urljoin(self.current.base, uri, allow_fragments=1) # type: ignore[arg-type]
265 if uri and uri[-1] == "#" and result[-1] != "#":
266 result = "%s#" % result
267 return URIRef(result)
268
269 def convert(
270 self, name: Tuple[Optional[str], str], qname, attrs: AttributesImpl
271 ) -> Tuple[URIRef, Dict[URIRef, str]]:
272 if name[0] is None:
273 # type error: Incompatible types in assignment (expression has type "URIRef", variable has type "Tuple[Optional[str], str]")
274 name = URIRef(name[1]) # type: ignore[assignment]
275 else:
276 # type error: Incompatible types in assignment (expression has type "URIRef", variable has type "Tuple[Optional[str], str]")
277 # type error: Argument 1 to "join" of "str" has incompatible type "Tuple[Optional[str], str]"; expected "Iterable[str]"
278 name = URIRef("".join(name)) # type: ignore[assignment, arg-type]
279 atts = {}
280 for n, v in attrs.items():
281 # mypy error: mypy thinks n[0]==None is unreachable
282 if n[0] is None:
283 att = n[1] # type: ignore[unreachable, unused-ignore]
284 else:
285 att = "".join(n)
286 if att.startswith(XMLNS) or att[0:3].lower() == "xml":
287 pass
288 elif att in UNQUALIFIED:
289 # if not RDFNS[att] in atts:
290 # type error: Variable "att" is not valid as a type
291 atts[RDFNS[att]] = v # type: ignore[misc, valid-type]
292 else:
293 atts[URIRef(att)] = v
294 # type error: Incompatible return value type (got "Tuple[Tuple[Optional[str], str], Dict[Any, Any]]", expected "Tuple[URIRef, Dict[URIRef, str]]")
295 return name, atts # type: ignore[return-value]
296
297 def document_element_start(
298 self, name: Tuple[str, str], qname, attrs: AttributesImpl
299 ) -> None:
300 if name[0] and URIRef("".join(name)) == RDFVOC.RDF:
301 # Cheap hack so 2to3 doesn't turn it into __next__
302 next = getattr(self, "next")
303 next.start = self.node_element_start
304 next.end = self.node_element_end
305 else:
306 self.node_element_start(name, qname, attrs)
307 # self.current.end = self.node_element_end
308 # TODO... set end to something that sets start such that
309 # another element will cause error
310
311 def node_element_start(
312 self, name: Tuple[str, str], qname, attrs: AttributesImpl
313 ) -> None:
314 # type error: Incompatible types in assignment (expression has type "URIRef", variable has type "Tuple[str, str]")
315 name, atts = self.convert(name, qname, attrs) # type: ignore[assignment]
316 current = self.current
317 absolutize = self.absolutize
318
319 # Cheap hack so 2to3 doesn't turn it into __next__
320 next = getattr(self, "next")
321 next.start = self.property_element_start
322 next.end = self.property_element_end
323
324 if name in NODE_ELEMENT_EXCEPTIONS:
325 # type error: Not all arguments converted during string formatting
326 self.error("Invalid node element URI: %s" % name) # type: ignore[str-format]
327 subject: _SubjectType
328 if RDFVOC.ID in atts:
329 if RDFVOC.about in atts or RDFVOC.nodeID in atts:
330 self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
331
332 id = atts[RDFVOC.ID]
333 if not is_ncname(id):
334 self.error("rdf:ID value is not a valid NCName: %s" % id)
335 subject = absolutize("#%s" % id)
336 if subject in self.ids:
337 self.error("two elements cannot use the same ID: '%s'" % subject)
338 self.ids[subject] = 1 # IDs can only appear once within a document
339 elif RDFVOC.nodeID in atts:
340 if RDFVOC.ID in atts or RDFVOC.about in atts:
341 self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
342 nodeID = atts[RDFVOC.nodeID]
343 if not is_ncname(nodeID):
344 self.error("rdf:nodeID value is not a valid NCName: %s" % nodeID)
345 if self.preserve_bnode_ids is False:
346 if nodeID in self.bnode:
347 subject = self.bnode[nodeID]
348 else:
349 subject = BNode()
350 self.bnode[nodeID] = subject
351 else:
352 subject = BNode(nodeID)
353 elif RDFVOC.about in atts:
354 if RDFVOC.ID in atts or RDFVOC.nodeID in atts:
355 self.error("Can have at most one of rdf:ID, rdf:about, and rdf:nodeID")
356 subject = absolutize(atts[RDFVOC.about])
357 else:
358 subject = BNode()
359
360 if name != RDFVOC.Description: # S1
361 # error: Argument 1 has incompatible type "Tuple[str, str]"; expected "str"
362 self.store.add((subject, RDF.type, absolutize(name))) # type: ignore[arg-type]
363
364 object: _ObjectType
365 language = current.language
366 for att in atts:
367 if not att.startswith(str(RDFNS)):
368 predicate = absolutize(att)
369 try:
370 object = Literal(atts[att], language)
371 except Error as e:
372 # type error: Argument 1 to "error" of "RDFXMLHandler" has incompatible type "Optional[str]"; expected "str"
373 self.error(e.msg) # type: ignore[arg-type]
374 elif att == RDF.type: # S2
375 predicate = RDF.type
376 object = absolutize(atts[RDF.type])
377 elif att in NODE_ELEMENT_ATTRIBUTES:
378 continue
379 elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS: # S3
380 self.error("Invalid property attribute URI: %s" % att)
381 # type error: Statement is unreachable
382 continue # type: ignore[unreachable] # for when error does not throw an exception
383 else:
384 predicate = absolutize(att)
385 try:
386 object = Literal(atts[att], language)
387 except Error as e:
388 # type error: Argument 1 to "error" of "RDFXMLHandler" has incompatible type "Optional[str]"; expected "str"
389 self.error(e.msg) # type: ignore[arg-type]
390 self.store.add((subject, predicate, object))
391
392 current.subject = subject
393
394 def node_element_end(self, name: Tuple[str, str], qname) -> None:
395 # repeat node-elements are only allowed
396 # at at top-level
397
398 if self.parent.object and self.current != self.stack[2]:
399 self.error(
400 "Repeat node-elements inside property elements: %s" % "".join(name)
401 )
402
403 self.parent.object = self.current.subject
404
405 def property_element_start(
406 self, name: Tuple[str, str], qname, attrs: AttributesImpl
407 ) -> None:
408 # type error: Incompatible types in assignment (expression has type "URIRef", variable has type "Tuple[str, str]")
409 name, atts = self.convert(name, qname, attrs) # type: ignore[assignment]
410 current = self.current
411 absolutize = self.absolutize
412
413 # Cheap hack so 2to3 doesn't turn it into __next__
414 next = getattr(self, "next")
415 object: Optional[_ObjectType] = None
416 current.data = None
417 current.list = None
418
419 # type error: "Tuple[str, str]" has no attribute "startswith"
420 if not name.startswith(str(RDFNS)): # type: ignore[attr-defined]
421 # type error: Argument 1 has incompatible type "Tuple[str, str]"; expected "str"
422 current.predicate = absolutize(name) # type: ignore[arg-type]
423 elif name == RDFVOC.li:
424 current.predicate = current.next_li()
425 elif name in PROPERTY_ELEMENT_EXCEPTIONS:
426 # type error: Not all arguments converted during string formatting
427 self.error("Invalid property element URI: %s" % name) # type: ignore[str-format]
428 else:
429 # type error: Argument 1 has incompatible type "Tuple[str, str]"; expected "str"
430 current.predicate = absolutize(name) # type: ignore[arg-type]
431
432 id = atts.get(RDFVOC.ID, None)
433 if id is not None:
434 if not is_ncname(id):
435 self.error("rdf:ID value is not a value NCName: %s" % id)
436 current.id = absolutize("#%s" % id)
437 else:
438 current.id = None
439
440 resource = atts.get(RDFVOC.resource, None)
441 nodeID = atts.get(RDFVOC.nodeID, None)
442 parse_type = atts.get(RDFVOC.parseType, None)
443 if resource is not None and nodeID is not None:
444 self.error("Property element cannot have both rdf:nodeID and rdf:resource")
445 if resource is not None:
446 object = absolutize(resource)
447 next.start = self.node_element_start
448 next.end = self.node_element_end
449 elif nodeID is not None:
450 if not is_ncname(nodeID):
451 self.error("rdf:nodeID value is not a valid NCName: %s" % nodeID)
452 if self.preserve_bnode_ids is False:
453 if nodeID in self.bnode:
454 object = self.bnode[nodeID]
455 else:
456 subject = BNode()
457 self.bnode[nodeID] = subject
458 object = subject
459 else:
460 object = subject = BNode(nodeID)
461 next.start = self.node_element_start
462 next.end = self.node_element_end
463 else:
464 if parse_type is not None:
465 for att in atts:
466 if att != RDFVOC.parseType and att != RDFVOC.ID:
467 self.error("Property attr '%s' now allowed here" % att)
468 if parse_type == "Resource":
469 current.subject = object = BNode()
470 current.char = self.property_element_char
471 next.start = self.property_element_start
472 next.end = self.property_element_end
473 elif parse_type == "Collection":
474 current.char = None
475 object = current.list = RDF.nil # BNode()
476 # self.parent.subject
477 next.start = self.node_element_start
478 next.end = self.list_node_element_end
479 else: # if parse_type=="Literal":
480 # All other values are treated as Literal
481 # See: http://www.w3.org/TR/rdf-syntax-grammar/
482 # parseTypeOtherPropertyElt
483 object = Literal("", datatype=RDFVOC.XMLLiteral)
484 current.char = self.literal_element_char
485 current.declared = {XMLNS: "xml"}
486 next.start = self.literal_element_start
487 next.char = self.literal_element_char
488 next.end = self.literal_element_end
489 current.object = object
490 return
491 else:
492 object = None
493 current.char = self.property_element_char
494 next.start = self.node_element_start
495 next.end = self.node_element_end
496
497 datatype = current.datatype = atts.get(RDFVOC.datatype, None)
498 language = current.language
499 if datatype is not None:
500 # TODO: check that there are no atts other than datatype and id
501 datatype = absolutize(datatype)
502 else:
503 for att in atts:
504 if not att.startswith(str(RDFNS)):
505 predicate = absolutize(att)
506 elif att in PROPERTY_ELEMENT_ATTRIBUTES:
507 continue
508 elif att in PROPERTY_ATTRIBUTE_EXCEPTIONS:
509 self.error("""Invalid property attribute URI: %s""" % att)
510 else:
511 predicate = absolutize(att)
512 o: _ObjectType
513 if att == RDF.type:
514 o = URIRef(atts[att])
515 else:
516 if datatype is not None:
517 # type error: Statement is unreachable
518 language = None # type: ignore[unreachable]
519 o = Literal(atts[att], language, datatype)
520
521 if object is None:
522 object = BNode()
523 self.store.add((object, predicate, o))
524 if object is None:
525 current.data = ""
526 current.object = None
527 else:
528 current.data = None
529 current.object = object
530
531 def property_element_char(self, data: str) -> None:
532 current = self.current
533 if current.data is not None:
534 current.data += data
535
536 def property_element_end(self, name: Tuple[str, str], qname) -> None:
537 current = self.current
538 if current.data is not None and current.object is None:
539 literalLang = current.language
540 if current.datatype is not None:
541 literalLang = None
542 current.object = Literal(current.data, literalLang, current.datatype)
543 current.data = None
544 if self.next.end == self.list_node_element_end:
545 if current.object != RDF.nil:
546 self.store.add((current.list, RDF.rest, RDF.nil))
547 if current.object is not None:
548 self.store.add((self.parent.subject, current.predicate, current.object))
549 if current.id is not None:
550 self.add_reified(
551 current.id, (self.parent.subject, current.predicate, current.object)
552 )
553 current.subject = None
554
555 def list_node_element_end(self, name: Tuple[str, str], qname) -> None:
556 current = self.current
557 if self.parent.list == RDF.nil:
558 list = BNode()
559 # Removed between 20030123 and 20030905
560 # self.store.add((list, RDF.type, LIST))
561 self.parent.list = list
562 self.store.add((self.parent.list, RDF.first, current.subject))
563 self.parent.object = list
564 self.parent.char = None
565 else:
566 list = BNode()
567 # Removed between 20030123 and 20030905
568 # self.store.add((list, RDF.type, LIST))
569 self.store.add((self.parent.list, RDF.rest, list))
570 self.store.add((list, RDF.first, current.subject))
571 self.parent.list = list
572
573 def literal_element_start(
574 self, name: Tuple[str, str], qname, attrs: AttributesImpl
575 ) -> None:
576 current = self.current
577 self.next.start = self.literal_element_start
578 self.next.char = self.literal_element_char
579 self.next.end = self.literal_element_end
580 current.declared = self.parent.declared.copy()
581 if name[0]:
582 prefix = self._current_context[name[0]]
583 if prefix:
584 current.object = "<%s:%s" % (prefix, name[1])
585 else:
586 current.object = "<%s" % name[1]
587 if not name[0] in current.declared: # noqa: E713
588 current.declared[name[0]] = prefix
589 if prefix:
590 current.object += ' xmlns:%s="%s"' % (prefix, name[0])
591 else:
592 current.object += ' xmlns="%s"' % name[0]
593 else:
594 current.object = "<%s" % name[1]
595 # type error: Incompatible types in assignment (expression has type "str", variable has type "Tuple[str, str]")
596 for name, value in attrs.items(): # type: ignore[assignment, unused-ignore]
597 if name[0]:
598 if not name[0] in current.declared: # noqa: E713
599 current.declared[name[0]] = self._current_context[name[0]]
600 name = current.declared[name[0]] + ":" + name[1]
601 else:
602 # type error: Incompatible types in assignment (expression has type "str", variable has type "Tuple[str, str]")
603 name = name[1] # type: ignore[assignment]
604 current.object += " %s=%s" % (name, quoteattr(value))
605 current.object += ">"
606
607 def literal_element_char(self, data: str) -> None:
608 self.current.object += escape(data)
609
610 def literal_element_end(self, name: Tuple[str, str], qname) -> None:
611 if name[0]:
612 prefix = self._current_context[name[0]]
613 if prefix:
614 end = "</%s:%s>" % (prefix, name[1])
615 else:
616 end = "</%s>" % name[1]
617 else:
618 end = "</%s>" % name[1]
619 self.parent.object += self.current.object + end
620
621
622def create_parser(target: InputSource, store: Graph) -> xmlreader.XMLReader:
623 parser = make_parser()
624 try:
625 # Workaround for bug in expatreader.py. Needed when
626 # expatreader is trying to guess a prefix.
627 parser.start_namespace_decl("xml", "http://www.w3.org/XML/1998/namespace") # type: ignore[attr-defined]
628 except AttributeError:
629 pass # Not present in Jython (at least)
630 parser.setFeature(handler.feature_namespaces, 1)
631 rdfxml = RDFXMLHandler(store)
632 # type error: Argument 1 to "setDocumentLocator" of "RDFXMLHandler" has incompatible type "InputSource"; expected "Locator"
633 rdfxml.setDocumentLocator(target) # type: ignore[arg-type]
634 # rdfxml.setDocumentLocator(_Locator(self.url, self.parser))
635 parser.setContentHandler(rdfxml)
636 parser.setErrorHandler(ErrorHandler())
637 return parser
638
639
640class RDFXMLParser(Parser):
641 """An RDF/XML parser."""
642
643 def __init__(self):
644 pass
645
646 def parse(self, source: InputSource, sink: Graph, **args: Any) -> None:
647 self._parser = create_parser(source, sink)
648 content_handler = self._parser.getContentHandler()
649 preserve_bnode_ids = args.get("preserve_bnode_ids", None)
650 if preserve_bnode_ids is not None:
651 # type error: ContentHandler has no attribute "preserve_bnode_ids"
652 content_handler.preserve_bnode_ids = preserve_bnode_ids # type: ignore[attr-defined, unused-ignore]
653 # # We're only using it once now
654 # content_handler.reset()
655 # self._parser.reset()
656 self._parser.parse(source)