def delete_all_status(event, context): """ deletes all clean or dirty flag for a given target's spectrum :param event: :param context: :return: """ if 'tgt_id' not in event['pathParameters']: return invalid_request("Missing path parameters 'tgt_id'") tgt_id = event['pathParameters']['tgt_id'] # splash = urllib.parse.unquote(events['pathParameters']['splash']) # method = urllib.parse.unquote(events['pathParameters']['method']) # version = urllib.parse.unquote(events['pathParameters']['version']) try: database.query( 'DELETE FROM compound_spectrum_quality ' 'WHERE target_id = %(tgt_id)s', # 'AND target_splash = %(splash)s ' # 'AND target_method = %(method)s ' # 'AND target_version = %(version)s', conn, {'tgt_id': tgt_id }) # , 'splash': splash, 'method': method, 'version': version}) return no_content() except Exception as ex: return server_error(ex)
def delete_metas(event, context): if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') library = urllib.parse.unquote(event['pathParameters']['library']) splash = urllib.parse.unquote(event['pathParameters']['splash']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT id ' 'FROM compound ' 'WHERE NOT hidden ' 'AND splash=%(splash)s ' 'AND method=%(library)s ' 'AND version=%(version)s ', conn, { 'splash': splash, 'library': library, 'version': version }) if result is not None: # compound with metadata exists database.query( 'DELETE FROM compound_meta ' 'WHERE target_id = %(tgt_id)s', conn, {'tgt_id': result[0][0]}) return no_content() else: return not_found()
def delete_comment(event, context): """ :param event: :param context: :return: """ # if 'library' not in event['pathParameters']: # return compounds.invalid_request('missing "library" path parameter') # if 'splash' not in event['pathParameters']: # return compounds.invalid_request('missing "splash" path parameter') if 'identifiedBy' not in event['pathParameters']: return compounds.invalid_request('missing "identifiedBy" path parameter') # library = urllib.parse.unquote(event['pathParameters']['library']) # splash = urllib.parse.unquote(event['pathParameters']['splash']) # version = urllib.parse.unquote(event['pathParameters'].get('version', 'fixed')) identifiedBy = urllib.parse.unquote(event['pathParameters']['identifiedBy']) comment_id = urllib.parse.unquote(event['pathParameters']['comment_id']) try: database.query( "DELETE FROM compound_comment WHERE id = %(comment_id)s AND identified_by = %(identifiedBy)s", conn, {'comt_id': comment_id, 'identifiedBy': identifiedBy}) except Exception as ex: return server_error(ex) return no_content()
def promote_adduct(event, context): if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') if 'name' not in event['pathParameters']: return invalid_request('missing "adduct" path parameter') library = urllib.parse.unquote(event['pathParameters']['library']) splash = urllib.parse.unquote(event['pathParameters']['splash']) adduct = urllib.parse.unquote(event['pathParameters']['name']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT exists (SELECT 1 FROM compound c ' 'WHERE NOT c.hidden ' 'AND c.method = %(library)s ' 'AND c.splash=%(splash)s ' 'AND c.version=%(version)s)', conn, { 'library': library, 'splash': splash, 'version': version }) if result[0][0] == 0: return not_found() else: try: response = database.query( 'UPDATE compound SET adduct = %(adduct)s ' 'WHERE method=%(library)s ' 'AND splash=%(splash)s ' 'AND version=%(version)s', conn, { 'adduct': adduct, 'library': library, 'splash': splash, 'version': version }) # create a response return { 'statusCode': 200, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps( { 'library': library, 'splash': splash, 'version': version, 'adduct': adduct }, use_decimal=True) } except Exception as ex: traceback.print_exc() return server_error(ex)
def promote_name(event, context): if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') if 'name' not in event['pathParameters']: return invalid_request('missing "name" path parameter') method_name = urllib.parse.unquote(event['pathParameters']['library']) splash = urllib.parse.unquote(event['pathParameters']['splash']) name = urllib.parse.unquote(event['pathParameters']['name']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT exists (SELECT 1 FROM compound c ' 'WHERE NOT c.hidden ' 'AND method = %(method)s ' 'AND splash = %(splash)s ' 'AND version = %(version)s)', conn, { 'method': method_name, 'splash': splash, 'version': version }) if result[0][0] == 0: return not_found() else: try: database.query( 'UPDATE compound c SET name = %(name)s ' 'WHERE method = %(method)s ' 'AND splash = %(splash)s ' 'AND version = %(version)s', conn, { 'name': name, 'method': method_name, 'splash': splash, 'version': version }) # create a response return { 'statusCode': 200, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps( { 'library': method_name, 'splash': splash, 'version': version, 'name': name }, use_decimal=True) } except Exception as ex: return server_error(ex)
def delete_adduct(event, context): """ :param event: :param context: :return: """ if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') if 'name' not in event['pathParameters']: return invalid_request('missing "name" path parameter') if 'identifiedBy' not in event['pathParameters']: return invalid_request('missing "identifiedBy" path parameter') splash = urllib.parse.unquote(event['pathParameters']['splash']) library = urllib.parse.unquote(event['pathParameters']['library']) identified_by = urllib.parse.unquote( event['pathParameters']['identifiedBy']) name = urllib.parse.unquote(event['pathParameters']['name']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT DISTINCT ca.id, c.id, c.name ' 'FROM compound c, compound_adduct ca ' 'WHERE NOT c.hidden ' 'AND c.id = ca.target_id ' 'AND splash = %(splash)s ' 'AND method = %(method)s ' 'AND version = %(version)s ' 'AND ca.name = %(name)s ' 'AND identified_by = %(identified_by)s', conn, { 'splash': splash, 'method': library, 'name': name, 'identified_by': identified_by, 'version': version }) if result is not None: adduct_id = result[0][0] target_id = result[0][1] target_name = result[0][2] if name == target_name: database.query( "UPDATE compound SET adduct = NULL WHERE id = %(target_id)s", conn, {'target_id': target_id}) database.query("DELETE FROM compound_adduct WHERE id = %(adduct_id)s", conn, {'adduct_id': adduct_id}) return no_content() else: return not_found()
def delete_meta(event, context): ''' deletes a single metadata item from a specific compound, matched by name and value. :param event: :param context: :return: ''' if 'library' not in event['pathParameters']: return compounds.invalid_request('missing "library" path parameter') if 'splash' not in event['pathParameters']: return compounds.invalid_request('missing "splash" path parameter') if 'name' not in event['pathParameters']: return compounds.invalid_request('missing "name" path parameter') if 'value' not in event['pathParameters']: return compounds.invalid_request('missing "value" path parameter') if 'identifiedBy' not in event['pathParameters']: return compounds.invalid_request( 'missing "identifiedBy" path parameter') library = urllib.parse.unquote(event['pathParameters']['library']) splash = urllib.parse.unquote(event['pathParameters']['splash']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) name = urllib.parse.unquote(event['pathParameters']['name']) value = urllib.parse.unquote(event['pathParameters']['value']) identifiedBy = urllib.parse.unquote( event['pathParameters']['identifiedBy']) result = database.query( f'SELECT id, splash, method, version ' f'FROM compound ' f'WHERE NOT hidden ' f'AND method = %(method)s ' f'AND splash = %(splash)s ' f'AND version = %(version)s', conn, { 'splash': splash, 'method': library, 'version': version }) if result is not None: try: database.query( 'DELETE FROM compound_meta ' 'WHERE target_id = %(tgt_id)s ' 'AND name = %(name)s ' 'AND value = %(value)s ' 'AND identified_by = %(identifiedBy)s ', conn, { 'tgt_id': result[0][0], 'name': name, 'value': value, 'identifiedBy': identifiedBy }) except Exception as ex: return server_error(ex) return no_content()
def reject_name(event, context): if 'name_id' not in event['pathParameters']: return invalid_request('Missing id of the name to reject') if 'compound_id' not in event['pathParameters']: return invalid_request('missing id of the compound to modify') if 'rejected' not in event['pathParameters'] or \ event['pathParameters']['rejected'].lower() not in ['true', 'false']: return invalid_request( 'Invalid rejection value. Please use true or false') try: name_id = urllib.parse.unquote( str(event['pathParameters'].get('name_id', ''))) compound_id = urllib.parse.unquote( str(event['pathParameters'].get('compound_id', ''))) rejected = urllib.parse.unquote( str(event['pathParameters'].get('rejected', 'false'))) except Exception as ex: logger.error(ex.args) return server_error(ex) result = database.query( 'SELECT c.id, pre_cursors_mass, retention_index, cn.id, c.name, cn.name, c.name = cn.name as promoted ' 'FROM compound c LEFT JOIN compound_name cn on c.id=cn.target_id ' 'WHERE cn.id = %(name_id)s', conn, {'name_id': name_id}) if result is not None: promoted = result[0][6] target_mz = result[0][1] target_ri = result[0][2] unk_name = f'unknown_{target_mz:.4f}_{target_ri:.4f}' # compound with name exists database.html_response_query( 'UPDATE compound_name ' 'SET rejected = %(rejected)s ' 'WHERE id = %(name_id)s', conn, { 'rejected': rejected, 'name_id': name_id, 'compound_id': compound_id }) if promoted and rejected: database.query( 'UPDATE compound ' 'SET name = %(unk_name)s ' 'WHERE id = %(tgt_id)s', conn, { 'unk_name': unk_name, 'tgt_id': compound_id }) return no_content() else: return not_found()
def delete(event, context): """ hide istd """ if 'id' not in event['pathParameters']: return compounds.invalid_request('Missing "id" pathParameter') istd_id = int(urllib.parse.unquote(event['pathParameters'].get('id', '0'))) try: database.query('UPDATE compound SET hidden = true WHERE id = %(id)s', conn, {'id': istd_id}) return { 'statusCode': http.HTTPStatus.NO_CONTENT, 'headers': headers.__HTTP_HEADERS__ } except Exception as ex: return compounds.server_error(ex)
def compound_without_associated_comments(request, conn): result = request.config.cache.get('cis/compound_without_comment', None) compound = result if result is None: result = database.query( 'SELECT c.id, method, splash, sample, version, pre_cursors_mass, retention_index ' 'FROM compound_consensus c LEFT JOIN compound_comment cc ON c.id = cc.target_id ' "WHERE cc.comment='' OR cc.comment IS NULL " 'LIMIT 1', conn) if result is None: pytest.fail("Can't find compounds in database") transform = lambda x: { 'id': x[0], 'method': x[1], 'splash': x[2], 'sample': x[3], 'version': x[4], 'mass': x[5], 'ri': x[6] } compound = list(map(transform, result))[0] request.config.cache.set('cis/compound_without_comment', compound) else: print('using cached data') compound = result return compound
def delete_status(event, context): """ deletes a clean or dirty flag for a given target's spectrum :param event: :param context: :return: """ if 'tgt_id' not in event['pathParameters']: return invalid_request("Missing path parameters 'tgt_id'") tgt_id = urllib.parse.unquote(event['pathParameters']['tgt_id']) if 'queryStringParameters' not in event or 'identifiedBy' not in event[ 'queryStringParameters']: return invalid_request("Missing query string parameter 'identifiedBy'") identified_by = event['queryStringParameters']['identifiedBy'] try: result = database.query( 'DELETE FROM compound_spectrum_quality ' 'WHERE target_id = %s AND identified_by = %s', conn, [tgt_id, identified_by]) response = {"statusCode": 204, "headers": headers.__HTTP_HEADERS__} except Exception as ex: logger.error(str(ex)) response = { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": str(ex)}, use_decimal=True) } return response
def counts(events, context): try: result = database.query( 'SELECT DISTINCT method, target_type, count(*) ' 'FROM compound ' 'WHERE NOT hidden ' 'GROUP BY method, target_type', conn) data = list( map(lambda x: { 'method': x[0], 'target_type': x[1], 'count': x[2] }, result)) # create a response return { 'statusCode': 200, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps(data, use_decimal=True) } except Exception as e: traceback.print_exc() return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": e.args}, use_decimal=True) }
def compound_list_with_dupes(request, conn): result = request.config.cache.get('cis/comps_with_dupes', None) if result is not None: print(f"using cached object: {result}") else: print("loading all, takes forever and should be cached instead...") libs = database.query( 'SELECT id, method, splash, version FROM compound_consensus ' 'WHERE id IN (' 'SELECT duplicate_of FROM compound_consensus WHERE duplicate_of IS NOT NULL)', conn) if len(libs) == 0: pytest.fail('No compounds with duplicates in db') result = [{ 'id': l[0], 'library': l[1], 'splash': l[2], 'version': l[3] } for l in libs] request.config.cache.set('cis/comps_with_dupes', result) return result
def comps_with_adducts(request, conn): result = request.config.cache.get('cis/comp_with_adducts', None) if result is not None: print(f"using cached object: {result}") else: print("loading all, takes forever and should be cached instead...") libs = database.query( 'SELECT c.id, method, splash, sample, version, ' 'pre_cursors_mass, retention_index, target_type, c.name, ca.name as adduct ' 'FROM compound_consensus c LEFT JOIN compound_adduct ca on c.id = ca.target_id ' 'WHERE ca.name IS NOT NULL LIMIT 100', conn) result = list( map( lambda x: { 'id': x[0], 'method': x[1], 'splash': x[2], 'sample': x[3], 'version': x[4], 'mass': x[5], 'ri': x[6], 'target_type': x[7], 'name': x[8], 'adduct': x[9] }, libs)) request.config.cache.set('cis/comp_with_adducts', result) return result
def reject_adduct(event, context): if 'adduct_id' not in event['pathParameters']: return invalid_request('Missing id of the adduct to reject') if 'compound_id' not in event['pathParameters']: return invalid_request('Missing id of compound to modify') if 'rejected' not in event['pathParameters'] or \ event['pathParameters']['rejected'].lower() not in ['true', 'false']: return invalid_request( 'Invalid rejection value. Please use true or false') adduct_id = urllib.parse.unquote(event['pathParameters']['adduct_id']) compound_id = urllib.parse.unquote(event['pathParameters']['compound_id']) rejected = urllib.parse.unquote(event['pathParameters']['rejected']) result = database.query( 'SELECT c.id, ca.id, c.adduct, ca.name, c.adduct = ca.name as promoted ' 'FROM compound c LEFT JOIN compound_adduct ca on c.id=ca.target_id ' 'WHERE ca.id = %(adduct_id)s', conn, {'adduct_id': adduct_id}) if result is not None: promoted = result[0][4] try: # compound with existing adduct database.html_response_query( 'UPDATE compound_adduct ' 'SET rejected = %(rejected)s ' 'WHERE id = %(adduct_id)s ' 'AND target_id = %(compound_id)s', conn, { 'rejected': rejected, 'adduct_id': adduct_id, 'compound_id': compound_id }) if promoted: database.query( 'UPDATE compound ' 'SET adduct = null ' 'WHERE id = %(tgt_id)s', conn, {'tgt_id': compound_id}) except Exception as ex: return server_error(ex) return no_content() else: return no_content()
def delete_names(event, context): if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') splash = urllib.parse.unquote(event['pathParameters']['splash']) library = urllib.parse.unquote(event['pathParameters']['library']) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT id, pre_cursors_mass, retention_index ' 'FROM compound ' 'WHERE NOT hidden ' 'AND splash = %(splash)s ' 'AND method = %(method)s ' 'AND version = %(version)s', conn, { 'splash': splash, 'method': library, 'version': version }) if result is not None: target_id = result[0][0] target_mz = result[0][1] target_ri = result[0][2] unk_name = f'unknown_{target_mz:.4f}_{target_ri:.4f}' # compound with adducts exists database.query( 'DELETE FROM compound_name WHERE target_id = %(tgt_id)s', conn, {'tgt_id': target_id}) database.query( 'UPDATE compound SET name = %(unk_name)s WHERE id = %(tgt_id)s', conn, { 'unk_name': unk_name, 'tgt_id': target_id }) return no_content() else: return not_found()
def save(event, context): """create / update""" obj = json.loads(event['body']) obj['created'] = event['requestContext']['requestTime'] try: if event['httpMethod'] == 'POST': # create / post new_data = database.query( "INSERT INTO compound (id, method, splash, version, accurate_mass, adduct, hidden, inchi_key, " "ion_mode, msms, name, pre_cursors_mass, retention_index, sample, target_type, created, updated) " "VALUES (nextval('compound_id'), %(method)s, %(splash)s, %(version)s, %(accurate_mass)s, %(adduct)s, " "%(hidden)s, %(inchi_key)s, %(ion_mode)s, %(msms)s, %(name)s, %(pre_cursors_mass)s, " "%(retention_index)s, %(sample)s, 'ISTD', %(created)s, %(created)s) " 'RETURNING id, method, splash, version, accurate_mass, name, adduct, hidden, inchi_key, ion_mode, ' 'msms, pre_cursors_mass, retention_index, target_type, sample', conn, obj) new_istd = list(map(istd_transform, new_data))[0] return { 'statusCode': http.HTTPStatus.CREATED, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps(new_istd, use_decimal=True) } elif event['httpMethod'] == 'PUT': # update / put database.query( 'UPDATE compound SET method = %(method)s, splash = %(splash)s, version = %(version)s, ' 'accurate_mass = %(accurate_mass)s, adduct = %(adduct)s, hidden = %(hidden)s, ' 'inchi_key = %(inchi_key)s, ion_mode = %(ion_mode)s, msms = %(msms)s, name = %(name)s, ' 'pre_cursors_mass = %(pre_cursors_mass)s, retention_index = %(retention_index)s ' 'WHERE id = %(id)s', conn, obj) return { 'statusCode': http.HTTPStatus.OK, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps(obj, use_decimal=True) } else: return compounds.invalid_request('Invalid request method') except Exception as ex: print(str(ex)) return compounds.server_error(ex)
def process_event(events, query_str): if 'method' not in events['pathParameters']: return invalid_request('missing or invalid method path parameter') method = urllib.parse.unquote(events['pathParameters']['method']) version = urllib.parse.unquote(events['pathParameters'].get('version')) # check if they request a compound or a sample if 'object_type' not in events['pathParameters'] or \ events['pathParameters']['object_type'] not in ['target', 'sample']: return invalid_request( 'missing or invalid object type, it should be <target|sample>') else: object_type = urllib.parse.unquote( events['pathParameters']['object_type']) # get the splash or sample name for query depending on 'object_type' if 'value' not in events['pathParameters']: if object_type == 'target': return invalid_request('missing splash as value path parameter') else: return invalid_request( 'missing sample name as value path parameter') else: value = urllib.parse.unquote(events['pathParameters']['value']) filters = {'value': value, 'version': version, 'method': method} if object_type == 'target': query = query_str.replace('@column_name@', 'splash') else: query = query_str.replace('@column_name@', 'sample') try: caller = inspect.stack()[1][3] result = database.query(query, conn, filters) code = http.HTTPStatus.NOT_FOUND if result is None else http.HTTPStatus.OK # create a response return { 'statusCode': code, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps( { caller: result, 'object_type': object_type, 'filters': filters }, use_decimal=True) } except Exception as ex: return server_error(ex)
def delete_comments(event, context): if 'library' not in event['pathParameters']: return invalid_request('missing "library" path parameter') if 'splash' not in event['pathParameters']: return invalid_request('missing "splash" path parameter') library = urllib.parse.unquote(event['pathParameters']['library']) splash = urllib.parse.unquote(event['pathParameters']['splash']) version = urllib.parse.unquote(event['pathParameters'].get('version', 'fixed')) try: database.query( 'DELETE FROM compound_comment ' 'WHERE target_splash = %(splash)s ' 'AND target_method = %(method)s ' 'AND target_version = %(version)s', conn, {'splash': splash, 'method': library, 'version': version}) except Exception as ex: return server_error(ex) return no_content()
def libraries_list(request, conn) -> list: libs = request.config.cache.get('cis/libraries', None) if libs is None: libs = database.query('SELECT DISTINCT method FROM compound', conn) if libs is not None: libs = [l[0] for l in libs] request.config.cache.set('cis/libraries', libs) else: pytest.fail("Didn't find libraries in the database.") return libs
def get_duplicates_list(tgt_id): dupes = database.query( 'SELECT id, method, splash, version FROM compound WHERE duplicate_of = %(tgt_id)s', conn, params={'tgt_id': tgt_id}) if dupes is None: return [] else: return [{ 'id': y[0], 'method': y[1], 'splash': y[2], 'version': y[3] } for y in dupes]
def delete(event, context): if 'pathParameters' in event: if 'library' in event['pathParameters']: method_name = urllib.parse.unquote( event['pathParameters']['library']) result = database.query('DELETE FROM compound WHERE "method" = %s', conn, [method_name]) try: # create a response return { "statusCode": 200, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"library": method_name}, use_decimal=True) } except Exception as e: traceback.print_exc() return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({ "error": str(e), "library": method_name }, use_decimal=True) } else: return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": "you need to provide a 'method' name"}, use_decimal=True) } else: return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": "missing path parameters"}, use_decimal=True) }
def size(events, context): if 'library' in events['pathParameters']: method_name = urllib.parse.unquote(events['pathParameters']['library']) try: result = database.query( 'SELECT count(*), target_type ' 'FROM compound ' 'WHERE NOT hidden ' 'AND method = %(method)s ' 'GROUP BY target_type', conn, {'method': method_name}) data = list( map(lambda x: { 'target_type': x[1], 'count': x[0] }, result)) # create a response return { 'statusCode': 200, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps(data, use_decimal=True) } except Exception as e: traceback.print_exc() return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({ "error": str(e), "library": method_name }, use_decimal=True) } else: return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": "you need to provide a 'method' name"}, use_decimal=True) }
def generate_status_list(tgt_id): stats = database.query( 'SELECT id, clean, target_id, identified_by FROM compound_spectrum_quality ' 'WHERE target_id = %(tgt_id)s ' 'LIMIT 10 OFFSET 0', conn, params={'tgt_id': tgt_id}) if stats is None: return [] else: return [{ 'status_id': y[0], 'clean': y[1], 'target_id': y[2], 'identifiedBy': y[3] } for y in stats]
def duplicates_of_compound(event, context): """ Lists all duplicate splashes for a given compound :param event: :param context: :return: """ if 'library' not in event['pathParameters']: return invalid_request('Missing library path parameter') if 'splash' not in event['pathParameters']: return invalid_request('Missing splash path parameter') library = urllib.parse.unquote(event['pathParameters'].get('library', '')) splash = urllib.parse.unquote(event['pathParameters'].get('splash', '')) version = urllib.parse.unquote(event['pathParameters'].get( 'version', 'fixed')) result = database.query( 'SELECT id, method, splash, version FROM compound ' 'WHERE duplicate_of = (' ' SELECT id FROM compound ' ' WHERE method = %(library)s ' ' AND splash = %(splash)s ' ' AND version = %(version)s ' ')', conn, params={ 'library': library, 'splash': splash, 'version': version }) if result is None: return not_found() result = [{ 'id': x[0], 'library': x[1], 'splash': x[2], 'version': x[3] } for x in result] return { 'statusCode': http.HTTPStatus.OK, 'headers': headers.__HTTP_HEADERS__, 'body': json.dumps(result) }
def exists(events, context): if 'library' in events['pathParameters']: method_name = urllib.parse.unquote(events['pathParameters']['library']) result = database.query( 'SELECT exists (SELECT 1 FROM compound WHERE method = %(method)s)', conn, {'method': method_name}) try: # create a response return { "statusCode": 200 if result[0][0] is True else 404, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({ "exists": result[0][0], "library": method_name }, use_decimal=True) } except Exception as e: traceback.print_exc() return { "statusCode": 500, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({ "error": str(e), "library": method_name }, use_decimal=True) } else: return { "statusCode": 400, "headers": headers.__HTTP_HEADERS__, "body": json.dumps({"error": "you need to provide a 'method' name"}, use_decimal=True) }
def libraries_with_unconfirmed(request, conn) -> list: libs = request.config.cache.get('cis/libraries_unconfirmed', None) if libs is None: libs = database.query( 'SELECT DISTINCT method, splash ' 'FROM compound_consensus ' "WHERE lower(target_type) = 'unconfirmed'" 'ORDER BY splash', conn) if libs is not None: libs = [{'library': l[0], 'splash': l[1]} for l in libs] request.config.cache.set('cis/libraries_unconfirmed', libs) else: pytest.fail("Didn't find libraries in the database.") return libs
def generate_comments_list(tgt_id): comments = database.query( 'SELECT id, comment, identified_by, rejected ' 'FROM compound_comment ' 'WHERE target_id = %(tgt_id)s', conn, {'tgt_id': tgt_id}) logger.info(f'received comments: {comments}') if comments is None: return [] else: return list( map( lambda y: { 'id': y[0], 'identifiedBy': y[2], 'comment': y[1], 'rejected': y[3] }, comments))
def libs_with_hidden_comps(request, conn): result = request.config.cache.get('cis/libs_with_hidden_comps', None) if result is not None: print(f"using cached object: {result}") else: print("loading all, takes forever and should be cached instead...") libs = database.query( 'SELECT distinct method FROM compound_consensus WHERE hidden', conn) if len(libs) == 0: pytest.fail('No libraries with hidden compounds in db') result = [x[0] for x in libs] request.config.cache.set('cis/libs_with_hidden_comps', result) return result
def generate_name_list(tgt_id): names = database.query( 'SELECT id, name, identified_by, comment, rejected ' 'FROM compound_name ' 'WHERE target_id = %(tgt_id)s', conn, {'tgt_id': tgt_id}) logger.info(f'received names: {names}') if names is None: return [] else: return list( map( lambda y: { 'id': y[0], 'name': y[1], 'identifiedBy': y[2], 'comment': y[3], 'rejected': y[4] }, names))