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 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_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 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 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 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 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 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 add_observed_map_comments(observed_map_id, params): """ Adds Comment for particular ObservedMap """ try: observed_map_comment = ObservedMapComment(params['comment'], observed_map_id, params['username'], params['username']) db_util.db_add_query(observed_map_comment) db_util.db.session.commit() observed_map_comment = observed_map_comment.as_dict() db_util.db.session.close() except Exception as e: logger.error('Failed to add ObservedMap comments with error: {}' .format(str(e))) raise Exception('Failed to add Comments for ObservedMap as error in ' 'query: ', e) logger.info("Comment record for ObservedMap id [{}] added successfully." .format(observed_map_id)) return observed_map_comment
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 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
def add_tool_record(analysis_tool_details): db_util.db_add_query(analysis_tool_details) db_util.db_commit() return analysis_tool_details