def refine_metadata(specs): # GENERATE GENERIC METADATA metadata = Gn.linkset_refined_metadata(specs) if int(specs[St.triples]) > 0: # print metadata is_inserted = Qry.boolean_endpoint_response(metadata["query"]) print ">>> THE METADATA IS SUCCESSFULLY INSERTED:", is_inserted # GENERATE LINKSET CONSTRUCT QUERY construct_query = "\n{}\n{}\n{}\n{}\n{}\n".format( "PREFIX predicate: <{}>".format(Ns.alivocab), "PREFIX src{}: <{}>".format(specs[St.source][St.graph_name], specs[St.source][St.graph_ns]), "PREFIX trg{}: <{}>".format(specs[St.target][St.graph_name], specs[St.target][St.graph_ns]), "construct { ?x ?y ?z }", "where {{ graph <{}> {{ ?x ?y ?z }} }}".format( specs[St.refined]), ) # GENERATE LINKSET SINGLETON METADATA QUERY singleton_metadata_query = "\n{}\n{}\n{}\n{}\n{}\n{}\n\n".format( "PREFIX singMetadata: <{}>".format(Ns.singletons), "PREFIX predicate: <{}>".format(Ns.alivocab), "PREFIX prov: <{}>".format(Ns.prov), "PREFIX rdf: <{}>".format(Ns.rdf), "construct { ?x ?y ?z }", "where {{ graph <{}> {{ ?x ?y ?z }} }}".format( specs[St.singleton]), ) # GET THE CORRESPONDENCES INSERTED USING A THE CONSTRUCT QUERY singleton_construct = Qry.endpointconstruct(singleton_metadata_query) if singleton_construct is not None: singleton_construct = \ singleton_construct.replace('{', "singMetadata:{}\n{{".format(specs[St.refined_name]), 1) # GET THE SINGLETON METADATA USING THE CONSTRUCT QUERY construct_response = Qry.endpointconstruct(construct_query) if construct_response is not None: construct_response = construct_response.replace( '{', "<{}>\n{{".format(specs[St.refined]), 1) # WRITE TO FILE print "\t>>> WRITING THE METADATA YO FILE TO FILE" write_to_file(graph_name=specs[St.refined_name], metadata=metadata["query"].replace("INSERT DATA", ""), correspondences=construct_response, singletons=singleton_construct, directory=DIRECTORY) return metadata["message"]
def export_flat_alignment_service(alignment): alignment = str(alignment).strip() row_alignment = alignment alignment = alignment if Ut.is_nt_format( alignment) is True else "<{}>".format(alignment) # CONSTRUCT QUERY query = """ PREFIX ll: <{0}> PREFIX linkset: <{1}> PREFIX lens: <{2}> PREFIX singletons: <{3}> CONSTRUCT {{ ?srcCorr ll:mySameAs ?trgCorr . ?trgCorr ll:mySameAs ?srcCorr . }} WHERE {{ BIND( {4} as ?alignment ) # THE ALIGNMENT GRAPH WITH EXPLICIT SYMMETRY GRAPH ?alignment {{ ?srcCorr ?singleton ?trgCorr . }} }} ; CONSTRUCT {{ ?alignment ?pred ?obj . ?obj ?predicate ?object . }} WHERE {{ # THE METADATA BIND( {4} as ?alignment ) ?alignment ?pred ?obj . OPTIONAL {{ ?obj ?predicate ?object . }} }} """.format( Ns.alivocab, Ns.linkset, Ns.lens, Ns.singletons, alignment, ) print query exit(0) # FIRE THE CONSTRUCT AGAINST THE TRIPLE STORE alignment_construct = Qry.endpointconstruct(query) # REMOVE EMPTY LINES triples = len(regex.findall('ll:mySameAs', alignment_construct)) alignment_construct = "\n".join( [line for line in alignment_construct.splitlines() if line.strip()]) result = "### TRIPLE COUNT: {}\n### LINKSET: {}\n".format( triples, alignment) + alignment_construct message = "You have just downloaded the graph [{}] which contains [{}] correspondences. ".format( row_alignment, triples) return {'result': result, 'message': message}
def export_flat_alignment_and_metadata(alignment): flat = export_flat_alignment(alignment) alignment = str(alignment).strip() row_alignment = alignment alignment = alignment if Ut.is_nt_format( alignment) is True else "<{}>".format(alignment) # CONSTRUCT QUERY query = """ PREFIX ll: <{0}> PREFIX linkset: <{1}> PREFIX lens: <{2}> PREFIX singletons: <{3}> CONSTRUCT {{ ?alignment ?pred ?obj . ?obj ?predicate ?object . }} WHERE {{ BIND ({4} AS ?alignment) # THE METADATA ?alignment ?pred ?obj . OPTIONAL {{ ?obj ?predicate ?object . }} }} #LIMIT 10 """.format(Ns.alivocab, Ns.linkset, Ns.lens, Ns.singletons, alignment) # print query # FIRE THE CONSTRUCT AGAINST THE TRIPLE STORE alignment_construct = Qry.endpointconstruct(query, clean=False) # REMOVE EMPTY LINES triples = flat["triples"] # triples = len(re.findall('ll:mySameAs', alignment_construct)) alignment_construct = "\n".join([line for line in alignment_construct.splitlines() if line.strip()]) + "\n\n" + \ flat['result'] result = "### GENERIC METADATA FOR \n### LINKSET: {}\n\n{}".format( alignment, alignment_construct) message = "You have just downloaded the graph [{}] which contains [{}] correspondences. ".format( row_alignment, triples) print result return {'result': result, 'message': message}
def export_flat_alignment(alignment): print Ut.headings("EXPORTING THE ALIGNMENT WITH NO METADATA") print "Export for: {}".format(alignment) alignment = str(alignment).strip() row_alignment = alignment alignment = alignment if Ut.is_nt_format( alignment) is True else "<{}>".format(alignment) # CONSTRUCT QUERY query = """ PREFIX ll: <{}> CONSTRUCT {{ ?x ll:mySameAs ?z }} WHERE {{ GRAPH {} {{ ?x ?y ?z }} }} order by ?x """.format(Ns.alivocab, alignment) # print query # FIRE THE CONSTRUCT AGAINST THE TRIPLE STORE alignment_construct = Qry.endpointconstruct(query) # REMOVE EMPTY LINES # COMMA IS COUNTED WHENEVER THERE ARE MORE OBJECTS FOR THE SUBJECT triples = len(regex.findall('ll:mySameAs', alignment_construct)) + len( regex.findall(',', alignment_construct)) alignment_construct = "\n".join( [line for line in alignment_construct.splitlines() if line.strip()]) alignment_construct = alignment_construct.replace( "{", "{}\n{{".format(alignment)) # RESULTS result = "### TRIPLE COUNT: {0}\n### LINKSET: {1}\n".format( triples, alignment) + alignment_construct message = "You have just downloaded the graph [{}] which contains [{}] correspondences. ".format( row_alignment, triples) return {'result': result, 'message': message, "triples": triples}
def linkset_evolution_composition(alignment_mapping): question_uri = alignment_mapping[St.researchQ_URI] linkset_uri = alignment_mapping[ St.refined] if St.refined in alignment_mapping else alignment_mapping[ St.linkset] # 1.1 GET THE LINKSET ALIGNMENT alignment_query = PREFIX + """ construct {{ <{1}> a <http://risis.eu/class/AlignmentMapping> ; alivocab:alignsSubjects ?srcAligns ; alivocab:alignsObjects ?trgAligns ; alivocab:alignsMechanism ?mechanism . }} where {{ #BIND(iri(replace('http://risis.eu/activity/idea_algmt_#','#',SUBSTR(str(uuid()), 40))) as ?alignmentMapping) <{1}> alivocab:alignsSubjects ?alignsSubjects ; alivocab:alignsObjects ?alignsObjects ; alivocab:alignsMechanism ?alignsMechanism . bind( str( ?alignsSubjects) as ?srcAligns ) bind( str( ?alignsObjects ) as ?trgAligns ) bind( str( ?alignsMechanism) as ?mechanism ) }} """.format(question_uri, linkset_uri) construct = Qry.endpointconstruct(alignment_query) # print construct composition = re.findall('{.*a <.*?> ;(.*)}', construct, re.S) if composition: return composition[0] return None
def spa_linkset_subset(specs, activated=False): if activated is True: check = Ls.run_checks(specs, check_type="subset") if check[St.result] != "GOOD TO GO": return check # THE LINKSET DOES NOT EXIT, LETS CREATE IT NOW print Ls.linkset_info(specs, specs[St.sameAsCount]) ########################################################## """ 1. GENERATE SUBSET LINKSET INSERT QUERY """ ########################################################## insert_query = spa_subset_insert(specs) # print insert_query ############################################################# """ 2. EXECUTING INSERT SUBSET LINKSET QUERY AT ENDPOINT """ ############################################################# Qry.endpoint(insert_query) ############################################################# """ 3. LINKSET SIZE (NUMBER OF TRIPLES) """ ############################################################# # LINKSET SIZE (NUMBER OF TRIPLES) specs[St.triples] = Qry.get_namedgraph_size(specs[St.linkset]) print "\t>>> {} TRIPLES INSERTED".format(specs[St.triples]) # NO MATCH FOUND if specs[St.triples] == "0": # logger.warning("WE DID NOT INSERT A METADATA AS NO TRIPLE WAS INSERTED.") print "WE DID NOT INSERT A METADATA AS NO TRIPLE WAS INSERTED." specs[St.insert_query] = insert_query # metadata = spa_subset_metadata(source, target, data, size) explain_q = "ask {{ GRAPH <{}> {{ ?s <{}> ?o }} }}".format( specs[St.linkset], specs[St.source][St.link_old]) response = Qry.boolean_endpoint_response(explain_q) explain = True if response == "true" else False # print explain if explain is False: # logger.warning("{} DOES NOT EXIST IS {}.".format(data[St.link_old], source[St.graph])) print "{} DOES NOT EXIST IS {}.".format( specs[St.source][St.link_old], specs[St.source][St.graph]) message = "{} DOES NOT EXIST IS {}.".format( specs[St.source][St.link_old], specs[St.source][St.graph]) return {St.message: message, St.error_code: 1, St.result: None} # SOME MATCHES WHERE FOUND construct_query = "\n{}\n{}\n{}\n".format( "PREFIX predicate: <{}>".format(Ns.alivocab), "construct { ?x ?y ?z }", "where {{ graph <{}> {{ ?x ?y ?z }} }}".format( specs[St.linkset]), ) # print construct_query construct_response = Qry.endpointconstruct(construct_query) if construct_response is not None: construct_response = construct_response.replace( '{', "<{}>\n{{".format(specs[St.linkset]), 1) # GENERATE LINKSET SINGLETON METADATA QUERY singleton_metadata_query = "\n{}\n{}\n{}\n{}\n{}\n{}\n\n".format( "PREFIX singMetadata: <{}>".format(Ns.singletons), "PREFIX predicate: <{}>".format(Ns.alivocab), "PREFIX prov: <{}>".format(Ns.prov), "PREFIX rdf: <{}>".format(Ns.rdf), "construct { ?x ?y ?z }", "where {{ graph <{}{}> {{ ?x ?y ?z }} }}".format( Ns.singletons, specs[St.linkset_name]), ) # GET THE SINGLETON METADATA USING THE CONSTRUCT QUERY singleton_construct = Qry.endpointconstruct(singleton_metadata_query) if singleton_construct is not None: singleton_construct = singleton_construct.replace( '{', "singMetadata:{}\n{{".format(specs[St.linkset_name]), 1) ############################################################# """ 4. LINKSET METADATA """ ############################################################# # METADATA specs[St.insert_query] = insert_query metadata = Gn.spa_subset_metadata(specs) ############################################################### """ 5. EXECUTING INSERT LINKSET METADATA QUERY AT ENDPOINT """ ############################################################### # EXECUTING METADATA QUERY AT ENDPOINT Qry.endpoint(metadata) print "\t>>> WRITING TO FILE" write_to_file(graph_name=specs[St.linkset_name], metadata=metadata.replace("INSERT DATA", ""), correspondences=construct_response, singletons=singleton_construct, directory=DIRECTORY) print "\tLinkset created as [SUBSET]: ", specs[St.linkset] print "\t*** JOB DONE! ***" message = "The linkset was created as [{}] with {} triples found!".format( specs[St.linkset], specs[St.triples]) return { St.message: message, St.error_code: 0, St.result: specs[St.linkset] }
def linkset_composition(alignment_mapping, request_ask_select_or_insert="ask", get_composition=False): question_uri = alignment_mapping[St.researchQ_URI] linkset_uri = alignment_mapping[ St.refined] if St.refined in alignment_mapping else alignment_mapping[ St.linkset] # 1.1 GET THE LINKSET ALIGNMENT linkset_alignment_query = get_linkset_alignment(question_uri, linkset_uri) # print "ALIGNMENT QUERY:", linkset_alignment_query construct = Qry.endpointconstruct(linkset_alignment_query) # print "CONSTRUCT:", construct composition_init = re.findall('{(.*\)).*<.*> a <.*?> ;.*}', construct, re.S) if len(composition_init) > 0: composition_init = composition_init[0] else: composition_init = "" # print "COMPOSITION BINDINGS:", composition_init composition = re.findall('{.*a <.*?> ;(.*)}', construct, re.S) if get_composition: return composition[0] if len(composition) == 0: # INSPECT linkset_alignment_query = get_linkset_alignment(question_uri, linkset_uri) # print "construct", construct print "\tcomposition:", type(composition), len( composition), composition print "\tTHE LINKSET <{}> DOES NOT EXIST".format(linkset_uri) print linkset_alignment_query return None composition_str = composition[0] composition_str = composition_str.replace("\t\t", "\t\t\t\t") # print "COMPOSITION STRING EXTRACTED:", composition_str ask = "ASK" where = "" if request_ask_select_or_insert.upper() == "SELECT *": ask = "SELECT " elif request_ask_select_or_insert.upper() == "INSERT": ask = "INSERT" where = """ WHERE {{ {} BIND(iri(replace('http://risis.eu/activity/idea_algmt_#','#',SUBSTR(str(uuid()), 40))) as ?alignmentMapping) }}""".format(composition_init) # SO THAT IT IS NOT INSERTED MORE THAN ONES composition_init = "" # 1.2 CHECK WHETHER THE ALIGNMENT WAS REGISTERED query = PREFIX + """ {0} {{ {4} GRAPH <{1}> {{ <{1}> alivocab:created ?alignmentMapping . ?alignmentMapping a <http://risis.eu/class/AlignmentMapping> ;{2}\t\t\t\t###@SLOT\n\t\t}} }} {3}""".format(ask, question_uri, composition_str, where, composition_init) if ask: return query
def writelinkset(source, target, linkset_graph_name, outputs_path, metadata_triples, check_file=False): # print "CALL A CONSTRUCT ON: {}".format(linkset_graph_name) linkset_query = "\n{}\n{}\n{}\n{}\n\n{}\n{}\n\n".format( "PREFIX linkset: <{}>".format(Ns.linkset), "PREFIX {}: <{}>".format(source[0], source[2]), "PREFIX predicate: <{}>".format(Ns.alivocab), "" if source[0] == target[0] else "PREFIX {}: <{}>".format( target[0], target[2]), "construct { ?x ?y ?z }", "where {{ graph linkset:{} {{ ?x ?y ?z }} }}".format( linkset_graph_name), ) # print linkset_query singleton_metadata_query = "\n{}\n{}\n{}\n{}\n\n{}\n{}\n{}\n\n".format( "PREFIX singMetadata: <{}>".format(Ns.singletons), "PREFIX predicate: <{}>".format(Ns.alivocab), "PREFIX rdf: <{}>".format(Ns.rdf), "PREFIX {}: <{}>".format(source[0], source[2]), "" if source[0] == target[0] else "PREFIX {}: <{}>".format( target[0], target[2]), "construct { ?x ?y ?z }", "where {{ graph <{}{}> {{ ?x ?y ?z }} }}".format( Ns.singletons, linkset_graph_name), ) # print singleton_metadata_query """ 1. RUN SPARQL CONSTRUCT QUERIES AGAINST ENDPOINT """ linkset_construct = Qry.endpointconstruct(linkset_query) if linkset_construct is not None: linkset_construct = to_unicode( linkset_construct.replace( '{', "linkset:{}\n{{".format(linkset_graph_name), 1)) singleton_metadata_construct = Qry.endpointconstruct( singleton_metadata_query) if singleton_metadata_construct is not None: singleton_metadata_construct = singleton_metadata_construct.\ replace('{', "singMetadata:{}\n{{".format(linkset_graph_name), 1) """ 2. FILE NAME SETTINGS """ date = datetime.date.isoformat(datetime.date.today()).replace('-', '') dir_name = outputs_path # os.path.dirname(f_path) linkset_file = "{}(Linksets)-{}.trig".format(linkset_graph_name, date) metadata_file = "{}(Metadata)-{}.trig".format(linkset_graph_name, date) singleton_metadata_file = "{}(SingletonMetadata)-{}.trig".format( linkset_graph_name, date) dir_name = dir_name.replace("\\", "/") linkset_output = "{}/{}".format(dir_name, linkset_file) metadata_output = "{}/{}".format(dir_name, metadata_file) singleton_metadata_output = "{}/{}".format(dir_name, singleton_metadata_file) try: if not os.path.exists(dir_name): os.makedirs(dir_name) except OSError as err: print "\n\t[__init__ in RDF]", err return # print "output file is :\n\t{}".format(output_path) """ 3. WRITE LINKSET TO FILE """ linkset_disc = codecs.open(linkset_output, "wb", "utf-8") if linkset_construct is not None: linkset_disc.write(linkset_construct) linkset_disc.close() """ 4. WRITE METADATA TO FILE """ metadata_disc = codecs.open(metadata_output, "wb", "utf-8") metadata_disc.write(metadata_triples.replace("INSERT DATA", "") + "\n\n") metadata_disc.close() """ 5. WRITE SINGLETON METADATA TO FILE """ sing_metadata_disc = codecs.open(singleton_metadata_output, "wb", "utf-8") if singleton_metadata_construct is not None: sing_metadata_disc.write( to_unicode(singleton_metadata_construct) + "\n\n") sing_metadata_disc.close() if check_file is True: """ 6. CHECK THE WRITTEN FILES """ check_rdf_file(linkset_output) if metadata_triples.__contains__("INSERT") is not True: check_rdf_file(metadata_output) else: print "\nTHE GENERIC METADATA IS NIT CHECKED AS IT IS AN INSERTION\n" check_rdf_file(singleton_metadata_output)
def lens_transitive(specs, activated=False): # CHECK BOTH DATASETS FOR SAME MECHANISM print "GENERATE THE LENS NAME" Lu.composition_lens_name(specs) print "GET THE SAME AS COUNT" specs[St.sameAsCount] = Qry.get_same_as_count(specs[St.lens_operation]) # print same_as_count # GENERATE THE INSERT QUERY FOR TRANSITIVITY # transitive_analyses = lens_transitive_query(specs) # if transitive_analyses is None: # return # specs[St.insert_query] = transitive_analyses[1] # print insert_query # exit(0) # specs['is_transitive_by'] = transitive_analyses[0] ln = get_uri_local_name(specs[St.lens]) sg = specs[St.subjectsTarget] tg = specs[St.objectsTarget] ssg = "{}{}".format(Ns.singletons, get_uri_local_name(sg)) tsg = "{}{}".format(Ns.singletons, get_uri_local_name(tg)) print "SOURCE: {}".format(sg) print "TARGET: {}".format(tg) print "1. GENERATING THE INSERT QUERY" specs[St.insert_query] = transitive_insert_query(ln, sg, tg, ssg, tsg) if activated is True: # RUN THE QUERY AT THE END POINT print "2. RUNNING THE INSERT QUERY" Qry.boolean_endpoint_response(specs[St.insert_query]) # GET THE SIZE OF THE LENS JUST CREATED ABOVE print "3. ETTING THE SIZE OF THE LENS JUST INSERTED" size = Qry.get_namedgraph_size(specs[St.lens], isdistinct=False) # IF ACTIVATED, INSERT THE METADATA if size > 0: # GENERATE THE METADATA ABOUT THE LENS JUST CREATED print "4. SOME {} TRANSITIVE TRIPLES WERE FOUND".format(size) metadata = transitive_metadata(specs, size) # print metadata print "5. INSERTING THE METADATA" Qry.boolean_endpoint_response(metadata) print "6. REGISTER THE LENS" Urq.register_lens(specs, is_created=True) # RUN A CORRESPONDENCE CONSTRUCT QUERY FOR BACKING UP THE DATA TO DISC print "7. GENERATE THE CONSTRUCT FOR FILE DUMP" construct_correspondence = Qry.endpointconstruct( Qry.construct_namedgraph(specs[St.lens])) if construct_correspondence is not None: construct_correspondence = construct_correspondence.replace( '{', "<{}>\n{{".format(specs[St.lens]), 1) # RUN A SINGLETON METADATA CONSTRUCT QUERY FOR BACKING UP THE DATA TO DISC construct_singletons = Qry.endpointconstruct( Qry.construct_namedgraph("{}{}".format(Ns.singletons, specs[St.lens_name]))) if construct_singletons is not None: construct_singletons = construct_singletons. \ replace('{', "<{}{}>\n{{".format(Ns.singletons, specs[St.lens_name]), 1) # WRITE TO FILE print "WRITING TO FILE" write_to_file(graph_name=ln, metadata=metadata, directory=DIRECTORY, correspondences=construct_correspondence, singletons=construct_singletons) # return specs[St.lens] message = "THE LENS WAS CREATED!<br/>URI = {}".format( specs[St.lens]) print message print "\t*** JOB DONE! ***" return { St.message: message, St.error_code: 0, St.result: specs[St.lens] } if activated is False: logger.warning( "THE FUNCTION IS NOT ACTIVATED BUT THE METADATA THAT IS " "SUPPOSED TO BE ENTERED IS WRITEN TO THE CONSOLE.")
def export_alignment(alignment, limit=5000): # COMMENT THE LINKSET IF IT IS EQUAL TO NONE # This function returns all the links + some metadata about the alignment. # METADATA: source dataset, target dataset and mechanism use = alignment alignment = str(alignment).strip() row_alignment = alignment alignment = alignment if Ut.is_nt_format( alignment) is True else "<{}>".format(alignment) src_dataset = None trg_dataset = None lens_targets = [] mec_dataset = None rdf_type = None # GET THE METADATA OF THE ALIGNMENT: THE QUERY meta = """ PREFIX ll: <{0}> CONSTRUCT {{ {1} ?y ?z. ?z ?p ?o . }} WHERE {{ {1} ?y ?z . #?z ?p ?o . }} order by ?y """.format(Ns.alivocab, alignment) # print meta # GET THE METADATA OF THE ALIGNMENT: RUN THE QUERY meta_construct = Qry.endpointconstruct(meta, clean=False) meta_construct = meta_construct.replace("{", "").replace("}", "") # print meta_construct # LOAD THE METADATA USING RDFLIB sg = rdflib.Graph() sg.parse(data=meta_construct, format="turtle") # EXTRACT FROM THE RESPONSE: THE SOURCE AND TARGET DATASETS AND THE ALIGNMENT sbj = rdflib.URIRef(use) source = rdflib.URIRef("http://rdfs.org/ns/void#subjectsTarget") target = rdflib.URIRef("http://rdfs.org/ns/void#objectsTarget") lens_uri_targets = rdflib.URIRef("http://rdfs.org/ns/void#target") rdf_uri_type = rdflib.URIRef( "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") mechanism = rdflib.URIRef( "http://risis.eu/alignment/predicate/alignsMechanism") # EXTRACT THE ALIGNMENT TYPE for item in sg.objects(sbj, rdf_uri_type): rdf_type = item print "TYPE: ", rdf_type if str(rdf_type) == Ns.lens_type: # EXTRACT THE SOURCE DATASET for item in sg.objects(sbj, lens_uri_targets): lens_targets += [str(item)] print "{} TARGETS in {}".format(len(lens_targets), alignment) for trg_item in lens_targets: print "\t- {}".format(trg_item) else: # EXTRACT THE SOURCE DATASET for item in sg.objects(sbj, source): src_dataset = item # EXTRACT THE TARGET DATASET for item in sg.objects(sbj, target): trg_dataset = item # EXTRACT THE MECHANISM USED FOR THIS ALIGNMENT for item in sg.objects(sbj, mechanism): mec_dataset = item # CONSTRUCT QUERY FOR EXTRACTING HE CORRESPONDENCES comment = "" if limit else "#" query = """ PREFIX ll: <{}> CONSTRUCT {{ ?x ?y ?z }} WHERE {{ GRAPH {} {{ ?x ?y ?z }} }} order by ?x {}LIMIT {} """.format(Ns.alivocab, alignment, comment, limit) # print query # FIRE THE CONSTRUCT FOR CORRESPONDENCES AGAINST THE TRIPLE STORE alignment_construct = Qry.endpointconstruct(query, clean=False) triples = 0 links = None # RESULTS if alignment_construct is not None: links = "### TRIPLE COUNT: {}\n### LINKSET: {}\n".format( triples, alignment) + alignment_construct links = links.replace("{", "").replace("}", "") message = "You have just downloaded the graph [{}] which contains [{}] correspondences. ".format( row_alignment, triples) # result = result # print result print "Done with graph: {}".format(alignment) return { "type": rdf_type, 'result': links, 'message': message, 'source': src_dataset, "target": trg_dataset, "lens_targets": lens_targets, 'mechanism': mec_dataset }
def export_alignment_all(alignment, directory=None, limit=5000): directory = os.path.join(directory, "") print directory if os.path.isdir(os.path.dirname(directory)) is False or os.path.exists( directory) is False: print "CREATING THE DIRECTORY" os.mkdir(os.path.dirname(directory)) # COMMENT THE LINKSET OIT IF IT IS EQUAL TO NONE # This function returns all the links + some metadata about the alignment. # METADATA: source dataset, target dataset and mechanism use = alignment alignment = str(alignment).strip() row_alignment = alignment alignment = alignment if Ut.is_nt_format( alignment) is True else "<{}>".format(alignment) # **************************************************** # 1. GET THE METADATA OF THE ALIGNMENT: THE QUERY # **************************************************** meta = """ PREFIX ll: <{0}> CONSTRUCT {{ {1} ?y ?z. ?z ?p ?o . }} WHERE {{ {1} ?y ?z . OPTIONAL{{ ?z ?p ?o . }} OPTIONAL{{ ?O ?Q ?R . }} }} order by ?y """.format(Ns.alivocab, alignment) # print meta # GET THE METADATA OF THE ALIGNMENT: RUN THE QUERY meta_construct = Qry.endpointconstruct(meta, clean=False) meta_construct = meta_construct.replace("{", "").replace("}", "") with open(os.path.join(directory, "metadata.ttl"), "wb") as metadata: metadata.write(meta_construct) # print meta_construct # **************************************************** # 2. GET THE CORRESPONDENCES OF THE LINKSET # **************************************************** # CONSTRUCT QUERY FOR EXTRACTING HE CORRESPONDENCES comment = "" if limit else "#" query = """ PREFIX ll: <{}> CONSTRUCT {{ ?x ?y ?z }} WHERE {{ GRAPH {} {{ ?x ?y ?z }} }} order by ?x {}LIMIT {} """.format(Ns.alivocab, alignment, comment, limit) # print query # FIRE THE CONSTRUCT FOR CORRESPONDENCES AGAINST THE TRIPLE STORE alignment_construct = Qry.endpointconstruct(query, clean=False) if alignment_construct: alignment_construct = alignment_construct.replace( "{", "{}\n{{".format(alignment)) # print alignment_construct with open(os.path.join(directory, "linkset.trig"), "wb") as links: links.write(alignment_construct) # **************************************************** # 3. GET THE METADATA CORRESPONDENCES' PREDICATES # **************************************************** singleton_graph_uri = Ut.from_alignment2singleton(alignment) singleton_query = """ PREFIX ll: <{0}> PREFIX singletons: <{1}> CONSTRUCT {{ ?predicate ?x ?y }} WHERE {{ {{ SELECT ?predicate {{ GRAPH {2} {{ ?subject ?predicate ?object }} }} order by ?x {3}LIMIT {4} }} GRAPH {5} {{ ?predicate ?x ?y }} }} """.format(Ns.alivocab, Ns.singletons, alignment, comment, limit, singleton_graph_uri) # print singleton_query # FIRE THE CONSTRUCT FOR SINGLETON AGAINST THE TRIPLE STORE singleton_construct = Qry.endpointconstruct(singleton_query, clean=False) if singleton_construct: singleton_construct = singleton_construct.replace( "{", "{}\n{{".format(singleton_graph_uri)) # print singleton_construct with open(os.path.join(directory, "singletons.trig"), "wb") as singletons: singletons.write(singleton_construct) # LOAD THE METADATA USING RDFLIB sg = rdflib.Graph() sg.parse(data=meta_construct, format="turtle") # EXTRACT FROM THE RESPONSE: THE SOURCE AND TARGET DATASETS AND THE ALIGNMENT sbj = rdflib.URIRef(use) triples_uri = rdflib.URIRef("http://rdfs.org/ns/void#triples") # EXTRACT THE ALIGNMENT TYPE triples = "" for item in sg.objects(sbj, triples_uri): triples = item print "TRIPLES: ", triples if alignment_construct is not None: links = "### TRIPLE COUNT: {}\n### LINKSET: {}\n".format( triples, alignment) + alignment_construct links = links.replace("{", "").replace("}", "") message = "You have just downloaded the graph [{}] which contains [{}] correspondences. ".format( row_alignment, triples) host = Svr.settings[St.stardog_host_name] endpoint = b"http://{}/annex/{}/sparql/query?".format( host, Svr.settings[St.database]) local_name = Ut.get_uri_local_name_plus(alignment) file_at_parent_directory = os.path.join( os.path.abspath(os.path.join(directory, os.pardir)), "{}.zip".format(local_name)) zipped_file = Ut.zip_folder(directory, output_file_path=file_at_parent_directory) print "\t>>> THE ZIPPED FILE IS LOCATED AT:\n\t\t- {}".format(zipped_file) # result = result # print result print "Done with graph: {}".format(alignment) # return {'result': { # "generic_metadata": meta_construct, # 'specific_metadata': singleton_construct, # 'data': alignment_construct}, 'message': message} return {'result': zipped_file, 'message': message}
def difference(specs, save=False, activated=False): # print "LINKSET FUNCTION ACTIVATED: {}".format(activated) if activated is False: print "THE FUNCTION IS NOT ACTIVATED" \ "\n======================================================" \ "========================================================" return {St.message: "THE FUNCTION IS NOT ACTIVATED.", St.error_code: 1, St.result: None} else: print "COMPUTING THE DIFFERENCE BETWEEN:\n\t{}\n\t{}".format(specs[St.subjectsTarget], specs[St.objectsTarget]) Lu.diff_lens_name(specs) # GENERATE THE LINKSET OF THE DIFFERENCE diff_insert_query = """ PREFIX prov: <{0}> PREFIX specific:<{8}> ### Difference between ### <{1}> and ### <{2}> INSERT {{ GRAPH <{3}> {{ ?subject ?newSingletons ?object . }} GRAPH specific:{9} {{ ?newSingletons prov:wasDerivedFrom ?predicate1 . ?predicate1 ?pre ?obj . }} }} WHERE {{ {{ GRAPH <{4}> {{ ?subject ?predicate1 ?object . bind( iri(replace("{5}{6}_#", "#", strafter(str(uuid()), "uuid:") )) as ?newSingletons ) }} GRAPH ?g {{ ?predicate1 ?pre ?obj . }} }} MINUS {{ GRAPH <{7}> {{ ?subject ?predicate2 ?object . }} }} }} """.format(Ns.prov, specs[St.subjectsTarget], specs[St.objectsTarget], specs[St.lens], specs[St.subjectsTarget], Ns.alivocab, "diff", specs[St.objectsTarget], Ns.singletons, specs[St.lens_name]) # print diff_insert_query # print specs[St.lens_name] specs[St.insert_query] = diff_insert_query # RUN THE INSERT QUERY insertion_result = Qry.boolean_endpoint_response(diff_insert_query) print "\tDIFFERENCE INSERTED: {}".format(insertion_result) # RUN THE METADATA metadata = Gn.diff_meta(specs) # print metadata if int(specs[St.triples]) > 0: insertion_metadata = Qry.boolean_endpoint_response(metadata) print "\tDIFFERENCE INSERTED METADATA: {}".format(insertion_metadata) if save is True: # GENERATE LINKSET CONSTRUCT QUERY construct_query = "\n{}\n{}\n{}\n".format( "PREFIX alivocab:<{}>".format(Ns.alivocab), "construct { ?x ?y ?z }", "where {{ graph <{}> {{ ?x ?y ?z }} }}".format(specs[St.lens]), ) # print construct_query # GET THE SINGLETON METADATA USING THE CONSTRUCT QUERY construct_response = Qry.endpointconstruct(construct_query) if construct_response is not None: construct_response = construct_response.replace('{', "<{}>\n{{".format(specs[St.lens]), 1) # print construct_response # WRITE TO FILE print "\t>>> WRITING THE DIFFERENCE TO FILE" write_to_file(graph_name=specs[St.lens_name], metadata=metadata.replace("INSERT DATA", ""), correspondences=construct_response, singletons=None, directory=DIRECTORY) server_message = "LENS created as: {}".format(specs[St.lens]) message = "The LENS DIFFERENCE was created as<br/> {}" \ "<br/>with {} CORRESPONDENCES INSERTED AS THE DIFFERENCE".format(specs[St.lens], specs[St.triples]) print "\t", server_message print "\t*** JOB DONE! ***" # REGISTER THE LENS register_lens(specs, is_created=True) return {St.message: message, St.error_code: 0, St.result: specs[St.lens]} else: return {St.message: Ec.ERROR_CODE_4, St.error_code: 4, St.result: None}