Update app.py

app.py

@@ -12,75 +12,47 @@ import pandas as pd
 import re
 import logging
 import numpy as np
+from predictor import EnhancedGenePredictor
+from tensorflow.keras.models import load_model
+from analyzer import PhylogeneticTreeAnalyzer
 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
 import stat
 import time
+import asyncio
+from fastapi import FastAPI, File, UploadFile, Form, HTTPException
+from fastapi.responses import HTMLResponse, FileResponse
+from pydantic import BaseModel
+from typing import Optional
+import uvicorn
 
-# Import with error handling
-try:
-    from predictor import EnhancedGenePredictor
-except ImportError as e:
-    logging.warning(f"Failed to import EnhancedGenePredictor: {e}")
-    EnhancedGenePredictor = None
-
-try:
-    from tensorflow.keras.models import load_model
-except ImportError as e:
-    logging.warning(f"Failed to import TensorFlow: {e}")
-    load_model = None
-
+# --- Logging Setup ---
+log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+log_handler = logging.StreamHandler()
+log_handler.setFormatter(log_formatter)
 try:
-    from analyzer import PhylogeneticTreeAnalyzer
-except ImportError as e:
-    logging.warning(f"Failed to import PhylogeneticTreeAnalyzer: {e}")
-    PhylogeneticTreeAnalyzer = None
+    file_handler = logging.FileHandler('/tmp/app.log')
+    file_handler.setFormatter(log_formatter)
+    logging.basicConfig(level=logging.INFO, handlers=[log_handler, file_handler])
+except Exception as e:
+    logging.basicConfig(level=logging.INFO, handlers=[log_handler])
+    logging.warning(f"Failed to set up file logging: {e}")
 
-try:
-    from huggingface_hub import hf_hub_download
-except ImportError as e:
-    logging.warning(f"Failed to import huggingface_hub: {e}")
-    hf_hub_download = None
+logger = logging.getLogger(__name__)
+logger.info(f"Gradio version: {gr.__version__}")
 
+# Set event loop policy for compatibility with Gradio Spaces
 try:
-    from Bio import SeqIO
-    from Bio.Seq import Seq
-    from Bio.SeqRecord import SeqRecord
-except ImportError as e:
-    logging.warning(f"Failed to import BioPython: {e}")
-    SeqIO = None
-
-# --- Logging Setup ---
-def setup_logging():
-    """Setup logging configuration"""
-    try:
-        log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-        log_handler = logging.StreamHandler()
-        log_handler.setFormatter(log_formatter)
-        
-        # Try to setup file logging, fallback if it fails
-        handlers = [log_handler]
-        try:
-            file_handler = logging.FileHandler('/tmp/app.log')
-            file_handler.setFormatter(log_formatter)
-            handlers.append(file_handler)
-        except Exception as e:
-            print(f"Warning: Failed to set up file logging: {e}")
-        
-        logging.basicConfig(level=logging.INFO, handlers=handlers, force=True)
-        logger = logging.getLogger(__name__)
-        logger.info(f"Gradio version: {gr.__version__}")
-        return logger
-    except Exception as e:
-        print(f"Critical: Failed to setup logging: {e}")
-        # Create basic logger
-        logging.basicConfig(level=logging.INFO)
-        return logging.getLogger(__name__)
-
-logger = setup_logging()
+    asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+except Exception as e:
+    logger.warning(f"Failed to set event loop policy: {e}")
 
 # --- Global Variables ---
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -89,13 +61,7 @@ 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")
-
-# Ensure output directory exists
-try:
-    os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
-    os.makedirs("/tmp", exist_ok=True)
-except Exception as e:
-    logger.warning(f"Failed to create directories: {e}")
+os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
 
 # Model repository and file paths
 MODEL_REPO = "GGproject10/best_boundary_aware_model"
@@ -107,815 +73,730 @@ keras_model = None
 kmer_to_index = None
 analyzer = None
 
-# --- Safe Model Loading ---
+# --- Model Loading ---
 def load_models_safely():
-    """Load models with comprehensive error handling"""
     global boundary_model, keras_model, kmer_to_index, analyzer
-    
-    logger.info("🔍 Starting model loading...")
-    
-    # Load boundary model
-    if EnhancedGenePredictor and hf_hub_download:
-        try:
-            logger.info("Loading boundary model...")
-            boundary_path = hf_hub_download(
-                repo_id=MODEL_REPO,
-                filename="best_boundary_aware_model.pth",
-                token=None
-            )
-            if os.path.exists(boundary_path):
-                boundary_model = EnhancedGenePredictor(boundary_path)
-                logger.info("✅ Boundary model loaded successfully.")
-            else:
-                logger.error("❌ Boundary model file not found after download.")
-        except Exception as e:
-            logger.error(f"❌ Failed to load boundary model: {e}")
-            boundary_model = None
-    else:
-        logger.warning("⚠️ EnhancedGenePredictor or hf_hub_download not available")
-    
-    # Load Keras model
-    if load_model and hf_hub_download:
-        try:
-            logger.info("Loading Keras model...")
-            keras_path = hf_hub_download(
-                repo_id=MODEL_REPO,
-                filename="best_model.keras",
-                token=None
-            )
-            kmer_path = hf_hub_download(
-                repo_id=MODEL_REPO,
-                filename="kmer_to_index.pkl",
-                token=None
-            )
-            
-            if os.path.exists(keras_path) and os.path.exists(kmer_path):
-                keras_model = load_model(keras_path)
-                with open(kmer_path, "rb") as f:
-                    kmer_to_index = pickle.load(f)
-                logger.info("✅ Keras model and k-mer index loaded successfully.")
-            else:
-                logger.error("❌ Keras model or k-mer files not found.")
-        except Exception as e:
-            logger.error(f"❌ Failed to load Keras model: {e}")
-            keras_model = None
-            kmer_to_index = None
-    else:
-        logger.warning("⚠️ TensorFlow load_model or hf_hub_download not available")
-    
-    # Load tree analyzer
-    if PhylogeneticTreeAnalyzer:
-        try:
-            logger.info("🌳 Initializing tree analyzer...")
-            analyzer = PhylogeneticTreeAnalyzer()
-            
-            # Try to find CSV file
-            csv_candidates = [
-                CSV_PATH,
-                os.path.join(BASE_DIR, CSV_PATH),
-                os.path.join(BASE_DIR, "app", CSV_PATH),
-                os.path.join(os.path.dirname(__file__), CSV_PATH),
-                "f_cleaned.csv",
-                os.path.join(BASE_DIR, "f_cleaned.csv")
-            ]
-            
-            csv_loaded = False
-            for csv_candidate in csv_candidates:
-                if os.path.exists(csv_candidate):
-                    logger.info(f"📊 Trying CSV: {csv_candidate}")
-                    try:
-                        if analyzer.load_data(csv_candidate):
-                            logger.info(f"✅ CSV loaded from: {csv_candidate}")
-                            csv_loaded = True
-                            break
-                    except Exception as e:
-                        logger.warning(f"CSV load failed for {csv_candidate}: {e}")
-                        continue
-            
-            if not csv_loaded:
-                logger.error("❌ Failed to load CSV data from any candidate location.")
-                analyzer = None
-            else:
+    logger.info("🔍 Loading models...")
+    try:
+        boundary_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename="best_boundary_aware_model.pth",
+            token=None
+        )
+        if os.path.exists(boundary_path):
+            boundary_model = EnhancedGenePredictor(boundary_path)
+            logger.info("✅ Boundary model loaded successfully.")
+        else:
+            logger.error(f"❌ Boundary model file not found after download.")
+    except Exception as e:
+        logger.error(f"❌ Failed to load boundary model: {e}")
+        boundary_model = None
+    try:
+        keras_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename="best_model.keras",
+            token=None
+        )
+        kmer_path = hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename="kmer_to_index.pkl",
+            token=None
+        )
+        if os.path.exists(keras_path) and os.path.exists(kmer_path):
+            keras_model = load_model(keras_path)
+            with open(kmer_path, "rb") as f:
+                kmer_to_index = pickle.load(f)
+            logger.info("✅ Keras model and k-mer index loaded successfully.")
+        else:
+            logger.error(f"❌ Keras model or k-mer files not found.")
+    except Exception as e:
+        logger.error(f"❌ Failed to load Keras model: {e}")
+        keras_model = None
+        kmer_to_index = None
+    try:
+        logger.info("🌳 Initializing tree analyzer...")
+        analyzer = PhylogeneticTreeAnalyzer()
+        csv_candidates = [
+            CSV_PATH,
+            os.path.join(BASE_DIR, CSV_PATH),
+            os.path.join(BASE_DIR, "app", CSV_PATH),
+            os.path.join(os.path.dirname(__file__), CSV_PATH),
+            "f_cleaned.csv",
+            os.path.join(BASE_DIR, "f_cleaned.csv")
+        ]
+        csv_loaded = False
+        for csv_candidate in csv_candidates:
+            if os.path.exists(csv_candidate):
+                logger.info(f"📊 Trying CSV: {csv_candidate}")
                 try:
