Update app.py

app.py

@@ -20,16 +20,22 @@ from Bio.Align import PairwiseAligner
 import gradio as gr
 import hydra
 import pandas as pd
-import plotly.express as px
 import requests
-from bokeh.models import HTMLTemplateFormatter, StringFormatter
+from rdkit.Chem.PandasTools import _MolPlusFingerprint
 from rdkit.Chem.rdMolDescriptors import CalcNumRotatableBonds, CalcNumHeavyAtoms, CalcNumAtoms, CalcTPSA
 from requests.adapters import HTTPAdapter, Retry
 from rdkit import Chem
-from rdkit.Chem import RDConfig, Descriptors, Draw, Lipinski, Crippen, PandasTools, AllChem
+from rdkit.Chem import RDConfig, Descriptors, Draw, Lipinski, Crippen, PandasTools
 from rdkit.Chem.Scaffolds import MurckoScaffold
 import seaborn as sns
 
+from bokeh.models import Legend, NumberFormatter, BooleanFormatter, HTMLTemplateFormatter, LegendItem
+from bokeh.palettes import Category20c_20
+from bokeh.plotting import figure
+from bokeh.transform import cumsum
+from bokeh.resources import INLINE
+import panel as pn
+
 import swifter
 from tqdm.auto import tqdm
 
@@ -47,11 +53,11 @@ pd.set_option('display.float_format', '{:.3f}'.format)
 PandasTools.molRepresentation = 'svg'
 PandasTools.drawOptions = Draw.rdMolDraw2D.MolDrawOptions()
 PandasTools.drawOptions.clearBackground = False
-PandasTools.drawOptions.bondLineWidth = 1.5
+PandasTools.drawOptions.bondLineWidth = 1
 PandasTools.drawOptions.explicitMethyl = True
 PandasTools.drawOptions.singleColourWedgeBonds = True
 PandasTools.drawOptions.useCDKAtomPalette()
-PandasTools.molSize = (128, 128)
+PandasTools.molSize = (128, 80)
 
 SESSION = requests.Session()
 ADAPTER = HTTPAdapter(max_retries=Retry(total=5, backoff_factor=0.1, status_forcelist=[500, 502, 503, 504]))
@@ -329,13 +335,13 @@ def rule_of_three(mol):
 SCORE_MAP = {
     'SAscore': sa_score,
     'LogP': logp,
-    'Molecular weight': mw,
-    'Number of heavy atoms': heavy_atom,
-    'Molar refractivity': mr,
-    'H-bond donor count': hbd,
-    'H-Bond acceptor count': hba,
-    'Rotatable bond count': rotatable_bond,
-    'Topological polar surface area': tpsa,
+    'Molecular Weight': mw,
+    'Number of Heavy Atoms': heavy_atom,
+    'Molar Refractivity': mr,
+    'H-Bond Donor Count': hbd,
+    'H-Bond Acceptor Count': hba,
+    'Rotatable Bond Count': rotatable_bond,
+    'Topological Polar Surface Area': tpsa,
 }
 
 FILTER_MAP = {
@@ -393,7 +399,6 @@ COLUMN_ALIASES = {
     'ID2': 'Target ID',
     'Y': 'Actual CPI/CPA',
     'Y^': 'Predicted CPI/CPA',
-    'N': 'Original Index'
 }
 
 
@@ -401,7 +406,7 @@ 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('[]')}.")
+                         f"in the uploaded dataset: {str(mandatory_cols).strip('[]')}.")
         raise ValueError(error_message)
     else:
         return
@@ -540,17 +545,26 @@ def submit_predict(predict_filepath, task, preset, target_family, flag, state, p
 
 def update_df(file, progress=gr.Progress(track_tqdm=True)):
     # global DF_FOR_REPORT
-    if Path(file).is_file():
+    if file and Path(file).is_file():
         df = pd.read_csv(file)
+        if 'N' in df.columns:
+            df.set_index('N', inplace=True)
+        if not any(col in ['X1', 'X2'] for col in df.columns):
+            gr.Warning("At least one of columns `X1` and `X2` must be in the uploaded dataset.")
+            return {analyze_btn: gr.Button(interactive=False)}
         # if df['X1'].nunique() > 1:
-        df['Scaffold SMILES'] = df['X1'].swifter.progress_bar(
-            desc=f"Calculating scaffold...").apply(MurckoScaffold.MurckoScaffoldSmilesFromSmiles)
-        # Add a new column with RDKit molecule objects
-        if 'Compound' not in df.columns or df['Compound'].dtype != 'object':
-            PandasTools.AddMoleculeColumnToFrame(df, smilesCol='X1', molCol='Compound',
-                                                 includeFingerprints=True)
-        PandasTools.AddMoleculeColumnToFrame(df, smilesCol='Scaffold SMILES', molCol='Scaffold',
-                                             includeFingerprints=True)
+        if 'X1' in df.columns:
+            df['Scaffold SMILES'] = df['X1'].swifter.progress_bar(
+                desc=f"Calculating scaffold...").apply(MurckoScaffold.MurckoScaffoldSmilesFromSmiles)
+            df['Scaffold'] = df['Scaffold SMILES'].swifter.progress_bar(
+                desc='Generating scaffold graphs...').apply(
+                lambda smiles: _MolPlusFingerprint(Chem.MolFromSmiles(smiles)))
+            # Add a new column with RDKit molecule objects
+            if 'Compound' not in df.columns or df['Compound'].dtype != 'object':
+                df['Compound'] = df['X1'].swifter.progress_bar(
+                    desc='Generating molecular graphs...').apply(
+                    lambda smiles: _MolPlusFingerprint(Chem.MolFromSmiles(smiles)))
+
         # DF_FOR_REPORT = df.copy()
 
         # pie_chart = None
@@ -574,44 +588,81 @@ def update_df(file, progress=gr.Progress(track_tqdm=True)):
         return {analyze_btn: gr.Button(interactive=False)}
 
 
-def create_html_report(df, file=None, progress=gr.Progress(track_tqdm=True)):
+def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm=True)):
     df_html = df.copy(deep=True)
