Update app.py

app.py

@@ -13,12 +13,21 @@ import ml_simplified_tree
 import tempfile
 import shutil
 import sys
+import uuid
 from pathlib import Path
 from huggingface_hub import hf_hub_download
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
 
 # --- Global Variables ---
-MAFFT_PATH = "mafft/mafftdir/bin/mafft"  # Update this path as needed
-IQTREE_PATH = "iqtree/bin/iqtree2"  # Update this path as needed
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft.bat")  # Windows path
+IQTREE_PATH = os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree3")
+ALIGNMENT_PATH = os.path.join(BASE_DIR, "f_gene_sequences_aligned.fasta")
+TREE_PATH = os.path.join(BASE_DIR, "f_gene_sequences.phy.treefile")
+QUERY_OUTPUT_DIR = os.path.join(BASE_DIR, "queries")
+os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
 
 # --- Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -112,6 +121,7 @@ def check_tool_availability():
         '/usr/bin/mafft',
         '/usr/local/bin/mafft',
         'mafft.bat',  # Windows
+        os.path.join(BASE_DIR, "mafft", "mafftdir", "bin", "mafft"),
     ]
     
     for candidate in mafft_candidates:
@@ -130,12 +140,15 @@ def check_tool_availability():
         IQTREE_PATH,
         'iqtree2',
         'iqtree',
+        'iqtree3',
         '/usr/bin/iqtree2',
         '/usr/local/bin/iqtree2',
         '/usr/bin/iqtree',
         '/usr/local/bin/iqtree',
         'iqtree2.exe',  # Windows
         'iqtree.exe',   # Windows
+        'iqtree3.exe',  # Windows
+        os.path.join(BASE_DIR, "iqtree", "bin", "iqtree2"),
     ]
     
     for candidate in iqtree_candidates:
@@ -173,170 +186,148 @@ Docker option:
 """
     return guide
 
-def run_mafft_alignment(input_fasta, output_fasta, mafft_cmd):
-    """Run MAFFT alignment with enhanced error handling"""
+def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
+    """
+    Perform phylogenetic placement using MAFFT + IQ-TREE approach.
+    This adds the query sequence to a reference alignment and tree.
+    """
     try:
-        # 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 with enhanced error handling
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=600,  # Increased timeout to 10 minutes
-            cwd=os.getcwd()  # Ensure working directory is set
-        )
-        
-        if result.returncode == 0:
-            # Write aligned sequences to output file
-            with open(output_fasta, 'w') as f:
-                f.write(result.stdout)
-            logging.info(f"MAFFT alignment completed: {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:
-            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 (>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)}"
+        # Validate sequence
+        if len(sequence.strip()) < 100:
+            return False, "Error: Sequence is too short for phylogenetic placement (minimum 100 bp).", None, None
 
-def run_iqtree_analysis(aligned_fasta, output_prefix, iqtree_cmd):
-    """Run IQ-TREE with enhanced options and error handling"""
-    try:
-        # Enhanced IQ-TREE command
-        cmd = [
-            iqtree_cmd,
-            '-s', aligned_fasta,
-            '-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
-            '--quiet'  # Reduce verbosity
-        ]
-        
-        logging.info(f"Running IQ-TREE: {' '.join(cmd)}")
-        
-        # Run IQ-TREE with enhanced error handling
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            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) 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 or empty")
-                return False, "Tree file not generated or empty"
-        else:
-            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 (>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)}"
+        # Generate unique query ID
+        query_id = f"QUERY_{uuid.uuid4().hex[:8]}"
+        query_fasta = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}.fa")
+        aligned_with_query = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_aligned.fa")
+        output_prefix = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_placed_tree")
 
-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]]) + ");"
+        # Check if reference files exist
+        if not os.path.exists(ALIGNMENT_PATH):
+            return False, f"Reference alignment not found: {ALIGNMENT_PATH}", None, None
         
-        # 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)}"
+        if not os.path.exists(TREE_PATH):
+            return False, f"Reference tree not found: {TREE_PATH}", None, None
 
-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:
-        # Create temporary FASTA file
-        temp_fasta = tempfile.NamedTemporaryFile(mode='w', suffix='.fasta', delete=False)
-        
-        # Add query sequence
-        temp_fasta.write(f">{query_id}\n{query_sequence}\n")
-        
-        # Add reference sequences from existing aligned FASTA if available
-        ref_fasta_path = "f_gene_sequences_aligned.fasta"
-        if os.path.exists(ref_fasta_path):
-            with open(ref_fasta_path, 'r') as ref_file:
-                temp_fasta.write(ref_file.read())
-            logging.info(f"Added reference sequences from {ref_fasta_path}")
-        else:
-            # If no reference file, try to create from CSV data
-            if analyzer and hasattr(analyzer, 'data'):
-                count = 0
-                for idx, row in analyzer.data.iterrows():
-                    if 'sequence' in row and len(str(row['sequence'])) > 50:
-                        seq_id = row.get('id', f"Ref_{count}")
-                        sequence = str(row['sequence']).upper()
-                        temp_fasta.write(f">{seq_id}\n{sequence}\n")
-                        count += 1
-                        if count >= 20:  # Limit to prevent too large datasets
-                            break
-                logging.info(f"Added {count} reference sequences from CSV")
-        
-        temp_fasta.close()
-        return temp_fasta.name
-        
+        # Save query sequence as FASTA
+        try:
+            query_record = SeqRecord(Seq(sequence.upper()), id=query_id, description="Query sequence")
+            SeqIO.write([query_record], query_fasta, "fasta")
+            logging.info(f"Query sequence saved: {query_fasta}")
+        except Exception as e:
+            return False, f"Failed to save query sequence: {str(e)}", None, None
+
+        # Step 1: Add query sequence to reference alignment using MAFFT
+        logging.info("Adding query sequence to reference alignment...")
+        try:
+            with open(aligned_with_query, "w") as output_file:
+                mafft_cmd_full = [
+                    mafft_cmd, 
+                    "--add", query_fasta,
+                    "--reorder", 
+                    ALIGNMENT_PATH
+                ]
+                
+                logging.info(f"Running MAFFT: {' '.join(mafft_cmd_full)}")
+                
+                result = subprocess.run(
+                    mafft_cmd_full,
+                    stdout=output_file,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    timeout=600,  # 10 minute timeout
+                    check=True
+                )
+                
+            # Verify alignment file was created and is not empty
+            if not os.path.exists(aligned_with_query) or os.path.getsize(aligned_with_query) == 0:
+                return False, "MAFFT alignment failed: output file is empty", None, None
+                
+            logging.info(f"MAFFT alignment completed: {aligned_with_query}")
+            
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr.decode() if e.stderr else "Unknown MAFFT error"
+            return False, f"MAFFT alignment failed: {error_msg}", None, None
+        except subprocess.TimeoutExpired:
+            return False, "MAFFT alignment timeout (>10 minutes)", None, None
+        except Exception as e:
+            return False, f"MAFFT alignment error: {str(e)}", None, None
+
+        # Step 2: Place sequence in phylogenetic tree using IQ-TREE
+        logging.info("Placing sequence in phylogenetic tree...")
+        try:
+            iqtree_cmd_full = [
+                iqtree_cmd,
+                "-s", aligned_with_query,
+                "-g", TREE_PATH,  # Constraint tree (reference tree)
+                "-m", "GTR+G",    # Substitution model
+                "-pre", output_prefix,
+                "-redo",          # Overwrite existing files
+                "--quiet"         # Reduce verbosity
+            ]
+            
+            logging.info(f"Running IQ-TREE: {' '.join(iqtree_cmd_full)}")
+            
+            result = subprocess.run(
+                iqtree_cmd_full,
+                capture_output=True,
+                text=True,
+                timeout=1200,  # 20 minute timeout
+                check=True
+            )
+            
+            # Check if treefile was generated
+            treefile = f"{output_prefix}.treefile"
+            if not os.path.exists(treefile) or os.path.getsize(treefile) == 0:
+                return False, "IQ-TREE placement failed: treefile not generated", aligned_with_query, None
+                
+            logging.info(f"IQ-TREE placement completed: {treefile}")
+            
+            # Generate success message with details
+            success_msg = "✅ Phylogenetic placement completed successfully!\n"
+            success_msg += f"- Query ID: {query_id}\n"
+            success_msg += f"- Alignment: {os.path.basename(aligned_with_query)}\n"
+            success_msg += f"- Tree: {os.path.basename(treefile)}\n"
+            
+            # Try to extract model information from log
+            log_file = f"{output_prefix}.log"
+            if os.path.exists(log_file):
+                try:
+                    with open(log_file, 'r') as f:
+                        log_content = f.read()
+                        if "Log-likelihood" in log_content:
+                            log_lines = [line for line in log_content.split('\n') if "Log-likelihood" in line]
+                            if log_lines:
+                                success_msg += f"- {log_lines[0].strip()}\n"
+                except Exception as e:
+                    logging.warning(f"Could not read log file: {e}")
+            
+            return True, success_msg, aligned_with_query, treefile
+            
+        except subprocess.CalledProcessError as e:
+            error_msg = e.stderr if e.stderr else "Unknown IQ-TREE error"
+            return False, f"IQ-TREE placement failed: {error_msg}", aligned_with_query, None
+        except subprocess.TimeoutExpired:
+            return False, "IQ-TREE placement timeout (>20 minutes)", aligned_with_query, None
+        except Exception as e:
+            return False, f"IQ-TREE placement error: {str(e)}", aligned_with_query, None
+            
     except Exception as e:
-        logging.error(f"Failed to create multi-FASTA: {e}")
-        return None
+        logging.error(f"Phylogenetic placement failed: {e}")
+        return False, f"Phylogenetic placement failed: {str(e)}", None, None
+    finally:
+        # Clean up temporary query file
+        if os.path.exists(query_fasta):
+            try:
+                os.unlink(query_fasta)
+            except:
+                pass
 
 def build_maximum_likelihood_tree(f_gene_sequence):
-    """Build maximum likelihood phylogenetic tree with comprehensive fallback options"""
+    """
+    Build maximum likelihood phylogenetic tree using phylogenetic placement approach.
+    This replaces the previous de novo tree building with placement-based analysis.
+    """
     try:
         # Check tool availability with enhanced detection
         mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
@@ -354,110 +345,51 @@ def build_maximum_likelihood_tree(f_gene_sequence):
         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:
+        # Check for reference files
+        if not os.path.exists(ALIGNMENT_PATH):
+            status_msg += f"❌ Reference alignment not found: {ALIGNMENT_PATH}\n"
+        else:
+            status_msg += f"✅ Reference alignment found\n"
+            
+        if not os.path.exists(TREE_PATH):
+            status_msg += f"❌ Reference tree not found: {TREE_PATH}\n"
+        else:
+            status_msg += f"✅ Reference tree found\n"
+        
+        # If any required component is missing, provide installation guide
+        if not mafft_available or 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, f"{status_msg}\n❌ MAFFT is required for sequence alignment. Please install MAFFT first.", None, None
+        if not os.path.exists(ALIGNMENT_PATH) or not os.path.exists(TREE_PATH):
+            status_msg += "\n❌ Reference alignment and/or tree files are missing.\n"
+            status_msg += "Please ensure f_gene_sequences_aligned.fasta and f_gene_sequences.phy.treefile are available."
+            return False, status_msg, None, None
+
+        # Perform phylogenetic placement
+        logging.info("Starting phylogenetic placement...")
+        placement_success, placement_message, aligned_file, tree_file = phylogenetic_placement(
+            f_gene_sequence, mafft_cmd, iqtree_cmd
+        )
         
-        if not iqtree_available:
-            status_msg += "\n⚠️  IQ-TREE not available. Attempting simple tree construction...\n"
+        if placement_success:
+            final_message = f"{status_msg}\n{placement_message}"
             
-            # 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
+            # Copy files to standard locations for compatibility
+            if aligned_file and os.path.exists(aligned_file):
+                standard_aligned = "query_with_references_aligned.fasta"
+                shutil.copy2(aligned_file, standard_aligned)
+                aligned_file = standard_aligned
                 
-                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)
-        
-        # Step 1: Create multi-FASTA file with query and reference sequences
-        logging.info("Creating multi-FASTA file...")
-        multi_fasta = create_multi_fasta_with_query(f_gene_sequence)
-        if not multi_fasta:
-            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_cmd)
-        
-        # Clean up temporary file
-        os.unlink(multi_fasta)
-        
-        if not mafft_success:
-            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_cmd)
-        
-        if not iqtree_success:
-            return False, f"{status_msg}❌ IQ-TREE failed: {iqtree_result}", aligned_fasta, None
-        
-        # Step 4: Prepare output files
-        tree_file = iqtree_result
-        log_file = f"{tree_prefix}.log"
-        
-        # Copy to standard names for compatibility
-        standard_aligned = "f_gene_sequences_aligned.fasta"
-        standard_tree = "f_gene_sequences.phy.treefile"
-        
-        if os.path.exists(aligned_fasta):
-            shutil.copy2(aligned_fasta, standard_aligned)
-        if os.path.exists(tree_file):
-            shutil.copy2(tree_file, standard_tree)
-        
-        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):
-            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
+            if tree_file and os.path.exists(tree_file):
+                standard_tree = "query_placement_tree.treefile"
+                shutil.copy2(tree_file, standard_tree)
+                tree_file = standard_tree
+            
+            logging.info("Phylogenetic placement completed successfully")
+            return True, final_message, aligned_file, tree_file
+        else:
+            return False, f"{status_msg}\n{placement_message}", aligned_file, tree_file
         
     except Exception as e:
         logging.error(f"ML tree construction failed: {e}")
@@ -629,19 +561,19 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         keras_output = ""
         if processed_sequence and len(processed_sequence) >= 6:
             keras_prediction = predict_with_keras(processed_sequence)
-            # Use the prediction directly as it’s now a percentage
+            # Use the prediction directly as it's now a percentage
             keras_output = keras_prediction
         else:
             keras_output = "Skipped: sequence too short for F gene validation"
 
-        # Step 3: Maximum Likelihood Tree (MAFFT + IQ-TREE)
+        # Step 3: Maximum Likelihood Tree (Phylogenetic Placement)
         aligned_file = None
         phy_file = None
         ml_tree_output = ""
         
-        if build_ml_tree and processed_sequence and len(processed_sequence) >= 50:
+        if build_ml_tree and processed_sequence and len(processed_sequence) >= 100:
             try:
-                logging.info("Starting maximum likelihood tree construction...")
+                logging.info("Starting phylogenetic placement...")
                 ml_success, ml_message, ml_aligned, ml_tree = build_maximum_likelihood_tree(processed_sequence)
                 
                 if ml_success:
@@ -652,12 +584,12 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                     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)}"
-                logging.error(f"ML Tree failed: {e}")
+                ml_tree_output = f"❌ Phylogenetic placement failed: {str(e)}"
+                logging.error(f"Phylogenetic placement failed: {e}")
         elif build_ml_tree:
-            ml_tree_output = "❌ F gene sequence too short for ML tree construction (minimum 50 bp)"
+            ml_tree_output = "❌ F gene sequence too short for phylogenetic placement (minimum 100 bp)"
         else:
-            ml_tree_output = "ML tree construction skipped (not requested)"
+            ml_tree_output = "Phylogenetic placement skipped (not requested)"
 
         # Step 4: ML Simplified Tree (using the existing approach)
         html_file = None
@@ -709,7 +641,7 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         return (
             boundary_output,           # F gene extraction result
             keras_output,             # F gene validation result
-            ml_tree_output,           # ML tree construction status
+            ml_tree_output,           # Phylogenetic placement status
             simplified_ml_output,     # Simplified tree analysis status
             tree_html_content,        # HTML content from file for tree display
             aligned_file,             # Path to aligned FASTA file
@@ -752,290 +684,239 @@ def create_interface():
         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
+        - **Phylogenetic Placement**: Add your sequence to reference phylogenetic trees using MAFFT & IQ-TREE
+        - **Simplified Phylogenetic Analysis**: Build quick phylogenetic trees for comparison
         """)
         
