Source code

Download source archive ↓

src/rdflib/plugins/serializers/rdfxml.py

1from __future__ import annotations
2
3import xml.dom.minidom
4from typing import IO, Any, Dict, Generator, Optional, Set, Tuple
5from xml.sax.saxutils import escape, quoteattr
6
7from rdflib.collection import Collection
8from rdflib.graph import Graph
9from rdflib.namespace import RDF, RDFS, Namespace  # , split_uri
10from rdflib.plugins.parsers.RDFVOC import RDFVOC
11from rdflib.plugins.serializers.xmlwriter import XMLWriter
12from rdflib.serializer import Serializer
13from rdflib.term import BNode, IdentifiedNode, Identifier, Literal, Node, URIRef
14from rdflib.util import first, more_than
15
16from .xmlwriter import ESCAPE_ENTITIES
17
18__all__ = ["fix", "XMLSerializer", "PrettyXMLSerializer"]
19
20
21class XMLSerializer(Serializer):
22    """RDF/XML RDF graph serializer."""
23
24    def __init__(self, store: Graph):
25        super(XMLSerializer, self).__init__(store)
26
27    def __bindings(self) -> Generator[Tuple[str, URIRef], None, None]:
28        store = self.store
29        nm = store.namespace_manager
30        bindings: Dict[str, URIRef] = {}
31
32        for predicate in set(store.predicates()):
33            # type error: Argument 1 to "compute_qname_strict" of "NamespaceManager" has incompatible type "Node"; expected "str"
34            prefix, namespace, name = nm.compute_qname_strict(predicate)  # type: ignore[arg-type]
35            bindings[prefix] = URIRef(namespace)
36
37        RDFNS = URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#")  # noqa: N806
38
39        if "rdf" in bindings:
40            assert bindings["rdf"] == RDFNS
41        else:
42            bindings["rdf"] = RDFNS
43
44        for prefix, namespace in bindings.items():
45            yield prefix, namespace
46
47    def serialize(
48        self,
49        stream: IO[bytes],
50        base: Optional[str] = None,
51        encoding: Optional[str] = None,
52        **kwargs: Any,
53    ) -> None:
54        # if base is given here, use that, if not and a base is set for the graph use that
55        if base is not None:
56            self.base = base
57        elif self.store.base is not None:
58            self.base = self.store.base
59        self.__stream = stream
60        self.__serialized: Dict[Identifier, int] = {}
61        encoding = self.encoding
62        self.write = write = lambda uni: stream.write(uni.encode(encoding, "replace"))
63
64        # startDocument
65        write('<?xml version="1.0" encoding="%s"?>\n' % self.encoding)
66
67        # startRDF
68        write("<rdf:RDF\n")
69
70        # If provided, write xml:base attribute for the RDF
71        if "xml_base" in kwargs:
72            write('   xml:base="%s"\n' % kwargs["xml_base"])
73        elif self.base:
74            write('   xml:base="%s"\n' % self.base)
75        # TODO:
76        # assert(
77        #    namespaces["http://www.w3.org/1999/02/22-rdf-syntax-ns#"]=='rdf')
78        bindings = list(self.__bindings())
79        bindings.sort()
80
81        for prefix, namespace in bindings:
82            if prefix:
83                write('   xmlns:%s="%s"\n' % (prefix, namespace))
84            else:
85                write('   xmlns="%s"\n' % namespace)
86        write(">\n")
87
88        # write out triples by subject
89        for subject in self.store.subjects():
90            # type error: Argument 1 to "subject" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
91            self.subject(subject, 1)  # type: ignore[arg-type]
92
93        # endRDF
94        write("</rdf:RDF>\n")
95
96        # Set to None so that the memory can get garbage collected.
97        # self.__serialized = None
98        del self.__serialized
99
100    def subject(self, subject: Identifier, depth: int = 1) -> None:
101        if subject not in self.__serialized:
102            self.__serialized[subject] = 1
103
104            if isinstance(subject, (BNode, URIRef)):
105                write = self.write
106                indent = "  " * depth
107                element_name = "rdf:Description"
108
109                if isinstance(subject, BNode):
110                    write('%s<%s rdf:nodeID="%s"' % (indent, element_name, subject))
111                else:
112                    uri = quoteattr(self.relativize(subject))
113                    write("%s<%s rdf:about=%s" % (indent, element_name, uri))
114
115                if (subject, None, None) in self.store:
116                    write(">\n")
117
118                    for predicate, object in self.store.predicate_objects(subject):
119                        # type error: Argument 1 to "predicate" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
120                        # type error: Argument 2 to "predicate" of "XMLSerializer" has incompatible type "Node"; expected "Identifier"
121                        self.predicate(predicate, object, depth + 1)  # type: ignore[arg-type]
122                    write("%s</%s>\n" % (indent, element_name))
123
124                else:
125                    write("/>\n")
126
127    def predicate(
128        self, predicate: Identifier, object: Identifier, depth: int = 1
129    ) -> None:
130        write = self.write
131        indent = "  " * depth
132        qname = self.store.namespace_manager.qname_strict(predicate)
133
134        if isinstance(object, Literal):
135            attributes = ""
136
137            if object.language:
138                attributes += ' xml:lang="%s"' % object.language
139
140            if object.datatype:
141                attributes += ' rdf:datatype="%s"' % object.datatype
142
143            write(
144                "%s<%s%s>%s</%s>\n"
145                % (indent, qname, attributes, escape(object, ESCAPE_ENTITIES), qname)
146            )
147        else:
148            if isinstance(object, BNode):
149                write('%s<%s rdf:nodeID="%s"/>\n' % (indent, qname, object))
150            else:
151                write(
152                    "%s<%s rdf:resource=%s/>\n"
153                    % (indent, qname, quoteattr(self.relativize(object)))
154                )
155
156
157XMLLANG = "http://www.w3.org/XML/1998/namespacelang"
158XMLBASE = "http://www.w3.org/XML/1998/namespacebase"
159OWL_NS = Namespace("http://www.w3.org/2002/07/owl#")
160
161
162# TODO:
163def fix(val: str) -> str:
164    "strip off _: from nodeIDs... as they are not valid NCNames"
165    if val.startswith("_:"):
166        return val[2:]
167    else:
168        return val
169
170
171class PrettyXMLSerializer(Serializer):
172    """Pretty RDF/XML RDF graph serializer."""
173
174    def __init__(self, store: Graph, max_depth=3):
175        super(PrettyXMLSerializer, self).__init__(store)
176        self.forceRDFAbout: Set[URIRef] = set()
177
178    def serialize(
179        self,
180        stream: IO[bytes],
181        base: Optional[str] = None,
182        encoding: Optional[str] = None,
183        **kwargs: Any,
184    ) -> None:
185        self.__serialized: Dict[Identifier, int] = {}
186        store = self.store
187        # if base is given here, use that, if not and a base is set for the graph use that
188        if base is not None:
189            self.base = base
190        elif store.base is not None:
191            self.base = store.base
192        self.max_depth = kwargs.get("max_depth", 3)
193        assert self.max_depth > 0, "max_depth must be greater than 0"
194
195        self.nm = nm = store.namespace_manager
196        self.writer = writer = XMLWriter(stream, nm, encoding)
197        namespaces = {}
198
199        possible: Set[Node] = set(store.predicates()).union(
200            store.objects(None, RDF.type)
201        )
202
203        for predicate in possible:
204            # type error: Argument 1 to "compute_qname_strict" of "NamespaceManager" has incompatible type "Node"; expected "str"
205            prefix, namespace, local = nm.compute_qname_strict(predicate)  # type: ignore[arg-type]
206            namespaces[prefix] = namespace
207
208        namespaces["rdf"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
209
210        writer.push(RDFVOC.RDF)
211
212        if "xml_base" in kwargs:
213            writer.attribute(XMLBASE, kwargs["xml_base"])
214        elif self.base:
215            writer.attribute(XMLBASE, self.base)
216
217        writer.namespaces(namespaces.items())
218
219        subject: IdentifiedNode
220        # Write out subjects that can not be inline
221        # type error: Incompatible types in assignment (expression has type "Node", variable has type "IdentifiedNode")
222        for subject in store.subjects():  # type: ignore[assignment]
223            if (None, None, subject) in store:
224                if (subject, None, subject) in store:
225                    self.subject(subject, 1)
226            else:
227                self.subject(subject, 1)
228
229        # write out anything that has not yet been reached
230        # write out BNodes last (to ensure they can be inlined where possible)
231        bnodes = set()
232
233        # type error: Incompatible types in assignment (expression has type "Node", variable has type "IdentifiedNode")
234        for subject in store.subjects():  # type: ignore[assignment]
235            if isinstance(subject, BNode):
236                bnodes.add(subject)
237                continue
238            self.subject(subject, 1)
239
240        # now serialize only those BNodes that have not been serialized yet
241        for bnode in bnodes:
242            if bnode not in self.__serialized:
243                self.subject(subject, 1)
244
245        writer.pop(RDFVOC.RDF)
246        stream.write("\n".encode("latin-1"))
247
248        # Set to None so that the memory can get garbage collected.
249        self.__serialized = None  # type: ignore[assignment]
250
251    def subject(self, subject: Identifier, depth: int = 1):
252        store = self.store
253        writer = self.writer
254
255        if subject in self.forceRDFAbout:
256            writer.push(RDFVOC.Description)
257            writer.attribute(RDFVOC.about, self.relativize(subject))
258            writer.pop(RDFVOC.Description)
259            self.forceRDFAbout.remove(subject)  # type: ignore[arg-type]
260
261        elif subject not in self.__serialized:
262            self.__serialized[subject] = 1
263            type = first(store.objects(subject, RDF.type))
264
265            try:
266                # type error: Argument 1 to "qname" of "NamespaceManager" has incompatible type "Optional[Node]"; expected "str"
267                self.nm.qname(type)  # type: ignore[arg-type]
268            except Exception:
269                type = None
270
271            element = type or RDFVOC.Description
272            # type error: Argument 1 to "push" of "XMLWriter" has incompatible type "Node"; expected "str"
273            writer.push(element)  # type: ignore[arg-type]
274
275            if isinstance(subject, BNode):
276
277                def subj_as_obj_more_than(ceil):
278                    return True
279                    # more_than(store.triples((None, None, subject)), ceil)
280
281                # here we only include BNode labels if they are referenced
282                # more than once (this reduces the use of redundant BNode
283                # identifiers)
284                if subj_as_obj_more_than(1):
285                    writer.attribute(RDFVOC.nodeID, fix(subject))
286
287            else:
288                writer.attribute(RDFVOC.about, self.relativize(subject))
289
290            if (subject, None, None) in store:
291                for predicate, object in store.predicate_objects(subject):
292                    if not (predicate == RDF.type and object == type):
293                        # type error: Argument 1 to "predicate" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
294                        # type error: Argument 2 to "predicate" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
295                        self.predicate(predicate, object, depth + 1)  # type: ignore[arg-type]
296
297            # type error: Argument 1 to "pop" of "XMLWriter" has incompatible type "Node"; expected "Optional[str]"
298            writer.pop(element)  # type: ignore[arg-type]
299
300        elif subject in self.forceRDFAbout:
301            # TODO FIXME?: this looks like a duplicate of first condition
302            writer.push(RDFVOC.Description)
303            writer.attribute(RDFVOC.about, self.relativize(subject))
304            writer.pop(RDFVOC.Description)
305            self.forceRDFAbout.remove(subject)  # type: ignore[arg-type]
306
307    def predicate(
308        self, predicate: Identifier, object: Identifier, depth: int = 1
309    ) -> None:
310        writer = self.writer
311        store = self.store
312        writer.push(predicate)
313
314        if isinstance(object, Literal):
315            if object.language:
316                writer.attribute(XMLLANG, object.language)
317
318            if object.datatype == RDF.XMLLiteral and isinstance(
319                object.value, xml.dom.minidom.Document
320            ):
321                writer.attribute(RDFVOC.parseType, "Literal")
322                writer.text("")
323                writer.stream.write(object)
324            else:
325                if object.datatype:
326                    writer.attribute(RDFVOC.datatype, object.datatype)
327                writer.text(object)
328
329        elif (
330            object in self.__serialized
331            or not (object, None, None) in store  # noqa: E713
332        ):
333            if isinstance(object, BNode):
334                if more_than(store.triples((None, None, object)), 0):
335                    writer.attribute(RDFVOC.nodeID, fix(object))
336            else:
337                writer.attribute(RDFVOC.resource, self.relativize(object))
338
339        else:
340            if first(store.objects(object, RDF.first)):  # may not have type
341                # RDF.List
342
343                self.__serialized[object] = 1
344
345                # Warn that any assertions on object other than
346                # RDF.first and RDF.rest are ignored... including RDF.List
347                import warnings
348
349                warnings.warn(
350                    "Assertions on %s other than RDF.first " % repr(object)
351                    + "and RDF.rest are ignored ... including RDF.List",
352                    UserWarning,
353                    stacklevel=2,
354                )
355                writer.attribute(RDFVOC.parseType, "Collection")
356
357                col = Collection(store, object)
358
359                for item in col:
360                    if isinstance(item, URIRef):
361                        self.forceRDFAbout.add(item)
362                    # type error: Argument 1 to "subject" of "PrettyXMLSerializer" has incompatible type "Node"; expected "Identifier"
363                    self.subject(item)  # type: ignore[arg-type]
364
365                    if not isinstance(item, URIRef):
366                        # type error: Invalid index type "Node" for "Dict[Identifier, int]"; expected type "Identifier"
367                        self.__serialized[item] = 1  # type: ignore[index]
368            else:
369                if first(
370                    store.triples_choices(
371                        # type error: Argument 1 to "triples_choices" of "Graph" has incompatible type "Tuple[Identifier, URIRef, List[URIRef]]"; expected "Union[Tuple[List[Node], Node, Node], Tuple[Node, List[Node], Node], Tuple[Node, Node, List[Node]]]"
372                        (object, RDF.type, [OWL_NS.Class, RDFS.Class])  # type: ignore[arg-type]
373                    )
374                ) and isinstance(object, URIRef):
375                    writer.attribute(RDFVOC.resource, self.relativize(object))
376
377                elif depth <= self.max_depth:
378                    self.subject(object, depth + 1)
379
380                elif isinstance(object, BNode):
381                    if (
382                        object not in self.__serialized
383                        and (object, None, None) in store
384                        and len(list(store.subjects(object=object))) == 1
385                    ):
386                        # inline blank nodes if they haven't been serialized yet
387                        # and are only referenced once (regardless of depth)
388                        self.subject(object, depth + 1)
389                    else:
390                        writer.attribute(RDFVOC.nodeID, fix(object))
391
392                else:
393                    writer.attribute(RDFVOC.resource, self.relativize(object))
394
395        writer.pop(predicate)