+    # email_hash = hashlib.sha256(email.encode()).hexdigest()
 
-    cols_left = ['N', 'ID1', 'Compound', 'Scaffold', 'Scaffold SMILES', 'ID2', 'Y', 'Y^',]
-    cols_right = ['X1', 'X2']
-    cols_left = [col for col in cols_left if col in df_html.columns]
-    cols_right = [col for col in cols_right if col in df_html.columns]
+    cols_left = list(pd.Index(
+        ['ID1', 'Compound', 'Scaffold', 'Scaffold SMILES', 'ID2', 'Y', 'Y^']).intersection(df_html.columns))
+    cols_right = list(pd.Index(['X1', 'X2']).intersection(df_html.columns))
     df_html = df_html[cols_left + (df_html.columns.drop(cols_left + cols_right).tolist()) + cols_right]
 
-    ascending = True if COLUMN_ALIASES['Y^'] == 'Predicted binding affinity' else False
+    if isinstance(task, str):
+        task = TASK_MAP[task]
+        COLUMN_ALIASES.update({
+            'Y': 'Actual Interaction Probability' if task == 'DTI' else 'Actual Binding Affinity',
+            'Y^': 'Predicted Interaction Probability' if task == 'DTI' else 'Predicted Binding Affinity'
+        })
+
+    ascending = True if COLUMN_ALIASES['Y^'] == 'Predicted Binding Affinity' else False
     df_html = df_html.sort_values(
         [col for col in ['Y', 'Y^'] if col in df_html.columns], ascending=ascending
     )
 
-    # # Remove repeated info for one-against-N tasks to save visual and physical space
-    # if df_html['X1'].nunique() <= 1:
-    #     columns_to_clean = ['X1', 'ID1', 'Scaffold', 'Compound'] + list(FILTER_MAP.keys()) + list(SCORE_MAP.keys())
-    #     for column in columns_to_clean:
-    #         if column in df_html.columns:
-    #             df_html.loc[1:, column] = pd.NA
-    #
-    # if df_html['X2'].nunique() <= 1:
-    #     columns_to_clean = ['X2', 'ID2']
-    #     for column in columns_to_clean:
-    #         if column in df_html.columns:
-    #             df_html.loc[1:, column] = pd.NA
-
     if not file:
         df_html = df_html.iloc[:31]
 