-        with gr.Tab("🔬 Analysis Pipeline"):
+        with gr.Tab("📁 Input"):
             with gr.Row():
                 with gr.Column(scale=2):
-                    # Input section
-                    gr.Markdown("### Input Sequence")
+                    gr.Markdown("### Input Options")
+                    input_choice = gr.Radio(
+                        choices=["Text Input", "FASTA File"], 
+                        value="Text Input",
+                        label="Choose Input Method"
+                    )
+                    
                     dna_input = gr.Textbox(
-                        label="DNA Sequence", 
+                        label="DNA Sequence",
                         placeholder="Enter your DNA sequence here (ATCG format)...",
-                        lines=5,
-                        max_lines=10
+                        lines=6,
+                        visible=True
                     )
                     
                     fasta_file = gr.File(
-                        label="Or Upload FASTA File",
-                        file_types=[".fasta", ".fa", ".fas", ".txt"]
+                        label="Upload FASTA File",
+                        file_types=[".fasta", ".fa", ".fas", ".txt"],
+                        visible=False
                     )
                     
-                    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)"
-                        )
+                    def toggle_input(choice):
+                        if choice == "Text Input":
+                            return gr.update(visible=True), gr.update(visible=False)
+                        else:
+                            return gr.update(visible=False), gr.update(visible=True)
                     
