Update app.py

app.py

@@ -1,14 +1,9 @@
-import os
-# Disable GPU to avoid CUDA errors
-os.environ["CUDA_VISIBLE_DEVICES"] = ""
-# Suppress TensorFlow warnings
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-
 import gradio as gr
 import torch
 import pickle
 import subprocess
 import pandas as pd
+import os
 import re
 import logging
 import numpy as np
@@ -27,16 +22,14 @@ from Bio.SeqRecord import SeqRecord
 import stat
 import time
 import asyncio
+
+# FastAPI imports
 from fastapi import FastAPI, File, UploadFile, Form, HTTPException
 from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
 from typing import Optional
 import uvicorn
 
-# Log Gradio version
-logger = logging.getLogger(__name__)
-logger.info(f"Gradio version: {gr.__version__}")
-
 # Set event loop policy for Spaces
 try:
     asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
@@ -50,6 +43,8 @@ app = FastAPI(title="🧬 Gene Analysis Pipeline", version="1.0.0")
 log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
 log_handler = logging.StreamHandler()
 log_handler.setFormatter(log_formatter)
+
+# File handler with error handling
 try:
     file_handler = logging.FileHandler('/tmp/app.log')
     file_handler.setFormatter(log_formatter)
@@ -57,18 +52,23 @@ try:
 except Exception:
     logging.basicConfig(level=logging.INFO, handlers=[log_handler])
 
+logger = logging.getLogger(__name__)
+
 # --- Global Variables ---
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft")
-IQTREE_PATH = os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree3")
+MODELS_DIR = os.path.join(BASE_DIR, "models")  # Local models directory
+MAFFT_PATH = shutil.which("mafft") or os.path.join(BASE_DIR, "binaries", "mafft", "mafft")
+IQTREE_PATH = shutil.which("iqtree") or 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")
+QUERY_OUTPUT_DIR = os.path.join("/tmp", "queries")
 os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
 
-# --- Model Configuration ---
-MODEL_REPO = "GGproject10/best_boundary_aware_model"
-CSV_PATH = "f cleaned.csv"
+# --- Corrected Paths ---
+boundary_model_repo = "GGproject10/best_boundary_aware_model"
+other_models_repo = "GGproject10/simplified_tree_AI"
+csv_path = os.path.join(BASE_DIR, "f_cleaned.csv")
+hf_token = os.getenv("HF_TOKEN")
 
 # Initialize models as None
 boundary_model = None
@@ -76,85 +76,128 @@ keras_model = None
 kmer_to_index = None
 analyzer = None
 
-# --- Model Loading ---
+# --- Enhanced Model Loading with Correct Paths ---
 def load_models_safely():
     global boundary_model, keras_model, kmer_to_index, analyzer
-    logger.info("🔍 Loading models...")
-
-    # Load Boundary Model
+    
+    logger.info(f"🔍 Looking for models in: {MODELS_DIR}")
+    logger.info(f"📁 Models directory exists: {os.path.exists(MODELS_DIR)}")
+    
+    if os.path.exists(MODELS_DIR):
+        logger.info(f"📂 Contents of models directory: {os.listdir(MODELS_DIR)}")
+    
+    # Load Boundary Model - Try local first, then HF from correct repo
     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 from Hugging Face Hub.")
+        # Local model paths
+        local_boundary_path = os.path.join(MODELS_DIR, "best_boundary_aware_model.pth")
+        
+        if os.path.exists(local_boundary_path):
+            logger.info(f"✅ Loading boundary model from local path: {local_boundary_path}")
+            boundary_model = EnhancedGenePredictor(local_boundary_path)
+            logger.info("✅ Boundary model loaded successfully from local directory")
+        elif hf_token:
+            logger.info("🌐 Attempting to load boundary model from Hugging Face...")
+            boundary_path = hf_hub_download(
+                repo_id=boundary_model_repo,  # Correct repo for boundary model
+                filename="best_boundary_aware_model.pth", 
+                token=hf_token, 
+                cache_dir="/tmp/hf_cache"
+            )
+            if os.path.exists(boundary_path):
+                boundary_model = EnhancedGenePredictor(boundary_path)
+                logger.info("✅ Boundary model loaded successfully from HF")
+            else:
+                logger.warning("❌ Boundary model file not found after HF download")
         else:
-            logger.error(f"❌ Boundary model file not found after download from {MODEL_REPO}")
+            logger.warning("❌ No local boundary model found and no HF_TOKEN available")
     except Exception as e:
-        logger.error(f"❌ Failed to load boundary model from HF Hub: {e}. Ensure {MODEL_REPO} is public and accessible.")
+        logger.error(f"❌ Failed to load boundary model: {e}")
+        boundary_model = None
 
-    # Load Keras Model
+    # Load Keras Model - Try local first, then HF from correct repo
     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:
+        # Local model paths
+        local_keras_path = os.path.join(MODELS_DIR, "best_model.keras")
+        local_kmer_path = os.path.join(MODELS_DIR, "kmer_to_index.pkl")
+        
+        if os.path.exists(local_keras_path) and os.path.exists(local_kmer_path):
+            logger.info(f"✅ Loading Keras model from local paths:")
+            logger.info(f"   - Keras model: {local_keras_path}")
+            logger.info(f"   - K-mer index: {local_kmer_path}")
+            
+            keras_model = load_model(local_keras_path)
+            with open(local_kmer_path, "rb") as f:
                 kmer_to_index = pickle.load(f)
-            logger.info("✅ Keras model and k-mer index loaded successfully from Hugging Face Hub.")
+            logger.info("✅ Keras model loaded successfully from local directory")
+            
+        elif hf_token:
+            logger.info("🌐 Attempting to load Keras model from Hugging Face...")
+            keras_path = hf_hub_download(
+                repo_id=other_models_repo,  # Correct repo for other models
+                filename="best_model.keras", 
+                token=hf_token, 
+                cache_dir="/tmp/hf_cache"
+            )
+            kmer_path = hf_hub_download(
+                repo_id=other_models_repo,  # Correct repo for other models
+                filename="kmer_to_index.pkl", 
+                token=hf_token, 
+                cache_dir="/tmp/hf_cache"
+            )
+            
+            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 loaded successfully from HF")
+            else:
+                logger.warning("❌ Keras model files not found after HF download")
         else:
-            logger.error(f"❌ Keras model or kmer files not found after download from {MODEL_REPO}")
+            logger.warning("❌ No local Keras model found and no HF_TOKEN available")
     except Exception as e:
-        logger.error(f"❌ Failed to load Keras model from HF Hub: {e}. Ensure {MODEL_REPO} is public and accessible.")
+        logger.error(f"❌ Failed to load Keras model: {e}")
+        keras_model = None
+        kmer_to_index = None
 
     # Initialize Tree Analyzer
     try:
         logger.info("🌳 Initializing tree analyzer...")
         analyzer = PhylogeneticTreeAnalyzer()
+        
+        # Try multiple CSV locations
         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),
+            csv_path, 
+            os.path.join(BASE_DIR, "f cleaned.csv"), 
             "f_cleaned.csv",
-            os.path.join(BASE_DIR, "f_cleaned.csv")
+            os.path.join(BASE_DIR, "data", "f_cleaned.csv"),
+            os.path.join(MODELS_DIR, "f_cleaned.csv")  # Also check models directory
         ]
+        
         csv_loaded = False
         for csv_candidate in csv_candidates:
             if os.path.exists(csv_candidate):
-                logger.info(f"📊 Trying CSV: {csv_candidate}")
                 try:
+                    logger.info(f"📊 Trying to load CSV from: {csv_candidate}")
                     if analyzer.load_data(csv_candidate):
-                        logger.info(f"✅ CSV loaded from: {csv_candidate}")
+                        logger.info(f"✅ Tree analyzer loaded CSV from: {csv_candidate}")
                         csv_loaded = True
                         break
                 except Exception as e:
-                    logger.warning(f"CSV load failed for {csv_candidate}: {e}")
+                    logger.warning(f"Failed to load CSV from {csv_candidate}: {e}")
                     continue
+        
         if not csv_loaded:
-            logger.error("❌ Failed to load CSV data from any candidate location. Place 'f cleaned.csv' in project root.")
-            analyzer = None
-        else:
+            logger.error("❌ Failed to load CSV data from any location")
+            logger.info("📂 Available files in base directory:")
             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}")
+                for file in os.listdir(BASE_DIR):
+                    if file.endswith('.csv'):
+                        logger.info(f"   - {file}")
+            except:
+                pass
+            analyzer = None
     except Exception as e:
-        logger.error(f"❌ Tree analyzer initialization failed: {e}")
+        logger.error(f"❌ Failed to initialize tree analyzer: {e}")
         analyzer = None
 
 # Load models at startup
@@ -172,16 +215,19 @@ def setup_binary_permissions():
 
 def check_tool_availability():
     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,
+                    [candidate, "--help"], 
+                    capture_output=True, 
+                    text=True, 
                     timeout=5
                 )
                 if result.returncode == 0 or "mafft" in result.stderr.lower():
@@ -191,16 +237,19 @@ def check_tool_availability():
                     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,
+                    [candidate, "--help"], 
+                    capture_output=True, 
+                    text=True, 
                     timeout=5
                 )
                 if result.returncode == 0 or "iqtree" in result.stderr.lower():
@@ -210,36 +259,46 @@ def check_tool_availability():
                     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 ---
+# --- Pipeline Functions (keeping your original logic) ---
 def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
     try:
         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,
+            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.error(f"Phylogenetic placement failed: {e}")
         return False, f"Error: {str(e)}", None, None
@@ -250,73 +309,40 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
             except:
                 pass
 
-def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
-    try:
-        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
-        if not analyzer.find_query_sequence(sequence):
-            return "❌ Sequence not accepted.", None, None
-        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
-        analyzer.build_tree_structure_with_ml_safe(matched_ids)
-        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')
-        fig.write_html(tree_html_path)
-        analyzer.matching_percentage = matching_percentage
-        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
-        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"Tree analysis failed: {e}")
-        return f"❌ Error: {str(e)}", None, None
-
 def predict_with_keras(sequence):
     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)."
+            
         kmers = [sequence[i:i+6] for i in range(len(sequence)-5)]
         indices = [kmer_to_index.get(kmer, 0) for kmer in kmers]
         input_arr = np.array([indices])
+        
         prediction = keras_model.predict(input_arr, verbose=0)[0]
         f_gene_prob = prediction[-1]
         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}")
         return f"❌ Error: {str(e)}"
 
-def read_fasta_file(file_obj):
-    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")
-        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}")
-        return ""
-
 def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
     try:
         dna_input = dna_input.upper().strip()
         if not dna_input:
             return "❌ Empty input", "", "", "", "", None, None, None, None, "No input", "No input"
+            
+        # Clean sequence
         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 prediction
         boundary_output = ""
         if boundary_model:
             try:
@@ -333,10 +359,15 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                 processed_sequence = dna_input
         else:
             boundary_output = f"⚠️ Boundary model not available. Using full input: {len(dna_input)} bp"
+            
+        # Keras prediction
         keras_output = predict_with_keras(processed_sequence) if processed_sequence and len(processed_sequence) >= 6 else "❌ Sequence too short."
+        
+        # ML Tree (keeping your original logic)
         aligned_file = None
         phy_file = None
         ml_tree_output = ""
+        
         if build_ml_tree and processed_sequence and len(processed_sequence) >= 100:
             try:
                 mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
@@ -353,23 +384,29 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
             ml_tree_output = "❌ Sequence too short for placement (<100 bp)."
         else:
             ml_tree_output = "⚠️ Phylogenetic placement skipped."
+            
+        # Tree analysis
         tree_html_content = "No tree generated."
         report_html_content = "No report generated."
         simplified_ml_output = ""
+        
         if analyzer and processed_sequence and len(processed_sequence) >= 10:
             try:
                 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:
                 simplified_ml_output = f"❌ Tree analysis error: {str(e)}"
                 tree_html_content = f"<div style='color: red;'>{simplified_ml_output}</div>"