-    # PandasTools.ChangeMoleculeRendering(df_html, renderer='image')
-    # PandasTools.RenderImagesInAllDataFrames(images=True)
-    df_html['Compound'] = df_html['Compound'].swifter.progress_bar(
-        'Generating compound graph...').apply(lambda x: PandasTools.PrintAsImageString(x) if not pd.isna(x) else x)
-    df_html['Scaffold'] = df_html['Scaffold'].swifter.progress_bar(
-        'Generating scaffold graph...').apply(lambda x: PandasTools.PrintAsImageString(x) if not pd.isna(x) else x)
-    df_html = df_html.rename(columns=COLUMN_ALIASES)
+    # Remove repeated info for one-against-N tasks to save visual and physical space
+    job = 'Chemical Property'
+    unique_entity = 'Unique Entity'
+    unique_df = None
+    category = None
+    columns_unique = None
+    if 'X1' in df_html.columns and 'X2' in df_html.columns:
+        n_compound = df_html['X1'].nunique()
+        n_protein = df_html['X2'].nunique()
+
+        if n_compound == 1 and n_protein >= 2:
+            unique_entity = 'Compound of Interest'
+            if any(col in df_html.columns for col in ['Y^', 'Y']):
+                job = 'Target Protein Identification'
+                category = 'Target Family'
+            columns_unique = df_html.columns.isin(['X1', 'ID1', 'Scaffold', 'Compound', 'Scaffold SMILES']
+                                                  + list(FILTER_MAP.keys()) + list(SCORE_MAP.keys()))
+
+        elif n_compound >= 2 and n_protein == 1:
+            unique_entity = 'Target of Interest'
+            if any(col in df_html.columns for col in ['Y^', 'Y']):
+                job = 'Drug Hit Screening'
+                category = 'Scaffold SMILES'
+            columns_unique = df_html.columns.isin(['X2', 'ID2'])
+
+        elif 'Y^' in df_html.columns:
+            job = 'Interaction Pair Inference'
+    if 'Compound' in df_html.columns:
+        df_html['Compound'] = df_html['Compound'].swifter.progress_bar(
+            desc='Generating compound graph...').apply(
+            lambda x: PandasTools.PrintAsImageString(x) if not pd.isna(x) else x)
+    if 'Scaffold' in df_html.columns:
+        df_html['Scaffold'] = df_html['Scaffold'].swifter.progress_bar(
+            desc='Generating scaffold graph...').apply(
+            lambda x: PandasTools.PrintAsImageString(x) if not pd.isna(x) else x)
+
+    df_html.rename(columns=COLUMN_ALIASES, inplace=True)
     df_html.index.name = 'Index'
+    if 'Target FASTA' in df_html.columns:
+        df_html['Target FASTA'] = df_html['Target FASTA'].swifter.progress_bar(
+            desc='Processing FASTA...').apply(
+            lambda x: wrap_text(x) if not pd.isna(x) else x)
+
+    if columns_unique is not None:
+        unique_df = df_html.loc[:, columns_unique].iloc[[0]]
+        df_html = df_html.loc[:, ~columns_unique]
+
+    num_cols = df_html.select_dtypes('number').columns
+    num_col_colors = sns.color_palette('husl', len(num_cols))
+    bool_cols = df_html.select_dtypes(bool).columns
+    bool_col_colors = {True: 'lightgreen', False: 'lightpink'}
 
     if not file:
         if 'Compound ID' in df_html.columns:
@@ -620,100 +671,253 @@ def create_html_report(df, file=None, progress=gr.Progress(track_tqdm=True)):
             df_html.drop(['Target FASTA'], axis=1, inplace=True)
         if 'Target FASTA' in df_html.columns:
             df_html['Target FASTA'] = df_html['Target FASTA'].swifter.progress_bar(
-                'Processing FASTA...').apply(lambda x: wrap_text(x) if not pd.isna(x) else x)
-        df_html.drop(['Scaffold SMILES'], axis=1, inplace=True)
-        # num_formatters = {col: "{:.3f}" for col in df.select_dtypes('number').columns}
+                desc='Processing FASTA...').apply(
+                lambda x: wrap_text(x) if not pd.isna(x) else x)
+        if 'Scaffold SMILES' in df_html.columns:
+            df_html.drop(['Scaffold SMILES'], axis=1, inplace=True)
         styled_df = df_html.style.format(precision=3)
-        colors = sns.color_palette('husl', len(df_html.columns))
-        for i, col in enumerate(df_html.columns):
-            if pd.api.types.is_numeric_dtype(df_html[col]):
-                styled_df = styled_df.background_gradient(subset=col, cmap=sns.light_palette(colors[i], as_cmap=True))
-        html = styled_df.to_html()
-        return f'Report preview<div style="overflow:auto; height: 300px; font-family: Courier !important;">{html}</div>'
-    else:
-        import panel as pn
-        from bokeh.resources import INLINE
-        from bokeh.models import NumberFormatter, BooleanFormatter
 
+        for i, col in enumerate(num_cols):
+            if col not in ['Predicted Binding Affinity', 'Actual Binding Affinity']:
+                styled_df = styled_df.background_gradient(
+                    subset=[col], cmap=sns.light_palette(num_col_colors[i], as_cmap=True))
+            else:
+                styled_df = styled_df.background_gradient(
+                    subset=[col], cmap=sns.light_palette(num_col_colors[i], as_cmap=True).reversed())
+
+        styled_df.applymap(lambda val: f'background-color: {bool_col_colors[val]}', subset=bool_cols)
+
+        table_html = styled_df.to_html()
+        unique_html = ''
+        if unique_df is not None:
+            unique_html = unique_df.replace('\n', '<br>', regex=True).to_html(escape=False, index=False)
+            unique_html = f'<div style="font-family: Courier !important;">{unique_html}</div>'
+
+        return (f'<div style="font-size: 16px; font-weight: bold;">{job} Report Preview (Top 30 Records)</div>'
+                f'{unique_html}'
+                f'<div style="overflow:auto; height: 300px; font-family: Courier !important;">{table_html}</div>')
+
+    else:
         bool_formatters = {col: BooleanFormatter() for col in df_html.select_dtypes(bool).columns}
