Update app.py

app.py

@@ -9,7 +9,8 @@ import logging
 import numpy as np
 from predictor import GenePredictor
 from tensorflow.keras.models import load_model
-import ml_simplified_tree
+# Import the new analyzer
+from analyzer import PhylogeneticTreeAnalyzer
 import tempfile
 import shutil
 import sys
@@ -83,25 +84,45 @@ try:
 except Exception as e:
     logging.error(f"Failed to load Keras model from HF Hub: {e}")
 
-# --- Initialize Tree Analyzer ---
+# --- Initialize New Tree Analyzer ---
 analyzer = None
 try:
-    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:
-        logging.error(f"CSV file not found: {csv_path}")
+    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
+    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}")
+            
 except Exception as e:
     logging.error(f"Failed to initialize tree analyzer: {e}")
     analyzer = None
@@ -452,70 +473,66 @@ 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
 
-# --- Tree Analysis Function (Based on old Gradio API) ---
-def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> str:
+# --- NEW Tree Analysis Function (Using the new analyzer API) ---
+def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> tuple:
     """
-    Analyze sequence and create phylogenetic tree using the working Gradio API pattern
+    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)
     """
     try:
         if not analyzer:
-            return "Error: Tree analyzer not initialized. Please check if the CSV data file is available."
+            return "❌ Error: Tree analyzer not initialized. Please check if the CSV data file is available.", None
             
         if not sequence:
-            return "Error: Please provide a sequence."
+            return "❌ Error: Please provide a sequence.", None
             
         if not (1 <= matching_percentage <= 99):
-            return "Error: Matching percentage must be between 1 and 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
         
         # Find query sequence
         if not analyzer.find_query_sequence(sequence):
-            return "Error: Invalid query sequence or sequence not found in dataset."
-        
-        # Set matching percentage
-        analyzer.matching_percentage = matching_percentage
+            return "❌ Error: Sequence not accepted.", None
         
         # Find similar sequences
         matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
         
         if not matched_ids:
-            return f"No similar sequences found at {matching_percentage}% similarity. Try lowering the threshold."
+            return f"❌ Error: No similar sequences found at {matching_percentage}% similarity threshold.", None
         
-        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.1f}% similarity")
+        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.2f}% similarity")
         
         # Build tree structure
-        tree_structure = analyzer.build_tree_structure(matched_ids)
-        if not tree_structure:
-            return "Error: Failed to build tree structure."
+        analyzer.build_tree_structure_with_ml_safe(matched_ids)
         
         # 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 output folder
-        output_dir = "output"
-        os.makedirs(output_dir, exist_ok=True)
+        # 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)
         
-        # 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")
+        success_msg = f"✅ Analysis complete! Found {len(matched_ids)} similar sequences with {actual_percentage:.2f}% average similarity."
         
-        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
+        return success_msg, output_path
         
     except Exception as e:
-        error_msg = f"Tree analysis error: {str(e)}"
+        error_msg = f"❌ Error during analysis: {str(e)}"
         logging.error(error_msg)
         import traceback
         logging.error(f"Full traceback: {traceback.format_exc()}")
-        return error_msg
+        return error_msg, None
 
 # --- Keras Prediction ---
 def predict_with_keras(sequence):
@@ -648,7 +665,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: ML Simplified Tree (using the existing approach)
+        # Step 4: NEW Simplified Tree Analysis (using the new analyzer API)
         html_file = None
         tree_html_content = "No tree generated"
         simplified_ml_output = ""
@@ -657,256 +674,270 @@ 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 existing tree analysis function with user-specified similarity
-                tree_result = analyze_sequence_for_tree(processed_sequence, matching_percentage=similarity_score)
+                # Use the new analyze_sequence_for_tree function
+                tree_result, html_path = analyze_sequence_for_tree(processed_sequence, similarity_score)
                 
-                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!"
-                    
-                    # Check if HTML file was created
+                if html_path and os.path.exists(html_path):
+                    # Success - copy the HTML file to a location Gradio can serve
                     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()
+                    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")
+                    
+                    # Copy the HTML file
+                    shutil.copy2(html_path, html_filename)
+                    html_file = html_filename
                     
-                    # 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"
+                    # Read HTML content for display
+                    with open(html_filename, 'r', encoding='utf-8') as f:
+                        tree_html_content = f.read()
                     
+                    simplified_ml_output = tree_result
+                    logging.info(f"Tree analysis completed successfully. HTML saved to: {html_filename}")
                 else:
-                    # Error case
-                    simplified_ml_output = f"❌ Simplified ML tree failed: {tree_result}"
+                    simplified_ml_output = tree_result or "❌ Failed to generate tree visualization"
+                    logging.warning("Tree analysis failed or no HTML output generated")
                     
             except Exception as e:
-                simplified_ml_output = f"❌ Simplified ML tree error: {str(e)}"
-                logging.error(f"Simplified ML tree failed: {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)"
         else:
-            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)"
+            simplified_ml_output = "Tree analysis skipped"
 
         # Prepare final outputs
