Python SPARQLWrapper.JSON属性代码示例

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def getResponseText(endpoint, query, requestedMimeType):
    """Returns the result and mimetype of executing the given query against 
    the given endpoint.

    Keyword arguments:
    endpoint - URL of sparql endpoint
    query    - SPARQL query to be executed
    requestedMimeType  Type of content requested. can be:
                'text/csv; q=1.0, */*; q=0.1'
                'application/json'
                etc.
    """
    retFormat = _mimeTypeToSparqlFormat(requestedMimeType)

    client = SPARQLWrapper(endpoint)
    client.setQuery(query)
    client.setReturnFormat(retFormat)
    client.setCredentials(static.DEFAULT_ENDPOINT_USER, static.DEFAULT_ENDPOINT_PASSWORD)
    result = client.queryAndConvert()

    if retFormat==JSON:
        result = jsonify(result)

    return result, MIME_FORMAT[retFormat] 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def askQuery(query):
    #print query
    try:
        sparql.setQuery(query)
        sparql.setReturnFormat(JSON)
        results = sparql.query().convert()
        #print str(results)
        for result in results:

            try:
                string = str(results[result])
                if "True" in string:
                    return "True"
            except:
                return "False"
    except:
        return "False"
        
    return "False" 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def selectQuery(query):
    array = []
    try:
        sparql.setQuery(query)
        sparql.setReturnFormat(JSON)
        results = sparql.query().convert()
        select_term = ""
        for result in results["head"]["vars"]:
            select_term = result
        for result in results["results"]["bindings"]:
            try:
                string1 = result[select_term]["value"]
                array.append(string1)
            except:
                #print "Unexpected error:", sys.exc_info()[0]
                pass
    except:
        pass
    return array 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def askQuery(query):
    #print query
    if es: sparql = es_sparql
    else:  sparql = en_sparql
    try:
        sparql.setQuery(query)
        sparql.setReturnFormat(JSON)
        results = sparql.query().convert()
        #print str(results)
        for result in results:

            try:
                string = str(results[result])
                if "True" in string:
                    return "True"
            except:
                return "False"
    except:
        return "False"
        
    return "False" 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def selectQuery(query):
    if es: sparql = es_sparql
    else:  sparql = en_sparql
    array = []
    try:
        sparql.setQuery(query)
        sparql.setReturnFormat(JSON)
        results = sparql.query().convert()
        select_term = ""
        for result in results["head"]["vars"]:
            select_term = result
        for result in results["results"]["bindings"]:
            try:
                string1 = result[select_term]["value"]
                array.append(string1)
            except:
                #print "Unexpected error:", sys.exc_info()[0]
                pass
    except:
        pass
    return array 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def askClassProperty(uri):
    sparql = SPARQLWrapper(endpoint)
    sparql.setQuery("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX owl: <http://www.w3.org/2002/07/owl#>  ASK WHERE {<"+uri+"> rdf:type owl:Class}")
    sparql.setReturnFormat(JSON)
    results = sparql.query().convert()
    #print results
    for result in results:
        try:
            string = str(results[result])
            if "False" in string:
                return False
            
            if "True" in string:
                return True
        except:
            pass
    return False 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def check_relation_range_type(relation,qType):
    return True
    sparql = SPARQLWrapper(wikidataSPARQL)
    sparql.setQuery("""
               PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
               ASK {<"""+relation+"""> rdfs:range <"""+qType+"""> }
            """)
    sparql.setReturnFormat(JSON)
    results1 = sparql.query().convert()
    if results1['boolean']:
        return True
    else:
        sparql.setQuery("""
               PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
               ASK {<"""+relation+"""> rdfs:range ?range. ?range rdfs:subClassOf ?t. ?t rdfs:subClassOf <"""+qType+""">}
            """)
        sparql.setReturnFormat(JSON)
        results2 = sparql.query().convert()
        if results2['boolean']:
            return True
        else:
            return False
    return results1['boolean']

