Spaces:
Runtime error
Runtime error
import streamlit as st | |
import pandas as pd | |
import numpy as np | |
from st_aggrid import AgGrid, GridOptionsBuilder,GridUpdateMode,DataReturnMode | |
from iteration_utilities import duplicates | |
from iteration_utilities import unique_everseen | |
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>' | |
#READ INPUT FILES | |
cwd=os.getcwd()+'/'+'data/' | |
#Here, gene column is modified for non-targeting guides in the format sgID_1|sgID_2 for coherent downstream manipulation | |
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] | |
#st.write(listA.shape) | |
variantsa1=listA['gene'].unique() | |
variantsb1=listB['gene'].unique() | |
variantsc1=listC['gene'].unique() | |
#Make a comprehensive lsit of genes in all 3 lists (Please not that non-targeting guide names are not same across three lists) | |
con = np.concatenate((variantsa1, variantsb1, variantsc1)) | |
variants_s=sorted(np.unique(con)) | |
#NOW read GRCh38 and LR guides for stea as identified by LR-Guides pipeline | |
#Format is: gene (as many entries as number of guides found, both matched and mutated), ref_guide, chr, position, mutated_guide (can also be same as reference), strand, num_mismatcg (excluding leading G), Please note that each guide has trailing NGG | |
listA_found_ref = pd.read_csv(cwd+"seta_found_ref1.csv",index_col=False) | |
listA_found_ref = listA_found_ref.sort_values('gene') | |
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) #Also change strnad to strand (was misspelled in LR-Guides pipeline) | |
#This (all such) file has 2-columns (gene as given in sgID_1/2, ref_guide). | |
listA_notfound_ref = pd.read_csv(cwd+"seta_notfound_ref1.csv",index_col=False) | |
listA_notfound_ref=listA_notfound_ref.sort_values('gene') | |
lsita_ref_notfound_sz=listA_notfound_ref.shape[0] | |
#LR guides | |
listA_found_lr = pd.read_csv(cwd+"seta_found_LR1.csv",index_col=False) | |
listA_found_lr=listA_found_lr.sort_values('gene') | |
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) | |
listA_notfound_lr=listA_notfound_lr.sort_values('gene') | |
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) | |
listB_found_ref=listB_found_ref.sort_values('gene') | |
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=listB_found_ref.sort_values('gene') | |
listB_found_ref.rename(columns = {'strnad':'strand'}, inplace = True) | |
listB_notfound_ref = pd.read_csv(cwd+"setb_notfound_ref1.csv",index_col=False) | |
listB_notfound_ref=listB_notfound_ref.sort_values('gene') | |
lsitb_ref_notfound_sz=listB_notfound_ref.shape[0] | |
listB_found_lr = pd.read_csv(cwd+"setb_found_LR1.csv",index_col=False) | |
listB_found_lr=listB_found_lr.sort_values('gene') | |
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) | |
listB_notfound_lr=listB_notfound_lr.sort_values('gene') | |
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) | |
listC_found_ref=listC_found_ref.sort_values('gene') | |
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) | |
listC_notfound_ref=listC_notfound_ref.sort_values('gene') | |
lsitc_ref_notfound_sz=listC_notfound_ref.shape[0] | |
listC_found_lr = pd.read_csv(cwd+"setc_found_LR1.csv",index_col=False) | |
listC_found_lr=listC_found_lr.sort_values('gene') | |
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) | |
listC_notfound_lr=listC_notfound_lr.sort_values('gene') | |
lsitc_lr_notfound_sz=listC_notfound_lr.shape[0] | |
#This for all guides order table | |
set_start=0 | |
regular_lista=listA[~listA['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
regular_lista=regular_lista.sort_values() | |
set_end=regular_lista.shape[0] #18905 | |
#regular_lista=regular_lista.iloc[set_start:set_end] | |
non_targeting_lista=listA[listA['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
non_targeting_lista=non_targeting_lista.sort_values() | |
#regular_lista=regular_lista.reset_index() | |
regular_listb=listB[~listB['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
regular_listb=regular_listb.sort_values() | |
#regular_listb=regular_listb.iloc[set_start:set_end] | |
non_targeting_listb=listB[listB['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
non_targeting_listb=non_targeting_listb.sort_values() | |
#regular_listb=regular_listb.reset_index() | |
regular_listc=listC[~listC['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
regular_listc=regular_listc.sort_values() | |
#regular_listc=regular_listc[set_start:set_end] | |
non_targeting_listc=listC[listC['gene'].str.contains('non-targeting')]['sgID_AB']#[['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
non_targeting_listc=non_targeting_listc.sort_values() | |
#GENERAL FUNCTIONS | |
def transform(df,str): | |
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') | |
#########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, | |
) | |
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 get_lists(ref_list,list_found_ref,list_notfound_ref): | |
#This module retrieves guide_id and searches for guide sequences from the table | |
#st.table(ref_list) | |
a_ref=[] | |
#st.table(ref_list) | |
for i in range(len(ref_list)): | |
a_ref.append(ref_list.sgID_AB.values[i].split('|')[0]) | |
a_ref.append(ref_list.sgID_AB.values[i].split('|')[1]) | |
set_found0_ref=[] | |
#st.table(a_ref) | |
for i in range(len(a_ref)): | |
set_found0_ref.append(list_found_ref[list_found_ref['gene']==a_ref[i]]) | |
#st.write(set_found0_ref) | |
list_concatenated_found_ref = pd.concat(set_found0_ref) | |
list_concatenated_match_ref = list_concatenated_found_ref[list_concatenated_found_ref.num_mismatch == 0] #only select guides with zero mismatches for match list, MISSMATCH LIST LATER | |
#Also remove Alternate loci's data | |
list_concatenated_match_ref = list_concatenated_match_ref[list_concatenated_match_ref['chr'].str.contains('chr')] | |
#st.table(list_concatenated_match_ref) | |
#also create new list with both sgRNAs in one row | |
dft=pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
guideflg1=1 | |
#st.table(list_concatenated_match_ref) | |
if list_concatenated_match_ref.shape[0]>0: | |
guideflg1=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) | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,t.iloc[[i]]], 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) | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,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) | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,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.iloc[:1], 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) | |
dft_mut=pd.concat([dft_mut,list_concatenated_mutated_ref1]) | |
return dft_mut | |
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,ref_sel): | |
# st.table(set12) | |
# st.table(set34) | |
# st.table(set56) | |
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_notfound_all=pd.DataFrame(columns=['gene','sgID_AB','guide_type','protospacer_A','protospacer_B']) | |
#dft_notfound=pd.DataFrame(columns=['gene','ref_guide']) | |
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]][['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
ref_listA = ref_listA[['gene','sgID_AB','guide_type','protospacer_A','protospacer_B']] | |
#st.write(ref_listA) | |
#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) | |
#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.table(ref_listA) | |
# st.write(gflga1,gflgb1,gflgc1) | |
if gflga1==0: | |
#Also verigy that both guides are different | |
#st.table(resa) | |
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) | |
dft_order_table=pd.concat([dft_order_table, resa]) #dft_order_table.concat(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 | |
if f[0]==0: | |
resa['guide_type']="1-3" | |
else: | |
resa['guide_type']="2-3" | |
#dft_order_table=dft_order_table.append(resa) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: # f[2]==0: | |
resa['gene']=gene_n | |
if f[0]==0: | |
resa['guide_type']="1-4" | |
else: | |
resa['guide_type']="2-4" | |
#dft_order_table=dft_order_table.append(resa) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
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) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: # f[2]==0: | |
resa['gene']=gene_n | |
resa['guide_type']=str(gflga1)+"-4" | |
#dft_order_table=dft_order_table.append(resa) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
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) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: # f[2]==0: | |
resa['gene']=gene_n | |
resa['guide_type']=str(gflga1)+"-6" | |
#dft_order_table=dft_order_table.append(resa) | |
dft_order_table=pd.concat([dft_order_table,resa]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
elif resb.shape[0]>0: #at least one guide | |
if gflgb1==0: | |
if resb['sgID_1'][0] != resb['sgID_2'][0]: | |
resb['gene']=gene_n | |
resb['guide_type']='3-4' | |
#dft_order_table=dft_order_table.append(resb) | |
dft_order_table=pd.concat([dft_order_table,resb]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
elif 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+2)+"-5" | |
#dft_order_table=dft_order_table.append(resb) | |
dft_order_table=pd.concat([dft_order_table,resb]) | |
else: # f[2]==0: | |
resb['gene']=gene_n | |
resb['guide_type']=str(gflgb1+2)+"-6" | |
#dft_order_table=dft_order_table.append(resb) | |
dft_order_table=pd.concat([dft_order_table,resb]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
elif resc.shape[0]>0: #at least one guide | |
if gflgc1==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) | |
dft_order_table=pd.concat([dft_order_table,resc]) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
else: | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listA], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listB], ignore_index = True) | |
dft_notfound_all=pd.concat([dft_notfound_all,ref_listC], ignore_index = True) | |
if dft_order_table.shape[0]>0: | |
#check total guides found | |
# st.write(str(set12.shape[0])) | |
# st.write(str(set34.shape[0])) | |
# st.write(str(set56.shape[0])) | |
st.write('**Please note that for guides matching to multiple locations (an example is ABCC6), only first pair is returned**') | |
szt=set12.shape[0] | |
szf=dft_order_table.shape[0] | |
# st.write(str(dft_order_table.shape[0])) | |
szd=szt-szf | |
if szd>0: | |
st.write('Order Ready '+ref_sel+' guides List: '+str(szd)+'/'+str(szt)+' **guides were not found**') | |
tbl_disp(dft_order_table,'select_genes','SetA_CHM13',5) | |
else: | |
st.write('Order Ready '+ref_sel+' guides List') | |
tbl_disp(dft_order_table,'select_genes','SetA_CHM13',5) | |
else: | |
st.write('**No guides found in ListA, ListB and ListC**') | |
if dft_notfound_all.shape[0]>0: | |
st.write('**Guides not found in any lists**') | |
tbl_disp(dft_notfound_all,'select_genes','SetA_CHM13',6) | |
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): | |
mid=int(t.shape[0]/2) | |
for i in range(int(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=t.iloc[[mid]] | |
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_2'] | |
#dft=dft.append(listA_concatenated_match_LR1) | |
dft=pd.concat([dft,listA_concatenated_match_LR1]) | |
mid=mid+1 | |
return dft | |
#Get non-targeting lists | |
def get_lists_non_targeting(ref_list,list_found_ref,list_notfound_ref): | |
#This module retrieves guide_id and searches for guide sequences from the table | |
#st.table(ref_list) | |
a_ref=[] | |
for i in range(len(ref_list)): | |
a_ref.append(ref_list.sgID_AB.values[i].split('|')[0]) | |
a_ref.append(ref_list.sgID_AB.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] #only select guides with zero mismatches for match list, MISSMATCH LIST LATER | |
#get matching to Alternating loci's | |
list_concatenated_match_alt_ref = list_concatenated_match_ref[~list_concatenated_match_ref['chr'].str.contains('chr')] | |
#Also remove Alternate loci's data | |
list_concatenated_match_ref = list_concatenated_match_ref[list_concatenated_match_ref['chr'].str.contains('chr')] | |
#st.table(list_concatenated_match_ref) | |
#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=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,t.iloc[[i+1]]], ignore_index = True) | |
i=i+2 | |
else: #repeat entries | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
#st.table(t1) | |
i=i+1 | |
else: | |
t1=pd.concat([t1,t.iloc[[i]]], ignore_index = True) | |
t1=pd.concat([t1,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_alt_ref = list_concatenated_mutated_ref[~list_concatenated_mutated_ref['chr'].str.contains('chr')] | |
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(list_notfound_ref[list_notfound_ref['gene']==a_ref[0]]) | |
#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(a_ref) | |
#st.table(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,list_concatenated_match_alt_ref,list_concatenated_mutated_alt_ref,guideflg1 | |
########### | |
#Get All Guides Stats | |
#def process_all_guides(glist,list,ref_type,guide_type): | |
def process_all_guides(glist,for_list,f_list,nf_list): | |
#st.write(type(glist)) | |
#st.table(for_list) | |
#for_list=for_list.reset_index() | |
variant_set=glist['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_matched_alt_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']) | |
df_mutated_guides_alt_ref = pd.DataFrame(columns=['gene','ref_guide', 'chr', 'position', 'mutated_guide', 'strand', 'num_mismatch']) | |
#st.table(for_list) | |
for i in range(variant_set.shape[0]): | |
#st.write(variant_set.iloc[i]) | |
ref_listC=for_list[for_list['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']] | |
#st.table(ref_listC) | |
#st.table(ref_listC) | |
res,res_mut,res_notfound,list_match,list_mutated,list_match_alt,list_mutated_alt,gflgc1=get_lists_non_targeting(ref_listC,f_list,nf_list) | |
#dft_c=dft_c.append(ref_listC) | |
if res.shape[0]>0: | |
dft_resc=pd.concat([dft_resc,res]) | |
if res_mut.shape[0]>0: | |
dft_res_mutc=pd.concat([dft_res_mutc,res_mut]) | |
if res_notfound.shape[0]>0: | |
dft_notfoundc= pd.concat([dft_notfoundc,res_notfound]) | |
if list_match.shape[0]>0: | |
df_matched_guides_ref= pd.concat([df_matched_guides_ref,list_match]) | |
if list_mutated.shape[0]>0: | |
df_mutated_guides_ref= pd.concat([df_mutated_guides_ref,list_mutated]) | |
if list_match_alt.shape[0]>0: | |
df_matched_alt_ref=pd.concat([df_matched_alt_ref,list_mutated]) | |
if list_mutated_alt.shape[0]>0: | |
df_mutated_guides_alt_ref=pd.concat([df_mutated_guides_alt_ref,list_mutated_alt]) | |
if df_matched_guides_ref.shape[0]>0: | |
#st.write(type(df_matched_guides_ref['gene'])) | |
gl=df_matched_guides_ref['gene'] | |
dupesm=gl[gl.duplicated()] | |
if df_mutated_guides_ref.shape[0]>0: | |
gl=df_mutated_guides_ref['gene'] | |
dupesmu=gl[gl.duplicated()] | |
#now check common between matched and mutated | |
# if dupesm.shape[0]>0 and dupesmu.shape[0]>0: | |
# common_list = set(dupesm).intersection(dupesmu) | |
# st.table(common_list) | |
# st.write('common guides between matched and mutated lists are: '+len(common_list)) | |
if df_matched_guides_ref.shape[0]>0: | |
if dupesm.shape[0]>0: | |
st.write('**Matched Guides**: '+str(df_matched_guides_ref.shape[0])+' and: '+str(dupesm.shape[0])+' are repeated guides (matched to multiple locations)') | |
tbl_disp(df_matched_guides_ref,'select_genes','SetC_GRCh38',17) | |
#st.table(dupesm,'select_genes','SetC_GRCh38',17) | |
tbl_disp(dupesm,'select_genes','SetC_GRCh38',17) | |
else: | |
st.write('**Matched Guides**: '+str(df_matched_guides_ref.shape[0])) | |
tbl_disp(df_matched_guides_ref,'select_genes','SetC_GRCh38',17) | |
if df_matched_alt_ref.shape[0]>0: | |
st.write('**Matched Guides to Alt Loci**: '+str(df_matched_alt_ref.shape[0])) | |
tbl_disp(df_matched_alt_ref,'select_genes','SetC_GRCh38',17) | |
if df_mutated_guides_ref.shape[0]>0: | |
#gl=df_mutated_guides_ref['gene'] | |
#dupesmu=gl[gl.duplicated()] | |
if dupesmu.shape[0]>0: | |
st.write('**Mutated Guides (some might have >1 guides)**: '+str(df_mutated_guides_ref.shape[0])+' and: '+str(dupesmu.shape[0])+' are repeated guides') | |
tbl_disp(df_mutated_guides_ref,'select_genes','SetC_GRCh38',18) | |
#st.table(dupesmu) | |
else: | |
st.write('**Mutated Guides (some might have >1 guides)**: '+str(df_mutated_guides_ref.shape[0])) | |
tbl_disp(df_mutated_guides_ref,'select_genes','SetC_GRCh38',18) | |
if df_mutated_guides_alt_ref.shape[0]>0: | |
st.write('**Mutated Guides to Alt Loci**: '+str(df_mutated_guides_alt_ref.shape[0])) | |
tbl_disp(df_mutated_guides_alt_ref,'select_genes','SetC_GRCh38',18) | |
if dft_notfoundc.shape[0]>0: | |
st.write('**Guides Not Found**: '+str(dft_notfoundc.shape[0])) | |
tbl_disp(dft_notfoundc,'select_genes','SetC_GRCh38',19) | |
#CALC BASED ON LIST, GUIDE TYPE AND REFERENCE | |
#END GENERAL FUNCTIONS | |
st.title('Long Read Guides Search') | |
st.write('**Important:** Please note that **MTMR3** is not present in guides_c list, so we have **removed it from list a and list b**') | |
#tbl_disp(regulara,'variant','ref_guides',0,1) | |
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','sgID_AB','guide_type','protospacer_A','protospacer_B']) | |
reflistA_concatenated = pd.DataFrame(columns=['gene','sgID_AB','guide_type','protospacer_A','protospacer_B']) | |
reflistB_concatenated = pd.DataFrame(columns=['gene','sgID_AB','guide_type','protospacer_A','protospacer_B']) | |
reflistC_concatenated = pd.DataFrame(columns=['gene','sgID_AB','guide_type','protospacer_A','protospacer_B']) | |
for variant in multi_genes: | |
ref_listA=listA[listA['gene']==variant][['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
ref_listA = ref_listA[['gene','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][['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
ref_listB = ref_listB[['gene','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][['gene','guide_type','protospacer_A','protospacer_B','sgID_AB']] | |
ref_listC = ref_listC[['gene','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([10,2]) | |
with c2: | |
get_table_order=tbl_disp(listA_concatenated_orig,'variant','ref_guides',111,0) | |
with c3: | |
ref_sel = st.radio("Select Reference", | |
('CHM13','GRCh38'), | |
horizontal=True) | |
Updated1=st.form_submit_button(label = 'Generate Order Ready Table') | |
if not isinstance(get_table_order, type(None)): # and Updated1:# and get_table_order.shape[0]>0: | |
if ref_sel=='GRCh38': | |
list_founda=listA_found_ref | |
list_notfounda=listA_notfound_ref | |
list_foundb=listB_found_ref | |
list_notfoundb=listB_notfound_ref | |
list_foundc=listC_found_ref | |
list_notfoundc=listC_notfound_ref | |
else: | |
list_founda=listA_found_lr | |
list_notfounda=listA_notfound_lr | |
list_foundb=listB_found_lr | |
list_notfoundb=listB_notfound_lr | |
list_foundc=listC_found_lr | |
list_notfoundc=listC_notfound_lr | |
variant_set12=get_table_order[get_table_order['guide_type']=='1-2']['sgID_AB'] | |
variant_set34=get_table_order[get_table_order['guide_type']=='3-4']['sgID_AB'] | |
variant_set56=get_table_order[get_table_order['guide_type']=='5-6']['sgID_AB'] | |
#st.table(variant_set12) | |
#st.write(variant_set12) | |
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) | |
order_ready_tbl_CHM13(variant_set12,variant_set34,variant_set56,list_founda,list_notfounda,list_foundb,list_notfoundb,list_foundc,list_notfoundc,ref_sel) | |
########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) | |
else: | |
st.write('**Please select guides and Press Update Button to Begin Processing**') | |
if 'get_table_order' in locals(): | |
if not isinstance(get_table_order, type(None)): | |
st.write('**For List wise results, Please select a List**') | |
reflistA_concatenated=get_table_order[get_table_order['guide_type']=='1-2'] | |
reflistA_concatenated.drop("_selectedRowNodeInfo",axis=1,inplace=True) | |
reflistB_concatenated=get_table_order[get_table_order['guide_type']=='3-4'] | |
reflistB_concatenated.drop("_selectedRowNodeInfo",axis=1,inplace=True) | |
reflistC_concatenated=get_table_order[get_table_order['guide_type']=='5-6'] | |
reflistC_concatenated.drop("_selectedRowNodeInfo",axis=1,inplace=True) | |
#st.write('**Important:** If a guides is **not** in **found, mutated and not_found list (such as GSTT1), then it is found in Alternative Loci and Removed**') | |
with st.form(key='columns_in_form_lists'): | |
c2, c3= st.columns([10,1])#([10,10]) | |
with c2: | |
List_Selected = st.selectbox('Please select list', | |
('','ListA','ListB','ListC')) | |
Show_ListResults=st.form_submit_button(label = 'GO') | |
#ListARes = st.checkbox('Results For SetA',key=300) | |
if List_Selected=='ListA':# and not isinstance(get_table, type(None)):#get_table!=None: | |
ref_list= listA | |
st.write('**Please select Guides From Table Below to processes from ListA**') | |
with st.form(key='columns_in_form_listsA'): | |
c2, c3= st.columns([100,2])#([10,10]) | |
with c2: | |
get_table=tbl_disp(reflistA_concatenated,variant,'ref_guides',2,0) | |
#List_Selected = st.selectbox('Please select list', | |
#('ListA','ListB','ListC')) | |
Show_ListResults=st.form_submit_button(label = 'Show ListA Results') | |
#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)): | |
if ref_sel=='GRCh38': | |
list_found=listA_found_ref | |
list_notfound=listA_notfound_ref | |
else: | |
list_found=listA_found_lr | |
list_notfound=listA_notfound_lr | |
variant_set=get_table['sgID_AB'] | |
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=ref_list[ref_list['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'] | |
#st.table(ref_listA) | |
res,res_mut,res_notfound,list_match,list_mutated,gflga1=get_lists(ref_listA,list_found,list_notfound) | |
#dft_a=dft_a.append(ref_listA) | |
if res.shape[0]>0: | |
dft_resa=pd.concat([dft_resa,res]) | |
if res_mut.shape[0]>0: | |
dft_res_muta=pd.concat([dft_res_muta,res_mut]) | |
if res_notfound.shape[0]>0: | |
dft_notfounda= pd.concat([dft_notfounda,res_notfound]) | |
if list_match.shape[0]>0: | |
df_matched_guides_ref= pd.concat([df_matched_guides_ref,list_match]) | |
if list_mutated.shape[0]>0: | |
df_mutated_guides_ref= pd.concat([df_mutated_guides_ref,list_mutated]) | |
#st.write('Selected Reference Guides for **Set A**') | |
#tbl_disp(dft_a,'All','ReferenceGuides',0) | |
st.write('**Important:** If a guides is **not** in **found, mutated and not_found list (such as GSTT1), then it is found in Alternative Loci and Removed**') | |
if dft_resa.shape[0]>0: | |
st.write('Matched to '+ref_sel+' Reference Guides for **Set A**') | |
tbl_disp(dft_resa,'select_genes','SetA_GRCh38',3) | |
elif dft_res_muta.shape[0]>0: | |
st.write('None of the guides Matched, So reporting **Mutated to** '+ref_sel+' 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 '+ref_sel+' (None of the guides are Matched/Mutated)**') | |
#tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
st.table(dft_notfounda) | |
#ListBRes = st.checkbox('Results For SetB',key=40) | |
if List_Selected=='ListB': # and not isinstance(get_table, type(None)):#get_table!=None: | |
ref_list= listB | |
st.write('**Please select Guides From Table Below to processes from ListB**') | |
with st.form(key='columns_in_form_listsA'): | |
c2, c3= st.columns([100,2])#([10,10]) | |
with c2: | |
get_table=tbl_disp(reflistB_concatenated,variant,'ref_guides',2,0) | |
Show_ListResults=st.form_submit_button(label = 'Show ListB Results') | |
if not isinstance(get_table, type(None)): | |
if ref_sel=='GRCh38': | |
list_found=listB_found_ref | |
list_notfound=listB_notfound_ref | |
else: | |
list_found=listB_found_lr | |
list_notfound=listB_notfound_lr | |
#variant_set=get_table[['gene']] | |
variant_set=get_table['sgID_AB'] | |
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=ref_list[ref_list['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,list_found,list_notfound) | |
#dft_b=dft_b.append(ref_listB) | |
if res.shape[0]>0: | |
dft_resb=pd.concat([dft_resb,res]) | |
if res_mut.shape[0]>0: | |
dft_res_mutb=pd.concat([dft_res_mutb,res_mut]) | |
if res_notfound.shape[0]>0: | |
dft_notfoundb= pd.concat([dft_notfoundb,res_notfound]) | |
if list_match.shape[0]>0: | |
df_matched_guides_ref= pd.concat([df_matched_guides_ref,list_match]) | |
if list_mutated.shape[0]>0: | |
df_mutated_guides_ref= pd.concat([df_mutated_guides_ref,list_mutated]) | |
#st.write('Selected Reference Guides for **Set B**') | |
#tbl_disp(dft_b,'All','ReferenceGuides',0) | |
st.write('**Important:** If a guides is **not** in **found, mutated and not_found list (such as GSTT1), then it is found in Alternative Loci and Removed**') | |
if dft_resb.shape[0]>0: | |
st.write('Matched to '+ref_sel+' Reference Guides for **Set B**') | |
tbl_disp(dft_resb,'select_genes','SetB_GRCh38',10) | |
elif dft_res_mutb.shape[0]>0: | |
st.write('None of the guides Matched, So reporting **Mutated to '+ref_sel+' 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 '+ref_sel+' (None of the guides are Matched/Mutated)**') | |
#tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
st.table(dft_notfoundb) | |
#ListCRes = st.checkbox('Results For SetC',key=50) | |
if List_Selected=='ListC': # and not isinstance(get_table, type(None)):#get_table!=None: | |
ref_list= listC | |
st.write('**Please select Guides From Table Below to processes from ListC**') | |
with st.form(key='columns_in_form_listsA'): | |
c2, c3= st.columns([100,2])#([10,10]) | |
with c2: | |
get_table=tbl_disp(reflistC_concatenated,variant,'ref_guides',2,0) | |
Show_ListResults=st.form_submit_button(label = 'Show ListC Results') | |
if not isinstance(get_table, type(None)): | |
if ref_sel=='GRCh38': | |
list_found=listC_found_ref | |
list_notfound=listC_notfound_ref | |
else: | |
list_found=listC_found_lr | |
list_notfound=listC_notfound_lr | |
variant_set=get_table['sgID_AB'] | |
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=ref_list[ref_list['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,list_found,list_notfound) | |
#dft_c=dft_c.append(ref_listC) | |
if res.shape[0]>0: | |
dft_resc=pd.concat([dft_resc,res]) | |
if res_mut.shape[0]>0: | |
dft_res_mutc=pd.concat([dft_res_mutc,res_mut]) | |
if res_notfound.shape[0]>0: | |
dft_notfoundc= pd.concat([dft_notfoundc,res_notfound]) | |
if list_match.shape[0]>0: | |
df_matched_guides_ref= pd.concat([df_matched_guides_ref,list_match]) | |
if list_mutated.shape[0]>0: | |
df_mutated_guides_ref= pd.concat([df_mutated_guides_ref,list_mutated]) | |
#st.write('Selected Reference Guides for **Set C**') | |
#tbl_disp(dft_c,'All','ReferenceGuides',0) | |
st.write('**Important:** If a guides is **not** in **found, mutated and not_found list (such as GSTT1), then it is found in Alternative Loci and Removed**') | |
if dft_resc.shape[0]>0: | |
st.write('Matched to '+ref_sel+' Reference Guides for **Set C**') | |
tbl_disp(dft_resc,'select_genes','SetC_GRCh38',17) | |
elif dft_res_mutc.shape[0]>0: | |
st.write('None of the guides Matched, So reporting **Mutated to '+ref_sel+' 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 '+ref_sel+' (None of the guides are Matched/Mutated)**') | |
#tbl_disp(dft_notfound,'select_genes','SetA_Notfound_GRCh38') | |
st.table(dft_notfoundc) | |
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: | |
guidetype = st.radio("Select Guide Type",('Non-targetting','Regular'),horizontal=True) | |
if guidetype=='Non-targetting': | |
with st.form(key='columns_in_form_non'): | |
c2, c3 = st.columns([5,5])#([10,10]) | |
with c2: | |
guides_List = st.selectbox('Please select list', | |
('ListA','ListB','ListC')) | |
with c3: | |
ref_type_sel_non = st.radio("Select Reference", | |
('CHM13','GRCh38'), | |
horizontal=True) | |
Show_Results_non=st.form_submit_button(label = 'Non-targeting Guides Results') | |
if Show_Results_non and guides_List=='ListA': | |
for_list=listA | |
if ref_type_sel_non=='GRCh38': | |
f_list=listA_found_ref | |
nf_list=listA_notfound_ref | |
else: | |
f_list=listA_found_lr | |
nf_list=listA_notfound_lr | |
st.write('Total: '+str(len(non_targeting_lista))+' Non-targeting Guide pairs and '+str(2*len(non_targeting_lista))+' single guides in ListA') | |
process_all_guides(pd.DataFrame(pd.Series(non_targeting_lista,name='gene')),for_list,f_list,nf_list) | |
if Show_Results_non and guides_List=='ListB': | |
for_list=listB | |
if ref_type_sel_non=='GRCh38': | |
f_list=listB_found_ref | |
nf_list=listB_notfound_ref | |
else: | |
f_list=listB_found_lr | |
nf_list=listB_notfound_lr | |
st.write('Total: '+str(len(non_targeting_listb))+' Non-targeting Guide pairs and '+str(2*len(non_targeting_listb))+' single guides in ListA') | |
process_all_guides(pd.DataFrame(pd.Series(non_targeting_listb,name='gene')),for_list,f_list,nf_list) | |
if Show_Results_non and guides_List=='ListC': | |
for_list=listC | |
if ref_type_sel_non=='GRCh38': | |
f_list=listC_found_ref | |
nf_list=listC_notfound_ref | |
else: | |
f_list=listC_found_lr | |
nf_list=listC_notfound_lr | |
st.write('Total: '+str(len(non_targeting_listc))+' Non-targeting Guide pairs and '+str(2*len(non_targeting_listc))+' single guides in ListA') | |
process_all_guides(pd.DataFrame(pd.Series(non_targeting_listc,name='gene')),for_list,f_list,nf_list) | |
elif guidetype=='Regular': | |
st.write('**Maximum End Index=** '+str(regular_lista.shape[0])) | |
with st.form(key='columns_in_form_regular'): | |
c2, c3, c4 = st.columns([5,5,5])#([10,10]) | |
with c2: | |
set_start = int(st.text_input('Start Index', '0')) | |
with c3: | |
set_end = int(st.text_input('End Index', str(regular_lista.shape[0]))) | |
with c4: | |
ref_type_sel = st.radio("Select Reference", | |
('CHM13','GRCh38'), | |
horizontal=True) | |
Show_Results=st.form_submit_button(label = 'Show Regular Guides Results') | |
if Show_Results:# and guides_List=="ListA": | |
regular_listc=regular_listc[set_start:set_end] | |
regular_listb=regular_listb.iloc[set_start:set_end] | |
regular_lista=regular_lista.iloc[set_start:set_end] | |
if ref_type_sel=='GRCh38': | |
list_founda=listA_found_ref | |
list_notfounda=listA_notfound_ref | |
list_foundb=listB_found_ref | |
list_notfoundb=listB_notfound_ref | |
list_foundc=listC_found_ref | |
list_notfoundc=listC_notfound_ref | |
else: | |
list_founda=listA_found_lr | |
list_notfounda=listA_notfound_lr | |
list_foundb=listB_found_lr | |
list_notfoundb=listB_notfound_lr | |
list_foundc=listC_found_lr | |
list_notfoundc=listC_notfound_lr | |
dupesq=list(duplicates(listA['gene'])) | |
non_targetinga=variantsa1[pd.Series(variantsa1).str.contains('non-targeting')] | |
regulara=variantsa1[~pd.Series(variantsa1).str.contains('non-targeting')] | |
st.write('Total: '+str(len(regulara))+' Regular Guide (unique genes only) **Excluding:** '+str(len(non_targetinga))+' Non-targeting pairs **and** '+str(len(dupesq))+' Repeated entries (same gene names)') | |
order_ready_tbl_CHM13(regular_lista,regular_listb,regular_listc,list_founda,list_notfounda,list_foundb,list_notfoundb,list_foundc,list_notfoundc,ref_type_sel) | |