def get_src_queries(self):
        q1 = prepareQuery(
            QueryStrings.SPARQL_HEIGHT_DIAMETER_CONTENT_X_Y_VELOCITY_MASSFLOW_TEMP_HEATCAPA_DENSITY_MOLEWEIGHT)
        q2 = prepareQuery(QueryStrings.SPARQL_CONTENT)
        q3 = prepareQuery(QueryStrings.SPARQL_ERATE)

        return q1, q2, q3
Exemple #2
0
    def get_src_data(self):
        """Gets all sourced data.
        returns: list of source data objects for the ADMS_SOURCE_DETAILS section of the APL.
        """
        sources = []
        q1 = prepareQuery(
            QueryStrings.
            SPARQL_DIAMETER_TEMP_HEIGHT_MASSFLOW_HEATCAPA_DENSITY_MOLEWEIGHT)
        q2 = prepareQuery(QueryStrings.SPARQL_CONTENT)
        q3 = prepareQuery(QueryStrings.SPARQL_ERATE)

        for src in self.topnode:
            iri = self.connectChimneyDB(src)
            qdata = self.query(q1)
            qdataC = self.query(q2)
            qdataERate = self.query(q3)

            aresult, sorteder, pollutantnames = self.get_new_src_data(
                iri, qdata, qdataC, qdataERate)

            new_src = admsSrc(
                SrcName=str(src[Constants.KEY_MMSI]),
                SrcHeight=aresult[Constants.KEY_HEIGHT].toPython(),
                SrcDiameter=float(aresult[Constants.KEY_DIAMETER].toPython()),
                SrcPolEmissionRate=sorteder,
                SrcPollutants=pollutantnames,
                SrcTemperature=aresult[Constants.KEY_TEMP].toPython(),
                SrcMolWeight=aresult[Constants.KEY_MOLE_WEIGHT].toPython(),
                SrcDensity=float(aresult[Constants.KEY_DENSITY].toPython()),
                SrcSpecHeatCap=aresult[Constants.KEY_HEAT_CAP].toPython(),
                SrcNumPollutants=len(pollutantnames),
                SrcMassFlux=aresult[Constants.KEY_MASS_FLOW].toPython())
            sources.append(new_src)

        return sources
Exemple #3
0
def rewriteQueryToCapabilityMap(q):
    # Note, for debugging, use: algebra.pprintAlgebra(<node?>)

    # Navigate to BGP node in tree
    prologue_ = []
    for prefix, uri in q.prologue.namespace_manager.namespaces():
        prologue_.append("PREFIX %s: <%s>" % (
            prefix,
            uri,
        ))

    capabilityServiceMappings = [
        ('http://froogle.com/',
         algebra.Join(
             algebra.BGP([(Variable('a'), Variable('a'), Variable('a'))]),
             algebra.BGP([(Variable('b'), Variable('b'), Variable('b'))]))),
    ]

    addServiceCapabilities(q.algebra, capabilityServiceMappings)
    query_ = evalPart(q.prologue, q.algebra)

    #print "\n".join(prologue_)
    print query_
    #			ServiceGraphPattern(
    #                    term = http://fish.db.endpoint
    #                    graph = GroupGraphPatternSub(
    #                        part = [TriplesBlock_{'_vars': set([?dbp]), 'triples': [[?dbp, rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.Literal(u'fish')]]}]
    #                        _vars = set([?dbp])
    #                        )
    #                    _vars = set([?dbp])
    #                    )
    try:
        prepareQuery("\n".join(prologue_) + query_, initNs=initNS)
    except:
        print '## Did not validate ##'
def rewriteQueryToCapabilityMap(q):
	# Note, for debugging, use: algebra.pprintAlgebra(<node?>) 

	# Navigate to BGP node in tree
	prologue_ = []
	for prefix, uri in q.prologue.namespace_manager.namespaces():
		prologue_.append("PREFIX %s: <%s>" % (prefix, uri,))

	capabilityServiceMappings = [ ('http://froogle.com/', algebra.Join( algebra.BGP([( Variable('a'), Variable('a'), Variable('a'))]), algebra.BGP([( Variable('b'), Variable('b'), Variable('b'))]))), ]

	addServiceCapabilities(q.algebra, capabilityServiceMappings)
	query_ = evalPart(q.prologue, q.algebra)

	
	#print "\n".join(prologue_)
	print query_
	#			ServiceGraphPattern(
    #                    term = http://fish.db.endpoint
    #                    graph = GroupGraphPatternSub(
    #                        part = [TriplesBlock_{'_vars': set([?dbp]), 'triples': [[?dbp, rdflib.term.URIRef(u'http://www.w3.org/1999/02/22-rdf-syntax-ns#type'), rdflib.term.Literal(u'fish')]]}]
    #                        _vars = set([?dbp])
    #                        )
    #                    _vars = set([?dbp])
    #                    )
	try:
		prepareQuery("\n".join(prologue_) + query_, initNs = initNS)
	except:
		print '## Did not validate ##'
Exemple #5
0
def build_possible_queries():
    queries = []
    query = prepareQuery("""SELECT ?name
        WHERE { ?r owl:Class ro:Recipe .
                ?r ro:name ?name . }
        ORDER BY ?name""",
                         initNs={
                             'ro': RO,
                             'owl': OWL
                         })
    queries.append(Query('List all imported recipes', query))
    query = prepareQuery("""SELECT ?name
        WHERE { ?i owl:Class ro:Food .
                ?i ro:food_name ?name . }
        ORDER BY ?name""",
                         initNs={
                             'ro': RO,
                             'owl': OWL
                         })
    queries.append(Query('List all imported ingredients', query))
    query = prepareQuery("""SELECT ?name
        WHERE { ?recipe ro:name ?name .
                ?recipe ro:ingredient ?ingredient .
                ?ingredient ro:food ?food .
                ?food ro:food_name ?param . }
        ORDER BY ?name""",
                         initNs={
                             'ro': RO,
                             'owl': OWL
                         })
    queries.append(
        Query('List all recipes containing desired ingredient', query,
              'Ingredient name: '))
    return queries