#To split the surface forms in case of possessive forms 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def get_data(sparql_query):
    """ Gets data from Virtuoso """

    tries = 0
    max_tries = 5
    success = False
    while success is False and tries < max_tries:
        try:
            UNIPROT_SERVER.setQuery(sparql_query)
            UNIPROT_SERVER.setReturnFormat(JSON)
            UNIPROT_SERVER.setTimeout(60)
            result = UNIPROT_SERVER.query().convert()
            success = True
        except Exception as e:
            tries += 1
            result = e
            time.sleep(1)

    return result 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def query(self, qstr, is_update=False):
        sparql = self._get_sparql()
        if is_update:
            sparql.setMethod(POST)
        else:
            sparql.setMethod(GET)
        sparql.setReturnFormat(JSON)
        qstr = sparql_prefix + qstr
        sparql.setHTTPAuth
        sparql.setQuery(qstr)
        raw_res = sparql.query().convert()
        if sparql.queryType == SELECT:
            res = self._format_select_res(raw_res)
        elif sparql.queryType == INSERT:
            res = raw_res # TODO: Error handling here
        elif sparql.queryType == 'LOAD':
            res = raw_res # TODO: Error handling here
        else:
            res = raw_res
        return res 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def run_sparql(q):
    # TODO: select endpoint based on ontology
    #sparql = SPARQLWrapper("http://rdf.geneontology.org/sparql")
    logger.info("Connecting to sparql endpoint...")
    sparql = SPARQLWrapper("http://sparql.hegroup.org/sparql")
    logger.info("Made wrapper: {}".format(sparql))
    # TODO: iterate over large sets?
    full_q = q + ' LIMIT 250000'
    sparql.setQuery(q)
    sparql.setReturnFormat(JSON)
    logger.info("Query: {}".format(q))
    results = sparql.query().convert()
    bindings = results['results']['bindings']
    logger.info("Rows: {}".format(len(bindings)))
    for r in bindings:
        curiefy(r)
    return bindings 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def run_sparql_on(q, ontology):
    """
    Run a SPARQL query (q) on a given Ontology (Enum EOntology)
    """
    logger.info("Connecting to " + ontology.value + " SPARQL endpoint...")
    sparql = SPARQLWrapper(ontology.value)
    logger.info("Made wrapper: {}".format(sparql))
    sparql.setQuery(q)
    sparql.setReturnFormat(JSON)
    logger.info("Query: {}".format(q))
    results = sparql.query().convert()
    bindings = results['results']['bindings']
    logger.info("Rows: {}".format(len(bindings)))
    for r in bindings:
        curiefy(r)
    return bindings 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def run_sparql(q):
    # TODO: select endpoint based on ontology
    logger.info("Connecting to sparql endpoint...")
    sparql = SPARQLWrapper("http://query.wikidata.org/sparql")
    logger.info("Made wrapper: {}".format(sparql))
    # TODO: iterate over large sets?
    full_q = q + ' LIMIT ' + str(LIMIT)
    sparql.setQuery(q)
    sparql.setReturnFormat(JSON)
    logger.info("Query: {}".format(q))
    results = sparql.query().convert()
    bindings = results['results']['bindings']
    logger.info("Rows: {}".format(len(bindings)))
    for r in bindings:
        curiefy(r)
    return bindings 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def __init__(self, entities, config_file, dataset, endpoint, default_graph):

        self.entities = entities  # file containing a list of entities

        self.dataset = dataset

        self.wrapper = SPARQLWrapper(endpoint)

        self.wrapper.setReturnFormat(JSON)

        if default_graph:

            self.default_graph = default_graph

            self.wrapper.addDefaultGraph(self.default_graph)

        self.query_prop = "SELECT ?s ?o  WHERE {?s %s ?o. }"

        self.query_prop_uri = "SELECT ?s ?o  WHERE {?s %s ?o. FILTER (?s = %s)}"

        self._define_properties(config_file) 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def get_uri_from_wiki_id(wiki_id):

        sparql = SPARQLWrapper("http://dbpedia.org/sparql")

        sparql.setQuery("""select ?s where {?s <http://dbpedia.org/ontology/wikiPageID> %d
           }""" % int(wiki_id))

        sparql.setReturnFormat(JSON)

        try:
            uri = sparql.query().convert()['results']['bindings'][0]['s']['value']

        except:

            uri = None

        return uri 

# 需要导入模块: import SPARQLWrapper [as 别名]
# 或者: from SPARQLWrapper import JSON [as 别名]
def fetch_data(q, i):
    """
    Async call to DBpedia, making sparql queries
    to get the abstracts of entities of type 'Organisation'

    Arguments
    ---------
    q : query to be made
    i : request id
    """
    global final_pool
    print(f'INFO : sending request # {i + 1}')
    sparql.setQuery(q)
    sparql.setReturnFormat(JSON)
    results = sparql.query().convert()

    data = results['results']['bindings']
    final_pool = final_pool + data
    print(f'INFO : completed request # {i + 1}')