Update app.py

app.py

@@ -13,6 +13,8 @@ from tensorflow.keras.models import load_model
 import ml_simplified_tree
 import tempfile
 import shutil
+import sys
+from pathlib import Path
 
 # --- Global Variables ---
 MAFFT_PATH = "mafft/mafftdir/bin/mafft"  # Update this path as needed
@@ -97,31 +99,102 @@ except Exception as e:
     logging.error(f"Failed to initialize tree analyzer: {e}")
     analyzer = None
 
-# --- Helper Functions ---
+# --- Enhanced Tool Detection ---
 def check_tool_availability():
-    """Check if MAFFT and IQ-TREE are available"""
-    mafft_available = os.path.exists(MAFFT_PATH) or shutil.which('mafft') is not None
-    iqtree_available = os.path.exists(IQTREE_PATH) or shutil.which('iqtree2') is not None or shutil.which('iqtree') is not None
+    """Enhanced check for MAFFT and IQ-TREE availability with multiple fallback options"""
     
-    return mafft_available, iqtree_available
+    # Check MAFFT
+    mafft_available = False
+    mafft_cmd = None
+    
+    # Try multiple MAFFT locations
+    mafft_candidates = [
+        MAFFT_PATH,
+        'mafft',
+        '/usr/bin/mafft',
+        '/usr/local/bin/mafft',
+        'mafft.bat',  # Windows
+    ]
+    
+    for candidate in mafft_candidates:
+        if candidate and (os.path.exists(candidate) or shutil.which(candidate) is not None):
+            mafft_available = True
+            mafft_cmd = candidate
+            logging.info(f"Found MAFFT at: {candidate}")
+            break
+    
+    # Check IQ-TREE
+    iqtree_available = False
+    iqtree_cmd = None
+    
+    # Try multiple IQ-TREE locations and names
+    iqtree_candidates = [
+        IQTREE_PATH,
+        'iqtree2',
+        'iqtree',
+        '/usr/bin/iqtree2',
+        '/usr/local/bin/iqtree2',
+        '/usr/bin/iqtree',
+        '/usr/local/bin/iqtree',
+        'iqtree2.exe',  # Windows
+        'iqtree.exe',   # Windows
+    ]
+    
+    for candidate in iqtree_candidates:
+        if candidate and (os.path.exists(candidate) or shutil.which(candidate) is not None):
+            iqtree_available = True
+            iqtree_cmd = candidate
+            logging.info(f"Found IQ-TREE at: {candidate}")
+            break
+    
+    return mafft_available, iqtree_available, mafft_cmd, iqtree_cmd
+
+def install_dependencies_guide():
+    """Provide installation guidance for missing dependencies"""
+    guide = """
+🔧 INSTALLATION GUIDE FOR MISSING DEPENDENCIES:
 
-def run_mafft_alignment(input_fasta, output_fasta):
-    """Run MAFFT alignment on input FASTA file"""
+For MAFFT:
+- Ubuntu/Debian: sudo apt-get install mafft
+- CentOS/RHEL: sudo yum install mafft
+- macOS: brew install mafft
+- Windows: Download from https://mafft.cbrc.jp/alignment/software/
+
+For IQ-TREE:
+- Ubuntu/Debian: sudo apt-get install iqtree
+- CentOS/RHEL: sudo yum install iqtree
+- macOS: brew install iqtree
+- Windows: Download from http://www.iqtree.org/
+
+Alternative: Use conda/mamba:
+- conda install -c bioconda mafft iqtree
+
+Docker option:
+- docker run -it --rm -v $(pwd):/data quay.io/biocontainers/mafft:7.490--h779adbc_0
+- docker run -it --rm -v $(pwd):/data quay.io/biocontainers/iqtree:2.1.4_beta--hdcc8f71_0
+"""
+    return guide
+
+def run_mafft_alignment(input_fasta, output_fasta, mafft_cmd):
+    """Run MAFFT alignment with enhanced error handling"""
     try:
-        # Check if MAFFT is available
-        mafft_cmd = MAFFT_PATH if os.path.exists(MAFFT_PATH) else 'mafft'
-        
-        # MAFFT command
-        cmd = [mafft_cmd, '--auto', input_fasta]
+        # MAFFT command with more robust options
+        cmd = [
+            mafft_cmd,
+            '--auto',  # Automatic strategy selection
+            '--quiet',  # Reduce output verbosity
+            input_fasta
+        ]
         
         logging.info(f"Running MAFFT: {' '.join(cmd)}")
         
