Update app.py

app.py

@@ -462,12 +462,20 @@ def submit_predict(predict_filepath, task, preset, target_family, flag, state, p
                 predictions = [pd.DataFrame(prediction) for prediction in predictions]
                 prediction_df = pd.concat([prediction_df, pd.concat(predictions, ignore_index=True)])
                 prediction_df.set_index('N', inplace=True)
+                orig_df = pd.read_csv(
+                    predict_filepath,
+                    usecols=lambda x: x not in ['X1', 'ID1', 'Compound', 'Scaffold', 'Scaffold SMILES',
+                                                'X2', 'ID2',
+                                                'Y', 'Y^']
+                )
+                prediction_df = pd.merge(prediction_df, orig_df, left_index=True, right_index=True, how='left')
 
                 predictions_file = f'temp/{job_id}_predictions.csv'
                 prediction_df.to_csv(predictions_file)
 
-                return [predictions_file,
-                        False]
+                return {file_for_report: predictions_file,
+                        run_state: False,
+                        report_upload_flag: False}
         except Exception as e:
             gr.Warning(f"Prediction job failed due to error: {str(e)}")
             return {run_state: False}
@@ -655,15 +663,15 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
             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 columns_unique is not None:
+        unique_df = df_html.loc[:, columns_unique].iloc[[0]].copy()
+        df_html = df_html.loc[:, ~columns_unique]
+
     if not file:
         if 'Compound ID' in df_html.columns:
             df_html.drop(['Compound SMILES'], axis=1, inplace=True)
@@ -678,28 +686,35 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
         styled_df = df_html.style.format(precision=3)
 
         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())
+            if col in df_html.columns:
+                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)
+        if any(df_html.columns.isin(bool_cols)):
+            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>'
+            if 'Target FASTA' in unique_df.columns:
+                unique_df['Target FASTA'] = unique_df['Target FASTA'].str.replace('\n', '<br>')
+            if any(unique_df.columns.isin(bool_cols)):
+                unique_df = unique_df.style.applymap(
+                    lambda val: f"background-color: {bool_col_colors[val]}", subset=bool_cols)
+            unique_html = (f'<div style="font-family: Courier !important;">'
+                           f'{unique_df.to_html(escape=False, index=False)}</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-x:auto; font-family: Courier !important;">{unique_html}</div>'
                 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('floating').columns}
+        bool_formatters = {col: BooleanFormatter() for col in bool_cols}
+        float_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},
@@ -716,7 +731,7 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
                 template='<a href="https://pubchem.ncbi.nlm.nih.gov/compound/<%= value %>" '
                          'target="_blank"><%= value %></a>')
         }
-        formatters = {**bool_formatters, **num_formatters, **other_formatters}
+        formatters = {**bool_formatters, **float_formatters, **other_formatters}
 
         # html = df.to_html(file)
         # return html
@@ -724,7 +739,7 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
         report_table = pn.widgets.Tabulator(
             df_html, formatters=formatters,
             frozen_columns=['Index', 'Target ID', 'Compound ID', 'Compound', 'Scaffold'],
-            disabled=True, sizing_mode='stretch_both')
+            disabled=True, sizing_mode='stretch_both', pagination='local')
 
         for i, col in enumerate(num_cols):
             if col not in ['Predicted Binding Affinity', 'Actual Binding Affinity']:
@@ -754,34 +769,28 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
             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:hover {
+            z-index: 1000 !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 */
+            overflow: visible; 
+            z-index: 1000;
         }
         
         .image-zoom-viewer::after {
             content: "";
-            position: absolute;
             top: 0;
             left: 0;
             width: 100%;
@@ -795,14 +804,15 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
         
         /* 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 */
+            padding: 3px;
+            position: absolute; 
             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 */
+            transform: scale(3) translate(+38.2%, +38.2%); /* Scale up the SVG */
             transition: transform 0.3s ease;
             pointer-events: none; /* Prevents the SVG from blocking mouse interactions */
+            z-index: 1000;
         }
         
         .image-zoom-viewer svg {
@@ -828,19 +838,24 @@ def create_html_report(df, file=None, task=None, progress=gr.Progress(track_tqdm
             busy_indicator=None,
         )
 
-        info_row = pn.Row()
+        stats_pane = 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))
+            unique_table = pn.widgets.Tabulator(unique_df, formatters=formatters, sizing_mode='stretch_width',
+                                                show_index=False, disabled=True,
+                                                frozen_columns=['Compound ID', 'Compound', 'Scaffold'])
+            # if pie_charts:
+            #     unique_table.width = 640
+            stats_pane.append(pn.Column(f'### {unique_entity}', unique_table))
         if pie_charts:
             for score_name, figure_list in pie_charts.items():
-                info_row.append(
+                stats_pane.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,
+
+        if stats_pane:
+            template.main.append(pn.Card(stats_pane,
                                          sizing_mode='stretch_width', title='Summary Statistics', margin=10))
 
         template.main.append(
@@ -860,13 +875,19 @@ def create_pie_chart(df, category, value, top_k):
     data = pd.DataFrame({category: category_counts.index, 'value': category_counts.values})
 
     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])
