def callMes(call_record, sample_name, variant_id):
gaVariantC = variants_pb2.Call()
call_set_id = uuid.uuid4()
gaVariantC.call_set_name = sample_name
gaVariantC.call_set_id = str(call_set_id)
try:
if call_record.allele_indices is not None:
gaVariantC.genotype.extend(list(call_record.allele_indices))
except:
pass
if call_record.phased:
phaseset = str(call_record.phased)
gaVariantC.phaseset = str(phaseset)
for key, value in call_record.iteritems():
if key == 'GL' and value is not None:
gtlikelihood = value
gaVariantC.genotype_likelihood.extend(list(gtlikelihood)) #GTLikelihood is not always in a VCF File
gaVariantC.info["variant_id"].append(str(variant_id))
c_FileName = gaVariantC.call_set_id
if p.protobuf is None:
c_txt_FileName = c_FileName + '.txt'
else:
c_txt_FileName = c_FileName + '.pb'
if not os.path.isfile(c_txt_FileName):
fout3 = open(os.path.join("output2/variantSet/variants/calls", c_txt_FileName), 'w')
if p.protobuf is None:
fout3.write (json.dumps(json_format._MessageToJsonObject(gaVariantC, True)))
else:
fout3.write (gaVariantC.SerializeToString())
fout3.close()
if "db" in globals():
calls.insert_one(json_format._MessageToJsonObject(gaVariantC, True))
callSet(sampleNames, gaVariantC.call_set_id)
return gaVariantC
def callSet(sampleNames, callSetId, outputDirectory, p):
"""Creates a GA4GH Call Set Message."""
gaVariantCS = variants_pb2.CallSet()
gaVariantCS.name = str(sampleNames)
#gaVariantCS.bio_sample_id = //Leave blank
gaVariantCS.variant_set_ids.append(str(vsID))
gaVariantCS.created = int(time.time())
gaVariantCS.updated = int(time.time())
#gaVariantCS.info = //Not currently utilized
cs_FileName = callSetId
if p.protobuf is None:
cs_txt_FileName = cs_FileName + '.txt'
else:
cs_txt_FileName = cs_FileName + '.pb'
if not os.path.isfile(cs_txt_FileName):
fout4 = open(
os.path.join(outputDirectory, "variantSet/variants/calls/callsets",
cs_txt_FileName), 'w')
if p.protobuf is None:
fout4.write(
json.dumps(json_format._MessageToJsonObject(gaVariantCS, True)))
else:
fout4.write(gaVariantCS.SerializeToString())
fout4.close()
if p.database:
callset.insert_one(json_format._MessageToJsonObject(gaVariantCS, True))
def search_variant_sets(request):
"""Handles requests at the /variantsets/search endpoint"""
invalid_request = validate_search_variant_sets_request(request)
if invalid_request:
return invalid_request
else:
try:
req_dict = json_format.Parse(request.body, variant_service.SearchVariantSetsRequest())
except Exception as e :
return HttpResponseBadRequest(json.dumps({"message": e.message.replace("\"", "'")}),
content_type='application/json')
dataset_id = req_dict.dataset_id
page_size = req_dict.page_size
page_token = req_dict.page_token
if dataset_id != DATASET_ID:
"""Bad Request returns empty response"""
return JsonResponse(
json_format._MessageToJsonObject(
variant_service.SearchCallSetsResponse(), True))
if not page_size or page_size == 0:
page_size = DEFAULT_PAGE_SIZE
if not page_token:
page_token = '0'
response = variant_service.SearchVariantSetsResponse()
variant_sets_list = [obtain_variant_set_for_set(i) for i in SET_IDS]
variant_sets_list = ga4gh_brca_page(variant_sets_list, int(page_size), int(page_token))
if len(variant_sets_list) > page_size:
variant_sets_list.pop()
page_token = str(1 + int(page_token))
response.next_page_token = page_token
for sets in variant_sets_list:
response.variant_sets.extend([sets])
return JsonResponse(json_format._MessageToJsonObject(response, True))
def test_ga4gh_translator(self):
var_resp = vrs.Variant()
resp = Variant.objects.values()[0]
for j in resp:
if j == "Genomic_Coordinate_hg37":
var_resp.reference_name, start, bases = resp[j].split(':')
var_resp.reference_bases, alternbases = bases.split(">")
for i in range(len(alternbases)):
var_resp.alternate_bases.append(alternbases[i])
var_resp.start = int(start)
var_resp.end = var_resp.start + len(alternbases)
continue
if j == "id":
var_resp.id = str(resp['id'])
var_resp.variant_set_id = "brca_exchange_hg37"
var_resp.names.append("This are names")
var_resp.created = 0
var_resp.updated = 0
continue
else:
var_resp.info[str(j)].append(resp[j])
expectedResp = json.dumps(json_format._MessageToJsonObject(var_resp, False))
jresponse = json.dumps(json_format._MessageToJsonObject(brca_to_ga4gh(resp), False))
self.assertJSONEqual(jresponse , expectedResp)
def variantSet(hdr, outputDirectory, p, variantset=None):
"""
Creates GA4GH Variant Set message.
Also contains the files metadata by calling vHeader function.
"""
ranId = uuid.uuid4()
gaVariantVS = variants_pb2.VariantSet()
#gaVariantVS.reference_set_id = pysam has .rid but all files show as 0 for value
gaVariantVS.id = str(vsID)
gaVariantVS.name = str(hdr.contigs)
gaVariantVS.dataset_id = str(ranId)
gaVariantVS.metadata.extend(vHeader(hdr))
if p.protobuf is None:
vSet_FileName = vsID + '.txt'
else:
vSet_FileName = vsID + '.pb'
with open(os.path.join(outputDirectory, "variantSet", vSet_FileName),
'w') as fout1:
if p.protobuf is None:
fout1.write(
json.dumps(json_format._MessageToJsonObject(gaVariantVS,
True)))
else:
fout1.write(gaVariantVS.SerializeToString())
if p.database:
variantset.insert_one(
json_format._MessageToJsonObject(gaVariantVS, True))
def vMes(variant, outputDirectory, params):
"""
Creates a GA4GH variant message.
Calls the Call Message function also.
"""
def _encodeValue(value):
"""this function taken from ga4gh/datamodel/variants.py."""
if isinstance(value, (list, tuple)):
return [struct_pb2.Value(string_value=str(v)) for v in value]
else:
return [struct_pb2.Value(string_value=str(value))]
ranId = uuid.uuid4()
gaVariant = variants_pb2.Variant()
gaVariant.variant_set_id = str(vsID)
variant_id = ranId
gaVariant.id = str(variant_id)
gaVariant.reference_name = variant.contig
gaVariant.created = int(time.time())
gaVariant.updated = int(time.time())
gaVariant.start = variant.start
gaVariant.end = variant.stop
gaVariant.reference_bases = variant.ref
if variant.alts is not None:
gaVariant.alternate_bases.extend(list(variant.alts))
for key, value in variant.info.iteritems():
if value is not None:
gaVariant.info[key].values.extend(_encodeValue(value))
if variant.id is not None:
gaVariant.names.append(variant.id)
else:
variant.id = None
for sample_name in sampleNames:
call_record = variant.samples[sample_name]
gaVariant.calls.extend([
callMes(call_record, sample_name, variant_id, outputDirectory, p)
])
if params.protobuf is None:
v_FileName = gaVariant.id + '.txt'
else:
v_FileName = gaVariant.id + '.pb'
if not os.path.isfile(v_FileName):
fout2 = open(
os.path.join(outputDirectory, "variantSet/variants", v_FileName),
'w')
if params.database:
variantd.insert_one(json_format._MessageToJsonObject(gaVariant, True))
if params.protobuf is None:
fout2.write(
json.dumps(json_format._MessageToJsonObject(gaVariant, True)))
fout2.close()
else:
fout2.write(gaVariant.SerializeToString())
fout2.close()
return
def index_num_2(request):
conditional = validate_request(request)
if conditional :
return conditional
else:
req_dict = json.loads(request.body)
variant_set_id = req_dict.get('variantSetId')
reference_name = req_dict.get('referenceName')
start = req_dict.get('start')
end = req_dict.get('end')
page_size = req_dict.get('pageSize', 1)
page_token = req_dict.get('pageToken', "0")
response0 = v_s.SearchVariantsResponse()
filt = str(reference_name)+":"
DbResp = Variant.objects
DbResp = DbResp.filter(Genomic_Coordinate_hg37__startswith=filt)
ret_data = ga4gh_brca_page(DbResp, int(page_size), int(page_token))
ga_vars = [brca_to_ga4gh(i) for i in ret_data.values()]
if len(ga_vars) > page_size:
ga_vars.pop()
page_token = str(1 + int(page_token))
else:
response0.next_page_token = ""
response0.variants.extend(ga_vars)
response0.next_page_token = page_token
resp = json_format._MessageToJsonObject(response0, True)
return JsonResponse(resp)
def toJson(protoObject, indent=None):
"""
Serialises a protobuf object as json
"""
# Using the internal method because this way we can reformat the JSON
js = json_format._MessageToJsonObject(protoObject, True)
return json.dumps(js, indent=indent)
def test_brca_to_ga4gh(self):
"""
Gets rows from database and converts them into tests that
ensure the function brca_to_ga4gh makes well formed GA4GH messages.
"""
variant = {
'Genomic_Coordinate_hg37': 'chr13:32923951:CA>C',
'Reference_Name': 'chr13',
'id': 1,
'Hg37_End': 32923951,
'Genomic_Coordinate_hg36': 'chr13:31821951:CA>C',
'Hg36_Start': 31821950,
'Hg37_Start': 32923950,
'Genomic_Coordinate_hg38': 'chr13:32349814:CA>C',
'Hg38_End': 32349814,
'Hg36_End': 31821951,
'Hg38_Start': 32349813,
'Synonyms': 'U43746.1:c.7234+2936delA'
}
genomic_coordinate = "hg37"
response = views.brca_to_ga4gh(variant, genomic_coordinate)
json_response = json_format._MessageToJsonObject(response, True)
self.assertEqual(int(json_response['start']), 32923950)
self.assertEqual(json_response['referenceBases'], "CA")
self.assertEqual(json_response['alternateBases'][0], "C")
self.assertEqual(json_response['referenceName'], "chr13")
self.assertEqual(json_response['id'], "hg37-1")
def toJson(protoObject, indent=None):
"""
Serialises a protobuf object as json
"""
# Using the internal method because this way we can reformat the JSON
js = json_format._MessageToJsonObject(protoObject, True)
return json.dumps(js, indent=indent)
def get_variant(request, variant_id):
"""Handles requests to the /variants/<variant id> endpoint"""
if not variant_id:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['variantId']),
content_type='application/json')
else:
set_id, v_id = variant_id.split('-')
if set_id in SET_IDS:
variants = Variant.objects.values()
try:
variant = variants.get(id=int(v_id))
except Exception:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['notFoundId']),
content_type='application/json',
status=404)
ga_variant = brca_to_ga4gh(variant, set_id)
response = json_format._MessageToJsonObject(ga_variant, True)
return JsonResponse(response)
else:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['notFoundId']),
content_type='application/json',
status=404)
def callSet(sampleNames):
gaVariantCS = variants_pb2.CallSet()
gaVariantCS.name = str(sampleNames)
#gaVariantCS.bio_sample_id = //Leave blank
gaVariantCS.variant_set_ids.append(str(vsID))
gaVariantCS.created = int(time.time())
gaVariantCS.updated = int(time.time())
#gaVariantCS.info = //seems useless
cs_FileName = "Call_Sets"
cs_txt_FileName = cs_FileName + '.txt'
if not os.path.isfile(cs_txt_FileName):
fout4 = open(os.path.join("output2/variantSet/variants/calls/callsets", cs_txt_FileName), 'w')
fout4.write (json.dumps(json_format._MessageToJsonObject(gaVariantCS, True)))
fout4.close()
if "db" in globals():
callset.insert_one(json_format._MessageToJsonObject(gaVariantCS, True))
return gaVariantCS
def callMes(call_record, sample_name, variant_id, outputDirectory, params):
"""
Creates a GA4GH Call message.
Calls the CallSet function, sends it sampleNames and the call set ID.
"""
gaVariantC = variants_pb2.Call()
call_set_id = uuid.uuid4()
gaVariantC.call_set_name = sample_name
gaVariantC.call_set_id = str(call_set_id)
try:
if call_record.allele_indices is not None:
gaVariantC.genotype.extend(list(call_record.allele_indices))
except:
pass
if call_record.phased:
phaseset = str(call_record.phased)
gaVariantC.phaseset = str(phaseset)
for key, value in call_record.iteritems():
if key == 'GL' and value is not None:
gtlikelihood = value
gaVariantC.genotype_likelihood.extend(
list(gtlikelihood)) #GTLikelihood is not always in a VCF File
# I commented this line b/c I couldn't get something working.
#gaVariantC.info["variant_id"].append(str(variant_id))
c_FileName = gaVariantC.call_set_id
if params.protobuf is None:
c_txt_FileName = c_FileName + '.txt'
else:
c_txt_FileName = c_FileName + '.pb'
if not os.path.isfile(c_txt_FileName):
fout3 = open(
os.path.join(outputDirectory, "variantSet/variants/calls",
c_txt_FileName), 'w')
if params.protobuf is None:
fout3.write(
json.dumps(json_format._MessageToJsonObject(gaVariantC, True)))
else:
fout3.write(gaVariantC.SerializeToString())
fout3.close()
if params.database:
calls.insert_one(json_format._MessageToJsonObject(gaVariantC, True))
callSet(sampleNames, gaVariantC.call_set_id, outputDirectory, params)
return gaVariantC
def variantSet(hdr):
ranId = uuid.uuid4()
gaVariantVS = variants_pb2.VariantSet()
#gaVariantVS.reference_set_id = pysam has .rid but all files show as 0 for value
gaVariantVS.id = str(vsID)
gaVariantVS.name = str(hdr.contigs)
gaVariantVS.dataset_id = str(ranId)
gaVariantVS.metadata.extend(vHeader(hdr))
if p.protobuf is None:
vSet_FileName = vsID + '.txt'
else:
vSet_FileName = vsID + '.pb'
fout1 = open(os.path.join("output2/variantSet", vSet_FileName), 'w')
if p.protobuf is None:
fout1.write (json.dumps(json_format._MessageToJsonObject(gaVariantVS, True)))
else:
fout1.write (gaVariantVS.SerializeToString())
fout1.close()
if "db" in globals():
variantset.insert_one(json_format._MessageToJsonObject(gaVariantVS, True))
def vMes(variant):
ranId = uuid.uuid4()
gaVariant = variants_pb2.Variant()
gaVariant.variant_set_id = str(vsID)
variant_id = ranId
gaVariant.id = str(variant_id)
gaVariant.reference_name = variant.contig
gaVariant.created = int(time.time())
gaVariant.updated = int(time.time())
gaVariant.start = variant.start
gaVariant.end = variant.stop
gaVariant.reference_bases = variant.ref
if variant.alts is not None:
gaVariant.alternate_bases.extend(list(variant.alts))
for key, value in variant.info.iteritems():
if value is not None:
gaVariant.info[key].values.extend(_encodeValue(value))
if variant.id is not None:
gaVariant.names.append(variant.id)
else:
variant.id = None
for sample_name in sampleNames:
call_record = variant.samples[sample_name]
gaVariant.calls.extend([callMes(call_record,sample_name,variant_id)])
if p.protobuf is None:
v_FileName = gaVariant.id + '.txt'
else:
v_FileName = gaVariant.id + '.pb'
if not os.path.isfile(v_FileName):
fout2 = open(os.path.join("output2/variantSet/variants", v_FileName), 'w')
if "db" in globals():
variantd.insert_one(json_format._MessageToJsonObject(gaVariant, True))
if p.protobuf is None:
fout2.write (json.dumps(json_format._MessageToJsonObject(gaVariant, True)))
fout2.close()
else:
fout2.write (gaVariant.SerializeToString())
fout2.close()
return
def get_var_by_id(request, variant_id):
if not variant_id:
return JsonResponse(ErrorMessages['variantId'])
else:
gen_coor_and_id = variant_id
gen_coor, v_id = gen_coor_and_id.split("-")
DbResp = Variant.objects.values()
resp1 = DbResp.get(id=int(v_id))
Var_resp = brca_to_ga4gh(resp1)
resp = json_format._MessageToJsonObject(Var_resp, True)
return JsonResponse(resp)
def callSet(sampleNames, callSetId):
gaVariantCS = variants_pb2.CallSet()
gaVariantCS.name = str(sampleNames)
#gaVariantCS.bio_sample_id = //Leave blank
gaVariantCS.variant_set_ids.append(str(vsID))
gaVariantCS.created = int(time.time())
gaVariantCS.updated = int(time.time())
#gaVariantCS.info = //Not currently utilized
cs_FileName = callSetId
if p.protobuf is None:
cs_txt_FileName = cs_FileName + '.txt'
else:
cs_txt_FileName = cs_FileName + '.pb'
if not os.path.isfile(cs_txt_FileName):
fout4 = open(os.path.join("output2/variantSet/variants/calls/callsets", cs_txt_FileName), 'w')
if p.protobuf is None:
fout4.write (json.dumps(json_format._MessageToJsonObject(gaVariantCS, True)))
else:
fout4.write (gaVariantCS.SerializeToString())
fout4.close()
if "db" in globals():
callset.insert_one(json_format._MessageToJsonObject(gaVariantCS, True))
return
def get_dataset(request, dataset_id):
"""/datasets/<dataset id> get dataset via id method"""
if not dataset_id:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['datasetId']),
content_type='application/json')
response = metadata_service.GetDatasetRequest()
dataset = metadata.Dataset()
response.dataset_id = dataset_id
dataset.id = DATASET_ID
dataset.name = SETNAME
dataset.description = 'Variants observed in brca-exchange project'
# Needs field for info, still not available from ga4gh client
return JsonResponse(json_format._MessageToJsonObject(dataset, False))
def main():
if p.database is not None:
global db
db = get_db(p.database)
variantset = db.VariantSet
variantd = db.Variants
global calls
calls = db.Calls
global callset
callset = db.CallSets
#if the directory does not already exist then create it
if not os.path.exists("output2/variantSet/variants/calls/callsets"):
os.makedirs("output2/variantSet/variants/calls/callsets")
vSet_FileName = vsID + '.txt'
fout1 = open(os.path.join("output2/variantSet", vSet_FileName), 'w')
fout1.write (json.dumps(json_format._MessageToJsonObject(variantSet(hdr), True)))
fout1.close()
count = 0
#checking if the database option was chosen
if "db" in globals():
variantset.insert_one(json_format._MessageToJsonObject(variantSet(hdr), True))
pBar.start()
for variant in vcfFile.fetch(chrom):
count += 1
if count % 100 == 0:
pBar.update()
v_FileName = variant.id + '.txt'
#checking if the database option was chosen
if "db" in globals():
variantd.insert_one(json_format._MessageToJsonObject(vMes(variant), True))
if not os.path.isfile(v_FileName):
fout2 = open(os.path.join("output2/variantSet/variants", v_FileName), 'w')
fout2.write (json.dumps(json_format._MessageToJsonObject(vMes(variant), True)))
pBar.finish()
fout2.close()
return
def callMes(call_record, sample_name):
gaVariantC = variants_pb2.Call()
call_set_id = uuid.uuid4()
gaVariantC.call_set_name = sample_name
gaVariantC.call_set_id = str(call_set_id)
gaVariantC.genotype.extend(list(call_record.allele_indices))
if call_record.phased:
phaseset = str(call_record.phased)
gaVariantC.phaseset = str(phaseset)
for key, value in call_record.iteritems():
if key == 'GL' and value is not None:
gtlikelihood = value
gaVariantC.genotype_likelihood.extend(list(gtlikelihood))
#gaVariantC.info
c_FileName = gaVariantC.call_set_id
c_txt_FileName = c_FileName + '.txt'
if not os.path.isfile(c_txt_FileName):
fout3 = open(os.path.join("output2/variantSet/variants/calls", c_txt_FileName), 'w')
fout3.write (json.dumps(json_format._MessageToJsonObject(gaVariantC, True)))
fout3.close()
if "db" in globals():
calls.insert_one(json_format._MessageToJsonObject(gaVariantC, True))
callSet(sampleNames)
return gaVariantC
def test_validated_request(self):
request = v_s.SearchVariantsRequest()
req = self.factory.post("/data/ga4gh/variants/search", json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = index_num_2(req)
self.assertJSONEqual(response.content, ErrorMessages['VariantSetId'])
request.variant_set_id = "Something not null"
req = self.factory.post("/data/ga4gh/variants/search", json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = index_num_2(req)
self.assertJSONEqual(response.content, ErrorMessages['referenceName'])
request.reference_name = "chr17"
req= self.factory.post("/data/ga4gh/variants/search", json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = index_num_2(req)
self.assertJSONEqual(response.content, ErrorMessages['start'])
request.start = 14589
req = self.factory.post("/data/ga4gh/variants/search", json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = index_num_2(req)
self.assertJSONEqual(response.content, ErrorMessages['end'])
def get_varset_by_id(request, variantSetId):
if not variantSetId :
return JsonResponse(ErrorMessages["variantSetId"])
dataset, Id = variantSetId.split("-")
if Id in SetIds:
response = vrs.VariantSet()
response.id = dataset + "-" + Id
response.name = name + "-" + Id
response.dataset_id = name
response.reference_set_id = referenceSetId + "-" + Id
brca_meta(response.metadata, Id)
resp = json_format._MessageToJsonObject(response, False)
return JsonResponse(resp)
else:
return JsonResponse({"Invalid Set Id": Id})
def get_variant_set(request, variant_set_id):
"""/variantsets/<set id> method"""
if not variant_set_id:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['variantSetId']),
content_type='application/json')
dataset, id_ = variant_set_id.split('-')
if id_ in SET_IDS and dataset == 'brca':
variant_set = variants.VariantSet()
variant_set.id = '{}-{}'.format(dataset, id_)
variant_set.name = '{}-{}'.format(SETNAME, id_)
variant_set.dataset_id = DATASET_ID
variant_set.reference_set_id = '{}-{}'.format(REFERENCE_SET_BASE, id_)
brca_meta(variant_set.metadata, id_)
resp = json_format._MessageToJsonObject(variant_set, True)
return JsonResponse(resp)
else:
return JsonResponse({'Invalid Set Id': variant_set_id}, status=404)
def search_datasets(request):
"""/datasets/search method request handler"""
if not request.body:
page_size = DEFAULT_PAGE_SIZE
page_token = '0'
else:
try :
request_dict = json_format.Parse(request.body, metadata_service.SearchDatasetsRequest())
except Exception as e:
return HttpResponseBadRequest(json.dumps({"message": e.message.replace("\"", "'")}), content_type='application/json')
page_size = request_dict.page_size
page_token = request_dict.page_token
if not page_size or page_size == 0:
page_size = DEFAULT_PAGE_SIZE
if not page_token:
page_token = '0'
response = metadata_service.SearchDatasetsResponse()
dataset = metadata.Dataset()
dataset.name = SETNAME
dataset.id = DATASET_ID
dataset.description = 'Variants observed in brca-exchange project'
# TODO uncomment when ga4gh client implements info field otherwise hardcoded values are placed
#dataset.info[SETNAME].append("This set contains variants as stored and mantained by the brca-exchange project")
list_of_sets = []
list_of_sets.append(dataset)
sets = ga4gh_brca_page(list_of_sets, int(page_size), int(page_token))
response.next_page_token
if len(sets) > page_size:
page_token = str(1 + int(page_token))
response.next_page_token = page_token
##############
# TODO Block gets fixed when ga4gh client implements
# info field otherwise hardcoded values are placed
if sets:
response.datasets.extend(sets)
else:
response.next_page_token = ' '
response.datasets.extend([metadata.Dataset()])
##############
return JsonResponse(json_format._MessageToJsonObject(response, False))
def search_variants(request):
"""Handles requests to the /variants/search method"""
conditional = validate_search_variants_request(request)
if conditional :
return conditional
else:
try:
protocol_variable = json_format.Parse(request.body, variant_service.SearchVariantsRequest())
except Exception as e:
return HttpResponseBadRequest(json.dumps({"message": e.message.replace("\"", "'")}),
content_type='application/json')
variant_set_id = protocol_variable.variant_set_id
reference_name = protocol_variable.reference_name
start = protocol_variable.start
end = protocol_variable.end
page_size = protocol_variable.page_size
page_token = protocol_variable.page_token
if not page_size or page_size == 0:
page_size = DEFAULT_PAGE_SIZE
if not page_token:
page_token = '0'
response = variant_service.SearchVariantsResponse()
variants = Variant.objects
dataset_id, reference_genome = variant_set_id.split('-')
if dataset_id != DATASET_ID:
return HttpResponseBadRequest(
json.dumps(ErrorMessages['variantSetId']),
content_type='application/json')
variants = range_filter(reference_genome, variants, reference_name, start, end)
variants = ga4gh_brca_page(variants, int(page_size), int(page_token))
ga_variants = [brca_to_ga4gh(i, reference_genome) for i in variants.values()]
if len(ga_variants) > page_size:
ga_variants.pop()
page_token = str(1 + int(page_token))
response.next_page_token = page_token
response.variants.extend(ga_variants)
resp = json_format._MessageToJsonObject(response, True)
return JsonResponse(resp)
def get_variantSet(request):
condit = validate_varsetreq(request)
if condit:
return condit
else:
req_dict = json.loads(request.body)
dataset_id = req_dict.get('datasetId')
page_size = req_dict.get('pageSize', 3)
page_token = req_dict.get('pageToken', '0')
response1 = v_s.SearchVariantSetsResponse()
response1.next_page_token = page_token
response = vrs.VariantSet()
response.id = datasetId+"-"+dataset_id
response.name = name+"-"+dataset_id
response.dataset_id = name
response.reference_set_id = referenceSetId+"-"+dataset_id
brca_meta(response.metadata, dataset_id)
response1.variant_sets.extend([response])
resp = json_format._MessageToJsonObject(response1, True)
return JsonResponse(resp)
def test_search_variants_request_validation(self):
"""Ensures the search variants endpoint responds with expected failure modes"""
request = variant_service.SearchVariantsRequest()
req = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEqual(response.status_code, 400,
"No variant set ID should 400")
self.assertJSONEqual(
response.content, views.ErrorMessages['variantSetId'],
"No variant set ID in the request should provide a useful error")
request.variant_set_id = "Something not null"
req = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 400)
self.assertJSONEqual(
response.content, views.ErrorMessages['referenceName'],
"A useful error is thrown when the reference name is not present")
request.reference_name = "chr17"
req = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(
response.content, views.ErrorMessages['start'],
"A useful error is thrown when no start is present")
request.start = 14589
req = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertJSONEqual(
response.content, views.ErrorMessages['end'],
"A useful error is provided when no end is present")
request.end = 143295
req = self.factory.post(
"/data/ga4gh/variants/search",
json.dumps(json_format._MessageToJsonObject(request, False)),
content_type="application/json")
response = views.search_variants(req)
self.assertEquals(response.status_code, 404,
"A bad variant set ID should 404")
# Test for an end value less than the end value
test_request = self.factory.post("/data/ga4gh/variants/search",
json.dumps({
"referenceName": "chr17",
"variantSetId": "brca-hg37",
"start": 10000,
"end": 1000
}),
content_type="application/json")
response_x = views.search_variants(test_request)
self.assertEqual(response_x.status_code, 400)
self.assertJSONEqual(response_x.content,
views.ErrorMessages['invalidPositions'])
def toFlaskJson(protoObject): """ Serialises a protobuf object as a flask Response object """ js = json_format._MessageToJsonObject(protoObject, True) return buildResponse(nullifyToken(js))