-                    # Action buttons
-                    with gr.Row():
-                        run_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
-                        clear_btn = gr.Button("🗑️ Clear", variant="secondary")
+                    input_choice.change(
+                        fn=toggle_input,
+                        inputs=[input_choice],
+                        outputs=[dna_input, fasta_file]
+                    )
                 
                 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
+                    gr.Markdown("### Analysis Options")
+                    similarity_score = gr.Slider(
+                        minimum=50,
+                        maximum=99,
+                        value=95,
+                        step=1,
+                        label="Similarity Threshold (%)",
+                        info="Minimum similarity for phylogenetic analysis"
                     )
                     
-                    # 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")
+                    build_ml_tree = gr.Checkbox(
+                        label="Build Phylogenetic Tree",
+                        value=False,
+                        info="Perform phylogenetic placement (requires MAFFT & IQ-TREE)"
+                    )
                     
-                    gr.Markdown("\n".join(model_status))
+                    run_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
         
         with gr.Tab("📊 Results"):
             with gr.Row():
                 with gr.Column():
-                    # Text outputs
-                    boundary_output = gr.Textbox(
-                        label="🎯 F Gene Extraction",
-                        lines=5,
-                        interactive=False
-                    )
+                    gr.Markdown("### Analysis Results")
                     
-                    keras_output = gr.Textbox(
-                        label="🔍 Gene Validation",
-                        lines=3,
-                        interactive=False
-                    )
+                    with gr.Accordion("🔍 Gene Boundary Detection", open=True):
+                        boundary_output = gr.Textbox(
+                            label="F Gene Extraction",
+                            lines=4,
+                            interactive=False
+                        )
                     
