Update app.py

app.py

@@ -9,8 +9,7 @@ import logging
 import numpy as np
 from predictor import GenePredictor
 from tensorflow.keras.models import load_model
-# Import the new analyzer
-from analyzer import PhylogeneticTreeAnalyzer
+import ml_simplified_tree
 import tempfile
 import shutil
 import sys
@@ -84,45 +83,25 @@ try:
 except Exception as e:
     logging.error(f"Failed to load Keras model from HF Hub: {e}")
 
-# --- Initialize New Tree Analyzer ---
+# --- Initialize Tree Analyzer ---
 analyzer = None
 try:
-    analyzer = PhylogeneticTreeAnalyzer()
-    
-    # Try multiple potential locations for the CSV file
-    csv_candidates = [
-        csv_path,
-        os.path.join(BASE_DIR, csv_path),
-        os.path.join(BASE_DIR, "app", csv_path),
-        os.path.join(os.path.dirname(__file__), csv_path),
-        "f_cleaned.csv",  # Alternative naming
-        os.path.join(BASE_DIR, "f_cleaned.csv")
-    ]
-    
-    csv_loaded = False
-    for csv_candidate in csv_candidates:
-        if os.path.exists(csv_candidate):
-            if analyzer.load_data(csv_candidate):
-                logging.info(f"Tree analyzer data loaded from: {csv_candidate}")
-                csv_loaded = True
-                csv_path = csv_candidate  # Update path for consistency
-                break
-            else:
-                logging.warning(f"Failed to load data from: {csv_candidate}")
-    
-    if not csv_loaded:
-        logging.error("Failed to load CSV data from any candidate location")
-        analyzer = None
+    analyzer = ml_simplified_tree.PhylogeneticTreeAnalyzer()
+    if os.path.exists(csv_path):
+        if analyzer.load_data(csv_path):
+            logging.info("Tree analyzer initialized successfully")
+            # Try to train AI model (optional)
+            try:
+                if not analyzer.train_ai_model():
+                    logging.warning("AI model training failed; proceeding with basic analysis.")
+            except Exception as e:
+                logging.warning(f"AI model training failed: {e}")
+        else:
+            logging.error("Failed to load CSV data for tree analyzer")
+            analyzer = None
     else:
-        # Try to train AI model (optional)
-        try:
-            if analyzer.train_ai_model():
-                logging.info("AI model training completed successfully")
-            else:
-                logging.warning("AI model training failed; proceeding with basic analysis.")
-        except Exception as e:
-            logging.warning(f"AI model training failed: {e}")
-            
+        logging.error(f"CSV file not found: {csv_path}")
+        analyzer = None
 except Exception as e:
     logging.error(f"Failed to initialize tree analyzer: {e}")
     analyzer = None
@@ -473,66 +452,70 @@ def build_maximum_likelihood_tree(f_gene_sequence):
         logging.error(f"ML tree construction failed: {e}")
         return False, f"ML tree construction failed: {str(e)}", None, None
 
-# --- NEW Tree Analysis Function (Using the new analyzer API) ---
-def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> tuple:
+# --- Tree Analysis Function (Based on old Gradio API) ---
+def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> str:
     """
-    Analyze sequence and create phylogenetic tree using the new analyzer API
-    
-    Args:
-        sequence (str): DNA sequence to analyze
-        matching_percentage (float): Similarity threshold percentage
-        
-    Returns:
-        tuple: (status_message, html_file_path)
+    Analyze sequence and create phylogenetic tree using the working Gradio API pattern
     """
     try:
         if not analyzer:
-            return "❌ Error: Tree analyzer not initialized. Please check if the CSV data file is available.", None
+            return "Error: Tree analyzer not initialized. Please check if the CSV data file is available."
             
         if not sequence:
-            return "❌ Error: Please provide a sequence.", None
+            return "Error: Please provide a sequence."
             
         if not (1 <= matching_percentage <= 99):
