Create app.py

app.py

@@ -0,0 +1,370 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+from Bio import SeqIO
+from Bio.Seq import Seq # Though not directly used in final logic, good for context
+from Bio.Restriction import RestrictionBatch, AllEnzymes, Analysis
+import os # For getting filename
+
+# Ensure matplotlib uses a non-interactive backend for Gradio
+import matplotlib
+matplotlib.use('Agg')
+
+# --- Core BioPython and Plotting Functions ---
+
+def simulate_digest_and_plot_gradio(plasmid_seq_record, enzyme_name, plasmid_label):
+    """
+    Simulates restriction digest and plots a virtual agarose gel.
+    Uses enzyme.catalyse() for robust fragment generation.
+    """
+    fig, ax = plt.subplots(figsize=(6, 8)) # Adjusted size for better readability
+
+    try:
+        # enzyme_name is a string, get the Biopython enzyme object
+        enzyme = AllEnzymes.get(str(enzyme_name)) # Ensure enzyme_name is string
+        if not enzyme:
+            raise ValueError(f"Enzyme '{enzyme_name}' not found in Biopython's AllEnzymes.")
+    except Exception as e:
+        ax.text(0.5, 0.5, f"Error: Could not load enzyme '{enzyme_name}'.\n{e}",
+                ha='center', va='center', wrap=True, color='red')
+        ax.set_xticks([]); ax.set_yticks([])
+        ax.set_title(f"Virtual Gel: {plasmid_label} - Error", fontsize=10)
+        plt.tight_layout()
+        return fig
+
+    # Use enzyme.catalyse() to get fragments directly
+    fragments_seqs = enzyme.catalyse(plasmid_seq_record.seq)
+    
+    is_uncut = False
+    if len(fragments_seqs) == 1 and len(fragments_seqs[0]) == len(plasmid_seq_record.seq):
+        # Further check: does the enzyme actually have sites?
+        # If catalyse returns the original sequence, it might be circular and cut once,
+        # or linear and uncut, or truly no sites.
+        if not enzyme.search(plasmid_seq_record.seq):
+            is_uncut = True
+
+    if is_uncut:
+        ax.text(0.5, 0.5, f"Enzyme {enzyme_name} does not cut {plasmid_label}",
+                ha='center', va='center', wrap=True)
+        ax.set_title(f"Virtual Gel: {plasmid_label} + {enzyme_name} (No Sites)", fontsize=10)
+        # Still show the uncut plasmid band
+        lengths = [len(plasmid_seq_record.seq)]
+    else:
+        lengths = sorted([len(f) for f in fragments_seqs], reverse=True)
+
+    ax.set_yscale("log")
+    
+    min_display_size = 10 # bp
+    plasmid_len_for_scale = max(len(plasmid_seq_record.seq), min_display_size * 10) # Ensure decent scale range
+    # Ensure max_display_size is greater than min_display_size
+    max_display_size = max(plasmid_len_for_scale * 1.1, min_display_size * 2) 
+
+    ax.set_ylim(min_display_size, max_display_size)
+    
+    band_width = 0.6
+    lane_center = 0.5
+
+    if not lengths: # Should not happen if is_uncut is handled
+        ax.text(0.5, 0.5, "No fragments to display.", ha='center', va='center')
+    else:
+        for i, size in enumerate(lengths):
+            if size < min_display_size:
+                ax.text(lane_center, min_display_size * 1.1 , f"(+ {len(lengths) - i} small fragments < {min_display_size}bp not shown)", 
+                        ha='center', va='top', fontsize=7, color='gray')
+                break 
+            ax.plot([lane_center - band_width/2, lane_center + band_width/2], [size, size], 
+                    linewidth=6, color='royalblue', solid_capstyle='butt')
+            ax.text(lane_center + band_width/2 + 0.05, size, f"{size} bp", 
+                    va='center', ha='left', fontsize=8)
+
+    ax.invert_yaxis()
+    ax.set_title(f"Virtual Gel: {plasmid_label} digested with {enzyme_name}", fontsize=10)
+    ax.set_ylabel("Fragment Size (bp)", fontsize=9)
+    ax.set_xlabel("Lane 1", fontsize=9) # Indicate it's one lane
+    ax.set_xticks([]) # No x-axis ticks for a single lane view
+    ax.tick_params(axis='y', labelsize=8)
+
+    # Draw well at the top (after y-axis inversion)
+    # The y-axis top is effectively max_display_size after inversion.
+    well_top_y = ax.get_ylim()[0] # This is the largest value on the y-axis (top of inverted plot)
+    
+    # Draw well slightly above the max data point or at the very top
+    well_line_y = well_top_y * 1.01 # Position for the horizontal line of the well
+    well_depth_y = well_top_y * 0.98 # Bottom of the well sides (relative depth)
+
+    ax.plot([lane_center - band_width/1.5, lane_center + band_width/1.5], [well_line_y, well_line_y], 
+            linewidth=1.5, color='black') # Top line of well
+    ax.plot([lane_center - band_width/1.5, lane_center - band_width/1.5], [well_line_y, well_depth_y], 
+            linewidth=1.5, color='black') # Left side of well
+    ax.plot([lane_center + band_width/1.5, lane_center + band_width/1.5], [well_line_y, well_depth_y], 
+            linewidth=1.5, color='black') # Right side of well
+
+    plt.tight_layout(pad=1.5)
+    return fig
+
+def analyze_plasmids_gradio(file1_path, file2_path, current_plasmid_choice_for_plot):
+    """
+    Analyzes two plasmid files to find unique restriction enzymes.
+    Returns status messages, plasmid data, lists of unique enzyme names,
+    and an update for the enzyme selection dropdown.
+    """
+    initial_enzyme_dd_update = gr.update(choices=["Analyze plasmids first"], value="Analyze plasmids first", interactive=False)
+
+    if file1_path is None or file2_path is None:
+        return "Error: Please upload both plasmid files.", "", "", None, None, [], [], initial_enzyme_dd_update
+
+    try:
+        # file_path is already a string (path to temp file) when type="filepath"
+        def read_plasmid(filepath, filename_for_error):
+            try:
+                return SeqIO.read(filepath, "genbank")
+            except Exception: # Broad exception for parsing
+                try:
+                    return SeqIO.read(filepath, "fasta")
+                except Exception as e_fasta:
+                    # More specific error message
+                    raise ValueError(f"Could not parse '{filename_for_error}'. Ensure it's a valid GenBank or FASTA file. Last error: {e_fasta}")
+        
+        # Get original filenames for messages
+        p1_orig_filename = os.path.basename(file1_path)
+        p2_orig_filename = os.path.basename(file2_path)
+
+        plasmid1_seq_rec = read_plasmid(file1_path, p1_orig_filename)
+        plasmid2_seq_rec = read_plasmid(file2_path, p2_orig_filename)
+
+    except Exception as e:
+        return str(e), "", "", None, None, [], [], initial_enzyme_dd_update
+
+    # Filter for valid enzymes from AllEnzymes
+    # Some entries in AllEnzymes might be None or lack necessary attributes
+    valid_enzyme_objects = []
+    for enz_name in AllEnzymes.elements(): # Iterate over names to get objects
+        enzyme_obj = AllEnzymes.get(enz_name)
+        if enzyme_obj and hasattr(enzyme_obj, 'site') and enzyme_obj.site is not None:
+             # Further check if it's a real enzyme, not a category like 'Commercial'
+            if hasattr(enzyme_obj, 'is_restriction') and enzyme_obj.is_restriction():
+                valid_enzyme_objects.append(enzyme_obj)
+            elif not hasattr(enzyme_obj, 'is_restriction'): # If it doesn't have this, assume it's a basic enzyme type
+                 valid_enzyme_objects.append(enzyme_obj)
+
+
+    if not valid_enzyme_objects:
+         return "Error: Could not load any restriction enzymes from Biopython.", "", "", None, None, [], [], initial_enzyme_dd_update
+
+    enzymes_batch = RestrictionBatch(valid_enzyme_objects)
+
+    # Assuming circular plasmids, common for this type of analysis
+    analysis1 = Analysis(enzymes_batch, plasmid1_seq_rec.seq, linear=False)
+    analysis2 = Analysis(enzymes_batch, plasmid2_seq_rec.seq, linear=False)
+
+    enzymes_cutting_p1 = set(analysis1.with_sites().keys())
+    enzymes_cutting_p2 = set(analysis2.with_sites().keys())
+
+    unique_to_1_obj = sorted(list(enzymes_cutting_p1 - enzymes_cutting_p2), key=lambda e: str(e))
+    unique_to_2_obj = sorted(list(enzymes_cutting_p2 - enzymes_cutting_p1), key=lambda e: str(e))
+
+    unique_to_1_names = [str(e) for e in unique_to_1_obj]
+    unique_to_2_names = [str(e) for e in unique_to_2_obj]
+    
+    p1_display_label = f"Plasmid 1 ({p1_orig_filename})"
+    p2_display_label = f"Plasmid 2 ({p2_orig_filename})"
+
+    msg1 = f"Enzymes cutting only {p1_display_label} ({len(unique_to_1_names)}):\n" + ", ".join(unique_to_1_names) if unique_to_1_names else f"No unique enzymes found for {p1_display_label}."
+    msg2 = f"Enzymes cutting only {p2_display_label} ({len(unique_to_2_names)}):\n" + ", ".join(unique_to_2_names) if unique_to_2_names else f"No unique enzymes found for {p2_display_label}."
+    
+    status = "Analysis complete."
+    if not unique_to_1_names and not unique_to_2_names:
+        status += " No enzymes found that uniquely cut only one of the plasmids."
+    
+    # Determine initial choices for the enzyme dropdown based on current_plasmid_choice_for_plot
+    # current_plasmid_choice_for_plot is "Plasmid 1" or "Plasmid 2"
+    dd_choices = []
+    if current_plasmid_choice_for_plot == "Plasmid 1":
+        dd_choices = unique_to_1_names if unique_to_1_names else [f"No unique enzymes for {p1_display_label}"]
+    else: # Plasmid 2
+        dd_choices = unique_to_2_names if unique_to_2_names else [f"No unique enzymes for {p2_display_label}"]
+
+    if (current_plasmid_choice_for_plot == "Plasmid 1" and unique_to_1_names) or \
+       (current_plasmid_choice_for_plot == "Plasmid 2" and unique_to_2_names):
+        initial_enzyme_dd_update = gr.update(choices=["Select an enzyme"] + dd_choices, value="Select an enzyme", interactive=True)
+    else:
+        initial_enzyme_dd_update = gr.update(choices=dd_choices, value=dd_choices[0], interactive=False if not dd_choices or "No unique" in dd_choices[0] else True)
+        
+    return status, msg1, msg2, plasmid1_seq_rec, plasmid2_seq_rec, unique_to_1_names, unique_to_2_names, initial_enzyme_dd_update
+
+def plot_selected_digest_controller(plasmid_choice_label, enzyme_name, p1_data, p2_data):
+    """
+    Controller to select the correct plasmid data and call the plotting function.
+    """
+    fig_placeholder, ax_placeholder = plt.subplots(figsize=(6, 8))
+    ax_placeholder.text(0.5, 0.5, "Plot will appear here.", ha='center', va='center')
+    ax_placeholder.set_xticks([]); ax_placeholder.set_yticks([])
+    plt.tight_layout()
+
+    if not enzyme_name or enzyme_name == "Select an enzyme" or "No unique enzymes" in enzyme_name or "Analyze plasmids first" in enzyme_name:
+        ax_placeholder.clear()
+        ax_placeholder.text(0.5, 0.5, "Please select a valid plasmid and enzyme after analysis.", ha='center', va='center', wrap=True)
+        ax_placeholder.set_xticks([]); ax_placeholder.set_yticks([])
+        plt.tight_layout()
+        return fig_placeholder
+    
+    target_plasmid_rec = None
+    target_label = ""
+
+    if plasmid_choice_label == "Plasmid 1":
+        if p1_data is None:
+            ax_placeholder.clear()
+            ax_placeholder.text(0.5, 0.5, "Plasmid 1 data not loaded. Please re-analyze.", ha='center', va='center', wrap=True, color='red')
+            ax_placeholder.set_xticks([]); ax_placeholder.set_yticks([])
+            plt.tight_layout()
+            return fig_placeholder
+        target_plasmid_rec = p1_data
+        target_label = "Plasmid 1"
+        if hasattr(p1_data, 'name') and p1_data.name: target_label += f" ({p1_data.name})"
+        elif hasattr(p1_data, 'id') and p1_data.id: target_label += f" ({p1_data.id})"
+
+
+    elif plasmid_choice_label == "Plasmid 2":
+        if p2_data is None:
+            ax_placeholder.clear()
+            ax_placeholder.text(0.5, 0.5, "Plasmid 2 data not loaded. Please re-analyze.", ha='center', va='center', wrap=True, color='red')
+            ax_placeholder.set_xticks([]); ax_placeholder.set_yticks([])
+            plt.tight_layout()
+            return fig_placeholder
+        target_plasmid_rec = p2_data
+        target_label = "Plasmid 2"
+        if hasattr(p2_data, 'name') and p2_data.name: target_label += f" ({p2_data.name})"
+        elif hasattr(p2_data, 'id') and p2_data.id: target_label += f" ({p2_data.id})"
+    
+    else: # Should not happen
+        ax_placeholder.clear()
+        ax_placeholder.text(0.5, 0.5, "Invalid plasmid selection.", ha='center', va='center', wrap=True, color='red')
+        ax_placeholder.set_xticks([]); ax_placeholder.set_yticks([])
+        plt.tight_layout()
+        return fig_placeholder
+
+    return simulate_digest_and_plot_gradio(target_plasmid_rec, enzyme_name, target_label)
+
+def update_enzyme_dropdown_choices_on_radio_change(plasmid_choice_label, p1_enzyme_names, p2_enzyme_names):
+    """
+    Updates the enzyme dropdown choices when the plasmid selection radio button changes.
+    """
+    if plasmid_choice_label == "Plasmid 1":
+        choices = p1_enzyme_names if p1_enzyme_names else ["No unique enzymes for P1"]
+        if p1_enzyme_names: # If there are actual enzymes
+            return gr.update(choices=["Select an enzyme"] + choices, value="Select an enzyme", interactive=True)
+        return gr.update(choices=choices, value=choices[0], interactive=False) # No unique enzymes, so not interactive
+    
+    elif plasmid_choice_label == "Plasmid 2":
+        choices = p2_enzyme_names if p2_enzyme_names else ["No unique enzymes for P2"]
+        if p2_enzyme_names: # If there are actual enzymes
+            return gr.update(choices=["Select an enzyme"] + choices, value="Select an enzyme", interactive=True)
+        return gr.update(choices=choices, value=choices[0], interactive=False) # No unique enzymes, so not interactive
+    
+    return gr.update(choices=[], value=None, interactive=False) # Fallback, should not be reached
+
+
+# --- Gradio Interface Definition ---
+with gr.Blocks(theme=gr.themes.Default()) as demo:
+    gr.Markdown("# Plasmid Restriction Digest Analyzer & Virtual Gel")
+    gr.Markdown(
+        "**Instructions:**\n"
+        "1. Upload two plasmid sequence files (GenBank `.gb`/`.gbk` or FASTA `.fasta`/`.fna`/`.fa` format).\n"
+        "2. Click `Analyze Plasmids`. Results will show enzymes that uniquely cut one plasmid but not the other.\n"
+        "3. Select which plasmid's unique enzymes you want to consider for plotting.\n"
+        "4. Choose a specific enzyme from the dropdown list.\n"
+        "5. Click `Generate Gel Plot` to visualize the digestion pattern."
+    )
+
+    # States to store full plasmid SeqRecord objects and lists of unique enzyme names
+    plasmid1_data_state = gr.State()
+    plasmid2_data_state = gr.State()
+    p1_unique_enzymes_list_state = gr.State([]) # Stores list of names for P1 unique enzymes
+    p2_unique_enzymes_list_state = gr.State([]) # Stores list of names for P2 unique enzymes
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 1. Upload Plasmids & Analyze")
+            file_p1 = gr.File(label="Plasmid 1 File", type="filepath", file_types=[".gb", ".gbk", ".fasta", ".fna", ".fa"])
+            file_p2 = gr.File(label="Plasmid 2 File", type="filepath", file_types=[".gb", ".gbk", ".fasta", ".fna", ".fa"])
+            
+            # Hidden component to pass the current plasmid choice to the analysis function
+            # This helps initialize the enzyme dropdown correctly after analysis
+            _current_plasmid_choice_for_plot_hidden = gr.Textbox(value="Plasmid 1", visible=False)
+
+            analyze_btn = gr.Button("Analyze Plasmids", variant="primary", elem_id="analyze_button")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### Analysis Results")
+            status_message_txt = gr.Textbox(label="Status", interactive=False, lines=1, max_lines=2)
+            unique_enzymes_p1_txt = gr.Textbox(label="Enzymes cutting only Plasmid 1", interactive=False, lines=3, max_lines=6)
+            unique_enzymes_p2_txt = gr.Textbox(label="Enzymes cutting only Plasmid 2", interactive=False, lines=3, max_lines=6)
+
+    gr.Markdown("---")
+    gr.Markdown("### 2. Visualize Digestion on Virtual Gel")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            plasmid_to_plot_choice_radio = gr.Radio(
+                choices=["Plasmid 1", "Plasmid 2"], 
+                label="Select Plasmid for Gel Visualization",
+                value="Plasmid 1", # Default choice
+                interactive=True
+            )
+            
+            enzyme_for_plot_dropdown = gr.Dropdown(
+                label="Select Unique Enzyme", 
+                choices=["Analyze plasmids first"], 
+                value="Analyze plasmids first",
+                interactive=False # Initially not interactive until analysis is done
+            )
+            plot_btn = gr.Button("Generate Gel Plot", variant="primary", elem_id="plot_button")
+
+        with gr.Column(scale=2):
+            gel_plot_output = gr.Plot(label="Virtual Agarose Gel")
+    
+    gr.Markdown("---")
+    gr.Markdown("Developed using Biopython, Matplotlib, and Gradio.")
+    gr.Markdown("Note: Large plasmid files or complex analyses might take a few moments.")
+
+
+    # --- Event Handlers ---
+
+    # Update the hidden textbox when radio button changes
+    plasmid_to_plot_choice_radio.change(
+        fn=lambda x: x, 
+        inputs=[plasmid_to_plot_choice_radio], 
+        outputs=[_current_plasmid_choice_for_plot_hidden]
+    )
+    
+    # When Analyze button is clicked:
+    analyze_btn.click(
+        fn=analyze_plasmids_gradio,
+        inputs=[file_p1, file_p2, _current_plasmid_choice_for_plot_hidden], # Pass current radio choice
+        outputs=[
+            status_message_txt, 
+            unique_enzymes_p1_txt, 
+            unique_enzymes_p2_txt,
+            plasmid1_data_state, # Store full plasmid SeqRecord data
+            plasmid2_data_state, # Store full plasmid SeqRecord data
+            p1_unique_enzymes_list_state, 
+            p2_unique_enzymes_list_state, 
+            enzyme_for_plot_dropdown # Update dropdown based on analysis and radio choice
+        ]
+    )
+
+    # When plasmid choice (Radio) changes AFTER analysis, update the enzyme dropdown:
+    plasmid_to_plot_choice_radio.change(
+        fn=update_enzyme_dropdown_choices_on_radio_change,
+        inputs=[plasmid_to_plot_choice_radio, p1_unique_enzymes_list_state, p2_unique_enzymes_list_state],
+        outputs=[enzyme_for_plot_dropdown]
+    )
+
+    # When Plot button is clicked:
+    plot_btn.click(
+        fn=plot_selected_digest_controller,
+        inputs=[plasmid_to_plot_choice_radio, enzyme_for_plot_dropdown, plasmid1_data_state, plasmid2_data_state],
+        outputs=[gel_plot_output]
+    )
+
+if __name__ == '__main__':
+    demo.launch()