Update app.py

app.py

@@ -20,10 +20,11 @@ from huggingface_hub import hf_hub_download
 from Bio import SeqIO
 from Bio.Seq import Seq
 from Bio.SeqRecord import SeqRecord
+import stat
 
 # --- Global Variables ---
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft.bat")  # Windows path
+MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft")  # Updated 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")
@@ -127,24 +128,41 @@ except Exception as e:
     logging.error(f"Failed to initialize tree analyzer: {e}")
     analyzer = None
 
-# --- Enhanced Tool Detection ---
+# --- Enhanced Tool Detection with Binary Permission Setup ---
+def setup_binary_permissions():
+    """Set executable permissions on MAFFT and IQ-TREE binaries"""
+    binaries = [MAFFT_PATH, IQTREE_PATH]
+    
+    for binary in binaries:
+        if os.path.exists(binary):
+            try:
+                # Set executable permission
+                current_mode = os.stat(binary).st_mode
+                os.chmod(binary, current_mode | stat.S_IEXEC)
+                logging.info(f"Set executable permission on {binary}")
+            except Exception as e:
+                logging.warning(f"Failed to set executable permission on {binary}: {e}")
+        else:
+            logging.warning(f"Binary not found: {binary}")
+
 def check_tool_availability():
     """Enhanced check for MAFFT and IQ-TREE availability with improved path validation"""
     
+    # First, ensure binaries have executable permissions
+    setup_binary_permissions()
+    
     # Check MAFFT
     mafft_available = False
     mafft_cmd = None
     