Exemple #6
0
def parse(foaf_url):
    global gexf_graph
    global parsedFOAFS
    global queuedFOAFS

    g = Graph()

    try:
        g.load(foaf_url)
    except Exception:
        print "Can't fetch " + foaf_url
        return

    SIOC = Namespace("http://rdfs.org/sioc/ns#")

    acctID = URIRef(g.value(URIRef(foaf_url), FOAF.maker) + "#acct")
    root_accountName = str(g.value(acctID, FOAF.accountName))
    root_webfinger = root_accountName + "@" + urlparse(foaf_url).hostname

    subscriptions = prepareQuery(
        """SELECT ?accountName ?accountProfilePage
           WHERE {
              ?person sioc:follows ?b .
              ?b foaf:accountName ?accountName .
              ?b foaf:accountProfilePage ?accountProfilePage .
           }""",
        initNs = { "foaf": FOAF, "sioc": SIOC })

    subscribers = prepareQuery(
        """SELECT ?accountName ?accountProfilePage
           WHERE {
              ?b sioc:follows ?person .
              ?b foaf:accountName ?accountName .
              ?b foaf:accountProfilePage ?accountProfilePage .
           }""",
        initNs = { "foaf": FOAF, "sioc": SIOC })

    gexf_graph.addNode(root_webfinger, root_webfinger)

    for subscription in g.query(subscriptions, initBindings={'person': acctID}):
        accountProfilePage = str(subscription.accountProfilePage) + "/foaf"
        accountName = str(subscription.accountName)
        if (blacklisted(accountProfilePage) is False):
            hostname = urlparse(accountProfilePage).hostname
            webfinger = accountName + "@" + hostname
            gexf_graph.addNode(webfinger, webfinger)
            gexf_graph.addEdge(root_webfinger + webfinger, root_webfinger, webfinger)
            if accountProfilePage not in parsedFOAFS:
                queuedFOAFS.put(accountProfilePage)

    for subscriber in g.query(subscribers, initBindings={'person': acctID}):
        accountProfilePage = str(subscriber.accountProfilePage) + "/foaf"
        accountName = str(subscriber.accountName)
        if (blacklisted(accountProfilePage) is False):
            hostname = urlparse(accountProfilePage).hostname
            webfinger = accountName + "@" + hostname
            gexf_graph.addNode(webfinger, webfinger)
            gexf_graph.addEdge(webfinger + root_webfinger, root_webfinger, webfinger)
            if accountProfilePage not in parsedFOAFS:
                queuedFOAFS.put(accountProfilePage)
Exemple #7
0
 def validateSPARQL(self):
     if self.prefixes != None and self.comboBox != None and self.comboBox.currentIndex(
     ) != None and self.prefixes[self.comboBox.currentIndex(
     )] != None and self.inp_sparql2.toPlainText(
     ) != None and self.inp_sparql2.toPlainText() != "":
         try:
             if self.prefixes[self.comboBox.currentIndex()] != "":
                 prepareQuery(
                     "".join(self.prefixes[self.comboBox.currentIndex()]) +
                     "\n" + self.inp_sparql2.toPlainText())
             self.errorLabel.setText("Valid Query")
             self.errorline = -1
             self.sparqlhighlight.errorhighlightline = self.errorline
             self.sparqlhighlight.currentline = 0
             self.inp_sparql2.errorline = None
         except Exception as e:
             match = re.search(r'line:([0-9]+),', str(e))
             match2 = re.search(r'col:([0-9]+),', str(e))
             start = int(match.group(1)) - len(self.triplestoreconf[
                 self.comboBox.currentIndex()]["prefixes"]) - 1
             self.errorLabel.setText(
                 re.sub("line:([0-9]+),", "line: " + str(start) + ",",
                        str(e)))
             self.inp_sparql2.errorline = start - 1
             if "line" in str(e):
                 ex = str(e)
                 start = ex.find('line:') + 5
                 end = ex.find(',', start)
                 start2 = ex.find('col:') + 4
                 end2 = ex.find(')', start2)
                 self.errorline = ex[start:end]
                 self.sparqlhighlight.errorhighlightcol = ex[start2:end2]
                 self.sparqlhighlight.errorhighlightline = self.errorline
                 self.sparqlhighlight.currentline = 0
Exemple #8
0
def test_info(testname):
    q = prepareQuery(('SELECT ?atest ?analname ?fastinfo WHERE {'
                      '?analyte foaf:name ?analname .'
                      '?atest lab:tests ?analyte .'
                      '?atest lab:fasting ?fastinfo .}'),
                     initNs={
                         'foaf': FOAF,
                         'lab': labn
                     })
    test = labn[testname.upper()]
    data = []
    for row in graph.query(q, initBindings={'atest': test}):
        data.append({
            'test': row.atest,
            'test_code': testname.upper(),
            'analyte': row.analname,
            'preparation': {
                'fasting': row.fastinfo
            }
        })
    q = prepareQuery(
        'SELECT ?specimens ?label WHERE { ?atest lab:testWith ?specimens . ?specimens rdfs:label ?label}',
        initNs={'lab': labn})
    specimens = []
    for row in graph.query(q, initBindings={'test': data[0]['test']}):
        specimens.append({'specimens': row.specimens, 'label': row.label})
    data[0]['specimens'] = specimens
    return jsonify(data)
Exemple #9
0
    def get_pol(self):
        """
        Prepares data for ADMS_POLLUTANT_DETAILS section of the APL.
        Separates particles to PM10 and PM2.5 categories. Stores emission rates in em_rates
        class member variable for every examined source for later use. @see: get_src_data()
        @return: list of Pol objects.
        """
        limit = 10 - len(
            self.pollutants
        )  # No more that 10 pollutants are allowed per ADMS source
        pols = []
        pol_data = []
        diam_dens = set()
        pol_names = {}
        q1 = prepareQuery(QueryStrings.SPARQL_DIAMETER_DENSITY_MASSFRACTION)
        q2 = prepareQuery(QueryStrings.SPARQL_MASSRATE)
        i = 0
        k = 0

        for src in self.entity:
            iri = self.connect_chimney_db(src)
            self.em_rates[iri] = {}
            qb = self.query(q1)
            massrate = self.query(q2).__iter__().__next__()[
                Constants.KEY_MASS_RATE].toPython()

            for row in qb:
                dd = (row[Constants.KEY_DIAMETER].toPython(),
                      row[Constants.KEY_DENSITY].toPython())
                mf = float(row[Constants.KEY_MASS_FRACTION]) * massrate
                pol_data.append({
                    Constants.KEY_DIAMETER + Constants.KEY_DENSITY:
                    dd,
                    Constants.KEY_MASS_FLOW:
                    mf,
                    Constants.KEY_SRC:
                    iri
                })
                diam_dens.add(dd)
                self.em_rates[iri][dd] = mf

        dd_srt = sorted(diam_dens, key=lambda tup: tup[0],
                        reverse=True)[0:limit]
        for diam, dens in dd_srt:
            name = None
            if diam <= 0.00001:
                name = Constants.POL_PM10 + '-' + str(i)
                i = i + 1
                if diam <= 0.0000025:
                    name = Constants.POL_PM25 + '-' + str(k)
                    k = k + 1
            if name is not None:
                pol_names[(diam, dens)] = name
                pols.append(AdmsPol(name, 1, [diam], [dens], [1.0e+0]))
                self.pollutants.append(name)

        self.update_em_rates(pol_names, limit)

        return pols
    def load_rules(self):
        # Create the var to store the rules
        rules = {}

        # Load the rules file
        g = rdflib.Graph()
        g.load(bz2.BZ2File(self.rulesFile), format="turtle")
        if len(g) == 0:
            return
        print "Loaded %d triple rules from %s" % (len(g), self.rulesFile)

        # Load the AddDimensionValue rules from the graph g
        q = prepareQuery("""
            select ?target ?dim ?value where {
                ?rule a harmonizer:AddDimensionValue.
                ?rule harmonizer:dimension ?dim.
                ?rule harmonizer:targetDimension ?target.
                ?rule harmonizer:value ?value.
            }
        """,
                         initNs={"harmonizer": self.namespaces['harmonizer']})
        qres = g.query(q)
        for row in qres:
            (target, dim, value) = row
            rule = {'type': 'AddDimensionValue', 'dimval': (dim, value)}
            rules.setdefault(target, []).append(rule)

        # Load the SetDimension rules from the graph g
        q = prepareQuery("""
            select ?target ?dim where {
                ?rule a harmonizer:SetDimension.
                ?rule harmonizer:dimension ?dim.
                ?rule harmonizer:targetDimension ?target.
            }
        """,
                         initNs={"harmonizer": self.namespaces['harmonizer']})
        qres = g.query(q)
        for row in qres:
            (target, dim) = row
            rule = {'type': 'SetDimension', 'dimension': dim}
            rules.setdefault(target, []).append(rule)

        # Load the IgnoreObservation rules from the graph g
        q = prepareQuery("""
            select ?target where {
                ?rule a harmonizer:IgnoreObservation.
                ?rule harmonizer:targetDimension ?target.
            }
        """,
                         initNs={"harmonizer": self.namespaces['harmonizer']})
        qres = g.query(q)
        for row in qres:
            target = row[Variable('target')]
            rule = {
                'type': 'IgnoreObservation',
            }
            rules.setdefault(target, []).append(rule)

        return rules