-                    if hasattr(analyzer, 'train_ai_model') and analyzer.train_ai_model():
-                        logger.info("✅ AI model training completed successfully")
-                    else:
-                        logger.warning("⚠️ AI model training failed; proceeding with basic analysis.")
+                    if analyzer.load_data(csv_candidate):
+                        logger.info(f"✅ CSV loaded from: {csv_candidate}")
+                        csv_loaded = True
+                        break
                 except Exception as e:
-                    logger.warning(f"⚠️ AI model training failed: {e}")
-                    
-        except Exception as e:
-            logger.error(f"❌ Tree analyzer initialization failed: {e}")
+                    logger.warning(f"CSV load failed for {csv_candidate}: {e}")
+                    continue
+        if not csv_loaded:
+            logger.error("❌ Failed to load CSV data from any candidate location.")
             analyzer = None
-    else:
-        logger.warning("⚠️ PhylogeneticTreeAnalyzer not available")
+        else:
+            try:
+                if analyzer.train_ai_model():
+                    logger.info("✅ AI model training completed successfully")
+                else:
+                    logger.warning("⚠️ AI model training failed; proceeding with basic analysis.")
+            except Exception as e:
+                logger.warning(f"⚠️ AI model training failed: {e}")
+    except Exception as e:
+        logger.error(f"❌ Tree analyzer initialization failed: {e}")
+        analyzer = None
+
+# Load models at startup
+load_models_safely()
 
 # --- Tool Detection ---
 def setup_binary_permissions():
-    """Set executable permissions on binary files"""
+    for binary in [MAFFT_PATH, IQTREE_PATH]:
+        if os.path.exists(binary):
+            try:
+                os.chmod(binary, os.stat(binary).st_mode | stat.S_IEXEC)
+                logger.info(f"Set executable permission on {binary}")
+            except Exception as e:
+                logger.warning(f"Failed to set permission on {binary}: {e}")
+
+def check_tool_availability():
+    setup_binary_permissions()
+    mafft_available = False
+    mafft_cmd = None
+    mafft_candidates = ['mafft', '/usr/bin/mafft', '/usr/local/bin/mafft', MAFFT_PATH]
+    for candidate in mafft_candidates:
+        if shutil.which(candidate) or os.path.exists(candidate):
+            try:
+                result = subprocess.run(
+                    [candidate, "--help"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5
+                )
+                if result.returncode == 0 or "mafft" in result.stderr.lower():
+                    mafft_available = True
+                    mafft_cmd = candidate
+                    logger.info(f"✅ MAFFT found at: {candidate}")
+                    break
+            except Exception as e:
+                logger.debug(f"MAFFT test failed for {candidate}: {e}")
+    iqtree_available = False
+    iqtree_cmd = None
+    iqtree_candidates = ['iqtree', 'iqtree2', 'iqtree3', '/usr/bin/iqtree', '/usr/local/bin/iqtree', IQTREE_PATH]
+    for candidate in iqtree_candidates:
+        if shutil.which(candidate) or os.path.exists(candidate):
+            try:
+                result = subprocess.run(
+                    [candidate, "--help"],
+                    capture_output=True,
+                    text=True,
+                    timeout=5
+                )
+                if result.returncode == 0 or "iqtree" in result.stderr.lower():
+                    iqtree_available = True
+                    iqtree_cmd = candidate
+                    logger.info(f"✅ IQ-TREE found at: {candidate}")
+                    break
+            except Exception as e:
+                logger.debug(f"IQ-TREE test failed for {candidate}: {e}")
+    return mafft_available, iqtree_available, mafft_cmd, iqtree_cmd
+
+# --- Pipeline Functions ---
+def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
     try:
-        for binary in [MAFFT_PATH, IQTREE_PATH]:
-            if os.path.exists(binary):
-                try:
-                    os.chmod(binary, os.stat(binary).st_mode | stat.S_IEXEC)
-                    logger.info(f"Set executable permission on {binary}")
-                except Exception as e:
-                    logger.warning(f"Failed to set permission on {binary}: {e}")
+        if len(sequence.strip()) < 100:
+            return False, "Sequence too short (<100 bp).", None, None
+        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")
+        if not os.path.exists(ALIGNMENT_PATH) or not os.path.exists(TREE_PATH):
+            return False, "Reference alignment or tree not found.", None, None
+        query_record = SeqRecord(Seq(sequence.upper()), id=query_id, description="")
+        SeqIO.write([query_record], query_fasta, "fasta")
+        with open(aligned_with_query, "w") as output_file:
+            subprocess.run([
+                mafft_cmd, "--add", query_fasta, "--reorder", ALIGNMENT_PATH
+            ], stdout=output_file, stderr=subprocess.PIPE, text=True, timeout=600, check=True)
+        if not os.path.exists(aligned_with_query) or os.path.getsize(aligned_with_query) == 0:
+            return False, "MAFFT alignment failed.", None, None
+        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)
+        treefile = f"{output_prefix}.treefile"
+        if not os.path.exists(treefile):
+            return False, "IQ-TREE placement failed.", aligned_with_query, None
+        success_msg = f"Placement completed!\nQuery ID: {query_id}\nAlignment: {os.path.basename(aligned_with_query)}\nTree: {os.path.basename(treefile)}"
+        return True, success_msg, aligned_with_query, treefile
     except Exception as e:
-        logger.warning(f"Binary permission setup failed: {e}")
+        logger.error(f"Phylogenetic placement failed: {e}", exc_info=True)
+        return False, f"Error: {str(e)}", None, None
+    finally:
+        if 'query_fasta' in locals() and os.path.exists(query_fasta):
+            try:
+                os.unlink(query_fasta)
+            except Exception as e:  # Fixed bare 'except'
+                logger.warning(f"Failed to clean up {query_fasta}: {e}")
 
