fix results dict in new pipeline, remove double tab logic for config

app.py

@@ -38,9 +38,6 @@ with gr.Blocks(title="RFD3 Test") as demo:
 
         gr.Image("assets/overview_rfd3_baker.png", width=600)
 
-        
-
-    tab_selected = gr.State("upload") # which tab is selected on the left
     config_ready = gr.State(None) # whether the config is ready for running generation, takes values None, "manual", or "upload"
     scaffold_ready = gr.State(None) # whether the scaffold is ready for running generation, takes values None, "upload", or "no_input"
     gen_directory = gr.State(None) # the directory where generation results are saved, used to trigger the download of results as zip file
@@ -49,54 +46,29 @@ with gr.Blocks(title="RFD3 Test") as demo:
     # inputs from user
     with gr.Row():
         with gr.Column(scale=1):  # Left half
-            gr.Markdown("Set up the configuration for your run through a valid yaml file or by manually setting minimal parameters for an unconditional run.")
-            with gr.Tabs() as config_tabs:
-                with gr.TabItem("Upload Config") as upload_tab: # upload a config yaml or json
-                    config_upload = gr.File(label="Config file: .yaml or .json", file_types=[".pdb", ".yaml", ".json"])
-                    num_designs_per_batch_upload = gr.Number(
-                        value=2,
-                        label="Number of Designs per Batch",
-                        precision=0,
-                        minimum=1,
-                        maximum=8
-                    )
-                    num_batches_upload = gr.Number(
-                        value=5,
-                        label="Number of Batches",
-                        precision=0,
-                        minimum=1,
-                        maximum=10
-                    )
-                with gr.TabItem("Manual Config") as manual_tab: # minimal config for testing unconditional generation
-                    num_designs_per_batch = gr.Number(
-                        value=2,
-                        label="Number of Designs per Batch",
-                        precision=0,
-                        minimum=1,
-                        maximum=8
-                    )
-                    num_batches = gr.Number(
-                        value=5,
-                        label="Number of Batches",
-                        precision=0,
-                        minimum=1,
-                        maximum=10
-                    )
-                    length = gr.Number(
-                        value=40,
-                        label="Length of Protein (number of residues)",
-                        precision=0,
-                        minimum=10,
-                        maximum=200
-                    )
+            gr.Markdown("Set up the configuration for your run through a valid yaml file. Choose the number of batches and designs per batch for your run.")
+            config_upload = gr.File(label="Config file: .yaml or .json", file_types=[".pdb", ".yaml", ".json"])
+            num_designs_per_batch = gr.Number(
+                value=2,
+                label="Number of Designs per Batch",
+                precision=0,
+                minimum=1,
+                maximum=8
+            )
+            num_batches= gr.Number(
+                value=5,
+                label="Number of Batches",
+                precision=0,
+                minimum=1,
+                maximum=10
+            )
+
             config_validation_btn = gr.Button("Validate Config")
             config_textbox = gr.Textbox(value ="Waiting for config validation...")
         
         with gr.Column(scale=1):  # Right half
             gr.Markdown("Upload your target/scaffold structure as a PDB file to condition the generation. Press 'No Scaffold/Target' if you want to run an unconditional generation.")
-            with gr.Tabs():
-                with gr.TabItem("Scaffold PDB"):
-                    scaffold_upload = gr.File(label="Target/Scaffold PDB", file_types=[".pdb"])
+            scaffold_upload = gr.File(label="Target/Scaffold PDB", file_types=[".pdb"])
             with gr.Row():
                 scaffold_validation_btn = gr.Button("Validate Scaffold")
                 no_input_btn = gr.Button("No Scaffold/Target")
@@ -105,18 +77,14 @@ with gr.Blocks(title="RFD3 Test") as demo:
     runtextbox = gr.Textbox(value="Waiting for generation run...")
 
 
