本文整理匯總了Python中rdflib.Graph.ConjunctiveGraph.serialize方法的典型用法代碼示例。如果您正苦於以下問題:Python ConjunctiveGraph.serialize方法的具體用法?Python ConjunctiveGraph.serialize怎麽用?Python ConjunctiveGraph.serialize使用的例子?那麽, 這裏精選的方法代碼示例或許可以為您提供幫助。您也可以進一步了解該方法所在類rdflib.Graph.ConjunctiveGraph
的用法示例。
在下文中一共展示了ConjunctiveGraph.serialize方法的15個代碼示例,這些例子默認根據受歡迎程度排序。您可以為喜歡或者感覺有用的代碼點讚,您的評價將有助於係統推薦出更棒的Python代碼示例。
示例1: build
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def build(self, person):
FOAF = Namespace("http://xmlns.com/foaf/0.1/")
MYTERMS = Namespace("http://peoples.org/terms/")
graph = ConjunctiveGraph()
user = BNode('user')
graph.add((user, MYTERMS['vkontakteID'], Literal(person.id)))
graph.add((user, RDF.type, FOAF['Person']))
graph.add((user, FOAF['firstName'], Literal(person.name)))
graph.add((user, FOAF['surname'], Literal(person.sname)))
attr = [item for item in dir(person) if not callable(item)]
if 'icq' in attr:
graph.add((user, FOAF['icqChatID'], Literal(person.icq)))
if 'nickname' in attr:
graph.add((user, FOAF['nick'], Literal(person.nickname)))
if 'town' in attr:
graph.add((user, MYTERMS['town'], Literal(person.town)))
if 'gender' in attr:
graph.add((user, FOAF['gender'], Literal(person.gender)))
if 'status' in attr:
graph.add((user, MYTERMS['marital'], Literal(person.status)))
if 'religion' in attr:
graph.add((user, MYTERMS['religion'], Literal(person.religion)))
if 'politic' in attr:
graph.add((user, MYTERMS['politic'], Literal(person.politic)))
if 'bday' or 'bmonth' or 'byear' in attr:
birthday = BNode('birthday')
graph.add((user, FOAF['birthday'], birthday))
if 'bday' in attr:
graph.add((birthday, MYTERMS['bday'], Literal(person.bday)))
if 'bmonth' in attr:
graph.add((birthday, MYTERMS['bmonth'], Literal(person.bmonth)))
if 'byear' in attr:
graph.add((birthday, MYTERMS['byear'], Literal(person.byear)))
if 'university' in attr:
university = BNode('university')
graph.add((user, MYTERMS['university'], university))
graph.add((university, MYTERMS['university_name'], Literal( \
person.university)))
if 'faculty' in attr:
graph.add((university, MYTERMS['faculty_name'], Literal( \
person.faculty)))
if 'chair' in attr:
graph.add((university, MYTERMS['chair_name'], Literal( \
person.chair)))
if 'edu_form' in attr:
graph.add((university, MYTERMS['edu_form'], Literal( \
person.edu_form)))
friends = BNode('friends')
graph.add((user, MYTERMS['friends'], friends))
graph.add((friends, RDF.type, RDF.Bag))
for id in person.friends.keys():
friend = URIRef('http://vkontakte.ru/id%s' % id)
graph.add((friends, RDF.li, friend))
# save graph to rdf-file
fname = "%s.rdf" % person.id
graph.serialize(os.path.join(self.store_path, fname), \
format='xml', encoding='UTF-8')
示例2: createFeatureGraphs
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def createFeatureGraphs(rows):
albums = {}
graph = Graph(identifier = URIRef(graph_uri))
counter = 1
databases[catalogueID] = []
for row in rows:
# Create all the relevant nodes (with the correct IDs)
database = getNewNode('database')
databases[catalogueID].append(database)
feature = getNewNode('feature')
segmentation = getNewNode('segmentation')
window = getNewNode('window')
if row['feature'] == "cqt":
graph.add((feature, RDF.type, audiodb['CQTFeature']))
elif row['feature'] == "chr":
graph.add((feature, RDF.type, audiodb['ChromagramFeature']))
elif row['feature'] == "mfcc":
graph.add((feature, RDF.type, audiodb['MFCCFeature']))
if row['segtype'] == "frames":
graph.add((segmentation, RDF.type, audiodb['FrameSegmentation']))
elif row['segtype'] == "beats":
graph.add((segmentation, RDF.type, audiodb['BeatSegmentation']))
elif row['segtype'] == "segs":
graph.add((segmentation, RDF.type, audiodb['StructuralSegmentation']))
if row['windowtype'] == "hamming":
graph.add((window, RDF.type, audiodb['HammingWindow']))
graph.add((feature, audiodb["window"], window))
graph.add((feature, audiodb["segmentation"], segmentation))
graph.add((feature, audiodb["dimension"], Literal(row['dim'])))
graph.add((feature, audiodb["hop-size"], Literal(row['hopsize'])))
graph.add((feature, audiodb["window-length"], Literal(row['winlen'])))
graph.add((feature, audiodb["nfft"], Literal(row['nfft'])))
graph.add((feature, audiodb["segn"], Literal(row['segn'])))
graph.add((feature, audiodb["channel"], Literal(row['channel'])))
graph.add((feature, audiodb["loedge"], Literal(row['loedge'])))
graph.add((feature, audiodb["hiedge"], Literal(row['hiedge'])))
graph.add((feature, audiodb["octaveres"], Literal(row['octaveres'])))
version = buildNewExtractor(graph, row['software'], row['version'], row['platform'])
project = buildNewProject(graph, row['software'])
graph.add((project, doap['release'], version))
graph.add((database, RDF.type, audiodb["Database"]))
graph.add((database, audiodb["feature"], feature))
graph.add((database, audiodb["extractor"], version))
counter += 1
graph.serialize(format='xml',destination="output/"+catalogueID.lower()+"/"+"features.rdf")
示例3: to_rdf
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def to_rdf(self, format="settings"):
"""Convert the RdfSerializer store into RDF."""
graph = Graph()
for k, v in self.NAMESPACES.iteritems():
graph.bind(k, v)
for g in self.subgraphs:
graph += g
if format == "settings":
format = settings.RDF_SERIALIZATION
return graph.serialize(format=format)
示例4: del_vocab_from_creator
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def del_vocab_from_creator(userid, vocab):
if not os.path.isfile(os.path.join(ag.creatorsdir, '%s.rdf'%userid)):
return False
graph = Graph()
graph.parse(os.path.join(ag.creatorsdir, '%s.rdf'%userid))
vocab_uri = URIRef("http://vocab.ox.ac.uk/%s"%vocabprefix)
for s, p, o in graph.triples((URIRef(vocab_uri), namespaces['dcterms']['mediator'], None)):
graph.remove((s, p, o))
rdf_str = None
rdf_str = graph.serialize()
f = codecs.open(creatorfile, 'w', 'utf-8')
f.write(rdf_str)
f.close()
return True
示例5: getRdfXml
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def getRdfXml(rdf):
n3 = ""
# Append the RDF namespace and print the prefix namespace mappings
rdf['namespaces']['xh1'] = "http://www.w3.org/1999/xhtml/vocab#"
rdf['namespaces']['rdf'] = "http://www.w3.org/1999/02/22-rdf-syntax-ns#"
for prefix, uri in rdf['namespaces'].items():
n3 += "@prefix %s: <%s> .\n" % (prefix, uri)
# Print each subject-based triple to the screen
triples = rdf['triples']
processed = []
# Get all of the non-bnode subjects
nonBnodeSubjects = getNonBnodeSubjects(triples)
# Get all of the bnode subjects
bnodeSubjects = getBnodeSubjects(triples)
for subject in nonBnodeSubjects:
subjectTriples = getTriplesBySubject(subject, triples)
#print "PROCESSING NB SUBJECT:", subjectTriples
if(subject not in processed):
n3 += tripleToN3(subjectTriples, processed, triples)
processed.append(subject)
for subject in bnodeSubjects:
subjectTriples = getTriplesBySubject(subject, triples)
#print "PROCESSING BN SUBJECT:", subject
if(subject not in processed):
n3 += bnodeToN3(subjectTriples, processed, triples)
n3 += " .\n"
#print n3
g = ConjunctiveGraph()
g.parse(StringIO(n3), format="n3")
rdfxml = g.serialize()
return rdfxml
示例6: Graph
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
# Get the sqlite plugin. You may have to install the python sqlite libraries
store = plugin.get('SQLite', Store)('rdfstore.db')
# Open previously created store, or create it if it doesn't exist yet
try:
rt = store.open(configString,create=False)
except OperationalError, e:
try:
# There is no underlying sqlite infrastructure, create it
rt = store.open(configString,create=True)
assert rt == VALID_STORE
except OperationalError, e:
raise
import sys, pdb; pdb.post_mortem(sys.exc_info()[2])
# There is a store, use it
graph = Graph(store, identifier = URIRef(default_graph_uri))
print "Triples in graph before add: ", len(graph)
# Now we'll add some triples to the graph & commit the changes
rdflibNS = Namespace('http://rdflib.net/test/')
graph.add((rdflibNS['pic:1'], rdflibNS['name'], Literal('Jane & Bob')))
graph.add((rdflibNS['pic:2'], rdflibNS['name'], Literal('Squirrel in Tree')))
graph.commit()
print "Triples in graph after add: ", len(graph)
# display the graph in RDF/XML
print graph.serialize()
示例7: reader
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
# Connecion to Sesame
con=connection('http://freerisk.org:8280/openrdf-sesame/')
con.use_repository('joblistings')
con.addnamespace('company',str(COMPANY))
cg=ConjunctiveGraph()
cg.bind('dc',DC)
cg.bind('jobboard',JB)
# Find companies with ticker symbols
res=con.query('select ?id ?ticker where {?id company:symbol ?ticker .}')
# Loop over the results
for row in res:
company=URIRef(row['id']['value'])
ticker=row['ticker']['value']
url='http://ichart.finance.yahoo.com/table.csv?s=%s&a=00&b=28&c=2008&d=00&e=28&f=2009&g=m&ignore=.csv' % ticker
rows=[row for row in reader(urllib.urlopen(url))]
current=float(rows[1][6])
yearago=float(rows[-1][6])
# Calculate percent change
change=((current-yearago)/current)*100
cg.add((company,JB['stockpricechange'],Literal(change)))
print cg.serialize(format='xml')
示例8: resolveURI
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def resolveURI(self, uri):
return _urljoin(self.baseuri or "", uri)
def _popStacks(self, event, node):
# check abouts
if len(self.abouts) <> 0:
about, aboutnode = self.abouts[-1]
if aboutnode == node:
self.abouts.pop()
# keep track of nodes going out of scope
self.elementStack.pop()
# track xml:base and xml:lang going out of scope
if self.xmlbases:
self.xmlbases.pop()
if self.xmlbases and self.xmlbases[-1]:
self.baseuri = self.xmlbases[-1]
if self.langs:
self.langs.pop()
if self.langs and self.langs[-1]:
self.lang = self.langs[-1]
if __name__ == "__main__":
store = ConjunctiveGraph()
store.load(sys.argv[1], format="rdfa")
print store.serialize(format="pretty-xml")
示例9: Namespace
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
from rdflib.Graph import ConjunctiveGraph
from rdflib import Namespace, BNode, Literal, RDF, URIRef
import csv
import pysesame
JB = Namespace("http://semprog.com/schemas/jobboard#")
GEO = Namespace('http://www.w3.org/2003/01/geo/wgs84_pos#')
lg=ConjunctiveGraph()
lg.bind('geo',GEO)
for city,lat,long in csv.reader(file('city_locations.csv','U')):
lg.add((JB[city],GEO['lat'],Literal(float(lat))))
lg.add((JB[city],GEO['long'],Literal(float(long))))
data=lg.serialize(format='xml')
print data
c=pysesame.connection('http://semprog.com:8280/openrdf-sesame/')
c.use_repository('joblistings')
print c.postdata(data)
示例10: TriplesDatabase
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
class TriplesDatabase(object):
"""A database from the defined triples"""
def __init__(self):
self._open = False
def open(self, filename, graphClass=None):
"""
Load existing database at 'filename'.
"""
if filename is None:
if graphClass is None:
self.graph = Graph()
else:
self.graph = graphClass()
else:
assert os.path.exists(filename), (
"%s must be an existing database" % (filename,))
path, filename = os.path.split(filename)
self.graph = sqliteBackedGraph(path, filename)
self._open = True
def query(self, rest, initNs=None, initBindings=None):
"""
Execute a SPARQL query and get the results as a SPARQLResult
{rest} is a string that should begin with "SELECT ", usually
"""
assert self._open
if initNs is None:
initNs = dict(self.graph.namespaces())
if initBindings is None: initBindings = {}
sel = select(self.getBase(), rest)
ret = self.graph.query(sel, initNs=initNs, initBindings=initBindings,
DEBUG=False)
return ret
def getBase(self):
d = dict(self.graph.namespaces())
return d.get('', RDFSNS)
def addTriple(self, s, v, *objects):
"""
Make a statement/arc/triple in the database.
Strings, ints and floats as s or o will automatically be coerced to
RDFLiteral(). It is an error to give a RDFLiteral as v, so no
coercion will be done in that position.
2-tuples will be coerced to bnodes.
If more than one object is given, i.e.
addTriple(a, b, c1, c2, c3)
this is equivalent to:
addTriple(a,b,c1); addTriple(a,b,c2); addTriple(a,b,c3)
"""
assert self._open
assert len(objects) >= 1, "You must provide at least one object"
if canBeLiteral(s):
s = RDFLiteral(s)
bnode = None
for o in objects:
if canBeLiteral(o):
o = RDFLiteral(o)
elif isinstance(o, tuple) and len(o) == 2:
if bnode is None:
bnode = BNode()
self.addTriple(bnode, *o)
o = bnode
assert None not in [s,v,o]
self.graph.add((s, v, o))
def dump(self):
assert self._open
io = StringIO()
try:
self.graph.serialize(destination=io, format='n3')
except Exception, e:
import sys, pdb; pdb.post_mortem(sys.exc_info()[2])
return io.getvalue()
示例11: proxy
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
Further information about Construct can be obtained from
http://www.construct-infrastructure.org
"""
from construct.proxy import proxy
from construct.constructservice import ServiceError
from rdflib.Graph import ConjunctiveGraph
# Create a new proxy object.
proxy = proxy()
print "Executing Script"
try:
# Generate a piece of FOAF RDF
store = ConjunctiveGraph()
store.load("joebloggs_foaf.rdf")
data = store.serialize(format="nt")
# Send the FOAF RDF to the data store
if(proxy.insert(data)):
# Now query for joebloggs web address
query = """SELECT ?nickname WHERE{
?subject <http://xmlns.com/foaf/0.1/name> "Joe Bloggs".
?subject <http://xmlns.com/foaf/0.1/nick> ?nickname.}
"""
results = proxy.query(query)
print "Here is the N3 form of the QueryResults Object:"
print results
except ServiceError, e:
print e
# Close the proxy.
proxy.close()
示例12: __toRDF
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def __toRDF(self):
"""
Dump mailing list into a RDF file
"""
#rdf graph
store = ConjunctiveGraph()
#namespaces
store.bind('rdfs', RDFS)
store.bind('swaml', SWAML)
store.bind('sioc', SIOC)
store.bind('sioct', SIOCT)
store.bind('foaf', FOAF)
store.bind('dc', DC)
store.bind('mvcb', MVCB)
#fisrt the host graph
host = self.config.get('host')
if (len(host) > 0):
self.__addSite(store, host)
#and then the mailing list
list = URIRef(self.__getUri())
store.add((list, RDF.type, SIOC['Forum']))
#store.add((list, RDF.type, SIOCT['MailingList']))
#list information
title = self.config.get('title')
if (len(title) > 0):
store.add((list, DC['title'], Literal(title)))
description = self.config.get('description')
if (len(description) > 0):
store.add((list, DC['description'], Literal(description)))
if (len(host) > 0):
store.add((list, SIOC['has_host'], URIRef(host)))
store.add((list, SWAML['address'], Literal(self.config.get('to'))))
store.add((list, DC['date'], Literal(FileDate(self.config.get('mbox')).getStringFormat())))
store.add((list, MVCB['generatorAgent'], URIRef(self.config.getAgent())))
store.add((list, MVCB['errorReportsTo'], URIRef('http://swaml.berlios.de/bugs')))
if (self.lang != None):
store.add((list, DC['language'], Literal(self.lang)))
#subscribers
subscribers = self.subscribers.getSubscribersUris()
for uri in subscribers:
store.add((list, SIOC['has_subscriber'], URIRef(uri)))
store.add((URIRef(uri), RDF.type, SIOC['UserAccount']))
#and all messages
for msg in self.index.items:
uri = msg.getUri()
store.add((list, SIOC['container_of'], URIRef(uri)))
store.add((URIRef(uri), RDF.type, SIOC['Post']))
parent = msg.getParent()
if (parent != None):
store.add((URIRef(uri), SIOC['reply_of'], URIRef(parent)))
#and dump to disk
try:
rdf_file = open(self.config.get('dir')+'forum.rdf', 'w+')
rdf_file.write(store.serialize(format="pretty-xml"))
rdf_file.flush()
rdf_file.close()
except IOError, detail:
print 'Error exporting mailing list to RDF: ' + str(detail)
示例13: createMediaGraphs
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def createMediaGraphs(rows):
albums = {}
artists = {
'Madonna': mb_artist['79239441-bfd5-4981-a70c-55c3f15c1287'],
'John Coltrane': mb_artist['b625448e-bf4a-41c3-a421-72ad46cdb831'],
'Miles Davis' : mb_artist['561d854a-6a28-4aa7-8c99-323e6ce46c2a']}
counter = 1
for row in rows:
graph = Graph(identifier = URIRef(graph_uri))
# Create all the relevant nodes (with the correct IDs)
work = getNewNode('work')
composition = getNewNode('composition')
track = getNewNode('track')
record = getNewNode('record')
performance = getNewNode('performance')
signal = Namespace(graph_uri+"/"+row['uid'])
# If we don't have an artist url, make a foaf Agent instead.
if row['artist']:
try:
artist = artists[row['artist']]
except KeyError:
artist = getNewNode('artist')
graph.add((artist, RDF.type, foaf['Agent']))
graph.add((artist, foaf['name'], Literal(row['artist'].strip())))
artists[row['artist']] = artist;
if row['composer']:
try:
composer = artists[row['composer']]
except KeyError:
composer = getNewNode('artist')
graph.add((composer, RDF.type, foaf['Agent']))
graph.add((composer, foaf['name'], Literal(row['composer'].strip())))
artists[row['composer']] = composer;
else:
composer = artist
# Work
graph.add((work, RDF.type, mo['MusicalWork']))
# Composition
graph.add((composition, RDF.type, mo['Composition']))
if composer:
graph.add((composition, mo['composer'], composer))
graph.add((composition, mo['produced_work'], work))
# Track
graph.add((track, RDF.type, mo['Track']))
if row['artist']:
graph.add((track, foaf['maker'], artist))
if row['tracknum']:
graph.add((track, mo['track_number'], Literal(row['tracknum'])))
if row['album']:
# Album
try:
album = albums[row['album']]
except KeyError:
album = getNewNode('album')
graph.add((album, RDF.type, mo['Record']))
graph.add((album, dc['title'], Literal(row['album'].strip())))
graph.add((album, mo['release_type'], mo['album']))
albums[row['album']] = album
graph.add((album, mo['track'], track))
# Signal
graph.add((signal, RDF.type, mo['Signal']))
graph.add((signal, mo['published_as'], record))
if row['track']:
graph.add((signal, dc['title'], Literal(row['track'].strip())))
if row['isrc']:
graph.add((signal, mo['isrc'], Literal(row['isrc'].strip())))
# Add to the various databases
dbs = databases[catalogueID]
for db in dbs:
graph.add((db, audiodb["has-signal"], signal))
# Record
graph.add((record, RDF.type, mo['Record']))
graph.add((record, mo['publication_of'], signal))
graph.add((record, mo['track'], track))
# Performance
graph.add((performance, RDF.type, mo['Performance']))
graph.add((performance, mo['performance_of'], work))
if row['artist']:
graph.add((performance, mo['performer'], artist))
graph.add((performance, mo['recorded_as'], signal))
graph.close()
graph.serialize(format='xml',destination="output/"+catalogueID.lower()+"/media_"+str(counter)+".rdf")
counter += 1
示例14: __init__
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
class rdf_transform:
def __init__(self):
self.g = Graph('IOMemory')
self.g.bind('dc', dublin_core)
self.g.bind('foaf', FOAF)
self.g.bind('time-entry', owl_time)
self.g.bind('letter', letter_ns)
self.g.bind('owl', owl)
self.g.bind('ex', exam)
self.g.bind('geo', geo)
self.g.bind('base', base_uri)
def create_rdf_letter (self, letters):
'''
creates an rdf representation of letter used to load into the triple store
'''
for l in letters:
correspondence = base_uri + "letters/resource/" + l.type + '/' + urllib.quote(l.correspondent) + '/' + str(l.id) + '/rdf'
self.add_author(correspondence, "Charles Dickens")
self.add_subject(correspondence, "letter")
self.add_time(correspondence, str(l.letter_date)+'T00:00:00')
self.add_correspondent(correspondence, l.correspondent)
#self.add_place(correspondence, parse_text.find_geographical(l.letter_text))
place = ''
try:
place = str(l.letter_place)
#unicode errors are text related
except UnicodeError:
pass
if place is not '':
self.add_place(correspondence, place)
self.add_letter_text(correspondence, l.letter_text)
self.add_salutation(correspondence, l.correspondent, l.salutation)
#for line in l.letter_text.splitlines():
# if len(line.strip()) > 1:
# self.add_open(correspondence, parse_text.parse_salutation_line(line))
#this section will parse for proper names in due course
#commented out whilst code is being ported
#letter_name = parse_text.parseProperNames(text)
# print"names, ", letter_name
#for name in letter_name:
# letter_rdf += "<letter:personReferred>%s</letter:personReferred>" %(name)
letter_quotes = parse_text.parse_balanced_quotes(l.letter_text)
for quote in letter_quotes:
if str(quote[0:1]).isupper and "!" not in quote:
if quote == "ALL THE YEAR ROUND" or quote=="HOUSEHOLD WORDS" or quote== "Household Words":
self.add_magazine(correspondence, parse_text.stripPunc(quote))
else:
self.add_text(correspondence, parse_text.stripPunc(quote))
letter_rdf = self.g.serialize(format="pretty-xml", max_depth=3)
return letter_rdf
def create_rdf_end (self):
''' function to create an endpoint in rdf/xml '''
correspondence = base_uri
letter = {}
letter = dbase.get_endpoint_rdf()
letter_items = letter.items()
letter_items.sort()
works = set()
works = dbase.get_books()
for url, text in letter_items:
try:
correspondence = base_uri + "letters/resource/dickens/" + urllib.quote(str(text[1])) + '/' + str(url) + '/rdf'
self.add_author(correspondence, "Charles Dickens")
self.add_subject(correspondence, "letter")
self.add_subject(correspondence, "Charles Dickens")
self.add_subject(correspondence, parse_text.camel_case(str(text[1])))
self.add_time(correspondence, str(text[3])+'T00:00:00')
self.add_correspondent(correspondence, str(text[1]))
self.add_salutation(correspondence, urllib.quote(str(text[1])), str(text[4]))
place = str(text[5])
#for line in str(text[2]).splitlines():
# self.add_open(correspondence, parse_text.parse_salutation_line(str(text[2])))
letter = str(text[2])
#unicode errors are text related
except UnicodeError:
pass
if place is not None:
self.add_place(correspondence, place)
self.add_letter_text(correspondence, letter)
#this section will parse for proper names in due course
#.........這裏部分代碼省略.........
示例15: update_rdf_for_conversion
# 需要導入模塊: from rdflib.Graph import ConjunctiveGraph [as 別名]
# 或者: from rdflib.Graph.ConjunctiveGraph import serialize [as 別名]
def update_rdf_for_conversion(prefix, vocab_properties, rdf_vocab_properties):
#(id, base, prefix) = get_vocab_base(vocabfile)
html_vocab_properties = {}
html_vocab_properties['format'] = 'text/html'
html_vocab_properties['name'] = "%s.html"%os.path.splitext(rdf_vocab_properties['name'])[0]
html_vocab_properties['path'] = rdf_vocab_properties['path'].replace(rdf_vocab_properties['name'], html_vocab_properties['name'])
html_vocab_properties['uri'] = rdf_vocab_properties['uri'].replace(rdf_vocab_properties['name'], html_vocab_properties['name'])
newrdf_vocab_properties = {}
newrdf_vocab_properties['format'] = 'application/rdf+xml'
newrdf_vocab_properties['name'] = "%s_modified.rdf"%os.path.splitext(rdf_vocab_properties['name'])[0]
newrdf_vocab_properties['path'] = rdf_vocab_properties['path'].replace(rdf_vocab_properties['name'], newrdf_vocab_properties['name'])
newrdf_vocab_properties['uri'] = rdf_vocab_properties['uri'].replace(rdf_vocab_properties['name'], newrdf_vocab_properties['name'])
graph = Graph()
graph.parse(rdf_vocab_properties['path'])
subject = None
for s in graph.subjects(namespaces['rdf']['type'], URIRef(namespaces['owl']['Ontology'])):
subject = s
#graph2 = Graph()
graph_ns = []
for nsprefix, nsurl in graph.namespaces():
graph_ns.append(str(nsurl))
for prefix, url in namespaces.iteritems():
if not str(url) in graph_ns:
graph.bind(prefix, URIRef(url))
#properties = get_vocab_properties(prefix)
#subject = None
#for s in graph.subjects(namespaces['dc']['title'], None):
# subject = s
#if not subject:
# for s in graph.subjects(namespaces['dcterms']['title'], None):
# subject = s
#if not subject:
# for s in graph.subjects(namespaces['dc']['creator'], None):
# subject = s
#if not subject:
# for s in graph.subjects(namespaces['dcterms']['creator'], None):
# subject = s
formatNode1 = BNode()
formatNode2 = BNode()
#Add vocabulary properties identifier and format
graph.add((subject, namespaces['dc']['identifier'], URIRef(rdf_vocab_properties['uri'])))
graph.add((subject, namespaces['dcterms']['isVersionOf'], URIRef(vocab_properties['preferredNamespaceUri'])))
graph.add((subject, namespaces['dcterms']['hasFormat'], URIRef(rdf_vocab_properties['uri'])))
graph.add((subject, namespaces['dcterms']['hasFormat'], URIRef(html_vocab_properties['uri'])))
graph.add((subject, namespaces['vann']['preferredNamespaceUri'], URIRef(vocab_properties['preferredNamespaceUri'])))
graph.add((subject, namespaces['vann']['preferredNamespacePrefix'], URIRef(vocab_properties['preferredNamespacePrefix'])))
graph.add((URIRef(html_vocab_properties['uri']), namespaces['rdf']['type'], URIRef(namespaces['dctype']['Text'])))
graph.add((URIRef(html_vocab_properties['uri']), namespaces['dc']['format'], formatNode1))
graph.add((formatNode1, namespaces['rdf']['value'], Literal('text/html')))
graph.add((formatNode1, namespaces['rdfs']['label'], Literal('HTML')))
graph.add((formatNode1, namespaces['rdf']['type'], URIRef(namespaces['dcterms']['IMT'])))
graph.add((URIRef(rdf_vocab_properties['uri']), namespaces['rdf']['type'], URIRef(namespaces['dctype']['Text'])))
graph.add((URIRef(rdf_vocab_properties['uri']), namespaces['dc']['format'], formatNode2))
graph.add((formatNode2, namespaces['rdf']['value'], Literal('application/rdf+xml')))
graph.add((formatNode2, namespaces['rdfs']['label'], Literal('RDF')))
graph.add((formatNode2, namespaces['rdf']['type'], URIRef(namespaces['dcterms']['IMT'])))
#Add rdfs:isDefinedBy for each class / property / term of the vocabulary
#Find if schema is rdfs / owl. This defines the possible types (rdf:type) for each class / property / term
#testo = vocab_type_definitions_test['rdfs']
#subjects = []
#subs = graph.subjects(namespaces['rdf']['type'], URIRef(testo))
#for s in subs:
# subjects.append(s)
#if subjects:
# objects = vocab_type_definitions_rdfs
#else:
# objects = vocab_type_definitions_owl
#For all subjects that are of the type found above, add rdfs:isDefinedBy
#for o in objects:
# subs = graph.subjects(namespaces['rdf']['type'], o)
# for s in subs:
# graph.add((s, namespaces['rdfs']['isDefinedBy'], URIRef(vocab_properties['preferredNamespaceUri'])))
list_of_terms = get_terms(rdf_vocab_properties['path'])
for s in list_of_terms:
graph.add((URIRef(s), namespaces['rdfs']['isDefinedBy'], URIRef(vocab_properties['preferredNamespaceUri'])))
rdf_str = None
rdf_str = graph.serialize(format="pretty-xml")
#f = codecs.open(newrdf_vocab_properties['path'], 'w', 'utf-8')
f = codecs.open(newrdf_vocab_properties['path'], 'w')
f.write(rdf_str)
f.close()
return (newrdf_vocab_properties, html_vocab_properties)