@@ -378,6 +415,8 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
             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
         summary_output = f"""
 📊 ANALYSIS SUMMARY:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -388,15 +427,72 @@ Placement: {'✅ OK' if '✅' in ml_tree_output else '⚠️ Skipped' if 'skippe
 Tree Analysis: {'✅ OK' if 'Found' in simplified_ml_output else '❌ Failed'}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
+        
         return (
             boundary_output, keras_output, ml_tree_output, simplified_ml_output, summary_output,
             aligned_file, phy_file, None, None, tree_html_content, report_html_content
         )
+        
     except Exception as e:
         logger.error(f"Pipeline error: {e}")
         error_msg = f"❌ Pipeline Error: {str(e)}"
         return error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg
 
+# Keep your other functions (analyze_sequence_for_tree, build_maximum_likelihood_tree, etc.)
+def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
+    try:
+        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
+            
+        if not analyzer.find_query_sequence(sequence):
+            return "❌ Sequence not accepted.", None, None
+            
+        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
+            
+        analyzer.build_tree_structure_with_ml_safe(matched_ids)
+        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')
+        fig.write_html(tree_html_path)
+        
+        analyzer.matching_percentage = matching_percentage
+        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
+        
+        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"Tree analysis failed: {e}")
+        return f"❌ Error: {str(e)}", None, None
+
+def read_fasta_file(file_obj):
+    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")
+            
+        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}")
+        return ""
+
 async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
     try:
         dna_input = read_fasta_file(fasta_file_obj)
@@ -453,7 +549,18 @@ async def health_check():
             },
             "paths": {
                 "base_dir": BASE_DIR,
-                "query_output_dir": QUERY_OUTPUT_DIR
+                "models_dir": MODELS_DIR,
+                "models_dir_exists": os.path.exists(MODELS_DIR),
+                "csv_path": csv_path,
+                "csv_exists": os.path.exists(csv_path)
+            },
+            "model_repos": {
+                "boundary_model": boundary_model_repo,
+                "other_models": other_models_repo
+            },
+            "recommendations": {
+                "models": "Models loaded from local directory" if (boundary_model and keras_model) else "Check models directory",
+                "bioinformatics_tools": "Install MAFFT and IQ-TREE" if not (mafft_available and iqtree_available) else "OK"
             }
         }
     except Exception as e:
@@ -475,15 +582,15 @@ async def analyze_sequence(request: AnalysisRequest):
     except Exception as e:
         logger.error(f"Analyze error: {e}")
         return AnalysisResponse(
-            boundary_output="", keras_output="", ml_tree_output="",
+            boundary_output="", keras_output="", ml_tree_output="", 
             tree_analysis_output="", summary_output="",
             success=False, error_message=str(e)
         )
 
 @app.post("/analyze-file")
 async def analyze_file(
-    file: UploadFile = File(...),
-    similarity_score: float = Form(95.0),
+    file: UploadFile = File(...), 
+    similarity_score: float = Form(95.0), 
     build_ml_tree: bool = Form(False)
 ):
     temp_file_path = None
@@ -492,7 +599,9 @@ async def analyze_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 "",
@@ -504,7 +613,7 @@ async def analyze_file(
     except Exception as e:
         logger.error(f"Analyze-file error: {e}")
         return AnalysisResponse(
-            boundary_output="", keras_output="", ml_tree_output="",
+            boundary_output="", keras_output="", ml_tree_output="", 
             tree_analysis_output="", summary_output="",
             success=False, error_message=str(e)
         )
@@ -515,7 +624,7 @@ async def analyze_file(
             except:
                 pass
 
-# --- Gradio Interface ---
+# --- Fixed Gradio Interface ---
 def create_gradio_interface():
     try:
         with gr.Blocks(
@@ -529,7 +638,10 @@ def create_gradio_interface():
             .error { background-color: #f8d7da; border: 1px solid #f5c6cb; color: #721c24; }
             """
         ) as iface:
+            
             gr.Markdown("# 🧬 Gene Analysis Pipeline")
+            
+            # Status display
             with gr.Row():
                 with gr.Column():
                     status_display = gr.HTML(value=f"""
@@ -537,266 +649,281 @@ def create_gradio_interface():
                         <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>
+                        <p>🌳 Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Missing'}
+                        <p>🔬 MAFFT/IQ-TREE: {'✅ Available' if check_tool_availability()[0] and check_tool_availability()[1] else '❌ Missing'}</p>
                     """)
