本文整理汇总了Python中rdflib.Graph.serialize方法的典型用法代码示例。如果您正苦于以下问题:Python Graph.serialize方法的具体用法?Python Graph.serialize怎么用?Python Graph.serialize使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类rdflib.Graph
的用法示例。
在下文中一共展示了Graph.serialize方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: named_entity_linking
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def named_entity_linking(original_model, text_filename, segment):
with open(text_filename) as file:
text = file.read()
# build nif context for kea service
nif = Graph()
data_uri = URIRef(RESOURCE_URL + '#char=' + str(0) + ',' + str(len(text)))
nif.add((data_uri, RDF.type, namespaces.nif.RFC5147String))
nif.add((data_uri, RDF.type, namespaces.nif.String))
nif.add((data_uri, RDF.type, namespaces.nif.Context))
nif.add((data_uri, namespaces.nif.isString, Literal(text, datatype=XSD.String)))
nif_text = nif.serialize(format='turtle')
# request to kea service
response = requests.post(KEA_URL, data=nif_text)
# insert correct media fragment (workaround)
corrected_response = response.content.replace("#char=", '#t=' + str(segment[0]) + ',' + str(segment[1]) + '&char=')
# merge existing and new rdf graphs
model = Graph()
model.parse(original_model, format='turtle')
model.parse(data=corrected_response, format='turtle')
with open(original_model, "r+") as turtleFile:
turtleFile.write(model.serialize(format='turtle') + "\n")
turtleFile.close()
示例2: PrefixCache
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
class PrefixCache(object):
PREFIX_URI_TEMPLATE = 'http://prefix.cc/{pfx}.file.ttl'
def __init__(self, prefix_file):
self._prefix_file = prefix_file
self._pfxgraph = Graph()
if os.path.isfile(self._prefix_file):
self._pfxgraph.parse(self._prefix_file, format='turtle')
def lookup(self, pfx):
ns = self._pfxgraph.store.namespace(pfx)
return ns or self._fetch_ns(pfx)
def prefix(self, uri):
return self._pfxgraph.store.prefix(URIRef(uri.decode('utf-8')))
def namespaces(self):
return self._pfxgraph.namespaces()
def _fetch_ns(self, pfx):
url = self.PREFIX_URI_TEMPLATE.format(pfx=pfx)
logger.debug("Fetching <%s>" % url)
try:
self._pfxgraph.parse(url, format='turtle')
except: # not found
logger.debug("Could not read <%s>" % url)
if self._prefix_file:
logger.debug("Saving prefixes to '%s'" % self._prefix_file)
self._pfxgraph.serialize(self._prefix_file, format='turtle')
return self._pfxgraph.store.namespace(pfx)
示例3: OntologyManager
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
class OntologyManager(object):
def __init__(self):
self.filepath = os.path.dirname(os.path.abspath(__file__)) + os.sep + ONTOLOGY_FILE
self.graph = Graph()
self.graph.parse(self.filepath)
def decorate_owl(self, value):
return OWL[value]
def decorate_minerva(self, value):
return MINERVA[value]
def add(self, s, p, o):
self.graph.add((s, p, o))
def add_individual(self, class__, individual):
self.add(self.decorate_minerva(individual), RDF.type, self.decorate_minerva(class__))
self.add(self.decorate_minerva(individual), RDF.type, self.decorate_owl("NamedIndividual"))
def print__(self):
for s, p, o in self.graph:
print "Triple: s: %s, p: %s, o: %s" % (s, p, o)
def save(self):
self.graph.serialize(self.filepath)
示例4: save
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def save(self):
raise NotImplementedError("obsolete?")
if self.temporary:
log.info("not saving temporary sub named %s",self.name)
return
graph = Graph()
subUri = L9['sub/%s' % self.name]
graph.add((subUri, RDFS.label, Literal(self.name)))
for chan in self.levels.keys():
try:
chanUri = get_channel_uri(chan)
except KeyError:
log.error("saving dmx channels with no :Channel node "
"is not supported yet. Give channel %s a URI "
"for it to be saved. Omitting this channel "
"from the sub." % chan)
continue
lev = BNode()
graph.add((subUri, L9['lightLevel'], lev))
graph.add((lev, L9['channel'], chanUri))
graph.add((lev, L9['level'],
Literal(self.levels[chan], datatype=XSD['decimal'])))
graph.serialize(showconfig.subFile(self.name), format="nt")
示例5: match
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def match(rdf_filename, relations_prompt=False, skosxl=False):
G = Graph()
G.parse(rdf_filename)
q = query(skosxl)
count = 0
for concept_uri, label, c, e, b, n, r in G.query(q, initNs=NS):
# no need to map again
if c or e or b or n or r:
continue
# get our wikidata suggestion
try:
wd = suggest(label)
except Quit:
print
print "Thanks for playing: you matched %s concepts" % count
print
break
# if we got a suggestion ask what skos relation to use to link them up
# and save the new assertion to our file
if wd:
if relations_prompt:
rel = pick_rel(label, wd['label'])
else:
rel = SKOS.exactMatch
wikidata_uri = WIKIDATA[wd['id']]
G.add((concept_uri, rel, wikidata_uri))
G.serialize(open(rdf_filename, "w"))
count += 1
示例6: JsonLDSerializerTestCase
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
class JsonLDSerializerTestCase(unittest.TestCase):
identifier = "rdflib_test"
def setUp(self):
self.n3_graph = Graph()
def tearDown(self):
self.n3_graph = None
def test_serialize_01(self):
self.n3_graph.parse(data=test01_n3, format="n3")
json_data = self.n3_graph.serialize(data=test01_json, format="json-ld")
gjson = Graph()
self.assert_(gjson.parse(data=json_data, format="json-ld").isomorphic(self.n3_graph))
def test_serialize_02(self):
self.n3_graph.parse(data=test02_n3, format="n3")
json_data = self.n3_graph.serialize(data=test02_json, format="json-ld")
gjson = Graph()
self.assert_(gjson.parse(data=json_data, format="json-ld").isomorphic(self.n3_graph))
def test_serialize_03(self):
self.n3_graph.parse(data=test03_n3, format="n3")
json_data = self.n3_graph.serialize(data=test03_json, format="json-ld")
gjson = Graph()
self.assert_(gjson.parse(data=json_data, format="json-ld").isomorphic(self.n3_graph))
示例7: __init__
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
class Store:
def __init__(self):
self.graph = Graph()
rt = self.graph.open(storeuri, create=False)
if rt == None:
# There is no underlying Sleepycat infrastructure, create it
self.graph.open(storeuri, create=True)
else:
assert rt == VALID_STORE, 'The underlying store is corrupt'
self.graph.bind('os', OS)
self.graph.bind('rdfs', RDFS)
self.graph.bind('geo', GEO)
self.graph.bind('vcard', VCARD)
self.graph.bind('scheme', SCHEME)
def save(self):
self.graph.serialize(storeuri, format='pretty-xml')
def new_bandvalue(self, band, charge):
allotment = al[band] # @@ humanize the identifier (something like #rev-$date)
self.graph.add((allotment, RDF.type, URIRef('http://data.gmdsp.org.uk/def/council/counciltax/CouncilTaxCharge')))
self.graph.add((allotment, URIRef('http://data.gmdsp.org.uk/def/council/counciltax/charge'), Literal(charge)))
self.graph.add((allotment, URIRef('http://data.gmdsp.org.uk/def/council/counciltax/councilTaxBand'), URIRef('http://data.gmdsp.org.uk/def/council/counciltax/council-tax-bands/'+band)))
self.graph.add((allotment, RDFS.label, Literal('Council tax valuation charges for band '+band, lang='en')))
self.save()
示例8: make_graph
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def make_graph (self, outputfile):
g = Graph()
for k, v in self.__prefixes.iteritems():
g.bind(k, v)
if self.verbose: puts(colored.green("Establishing URIRefs for Provenances..."))
for k, v in self.dict_provenances.iteritems():
v.establish_URIRef()
if self.verbose: puts(colored.green("Putting Provenances to Graph..."))
for k, v in self.dict_provenances.iteritems():
v.put_on_graph(g)
if self.verbose: puts(colored.green("Putting Chronicles to Graph..."))
for k, v in self.dict_chronicles.iteritems():
v.put_on_graph(g)
if self.verbose: puts(colored.green("Serialising Graph..."))
g.serialize(outputfile, format="turtle")
if self.verbose:
puts(colored.white("+-------------------+"))
puts(colored.white("| ")+colored.blue("cxxr2prov Summary")+colored.white(" |"))
puts(colored.white("+-------------------+"))
puts("Number of PROV Entities: " + str(len(self.dict_provenances)))
puts("Number of PROV Activities: " + str(len(self.dict_chronicles)))
puts("Number of PROV used attributes: " + str(self.count_used))
puts("Number of PROV wasGeneratedBy attributes: " + str(self.count_was_generated_by))
示例9: register
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def register():
"""
Entry point del agente que recibe los mensajes de registro
:return:
"""
global dsgraph
global mss_cnt
#cola1.put('zzz')
message= request.args['content']
gm = Graph()
gr = Graph()
gr.bind('acl',ACL)
gm.parse(data=message)
print gm.serialize(format='turtle')
perf = gm.triples( (None, RDF.type, sa)) # Obtenemos la performativa
if perf is None:
gr.add((ACL['not-understood'], RDF.type, sa))
else:
aresp= gm.subject_objects(FOAF.name)
a,n = aresp.next()
print a, n
ms = ACL['message{:{fill}4d}'.format(mss_cnt, fill='0')]
mss_cnt += 1
gr.add((ms, RDF.type, sa))
gr.add((ms, ACL.performative, ACL.confirm))
gm.add((agn.juan, FOAF.name, Literal('RegisterAgent')))
gm.add((ms, ACL.sender, agn.RegisterAgent))
#dsgraph.open('./myRDFLibStore')
dsgraph += gm
return gr.serialize(format='xml')
示例10: get
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def get(self, format):
logging.info('[API] alternative format request for [%s] from IP [%s]' %(format, os.environ['REMOTE_ADDR']))
if format in SUPPORTED_OUTPUT_FORMATS:
g = Graph()
g.bind('void', NAMESPACES['void'], True)
g.bind('eui', NAMESPACES['eui'], True)
g.parse(location = 'index.html', format="rdfa") # load the RDFa-based dataset
self.response.headers.add_header("Access-Control-Allow-Origin", "*") # CORS-enabled
if format == 'rdf-xml':
self.response.headers['Content-Type'] = 'application/rdf+xml'
self.response.out.write(g.serialize())
elif format == 'ttl':
self.response.headers['Content-Type'] = 'text/turtle'
self.response.out.write(g.serialize(format="turtle"))
elif format == 'nt':
self.response.headers['Content-Type'] = 'text/plain'
self.response.out.write(g.serialize(format="nt"))
elif format == 'json':
# based on https://bitbucket.org/okfn/openbiblio/src/tip/rdflib/
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(g.serialize(None, "rdf-json-pretty"))
elif format == 'csv':
self.response.headers['Content-Type'] = 'text/csv'
self.response.out.write(self.dump_csv(g))
elif format =='':
self.response.out.write("<div>Supported output formats or go back [<a href='/'>home</a>]:</div><ul>")
for format in SUPPORTED_OUTPUT_FORMATS:
self.response.out.write("".join(["<li>", "<a href='../format/", format, "'>", format , "</a></li>"]))
self.response.out.write("</ul>")
else:
self.response.out.write(template.render('a404.html', None))
示例11: main
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def main():
# check if output dir exists
d = os.path.abspath(OUTPUT_DIR)
if not os.path.exists(d):
os.makedirs(OUTPUT_DIR)
genoutput(seo.genseo, 'seo', SEO)
genoutput(seo1998.genseo98, 'seo98', SEO98)
genoutput(seo2008.genseo08, 'seo08', SEO08)
genoutput(for_.genfor, 'for', FOR)
genoutput(rfcd.genrfcd, 'rfcd', RFCD)
genoutput(for2008.genfor08, 'for08', FOR08)
genoutput(toa.gentoa, 'toa', TOA)
genoutput(genanzsrc, 'anzsrc', ANZSRC)
g = Graph()
setnamespaceprefixes(g)
fref = URIRef(ANZSRCVIVO)
ontoannot(g, fref)
addvivo(g)
f = open(OUTPUT_DIR + '/anzsrc_vivo.rdf', 'w')
g.serialize(f)
f.close()
示例12: lookup_resource
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def lookup_resource(self, environ, basefile, params, contenttype, suffix):
pathfunc = self.get_pathfunc(environ, basefile, params, contenttype, suffix)
if not pathfunc:
extended = False
# no static file exists, we need to call code to produce data
if basefile.endswith("/data"):
extended = True
basefile = basefile[:-5]
if contenttype in self._rdfformats or suffix in self._rdfsuffixes:
g = Graph()
g.parse(self.repo.store.distilled_path(basefile))
if extended:
annotation_graph = self.repo.annotation_file_to_graph(
self.repo.store.annotation_path(basefile))
g += annotation_graph
path = None
if contenttype in self._rdfformats:
data = g.serialize(format=self._rdfformats[contenttype])
elif suffix in self._rdfsuffixes:
data = g.serialize(format=rdfsuffixes[suffix])
else:
data = None
path = None
if pathfunc:
path = pathfunc(basefile)
data = None
return path, data
示例13: remove_handle
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def remove_handle(self, key):
dir_ = self._key2filename(key)
# remove handle from collection descriptor:
uri = Graph().parse(opj(self.path, dir_, REPO_STD_META_FILE),
format="turtle").value(predicate=RDF.type,
object=DLNS.Handle)
col_graph = Graph().parse(opj(self.path, REPO_STD_META_FILE),
format="turtle")
col_graph.remove((DLNS.this, DCTERMS.hasPart, uri))
col_graph.serialize(opj(self.path, REPO_STD_META_FILE), format="turtle")
# remove handle's directory:
# Note: Currently all files separatly due to issues with the
# normalize_path decorator in gitrepo.py. It expects one output per
# one input file. So, recursively removing the 'dir_' violates that
# assertion.
# Note2: Currently using "-f" option, since on ntfs/vfat, git somehow
# reports the files (at least config.ttl) have staged changes.
# TODO: Figure out, what the hell this is about.
[self.git_remove(file_, f=True) for file_ in self.get_indexed_files()
if file_.startswith(dir_)]
self.git_add(REPO_STD_META_FILE)
self.git_commit("Removed handle %s." % key)
示例14: main
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def main(args):
out = Graph()
p_map = {}
for f in args.files:
logging.info("Parsing: %s" % f)
g = Graph()
g.parse(f, format="turtle")
for s, p, o in g:
if isinstance(o, URIRef):
if p != RDF.type:
if p not in tcga_pred_exclude:
if p not in p_map:
p_map[p] = {}
p_map[p][o] = True
for p in p_map:
#print p
pred = str(p).replace(str(TCGA_OWL), "")
a = re.sub(r'^(.)', lambda match:match.group(1).upper(), pred )
b = re.sub(r'_(.)', lambda match:match.group(1).upper(), a)
#print TCGA_OWL[b]
for o in p_map[p]:
#print "\t", o
out.add( (o, RDF.type, TCGA_OWL[b]))
out.add( (TCGA_OWL[b], OWL.oneOf, o))
print out.serialize(format="turtle")
示例15: serialize
# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import serialize [as 别名]
def serialize(self, format = "xml") :
"""Overriding the Graph's serialize method to adjust the output format"""
if rdflib.__version__ >= "3.0.0" :
# this is the easy case
if format == "xml" or format == "pretty-xml" :
# Fall back to system
Graph.serialize(self, format="pretty-xml")
elif format == "n3" or format == "turtle" :
format = _turtle_serializer_name
self._register_Turtle_serializer_3()
elif _can_json and (format == "json-ld" or format == "json") :
# The new version of the serialziers in RDFLib 3.2.X require this extra round...
# I do not have the patience of working out why that is so.
self._register_JSON_serializer_3()
stream = StringIO()
Graph.serialize(self, format=_json_serializer_name, destination = stream)
return stream.getvalue()
else :
if format == "pretty-xml" :
self._register_XML_serializer_2()
format = _xml_serializer_name
elif format == "n3" or format == "turtle" :
format = _turtle_serializer_name
self._register_Turtle_serializer_2()
return Graph.serialize(self, format=format)