def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
# if base is given here, use that, if not and a base is set for the graph use that
if base is None and self.store.base is not None:
base = self.store.base
if base is not None:
self.writer.attribute("http://www.w3.org/XML/1998/namespacebase",
base)
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write(b("\n"))
def serialize(self, stream, base=None, encoding=None, **args):
self.__serialized = {}
store = self.store
# if base is given here, use that, if not and a base is set for the graph use that
if base is not None:
self.base = base
elif store.base is not None:
self.base = store.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_strict(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"])
elif self.base:
writer.attribute(XMLBASE, self.base)
writer.namespaces(namespaces.items())
# 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("\n".encode("latin-1"))
# Set to None so that the memory can get garbage collected.
self.__serialized = None
def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write("\n")
def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write(b("\n"))
class TriXSerializer(Serializer):
def __init__(self, store):
super(TriXSerializer, self).__init__(store)
def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write("\n")
def _writeGraph(self, graph):
self.writer.push(TRIXNS[u"graph"])
if isinstance(graph.identifier, URIRef):
self.writer.element(TRIXNS[u"uri"],
content=unicode(graph.identifier))
for triple in graph.triples((None, None, None)):
self._writeTriple(triple)
self.writer.pop()
def _writeTriple(self, triple):
self.writer.push(TRIXNS[u"triple"])
for component in triple:
if isinstance(component, URIRef):
self.writer.element(TRIXNS[u"uri"], content=unicode(component))
elif isinstance(component, BNode):
self.writer.element(TRIXNS[u"id"], content=unicode(component))
elif isinstance(component, Literal):
if component.datatype:
self.writer.element(TRIXNS[u"typedLiteral"],
content=unicode(component),
attributes={
TRIXNS[u"datatype"]:
unicode(component.datatype)
})
elif component.language:
self.writer.element(TRIXNS[u"plainLiteral"],
content=unicode(component),
attributes={
XMLNS[u"lang"]:
unicode(component.language)
})
else:
self.writer.element(TRIXNS[u"plainLiteral"],
content=unicode(component))
self.writer.pop()
class TriXSerializer(Serializer):
def __init__(self, store):
super(TriXSerializer, self).__init__(store)
if not store.context_aware:
raise Exception(
"TriX serialization only makes sense for context-aware stores")
def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
# if base is given here, use that, if not and a base is set for the graph use that
if base is None and self.store.base is not None:
base = self.store.base
if base is not None:
self.writer.attribute("http://www.w3.org/XML/1998/namespacebase",
base)
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write(b("\n"))
def _writeGraph(self, graph):
self.writer.push(TRIXNS[u"graph"])
if graph.base:
self.writer.attribute("http://www.w3.org/XML/1998/namespacebase",
graph.base)
if isinstance(graph.identifier, URIRef):
self.writer.element(TRIXNS[u"uri"],
content=text_type(graph.identifier))
for triple in graph.triples((None, None, None)):
self._writeTriple(triple)
self.writer.pop()
def _writeTriple(self, triple):
self.writer.push(TRIXNS[u"triple"])
for component in triple:
if isinstance(component, URIRef):
self.writer.element(TRIXNS[u"uri"],
content=text_type(component))
elif isinstance(component, BNode):
self.writer.element(TRIXNS[u"id"],
content=text_type(component))
elif isinstance(component, Literal):
if component.datatype:
self.writer.element(TRIXNS[u"typedLiteral"],
content=text_type(component),
attributes={
TRIXNS[u"datatype"]:
text_type(component.datatype)
})
elif component.language:
self.writer.element(TRIXNS[u"plainLiteral"],
content=text_type(component),
attributes={
XMLNS[u"lang"]:
text_type(component.language)
})
else:
self.writer.element(TRIXNS[u"plainLiteral"],
content=text_type(component))
self.writer.pop()
class TriXSerializer(Serializer):
def __init__(self, store):
super(TriXSerializer, self).__init__(store)
if not store.context_aware:
raise Exception(
"TriX serialization only makes sense for context-aware stores")
def serialize(self, stream, base=None, encoding=None, **args):
nm = self.store.namespace_manager
self.writer = XMLWriter(stream, nm, encoding, extra_ns={"": TRIXNS})
self.writer.push(TRIXNS[u"TriX"])
self.writer.namespaces()
if isinstance(self.store, ConjunctiveGraph):
for subgraph in self.store.contexts():
self._writeGraph(subgraph)
elif isinstance(self.store, Graph):
self._writeGraph(self.store)
else:
raise Exception("Unknown graph type: " + type(self.store))
self.writer.pop()
stream.write(b("\n"))
def _writeGraph(self, graph):
self.writer.push(TRIXNS[u"graph"])
if isinstance(graph.identifier, URIRef):
self.writer.element(
TRIXNS[u"uri"], content=unicode(graph.identifier))
for triple in graph.triples((None, None, None)):
self._writeTriple(triple)
self.writer.pop()
def _writeTriple(self, triple):
self.writer.push(TRIXNS[u"triple"])
for component in triple:
if isinstance(component, URIRef):
self.writer.element(TRIXNS[u"uri"],
content=unicode(component))
elif isinstance(component, BNode):
self.writer.element(TRIXNS[u"id"],
content=unicode(component))
elif isinstance(component, Literal):
if component.datatype:
self.writer.element(TRIXNS[u"typedLiteral"],
content=unicode(component),
attributes={TRIXNS[u"datatype"]:
unicode(
component.datatype)})
elif component.language:
self.writer.element(TRIXNS[u"plainLiteral"],
content=unicode(component),
attributes={XMLNS[u"lang"]:
unicode(
component.language)})
else:
self.writer.element(TRIXNS[u"plainLiteral"],
content=unicode(component))
self.writer.pop()
def serialize(self, stream, base=None, encoding=None, **args):
self.__serialized = {}
store = self.store
# if base is given here, use that, if not and a base is set for the graph use that
if base is not None:
self.base = base
elif store.base is not None:
self.base = store.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_strict(predicate)
namespaces[prefix] = namespace
namespaces["rdf"] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
namespaces["dc"] = "http://purl.org/dc/terms/"
namespaces["jd"] = JAZZ_DISCOVERY.uri
namespaces["jfs"] = JFS.uri
namespaces["trs"] = OSLC_TRS.uri
namespaces["jp06"] = "http://jazz.net/xmlns/prod/jazz/process/0.6/"
namespaces["jp"] = JAZZ_PROCESS.uri
writer.push(RDF.Description)
for subject in store.subjects():
if not (None, None, subject) in store:
writer.attribute(RDF.about, self.relativize(subject))
self.__root_serialized[subject] = 1
break
if "xml_base" in args:
writer.attribute(XMLBASE, args["xml_base"])
elif self.base:
writer.attribute(XMLBASE, self.base)
writer.namespaces(list(namespaces.items()))
# 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.Description)
stream.write(b("\n"))
# Set to None so that the memory can get garbage collected.
self.__serialized = None
self.__root_serialized = None
