def test_create_message_basic():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
assert message.type == 'translator_reasoner_message'
assert message.schema_version == '0.9.3'
def test_add_qnode_bad_parameters():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
bad_parameters_list = [
{
'parameters': ['curie', 'PICKLES:123'],
'error_code': 'ParametersNotDict'
},
{
'parameters': {
'curie': 'UniProtKB:P14136',
'is_set': 'true'
},
'error_code': 'CurieScalarButIsSetTrue'
},
{
'parameters': {
'pickles': 'on the side'
},
'error_code': 'UnknownParameter'
},
]
reference_message = copy.deepcopy(message)
for bad_parameters in bad_parameters_list:
message = copy.deepcopy(reference_message)
print(bad_parameters)
response = messenger.add_qnode(message, bad_parameters['parameters'])
assert response.status == 'ERROR'
assert len(message.query_graph.nodes) == 0
assert response.error_code == bad_parameters['error_code']
def main():
#### Create a response object
response = Response()
ranker = ARAXRanker()
#### Get a Message to work on
messenger = ARAXMessenger()
print("INFO: Fetching message to work on from arax.rtx.ai", flush=True)
message = messenger.fetch_message(
'https://arax.rtx.ai/api/rtx/v1/message/2614')
if message is None:
print("ERROR: Unable to fetch message")
return
ranker.aggregate_scores(message, response=response)
#### Show the final result
print(response.show(level=Response.DEBUG))
print("Results:")
for result in message.results:
confidence = result.confidence
if confidence is None:
confidence = 0.0
print(" -" + '{:6.3f}'.format(confidence) + f"\t{result.essence}")
def QGI_test5():
# This is to test forked/non-linear queries (currently not working properly)
input_query_graph = {
"message": {
"query_graph": {
"nodes": {
"n0": {
"categories": ["biolink:Gene"]
},
"n1": {
"ids": ["CHEBI:45783"],
"categories": ["biolink:ChemicalEntity"]
},
"n2": {
"ids": ["MONDO:0005301"],
"categories": ["biolink:Disease"]
},
"n3": {
"categories": ["biolink:ChemicalEntity"]
}
},
"edges": {
"e01": {
"subject": "n0",
"object": "n1",
"predicates": ["biolink:related_to"]
},
"e02": {
"subject": "n0",
"object": "n2",
"predicates": ["biolink:related_to"]
},
"e03": {
"subject": "n0",
"object": "n3",
"predicates": ["biolink:related_to"]
}
}
}
}
}
#### Create a template Message
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
message = ARAXMessenger().from_dict(input_query_graph['message'])
response.envelope.message.query_graph = message.query_graph
interpreter = ARAXQueryGraphInterpreter()
interpreter.translate_to_araxi(response)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
araxi_commands = response.data['araxi_commands']
for cmd in araxi_commands:
print(f" - {cmd}")
def test_create_message_basic():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
assert response.envelope.type == 'translator_reasoner_response'
assert response.envelope.schema_version == '1.0.0'
def test_create_message_node_edge_types():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
assert isinstance(message.knowledge_graph.nodes, list)
assert isinstance(message.knowledge_graph.edges, list)
assert isinstance(message.query_graph.nodes, list)
assert isinstance(message.query_graph.edges, list)
def test_add_qnode_basic():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
response = messenger.add_qnode(message, {})
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, list)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes[0].id == 'n00'
def test_add_qnode_bad_name():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
response = messenger.add_qnode(message, {'name': 'Big Bird'})
assert response.status == 'ERROR'
assert isinstance(message.query_graph.nodes, list)
assert len(message.query_graph.nodes) == 0
assert response.error_code == 'UnknownCURIE'
def test_create_message_node_edge_types():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
assert isinstance(message.knowledge_graph.nodes, dict)
assert isinstance(message.knowledge_graph.edges, dict)
assert isinstance(message.query_graph.nodes, dict)
assert isinstance(message.query_graph.edges, dict)
def test_example1():
query_graph = {
"edges": {
"e00": {
"subject": "n00",
"object": "n01"
},
"e01": {
"subject": "n00",
"object": "n01",
"predicate": "biolink:contraindicated_for",
"exclude": True
}
},
"nodes": {
"n00": {
"id": "MONDO:0001627",
"category": "biolink:Disease"
},
"n01": {
"category": "biolink:ChemicalSubstance"
}
}
}
from ARAX_messenger import ARAXMessenger
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
response.envelope.message.query_graph = QueryGraph().from_dict(query_graph)
query_graph_info = QueryGraphInfo()
result = query_graph_info.assess(response.envelope.message)
response.merge(result)
if result.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
query_graph_info_dict = {
'n_nodes': query_graph_info.n_nodes,
'n_edges': query_graph_info.n_edges,
'is_bifurcated_graph': query_graph_info.is_bifurcated_graph,
'start_node': query_graph_info.start_node,
'node_info': query_graph_info.node_info,
'edge_info': query_graph_info.edge_info,
'node_order': query_graph_info.node_order,
'edge_order': query_graph_info.edge_order,
'node_category_map': query_graph_info.node_category_map,
'edge_predicate_map': query_graph_info.edge_predicate_map,
}
print(
json.dumps(ast.literal_eval(repr(query_graph_info_dict)),
sort_keys=True,
indent=2))
def main():
# Note that most of this is just manually doing what ARAXQuery() would normally do for you
response = Response()
from actions_parser import ActionsParser
actions_parser = ActionsParser()
actions_list = [
"create_message",
"add_qnode(id=n00, curie=CHEMBL.COMPOUND:CHEMBL112)", # acetaminophen
"add_qnode(id=n01, type=protein, is_set=true)",
"add_qedge(id=e00, source_id=n00, target_id=n01)",
"expand(edge_id=e00, kp=BTE)",
"return(message=true, store=false)",
]
# Parse the raw action_list into commands and parameters
result = actions_parser.parse(actions_list)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
actions = result.data['actions']
from ARAX_messenger import ARAXMessenger
messenger = ARAXMessenger()
expander = ARAXExpander()
for action in actions:
if action['command'] == 'create_message':
result = messenger.create_message()
message = result.data['message']
response.data = result.data
elif action['command'] == 'add_qnode':
result = messenger.add_qnode(message, action['parameters'])
elif action['command'] == 'add_qedge':
result = messenger.add_qedge(message, action['parameters'])
elif action['command'] == 'expand':
result = expander.apply(message, action['parameters'])
elif action['command'] == 'return':
break
else:
response.error(f"Unrecognized command {action['command']}",
error_code="UnrecognizedCommand")
print(response.show(level=Response.DEBUG))
return response
# Merge down this result and end if we're in an error state
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
# Show the final response
# print(json.dumps(ast.literal_eval(repr(message.knowledge_graph)),sort_keys=True,indent=2))
print(response.show(level=Response.DEBUG))
def test_add_qnode_curie_scalar():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
response = messenger.add_qnode(message, {'curie': 'UniProtKB:P14136'})
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, list)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes[0].id == 'n00'
assert message.query_graph.nodes[0].curie == 'UniProtKB:P14136'
def test_add_qnode_name():
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
response = messenger.add_qnode(message, {'name': 'acetaminophen'})
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, list)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes[0].id == 'n00'
assert message.query_graph.nodes[0].curie == 'CHEMBL.COMPOUND:CHEMBL112'
def QGI_test4():
input_query_graph = { "message": { "query_graph":
{
"nodes": {
"n00": {
"categories": [
"biolink:Gene"
],
"is_set": False
},
"n01": {
"ids": [
"MONDO:0018177"
],
"categories": [
"biolink:Disease"
],
"is_set": False
}
},
"edges": {
"e00": {
"subject": "n00",
"object": "n01",
"exclude": False
}
}
}
} }
#### Create a template Message
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
message = ARAXMessenger().from_dict(input_query_graph['message'])
response.envelope.message.query_graph = message.query_graph
interpreter = ARAXQueryGraphInterpreter()
interpreter.translate_to_araxi(response)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
araxi_commands = response.data['araxi_commands']
for cmd in araxi_commands:
print(f" - {cmd}")
def main():
#### Create a response object
response = Response()
#### Create an ActionsParser object
from actions_parser import ActionsParser
actions_parser = ActionsParser()
#### Set a simple list of actions
actions_list = [
"filter(start_node=1, maximum_results=10, minimum_confidence=0.5)",
"return(message=true,store=false)"
]
#### Parse the action_list and print the result
result = actions_parser.parse(actions_list)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
actions = result.data['actions']
#### Read message #2 from the database. This should be the acetaminophen proteins query result message
sys.path.append(
os.path.dirname(os.path.abspath(__file__)) + "/../../UI/Feedback")
from RTXFeedback import RTXFeedback
araxdb = RTXFeedback()
message_dict = araxdb.getMessage(2)
#### The stored message comes back as a dict. Transform it to objects
from ARAX_messenger import ARAXMessenger
message = ARAXMessenger().from_dict(message_dict)
#print(json.dumps(ast.literal_eval(repr(message)),sort_keys=True,indent=2))
#### Create a filter object and use it to apply action[0] from the list
query_graph_info = QueryGraphInfo()
result = query_graph_info.assess(message)
response.merge(result)
if result.status != 'OK':
print(response.show(level=Response.DEBUG))
return response
query_graph_info_dict = {
'n_nodes': query_graph_info.n_nodes,
'n_edges': query_graph_info.n_edges,
'is_bifurcated_graph': query_graph_info.is_bifurcated_graph,
'start_node': query_graph_info.start_node,
'node_info': query_graph_info.node_info,
'edge_info': query_graph_info.edge_info,
'node_order': query_graph_info.node_order,
'edge_order': query_graph_info.edge_order,
'node_type_map': query_graph_info.node_type_map,
'edge_type_map': query_graph_info.edge_type_map,
}
print(
json.dumps(ast.literal_eval(repr(query_graph_info_dict)),
sort_keys=True,
indent=2))
def QGI_test1():
#### Some qnode examples
test_query_graphs = [
[ { 'id': 'n10', 'curie': 'DOID:9281', 'category': 'disease'}, { 'id': 'n11', 'category': 'chemical_substance'}, { 'id': 'e10', 'source_id': 'n10', 'target_id': 'n11', 'category': 'treats'} ],
[ { 'id': 'n10', 'curie': 'DOID:9281'}, { 'id': 'n11', 'category': 'protein'}, { 'id': 'e10', 'source_id': 'n10', 'target_id': 'n11'} ],
[ { 'id': 'n10', 'curie': 'DOID:9281'}, { 'id': 'n11', 'category': 'protein'}, { 'id': 'n12', 'category': 'chemical_substance'},
{ 'id': 'e10', 'source_id': 'n10', 'target_id': 'n11'}, { 'id': 'e11', 'source_id': 'n11', 'target_id': 'n12'} ],
[ { 'id': 'n10', 'curie': 'DOID:9281'}, { 'id': 'n11', 'category': 'chemical_substance'}, { 'id': 'e10', 'source_id': 'n10', 'target_id': 'n11'} ],
[ { 'id': 'n10', 'curie': 'DOID:9281', 'category': 'disease'}, { 'id': 'n11', 'category': 'chemical_substance'}, { 'id': 'e10', 'source_id': 'n10', 'target_id': 'n11'} ],
]
#interpreter = ARAXQueryGraphInterpreter()
#print(json.dumps(interpreter.query_graph_tree,sort_keys=True,indent=2))
#return
for test_query_graph in test_query_graphs:
#### Create a response object for each test
response = ARAXResponse()
#### Create a template Message
messenger = ARAXMessenger()
messenger.create_envelope(response)
message = response.envelope.message
for parameters in test_query_graph:
if 'n' in parameters['id']:
messenger.add_qnode(response, parameters)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
elif 'e' in parameters['id']:
#print(f"++ Adding qedge with {parameters}")
messenger.add_qedge(response, parameters)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
else:
response.error(f"Unrecognized component {parameters['id']}")
return response
interpreter = ARAXQueryGraphInterpreter()
interpreter.translate_to_araxi(response)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
araxi_commands = response.data['araxi_commands']
for cmd in araxi_commands:
print(f" - {cmd}")
def test_add_qnode_bad_parameters():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
bad_parameters_list = [
{
'parameters': ['ids', 'PICKLES:123'],
'error_code': 'ParametersNotDict'
},
{
'parameters': {
'pickles': 'on the side'
},
'error_code': 'UnknownParameter'
},
{
'parameters': {
'ids': 'n2',
'category': 'biolink:Disease'
},
'error_code': 'UnknownParameter'
},
]
template_response = copy.deepcopy(response)
for bad_parameters in bad_parameters_list:
response = copy.deepcopy(template_response)
message = response.envelope.message
print(bad_parameters)
messenger.add_qnode(response, bad_parameters['parameters'])
assert response.status == 'ERROR'
assert len(message.query_graph.nodes) == 0
assert response.error_code == bad_parameters['error_code']
def QGI_test3():
input_query_graph = {
"message": {
"query_graph": {
"nodes": {
"n00": {
"id": "MONDO:0002715"
},
"n01": {
"category": "biolink:ChemicalSubstance"
},
"n02": {
"category": "biolink:Gene"
}
},
"edges": {
"e00": {
"predicate": "biolink:correlated_with",
"subject": "n00",
"object": "n01"
},
"e01": {
"predicate": "biolink:related_to",
"subject": "n01",
"object": "n02"
}
}
}
}
}
#### Create a template Message
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
message = ARAXMessenger().from_dict(input_query_graph['message'])
response.envelope.message.query_graph = message.query_graph
interpreter = ARAXQueryGraphInterpreter()
interpreter.translate_to_araxi(response)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
araxi_commands = response.data['araxi_commands']
for cmd in araxi_commands:
print(f" - {cmd}")
#### Show the final result
print('-------------------------')
print(response.show(level=ARAXResponse.DEBUG))
print(json.dumps(message.to_dict(), sort_keys=True, indent=2))
def test_add_qedge_multitest():
# Set up a message with two nodes
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'name': 'acetaminophen' })
assert response.status == 'OK'
messenger.add_qnode(response,{ 'category': 'biolink:Protein' })
assert response.status == 'OK'
# Set up a list of parameters to feed to add_qedge() and what the result should be
parameters_list = [
{ 'status': 'ERROR', 'parameters': [ 'subject', 'n00' ], 'error_code': 'ParametersNotDict' },
{ 'status': 'OK', 'parameters': { 'subject': 'n00', 'object': 'n01' }, 'error_code': 'OK' },
{ 'status': 'OK', 'parameters': { 'subject': 'n00', 'object': 'n01', 'key': 'e99' }, 'error_code': 'OK' },
{ 'status': 'OK', 'parameters': { 'subject': 'n00', 'object': 'n01', 'key': 'e99', 'predicate': 'physically_interacts_with' }, 'error_code': 'OK' },
{ 'status': 'ERROR', 'parameters': { 'subject': 'n00' }, 'error_code': 'MissingTargetKey' },
{ 'status': 'ERROR', 'parameters': { 'object': 'n00' }, 'error_code': 'MissingSourceKey' },
{ 'status': 'ERROR', 'parameters': { 'subject': 'n99', 'object': 'n01' }, 'error_code': 'UnknownSourceKey' },
{ 'status': 'ERROR', 'parameters': { 'subject': 'n00', 'object': 'n99' }, 'error_code': 'UnknownTargetKey' },
{ 'status': 'ERROR', 'parameters': { 'pickles': 'on the side' }, 'error_code': 'UnknownParameter' },
]
# Loop over all the parameter sets and try to run it
template_response = copy.deepcopy(response)
for parameters in parameters_list:
response = copy.deepcopy(template_response)
message = response.envelope.message
print(parameters)
messenger.add_qedge(response, parameters['parameters'])
assert response.status == parameters['status']
if parameters['status'] == 'OK':
assert len(message.query_graph.edges) == 1
continue
assert len(message.query_graph.edges) == 0
assert response.error_code == parameters['error_code']
def test_add_qnode_bad_name():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'name': 'Big Bird' })
assert response.status == 'ERROR'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 0
assert response.error_code == 'UnresolvableNodeName'
def test_add_qnode_group_id_is_set_false():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'category': 'biolink:Protein', 'is_set' : 'false', 'option_group_id' : '0' })
assert response.status == 'ERROR'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 0
assert response.error_code == 'InputMismatch'
def test_add_qnode_basic():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{})
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes['n00'].id == None
def test_add_qnode_type():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'category': 'biolink:Protein' })
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes['n00'].category == 'biolink:Protein'
def test_add_qnode_name():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'name': 'acetaminophen' })
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 1
assert message.query_graph.nodes['n00'].id == 'CHEMBL.COMPOUND:CHEMBL112'
def test_add_qnode_curie_list():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response,{ 'id': ['UniProtKB:P14136','UniProtKB:P35579'] })
assert response.status == 'OK'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 1
assert len(message.query_graph.nodes['n00'].id) == 2
def _answer_query_using_kp(self, query_graph: QueryGraph) -> Tuple[QGOrganizedKnowledgeGraph, Dict[str, Dict[str, str]]]:
answer_kg = QGOrganizedKnowledgeGraph()
edge_to_nodes_map = dict()
# Strip non-essential and 'empty' properties off of our qnodes and qedges
stripped_qnodes = {qnode_key: self._strip_empty_properties(qnode)
for qnode_key, qnode in query_graph.nodes.items()}
stripped_qedges = {qedge_key: self._strip_empty_properties(qedge)
for qedge_key, qedge in query_graph.edges.items()}
# Send the query to the KP's API
body = {'message': {'query_graph': {'nodes': stripped_qnodes, 'edges': stripped_qedges}}}
self.log.debug(f"Sending query to {self.kp_name} API")
kp_response = requests.post(f"{self.kp_endpoint}/query", json=body, headers={'accept': 'application/json'})
json_response = kp_response.json()
if kp_response.status_code == 200:
if not json_response.get("message"):
self.log.warning(
f"No 'message' was included in the response from {self.kp_name}. Response from KP was: "
f"{json.dumps(json_response, indent=4)}")
elif not json_response["message"].get("results"):
self.log.warning(f"No 'results' were returned from {self.kp_name}. Response from KP was: "
f"{json.dumps(json_response, indent=4)}")
json_response["message"]["results"] = [] # Setting this to empty list helps downstream processing
else:
kp_message = ARAXMessenger().from_dict(json_response["message"])
# Build a map that indicates which qnodes/qedges a given node/edge fulfills
kg_to_qg_mappings = self._get_kg_to_qg_mappings_from_results(kp_message.results)
# Populate our final KG with the returned nodes and edges
for returned_edge_key, returned_edge in kp_message.knowledge_graph.edges.items():
arax_edge_key = self._get_arax_edge_key(returned_edge) # Convert to an ID that's unique for us
for qedge_key in kg_to_qg_mappings['edges'][returned_edge_key]:
answer_kg.add_edge(arax_edge_key, returned_edge, qedge_key)
for returned_node_key, returned_node in kp_message.knowledge_graph.nodes.items():
for qnode_key in kg_to_qg_mappings['nodes'][returned_node_key]:
answer_kg.add_node(returned_node_key, returned_node, qnode_key)
# Build a map that indicates which of an edge's nodes fulfill which qnode
if query_graph.edges:
qedge = next(qedge for qedge in query_graph.edges.values())
edge_to_nodes_map = self._create_edge_to_nodes_map(kg_to_qg_mappings, kp_message.knowledge_graph, qedge)
else:
self.log.warning(f"{self.kp_name} API returned response of {kp_response.status_code}. Response from KP was:"
f" {json.dumps(json_response, indent=4)}")
return answer_kg, edge_to_nodes_map
def test_add_qnode_duplicate_key():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
message = response.envelope.message
messenger.add_qnode(response, {
'key': 'n00',
'ids': ['CHEMBL.COMPOUND:CHEMBL112']
})
assert response.status == 'OK'
messenger.add_qnode(response, {'key': 'n00', 'ids': ['CHEBI:46195']})
print(
json.dumps(ast.literal_eval(repr(message.query_graph.nodes)),
sort_keys=True,
indent=2))
assert response.status == 'ERROR'
assert isinstance(message.query_graph.nodes, dict)
assert len(message.query_graph.nodes) == 1
assert response.error_code == 'QNodeDuplicateKey'
def test_add_qnode_bad_parameters():
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
assert response.status == 'OK'
bad_parameters_list = [
{ 'parameters': [ 'id', 'PICKLES:123' ], 'error_code': 'ParametersNotDict' },
{ 'parameters': { 'id': 'UniProtKB:P14136', 'is_set': 'true' }, 'error_code': 'IdScalarButIsSetTrue' },
{ 'parameters': { 'pickles': 'on the side' }, 'error_code': 'UnknownParameter' },
]
template_response = copy.deepcopy(response)
for bad_parameters in bad_parameters_list:
response = copy.deepcopy(template_response)
message = response.envelope.message
print(bad_parameters)
messenger.add_qnode(response, bad_parameters['parameters'])
assert response.status == 'ERROR'
assert len(message.query_graph.nodes) == 0
assert response.error_code == bad_parameters['error_code']
def QGI_test2():
#### Set example query_graph
# TRAPI 0.9.2
input_query_graph = { "message": { "query_graph": { "nodes": [ { "id": "n1", "category": "chemical_substance" }, { "id": "n2", "curie": "UMLS:C0002395" } ], "edges": [ { "id": "e1", "predicate": "clinically_tested_approved_unknown_phase", "source_id": "n1", "target_id": "n2" } ] } } }
# TRAPI 1.0.0
input_query_graph = { "message": { "query_graph": {
"nodes": { "n1": { "category": "biolink:ChemicalEntity" }, "n2": { "id": "UMLS:C0002395" } },
"edges": { "e1": { "predicate": "clinically_tested_approved_unknown_phase", "subject": "n1", "object": "n2" } }
} } }
# TRAPI 1.1.0
input_query_graph = { "message": { "query_graph": {
"nodes": { "n1": { "categories": [ "biolink:ChemicalEntity" ] }, "n2": { "ids": [ "UMLS:C0002395" ] } },
"edges": { "e1": { "predicates": [ "biolink:clinically_tested_approved_unknown_phase" ], "subject": "n1", "object": "n2" } }
} } }
#### Create a template Message
response = ARAXResponse()
messenger = ARAXMessenger()
messenger.create_envelope(response)
message = ARAXMessenger().from_dict(input_query_graph['message'])
response.envelope.message.query_graph = message.query_graph
interpreter = ARAXQueryGraphInterpreter()
interpreter.translate_to_araxi(response)
if response.status != 'OK':
print(response.show(level=ARAXResponse.DEBUG))
return response
araxi_commands = response.data['araxi_commands']
for cmd in araxi_commands:
print(f" - {cmd}")
#### Show the final result
print('-------------------------')
print(response.show(level=ARAXResponse.DEBUG))
print(json.dumps(message.to_dict(),sort_keys=True,indent=2))
def test_add_qedge_multitest():
# Set up a message with two nodes
messenger = ARAXMessenger()
response = messenger.create_message()
assert response.status == 'OK'
message = response.data['message']
response = messenger.add_qnode(message, {'name': 'acetaminophen'})
assert response.status == 'OK'
response = messenger.add_qnode(message, {'type': 'protein'})
assert response.status == 'OK'
# Set up a list of parameters to feed to add_qedge() and what the result should be
parameters_list = [
{
'status': 'ERROR',
'parameters': ['source_id', 'n00'],
'error_code': 'ParametersNotDict'
},
{
'status': 'OK',
'parameters': {
'source_id': 'n00',
'target_id': 'n01'
},
'error_code': 'OK'
},
{
'status': 'OK',
'parameters': {
'source_id': 'n00',
'target_id': 'n01',
'id': 'e99'
},
'error_code': 'OK'
},
{
'status': 'OK',
'parameters': {
'source_id': 'n00',
'target_id': 'n01',
'id': 'e99',
'type': 'physically_interacts_with'
},
'error_code': 'OK'
},
{
'status': 'ERROR',
'parameters': {
'source_id': 'n00'
},
'error_code': 'MissingTargetId'
},
{
'status': 'ERROR',
'parameters': {
'target_id': 'n00'
},
'error_code': 'MissingSourceId'
},
{
'status': 'ERROR',
'parameters': {
'source_id': 'n99',
'target_id': 'n01'
},
'error_code': 'UnknownSourceId'
},
{
'status': 'ERROR',
'parameters': {
'source_id': 'n00',
'target_id': 'n99'
},
'error_code': 'UnknownTargetId'
},
{
'status': 'ERROR',
'parameters': {
'pickles': 'on the side'
},
'error_code': 'UnknownParameter'
},
]
# Loop over all the parameter sets and try to run it
reference_message = copy.deepcopy(message)
for parameters in parameters_list:
message = copy.deepcopy(reference_message)
print(parameters)
response = messenger.add_qedge(message, parameters['parameters'])
assert response.status == parameters['status']
if parameters['status'] == 'OK':
assert len(message.query_graph.edges) == 1
continue
assert len(message.query_graph.edges) == 0
assert response.error_code == parameters['error_code']
