1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
|
from __future__ import generators
from rdflib.plugins.serializers.xmlwriter import XMLWriter
from rdflib.namespace import Namespace, RDF, RDFS, split_uri
from rdflib.term import URIRef, Literal, BNode
from rdflib.util import first, more_than
from rdflib.collection import Collection
from rdflib.serializer import Serializer
from rdflib.exceptions import Error
from rdflib.py3compat import b
from xml.sax.saxutils import quoteattr, escape
__all__ = ['fix', 'XMLSerializer', 'PrettyXMLSerializer']
class XMLSerializer(Serializer):
def __init__(self, store):
super(XMLSerializer, self).__init__(store)
def __bindings(self):
store = self.store
nm = store.namespace_manager
bindings = {}
for predicate in set(store.predicates()):
prefix, namespace, name = nm.compute_qname(predicate)
bindings[prefix] = URIRef(namespace)
RDFNS = URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#")
if "rdf" in bindings:
assert bindings["rdf"]==RDFNS
else:
bindings["rdf"] = RDFNS
for prefix, namespace in bindings.iteritems():
yield prefix, namespace
def serialize(self, stream, base=None, encoding=None, **args):
self.base = base
self.__stream = stream
self.__serialized = {}
encoding = self.encoding
self.write = write = lambda uni: stream.write(uni.encode(encoding, 'replace'))
# startDocument
write('<?xml version="1.0" encoding="%s"?>\n' % self.encoding)
# startRDF
write('<rdf:RDF\n')
# If provided, write xml:base attribute for the RDF
if "xml_base" in args:
write(' xml:base="%s"\n' % args['xml_base'])
# TODO: assert(namespaces["http://www.w3.org/1999/02/22-rdf-syntax-ns#"]=='rdf')
bindings = list(self.__bindings())
bindings.sort()
for prefix, namespace in bindings:
if prefix:
write(' xmlns:%s="%s"\n' % (prefix, namespace))
else:
write(' xmlns="%s"\n' % namespace)
write('>\n')
# write out triples by subject
for subject in self.store.subjects():
self.subject(subject, 1)
# endRDF
write( "</rdf:RDF>\n" )
# Set to None so that the memory can get garbage collected.
#self.__serialized = None
del self.__serialized
def subject(self, subject, depth=1):
if not subject in self.__serialized:
self.__serialized[subject] = 1
if isinstance(subject, (BNode,URIRef)):
write = self.write
indent = " " * depth
element_name = "rdf:Description"
if isinstance(subject, BNode):
write( '%s<%s rdf:nodeID="%s"' %
(indent, element_name, subject))
else:
uri = quoteattr(self.relativize(subject))
write( "%s<%s rdf:about=%s" % (indent, element_name, uri))
if (subject, None, None) in self.store:
write( ">\n" )
for predicate, object in self.store.predicate_objects(subject):
self.predicate(predicate, object, depth+1)
write( "%s</%s>\n" % (indent, element_name))
else:
write( "/>\n" )
def predicate(self, predicate, object, depth=1):
write = self.write
indent = " " * depth
qname = self.store.namespace_manager.qname(predicate)
if isinstance(object, Literal):
attributes = ""
if object.language:
attributes += ' xml:lang="%s"'%object.language
if object.datatype:
attributes += ' rdf:datatype="%s"'%object.datatype
write("%s<%s%s>%s</%s>\n" %
(indent, qname, attributes,
escape(object), qname) )
else:
if isinstance(object, BNode):
write('%s<%s rdf:nodeID="%s"/>\n' %
(indent, qname, object))
else:
write("%s<%s rdf:resource=%s/>\n" %
(indent, qname, quoteattr(self.relativize(object))))
XMLLANG = "http://www.w3.org/XML/1998/namespacelang"
XMLBASE = "http://www.w3.org/XML/1998/namespacebase"
OWL_NS = Namespace('http://www.w3.org/2002/07/owl#')
# TODO:
def fix(val):
"strip off _: from nodeIDs... as they are not valid NCNames"
if val.startswith("_:"):
return val[2:]
else:
return val
class PrettyXMLSerializer(Serializer):
def __init__(self, store, max_depth=3):
super(PrettyXMLSerializer, self).__init__(store)
self.forceRDFAbout=set()
def serialize(self, stream, base=None, encoding=None, **args):
self.__serialized = {}
store = self.store
self.base = base
self.max_depth = args.get("max_depth", 3)
assert self.max_depth>0, "max_depth must be greater than 0"
self.nm = nm = store.namespace_manager
self.writer = writer = XMLWriter(stream, nm, encoding)
namespaces = {}
possible = set(store.predicates()).union(store.objects(None, RDF.type))
for predicate in possible:
prefix, namespace, local = nm.compute_qname(predicate)
namespaces[prefix] = namespace
namespaces["rdf"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
writer.push(RDF.RDF)
if "xml_base" in args:
writer.attribute(XMLBASE, args["xml_base"])
writer.namespaces(namespaces.iteritems())
# Write out subjects that can not be inline
for subject in store.subjects():
if (None, None, subject) in store:
if (subject, None, subject) in store:
self.subject(subject, 1)
else:
self.subject(subject, 1)
# write out anything that has not yet been reached
# write out BNodes last (to ensure they can be inlined where possible)
bnodes=set()
for subject in store.subjects():
if isinstance(subject,BNode):
bnodes.add(subject)
continue
self.subject(subject, 1)
#now serialize only those BNodes that have not been serialized yet
for bnode in bnodes:
if bnode not in self.__serialized:
self.subject(subject, 1)
writer.pop(RDF.RDF)
stream.write(b("\n"))
# Set to None so that the memory can get garbage collected.
self.__serialized = None
def subject(self, subject, depth=1):
store = self.store
writer = self.writer
if subject in self.forceRDFAbout:
writer.push(RDF.Description)
writer.attribute(RDF.about, self.relativize(subject))
writer.pop(RDF.Description)
self.forceRDFAbout.remove(subject)
elif not subject in self.__serialized:
self.__serialized[subject] = 1
type = first(store.objects(subject, RDF.type))
try:
self.nm.qname(type)
except:
type = None
element = type or RDF.Description
writer.push(element)
if isinstance(subject, BNode):
def subj_as_obj_more_than(ceil):
return True
# more_than(store.triples((None, None, subject)), ceil)
#here we only include BNode labels if they are referenced
#more than once (this reduces the use of redundant BNode identifiers)
if subj_as_obj_more_than(1):
writer.attribute(RDF.nodeID, fix(subject))
else:
writer.attribute(RDF.about, self.relativize(subject))
if (subject, None, None) in store:
for predicate, object in store.predicate_objects(subject):
if not (predicate==RDF.type and object==type):
self.predicate(predicate, object, depth+1)
writer.pop(element)
elif subject in self.forceRDFAbout:
writer.push(RDF.Description)
writer.attribute(RDF.about, self.relativize(subject))
writer.pop(RDF.Description)
self.forceRDFAbout.remove(subject)
def predicate(self, predicate, object, depth=1):
writer = self.writer
store = self.store
writer.push(predicate)
if isinstance(object, Literal):
attributes = ""
if object.language:
writer.attribute(XMLLANG, object.language)
if object.datatype:
writer.attribute(RDF.datatype, object.datatype)
writer.text(object)
elif object in self.__serialized or not (object, None, None) in store:
if isinstance(object, BNode):
if more_than(store.triples((None, None, object)), 0):
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
else:
if first(store.objects(object, RDF.first)): # may not have type RDF.List
collection = object
self.__serialized[object] = 1
# TODO: warn that any assertions on object other than
# RDF.first and RDF.rest are ignored... including RDF.List
writer.attribute(RDF.parseType, "Collection")
col=Collection(store,object)
for item in col:
if isinstance(item,URIRef):
self.forceRDFAbout.add(item)
self.subject(item)
if not isinstance(item,URIRef):
self.__serialized[item] = 1
else:
if first(store.triples_choices((object,
RDF.type,
[OWL_NS.Class,RDFS.Class]))) and\
isinstance(object, URIRef):
writer.attribute(RDF.resource, self.relativize(object))
elif depth<=self.max_depth:
self.subject(object, depth+1)
elif isinstance(object, BNode):
if not object in self.__serialized and \
(object, None, None) in store and \
len(list(store.subjects(object=object)))==1:
#inline blank nodes if they haven't been serialized yet and are
#only referenced once (regardless of depth)
self.subject(object, depth+1)
else:
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
writer.pop(predicate)
|