-            return "❌ Error: Matching percentage must be between 1 and 99.", None
-        
-        # Validate inputs
-        sequence = sequence.strip()
-        if len(sequence) < 10:
-            return "❌ Error: Invalid or missing sequence. Must be ≥10 nucleotides.", None
+            return "Error: Matching percentage must be between 1 and 99."
         
         # Find query sequence
         if not analyzer.find_query_sequence(sequence):
-            return "❌ Error: Sequence not accepted.", None
+            return "Error: Invalid query sequence or sequence not found in dataset."
+        
+        # Set matching percentage
+        analyzer.matching_percentage = matching_percentage
         
         # Find similar sequences
         matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
         
         if not matched_ids:
-            return f"❌ Error: No similar sequences found at {matching_percentage}% similarity threshold.", None
+            return f"No similar sequences found at {matching_percentage}% similarity. Try lowering the threshold."
         
-        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.2f}% similarity")
+        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.1f}% similarity")
         
         # Build tree structure
-        analyzer.build_tree_structure_with_ml_safe(matched_ids)
+        tree_structure = analyzer.build_tree_structure(matched_ids)
+        if not tree_structure:
+            return "Error: Failed to build tree structure."
         
         # Create interactive tree
         fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
+        if not fig:
+            return "Error: Failed to create tree visualization."
+        
+        # Generate HTML content
+        html_content = fig.to_html(full_html=True, include_plotlyjs='cdn')
         
-        # Save to temporary file that Gradio can access
-        temp_dir = tempfile.gettempdir()
-        output_path = os.path.join(temp_dir, 'phylogenetic_tree_interactive.html')
-        fig.write_html(output_path)
+        # Save to output folder
+        output_dir = "output"
+        os.makedirs(output_dir, exist_ok=True)
         
-        success_msg = f"✅ Analysis complete! Found {len(matched_ids)} similar sequences with {actual_percentage:.2f}% average similarity."
+        # Create a safe filename
+        safe_seq_name = re.sub(r'[^a-zA-Z0-9]', '_', sequence[:20])
+        html_filename = os.path.join(output_dir, f"tree_{safe_seq_name}_{matching_percentage}.html")
         
-        return success_msg, output_path
+        with open(html_filename, "w", encoding='utf-8') as f:
+            f.write(html_content)
+        
+        logging.info(f"Tree HTML saved to {html_filename}")
+        
+        return html_content
         
     except Exception as e:
-        error_msg = f"❌ Error during analysis: {str(e)}"
+        error_msg = f"Tree analysis error: {str(e)}"
         logging.error(error_msg)
         import traceback
         logging.error(f"Full traceback: {traceback.format_exc()}")
-        return error_msg, None
+        return error_msg
 
 # --- Keras Prediction ---
 def predict_with_keras(sequence):
@@ -665,7 +648,7 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         else:
             ml_tree_output = "Phylogenetic placement skipped (not requested)"
 
-        # Step 4: NEW Simplified Tree Analysis (using the new analyzer API)
+        # Step 4: ML Simplified Tree (using the existing approach)
         html_file = None
         tree_html_content = "No tree generated"
         simplified_ml_output = ""
@@ -674,269 +657,256 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
             try:
                 logging.info(f"Starting simplified ML tree analysis with F gene sequence length: {len(processed_sequence)}")
                 
-                # Use the new analyze_sequence_for_tree function
-                tree_result, html_path = analyze_sequence_for_tree(processed_sequence, similarity_score)
+                # Use the existing tree analysis function with user-specified similarity
+                tree_result = analyze_sequence_for_tree(processed_sequence, matching_percentage=similarity_score)
                 
