Python rdflib.Graph类代码示例

 def test_post_no_type_to_root(self):
     graph = Graph()
     created = BNode()
     graph.add((self.my_ktbs.uri, RDFS.seeAlso, created))
     graph.add((created, RDF.type, KTBS.Base))
     with assert_raises(RdfRestException):
         self.my_ktbs.post_graph(graph)

 def _read_id_from_install_rdf(self, installrdfpath):
     from rdflib import Graph
     rdf = Graph()
     installrdf = rdf.parse(file=file(installrdfpath))
     for i in installrdf.all_nodes():
         if re.search(".*@.*\..*", i):
             return i.decode()

def generate_productlist(config, data):
	g = Graph('IOMemory', BNode())
	for product_data in data['products']:
		product = URIRef(link(product_data['link'])+"#subject")
		add_lang_names(g, product, product_data['names'], rel=[SCHEMA.name, DCTERMS.title])
		g.add((product, RDF.type, SCHEMA.CreativeWork))
	return g

def fragment(gp, broker, agora, channel, updating, gen):
    try:
        gp_match = re.search(r'\{(.*)\}', gp).groups(0)
        if len(gp_match) != 1:
            raise click.ClickException('Invalid graph pattern')

        STOA = {
            "broker_host": broker[0],
            "broker_port": broker[1],
            "agora_host": agora[0],
            "agora_port": agora[1],
            "exchange": channel[0],
            "topic_pattern": channel[1],
            "response_prefix": channel[2]
        }

        tps = re.split('\. ', gp_match[0])

        prefixes, fragment_gen = get_fragment_generator(*tps, monitoring=30, STOA=STOA, updating=updating, gen=gen)
        graph = Graph()
        for prefix in prefixes:
            graph.bind(prefix, prefixes[prefix])
            click.echo('@prefix {}: <{}> .'.format(prefix, prefixes[prefix]))
        click.echo('')

        for chunk in fragment_gen:
            if chunk is not None:
                headers, (c, s, p, o) = chunk
                triple = u'{} {} {} .'.format(s.n3(graph.namespace_manager), p.n3(graph.namespace_manager),
                                              o.n3(graph.namespace_manager))
                click.echo(triple)
    except Exception as e:
        raise click.ClickException('There was a problem with the request: {}'.format(e.message))

def annotateConfidence(target, un, con, com):
    # thisAnnotation id is the full string, eg:
    # http://chartex.org/user/jjon/annotation/dc9d7cbdd0ebefb583e46fc2b79bc8cedde34d68
    # the last element being a hash (hashlib.sha1(oa:hastarget).hexdigest()) of this full string:
    # http://chartex.org/graphid/Person_11139might_bePerson_11339 (this triple is actually in there, why?, weird!
    target = re.sub('[<>]', '', target)
    thisAnnotationURI =  "http://chartex.org/user/%s/annotation/%s" % (un, sha1(target).hexdigest())
    confidence = Literal(con) if con == 'nochange' else Literal(con,datatype=XSD.decimal)
    #TODO: if no change, create no confidenceMetric triple for the annotation OR insert original decimal value
    
    if (int(annotationExists('<' + thisAnnotationURI + '>')) > 0):
        return ("You've already annotated this statement: %s \nPresumably you could make a separate annotation with a different username. If you start doing that, you should keep track of all your usernames. When we have authentication and session logic, this won't be necessary.\n\nAnnotation triples:\n" % (target,), getSingleConfidenceAnnotation('<' + thisAnnotationURI + '>', 'application/rdf+xml'))
    else:
        thisann = URIRef(thisAnnotationURI)
        g = Graph()
        bodyNode = BNode()
        triples = [
            (thisann, RDF.type, oa.Annotation),
            (thisann, oa.hasTarget, URIRef(target)),
            (thisann, oa.hasBody, bodyNode),
            (bodyNode, chartex.suggestedConfidenceMetric, confidence),
            (bodyNode, chartex.userComment, Literal(com))
        ]
        for t in triples: g.add(t)
        r = requests.post(
            AGVM_VC_REPO + "/statements",
            headers={'Content-Type': 'text/turtle'},
            data=g.serialize(format='turtle'),
            auth=AG_AUTH
        )

        return (g.serialize(format='pretty-xml'), r.__dict__)

 def testConjunction(self):
     self.addStuffInMultipleContexts()
     triple = (self.pizza, self.likes, self.pizza)
     # add to context 1
     graph = Graph(self.graph.store, self.c1)
     graph.add(triple)
     self.assertEquals(len(self.graph), len(graph))