-    # Try multiple MAFFT locations with actual execution test
+    # Updated MAFFT candidates list based on your new API
     mafft_candidates = [
-        # Your specific path from the error message
-        os.path.join(BASE_DIR, "mafft", "mafftdir", "bin", "mafft"),
-        # Other standard locations
-        MAFFT_PATH,
+        MAFFT_PATH,  # Primary path from your new API
+        os.path.join(BASE_DIR, "binaries", "mafft", "mafft"),
+        os.path.join(BASE_DIR, "binaries", "mafft", "mafft.bat"),  # Windows fallback
         'mafft',
         '/usr/bin/mafft',
         '/usr/local/bin/mafft',
-        'mafft.bat',  # Windows
         os.path.join(BASE_DIR, "binaries", "mafft", "mafftdir", "bin", "mafft"),
         # Add potential conda/miniconda paths
         os.path.expanduser("~/anaconda3/bin/mafft"),
@@ -181,9 +199,9 @@ def check_tool_availability():
     iqtree_available = False
     iqtree_cmd = None
     
-    # Try multiple IQ-TREE locations and names with execution test
+    # Updated IQ-TREE candidates list
     iqtree_candidates = [
-        IQTREE_PATH,
+        IQTREE_PATH,  # Primary path from your new API
         'iqtree2',
         'iqtree',
         'iqtree3',
@@ -194,7 +212,7 @@ def check_tool_availability():
         'iqtree2.exe',  # Windows
         'iqtree.exe',   # Windows
         'iqtree3.exe',  # Windows
-        os.path.join(BASE_DIR, "iqtree", "bin", "iqtree2"),
+        os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree2"),
         # Add potential conda paths
         os.path.expanduser("~/anaconda3/bin/iqtree2"),
         os.path.expanduser("~/miniconda3/bin/iqtree2"),
@@ -257,12 +275,13 @@ If tools are installed but not detected, try:
 1. Add installation directory to PATH
 2. Use absolute paths in the configuration
 3. Check permissions on executable files
+4. Ensure binaries have executable permissions (chmod +x)
 """
     return guide
 
 def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
     """
-    Perform phylogenetic placement using MAFFT + IQ-TREE approach.
+    Improved phylogenetic placement using the new API approach.
     This adds the query sequence to a reference alignment and tree.
     """
     try:
@@ -283,35 +302,21 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
         if not os.path.exists(TREE_PATH):
             return False, f"Reference tree not found: {TREE_PATH}", None, None
 
-        # Save query sequence as FASTA
+        # Save query sequence as FASTA (improved error handling)
         try:
-            query_record = SeqRecord(Seq(sequence.upper()), id=query_id, description="Query sequence")
+            query_record = SeqRecord(Seq(sequence.upper()), id=query_id, description="")
             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
+            return False, f"Error writing query sequence: {e}", None, None
 
-        # Step 1: Add query sequence to reference alignment using MAFFT
+        # Step 1: Add query sequence to reference alignment using MAFFT (improved approach)
         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
-                )
+                mafft_result = subprocess.run([
+                    mafft_cmd, "--add", query_fasta, "--reorder", ALIGNMENT_PATH
+                ], stdout=output_file, stderr=subprocess.PIPE, text=True, timeout=600, 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:
@@ -320,37 +325,22 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
             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"
+            error_msg = e.stderr 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 FileNotFoundError as e:
-            return False, f"MAFFT executable not found: {mafft_cmd}. Please check installation.", None, None
+        except FileNotFoundError:
+            return False, f"MAFFT executable not found: {mafft_cmd}", None, None
         except Exception as e:
-            return False, f"MAFFT alignment error: {str(e)}", None, None
+            return False, f"MAFFT execution error: {e}", None, None
 
-        # Step 2: Place sequence in phylogenetic tree using IQ-TREE
+        # Step 2: Place sequence in phylogenetic tree using IQ-TREE (improved approach)
         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
-            )
+            iqtree_result = subprocess.run([
+                iqtree_cmd, "-s", aligned_with_query, "-g", TREE_PATH,
+                "-m", "GTR+G", "-pre", output_prefix, "-redo"
+            ], capture_output=True, text=True, timeout=1200, check=True)
             
             # Check if treefile was generated
             treefile = f"{output_prefix}.treefile"
@@ -385,10 +375,10 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
             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 FileNotFoundError as e:
-            return False, f"IQ-TREE executable not found: {iqtree_cmd}. Please check installation.", aligned_with_query, None
+        except FileNotFoundError:
+            return False, f"IQ-TREE executable not found: {iqtree_cmd}", aligned_with_query, None
         except Exception as e:
-            return False, f"IQ-TREE placement error: {str(e)}", aligned_with_query, None
+            return False, f"IQ-TREE execution error: {e}", aligned_with_query, None
             
     except Exception as e:
         logging.error(f"Phylogenetic placement failed: {e}")
@@ -403,8 +393,7 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
 
 def build_maximum_likelihood_tree(f_gene_sequence):
     """
-    Build maximum likelihood phylogenetic tree using phylogenetic placement approach.
-    This replaces the previous de novo tree building with placement-based analysis.
+    Build maximum likelihood phylogenetic tree using the improved phylogenetic placement approach.
     """
     try:
         # Check tool availability with enhanced detection
@@ -444,7 +433,7 @@ def build_maximum_likelihood_tree(f_gene_sequence):
             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
+        # Perform phylogenetic placement using improved method
         logging.info("Starting phylogenetic placement...")
         placement_success, placement_message, aligned_file, tree_file = phylogenetic_placement(
             f_gene_sequence, mafft_cmd, iqtree_cmd
@@ -640,7 +629,7 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         else:
             keras_output = "Skipped: sequence too short for F gene validation"
 
-        # Step 3: Maximum Likelihood Tree (Phylogenetic Placement)
+        # Step 3: Maximum Likelihood Tree (Phylogenetic Placement) - Using improved API
         aligned_file = None
         phy_file = None
         ml_tree_output = ""
@@ -665,7 +654,7 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         else:
             ml_tree_output = "Phylogenetic placement skipped (not requested)"
 
-        # Step 4: NEW Simplified Tree Analysis (using the new analyzer API)
+# Step 4: NEW Simplified Tree Analysis (using the new analyzer API)
         html_file = None
         tree_html_content = "No tree generated"
         simplified_ml_output = ""
@@ -683,304 +672,364 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                     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")
+                    safe_seq_name = re.sub(r'[^a-zA-Z0-9_-]', '', processed_sequence[:20])
+                    timestamp = str(int(time.time()))
+                    html_filename = f"tree_{safe_seq_name}_{timestamp}.html"
+                    final_html_path = os.path.join(output_dir, html_filename)
                     
                     # Copy the HTML file
-                    shutil.copy2(html_path, html_filename)
-                    html_file = html_filename
+                    shutil.copy2(html_path, final_html_path)
+                    html_file = final_html_path
                     
                     # Read HTML content for display
-                    with open(html_filename, 'r', encoding='utf-8') as f:
+                    with open(html_path, '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}")
+                    logging.info(f"Tree analysis completed successfully: {html_filename}")
+                    
+                    # Clean up temporary file
+                    try:
+                        os.unlink(html_path)
+                    except:
+                        pass
+                        
                 else:
-                    simplified_ml_output = tree_result or "❌ Failed to generate tree visualization"
-                    logging.warning("Tree analysis failed or no HTML output generated")
+                    simplified_ml_output = tree_result  # Error message
+                    tree_html_content = f"<div style='color: red;'>{tree_result}</div>"
                     
             except Exception as e:
-                simplified_ml_output = f"❌ Simplified ML tree analysis failed: {str(e)}"
-                logging.error(f"Simplified ML tree analysis failed: {e}")
-        elif not analyzer:
-            simplified_ml_output = "❌ Tree analyzer not available (CSV data not loaded)"
-        elif len(processed_sequence) < 10:
-            simplified_ml_output = "❌ Sequence too short for tree analysis (minimum 10 bp)"
+                error_msg = f"❌ Tree analysis failed: {str(e)}"
+                simplified_ml_output = error_msg
+                tree_html_content = f"<div style='color: red;'>{error_msg}</div>"
+                logging.error(f"Tree analysis failed: {e}")
         else:
-            simplified_ml_output = "Tree analysis skipped"
+            if not analyzer:
+                simplified_ml_output = "❌ Tree analyzer not available (CSV data not loaded)"
+            elif len(processed_sequence) < 10:
+                simplified_ml_output = "❌ F gene sequence too short for tree analysis (minimum 10 bp)"
+            else:
+                simplified_ml_output = "❌ No processed sequence available for tree analysis"
+            
+            tree_html_content = f"<div style='color: orange;'>{simplified_ml_output}</div>"
+
+        # Final summary
+        summary_output = f"""
+🧬 ANALYSIS SUMMARY:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📊 INPUT: {len(dna_input)} bp DNA sequence
+🎯 F GENE EXTRACTED: {len(processed_sequence)} bp
+✅ F GENE VALIDATION: {keras_output}
+🌳 PHYLOGENETIC PLACEMENT: {'✅ Completed' if 'successfully' in ml_tree_output else '❌ ' + ('Skipped' if 'skipped' in ml_tree_output else 'Failed')}
+🔬 TREE ANALYSIS: {'✅ Completed' if '✅' in simplified_ml_output else '❌ ' + ('Not available' if 'not available' in simplified_ml_output else 'Failed')}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
 
-        # Prepare final outputs
-        final_boundary_output = f"F gene sequence ({len(processed_sequence)} bp):\n{boundary_output}"
-        final_keras_output = f"F gene validation: {keras_output}"
-        
-        logging.info("Pipeline completed successfully")
-        
         return (
-            final_boundary_output,     # Boundary prediction output
-            final_keras_output,        # Keras prediction output  
-            ml_tree_output,           # ML tree output
-            simplified_ml_output,     # Simplified tree output
-            processed_sequence,       # The extracted F gene sequence
-            aligned_file,             # Alignment file path
-            phy_file,                 # Tree file path
-            html_file,                # HTML tree file path
-            tree_html_content         # HTML content for display
+            boundary_output,  # F gene sequence
+            keras_output,     # F gene validation
+            ml_tree_output,   # Phylogenetic placement
+            simplified_ml_output,  # Tree analysis
+            summary_output,   # Summary
+            aligned_file,     # Alignment file
+            phy_file,         # Tree file
+            html_file,        # HTML tree file
+            tree_html_content # HTML content for display
         )
         
     except Exception as e:
         error_msg = f"Pipeline error: {str(e)}"
         logging.error(error_msg)
-        return error_msg, "", "", "", "", None, None, None, "Pipeline failed"
+        import traceback
+        logging.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg, "", "", "", "", None, None, None, error_msg
+
+# Add missing import
+import time
 
 # --- Gradio Interface ---
-def create_gradio_interface():
+def create_interface():
     """Create and configure the Gradio interface"""
     
-    with gr.Blocks(
-        title="F Gene Analysis Pipeline",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container {
-            max-width: 1200px !important;
-        }
-        .output-html {
-            height: 600px;
-            overflow: auto;
-        }
-        """
-    ) as demo:
-        
-        gr.Markdown("""
-        # 🧬 F Gene Analysis Pipeline
-        
-        This tool performs comprehensive analysis of F gene sequences including:
-        - **Gene Boundary Prediction**: Extract F gene regions from input sequences
-        - **F Gene Validation**: Validate sequences using ML models
-        - **Phylogenetic Analysis**: Build phylogenetic trees and perform sequence placement
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+    .gr-button-primary {
+        background: linear-gradient(45deg, #1e3a8a, #3b82f6);
+        border: none;
+        border-radius: 8px;
+        font-weight: 600;
+    }
+    .gr-button-primary:hover {
+        background: linear-gradient(45deg, #1e40af, #2563eb);
+        transform: translateY(-1px);
+        box-shadow: 0 4px 12px rgba(59, 130, 246, 0.4);
+    }
+    .gr-textbox, .gr-textarea {
+        border-radius: 8px;
+        border: 2px solid #e5e7eb;
+    }
+    .gr-textbox:focus, .gr-textarea:focus {
+        border-color: #3b82f6;
+        box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
+    }
+    .warning-box {
+        background: linear-gradient(135deg, #fef3c7, #fbbf24);
+        border: 1px solid #f59e0b;
+        border-radius: 8px;
+        padding: 12px;
+        margin: 8px 0;
+    }
+    .success-box {
+        background: linear-gradient(135deg, #d1fae5, #10b981);
+        border: 1px solid #059669;
+        border-radius: 8px;
+        padding: 12px;
+        margin: 8px 0;
+    }
+    .error-box {
+        background: linear-gradient(135deg, #fee2e2, #ef4444);
+        border: 1px solid #dc2626;
+        border-radius: 8px;
+        padding: 12px;
+        margin: 8px 0;
+    }
+    """
+    
+    with gr.Blocks(css=custom_css, title="🧬 Advanced Gene Analysis Pipeline", theme=gr.themes.Soft()) as iface:
+        
+        # Header
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border-radius: 15px; margin-bottom: 20px;">
+            <h1 style="color: white; margin: 0; font-size: 2.5em; font-weight: 700;">🧬 Advanced Gene Analysis Pipeline</h1>
+            <p style="color: rgba(255,255,255,0.9); margin: 10px 0 0 0; font-size: 1.2em;">F Gene Boundary Detection • Validation • Phylogenetic Analysis</p>
+        </div>
         """)
         
-        with gr.Tab("Sequence Analysis"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### Input")
-                    
-                    # Input options
-                    input_method = gr.Radio(
-                        choices=["Text Input", "File Upload"],
-                        value="Text Input",
-                        label="Input Method"
-                    )
-                    
-                    # Text input
-                    dna_sequence = gr.Textbox(
-                        label="DNA Sequence",
-                        placeholder="Enter your DNA sequence here (FASTA format or raw sequence)",
-                        lines=8,
-                        visible=True
-                    )
-                    
-                    # File upload
-                    fasta_file = gr.File(
-                        label="Upload FASTA File",
-                        file_types=[".fasta", ".fa", ".txt"],
-                        visible=False
-                    )
+        # Instructions
+        with gr.Accordion("📋 Instructions & Information", open=False):
+            gr.HTML("""
+            <div style="background: #f8fafc; padding: 20px; border-radius: 10px; border-left: 4px solid #3b82f6;">
+                <h3 style="color: #1e40af; margin-top: 0;">🔬 Pipeline Overview</h3>
+                <ol style="line-height: 1.6;">
+                    <li><strong>F Gene Extraction:</strong> Uses boundary-aware model to identify and extract F gene regions</li>
+                    <li><strong>Gene Validation:</strong> Validates extracted sequence as F gene using deep learning</li>
+                    <li><strong>Phylogenetic Placement:</strong> Places sequence in reference phylogenetic tree (MAFFT + IQ-TREE)</li>
+                    <li><strong>Interactive Tree Analysis:</strong> Creates interactive phylogenetic tree with similar sequences</li>
+                </ol>
+                
+                <h3 style="color: #1e40af;">📁 Input Requirements</h3>
+                <ul style="line-height: 1.6;">
+                    <li><strong>DNA Sequence:</strong> Minimum 100 bp for phylogenetic analysis</li>
+                    <li><strong>FASTA Format:</strong> Supported for file uploads</li>
+                    <li><strong>Similarity Score:</strong> 70-99% (default: 95%)</li>
+                </ul>
+                
+                <h3 style="color: #1e40af;">⚙️ Dependencies</h3>
+                <p style="background: #fef3c7; padding: 10px; border-radius: 5px; border-left: 3px solid #f59e0b;">
+                    <strong>Required:</strong> MAFFT and IQ-TREE must be installed for phylogenetic analysis.<br>
+                    <strong>Installation:</strong> <code>conda install -c bioconda mafft iqtree</code>
+                </p>
+            </div>
+            """)
+        
+        # Main input section
+        with gr.Row():
+            with gr.Column(scale=2):
+                gr.HTML("<h3 style='color: #1e40af; margin-bottom: 10px;'>📝 Sequence Input</h3>")
+                
+                # Input tabs
+                with gr.Tabs():
+                    with gr.TabItem("✍️ Text Input"):
+                        dna_input = gr.Textbox(
+                            label="DNA Sequence",
+                            placeholder="Enter your DNA sequence here (A, T, C, G, N)...",
+                            lines=6,
+                            value="",
+                            info="Paste your DNA sequence or enter it manually"
+                        )
                     
-                    # Parameters
-                    gr.Markdown("### Parameters")
-                    similarity_threshold = gr.Slider(
-                        minimum=50,
-                        maximum=99,
-                        value=95,
-                        step=1,
-                        label="Similarity Threshold (%)",
-                        info="For phylogenetic tree analysis"
+                    with gr.TabItem("📁 File Upload"):
+                        fasta_file = gr.File(
+                            label="Upload FASTA File",
+                            file_types=[".fasta", ".fa", ".fas", ".txt"],
+                            type="filepath"
+                        )
+            
+            with gr.Column(scale=1):
+                gr.HTML("<h3 style='color: #1e40af; margin-bottom: 10px;'>⚙️ Analysis Settings</h3>")
+                
+                similarity_score = gr.Slider(
+                    minimum=70.0,
+                    maximum=99.0,
+                    value=95.0,
+                    step=1.0,
+                    label="Similarity Threshold (%)",
+                    info="Minimum similarity for tree analysis"
+                )
+                
+                build_ml_tree = gr.Checkbox(
+                    label="🌳 Enable Phylogenetic Placement",
+                    value=False,
+                    info="Requires MAFFT and IQ-TREE (slower but more accurate)"
+                )
+                
+                # Action buttons
+                with gr.Row():
+                    analyze_text_btn = gr.Button(
+                        "🚀 Analyze Text Input",
+                        variant="primary",
+                        size="lg"
                     )
-                    
-                    build_ml_tree_checkbox = gr.Checkbox(
-                        label="Build Maximum Likelihood Tree",
-                        value=False,
-                        info="Requires MAFFT and IQ-TREE (slower but more comprehensive)"
+                    analyze_file_btn = gr.Button(
+                        "📁 Analyze File",
+                        variant="secondary",
+                        size="lg"
                     )
-                    
-                    # Action buttons
-                    analyze_btn = gr.Button("🚀 Run Analysis", variant="primary", size="lg")
-                    clear_btn = gr.Button("🗑️ Clear", variant="secondary")
-                
-                with gr.Column(scale=2):
-                    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"):
-                            alignment_file = gr.File(
-                                label="Alignment File",
-                                interactive=False
-                            )
-                            
-                            tree_file = gr.File(
-                                label="Tree File",
-                                interactive=False
-                            )
-                            
-                            html_tree_file = gr.File(
-                                label="Interactive Tree (HTML)",
-                                interactive=False
-                            )
         
+        # Results section
+        gr.HTML("<hr style='margin: 30px 0; border: none; height: 2px; background: linear-gradient(to right, #3b82f6, #8b5cf6);'>")
+        gr.HTML("<h2 style='color: #1e40af; text-align: center; margin-bottom: 20px;'>📊 Analysis Results</h2>")
         
-        # Event handlers
-        def toggle_input_method(method):
-            if method == "Text Input":
-                return gr.update(visible=True), gr.update(visible=False)
-            else:
-                return gr.update(visible=False), gr.update(visible=True)
+        # Output tabs
+        with gr.Tabs():
+            with gr.TabItem("🎯 F Gene Extraction"):
+                f_gene_output = gr.Textbox(
+                    label="Extracted F Gene Sequence",
+                    lines=8,
+                    info="Boundary-detected F gene region"
+                )
+            
+            with gr.TabItem("✅ Gene Validation"):
+                keras_output = gr.Textbox(
+                    label="F Gene Validation Result",
+                    lines=3,
+                    info="Deep learning validation of F gene"
+                )
+            
+            with gr.TabItem("🌳 Phylogenetic Placement"):
+                ml_tree_output = gr.Textbox(
+                    label="Phylogenetic Placement Results",
+                    lines=10,
+                    info="MAFFT alignment + IQ-TREE placement results"
+                )
+            
+            with gr.TabItem("🔬 Interactive Tree"):
+                tree_analysis_output = gr.Textbox(
+                    label="Tree Analysis Status",
+                    lines=5,
+                    info="Interactive phylogenetic tree generation"
+                )
+                tree_html_display = gr.HTML(
+                    label="Interactive Phylogenetic Tree",
+                    value="<div style='text-align: center; color: #6b7280; padding: 40px;'>No tree generated yet. Run analysis to create interactive tree.</div>"
+                )
+            
+            with gr.TabItem("📋 Summary"):
+                summary_output = gr.Textbox(
+                    label="Analysis Summary",
+                    lines=12,
+                    info="Complete pipeline summary"
+                )
         
-        input_method.change(
-            toggle_input_method,
-            inputs=[input_method],
-            outputs=[dna_sequence, fasta_file]
-        )
+        # Download section
+        with gr.Accordion("💾 Download Results", open=False):
+            with gr.Row():
+                alignment_file = gr.File(
+                    label="📄 Download Alignment",
+                    visible=True
+                )
+                tree_file = gr.File(
+                    label="🌳 Download Tree",
+                    visible=True
+                )
+                html_tree_file = gr.File(
+                    label="🌐 Download Interactive Tree (HTML)",
+                    visible=True
+                )
         
-        def run_analysis(input_method, dna_seq, file_obj, similarity, build_ml):
-            """Main analysis function"""
-            try:
-                if input_method == "File Upload" and file_obj is not None:
-                    # Process file upload
-                    results = run_pipeline_from_file(file_obj, similarity, build_ml)
-                else:
-                    # Process text input
-                    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
-                
-            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
-                None,  # fasta_file
-                95,  # similarity_threshold
-                False,  # build_ml_tree_checkbox
-                "",  # boundary_output
-                "",  # keras_output
-                "",  # ml_tree_output
-                "",  # tree_analysis_output
-                "",  # extracted_sequence
-                "",  # tree_html
-                None,  # alignment_file
-                None,  # tree_file
-                None   # html_tree_file
-            )
-        
-        # Connect the analyze button
-        analyze_btn.click(
-            fn=run_analysis,
-            inputs=[
-                input_method,
-                dna_sequence,
-                fasta_file,
-                similarity_threshold,
-                build_ml_tree_checkbox
-            ],
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 2px solid #e5e7eb; color: #6b7280;">
+            <p style="margin: 0;">🧬 Advanced Gene Analysis Pipeline | Powered by Deep Learning & Phylogenetics</p>
+            <p style="margin: 5px 0 0 0; font-size: 0.9em;">Built with Gradio • MAFFT • IQ-TREE • TensorFlow</p>
+        </div>
+        """)
+        
+        # Event handlers
+        analyze_text_btn.click(
+            fn=run_pipeline,
+            inputs=[dna_input, similarity_score, build_ml_tree],
             outputs=[
-                boundary_output,
+                f_gene_output,
                 keras_output,
                 ml_tree_output,
                 tree_analysis_output,
-                extracted_sequence,
+                summary_output,
                 alignment_file,
                 tree_file,
                 html_tree_file,
-                tree_html
+                tree_html_display
             ]
         )
         
-        # Connect the clear button
-        clear_btn.click(
-            fn=clear_all,
+        analyze_file_btn.click(
+            fn=run_pipeline_from_file,
+            inputs=[fasta_file, similarity_score, build_ml_tree],
             outputs=[
-                dna_sequence,
-                fasta_file,
-                similarity_threshold,
-                build_ml_tree_checkbox,
-                boundary_output,
+                f_gene_output,
                 keras_output,
                 ml_tree_output,
                 tree_analysis_output,
-                extracted_sequence,
-                tree_html,
+                summary_output,
                 alignment_file,
                 tree_file,
-                html_tree_file
+                html_tree_file,
+                tree_html_display
             ]
         )
     
-    return demo
+    return iface
 
-# --- Main Application ---
+# --- Main Execution ---
 if __name__ == "__main__":
     try:
-        # Initialize the Gradio interface
-        demo = create_gradio_interface()
-        
-        # Launch the application
-        demo.queue(max_size=10)  # Enable queuing for long-running tasks
-        demo.launch(
-            server_name="0.0.0.0",  # Allow external connections
-            server_port=7860,       # Default port
-            share=False,            # Set to True to create public link
-            debug=True,             # Enable debug mode
-            show_error=True         # Show detailed error messages
+        # Print startup information
+        print("🧬 Advanced Gene Analysis Pipeline")
+        print("=" * 50)
+        print(f"Base Directory: {BASE_DIR}")
+        print(f"Boundary Model: {'✅ Loaded' if boundary_model else '❌ Not Available'}")
+        print(f"Keras Model: {'✅ Loaded' if keras_model else '❌ Not Available'}")
+        print(f"Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Not Available'}")
+        
+        # Check tool availability
+        mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
+        print(f"MAFFT: {'✅ Available' if mafft_available else '❌ Not Found'}")
+        print(f"IQ-TREE: {'✅ Available' if iqtree_available else '❌ Not Found'}")
+        
+        if not mafft_available or not iqtree_available:
+            print("\n⚠️  Warning: Some phylogenetic tools are missing!")
+            print("Install with: conda install -c bioconda mafft iqtree")
+        
+        print("\n🚀 Starting Gradio interface...")
+        
+        # Create and launch interface
+        iface = create_interface()
+        iface.launch(
+            share=False,  # Set to True if you want to create a public link
+            server_name="0.0.0.0",  # Allow connections from any IP
+            server_port=7860,       # Default Gradio port
+            show_error=True,
+            show_tips=True,
+            enable_queue=True,      # Enable queuing for long-running tasks
+            max_threads=4           # Limit concurrent processing
         )
         
     except Exception as e:
-        logging.error(f"Failed to launch application: {e}")
-        print(f"❌ Application failed to start: {e}")
+        logging.error(f"Failed to start application: {e}")
+        import traceback
+        print(f"Error: {e}")
+        print(f"Traceback: {traceback.format_exc()}")
+        sys.exit(1)