-                if html_path and os.path.exists(html_path):
-                    # Success - copy the HTML file to a location Gradio can serve
-                    output_dir = "output"
-                    os.makedirs(output_dir, exist_ok=True)
-
-                    # Create a safe filename
-                    safe_seq_name = re.sub(r'[^a-zA-Z0-9]', '_', processed_sequence[:20])
-                    html_filename = os.path.join(output_dir, f"tree_{safe_seq_name}_{uuid.uuid4().hex[:8]}.html")
+                if tree_result and not tree_result.startswith("Error:"):
+                    # Success - find and read the generated HTML file
+                    simplified_ml_output = "✅ Simplified phylogenetic tree generated successfully!"
                     
-                    # Copy the HTML file
-                    shutil.copy2(html_path, html_filename)
-                    html_file = html_filename
+                    # Check if HTML file was created
+                    output_dir = "output"
+                    if os.path.exists(output_dir):
+                        html_files = [f for f in os.listdir(output_dir) if f.endswith('.html')]
+                        if html_files:
+                            html_file = os.path.join(output_dir, html_files[-1])  # Get the latest
+                            simplified_ml_output += f"\n- Tree file: {html_files[-1]}"
+                            # Read the HTML file content for display
+                            with open(html_file, "r", encoding='utf-8') as f:
+                                tree_html_content = f.read()
                     
-                    # Read HTML content for display
-                    with open(html_filename, 'r', encoding='utf-8') as f:
-                        tree_html_content = f.read()
+                    # Count sequences analyzed
+                   
+                    if analyzer.find_query_sequence(processed_sequence):
+                        matched_ids, actual_percentage = analyzer.find_similar_sequences(similarity_score)
+                        simplified_ml_output += f"\n- Found {len(matched_ids)} similar sequences at {actual_percentage:.1f}% similarity"
                     
-                    simplified_ml_output = tree_result
-                    logging.info(f"Tree analysis completed successfully. HTML saved to: {html_filename}")
                 else:
-                    simplified_ml_output = tree_result or "❌ Failed to generate tree visualization"
-                    logging.warning("Tree analysis failed or no HTML output generated")
+                    # Error case
+                    simplified_ml_output = f"❌ Simplified ML tree failed: {tree_result}"
                     
             except Exception as e:
-                simplified_ml_output = f"❌ Simplified ML tree analysis failed: {str(e)}"
-                logging.error(f"Simplified ML tree analysis failed: {e}")
-        elif not analyzer:
-            simplified_ml_output = "❌ Tree analyzer not available (CSV data not loaded)"
-        elif len(processed_sequence) < 10:
-            simplified_ml_output = "❌ Sequence too short for tree analysis (minimum 10 bp)"
+                simplified_ml_output = f"❌ Simplified ML tree error: {str(e)}"
+                logging.error(f"Simplified ML tree failed: {e}")
         else:
-            simplified_ml_output = "Tree analysis skipped"
+            if not analyzer:
+                simplified_ml_output = "❌ Tree analyzer not available (missing CSV data)"
+            else:
+                simplified_ml_output = "❌ F gene sequence too short for tree analysis (minimum 10 bp)"
 
         # Prepare final outputs
-        final_boundary_output = f"F gene sequence ({len(processed_sequence)} bp):\n{boundary_output}"
-        final_keras_output = f"F gene validation: {keras_output}"
-        
+        final_boundary = boundary_output if boundary_output else "No boundary prediction"
+        final_keras = keras_output if keras_output else "No F gene validation"
+        final_ml_tree = ml_tree_output if ml_tree_output else "No phylogenetic placement"
+        final_simplified_ml = simplified_ml_output if simplified_ml_output else "No simplified tree"
+        
+        # Summary
+        summary = f"""
+🧬 PIPELINE SUMMARY:
+- Input sequence: {len(dna_input)} bp
+- F gene extracted: {len(processed_sequence)} bp
+- F gene validation: {final_keras}
+- Phylogenetic placement: {'Completed' if 'successfully' in final_ml_tree else 'Failed/Skipped'}
+- Simplified tree: {'Generated' if 'successfully' in final_simplified_ml else 'Failed/Skipped'}
+"""
+
         logging.info("Pipeline completed successfully")