-        num_formatters = {col: NumberFormatter(format='0.000') for col in df_html.select_dtypes('number').columns}
+        num_formatters = {col: NumberFormatter(format='0.000') for col in df_html.select_dtypes('floating').columns}
         other_formatters = {
-            'Predicted interaction probability': {'type': 'progress', 'max': 1.0, 'legend': True},
-            'Actual interaction probability': {'type': 'progress', 'max': 1.0, 'legend': True},
-            'Compound': HTMLTemplateFormatter(),
-            'Scaffold': HTMLTemplateFormatter(),
+            'Predicted Interaction Probability': {'type': 'progress', 'max': 1.0, 'legend': True},
+            'Actual Interaction Probability': {'type': 'progress', 'max': 1.0, 'legend': True},
+            'Compound': HTMLTemplateFormatter(template='<div class="image-zoom-viewer"><%= value %></div>'),
+            'Scaffold': HTMLTemplateFormatter(template='<div class="image-zoom-viewer"><%= value %></div>'),
             'Target FASTA': {'type': 'textarea', 'width': 60},
+            'Target ID': HTMLTemplateFormatter(
+                template='<a href="<% '
+                         'if (/^[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]([A-Z][A-Z0-9]{2}[0-9]){1,2}$/.test(value)) '
+                         '{ %>https://www.uniprot.org/uniprotkb/<%= value %><% } '
+                         'else { %>https://www.uniprot.org/uniprotkb?query=<%= value %><% } '
+                         '%>" target="_blank"><%= value %></a>'),
+            'Compound ID': HTMLTemplateFormatter(
+                template='<a href="https://pubchem.ncbi.nlm.nih.gov/compound/<%= value %>" '
+                         'target="_blank"><%= value %></a>')
         }
         formatters = {**bool_formatters, **num_formatters, **other_formatters}
 
         # html = df.to_html(file)
         # return html
-        pn.widgets.Tabulator(df_html, formatters=formatters).save(file, resources=INLINE)
-
-
-# def create_pie_chart(df, category, value, top_k):
-#     df.rename(COLUMN_ALIASES, inplace=True)
-#     # Select the top_k records based on the value_col
-#     top_k_df = df.nlargest(top_k, value)
-#
-#     # Count the frequency of each unique value in the category_col column
-#     category_counts = top_k_df[category].value_counts()
-#
-#     # Convert the counts to a DataFrame
-#     data = pd.DataFrame({category: category_counts.index, 'value': category_counts.values})
-#
-#     # Calculate the angle for each category
-#     data['angle'] = data['value']/data['value'].sum() * 2*pi
-#
-#     # Assign colors
-#     data['color'] = Spectral11[0:len(category_counts)]
-#
-#     # Create the plot
-#     p = figure(height=350, title="Pie Chart", toolbar_location=None,
-#                tools="hover", tooltips="@{}: @value".format(category), x_range=(-0.5, 1.0))
-#
-#     p.wedge(x=0, y=1, radius=0.4,
-#             start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
-#             line_color="white", fill_color='color', legend_field=category, source=data)
-#
-#     p.axis.axis_label = None
-#     p.axis.visible = False
-#     p.grid.grid_line_color = None
-#
-#     return p
 
-def create_pie_chart(df, category, value, top_k):
-    df = df.copy()
-    df.rename(COLUMN_ALIASES, inplace=True)
-    value = COLUMN_ALIASES.get(value, value)
-    # Select the top_k records based on the value_col
-    top_k_df = df.nlargest(top_k, value)
+        report_table = pn.widgets.Tabulator(
+            df_html, formatters=formatters,
+            frozen_columns=['Index', 'Target ID', 'Compound ID', 'Compound', 'Scaffold'],
+            disabled=True, sizing_mode='stretch_both')
 