+            
+            # Input tabs
             with gr.Tabs():
                 with gr.TabItem("📝 Text Input"):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            dna_input = gr.Textbox(
-                                label="🧬 DNA Sequence",
-                                placeholder="Enter DNA sequence (ATCG format)...",
-                                lines=5,
-                                info="Paste your DNA sequence here"
-                            )
-                        with gr.Column(scale=1):
-                            similarity_score = gr.Slider(
-                                minimum=1,
-                                maximum=99,
-                                value=95.0,
-                                step=1.0,
-                                label="🎯 Similarity Threshold (%)",
-                                info="Minimum similarity for tree analysis"
-                            )
-                            build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree",
-                                value=False,
-                                info="Generate phylogenetic placement (slower)"
-                            )
-                            analyze_btn = gr.Button("🔬 Analyze Sequence", variant="primary")
+                    dna_input = gr.Textbox(
+                        label="🧬 DNA Sequence",
+                        placeholder="Enter DNA sequence (ATCG format)...",
+                        lines=5,
+                        max_lines=10
+                    )
+                    
                 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="Upload a FASTA file containing your sequence"
-                            )
-                        with gr.Column(scale=1):
-                            file_similarity_score = gr.Slider(
-                                minimum=1,
-                                maximum=99,
-                                value=95.0,
-                                step=1.0,
-                                label="🎯 Similarity Threshold (%)",
-                                info="Minimum similarity for tree analysis"
-                            )
-                            file_build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree",
-                                value=False,
-                                info="Generate phylogenetic placement (slower)"
-                            )
-                            analyze_file_btn = gr.Button("🔬 Analyze File", variant="primary")
-            gr.Markdown("## 📊 Analysis Results")
+                    fasta_file = gr.File(
+                        label="📄 Upload FASTA File",
+                        file_types=[".fasta", ".fa", ".txt"],
+                        file_count="single"
+                    )
+            
+            # Analysis options
             with gr.Row():
                 with gr.Column():
+                    similarity_slider = gr.Slider(
+                        minimum=1,
+                        maximum=99,
+                        value=95,
+                        step=1,
+                        label="🎯 Similarity Threshold (%)",
+                        info="Minimum similarity for phylogenetic analysis"
+                    )
+                    
+                with gr.Column():
+                    ml_tree_checkbox = gr.Checkbox(
+                        label="🌲 Build ML Tree",
+                        value=False,
+                        info="Perform phylogenetic placement (slower)"
+                    )
+            
+            # Action buttons
+            with gr.Row():
+                analyze_text_btn = gr.Button("🔍 Analyze Text", variant="primary", size="lg")
+                analyze_file_btn = gr.Button("📁 Analyze File", variant="secondary", size="lg")
+                clear_btn = gr.Button("🗑️ Clear", variant="stop")
+            
+            # Results section
+            gr.Markdown("## 📊 Analysis Results")
+            
+            with gr.Tabs():
+                with gr.TabItem("🎯 Boundary Prediction"):
                     boundary_output = gr.Textbox(
-                        label="🎯 Boundary Detection",
-                        interactive=False,
-                        lines=2
+                        label="🔍 F Gene Boundary Detection",
+                        lines=3,
+                        interactive=False
                     )
+                    
+                with gr.TabItem("🧠 Keras Validation"):
                     keras_output = gr.Textbox(
-                        label="🧠 F Gene Validation",
-                        interactive=False,
-                        lines=2
+                        label="🤖 Neural Network Validation",
+                        lines=3,
+                        interactive=False
                     )
-                with gr.Column():
+                    
+                with gr.TabItem("🌲 ML Tree Placement"):
                     ml_tree_output = gr.Textbox(
-                        label="🌲 Phylogenetic Placement",
-                        interactive=False,
-                        lines=2
+                        label="🌳 Maximum Likelihood Tree",
+                        lines=5,
+                        interactive=False
                     )
+                    
+                with gr.TabItem("📈 Tree Analysis"):
                     tree_analysis_output = gr.Textbox(
-                        label="🌳 Tree Analysis",
-                        interactive=False,
-                        lines=2
+                        label="📊 Phylogenetic Analysis",
+                        lines=5,
+                        interactive=False
                     )
-            summary_output = gr.Textbox(
-                label="📋 Summary",
-                interactive=False,
-                lines=8
-            )
-            with gr.Row():
-                aligned_file = gr.File(label="📄 Alignment File", visible=False)
-                tree_file = gr.File(label="🌲 Tree File", visible=False)
+                    
+                with gr.TabItem("📋 Summary"):
+                    summary_output = gr.Textbox(
+                        label="📝 Analysis Summary",
+                        lines=10,
+                        interactive=False
+                    )
+            
+            # Visualization section
             with gr.Tabs():
                 with gr.TabItem("🌳 Interactive Tree"):
                     tree_html = gr.HTML(
                         label="Phylogenetic Tree Visualization",
-                        value="<div style='text-align: center; padding: 20px; color: #666;'>Run analysis to see interactive tree</div>"
+                        value="<div style='text-align: center; padding: 20px; color: #666;'>Tree visualization will appear here after analysis</div>"
                     )
