def mme_match(case_obj, match_type, mme_base_url, mme_token, nodes=None, mme_accepts=None):
"""Initiate a MatchMaker match against either other Scout patients or external nodes
Args:
case_obj(dict): a scout case object already submitted to MME
match_type(str): 'internal' or 'external'
mme_base_url(str): base url of the MME server
mme_token(str): auth token of the MME server
mme_accepts(str): request content accepted by MME server (only for internal matches)
Returns:
matches(list): a list of eventual matches
"""
query_patients = []
server_responses = []
url = None
# list of patient dictionaries is required for internal matching
query_patients = case_obj["mme_submission"]["patients"]
if match_type == "internal":
url = "".join([mme_base_url, "/match"])
for patient in query_patients:
json_resp = matchmaker_request(
url=url,
token=mme_token,
method="POST",
content_type=mme_accepts,
accept=mme_accepts,
data={"patient": patient},
)
resp_obj = {
"server": "Local MatchMaker node",
"patient_id": patient["id"],
"results": json_resp.get("results"),
"status_code": json_resp.get("status_code"),
"message": json_resp.get("message"), # None if request was successful
}
server_responses.append(resp_obj)
else: # external matching
# external matching requires only patient ID
query_patients = [patient["id"] for patient in query_patients]
node_ids = [node["id"] for node in nodes]
if match_type in node_ids: # match is against a specific external node
node_ids = [match_type]
# Match every affected patient
for patient in query_patients:
# Against every node
for node in node_ids:
url = "".join([mme_base_url, "/match/external/", patient, "?node=", node])
json_resp = matchmaker_request(url=url, token=mme_token, method="POST")
resp_obj = {
"server": node,
"patient_id": patient,
"results": json_resp.get("results"),
"status_code": json_resp.get("status_code"),
"message": json_resp.get("message"), # None if request was successful
}
server_responses.append(resp_obj)
return server_responses
def mme_match(case_obj, match_type, mme_base_url, mme_token, nodes=None, mme_accepts=None):
"""Initiate a MatchMaker match against either other Scout patients or external nodes
Args:
case_obj(dict): a scout case object already submitted to MME
match_type(str): 'internal' or 'external'
mme_base_url(str): base url of the MME server
mme_token(str): auth token of the MME server
mme_accepts(str): request content accepted by MME server (only for internal matches)
Returns:
matches(list): a list of eventual matches
"""
query_patients = []
server_responses = []
url = None
# list of patient dictionaries is required for internal matching
query_patients = case_obj['mme_submission']['patients']
if match_type=='internal':
url = ''.join([mme_base_url,'/match'])
for patient in query_patients:
json_resp = matchmaker_request(url=url, token=mme_token, method='POST',
content_type=mme_accepts, accept=mme_accepts, data={'patient':patient})
resp_obj = {
'server' : 'Local MatchMaker node',
'patient_id' : patient['id'],
'results' : json_resp.get('results'),
'status_code' : json_resp.get('status_code'),
'message' : json_resp.get('message') # None if request was successful
}
server_responses.append(resp_obj)
else: # external matching
# external matching requires only patient ID
query_patients = [ patient['id'] for patient in query_patients]
node_ids = [ node['id'] for node in nodes ]
if match_type in node_ids: # match is against a specific external node
node_ids = [match_type]
# Match every affected patient
for patient in query_patients:
# Against every node
for node in node_ids:
url = ''.join([mme_base_url,'/match/external/', patient, '?node=', node])
json_resp = matchmaker_request(url=url, token=mme_token, method='POST')
resp_obj = {
'server' : node,
'patient_id' : patient,
'results' : json_resp.get('results'),
'status_code' : json_resp.get('status_code'),
'message' : json_resp.get('message') # None if request was successful
}
server_responses.append(resp_obj)
return server_responses
def mme_match(case_obj, match_type, mme_base_url, mme_token, nodes=None, mme_accepts=None):
"""Initiate a MatchMaker match against either other Scout patients or external nodes
Args:
case_obj(dict): a scout case object already submitted to MME
match_type(str): 'internal' or 'external'
mme_base_url(str): base url of the MME server
mme_token(str): auth token of the MME server
mme_accepts(str): request content accepted by MME server (only for internal matches)
Returns:
matches(list): a list of eventual matches
"""
query_patients = []
server_responses = []
url = None
# list of patient dictionaries is required for internal matching
query_patients = case_obj['mme_submission']['patients']
if match_type=='internal':
url = ''.join([mme_base_url,'/match'])
for patient in query_patients:
json_resp = matchmaker_request(url=url, token=mme_token, method='POST',
content_type=mme_accepts, accept=mme_accepts, data={'patient':patient})
resp_obj = {
'server' : 'Local MatchMaker node',
'patient_id' : patient['id'],
'results' : json_resp.get('results'),
'status_code' : json_resp.get('status_code'),
'message' : json_resp.get('message') # None if request was successful
}
server_responses.append(resp_obj)
else: # external matching
# external matching requires only patient ID
query_patients = [ patient['id'] for patient in query_patients]
node_ids = [ node['id'] for node in nodes ]
if match_type in node_ids: # match is against a specific external node
node_ids = [match_type]
# Match every affected patient
for patient in query_patients:
# Against every node
for node in node_ids:
url = ''.join([mme_base_url,'/match/external/', patient, '?node=', node])
json_resp = matchmaker_request(url=url, token=mme_token, method='POST')
resp_obj = {
'server' : node,
'patient_id' : patient,
'results' : json_resp.get('results'),
'status_code' : json_resp.get('status_code'),
'message' : json_resp.get('message') # None if request was successful
}
server_responses.append(resp_obj)
return server_responses
def mme_delete(case_obj, mme_base_url, mme_token):
"""Delete all affected samples for a case from MatchMaker
Args:
case_obj(dict) a scout case object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
server_responses(list): a list of object of this type:
{
'patient_id': patient_id
'message': server_message,
'status_code': server_status_code
}
"""
server_responses = []
if not mme_base_url or not mme_token:
return 'Please check that Matchmaker connection parameters are valid'
# for each patient of the case in matchmaker
for patient in case_obj['mme_submission']['patients']:
# send delete request to server and capture server's response
patient_id = patient['id']
url = ''.join([mme_base_url, '/patient/delete/', patient_id])
resp = matchmaker_request(
url=url,
token=mme_token,
method='DELETE',
)
server_responses.append({
'patient_id': patient_id,
'message': resp.get('message'),
'status_code': resp.get('status_code')
})
return server_responses
def mme_matches(case_obj, institute_obj, mme_base_url, mme_token):
"""Show Matchmaker submission data for a sample and eventual matches.
Args:
case_obj(dict): a scout case object
institute_obj(dict): an institute object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
data(dict): data to display in the html template
"""
data = {
'institute' : institute_obj,
'case' : case_obj,
'server_errors' : []
}
matches = {}
# loop over the submitted samples and get matches from the MatchMaker server
if not case_obj.get('mme_submission'):
return None
for patient in case_obj['mme_submission']['patients']:
patient_id = patient['id']
matches[patient_id] = None
url = ''.join([ mme_base_url, '/matches/', patient_id])
server_resp = matchmaker_request(url=url, token=mme_token, method='GET')
if 'status_code' in server_resp: # the server returned a valid response
# and this will be a list of match objects sorted by desc date
pat_matches = []
if server_resp.get('matches'):
pat_matches = parse_matches(patient_id, server_resp['matches'])
matches[patient_id] = pat_matches
else:
LOG.warning('Server returned error message: {}'.format(server_resp['message']))
data['server_errors'].append(server_resp['message'])
data['matches'] = matches
return data
def mme_matches(case_obj, institute_obj, mme_base_url, mme_token):
"""Show Matchmaker submission data for a sample and eventual matches.
Args:
case_obj(dict): a scout case object
institute_obj(dict): an institute object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
data(dict): data to display in the html template
"""
data = {
'institute' : institute_obj,
'case' : case_obj,
'server_errors' : []
}
matches = {}
# loop over the submitted samples and get matches from the MatchMaker server
if not case_obj.get('mme_submission'):
return None
for patient in case_obj['mme_submission']['patients']:
patient_id = patient['id']
matches[patient_id] = None
url = ''.join([ mme_base_url, '/matches/', patient_id])
server_resp = matchmaker_request(url=url, token=mme_token, method='GET')
if 'status_code' in server_resp: # the server returned a valid response
# and this will be a list of match objects sorted by desc date
pat_matches = []
if server_resp.get('matches'):
pat_matches = parse_matches(patient_id, server_resp['matches'])
matches[patient_id] = pat_matches
else:
LOG.warning('Server returned error message: {}'.format(server_resp['message']))
data['server_errors'].append(server_resp['message'])
data['matches'] = matches
return data
def mme_matches(case_obj, institute_obj, mme_base_url, mme_token):
"""Show Matchmaker submission data for a sample and eventual matches.
Args:
case_obj(dict): a scout case object
institute_obj(dict): an institute object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
data(dict): data to display in the html template
"""
data = {"institute": institute_obj, "case": case_obj, "server_errors": []}
matches = {}
# loop over the submitted samples and get matches from the MatchMaker server
if not case_obj.get("mme_submission"):
return None
for patient in case_obj["mme_submission"]["patients"]:
patient_id = patient["id"]
matches[patient_id] = None
url = "".join([mme_base_url, "/matches/", patient_id])
server_resp = matchmaker_request(url=url,
token=mme_token,
method="GET")
if "status_code" in server_resp: # the server returned a valid response
# and this will be a list of match objects sorted by desc date
pat_matches = []
if server_resp.get("matches"):
pat_matches = parse_matches(patient_id, server_resp["matches"])
matches[patient_id] = pat_matches
else:
LOG.warning("Server returned error message: {}".format(
server_resp["message"]))
data["server_errors"].append(server_resp["message"])
data["matches"] = matches
return data
def mme_delete(case_obj, mme_base_url, mme_token):
"""Delete all affected samples for a case from MatchMaker
Args:
case_obj(dict) a scout case object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
server_responses(list): a list of object of this type:
{
'patient_id': patient_id
'message': server_message,
'status_code': server_status_code
}
"""
server_responses = []
if not mme_base_url or not mme_token:
return "Please check that Matchmaker connection parameters are valid"
# for each patient of the case in matchmaker
for patient in case_obj["mme_submission"]["patients"]:
# send delete request to server and capture server's response
patient_id = patient["id"]
url = "".join([mme_base_url, "/patient/delete/", patient_id])
resp = matchmaker_request(url=url, token=mme_token, method="DELETE")
server_responses.append(
{
"patient_id": patient_id,
"message": resp.get("message"),
"status_code": resp.get("status_code"),
}
)
return server_responses
def mme_delete(case_obj, mme_base_url, mme_token):
"""Delete all affected samples for a case from MatchMaker
Args:
case_obj(dict) a scout case object
mme_base_url(str) base url of the MME server
mme_token(str) auth token of the MME server
Returns:
server_responses(list): a list of object of this type:
{
'patient_id': patient_id
'message': server_message,
'status_code': server_status_code
}
"""
server_responses = []
if not mme_base_url or not mme_token:
return 'Please check that Matchmaker connection parameters are valid'
# for each patient of the case in matchmaker
for patient in case_obj['mme_submission']['patients']:
# send delete request to server and capture server's response
patient_id = patient['id']
url = ''.join([mme_base_url, '/patient/delete/', patient_id])
resp = matchmaker_request(url=url, token=mme_token, method='DELETE', )
server_responses.append({
'patient_id': patient_id,
'message': resp.get('message'),
'status_code': resp.get('status_code')
})
return server_responses
def mme_add(
store,
user_obj,
case_obj,
add_gender,
add_features,
add_disorders,
genes_only,
mme_base_url,
mme_accepts,
mme_token,
):
"""Add a patient to MatchMaker server
Args:
store(adapter.MongoAdapter)
user_obj(dict) a scout user object (to be added as matchmaker contact)
case_obj(dict) a scout case object
add_gender(bool) if True case gender will be included in matchmaker
add_features(bool) if True HPO features will be included in matchmaker
add_disorders(bool) if True OMIM diagnoses will be included in matchmaker
genes_only(bool) if True only genes and not variants will be shared
mme_base_url(str) base url of the MME server
mme_accepts(str) request content accepted by MME server
mme_token(str) auth token of the MME server
Returns:
submitted_info(dict) info submitted to MatchMaker and its responses
"""
if not mme_base_url or not mme_accepts or not mme_token:
return "Please check that Matchmaker connection parameters are valid"
url = "".join([mme_base_url, "/patient/add"])
features = [] # this is the list of HPO terms
disorders = [] # this is the list of OMIM diagnoses
g_features = []
# create contact dictionary
contact_info = {
"name": user_obj["name"],
"href": "".join(["mailto:", user_obj["email"]]),
"institution": "Scout software user, Science For Life Laboratory, Stockholm, Sweden",
}
if add_features: # create features dictionaries
features = hpo_terms(case_obj)
if add_disorders: # create OMIM disorders dictionaries
disorders = omim_terms(case_obj)
# send a POST request and collect response for each affected individual in case
server_responses = []
submitted_info = {
"contact": contact_info,
"sex": add_gender,
"features": features,
"disorders": disorders,
"genes_only": genes_only,
"patient_id": [],
}
for individual in case_obj.get("individuals"):
if not individual["phenotype"] in [
2,
"affected",
]: # include only affected individuals
continue
patient = {
"contact": contact_info,
"id": ".".join(
[case_obj["_id"], individual.get("individual_id")]
), # This is a required field form MME
"label": ".".join([case_obj["display_name"], individual.get("display_name")]),
"features": features,
"disorders": disorders,
}
if add_gender:
if individual["sex"] == "1":
patient["sex"] = "MALE"
else:
patient["sex"] = "FEMALE"
if case_obj.get("suspects"):
g_features = genomic_features(
store, case_obj, individual.get("display_name"), genes_only
)
patient["genomicFeatures"] = g_features
# send add request to server and capture response
resp = matchmaker_request(
url=url,
token=mme_token,
method="POST",
content_type=mme_accepts,
accept="application/json",
data={"patient": patient},
)
server_responses.append(
{
"patient": patient,
"message": resp.get("message"),
"status_code": resp.get("status_code"),
}
)
submitted_info["server_responses"] = server_responses
return submitted_info
def mme_add(store, user_obj, case_obj, add_gender, add_features, add_disorders,
genes_only, mme_base_url, mme_accepts, mme_token):
"""Add a patient to MatchMaker server
Args:
store(adapter.MongoAdapter)
user_obj(dict) a scout user object (to be added as matchmaker contact)
case_obj(dict) a scout case object
add_gender(bool) if True case gender will be included in matchmaker
add_features(bool) if True HPO features will be included in matchmaker
add_disorders(bool) if True OMIM diagnoses will be included in matchmaker
genes_only(bool) if True only genes and not variants will be shared
mme_base_url(str) base url of the MME server
mme_accepts(str) request content accepted by MME server
mme_token(str) auth token of the MME server
Returns:
submitted_info(dict) info submitted to MatchMaker and its responses
"""
if not mme_base_url or not mme_accepts or not mme_token:
return 'Please check that Matchmaker connection parameters are valid'
url = ''.join([mme_base_url, '/patient/add'])
features = [] # this is the list of HPO terms
disorders = [] # this is the list of OMIM diagnoses
g_features = []
# create contact dictionary
contact_info = {
'name':
user_obj['name'],
'href':
''.join(['mailto:', user_obj['email']]),
'institution':
'Scout software user, Science For Life Laboratory, Stockholm, Sweden'
}
if add_features: # create features dictionaries
features = hpo_terms(case_obj)
if add_disorders: # create OMIM disorders dictionaries
disorders = omim_terms(case_obj)
# send a POST request and collect response for each affected individual in case
server_responses = []
submitted_info = {
'contact': contact_info,
'sex': add_gender,
'features': features,
'disorders': disorders,
'genes_only': genes_only,
'patient_id': []
}
for individual in case_obj.get('individuals'):
if not individual['phenotype'] in [
2, 'affected'
]: # include only affected individuals
continue
patient = {
'contact':
contact_info,
'id':
'.'.join([case_obj['_id'],
individual.get('individual_id')
]), # This is a required field form MME
'label':
'.'.join(
[case_obj['display_name'],
individual.get('display_name')]),
'features':
features,
'disorders':
disorders
}
if add_gender:
if individual['sex'] == '1':
patient['sex'] = 'MALE'
else:
patient['sex'] = 'FEMALE'
if case_obj.get('suspects'):
g_features = genomic_features(store, case_obj,
individual.get('display_name'),
genes_only)
patient['genomicFeatures'] = g_features
# send add request to server and capture response
resp = matchmaker_request(url=url,
token=mme_token,
method='POST',
content_type=mme_accepts,
accept='application/json',
data={'patient': patient})
server_responses.append({
'patient': patient,
'message': resp.get('message'),
'status_code': resp.get('status_code')
})
submitted_info['server_responses'] = server_responses
return submitted_info
def mme_add(store, user_obj, case_obj, add_gender, add_features, add_disorders, genes_only,
mme_base_url, mme_accepts, mme_token):
"""Add a patient to MatchMaker server
Args:
store(adapter.MongoAdapter)
user_obj(dict) a scout user object (to be added as matchmaker contact)
case_obj(dict) a scout case object
add_gender(bool) if True case gender will be included in matchmaker
add_features(bool) if True HPO features will be included in matchmaker
add_disorders(bool) if True OMIM diagnoses will be included in matchmaker
genes_only(bool) if True only genes and not variants will be shared
mme_base_url(str) base url of the MME server
mme_accepts(str) request content accepted by MME server
mme_token(str) auth token of the MME server
Returns:
submitted_info(dict) info submitted to MatchMaker and its responses
"""
if not mme_base_url or not mme_accepts or not mme_token:
return 'Please check that Matchmaker connection parameters are valid'
url = ''.join([mme_base_url, '/patient/add'])
features = [] # this is the list of HPO terms
disorders = [] # this is the list of OMIM diagnoses
g_features = []
# create contact dictionary
contact_info = {
'name' : user_obj['name'],
'href' : ''.join( ['mailto:',user_obj['email']] ),
'institution' : 'Scout software user, Science For Life Laboratory, Stockholm, Sweden'
}
if add_features: # create features dictionaries
features = hpo_terms(case_obj)
if add_disorders: # create OMIM disorders dictionaries
disorders = omim_terms(case_obj)
# send a POST request and collect response for each affected individual in case
server_responses = []
submitted_info = {
'contact' : contact_info,
'sex' : add_gender,
'features' : features,
'disorders' : disorders,
'genes_only' : genes_only,
'patient_id' : []
}
for individual in case_obj.get('individuals'):
if not individual['phenotype'] in [2, 'affected']: # include only affected individuals
continue
patient = {
'contact' : contact_info,
'id' : '.'.join([case_obj['_id'], individual.get('individual_id')]), # This is a required field form MME
'label' : '.'.join([case_obj['display_name'], individual.get('display_name')]),
'features' : features,
'disorders' : disorders
}
if add_gender:
if individual['sex'] == '1':
patient['sex'] = 'MALE'
else:
patient['sex'] = 'FEMALE'
if case_obj.get('suspects'):
g_features = genomic_features(store, case_obj, individual.get('display_name'), genes_only)
patient['genomicFeatures'] = g_features
# send add request to server and capture response
resp = matchmaker_request(url=url, token=mme_token, method='POST', content_type=mme_accepts,
accept='application/json', data={'patient':patient})
server_responses.append({
'patient': patient,
'message': resp.get('message'),
'status_code' : resp.get('status_code')
})
submitted_info['server_responses'] = server_responses
return submitted_info
