def add_tx_method(params):
"""
Adds tx_method record or returns tx_method record if already exists
"""
method_name = params['tx_method']
try:
tx_method = TxMethod.query.filter_by(method_name=method_name) \
.one_or_none()
if tx_method:
logger.info(
"TxMethod with method name [{}] already exists.".format(
method_name))
return tx_method
tx_method = TxMethod(method_name)
db_util.db_add_query(tx_method)
db_util.db_commit()
logger.info(
"Transformation method record for method {} added successfully.".
format(method_name))
tx_method = TxMethod.query.filter_by(method_name=method_name) \
.one_or_none()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to fetch Transformation method id for method '
'[{}] with error {} '.format(method_name, e))
return tx_method
def add_request_comments(request_id, params):
"""
Adds Comment for particular request
"""
request_primary_id = None
try:
request_object = get_request_object(request_id)
if request_object:
request_primary_id = request_object.id
if request_primary_id:
request_comment = RequestComment(params['comment'],
request_primary_id,
params['username'],
params['username'])
db_util.db_add_query(request_comment)
db_util.db_commit()
logger.info(
"Comment record for request id [{}] added successfully.".
format(request_id))
return "Successfully added comment for request {}".format(
request_id)
else:
raise Exception(
"Failed to add comment for request {}".format(request_id))
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception(
'Failed to add Comments for Request as error in query: ', e)
def submit_recalculate_pipeline_call_job(sample_id, analysis_id, waiting_time):
try:
analysis = Analysis.query.filter_by(id=analysis_id).one()
if not analysis:
raise Exception("Failed to get Analysis record")
analysis.manual_set = None
analysis.current_call = "Pending"
db_util.db_commit()
logger.info("Analysis record for manual_set column updated "
"successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception(
'Failed to update manual_set column of Analysis '
'with error: ', e)
# Get latest DB records and upload to s3
db_util.upload_latest_db_records('junction', sample_id, analysis_id)
db_util.upload_latest_db_records('variation', sample_id, analysis_id)
db_util.upload_latest_db_records('config', sample_id, analysis_id)
# submit batch job
job_name = 'recalculate-call-{}-{}-{}' \
.format(str(sample_id), str(analysis_id), date_hash())
job_queue_name = cfg.recal_queue
job_definition = cfg.rt_jobdef_name
script = 'sbs-pipeline/bin/EC2_RecalculatePipeline.sh'
command = [
"sh", script,
str(sample_id),
str(analysis_id), "--bucket", cfg.s3_bucket
]
response = submit_job(command, job_name, job_queue_name, job_definition)
job_id = response['jobId']
if waiting_time:
timeout = time.time() + 18 # 18 secs from now
status = get_job_status(job_id, timeout)
else:
status = {
"job_id": job_id,
"job_name": job_name,
"sample_id": sample_id,
"analysis_id": analysis_id
}
if status == TIMEOUT:
logger.info('Failed to get status for recalculate pipeline call '
'job id {}. Timeout occurred.'.format(job_id))
return TIMEOUT
else:
logger.info('Status for Recalculate pipeline call job {} is {}'.format(
job_name, status))
return status
def delete_observed_map(observed_map_id):
"""
Delete Observed Map
"""
try:
ObservedMap.query.filter_by(id=observed_map_id).delete()
db_util.db_commit()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to delete ObservedMap with error: ', e)
def add_record(observed_map):
try:
db_util.db_add_query(observed_map)
db_util.db_commit()
logger.info("Observed Map added successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Observed Map with error: ', e)
return observed_map
def update_sample(params):
"""
Update sample record
"""
try:
sample = Sample.query.filter_by(sample_id=params.get('sample_id')).one()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to get Sample with error: ', e)
# get rquest primary id
request_primary_id = None
request_id = params.get('request_id', None)
request_object = req_svc.get_request_object(request_id)
if request_object:
request_primary_id = request_object.id
if not request_primary_id:
raise Exception(
'Failed to get request primary id for Request: {}'.format(
request_id))
sample.primary_map = params.get('primary_map', sample.primary_map)
sample.ev_man_event = params.get('ev_man_event', sample.ev_man_event)
sample.other_maps = params.get('other_maps', sample.other_maps)
sample.construct_name = params.get('construct_name', sample.construct_name)
sample.event_id = params.get('event_id', sample.event_id)
sample.geno_type = params.get('geno_type', sample.geno_type)
sample.organism = params.get('organism', sample.organism)
sample.sample_name = params.get('sample_name', sample.sample_name)
sample.develop_stage = params.get('develop_stage', sample.develop_stage)
sample.growth_location = params.get('growth_location',
sample.growth_location)
sample.treated = params.get('treated', sample.treated)
sample.eu_id = params.get('eu_id', sample.eu_id)
sample.request_id = params.get(request_primary_id, sample.request_id)
if 'curr_alpha_analysis' in params and params['curr_alpha_analysis']:
update_analysis_type(params['curr_alpha_analysis'])
sample.curr_alpha_analysis = params.get('curr_alpha_analysis',
sample.curr_alpha_analysis)
try:
db_util.db_commit()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to commit with error: ', e)
logger.info("Successfully updated sample for id [{}]."
.format(params['sample_id']))
return sample
def update_request(params):
"""
Update Request Info
"""
request_primary_id = None
try:
request_object = get_request_object(params['request_id'])
request_primary_id = request_object.id
if not request_primary_id:
raise Exception("Failed to update Request {}: Request does not "
"exists".format(params['request_id']))
request = Request.query.get(request_primary_id)
request.request_id = params.get('request_id', request.request_id)
request.sample_prep_methods = params.get('sample_prep_methods',
request.sample_prep_methods)
request.sbs_internalpipeline_version = params.get(
'sbs_internalpipeline_version',
request.sbs_internalpipeline_version)
request.request_name = params.get('request_name', request.request_name)
request.released_on = params.get('released_on', request.released_on)
request.sbs_status = params.get('sbs_status', request.sbs_status)
request.organism_id = params.get('organism_id', request.organism_id)
if 'tx_method' in params and params['tx_method']:
try:
tx_method = TxMethod.query \
.filter_by(method_name=params['tx_method']) \
.first()
except Exception as e:
logger.error('Failed to get tx_method with error: {}'.format(
str(e)))
raise Exception('Failed to get tx_method with error: ', e)
if tx_method:
request.tx_method_id = tx_method.id
db_util.db_commit()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to update Request with error: ', e)
if request:
logger.info("Successfully updated Request for request_id [{}].".format(
params['request_id']))
return get_request_by_request_id(request_primary_id)
else:
return {
"status":
"Failed to update sbs_status/transformation method "
"for id {}.".format(params['request_id'])
}
def add_endo_junction_set(endo_set_name):
# Add Endogenous Set record if not present
endo_set = EndogenousJunctionSet.query \
.filter_by(name=endo_set_name) \
.one_or_none
if not endo_set:
crop_id = None
endo_set = EndogenousJunctionSet(crop_id, endo_set_name)
db_util.db_add_query(endo_set)
db_util.db_commit()
return endo_set
def add_analysis(params):
"""
Adds ANALYSIS record
"""
try:
analysis = create_analysis(params)
db_util.db_add_query(analysis)
db_util.db_commit()
logger.info("Analysis record added successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Analysis with error: ', e)
return analysis
def update_endogenous_set(analysis_id, junction_ids):
if not junction_ids:
return False
# Get Endogenous Set name
endo_set_name = PipelineConfiguration.query \
.with_entities(PipelineConfiguration.endogenous_set) \
.outerjoin(Analysis) \
.filter(Analysis.id == analysis_id) \
.one_or_none()
if not endo_set_name:
return False
endo_set = add_endo_junction_set(endo_set_name)
# Check if sequences exists in Endogenous set
items = EndogenousJunction.query \
.with_entities(EndogenousJunction,
Junction.junction_sequence.label('seq')) \
.filter(EndogenousJunction.junction_id.in_(junction_ids)) \
.outerjoin(Junction) \
.all()
sequences = {} # Dict of {sequence: endogenous_junction_obj}
for item in items:
if item.seq not in sequences.values():
sequences[item.seq] = item[0]
avl_endoseqs = Junction.query() \
.with_entities(distinct(Junction.junction_sequence.label('seq'))) \
.outerjoin(EndogenousJunction) \
.outerjoin(EndogenousJunctionSet) \
.filter(EndogenousJunctionSet.name == endo_set_name) \
.filter(Junction.junction_sequence.in_(sequences)) \
.all()
avl_endoseqs_list = []
for s in avl_endoseqs:
if s.seq not in avl_endoseqs_list:
avl_endoseqs_list.append(s.seq)
# Update Endogenous Junction record with endo set id
for seq in sequences.values():
if seq not in avl_endoseqs_list:
endo_junc = sequences[seq]
endo_junc.junction_set = endo_set.id
db_util.db_commit()
return True
def update_record(observed_map, params):
try:
observed_map.name = params.get('name', observed_map.name)
observed_map.status = params.get('status', observed_map.status)
observed_map.load_time = params.get('load_time', observed_map.load_time)
observed_map.length = params.get('length', observed_map.length)
observed_map.send_to_evman = params.get('send_to_evman',
observed_map.send_to_evman)
db_util.db_commit()
logger.info("Observed Map record updated successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to update Observed Map with error: ', e)
return observed_map
def update_junction_duplicate_mask(junction_id_list, comment, curr_req_id,
is_masked, masked_by):
map_analyses = request_service.get_map_analysis_by_request(curr_req_id)
for map_analysis_id in map_analyses:
for jn_id in junction_id_list:
map_analysis_jn = MapAnalysisJunctions.query.filter_by(
junction_id=jn_id).filter_by(
map_analysis_id=map_analysis_id[0]).one_or_none()
if map_analysis_jn and map_analysis_jn.masked != is_masked:
map_analysis_jn.masked = is_masked
map_analysis_jn.junction_comment = comment
map_analysis_jn.masked_by = masked_by
db_util.db_commit()
return SUCCESS
def add_map(params):
"""
Adds Map
"""
version = 0
construct_id = params.get('construct_id', None)
if construct_id:
logger.info('Adding Map for construct_id [{}]'.format(construct_id))
map = get_map_by_construct_id(construct_id)
if map:
logger.info('Map {} already exists'.format(map.construct_id))
return map
else:
construct_id_no_ver = '.'.join(
[params['map_id'], params['sample_id'], '']).lower()
obs_map_ver = ObservedMap.query \
.with_entities(ObservedMap.version) \
.outerjoin(Map) \
.outerjoin(MapAnalysis) \
.filter(MapAnalysis.analysis_id == params['analysis_id']) \
.filter(Map.construct_id.ilike(construct_id_no_ver + '%')) \
.order_by(ObservedMap.version.desc()) \
.limit(1) \
.one_or_none()
if obs_map_ver:
version = int(obs_map_ver[0]) + 1
else:
version = 1
construct_id = construct_id_no_ver + str(version)
try:
map = Map(construct_id.upper())
db_util.db_add_query(map)
db_util.db_commit()
if version > 0:
map.obs_map_version = version
logger.info("Successfully added Map {}".format(construct_id))
except Exception as e:
logger.error('Failed to add Map with error: {}'.format(str(e)))
raise Exception('Failed to add Map with error: ', e)
return map
def delete_sample(id):
"""
delete sample
"""
try:
sample = Sample.query \
.filter_by(id=id) \
.delete()
db_util.db_commit()
if sample:
return {"status": "Deleted sample for id [{}]".format(id)}
else:
return {"status": "Error while deleting id [{}]".format(id)}
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to delete Sample with error: ', e)
def delete_crop(crop_id):
"""
delete crop record
"""
try:
crop = Crop.query \
.filter_by(id=crop_id) \
.delete()
db_util.db_commit()
if crop:
return {"status": "Deleted crop for id [{}]".format(id)}
else:
return {"status": "Error while deleting crop id [{}]".format(id)}
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to delete crop with error: ', e)
def update_junction(junction):
cur_junction = Junction.query \
.filter_by(junction_id=junction['id']) \
.one_or_none()
if cur_junction:
cur_junction.end = junction.get('end', cur_junction.end)
cur_junction.position = junction.get('position', cur_junction.position)
cur_junction.proximal_mapping = junction.get('proximal_mapping',
cur_junction.proximal_mapping)
cur_junction.proximal_percent_identity = junction.get(
'proximal_percent_identity', cur_junction.proximal_percent_identity)
cur_junction.proximal_sequence = junction.get('proximal_sequence',
cur_junction.proximal_sequence)
cur_junction.junction_sequence = junction.get('junction_sequence',
cur_junction.junction_sequence)
cur_junction.distal_sequence = junction.get('distal_sequence',
cur_junction.distal_sequence)
cur_junction.proximal_sequence_length = junction.get(
'proximal_sequence_length', cur_junction.proximal_sequence_length)
cur_junction.distal_mapping = junction.get('distal_mapping',
cur_junction.distal_mapping)
cur_junction.distal_percent_identity = junction.get(
'distal_percent_identity', cur_junction.distal_percent_identity)
cur_junction.distal_sequence_length = junction.get(
'distal_sequence_length', cur_junction.distal_sequence_length)
cur_junction.element = junction.get('element', cur_junction.element)
cur_junction.unique_reads = junction.get('unique_reads',
cur_junction.unique_reads)
cur_junction.supporting_reads = junction.get('supporting_reads',
cur_junction.supporting_reads)
cur_junction.endogenous = junction.get('endogenous',
cur_junction.endogenous)
cur_junction.source = junction.get('source', cur_junction.source)
cur_junction.duplicates = junction.get('duplicates',
cur_junction.duplicates)
try:
db_util.db_commit()
logger.info("Junction record updated successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to update Junction with error: ', e)
return cur_junction
def batch_insert_integrities(integrities_dict_list):
"""
Adds variation
"""
try:
for variation in integrities_dict_list:
if variation:
position = variation.get('position', None)
type = variation.get('type', None)
gt = variation.get('gt', None)
ref_base = variation.get('ref_base', None)
total_read_depth = variation.get('total_read_depth', None)
sample_base = variation.get('sample_base', None)
read_depth = variation.get('read_depth', None)
purity = variation.get('purity', None)
feature_type = variation.get('feature_type', None)
annotation = variation.get('annotation', None)
effects = variation.get('effects', None)
translation = variation.get('translation', None)
organism = variation.get('organism', None)
tier_label = variation.get('tier_label', None)
coverage = variation.get('coverage', None)
tier = variation.get('tier', None)
is_tier_label_updated = variation.get('is_tier_label_updated',
False)
map_analysis_id = variation.get('map_analysis_id', None)
if not check_duplicate_variation(
position, type, gt, ref_base, total_read_depth,
sample_base, read_depth, purity, feature_type,
annotation, effects, translation, organism, tier_label,
map_analysis_id):
variation = Variation(position, type, ref_base,
sample_base, translation, coverage,
purity, tier, read_depth, annotation,
tier_label, is_tier_label_updated,
gt, total_read_depth, feature_type,
effects, organism, map_analysis_id)
db_util.db_add_query(variation)
db_util.db_commit()
logger.info("Variation record added successfully.")
except Exception as e:
logger.error(
'Failed to batch insert Variation records with error: {}'.format(
str(e)))
raise Exception('Error occurred: {}'.format(e))
def update_map_analysis_jn(constructs, junctions_dict_list, is_masked, comment,
masked_by, is_duplicate):
for junction in junctions_dict_list:
for map in constructs:
map_analysis_jn = MapAnalysisJunctions.query.filter_by(
junction_id=junction['id']).filter_by(
map_analysis_id=map['map_analysis_id']).one_or_none()
if map_analysis_jn and map_analysis_jn.masked != is_masked:
map_analysis_jn.masked = is_masked
if is_duplicate and is_masked:
map_analysis_jn.junction_comment = comment.format(
junction['position'])
elif is_duplicate and not is_masked:
map_analysis_jn.junction_comment = None
else:
map_analysis_jn.junction_comment = comment
map_analysis_jn.masked_by = masked_by
db_util.db_commit()
def add_analysis_tools(analysis_tools):
"""
Adds Analysis Tools record
"""
analysis_tool_list = []
for name in analysis_tools:
analysis_tool = AnalysisTools.query.filter(
AnalysisTools.name == name).one_or_none()
if not analysis_tool:
analysis_tool = AnalysisTools(name)
db_util.db_add_query(analysis_tool)
db_util.db_commit()
# Get all the five tools records
all_tool_records = AnalysisTools.query.all()
for tool_obj in all_tool_records:
analysis_tool_list.append(tool_obj)
return analysis_tool_list
def add_analysis_comments(analysis_id, params):
"""
Adds Comment for particular analysis
"""
try:
analysis_comment = AnalysisComment(params['comment'], analysis_id,
params['username'],
params['username'])
db_util.db_add_query(analysis_comment)
db_util.db_commit()
logger.info("Comment record for analysis id [{}] added "
"successfully.".format(analysis_id))
return "Successfully added comment for analysis {}".format(analysis_id)
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Comments for Analysis as error in '
'query: ', e)
def update_crop(params):
"""
Update crop record
"""
try:
crop = Crop.query.get(params['id'])
if not crop:
raise Exception(
'Crop not found for given id {}: '.format(params['id']))
crop.organism = params.get('organism', crop.organism)
db_util.db_commit()
logger.info("Successfully updated crop for id [{}]." \
.format(params['id']))
crop = Crop.query.filter_by(id=params['id']).one_or_none()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to update Crop with error: ', e)
return crop
def add_map_analysis(analysis_id, map_id, read_count):
"""
Adds Map record
"""
logger.info('Adding MapAnalysis for map_id [{}] and analysis_id [{}]')
map_analysis = get_map_analysis(map_id, analysis_id)
if map_analysis:
logger.info('MapAnalysis already exists')
return map_analysis
try:
map_analysis = MapAnalysis(read_count, analysis_id, map_id)
db_util.db_add_query(map_analysis)
db_util.db_commit()
logger.info("Successfully added MapAnalysis.".format(
analysis_id, map_id))
except Exception as e:
logger.error('Failed to add MapAnalysis with error: {}'.format(str(e)))
raise Exception('Failed to add MapAnalysis with error: ', e)
return map_analysis
def update_analysis_tool_details(params):
tool_details = AnalysisToolsDetails.query \
.filter_by(analysis_id=int(params['analysis_id'])) \
.filter_by(tool_id=int(params['tool_id'])) \
.one_or_none()
if tool_details:
# only update Current Analysis Tool Details record
tool_details.analysis_id = params.get('analysis_id',
tool_details.analysis_id)
tool_details.tool_id = params.get('tool_id', tool_details.tool_id)
tool_details.current_call = params.get('call',
tool_details.current_call)
tool_details.current_msg = params.get('message',
tool_details.current_msg)
tool_details.current_detail = params.get('cna_detail',
tool_details.current_detail)
db_util.db_commit()
logger.info("Analysis Tools Details record updated successfully.")
return tool_details
return None
def delete_request(request_id):
"""
Deletes request record
"""
try:
request = Request.query \
.filter_by(request_id=request_id) \
.delete()
db_util.db_commit()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to delete request with error: ', e)
if request:
return {
"status": "Deleted request for Request id [{}]".format(request_id)
}
else:
return {
"status": "Error while deleting Request id [{}]".format(request_id)
}
def add_request(params):
"""
Adds request record or raise exception if already exists
"""
request = None
try:
request_id = params['request_id'].rstrip('/')
request = Request.query.filter_by(request_id=request_id).one_or_none()
if request:
logger.info("Request with request id [{}] already exists." \
.format(params['request_id']))
return request
sample_prep_methods = params.get('sample_prep_methods', None)
sbs_internalpipeline_version = params.get(
'sbs_internalpipeline_version', None)
request_name = params.get('request_name', None)
released_on = params.get('released_on', None)
sbs_status = params.get('sbs_status', None)
researcher = params.get('researcher', None)
tx_method_id = params.get('tx_method_id', None)
organism_id = params.get('organism_id', None)
request = Request(request_id, sample_prep_methods,
sbs_internalpipeline_version, request_name,
released_on, sbs_status, tx_method_id, researcher,
organism_id)
db_util.db_add_query(request)
db_util.db_commit()
logger.info(
"Request record for request id [{}] added successfully.".format(
params['request_id']))
request = Request.query.filter_by(request_id=request_id).one_or_none()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Request with error: ', e)
return request
def add_crop(params):
"""
Adds crop record or returns crop record if already exists
"""
organism = params['organism']
try:
crop = Crop.query.filter_by(organism=organism).one_or_none()
if crop:
logger.info("Crop with organism [{}] already exists." \
.format(organism))
return crop
crop = Crop(organism)
db_util.db_add_query(crop)
db_util.db_commit()
logger.info("Crop record for organism [{}] added successfully."
.format(organism))
crop = Crop.query.filter_by(organism=organism).one_or_none()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Crop with error: ', e)
return crop
def save_map_analysis_junctions(map_analysis_id, junction_id, masked):
try:
map_analysis_junction = MapAnalysisJunctions.query \
.with_entities(MapAnalysisJunctions) \
.filter(MapAnalysisJunctions.map_analysis_id == map_analysis_id) \
.filter(MapAnalysisJunctions.junction_id == junction_id) \
.one_or_none()
if not map_analysis_junction:
map_analysis_junction = MapAnalysisJunctions(map_analysis_id,
junction_id, masked,
None,
None)
else:
map_analysis_junction.masked = masked
db_util.db_add_query(map_analysis_junction)
db_util.db_commit()
logger.info("Record for map_analysis_junction id [{}] added "
"successfully.".format(junction_id))
except Exception as e:
logger.error(
'An error occurred while saving map analysis junctions : {}'
.format(str(e)))
raise Exception('Failed to save map analysis junction : ', e)
def add_tool_record(analysis_tool_details):
db_util.db_add_query(analysis_tool_details)
db_util.db_commit()
return analysis_tool_details
def insert_junctions(junctions_dict_list):
"""
Adds JUNCTION records
"""
try:
for junction in junctions_dict_list:
if junction:
if 'map_analysis_id' not in junction or not junction[
'map_analysis_id']:
logger.error('map_analysis_id is required')
raise Exception('map_analysis_id is required in junction')
map_analysis_id = junction['map_analysis_id']
masked = junction['masked']
masked = set_boolean_junction_values(masked)
endogenous = junction['endogenous']
endogenous = set_boolean_junction_values(endogenous)
junction['endogenous'] = endogenous
junction, is_duplicate = get_duplicate_junctions(junction)
if is_duplicate:
try:
junction_id = junction.id
save_map_analysis_junctions(map_analysis_id,
junction_id, masked)
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception(
'Failed to insert map_analysis_junction records with error: {}'.format(
e))
elif not is_duplicate:
try:
end = junction.get('end', None)
position = junction.get('position', None)
proximal_mapping = junction.get('proximal_mapping',
None)
if proximal_mapping == "NA" or not proximal_mapping:
proximal_percent_identity = None
else:
proximal_percent_identity = proximal_mapping \
.split(",")[-1]
proximal_sequence = junction.get('proximal_sequence',
None)
junction_sequence = junction.get('junction_sequence',
None)
proximal_sequence_length = junction.get(
'proximal_sequence_length', None)
distal_sequence = junction.get('distal_sequence', None)
distal_mapping = junction.get('distal_mapping', None)
if distal_mapping == "NA" or not distal_mapping:
distal_percent_identity = None
else:
distal_percent_identity = distal_mapping \
.split(",")[-1]
distal_sequence_length = junction.get(
'distal_sequence_length', None)
element = junction.get('element', None)
unique_reads = junction.get('unique_reads', None)
supporting_reads = junction.get('supporting_reads',
None)
endogenous = junction.get('endogenous', endogenous)
source = junction.get('source', None)
duplicates = junction.get('duplicates', None)
junction_record = Junction(end, position,
proximal_mapping,
proximal_percent_identity,
proximal_sequence,
junction_sequence,
proximal_sequence_length,
distal_sequence,
distal_mapping,
distal_percent_identity,
distal_sequence_length,
element, unique_reads,
supporting_reads,
endogenous, source,
duplicates)
db_util.db_add_query(junction_record)
db_util.db_commit()
logger.info(
"Junction record for added successfully {}".format(
junction_record))
junction_id = junction_record.id
save_map_analysis_junctions(map_analysis_id,
junction_id, masked)
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception(
'Failed to insert map_analysis_junction records with error: {}'.format(
e))
else:
logger.info("something went wrong")
logger.info("Junction record added successfully.")
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception(
'Failed to batch insert Junction records with error: {}'.format(e))
return SUCCESS
def add_sample(params):
"""
Adds sample record or raise exception if already exists
"""
try:
request_id = params['request_id']
request = Request.query.filter_by(id=request_id).one_or_none()
if not request:
logger.error("Request with id [{}] does not exist."
.format(params['request_id']))
sample_id = params['sample_id']
sample = Sample.query.filter_by(sample_id=sample_id).one_or_none()
if sample:
logger.info("Sample with sample_id [{}] already exists."
.format(params['sample_id']))
return sample
primary_map = params.get('primary_map', None)
ev_man_event = params.get('ev_man_event', None)
other_maps = params.get('other_maps', None)
construct_name = params.get('construct_name', None)
event_id = params.get('event_id', None)
geno_type = params.get('geno_type', None)
organism = params.get('organism', None)
sample_name = params.get('sample_name', None)
develop_stage = params.get('develop_stage', None)
growth_location = params.get('growth_location', None)
treated = params.get('treated', False)
eu_id = params.get('eu_id', None)
curr_alpha_analysis = params.get('curr_alpha_analysis', None)
if curr_alpha_analysis:
update_analysis_type(curr_alpha_analysis)
sample = Sample(sample_id,
primary_map,
ev_man_event,
other_maps,
request_id,
construct_name,
event_id,
geno_type,
organism,
sample_name,
develop_stage,
growth_location,
treated,
eu_id,
curr_alpha_analysis)
db_util.db_add_query(sample)
db_util.db_commit()
logger.info("Sample record for request id [{}] added successfully."
.format(params['request_id']))
sample = Sample.query.filter_by(sample_id=sample_id).one_or_none()
except Exception as e:
logger.error('An error occurred : {}'.format(str(e)))
raise Exception('Failed to add Sample with error: ', e)
return sample