def ext_json():
    rdfUrl = ''
    tok = Tokenizer()
    if request.method == 'POST':
        rdf = request.form['data']
        status_test = "0"#request.form['status']
        filters = ""#request.form['exculdeurls']
        #rdf = "http://jpp.no-ip.org/MAD_J.rdf"
        try:
            #r = requests.get(rdf)
            gg = Graph()
            #g.load(rdfUrl)
            rdf_content = StringIO.StringIO(rdf.encode('utf-8'))
            #print rdf_content.readline()
            gg.parse(rdf_content,  format="xml")
            ext = Extractor(gg)
            uris = ext.getUris()
            mapping = MapFactory()
            for uri in uris:
                term = tok.tokenized_url(uri)
                uri_status = ""
                if status_test == "1":
                    uri_status = ext.testUri(uri)
                else:
                    uri_status = "N/A"  
                uri_lookup = str(uri)+"\"" 
                lnum = ext.get_lines(rdf_content, uri_lookup)          
                ent = MapEntry(uri, term, "", lnum, uri_status)
                mapping.add(ent)
            jsonized_result = json.dumps(mapping.get())              
            return Response(jsonized_result, mimetype='application/json')
        except requests.exceptions.ConnectionError:
            X2Rwarning = 'X2R Warning: The requested URL raises ConnectionError~!!!'
            return X2Rwarning

    def test_dataset_description_linksets(self):
        res = self.client.get('/.well-known/void')
        self.assertEqual(res.status_code, http.client.OK)
        self.assertEqual(res.headers['Content-Type'], 'text/turtle')
        g = Graph()
        g.parse(format='turtle', data=res.get_data(as_text=True))
        # http://dbpedia.org/void/Dataset
        q = sparql.prepareQuery('''
SELECT ?triples
WHERE {
  ?linkset a void:Linkset .
  ?linkset void:subset <http://n2t.net/ark:/99152/p0d> .
  ?linkset void:subjectsTarget <http://n2t.net/ark:/99152/p0d> .
  ?linkset void:linkPredicate ?predicate .
  ?linkset void:objectsTarget ?dataset .
  ?linkset void:triples ?triples .
}
''', initNs={'void': VOID})
        dbpedia = URIRef('http://dbpedia.org/void/Dataset')
        triples = next(iter(g.query(
            q, initBindings={'dataset': dbpedia,
                             'predicate': DCTERMS.spatial})))['triples'].value
        self.assertEqual(triples, 3)

        worldcat = URIRef('http://purl.oclc.org/dataset/WorldCat')
        triples = next(iter(g.query(
            q, initBindings={'dataset': worldcat,
                             'predicate': DCTERMS.isPartOf})))['triples'].value
        self.assertEqual(triples, 1)

