Python Graph.query方法代码示例

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
class SDOGraphSetupTestCase(unittest.TestCase):


  @classmethod
  def parseRDFaFilesWithRDFLib(self):
      """Parse data/*rdfa into a data object and an error object with rdflib.
      We glob so that work-in-progress schemas can be stored separately. For
      final publication, a single schema file is used."""
      
      from rdflib import Graph
      files = glob.glob("data/*.rdfa")
      log.info("Found %s files via data/*rdfa." % len(files))
      self.rdflib_errors = Graph()
      self.rdflib_data = Graph()
      for f in files:
        log.info("Files to parse: %s" % f )
        log.info("Parsing URL %s with rdflib RDFa parser. " % f)
        self.rdflib_data.parse(f, format='rdfa', pgraph=self.rdflib_errors)
        # log.info(self.rdflib_errors.serialize(format="nt"))

  @classmethod
  def setUpClass(self):
    log.info("Graph tests require rdflib.")
    import unittest
    try:
      import rdflib
      from rdflib import Graph
    except:
      raise unittest.SkipTest("Need rdflib installed to do graph tests.")

    read_schemas() # built-in parsers.
    self.schemasInitialized = schemasInitialized
    log.info("SDOGraphSetupTestCase reading schemas using built-in parsers.")

    log.info("Attempting to parse data/*rdfa with rdflib.")
    SDOGraphSetupTestCase.parseRDFaFilesWithRDFLib()

  def test_schemasInitializedForGraph(self):
    self.assertEqual(self.schemasInitialized,True, "Schemas should be initialized during setup, so we can load them into a graph for testing.")

  def test_rdflib_happy(self):
    self.assertEqual(len(self.rdflib_errors)==0, True, "rdflib should have zero errors. %s" % self.rdflib_errors.serialize(format="nt"))

  # SPARQLResult http://rdflib.readthedocs.org/en/latest/apidocs/rdflib.plugins.sparql.html
  # "A list of dicts (solution mappings) is returned"

  def test_found_sixplus_inverseOf(self):
    inverseOf_results = self.rdflib_data.query("select ?x ?y where { ?x <http://schema.org/inverseOf> ?y }")
    log.info("inverseOf result count: %s" % len(inverseOf_results ) )
    self.assertEqual(len(inverseOf_results ) >= 6, True, "Six or more inverseOf expected. Found: %s " % len(inverseOf_results ) )

  def test_even_number_inverseOf(self):
    inverseOf_results = self.rdflib_data.query("select ?x ?y where { ?x <http://schema.org/inverseOf> ?y }")
    self.assertEqual(len(inverseOf_results ) % 2 == 0, True, "Even number of inverseOf triples expected. Found: %s " % len(inverseOf_results ) )

  # These are place-holders for more sophisticated SPARQL-expressed checks.

  @unittest.expectedFailure
  def test_readSchemaFromRDFa(self):
    self.assertTrue(True, False, "We should know how to locally get /docs/schema_org_rdfa.html but this requires fixes to api.py.")

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
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)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
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)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
class AdvancedTests(unittest.TestCase):
    def setUp(self):
        memStore = plugin.get('IOMemory',Store)()
        self.testGraph = Graph(memStore)
        self.testGraph.parse(StringIO(testGraph1N3),format='n3')
        
    def testNamedGraph(self):
        # I am not sure this is the behaviour we DO want. 
        # see http://code.google.com/p/rdfextras/issues/detail?id=26
        OWL_NS = Namespace("http://www.w3.org/2002/07/owl#")
        rt =  self.testGraph.query(sparqlQ4)
        self.assertEquals(set(rt),set((x,) for x in [OWL_NS.DatatypeProperty, OWL_NS.ObjectProperty, OWL_NS.OntologyProperty,OWL_NS.Class,OWL_NS.Ontology,OWL_NS.AnnotationProperty,RDF.Property,RDFS.Class]))

    def testScopedBNodes(self):
        rt =  self.testGraph.query(sparqlQ1)
        self.assertEquals(list(rt)[0][0],URIRef("http://test/foo"))

    def testCollectionContentWithinAndWithout(self):
        rt =  self.testGraph.query(sparqlQ3)
        self.assertEquals(list(rt)[0][0],URIRef("http://test/bar"))

    def testCollectionAsObject(self):
        rt =  self.testGraph.query(sparqlQ2)
        self.assertEquals(list(rt)[0][0],URIRef("http://test/foo"))
        self.assertEquals(1,len(rt))

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def testcoverage(queries,filename):
    g = Graph()
    g.parse(filename, format="nt")   
    querystring = "select distinct ?s where {?s ?p ?o}" 
    allSubj = g.query(querystring)
    unique = set()
    total = 0
    
    for row in allSubj:
        s = row['s']
        if s not in unique:
            total = total +1
    
    print total
    
    subjects = set()
    
    for q in queries:
        print "Query: " + q
        results = g.query(q)       
        for row in results:
            subject = row['s']
            if subject not in subjects:
                subjects.add(subject)                
    
    coverage = len(subjects)/float(total)
    print len(subjects)
    print coverage
    
    return

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def create_manifest(srcdir, format):
    rdf_files = get_files(srcdir)
    manifest_hash = {"collection_name":extract_manifest_collection(rdf_files[0], format), "files":{}}

    total = len(rdf_files)
    sofar = 0

    for rdf in rdf_files:
        filename = os.path.basename(rdf)

        graph = Graph()
        graph.parse(rdf, format=format)

        res = graph.query(ITEM_QUERY)
        if len(res) == 0:
            print "No Item info found in rdf file ", filename
            exit()
        else:
            for row in res:
                entry = {"id":str(row[1]), "uri":str(row[0]), "docs":[]}
                break

        res = graph.query(DOCUMENT_QUERY)
        for row in res:
            entry["docs"].append({"identifier":str(row[1]), "source":str(row[2]), "type":str(row[0])})

        manifest_hash["files"][filename] = entry

        sofar = sofar + 1
        print "\033[2K   ", sofar, "of", total, os.path.basename(rdf), "\033[A"

    with open(os.path.join(srcdir, "manifest.json"), 'w') as outfile:
        json.dump(manifest_hash, outfile, indent=True)

    print "\033[2K   ", total, "files processed"

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
    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)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def buscar_transportes():
    g = Graph()

    # Carga el grafo RDF desde el fichero
    # Cambiar por RDF transportes
    # El fichero actual no esta en el mismo formato y no lo lee
    ontofile = gzip.open('../../TransportData/TransportRoutes.ttl.gz')
    g.parse(ontofile, format='turtle')

    # Consulta al grafo los aeropuertos dentro de la caja definida por las coordenadas
    qres = g.query(
        """
        prefix tio:<http://purl.org/tio/ns#>
        prefix geo:<http://www.w3.org/2003/01/geo/wgs84_pos#>
        prefix dbp:<http://dbpedia.org/ontology/>

        Select ?f
        where {
            ?f rdf:type dbp:Airport .
            ?f geo:lat ?lat .
            ?f geo:long ?lon .
            Filter ( ?lat < "41.7"^^xsd:float &&
                     ?lat > "41.0"^^xsd:float &&
                     ?lon < "2.3"^^xsd:float &&
                     ?lon > "2.0"^^xsd:float)
            }
        LIMIT 30
        """,
        initNs=dict(tio=TIO))

    # Recorre los resultados y se queda con el ultimo
    for r in qres:
        ap = r['f']

    print 'Aeropuerto:', ap
    print


    # Consulta todos los vuelos que conectan con ese aeropuerto
    airquery = """
        prefix tio:<http://purl.org/tio/ns#>
        Select *
        where {
            ?f rdf:type tio:Flight.
            ?f tio:to <%s>.
            ?f tio:from ?t.
            ?f tio:operatedBy ?o.
            }
        """ % ap

    qres = g.query(airquery, initNs=dict(tio=TIO))

    print 'Num Vuelos:', len(qres.result)
    print


    # Imprime los resultados
    for row in qres.result:
        print row    

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
    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)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def test_complex_sparql_construct():

    g = Graph()
    q = '''select ?subject ?study ?id where {
    ?s a <urn:Person>;
      <urn:partOf> ?c;
      <urn:hasParent> ?mother, ?father;
      <urn:id> [ a <urn:Identifier>; <urn:has-value> ?id].
    }'''
    g.query(q)

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
    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

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def rdfNamespaceProcessor(filename, fyle):
    g=Graph()
    g.parse(fyle ,format=rdflib.util.guess_format(filename))
    #print filename, str(len(g))
    #for ns in g.namespaces():
    #    print ns
    predicates = g.query("""SELECT DISTINCT ?p WHERE {?s ?p ?o}""")
    objects = g.query("""SELECT DISTINCT ?o WHERE {?s ?p ?o}""")
    po_list = [predicates,objects,g.namespaces()]
    #print po_list
    return po_list

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
class SPARQLStoreDBPediaTestCase(unittest.TestCase):
    store_name = 'SPARQLStore'
    path = "http://dbpedia.org/sparql"
    storetest = True
    create = False

    def setUp(self):
        self.graph = Graph(store="SPARQLStore")
        self.graph.open(self.path, create=self.create)
        ns = list(self.graph.namespaces())
        assert len(ns) > 0, ns

    def tearDown(self):
        self.graph.close()

    def test_Query(self):
        query = "select distinct ?Concept where {[] a ?Concept} LIMIT 1"
        res = self.graph.query(query, initNs={})
        for i in res:
            assert type(i[0]) == URIRef, i[0].n3()

    def test_initNs(self):
        query = """\
        SELECT ?label WHERE
            { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
        """
        res = self.graph.query(
            query,
            initNs={"xyzzy": "http://www.w3.org/2004/02/skos/core#"})
        for i in res:
            assert type(i[0]) == Literal, i[0].n3()

    def test_noinitNs(self):
        query = """\
        SELECT ?label WHERE
            { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
        """
        self.assertRaises(
            SPARQLWrapper.Wrapper.QueryBadFormed,
            self.graph.query,
            query)

    def test_query_with_added_prolog(self):
        prologue = """\
        PREFIX xyzzy: <http://www.w3.org/2004/02/skos/core#>
        """
        query = """\
        SELECT ?label WHERE
            { ?s a xyzzy:Concept ; xyzzy:prefLabel ?label . } LIMIT 10
        """
        res = self.graph.query(prologue + query)
        for i in res:
            assert type(i[0]) == Literal, i[0].n3()

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def fetch_triples(request, graph_uri, type, query_mapping):
    
    print graph_uri
    
    # Get the mapping
    #query_mapping = json.loads(open(SINDICE_CONFIG_MAPPING, 'r').read())
    
    # Create a new graph
    new_graph = Graph()
    
    # Bind namespaces to the graph
    for ns in namespaces_dict:
        new_graph.bind(ns, Namespace(namespaces_dict[ns]))
    
    if type in query_mapping:
        
        # Get the mapping for the particular type
        type_mapping = query_mapping[type]
        
        # Load the external graph
        external_graph = Graph()
        
        try:
            external_graph.load(URIRef(graph_uri))
        except:
            print "URI unreachable"
        
        for ns in namespaces_dict:
            external_graph.bind(ns, Namespace(namespaces_dict[ns    ]))
        
        # Iterate over the mappings
        for orig_uri in type_mapping:

            # Create a sparql query
            sparql_query = 'select * where { ?s ' + orig_uri +  ' ?o .}'
            
            # Convert the prefix version into a full URIRef
            new_uri_prefix = type_mapping[orig_uri].split(":")[0]
            if new_uri_prefix in namespaces_dict:
                new_uri = URIRef(type_mapping[orig_uri].replace(new_uri_prefix + ":", namespaces_dict[new_uri_prefix]))
                
            for row in external_graph.query(sparql_query):
                #print row
                new_graph.add((row.s, new_uri, row.o))
        
        # Get all triples from the new graph
        triple_list = list()
        spo_query = 'select * where {?s ?p ?o .}'
        for row in new_graph.query(spo_query):
            triple_list.append([row.s, row.p, row.o])
    
        return json.dumps({"triple_list": triple_list})

# 需要导入模块: from rdflib import Graph [as 别名]
# 或者: from rdflib.Graph import query [as 别名]
def test_count_distinct():
    g = Graph()

    g.parse(
        format="turtle",
        publicID="http://example.org/",
        data="""
    @prefix : <> .

    <#a>
      :knows <#b>, <#c> ;
      :age 42 .

    <#b>
      :knows <#a>, <#c> ;
      :age 36 .

    <#c>
      :knows <#b>, <#c> ;
      :age 20 .

    """,
    )

    # Query 1: people knowing someone younger
    results = g.query(
        """
    PREFIX : <http://example.org/>

    SELECT DISTINCT ?x {
      ?x :age ?ax ; :knows [ :age ?ay ].
      FILTER( ?ax > ?ay )
    }
    """
    )
    assert len(results) == 2

    # nQuery 2: count people knowing someone younger
    results = g.query(
        """
    PREFIX : <http://example.org/>

    SELECT (COUNT(DISTINCT ?x) as ?cx) {
      ?x :age ?ax ; :knows [ :age ?ay ].
      FILTER( ?ax > ?ay )
    }
    """
    )
    assert list(results)[0][0].toPython() == 2