Exemple #11
0
    def get_pol(self):
        """
        Prepares data for ADMS_POLLUTANT_DETAILS section of the APL.
        Separates particles to PM10 and PM2.5 categories. Stores emission rates in em_rates
        class member variable for every examined source for later use. @see: get_src_data()
        @return: list of Pol objects.
        """
        pols = []
        pol_data = []
        diam_dens = set()
        pol_names = {}
        q1 = prepareQuery(QueryStrings.SPARQL_DIAMETER_DENSITY_MASSFRACTION)
        q2 = prepareQuery(QueryStrings.SPARQL_MASSRATE)
        i = 0
        k = 0

        for src in self.topnode:
            iri = self.connectChimneyDB(src)
            qb = self.query(q1)
            massrate = self.query(q2).__iter__().__next__()[
                Constants.KEY_MASS_RATE].toPython()

            for row in qb:
                dd = (row[Constants.KEY_DIAMETER].toPython(),
                      row[Constants.KEY_DENSITY].toPython())
                pol_data.append({
                    Constants.KEY_DIAMETER + Constants.KEY_DENSITY:
                    dd,
                    Constants.KEY_MASS_FLOW:
                    float(row[Constants.KEY_MASS_FRACTION]) * massrate,
                    Constants.KEY_SRC:
                    iri
                })
                diam_dens.add(dd)
            self.em_rates[iri] = {}

        for diam, dens in diam_dens:
            name = None
            if diam <= 0.00001:
                name = Constants.POL_PM10 + '-' + str(i)
                i = i + 1
                if diam <= 0.0000025:
                    name = Constants.POL_PM25 + '-' + str(k)
                    k = k + 1
            if name != None:
                pol_names[(diam, dens)] = name
                pols.append(admsPol(name, 1, [diam], [dens], [1.0e+0]))
                self.pollutants.append(name)

        for pd in pol_data:
            pol_key = pd[Constants.KEY_DIAMETER + Constants.KEY_DENSITY]
            if pol_key in pol_names:
                self.em_rates[pd[Constants.KEY_SRC]][pol_names[pol_key]] = pd[
                    Constants.KEY_MASS_FLOW]

        return pols
Exemple #12
0
 def localPropertyTypeExtractor(self):
 
         
     query_str = "SELECT DISTINCT ?p  WHERE { ?s ?p ?o . } "
     
     query_object = prepareQuery(query_str)#, initNs={CMR_QA.NAMESPACE_PREFIX : CMR_QA.BASE_URI})
     
     predicates = self.localrdfgraph.query(query_object)
     
     print("Using %s local predicates" % (len(predicates)))
     
     for p in predicates:
      
         #print(p)
         #continue
         prop = str(p[0])
         
         #print(prop)
         
         if not prop.startswith("http://dbpedia.org/"):  
             #we ignore other type of properties. Focus on dbpedia ones. 
             #Others will be trreates as annotation (rdfs:label, foaf:name) or specially (rdf:type)
             continue
         
     
         query_str = "SELECT ?value WHERE { ?s <" + prop + "> ?value . } limit 100"
         
         #print(query_str)
         #continue
         #print("lalala")
         
         query_object = prepareQuery(query_str)#, initNs={CMR_QA.NAMESPACE_PREFIX : CMR_QA.BASE_URI})
         
         values = self.localrdfgraph.query(query_object)
         
         n_values = len(values)
         n_uris = 0
         
         for v in values:
             #print(v[0])
             if str(v[0]).startswith("http"):
                 n_uris+=1
         
         
         if n_values==1:
             isObjectProperty = (n_uris == n_values)
         else:   
             isObjectProperty = (n_uris > (n_values/2))
         
         #print("New: " + prop)
         if isObjectProperty:                
             #self.rdfgraph.add( (URIRef(prop),  RDF.type, URIRef(OWL.OWLOBJECTPROPERTY)) )
             self.propertyType[prop]=True                                                                    
         else:
             #self.rdfgraph.add( (URIRef(prop),  RDF.type, URIRef(OWL.OWLDATAPROPERTY)) )
             self.propertyType[prop]=False
Exemple #13
0
Fichier : tag.py Projet : kba/fff
    def find_filenames_for_tags(self, tags, flag_only_existing=False):
        dinst_set = self.find_datainstances_for_tags(tags)
        print(dinst_set)
        g = Graph()
        for dinst in dinst_set:
            g.parse(self.client.target('observation/data-about?urn=' + dinst))
        filepaths = {}
        for dinst in dinst_set:
            queryDataInstance = prepareQuery("""
                SELECT DISTINCT ?filepath ?dataobject
                WHERE {
                    ?dataInstance fff:dataObject ?dataobject .
                    ?dataInstance fff:dataLocation ?dataLocation .
                    ?dataLocation fff:filePath ?filepath .
                }""", initNs=ns)
            queryDataObject = prepareQuery(
                """
                SELECT ?tag
                WHERE {
                    ?anno oa:hasTarget ?dataobject .
                    ?anno oa:hasBody ?body .
                    ?body cnt:chars ?tag .
                }""", initNs=ns)

            queryDataInstance
            dinst_uri = URIRef(dinst)
            filepath = ""
            tags = set()
            for row in g.query(queryDataInstance, initBindings=dict(dataInstance=dinst_uri)):
                try:
                    row['filepath']
                    fp = row['filepath'].value
                    filepath = fp
                    print fp
                except KeyError:
                    pass
                try:
                    dataobject = "" + row['dataobject']
                    g.parse(self.client.target("observation/data-about?urn=" + dataobject))
                    # print len(g)
                    for row2 in g.query(queryDataObject, initBindings=dict(dataobject=dataobject)):
                        try:
                            row2['tag']
                            tag = row2['tag'].value
                            tags.add(tag)
                        except KeyError:
                            pass
                except KeyError:
                    pass
        # if (flag_only_existing and os.path.exists(filepath)):
        #     filepaths[filepath] = tags
        # else:
            filepaths[filepath] = tags

        return filepaths