def all_products():
  params = request.args.get('categoria')
  g = Graph()
  try:
    g.parse('prueba.rdf', format='xml')
  except Exception,e:
    print str(e)

    def __init__(self, err, data, namespace=None):
        self.err = err
        self.manifest = u"urn:mozilla:install-manifest"
        self.namespace = namespace or "http://www.mozilla.org/2004/em-rdf"

        if isinstance(data, types.StringTypes):
            data = StringIO(data)  # Wrap data in a pseudo-file

        from rdflib.plugins.parsers import rdfxml
        orig_create_parser = rdfxml.create_parser

        try:
            # Patch rdflib to not resolve URL entities.
            def create_parser(*args, **kwargs):
                parser = orig_create_parser(*args, **kwargs)
                parser.setEntityResolver(AddonRDFEntityResolver(err))
                return parser
            rdfxml.create_parser = create_parser

            # Load up and parse the file in XML format.
            graph = Graph()
            graph.parse(data, format="xml")
            self.rdf = graph

        except ParserError as ex:
            # Re-raise the exception in a local exception type.
            raise RDFException(message=ex.message)
        except SAXParseException as ex:
            # Raise the SAX parse exceptions so we get some line info.
            raise RDFException(orig_exception=ex)
        finally:
            # If we fail, we don't want to sully up the creation function.
            rdfxml.create_parser = orig_create_parser

    def test_load_from_model(self):
        """Can we round trip through a RDF model"""
        model = Graph()
        path = '/root/42BW9AAXX/C1-38/Project_12345/'
        filename = '12345_AAATTT_L003_R1_001.fastq.gz'
        seq = sequences.parse_fastq(path, filename)
        seq.save_to_model(model)

        seq_id = 'file://'+path+filename
        seqNode = URIRef(seq_id)
        libNode = URIRef('http://localhost/library/12345')
        model.add((seqNode, libraryOntology['library'], libNode))
        seq2 = sequences.SequenceFile.load_from_model(model, seq_id)

        self.assertEqual(seq.flowcell, seq2.flowcell)
        self.assertEqual(seq.flowcell, '42BW9AAXX')
        self.assertEqual(seq.filetype, seq2.filetype)
        self.assertEqual(seq2.filetype, 'split_fastq')
        self.assertEqual(seq.lane, seq2.lane)
        self.assertEqual(seq2.lane, '3')
        self.assertEqual(seq.read, seq2.read)
        self.assertEqual(seq2.read, 1)
        self.assertEqual(seq.project, seq2.project)
        self.assertEqual(seq2.project, '12345')
        self.assertEqual(seq.index, seq2.index)
        self.assertEqual(seq2.index, 'AAATTT')
        self.assertEqual(seq.split, seq2.split)
        self.assertEqual(seq2.split, '001')
        self.assertEqual(seq.cycle, seq2.cycle)
        self.assertEqual(seq.pf, seq2.pf)
        self.assertEqual(seq2.libraryNode, libNode)
        self.assertEqual(seq.path, seq2.path)

 def test_post_no_type_to_base(self):
     graph = Graph()
     created = BNode()
     graph.add((self.my_ktbs.uri, RDFS.seeAlso, created))
     graph.add((created, RDF.type, KTBS.hasModel)) # in correct NS
     with assert_raises(RdfRestException):
         self.my_ktbs.post_graph(graph)

 def test_post_bad_type_to_base(self):
     graph = Graph()
     created = BNode()
     graph.add((self.my_ktbs.uri, KTBS.contains, created))
     graph.add((created, RDF.type, RDFS.Resource))
     with assert_raises(RdfRestException):
         self.my_ktbs.post_graph(graph)

def open_store(identifier):
    ident = URIRef(identifier)
    store = plugin.get("SQLAlchemy", Store)(identifier=ident)
    graph = Graph(store, identifier=ident)
    uri = Literal(os.environ.get("DATABASE_URL"))
    graph.open(uri, create=False)
    return graph

    def test_period_json(self):
        res1 = self.client.get('/trgkvwbjd.json')
        self.assertEqual(res1.status_code, http.client.OK)
        self.assertEqual(res1.headers['Content-Type'], 'application/json')
        self.assertEqual(
            res1.headers['Content-Disposition'],
            'attachment; filename="periodo-period-trgkvwbjd.json"')
        context = json.loads(res1.get_data(as_text=True))['@context']
        self.assertEqual(context, [
            'http://localhost.localdomain:5000/c',
            {'@base': 'http://n2t.net/ark:/99152/'}])

        res2 = self.client.get('/trgkvwbjd.jsonld')
        self.assertEqual(res2.status_code, http.client.OK)
        self.assertEqual(res2.headers['Content-Type'], 'application/ld+json')
        self.assertEqual(
            res2.headers['Content-Disposition'],
            'attachment; filename="periodo-period-trgkvwbjd.json"')

        jsonld = json.loads(res1.get_data(as_text=True))
        context = json.loads(self.client.get('/c', buffered=True)
                             .get_data(as_text=True))
        g = Graph().parse(
            data=json.dumps({**jsonld, **context}), format='json-ld')
        self.assertIsNone(
            g.value(predicate=RDF.type, object=SKOS.ConceptScheme))
        self.assertIn((PERIODO['p0trgkvwbjd'],
                       FOAF.isPrimaryTopicOf, HOST['trgkvwbjd.json']), g)
        self.assertIn((HOST['trgkvwbjd.json'],
                       VOID.inDataset, HOST['d']), g)
        self.assertIn((PERIODO['p0trgkvwbjd'],
                       SKOS.inScheme, PERIODO['p0trgkv']), g)
        res3 = self.client.get('/trgkvwbjd.json.html')
        self.assertEqual(res3.status_code, http.client.OK)
        self.assertEqual(res3.headers['Content-Type'], 'text/html')