-        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'}
-"""
-
+        final_boundary_output = f"F gene sequence ({len(processed_sequence)} bp):\n{boundary_output}"
+        final_keras_output = f"F gene validation: {keras_output}"
+        
         logging.info("Pipeline completed successfully")
+        
         return (
-            final_boundary,
-            final_keras, 
-            final_ml_tree,
-            final_simplified_ml,
-            summary,
-            aligned_file,
-            phy_file,
-            html_file,
-            tree_html_content
+            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
         )
         
     except Exception as e:
-        error_msg = f"Pipeline failed: {str(e)}"
+        error_msg = f"Pipeline error: {str(e)}"
         logging.error(error_msg)
-        import traceback
-        logging.error(f"Full traceback: {traceback.format_exc()}")
-        return error_msg, "", "", "", error_msg, None, None, None, "Pipeline error occurred"
+        return error_msg, "", "", "", "", None, None, None, "Pipeline failed"
 
 # --- Gradio Interface ---
 def create_gradio_interface():
-    with gr.Blocks(title="F Gene Analysis Pipeline", theme=gr.themes.Soft()) as iface:
+    """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:
+        
         gr.Markdown("""
         # 🧬 F Gene Analysis Pipeline
         
-        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
+        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
         """)
         
-        with gr.Tab("📝 Text Input"):
+        with gr.Tab("Sequence Analysis"):
             with gr.Row():
-                with gr.Column(scale=2):
-                    dna_input = gr.Textbox(
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input")
+                    
+                    # Input options (simplified to Text Input only)
+                    dna_sequence = gr.Textbox(
                         label="DNA Sequence",
-                        placeholder="Enter your DNA sequence here (FASTA format or raw sequence)...",
+                        placeholder="Enter your DNA sequence here (raw sequence)",
                         lines=8,
-                        max_lines=20
+                        visible=True
                     )
                     
-                with gr.Column(scale=1):
-                    similarity_score = gr.Slider(
-                        minimum=30, 
-                        maximum=100, 
+                    # Parameters
+                    gr.Markdown("### Parameters")
+                    similarity_threshold = gr.Slider(
+                        minimum=50,
+                        maximum=99,
                         value=95,
                         step=1,
-                        label="Similarity Score (%)",
-                        info="Minimum similarity for tree analysis"
+                        label="Similarity Threshold (%)",
+                        info="For phylogenetic tree analysis"
                     )
                     
-                    build_ml_tree = gr.Checkbox(
-                        label="Build ML Tree",
-                        value=True,
-                        info="Perform phylogenetic placement (requires MAFFT + IQ-TREE)"
+                    build_ml_tree_checkbox = gr.Checkbox(
+                        label="Build Maximum Likelihood Tree",
+                        value=False,
+                        info="Requires MAFFT and IQ-TREE (slower but more comprehensive)"
                     )
                     
-                    run_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
-        
-        with gr.Tab("📁 File Input"):
-            with gr.Row():
+                    # Action buttons
+                    analyze_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                
                 with gr.Column(scale=2):
-                    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"
-                    )
+                    gr.Markdown("### Results")
                     
-                    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")
+                    # 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
+                            )
         
-        with gr.Row():
-            with gr.Column():
-                boundary_output = gr.Textbox(
-                    label="🎯 F Gene Extraction",
-                    lines=5,
-                    info="Extracted F gene sequence and boundary predictions"
-                )
-                
-                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"
-            )
         
-        # 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
-                )
+        # 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.Column():
-                html_file_output = gr.File(
-                    label="🎨 Interactive Tree",
-                    visible=True
-                )
-        
-        # Interactive Tree Viewer
-        tree_viewer = gr.HTML(
-            label="🎨 Interactive Tree Visualization",
-            visible=True
-        )
+            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
+            )
         
-        # Event handlers
-        run_btn.click(
-            fn=run_pipeline,
-            inputs=[dna_input, similarity_score, build_ml_tree],
+        # Connect the analyze button
+        analyze_btn.click(
+            fn=run_analysis,
+            inputs=[
+                dna_sequence,
+                similarity_threshold,
+                build_ml_tree_checkbox
+            ],
             outputs=[
                 boundary_output,
                 keras_output,
                 ml_tree_output,
-                simplified_ml_output,
-                summary_output,
-                aligned_file_output,
-                phy_file_output,
-                html_file_output,
-                tree_viewer
+                tree_analysis_output,
+                extracted_sequence,
+                tree_file,
+                html_tree_file,
+                tree_html
             ]
         )
         
-        run_file_btn.click(
-            fn=run_pipeline_from_file,
-            inputs=[fasta_file, similarity_score_file, build_ml_tree_file],
+        # Connect the clear button
+        clear_btn.click(
+            fn=clear_all,
             outputs=[
+                dna_sequence,
+                similarity_threshold,
+                build_ml_tree_checkbox,
                 boundary_output,
                 keras_output,
                 ml_tree_output,
-                simplified_ml_output,
-                summary_output,
-                aligned_file_output,
-                phy_file_output,
-                html_file_output,
-                tree_viewer
+                tree_analysis_output,
+                extracted_sequence,
+                tree_html,
+                tree_file,
+                html_tree_file
             ]
         )
-        
-    return iface
+    
+    return demo
 
-# --- Main Execution ---
+# --- Main Application ---
 if __name__ == "__main__":
-    # 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
-    )
+    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}")