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}
