def subject(self, subject, depth=1):
store = self.store
write = self.write
indent = "\n" + indent_string * depth
if 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 RDFS.Resource
if isinstance(subject, BNode): # not referenced more than once
if more_than(store.triples((None, None, subject)), 1):
write("%s<div typeof=\"%s\" about=\"%s\">" %
(indent, self.getQName(element), fix(subject)))
else:
write("%s<div typeof=\"%s\">" %
(indent, self.getQName(element)))
else:
write(
"%s<div typeof=\"%s\" about=\"%s\">" %
(indent, self.getQName(element), 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)
write("%s</div>" % indent)
def subject(self, subject, depth=1):
store = self.store
write = self.write
indent = "\n"+indent_string*depth
if 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 RDFS.Resource
if isinstance(subject, BNode):# not referenced more than once
if more_than(store.triples((None, None, subject)), 1):
write("%s<div typeof=\"%s\" about=\"%s\">" % (indent, self.getQName(element), fix(subject)))
else:
write("%s<div typeof=\"%s\">" % (indent, self.getQName(element)))
else:
write("%s<div typeof=\"%s\" about=\"%s\">" % (indent, self.getQName(element), 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)
write("%s</div>" % indent)
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)
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)
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:
items = []
for item in store.items(object): # add a strict option to items?
if isinstance(item, Literal):
items = None # can not serialize list with literal values in them with rdf/xml
else:
items.append(item)
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")
while collection:
item = first(store.objects(collection, RDF.first))
if item:
self.subject(item)
collection = first(store.objects(collection, RDF.rest))
self.__serialized[collection] = 1
else:
if depth <= self.max_depth:
self.subject(object, depth + 1)
elif isinstance(object, BNode):
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
writer.pop(predicate)
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:
items = []
for item in store.items(object): # add a strict option to items?
if isinstance(item, Literal):
items = None # can not serialize list with literal values in them with rdf/xml
else:
items.append(item)
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")
while collection:
item = first(store.objects(collection, RDF.first))
if item:
self.subject(item)
collection = first(store.objects(collection, RDF.rest))
self.__serialized[collection] = 1
else:
if depth<=self.max_depth:
self.subject(object, depth+1)
elif isinstance(object, BNode):
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
writer.pop(predicate)
def subject(self, subject, depth=1, skip_node=False):
store = self.store
write = self.write
indent = "\n" + indent_string * depth
if skip_node:
depth = depth - 1
if 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 RDFS.Resource
if not skip_node:
if isinstance(subject, BNode): # not referenced more than once
if more_than(store.triples((None, None, subject)), 1):
write(
"%s<div itemtype=\"%s\" itemid=\"%s\" itemscope>" %
(indent, element, fix(subject)))
else:
write("%s<div itemtype=\"%s\" itemscope>" %
(indent, element))
else:
write("%s<div itemtype=\"%s\" itemid=\"%s\" itemscope>" %
(indent, element, self.relativize(subject)))
context = self.extract_base(element)
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, context)
if not skip_node:
write("%s</div>" % indent)
def subject(self, subject, depth=1, skip_node=False):
store = self.store
write = self.write
indent = "\n"+indent_string*depth
if skip_node:
depth = depth-1
if 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 RDFS.Resource
if not skip_node:
if isinstance(subject, BNode):# not referenced more than once
if more_than(store.triples((None, None, subject)), 1):
write("%s<div itemtype=\"%s\" itemid=\"%s\" itemscope>" % (indent, element, fix(subject)))
else:
write("%s<div itemtype=\"%s\" itemscope>" % (indent, element))
else:
write("%s<div itemtype=\"%s\" itemid=\"%s\" itemscope>" % (indent, element, self.relativize(subject)))
context = self.extract_base(element)
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, context)
if not skip_node:
write("%s</div>" % indent)
def predicate(self, predicate, object, depth=1):
writer = self.writer
store = self.store
writer.push(predicate)
if isinstance(object, Literal):
if object.language:
writer.attribute(XMLLANG, object.language)
if object.datatype == RDF.XMLLiteral and isinstance(
object.value, xml.dom.minidom.Document):
writer.attribute(RDFVOC.parseType, "Literal")
writer.text("")
writer.stream.write(object)
else:
if object.datatype:
writer.attribute(RDFVOC.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(RDFVOC.nodeID, fix(object))
else:
writer.attribute(RDFVOC.resource, self.relativize(object))
else:
if first(store.objects(object, RDF.first)): # may not have type
# RDF.List
self.__serialized[object] = 1
# Warn that any assertions on object other than
# RDF.first and RDF.rest are ignored... including RDF.List
import warnings
warnings.warn(
"Assertions on %s other than RDF.first " % repr(object) +
"and RDF.rest are ignored ... including RDF.List",
UserWarning,
stacklevel=2,
)
writer.attribute(RDFVOC.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(RDFVOC.resource, self.relativize(object))
elif depth <= self.max_depth:
self.subject(object, depth + 1)
elif isinstance(object, BNode):
if (object not 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(RDFVOC.nodeID, fix(object))
else:
writer.attribute(RDFVOC.resource, self.relativize(object))
writer.pop(predicate)
def predicate(self, predicate, object, depth=1):
writer = self.writer
store = self.store
writer.push(predicate)
if isinstance(object, Literal):
if object.language:
writer.attribute(XMLLANG, object.language)
if (object.datatype == RDF.XMLLiteral and
isinstance(object.value, xml.dom.minidom.Document)):
writer.attribute(RDF.parseType, "Literal")
writer.text("")
writer.stream.write(object)
else:
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
self.__serialized[object] = 1
# Warn that any assertions on object other than
# RDF.first and RDF.rest are ignored... including RDF.List
import warnings
warnings.warn(
"Assertions on %s other than RDF.first " % repr(object) +
"and RDF.rest are ignored ... including RDF.List",
UserWarning, stacklevel=2)
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)
def predicate(self, predicate, object, depth=1, context=None):
store = self.store
write = self.write
indent = "\n"+indent_string*depth
if isinstance(object, Literal):
write("%s<meta itemprop=\"%s\"" % (indent, self.relativize(predicate, context)))
#if object.language:
# write(" xml:lang=\"%s\"" % object.language)
#elif object.datatype:
# write(" datatype=\"%s\"" % self.getQName(object.datatype))
write(" content=\"%s\" />" % object)
elif object in self.__serialized or not (object, None, None) in store:
write("%s<link itemprop=\"%s\"" % (indent, self.relativize(predicate, context)))
if isinstance(object, BNode) and more_than(store.triples((None, None, object)), 0):
write(" href=\"%s\" />" % fix(object))
else:
write(" href=\"%s\" />" % self.relativize(object))
else:
if first(store.objects(object, RDF.first)): # may not have type RDF.List
self.__serialized[object] = 1
# Warn that any assertions on object other than
# RDF.first and RDF.rest are ignored... including RDF.List
import warnings
warnings.warn(
"Assertions on %s other than RDF.first " % repr(object) + \
"and RDF.rest are ignored ... including RDF.List",
UserWarning, stacklevel=2)
col = Collection(store, object)
for item in col:
if isinstance(item, BNode):
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), fix(item)))
elif isinstance(item, URIRef):
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), self.relativize(item)))
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), 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):
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), self.relativize(object)))
elif depth <= self.max_depth:
write("%s<div itemprop=\"%s\"" % (indent, self.relativize(predicate, context)))
if first(store.objects(object, RDF.type)):
write(" itemtype=\"%s\"" % first(store.objects(object, RDF.type)))
if isinstance(object, URIRef):
write(" itemid=\"%s\"" % object)
write(" itemscope>")
self.subject(object, depth+1, True) # skip node
write("%s</div>" % indent)
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)
#write(">")
self.subject(object, depth+1)
#write(indent)
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), fix(object)))
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" % (indent, self.relativize(predicate, context), self.relativize(object)))
def subj_as_obj_more_than(ceil):
return more_than(store.triples((None, None, subject)),
ceil)
def subj_as_obj_more_than(ceil):
return more_than(store.triples((None, None, subject)), ceil)
def predicate(self, predicate, object, depth=1):
def defaultCase() :
if depth <= self.max_depth:
self.subject(object, depth+1)
elif isinstance(object, BNode):
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
#####
writer = self.writer
store = self.store
writer.push(predicate)
if isinstance(object, Literal):
attributes = ""
to_escape = True
if object.language:
writer.attribute(XMLLANG, object.language)
if object.datatype:
if ("%s" % object.datatype) == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral" :
writer.attribute(RDF.parseType, "Literal")
to_escape = False
else :
writer.attribute(RDF.datatype, object.datatype)
writer.text(object,to_escape)
elif object in self.list_heads :
items = [item for item in store.items(object)]
if True not in [ isinstance(item,Literal) for item in items ] :
# This is a kosher list that could be handled with the Collection parse type trick
self.__serialized[object] = 1
if object in self.list_really_heads :
collection = object
self.__serialized[object] = 1
writer.attribute(RDF.parseType, "Collection")
for item in items :
if item in self.__serialized :
# bugger; already done somewhere else... :-)
writer.push(RDF.Description)
if isinstance(item, BNode):
if more_than(store.triples((None, None, item)), 0):
writer.attribute(RDF.nodeID, fix(item))
else:
writer.attribute(RDF.about, self.relativize(item))
writer.pop(RDF.Description)
else :
self.subject(item)
self.__serialized[item] = 1
else :
defaultCase()
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))
elif (object,RDF.type,RDF.Seq) in store or (object,RDF.type,RDF.Bag) in store or (object,RDF.type,RDF.Alt) in store :
seq = Seq(store,object)
self.__serialized[object] = 1
if (object,RDF.type,RDF.Seq) in store :
typ = RDF.Seq
elif (object,RDF.type,RDF.Alt) in store :
typ = RDF.Alt
else :
typ = RDF.Bag
writer.push(typ)
for item in seq :
self.predicate(RDF.li,item,depth+1)
writer.pop(typ)
else :
defaultCase()
writer.pop(predicate)
def predicate(self, predicate, object, depth=1, context=None):
store = self.store
write = self.write
indent = "\n" + indent_string * depth
if isinstance(object, Literal):
write("%s<meta itemprop=\"%s\"" %
(indent, self.relativize(predicate, context)))
#if object.language:
# write(" xml:lang=\"%s\"" % object.language)
#elif object.datatype:
# write(" datatype=\"%s\"" % self.getQName(object.datatype))
write(" content=\"%s\" />" % object)
elif object in self.__serialized or not (object, None, None) in store:
write("%s<link itemprop=\"%s\"" %
(indent, self.relativize(predicate, context)))
if isinstance(object, BNode) and more_than(
store.triples((None, None, object)), 0):
write(" href=\"%s\" />" % fix(object))
else:
write(" href=\"%s\" />" % self.relativize(object))
else:
if first(store.objects(object,
RDF.first)): # may not have type RDF.List
self.__serialized[object] = 1
# Warn that any assertions on object other than
# RDF.first and RDF.rest are ignored... including RDF.List
import warnings
warnings.warn(
"Assertions on %s other than RDF.first " % repr(object) + \
"and RDF.rest are ignored ... including RDF.List",
UserWarning, stacklevel=2)
col = Collection(store, object)
for item in col:
if isinstance(item, BNode):
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(predicate,
context), fix(item)))
elif isinstance(item, URIRef):
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(
predicate, context), self.relativize(item)))
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(predicate,
context), 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):
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(
predicate, context), self.relativize(object)))
elif depth <= self.max_depth:
write("%s<div itemprop=\"%s\"" %
(indent, self.relativize(predicate, context)))
if first(store.objects(object, RDF.type)):
write(" itemtype=\"%s\"" %
first(store.objects(object, RDF.type)))
if isinstance(object, URIRef):
write(" itemid=\"%s\"" % object)
write(" itemscope>")
self.subject(object, depth + 1, True) # skip node
write("%s</div>" % indent)
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)
#write(">")
self.subject(object, depth + 1)
#write(indent)
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(predicate,
context), fix(object)))
else:
write("%s<link itemprop=\"%s\" href=\"%s\" />" %
(indent, self.relativize(
predicate, context), self.relativize(object)))
def predicate(self, predicate, object, depth=1):
def defaultCase():
if depth <= self.max_depth:
self.subject(object, depth + 1)
elif isinstance(object, BNode):
writer.attribute(RDF.nodeID, fix(object))
else:
writer.attribute(RDF.resource, self.relativize(object))
#####
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:
if (
"%s" % object.datatype
) == "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral":
writer.attribute(RDF.parseType, "Literal")
else:
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))
elif (object, RDF.type,
RDF.Seq) in store or (object, RDF.type,
RDF.Bag) in store or (object, RDF.type,
RDF.Alt) in store:
seq = Seq(store, object)
self.__serialized[object] = 1
if (object, RDF.type, RDF.Seq) in store:
typ = RDF.Seq
elif (object, RDF.type, RDF.Alt) in store:
typ = RDF.Alt
else:
typ = RDF.Bag
writer.push(typ)
for item in seq:
self.predicate(RDF.li, item, depth + 1)
writer.pop(typ)
elif object in self.listHeads:
items = [item for item in store.items(object)]
if True not in [isinstance(item, Literal) for item in items]:
# This is a kosher list that could be handled with the Collection parse type trick
collection = object
self.__serialized[object] = 1
writer.attribute(RDF.parseType, "Collection")
for item in items:
if item in self.__serialized:
# bugger; already done somewhere else... :-)
writer.push(RDF.Description)
if isinstance(item, BNode):
if more_than(store.triples((None, None, item)), 0):
writer.attribute(RDF.nodeID, fix(item))
else:
writer.attribute(RDF.about, self.relativize(item))
writer.pop(RDF.Description)
else:
self.subject(item)
self.__serialized[item] = 1
else:
defaultCase()
else:
defaultCase()
writer.pop(predicate)
