def get_step_triples(update_graph, uri, step_def, debug=True): """ Return the triples matching the criteria defined in the current step of an update :param update_graph: the update graph :param uri: uri of the entity currently the subject of an update :param step_def: step definition from update_def :return: Graph containing one or more triples that match the criteria for the step """ from rdflib import Graph from vivopump import vivo_query, add_qualifiers, make_rdf_term if 'qualifier' not in step_def['object']: g = update_graph.triples((uri, step_def['predicate']['ref'], None)) else: q = 'select (?' + step_def['object']['name'] +' as ?o) where { <' + str(uri) + '> <' + \ str(step_def['predicate']['ref']) + '> ?' + step_def['object']['name'] + ' .\n' + \ add_qualifiers([step_def]) + ' }\n' if debug: print "\nStep Triples Query\n", q result_set = vivo_query(q) g = Graph() for binding in result_set['results']['bindings']: o = make_rdf_term(binding['o']) g.add((uri, step_def['predicate']['ref'], o)) if debug: print "Step Triples", len(g) return g
def test_uriref_case(self): from rdflib import URIRef input_dict = { "type": "uri", "value": "http://vivo.ufl.edu/individual/n531532305" } rdf_term = make_rdf_term(input_dict) print rdf_term self.assertTrue(type(rdf_term) is URIRef)
def _get_step_triples(self, uri, step_def): """ Return the triples matching the criteria defined in the current step of an update :param uri: uri of the entity currently the subject of an update :param step_def: step definition from update_def :return: Graph containing zero or more triples that match the criteria for the step """ from rdflib import Graph, RDF from vivopump import add_qualifiers, vivo_query, make_rdf_term def step_graph(uris, pred, otype=None, graph=self.update_graph): """ Given a list of uri, a pred and a type, return a graph of the update_graph triples satisfying uri pred any <- these are the returned triples any a type :param uris: list of uris. :param pred: the predicate to use in selecting triples for the step_graph :param otype: the object type to use. default in None, and no type selection will be done. :param graph: default is update_graph. Closure sieve requires original_graph :return: graph """ sg = Graph() for suri in uris: for obj in graph.objects(suri, pred): if otype is None: sg.add((suri, pred, obj)) elif (obj, RDF.type, otype) in self.update_graph: sg.add((suri, pred, obj)) return sg def sieve_triples(sgc, column_name): """ Given a step graph of triples from a closure (sgc), and the current column_name, select the triples from the closure graph that have a path from the entity_uri to one or more objects in the closure. If there is no path, return an empty graph. :param sgc: the step closure graph to be "sieved" :param column_name: the name of the column to use :return: the sieved closure graph """ print "\nBeginning Closure Graph for", column_name for (s, p, o) in sgc.triples((None, None, None)): print s, p, o if len(sgc) == 0: return sgc # Nothing to sieve else: pred = self.update_def['column_defs'][column_name][0]['predicate']['ref'] otype = self.update_def['column_defs'][column_name][0]['object'].get('type', None) sg = step_graph([self.entity_uri], pred, otype, graph=self.original_graph) if len(sg) == 0 or len(self.update_def['column_defs'][column_name]) == 1: return sg print "step 0 graph" for (s, p, o) in sg.triples((None, None, None)): print s, p, o for step in self.update_def['column_defs'][column_name][1:]: sg = step_graph([y for y in sg.objects(None, None)], step['predicate']['ref'], step['object'].get('type', None), graph=self.original_graph) print "next step graph" for (s, p, o) in sg.triples((None, None, None)): print s, p, o if len(sg) == 0: return sg # column path is empty, so nothing in the closure can match # Wait for it .... Here's the sieve. Return triples in the closure graph that have # objects on the column graph sgr = Graph() for (sgcs, sgcp, sgco) in sgc.triples((None, None, None)): if sgco in sg.objects(None, None): sgr.add((sgcs, sgcp, sgco)) print "reduced step graph" for (s, p, o) in sgr.triples((None, None, None)): print s, p, o return sgr if 'qualifier' not in step_def['object']: g = step_graph([uri], step_def['predicate']['ref'], step_def['object'].get('type', None)) # print "\nStep_triples for", step_def['column_name'], [uri], # step_def['predicate']['ref'], step_def['object'].get('type', None) for (s, p, o) in g.triples((None, None, None)): print unicode(s), unicode(p), unicode(o) # If the step_def is in a closure, and its the last step in the closure, then the # closure triples must be sieved against the objects defined by the column. if step_def['closure'] and step_def['last']: g = sieve_triples(g, step_def['column_name']) else: # Handle non-specific predicates qualified by SPARQL (a rare case for VIVO-ISF) q = 'select (?' + step_def['object']['name'] + ' as ?o) where { <' + str(uri) + '> <' + \ str(step_def['predicate']['ref']) + '> ?' + step_def['object']['name'] + ' . \n' + \ add_qualifiers([step_def]) + ' }\n' logger.debug(u"Qualified Step Triples Query {}".format(q)) result_set = vivo_query(q, self.query_parms) # SLOW g = Graph() for binding in result_set['results']['bindings']: o = make_rdf_term(binding['o']) g.add((uri, step_def['predicate']['ref'], o)) logger.debug(u"Step Triples {}".format(g.serialize(format='nt'))) return g