-def check_tool_availability():
-    """Check if required tools are available"""
+def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
     try:
-        setup_binary_permissions()
-        
-        # Check MAFFT
-        mafft_available = False
-        mafft_cmd = None
-        mafft_candidates = ['mafft', '/usr/bin/mafft', '/usr/local/bin/mafft', MAFFT_PATH]
-        
-        for candidate in mafft_candidates:
-            if shutil.which(candidate) or os.path.exists(candidate):
-                try:
-                    result = subprocess.run(
-                        [candidate, "--help"],
-                        capture_output=True,
-                        text=True,
-                        timeout=5
-                    )
-                    if result.returncode == 0 or "mafft" in result.stderr.lower():
-                        mafft_available = True
-                        mafft_cmd = candidate
-                        logger.info(f"✅ MAFFT found at: {candidate}")
-                        break
-                except Exception as e:
-                    logger.debug(f"MAFFT test failed for {candidate}: {e}")
-        
-        # Check IQ-TREE
-        iqtree_available = False
-        iqtree_cmd = None
-        iqtree_candidates = ['iqtree', 'iqtree2', 'iqtree3', '/usr/bin/iqtree', '/usr/local/bin/iqtree', IQTREE_PATH]
-        
-        for candidate in iqtree_candidates:
-            if shutil.which(candidate) or os.path.exists(candidate):
-                try:
-                    result = subprocess.run(
-                        [candidate, "--help"],
-                        capture_output=True,
-                        text=True,
-                        timeout=5
-                    )
-                    if result.returncode == 0 or "iqtree" in result.stderr.lower():
-                        iqtree_available = True
-                        iqtree_cmd = candidate
-                        logger.info(f"✅ IQ-TREE found at: {candidate}")
-                        break
-                except Exception as e:
-                    logger.debug(f"IQ-TREE test failed for {candidate}: {e}")
-        
-        return mafft_available, iqtree_available, mafft_cmd, iqtree_cmd
-    
+        logger.debug("Starting tree analysis...")
+        if not analyzer:
+            return "❌ Tree analyzer not initialized.", None, None
+        if not sequence or len(sequence.strip()) < 10:
+            return "❌ Invalid sequence.", None, None
+        if not (1 <= matching_percentage <= 99):
+            return "❌ Matching percentage must be 1-99.", None, None
+        logger.debug("Finding query sequence...")
+        if not analyzer.find_query_sequence(sequence):
+            return "❌ Sequence not accepted.", None, None
+        logger.debug("Finding similar sequences...")
+        matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
+        if not matched_ids:
+            return f"❌ No similar sequences at {matching_percentage}% threshold.", None, None
+        logger.debug("Building tree structure...")
+        analyzer.build_tree_structure_with_ml_safe(matched_ids)
+        logger.debug("Creating interactive tree...")
+        fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
+        query_id = analyzer.query_id or f"query_{int(time.time())}"
+        tree_html_path = os.path.join("/tmp", f'phylogenetic_tree_{query_id}.html')
+        logger.debug(f"Saving tree to {tree_html_path}")
+        fig.write_html(tree_html_path)
+        analyzer.matching_percentage = matching_percentage
+        logger.debug("Generating detailed report...")
+        report_success = analyzer.generate_detailed_report(matched_ids, actual_percentage)
+        report_html_path = os.path.join("/tmp", f'detailed_report_{query_id}.html') if report_success else None
+        logger.debug(f"Tree analysis completed: {len(matched_ids)} matches")
+        return f"✅ Found {len(matched_ids)} sequences at {actual_percentage:.2f}% similarity.", tree_html_path, report_html_path
     except Exception as e:
-        logger.error(f"Tool availability check failed: {e}")
-        return False, False, None, None
+        logger.error(f"Tree analysis failed: {e}", exc_info=True)
+        return f"❌ Error: {str(e)}", None, None
 
-# --- Core Functions ---
 def predict_with_keras(sequence):
-    """Predict using Keras model with error handling"""
     try:
         if not keras_model or not kmer_to_index:
             return "❌ Keras model not available."
-        
         if len(sequence) < 6:
             return "❌ Sequence too short (<6 bp)."
-        
-        # Generate k-mers
         kmers = [sequence[i:i+6] for i in range(len(sequence)-5)]
         indices = [kmer_to_index.get(kmer, 0) for kmer in kmers]
-        
-        # Make prediction
         input_arr = np.array([indices])
         prediction = keras_model.predict(input_arr, verbose=0)[0]
         f_gene_prob = prediction[-1]
-        
-        # Convert to percentage
         percentage = min(100, max(0, int(f_gene_prob * 100 + 5)))
         return f"✅ {percentage}% F gene confidence"
-        
     except Exception as e:
-        logger.error(f"Keras prediction failed: {e}")
+        logger.error(f"Keras prediction failed: {e}", exc_info=True)
         return f"❌ Error: {str(e)}"
 
 def read_fasta_file(file_obj):
-    """Read FASTA file with error handling"""
     try:
         if file_obj is None:
             return ""
-        
         if isinstance(file_obj, str):
             with open(file_obj, "r") as f:
                 content = f.read()
         else:
             content = file_obj.read().decode("utf-8")
-        
-        # Extract sequence lines (non-header lines)
         lines = content.strip().split("\n")
         seq_lines = [line.strip() for line in lines if not line.startswith(">")]
         return ''.join(seq_lines)
-        
     except Exception as e:
-        logger.error(f"Failed to read FASTA file: {e}")
+        logger.error(f"Failed to read FASTA file: {e}", exc_info=True)
         return ""
+import gradio as gr
 
-def analyze_sequence_basic(sequence, similarity_score=95.0):
-    """Basic sequence analysis without external tools"""
-    try:
-        if not sequence or len(sequence.strip()) < 10:
-            return "❌ Invalid sequence.", None, None
-        
-        # Clean sequence
-        clean_seq = re.sub(r'[^ATCGN]', 'N', sequence.upper())
-        
-        # Basic analysis
-        length = len(clean_seq)
-        gc_content = (clean_seq.count('G') + clean_seq.count('C')) / length * 100
-        n_content = clean_seq.count('N') / length * 100
-        
-        analysis_result = f"""
-        ✅ Basic Analysis Complete
-        • Length: {length} bp
-        • GC Content: {gc_content:.1f}%
-        • N Content: {n_content:.1f}%
-        • Similarity Threshold: {similarity_score}%
-        """
-        
-        return analysis_result, None, None
-        
-    except Exception as e:
-        logger.error(f"Basic analysis failed: {e}")
-        return f"❌ Analysis error: {str(e)}", None, None
-
-def run_pipeline_safe(dna_input, similarity_score=95.0, build_ml_tree=False):
-    """Safe pipeline execution with comprehensive error handling"""
+@gr.queue()
+def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
     try:
-        # Input validation
-        if not dna_input or not dna_input.strip():
-            return "❌ Empty input", "", "", "", "No input provided", None, None, None, None, "No input", "No input", None, None
-        
-        # Clean and validate sequence
         dna_input = dna_input.upper().strip()
