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)