-                with gr.Column():
-                    ml_tree_output = gr.Textbox(
-                        label="🌳 Maximum Likelihood Tree",
-                        lines=5,
-                        interactive=False
-                    )
+                    with gr.Accordion("✅ Gene Validation", open=True):
+                        keras_output = gr.Textbox(
+                            label="F Gene Validation",
+                            lines=2,
+                            interactive=False
+                        )
                     
-                    simplified_ml_output = gr.Textbox(
-                        label="📈 Simplified Phylogenetic Analysis", 
-                        lines=3,
-                        interactive=False
-                    )
-            
-            # Tree visualization
-            gr.Markdown("### 🌲 Phylogenetic Tree Visualization (ML Simplified Tree)")
+                    with gr.Accordion("🌳 Phylogenetic Placement", open=False):
+                        ml_tree_output = gr.Textbox(
+                            label="ML Tree Status",
+                            lines=6,
+                            interactive=False
+                        )
+                    
+                    with gr.Accordion("📈 Simplified Tree Analysis", open=False):
+                        simplified_ml_output = gr.Textbox(
+                            label="Tree Analysis Status",
+                            lines=4,
+                            interactive=False
+                        )
+        
+        with gr.Tab("🌳 Tree Visualization"):
+            gr.Markdown("### Interactive Phylogenetic Tree")
             tree_html = gr.HTML(
-                label="Interactive Tree",
-                value="<p>Click the link below to view the ML Simplified Tree in a new tab.</p>"
+                label="Phylogenetic Tree",
+                value="<p>Run analysis to generate tree visualization</p>"
             )