-        if not re.match('^[ACTGN\s\n\r]+$', dna_input):
-            # Remove invalid characters
-            dna_input = re.sub(r'[^ACTGN]', 'N', dna_input)
-        
-        # Remove whitespace
-        processed_sequence = re.sub(r'\s+', '', dna_input)
-        
-        logger.info(f"Processing sequence of length: {len(processed_sequence)}")
-        
-        # Boundary detection
+        if not dna_input:
+            return "❌ Empty input", "", "", "", "", None, None, None, None, "No input", "No input", None, None
+        if not re.match('^[ACTGN]+$', dna_input):
+            dna_input = ''.join(c if c in 'ACTGN' else 'N' for c in dna_input)
+        processed_sequence = dna_input
         boundary_output = ""
         if boundary_model:
             try:
-                result = boundary_model.predict_sequence(processed_sequence)
-                if hasattr(result, 'get') and result.get('gene_regions'):
-                    regions = result['gene_regions']
-                    if regions:
-                        processed_sequence = regions[0]["sequence"]
-                        boundary_output = f"✅ F gene region found: {len(processed_sequence)} bp"
-                    else:
-                        boundary_output = "⚠️ No F gene regions found."
+                result = boundary_model.predict_sequence(dna_input)
+                regions = result['gene_regions']
+                if regions:
+                    processed_sequence = regions[0]["sequence"]
+                    boundary_output = f"✅ F gene region found: {len(processed_sequence)} bp"
                 else:
-                    boundary_output = "⚠️ Boundary detection completed (no regions found)."
+                    boundary_output = "⚠️ No F gene regions found."
+                    processed_sequence = dna_input
             except Exception as e:
-                logger.error(f"Boundary prediction error: {e}")
                 boundary_output = f"❌ Boundary prediction error: {str(e)}"
+                processed_sequence = dna_input
         else:
-            boundary_output = f"⚠️ Boundary model not available. Using full input: {len(processed_sequence)} bp"
-        
-        # Keras prediction
-        keras_output = ""
-        if len(processed_sequence) >= 6:
-            keras_output = predict_with_keras(processed_sequence)
-        else:
-            keras_output = "❌ Sequence too short for classification."
-        
-        # ML Tree analysis (simplified for now)
+            boundary_output = f"⚠️ Boundary model not available. Using full input: {len(dna_input)} bp"
+        keras_output = predict_with_keras(processed_sequence) if processed_sequence and len(processed_sequence) >= 6 else "❌ Sequence too short."
+        aligned_file = None
+        phy_file = None
         ml_tree_output = ""
-        if build_ml_tree:
-            if len(processed_sequence) >= 100:
-                try:
-                    mafft_available, iqtree_available, _, _ = check_tool_availability()
-                    if mafft_available and iqtree_available:
-                        ml_tree_output = "⚠️ ML tree analysis not implemented in safe mode."
-                    else:
-                        ml_tree_output = "❌ MAFFT or IQ-TREE not available"
-                except Exception as e:
-                    ml_tree_output = f"❌ ML tree error: {str(e)}"
-            else:
-                ml_tree_output = "❌ Sequence too short for ML tree (<100 bp)."
+        if build_ml_tree and processed_sequence and len(processed_sequence) >= 100:
+            try:
+                mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
+                if mafft_available and iqtree_available:
+                    ml_success, ml_message, ml_aligned, ml_tree = phylogenetic_placement(processed_sequence, mafft_cmd, iqtree_cmd)
+                    ml_tree_output = ml_message
+                    aligned_file = ml_aligned
+                    phy_file = ml_tree
+                else:
+                    ml_tree_output = "❌ MAFFT or IQ-TREE not available"
+            except Exception as e:
+                ml_tree_output = f"❌ ML tree error: {str(e)}"
+        elif build_ml_tree:
+            ml_tree_output = "❌ Sequence too short for placement (<100 bp)."
         else:
-            ml_tree_output = "⚠️ ML tree analysis skipped."
-        
-        # Tree analysis
-        tree_analysis_output = ""
-        tree_html_content = "<div style='text-align: center; color: #666; padding: 50px;'>Tree analysis not available in safe mode.</div>"
-        report_html_content = "<div style='text-align: center; color: #666; padding: 50px;'>Report not available in safe mode.</div>"
-        
-        if analyzer and len(processed_sequence) >= 10:
+            ml_tree_output = "⚠️ Phylogenetic placement skipped."
+        tree_html_content = "No tree generated."
+        report_html_content = "No report generated."
+        tree_html_path = None
+        report_html_path = None
+        simplified_ml_output = ""
+        if analyzer and processed_sequence and len(processed_sequence) >= 10:
             try:
-                result, _, _ = analyze_sequence_basic(processed_sequence, similarity_score)
-                tree_analysis_output = result
-                tree_html_content = f"<div style='padding: 20px;'><h3>Basic Analysis</h3><pre>{result}</pre></div>"
-                report_html_content = tree_html_content
+                tree_result, tree_html_path, report_html_path = analyze_sequence_for_tree(processed_sequence, similarity_score)
+                simplified_ml_output = tree_result
+                if tree_html_path and os.path.exists(tree_html_path):
+                    with open(tree_html_path, 'r', encoding='utf-8') as f:
+                        tree_html_content = f.read()
+                else:
+                    tree_html_content = f"<div style='color: red;'>{tree_result}</div>"
+                if report_html_path and os.path.exists(report_html_path):
+                    with open(report_html_path, 'r', encoding='utf-8') as f:
+                        report_html_content = f.read()
+                else:
+                    report_html_content = f"<div style='color: red;'>{tree_result}</div>"
             except Exception as e:
-                logger.error(f"Tree analysis error: {e}")
-                tree_analysis_output = f"❌ Tree analysis error: {str(e)}"
+                simplified_ml_output = f"❌ Tree analysis error: {str(e)}"
+                tree_html_content = f"<div style='color: red;'>{simplified_ml_output}</div>"
+                report_html_content = f"<div style='color: red;'>{simplified_ml_output}</div>"
         else:
-            tree_analysis_output = "❌ Tree analyzer not available or sequence too short."
-        
-        # Create summary
+            simplified_ml_output = "❌ Tree analyzer not available." if not analyzer else "❌ Sequence too short (<10 bp)."
+            tree_html_content = f"<div style='color: orange;'>{simplified_ml_output}</div>"
+            report_html_content = f"<div style='color: orange;'>{simplified_ml_output}</div>"
         summary_output = f"""
 📊 ANALYSIS SUMMARY:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Input Length: {len(dna_input)} bp
-Processed Length: {len(processed_sequence)} bp
-Boundary Detection: {'✅ Active' if boundary_model else '❌ Unavailable'}
-Classification: {'✅ Active' if keras_model else '❌ Unavailable'}
-ML Tree: {'✅ Requested' if build_ml_tree else '⚠️ Skipped'}
-Tree Analysis: {'✅ Active' if analyzer else '❌ Unavailable'}
+Input: {len(dna_input)} bp
+F Gene: {len(processed_sequence)} bp
+Validation: {keras_output.split(':')[-1].strip() if ':' in keras_output else keras_output}
+Placement: {'✅ OK' if '✅' in ml_tree_output else '⚠️ Skipped' if 'skipped' in ml_tree_output else '❌ Failed'}
+Tree Analysis: {'✅ OK' if 'Found' in simplified_ml_output else '❌ Failed'}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Results:
-• Boundary: {boundary_output.split(':')[-1].strip() if ':' in boundary_output else boundary_output}
-• Classification: {keras_output.split(':')[-1].strip() if ':' in keras_output else keras_output}
-• ML Tree: {'Requested' if build_ml_tree else 'Skipped'}
-• Analysis: {'Completed' if '✅' in tree_analysis_output else 'Failed'}
 """
