Spaces:
Runtime error
Runtime error
| #from turtle import shape | |
| import streamlit as st | |
| #from st_keyup import st_keyup | |
| import pandas as pd | |
| import numpy as np | |
| from st_aggrid import AgGrid, GridOptionsBuilder,GridUpdateMode,DataReturnMode | |
| import os | |
| st.set_page_config(layout="wide") | |
| st.markdown( | |
| """ | |
| <style> | |
| .streamlit-expanderHeader { | |
| font-size: x-large; | |
| } | |
| </style> | |
| """, | |
| unsafe_allow_html=True, | |
| ) | |
| caution = '<p style="font-family:sans-serif; color:Red; font-size: 18px;">Please note that Only one Guide (from pair) is found. Please see guides not found section for other guide</p>' | |
| caution1 = '<p style="font-family:sans-serif; color:Red; font-size: 18px;">Please note that Each mutated guide is reported as a sepearte line. sgID_1/2, sgRNA_1/2, chr_sgRNA_1/2 and position_sgRNA_1/2 represent values for reference/mutated guide</p>' | |
| caution2 = '<p style="font-family:sans-serif; color:Red; font-size: 18px;">Please Select a single/multiple guides and then select Check Box A, B or C Otherwise code will through error</p>' | |
| table_edit = '<p style="font-family:sans-serif; color:Green; font-size: 16px;">About Table: Please note that table can be <b>sorted by clicking on any column</b> and <b>Multiple rows can be selected</b> (by clicking check box in first column) to save only those rows.</p>' | |
| caution_genes = '<p style="font-family:sans-serif; color:Red; font-size: 16px;">Please make sure that desired genes from all three lists should be selected to generate Order Ready Table.</p>' | |
| def transform(df,str): | |
| # Select columns | |
| #cols = st.multiselect('Please select columns to save current Table as csv file', | |
| cols = st.multiselect(str, | |
| df.columns.tolist(), | |
| df.columns.tolist() | |
| ) | |
| df = df[cols] | |
| return df | |
| def convert_df(df): | |
| return df.to_csv().encode('utf-8') | |
| def convert_df1(df): | |
| return df.to_csv(index=False).encode('utf-8') | |
| # CSS to inject contained in a string | |
| hide_table_row_index = """ | |
| <style> | |
| thead tr th:first-child {display:none} | |
| tbody th {display:none} | |
| </style> | |
| """ | |
| # Inject CSS with Markdown | |
| st.markdown(hide_table_row_index, unsafe_allow_html=True) | |
| #########TABLE DISPLAY | |
| def tbl_disp(dat,var,ref,key,flg=1): | |
| dat.reset_index(drop=True, inplace=True) | |
| #df = transform(dft,'Please Select columns to save whole table') | |
| #fname = st.text_input('Please input file name to save Table', 'temp') | |
| #fname = st_keyup("Please input file name to save Table", value='temp') | |
| csv = convert_df(dat) | |
| if flg==1: | |
| st.download_button( | |
| label="Download Full Table as CSV file", | |
| data=csv, | |
| file_name=var+'_'+ref+'.csv',#fname+'.csv', | |
| mime='text/csv', | |
| #key=key, | |
| ) | |
| #st.table(dft) | |
| #st.markdown(table_edit,unsafe_allow_html=True) | |
| gb = GridOptionsBuilder.from_dataframe(dat) | |
| gb.configure_pagination(enabled=False)#,paginationAutoPageSize=False)#True) #Add pagination | |
| gb.configure_default_column(enablePivot=True, enableValue=True, enableRowGroup=True) | |
| gb.configure_selection(selection_mode="multiple", use_checkbox=True) | |
| gb.configure_column("gene", headerCheckboxSelection = True) | |
| gb.configure_side_bar() | |
| gridOptions = gb.build() | |
| grid_response = AgGrid( | |
| dat, | |
| height=200, | |
| gridOptions=gridOptions, | |
| enable_enterprise_modules=True, | |
| update_mode=GridUpdateMode.MODEL_CHANGED, | |
| data_return_mode=DataReturnMode.FILTERED_AND_SORTED, | |
| fit_columns_on_grid_load=False, | |
| header_checkbox_selection_filtered_only=True, | |
| use_checkbox=True, | |
| width='100%' | |
| #key=key | |
| ) | |
| selected = grid_response['selected_rows'] | |
| if selected: | |
| #st.write('Selected rows') | |
| dfs = pd.DataFrame(selected) | |
| #st.dataframe(dfs[dfs.columns[1:dfs.shape[1]]]) | |
| #dfs1 = transform(dfs[dfs.columns[1:dfs.shape[1]]],'Please select columns to save selected Table') | |
| csv = convert_df1(dfs[dfs.columns[1:dfs.shape[1]]]) | |
| #csv = convert_df1(dfs1) | |
| if flg: | |
| st.download_button( | |
| label="Download Selected data as CSV", | |
| data=csv, | |
| file_name=var+'_'+ref+'.csv', | |
| mime='text/csv', | |
| ) | |
| return dfs | |
| def assemble_tbl(t): | |
| dft = pd.DataFrame(columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2', 'sgID_1_2']) | |
| for i in range(0,t.shape[0],2): | |
| l1=t.iloc[[i]] | |
| l1.columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','mutated_guide', 'strand', 'num_mismatch'] | |
| l2=t.iloc[[i+1]] | |
| l2.columns=['sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2','mutated_guide2', 'strand2', 'num_mismatch2'] | |
| listA_concatenated_match_LR1=pd.concat([l1.reset_index(drop=True),l2.reset_index(drop=True)],axis=1) | |
| listA_concatenated_match_LR1=listA_concatenated_match_LR1[['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2']] | |
| listA_concatenated_match_LR1['sgRNA_1']=listA_concatenated_match_LR1['sgRNA_1'].str.slice(0, 20) | |
| listA_concatenated_match_LR1['sgRNA_2']=listA_concatenated_match_LR1['sgRNA_2'].str.slice(0, 20) | |
| listA_concatenated_match_LR1['sgID_1_2']=listA_concatenated_match_LR1['sgID_1']+"|"+listA_concatenated_match_LR1['sgID_1'] | |
| dft=dft.append(listA_concatenated_match_LR1) | |
| return dft | |
| def get_lists(ref_list,list_found_ref,list_notfound_ref): | |
| a_ref=[] | |
| for i in range(len(ref_list)): | |
| a_ref.append(ref_list.gene.values[i].split('|')[0]) | |
| a_ref.append(ref_list.gene.values[i].split('|')[1]) | |
| set_found0_ref=[] | |
| for i in range(len(a_ref)): | |
| set_found0_ref.append(list_found_ref[list_found_ref['gene']==a_ref[i]]) | |
| list_concatenated_found_ref = pd.concat(set_found0_ref) | |
| list_concatenated_match_ref = list_concatenated_found_ref[list_concatenated_found_ref.num_mismatch == 0] | |
| #Also remove Alternate loci's data | |
| list_concatenated_match_ref = list_concatenated_match_ref[list_concatenated_match_ref['chr'].str.contains('chr')] | |
| #also create new list with both sgRNAs in one row | |
| dft=pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| if list_concatenated_match_ref.shape[0]>0: | |
| t=list_concatenated_match_ref.reset_index(drop=True) | |
| #st.table(t) | |
| ########## | |
| #check even/odd entries | |
| if t.shape[0]==1: | |
| t1=t.loc[t.index.repeat(2)].reset_index(drop=True) | |
| #st.write(t1) | |
| dft=assemble_tbl(t1) | |
| elif t.shape[0]%2==0: #even | |
| dft=assemble_tbl(t) | |
| else: #odd | |
| t1 = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| i=0 | |
| while i <t.shape[0]: | |
| if i<t.shape[0]-1: | |
| if t.iloc[i]['gene'] == t.iloc[i+1]['gene'] and t.iloc[i]['chr'] == t.iloc[i+1]['chr'] and t.iloc[i]['position'] == t.iloc[i+1]['position']: | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i+1]], ignore_index = True) | |
| i=i+2 | |
| else: #repeat entries | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| #st.table(t1) | |
| i=i+1 | |
| else: | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| i=i+1 | |
| #st.table(t1) | |
| dft=assemble_tbl(t1) | |
| list_concatenated_mutated_ref = list_concatenated_found_ref[list_concatenated_found_ref.num_mismatch > 0] | |
| list_concatenated_mutated_ref=list_concatenated_mutated_ref.sort_values('position') | |
| #Also remove Alternate loci's data | |
| list_concatenated_mutated_ref = list_concatenated_mutated_ref[list_concatenated_mutated_ref['chr'].str.contains('chr')] | |
| dft_mut = pd.DataFrame(columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2', 'sgID_1_2']) | |
| if list_concatenated_mutated_ref.shape[0]>0: | |
| dft_mut = get_mutated_res(list_concatenated_mutated_ref) | |
| #check not found | |
| seta_notfound0_ref=list_notfound_ref[list_notfound_ref['gene']==a_ref[0]] | |
| seta_notfound1_ref=list_notfound_ref[list_notfound_ref['gene']==a_ref[1]] | |
| #st.write(seta_notfound0_ref) | |
| #st.write(seta_notfound1_ref) | |
| #add guideflg1 to return which guide is found | |
| guideflg1=0 | |
| if seta_notfound0_ref.shape[0]>0: | |
| guideflg1=2 | |
| if seta_notfound1_ref.shape[0]>0: | |
| guideflg1=1 | |
| list_concatenated_notfound_ref = pd.concat([seta_notfound0_ref,seta_notfound1_ref]) | |
| #st.table(dft) | |
| #st.table(dft_mut) | |
| return dft, dft_mut,list_concatenated_notfound_ref,list_concatenated_match_ref,list_concatenated_mutated_ref,guideflg1 | |
| ########### | |
| def get_mutated_res(list_concatenated_mutated_ref): | |
| ######### | |
| #if list_concatenated_mutated_ref.shape[0]>0: | |
| t=list_concatenated_mutated_ref.reset_index(drop=True) | |
| #st.table(t) | |
| dft_mut = pd.DataFrame(columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2', 'sgID_1_2']) | |
| c1=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1'] | |
| c2=['sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2']#, 'sgID_1_2'] | |
| #st.table(listA_concatenated_match_ref) | |
| #st.write(t.shape[0]) | |
| tf=0 | |
| #for i in range(0,t.shape[0],2): | |
| for i in range(t.shape[0]): | |
| l1=t.iloc[[i]] | |
| l1.columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','mutated_guide', 'strand', 'num_mismatch'] | |
| l2=l1.copy() | |
| l2.columns=['sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2','mutated_guide2', 'strand2', 'num_mismatch2'] | |
| list_concatenated_mutated_ref1=[] | |
| #listA_concatenated_mutated_ref1=pd.concat([l1.reset_index(drop=True),l2.reset_index(drop=True)],axis=1) | |
| list_concatenated_mutated_ref1=pd.concat([l1.reset_index(drop=True),l2.reset_index(drop=True)],axis=1) | |
| #st.table(listA_concatenated_mutated_ref1) | |
| list_concatenated_mutated_ref1=list_concatenated_mutated_ref1[['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','mutated_guide2','chr_sgRNA_2','position_sgRNA_2']] | |
| #also change if not leading G | |
| list_concatenated_mutated_ref1['sgRNA_1']='G'+list_concatenated_mutated_ref1['sgRNA_1'].str.slice(1, 20) | |
| #also change name of mutated_guide2 column | |
| list_concatenated_mutated_ref1.columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2'] | |
| list_concatenated_mutated_ref1['sgRNA_2']='G'+list_concatenated_mutated_ref1['sgRNA_2'].str.slice(1, 20) | |
| list_concatenated_mutated_ref1['sgID_1_2']=list_concatenated_mutated_ref1['sgID_1']+"|"+list_concatenated_mutated_ref1['sgID_1'] | |
| dft_mut=dft_mut.append(list_concatenated_mutated_ref1) | |
| return dft_mut | |
| ######### | |
| #######THIS SECTION ADDED FOR ORDER READY LIST AND REMOVE REPITION FOR NOT_FOUND ENTRUES | |
| def get_lists_ol(ref_list,list_found_ref,list_notfound_ref): | |
| a_ref=[] | |
| for i in range(len(ref_list)): | |
| a_ref.append(ref_list.gene.values[i].split('|')[0]) | |
| a_ref.append(ref_list.gene.values[i].split('|')[1]) | |
| set_found0_ref=[] | |
| for i in range(len(a_ref)): | |
| set_found0_ref.append(list_found_ref[list_found_ref['gene']==a_ref[i]]) | |
| list_concatenated_found_ref = pd.concat(set_found0_ref) | |
| list_concatenated_match_ref = list_concatenated_found_ref[list_concatenated_found_ref.num_mismatch == 0] | |
| #Also remove Alternate loci's data | |
| list_concatenated_match_ref = list_concatenated_match_ref[list_concatenated_match_ref['chr'].str.contains('chr')] | |
| #also create new list with both sgRNAs in one row | |
| dft=pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| if list_concatenated_match_ref.shape[0]>0: | |
| t=list_concatenated_match_ref.reset_index(drop=True) | |
| #st.table(t) | |
| ########## | |
| #check even/odd entries | |
| if t.shape[0]==1: | |
| t1=t.loc[t.index.repeat(2)].reset_index(drop=True) | |
| #st.write(t1) | |
| dft=assemble_tbl(t1) | |
| elif t.shape[0]%2==0: #even | |
| dft=assemble_tbl(t) | |
| else: #odd | |
| t1 = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| i=0 | |
| while i <t.shape[0]: | |
| if i<t.shape[0]-1: | |
| if t.iloc[i]['gene'] == t.iloc[i+1]['gene'] and t.iloc[i]['chr'] == t.iloc[i+1]['chr'] and t.iloc[i]['position'] == t.iloc[i+1]['position']: | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i+1]], ignore_index = True) | |
| i=i+2 | |
| else: #repeat entries | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| #st.table(t1) | |
| i=i+1 | |
| else: | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| t1=t1.append(t.iloc[[i]], ignore_index = True) | |
| i=i+1 | |
| #st.table(t1) | |
| dft=assemble_tbl(t1) | |
| list_concatenated_mutated_ref = list_concatenated_found_ref[list_concatenated_found_ref.num_mismatch > 0] | |
| list_concatenated_mutated_ref=list_concatenated_mutated_ref.sort_values('position') | |
| #Also remove Alternate loci's data | |
| list_concatenated_mutated_ref = list_concatenated_mutated_ref[list_concatenated_mutated_ref['chr'].str.contains('chr')] | |
| dft_mut = pd.DataFrame(columns=['sgID_1','sgRNA_1','chr_sgRNA_1','position_sgRNA_1','sgID_2','sgRNA_2','chr_sgRNA_2','position_sgRNA_2', 'sgID_1_2']) | |
| if list_concatenated_mutated_ref.shape[0]>0: | |
| dft_mut = get_mutated_res(list_concatenated_mutated_ref) | |
| #check not found | |
| seta_notfound0_ref=list_notfound_ref[list_notfound_ref['gene']==a_ref[0]] | |
| seta_notfound1_ref=list_notfound_ref[list_notfound_ref['gene']==a_ref[1]] | |
| list_concatenated_notfound_ref = pd.concat([seta_notfound0_ref,seta_notfound1_ref]) | |
| return dft, dft_mut,list_concatenated_notfound_ref,list_concatenated_match_ref,list_concatenated_mutated_ref | |
| ########### | |
| #THIS WILL GENERATE ORDER READY TABLE FOR GRCh38 | |
| #THIS WILL GENERATE ORDER READY TABLE FOR CHM13 | |
| #CHECK IF GUIDE ARE IN NOT FOUND LIST | |
| def not_found_check(set12,set34,set56,listA_notfound_lr,listB_notfound_lr,listC_notfound_lr): | |
| flg11=0 | |
| flg12=0 | |
| flg21=0 | |
| flg22=0 | |
| flg31=0 | |
| flg32=0 | |
| #st.write(set12.split('|')[1]) | |
| if listA_notfound_lr[listA_notfound_lr['gene']==set12.split('|')[0]].shape[0]>0: | |
| flg11=1 | |
| if listA_notfound_lr[listA_notfound_lr['gene']==set12.split('|')[1]].shape[0]>0: | |
| flg12=1 | |
| if listB_notfound_lr[listB_notfound_lr['gene']==set34.split('|')[0]].shape[0]>0: | |
| flg21=1 | |
| if listB_notfound_lr[listB_notfound_lr['gene']==set34.split('|')[1]].shape[0]>0: | |
| flg22=1 | |
| if listC_notfound_lr[listC_notfound_lr['gene']==set56.split('|')[0]].shape[0]>0: | |
| flg31=1 | |
| if listC_notfound_lr[listC_notfound_lr['gene']==set56.split('|')[1]].shape[0]>0: | |
| flg32=1 | |
| return flg11,flg12,flg21,flg22,flg31,flg32 | |
| def order_ready_tbl_CHM13(set12,set34,set56,listA_found_lr,listA_notfound_lr,listB_found_lr,listB_notfound_lr,listC_found_lr,listC_notfound_lr): | |
| dft_order_table=pd.DataFrame(columns=['gene','guide_type','sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_a = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_b = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_c = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| set12=set12.reset_index(drop = True) | |
| set34=set34.reset_index(drop = True) | |
| set56=set56.reset_index(drop = True) | |
| for i in range(set12.shape[0]): | |
| gene_n=set12[i].split('_')[0] | |
| f=not_found_check(set12[i],set34[i],set56[i],listA_notfound_lr,listB_notfound_lr,listC_notfound_lr) | |
| #st.write(f) | |
| #st.write(set12[i],set34[i],set56[i]) | |
| #ref_listA=listA[listA['gene']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA=listA[listA['sgID_AB']==set12.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA = ref_listA[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listA.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| resa,res_muta,res_notfounda,list_matcha,list_mutateda,gflga1=get_lists(ref_listA,listA_found_lr,listA_notfound_lr) | |
| dft_a=dft_a.append(ref_listA) | |
| #listb | |
| ref_listB=listB[listB['sgID_AB']==set34.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB = ref_listB[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listB.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| resb,res_mutb,res_notfoundb,list_matchb,list_mutatedb,gflgb1=get_lists(ref_listB,listB_found_lr,listB_notfound_lr) | |
| dft_b=dft_b.append(ref_listB) | |
| #st.table(not resb.empty) | |
| #st.table(res_mutb) | |
| #st.table(resb) | |
| #listc | |
| ref_listC=listC[listC['sgID_AB']==set56.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC = ref_listC[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listC.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| resc,res_mutc,res_notfoundc,list_matchc,list_mutatedc,gflgc1=get_lists(ref_listC,listC_found_lr,listC_notfound_lr) | |
| dft_c=dft_c.append(ref_listC) | |
| # st.write(set12[i]) | |
| # st.write(set34[i]) | |
| # st.write(set56[i]) | |
| # st.write(f) | |
| # st.write(gflga1,gflgb1,gflgc1) | |
| if gflga1==0: | |
| #Also verigy that both guides are different | |
| if resa['sgID_1'][0] != resa['sgID_2'][0]: | |
| resa['gene']=gene_n | |
| resa['guide_type']='1-2' | |
| dft_order_table=dft_order_table.append(resa) | |
| else: #it is nutation case, so check next | |
| if f[2]==0 or f[3] == 0: | |
| #st.write('came in 1') | |
| if not resb.empty: # and resb['sgID_1'][0] != resb['sgID_2'][0]: #second guide in from setb | |
| resa[['sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2']] = resb[['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1']] | |
| resa['sgID_1_2'] = resa['sgID_1']+"|"+resa['sgID_2'] | |
| if f[2]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-3" | |
| dft_order_table=dft_order_table.append(resa) | |
| else: # f[2]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-4" | |
| dft_order_table=dft_order_table.append(resa) | |
| elif resa.shape[0] >0: #at least one guide is from seta | |
| #if resa['sgID_1'][0] != resa['sgID_2'][0]: | |
| if f[2]==0 or f[3] == 0: | |
| st.write('came in 1') | |
| if not resb.empty: # and resb['sgID_1'][0] != resb['sgID_2'][0]: #second guide in from setb | |
| resa[['sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2']] = resb[['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1']] | |
| resa['sgID_1_2'] = resa['sgID_1']+"|"+resa['sgID_2'] | |
| if f[2]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-3" | |
| dft_order_table=dft_order_table.append(resa) | |
| else: # f[2]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-4" | |
| dft_order_table=dft_order_table.append(resa) | |
| elif f[4]==0 or f[5] == 0: | |
| #st.write('came in 2') | |
| #if resa['sgID_1'][0] != resa['sgID_2'][0]: | |
| if not resc.empty: # and resc['sgID_1'][0] != resc['sgID_2'][0]: # resc.shape[0]>0: #second guide is from setc | |
| resa[['sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2']] = resc[['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1']] | |
| resa['sgID_1_2'] = resa['sgID_1']+"|"+resa['sgID_2'] | |
| #dft_order_table=dft_order_table.append(resa) | |
| if f[4]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-5" | |
| dft_order_table=dft_order_table.append(resa) | |
| else: # f[2]==0: | |
| resa['gene']=gene_n | |
| resa['guide_type']=str(gflga1)+"-6" | |
| dft_order_table=dft_order_table.append(resa) | |
| elif resb.shape[0]>0: #at least one guide | |
| #if resb['sgID_1'][0] != resb['sgID_2'][0]: | |
| if f[4]==0 or f[5] == 0: | |
| #if not resc.empty and resc['sgID_1'][0] != resc['sgID_2'][0]: | |
| resb[['sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2']] = resc[['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1']] | |
| resb['sgID_1_2'] = resb['sgID_1']+"|"+resb['sgID_2'] | |
| #dft_order_table=dft_order_table.append(resb) | |
| if f[4]==0: | |
| resb['gene']=gene_n | |
| resb['guide_type']=str(gflgb1+1)+"-5" | |
| dft_order_table=dft_order_table.append(resb) | |
| else: # f[2]==0: | |
| resb['gene']=gene_n | |
| resb['guide_type']=str(gflgb1+2)+"-6" | |
| dft_order_table=dft_order_table.append(resb) | |
| elif resc.shape[0]>0: #at least one guide | |
| #if f[4]==0 and f[5] == 0: | |
| if resc['sgID_1'][0] != resc['sgID_2'][0]: | |
| resc['gene']=gene_n | |
| resc['guide_type']='5-6' | |
| dft_order_table=dft_order_table.append(resc) | |
| if dft_order_table.shape[0]>0: | |
| st.write('Order Ready **CHM13** guides List') | |
| tbl_disp(dft_order_table,'select_genes','SetA_CHM13',5) | |
| else: | |
| st.write('**No guides found in ListA, ListB and ListC**') | |
| #st.table(dft_order_table) | |
| #def get_notfound(): | |
| cwd=os.getcwd()+'/'+'data/' | |
| listA = pd.read_csv(cwd+"guides_a_new.csv",index_col=False) | |
| listB = pd.read_csv(cwd+"guides_b_new.csv",index_col=False) | |
| listC = pd.read_csv(cwd+"guides_c_new.csv",index_col=False) | |
| lista_sz=listA.shape[0] | |
| listb_sz=listB.shape[0] | |
| listc_sz=listC.shape[0] | |
| variantsa1=listA['gene'].unique() | |
| variantsb1=listB['gene'].unique() | |
| variantsc1=listC['gene'].unique() | |
| con = np.concatenate((variantsa1, variantsb1,variantsc1)) | |
| #st.write(type(variantsc1)) | |
| variants_s=sorted(np.unique(con)) | |
| #st.write(len(variants_s)) | |
| #also get names for non-targetting guides | |
| #Also read GRCh38 and LR guides for stea | |
| listA_found_ref = pd.read_csv(cwd+"seta_found_ref1.csv",index_col=False) | |
| lsita_ref_found_sz=listA_found_ref.shape[0] | |
| #remove # from chr# # | |
| listA_found_ref['chr'] = [x.split(' ')[-0] for x in listA_found_ref['chr']] | |
| listA_found_ref.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listA_notfound_ref = pd.read_csv(cwd+"seta_notfound_ref1.csv",index_col=False) | |
| lsita_ref_notfound_sz=listA_notfound_ref.shape[0] | |
| listA_found_lr = pd.read_csv(cwd+"seta_found_LR1.csv",index_col=False) | |
| lsita_lr_found_sz=listA_found_lr.shape[0] | |
| listA_found_lr.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listA_notfound_lr = pd.read_csv(cwd+"seta_notfound_LR1.csv",index_col=False) | |
| lsita_lr_notfound_sz=listA_notfound_lr.shape[0] | |
| #Also read GRCh38 and LR guides for set b | |
| listB_found_ref = pd.read_csv(cwd+"setb_found_ref1.csv",index_col=False) | |
| lsitb_ref_found_sz=listB_found_ref.shape[0] | |
| #remove # from chr# # | |
| listB_found_ref['chr'] = [x.split(' ')[-0] for x in listB_found_ref['chr']] | |
| listB_found_ref.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listB_notfound_ref = pd.read_csv(cwd+"setb_notfound_ref1.csv",index_col=False) | |
| lsitb_ref_notfound_sz=listB_notfound_ref.shape[0] | |
| listB_found_lr = pd.read_csv(cwd+"setb_found_LR1.csv",index_col=False) | |
| lsitb_lr_found_sz=listB_found_lr.shape[0] | |
| listB_found_lr.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listB_notfound_lr = pd.read_csv(cwd+"setb_notfound_LR1.csv",index_col=False) | |
| lsitb_lr_notfound_sz=listB_notfound_lr.shape[0] | |
| #Also read GRCh38 and LR guides for set c | |
| listC_found_ref = pd.read_csv(cwd+"setc_found_ref1.csv",index_col=False) | |
| lsitc_ref_found_sz=listC_found_ref.shape[0] | |
| #remove # from chr# # | |
| listC_found_ref['chr'] = [x.split(' ')[-0] for x in listC_found_ref['chr']] | |
| listC_found_ref.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listC_notfound_ref = pd.read_csv(cwd+"setc_notfound_ref1.csv",index_col=False) | |
| lsitc_ref_notfound_sz=listC_notfound_ref.shape[0] | |
| listC_found_lr = pd.read_csv(cwd+"setc_found_LR1.csv",index_col=False) | |
| lsitc_lr_found_sz=listC_found_lr.shape[0] | |
| listC_found_lr.rename(columns = {'strnad':'strand'}, inplace = True) | |
| listC_notfound_lr = pd.read_csv(cwd+"setc_notfound_LR1.csv",index_col=False) | |
| lsitc_lr_notfound_sz=listC_notfound_lr.shape[0] | |
| #also load all mismatched except non-targe guides | |
| #listA_notfound_lr = pd.read_csv(cwd+"setc_notfound_LR1.csv",index_col=False) seta_all_notmatched_table.csv | |
| st.title('Long Read Guides Search') | |
| #st.markdown('**Please select an option from the sidebar**') | |
| #st.write(variants) | |
| Calc = st.sidebar.radio( | |
| "", | |
| ('ReadME', 'Single/Multiple Guides','All','Not_Found')) | |
| if Calc == 'ReadME': | |
| expander = st.expander("How to use this app") | |
| #st.header('How to use this app') | |
| expander.markdown('Please select **Single Gene** OR **Multiple Genes** Menue checkbox from the sidebar') | |
| expander.markdown('Select a Gene (from genes dropdown list) OR Multiple genes (from table)') | |
| expander.markdown('A table showing all reference gudies from three LISTS will appear in the main panel. **Please not some of the genes (for example A1BG and GJB7) have multiple guide pairs and all of these are selected.**') | |
| expander.markdown('To see results for each of the selected reference guide from ListA, ListB and ListC, Please select respective checkbox') | |
| expander.markdown('Results are shown as two tables, **Matched** and **Mutated** guides tables and **NOT FOUND** table if guides are not found in GRCh38 and LR reference fasta files') | |
| expander.markdown('**Mutated** guides table shows the genomic postion in GRCh38 and LR Fasta file along other fields. **If a guide is found in GRCh38 but not in LR fasta, then corresponding columns will be NA**') | |
| expander.markdown('**Mutated** guides table shows the genomic postion in GRCh38 and LR Fasta file along other fields. **If a guide is found in GRCh38 but not in LR fasta, then corresponding columns will be NA**') | |
| expander1 = st.expander('Introduction') | |
| expander1.markdown( | |
| """ This app helps navigate all probable genomic **miss-matched/Mutations (upto 2 bp)** for a given sgRNA (from 3 lists of CRISPRi dual sgRNA libraries) in GRCh38 reference fasta and a Reference fasta generated from BAM generated against KOLF2.1J longread data. | |
| """ | |
| ) | |
| expander1.markdown('Merged bam file was converted to fasta file using following steps:') | |
| expander1.markdown('- samtools mpileup to generate bcf file') | |
| expander1.markdown('- bcftools to generate vcf file') | |
| expander1.markdown('- bcftools consensus to generate fasta file') | |
| expander1.markdown('A GPU based [Cas-OFFinder](http://www.rgenome.net/cas-offinder/) tool was used to find off-target sequences (upto 2 miss-matched) for each geiven reference guide against GRCh38 and LR fasta references.') | |
| elif Calc=='Single/Multiple Guides': | |
| flg_a_fount=0 | |
| flg_b_fount=0 | |
| flg_c_fount=0 | |
| #st.write('**General Stats:**') | |
| #st.write('**GRCh38 Stats: Guides Found: **'+str(lsita_ref_found_sz)+"/"+str(lista_sz)) | |
| with st.form(key='columns_in_form'): | |
| c2, c3 = st.columns(2) | |
| with c2: | |
| multi_genes = st.multiselect( | |
| 'Please select genes list to start processing', | |
| variants_s) | |
| Updated=st.form_submit_button(label = 'Update') | |
| listA_concatenated_orig = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| reflistA_concatenated = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| reflistB_concatenated = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| reflistC_concatenated = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| for variant in multi_genes: | |
| ref_listA=listA[listA['gene']==variant][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA = ref_listA[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listA.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| reflistA_concatenated=pd.concat([reflistA_concatenated,ref_listA]) | |
| ref_listB=listB[listB['gene']==variant][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB = ref_listB[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listB.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| reflistB_concatenated=pd.concat([reflistB_concatenated,ref_listB]) | |
| ref_listC=listC[listC['gene']==variant][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC = ref_listC[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listC.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| reflistC_concatenated=pd.concat([reflistC_concatenated,ref_listC]) | |
| listA_concatenated_orig = pd.concat([listA_concatenated_orig,ref_listA,ref_listB,ref_listC]) | |
| if listA_concatenated_orig.shape[0] > 0: | |
| #st.markdown(table_edit,unsafe_allow_html=True) | |
| st.write('**Input** Guides (all 6 from 3 sets).') | |
| st.write('**Please Select Guides common to ALL 3 Lists to procede further Processing**') | |
| st.markdown(caution_genes,unsafe_allow_html=True) | |
| with st.form(key='columns_in_form_a'): | |
| c2, c3 = st.columns(2) | |
| with c2: | |
| get_table_order=tbl_disp(listA_concatenated_orig,'variant','ref_guides',111,0) | |
| #multi_genes = st.multiselect( | |
| #'Please select genes list to start processing', | |
| #variants_s) | |
| Updated1=st.form_submit_button(label = 'Generate Order Ready Table') | |
| #get_table_order=tbl_disp(listA_concatenated_orig,'variant','ref_guides',1,0) | |
| if not isinstance(get_table_order, type(None)): # and Updated1:# and get_table_order.shape[0]>0: | |
| #if not isinstance(get_table_order, type(None)): | |
| variant_set12=get_table_order[get_table_order['guide_type']=='1-2']['gene'] | |
| variant_set34=get_table_order[get_table_order['guide_type']=='3-4']['gene'] | |
| variant_set56=get_table_order[get_table_order['guide_type']=='5-6']['gene'] | |
| #st.table(variant_set12) | |
| #st.write(type(variant_set12)) | |
| #if not variant_set12.equals(variant_set34): | |
| # st.write('**Please select Identical Genes From List A and B**') | |
| if variant_set12.shape[0]==variant_set34.shape[0]==variant_set56.shape[0]: | |
| #########Here we call order ready table | |
| #order_ready_tbl_GRCh38(variant_set12,variant_set34,variant_set56) | |
| order_ready_tbl_CHM13(variant_set12,variant_set34,variant_set56,listA_found_lr,listA_notfound_lr,listB_found_lr,listB_notfound_lr,listC_found_lr,listC_notfound_lr) | |
| ########END ORDER READY TABLE | |
| elif variant_set12.shape[0]!=variant_set34.shape[0]: | |
| st.markdown("""**<span style='color:red'>SetA and SetB</span> guides are not same, Please correct the problem and re-run**""",unsafe_allow_html=True) | |
| elif variant_set12.shape[0]!=variant_set56.shape[0]: | |
| st.markdown("""**<span style='color:red'>SetA and SetC</span> guides are not same, Please correct the problem and re-run**""",unsafe_allow_html=True) | |
| elif variant_set34.shape[0]!=variant_set56.shape[0]: | |
| st.markdown("""**<span style='color:red'>SetB and SetC</span> guides are not same, Please correct the problem and re-run**""",unsafe_allow_html=True) | |
| else: | |
| st.markdown("""**<span style='color:red'>Probably Mixed guides are selected from three lists, Please correct the problem and re-run</span>**""",unsafe_allow_html=True) | |
| #Now BUILD Order Ready List | |
| #if dft_lr_resa.shape[0] >0 and dft_lr_resb.shape[0] >0 and dft_lr_resc.shape[0] >0: | |
| # for sgrna in dft_lr_resa | |
| else: | |
| st.write('**Please select guides and Press Update Button to Begin Processing**') | |
| ListARes = st.checkbox('Results For SetA',key=300) | |
| if ListARes:# and not isinstance(get_table, type(None)):#get_table!=None: | |
| #if ListARes and get_table.shape[0]>0: | |
| st.write('**Please select Guides From Table Below to processes from ListA**') | |
| get_table=tbl_disp(reflistA_concatenated,variant,'ref_guides',2,0) | |
| if not isinstance(get_table, type(None)): | |
| #variant_set=get_table[get_table['guide_type']=='1-2']['gene'] | |
| variant_set=get_table['gene'] | |
| dft_a = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_resa=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_res_muta=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_notfounda=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| #CHECK FOR GRCh38 | |
| for i in range(variant_set.shape[0]): | |
| #ref_listA=listA[listA['sgID_AB']==variant_set.iloc[i]['gene']][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA=listA[listA['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA = ref_listA[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listA.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflga1=get_lists(ref_listA,listA_found_ref,listA_notfound_ref) | |
| dft_a=dft_a.append(ref_listA) | |
| if res.shape[0]>0: | |
| dft_resa=dft_resa.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_res_muta=dft_res_muta.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_notfounda= dft_notfounda.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_ref= df_matched_guides_ref.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_ref= df_mutated_guides_ref.append(list_mutated) | |
| #st.write('Selected Reference Guides for **Set A**') | |
| #tbl_disp(dft_a,'All','ReferenceGuides',0) | |
| if dft_resa.shape[0]>0: | |
| st.write('Matched to **GRCh38** Reference Guides for **Set A**') | |
| tbl_disp(dft_resa,'select_genes','SetA_GRCh38',3) | |
| elif dft_res_muta.shape[0]>0: | |
| st.write('Mutated to **GRCh38** Reference Guides for **Set A**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_res_muta,'select_genes','SetA_Mutated_GRCh38',4) | |
| if dft_notfounda.shape[0]>0: | |
| st.write('**SetA Guides Not Found in GRCh38**') | |
| #tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
| st.table(dft_notfounda) | |
| #Now CHECK FOR CHM13 | |
| dft_a = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_lr_resa=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_res_muta=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_notfounda=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| for i in range(variant_set.shape[0]): | |
| #ref_listA=listA[listA['gene']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA=listA[listA['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listA = ref_listA[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listA.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflga1=get_lists(ref_listA,listA_found_lr,listA_notfound_lr) | |
| dft_a=dft_a.append(ref_listA) | |
| if res.shape[0]>0: | |
| dft_lr_resa=dft_lr_resa.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_lr_res_muta=dft_lr_res_muta.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_lr_notfounda= dft_lr_notfounda.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_lr= df_matched_guides_lr.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_lr= df_mutated_guides_lr.append(list_mutated) | |
| if dft_lr_resa.shape[0]>0: | |
| st.write('Matched to **CHM13** Reference Guides for **Set A**') | |
| tbl_disp(dft_lr_resa,'select_genes','SetA_CHM13',5) | |
| elif dft_lr_res_muta.shape[0]>0: | |
| st.write('Mutated to **CHM13** Reference Guides for **Set A**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_lr_res_muta,'select_genes','SetA_Mutated_CHM13',6) | |
| if dft_lr_notfounda.shape[0]>0: | |
| st.write('**SetA Guides Not Found in CHM13**') | |
| st.table(dft_lr_notfounda) | |
| #NOW MERGE FROM GRCh38 and LR | |
| merged_mutated_set=pd.merge(df_mutated_guides_ref,df_mutated_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_mutated_set = merged_mutated_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| merged_match_set=pd.merge(df_matched_guides_ref,df_matched_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_match_set = merged_match_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| if merged_match_set.shape[0]>0: | |
| #st.write('**Matched** Guides for **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Matched** Guides for **Set A** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| tbl_disp(merged_match_set,'select_genes','SetA_Matched_GRCh38_CHM13',7,0) | |
| #st.table(merged_match_seta) | |
| elif merged_mutated_set.shape[0]>0: | |
| #st.write('**Missmatched** Guides **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Mutated** Guides for **Set A** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| tbl_disp(merged_mutated_set,'select_genes','SetA_Mutated_GRCh38_CHM13',8,0) | |
| elif ListARes: | |
| st.write("**Please select genes from the above table to begin**") | |
| ListBRes = st.checkbox('Results For SetB',key=40) | |
| if ListBRes: # and not isinstance(get_table, type(None)):#get_table!=None: | |
| st.write('**Please select Guides From Table Below to processes from ListB**') | |
| get_table=tbl_disp(reflistB_concatenated,variant,'ref_guides',9,0) | |
| if not isinstance(get_table, type(None)): | |
| #variant_set=get_table[['gene']] | |
| variant_set=get_table['gene'] | |
| dft_b = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_resb=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_res_mutb=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_notfoundb=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| #CHECK FOR GRCh38 | |
| for i in range(variant_set.shape[0]): | |
| #ref_listB=listB[listB['gene']==variant_set.iloc[i]['gene']][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB=listB[listB['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB =ref_listB[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listB.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflgb1=get_lists(ref_listB,listB_found_ref,listB_notfound_ref) | |
| dft_b=dft_b.append(ref_listB) | |
| if res.shape[0]>0: | |
| dft_resb=dft_resb.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_res_mutb=dft_res_mutb.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_notfoundb= dft_notfoundb.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_ref= df_matched_guides_ref.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_ref= df_mutated_guides_ref.append(list_mutated) | |
| #st.write('Selected Reference Guides for **Set B**') | |
| #tbl_disp(dft_b,'All','ReferenceGuides',0) | |
| if dft_resb.shape[0]>0: | |
| st.write('Matched to **GRCh38** Reference Guides for **Set B**') | |
| tbl_disp(dft_resb,'select_genes','SetB_GRCh38',10) | |
| elif dft_res_mutb.shape[0]>0: | |
| st.write('Mutated to **GRCh38** Reference Guides for **Set B**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_res_mutb,'select_genes','SetB_Mutated_GRCh38',11) | |
| if dft_notfoundb.shape[0]>0: | |
| st.write('**SetB Guides Not Found in GRCh38**') | |
| #tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
| st.table(dft_notfoundb) | |
| #Now CHECK FOR CHM13 | |
| dft_b = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_lr_resb=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_res_mutb=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_notfoundb=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| for i in range(variant_set.shape[0]): | |
| #ref_listB=listB[listB['gene']==variant_set.iloc[i]['gene']][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB=listB[listB['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listB=ref_listB[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listB.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflgb1=get_lists(ref_listB,listB_found_lr,listB_notfound_lr) | |
| dft_b=dft_b.append(ref_listB) | |
| if res.shape[0]>0: | |
| dft_lr_resb=dft_lr_resb.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_lr_res_mutb=dft_lr_res_mutb.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_lr_notfoundb= dft_lr_notfoundb.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_lr= df_matched_guides_lr.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_lr= df_mutated_guides_lr.append(list_mutated) | |
| if dft_lr_resb.shape[0]>0: | |
| st.write('Matched to **CHM13** Reference Guides for **Set B**') | |
| tbl_disp(dft_lr_resb,'select_genes','SetB_CHM13',12) | |
| elif dft_lr_res_mutb.shape[0]>0: | |
| st.write('Mutated to **CHM13** Reference Guides for **Set B**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_lr_res_mutb,'select_genes','SetB_Mutated_CHM13',13) | |
| if dft_lr_notfoundb.shape[0]>0: | |
| st.write('**SetB Guides Not Found in CHM13**') | |
| st.table(dft_lr_notfoundb) | |
| #NOW MERGE FROM GRCh38 and LR | |
| merged_mutated_set=pd.merge(df_mutated_guides_ref,df_mutated_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_mutated_set = merged_mutated_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| merged_match_set=pd.merge(df_matched_guides_ref,df_matched_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_match_set = merged_match_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| if merged_match_set.shape[0]>0: | |
| #st.write('**Matched** Guides for **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Matched** Guides for **Set B** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| tbl_disp(merged_match_set,'select_genes','SetB_Matched_GRCh38_CHM13',14,0) | |
| #st.table(merged_match_seta) | |
| elif merged_mutated_set.shape[0]>0: | |
| #st.write('**Missmatched** Guides **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Mutated** Guides for **Set B** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| #st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(merged_mutated_set,'select_genes','SetB_Mutated_GRCh38_CHM13',15,0) | |
| elif ListBRes: | |
| st.write("**Please select genes from the above table to begin**") | |
| ListCRes = st.checkbox('Results For SetC',key=50) | |
| if ListCRes: # and not isinstance(get_table, type(None)):#get_table!=None: | |
| #variant_set=get_table[['gene']] | |
| st.write('**Please select Guides From Table Below to processes from ListC**') | |
| get_table=tbl_disp(reflistC_concatenated,variant,'ref_guides',16,0) | |
| if not isinstance(get_table, type(None)): | |
| variant_set=get_table['gene'] | |
| dft_c = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_resc=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_res_mutc=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_notfoundc=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| #CHECK FOR GRCh38 | |
| for i in range(variant_set.shape[0]): | |
| #ref_listC=listC[listC['gene']==variant_set.iloc[i]['gene']][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC=listC[listC['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC =ref_listC[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listC.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflgc1=get_lists(ref_listC,listC_found_ref,listC_notfound_ref) | |
| dft_c=dft_c.append(ref_listC) | |
| if res.shape[0]>0: | |
| dft_resc=dft_resc.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_res_mutc=dft_res_mutc.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_notfoundc= dft_notfoundc.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_ref= df_matched_guides_ref.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_ref= df_mutated_guides_ref.append(list_mutated) | |
| #st.write('Selected Reference Guides for **Set C**') | |
| #tbl_disp(dft_c,'All','ReferenceGuides',0) | |
| if dft_resc.shape[0]>0: | |
| st.write('Matched to **GRCh38** Reference Guides for **Set C**') | |
| tbl_disp(dft_resc,'select_genes','SetC_GRCh38',17) | |
| elif dft_res_mutc.shape[0]>0: | |
| st.write('Mutated to **GRCh38** Reference Guides for **Set C**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_res_mutc,'select_genes','SetC_Mutated_GRCh38',18) | |
| if dft_notfoundc.shape[0]>0: | |
| st.write('**SetC Guides Not Found in GRCh38**') | |
| #tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
| st.table(dft_notfoundc) | |
| #Now CHECK FOR CHM13 | |
| dft_c = pd.DataFrame(columns=['gene','guide_type','protospacer_A','protospacer_B']) | |
| dft_lr_resc=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_res_mutc=pd.DataFrame(columns=['sgID_1', 'sgRNA_1', 'chr_sgRNA_1', 'position_sgRNA_1', 'sgID_2', 'sgRNA_2', 'chr_sgRNA_2', 'position_sgRNA_2', 'sgID_1_2']) | |
| dft_lr_notfoundc=pd.DataFrame(columns=['gene','ref_guide']) | |
| df_matched_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| df_mutated_guides_lr = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
| for i in range(variant_set.shape[0]): | |
| #ref_listC=listC[listC['gene']==variant_set.iloc[i]['gene']][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC=listC[listC['sgID_AB']==variant_set.iloc[i]][['guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
| ref_listC=ref_listC[['sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
| ref_listC.columns=['gene','guide_type','protospacer_A','protospacer_B'] | |
| res,res_mut,res_notfound,list_match,list_mutated,gflgc1=get_lists(ref_listC,listC_found_lr,listC_notfound_lr) | |
| dft_c=dft_c.append(ref_listC) | |
| if res.shape[0]>0: | |
| dft_lr_resc=dft_lr_resc.append(res) | |
| if res_mut.shape[0]>0: | |
| dft_lr_res_mutc=dft_lr_res_mutc.append(res_mut) | |
| if res_notfound.shape[0]>0: | |
| dft_lr_notfoundc= dft_lr_notfoundc.append(res_notfound) | |
| if list_match.shape[0]>0: | |
| df_matched_guides_lr= df_matched_guides_lr.append(list_match) | |
| if list_mutated.shape[0]>0: | |
| df_mutated_guides_lr= df_mutated_guides_lr.append(list_mutated) | |
| if dft_lr_resc.shape[0]>0: | |
| st.write('Matched to **CHM13** Reference Guides for **Set C**') | |
| tbl_disp(dft_lr_resc,'select_genes','SetC_CHM13',19) | |
| elif dft_lr_res_mutc.shape[0]>0: | |
| st.write('Mutated to **CHM13** Reference Guides for **Set C**') | |
| st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(dft_lr_res_mutc,'select_genes','SetC_Mutated_CHM13',20) | |
| if dft_lr_notfoundc.shape[0]>0: | |
| st.write('**SetC Guides Not Found in CHM13**') | |
| st.table(dft_lr_notfoundc) | |
| #NOW MERGE FROM GRCh38 and LR | |
| merged_mutated_set=pd.merge(df_mutated_guides_ref,df_mutated_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_mutated_set = merged_mutated_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| merged_match_set=pd.merge(df_matched_guides_ref,df_matched_guides_lr, how="outer",on=["gene","ref_guide","chr"],suffixes=["_GRCh38",'_LR']) | |
| merged_match_set = merged_match_set[['gene','ref_guide','chr','position_GRCh38','position_LR','strand_GRCh38','strand_LR','mutated_guide_GRCh38','mutated_guide_LR','num_mismatch_GRCh38','num_mismatch_LR']] | |
| if merged_match_set.shape[0]>0: | |
| #st.write('**Matched** Guides for **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Matched** Guides for **Set C** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| tbl_disp(merged_match_set,'select_genes','SetC_Matched_GRCh38_CHM13',21,0) | |
| #st.table(merged_match_seta) | |
| elif merged_mutated_set.shape[0]>0: | |
| #st.write('**Missmatched** Guides **Set C** (*Each guide sequence has a trailing NGG*)') | |
| st.write('**Mutated** Guides for **Set C** to both **GRCh38 and CHM13 references** (*Each guide sequence has a trailing NGG* and **leading G even if it is a missmatch**)') | |
| #st.markdown(caution1,unsafe_allow_html=True) | |
| tbl_disp(merged_mutated_set,'select_genes','SetC_Mutated_GRCh38_CHM13',22,0) | |
| # if ListARes and ListBRes and ListCRes: | |
| # Order_List = st.checkbox('Generate Order Ready List',key=100) | |
| # if Order_List: | |
| # if dft_lr_resa.shape[0]>0: | |
| # st.table(dft_lr_resa) | |
| elif ListCRes: | |
| st.write("**Please select genes from the above table to begin**") | |
| elif Calc=='Not_Found': | |
| ListAResNotFound = st.checkbox('Results For SetA',key=30) | |
| if ListAResNotFound and listA_notfound_lr.shape[0]>0: | |
| listA_notfound_LR_sorted=listA_notfound_lr.sort_values('gene') | |
| sz1a=listA_notfound_LR_sorted.shape[0] | |
| vaild_guides_a = listA_notfound_LR_sorted[~listA_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz2a=vaild_guides_a.shape[0] | |
| st.write(str(sz2a)+"/"+str(sz1a)+' Guides Not Found') | |
| tbl_disp(vaild_guides_a,'all_not_found','SetA_KOLF2.1',23,0) | |
| #now get gene names only | |
| genesa=vaild_guides_a['gene'].str.split('_').str[0] | |
| genesa1=genesa[genesa.duplicated(keep=False)] | |
| genesa2=genesa1.unique() | |
| pair_lista=[] | |
| for g in genesa2: | |
| g1=vaild_guides_a[vaild_guides_a['gene'].str.contains(g)] | |
| g2=g1.reset_index(drop=True) | |
| pair_lista.append([g2.gene[0],g2.ref_guide[0],g2.gene[1],g2.ref_guide[1]]) | |
| pair_missmatch_a = pd.DataFrame(pair_lista, columns=['sgID_1','sgRNA_1','sgID_2','sgRNA_2']) | |
| sz22a=pair_missmatch_a.shape[0] | |
| st.write(str(sz22a)+"/"+str(sz2a)+' Paired Guides Not Found') | |
| tbl_disp(pair_missmatch_a,'all_not_found','SetA_KOLF2.1',23,0) | |
| non_targeting_guides_a = listA_notfound_LR_sorted[listA_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz3a=non_targeting_guides_a.shape[0] | |
| st.write(str(sz3a)+"/"+str(sz1a)+' no-targeting Guides Not Found') | |
| tbl_disp(non_targeting_guides_a,'all_not_found','SetA_KOLF2.1',23,0) | |
| ListBResNotFound = st.checkbox('Results For SetB',key=40) | |
| if ListBResNotFound: | |
| listB_notfound_LR_sorted=listB_notfound_lr.sort_values('gene') | |
| sz1b=listB_notfound_LR_sorted.shape[0] | |
| vaild_guides_b = listB_notfound_LR_sorted[~listB_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz2b=vaild_guides_b.shape[0] | |
| st.write(str(sz2b)+"/"+str(sz1b)+' Guides Not Found') | |
| tbl_disp(vaild_guides_b,'all_not_found','SetA_KOLF2.1',23,0) | |
| #now get gene names only | |
| genesb=vaild_guides_b['gene'].str.split('_').str[0] | |
| genesb1=genesb[genesb.duplicated(keep=False)] | |
| genesb2=genesb1.unique() | |
| pair_listb=[] | |
| for g in genesb2: | |
| g1=vaild_guides_b[vaild_guides_b['gene'].str.contains(g)] | |
| g2=g1.reset_index(drop=True) | |
| pair_listb.append([g2.gene[0],g2.ref_guide[0],g2.gene[1],g2.ref_guide[1]]) | |
| pair_missmatch_b = pd.DataFrame(pair_listb, columns=['sgID_1','sgRNA_1','sgID_2','sgRNA_2']) | |
| sz22b=pair_missmatch_b.shape[0] | |
| st.write(str(sz22b)+"/"+str(sz2b)+' Paired Guides Not Found') | |
| tbl_disp(pair_missmatch_b,'all_not_found','SetA_KOLF2.1',23,0) | |
| non_targeting_guides_b = listB_notfound_LR_sorted[listB_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz3b=non_targeting_guides_b.shape[0] | |
| st.write(str(sz3b)+"/"+str(sz1b)+' no-targeting Guides Not Found') | |
| tbl_disp(non_targeting_guides_b,'all_not_found','SetA_KOLF2.1',23,0) | |
| ListCResNotFound = st.checkbox('Results For SetC',key=50) | |
| if ListCResNotFound: | |
| listC_notfound_LR_sorted=listC_notfound_lr.sort_values('gene') | |
| sz1c=listC_notfound_LR_sorted.shape[0] | |
| vaild_guides_c = listC_notfound_LR_sorted[~listC_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz2c=vaild_guides_c.shape[0] | |
| st.write(str(sz2c)+"/"+str(sz1c)+' Guides Not Found') | |
| tbl_disp(vaild_guides_c,'all_not_found','SetA_KOLF2.1',23,0) | |
| #now get gene names only | |
| genesc=vaild_guides_c['gene'].str.split('_').str[0] | |
| genesc1=genesc[genesc.duplicated(keep=False)] | |
| genesc2=genesc1.unique() | |
| pair_listc=[] | |
| for g in genesc2: | |
| g1=vaild_guides_c[vaild_guides_c['gene'].str.contains(g)] | |
| g2=g1.reset_index(drop=True) | |
| pair_listc.append([g2.gene[0],g2.ref_guide[0],g2.gene[1],g2.ref_guide[1]]) | |
| pair_missmatch_c = pd.DataFrame(pair_listc, columns=['sgID_1','sgRNA_1','sgID_2','sgRNA_2']) | |
| sz22c=pair_missmatch_c.shape[0] | |
| st.write(str(sz22c)+"/"+str(sz2c)+' Paired Guides Not Found') | |
| tbl_disp(pair_missmatch_c,'all_not_found','SetA_KOLF2.1',23,0) | |
| non_targeting_guides_c = listC_notfound_LR_sorted[listC_notfound_LR_sorted['gene'].str.contains("non")] | |
| sz3c=non_targeting_guides_c.shape[0] | |
| st.write(str(sz3c)+"/"+str(sz1c)+' no-targeting Guides Not Found') | |
| tbl_disp(non_targeting_guides_c,'all_not_found','SetA_KOLF2.1',23,0) | |
| else: | |
| st.write("**Place Holder for All**") |