+        
+        with gr.Tab("💾 Downloads"):
+            gr.Markdown("### Download Results")
             with gr.Row():
-                show_tree_link = gr.HTML()
-
-            # File downloads
-            gr.Markdown("### 📁 Download Results")
-            with gr.Row():
-                aligned_file = gr.File(
+                aligned_file_download = gr.File(
                     label="Aligned Sequences (FASTA)",
                     interactive=False
                 )
-                
-                phy_file = gr.File(
+                phy_file_download = gr.File(
                     label="Phylogenetic Tree File",
                     interactive=False
                 )
-                
-                html_file = gr.File(
-                    label="Interactive Tree (HTML) - ML Simplified Tree",
+                html_file_download = gr.File(
+                    label="Interactive Tree (HTML)",
                     interactive=False
                 )
         
-        with gr.Tab("ℹ️ Help & Info"):
+        with gr.Tab("ℹ️ Information"):
             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
+            ### About This Tool
             
-            ### Dependencies
+            This F Gene Analysis Pipeline provides comprehensive analysis capabilities:
             
-            **Required for ML Trees:**
-            ```bash
-            # Ubuntu/Debian
-            sudo apt-get install mafft iqtree
+            #### 🔍 **Gene Boundary Detection**
+            - Uses deep learning models to identify and extract F gene sequences from larger genomic contexts
+            - Provides confidence scores for extracted regions
             
-            # macOS
-            brew install mafft iqtree
+            #### ✅ **Gene Validation** 
+            - Validates extracted sequences using k-mer based machine learning
+            - Provides percentage confidence that the sequence is indeed an F gene
             
-            # Conda
-            conda install -c bioconda mafft iqtree
-            ```
+            #### 🌳 **Phylogenetic Analysis**
+            - **Phylogenetic Placement**: Places your sequence in a reference phylogenetic tree using MAFFT and IQ-TREE
+            - **Simplified Analysis**: Quick phylogenetic comparison with similar sequences from the database
             
-            ### Output Files
-            - **Aligned FASTA**: Multiple sequence alignment in FASTA format
-            - **Tree File**: Newick format phylogenetic tree
-            - **HTML Tree**: Interactive visualization for web browsers (ML Simplified Tree)
+            #### 📊 **Output Files**
+            - Aligned FASTA sequences
+            - Phylogenetic tree files (Newick format)
+            - Interactive HTML tree visualizations
             
-            ### Troubleshooting
+            #### ⚙️ **Requirements**
+            - For phylogenetic placement: MAFFT and IQ-TREE must be installed
+            - Reference alignment and tree files must be available
+            - CSV database for simplified tree analysis
             
-            **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
+            #### 📝 **Input Formats**
+            - Plain text DNA sequences (ATCG format)
+            - FASTA files (.fasta, .fa, .fas, .txt)
+            - Sequences should be at least 100 bp for phylogenetic analysis
             
-            **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.
+            #### 🎯 **Tips for Best Results**
+            - Use sequences longer than 100 bp for phylogenetic analysis
+            - Start with high similarity thresholds (95%) and adjust if needed
+            - For large sequences, the boundary detection will extract the F gene portion automatically
             """)
         
-        # 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)
+        # Status and summary
+        with gr.Row():
+            status_output = gr.Textbox(
+                label="Analysis Summary",
+                lines=2,
+                interactive=False
+            )
         
-        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)
+        # Event handlers
+        def run_analysis_wrapper(input_choice, dna_text, fasta_file, similarity, build_tree):
+            """Wrapper to handle both input methods"""
+            if input_choice == "Text Input":
+                return run_pipeline(dna_text, similarity, build_tree)
             else:
-                return run_pipeline(dna_seq, sim_score, build_tree)
-        
-        def clear_inputs():
-            return "", None, 95.0, False, "Ready to analyze"
-        
-        def show_tree(html_file):
-            if html_file and os.path.exists(html_file):
-                try:
-                    # Convert to relative path for Gradio file serving
-                    relative_path = os.path.relpath(html_file, os.getcwd())
-                    file_url = f"/file={relative_path}"
-                    link_html = f'<a href="{file_url}" target="_blank">View ML Simplified Tree</a>'
-                    return gr.update(value=link_html)
-                except Exception as e:
-                    return gr.update(value=f"<p>Error generating link: {str(e)}. Please download and open the file manually.</p>")
-            return gr.update(value="<p>No tree file available. Run analysis to generate one.</p>")
+                return run_pipeline_from_file(fasta_file, similarity, build_tree)
         
-        # Connect events
         run_btn.click(
-            fn=run_analysis_combined,
-            inputs=[dna_input, fasta_file, similarity_score, build_ml_tree],
+            fn=run_analysis_wrapper,
+            inputs=[
+                input_choice,
+                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
+                boundary_output,
+                keras_output,
+                ml_tree_output,
+                simplified_ml_output,
+                tree_html,
+                aligned_file_download,
+                phy_file_download,
+                html_file_download,
+                status_output
             ]
         )
         
-        clear_btn.click(
-            fn=clear_inputs,
-            outputs=[dna_input, fasta_file, similarity_score, build_ml_tree, status_display]
-        )
-        
-        show_tree_link.click(
-            fn=show_tree,
-            inputs=[html_file],
-            outputs=[show_tree_link]
-        )
-        
-        # 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 sequences for demonstration
+        examples = [
+            [
+                "Text Input",
+                "ATGAAACTCCTAGGATTCCTTGGAACCGTCAAGTCCTGCACATCCGATGCAGTCTTCCTGAGCACAGGCCCAATCAGCAGGGACAACCAGCTGGACAGCGTAAGCAAACCTGCACCCGACCCGTCGGTAACAGATGGAGACAGTGAGTCTACTCGGACCATCCGAAGCAGGAAACATGTCAACCTGCGACTTCCCGTTCGCCAGATGGCCAGTCCGACCTTCGCCGCCAACTACCTCGATGTCAACGCCGCCAATGATGGCTCCTGCACGTCCTACTACGGCTTCACCCCGACCAACATCCGAGACAACGAGATCTCGTCGGTGGATGTCAGATCGGGCGCCAACGCC",
+                None,
+                85.0,
+                False
+            ],
+            [
+                "Text Input", 
+                "ATGAAACTCCTGGGATTCCTTGGAACCGTCAAGTCCTGCACATCCGATGCAGTCTTCCTGAGCACAGGCCCAATCAGCAGGGACAACCAGCTGGACAGCGTAAGCAAACCTGCACCCGACCCGTCGGTAACAGATGGAGACAGTGAGTCTACTCGGACCATCCGAAGCAGGAAACATGTCAACCTGCGACTTCCCGTTCGCCAGATGGCCAGTCCGACCTTCGCCGCCAACTACCTCGATGTCAACGCCGCCAATGATGGCTCCTGCACGTCCTACTACGGCTTCACCCCGACCAACATCCGAGACAACGAGATCTCGTCGGTGGATGTCAGATCGGGCGCCAACGCCGAGATCTGA",
+                None,
+                90.0,
+                True
+            ]
+        ]
         
-        example_btn.click(
-            fn=load_example,
-            outputs=[dna_input, status_display]
+        gr.Examples(
+            examples=examples,
+            inputs=[
+                input_choice,
+                dna_input,
+                fasta_file,
+                similarity_score,
+                build_ml_tree
+            ],
+            label="Example Sequences"
         )
     
     return iface
+
 # --- Main Execution ---
 if __name__ == "__main__":
-    # Initialize and launch interface
-    interface = create_interface()
+    # Create and launch the interface
+    demo = 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
+    # Launch configuration
+    demo.launch(
+        share=False,          # Set to True to create public link
+        server_name="0.0.0.0", # Allow external access
+        server_port=7860,     # Default Gradio port
+        show_error=True,      # Show detailed error messages
+        debug=True            # Enable debug mode
     )