-        
         return (
-            boundary_output,
-            keras_output,
-            ml_tree_output,
-            tree_analysis_output,
-            summary_output,
-            None,  # aligned_file
-            None,  # phy_file
-            None,  # additional_file_1
-            None,  # additional_file_2
-            tree_html_content,
-            report_html_content,
-            None,  # tree_html_path
-            None   # report_html_path
+            boundary_output, keras_output, ml_tree_output, simplified_ml_output, summary_output,
+            aligned_file, phy_file, None, None, tree_html_content, report_html_content,
+            tree_html_path, report_html_path
         )
-        
     except Exception as e:
         logger.error(f"Pipeline error: {e}", exc_info=True)
         error_msg = f"❌ Pipeline Error: {str(e)}"
-        return (
-            error_msg, "", "", "", error_msg,
-            None, None, None, None,
-            f"<div style='color: red;'>{error_msg}</div>",
-            f"<div style='color: red;'>{error_msg}</div>",
-            None, None
+        return error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg, None, None
+
+@gr.queue()
+async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
+    temp_file_path = None
+    try:
+        if fasta_file_obj is None:
+            return "❌ No file provided", "", "", "", "", None, None, None, None, "No input", "No input", None, None
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".fasta", dir="/tmp") as temp_file:
+            if isinstance(fasta_file_obj, UploadFile):
+                content = await fasta_file_obj.read()
+                temp_file.write(content)
+            else:
+                with open(fasta_file_obj, 'rb') as f:
+                    content = f.read()
+                temp_file.write(content)
+            temp_file_path = temp_file.name
+        dna_input = read_fasta_file(temp_file_path)
+        if not dna_input:
+            return "❌ Failed to read FASTA file", "", "", "", "", None, None, None, None, "No input", "No input", None, None
+        return run_pipeline(dna_input, similarity_score, build_ml_tree)
+    except Exception as e:
+        logger.error(f"Pipeline from file error: {e}", exc_info=True)
+        error_msg = f"❌ Error: {str(e)}"
+        return error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg, None, None
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            try:
+                os.unlink(temp_file_path)
+            except Exception as e:
+                logger.warning(f"Failed to delete temp file {temp_file_path}: {e}")
+# --- Pydantic Models ---
+class AnalysisRequest(BaseModel):
+    sequence: str
+    similarity_score: float = 95.0
+    build_ml_tree: bool = False
+
+class AnalysisResponse(BaseModel):
+    boundary_output: str
+    keras_output: str
+    ml_tree_output: str
+    tree_analysis_output: str
+    summary_output: str
+    success: bool
+    error_message: Optional[str] = None
+    tree_html_path: Optional[str] = None
+    report_html_path: Optional[str] = None
+
+# --- FastAPI App Setup ---
+app = FastAPI(title="🧬 Gene Analysis Pipeline", version="1.0.0")
+
+@app.get("/")
+async def root():
+    return {
+        "message": "🧬 Gene Analysis Pipeline API",
+        "status": "running",
+        "endpoints": {
+            "docs": "/docs",
+            "health": "/health",
+            "gradio": "/gradio",
+            "analyze": "/analyze",
+            "analyze_file": "/analyze-file",
+            "download": "/download/{file_type}/{query_id}"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    try:
+        mafft_available, iqtree_available, _, _ = check_tool_availability()
+        return {
+            "status": "healthy",
+            "components": {
+                "boundary_model": boundary_model is not None,
+                "keras_model": keras_model is not None,
+                "tree_analyzer": analyzer is not None,
+                "mafft_available": mafft_available,
+                "iqtree_available": iqtree_available
+            },
+            "paths": {
+                "base_dir": BASE_DIR,
+                "query_output_dir": QUERY_OUTPUT_DIR
+            }
+        }
+    except Exception as e:
+        logger.error(f"Health check error: {e}", exc_info=True)
+        return {"status": "unhealthy", "error": str(e)}
+
+@app.post("/analyze", response_model=AnalysisResponse)
+async def analyze_sequence(request: AnalysisRequest):
+    try:
+        result = run_pipeline(request.sequence, request.similarity_score, request.build_ml_tree)
+        return AnalysisResponse(
+            boundary_output=result[0] or "",
+            keras_output=result[1] or "",
+            ml_tree_output=result[2] or "",
+            tree_analysis_output=result[3] or "",
+            summary_output=result[4] or "",
+            tree_html_path=result[11],
+            report_html_path=result[12],
+            success=True
+        )
+    except Exception as e:
+        logger.error(f"Analyze error: {e}", exc_info=True)
+        return AnalysisResponse(
+            boundary_output="", keras_output="", ml_tree_output="",
+            tree_analysis_output="", summary_output="",
+            tree_html_path=None, report_html_path=None,
+            success=False, error_message=str(e)
+        )
+
+@app.post("/analyze-file")
+async def analyze_file(
+    file: UploadFile = File(...),
+    similarity_score: float = Form(95.0),
+    build_ml_tree: bool = Form(False)
+):
+    temp_file_path = None
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".fasta", dir="/tmp") as temp_file:
+            content = await file.read()
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        result = await run_pipeline_from_file(temp_file_path, similarity_score, build_ml_tree)
+        return AnalysisResponse(
+            boundary_output=result[0] or "",
+            keras_output=result[1] or "",
+            ml_tree_output=result[2] or "",
+            tree_analysis_output=result[3] or "",
+            summary_output=result[4] or "",
+            tree_html_path=result[11],
+            report_html_path=result[12],
+            success=True
         )
+    except Exception as e:
+        logger.error(f"Analyze-file error: {e}", exc_info=True)
+        return AnalysisResponse(
+            boundary_output="", keras_output="", ml_tree_output="",
+            tree_analysis_output="", summary_output="",
+            tree_html_path=None, report_html_path=None,
+            success=False, error_message=str(e)
+        )
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            try:
+                os.unlink(temp_file_path)
+            except Exception as e:
+                logger.warning(f"Failed to clean up {temp_file_path}: {e}")
+
+@app.get("/download/{file_type}/{query_id}")
+async def download_file(file_type: str, query_id: str):
+    try:
+        if file_type not in ["tree", "report"]:
+            raise HTTPException(status_code=400, detail="Invalid file type. Use 'tree' or 'report'.")
+        file_name = f"phylogenetic_tree_{query_id}.html" if file_type == "tree" else f"detailed_report_{query_id}.html"
+        file_path = os.path.join("/tmp", file_name)
+        if not os.path.exists(file_path):
+            raise HTTPException(status_code=404, detail="File not found.")
+        return FileResponse(file_path, filename=file_name, media_type="text/html")
+    except Exception as e:
+        logger.error(f"Download error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error serving file: {str(e)}")
 
 # --- Gradio Interface ---
-def create_safe_gradio_interface():
-    """Create a safe Gradio interface with comprehensive error handling"""
+def create_gradio_interface():
     try:
         with gr.Blocks(
             title="🧬 Gene Analysis Pipeline",
             theme=gr.themes.Soft(),
             css="""
-            .gradio-container { 
-                max-width: 1200px !important; 
-                margin: 0 auto;
-            }
-            .status-box { 
-                padding: 15px; 
-                border-radius: 8px; 
-                margin: 10px 0; 
-                border-left: 4px solid #007bff;
-                background: linear-gradient(90deg, #f8f9fa 0%, #e9ecef 100%);
-            }
-            .success { 
-                background-color: #d4edda; 
-                border-left-color: #28a745; 
-                color: #155724; 
-            }
-            .warning { 
-                background-color: #fff3cd; 
-                border-left-color: #ffc107; 
-                color: #856404; 
-            }
-            .error { 
-                background-color: #f8d7da; 
-                border-left-color: #dc3545; 
-                color: #721c24; 
-            }
-            .analysis-section {
-                border: 1px solid #dee2e6;
-                border-radius: 8px;
-                padding: 20px;
-                margin: 10px 0;
-                background: white;
-            }
+            .gradio-container { max-width: 1200px !important; }
+            .status-box { padding: 10px; border-radius: 5px; margin: 5px 0; }
+            .success { background-color: #d4edda; border: 1px solid #c3e6cb; color: #155724; }
+            .warning { background-color: #fff3cd; border: 1px solid #ffeaa7; color: #856404; }
+            .error { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
             """
         ) as iface:
-            
-            # Header
-            gr.Markdown("""
-            # 🧬 Gene Analysis Pipeline
-            
-            ### Comprehensive DNA sequence analysis with machine learning
-            
-            This tool provides multi-modal analysis including boundary detection, gene classification, 
-            and phylogenetic analysis for DNA sequences.
-            """)
-            
-            # System Status
+            gr.Markdown("# 🧬 Gene Analysis Pipeline")
             with gr.Row():
                 with gr.Column():
-                    try:
-                        mafft_available, iqtree_available, _, _ = check_tool_availability()
-                        status_html = f"""
-                        <div class="status-box">
-                            <h3>🔧 System Status</h3>
-                            <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 10px; margin-top: 10px;">
-                                <div>🤖 Boundary Model: <strong>{'✅ Loaded' if boundary_model else '❌ Missing'}</strong></div>
-                                <div>🧠 Keras Model: <strong>{'✅ Loaded' if keras_model else '❌ Missing'}</strong></div>
-                                <div>🌳 Tree Analyzer: <strong>{'✅ Loaded' if analyzer else '❌ Missing'}</strong></div>
-                                <div>🧬 MAFFT: <strong>{'✅ Available' if mafft_available else '❌ Missing'}</strong></div>
-                                <div>🌲 IQ-TREE: <strong>{'✅ Available' if iqtree_available else '❌ Missing'}</strong></div>
-                                <div>📊 Safe Mode: <strong>{'✅ Active' if not all([boundary_model, keras_model, analyzer]) else '⚠️ Inactive'}</strong></div>
-                            </div>
-                        </div>
-                        """
-                    except Exception as e:
-                        status_html = f"""
-                        <div class="status-box error">
-                            <h3>❌ System Status Error</h3>
-                            <p>Failed to check system status: {str(e)}</p>
-                        </div>
-                        """
-                    
-                    gr.HTML(value=status_html)
-            
-            # Main Interface
+                    status_display = gr.HTML(value=f"""
+                    <div class="status-box">
+                        <h3>🔧 System Status</h3>
+                        <p>🤖 Boundary Model: {'✅ Loaded' if boundary_model else '❌ Missing'}</p>
+                        <p>🧠 Keras Model: {'✅ Loaded' if keras_model else '❌ Missing'}</p>
+                        <p>🌳 Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Missing'}</p>
+                        <p>🧬 MAFFT: {'✅ Available' if check_tool_availability()[0] else '❌ Missing'}</p>
+                        <p>🌲 IQ-TREE: {'✅ Available' if check_tool_availability()[1] else '❌ Missing'}</p>
+                    </div>
+                    """)
             with gr.Tabs():
-                with gr.Tab("📝 Text Input"):
+                with gr.TabItem("📝 Text Input"):
                     with gr.Row():
                         with gr.Column(scale=2):
                             dna_input = gr.Textbox(
                                 label="🧬 DNA Sequence",
-                                placeholder="Enter your DNA sequence (ATCG format)...\nExample: ATCGATCGATCG...",
-                                lines=8,
-                                max_lines=15,
-                                info="Paste your DNA sequence here. Supports FASTA format or raw sequence."
+                                placeholder="Enter DNA sequence (ATCG format)...",
+                                lines=5,
+                                description="Paste your DNA sequence here"
                             )
-                            
-                            with gr.Row():
-                                similarity_slider = gr.Slider(
-                                    minimum=1,
-                                    maximum=99,
-                                    value=95,
-                                    step=1,
-                                    label="🎯 Similarity Threshold (%)",
-                                    info="Minimum similarity for phylogenetic analysis"
-                                )
-                                
-                                ml_tree_checkbox = gr.Checkbox(
-                                    label="🌲 Build ML Tree",
-                                    value=False,
-                                    info="Perform phylogenetic placement (requires external tools)"
-                                )
-                            
-                            analyze_btn = gr.Button(
-                                "🔬 Analyze Sequence", 
-                                variant="primary", 
-                                size="lg",
-                                scale=1
-                            )
-                        
                         with gr.Column(scale=1):
-                            gr.Markdown("""
-                            ### 📋 Quick Guide
-                            
-                            1. **Paste DNA sequence** in ATCG format
-                            2. **Adjust similarity** threshold (1-99%)
-                            3. **Enable ML tree** for phylogenetic analysis
-                            4. **Click Analyze** to start processing
-                            
-                            **Supported formats:**
-                            - Raw DNA sequence: `ATCGATCG...`
-                            - FASTA format: `>header\\nATCG...`
-                            - Mixed case (auto-converted)
-                            - With/without spaces/newlines
-                            
-                            **Requirements:**
-                            - Minimum length: 10 bp for basic analysis
-                            - Minimum length: 100 bp for ML tree
-                            - Only ATCG nucleotides (others converted to N)
-                            """)
-
-                with gr.Tab("📁 File Upload"):
+                            similarity_score = gr.Slider(
+                                minimum=1,
+                                maximum=99,
+                                value=95.0,
+                                step=1.0,
+                                label="🎯 Similarity Threshold (%)",
+                                description="Minimum similarity for tree analysis"
+                            )
+                            build_ml_tree = gr.Checkbox(
+                                label="🌲 Build ML Tree",
+                                value=False,
+                                description="Generate phylogenetic placement (slower)"
+                            )
+                            analyze_btn = gr.Button("🔬 Analyze Sequence", variant="primary")
+                with gr.TabItem("📁 File Upload"):
                     with gr.Row():
                         with gr.Column(scale=2):
                             file_input = gr.File(
                                 label="📄 Upload FASTA File",
                                 file_types=[".fasta", ".fa", ".fas", ".txt"],
-                                info="Select a FASTA file containing your DNA sequence"
-                            )
-                            
-                            with gr.Row():
-                                file_similarity_slider = gr.Slider(
-                                    minimum=1,
-                                    maximum=99,
-                                    value=95,
-                                    step=1,
-                                    label="🎯 Similarity Threshold (%)"
-                                )
-                                
-                                file_ml_tree_checkbox = gr.Checkbox(
-                                    label="🌲 Build ML Tree",
-                                    value=False
-                                )
-                            
-                            analyze_file_btn = gr.Button(
-                                "🔬 Analyze File", 
-                                variant="primary", 
-                                size="lg"
+                                description="Upload a FASTA file containing your sequence"
                             )
-                        
                         with gr.Column(scale=1):
-                            gr.Markdown("""
-                            ### 📄 File Requirements
-                            
-                            **Accepted formats:**
-                            - `.fasta`, `.fa`, `.fas`
-                            - `.txt` with FASTA content
-                            
-                            **FASTA format example:**
-                            ```
-                            >sequence_name
-                            ATCGATCGATCG...
-                            ```
-                            
-                            **Notes:**
-                            - Single or multiple sequences supported
-                            - First sequence will be analyzed
-                            - Maximum file size: 10MB
-                            - UTF-8 encoding recommended
-                            """)
-
-            # Results Section
+                            file_similarity_score = gr.Slider(
+                                minimum=1,
+                                maximum=99,
+                                value=95.0,
+                                step=1.0,
+                                label="🎯 Similarity Threshold (%)",
+                                description="Minimum similarity for tree analysis"
+                            )
+                            file_build_ml_tree = gr.Checkbox(
+                                label="🌲 Build ML Tree",
+                                value=False,
+                                description="Generate phylogenetic placement (slower)"
+                            )
+                            analyze_file_btn = gr.Button("🔬 Analyze File", variant="primary")
             gr.Markdown("## 📊 Analysis Results")
-            
             with gr.Row():
-                with gr.Column(scale=1):
+                with gr.Column():
                     boundary_output = gr.Textbox(
                         label="🎯 Boundary Detection",
                         interactive=False,
-                        lines=3,
-                        info="Gene region identification results"
+                        lines=2
                     )
-                    
                     keras_output = gr.Textbox(
-                        label="🧠 Gene Classification",
+                        label="🧠 F Gene Validation",
                         interactive=False,
-                        lines=3,
-                        info="Machine learning classification confidence"
+                        lines=2
                     )
-                
-                with gr.Column(scale=1):
+                with gr.Column():
                     ml_tree_output = gr.Textbox(
                         label="🌲 Phylogenetic Placement",
                         interactive=False,
-                        lines=3,
-                        info="Maximum likelihood tree placement"
+                        lines=2
                     )
-                    
                     tree_analysis_output = gr.Textbox(
                         label="🌳 Tree Analysis",
                         interactive=False,
-                        lines=3,
-                        info="Phylogenetic tree construction results"
+                        lines=2
                     )
-
             summary_output = gr.Textbox(
-                label="📋 Comprehensive Summary Report",
+                label="📋 Summary",
                 interactive=False,
-                lines=12,
-                info="Complete analysis overview"
+                lines=8
             )
-
-            # Visualization Section
+            with gr.Row():
+                aligned_file = gr.File(label="📄 Alignment File", visible=False)
+                tree_file = gr.File(label="🌲 Tree File", visible=False)
+                tree_html_file = gr.File(label="🌳 Simplified Tree HTML", visible=False)
+                report_html_file = gr.File(label="📊 Detailed Report HTML", visible=False)
             with gr.Tabs():
-                with gr.Tab("🌳 Interactive Tree"):
+                with gr.TabItem("🌳 Interactive Tree"):
                     tree_html = gr.HTML(
-                        label="Phylogenetic Tree Visualization",
-                        value="""
-                        <div style='text-align: center; color: #666; padding: 50px; border: 2px dashed #ccc; border-radius: 8px;'>
-                            <h3>🌳 Tree Visualization</h3>
-                            <p>No tree generated yet. Run analysis to see interactive phylogenetic tree.</p>
-                            <p><em>Note: Tree visualization requires successful sequence analysis.</em></p>
-                        </div>
-                        """
+                        value="<div style='text-align: center; color: #666; padding: 20px;'>No tree generated yet. Run analysis to see results.</div>"
                     )
-                
-                with gr.Tab("📊 Detailed Report"):
+                with gr.TabItem("📊 Detailed Report"):
                     report_html = gr.HTML(
                         label="Analysis Report",
-                        value="""
-                        <div style='text-align: center; color: #666; padding: 50px; border: 2px dashed #ccc; border-radius: 8px;'>
-                            <h3>📊 Analysis Report</h3>
-                            <p>No report generated yet. Run analysis to see detailed results.</p>
-                            <p><em>Note: Report includes statistical analysis and recommendations.</em></p>
-                        </div>
-                        """
+                        value="<div style='text-align: center; color: #666; padding: 20px;'>No report generated yet. Run analysis to see results.</div>"
                     )
 
-            # Event Handlers
-            def handle_analysis_safe(dna_seq, similarity, build_ml):
-                """Safe analysis handler with comprehensive error handling"""
-                try:
-                    if not dna_seq or not dna_seq.strip():
-                        error_msg = "❌ Please enter a DNA sequence"
-                        return (
-                            error_msg, "", "", "", error_msg,
-                            None, None, None, None,
-                            f"<div style='color: red;'>{error_msg}</div>",
-                            f"<div style='color: red;'>{error_msg}</div>"
-                        )
-                    
-                    return run_pipeline_safe(dna_seq, similarity, build_ml)
-                
-                except Exception as e:
-                    logger.error(f"Analysis handler error: {e}")
-                    error_msg = f"❌ Analysis failed: {str(e)}"
-                    return (
-                        error_msg, "", "", "", error_msg,
-                        None, None, None, None,
-                        f"<div style='color: red;'>{error_msg}</div>",
-                        f"<div style='color: red;'>{error_msg}</div>"
-                    )
+            # Event handlers
+            def handle_analysis_output(*outputs):
+                boundary_output, keras_output, ml_tree_output, simplified_ml_output, summary_output, aligned_file, phy_file, _, _, tree_html_content, report_html_content, tree_html_path, report_html_path = outputs
+                return (
+                    boundary_output, keras_output, ml_tree_output, simplified_ml_output, summary_output,
+                    gr.File.update(value=aligned_file, visible=aligned_file is not None),
+                    gr.File.update(value=phy_file, visible=phy_file is not None),
+                    gr.File.update(value=tree_html_path, visible=tree_html_path is not None),
+                    gr.File.update(value=report_html_path, visible=report_html_path is not None),
+                    tree_html_content,
+                    report_html_content
+                )
 
-            def handle_file_analysis_safe(file_obj, similarity, build_ml):
-                """Safe file analysis handler"""
-                try:
-                    if file_obj is None:
-                        error_msg = "❌ Please upload a FASTA file"
-                        return (
-                            error_msg, "", "", "", error_msg,
-                            None, None, None, None,
-                            f"<div style='color: red;'>{error_msg}</div>",
-                            f"<div style='color: red;'>{error_msg}</div>"
-                        )
-                    
-                    sequence = read_fasta_file(file_obj)
-                    if not sequence:
-                        error_msg = "❌ Failed to read sequence from file"
-                        return (
-                            error_msg, "", "", "", error_msg,
-                            None, None, None, None,
-                            f"<div style='color: red;'>{error_msg}</div>",
-                            f"<div style='color: red;'>{error_msg}</div>"
-                        )
-                    
-                    return run_pipeline_safe(sequence, similarity, build_ml)
-                
-                except Exception as e:
-                    logger.error(f"File analysis handler error: {e}")
-                    error_msg = f"❌ File analysis failed: {str(e)}"
-                    return (
-                        error_msg, "", "", "", error_msg,
-                        None, None, None, None,
-                        f"<div style='color: red;'>{error_msg}</div>",
-                        f"<div style='color: red;'>{error_msg}</div>"
-                    )
-
-            # Connect event handlers
             analyze_btn.click(
-                fn=handle_analysis_safe,
-                inputs=[dna_input, similarity_slider, ml_tree_checkbox],
+                fn=run_pipeline,
+                inputs=[dna_input, similarity_score, build_ml_tree],
                 outputs=[
-                    boundary_output,
-                    keras_output,
-                    ml_tree_output,
-                    tree_analysis_output,
-                    summary_output,
-                    tree_html,
-                    report_html
+                    boundary_output, keras_output, ml_tree_output, tree_analysis_output, summary_output,
+                    aligned_file, tree_file, tree_html_file, report_html_file, tree_html, report_html
                 ],
-                show_progress=True
+                _js="""(outputs) => {
+                    return outputs;
+                }"""
             )
 
             analyze_file_btn.click(
-                fn=handle_file_analysis_safe,
-                inputs=[file_input, file_similarity_slider, file_ml_tree_checkbox],
+                fn=run_pipeline_from_file,
+                inputs=[file_input, file_similarity_score, file_build_ml_tree],
                 outputs=[
-                    boundary_output,
-                    keras_output,
-                    ml_tree_output,
-                    tree_analysis_output,
-                    summary_output,
-                    tree_html,
-                    report_html
+                    boundary_output, keras_output, ml_tree_output, tree_analysis_output, summary_output,
+                    aligned_file, tree_file, tree_html_file, report_html_file, tree_html, report_html
+                ],
+                _js="""(outputs) => {
+                    return outputs;
+                }"""
+            )
+
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["ATCG" * 250, 85.0, False],
+                    ["CGATCG" * 150, 90.0, True]
                 ],
