Source code

Download source archive ↓

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)