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 refining(specs, insert_query, activated=False):
refined = {St.message: Ec.ERROR_CODE_1, St.error_code: 5, St.result: None}
diff = {St.message: Ec.ERROR_CODE_4, St.error_code: 1, St.result: None}
# UPDATE THE SPECS VARIABLE
# print "UPDATE THE SPECS VARIABLE"
update_specification(specs)
update_specification(specs[St.source])
update_specification(specs[St.target])
# ACCESS THE TASK SPECIFIC PREDICATE COUNT
specs[St.sameAsCount] = Qry.get_same_as_count(specs[St.mechanism])
# print "sameAsCount:", specs[St.sameAsCount]
if specs[St.sameAsCount] is None:
return {'refined': refined, 'difference': diff}
# GENERATE THE NAME OF THE LINKSET
Ls.set_refined_name(specs)
# print "\nREFINED NAME:", specs[St.refined]
# print "LINKSET TO REFINE BEFORE CHECK:", specs[St.linkset]
# CHECK WHETHER OR NOT THE LINKSET WAS ALREADY CREATED
check = Ls.run_checks(specs, check_type="refine")
# print "\nREFINED NAME:", specs[St.refined]
# print "LINKSET TO REFINE:", specs[St.linkset]
if check[St.message] == "NOT GOOD TO GO":
# refined = check[St.refined]
# difference = check["difference"]
return check
# print "\nREFINED:", specs[St.refined]
# print "LINKSET TO REFINE:", specs[St.linkset]
# print "CHECK:", check
# THE LINKSET DOES NOT EXIT, LETS CREATE IT NOW
print Ls.refined_info(specs, specs[St.sameAsCount])
# POINT TO THE LINKSET THE CURRENT LINKSET WAS DERIVED FROM
print "1. wasDerivedFrom {}".format(specs[St.linkset])
specs[St.derivedfrom] = "\t\tprov:wasDerivedFrom\t\t\t<{}> ;".format(
specs[St.linkset])
# print "REFINED NAME:", specs[St.refined_name]
# print "REFINED:", specs[St.refined]
# print "LINKSET TO BE REFINED:", specs[St.linkset]
print "\n2. RETRIEVING THE METADATA ABOUT THE GRAPH TO REFINE"
# metadata_q = Qry.q_linkset_metadata(specs[St.linkset])
metadata_q = """
prefix ll: <{}>
SELECT DISTINCT ?type ?singletonGraph
{{
# LINKSET METADATA
<{}>
a ?type ;
ll:singletonGraph ?singletonGraph .
}}
""".format(Ns.alivocab, specs[St.linkset])
print "QUERY:", metadata_q
matrix = Qry.sparql_xml_to_matrix(metadata_q)
# print "\nMETA DATA: ", matrix
if matrix:
if matrix[St.message] == "NO RESPONSE":
print Ec.ERROR_CODE_1
print matrix[St.message]
return {'refined': refined, 'difference': diff}
elif matrix[St.result] is None:
print matrix[St.message]
returned = {
St.message: matrix[St.message],
St.error_code: 666,
St.result: None
}
return {'refined': returned, 'difference': diff}
else:
print Ec.ERROR_CODE_1
return {'refined': refined, 'difference': diff}
# GET THE SINGLETON GRAPH OF THE LINKSET TO BE REFINED
print "\n3. GETTING THE SINGLETON GRAPH OF THE GRAPH TO REFINE"
specs[St.singletonGraph] = matrix[St.result][1][1]
# print matrix[St.result][1][0]
specs[St.insert_query] = insert_query(specs)
print specs[St.insert_query]
if type(specs[St.insert_query]) == str:
is_run = Qry.boolean_endpoint_response(specs[St.insert_query])
else:
print "\n4. RUNNING THE EXTRACTION QUERY"
print specs[St.insert_query][0]
# is_run = Qry.boolean_endpoint_response(specs[St.insert_query][0])
Qry.boolean_endpoint_response(specs[St.insert_query][0])
print "\n5. RUNNING THE FINDING QUERY"
print specs[St.insert_query][1]
is_run = Qry.boolean_endpoint_response(specs[St.insert_query][1])
print "\n>>> RUN SUCCESSFULLY:", is_run.upper()
# NO INSERTION HAPPENED
if is_run == "true" or is_run == Ec.ERROR_STARDOG_1:
# GENERATE THE
# (1) LINKSET METADATA
# (2) LINKSET OF CORRESPONDENCES
# (3) SINGLETON METADATA
# AND WRITE THEM ALL TO FILE
print "GENERATING THE METADATA"
pro_message = refine_metadata(specs)
# SET THE RESULT ASSUMING IT WENT WRONG
refined = {
St.message: Ec.ERROR_CODE_4,
St.error_code: 4,
St.result: None
}
diff = {St.message: Ec.ERROR_CODE_4, St.error_code: 4, St.result: None}
server_message = "Linksets created as: [{}]".format(specs[St.refined])
message = "The linkset was created as [{}]. <br/>{}".format(
specs[St.refined], pro_message)
# MESSAGE ABOUT THE INSERTION STATISTICS
print "\t", server_message
if int(specs[St.triples]) > 0:
# UPDATE THE REFINED VARIABLE AS THE INSERTION WAS SUCCESSFUL
refined = {
St.message: message,
St.error_code: 0,
St.result: specs[St.linkset]
}
print "REGISTERING THE ALIGNMENT"
if refined[St.message].__contains__("ALREADY EXISTS"):
register_alignment_mapping(specs, created=False)
else:
register_alignment_mapping(specs, created=True)
try:
print "\nCOMPUTE THE DIFFERENCE AND DOCUMENT IT"
diff_lens_specs = {
St.researchQ_URI: specs[St.researchQ_URI],
St.subjectsTarget: specs[St.linkset],
St.objectsTarget: specs[St.refined]
}
diff = Df.difference(diff_lens_specs, activated=activated)
message_2 = "\t>>> {} CORRESPONDENCES INSERTED AS THE DIFFERENCE".format(
diff_lens_specs[St.triples])
print message_2
except Exception as err:
print "THE DIFFERENCE FAILED: ", str(err.message)
print "\tLinkset created as: ", specs[St.refined]
print "\t*** JOB DONE! ***"
return {'refined': refined, 'difference': diff}
else:
print ">>> NO TRIPLE WAS INSERTED BECAUSE NO MATCH COULD BE FOUND"
return {'refined': refined, 'difference': diff}
else:
print "NO MATCH COULD BE FOUND."