Exemple #14
0
    def add_prepared_query(self, name, query, initNs=None):
        self.log.debug("adding prepared query with name %s", name)
        pq = lambda x,y: prepareQuery(x, initNs=y)
        if initNs is None:
            pq = lambda x,y: prepareQuery(x)

        prepared_query = pq(query, initNs)
        self.prepared_queries[name] = (query, prepared_query)
        self.prepared_query_to_str[prepared_query] = query

        return self.prepared_queries[name][-1]
Exemple #15
0
def getQ10():
    q10 = prepareQuery('''
      SELECT
        ?name ?link (SUM(?amount) as ?totalAmount) (COUNT(?order) as ?orderCount)
      WHERE {
        ?company s:name ?name.
        ?order s:seller ?company.
        OPTIONAL { ?company o:sameAs  ?link. }
		?order ex:hasOrderAmount ?amount.
      }
      GROUP BY ?company
      ORDER BY DESC(?orderCount)
      ''',
                       initNs={
                           "s": s,
                           "ex": ex,
                           "o": o
                       })

    output = g.query(q10)
    df = pd.DataFrame(
        output,
        columns=["Company", "Link", "Total Amount", "Number of contracts"])

    print()
    #notFinisehd
    q10_1 = prepareQuery('''
      SELECT
        ?name (COUNT(?order) as ?orderCount)
      WHERE {
        ?company s:name ?name.
        ?order s:seller ?company.
        ?order ex:hasProductQuantityPending ?quantity.
        FILTER(?quantity > 0).
      }
      GROUP BY ?company
      ORDER BY DESC(?orderCount)
      ''',
                         initNs={
                             "s": s,
                             "ex": ex,
                             "o": o
                         })

    output2 = g.query(q10_1)
    df2 = pd.DataFrame(output2,
                       columns=["Company", "Number of contracts pending"])
    df_final = pd.merge(left=df, right=df2, on="Company")

    return df_final
Exemple #16
0
    def getStreamIDs(self, type):
        if type == 'temperature':
            stream_q = \
                '''
                SELECT DISTINCT ?sensor_uuid
                WHERE {
                    ?room     rdf:type/brick:subClassOf* brick:Room .
                    ?sensor   rdf:type/brick:subClassOf* brick:Temperature_Sensor .
                    
                    ?sensor   brick:pointOf ?room .

                    ?sensor   brick:label ?sensor_uuid .
                }
                '''
            prep_q = prepareQuery(stream_q, initNs={"rdf": RDF, "brick": BRICK})
            return self.pprint(self.query(prep_q))
        elif type == 'co2':
            stream_q = \
                '''
                SELECT DISTINCT ?sensor_uuid
                WHERE {
                    ?room     rdf:type/brick:subClassOf* brick:Room .
                    ?sensor   rdf:type/brick:subClassOf* brick:CO2_Sensor .
                    
                    ?sensor   brick:pointOf ?room .

                    ?sensor   brick:label ?sensor_uuid .
                }
                '''
            prep_q = prepareQuery(stream_q, initNs={"rdf": RDF, "brick": BRICK})
            return self.pprint(self.query(prep_q))
        elif type == 'humidity':
            stream_q = \
                '''
                SELECT DISTINCT ?sensor_uuid
                WHERE {
                    ?room     rdf:type/brick:subClassOf* brick:Room .
                    ?sensor   rdf:type/brick:subClassOf* brick:Humidity .
                    
                    ?sensor   brick:pointOf ?room .

                    ?sensor   brick:label ?sensor_uuid .
                }
                '''
            prep_q = prepareQuery(stream_q, initNs={"rdf": RDF, "brick": BRICK})
            return self.pprint(self.query(prep_q))
        else:
            return "No such type"
Exemple #17
0
 def __init__(self, callback, sparql_query):
     """Creates a SPARQL filter for RDF triples."""
     if sparql_query.strip()[:3].lower() != 'ask':
         raise ZtreamyException('Only ASK queries are allowed '
                                'in SPARQLFilter')
     super(SPARQLFilter, self).__init__(callback)
     self.query = prepareQuery(sparql_query)
    def get(self, concept, predicate, obj):
        sub = domain + concept
        pre = domain + predicate
        predUri = URIRef(pre)
        subUri = URIRef(sub)
        relations = []
        query = prepareQuery('SELECT ?a ?b ?c WHERE{?a ?b ?c}')

        if predicate == "all":
            results = g.query(query, initBindings={'a': subUri})
        else:
            results = g.query(query, initBindings={'a': subUri, 'b': predUri})

        if obj == 'no':
            for row in results:
                relation = OrderedDict()
                predicate = row.b
                relation['predicate'] = predicate
                relations.append(relation)
            return {'relations': marshal(relations, relation_fields)}
        else:
            for row in results:
                relation = OrderedDict()
                predicate = row.b
                obj = row.c
                relation['predicate'] = predicate
                relation['object'] = obj
                relations.append(relation)
            return {'relations': marshal(relations, relation_object_fields)}
Exemple #19
0
	def getTitle(self, expression):
		# Prepare query
		query = sparql.prepareQuery("""
			SELECT ?title
			WHERE
			{
				{
					?annotation ao:type "hasTitle" .
					?annotation oa:hasBody ?body .
					?body rdf:subject ?expression .
					?body rdf:object ?title .
				}
				UNION 
				{   
					?annotation ao:type "hasShortTitle" .
					?annotation oa:hasBody ?body .
					?body rdf:subject ?expression .
					?body rdf:object ?title .               
				}
			}""", 
			initNs = { 'oa': OA, 'ao': AO, 'rdf': RDF })

		# Fire query
		results = self.store.query(query, initBindings={'expression': URIRef(expression)})

		if results:
			return results[0].title
		else:
			item = self.getItem(expression)
			if item:
				h1 = self.getHeader()
				if h1:
					return h1
			return expression
Exemple #20
0
	def getAuthorInfo(self, author):
		# Prepare query
		query = sparql.prepareQuery("""
			SELECT ?name ?email
			WHERE
			{
				?id foaf:name ?name .
				OPTIONAL { ?id schema:email ?email } .
				?annotation ao:type "hasAuthor" .
				?annotation oa:hasBody ?body .
				?body rdf:object ?id .

			}""", initNs = { 'aop': AOP, 'oa': OA, 'rdf': RDF, 'dcterms': DCTERMS })

		# Fire the query
		results = self.store.query(query, initBindings={'author': URIRef(author)})

		# Build the json
		theJSON = []
		for tag in results:
			article = {}
			article['expression'] = tag.expression
			article['item'] = tag.item
			theJSON.append(article)

		return json.dumps(theJSON, indent=4)
Exemple #21
0
def getQ07_01(date):
    # Incidencia covid por comunidades en una fecha dada
    q07_1 = prepareQuery('''
      SELECT
        ?iso ?link ?na ?np ?nh ?nu
      WHERE {


        ?CCAA ex:hasCovidStatus  ?CS.
        ?CCAA ex:hasISOCode ?iso.
        ?CCAA o:sameAs ?link.
        ?CS ex:inDate ?date.
        ?CS ex:numPositiveAC ?na.
        ?CS ex:numPositivePCR ?np.
        ?CS ex:numberHospitalizations ?nh.
        ?CS ex:numberUCI ?nu.
        ?CS ex:inDate ?fecha .

      }
      ''',
                         initNs={"s": s, "ex": ex, "o": o}
                         )
    r = g.query(q07_1, initBindings={'?date': Literal(date, datatype=s + "Date")})
    df = pd.DataFrame(r, columns=['CCAA', 'Link', 'AC', 'PCR', 'Hospitalizations', 'UCI'])
    return df