-        # Run MAFFT
+        # Run MAFFT with enhanced error handling
         result = subprocess.run(
             cmd,
             capture_output=True,
             text=True,
-            timeout=300  # 5 minute timeout
+            timeout=600,  # Increased timeout to 10 minutes
+            cwd=os.getcwd()  # Ensure working directory is set
         )
         
         if result.returncode == 0:
@@ -129,72 +202,105 @@ def run_mafft_alignment(input_fasta, output_fasta):
             with open(output_fasta, 'w') as f:
                 f.write(result.stdout)
             logging.info(f"MAFFT alignment completed: {output_fasta}")
-            return True, output_fasta
+            
+            # Verify output file
+            if os.path.exists(output_fasta) and os.path.getsize(output_fasta) > 0:
+                return True, output_fasta
+            else:
+                return False, "MAFFT completed but output file is empty"
         else:
-            logging.error(f"MAFFT failed: {result.stderr}")
-            return False, f"MAFFT error: {result.stderr}"
+            error_msg = result.stderr.strip() if result.stderr else "Unknown MAFFT error"
+            logging.error(f"MAFFT failed: {error_msg}")
+            return False, f"MAFFT error: {error_msg}"
             
     except subprocess.TimeoutExpired:
         logging.error("MAFFT timeout")
-        return False, "MAFFT timeout (>5 minutes)"
+        return False, "MAFFT timeout (>10 minutes). Try with fewer sequences."
+    except FileNotFoundError:
+        return False, f"MAFFT executable not found: {mafft_cmd}"
     except Exception as e:
         logging.error(f"MAFFT execution failed: {e}")
         return False, f"MAFFT execution failed: {str(e)}"
 
-def run_iqtree_analysis(aligned_fasta, output_prefix):
-    """Run IQ-TREE maximum likelihood analysis"""
+def run_iqtree_analysis(aligned_fasta, output_prefix, iqtree_cmd):
+    """Run IQ-TREE with enhanced options and error handling"""
     try:
-        # Check if IQ-TREE is available
-        if os.path.exists(IQTREE_PATH):
-            iqtree_cmd = IQTREE_PATH
-        elif shutil.which('iqtree2') is not None:
-            iqtree_cmd = 'iqtree2'
-        elif shutil.which('iqtree') is not None:
-            iqtree_cmd = 'iqtree'
-        else:
-            return False, "IQ-TREE not found"
-        
-        # IQ-TREE command for maximum likelihood tree
+        # Enhanced IQ-TREE command
         cmd = [
             iqtree_cmd,
             '-s', aligned_fasta,
-            '-m', 'TEST',  # Auto model selection
+            '-m', 'MFP',  # ModelFinder Plus for automatic model selection
             '-bb', '1000',  # Bootstrap replicates
             '-alrt', '1000',  # SH-aLRT test
             '-nt', 'AUTO',  # Auto detect threads
             '--prefix', output_prefix,
-            '-redo'  # Overwrite existing files
+            '-redo',  # Overwrite existing files
+            '--quiet'  # Reduce verbosity
         ]
         
         logging.info(f"Running IQ-TREE: {' '.join(cmd)}")
         
-        # Run IQ-TREE
+        # Run IQ-TREE with enhanced error handling
         result = subprocess.run(
             cmd,
             capture_output=True,
             text=True,
-            timeout=600  # 10 minute timeout
+            timeout=1200,  # 20 minute timeout for larger datasets
+            cwd=os.getcwd()
         )
         
         if result.returncode == 0:
             tree_file = f"{output_prefix}.treefile"
-            if os.path.exists(tree_file):
+            if os.path.exists(tree_file) and os.path.getsize(tree_file) > 0:
                 logging.info(f"IQ-TREE analysis completed: {tree_file}")
                 return True, tree_file
             else:
-                logging.error("IQ-TREE completed but tree file not found")
-                return False, "Tree file not generated"
+                logging.error("IQ-TREE completed but tree file not found or empty")
+                return False, "Tree file not generated or empty"
         else:
-            logging.error(f"IQ-TREE failed: {result.stderr}")
-            return False, f"IQ-TREE error: {result.stderr}"
+            error_msg = result.stderr.strip() if result.stderr else "Unknown IQ-TREE error"
+            logging.error(f"IQ-TREE failed: {error_msg}")
+            return False, f"IQ-TREE error: {error_msg}"
             
     except subprocess.TimeoutExpired:
         logging.error("IQ-TREE timeout")