-        
         return (
-            final_boundary_output,     # Boundary prediction output
-            final_keras_output,        # Keras prediction output  
-            ml_tree_output,           # ML tree output
-            simplified_ml_output,     # Simplified tree output
-            processed_sequence,       # The extracted F gene sequence
-            aligned_file,             # Alignment file path
-            phy_file,                 # Tree file path
-            html_file,                # HTML tree file path
-            tree_html_content         # HTML content for display
+            final_boundary,
+            final_keras, 
+            final_ml_tree,
+            final_simplified_ml,
+            summary,
+            aligned_file,
+            phy_file,
+            html_file,
+            tree_html_content
         )
         
     except Exception as e:
-        error_msg = f"Pipeline error: {str(e)}"
+        error_msg = f"Pipeline failed: {str(e)}"
         logging.error(error_msg)
-        return error_msg, "", "", "", "", None, None, None, "Pipeline failed"
+        import traceback
+        logging.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg, "", "", "", error_msg, None, None, None, "Pipeline error occurred"
 
 # --- Gradio Interface ---
 def create_gradio_interface():
-    """Create and configure the Gradio interface"""
-    
-    with gr.Blocks(
-        title="F Gene Analysis Pipeline",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container {
-            max-width: 1200px !important;
-        }
-        .output-html {
-            height: 600px;
-            overflow: auto;
-        }
-        """
-    ) as demo:
-        
+    with gr.Blocks(title="F Gene Analysis Pipeline", theme=gr.themes.Soft()) as iface:
         gr.Markdown("""
         # 🧬 F Gene Analysis Pipeline
         
-        This tool performs comprehensive analysis of F gene sequences including:
-        - **Gene Boundary Prediction**: Identifies and extracts F gene regions from input sequences
-        - **F Gene Validation**: Validates sequences using ML models
-        - **Phylogenetic Analysis**: Builds phylogenetic trees and performs sequence placement
+        This pipeline performs comprehensive F gene analysis including:
+        - **Boundary Detection**: Extract F gene regions from input sequences
+        - **F Gene Validation**: Validate extracted sequences using deep learning
+        - **Phylogenetic Placement**: Place sequences in reference phylogenetic trees
+        - **Simplified Tree Analysis**: Generate interactive phylogenetic trees
         """)
         
-        with gr.Tab("Sequence Analysis"):
+        with gr.Tab("📝 Text Input"):
             with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### Input")
-                    
-                    # Input options (simplified to Text Input only)
-                    dna_sequence = gr.Textbox(
+                with gr.Column(scale=2):
+                    dna_input = gr.Textbox(
                         label="DNA Sequence",
-                        placeholder="Enter your DNA sequence here (raw sequence)",
+                        placeholder="Enter your DNA sequence here (FASTA format or raw sequence)...",
                         lines=8,
-                        visible=True
+                        max_lines=20
                     )
                     
-                    # Parameters
-                    gr.Markdown("### Parameters")
-                    similarity_threshold = gr.Slider(
-                        minimum=50,
-                        maximum=99,
+                with gr.Column(scale=1):
+                    similarity_score = gr.Slider(
+                        minimum=30, 
+                        maximum=100, 
                         value=95,
                         step=1,
-                        label="Similarity Threshold (%)",
-                        info="For phylogenetic tree analysis"
+                        label="Similarity Score (%)",
+                        info="Minimum similarity for tree analysis"
                     )
                     
-                    build_ml_tree_checkbox = gr.Checkbox(
-                        label="Build Maximum Likelihood Tree",
-                        value=False,
-                        info="Requires MAFFT and IQ-TREE (slower but more comprehensive)"
+                    build_ml_tree = gr.Checkbox(
+                        label="Build ML Tree",
+                        value=True,
+                        info="Perform phylogenetic placement (requires MAFFT + IQ-TREE)"
                     )
                     
-                    # Action buttons
-                    analyze_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                
+                    run_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
+        
+        with gr.Tab("📁 File Input"):
+            with gr.Row():
                 with gr.Column(scale=2):
-                    gr.Markdown("### Results")
+                    fasta_file = gr.File(
+                        label="Upload FASTA File",
+                        file_types=[".fasta", ".fa", ".fas", ".txt"]
+                    )
+                    
+                with gr.Column(scale=1):
+                    similarity_score_file = gr.Slider(
+                        minimum=70, 
+                        maximum=99, 
+                        value=95,
+                        step=1,
+                        label="Similarity Score (%)",
+                        info="Minimum similarity for tree analysis"
+                    )
                     
-                    # Output tabs
-                    with gr.Tabs():
-                        with gr.Tab("Gene Prediction"):
-                            boundary_output = gr.Textbox(
-                                label="F Gene Boundary Prediction",
-                                lines=8,
-                                interactive=False
-                            )
-                            
-                            keras_output = gr.Textbox(
-                                label="F Gene Validation",
-                                lines=3,
-                                interactive=False
-                            )
-                        
-                        with gr.Tab("Phylogenetic Tree"):
-                            ml_tree_output = gr.Textbox(
-                                label="Maximum Likelihood Tree Status",
-                                lines=8,
-                                interactive=False
-                            )
-                            
-                            tree_analysis_output = gr.Textbox(
-                                label="Tree Analysis Status",
-                                lines=4,
-                                interactive=False
-                            )
-                            
-                            # Tree visualization
-                            tree_html = gr.HTML(
-                                label="Interactive Phylogenetic Tree",
-                                elem_classes=["output-html"]
-                            )
-                        
-                        with gr.Tab("Sequence Output"):
-                            extracted_sequence = gr.Textbox(
-                                label="Extracted F Gene Sequence",
-                                lines=10,
-                                interactive=False,
-                                info="The F gene sequence extracted by the boundary model"
-                            )
-                        
-                        with gr.Tab("Download Files"):
-                            tree_file = gr.File(
-                                label="Tree File",
-                                interactive=False
-                            )
-                            
-                            html_tree_file = gr.File(
-                                label="Interactive Tree (HTML)",
-                                interactive=False
-                            )
+                    build_ml_tree_file = gr.Checkbox(
+                        label="Build ML Tree",
+                        value=True,
+                        info="Perform phylogenetic placement (requires MAFFT + IQ-TREE)"
+                    )
+                    
+                    run_file_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
         
+        # Results Section
+        gr.Markdown("## 📊 Results")
         
-        # Event handlers
-        def run_analysis(dna_seq, similarity, build_ml):
-            """Main analysis function"""
-            try:
-                if not dna_seq or not dna_seq.strip():
-                    return ("❌ Please provide a DNA sequence", "", "", "", "", None, None, None, "No input provided")
-                results = run_pipeline(dna_seq, similarity, build_ml)
-                return results
+        with gr.Row():
+            with gr.Column():
+                boundary_output = gr.Textbox(
+                    label="🎯 F Gene Extraction",
+                    lines=5,
+                    info="Extracted F gene sequence and boundary predictions"
+                )
                 
-            except Exception as e:
-                error_msg = f"Analysis failed: {str(e)}"
-                logging.error(error_msg)
-                return (error_msg, "", "", "", "", None, None, None, "Analysis failed")
-        
-        def clear_all():
-            """Clear all inputs and outputs"""
-            return (
-                "",  # dna_sequence
-                95,  # similarity_threshold
-                False,  # build_ml_tree_checkbox
-                "",  # boundary_output
-                "",  # keras_output
-                "",  # ml_tree_output
-                "",  # tree_analysis_output
-                "",  # extracted_sequence
-                "",  # tree_html
-                None,  # tree_file
-                None,  # html_tree_file
+                keras_output = gr.Textbox(
+                    label="🔍 F Gene Validation",
+                    lines=2,
+                    info="Deep learning validation of F gene authenticity"
+                )
+            
+            with gr.Column():
+                ml_tree_output = gr.Textbox(
+                    label="🌳 Phylogenetic Placement",
+                    lines=5,
+                    info="Maximum likelihood phylogenetic placement results"
+                )
+                
+                simplified_ml_output = gr.Textbox(
+                    label="🌲 Simplified Tree Analysis",
+                    lines=5,
+                    info="Interactive phylogenetic tree generation"
+                )
+        
+        # Summary and Downloads
+        with gr.Row():
+            summary_output = gr.Textbox(
+                label="📋 Analysis Summary",
+                lines=8,
+                info="Overview of all analysis steps and results"
             )
         
-        # Connect the analyze button
-        analyze_btn.click(
-            fn=run_analysis,
-            inputs=[
-                dna_sequence,
-                similarity_threshold,
-                build_ml_tree_checkbox
-            ],
+        # File Downloads
+        with gr.Row():
+            with gr.Column():
+                aligned_file_output = gr.File(
+                    label="📄 Alignment File",
+                    visible=True
+                )
+                
+            with gr.Column():
+                phy_file_output = gr.File(
+                    label="🌳 Tree File",
+                    visible=True
+                )
+                
+            with gr.Column():
+                html_file_output = gr.File(
+                    label="🎨 Interactive Tree",
+                    visible=True
+                )
+        
+        # Interactive Tree Viewer
+        tree_viewer = gr.HTML(
+            label="🎨 Interactive Tree Visualization",
+            visible=True
+        )
+        
+        # Event handlers
+        run_btn.click(
+            fn=run_pipeline,
+            inputs=[dna_input, similarity_score, build_ml_tree],
             outputs=[
                 boundary_output,
                 keras_output,
                 ml_tree_output,
-                tree_analysis_output,
-                extracted_sequence,
-                tree_file,
-                html_tree_file,
-                tree_html
+                simplified_ml_output,
+                summary_output,
+                aligned_file_output,
+                phy_file_output,
+                html_file_output,
+                tree_viewer
             ]
         )
         
-        # Connect the clear button
-        clear_btn.click(
-            fn=clear_all,
+        run_file_btn.click(
+            fn=run_pipeline_from_file,
+            inputs=[fasta_file, similarity_score_file, build_ml_tree_file],
             outputs=[
-                dna_sequence,
-                similarity_threshold,
-                build_ml_tree_checkbox,
                 boundary_output,
                 keras_output,
                 ml_tree_output,
-                tree_analysis_output,
-                extracted_sequence,
-                tree_html,
-                tree_file,
-                html_tree_file
+                simplified_ml_output,
+                summary_output,
+                aligned_file_output,
+                phy_file_output,
+                html_file_output,
+                tree_viewer
             ]
         )
-    
-    return demo
+        
+    return iface
 
-# --- Main Application ---
+# --- Main Execution ---
 if __name__ == "__main__":
-    try:
-        # Initialize the Gradio interface
-        demo = create_gradio_interface()
-        
-        # Launch the application
-        demo.queue(max_size=10)  # Enable queuing for long-running tasks
-        demo.launch(
-            server_name="0.0.0.0",  # Allow external connections
-            server_port=7860,       # Default port
-            share=False,            # Set to True to create public link
-            debug=True,             # Enable debug mode
-            show_error=True         # Show detailed error messages
-        )
-        
-    except Exception as e:
-        logging.error(f"Failed to launch application: {e}")
-        print(f"❌ Application failed to start: {e}")
+    # Initialize the interface
+    interface = create_gradio_interface()
+    
+    # Launch with appropriate settings
+    interface.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,        # Default Gradio port
+        share=False,             # Set to True for public sharing
+        debug=True,              # Enable debug mode for development
+        show_error=True,         # Show detailed error messages
+        max_threads=4            # Limit concurrent threads
+    )