Exemple #22
0
def getQ05():
    q05 = prepareQuery('''
      SELECT
          ?date ?service (COUNT(?service) as ?ns)
      WHERE {
    
         ?order s:orderDate ?date.
         ?order s:orderedItem ?sv.
         ?sv rdf:type s:Service.
         ?sv s:name ?service.
    
      }
      GROUP BY ?date ?sv
      ORDER BY ?date DESC(?ns) ?service
      LIMIT 100
    
      ''',
        initNs={"s": s, "ex": ex}
      )

    output = g.query(q05)
    df = pd.DataFrame(output, columns=["Date", "Service", "Requested times"])
    df["Date"] = df["Date"].astype(str)
    df['Date'] = pd.to_datetime(df['Date'])
    return df
Exemple #23
0
def getQ06():
    q06 = prepareQuery('''
      SELECT
          ?date ?cases ?product (SUM(?quantity) as ?nq)
      WHERE {
    
         ?order s:orderDate ?date.
         ?order ex:hasProductQuantityPending ?quantity.
         FILTER (?quantity > 0).
         ?order s:orderedItem ?pr.
         ?pr rdf:type s:Product.
         ?pr s:name ?product.
         ?order s:customer ?ccaa.
         ?ccaa ex:hasCovidStatus ?covid.
         ?covid ex:inDate ?date.
         ?covid ex:numberHospitalizations ?cases.
    
      }
      GROUP BY ?date ?pr
      ORDER BY ?date DESC(?nq)
    
      ''',
      initNs={"s": s, "ex": ex}
      )
    output = g.query(q06)
    df = pd.DataFrame(output, columns=["Date", "Number Hospitalizations", "Product", "Quantity pending"])
    df["Date"] = df["Date"].astype(str)
    df['Date'] = pd.to_datetime(df['Date'])
    return df
Exemple #24
0
def getQ07():
    q07 = prepareQuery('''
      SELECT
        ?iso ?link ?fecha ?na ?np ?nh ?nu
      WHERE {

        ?CCAA ex:hasCovidStatus  ?CS.
        ?CCAA ex:hasISOCode ?iso.
        ?CCAA o:sameAs ?link.
        ?CS ex:numPositiveAC ?na.
        ?CS ex:numPositivePCR ?np.
        ?CS ex:numberHospitalizations ?nh.
        ?CS ex:numberUCI ?nu.
        ?CS ex:inDate ?fecha .

      }

      ORDER BY ASC(?fecha)

      ''',
                       initNs={"s": s, "ex": ex, "o": o}
                       )

    df = pd.DataFrame(g.query(q07), columns=['CCAA', 'Link', 'Date', 'AC', 'PCR', 'Hospitalizations', 'UCI'])
    df["Date"] = df["Date"].astype(str)
    df['Date'] = pd.to_datetime(df['Date'])
    return df
Exemple #25
0
def test_graph_prefix():
    """
    This is issue https://github.com/RDFLib/rdflib/issues/313
    """

    g1 = Graph()
    g1.parse(data="""
    @prefix : <urn:ns1:> .
    :foo <p> 42.
    """, format="n3")

    g2 = Graph()
    g2.parse(data="""
    @prefix : <urn:somethingelse:> .
    <urn:ns1:foo> <p> 42.
    """, format="n3")

    assert isomorphic(g1, g2)

    q_str = ("""
    PREFIX : <urn:ns1:>
    SELECT ?val
    WHERE { :foo ?p ?val }
    """)
    q_prepared = prepareQuery(q_str)

    expected = [(Literal(42),)]

    eq_(list(g1.query(q_prepared)), expected)
    eq_(list(g2.query(q_prepared)), expected)

    eq_(list(g1.query(q_str)), expected)
    eq_(list(g2.query(q_str)), expected)
Exemple #26
0
def getQ06_1():
    q06_1 = prepareQuery('''
      SELECT
          ?date ?product (SUM(?quantity) as ?nq)
      WHERE {
    
         ?order s:orderDate ?date.
         ?order ex:hasProductQuantityPending ?quantity.
         FILTER (?quantity > 0).
         ?order s:orderedItem ?pr.
         ?pr rdf:type s:Product.
         ?pr s:name ?product.
    
      }
      GROUP BY ?date ?pr
      ORDER BY ?date DESC(?nq)
    
      ''',
      initNs={"s": s, "ex": ex}
      )

    output = g.query(q06_1)
    df = pd.DataFrame(output, columns=["Date", "Product", "Quantity Pending"])
    df["Date"] = df["Date"].astype(str)
    df['Date'] = pd.to_datetime(df['Date'])
    return df
def index():
    zipcode_query = Queries.ALL_ZIPCODES.value
    query = Queries.ALL_CARS.value
    data = []
    all_zipcodes = []

    for _ in g.query(zipcode_query):
        all_zipcodes.append(_.zipcode.value)

    if request.method == 'POST':
        if request.form['search']:
            code = Literal(request.form['search'])
            query = check_filters()
            q = prepareQuery(query)

            for item in g.query(q, initBindings={'zipcode': code}):
                data.append(parse_data(item))

        else:
            query = check_filters()

            for item in g.query(query):
                data.append(parse_data(item))

    else:
        for item in g.query(query):
            data.append(parse_data(item))

    return render_template('index.html', all_zipcodes=all_zipcodes, data=data)
Exemple #28
0
    async def a_sparqlQuery(self, app, loop, query: str, graphIri: str,
                            bindings):
        reply = []
        try:
            q = prepareQuery(query)
            graph = self.rdfService.graphByUri(graphIri)
            assert graph is not None

            if bindings:
                results = graph.query(q, initBindings=bindings)
            else:
                results = graph.query(q)
        except Exception as err:
            log.debug(f'SparQL query error for {query}: {err}')
            return QVariant([])
        else:
            # Build the QVariant from the results
            for row in results:
                r = {}
                for var in results.vars:
                    r[str(var)] = str(row[var])

                reply.append(r)

            return QVariant(reply)
Exemple #29
0
def test_graph_prefix():
    """
    This is issue https://github.com/RDFLib/rdflib/issues/313
    """

    g1 = Graph()
    g1.parse(data="""
    @prefix : <urn:ns1:> .
    :foo <p> 42.
    """,
             format="n3")

    g2 = Graph()
    g2.parse(data="""
    @prefix : <urn:somethingelse:> .
    <urn:ns1:foo> <p> 42.
    """,
             format="n3")

    assert isomorphic(g1, g2)

    q_str = ("""
    PREFIX : <urn:ns1:>
    SELECT ?val
    WHERE { :foo ?p ?val }
    """)
    q_prepared = prepareQuery(q_str)

    expected = [(Literal(42), )]

    eq_(list(g1.query(q_prepared)), expected)
    eq_(list(g2.query(q_prepared)), expected)

    eq_(list(g1.query(q_str)), expected)
    eq_(list(g2.query(q_str)), expected)
    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 loadFragmentDefinitions(self, folder, fileName):
        datasets = {}
        self.fragments = {}
        with open (fileName, 'r') as f:
            for line in f:
                line = line.strip()
                ws = line.split()
                if (len(ws) > 0):
                    fragment = ws[0]
                    ds = ws[1]
                    datasets[fragment] = ds

        content = os.listdir(folder)
        self.viewsDefinition = {}
        for g in content:
            path = folder+'/'+g
            f = open(path)
            viewStr = f.read()
            f.close()
            view = prepareQuery(viewStr)
            t = getTriple(view)
            i = path.rfind('/') + 1
            j = path.rfind('.')
            j = len(path) if j < 0 else j
            name = path[i:j]
            ds = datasets[name]
            self.fragments[name] = TriplePatternFragment(t, ds)
