Update app.py

app.py

@@ -11,30 +11,31 @@ import pathlib
 from pathlib import Path
 import sys
 
-from Bio import AlignIO, SeqIO
+import numpy as np
+from Bio.Align import PairwiseAligner
 # from email_validator import validate_email
 import gradio as gr
 import hydra
 import pandas as pd
 import plotly.express as px
 import requests
+from rdkit.Chem.rdMolDescriptors import CalcNumRotatableBonds, CalcNumHeavyAtoms, CalcNumAtoms
 from requests.adapters import HTTPAdapter, Retry
 from rdkit import Chem
-from rdkit.Chem import RDConfig, Descriptors, Draw, Lipinski, Crippen, PandasTools
+from rdkit.Chem import RDConfig, Descriptors, Draw, Lipinski, Crippen, PandasTools, AllChem
 from rdkit.Chem.Scaffolds import MurckoScaffold
 import seaborn as sns
 
 import swifter
 from tqdm.auto import tqdm
 
-from deepscreen.data.dti import rdkit_canonicalize, validate_seq_str, FASTA_PAT, SMILES_PAT
+from deepscreen.data.dti import validate_seq_str, FASTA_PAT, SMILES_PAT
 from deepscreen.predict import predict
 
 sys.path.append(os.path.join(RDConfig.RDContribDir, 'SA_Score'))
 import sascorer
 
 ROOT = Path.cwd()
-DATA_PATH = Path("./")  # Path("/data")
 
 DF_FOR_REPORT = pd.DataFrame()
 
@@ -56,6 +57,7 @@ SESSION.mount('https://', ADAPTER)
 # SCHEDULER = BackgroundScheduler()
 
 UNIPROT_ENDPOINT = 'https://rest.uniprot.org/uniprotkb/{query}'
+
 CSS = """
 .help-tip {
   position: absolute;
@@ -63,11 +65,11 @@ CSS = """
   top: 0px;
   right: 0px;
   text-align: center;
-  background-color: #29b6f6;
-  border-radius: 50%;
+  border-radius: 40%;
+  /* border: 2px solid darkred; background-color: #8B0000;*/
   width: 24px;
   height: 24px;
-  font-size: 12px;
+  font-size: 16px;
   line-height: 26px;
   cursor: default;
   transition: all 0.5s cubic-bezier(0.55, 0, 0.1, 1);
@@ -75,13 +77,13 @@ CSS = """
 
 .help-tip:hover {
   cursor: pointer;
-  background-color: #ccc;
+  /*background-color: #ccc;*/
 }
 
 .help-tip:before {
   content: '?';
   font-weight: 700;
-  color: #fff;
+  color: #8B0000;
   z-index: 100;
 }
 
@@ -89,13 +91,13 @@ CSS = """
   visibility: hidden;
   opacity: 0;
   text-align: left;
-  background-color: #039be5;
+  background-color: #EFDDE3;
   padding: 20px;
   width: 300px;
   position: absolute;
   border-radius: 4px;
   right: -4px;
-  color: #fff;
+  color: #494F5A;
   font-size: 13px;
   line-height: normal;
   transform: scale(0.7);
@@ -117,7 +119,7 @@ CSS = """
   width: 0;
   height: 0;
   border: 6px solid transparent;
-  border-bottom-color: #039be5;
+  border-bottom-color: #EFDDE3;
   right: 10px;
   top: -12px;
 }
@@ -131,16 +133,6 @@ CSS = """
   left: 0;
 }
 
-.help-tip a {
-  color: #fff;
-  font-weight: 700;
-}
-
-.help-tip a:hover, .help-tip a:focus {
-  color: #fff;
-  text-decoration: underline;
-}
-
 .upload_button {
   background-color: #008000;
 }
@@ -174,46 +166,131 @@ class HelpTip:
 
 
 def sa_score(row):
-    return sascorer.calculateScore((row['Compound']))
+    return sascorer.calculateScore(row['Compound'])
 
 
 def mw(row):
-    return Chem.Descriptors.MolWt((row['Compound']))
+    return Chem.Descriptors.MolWt(row['Compound'])
+
+
+def mr(row):
+    return Crippen.MolMR(row['Compound'])
 
 
 def hbd(row):
-    return Lipinski.NumHDonors((row['Compound']))
+    return Lipinski.NumHDonors(row['Compound'])
 
 
 def hba(row):
-    return Lipinski.NumHAcceptors((row['Compound']))
+    return Lipinski.NumHAcceptors(row['Compound'])
 
 
 def logp(row):
