Python Graph.serialize方法代码示例

# 需要导入模块: 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()

# 需要导入模块: 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)

# 需要导入模块: 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)

# 需要导入模块: 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")

# 需要导入模块: 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

# 需要导入模块: 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))

# 需要导入模块: 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()

# 需要导入模块: 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))

# 需要导入模块: 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')

# 需要导入模块: 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))

# 需要导入模块: 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()

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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")

# 需要导入模块: 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)