Exemple #32
0
    def test_construct_init_bindings(self):
        """
        This is issue https://github.com/RDFLib/rdflib/issues/1001
        """

        g1 = Graph()

        q_str = ("""
        PREFIX : <urn:ns1:>
        CONSTRUCT {
          ?uri :prop1 ?val1;
               :prop2 ?c .
        }
        WHERE {
          bind(uri(concat("urn:ns1:", ?a)) as ?uri)
          bind(?b as ?val1)
        }
        """)
        q_prepared = prepareQuery(q_str)

        expected = [
            (URIRef('urn:ns1:A'), URIRef('urn:ns1:prop1'), Literal('B')),
            (URIRef('urn:ns1:A'), URIRef('urn:ns1:prop2'), Literal('C'))
        ]
        results = g1.query(q_prepared,
                           initBindings={
                               'a': Literal('A'),
                               'b': Literal('B'),
                               'c': Literal('C')
                           })

        eq_(sorted(results, key=lambda x: str(x[1])), expected)
Exemple #33
0
def getQ04_1(date):
    q04_1 = prepareQuery('''
    SELECT
      ?product (SUM(?quantity) as ?nq)
    WHERE {
    
       ?order s:orderDate ?date.
       ?order ex:hasProductQuantity ?quantity.
       ?order s:orderedItem ?pr.
       ?pr rdf:type s:Product.
       ?pr s:name ?product
    
    }
    GROUP BY ?pr
    ORDER BY DESC(?nq)
    LIMIT 10
    ''',
        initNs={"s": s, "ex": ex}
    )

    output = g.query(q04_1, initBindings={'?date': Literal(date, datatype=s+"Date")})
    df = pd.DataFrame(output, columns=["Product", "Quantity"])
    #df["Date"] = df["Date"].astype(str)
    #df['Date'] = pd.to_datetime(df['Date'])
    return df
Exemple #34
0
    def getAllOfTypeDescendingTemporal(self, c_type: str) -> Query:
        """Function to get all instances of a given type in descending temporal
        order (based on `hasDate` property).
        
        Arguments:
            c_type {str} -- Target type (eg: 'Degree', 'WorkExperience', etc.).
        
        Returns:
            Query -- Prepared query.
        """

        logging.debug('Preparing query to extract instances of type {0} in\
            descending temporal order'.format(c_type))

        return prepareQuery("""
            SELECT DISTINCT ?s
            WHERE {{
                {{
                    ?s rdf:type precis:{c_type} .
                }}
                OPTIONAL
                {{
                    ?s precis:hasDate ?date .
                }}
            }}
            ORDER BY DESC(?date)
            """.format(c_type=c_type),
                            initNs=self.initN)
Exemple #35
0
    def getAwards(self, target_iri: str) -> Query:
        """SPARQL query to get the name and affiliated organizations issuing
        awards from given a `target_iri` 'relatedTo' entities.
        
        Arguments:
            target_iri {str} -- Target instance IRI.
        
        Returns:
            Query -- Prepared query.
        """

        logging.debug('Preparing awards query for individual {0}'.\
            format(target_iri))

        return prepareQuery("""
            SELECT ?award_name ?org_name
            WHERE {{
                <{target_iri}> precis:relatedTo ?org .
                ?org precis:hasName ?org_name .
                ?award precis:affiliatedWith ?org .
                ?award rdf:type precis:Award .
                ?award precis:hasName ?award_name .
            }}
        """.format(target_iri=target_iri),
                            initNs=self.initN)
Exemple #36
0
    def getOrderedDescriptionText(
        self, target_iri: str, max_priority: int = int(1e10)) -> Query:
        """SPARQL query to get description text for a given instance IRI, as
        ordered by the 'hasPriority' attribute (in ascending order, so priority
        0 > 1 > 2 > ...).
        
        Arguments:
            target_iri {str} -- Target instance IRI.

        Keyword Arguments:
            max_priority {int} -- Maximum description priority
                                  (default: {int(1e10)}).
        
        Returns:
            Query -- Prepared query.
        """

        logging.debug('Preparing description query for individual {0}'.format(
            target_iri))

        return prepareQuery("""
                SELECT DISTINCT ?text
                WHERE {{
                    <{target_iri}> precis:hasDescription ?descr .
                    ?descr precis:hasPriority ?priority .
                    FILTER (?priority < {max_priority}) .
                    ?descr precis:hasText ?text .
                }}
                ORDER BY ?priority
            """.format(target_iri=target_iri, max_priority=max_priority),
                            initNs=self.initN)
Exemple #37
0
def sparqlCommonObj(usr1,
                    usr2,
                    tbl1,
                    tbl2,
                    database_path=DEFAULT_DATABASE_PATH):
    loadstar = Namespace('https://loadstar.com/ontology#')

    myg = open_context(usr1, tbl1, database_path)
    for item in myg:
        if item != None:
            subj1 = item[0]
            break

    myg2 = open_context(usr2, tbl2, database_path)
    for item in myg2:
        if item != None:
            subj2 = item[0]
            break

    mydum = myg + myg2
    myquer = prepareQuery("""SELECT ?object ?a ?b WHERE {?subject1 ?a ?object .
                                                   ?subject2 ?b ?object .}""",
                          initNs={"load": loadstar})

    for row in mydum.query(myquer,
                           initBindings={
                               "subject1": subj1,
                               "subject2": subj2
                           }):
        print row
Exemple #38
0
    def synsets(self, word):
        synsets = []
        #word = 'cachorro'
        stringSparqlQuery = """
			select distinct ?word ?sspt ?lexico where {
				?word
				<https://w3id.org/own-pt/wn30/schema/lexicalForm>
				\"""" + word + """\"@pt .
				?sspt
				<https://w3id.org/own-pt/wn30/schema/containsWordSense>/<https://w3id.org/own-pt/wn30/schema/word>
				?word .
				?ssen
				<http://www.w3.org/2002/07/owl#sameAs>
				?sspt .
				?ssen
				<https://w3id.org/own-pt/wn30/schema/lexicographerFile>
				?lexico .
			}
		"""
        queryString = sparql.prepareQuery(stringSparqlQuery)
        syns = graph.query(queryString)
        for s in syns:
            synsets.append(str(s[0]))
            synsets.append(str(s[1]))
            synsets.append(str(s[2]))
        return synsets  #return array of synsets
	def validateSparql(self, text):
		''' validates a sparql query and stores it in a separate file '''
		text = str(text)
		
		try:
			return sparql.prepareQuery(text, initNs=self.namespaces)
		except Exception as error: 
			raise MalformedSparqlQueryError([str(type(error)), str(error), text])