-                show_progress=True
+                inputs=[dna_input, similarity_score, build_ml_tree],
+                label="Example Sequences"
             )
 
-            # Footer
             gr.Markdown("""
-            ---
-            ### 🔬 About This Tool
-            
-            This Gene Analysis Pipeline provides comprehensive DNA sequence analysis using:
-            - **Boundary Detection**: Machine learning-based gene region identification
-            - **Classification**: Deep learning confidence scoring for gene classification
-            - **Phylogenetic Analysis**: Maximum likelihood tree construction and placement
-            - **Interactive Visualization**: Dynamic tree and report generation
-            
-            **Safe Mode**: When external tools or models are unavailable, the pipeline operates in safe mode with basic analysis capabilities.
-            
-            ---
-            *Powered by Gradio • Built with ❤️ for genomics research*
+            ## 📚 Instructions
+            1. **Input**: Enter a DNA sequence (ATCG format) or upload a FASTA file
+            2. **Parameters**: 
+               - Set similarity threshold for phylogenetic analysis (1-99%)
+               - Choose whether to build ML tree (slower but more accurate)
+            3. **Analysis**: Click analyze to run the complete pipeline
+            4. **Results**: View results in different tabs - summary, tree visualization, and detailed report
+            5. **Downloads**: Download alignment, tree, simplified tree HTML, and detailed report HTML files
+            ### 🔬 Pipeline Components:
+            - **Boundary Detection**: Identifies F gene regions
+            - **F Gene Validation**: Validates F gene using ML
+            - **Phylogenetic Placement**: Places sequence in reference tree (optional)
+            - **Tree Analysis**: Builds phylogenetic tree with similar sequences
             """)
 
         return iface