-    # keep track of which tab is selected to determine whether to use uploaded config or manual config parameters for the generation run
-    upload_tab.select(lambda: "upload", outputs=tab_selected)
-    manual_tab.select(lambda: "manual", outputs=tab_selected)
 
     # validate the configuration
-    config_validation_btn.click(validate_config_ready, inputs=[tab_selected, config_upload, num_designs_per_batch, num_batches, length, num_designs_per_batch_upload, num_batches_upload], outputs=[config_textbox, config_ready])
+    config_validation_btn.click(validate_config_ready, inputs=[config_upload, num_designs_per_batch, num_batches], outputs=[config_textbox, config_ready])
     scaffold_validation_btn.click(validate_scaffold_ready_with_file, inputs=scaffold_upload, outputs=[scaffold_textbox, scaffold_ready])
     no_input_btn.click(lambda: ("No scaffold/target will be used. Ready for unconditional generation!", "no_input"), outputs=[scaffold_textbox, scaffold_ready])
 
     output_file = gr.File(label="Download RFD3 results as zip", visible=True)
-#
-#
+
     # Section to inspect PDB of generated structures
     with gr.Row():
         batch_dropdown = gr.Dropdown(
@@ -134,18 +102,17 @@ with gr.Blocks(title="RFD3 Test") as demo:
     display_state = gr.Textbox(label="Selected Batch and Design", visible=True)
     display_state.value = "Please Select a Batch and Design number to show sequence"
     
-    def generate(config_ready, scaffold_ready, num_batches, num_designs_per_batch, length, config_upload, num_designs_per_batch_upload, num_batches_upload):
+    def generate(config_ready, scaffold_ready, num_batches, num_designs_per_batch, config_upload):
         if config_ready is None or scaffold_ready is None:
             return None, None
         if config_ready == "upload" and scaffold_ready == "no_input":
-            gen_directory, gen_results = unconditional_generation_with_input_config(config_upload, num_batches_upload, num_designs_per_batch_upload)
-            return gen_directory, gen_results
-        if config_ready=="manual" and scaffold_ready=="no_input":
-            gen_directory, gen_results = unconditional_generation(num_batches, num_designs_per_batch, length)
+            gen_directory, gen_results = unconditional_generation_with_input_config(config_upload, num_batches, num_designs_per_batch)
             return gen_directory, gen_results
+        else:
+            return None, None
         
-    run_btn.click(give_run_status, inputs=[config_ready, scaffold_ready, num_batches, num_designs_per_batch, length, config_upload], outputs=runtextbox).then(
-        generate, inputs=[config_ready, scaffold_ready, num_batches, num_designs_per_batch, length, config_upload, num_designs_per_batch_upload, num_batches_upload], outputs=[gen_directory, gen_results]
+    run_btn.click(give_run_status, inputs=[config_ready, scaffold_ready, num_batches, num_designs_per_batch, config_upload], outputs=runtextbox).then(
+        generate, inputs=[config_ready, scaffold_ready, num_batches, num_designs_per_batch, config_upload], outputs=[gen_directory, gen_results]
     ).then(
         update_batch_choices,
         inputs=gen_results,

utils/handle_events.py

@@ -1,5 +1,6 @@
 import gradio as gr
 from utils.handle_files import *
+import os
 
 def update_batch_choices(result):
     """
@@ -58,38 +59,33 @@ def show_pdb(batch, design, result):
     print(pdb_str)
     return gr.update(value=f"Selected Batch: {batch}, Design: {design}, saved at {pdb_path}:\n {pdb_str}", visible=True)
 
-def validate_config_ready(tab_selected, config_upload, num_designs_per_batch, num_batches, length, num_designs_per_batch_upload, num_batches_upload):
+def validate_config_ready(config_upload, num_designs_per_batch, num_batches):
     """
     Once the user presses on the Validate Config button, this function checks whether the config is really ready to go.
-    It is ready, either if the user has selected the manual config tab, or if they have uploaded a config file in the upload config tab and have it open.
+    It is ready if the config file is uploaded and the number of batches and designs per batch are specified.
 
     Parameters:
     ----------
-    tab_selected: str or gr.State
-        takes the value "manual" or "upload" depending on which config tab the user has selected, used to determine whether to check for uploaded config file or not.
+
     config_upload: gr.File
         uploaded config file, is None if no file is uploaded
-    numbers: list of gr.Number
-        list of gr.Number input components for the manual config parameters, used to check that all parameters are filled.
+    num_designs_per_batch: gr.Number
+        number of designs per batch input by the user in the manual config.
+    num_batches: gr.Number
+        number of batches input by the user in the manual config.
 
     Returns:
     -------
     str: message to the user about the status of the config validation
     str: status string. "manual" if manual config is selected and valid, "upload" if upload, and None if config is not ready for generation.
     """
-
-    if tab_selected == "manual":
-        for num in [num_designs_per_batch, num_batches, length]:
+    for num in [num_designs_per_batch, num_batches]:
             if num is None:
                 return "Please fill in all the parameters for manual config to be ready for generation.", None
-        return "Manual parameters selected and valid!", "manual"
-    elif tab_selected == "upload" and config_upload is None:
-        return "Please upload a config file or switch to manual config for uncondition generation.", None
-    elif tab_selected == "upload" and config_upload is not None:
-        for num in [num_designs_per_batch_upload, num_batches_upload]:
-            if num is None:
-                return "Please specify the number of batches and designs per batch for your configuration based on the uploaded config file", None
-        return "Config file uploaded and valid! Number of batches and designs validated!", "upload"
+    if config_upload is None:
+        return "Please upload a config file for the generation to be ready.", None
+    return "Config file uploaded and valid! Number of batches and designs validated!", "upload"
+
     
 def validate_scaffold_ready_with_file(scaffold_upload):
     """
@@ -110,7 +106,7 @@ def validate_scaffold_ready_with_file(scaffold_upload):
     else:
         return "Please upload a scaffold file or press 'No Scaffold/Target' for unconditional generation.", None
     
-def give_run_status(config_ready, scaffold_ready, num_batches, num_designs_per_batch, length, config_upload):
+def give_run_status(config_ready, scaffold_ready, num_batches, num_designs_per_batch, config_upload):
     """
     Once the user presses on the Run Generation button, this function checks whether both config and scaffold are ready, and gives a status message about the generation run that is about to happen. If both config and scaffold are not ready, it prompts the user to ensure they are both validated before running the generation.
 
@@ -137,9 +133,7 @@ def give_run_status(config_ready, scaffold_ready, num_batches, num_designs_per_b
     """
     if config_ready is None or scaffold_ready is None:
         return gr.update(value="Please ensure both config and scaffold are validated before running the generation.")
-    elif config_ready=="manual" and scaffold_ready=="no_input":
-        return gr.update(value=f"Running unconditional generation with minimal configuration: {num_batches} batches of {num_designs_per_batch} designs each, length = {length} aa")
     elif config_ready == "upload" and scaffold_ready == "no_input":
-        return gr.update(value=f"Running unconditional generation with uploaded config file {config_upload}")
+        return gr.update(value=f"Running unconditional generation for {num_batches} batches of {num_designs_per_batch}, config uploaded from file {os.path.basename(config_upload)}")
     else:
         return gr.update(value=f"Not implemented yet")

utils/pipelines.py

@@ -134,8 +134,8 @@ def unconditional_generation_with_input_config(input_file, num_batches, num_desi
             if file_name.endswith(".cif.gz"):
                 terms = file_name.split("_")
                 model_index = terms.index("model")
-                batch =model_index - 1
-                design = model_index + 1
+                batch = int(terms[model_index - 1])
+                design = int(terms[model_index + 1])
                 cif_path = os.path.join(directory, file_name)
                 pdb_path = mcif_gz_to_pdb(cif_path)
                 results.append({"batch": batch, "design": design, "cif_path": cif_path, "pdb_path": pdb_path})