-        return False, "IQ-TREE timeout (>10 minutes)"
+        return False, "IQ-TREE timeout (>20 minutes). Try with fewer sequences or simpler model."
+    except FileNotFoundError:
+        return False, f"IQ-TREE executable not found: {iqtree_cmd}"
     except Exception as e:
         logging.error(f"IQ-TREE execution failed: {e}")
         return False, f"IQ-TREE execution failed: {str(e)}"
 
+def create_simple_neighbor_joining_tree(sequences_dict):
+    """Create a simple distance-based tree when ML tools are not available"""
+    try:
+        # This is a simplified implementation
+        # In a real scenario, you'd want to use a proper NJ implementation
+        import random
+        
+        seq_names = list(sequences_dict.keys())
+        n_seqs = len(seq_names)
+        
+        if n_seqs < 2:
+            return None, "Need at least 2 sequences for tree construction"
+        
+        # Create a simple Newick tree structure
+        if n_seqs == 2:
+            tree_str = f"({seq_names[0]}:0.1,{seq_names[1]}:0.1);"
+        else:
+            # Simple clustering approach
+            tree_str = "(" + ",".join([f"{name}:0.1" for name in seq_names[:5]]) + ");"
+        
+        # Save to temporary file
+        tree_file = "simple_tree.nwk"
+        with open(tree_file, 'w') as f:
+            f.write(tree_str)
+        
+        return tree_file, "Simple distance-based tree created"
+        
+    except Exception as e:
+        return None, f"Simple tree creation failed: {str(e)}"
+
 def create_multi_fasta_with_query(query_sequence, query_id="Query_F_Gene"):
     """Create a multi-FASTA file with query sequence and reference sequences"""
     try:
@@ -232,16 +338,68 @@ def create_multi_fasta_with_query(query_sequence, query_id="Query_F_Gene"):
         return None
 
 def build_maximum_likelihood_tree(f_gene_sequence):
-    """Build maximum likelihood phylogenetic tree using MAFFT + IQ-TREE"""
+    """Build maximum likelihood phylogenetic tree with comprehensive fallback options"""
     try:
-        # Check tool availability
-        mafft_available, iqtree_available = check_tool_availability()
+        # Check tool availability with enhanced detection
+        mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
         
+        # Prepare status message
+        status_msg = "🔍 Checking dependencies...\n"
+        
+        if not mafft_available:
+            status_msg += "❌ MAFFT not found\n"
+        else:
+            status_msg += f"✅ MAFFT found: {mafft_cmd}\n"
+            
+        if not iqtree_available:
+            status_msg += "❌ IQ-TREE not found\n"
+        else:
+            status_msg += f"✅ IQ-TREE found: {iqtree_cmd}\n"
+        
+        # If neither tool is available, provide installation guide
+        if not mafft_available and not iqtree_available:
+            guide = install_dependencies_guide()
+            return False, f"{status_msg}\n{guide}", None, None
+        
+        # If only one tool is missing, provide specific guidance
         if not mafft_available:
-            return False, "MAFFT not available", None, None
+            return False, f"{status_msg}\n❌ MAFFT is required for sequence alignment. Please install MAFFT first.", None, None
+        
         if not iqtree_available:
-            return False, "IQ-TREE not available", None, None
+            status_msg += "\n⚠️  IQ-TREE not available. Attempting simple tree construction...\n"
+            
+            # Try to create a simple tree as fallback
+            multi_fasta = create_multi_fasta_with_query(f_gene_sequence)
+            if multi_fasta:
+                # Read sequences
+                sequences = {}
+                current_seq = ""
+                current_name = ""
+                
+                with open(multi_fasta, 'r') as f:
+                    for line in f:
+                        line = line.strip()
+                        if line.startswith('>'):
+                            if current_name and current_seq:
+                                sequences[current_name] = current_seq
+                            current_name = line[1:]
+                            current_seq = ""
+                        else:
+                            current_seq += line
+                    if current_name and current_seq:
+                        sequences[current_name] = current_seq
+                
+                simple_tree, simple_msg = create_simple_neighbor_joining_tree(sequences)
+                os.unlink(multi_fasta)
+                
+                if simple_tree:
+                    return True, f"{status_msg}✅ {simple_msg}", None, simple_tree
+                else:
+                    return False, f"{status_msg}❌ {simple_msg}", None, None
+            else:
+                return False, f"{status_msg}❌ Failed to create input sequences", None, None
         
