Update app.py

app.py

@@ -1,19 +1,14 @@
 import os
-# Disable GPU to avoid CUDA errors
-os.environ["CUDA_VISIBLE_DEVICES"] = ""
-os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"  # Prevent TensorFlow memory issues
-# Suppress TensorFlow warnings
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'  # More aggressive suppression
-
-import gradio as gr
-import torch
+import logging
 import pickle
 import subprocess
 import pandas as pd
 import re
-import logging
 import numpy as np
-from predictor import EnhancedGenePredictor
+import torch
+from flask import Flask, request, jsonify, send_file
+from werkzeug.utils import secure_filename
+from predictor import GenePredictor
 from tensorflow.keras.models import load_model
 from analyzer import PhylogeneticTreeAnalyzer
 import tempfile
@@ -27,33 +22,23 @@ 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
 
 # --- Logging Setup ---
-log_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-log_handler = logging.StreamHandler()
-log_handler.setFormatter(log_formatter)
-try:
-    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}")
-
+os.makedirs('/tmp', exist_ok=True)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('/tmp/flask_app.log')
+    ]
+)
 logger = logging.getLogger(__name__)
-logger.info(f"Gradio version: {gr.__version__}")
 
-# Set event loop policy for compatibility with Gradio Spaces
-try:
-    asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
-except Exception as e:
-    logger.warning(f"Failed to set event loop policy: {e}")
+# Disable GPU to avoid CUDA errors
+os.environ["CUDA_VISIBLE_DEVICES"] = ""
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
 
 # --- Global Variables ---
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -63,59 +48,69 @@ ALIGNMENT_PATH = os.path.join(BASE_DIR, "f_gene_sequences_aligned.fasta")
 TREE_PATH = os.path.join(BASE_DIR, "f_gene_sequences.phy.treefile")
 QUERY_OUTPUT_DIR = os.path.join(BASE_DIR, "queries")
 os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
-
-# Model repository and file paths
 MODEL_REPO = "GGproject10/best_boundary_aware_model"
 CSV_PATH = "f cleaned.csv"
+HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Initialize models as None
+# Initialize models
 boundary_model = None
 keras_model = None
 kmer_to_index = None
 analyzer = None
 
-# --- Model Loading ---
+# --- Load Models ---
 def load_models_safely():
     global boundary_model, keras_model, kmer_to_index, analyzer
     logger.info("🔍 Loading models...")
+
+    # Boundary model
     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.")
+        boundary_path = os.path.join(BASE_DIR, "models", "best_boundary_aware_model.pth")
+        if not os.path.exists(boundary_path):
+            logger.info(f"Downloading boundary model from {MODEL_REPO}...")
+            boundary_path = hf_hub_download(
+                repo_id=MODEL_REPO,
+                filename="best_boundary_aware_model.pth",
+                token=HF_TOKEN,
+                local_dir=os.path.join(BASE_DIR, "models")
+            )
+        boundary_model = GenePredictor(boundary_path)
+        logger.info("✅ Boundary model loaded")
     except Exception as e:
         logger.error(f"❌ Failed to load boundary model: {e}")
         boundary_model = None
+
+    # Keras model
     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.")
+        keras_path = os.path.join(BASE_DIR, "models", "best_model.keras")
+        kmer_path = os.path.join(BASE_DIR, "models", "kmer_to_index.pkl")
+        if not os.path.exists(keras_path):
+            logger.info(f"Downloading Keras model from {MODEL_REPO}...")
+            keras_path = hf_hub_download(
+                repo_id=MODEL_REPO,
+                filename="best_model.keras",
+                token=HF_TOKEN,
+                local_dir=os.path.join(BASE_DIR, "models")
+            )
+        if not os.path.exists(kmer_path):
+            logger.info(f"Downloading k-mer index from {MODEL_REPO}...")
+            kmer_path = hf_hub_download(
+                repo_id=MODEL_REPO,
+                filename="kmer_to_index.pkl",
+                token=HF_TOKEN,
+                local_dir=os.path.join(BASE_DIR, "models")
+            )
+        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")
     except Exception as e:
         logger.error(f"❌ Failed to load Keras model: {e}")
         keras_model = None
         kmer_to_index = None
+
+    # Tree analyzer
     try:
-        logger.info("🌳 Initializing tree analyzer...")
         analyzer = PhylogeneticTreeAnalyzer()
         csv_candidates = [
             CSV_PATH,
@@ -128,94 +123,129 @@ def load_models_safely():
         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 analyzer.load_data(csv_candidate):
+                    logger.info(f"✅ CSV loaded: {csv_candidate}")
+                    csv_loaded = True
+                    break
         if not csv_loaded:
-            logger.error("❌ Failed to load CSV data from any candidate location.")
+            logger.error("❌ Failed to load CSV")
             analyzer = None
         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}")
+            if analyzer.train_ai_model():
+                logger.info("✅ AI model trained")
     except Exception as e:
-        logger.error(f"❌ Tree analyzer initialization failed: {e}")
+        logger.error(f"❌ Tree analyzer failed: {e}")
         analyzer = None
 
-# Load models at startup
-load_models_safely()
+try:
+    load_models_safely()
+except Exception as e:
+    logger.critical(f"Model loading failed: {e}")
+    sys.exit(1)
 
 # --- Tool Detection ---
 def setup_binary_permissions():
     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}")
+            os.chmod(binary, os.stat(binary).st_mode | stat.S_IEXEC)
+            logger.info(f"✅ Set permission: {binary}")
+        else:
+            logger.warning(f"⚠️ Binary not found: {binary}")
 
 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]
+    mafft_candidates = [
+        MAFFT_PATH,
+        os.path.join(BASE_DIR, "binaries", "mafft", "mafft"),
+        os.path.join(BASE_DIR, "binaries", "mafft", "mafft.bat"),
+        'mafft',
+        '/usr/bin/mafft',
+        '/usr/local/bin/mafft',
+        os.path.join(BASE_DIR, "binaries", "mafft", "mafftdir", "bin", "mafft"),
+        os.path.expanduser("~/anaconda3/bin/mafft"),
+        os.path.expanduser("~/miniconda3/bin/mafft"),
+        "/opt/conda/bin/mafft",
+        "/usr/local/miniconda3/bin/mafft"
+    ]
     for candidate in mafft_candidates:
-        if shutil.which(candidate) or os.path.exists(candidate):
+        if os.path.exists(candidate) or shutil.which(candidate):
             try:
                 result = subprocess.run(
                     [candidate, "--help"],
                     capture_output=True,
                     text=True,
-                    timeout=5
+                    timeout=10
                 )
                 if result.returncode == 0 or "mafft" in result.stderr.lower():
                     mafft_available = True
                     mafft_cmd = candidate
-                    logger.info(f"✅ MAFFT found at: {candidate}")
+                    logger.info(f"✅ MAFFT: {candidate}")
                     break
             except Exception as e:
-                logger.debug(f"MAFFT test failed for {candidate}: {e}")
+                logger.debug(f"MAFFT test failed: {candidate}: {e}")
     iqtree_available = False
     iqtree_cmd = None
-    iqtree_candidates = ['iqtree', 'iqtree2', 'iqtree3', '/usr/bin/iqtree', '/usr/local/bin/iqtree', IQTREE_PATH]
+    iqtree_candidates = [
+        IQTREE_PATH,
+        'iqtree',
+        'iqtree2',
+        'iqtree3',
+        '/usr/bin/iqtree',
+        '/usr/local/bin/iqtree',
+        'iqtree.exe',
+        'iqtree2.exe',
+        'iqtree3.exe',
+        os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree2"),
+        os.path.expanduser("~/anaconda3/bin/iqtree2"),
+        os.path.expanduser("~/miniconda3/bin/iqtree2"),
+        "/opt/conda/bin/iqtree2",
+        "/usr/local/miniconda3/bin/iqtree2"
+    ]
     for candidate in iqtree_candidates:
-        if shutil.which(candidate) or os.path.exists(candidate):
+        if os.path.exists(candidate) or shutil.which(candidate):
             try:
                 result = subprocess.run(
                     [candidate, "--help"],
                     capture_output=True,
                     text=True,
-                    timeout=5
+                    timeout=10
                 )
                 if result.returncode == 0 or "iqtree" in result.stderr.lower():
                     iqtree_available = True
                     iqtree_cmd = candidate
-                    logger.info(f"✅ IQ-TREE found at: {candidate}")
+                    logger.info(f"✅ IQ-TREE: {candidate}")
                     break
             except Exception as e:
-                logger.debug(f"IQ-TREE test failed for {candidate}: {e}")
+                logger.debug(f"IQ-TREE test failed: {candidate}: {e}")
     return mafft_available, iqtree_available, mafft_cmd, iqtree_cmd
 
+def install_dependencies_guide():
+    return """
+🔧 INSTALLATION GUIDE FOR MISSING DEPENDENCIES:
+For MAFFT:
+- Ubuntu/Debian: sudo apt-get install mafft
+- CentOS/RHEL: sudo yum install mafft
+- macOS: brew install mafft
+- Windows: Download from https://mafft.cbrc.jp/alignment/software/
+- Conda: conda install -c bioconda mafft
+For IQ-TREE:
+- Ubuntu/Debian: sudo apt-get install iqtree
+- CentOS/RHEL: sudo yum install iqtree
+- macOS: brew install iqtree
+- Windows: Download from http://www.iqtree.org/
+- Conda: conda install -c bioconda iqtree
+"""
+
 # --- Pipeline Functions ---
-def cleanup_file(file_path: str) -> None:
-    """Utility function to safely delete a file and log errors."""
+def cleanup_file(file_path: str):
     if file_path and os.path.exists(file_path):
         try:
             os.unlink(file_path)
             logger.debug(f"Cleaned up {file_path}")
-        except Exception as cleanup_error:
-            logger.warning(f"Failed to clean up {file_path}: {cleanup_error}")
+        except Exception as e:
+            logger.warning(f"Failed to clean up {file_path}: {e}")
 
 def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
     query_fasta = None
@@ -227,8 +257,7 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
         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):
-            cleanup_file(query_fasta)
-            return False, "Reference alignment or tree not found.", None, None
+            return False, f"Reference files missing: {ALIGNMENT_PATH}, {TREE_PATH}", 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:
@@ -257,49 +286,88 @@ def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
         success_msg = f"Placement completed!\nQuery ID: {query_id}\nAlignment: {os.path.basename(aligned_with_query)}\nTree: {os.path.basename(treefile)}"
         cleanup_file(query_fasta)
         return True, success_msg, aligned_with_query, treefile
-    except Exception as main_error:
-        logger.error(f"Phylogenetic placement failed: {main_error}", exc_info=True)
+    except Exception as e:
+        logger.error(f"Phylogenetic placement failed: {e}")
         cleanup_file(query_fasta)
-        return False, f"Error: {str(main_error)}", None, None
+        return False, f"Error: {str(e)}", None, None
+
+def build_maximum_likelihood_tree(f_gene_sequence):
+    try:
+        mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
+        status_msg = "🔍 Checking dependencies...\n"
+        if not mafft_available:
+            status_msg += "❌ MAFFT not found\n"
+        else:
+            status_msg += f"✅ MAFFT found: {mafft_cmd}\n"
+        if not iqtree_available:
+            status_msg += "❌ IQ-TREE not found\n"
+        else:
+            status_msg += f"✅ IQ-TREE found: {iqtree_cmd}\n"
+        if not os.path.exists(ALIGNMENT_PATH):
+            status_msg += f"❌ Reference alignment not found: {ALIGNMENT_PATH}\n"
+        else:
+            status_msg += f"✅ Reference alignment found\n"
+        if not os.path.exists(TREE_PATH):
+            status_msg += f"❌ Reference tree not found: {TREE_PATH}\n"
+        else:
+            status_msg += f"✅ Reference tree found\n"
+        if not mafft_available or not iqtree_available:
+            guide = install_dependencies_guide()
+            return False, f"{status_msg}\n{guide}", None, None
+        if not os.path.exists(ALIGNMENT_PATH) or not os.path.exists(TREE_PATH):
+            status_msg += "\n❌ Missing reference files.\n"
+            return False, status_msg, None, None
+        placement_success, placement_message, aligned_file, tree_file = phylogenetic_placement(
+            f_gene_sequence, mafft_cmd, iqtree_cmd
+        )
+        if placement_success:
+            final_message = f"{status_msg}\n{placement_message}"
+            if aligned_file and os.path.exists(aligned_file):
+                standard_aligned = os.path.join(QUERY_OUTPUT_DIR, "query_with_references_aligned.fasta")
+                shutil.copy2(aligned_file, standard_aligned)
+                aligned_file = standard_aligned
+            if tree_file and os.path.exists(tree_file):
+                standard_tree = os.path.join(QUERY_OUTPUT_DIR, "query_placement_tree.treefile")
+                shutil.copy2(tree_file, standard_tree)
+                tree_file = standard_tree
+            return True, final_message, aligned_file, tree_file
+        else:
+            return False, f"{status_msg}\n{placement_message}", aligned_file, tree_file
+    except Exception as e:
+        logger.error(f"ML tree construction failed: {e}")
+        return False, f"Error: {str(e)}", None, None
 
 def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
     try:
-        logger.debug("Starting tree analysis...")
         if not analyzer:
-            return "❌ Tree analyzer not initialized.", None, None
+            return "❌ Tree analyzer not initialized.", None
         if not sequence or len(sequence.strip()) < 10:
-            return "❌ Invalid sequence.", None, None
+            return "❌ Invalid sequence.", None
         if not (1 <= matching_percentage <= 99):
-            return "❌ Matching percentage must be 1-99.", None, None
-        logger.debug("Finding query sequence...")
+            return "❌ Matching percentage must be 1-99.", None
         if not analyzer.find_query_sequence(sequence):
-            return "❌ Sequence not accepted.", None, None
-        logger.debug("Finding similar sequences...")
+            return "❌ Sequence not accepted.", 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
-        logger.debug("Building tree structure...")
+            return f"❌ No similar sequences at {matching_percentage}% threshold.", None
         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
+        output_dir = os.path.join(BASE_DIR, "output")
+        os.makedirs(output_dir, exist_ok=True)
+        html_filename = f"tree_{query_id}.html"
+        html_path = os.path.join(output_dir, html_filename)
+        fig.write_html(html_path)
+        success_msg = f"✅ Found {len(matched_ids)} sequences at {actual_percentage:.2f}% similarity."
+        return success_msg, html_path
     except Exception as e:
-        logger.error(f"Tree analysis failed: {e}", exc_info=True)
-        return f"❌ Error: {str(e)}", None, None
+        logger.error(f"Tree analysis failed: {e}")
+        return f"❌ Error: {str(e)}", None
 
 def predict_with_keras(sequence):
     try:
         if not keras_model or not kmer_to_index:
-            return "❌ Keras model not available."
+            return f"❌ 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)]
@@ -310,46 +378,54 @@ def predict_with_keras(sequence):
         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}", exc_info=True)
+        logger.error(f"Keras prediction failed: {e}")
         return f"❌ Error: {str(e)}"
 
-def read_fasta_file(file_obj):
+def read_fasta_file(file_path):
     try:
-        if file_obj is None:
+        if not file_path:
             return ""
-        if isinstance(file_obj, str):
-            with open(file_obj, "r") as f:
-                content = f.read()
-        else:
-            content = file_obj.read().decode("utf-8")
+        with open(file_path, "r") as f:
+            content = f.read()
         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}", exc_info=True)
+        logger.error(f"Failed to read FASTA file: {e}")
         return ""
 
+def run_pipeline_from_file(fasta_file_path, similarity_score, build_ml_tree):
+    try:
+        dna_input = read_fasta_file(fasta_file_path)
+        if not dna_input:
+            return "❌ Failed to read FASTA file", "", "", "", "", None, None, None, "No input"
+        return run_pipeline(dna_input, similarity_score, build_ml_tree)
+    except Exception as e:
+        logger.error(f"Pipeline from file error: {e}")
+        return f"❌ Error: {str(e)}", "", "", "", "", None, None, None, f"❌ Error: {str(e)}"
+
 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", None, None
+            return "❌ Empty input", "", "", "", "", None, None, None, "No input"
         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(dna_input)
-                regions = result['gene_regions']
+                predictions, probs, confidence = boundary_model.predict(dna_input)
+                regions = boundary_model.extract_gene_regions(predictions, dna_input)
                 if regions:
                     processed_sequence = regions[0]["sequence"]
-                    boundary_output = f"✅ F gene region found: {len(processed_sequence)} bp"
+                    boundary_output = processed_sequence
+                    logger.info(f"F gene extracted: {len(processed_sequence)} bp")
                 else:
                     boundary_output = "⚠️ No F gene regions found."
                     processed_sequence = dna_input
             except Exception as e:
-                boundary_output = f"❌ Boundary prediction error: {str(e)}"
+                boundary_output = f"❌ Boundary error: {str(e)}"
                 processed_sequence = dna_input
         else:
             boundary_output = f"⚠️ Boundary model not available. Using full input: {len(dna_input)} bp"
@@ -358,48 +434,29 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         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()
-                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)}"
+            ml_success, ml_message, ml_aligned, ml_tree = build_maximum_likelihood_tree(processed_sequence)
+            ml_tree_output = ml_message
+            aligned_file = ml_aligned
+            phy_file = ml_tree
         elif build_ml_tree:
             ml_tree_output = "❌ Sequence too short for placement (<100 bp)."
         else:
             ml_tree_output = "⚠️ Phylogenetic placement skipped."
+        html_file = None
         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:
-                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>"
-                report_html_content = f"<div style='color: red;'>{simplified_ml_output}</div>"
+            tree_result, html_path = analyze_sequence_for_tree(processed_sequence, similarity_score)
+            simplified_ml_output = tree_result
+            html_file = html_path
+            if html_path and os.path.exists(html_path):
+                with open(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>"
         else:
             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:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -407,420 +464,171 @@ 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'}
+Tree Analysis: {'✅ OK' if '✅' 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,
-            tree_html_path, report_html_path
+            aligned_file, phy_file, html_file, tree_html_content
         )
     except Exception as e:
-        logger.error(f"Pipeline error: {e}", exc_info=True)
+        logger.error(f"Pipeline error: {e}")
         error_msg = f"❌ Pipeline Error: {str(e)}"
-        return error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg, None, None
-
-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:
-            cleanup_file(temp_file_path)
-            return "❌ Failed to read FASTA file", "", "", "", "", None, None, None, None, "No input", "No input", None, None
-        result = run_pipeline(dna_input, similarity_score, build_ml_tree)
-        cleanup_file(temp_file_path)
-        return result
-    except Exception as main_error:
-        logger.error(f"Pipeline from file error: {main_error}", exc_info=True)
-        cleanup_file(temp_file_path)
-        error_msg = f"❌ Error: {str(main_error)}"
-        return error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg, None, None
+        return error_msg, "", "", "", "", None, None, None, error_msg
 
-class AnalysisRequest(BaseModel):
-    sequence: str
-    similarity_score: float = 95.0
-    build_ml_tree: bool = False
+# --- Flask App ---
+app = Flask(__name__)
 
-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():
+@app.route("/health", methods=["GET"])
+def health_check():
     try:
         mafft_available, iqtree_available, _, _ = check_tool_availability()
-        return {
-            "status": "healthy",
+        files_exist = {
+            "alignment": os.path.exists(ALIGNMENT_PATH),
+            "tree": os.path.exists(TREE_PATH),
+            "csv": any(os.path.exists(c) for c in [
+                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")
+            ])
+        }
+        return jsonify({
+            "status": "healthy" if all([boundary_model, keras_model, analyzer, mafft_available, iqtree_available, files_exist["alignment"], files_exist["tree"], files_exist["csv"]]) else "unhealthy",
             "components": {
                 "boundary_model": boundary_model is not None,
                 "keras_model": keras_model is not None,
+                "kmer_index": kmer_to_index is not None,
                 "tree_analyzer": analyzer is not None,
                 "mafft_available": mafft_available,
-                "iqtree_available": iqtree_available
+                "iqtree_available": iqtree_available,
+                "files": files_exist
             },
             "paths": {
                 "base_dir": BASE_DIR,
-                "query_output_dir": QUERY_OUTPUT_DIR
+                "query_output_dir": QUERY_OUTPUT_DIR,
+                "alignment_path": ALIGNMENT_PATH,
+                "tree_path": TREE_PATH
             }
-        }
+        }), 200
     except Exception as e:
-        logger.error(f"Health check error: {e}", exc_info=True)
-        return {"status": "unhealthy", "error": str(e)}
+        logger.error(f"Health check failed: {e}")
+        return jsonify({"status": "unhealthy", "error": str(e)}), 500
 
-@app.post("/analyze", response_model=AnalysisResponse)
-async def analyze_sequence(request: AnalysisRequest):
+@app.route("/analyze", methods=["POST"])
+def analyze_sequence():
     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
-        )
+        data = request.get_json()
+        if not data or "sequence" not in data:
+            return jsonify({"error": "Missing 'sequence' in JSON body"}), 400
+        sequence = data["sequence"].upper().strip()
+        similarity_score = float(data.get("similarity_score", 95.0))
+        build_ml_tree = data.get("build_ml_tree", False)
+        if not sequence:
+            return jsonify({"error": "Empty sequence"}), 400
+        if not re.match('^[ACTGN]+$', sequence):
+            return jsonify({"error": "Invalid sequence (use A, T, C, G, N)"}), 400
+        if not 30.0 <= similarity_score <= 99.0:
+            return jsonify({"error": "Similarity score must be between 30 and 99"}), 400
+        result = run_pipeline(sequence, similarity_score, build_ml_tree)
+        return jsonify({
+            "status": "success",
+            "boundary_output": result[0],
+            "keras_output": result[1],
+            "ml_tree_output": result[2],
+            "tree_analysis_output": result[3],
+            "summary_output": result[4],
+            "aligned_file": os.path.basename(result[5]) if result[5] else None,
+            "tree_file": os.path.basename(result[6]) if result[6] else None,
+            "html_tree_file": os.path.basename(result[7]) if result[7] else None,
+            "tree_html_content": result[8]
+        }), 200
     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)