+    # Merge rows with proportion less than 0.2% into one row
+    mask = data['proportion'] < 0.002
+    if any(mask):
+        merged_row = data[mask].sum()
+        merged_row[category] = '...'
+        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)]
+
+    color_dict = {cat: color for cat, color in
+                  zip(df[category].unique(),
+                      (Category20c_20 * (len(df[category].unique()) // 20 + 1))[:len(df[category].unique())])}
+    color_dict['...'] = '#636363'
+    data['color'] = data[category].map(color_dict)
 
     tooltips = [
         (f"{category}", f"@{{{category}}}"),
@@ -878,30 +899,33 @@ def create_pie_chart(df, category, value, top_k):
         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 = figure(height=384, width=960, name=f"Top {top_k}" if top_k < len(df) else 'All', sizing_mode='stretch_height',
+               toolbar_location=None, tools="hover", tooltips=tooltips, x_range=(-0.4, 0.4))
+
+    def truncate_label(label, max_length=60):
+        return label if len(label) <= max_length else label[:max_length] + "..."
+
+    data['legend_field'] = data[category].apply(truncate_label)
 
     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)
+            line_color="white", fill_color='color', legend_field='legend_field', 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
+    # Limit the number of legend items to 20 and add "..." if there are more than 20 items
     if len(p.legend.items) > 20:
-        p.legend.items = p.legend.items[:21]
-        p.legend.items.append(LegendItem(label="..."))
+        new_legend_items = p.legend.items[:20]
+        new_legend_items.append(LegendItem(label="..."))
+        p.legend.items = new_legend_items
+
+    p.legend.label_text_font_size = "10pt"
+    p.legend.label_text_font="courier"
+    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.margin = 0
 
     return p
 
@@ -1408,7 +1432,7 @@ with gr.Blocks(theme=theme, title='DeepSEQreen', css=CSS) as demo:
                 The page shows only a preview report displaying at most 30 records 
                 (with top predicted CPI/CPA if reporting results from a prediction job). 
                 
-                Please first `**Preview**` the report, then `**Generate**` and download a CSV report 
+                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():
@@ -1841,7 +1865,7 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
         fn=submit_predict,
         inputs=[screen_data_for_predict, drug_screen_task, drug_screen_preset,
                 drug_screen_target_family, screen_flag, run_state],  # , drug_screen_email],
-        outputs=[file_for_report, run_state]
+        outputs=[file_for_report, run_state, report_upload_flag]
     ).then(
         fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False), gr.Tabs(selected=3)],
         outputs=[screen_page, screen_waiting, tabs]
@@ -1858,7 +1882,7 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
         fn=submit_predict,
         inputs=[identify_data_for_predict, target_identify_task, target_identify_preset,
                 target_identify_target_family, identify_flag, run_state],  # , target_identify_email],
-        outputs=[file_for_report, run_state]
+        outputs=[file_for_report, run_state, report_upload_flag]
     ).then(
         fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False), gr.Tabs(selected=3)],
         outputs=[identify_page, identify_waiting, tabs]
@@ -1875,7 +1899,7 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
         fn=submit_predict,
         inputs=[infer_data_for_predict, pair_infer_task, pair_infer_preset,
                 pair_infer_target_family, infer_flag, run_state],  # , pair_infer_email],
-        outputs=[file_for_report, run_state]
+        outputs=[file_for_report, run_state, report_upload_flag]
     ).then(
         fn=lambda: [gr.Column(visible=True), gr.Markdown(visible=False), gr.Tabs(selected=3)],
         outputs=[infer_page, infer_waiting, tabs]
@@ -1903,7 +1927,9 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
         else:
             return {report_task: gr.Dropdown(visible=False)}
 
-
+    file_for_report.upload(
+        fn=lambda: True, outputs=report_upload_flag
+    )
     file_for_report.change(fn=update_df, inputs=file_for_report, outputs=[
         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)],
@@ -1912,10 +1938,8 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
         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
-    )
+    file_for_report.clear(fn=lambda: [gr.Dropdown(visible=False, value=None), False],
+                          outputs=[report_task, 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
@@ -1969,10 +1993,10 @@ QALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES
     # demo.load(None, None, None, js="() => {document.body.classList.remove('dark')}")
 
 if __name__ == "__main__":
-    screen_block.queue(max_size=2)
-    identify_block.queue(max_size=2)
-    infer_block.queue(max_size=2)
-    report.queue(max_size=20)
+    screen_block.queue(max_size=3)
+    identify_block.queue(max_size=3)
+    infer_block.queue(max_size=3)
+    report.queue(max_size=3)
 
     # SCHEDULER.add_job(func=file_cleanup(), trigger="interval", seconds=60)
     # SCHEDULER.start()