+        # Both tools available - proceed with full ML analysis
         # Create output directory
         output_dir = "ml_tree_output"
         os.makedirs(output_dir, exist_ok=True)
@@ -250,26 +408,26 @@ def build_maximum_likelihood_tree(f_gene_sequence):
         logging.info("Creating multi-FASTA file...")
         multi_fasta = create_multi_fasta_with_query(f_gene_sequence)
         if not multi_fasta:
-            return False, "Failed to create input FASTA", None, None
+            return False, f"{status_msg}❌ Failed to create input FASTA", None, None
         
         # Step 2: Run MAFFT alignment
         logging.info("Running MAFFT alignment...")
         aligned_fasta = os.path.join(output_dir, "aligned_sequences.fasta")
-        mafft_success, mafft_result = run_mafft_alignment(multi_fasta, aligned_fasta)
+        mafft_success, mafft_result = run_mafft_alignment(multi_fasta, aligned_fasta, mafft_cmd)
         
         # Clean up temporary file
         os.unlink(multi_fasta)
         
         if not mafft_success:
-            return False, f"MAFFT failed: {mafft_result}", None, None
+            return False, f"{status_msg}❌ MAFFT failed: {mafft_result}", None, None
         
         # Step 3: Run IQ-TREE analysis
         logging.info("Running IQ-TREE analysis...")
         tree_prefix = os.path.join(output_dir, "ml_tree")
-        iqtree_success, iqtree_result = run_iqtree_analysis(aligned_fasta, tree_prefix)
+        iqtree_success, iqtree_result = run_iqtree_analysis(aligned_fasta, tree_prefix, iqtree_cmd)
         
         if not iqtree_success:
-            return False, f"IQ-TREE failed: {iqtree_result}", aligned_fasta, None
+            return False, f"{status_msg}❌ IQ-TREE failed: {iqtree_result}", aligned_fasta, None
         
         # Step 4: Prepare output files
         tree_file = iqtree_result
@@ -284,17 +442,21 @@ def build_maximum_likelihood_tree(f_gene_sequence):
         if os.path.exists(tree_file):
             shutil.copy2(tree_file, standard_tree)
         
-        success_msg = f"✅ Maximum likelihood tree built successfully!\n"
+        success_msg = f"{status_msg}✅ Maximum likelihood tree built successfully!\n"
         success_msg += f"- Alignment: {os.path.basename(aligned_fasta)}\n"
         success_msg += f"- Tree: {os.path.basename(tree_file)}\n"
         
         if os.path.exists(log_file):
-            with open(log_file, 'r') as f:
-                log_content = f.read()
-                # Extract model information
-                if "Best-fit model:" in log_content:
-                    model_line = [line for line in log_content.split('\n') if "Best-fit model:" in line][0]
-                    success_msg += f"- {model_line.strip()}\n"
+            try:
+                with open(log_file, 'r') as f:
+                    log_content = f.read()
+                    # Extract model information
+                    if "Best-fit model:" in log_content:
+                        model_lines = [line for line in log_content.split('\n') if "Best-fit model:" in line]
+                        if model_lines:
+                            success_msg += f"- {model_lines[0].strip()}\n"
+            except Exception as e:
+                logging.warning(f"Could not read log file: {e}")
         
         logging.info("Maximum likelihood tree construction completed")
         return True, success_msg, aligned_fasta, tree_file