-        )
+        logger.error(f"Analyze error: {e}")
+        return jsonify({"error": str(e)}), 500
 
-@app.post("/analyze-file", response_model=AnalysisResponse)
-async def analyze_file(
-    file: UploadFile = File(...),
-    similarity_score: float = Form(95.0),
-    build_ml_tree: bool = Form(False)
-):
-    temp_file_path = None
+@app.route("/analyze-file", methods=["POST"])
+def analyze_file():
     try:
+        if 'file' not in request.files:
+            return jsonify({"error": "No file provided"}), 400
+        file = request.files['file']
+        if file.filename == '':
+            return jsonify({"error": "Empty filename"}), 400
+        if not file.filename.endswith(('.fasta', '.fa', '.fas', '.txt')):
+            return jsonify({"error": "Invalid file type (use .fasta, .fa, .fas, .txt)"}), 400
+        similarity_score = float(request.form.get("similarity_score", 95.0))
+        build_ml_tree = request.form.get("build_ml_tree", "false").lower() == "true"
+        if not 30.0 <= similarity_score <= 99.0:
+            return jsonify({"error": "Similarity score must be between 30 and 99"}), 400
         with tempfile.NamedTemporaryFile(delete=False, suffix=".fasta", dir="/tmp") as temp_file:
-            content = await file.read()
-            temp_file.write(content)
+            file.save(temp_file.name)
             temp_file_path = temp_file.name
-        result = await run_pipeline_from_file(temp_file_path, similarity_score, build_ml_tree)
-        cleanup_file(temp_file_path)
-        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 main_error:
-        logger.error(f"Analyze-file error: {main_error}", exc_info=True)
+        result = run_pipeline_from_file(temp_file_path, similarity_score, build_ml_tree)
         cleanup_file(temp_file_path)
-        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(main_error)
-        )
+        return jsonify({
+            "status": "success",
+            "boundary_output": result[0],
+            "keras_output": result[1],
+            "ml_tree_output": result[2],
+            "tree_analysis_output": result[3],
+            "summary_output": result[4],
+            "aligned_file": os.path.basename(result[5]) if result[5] else None,
+            "tree_file": os.path.basename(result[6]) if result[6] else None,
+            "html_tree_file": os.path.basename(result[7]) if result[7] else None,
+            "tree_html_content": result[8]
+        }), 200
+    except Exception as e:
+        logger.error(f"Analyze-file error: {e}")
+        cleanup_file(temp_file_path) if 'temp_file_path' in locals() else None
+        return jsonify({"error": str(e)}), 500
 
-@app.get("/download/{file_type}/{query_id}")
-async def download_file(file_type: str, query_id: str):
+@app.route("/download/<file_type>/<filename>", methods=["GET"])
+def download_file(file_type, filename):
     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 file_type not in ["alignment", "tree", "html"]:
+            return jsonify({"error": "Invalid file type (use alignment, tree, html)"}), 400
+        if file_type == "html":
+            file_path = os.path.join(BASE_DIR, "output", filename)
+            if not filename.startswith("tree_") or not filename.endswith(".html"):
+                return jsonify({"error": "Invalid HTML filename"}), 400
+        else:
+            file_path = os.path.join(QUERY_OUTPUT_DIR, filename)
+            if file_type == "alignment" and not filename.endswith((".fasta", ".fa")):
+                return jsonify({"error": "Invalid alignment filename"}), 400
+            if file_type == "tree" and not filename.endswith(".treefile"):
+                return jsonify({"error": "Invalid tree filename"}), 400
         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")
+            return jsonify({"error": "File not found"}), 404
+        return send_file(file_path, as_attachment=True, download_name=filename)
     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_gradio_interface():
-    try:
-        with gr.Blocks(
-            title="🧬 Gene Analysis Pipeline",
-            theme=gr.themes.Soft(),
-            css="""
-            .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:
-            gr.Markdown("# 🧬 Gene Analysis Pipeline")
-            with gr.Row():
-                with gr.Column():
-                    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.TabItem("📝 Text Input"):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            gr.Markdown("Paste your DNA sequence here")
-                            dna_input = gr.Textbox(
-                                label="🧬 DNA Sequence",
-                                placeholder="Enter DNA sequence (ATCG format)...",
-                                lines=5
-                            )
-                        with gr.Column(scale=1):
-                            gr.Markdown("Minimum similarity for tree analysis")
-                            similarity_score = gr.Slider(
-                                minimum=1,
-                                maximum=99,
-                                value=95.0,
-                                step=1.0,
-                                label="🎯 Similarity Threshold (%)"
-                            )
-                            gr.Markdown("Generate phylogenetic placement (slower)")
-                            build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree",
-                                value=False
-                            )
-                            analyze_btn = gr.Button("🔬 Analyze Sequence", variant="primary")
-                with gr.TabItem("📁 File Upload"):
-                    with gr.Row():
-                        with gr.Column(scale=2):
-                            gr.Markdown("Upload a FASTA file containing your sequence")
-                            file_input = gr.File(
-                                label="📄 Upload FASTA File",
-                                file_types=[".fasta", ".fa", ".fas", ".txt"]
-                            )
-                        with gr.Column(scale=1):
-                            gr.Markdown("Minimum similarity for tree analysis")
-                            file_similarity_score = gr.Slider(
-                                minimum=1,
-                                maximum=99,
-                                value=95.0,
-                                step=1.0,
-                                label="🎯 Similarity Threshold (%)"
-                            )
-                            gr.Markdown("Generate phylogenetic placement (slower)")
-                            file_build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree",
-                                value=False
-                            )
-                            analyze_file_btn = gr.Button("🔬 Analyze File", variant="primary")
-            gr.Markdown("## 📊 Analysis Results")
-            with gr.Row():
-                with gr.Column():
-                    boundary_output = gr.Textbox(
-                        label="🎯 Boundary Detection",
-                        interactive=False,
-                        lines=2
-                    )
-                    keras_output = gr.Textbox(
-                        label="🧠 F Gene Validation",
-                        interactive=False,
-                        lines=2
-                    )
-                with gr.Column():
-                    ml_tree_output = gr.Textbox(
-                        label="🌲 Phylogenetic Placement",
-                        interactive=False,
-                        lines=2
-                    )
-                    tree_analysis_output = gr.Textbox(
-                        label="🌳 Tree Analysis",
-                        interactive=False,
-                        lines=2
-                    )
-            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)
-                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.TabItem("🌳 Interactive Tree"):
-                    tree_html = gr.HTML(
-                        value="<div style='text-align: center; color: #666; padding: 20px;'>No tree generated yet. Run analysis to see results.</div>"
-                    )
-                with gr.TabItem("📊 Detailed Report"):
-                    report_html = gr.HTML(
-                        label="Analysis Report",
-                        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_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
-                )
-
-            analyze_btn.click(
-                fn=run_pipeline,
-                inputs=[dna_input, similarity_score, build_ml_tree],
-                outputs=[
-                    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
-                ]
-            )
-
-            analyze_file_btn.click(
-                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,
-                    aligned_file, tree_file, tree_html_file, report_html_file, tree_html, report_html
-                ]
-            )
-
-            # Examples
-            gr.Examples(
-                examples=[
-                    ["ATCG" * 250, 85.0, False],
-                    ["CGATCG" * 150, 90.0, True]
-                ],
-                inputs=[dna_input, similarity_score, build_ml_tree],
-                label="Example Sequences"
-            )
-
-            gr.Markdown("""
-            ## 📚 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 main_error:
-        logger.error(f"Gradio interface creation failed: {main_error}", exc_info=True)
-        return gr.Interface(
-            fn=lambda x: f"Error: {str(main_error)}",
-            inputs=gr.Textbox(label="DNA Sequence"),
-            outputs=gr.Textbox(label="Error"),
-            title="🧬 Gene Analysis Pipeline (Error Mode)"
-        )
-
-# --- Application Startup ---
-def run_application():
-    try:
-        logger.info("🧬 Initializing Gene Analysis Pipeline...")
-        main_gradio_app = create_gradio_interface()
-        if main_gradio_app is None:
-            raise RuntimeError("Gradio interface creation returned None")
-        logger.info("✅ Gradio interface created successfully")
-        main_gradio_app = gr.mount_gradio_app(app, main_gradio_app, path="/gradio")
-        logger.info("✅ Gradio mounted to FastAPI at /gradio")
-        logger.info("=" * 50)
-        logger.info("🔍 Checking system components...")
-        logger.info(f"🤖 Boundary Model: {'✅ Loaded' if boundary_model else '❌ Missing'}")
-        logger.info(f"🧠 Keras Model: {'✅ Loaded' if keras_model else '❌ Missing'}")
-        logger.info(f"🌳 Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Missing'}")
-        mafft_available, iqtree_available, _, _ = check_tool_availability()
-        logger.info(f"🧬 MAFFT: {'✅ Available' if mafft_available else '❌ Missing'}")
-        logger.info(f"🌲 IQ-TREE: {'✅ Available' if iqtree_available else '❌ Missing'}")
-        logger.info("=" * 50)
-        logger.info("🚀 Starting Gene Analysis Pipeline...")
-        logger.warning("⚠️ Running without request queuing. Concurrent requests may block.")
-        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",
-            access_log=True,
-            timeout_keep_alive=120
-        )
-    except Exception as main_error:
-        logger.error(f"Application startup failed: {main_error}", exc_info=True)
-        try:
-            logger.info("🔄 Falling back to Gradio-only mode...")
-            fallback_gradio_app = create_gradio_interface()
-            if fallback_gradio_app is None:
-                raise RuntimeError("Fallback Gradio interface creation returned None")
-            logger.info("✅ Fallback Gradio interface created successfully")
-            logger.info("🧬 Gradio interface available at: http://localhost:7860")
-            fallback_gradio_app.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                prevent_thread_lock=True,
-                quiet=True
-            )
-        except Exception as fallback_error:
-            logger.error(f"Fallback failed: {fallback_error}", exc_info=True)
-            print("❌ Application failed to start. Check logs at /tmp/app.log for details.")
-            sys.exit(1)
+        logger.error(f"Download error: {e}")
+        return jsonify({"error": str(e)}), 500
 
 if __name__ == "__main__":
