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 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 union(specs, activated=False):
if activated is False:
# logger.warning("THE FUNCTION IS NOT ACTIVATED")
print("THE FUNCTION IS NOT ACTIVATED")
return {
St.message: "THE FUNCTION IS NOT ACTIVATED.",
St.error_code: 1,
St.result: None
}
print "\nEXECUTING UNION SPECS" \
"\n======================================================" \
"========================================================"
"""
THE generate_lens_name FUNCTION RETURNS THE NAME OF THE UNION AND A
QUERY THAT ALLOWS TO ASk WHETHER THE LENS TO BE CREATED EXIST BY CHECKING
WHETHER THERE EXISTS A LENS WITH THE SAME COMPOSITION IN TERMS GRAPHS USED FOR THE UNION
"""
# SET THE NAME OF THE UNION-LENS
print "1. DATASETS:", len(specs[St.datasets])
for ds in specs[St.datasets]:
print "\t- {}".format(ds)
info = Lu.generate_lens_name(specs[St.datasets])
specs[St.lens] = "{}{}".format(Ns.lens, info["name"])
print "\n2. LENS: ", info["name"]
# CHECK WHETHER THE LENS EXISTS
check = run_checks(specs, info["query"])
if check[St.result] != "GOOD TO GO":
if check[St.message].__contains__("ALREADY EXISTS"):
Urq.register_lens(specs, is_created=False)
return check
# print "AFTER CHECK"
# PREPARATION FOR THE CREATION OF THE LENS
specs[St.lens_target_triples] = ""
specs[St.expectedTriples] = 0
specs[St.insert_query] = ""
lens = specs[St.lens]
source = "{}{}".format(Ns.tmpgraph, "load00")
message_2 = Ec.ERROR_CODE_8.replace("#", specs[St.lens])
count = -1
insert_ans = False
try:
# GO THROUGH THE LINKSETS/LENSES IN THE LENS
# 1-SUM UP THE EXPECTED NUMBER OF TRIPLES
# 2-GENERATE THE TRIPLES REPRESENTATION OF GHE GRAPHS COMPOSING THIS LENS
# 3-GENERATE THE INSERT QUERY FOR MOVING BOTH LINKSET AND SINGLETON GRAPHS TO THE UNION GRAPH
total_size = 0
# LOAD ALL GRAPHS IN LOAD00
specs[St.insert_query] += "DROP SILENT GRAPH <{}{}> ;\n".format(
Ns.tmpgraph, "load00")
# ITERATE THROUGH THE PROVIDED GRAPHS
for linkset in specs[St.datasets]:
# print "TARGET: ", linkset
count += 1
# GET THE TOTAL NUMBER OF CORRESPONDENCE TRIPLES INSERTED
curr_triples = Qry.get_triples(linkset)
# PROBABLY THE LINKSET HAS NO SUCH PROPERTY " void:triples ?triples ."
if curr_triples is None:
curr_triples = Qry.get_triples_count(linkset)
total_size += int(curr_triples)
print "{} Contains {} triples".format(linkset, curr_triples)
if curr_triples is not None:
specs[St.expectedTriples] += int(curr_triples)
else:
# THE IS A PROBLEM WITH THE GRAPH FOR SEVERAL POSSIBLE REASONS
return {
St.message: message_2.replace("\n", "<br/>"),
St.error_code: 1,
St.result: None
}
# GENERATE TRIPLES OUT OF THE TARGETS
specs[
St.
lens_target_triples] += "\n\t void:target <{}> ;".format(
linkset)
# GET THE INSERT QUERY
# BOTH THE LINKSET AND THE SINGLETONS ARE MOVED TO A SINGLE GRAPH
partial_query = Qry.q_copy_graph(source, source, linkset)
if count == 0:
specs[St.insert_query] += partial_query
else:
specs[St.insert_query] += " ;\n{}".format(partial_query)
# INTERSECTION MANIPULATION OVER THE UNION (SOURCE)
insert_query = union_insert_q(lens, source, specs[St.lens_name])
# print "manipulation:", manipulation
specs[St.insert_query] += " ;\n{}".format(insert_query)
# GENERATE THE LENS UNION
if activated is True:
# print specs[St.insert_query]
insert_ans = Qry.boolean_endpoint_response(specs[St.insert_query])
specs[St.triples] = Qry.get_namedgraph_size(lens, isdistinct=False)
if specs[St.triples] == "0":
message = Ec.ERROR_CODE_9
print message
# return None
return {
St.message: message.replace("\n", "<br/>"),
St.error_code: 1,
St.result: None
}
# CHECK WHETHER THE RESULT CONTAINS DUPLICATES
contains_duplicated = Qry.contains_duplicates(lens)
print "Contains Opposite Direction Duplicated:", contains_duplicated
# IF IT DOES, REMOVE THE DUPLICATES
if contains_duplicated is True:
# logger.warning("THE LENS CONTAINS DUPLICATES.")
print "THE LENS CONTAINS DUPLICATES."
Qry.remove_duplicates(lens)
# logger.warning("THE DUPLICATES ARE NOW REMOVED.")
print "THE DUPLICATES ARE NOW REMOVED."
print "Number of triples loaded : {}".format(
total_size)
specs[St.triples] = Qry.get_namedgraph_size(lens, isdistinct=False)
print "\t>>> INSERTED: {}\n\t>>> INSERTED TRIPLES: {}".format(
insert_ans, specs[St.triples])
print "Inserted : {}".format(specs[St.triples])
print "Removed : {}".format(total_size - int(specs[St.triples]))
# LOAD THE METADATA
# NOT GOOD AS THE LENS ALSO HAS A SINGLETON GRAPH
# inserted_correspondences = int(Qry.get_union_triples(lens))
inserted_correspondences = int(specs[St.triples])
# print "inserted_correspondences:", inserted_correspondences
specs[St.removedDuplicates] = specs[
St.expectedTriples] - inserted_correspondences
metadata = Gn.union_meta(specs)
# print "METADATA:", metadata
meta_ans = Qry.boolean_endpoint_response(metadata)
print "\t>>> IS THE METADATA GENERATED AND INSERTED? {}".format(
meta_ans)
construct_response = Qry.get_constructed_graph(specs[St.lens])
if construct_response is not None:
print "\t>>> WRITING TO FILE"
construct_response = construct_response.replace(
'{', "<{}>\n{{".format(specs[St.lens]), 1)
write_to_file(graph_name=specs[St.lens_name],
metadata=None,
correspondences=construct_response,
directory=DIRECTORY)
print "\tLens created as : ", specs[St.lens]
# REGISTER THE LINKSET
Urq.register_lens(specs, is_created=True)
# return specs[St.lens]
message = "THE LENS WAS CREATED as {}. " \
"With initially {} triples loaded, {} duplicated triples were found and removed.".\
format(specs[St.lens], total_size, total_size - int(specs[St.triples]))
print "\t*** JOB DONE! ***"
return {
St.message: message,
St.error_code: 0,
St.result: specs[St.lens]
}
except Exception as err:
# logger.warning(err)
if insert_ans == "true":
"DROP THE INSERTED UNION"
drop_linkset(lens, activated=True)
print "ERROR IN UNION LENS CREATION:", err
return {St.message: ERROR_CODE_11, St.error_code: 11, St.result: None}
if count > 0:
print "\n{} INSTANCES FOUND.".format(count)
print "6. RUNNING THE BATCH FILE FOR LOADING THE CORRESPONDENCES INTO THE TRIPLE STORE\n\t\t{}", writers[
St.batch_output_path]
if Svr.settings[St.split_sys] is True:
print "THE DATA IS BEING LOADED OVER HTTP POST."
else:
print "THE DATA IS BEING LOADED AT THE STARDOG LOCAL HOST FROM BATCH."
# os.system(writers[St.batch_output_path])
Ut.batch_load(writers[St.batch_output_path])
# inserted = Qry.insert_size(specs[St.linkset], isdistinct=False)
metadata = Gn.linkset_metadata(specs, display=False).replace("INSERT DATA", "")
writers[St.meta_writer].write(to_unicode(metadata))
if int(specs[St.triples]) > 0:
Qry.boolean_endpoint_response(metadata)
writers[St.meta_writer].close()
# REGISTER THE ALIGNMENT
# if check[St.result].__contains__("ALREADY EXISTS"):
# Urq.register_alignment_mapping(specs, created=False)
# else:
# Urq.register_alignment_mapping(specs, created=True)
Urq.register_alignment_mapping(specs, created=False)
# WRITE TO FILE
# check_rdf_file(writers[St.crpdce_writer_path])
# check_rdf_file(writers[St.meta_writer_path])
def intersecting(specs, activated=False):
if activated is False:
print("THE FUNCTION [intersecting] IS NOT ACTIVATED")
return {
St.message: "THE FUNCTION [intersecting] IS NOT ACTIVATED.",
St.error_code: 1,
St.result: None
}
print Ut.headings("EXECUTING INTERSECTION SPECS...")
# 1. GENERATE THE LENS NAME
lens_name = generate_lens_name(specs['datasets'], operator="intersection")
specs[St.lens] = "{}{}".format(Ns.lens, lens_name['name'])
Ut.update_specification(specs)
# **********************************
# 3. GOOD TO GO CHECK
# **********************************
query = """
SELECT *
{{
<{}> ?predicate ?object .
}}
""".format(specs[St.lens])
check = Lens_Union.run_checks(specs, query, operator="intersection")
# NOT GOOD TO GO, IT ALREADY EXISTS
if check[St.message].__contains__("ALREADY EXISTS"):
return {
St.message: check[St.message],
St.error_code: 71,
St.result: specs[St.lens]
}
# **********************************
# GOOD TO GO
# **********************************
else:
try:
specs[St.lens_target_triples] = ""
# DOCUMENTING START TIME
lens_start = time.time()
print "\n4. GENERATE THE INSERT QUERY"
specs[St.insert_query] = intersection_extended(
specs, lens_name=specs[St.lens_name])
print specs[St.insert_query]
print "\n5. >>> LOOKING FOR INTERSECTING LINKS"
print "\t", Qry.boolean_endpoint_response(specs[St.insert_query])
print "\n6. EXTRACTING THE NUMBER OF TRIPLES"
specs[St.triples] = Qry.get_namedgraph_size("{0}{1}".format(
Ns.lens, specs[St.lens_name]))
lens_end = time.time()
diff = lens_end - lens_start
print " \n>>> Executed so far in : {:<14}".format(
str(datetime.timedelta(seconds=diff)))
if int(specs[St.triples]) > 0:
for linkset in specs[St.datasets]:
specs[St.lens_target_triples] += \
"\n\t void:target <{}> ;".format(linkset)
print "\n7. INSERTING THE GENERIC METADATA"
metadata = Gn.intersection_meta(specs)
# print metadata
Qry.boolean_endpoint_response(metadata)
# print "\n8. WRITING TO FILE"
server_message = "Linksets created as: {}".format(
specs[St.lens])
message = "The linkset was created as [{}] with {} triples found!".format(
specs[St.lens], specs[St.triples])
print "\n\t", server_message
Urq.register_lens(specs, is_created=True)
ls_end_2 = time.time()
diff = ls_end_2 - lens_end
print ">>> Executed in : {:<14}".format(
str(datetime.timedelta(seconds=diff)))
print "\t*** JOB DONE! ***"
return {
St.message: message,
St.error_code: 0,
St.result: specs[St.lens]
}
else:
print "The linkset was not generated as no match could be found"
print "\t*** JOB DONE! ***"
return {
St.message:
"The linkset was not generated as no match could be found",
St.error_code: 4,
St.result: None
}
except Exception as err:
traceback.print_exc()
return {
St.message: Ec.ERROR_CODE_1,
St.error_code: 5,
St.result: None
}
# specs = {
# 'lens_operation': u'intersection',
# 'datasets': [u'http://risis.eu/linkset/grid_20170712_eter_2014_approxStrSim_Organization_altLabel_P1079405301',
# u'http://risis.eu/linkset/grid_20170712_eter_2014_approxStrSim_Organization_altLabel_P1661430032',
# u'http://risis.eu/linkset/grid_20170712_eter_2014_approxStrSim_Organization_label_N1860664105'],
# 'researchQ_URI': u'http://risis.eu/activity/idea_67a6ce'}
# specs_2 = {'lens_operation': u'intersection',
# 'datasets': [u'http://risis.eu/lens/union_Grid_20170712_Eter_2014_N291690309',
# u'http://risis.eu/lens/union_Orgreg_20170718_Eter_2014_P1061032980',
# u'http://risis.eu/lens/union_Orgreg_20170718_Grid_20170712_N1966224323'],
# 'researchQ_URI': u'http://risis.eu/activity/idea_67a6ce'}
#
# specs_3 = {'lens_operation': u'intersection',
# 'datasets': [
# u'http://risis.eu/linkset/orgreg_20170718_grid_20170712_approxStrSim_University_Entity_current_name_English_N682223883',
# u'http://risis.eu/linkset/orgreg_20170718_grid_20170712_approxStrSim_University_Entity_current_name_English_P2117262605',
# u'http://risis.eu/lens/union_Grid_20170712_Eter_2014_N291690309',
# u'http://risis.eu/lens/union_Orgreg_20170718_Eter_2014_P1061032980',
# u'http://risis.eu/lens/union_Orgreg_20170718_Grid_20170712_N1966224323'],
# 'researchQ_URI': u'http://risis.eu/activity/idea_67a6ce'}
#
#
#
# print intersection_extended(specs_3, "lens_name", display=False)
# import Alignments.Manage.AdminGraphs as adm
# adm.drop_a_lens("http://risis.eu/lens/intersection_Grid_20170712_Eter_2014_P1326988364", display=True, activated=True)
# print intersecting(specs, activated=True)
def refine_lens(specs, activated=False, check_file=False):
try:
message = Ec.ERROR_CODE_0.replace('\n', "<br/>")
if activated is False:
print Ut.headings("THE FUNCTION [refine_lens] IS NOT ACTIVATED")
return {St.message: message, St.error_code: 4, St.result: None}
# 1. UPDATING THE SPECS BY CHANGING LINKSET TO TENS
specs[St.refined] = specs['linkset']
specs.pop('linkset')
Ut.update_specification(specs)
# CHECKING WHETHER THE LENS IS REFINENABLE
# Refine.is_refinable(specs[St.refined])
# PRINTING THE SPECIFICATIONS
# lensUt.print_specs(specs)
# ASSIGN THE SAME AS COUNT
specs[St.sameAsCount] = Qry.get_same_as_count(specs[St.mechanism])
message = Ec.ERROR_CODE_4.replace('\n', "<br/>")
if specs[St.sameAsCount]:
source = specs[St.source]
target = specs[St.target]
# 2. SET THE LENS NAME
# *******************************
print "\n2. SET THE LENS NAME"
# *******************************
lensUt.lens_refine_name(specs, 'refine')
#*******************************
# GOOD TO GO CHECK
# *******************************
query = """
SELECT *
{{
<{}> ?predicate ?object .
}}
""".format(specs[St.lens])
check = Lens_Union.run_checks(specs, query, operator="refine")
# NOT GOOD TO GO, IT ALREADY EXISTS
if check[St.message].__contains__("ALREADY EXISTS"):
return {
St.message: check[St.message],
St.error_code: 71,
St.result: specs[St.lens]
}
# *******************************
# GOOD TO GO
# *******************************
else:
lens_start = time.time()
# UPDATE THE SPECIFICATION
Ut.update_specification(specs[St.source])
Ut.update_specification(specs[St.target])
# PRINTING THE SPECIFICATIONS
lensUt.print_specs(specs)
########################################################################
print """\n4. EXECUTING THE GEO-MATCH """
########################################################################
geo_match(specs)
########################################################################
print """\n5. EXTRACT THE NUMBER OF TRIPLES """
########################################################################
specs[St.triples] = Qry.get_namedgraph_size("{0}{1}".format(
Ns.lens, specs[St.lens_name]))
########################################################################
print """\n6. ASSIGN THE SPARQL INSERT QUERY """
########################################################################
specs[St.insert_query] = "{} ;\n{};\n{}".format(
geo_load_query(specs, True), geo_load_query(specs, False),
geo_match_query(specs))
lens_end = time.time()
diff = lens_end - lens_start
print "\n\t>>> Executed so far in : {:<14}".format(
str(datetime.timedelta(seconds=diff)))
if int(specs[St.triples]) > 0:
########################################################################
print """\n4. INSERTING THE GENERIC METADATA """
########################################################################
metadata = Gn.lens_refine_geo_metadata(specs)
Qry.boolean_endpoint_response(metadata)
########################################################################
print """\n5. WRITING TO FILE """
########################################################################
src = [source[St.graph_name], "", source[St.entity_ns]]
trg = [target[St.graph_name], "", target[St.entity_ns]]
# linkset_path = "D:\datasets\Linksets\ExactName"
linkset_path = DIRECTORY
writelinkset(src,
trg,
specs[St.lens_name],
linkset_path,
metadata,
check_file=check_file)
server_message = "Linksets created as: {}".format(
specs[St.lens])
message = "The linkset was created as [{}] with {} triples found!".format(
specs[St.lens], specs[St.triples])
print "\n\t", server_message
Urq.register_lens(specs, is_created=True)
ls_end_2 = time.time()
diff = ls_end_2 - lens_end
print ">>> Executed in : {:<14}".format(
str(datetime.timedelta(seconds=diff)))
print "\t*** JOB DONE! ***"
return {
St.message: message,
St.error_code: 0,
St.result: specs[St.lens]
}
else:
print "\tThe linkset was not generated as no match could be found"
print "\t*** JOB DONE! ***"
return {
St.message: message,
St.error_code: 4,
St.result: None
}
except Exception as err:
traceback.print_exc()
return {St.message: Ec.ERROR_CODE_1, St.error_code: 5, St.result: None}
# print geo_load_query(specs, is_source=True)
# print geo_load_query(specs, is_source=False)
# geo_match_query(specs)
# traceback.print_exception()
# import Alignments.Manage.AdminGraphs as adm
# adm.drop_a_lens("http://risis.eu/lens/refine_union_Grid_20170712_Eter_2014_N291690309", display=True, activated=True)
# refine_lens(specs_example, activated=True, check_file=False)
#
# adm.drop_a_lens("http://risis.eu/lens/refine_union_Orgreg_20170718_Eter_2014_P1061032980", display=True, activated=True)
# refine_lens(specs_example_2, activated=True, check_file=False)
#
# adm.drop_a_lens("http://risis.eu/lens/refine_union_Orgreg_20170718_Grid_20170712_N1966224323", display=True, activated=True)
# refine_lens(specs_example_3, activated=True, check_file=False)
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}