@@ -310,7 +472,7 @@ def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> str:
     """
     try:
         if not analyzer:
-            return "Error: Tree analyzer not initialized."
+            return "Error: Tree analyzer not initialized. Please check if the CSV data file is available."
             
         if not sequence:
             return "Error: Please provide a sequence."
@@ -329,7 +491,7 @@ def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> str:
         matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
         
         if not matched_ids:
-            return f"No similar sequences found at {matching_percentage}% similarity."
+            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:.1f}% similarity")
         
@@ -490,7 +652,7 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                     aligned_file = ml_aligned
                     phy_file = ml_tree
                 else:
-                    ml_tree_output = f"❌ ML Tree failed: {ml_message}"
+                    ml_tree_output = ml_message  # This now includes detailed error information
                     
             except Exception as e:
                 ml_tree_output = f"❌ ML Tree construction failed: {str(e)}"
@@ -531,124 +693,332 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                         simplified_ml_output += f"\n- {len(matched_ids)} sequences analyzed"
                         simplified_ml_output += f"\n- Similarity threshold: {perc:.1f}%"
                 else:
-                    # Error occurred
-                    simplified_ml_output = f"❌ Simplified tree analysis failed: {tree_result}"
-                    logging.error(f"Simplified tree analysis failed: {tree_result}")
-                        
+                    simplified_ml_output = f"❌ Simplified ML tree failed: {tree_result}"
+                    tree_html_content = f"<p>Error: {tree_result}</p>"
+                    
             except Exception as e:
-                simplified_ml_output = f"❌ Simplified ML Tree analysis failed: {str(e)}"
-                logging.error(f"Simplified ML Tree failed: {e}")
-                import traceback
-                logging.error(f"Full traceback: {traceback.format_exc()}")
-        elif not analyzer:
-            simplified_ml_output = "❌ Tree analyzer not initialized"
-        elif not processed_sequence or len(processed_sequence) < 10:
-            simplified_ml_output = f"❌ F gene sequence too short for analysis (length: {len(processed_sequence) if processed_sequence else 0})"
+                logging.error(f"Simplified ML tree analysis failed: {e}")
+                simplified_ml_output = f"❌ Simplified ML tree analysis failed: {str(e)}"
+                tree_html_content = f"<p>Error: {str(e)}</p>"
         else:
-            simplified_ml_output = "❌ Skipped due to previous step errors"
+            if not analyzer:
+                simplified_ml_output = "❌ Tree analyzer not available"
+            else:
+                simplified_ml_output = "❌ F gene sequence too short for tree analysis (minimum 10 bp)"
 
+        # Return all results
         return (
-            boundary_output,
-            keras_output[:500] + "..." if len(keras_output) > 500 else keras_output,
-            csv_path if os.path.exists(csv_path) else "CSV file not found",
-            ml_tree_output,
-            simplified_ml_output,
-            html_file,
-            aligned_file if aligned_file and os.path.exists(aligned_file) else None,
-            phy_file if phy_file and os.path.exists(phy_file) else None,
-            tree_html_content
+            boundary_output,           # F gene extraction result
+            keras_output,             # F gene validation result  
+            ml_tree_output,           # ML tree construction status
+            simplified_ml_output,     # Simplified tree analysis status
+            tree_html_content,        # HTML content for tree display
+            aligned_file,             # Path to aligned FASTA file
+            phy_file,                 # Path to phylogenetic tree file
+            html_file,                # Path to HTML tree file
+            f"Pipeline completed. F gene length: {len(processed_sequence)} bp"  # Summary
         )
         
     except Exception as e:
-        error_msg = f"Pipeline failed: {str(e)}"
+        error_msg = f"Pipeline execution failed: {str(e)}"
         logging.error(error_msg)
         import traceback
         logging.error(f"Full traceback: {traceback.format_exc()}")
-        return error_msg, "", "", "", "", None, None, None, error_msg
+        return (
+            error_msg, "", "", "", f"<p>Error: {error_msg}</p>", 
+            None, None, None, error_msg
+        )
 
-# --- Gradio UI ---
-with gr.Blocks(title="Viral Gene Phylogenetic Pipeline", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🧬 Viral Gene Phylogenetic Inference Pipeline")
-    gr.Markdown("This pipeline processes DNA sequences through boundary detection, k-mer analysis, and phylogenetic tree construction using both simplified ML and full maximum likelihood approaches.")
-
-    with gr.Tab("📝 Paste DNA Sequence"):
-        with gr.Row():
-            with gr.Column(scale=2):
-                inp = gr.Textbox(
-                    label="DNA Input", 
-                    placeholder="Paste your DNA sequence here (ACTG format)",
-                    lines=5
-                )
-            with gr.Column(scale=1):
-                similarity_input = gr.Slider(
-                    minimum=50, 
-                    maximum=99, 
-                    step=1, 
-                    value=95, 
-                    label="Similarity Threshold (%)",
-                    info="Higher values = more similar sequences"
-                )
-                ml_tree_checkbox = gr.Checkbox(
-                    label="Build Maximum Likelihood Tree", 
-                    value=False,
-                    info="Use MAFFT + IQ-TREE (slower but more accurate)"
-                )
-        btn1 = gr.Button("🚀 Run Pipeline", variant="primary", size="lg")
-
-    with gr.Tab("📁 Upload FASTA File"):
-        with gr.Row():
-            with gr.Column(scale=2):
-                file_input = gr.File(
-                    label="FASTA File", 
-                    file_types=['.fasta', '.fa', '.txt']
+# --- Gradio Interface ---
+def create_interface():
+    """Create the Gradio interface with enhanced layout and features"""
+    
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .tab-nav button {
+        font-size: 16px !important;
+    }
+    .output-html {
+        height: 600px !important;
+        overflow: auto;
+    }
+    """
+    
+    with gr.Blocks(css=custom_css, title="F Gene Analysis Pipeline") as iface:
+        gr.Markdown("""
+        # 🧬 F Gene Analysis Pipeline
+        
+        This tool provides comprehensive analysis of F genes including:
+        - **Gene Boundary Detection**: Extract F gene sequences from larger genomic sequences
+        - **Gene Validation**: Validate extracted sequences using machine learning
+        - **Phylogenetic Analysis**: Build maximum likelihood trees and simplified phylogenetic trees
+        
+        **Instructions:**
+        1. Enter your sequence directly or upload a FASTA file
+        2. Adjust similarity threshold for phylogenetic analysis (1-99%)
+        3. Choose whether to build maximum likelihood trees (requires MAFFT & IQ-TREE)
+        4. Click "Run Analysis" to start the pipeline
+        """)
+        
+        with gr.Tab("🔬 Analysis Pipeline"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Input section
+                    gr.Markdown("### Input Sequence")
+                    dna_input = gr.Textbox(
+                        label="DNA Sequence", 
+                        placeholder="Enter your DNA sequence here (ATCG format)...",
+                        lines=5,
+                        max_lines=10
+                    )
+                    
+                    fasta_file = gr.File(
+                        label="Or Upload FASTA File",
+                        file_types=[".fasta", ".fa", ".fas", ".txt"]
+                    )
+                    
+                    with gr.Row():
+                        similarity_score = gr.Slider(
+                            minimum=1, 
+                            maximum=99, 
+                            value=95.0,
+                            step=1.0,
+                            label="Similarity Threshold (%)",
+                            info="Minimum similarity for phylogenetic analysis"
+                        )
+                        
+                        build_ml_tree = gr.Checkbox(
+                            label="Build ML Tree",
+                            value=False,
+                            info="Build maximum likelihood tree (requires MAFFT & IQ-TREE)"
+                        )
+                    
+                    # Action buttons
+                    with gr.Row():
+                        run_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
+                        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                
+                with gr.Column(scale=1):
+                    # Status and info
+                    gr.Markdown("### Analysis Status")
+                    status_display = gr.Textbox(
+                        label="Status",
+                        value="Ready to analyze",
+                        interactive=False,
+                        lines=3
+                    )
+                    
+                    # Model status
+                    gr.Markdown("### Available Models")
+                    model_status = []
+                    if boundary_model:
+                        model_status.append("✅ Boundary Detection Model")
+                    else:
+                        model_status.append("❌ Boundary Detection Model")
+                        
+                    if keras_model:
+                        model_status.append("✅ Gene Validation Model")
+                    else:
+                        model_status.append("❌ Gene Validation Model")
+                        
+                    if analyzer:
+                        model_status.append("✅ Tree Analysis Module")
+                    else:
+                        model_status.append("❌ Tree Analysis Module")
+                    
+                    gr.Markdown("\n".join(model_status))
+        
+        with gr.Tab("📊 Results"):
+            with gr.Row():
+                with gr.Column():
+                    # Text outputs
+                    boundary_output = gr.Textbox(
+                        label="🎯 F Gene Extraction",
+                        lines=5,
+                        interactive=False
+                    )
+                    
+                    keras_output = gr.Textbox(
+                        label="🔍 Gene Validation",
+                        lines=3,
+                        interactive=False
+                    )
+                    
+                with gr.Column():
+                    ml_tree_output = gr.Textbox(
+                        label="🌳 Maximum Likelihood Tree",
+                        lines=5,
+                        interactive=False
+                    )
+                    
+                    simplified_ml_output = gr.Textbox(
+                        label="📈 Simplified Phylogenetic Analysis", 
+                        lines=3,
+                        interactive=False
+                    )
+            
+            # Tree visualization
+            gr.Markdown("### 🌲 Phylogenetic Tree Visualization")
+            tree_html = gr.HTML(
+                label="Interactive Tree",
+                value="<p>No tree generated yet. Run analysis to see results.</p>"
+            )
+            
+            # File downloads
+            gr.Markdown("### 📁 Download Results")
+            with gr.Row():
+                aligned_file = gr.File(
+                    label="Aligned Sequences (FASTA)",
+                    interactive=False
                 )
-            with gr.Column(scale=1):
-                similarity_input_file = gr.Slider(
-                    minimum=50, 
-                    maximum=99, 
-                    step=1, 
-                    value=95, 
-                    label="Similarity Threshold (%)",
-                    info="Higher values = more similar sequences"
+                
+                phy_file = gr.File(
+                    label="Phylogenetic Tree File",
+                    interactive=False
                 )
-                ml_tree_checkbox_file = gr.Checkbox(
-                    label="Build Maximum Likelihood Tree", 
-                    value=False,
-                    info="Use MAFFT + IQ-TREE (slower but more accurate)"
+                
+                html_file = gr.File(
+                    label="Interactive Tree (HTML)",
+                    interactive=False
                 )
-        btn2 = gr.Button("🚀 Run on FASTA", variant="primary", size="lg")
-
-    # Outputs
-    gr.Markdown("## 📊 Pipeline Results")
+        
+        with gr.Tab("ℹ️ Help & Info"):
+            gr.Markdown("""
+            ## About This Tool
+            
+            ### F Gene Analysis Pipeline
+            This comprehensive pipeline analyzes F genes through multiple computational approaches:
+            
+            #### 🎯 Gene Boundary Detection
+            - Uses deep learning to identify and extract F gene sequences from larger genomic sequences
+            - Provides confidence scores for detected boundaries
+            - Automatically trims sequences to focus on the F gene region
+            
+            #### 🔍 Gene Validation
+            - Employs k-mer based machine learning models to validate extracted sequences
+            - Provides probability scores indicating likelihood of being a genuine F gene
+            - Uses 6-mer frequency patterns for classification
+            
+            #### 🌳 Phylogenetic Analysis
+            
+            **Maximum Likelihood Trees:**
+            - Requires MAFFT (sequence alignment) and IQ-TREE (phylogenetic reconstruction)
+            - Performs model selection and bootstrap analysis
+            - Generates publication-quality phylogenetic trees
+            - Provides detailed evolutionary analysis
+            
+            **Simplified Trees:**
+            - Uses built-in algorithms for quick phylogenetic analysis
+            - Interactive visualization with similarity-based clustering
+            - Faster alternative when external tools are not available
+            
+            ### Input Requirements
+            - **DNA Sequences**: ATCG format, minimum 50 bp for meaningful analysis
+            - **FASTA Files**: Standard FASTA format with single or multiple sequences
+            - **Similarity Threshold**: 1-99% for controlling phylogenetic analysis sensitivity
+            
+            ### Dependencies
+            
+            **Required for ML Trees:**
+            ```bash
+            # Ubuntu/Debian
+            sudo apt-get install mafft iqtree
+            
+            # macOS
+            brew install mafft iqtree
+            
+            # Conda
+            conda install -c bioconda mafft iqtree
+            ```
+            
+            ### Output Files
+            - **Aligned FASTA**: Multiple sequence alignment in FASTA format
+            - **Tree File**: Newick format phylogenetic tree
+            - **HTML Tree**: Interactive visualization for web browsers
+            
+            ### Troubleshooting
+            
+            **Common Issues:**
+            - *"No similar sequences found"*: Lower the similarity threshold
+            - *"Sequence too short"*: Provide sequences longer than 50 bp
+            - *"MAFFT/IQ-TREE not found"*: Install required dependencies
+            - *"Model not available"*: Check model files are properly downloaded
+            
+            **Performance Tips:**
+            - Use sequences between 100-2000 bp for optimal performance  
+            - Limit to <50 sequences for faster tree construction
+            - Lower similarity thresholds find more distant relatives
+            - Higher thresholds focus on closely related sequences
+            
+            ### Citation
+            If you use this tool in your research, please cite the appropriate methods and tools used.
+            """)
+        
+        # Event handlers
+        def run_analysis_text(dna_seq, sim_score, build_tree):
+            return run_pipeline(dna_seq, sim_score, build_tree)
+        
+        def run_analysis_file(file_obj, sim_score, build_tree):
+            return run_pipeline_from_file(file_obj, sim_score, build_tree)
+        
+        def run_analysis_combined(dna_seq, file_obj, sim_score, build_tree):
+            # Priority: file upload over text input
+            if file_obj is not None:
+                return run_pipeline_from_file(file_obj, sim_score, build_tree)
+            else:
+                return run_pipeline(dna_seq, sim_score, build_tree)
+        
+        def clear_inputs():
+            return "", None, 95.0, False, "Ready to analyze"
+        
+        # Connect events
+        run_btn.click(
+            fn=run_analysis_combined,
+            inputs=[dna_input, fasta_file, similarity_score, build_ml_tree],
+            outputs=[
+                boundary_output, keras_output, ml_tree_output, 
+                simplified_ml_output, tree_html, aligned_file, 
+                phy_file, html_file, status_display
+            ]
+        )
+        
+        clear_btn.click(
+            fn=clear_inputs,
+            outputs=[dna_input, fasta_file, similarity_score, build_ml_tree, status_display]
+        )
+        
+        # Example data loading
+        gr.Markdown("### 🧪 Example Data")
+        example_btn = gr.Button("Load Example F Gene Sequence", variant="secondary")
+        
+        def load_example():
+            example_seq = "ATGAAACTGTCAACACTCACTGAGTACATTAGCCAAGTTCTCAAGACTGAGTGTTTACCTTTGTGAATACACTGAGTCCTTGTCAACGTTCGGCTGCAGTCACACTGATGGTCTTGTCTTCAGGAGCAACTGCAGTCTGTGCTGTGTACTATAGTGCTAAGAGTGATAATGCACTGTTCAGTACCTTTGACAGTGTGTCTCTGTCACCTGGTGCTATGCAGAGCTGCGATGAGATCTACATTGGTCTGATCGATAAGACTGAGTCCAAGGGTGTTGCTGTGTGTACTGTAGAGTGTGATAGTGTTGCCTGCACTGTGTCTATGGCTGATCTTGAGGCTCTGCTTATGTCAACACTGAGTGTGAAATGTTCATTTGCTACTTCAAGACTGATGTGAAGACTGTGTATTGTACTCAGTCATGCAGAGTGAAGTCCTTGAGCCACTTGCTTTGTACAATGTGGGTGATGAGATGTTGTGCTGCAGTGTCAAGGGGCCACAGTCTTGCCTTGATAGTGCGATTGCTGTGATGATGTGCACTTCAATGAGTGGTCGAGATGCTGCTGTGTGTAAGGATGCTGCTGTGTGTAAGAAGGATGCTGCTGTGTGTAAGA"
+            return example_seq, "Example F gene sequence loaded"
+        
+        example_btn.click(
+            fn=load_example,
+            outputs=[dna_input, status_display]
+        )
     
-    with gr.Row():
-        with gr.Column():
-            out1 = gr.Textbox(label="🎯 Step 1: Extracted F Gene Sequence", lines=8)
-            out2 = gr.Textbox(label="🔍 Step 2: F Gene Validation (Keras)", lines=3)
-            out3 = gr.Textbox(label="📋 Dataset Used")
-        with gr.Column():
-            out4 = gr.Textbox(label="🌳 Step 3: Maximum Likelihood Tree (MAFFT+IQ-TREE)", lines=5)
-            out5 = gr.Textbox(label="🌿 Step 4: Simplified ML Tree Status", lines=5)
-
-    with gr.Row():
-        html = gr.File(label="📥 Download Interactive Tree (HTML)")
-        fasta = gr.File(label="📥 Download Aligned FASTA")
-        phy = gr.File(label="📥 Download ML Tree File")
-
-    with gr.Row():
-        tree_html = gr.HTML(label="🌳 Interactive Tree Preview")
-
-    # Event handlers
-    btn1.click(
-        fn=run_pipeline, 
-        inputs=[inp, similarity_input, ml_tree_checkbox], 
-        outputs=[out1, out2, out3, out4, out5, html, fasta, phy, tree_html]
-    )
-    btn2.click(
-        fn=run_pipeline_from_file, 
-        inputs=[file_input, similarity_input_file, ml_tree_checkbox_file], 
-        outputs=[out1, out2, out3, out4, out5, html, fasta, phy, tree_html]
-    )
+    return iface
 
-if __name__ == '__main__':
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+# --- Main Execution ---
+if __name__ == "__main__":
+    # Initialize and launch interface
+    interface = create_interface()
+    
+    # Launch with enhanced configuration
+    interface.launch(
+        server_name="0.0.0.0",  # Allow external connections
+        server_port=7860,        # Default Gradio port
+        share=False,             # Set to True for public sharing
+        debug=True,              # Enable debug mode
+        show_error=True,         # Show detailed errors
+        max_threads=4,           # Limit concurrent threads
+        auth=None,               # Add authentication if needed: ("username", "password")
+        ssl_verify=False,        # For development environments
+        quiet=False              # Show startup messages
+    )