-    return Crippen.MolLogP((row['Compound']))
+    return Crippen.MolLogP(row['Compound'])
+
+
+def atom(row):
+    return CalcNumAtoms(row['Compound'])
+
+
+def heavy_atom(row):
+    return CalcNumHeavyAtoms(row['Compound'])
+
+
+def rotatable_bond(row):
+    return CalcNumRotatableBonds((row['Compound']))
+
+
+def lipinski(row):
+    """
+    Lipinski's rules:
+    Hydrogen bond donors <= 5
+    Hydrogen bond acceptors <= 10
+    Molecular weight <= 500 daltons
+    logP <= 5
+    """
+    if hbd(row) > 5:
+        return False
+    elif hba(row) > 10:
+        return False
+    elif mw(row) > 500:
+        return False
+    elif logp(row) > 5:
+        return False
+    else:
+        return True
+
+
+def reos(row):
+    """
+    Rapid Elimination Of Swill filter:
+    Molecular weight between 200 and 500
+    LogP between -5.0 and +5.0
+    H-bond donor count between 0 and 5
+    H-bond acceptor count between 0 and 10
+    Formal charge between -2 and +2
+    Rotatable bond count between 0 and 8
+    Heavy atom count between 15 and 50
+    """
+    if not 200 < mw(row) < 500:
+        return False
+    elif not -5.0 < logp(row) < 5.0:
+        return False
+    elif not 0 < hbd(row) < 5:
+        return False
+    elif not 0 < hba(row) < 10:
+        return False
+    elif not 0 < rotatable_bond(row) < 8:
+        return False
+    elif not 15 < heavy_atom(row) < 50:
+        return False
+    else:
+        return True
+
+
+def ghose(row):
+    """
+    Ghose drug like filter:
+    Molecular weight between 160 and 480
+    LogP between -0.4 and +5.6
+    Atom count between 20 and 70
+    Molar refractivity between 40 and 130
+    """
+    if not 160 < mw(row) < 480:
+        return False
+    elif not -0.4 < logp(row) < 5.6:
+        return False
+    elif not 20 < atom(row) < 70:
+        return False
+    elif not 40 < mr(row) < 130:
+        return False
+    else:
+        return True
 
 
 SCORE_MAP = {
     'SAscore': sa_score,
-    'RAscore': None,  # https://github.com/reymond-group/RAscore
-    'SCScore': None,  # https://pubs.acs.org/doi/10.1021/acs.jcim.7b00622
-    'LogP': logp,  # https://www.rdkit.org/docs/source/rdkit.Chem.Crippen.html
-    'MW': mw,  # https://www.rdkit.org/docs/source/rdkit.Chem.Descriptors.html
-    'HBD': hbd,  # https://www.rdkit.org/docs/source/rdkit.Chem.Lipinski.html
-    'HBA': hba,  # https://www.rdkit.org/docs/source/rdkit.Chem.Lipinski.html
-    'TopoPSA': None,  # http://mordred-descriptor.github.io/documentation/master/api/mordred.TopoPSA.html
+    'LogP': logp,
+    'Molecular weight': mw,
+    'Molar refractivity': mr,
+    'H-bond donor count': hbd,
+    'H-Bond acceptor count': hba,
+    'Rotatable bond count': rotatable_bond,
+    # 'TopoPSA': None,
 }
 
 FILTER_MAP = {
-    'PAINS filter': None,
-    "Lipinski's rule of five": None,  # https://gist.github.com/strets123/fdc4db6d450b66345f46
-    'ADMET filter': None,
-    'TCL filter': None
+    'REOS': reos,
+    "Lipinski's rule of 5": lipinski,
+    'Ghose': ghose,
+    # 'Rule of 3': rule_of_3,
+    # 'Veber': veber,
+    # 'PAINS': pains,
 }
 
 TASK_MAP = {
-    'Drug-target interaction': 'binary',
-    'Drug-target binding affinity': 'regression',
+    'Drug-target interaction': 'DTI',
+    'Drug-target binding affinity': 'DTA',
 }
 
 PRESET_MAP = {
@@ -231,22 +308,21 @@ PRESET_MAP = {
 
 TARGET_FAMILY_MAP = {
     'General': 'general',
-    'Kinase': 'kinases',
-    'Non-kinase enzyme': 'non-kinase_enzymes',
-    'Membrane receptor': 'membrane_receptors',
-    'Nuclear receptor': 'nuclear_receptors',
-    'Ion channel': 'ion_channels',
-    'Other protein targets': 'other_protein_targets',
+    'Kinase': 'kinase',
+    'Non-kinase enzyme': 'enzyme',
+    'Membrane receptor': 'membrane',
+    'Nuclear receptor': 'nuclear',
+    'Ion channel': 'ion',
+    'Other protein targets': 'others',
 }
 
 TARGET_LIBRARY_MAP = {
-    # 'STITCH': 'stitch.csv',
-    'ChEMBL33 (all species)': 'ChEMBL33_all_spe_single_prot_info.csv',
-    'DrugBank (Human)': 'drugbank_human_py_annot.csv',
+    'ChEMBL33 (all species)': 'ChEMBL33_all_spe_single_prot_info.csv.csv',
+    'STITCH': 'stitch.csv',
+    'Drug Repurposing Hub': 'drug_repurposing_hub.csv',
 }
 
 DRUG_LIBRARY_MAP = {
-    # 'ChEMBL': 'chembl.csv',
     'DrugBank (Human)': 'drugbank_human_py_annot.csv',
 }
 
@@ -257,21 +333,28 @@ MODE_LIST = [
 ]
 
 COLUMN_ALIASES = {
-    'X1': 'Drug SMILES',
+    'X1': 'Compound SMILES',
     'X2': 'Target FASTA',
-    'ID1': 'Drug ID',
+    'ID1': 'Compound ID',
     'ID2': 'Target ID',
 }
 
-URL = "https://ciddr-lab.ac.cn/deepseqreen"
-
 
 def validate_columns(df, mandatory_cols):
     missing_cols = [col for col in mandatory_cols if col not in df.columns]
     if missing_cols:
         error_message = (f"The following mandatory columns are missing "
                          f"in the uploaded dataset: {str(['X1', 'X2']).strip('[]')}.")
-        raise gr.Error(error_message)
+        raise ValueError(error_message)
+    else:
+        return
+
+
+def process_target_fasta(sequence):
+    lines = sequence.strip().split("\n")
+    if lines[0].startswith(">"):
+        lines = lines[1:]
+    return ''.join(lines).split(">")[0]
 
 
 def send_email(receiver, msg):
@@ -280,40 +363,48 @@ def send_email(receiver, msg):
 
 def submit_predict(predict_filepath, task, preset, target_family, flag, progress=gr.Progress(track_tqdm=True)):
     if flag:
-        job_id = flag
-        global COLUMN_ALIASES
-        task = TASK_MAP[task]
-        preset = PRESET_MAP[preset]
-        target_family = TARGET_FAMILY_MAP[target_family]
-        # email_hash = hashlib.sha256(email.encode()).hexdigest()
-        COLUMN_ALIASES = COLUMN_ALIASES | {
-            'Y': 'Actual interaction' if task == 'binary' else 'Actual affinity',
-            'Y^': 'Predicted interaction' if task == 'binary' else 'Predicted affinity'
-        }
-
-        # target_family_list = [target_family]
-        # for family in target_family_list:
-
-        # try:
-        prediction_df = pd.DataFrame()
-        with hydra.initialize(version_base="1.3", config_path="configs", job_name="webserver_inference"):
-            cfg = hydra.compose(
-                config_name="webserver_inference",
-                overrides=[f"task={task}",
-                           f"preset={preset}",
-                           f"ckpt_path=resources/checkpoints/{preset}-{task}-{target_family}.ckpt",
-                           f"data.data_file='{str(predict_filepath)}'"])
-
-            predictions, _ = predict(cfg)
-            predictions = [pd.DataFrame(prediction) for prediction in predictions]
-            prediction_df = pd.concat([prediction_df, pd.concat(predictions, ignore_index=True)])
-
-            predictions_file = f'{job_id}_predictions.csv'
-            prediction_df.to_csv(predictions_file)
-
-            return [gr.Markdown(visible=True),
-                    gr.File(predictions_file),
-                    gr.State(False)]
+        try:
+            job_id = flag
+            global COLUMN_ALIASES
+            task = TASK_MAP[task]
+            preset = PRESET_MAP[preset]
+            target_family = TARGET_FAMILY_MAP[target_family]
+            # email_hash = hashlib.sha256(email.encode()).hexdigest()
+            COLUMN_ALIASES = COLUMN_ALIASES | {
+                'Y': 'Actual interaction' if task == 'binary' else 'Actual affinity',
+                'Y^': 'Predicted interaction' if task == 'binary' else 'Predicted affinity'
+            }
+
+            # target_family_list = [target_family]
+            # for family in target_family_list:
+
+            # try:
+            prediction_df = pd.DataFrame()
+            with hydra.initialize(version_base="1.3", config_path="configs", job_name="webserver_inference"):
+                cfg = hydra.compose(
+                    config_name="webserver_inference",
+                    overrides=[f"task={task}",
+                               f"preset={preset}",
+                               f"ckpt_path=resources/checkpoints/{preset}-{task}-{target_family}.ckpt",
+                               f"data.data_file='{str(predict_filepath)}'"])
+
+                predictions, _ = predict(cfg)
+                predictions = [pd.DataFrame(prediction) for prediction in predictions]
+                prediction_df = pd.concat([prediction_df, pd.concat(predictions, ignore_index=True)])
+
+                predictions_file = f'temp/{job_id}_predictions.csv'
+                prediction_df.to_csv(predictions_file, index=False)
+
+                return [predictions_file,
+                        False]
+        except Exception as e:
+            gr.Warning(f"Prediction job failed due to error: {str(e)}")
+            return [None,
+                    False]
+
+    else:
+        return [None,
+                False]
         #
         # except Exception as e:
         #     raise gr.Error(str(e))
@@ -405,18 +496,18 @@ def update_df(file, progress=gr.Progress(track_tqdm=True)):
         elif 'Y' in DF_FOR_REPORT.columns:
             value = 'Y'
 
-        if value:
-            if DF_FOR_REPORT['X1'].nunique() > 1 >= DF_FOR_REPORT['X2'].nunique():
-                pie_chart = create_pie_chart(DF_FOR_REPORT, category='Scaffold SMILES', value=value, top_k=100)
-            elif DF_FOR_REPORT['X2'].nunique() > 1 >= DF_FOR_REPORT['X1'].nunique():
-                pie_chart = create_pie_chart(DF_FOR_REPORT, category='Target family', value=value, top_k=100)
+        # if value:
+        #     if DF_FOR_REPORT['X1'].nunique() > 1 >= DF_FOR_REPORT['X2'].nunique():
+        #         pie_chart = create_pie_chart(DF_FOR_REPORT, category='Scaffold SMILES', value=value, top_k=100)
+        #     elif DF_FOR_REPORT['X2'].nunique() > 1 >= DF_FOR_REPORT['X1'].nunique():
+        #         pie_chart = create_pie_chart(DF_FOR_REPORT, category='Target family', value=value, top_k=100)
 
         return create_html_report(DF_FOR_REPORT), pie_chart
     else:
         return gr.HTML(''), gr.Plot()
 
 
-def create_html_report(df, progress=gr.Progress(track_tqdm=True)):
+def create_html_report(df, file=None, progress=gr.Progress(track_tqdm=True)):
     cols_left = ['ID2', 'Y', 'Y^', 'ID1', 'Compound', 'Scaffold', 'Scaffold SMILES', ]
     cols_right = ['X1', 'X2']
     cols_left = [col for col in cols_left if col in df.columns]
@@ -435,8 +526,12 @@ def create_html_report(df, progress=gr.Progress(track_tqdm=True)):
     # Return the DataFrame as HTML
     PandasTools.RenderImagesInAllDataFrames(images=True)
 
-    html = df.to_html()
-    return f'<div style="overflow:auto; height: 500px;">{html}</div>'
+    if not file:
+        html = df.to_html()
+        return f'<div style="overflow:auto; height: 500px;">{html}</div>'
+    else:
+        html = df.to_html(file)
+        return html
     # return gr.HTML(pn.widgets.Tabulator(df).embed())
 
 
@@ -495,45 +590,46 @@ def submit_report(score_list, filter_list, progress=gr.Progress(track_tqdm=True)
     df = DF_FOR_REPORT.copy()
     try:
         for filter_name in filter_list:
-            pass
+            df[filter_name] = df.swifter.progress_bar(desc=f"Calculating {filter_name}").apply(
+                FILTER_MAP[filter_name], axis=1)
 
         for score_name in score_list:
             df[score_name] = df.swifter.progress_bar(desc=f"Calculating {score_name}").apply(
                 SCORE_MAP[score_name], axis=1)
 
-        pie_chart = None
-        value = None
-        if 'Y^' in df.columns:
-            value = 'Y^'
-        elif 'Y' in df.columns:
-            value = 'Y'
-
-        if value:
-            if df['X1'].nunique() > 1 >= df['X2'].nunique():
-                pie_chart = create_pie_chart(df, category='Scaffold SMILES', value=value, top_k=100)
-            elif df['X2'].nunique() > 1 >= df['X1'].nunique():
-                pie_chart = create_pie_chart(df, category='Target famiy', value=value, top_k=100)
+        # pie_chart = None
+        # value = None
+        # if 'Y^' in df.columns:
+        #     value = 'Y^'
+        # elif 'Y' in df.columns:
+        #     value = 'Y'
+        #
+        # if value:
+        #     if df['X1'].nunique() > 1 >= df['X2'].nunique():
+        #         pie_chart = create_pie_chart(df, category='Scaffold SMILES', value=value, top_k=100)
+        #     elif df['X2'].nunique() > 1 >= df['X1'].nunique():
+        #         pie_chart = create_pie_chart(df, category='Target family', value=value, top_k=100)
 
-        return create_html_report(df), pie_chart
+        return create_html_report(df), df  # pie_chart
 
     except Exception as e:
         raise gr.Error(str(e))
 
 
-def check_job_status(job_id):
-    job_lock = DATA_PATH / f"{job_id}.lock"
-    job_file = DATA_PATH / f"{job_id}.csv"
-    if job_lock.is_file():
-        return {gr.Markdown(f"Your job ({job_id}) is still running... "
-                            f"You may stay on this page or come back later to retrieve the results "
-                            f"Once you receive our email notification."),
-                None,
-                None
-                }
-    elif job_file.is_file():
-        return {gr.Markdown(f"Your job ({job_id}) is done! Redirecting you to generate reports..."),
-                gr.Tabs(selected=3),
-                gr.File(str(job_lock))}
+# def check_job_status(job_id):
+#     job_lock = DATA_PATH / f"{job_id}.lock"
+#     job_file = DATA_PATH / f"{job_id}.csv"
+#     if job_lock.is_file():
+#         return {gr.Markdown(f"Your job ({job_id}) is still running... "
+#                             f"You may stay on this page or come back later to retrieve the results "
+#                             f"Once you receive our email notification."),
+#                 None,
+#                 None
+#                 }
+#     elif job_file.is_file():
+#         return {gr.Markdown(f"Your job ({job_id}) is done! Redirecting you to generate reports..."),
+#                 gr.Tabs(selected=3),
+#                 gr.File(str(job_lock))}
 
 
 def wrap_text(text, line_length=60):
@@ -602,60 +698,70 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
             with gr.Blocks() as screen_block:
                 with gr.Column() as screen_page:
                     with gr.Row():
-                        with gr.Column(scale=4, variant='panel'):
-                            target_fasta = gr.Code(label='Target sequence FASTA',
-                                                   interactive=True, lines=5)
-                            example_target = gr.Button(value='Example: Human MAPK14', elem_id='example')
+                        with gr.Column():
                             with gr.Row():
-                                with gr.Column(scale=1):
-                                    with gr.Group():
-                                        with gr.Row():
-                                            target_input_type = gr.Radio(label='Target input type',
-                                                                         choices=['Sequence', 'UniProt ID', 'Gene symbol'],
-                                                                         value='Sequence')
-                                            target_query = gr.Textbox(label='UniProt ID/Accession',
-                                                                      visible=False, interactive=True)
-                                        target_upload_btn = gr.UploadButton(label='Upload a FASTA file',
-                                                                            type='binary',
-                                                                            visible=True, variant='primary',
-                                                                            size='lg', elem_classes="upload_button")
-                                        target_query_btn = gr.Button(value='Query the sequence', variant='primary',
-                                                                     elem_classes='upload_button', visible=False)
-
-                                with gr.Column(scale=1):
-                                    with gr.Row():
-                                        with gr.Group():
-                                            drug_screen_target_family = gr.Dropdown(
-                                                choices=list(TARGET_FAMILY_MAP.keys()),
-                                                value='General',
-                                                label='Target family', interactive=True)
-                                            # with gr.Column(scale=1, min_width=24):
-                                            auto_detect_btn = gr.Button(value='Auto-detect', variant='primary')
-                                        HelpTip(
-                                            "Target amino acid sequence in the FASTA format. Alternatively, you may use a "
-                                            "UniProt ID/accession to query UniProt database for the sequence of your target"
-                                            "of interest. You can also search on databases like UniProt, RCSB PDB, "
-                                            "NCBI Protein for the FASTA string representing your target of interest. If "
-                                            "the input FASTA contains multiple entities, only the first one will be used."
-                                        )
-
-                        with gr.Column(variant='panel'):
-                            with gr.Group():
-                                drug_library = gr.Radio(label='Drug library',
-                                                        choices=list(DRUG_LIBRARY_MAP.keys()) + ['Upload a drug library'])
-                                drug_library_upload = gr.File(label='Custom drug library file', visible=True)
-
-                    with gr.Row(variant='panel'):
-                        drug_screen_task = gr.Radio(list(TASK_MAP.keys()), label='Task',
-                                                    value='Drug-target interaction')
-
-                        with gr.Column(scale=2):
-                            with gr.Group():
-                                drug_screen_preset = gr.Dropdown(list(PRESET_MAP.keys()), label='Model')
-                                recommend_btn = gr.Button(value='Recommend a model', variant='primary')
+                                target_input_type = gr.Dropdown(
+                                    label='Target Input Type',
+                                    choices=['Sequence', 'UniProt ID', 'Gene symbol'],
+                                    info='Enter (paste) a FASTA string below manually or upload a FASTA file.',
+                                    value='Sequence',
+                                    scale=3, interactive=True
+                                )
+                                target_id = gr.Textbox(show_label=False, visible=False,
+                                                       interactive=True, scale=4,
+                                                       info='Query a sequence on UniProt  with a UniProt ID.')
+                                target_gene = gr.Textbox(
+                                    show_label=False, visible=False,
+                                    interactive=True, scale=4,
+                                    info='Query a sequence on UniProt with a gene symbol.')
+                                target_organism = gr.Textbox(
+                                    info='Organism common name or scientific name (default: human).',
+                                    placeholder='Human', show_label=False,
+                                    visible=False, interactive=True, scale=4, )
+                            HelpTip(
+                                "Target amino acid sequence in the FASTA format. Alternatively, you may use a "
+                                "UniProt ID/accession to query UniProt database for the sequence of your "
+                                "target of interest. If the input FASTA contains multiple entities, "
+                                "only the first one will be used."
+                            )
+                        with gr.Column():
+                            drug_screen_target_family = gr.Dropdown(
+                                choices=list(TARGET_FAMILY_MAP.keys()),
+                                value='General',
+                                label='Select Input Protein Family (Optional)', interactive=True)
+                            # with gr.Column(scale=1, min_width=24):
+                            HelpTip(
+                                "Identify the protein family by conducting sequence alignment. "
+                                "You may select General if you find the alignment score unsatisfactory."
+                            )
+                    with gr.Row():
+                        with gr.Column():
+                            target_upload_btn = gr.UploadButton(label='Upload a FASTA file', type='binary',
+                                                                visible=True, variant='primary',
+                                                                size='lg')
+                            target_query_btn = gr.Button(value='Query the sequence', variant='primary',
+                                                         visible=False)
+                        target_family_detect_btn = gr.Button(value='Auto-detect', variant='primary')
+
+                    target_fasta = gr.Code(label='Input or Display FASTA', interactive=True, lines=5)
+                    example_fasta = gr.Button(value='Example: Human MAPK14', elem_id='example')
+
+                    with gr.Row():
+                        with gr.Column():
+                            drug_library = gr.Dropdown(label='Select a Compound Library',
+                                                       choices=list(DRUG_LIBRARY_MAP.keys()))
+                            drug_library_upload_btn = gr.UploadButton(
+                                label='Upload a custom library', variant='primary')
+                            drug_library_upload = gr.File(label='Custom drug library file', visible=False)
+                            drug_screen_task = gr.Dropdown(list(TASK_MAP.keys()), label='Select a Prediction Task',
+                                                           value='Drug-target interaction')
+                        with gr.Column():
+                            drug_screen_preset = gr.Dropdown(list(PRESET_MAP.keys()), label='Select a Preset Model')
+                            screen_preset_recommend_btn = gr.Button(value='Recommend a model', variant='primary')
                             HelpTip("We recommend the appropriate model for your use case based on model performance "
-                                    "in drug-target interaction or binding affinity prediction "
-                                    "benchmarked on different target families and real-world data scenarios.")
+                                    "in drug-target interaction or binding affinity prediction. "
+                                    "The models were benchmarked on different target families "
+                                    "and real-world data scenarios.")
 
                     # drug_screen_email = gr.Textbox(
                     #     label='Email (optional)',
@@ -663,8 +769,8 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
                     # )
 
                     with gr.Row(visible=True):
-                        drug_screen_clr_btn = gr.ClearButton()
-                        drug_screen_btn = gr.Button(value='SCREEN', variant='primary')
+                        drug_screen_clr_btn = gr.ClearButton(size='lg')
+                        drug_screen_btn = gr.Button(value='SCREEN', variant='primary', size='lg')
                     # TODO Modify the pd df directly with df['X2'] = target
 
             screen_data_for_predict = gr.File(visible=False, file_count="single", type='filepath')
@@ -685,37 +791,45 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
             with gr.Blocks() as identify_block:
                 with gr.Column() as identify_page:
                     with gr.Row():
-                        with gr.Group():
-                            drug_type = gr.Dropdown(label='Drug input type',
-                                                    choices=['SMILES', 'SDF'],
-                                                    value='SMILES',
-                                                    scale=1,
-                                                    interactive=True)
-                            drug_upload = gr.UploadButton(label='⤒ Upload a file')
-                        drug_smiles = gr.Code(label='Drug canonical SMILES', interactive=True, scale=5, lines=5)
-                        with gr.Column(scale=1):
+                        with gr.Column():
+                            compound_type = gr.Dropdown(
+                                label='Compound Input Type',
+                                choices=['SMILES', 'SDF'],
+                                info='Enter (paste) an SMILES string or upload an SMI file.',
+                                value='SMILES',
+                                interactive=True)
+                            compound_upload_btn = gr.UploadButton(label='Upload', variant='primary', type='binary')
                             HelpTip(
-                                """Drug molecule in the SMILES format. You may search on databases like 
-                                NCBI PubChem, ChEMBL, and DrugBank for the SMILES strings 
-                                representing your drugs of interest.
+                                """Compound molecule in the SMILES format. You may input the SMILES string directly, 
+                                upload an SMI file, or upload an SDF file to convert to SMILES. Alternatively, 
+                                you may search on databases like NCBI PubChem, ChEMBL, and DrugBank for the SMILES 
+                                representing your drug of interest.
                                 """
                             )
-                            example_drug = gr.Button(value='Example: Aspirin', elem_id='example')
+                        with gr.Column():
+                            target_identify_target_family = gr.Dropdown(choices=['General'], value='General',
+                                                                        label='Target Protein Family')
 
-                    with gr.Column(variant='panel'):
-                        with gr.Group():
-                            target_library = gr.Radio(label='Target library',
-                                                      choices=list(TARGET_LIBRARY_MAP.keys()) + ['Upload a target library'])
-                            target_library_upload = gr.File(label='Custom target library file', visible=True)
+                    compound_smiles = gr.Code(label='Input or Display Compound SMILES', interactive=True, lines=5)
+                    example_drug = gr.Button(value='Example: Aspirin', elem_id='example')
 
-                    with gr.Row(visible=True):
-                        target_identify_task = gr.Dropdown(list(TASK_MAP.keys()), label='Task')
-                        HelpTip("Choose a preset model for making the predictions.")
-                        target_identify_preset = gr.Dropdown(list(PRESET_MAP.keys()), label='Preset')
-                        HelpTip("Choose the protein family of your target.")
-                        target_identify_target_family = gr.Dropdown(choices=['General'],
-                                                                    value='General',
-                                                                    label='Target family')
+                    with gr.Row():
+                        with gr.Column():
+                            target_library = gr.Dropdown(label='Select a Target Library',
+                                                         choices=list(TARGET_LIBRARY_MAP.keys()))
+                            target_library_upload_btn = gr.UploadButton(
+                                label='Upload a custom library', variant='primary')
+                            target_library_upload = gr.File(label='Custom target library file', visible=False)
+                            target_identify_task = gr.Dropdown(list(TASK_MAP.keys()), label='Select a Prediction Task',
+                                                               value='Drug-target interaction')
+
+                        with gr.Column():
+                            target_identify_preset = gr.Dropdown(list(PRESET_MAP.keys()), label='Preset')
+                            identify_preset_recommend_btn = gr.Button(value='Recommend a model', variant='primary')
+                            HelpTip("We recommend the appropriate model for your use case based on model performance "
+                                    "in drug-target interaction or binding affinity prediction. "
+                                    "The models were benchmarked on different target families "
+                                    "and real-world data scenarios.")
 
                     # with gr.Row():
                     #     target_identify_email = gr.Textbox(
@@ -724,8 +838,8 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
                     #     )
 
                     with gr.Row(visible=True):
-                        target_identify_clr_btn = gr.ClearButton()
-                        target_identify_btn = gr.Button(value='IDENTIFY', variant='primary')
+                        target_identify_clr_btn = gr.ClearButton(size='lg')
+                        target_identify_btn = gr.Button(value='IDENTIFY', variant='primary', size='lg')
 
             identify_data_for_predict = gr.File(visible=False, file_count="single", type='filepath')
             identify_waiting = gr.Markdown(f"Your job is running... It might take a few minutes."
@@ -763,8 +877,8 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
                     #     )
 
                     with gr.Row(visible=True):
-                        pair_infer_clr_btn = gr.ClearButton()
-                        pair_infer_btn = gr.Button(value='INFER', variant='primary')
+                        pair_infer_clr_btn = gr.ClearButton(size='lg')
+                        pair_infer_btn = gr.Button(value='INFER', variant='primary', size='lg')
 
             infer_waiting = gr.Markdown(f"Your job is running... It might take a few minutes."
                                         f"When it's done, you will be redirected to the report page. "
@@ -783,7 +897,7 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
                 ''')
                 with gr.Row():
                     file_for_report = gr.File(interactive=True, type='filepath')
-                    # df_original = gr.Dataframe(type="pandas", interactive=False, visible=False)
+                    df_raw = gr.Dataframe(type="pandas", interactive=False, visible=False)
                     scores = gr.CheckboxGroup(list(SCORE_MAP.keys()), label='Scores')
                     filters = gr.CheckboxGroup(list(FILTER_MAP.keys()), label='Filters')
 
@@ -797,68 +911,105 @@ with (gr.Blocks(theme=theme, title='DeepScreen', css=CSS) as demo):
                     ranking_pie_chart = gr.Plot(visible=False)
 
                 with gr.Row():
-                    csv_download_btn = gr.Button('Download report (HTML)', variant='primary')
-                    html_download_btn = gr.Button('Download raw data (CSV)', variant='primary')
+                    with gr.Column():
+                        csv_generate = gr.Button(value='Generate raw data (CSV)')
+                        csv_download_file = gr.File(label='Download raw data (CSV)', visible=False)
+                    with gr.Column():
+                        html_generate = gr.Button(value='Generate report (HTML)')
+                        html_download_file = gr.File(label='Download report (HTML)', visible=False)
 
 
     def target_input_type_select(input_type):
         match input_type:
             case 'UniProt ID':
-                return [gr.UploadButton(visible=False),
-                        gr.Textbox(visible=True, label='UniProt ID/accession', info=None, value=''),
-                        gr.Button(visible=True)]
+                return [gr.Dropdown(info=''),
+                        gr.UploadButton(visible=False),
+                        gr.Textbox(visible=True, value=''),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Button(visible=True),
+                        gr.Code(interactive=False, value='')]
             case 'Gene symbol':
-                return [gr.UploadButton(visible=False),
-                        gr.Textbox(visible=True, label='Gene symbol/name', info='Organism: human', value=''),
-                        gr.Button(visible=True)]
+                return [gr.Dropdown(info=''),
+                        gr.UploadButton(visible=False),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Textbox(visible=True, value=''),
+                        gr.Textbox(visible=True, value=''),
+                        gr.Button(visible=True),
+                        gr.Code(interactive=False, value='')]
             case 'Sequence':
-                return [gr.UploadButton(visible=True),
-                        gr.Textbox(visible=False), gr.Button(visible=False)]
-
-
-    target_input_type.select(fn=target_input_type_select,
-                             inputs=target_input_type, outputs=[target_upload_btn, target_query, target_query_btn],
-                             show_progress=False)
+                return [gr.Dropdown(info='Enter (paste) a FASTA string below manually or upload a FASTA file.'),
+                        gr.UploadButton(visible=True),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Textbox(visible=False, value=''),
+                        gr.Button(visible=False),
+                        gr.Code(interactive=True, value='')]
+
+
+    target_input_type.select(
+        fn=target_input_type_select,
+        inputs=target_input_type,
+        outputs=[
+            target_input_type, target_upload_btn, target_id, target_gene, target_organism, target_query_btn
+        ],
+        show_progress=False
+    )
 
 
-    def uniprot_query(query, input_type):
+    def uniprot_query(input_type, uid, gene, organism='Human'):
         fasta_seq = ''
-        query = query.strip()
 
         match input_type:
             case 'UniProt ID':
-                query = f"{query.strip()}.fasta"
+                query = f"{uid.strip()}.fasta"
             case 'Gene symbol':
-                query = f'search?query=organism_id:9606+AND+gene:{query}&format=fasta'
+                query = f'search?query=organism_name:{organism.strip()}+AND+gene:{gene.strip()}&format=fasta'
 
         try:
             fasta = SESSION.get(UNIPROT_ENDPOINT.format(query=query))
             fasta.raise_for_status()
             fasta_seq = fasta.text
         except Exception as e:
-            raise gr.Warning(f"Failed to query FASTA from UniProt due to {str(e)}")
+            raise gr.Warning(f"Failed to query FASTA from UniProt database due to {str(e)}")
         finally:
             return fasta_seq
 
 
     target_upload_btn.upload(fn=lambda x: x.decode(), inputs=target_upload_btn, outputs=target_fasta)
-    target_query_btn.click(uniprot_query, inputs=[target_query, target_input_type], outputs=target_fasta)
+    target_query_btn.click(uniprot_query,
+                           inputs=[target_input_type, target_id, target_gene, target_organism],
+                           outputs=target_fasta)
+
+
+    def target_family_detect(fasta, progress=gr.Progress(track_tqdm=True)):
+        aligner = PairwiseAligner(scoring='blastp', mode='local')
+        alignment_df = pd.read_csv('data/target_libraries/ChEMBL33_all_spe_single_prot_info.csv')
+
+        def align_score(query):
+            return aligner.align(process_target_fasta(fasta), query).score
+
+        alignment_df['score'] = alignment_df['X2'].swifter.progress_bar(
+            desc="Detecting protein family of the target...").apply(align_score)
+        row = alignment_df.loc[alignment_df['score'].idxmax()]
+        return gr.Dropdown(value=row['protein_family'].capitalize(),
+                           info=f"Reason: Best BLASTP score ({row['score']}) with {row['ID2']} from family {row['protein_family']}")
+
+
+    target_family_detect_btn.click(fn=target_family_detect, inputs=target_fasta, outputs=drug_screen_target_family)
 
     target_fasta.focus(fn=wrap_text, inputs=target_fasta, outputs=target_fasta, show_progress=False)
     target_fasta.blur(fn=wrap_text, inputs=target_fasta, outputs=target_fasta, show_progress=False)
-    drug_smiles.focus(fn=wrap_text, inputs=drug_smiles, outputs=drug_smiles, show_progress=False)
-    drug_smiles.blur(fn=wrap_text, inputs=drug_smiles, outputs=drug_smiles, show_progress=False)
+
+    drug_library_upload_btn.upload(fn=lambda x: [
+        x.name, gr.Dropdown(value=Path(x.name).name, choices=list(DRUG_LIBRARY_MAP.keys()) + [Path(x.name).name])
+    ], inputs=drug_library_upload_btn, outputs=[drug_library_upload, drug_library])
 
 
     def example_fill(input_type):
-        match input_type:
-            case 'UniProt ID':
-                query = 'Q16539'
-            case 'Gene symbol':
-                query = 'MAPK14'
-            case _:
-                query = ''
-        return {target_query: query,
+        return {target_id: 'Q16539',
+                target_gene: 'MAPK14',
+                target_organism: 'Human',
                 target_fasta: """
 >sp|Q16539|MK14_HUMAN Mitogen-activated protein kinase 14 OS=Homo sapiens OX=9606 GN=MAPK14 PE=1 SV=3
 MSQERPTFYRQELNKTIWEVPERYQNLSPVGSGAYGSVCAAFDTKTGLRVAVKKLSRPFQ
@@ -870,101 +1021,218 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
 """}
 
 
-    example_target.click(fn=example_fill, inputs=target_input_type,
-                         outputs=[target_query, target_fasta], show_progress=False)
-    example_drug.click(fn=lambda: 'CC(=O)Oc1ccccc1C(=O)O', outputs=drug_smiles, show_progress=False)
+    example_fasta.click(fn=example_fill, inputs=target_input_type,
+                        outputs=[target_id, target_gene, target_organism, target_fasta], show_progress=False)
 
 
-    def drug_screen_validate(fasta, library, library_upload, state):
-        if not state:
-            def process_target_fasta(sequence):
-                lines = sequence.strip().split("\n")
-                if lines[0].startswith(">"):
-                    lines = lines[1:]
-                return ''.join(lines).split(">")[0]
-
-            fasta = process_target_fasta(fasta)
-            err = validate_seq_str(fasta, FASTA_PAT)
-            if err:
-                raise gr.Error(f'Found error(s) in your target fasta input: {err}')
-
-            if library in DRUG_LIBRARY_MAP.keys():
-                screen_df = pd.read_csv(Path('data/drug_libraries', DRUG_LIBRARY_MAP[library]))
-            else:
-                screen_df = pd.read_csv(library_upload)
-                validate_columns(screen_df, ['X1'])
-
-            screen_df['X2'] = fasta
-
-            job_id = uuid4()
-            temp_file = Path(f'{job_id}_temp.csv').resolve()
-            screen_df.to_csv(temp_file)
-            if temp_file.is_file():
-                return {screen_data_for_predict: str(temp_file),
-                        screen_flag: job_id,
-                        run_state: job_id}
+    def screen_recommend_model(fasta, family, task):
+        task = TASK_MAP[task]
+        if task == 'DTI':
+            train = pd.read_csv('data/benchmarks/all_families_reduced_dti_train.csv')
+            score = 'AUROC'
+        elif task == 'DTA':
+            train = pd.read_csv('data/benchmarks/all_families_reduced_dta_train.csv')
+            score = 'CI'
+
+        if fasta not in train['X2']:
+            scenario = "Unseen target"
+        else:
+            scenario = "Seen target"
+        benchmark_df = pd.read_csv('data/benchmarks/compound_screen.csv')
+
+        if task == 'General':
+            filtered_df = benchmark_df[(benchmark_df[f'Task'] == task)
+                                       & (benchmark_df['Target.family'] == 'All families reduced')
+                                       & (benchmark_df['Scenario'] == 'Random split')
+                                       & (benchmark_df['all'] == True)]
+        else:
+            filtered_df = benchmark_df[(benchmark_df['Task'] == task)
+                                       & (benchmark_df['Target.family'] == family)
+                                       & (benchmark_df['Scenario'] == scenario)
+                                       & (benchmark_df['all'] == False)]
+        row = filtered_df.loc[filtered_df[score].idxmax()]
+
+        return gr.Dropdown(value=row['preset'],
+                           info=f"Reason: {scenario} in the training dataset; we recommend the model "
+                                f"with the best {score} ({float(row[score]):.3f}) "
+                                f"in the {scenario.lower()} scenario on {family.lower()} family.")
+
+
+    screen_preset_recommend_btn.click(fn=screen_recommend_model,
+                                      inputs=[target_fasta, drug_screen_target_family, drug_screen_task],
+                                      outputs=drug_screen_preset)
+
+
+    # compound_smiles.focus(fn=wrap_text, inputs=compound_smiles, outputs=compound_smiles, show_progress=False)
+    # compound_smiles.blur(fn=wrap_text, inputs=compound_smiles, outputs=compound_smiles, show_progress=False)
+
+    def compound_input_type_select(input_type):
+        match input_type:
+            case 'SMILES':
+                return gr.Dropdown(info='Input an SMILES string or upload an SMI file')
+            case 'SDF':
+                return gr.Dropdown(info='Convert the first molecule in an SDF file to SMILES')
+
+
+    compound_type.select(fn=compound_input_type_select,
+                         inputs=compound_type, outputs=compound_type, show_progress=False)
+
+
+    def compound_upload_process(input_type, input_upload):
+        match input_type:
+            case 'SMILES':
+                return input_upload.decode()
+            case 'SDF':
+                suppl = Chem.ForwardSDMolSupplier(io.BytesIO(input_upload))
+                return Chem.MolToSmiles(next(suppl))
+
+
+    compound_upload_btn.upload(fn=compound_upload_process,
+                               inputs=[compound_type, compound_upload_btn],
+                               outputs=compound_smiles)
 
+    example_drug.click(fn=lambda: 'CC(=O)Oc1ccccc1C(=O)O', outputs=compound_smiles, show_progress=False)
+
+    target_library_upload_btn.upload(fn=lambda x: [
+        x.name, gr.Dropdown(value=Path(x.name).name, choices=list(TARGET_LIBRARY_MAP.keys()) + [Path(x.name).name])
+    ], inputs=target_library_upload_btn, outputs=[target_library_upload, target_library])
+
+
+    def identify_recommend_model(smiles, task):
+        if task == 'Drug-target interaction':
+            train = pd.read_csv('data/benchmarks/all_families_reduced_dti_train.csv')
+            score = 'AUROC'
+        elif task == 'Drug-target binding affinity':
+            train = pd.read_csv('data/benchmarks/all_families_reduced_dta_train.csv')
+            score = 'CI'
+        task = TASK_MAP[task]
+        if smiles not in train['X1']:
+            scenario = "Unseen drug"
+        else:
+            scenario = "Seen drug"
+        benchmark_df = pd.read_csv('data/benchmarks/target_identification.csv')
+
+        filtered_df = benchmark_df[(benchmark_df['Task'] == task)
+                                   & (benchmark_df['Scenario'] == scenario)]
+        row = filtered_df.loc[filtered_df[score].idxmax()]
+
+        return gr.Dropdown(value=row['preset'],
+                           info=f"Reason: {scenario} in the training dataset; choosing the model"
+                                f"with the best {score} ({row[score]}) "
+                                f"in the {scenario.lower()} scenario.")
+
+
+    identify_preset_recommend_btn.click(fn=identify_recommend_model,
+                                        inputs=[compound_smiles, target_identify_task],
+                                        outputs=drug_screen_preset)
+
+
+    def drug_screen_validate(fasta, library, library_upload, state, progress=gr.Progress(track_tqdm=True)):
+        if not state:
+            try:
+                fasta = process_target_fasta(fasta)
+                err = validate_seq_str(fasta, FASTA_PAT)
+                if err:
+                    raise ValueError(f'Found error(s) in your target fasta input: {err}')
+                if library in DRUG_LIBRARY_MAP.keys():
+                    screen_df = pd.read_csv(Path('data/drug_libraries', DRUG_LIBRARY_MAP[library]))
+                else:
+                    screen_df = pd.read_csv(library_upload)
+                    validate_columns(screen_df, ['X1'])
+
+                screen_df['X2'] = fasta
+
+                job_id = uuid4()
+                temp_file = Path(f'temp/{job_id}_input.csv').resolve()
+                screen_df.to_csv(temp_file, index=False)
+                if temp_file.is_file():
+                    return {screen_data_for_predict: str(temp_file),
+                            screen_flag: job_id,
+                            run_state: job_id}
+                else:
+                    raise SystemError('Failed to create temporary files. Please try again later.')
+            except Exception as e:
+                gr.Warning(f'Failed to submit the job due to error: {str(e)}')
+                return {screen_flag: False,
+                        run_state: False}
         else:
             gr.Warning('You have another prediction job '
                        '(drug hit screening, target protein identification, or interation pair inference) '
                        'running in the session right now. '
                        'Please submit another job when your current job has finished.')
-            return {screen_flag: False}
+            return {screen_flag: False,
+                    run_state: state}
 
-    def target_identify_validate(smiles, library, library_upload, state):
-        if not state:
-            err = validate_seq_str(smiles, SMILES_PAT)
-            if err:
-                raise gr.Error(f'Found error(s) in your compound SMILES input: {err}')
-
-            if library in TARGET_LIBRARY_MAP.keys():
-                identify_df = pd.read_csv(TARGET_LIBRARY_MAP['target_library'])
-            else:
-                identify_df = pd.read_csv(library_upload)
-                validate_columns(identify_df, ['X2'])
-
-            identify_df['X1'] = smiles
-
-            job_id = uuid4()
-            temp_file = Path(f'{job_id}_temp.csv').resolve()
-            identify_df.to_csv(temp_file)
-            if temp_file.is_file():
-                return {identify_data_for_predict: str(temp_file),
-                        identify_flag: gr.State(job_id),
-                        run_state: gr.State(job_id)}
 
+    def target_identify_validate(smiles, library, library_upload, state, progress=gr.Progress(track_tqdm=True)):
+        if not state:
+            try:
+                smiles = smiles.strip()
+                err = validate_seq_str(smiles, SMILES_PAT)
+                if err:
+                    raise ValueError(f'Found error(s) in your target fasta input: {err}')
+                if library in TARGET_LIBRARY_MAP.keys():
+                    identify_df = pd.read_csv(TARGET_LIBRARY_MAP['target_library'])
+                else:
+                    identify_df = pd.read_csv(library_upload)
+                    validate_columns(identify_df, ['X2'])
+
+                identify_df['X1'] = smiles
+
+                job_id = uuid4()
+                temp_file = Path(f'temp/{job_id}_input.csv').resolve()
+                identify_df.to_csv(temp_file, index=False)
+                if temp_file.is_file():
+                    return {identify_data_for_predict: str(temp_file),
+                            identify_flag: job_id,
+                            run_state: job_id}
+                else:
+                    raise SystemError('Failed to create temporary files. Please try again later.')
+            except Exception as e:
+                gr.Warning(f'Failed to submit the job due to error: {str(e)}')
+                return {identify_flag: False,
+                        run_state: False}
         else:
             gr.Warning('You have another prediction job '
                        '(drug hit screening, target protein identification, or interation pair inference) '
                        'running in the session right now. '
                        'Please submit another job when your current job has finished.')
-            return {identify_flag: False}
+            return {identify_flag: False,
+                    run_state: state}
+            # return {identify_flag: False}
 
 
-    def pair_infer_validate(drug_target_pair_upload, run_state):
-        if not run_state:
-            df = pd.read_csv(drug_target_pair_upload)
-            validate_columns(df, ['X1', 'X2'])
-            df['X1_ERR'] = df['X1'].swifter.apply(
-                validate_seq_str, regex=SMILES_PAT)
-            df['X2_ERR'] = df['X2'].swifter.apply(
-                validate_seq_str, regex=FASTA_PAT)
-
-            if not df['X1_ERR'].isna().all():
-                raise gr.Error(f"Encountered invalid SMILES:\n{df[~df['X1_ERR'].isna()][['X1', 'X1_ERR']]}")
-            if not df['X2_ERR'].isna().all():
-                raise gr.Error(f"Encountered invalid FASTA:\n{df[~df['X2_ERR'].isna()][['X2', 'X2_ERR']]}")
-
-            job_id = uuid4()
-            return {infer_flag: gr.State(job_id),
-                    run_state: gr.State(job_id)}
+    def pair_infer_validate(drug_target_pair_upload, state, progress=gr.Progress(track_tqdm=True)):
+        if not state:
+            try:
+                df = pd.read_csv(drug_target_pair_upload)
+                validate_columns(df, ['X1', 'X2'])
+
+                df['X1_ERR'] = df['X1'].swifter.progress_bar(desc="Validating SMILES...").apply(
+                    validate_seq_str, regex=SMILES_PAT)
+                if not df['X1_ERR'].isna().all():
+                    raise ValueError(f"Encountered invalid SMILES:\n{df[~df['X1_ERR'].isna()][['X1', 'X1_ERR']]}")
+
+                df['X2_ERR'] = df['X2'].swifter.progress_bar(desc="Validating FASTA...").apply(
+                    validate_seq_str, regex=FASTA_PAT)
+                if not df['X2_ERR'].isna().all():
+                    raise ValueError(f"Encountered invalid FASTA:\n{df[~df['X2_ERR'].isna()][['X2', 'X2_ERR']]}")
+
+                job_id = uuid4()
+                return {infer_flag: job_id,
+                        run_state: job_id}
+            except Exception as e:
+                gr.Warning(f'Failed to submit the job due to error: {str(e)}')
+                return {infer_flag: False,
+                        run_state: False}
 
         else:
             gr.Warning('You have another prediction job '
                        '(drug hit screening, target protein identification, or interation pair inference) '
                        'running in the session right now. '
                        'Please submit another job when your current job has finished.')
-            return {infer_flag: False}
+            return {infer_flag: False,
+                    run_state: state}
 
 
     drug_screen_btn.click(
@@ -980,25 +1248,25 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
                 drug_screen_target_family, screen_flag],  # , drug_screen_email],
         outputs=[file_for_report, run_state]
     ).then(
-        fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False)],
-        outputs=[screen_page, screen_waiting]
+        fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False), gr.Tabs(selected=3)],
+        outputs=[screen_page, screen_waiting, tabs]
     )
 
     target_identify_btn.click(
         fn=target_identify_validate,
-        inputs=[drug_smiles, target_library, target_library_upload, run_state], # , drug_screen_email],
+        inputs=[compound_smiles, target_library, target_library_upload, run_state],  # , drug_screen_email],
         outputs=[identify_data_for_predict, identify_flag, run_state]
     ).then(
-        fn=lambda: [gr.Column(visible=False), gr.Markdown(visible=True)],
-        outputs=[identify_page, identify_waiting]
+        fn=lambda: [gr.Column(visible=False), gr.Markdown(visible=True), gr.Tabs(selected=3)],
+        outputs=[identify_page, identify_waiting, tabs]
     ).then(
         fn=submit_predict,
         inputs=[identify_data_for_predict, target_identify_task, target_identify_preset,
                 target_identify_target_family, identify_flag],  # , target_identify_email],
         outputs=[file_for_report, run_state]
     ).then(
-        fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False)],
-        outputs=[identify_page, identify_waiting]
+        fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False), gr.Tabs(selected=3)],
+        outputs=[identify_page, identify_waiting, tabs]
     )
 
     pair_infer_btn.click(
@@ -1020,9 +1288,36 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
 
     # TODO background job from these 3 pipelines to update file_for_report
 
-    file_for_report.change(fn=update_df, inputs=file_for_report, outputs=[html_report, ranking_pie_chart])
+    file_for_report.change(fn=update_df, inputs=file_for_report, outputs=[
+        html_report,
+        df_raw,
+        # ranking_pie_chart
+    ])
+    analyze_btn.click(fn=submit_report, inputs=[scores, filters], outputs=[
+        html_report,
+        df_raw,
+        # ranking_pie_chart
+    ])
+
+
+    def create_csv_raw_file(df, file_report):
+        from datetime import datetime
+        now = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
+        filename = f"reports/{Path(file_report.name).stem}_DeepSEQreen_report_{now}.csv"
+        df.to_csv(filename, index=False)
+        return gr.File(filename, visible=True)
+
+
+    def create_html_report_file(df, file_report):
+        from datetime import datetime
+        now = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
+        filename = f"reports/{Path(file_report.name).stem}_DeepSEQreen_report_{now}.csv"
+        create_html_report(df, filename)
+        return gr.File(filename, visible=True)
+
 
-    analyze_btn.click(fn=submit_report, inputs=[scores, filters], outputs=[html_report, ranking_pie_chart])
+    csv_generate.click(fn=create_csv_raw_file, inputs=[df_raw, file_for_report], outputs=csv_download_file)
+    html_generate.click(fn=create_html_report_file, inputs=[df_raw, file_for_report], outputs=html_download_file)
 
     # screen_waiting.change(fn=check_job_status, inputs=run_state, outputs=[pair_waiting, tabs, file_for_report],
     #                       every=5)
@@ -1043,9 +1338,5 @@ if __name__ == "__main__":
     # SCHEDULER.start()
 
     demo.launch(
-        # debug=True,
         show_api=False,
-        # favicon_path=,
-        # inline=False
-        debug=True
     )