-    # Count the frequency of each unique value in the category_col column
-    category_counts = top_k_df[category].value_counts()
+        for i, col in enumerate(num_cols):
+            if col not in ['Predicted Binding Affinity', 'Actual Binding Affinity']:
+                if col not in ['Predicted Interaction Probability', 'Actual Interaction Probability']:
+                    report_table.style.background_gradient(
+                        subset=df_html.columns == col, cmap=sns.light_palette(num_col_colors[i], as_cmap=True))
+                else:
+                    continue
+            else:
+                report_table.style.background_gradient(
+                    subset=df_html.columns == col, cmap=sns.light_palette(num_col_colors[i], as_cmap=True).reversed())
+
+        pie_charts = {}
+        for y in df_html.columns.intersection(['Predicted Interaction Probability', 'Actual Interaction Probability',
+                                               'Predicted Binding Affinity', 'Actual Binding Affinity']):
+            pie_charts[y] = []
+            for k in [10, 30, 100]:
+                if k < len(df_html):
+                    pie_charts[y].append(create_pie_chart(df_html, category=category, value=y, top_k=k))
+            pie_charts[y].append(create_pie_chart(df_html, category=category, value=y, top_k=len(df_html)))
+
+        # Remove keys with empty values
+        pie_charts = {k: v for k, v in pie_charts.items() if any(v)}
+
+        pn_css = """
+        .tabulator {
+            font-family: Courier New !important;
+            font-weight: normal !important;
+            font-size: 12px !important;
+            overflow: visible !important;
+        }
+        
+        .tabulator-cell {
+            overflow: visible !important;
+        }
+        
+        .bk-panel-models-tabulator-DataTabulator {
+            overflow: visible !important;
+        }
+        
+        .tabulator-cell.tabulator-frozen:hover {
+            z-index: 1000 !important;
+        }
+        
+        .bk-panel-models-tabulator-DataTabulator:hover {
+            z-index: 999 !important;
+        }
+        
+        .image-zoom-viewer {
+            display: inline-block;
+            position: relative;
+            overflow: visible; /* Ensures that the scaled SVG isn't clipped */
+        }
+        
+        .image-zoom-viewer::after {
+            content: "";
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+        }
+        
+        .image-zoom-viewer:hover::after {
+            pointer-events: all;
+        }
+        
+        /* When hovering over the container, scale its child (the SVG) */
+        .tabulator-cell:hover .image-zoom-viewer svg {
+            padding: 3px; 
+            position: relative; /* Position the SVG relative to the viewport */
+            background-color: rgba(250, 250, 250, 0.854);
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.618);
+            border-radius: 3px;
+            transform: scale(4) translate(+38.2%, +38.2%); /* Scale up the SVG */
+            transition: transform 0.3s ease;
+            pointer-events: none; /* Prevents the SVG from blocking mouse interactions */
+        }
+        
+        .image-zoom-viewer svg {
+            display: block; /* SVG is a block-level element for proper scaling */
+            z-index: 1000;
+        }
+        
+        .image-zoom-viewer:hover {
+            z-index: 1000;
+        }
+        
+        """
+
+        pn.extension(raw_css=[pn_css])
+
+        template = pn.template.VanillaTemplate(
+            title=f'DeepSEQreen {job} Report',
+            sidebar=[],
+            favicon='deepseqreen.svg',
+            logo='deepseqreen.svg',
+            header_background='#F3F5F7',
+            header_color='#4372c4',
+            busy_indicator=None,
+        )
 
-    # Convert the counts to a DataFrame
-    data = pd.DataFrame({category: category_counts.index, 'value': category_counts.values})
+        info_row = pn.Row()
+        if unique_df is not None:
+            unique_table = pn.widgets.Tabulator(unique_df, formatters=formatters, show_index=False, disabled=True)
+            info_row.append(pn.Column(f'### {unique_entity}', unique_table))
+        if pie_charts:
+            for score_name, figure_list in pie_charts.items():
+                info_row.append(
+                    pn.Column(f'### {category} by Top {score_name}',
+                              pn.Tabs(*figure_list, tabs_location='above'))
+                    # pn.Card(pn.Row(v), title=f'{category} by Top {k}')
+                )
+        if info_row:
+            template.main.append(pn.Card(info_row,
+                                         sizing_mode='stretch_width', title='Summary Statistics', margin=10))
+
+        template.main.append(
+            pn.Card(report_table, title=f'{job} Results',  # width=1200,
+                    margin=10)
+        )
 
-    # Create the plot
-    fig = px.pie(data, values='value', names=category, title=f'Top-{top_k} {category} in {value}')
-    fig.update_traces(textposition='inside', textinfo='percent+label')
+        template.save(file, resources=INLINE)
+        return file
 
-    return fig
 
+def create_pie_chart(df, category, value, top_k):
+    if category not in df or value not in df:
+        return
+    top_k_df = df.nlargest(top_k, value)
+    category_counts = top_k_df[category].value_counts()
+    data = pd.DataFrame({category: category_counts.index, 'value': category_counts.values})
 