+                    
                 with gr.TabItem("📊 Detailed Report"):
                     report_html = gr.HTML(
                         label="Analysis Report",
-                        value="<div style='text-align: center; padding: 20px; color: #666;'>Run analysis to see detailed report</div>"
+                        value="<div style='text-align: center; padding: 20px; color: #666;'>Detailed report will appear here after analysis</div>"
                     )
-
+            
+            # File downloads
+            gr.Markdown("## 📥 Download Results")
+            with gr.Row():
+                aligned_file = gr.File(
+                    label="📄 Aligned Sequences",
+                    interactive=False
+                )
+                tree_file = gr.File(
+                    label="🌳 Tree File",
+                    interactive=False
+                )
+            
             # Event handlers
-            analyze_btn.click(
+            def clear_all():
+                return (
+                    "",  # dna_input
+                    None,  # fasta_file
+                    "",  # boundary_output
+                    "",  # keras_output
+                    "",  # ml_tree_output
+                    "",  # tree_analysis_output
+                    "",  # summary_output
+                    "<div style='text-align: center; padding: 20px; color: #666;'>Tree visualization will appear here after analysis</div>",  # tree_html
+                    "<div style='text-align: center; padding: 20px; color: #666;'>Detailed report will appear here after analysis</div>",  # report_html
+                    None,  # aligned_file
+                    None   # tree_file
+                )
+            
+            # Text analysis
+            analyze_text_btn.click(
                 fn=run_pipeline,
-                inputs=[dna_input, similarity_score, build_ml_tree],
+                inputs=[dna_input, similarity_slider, ml_tree_checkbox],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output, 
-                    tree_analysis_output, summary_output,
-                    aligned_file, tree_file, gr.State(), gr.State(),
-                    tree_html, report_html
+                    boundary_output,
+                    keras_output,
+                    ml_tree_output,
+                    tree_analysis_output,
+                    summary_output,
+                    aligned_file,
+                    tree_file,
+                    gr.State(),  # placeholder for additional outputs
+                    gr.State(),  # placeholder for additional outputs
+                    tree_html,
+                    report_html
                 ]
             )
-
+            
+            # File analysis
             analyze_file_btn.click(
                 fn=run_pipeline_from_file,
-                inputs=[file_input, file_similarity_score, file_build_ml_tree],
+                inputs=[fasta_file, similarity_slider, ml_tree_checkbox],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output,
-                    tree_analysis_output, summary_output,
-                    aligned_file, tree_file, gr.State(), gr.State(),
-                    tree_html, report_html
+                    boundary_output,
+                    keras_output,
+                    ml_tree_output,
+                    tree_analysis_output,
+                    summary_output,
+                    aligned_file,
+                    tree_file,
+                    gr.State(),  # placeholder for additional outputs
+                    gr.State(),  # placeholder for additional outputs
+                    tree_html,
+                    report_html
                 ]
             )
-
+            
+            # Clear button
+            clear_btn.click(
+                fn=clear_all,
+                outputs=[
+                    dna_input,
+                    fasta_file,
+                    boundary_output,
+                    keras_output,
+                    ml_tree_output,
+                    tree_analysis_output,
+                    summary_output,
+                    tree_html,
+                    report_html,
+                    aligned_file,
+                    tree_file
+                ]
+            )
+            
             # Examples