def testQuery():
    g = makeGraph()

    q = sparql.prepareQuery('SELECT ?o WHERE {?s schema:name ?o} LIMIT 20', initNs = { "schema": "http://schema.org/" })

    myquery = g.query(q)
    
    return myquery
    def test_dataset_description(self):
        res1 = self.client.get(
            '/', headers={'Accept': 'text/html'}, buffered=True)
        self.assertEqual(res1.status_code, http.client.SEE_OTHER)
        self.assertEqual(urlparse(res1.headers['Location']).path,
                         '/index.json.html')

        res2 = self.client.get('/', headers={'Accept': 'text/turtle'})
        self.assertEqual(res2.status_code, http.client.OK)
        self.assertEqual(res2.headers['Content-Type'], 'text/turtle')

        res3 = self.client.get('/.well-known/void')
        self.assertEqual(res3.status_code, http.client.OK)
        self.assertEqual(res3.headers['Content-Type'], 'text/turtle')
        self.assertEqual(res3.get_data(as_text=True),
                         res2.get_data(as_text=True))

        res4 = self.client.get('/.wellknown/void')
        self.assertEqual(res4.status_code, http.client.OK)
        self.assertEqual(res4.headers['Content-Type'], 'text/turtle')
        self.assertEqual(res4.get_data(as_text=True),
                         res3.get_data(as_text=True))

        res5 = self.client.get('/.well-known/void.ttl')
        self.assertEqual(res5.status_code, http.client.OK)
        self.assertEqual(res5.headers['Content-Type'], 'text/turtle')
        self.assertEqual(res5.get_data(as_text=True),
                         res4.get_data(as_text=True))

        res6 = self.client.get('/.well-known/void.ttl.html')
        self.assertEqual(res6.status_code, http.client.OK)
        self.assertEqual(res6.headers['Content-Type'], 'text/html')

        g = Graph()
        g.parse(format='turtle', data=res2.get_data(as_text=True))
        self.assertIn(
            (PERIODO['p0d'], DCTERMS.provenance, HOST['h#changes']), g)
        desc = g.value(predicate=RDF.type, object=VOID.DatasetDescription)
        self.assertEqual(
            desc.n3(), '<http://n2t.net/ark:/99152/p0>')
        title = g.value(subject=desc, predicate=DCTERMS.title)
        self.assertEqual(
            title.n3(), '"Description of the PeriodO Period Gazetteer"@en')
        q = sparql.prepareQuery('''
SELECT ?count
WHERE {
  ?d void:classPartition ?p .
  ?p void:class ?class .
  ?p void:entities ?count .
}
''', initNs={'void': VOID, 'skos': SKOS})
        concept_count = next(iter(g.query(
            q, initBindings={'class': SKOS.Concept})))['count'].value
        self.assertEqual(concept_count, 3)
        scheme_count = next(iter(g.query(
            q, initBindings={'class': SKOS.ConceptScheme})))['count'].value
        self.assertEqual(scheme_count, 1)
Exemple #42
0
def is_inside(textplace,graph):
    """Returns true if the place defined as text is disambiguated in graph
    returns false otherwise"""
    askquery = prepareQuery(
            """ASK {?iri schema:jobLocation ?place .
                ?iri edsa:Location ?placeiri}""",
                initNs = {"schema" : ns.schema , 
                    "edsa" : ns.edsa})
    return bool(graph.query(askquery, initBindings={"place" : Literal(textplace)}))
Exemple #43
0
def timequery(action):                                                              #time query function
    
    q = prepareQuery(
        'SELECT ?time WHERE { ?action alfred:takes ?time .}',
        initNs = { "alfred": "http://www.semanticweb.org/suv/ontologies/2015/3/alfredowl/"})
    
    this = parse + action
    for row in g.query(q, initBindings={'action': this}):
        return int(row.time)
Exemple #44
0
def moodquery(action):                                                              #mood query function
    
    q = prepareQuery(
        'SELECT ?name WHERE { ?action alfred:results ?mood . ?mood alfred:named ?name .}',
        initNs = { "alfred": "http://www.semanticweb.org/suv/ontologies/2015/3/alfredowl/"})
    
    this = parse + action
    for row in g.query(q, initBindings={'action': this}):
        return str(row.name)
Exemple #45
0
def taskquery(action, tasks=[]):                                                    #tasks query function
    
    q = prepareQuery(
        'SELECT ?name WHERE { ?action alfred:involves ?task . ?task alfred:named ?name .}',
        initNs = { "alfred": "http://www.semanticweb.org/suv/ontologies/2015/3/alfredowl/"})
    
    this = parse + action
    for row in g.query(q, initBindings={'action': this}):
        print row.name
Exemple #46
0
def actionquery(mood, actions=[]):                                                  #actions query function
    
    q = prepareQuery(
        'SELECT ?name WHERE { ?mood alfred:possible ?action . ?action alfred:named ?name .}',
        initNs = { "alfred": "http://www.semanticweb.org/suv/ontologies/2015/3/alfredowl/"})
    
    this = parse + mood
    for row in g.query(q, initBindings={'mood': this}):
        actions.append(row.name)
    return actions
Exemple #47
0
def test_sparql_bnodelist():
    """

    syntax tests for a few corner-cases not touched by the
    official tests.

    """

    prepareQuery('select * where { ?s ?p ( [] ) . }')
    prepareQuery('select * where { ?s ?p ( [ ?p2 ?o2 ] ) . }')
    prepareQuery('select * where { ?s ?p ( [ ?p2 ?o2 ] [] ) . }')
    prepareQuery('select * where { ?s ?p ( [] [ ?p2 ?o2 ] [] ) . }')
Exemple #48
0
def build_possible_queries():
    queries = []
    query = prepareQuery("""SELECT ?name
        WHERE { ?r owl:Class ro:Recipe .
                ?r ro:name ?name . }
        ORDER BY ?name""", initNs={'ro': RO, 'owl': OWL})
    queries.append(Query('List all imported recipes', query))
    query = prepareQuery("""SELECT ?name
        WHERE { ?i owl:Class ro:Food .
                ?i ro:food_name ?name . }
        ORDER BY ?name""", initNs={'ro': RO, 'owl': OWL})
    queries.append(Query('List all imported ingredients', query))
    query = prepareQuery("""SELECT ?name
        WHERE { ?recipe ro:name ?name .
                ?recipe ro:ingredient ?ingredient .
                ?ingredient ro:food ?food .
                ?food ro:food_name ?param . }
        ORDER BY ?name""", initNs={'ro': RO, 'owl': OWL})
    queries.append(Query('List all recipes containing desired ingredient', query, 'Ingredient name: '))
    return queries
Exemple #49
0
    def delete(self):
        query = prepareQuery(
            'delete { ?s ?p ?o } WHERE { ?person foaf:knows ?s .}',
            initNs={"foaf": FOAF})

        tim = rdflib.URIRef("http://www.w3.org/People/Berners-Lee/card#i")

        for row in self._graph.query(query, initBindings={'person': tim}):
            print row

        return query