-def submit_report(df, score_list, filter_list, progress=gr.Progress(track_tqdm=True)):
+    data['proportion'] = data['value'] / data['value'].sum()
+    # Merge rows with proportion less than 0.1% into one row
+    mask = data['proportion'] <= 0.001
+    merged_row = data[mask].sum()
+    merged_row[category] = 'Other'
+    data = pd.concat([data[~mask], pd.DataFrame(merged_row).T])
+    data['angle'] = data['proportion'] * 2 * pi
+    data['color'] = (Category20c_20 * (len(data) // 20 + 1))[:len(data)]
+
+    tooltips = [
+        (f"{category}", f"@{{{category}}}"),
+        ("Count", "@value"),
+        ("Percentage", "@proportion{0.0%}")
+    ]
+
+    if category == 'Scaffold SMILES':
+        data = data.merge(top_k_df[['Scaffold SMILES', 'Scaffold']].drop_duplicates(), how='left',
+                          left_on='Scaffold SMILES', right_on='Scaffold SMILES')
+        tooltips.append(("Scaffold", "<div>@{Scaffold}{safe}</div>"))
+    p = figure(height=256, name=f"Top {top_k}" if top_k < len(df) else 'All',
+               toolbar_location=None, tools="hover", tooltips=tooltips, x_range=(-0.5, 0.5),
+               sizing_mode="scale_height")
+    p.axis.axis_label = None
+    p.axis.visible = False
+    p.grid.grid_line_color = None
+    p.outline_line_width = 0
+    p.min_border = 0
+    p.min_border_right = 0
+    p.margin = 0
+
+    p.add_layout(Legend(padding=0, margin=0), 'right')
+    p.wedge(x=0, y=1, radius=0.3,
+            start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
+            line_color="white", fill_color='color', legend_field=category, source=data)
+
+    p.legend.label_text_font_size = "8pt"
+    p.legend.margin = 0
+    p.legend.padding = 0
+
+    # Limit the number of legend items to 20 and add "..." if there are more than 30 items
+    if len(p.legend.items) > 20:
+        p.legend.items = p.legend.items[:21]
+        p.legend.items.append(LegendItem(label="..."))
+
+    return p
+
+
+def submit_report(df, score_list, filter_list, task, progress=gr.Progress(track_tqdm=True)):
     df_report = df.copy()
     try:
         for filter_name in filter_list:
             df_report[filter_name] = df_report['Compound'].swifter.progress_bar(
                 desc=f"Calculating {filter_name}").apply(
-                lambda x: FILTER_MAP[filter_name](x) if not pd.isna(x) else x, axis=1)
+                lambda x: FILTER_MAP[filter_name](x) if not pd.isna(x) else x)
 
         for score_name in score_list:
             df_report[score_name] = df_report['Compound'].swifter.progress_bar(
                 desc=f"Calculating {score_name}").apply(
-                lambda x: SCORE_MAP[score_name](x) if not pd.isna(x) else x, axis=1)
+                lambda x: SCORE_MAP[score_name](x) if not pd.isna(x) else x)
 
         # pie_chart = None
         # value = None
@@ -728,11 +932,13 @@ def submit_report(df, score_list, filter_list, progress=gr.Progress(track_tqdm=T
         #     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_report), df_report  # pie_chart
+        return (create_html_report(df_report, file=None, task=task), df_report,
+                gr.File(visible=False), gr.File(visible=False))
 
     except Exception as e:
         gr.Warning(f'Failed to report results due to error: {str(e)}')
-        return None, None
+        return None, None, None, None
+
 
 # def check_job_status(job_id):
 #     job_lock = DATA_PATH / f"{job_id}.lock"
@@ -844,6 +1050,7 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
     screen_flag = gr.State(value=False)
     identify_flag = gr.State(value=False)
     infer_flag = gr.State(value=False)
+    report_upload_flag = gr.State(value=False)
 
     with gr.Tabs() as tabs:
         with gr.TabItem(label='Drug Hit Screening', id=0):
@@ -916,7 +1123,8 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
 
                     with gr.Row():
                         with gr.Column():
-                            target_family_detect_btn = gr.Button(value='OR Let Us Auto-Detect for You', variant='primary')
+                            target_family_detect_btn = gr.Button(value='OR Let Us Auto-Detect for You',
+                                                                 variant='primary')
 
                     with gr.Row():
                         with gr.Column():
@@ -944,9 +1152,10 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                                 "while affinity prediction directly estimates their binding strength measured using "
                                 "IC50."
                             )
-                            drug_screen_task = gr.Dropdown(list(TASK_MAP.keys()),
-                                                           label='Step 4. Select the Prediction Task You Want to Conduct',
-                                                           value='Compound-protein interaction')
+                            drug_screen_task = gr.Dropdown(
+                                list(TASK_MAP.keys()),
+                                label='Step 4. Select the Prediction Task You Want to Conduct',
+                                value='Compound-protein interaction')
 
                     with gr.Row():
                         with gr.Column():
@@ -954,10 +1163,11 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                                 "Select your preferred model, or click Recommend for the best-performing model based "
                                 "on the selected task, family, and whether the target was trained. "
                                 "Please refer to documentation for detailed benchamrk results."
-                                )
+                            )
                             drug_screen_preset = gr.Dropdown(list(PRESET_MAP.keys()),
                                                              label='Step 5. Select a Preset Model')
-                            screen_preset_recommend_btn = gr.Button(value='OR Let Us Recommend for You', variant='primary')
+                            screen_preset_recommend_btn = gr.Button(
+                                value='OR Let Us Recommend for You', variant='primary')
                     with gr.Row():
                         with gr.Column():
                             drug_screen_email = gr.Textbox(
@@ -1048,9 +1258,10 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                                 "while affinity prediction directly estimates their binding strength measured using "
                                 "IC50."
                             )