+            gr.Markdown("## 🧪 Example Sequences")
             gr.Examples(
                 examples=[
-                    [
-                        "ATGAAACTGCAGATGAAGTCCAAGTTGAAGAAGCTGGTGAAGATCCTGAAGGAGAACCTGGTGAAGCCCGAGAAGTGA",
-                        95.0,
-                        False
-                    ],
-                    [
-                        "ATGCCCACCATGAAACTGCAGATGAAGTCCAAGTTGAAGAAGCTGGTGAAGATCCTGAAGGAGAACCTGGTGAAGCCCGAGAAGTGATCCGGGCGGTACATCCTGCTGCCCACCATGAAG",
-                        90.0,
-                        True
-                    ]
+                    ["ATGAAACTGCAGCTGAGGTCCCTGGTGGTGAACAAGCTCAGCAGCAAGTGCTGAACTGGATGGGCGAGAAGAGCAACTGCATCCAGTGCAAGCGCCTGAAGAGGAACTGCAAGAAGGTGGTGGACCTGCAGTGCAGCAGCAGCAGCAGCAGCAGCAGCAGC", 95.0, False],
+                    ["ATGAAACTGCAGCTGAGGTCCCTGGTGGTGAACAAGCTCAGCAGCAAGTGCTGAACTGGATGGGCGAGAAGAGCAACTGCATCCAGTGCAAGCGCCTGAAGAGGAACTGCAAGAAGGTGGTGGACCTGCAGTGCAGCAGCAGCAGCAGCAGCAGCAGCAGC", 85.0, True],
+                    ["ATGGAGCTGCAGCTGAGGTCCCTGGTGGTGAACAAGCTCAGCAGCAAGTGCTGAACTGGATGGGCGAGAAGAGCAACTGCATCCAGTGCAAGCGCCTGAAGAGGAACTGCAAGAAGGTGGTGGACCTGCAG", 90.0, False]
                 ],
-                inputs=[dna_input, similarity_score, build_ml_tree],
-                label="🧪 Example Sequences"
+                inputs=[dna_input, similarity_slider, ml_tree_checkbox],
+                label="Click to load example sequences"
             )
-
+            
+            # Footer
+            gr.Markdown("""
+            ---
+            
+            ### 🔬 About This Pipeline
+            
+            This tool performs comprehensive analysis of DNA sequences using multiple approaches:
+            
+            - **🎯 Boundary Detection**: Identifies F gene regions using ML models
+            - **🧠 Keras Validation**: Neural network-based sequence validation
+            - **🌲 ML Tree Placement**: Phylogenetic placement using MAFFT + IQ-TREE
+            - **📈 Tree Analysis**: Interactive phylogenetic analysis and visualization
+            
+            ### 📝 Usage Notes
+            
+            - Sequences should be in ATCG format (other characters will be converted to N)
+            - Minimum 100 bp recommended for phylogenetic placement
+            - Higher similarity thresholds = fewer but more similar sequences
+            - ML tree building requires MAFFT and IQ-TREE (slower but more accurate)
+            
+            ### ⚠️ System Requirements
+            
+            - Python packages: gradio, torch, tensorflow, biopython, plotly
+            - Bioinformatics tools: MAFFT, IQ-TREE (optional for ML placement)
+            - Pre-trained models: boundary detection + keras validation models
+            """)
+        
         return iface
-
+    
     except Exception as e:
-        logger.error(f"Gradio interface creation failed: {e}")
+        logger.error(f"Failed to create Gradio interface: {e}")
         # Fallback simple interface