-    print("🧬 Gene Analysis Pipeline Starting...")
-    print("=" * 50)
-    print("🔍 Checking system components...")
+    logger.info("🧬 Starting Flask Gene Analysis API...")
     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()
+    logger.info(f"🤖 Boundary Model: {'✅ Loaded' if boundary_model else '❌ Missing'}")
+    logger.info(f"🧠 Keras Model: {'✅ Loaded' if keras_model else '❌ Missing'}")
+    logger.info(f"🌳 Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Missing'}")
+    logger.info(f"🧬 MAFFT: {'✅ Available' if mafft_available else '❌ Missing'}")
+    logger.info(f"🌲 IQ-TREE: {'✅ Available' if iqtree_available else '❌ Missing'}")
+    files_exist = {
+        "alignment": os.path.exists(ALIGNMENT_PATH),
+        "tree": os.path.exists(TREE_PATH),
+        "csv": any(os.path.exists(c) for c in [
+            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")
+        ])
+    }
+    logger.info(f"📂 Files: Alignment={'✅' if files_exist['alignment'] else '❌'}, Tree={'✅' if files_exist['tree'] else '❌'}, CSV={'✅' if files_exist['csv'] else '❌'}")
+    if not all(files_exist.values()):
+        logger.critical("Missing required reference files")
+        sys.exit(1)
+    app.run(host="0.0.0.0", port=7860, debug=False)