-
     except Exception as e:
-        logger.error(f"Interface creation failed: {e}")
-        # Return minimal interface on failure
-        def minimal_interface():
-            return gr.Interface(
-                fn=lambda x: f"❌ System Error: {str(e)}",
-                inputs=gr.Textbox(label="Input"),
-                outputs=gr.Textbox(label="Output"),
-                title="Gene Analysis Pipeline - Error Mode"
-            )
-        return minimal_interface()
+        logger.error(f"Gradio interface creation failed: {e}", exc_info=True)
+        return gr.Interface(
+            fn=lambda x: f"Error: {str(e)}",
+            inputs=gr.Textbox(label="DNA Sequence"),
+            outputs=gr.Textbox(label="Error"),
+            title="🧬 Gene Analysis Pipeline (Error Mode)"
+        )
 
-# --- Main Execution ---
-def main():
-    """Main function with comprehensive error handling"""
+# --- Application Startup ---
+def run_application():
     try:
+        gradio_app = create_gradio_interface()
+        gradio_app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
         logger.info("🚀 Starting Gene Analysis Pipeline...")
-        
-        # Load models
-        load_models_safely()
-        
-        # Create interface
-        logger.info("🎨 Creating Gradio interface...")
-        iface = create_safe_gradio_interface()
-        
-        # Launch
-        logger.info("🌐 Launching application...")
-        iface.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False,
-            show_error=True,
-            max_threads=10
+        logger.info("📊 FastAPI docs available at: http://localhost:7860/docs")
+        logger.info("🧬 Gradio interface available at: http://localhost:7860/gradio")
+        uvicorn.run(
+            app,
+            host="0.0.0.0",
+            port=7860,
+            log_level="info"
         )