-        def simple_interface():
-            return gr.Interface(
-                fn=lambda x: f"Error creating interface: {e}",
-                inputs=gr.Textbox(label="Input"),
-                outputs=gr.Textbox(label="Output"),
-                title="Gene Analysis Pipeline - Error Mode"
+        with gr.Blocks() as fallback_iface:
+            gr.Markdown("# 🧬 Gene Analysis Pipeline (Fallback Mode)")
+            gr.Markdown(f"⚠️ Error creating full interface: {str(e)}")
+            
+            dna_input = gr.Textbox(label="DNA Sequence", lines=5)
+            analyze_btn = gr.Button("Analyze")
+            output = gr.Textbox(label="Results", lines=10)
+            
+            analyze_btn.click(
+                fn=lambda seq: run_pipeline(seq, 95.0, False)[4],  # Just return summary
+                inputs=[dna_input],
+                outputs=[output]
             )
-        return simple_interface()
+        
+        return fallback_iface
 
-# --- Main Application Launcher ---
-def launch_app():
-    """Launch the application with both FastAPI and Gradio"""
+# --- Application Startup ---
+if __name__ == "__main__":
     try:
         # Create Gradio interface
-        gradio_app = create_gradio_interface()
+        gr_interface = create_gradio_interface()
         
         # Mount Gradio app to FastAPI
-        app.mount("/gradio", gradio_app.mount_to_fastapi())
-        
-        # Add root redirect to Gradio
-        @app.get("/")
-        async def redirect_to_gradio():
-            return HTMLResponse("""
-            <html>
-                <head>
-                    <title>🧬 Gene Analysis Pipeline</title>
-                    <meta http-equiv="refresh" content="0; url=/gradio">
-                    <style>
-                        body { 
-                            font-family: Arial, sans-serif; 
-                            text-align: center; 
-                            padding: 50px;
-                            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-                            color: white;
-                        }
-                        .container {
-                            background: rgba(255,255,255,0.1);
-                            padding: 30px;
-                            border-radius: 15px;
-                            backdrop-filter: blur(10px);
-                            max-width: 500px;
-                            margin: 0 auto;
-                        }
-                        a {
-                            color: #fff;
-                            text-decoration: none;
-                            font-weight: bold;
-                        }
-                    </style>
-                </head>
-                <body>
-                    <div class="container">
-                        <h1>🧬 Gene Analysis Pipeline</h1>
-                        <p>Redirecting to the analysis interface...</p>
-                        <p><a href="/gradio">Click here if not redirected automatically</a></p>
-                        <br>
-                        <p><small>
-                            API Documentation: <a href="/docs">/docs</a><br>
-                            Health Check: <a href="/health">/health</a>
-                        </small></p>
-                    </div>
-                </body>
-            </html>
-            """)
+        gr_app = gr.mount_gradio_app(app, gr_interface, path="/gradio")
         
-        logger.info("🚀 Application setup complete!")
-        return app
+        # Log startup info
+        logger.info("🚀 Starting Gene Analysis Pipeline...")
+        logger.info(f"📁 Base directory: {BASE_DIR}")
+        logger.info(f"🤖 Models loaded: Boundary={boundary_model is not None}, Keras={keras_model is not None}")
+        logger.info(f"🌳 Tree analyzer: {analyzer is not None}")
+        
+        mafft_available, iqtree_available, _, _ = check_tool_availability()
+        logger.info(f"🔬 Tools available: MAFFT={mafft_available}, IQ-TREE={iqtree_available}")
+        
+        # Start server
+        logger.info("🌐 Starting server on http://0.0.0.0:7860")
+        logger.info("📊 FastAPI docs: http://0.0.0.0:7860/docs")
+        logger.info("🎮 Gradio interface: http://0.0.0.0:7860/gradio")
+        
+        uvicorn.run(
+            app,
+            host="0.0.0.0",
+            port=7860,
+            log_level="info",
+            access_log=True
+        )
         
     except Exception as e:
-        logger.error(f"Application launch failed: {e}")
-        raise
-
-# --- Entry Point ---
-if __name__ == "__main__":
-    try:
-        # Check if running in Hugging Face Spaces
-        if os.getenv("SPACE_ID"):
-            logger.info("🤗 Running in Hugging Face Spaces")
-            # In Spaces, just create and launch Gradio
-            gradio_app = create_gradio_interface()
-            gradio_app.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=False,
-                show_error=True,
-                quiet=False
-            )
-        else:
-            # Local development - run full FastAPI + Gradio
-            logger.info("💻 Running in local development mode")
-            app = launch_app()
-            
-            # Determine port
-            port = int(os.getenv("PORT", 8000))
-            
-            # Launch with uvicorn
-            uvicorn.run(
-                app,
-                host="0.0.0.0",
-                port=port,
-                log_level="info",
-                access_log=True
-            )
-            
-    except KeyboardInterrupt:
-        logger.info("🛑 Application stopped by user")
-    except Exception as e:
-        logger.error(f"💥 Application failed to start: {e}")
-        # Last resort - simple Gradio interface
-        try:
-            simple_gradio = gr.Interface(
-                fn=lambda x: f"Application Error: {e}",
-                inputs=gr.Textbox(label="Error Mode"),
-                outputs=gr.Textbox(label="Status"),
-                title="🧬 Gene Analysis Pipeline - Error Mode"
-            )
-            simple_gradio.launch(server_name="0.0.0.0", server_port=7860)
-        except:
-            logger.critical("💀 Complete application failure")
-            sys.exit(1)
+        logger.error(f"❌ Startup failed: {e}")
+        print(f"❌ Failed to start application: {e}")
+        sys.exit(1)