-                            target_identify_task = gr.Dropdown(list(TASK_MAP.keys()),
-                                                               label='Step 4. Select the Prediction Task You Want to Conduct',
-                                                               value='Compound-protein interaction')
+                            target_identify_task = gr.Dropdown(
+                                list(TASK_MAP.keys()),
+                                label='Step 4. Select the Prediction Task You Want to Conduct',
+                                value='Compound-protein interaction')
 
                     with gr.Row():
                         with gr.Column():
@@ -1058,7 +1269,7 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                                 "Select your preferred model, or click Recommend for the best-performing model based "
                                 "on the selected task, family, and whether the compound was trained. "
                                 "Please refer to documentation for detailed benchamrk results."
-                                )
+                            )
                             target_identify_preset = gr.Dropdown(list(PRESET_MAP.keys()),
                                                                  label='Step 5. Select a Preset Model')
                             identify_preset_recommend_btn = gr.Button(value='OR Let Us Recommend for You',
@@ -1073,7 +1284,8 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
 
                     with gr.Row(visible=True):
                         # target_identify_clr_btn = gr.ClearButton(size='lg')
-                        target_identify_btn = gr.Button(value='SUBMIT THE IDENTIFICATION JOB', variant='primary', size='lg')
+                        target_identify_btn = gr.Button(value='SUBMIT THE IDENTIFICATION JOB', 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."
@@ -1152,9 +1364,10 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                                 "while affinity prediction directly estimates their binding strength "
                                 "measured using IC50."
                             )
-                            pair_infer_task = gr.Dropdown(list(TASK_MAP.keys()),
-                                                          label='Step 3. Select the Prediction Task You Want to Conduct',
-                                                          value='Compound-protein interaction')
+                            pair_infer_task = gr.Dropdown(
+                                list(TASK_MAP.keys()),
+                                label='Step 3. Select the Prediction Task You Want to Conduct',
+                                value='Compound-protein interaction')
 
                     with gr.Row():
                         with gr.Column():
@@ -1189,17 +1402,20 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                 To compute chemical properties for the predictions of drug hit screening, 
                 target protein identification, and interaction pair inference. 
                 
-                You may also upload your own dataset using a CSV file containing one required column X1 for compound SMILES. 
+                You may also upload your own dataset using a CSV file containing 
+                one required column `X1` for compound SMILES. 
                 
                 The page shows only a preview report displaying at most 30 records 
                 (with top predicted CPI/CPA if reporting results from a prediction job). 
                 
-                For a full report, please 
-                generate and download a CSV or interactive HTML report below.
-           
+                Please first `**Preview**` the report, then `**Generate**` and download a CSV report 
+                or an interactive HTML report below if you wish to access the full report.
                 ''')
                 with gr.Row():
-                    file_for_report = gr.File(interactive=True, type='filepath')
+                    with gr.Column():
+                        file_for_report = gr.File(interactive=True, type='filepath')
+                        report_task = gr.Dropdown(list(TASK_MAP.keys()), visible=False, value=None,
+                                                  label='Specify the Task for the Labels in the Upload Dataset')
                     raw_df = gr.State(value=pd.DataFrame())
                     report_df = gr.State(value=pd.DataFrame())
                     scores = gr.CheckboxGroup(list(SCORE_MAP.keys()), label='Scores')
@@ -1207,7 +1423,8 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
 
                 with gr.Row():
                     # clear_btn = gr.ClearButton(size='lg')
-                    analyze_btn = gr.Button('Preview Top 30 Records', variant='primary', size='lg', interactive=False)
+                    analyze_btn = gr.Button('Preview Top 30 Records', variant='primary', size='lg',
+                                            interactive=False)
 
                 with gr.Row():
                     with gr.Column(scale=3):
@@ -1217,11 +1434,11 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                 with gr.Row():
                     with gr.Column():
                         csv_generate = gr.Button(value='Generate CSV Report',
-                                                 interactive=True, variant='primary', visible=False)
+                                                 interactive=False, variant='primary')
                         csv_download_file = gr.File(label='Download CSV Report', visible=False)
                     with gr.Column():
                         html_generate = gr.Button(value='Generate HTML Report',
-                                                  interactive=True, variant='primary', visible=False)
+                                                  interactive=False, variant='primary')
                         html_download_file = gr.File(label='Download HTML Report', visible=False)
 
 
@@ -1336,6 +1553,8 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
 
     example_fasta.click(fn=example_fill, inputs=target_input_type, outputs=[
         target_id, target_gene, target_organism, target_fasta], show_progress=False)
+
+
     # example_uniprot.click(fn=example_fill, inputs=target_input_type, outputs=target_fasta, show_progress=False)
     # example_gene.click(fn=example_fill, inputs=target_input_type, outputs=target_fasta, show_progress=False)
 
@@ -1663,47 +1882,82 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
     )
 
     # TODO background job from these 3 pipelines to update file_for_report
+    def inquire_task(df, upload_flag):
+        if upload_flag:
+            if 'Y' in df.columns:
+                label = 'actual CPI/CPA labels (`Y`)'
+            elif 'Y^' in df.columns:
+                label = 'predicted CPI/CPA labels (`Y^`)'
+            else:
+                return {analyze_btn: gr.Button(interactive=True),
+                        csv_generate: gr.Button(interactive=True),
+                        html_generate: gr.Button(interactive=True)}
+
+            return {report_task: gr.Dropdown(visible=True,
+                                             info=f'Found {label} in your uploaded dataset. '
+                                                  'Is it compound-target interaction or binding affinity?'),
+                    html_report: '',
+                    analyze_btn: gr.Button(interactive=False),
+                    csv_generate: gr.Button(interactive=False),
+                    html_generate: gr.Button(interactive=False)}
+        else:
+            return {report_task: gr.Dropdown(visible=False)}
+
 
     file_for_report.change(fn=update_df, inputs=file_for_report, outputs=[
-        html_report,
-        raw_df,
-        report_df,
-        analyze_btn
-        # ranking_pie_chart
-    ])
-    analyze_btn.click(fn=submit_report, inputs=[raw_df, scores, filters], outputs=[
-        html_report,
-        report_df,
-        # ranking_pie_chart
-    ])
-
-
-    def create_csv_report_file(df, file_report):
+        html_report, raw_df, report_df, analyze_btn]).success(
+        fn=lambda: [gr.Button(interactive=False)]*2 + [gr.File(visible=False)]*2 + [gr.Dropdown(visible=False)],
+        outputs=[csv_generate, html_generate, csv_download_file, html_download_file, report_task]
+    ).then(
+        fn=inquire_task, inputs=[raw_df, report_upload_flag],
+        outputs=[report_task, html_report, analyze_btn, csv_generate, html_generate]
+    )
+    file_for_report.clear(fn=lambda: gr.Dropdown(visible=False), outputs=report_task)
+    file_for_report.upload(
+        fn=lambda: True, outputs=report_upload_flag
+    )
+
+    analyze_btn.click(fn=submit_report, inputs=[raw_df, scores, filters, report_task], outputs=[
+        html_report, report_df, csv_download_file, html_download_file
+    ]).success(fn=lambda: [gr.Button(interactive=True)] * 2,
+               outputs=[csv_generate, html_generate])
+
+    report_task.select(fn=lambda: gr.Button(interactive=True),
+                       outputs=analyze_btn)
+
+
+    def create_csv_report_file(df, file_report, progress=gr.Progress(track_tqdm=True)):
         try:
             now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
             filename = f"reports/{Path(file_report.name).stem}_DeepSEQreen_report_{now}.csv"
             df.drop(labels=['Compound', 'Scaffold'], axis=1).to_csv(filename, index=False)
 
-            return gr.File(filename, visible=True), gr.Button(visible=False)
+            return gr.File(filename)
         except Exception as e:
             gr.Warning(f"Failed to generate CSV due to error: {str(e)}")
-            return None, None
+            return None
+
 
-    def create_html_report_file(df, file_report):
+    def create_html_report_file(df, file_report, progress=gr.Progress(track_tqdm=True)):
         try:
             now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
             filename = f"reports/{Path(file_report.name).stem}_DeepSEQreen_report_{now}.html"
             create_html_report(df, filename)
-            return gr.File(filename, visible=True), gr.Button(visible=False)
+            return gr.File(filename, visible=True)
         except Exception as e:
             gr.Warning(f"Failed to generate HTML due to error: {str(e)}")
-            return None, None
+            return None
+
 
     html_report.change(lambda: [gr.Button(visible=True)] * 2, outputs=[csv_generate, html_generate])
-    csv_generate.click(fn=create_csv_report_file, inputs=[report_df, file_for_report],
-                       outputs=[csv_download_file, csv_generate])
-    html_generate.click(fn=create_html_report_file, inputs=[report_df, file_for_report],
-                        outputs=[html_download_file, html_generate])
+    csv_generate.click(
+        lambda: [gr.Button(visible=False), gr.File(visible=True)], outputs=[csv_generate, csv_download_file],
+    ).then(fn=create_csv_report_file, inputs=[report_df, file_for_report],
+           outputs=csv_download_file, show_progress='full')
+    html_generate.click(
+        lambda: [gr.Button(visible=False), gr.File(visible=True)], outputs=[html_generate, html_download_file],
+    ).then(fn=create_html_report_file, inputs=[report_df, file_for_report],
+           outputs=html_download_file, show_progress='full')
 
     # screen_waiting.change(fn=check_job_status, inputs=run_state, outputs=[pair_waiting, tabs, file_for_report],
     #                       every=5)