-        
-    except KeyboardInterrupt:
-        logger.info("🛑 Application stopped by user")
-        iface.close()
     except Exception as e:
-        logger.error(f"❌ Critical error in main: {e}", exc_info=True)
-        
-        # Emergency fallback interface
+        logger.error(f"Application startup failed: {e}", exc_info=True)
         try:
-            logger.info("🚨 Starting emergency fallback interface...")
-            emergency_iface = gr.Interface(
-                fn=lambda x: f"❌ System in emergency mode. Error: {str(e)}",
-                inputs=gr.Textbox(label="DNA Sequence", placeholder="Emergency mode - limited functionality"),
-                outputs=gr.Textbox(label="Status"),
-                title="🚨 Gene Analysis Pipeline - Emergency Mode",
-                description="The system is running in emergency mode due to initialization errors."
-            )
-            emergency_iface.launch(
+            logger.info("🔄 Falling back to Gradio-only mode...")
+            gradio_app = create_gradio_interface()
+            gradio_app.launch(
                 server_name="0.0.0.0",
                 server_port=7860,
                 share=False,
-                show_error=True
+                debug=False
             )
-        except Exception as emergency_e:
-            logger.error(f"❌ Emergency interface failed: {emergency_e}")
-            print(f"CRITICAL: Complete system failure. Error: {e}")
-            print(f"Emergency fallback also failed: {emergency_e}")
-            sys.exit(1)
-        finally:
-            try:
-                emergency_iface.close()
-            except:
-                pass
-    finally:
-        try:
-            iface.close()
-        except:
-            pass
+        except Exception as fallback_error:
+            logger.error(f"Fallback failed: {fallback_error}", exc_info=True)
+            print("❌ Application failed to start. Check logs for details.")
+
+# --- Main Entry Point ---
 if __name__ == "__main__":
-    main()
+    print("🧬 Gene Analysis Pipeline Starting...")
+    print("=" * 50)
+    print("🔍 Checking system components...")
+    mafft_available, iqtree_available, _, _ = check_tool_availability()
+    print(f"🤖 Boundary Model: {'✅' if boundary_model else '❌'}")
+    print(f"🧠 Keras Model: {'✅' if keras_model else '❌'}")
+    print(f"🌳 Tree Analyzer: {'✅' if analyzer else '❌'}")
+    print(f"🧬 MAFFT: {'✅' if mafft_available else '❌'}")
+    print(f"🌲 IQ-TREE: {'✅' if iqtree_available else '❌'}")
+    print("=" * 50)
+    run_application()