Exemple #50
0
def get_iri(textplace,graph):
    """ Returns the IRI of an existent place in the jobs base
    """
    getquery = prepareQuery("""
            SELECT DISTINCT ?placeiri 
            WHERE {?iri schema:jobLocation ?place .
                ?iri edsa:Location ?placeiri}
        """, initNs = {"schema" : ns.schema , 
                    "edsa" : ns.edsa})
    res = graph.query(getquery, initBindings = {"place" : Literal(textplace)})
    for row in res:
        return row["placeiri"]
 def queryQualityDataIds(self):
     
     query_str = """SELECT DISTINCT ?uri ?comment
        WHERE {
           ?uri """ + CMR_QA.NAMESPACE_PREFIX + """:"""+ CMR_QA.hasQualityComment_Name+ """ ?comment .
           ?uri rdf:type """ + CMR_QA.NAMESPACE_PREFIX + """:""" + CMR_QA.Cine_MRI_Quality_Data_Name + """ .
        }"""
     query_object = prepareQuery(query_str, initNs={CMR_QA.NAMESPACE_PREFIX : CMR_QA.BASE_URI})
        
     #print(query2)
 
     self.qualityDataURIComments = self.rdfgraph.query(query_object)
def testPrepare():
    q = prepareQuery('SELECT ?target WHERE { }')
    r = list(g.query(q))
    e = []
    assert r == e, 'prepare: %r != %r'%(r,e)

    r = list(g.query(q, initBindings={'target': Literal('example')}))
    e = [(Literal('example'),)]
    assert r == e, 'prepare: %r != %r'%(r, e)

    r = list(g.query(q))
    e = []
    assert r == e, 'prepare: %r != %r'%(r,e)
Exemple #53
0
def test_issue():

    query = sparql.prepareQuery(
        """
            SELECT DISTINCT ?property ?parent
            WHERE{
                ?property a owl:DeprecatedProperty .
                ?property dc:relation ?relation .
                ?property rdfs:subPropertyOf ?parent .
                ?property rdfs:label | skos:altLabel ?label .
            }
        """,
        initNs={"rdfs": RDFS, "owl": OWL, "dc": DC, "skos": SKOS})
Exemple #54
0
def testPrepare():
    q = prepareQuery('SELECT ?target WHERE { }')
    r = list(g.query(q))
    e = [(None,)] # TODO: https://github.com/RDFLib/rdflib/issues/554
    assert r == e, 'prepare: %r != %r'%(r,e)

    r = list(g.query(q, initBindings={'target': Literal('example')}))
    e = [(Literal('example'),)]
    assert r == e, 'prepare: %r != %r'%(r, e)

    r = list(g.query(q))
    e = [(None,)] # TODO: https://github.com/RDFLib/rdflib/issues/554
    assert r == e, 'prepare: %r != %r'%(r,e)
 def test_find_location_simple(self):
     location = "Southampton, UK"
     tup = gn.find_location(location)
     self.assertTrue(isinstance(tup[0], rdflib.URIRef))
     self.assertTrue(isinstance(tup[1], rdflib.Graph))
     # At least we brought the correct name
     askplace = prepareQuery(
         """ ASK {
     ?iri gn:name ?name 
     }
     """,
         initNs={"gn": ns.geonames},
     )
     self.assertTrue(tup[1].query(askplace, initBindings={"name": rdflib.Literal("Southampton")}))
def writeOutBGP(f, query):
		''' writes existing BGP statistics (# triples and # of vars) in the query to given file'''
		try:
			sq = sparql.prepareQuery(query, initNs=ns.ns)
		except Exception as error:
			log.warn(str([str(type(error)), str(error), sparql]) + '\n')
			return
			
		# we only look into select queries with a projection
		if sq.algebra.name == "SelectQuery":
			if sq.algebra.p.name == 'Project':
				if sq.algebra.p.p.name == 'BGP':
					f.write(str(len(sq.algebra.p.p.triples)) + ', ' + str(len(sq.algebra.p.p._vars)) + '\n')		
		# will hopefully reduce memory usage
		del sq
Exemple #57
0
def home(request):
     query = prepareQuery('''SELECT ?object WHERE
                              { ?language dbpedia:influenced ?object. }''',
                          initNs= { "dbpedia": '<http://dbpedia.org/ontology/>' })

     results = Graph()
     fresh = Graph()

     results.parse("http://live.dbpedia.org/data/Programming_languages.ntriples", format="nt")
     python = rdflib.URIRef("<http://dbpedia.org/resource/Python_(programming_language)")
     results = results.query(query, initBindings={ 'language': python })
     #for triple in results.query(query, initBindings={ 'language': python }):
     #     fresh.append(triple.uri)

     return render(request, "semantic/index.html", {'results': results})
Exemple #58
0
 def get_query(self, q_str=None, q_parser=None):
     """
     :param q_parser: one of possible query parsers.
     :param q_str: doc(author:D. N. Adams) section(name:Stimulus) prop(name:Contrast, value:20, unit:%)
     :return rdflib prepare query.
     """
     # TODO find out if the validation for the q_str is important
     # We can possibly warn about not used parts and print the parsed dictionary
     if not self.q_dict:
         if not q_str:
             raise AttributeError("Please fulfill q_str param (query string)")
         elif not q_parser:
             raise AttributeError("Please fulfill q_parser param (query parser)")
         self.q_dict = q_parser.parse_query_string(q_str)
     self._prepare_query()
     return prepareQuery(self.query, initNs={"odml": Namespace("https://g-node.org/projects/odml-rdf#"),
                                             "rdf": RDF})
 def getQualityComments(self):
 
     #query = """SELECT DISTINCT ?uri ?comment
     #   WHERE {
     #      ?uri <""" + CMR_QA.hasQualityComment +  """> ?comment .
     #      ?uri rdf:type <""" + CMR_QA.Cine_MRI_Quality_Data + """> .
     #   }"""
        
     query_str = """SELECT DISTINCT ?uri ?comment
        WHERE {
           ?uri """ + CMR_QA.NAMESPACE_PREFIX + """:"""+ CMR_QA.hasQualityComment_Name+ """ ?comment .
           ?uri rdf:type """ + CMR_QA.NAMESPACE_PREFIX + """:""" + CMR_QA.Cine_MRI_Quality_Data_Name + """ .
        }"""
     query_object = prepareQuery(query_str, initNs={CMR_QA.NAMESPACE_PREFIX : CMR_QA.BASE_URI})
        
     #print(query2)
 
     return self.rdfgraph.query(query_object)
    def test_find_location_utf8(self):
        location = "Αθήνα, GR"
        tup = gn.find_location(location)
        self.assertTrue(isinstance(tup[0], rdflib.URIRef))
        self.assertTrue(isinstance(tup[1], rdflib.Graph))
        # At least we brought the correct name and country
        askplace = prepareQuery(
            """ ASK {
        ?iri gn:name ?name 
        }
        """,
            initNs={"gn": ns.geonames},
        )
        self.assertTrue(tup[1].query(askplace, initBindings={"name": rdflib.Literal("Athens")}))

        def test_find_location_unknown(self):
            location = "Unknownlandidfgdfg"
            with assertRaises(gn.NotFoundException):
                tup = gn.find_location(location)