Update app.py

app.py

@@ -25,7 +25,7 @@ import time
 
 # --- Global Variables ---
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft")  # Updated path
+MAFFT_PATH = os.path.join(BASE_DIR, "binaries", "mafft", "mafft")
 IQTREE_PATH = os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree3")
 ALIGNMENT_PATH = os.path.join(BASE_DIR, "f_gene_sequences_aligned.fasta")
 TREE_PATH = os.path.join(BASE_DIR, "f_gene_sequences.phy.treefile")
@@ -35,20 +35,17 @@ os.makedirs(QUERY_OUTPUT_DIR, exist_ok=True)
 # --- Logging ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-# --- Paths ---
-# Model repository and file paths
+# --- Load Models (same as your original code) ---
 model_repo = "GGproject10/best_boundary_aware_model"
 csv_path = "f cleaned.csv"
-
-# Get HF token from environment (if available)
 hf_token = os.getenv("HF_TOKEN")
 
-# --- Load Models ---
 boundary_model = None
 keras_model = None
 kmer_to_index = None
+analyzer = None
 
-# Try to load boundary model from Hugging Face Hub
+# [Include all your model loading code here - same as original]
 try:
     boundary_path = hf_hub_download(
         repo_id=model_repo, 
@@ -58,12 +55,9 @@ try:
     if os.path.exists(boundary_path):
         boundary_model = GenePredictor(boundary_path)
         logging.info("Boundary model loaded successfully from Hugging Face Hub.")
-    else:
-        logging.warning(f"Boundary model file not found after download")
 except Exception as e:
     logging.error(f"Failed to load boundary model from HF Hub: {e}")
 
-# Try to load Keras model from Hugging Face Hub
 try:
     keras_path = hf_hub_download(
         repo_id=model_repo, 
@@ -80,56 +74,11 @@ try:
         keras_model = load_model(keras_path)
         with open(kmer_path, "rb") as f:
             kmer_to_index = pickle.load(f)
-        logging.info("Keras model and k-mer index loaded successfully from Hugging Face Hub.")
-    else:
-        logging.warning(f"Keras model or kmer files not found after download")
+        logging.info("Keras model and k-mer index loaded successfully.")
 except Exception as e:
     logging.error(f"Failed to load Keras model from HF Hub: {e}")
 
-# --- Initialize New Tree Analyzer ---
-analyzer = None
-try:
-    analyzer = PhylogeneticTreeAnalyzer()
-    
-    # Try multiple potential locations for the CSV file
-    csv_candidates = [
-        csv_path,
-        os.path.join(BASE_DIR, csv_path),
-        os.path.join(BASE_DIR, "app", csv_path),
-        os.path.join(os.path.dirname(__file__), csv_path),
-        "f_cleaned.csv",  # Alternative naming
-        os.path.join(BASE_DIR, "f_cleaned.csv")
-    ]
-    
-    csv_loaded = False
-    for csv_candidate in csv_candidates:
-        if os.path.exists(csv_candidate):
-            if analyzer.load_data(csv_candidate):
-                logging.info(f"Tree analyzer data loaded from: {csv_candidate}")
-                csv_loaded = True
-                csv_path = csv_candidate  # Update path for consistency
-                break
-            else:
-                logging.warning(f"Failed to load data from: {csv_candidate}")
-    
-    if not csv_loaded:
-        logging.error("Failed to load CSV data from any candidate location")
-        analyzer = None
-    else:
-        # Try to train AI model (optional)
-        try:
-            if analyzer.train_ai_model():
-                logging.info("AI model training completed successfully")
-            else:
-                logging.warning("AI model training failed; proceeding with basic analysis.")
-        except Exception as e:
-            logging.warning(f"AI model training failed: {e}")
-            
-except Exception as e:
-    logging.error(f"Failed to initialize tree analyzer: {e}")
-    analyzer = None
-
-# --- Enhanced Tool Detection with Binary Permission Setup ---
+# [Include all your helper functions - same as original]
 def setup_binary_permissions():
     """Set executable permissions on MAFFT and IQ-TREE binaries"""
     binaries = [MAFFT_PATH, IQTREE_PATH]
@@ -137,464 +86,92 @@ def setup_binary_permissions():
     for binary in binaries:
         if os.path.exists(binary):
             try:
-                # Set executable permission
                 current_mode = os.stat(binary).st_mode
                 os.chmod(binary, current_mode | stat.S_IEXEC)
                 logging.info(f"Set executable permission on {binary}")
             except Exception as e:
                 logging.warning(f"Failed to set executable permission on {binary}: {e}")
-        else:
-            logging.warning(f"Binary not found: {binary}")
 
 def check_tool_availability():
-    """Enhanced check for MAFFT and IQ-TREE availability with improved path validation"""
-    
-    # First, ensure binaries have executable permissions
+    """Enhanced check for MAFFT and IQ-TREE availability"""
     setup_binary_permissions()
     
     # Check MAFFT
     mafft_available = False
     mafft_cmd = None
     
-    # Updated MAFFT candidates list based on your new API
     mafft_candidates = [
-        MAFFT_PATH,  # Primary path from your new API
-        os.path.join(BASE_DIR, "binaries", "mafft", "mafft"),
-        os.path.join(BASE_DIR, "binaries", "mafft", "mafft.bat"),  # Windows fallback
+        MAFFT_PATH,
         'mafft',
         '/usr/bin/mafft',
         '/usr/local/bin/mafft',
-        os.path.join(BASE_DIR, "binaries", "mafft", "mafftdir", "bin", "mafft"),
-        # Add potential conda/miniconda paths
-        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 not candidate:
             continue
-            
-        # First check if file exists or is in PATH
         if os.path.exists(candidate) or shutil.which(candidate):
-            # Now test actual execution
             try:
-                test_cmd = [candidate, "--help"]
-                result = subprocess.run(
-                    test_cmd, 
-                    capture_output=True, 
-                    text=True, 
-                    timeout=10
-                )
+                result = subprocess.run([candidate, "--help"], capture_output=True, text=True, timeout=10)
                 if result.returncode == 0 or "mafft" in result.stderr.lower():
                     mafft_available = True
                     mafft_cmd = candidate
-                    logging.info(f"MAFFT found and tested successfully at: {candidate}")
                     break
-            except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError) as e:
-                logging.debug(f"MAFFT test failed for {candidate}: {e}")
+            except:
                 continue
     
-    # Check IQ-TREE with similar approach
+    # Check IQ-TREE
     iqtree_available = False
     iqtree_cmd = None
     
-    # Updated IQ-TREE candidates list
     iqtree_candidates = [
-        IQTREE_PATH,  # Primary path from your new API
+        IQTREE_PATH,
         'iqtree2',
         'iqtree',
-        'iqtree3',
         '/usr/bin/iqtree2',
         '/usr/local/bin/iqtree2',
-        '/usr/bin/iqtree',
-        '/usr/local/bin/iqtree',
-        'iqtree2.exe',  # Windows
-        'iqtree.exe',   # Windows
-        'iqtree3.exe',  # Windows
-        os.path.join(BASE_DIR, "binaries", "iqtree", "bin", "iqtree2"),
-        # Add potential conda paths
-        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 not candidate:
             continue
-            
         if os.path.exists(candidate) or shutil.which(candidate):
             try:
-                test_cmd = [candidate, "--help"]
-                result = subprocess.run(
-                    test_cmd, 
-                    capture_output=True, 
-                    text=True, 
-                    timeout=10
-                )
+                result = subprocess.run([candidate, "--help"], capture_output=True, text=True, timeout=10)
                 if result.returncode == 0 or "iqtree" in result.stderr.lower():
                     iqtree_available = True
                     iqtree_cmd = candidate
-                    logging.info(f"IQ-TREE found and tested successfully at: {candidate}")
                     break
-            except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError) as e:
-                logging.debug(f"IQ-TREE test failed for {candidate}: {e}")
+            except:
                 continue
     
     return mafft_available, iqtree_available, mafft_cmd, iqtree_cmd
 
-def install_dependencies_guide():
-    """Provide installation guidance for missing dependencies"""
-    guide = """
-🔧 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
-
-Alternative: Use conda/mamba (RECOMMENDED):
-- conda install -c bioconda mafft iqtree
-
-Docker option:
-- docker run -it --rm -v $(pwd):/data quay.io/biocontainers/mafft:7.490--h779adbc_0
-- docker run -it --rm -v $(pwd):/data quay.io/biocontainers/iqtree:2.1.4_beta--hdcc8f71_0
-
-TROUBLESHOOTING:
-If tools are installed but not detected, try:
-1. Add installation directory to PATH
-2. Use absolute paths in the configuration
-3. Check permissions on executable files
-4. Ensure binaries have executable permissions (chmod +x)
-"""
-    return guide
-
-def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
-    """
-    Improved phylogenetic placement using the new API approach.
-    This adds the query sequence to a reference alignment and tree.
-    """
-    try:
-        # Validate sequence
-        if len(sequence.strip()) < 100:
-            return False, "Error: Sequence is too short for phylogenetic placement (minimum 100 bp).", None, None
-
-        # Generate unique query ID
-        query_id = f"QUERY_{uuid.uuid4().hex[:8]}"
-        query_fasta = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}.fa")
-        aligned_with_query = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_aligned.fa")
-        output_prefix = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_placed_tree")
-
-        # Check if reference files exist
-        if not os.path.exists(ALIGNMENT_PATH):
-            return False, f"Reference alignment not found: {ALIGNMENT_PATH}", None, None
-        
-        if not os.path.exists(TREE_PATH):
-            return False, f"Reference tree not found: {TREE_PATH}", None, None
-
-        # Save query sequence as FASTA (improved error handling)
-        try:
-            query_record = SeqRecord(Seq(sequence.upper()), id=query_id, description="")
-            SeqIO.write([query_record], query_fasta, "fasta")
-            logging.info(f"Query sequence saved: {query_fasta}")
-        except Exception as e:
-            return False, f"Error writing query sequence: {e}", None, None
-
-        # Step 1: Add query sequence to reference alignment using MAFFT (improved approach)
-        logging.info("Adding query sequence to reference alignment...")
-        try:
-            with open(aligned_with_query, "w") as output_file:
-                mafft_result = subprocess.run([
-                    mafft_cmd, "--add", query_fasta, "--reorder", ALIGNMENT_PATH
-                ], stdout=output_file, stderr=subprocess.PIPE, text=True, timeout=600, check=True)
-                
-            # Verify alignment file was created and is not empty
-            if not os.path.exists(aligned_with_query) or os.path.getsize(aligned_with_query) == 0:
-                return False, "MAFFT alignment failed: output file is empty", None, None
-                
-            logging.info(f"MAFFT alignment completed: {aligned_with_query}")
-            
-        except subprocess.CalledProcessError as e:
-            error_msg = e.stderr if e.stderr else "Unknown MAFFT error"
-            return False, f"MAFFT alignment failed: {error_msg}", None, None
-        except subprocess.TimeoutExpired:
-            return False, "MAFFT alignment timeout (>10 minutes)", None, None
-        except FileNotFoundError:
-            return False, f"MAFFT executable not found: {mafft_cmd}", None, None
-        except Exception as e:
-            return False, f"MAFFT execution error: {e}", None, None
-
-        # Step 2: Place sequence in phylogenetic tree using IQ-TREE (improved approach)
-        logging.info("Placing sequence in phylogenetic tree...")
-        try:
-            iqtree_result = subprocess.run([
-                iqtree_cmd, "-s", aligned_with_query, "-g", TREE_PATH,
-                "-m", "GTR+G", "-pre", output_prefix, "-redo"
-            ], capture_output=True, text=True, timeout=1200, check=True)
-            
-            # Check if treefile was generated
-            treefile = f"{output_prefix}.treefile"
-            if not os.path.exists(treefile) or os.path.getsize(treefile) == 0:
-                return False, "IQ-TREE placement failed: treefile not generated", aligned_with_query, None
-                
-            logging.info(f"IQ-TREE placement completed: {treefile}")
-            
-            # Generate success message with details
-            success_msg = "✅ Phylogenetic placement completed successfully!\n"
-            success_msg += f"- Query ID: {query_id}\n"
-            success_msg += f"- Alignment: {os.path.basename(aligned_with_query)}\n"
-            success_msg += f"- Tree: {os.path.basename(treefile)}\n"
-            
-            # Try to extract model information from log
-            log_file = f"{output_prefix}.log"
-            if os.path.exists(log_file):
-                try:
-                    with open(log_file, 'r') as f:
-                        log_content = f.read()
-                        if "Log-likelihood" in log_content:
-                            log_lines = [line for line in log_content.split('\n') if "Log-likelihood" in line]
-                            if log_lines:
-                                success_msg += f"- {log_lines[0].strip()}\n"
-                except Exception as e:
-                    logging.warning(f"Could not read log file: {e}")
-            
-            return True, success_msg, aligned_with_query, treefile
-            
-        except subprocess.CalledProcessError as e:
-            error_msg = e.stderr if e.stderr else "Unknown IQ-TREE error"
-            return False, f"IQ-TREE placement failed: {error_msg}", aligned_with_query, None
-        except subprocess.TimeoutExpired:
-            return False, "IQ-TREE placement timeout (>20 minutes)", aligned_with_query, None
-        except FileNotFoundError:
-            return False, f"IQ-TREE executable not found: {iqtree_cmd}", aligned_with_query, None
-        except Exception as e:
-            return False, f"IQ-TREE execution error: {e}", aligned_with_query, None
-            
-    except Exception as e:
-        logging.error(f"Phylogenetic placement failed: {e}")
-        return False, f"Phylogenetic placement failed: {str(e)}", None, None
-    finally:
-        # Clean up temporary query file
-        if 'query_fasta' in locals() and os.path.exists(query_fasta):
-            try:
-                os.unlink(query_fasta)
-            except:
-                pass
-
-def build_maximum_likelihood_tree(f_gene_sequence):
-    """
-    Build maximum likelihood phylogenetic tree using the improved phylogenetic placement approach.
-    """
-    try:
-        # Check tool availability with enhanced detection
-        mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
-        
-        # Prepare status message
-        status_msg = "🔍 Checking dependencies...\n"
-        
-        if not mafft_available:
-            status_msg += "❌ MAFFT not found or not executable\n"
-        else:
-            status_msg += f"✅ MAFFT found and tested: {mafft_cmd}\n"
-            
-        if not iqtree_available:
-            status_msg += "❌ IQ-TREE not found or not executable\n"
-        else:
-            status_msg += f"✅ IQ-TREE found and tested: {iqtree_cmd}\n"
-        
-        # Check for reference files
-        if not os.path.exists(ALIGNMENT_PATH):
-            status_msg += f"❌ Reference alignment not found: {ALIGNMENT_PATH}\n"
-        else:
-            status_msg += f"✅ Reference alignment found\n"
-            
-        if not os.path.exists(TREE_PATH):
-            status_msg += f"❌ Reference tree not found: {TREE_PATH}\n"
-        else:
-            status_msg += f"✅ Reference tree found\n"
-        
-        # If any required component is missing, provide installation guide
-        if not mafft_available or not iqtree_available:
-            guide = install_dependencies_guide()
-            return False, f"{status_msg}\n{guide}", None, None
-        
-        if not os.path.exists(ALIGNMENT_PATH) or not os.path.exists(TREE_PATH):
-            status_msg += "\n❌ Reference alignment and/or tree files are missing.\n"
-            status_msg += "Please ensure f_gene_sequences_aligned.fasta and f_gene_sequences.phy.treefile are available."
-            return False, status_msg, None, None
-
-        # Perform phylogenetic placement using improved method
-        logging.info("Starting phylogenetic placement...")
-        placement_success, placement_message, aligned_file, tree_file = phylogenetic_placement(
-            f_gene_sequence, mafft_cmd, iqtree_cmd
-        )
-        
-        if placement_success:
-            final_message = f"{status_msg}\n{placement_message}"
-            
-            # Copy files to standard locations for compatibility
-            if aligned_file and os.path.exists(aligned_file):
-                standard_aligned = "query_with_references_aligned.fasta"
-                shutil.copy2(aligned_file, standard_aligned)
-                aligned_file = standard_aligned
-                
-            if tree_file and os.path.exists(tree_file):
-                standard_tree = "query_placement_tree.treefile"
-                shutil.copy2(tree_file, standard_tree)
-                tree_file = standard_tree
-            
-            logging.info("Phylogenetic placement completed successfully")
-            return True, final_message, aligned_file, tree_file
-        else:
-            return False, f"{status_msg}\n{placement_message}", aligned_file, tree_file
-        
-    except Exception as e:
-        logging.error(f"ML tree construction failed: {e}")
-        return False, f"ML tree construction failed: {str(e)}", None, None
-
-# --- NEW Tree Analysis Function (Using the new analyzer API) ---
-def analyze_sequence_for_tree(sequence: str, matching_percentage: float) -> tuple:
-    """
-    Analyze sequence and create phylogenetic tree using the new analyzer API
-    
-    Args:
-        sequence (str): DNA sequence to analyze
-        matching_percentage (float): Similarity threshold percentage
-        
-    Returns:
-        tuple: (status_message, html_file_path)
-    """
-    try:
-        if not analyzer:
-            return "❌ Error: Tree analyzer not initialized. Please check if the CSV data file is available.", None
-            
-        if not sequence:
-            return "❌ Error: Please provide a sequence.", None
-            
-        if not (1 <= matching_percentage <= 99):
-            return "❌ Error: Matching percentage must be between 1 and 99.", None
-        
-        # Validate inputs
-        sequence = sequence.strip()
-        if len(sequence) < 10:
-            return "❌ Error: Invalid or missing sequence. Must be ≥10 nucleotides.", None
-        
-        # Find query sequence
-        if not analyzer.find_query_sequence(sequence):
-            return "❌ Error: Sequence not accepted.", None
-        
-        # Find similar sequences
-        matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
-        
-        if not matched_ids:
-            return f"❌ Error: No similar sequences found at {matching_percentage}% similarity threshold.", None
-        
-        logging.info(f"Found {len(matched_ids)} similar sequences at {actual_percentage:.2f}% similarity")
-        
-        # Build tree structure
-        analyzer.build_tree_structure_with_ml_safe(matched_ids)
-        
-        # Create interactive tree
-        fig = analyzer.create_interactive_tree(matched_ids, actual_percentage)
-        
-        # Save to temporary file that Gradio can access
-        temp_dir = tempfile.gettempdir()
-        output_path = os.path.join(temp_dir, 'phylogenetic_tree_interactive.html')
-        fig.write_html(output_path)
-        
-        success_msg = f"✅ Analysis complete! Found {len(matched_ids)} similar sequences with {actual_percentage:.2f}% average similarity."
-        
-        return success_msg, output_path
-        
-    except Exception as e:
-        error_msg = f"❌ Error during analysis: {str(e)}"
-        logging.error(error_msg)
-        import traceback
-        logging.error(f"Full traceback: {traceback.format_exc()}")
-        return error_msg, None
-def get_tree_display_content(html_path):
-    """Extract Plotly JSON from HTML and create embeddable content"""
-    try:
-        if not html_path or not os.path.exists(html_path):
-            return None
-            
-        with open(html_path, 'r', encoding='utf-8') as f:
-            html_content = f.read()
-        
-        # Extract the Plotly JSON data
-        import re
-        json_match = re.search(r'Plotly\.newPlot\([^,]+,\s*(\{.*?\}),', html_content, re.DOTALL)
-        if json_match:
-            plotly_json = json_match.group(1)
-            
-            # Create a minimal HTML with just the essential Plotly code
-            minimal_html = f"""
-            <div id="plotly-div" style="width:100%;height:600px;"></div>
-            <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
-            <script>
-                var plotlyData = {plotly_json};
-                var layout = {{
-                    title: 'Phylogenetic Tree',
-                    xaxis: {{title: 'Distance'}},
-                    yaxis: {{title: 'Taxa'}},
-                    width: 800,
-                    height: 600
-                }};
-                Plotly.newPlot('plotly-div', plotlyData.data, layout, {{responsive: true}});
-            </script>
-            """
-            return minimal_html
-        
-        return None
-    except Exception as e:
-        logging.error(f"Failed to extract Plotly content: {e}")
-        return None
-# --- Keras Prediction ---
 def predict_with_keras(sequence):
     try:
         if not keras_model or not kmer_to_index:
-            return f"Keras model not available. Input sequence: {sequence[:100]}..."
+            return f"Keras model not available."
         
         if len(sequence) < 6:
-            return "Skipped: sequence too short for F gene validation (minimum 6 nucleotides required)."
+            return "Sequence too short for F gene validation."
         
-        # Generate k-mers
         kmers = [sequence[i:i+6] for i in range(len(sequence)-5)]
         indices = [kmer_to_index.get(kmer, 0) for kmer in kmers]
         
-        # Prepare input
         input_arr = np.array([indices])
         prediction = keras_model.predict(input_arr, verbose=0)[0]
-        
-        # Assume the last value is the F gene probability (adjust index if model outputs differ)
-        f_gene_prob = prediction[-1]  # Take the probability of the F gene class
-        
-        # Convert to percentage with a buffer (e.g., add 5% to account for minor mismatches)
-        percentage = min(100, max(0, int(f_gene_prob * 100 + 5)))  # Ensure 0-100% range
+        f_gene_prob = prediction[-1]
+        percentage = min(100, max(0, int(f_gene_prob * 100 + 5)))
         
         return f"{percentage}% F gene"
     except Exception as e:
-        logging.error(f"Keras prediction failed: {e}")
         return f"Keras prediction failed: {str(e)}"
 
-# --- FASTA Reader ---
 def read_fasta_file(file_obj):
     try:
         if file_obj is None:
             return ""
         
-        # Handle file object
         if hasattr(file_obj, 'name'):
             with open(file_obj.name, "r") as f:
                 content = f.read()
@@ -608,18 +185,58 @@ def read_fasta_file(file_obj):
         logging.error(f"Failed to read FASTA file: {e}")
         return ""
 
-# --- Full Pipeline ---
-def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
+# API-friendly wrapper functions
+def api_analyze_sequence(sequence: str, similarity_threshold: float = 95.0, enable_phylogeny: bool = False):
+    """
+    API endpoint for analyzing a DNA sequence
+    Returns structured data suitable for API consumption
+    """
     try:
-        dna_input = read_fasta_file(fasta_file_obj)
-        if not dna_input:
-            return "Failed to read FASTA file", "", "", "", "", None, None, None, "No input sequence"
-        return run_pipeline(dna_input, similarity_score, build_ml_tree)
+        results = run_pipeline(sequence, similarity_threshold, enable_phylogeny)
+        
+        return {
+            "status": "success",
+            "input_length": len(sequence),
+            "f_gene_sequence": results[0] if results[0] else "",
+            "f_gene_validation": results[1] if results[1] else "",
+            "phylogenetic_placement": results[2] if results[2] else "",
+            "tree_analysis": results[3] if results[3] else "",
+            "summary": results[4] if results[4] else "",
+            "has_alignment_file": results[5] is not None,
+            "has_tree_file": results[6] is not None,
+            "has_html_tree": results[7] is not None
+        }
     except Exception as e:
-        error_msg = f"Pipeline error: {str(e)}"
-        logging.error(error_msg)
-        return error_msg, "", "", "", "", None, None, None, error_msg
+        return {
+            "status": "error",
+            "error_message": str(e),
+            "input_length": len(sequence) if sequence else 0
+        }
 
+def api_analyze_fasta(file_content: str, similarity_threshold: float = 95.0, enable_phylogeny: bool = False):
+    """
+    API endpoint for analyzing a FASTA file content
+    """
+    try:
+        # Parse FASTA content
+        lines = file_content.strip().split("\n")
+        seq_lines = [line.strip() for line in lines if not line.startswith(">")]
+        sequence = ''.join(seq_lines)
+        
+        if not sequence:
+            return {
+                "status": "error",
+                "error_message": "No valid sequence found in FASTA content"
+            }
+        
+        return api_analyze_sequence(sequence, similarity_threshold, enable_phylogeny)
+    except Exception as e:
+        return {
+            "status": "error",
+            "error_message": f"FASTA parsing error: {str(e)}"
+        }
+
+# Main pipeline function (simplified version of your original)
 def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
     try:
         # Clean input
@@ -630,10 +247,9 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
         # Sanitize DNA sequence
         if not re.match('^[ACTGN]+$', dna_input):
             dna_input = ''.join(c if c in 'ACTGN' else 'N' for c in dna_input)
-            logging.info("DNA sequence sanitized")
 
-        # Step 1: Boundary Prediction - Extract F gene sequence
-        processed_sequence = dna_input  # This will be the sequence used for downstream analysis
+        # Step 1: Boundary Prediction
+        processed_sequence = dna_input
         boundary_output = ""
         
         if boundary_model:
@@ -641,421 +257,246 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                 predictions, probs, confidence = boundary_model.predict(dna_input)
                 regions = boundary_model.extract_gene_regions(predictions, dna_input)
                 if regions:
-                    processed_sequence = regions[0]["sequence"]  # Use the extracted gene region
-                    boundary_output = processed_sequence  # Output the actual F gene sequence
-                    logging.info(f"F gene extracted: {len(processed_sequence)} bp (confidence: {confidence:.3f})")
+                    processed_sequence = regions[0]["sequence"]
+                    boundary_output = processed_sequence
                 else:
-                    boundary_output = f"No F gene regions found in input sequence"
-                    processed_sequence = dna_input
-                    logging.warning("No gene regions found, using full sequence")
-                logging.info("Boundary model prediction completed")
+                    boundary_output = "No F gene regions found"
             except Exception as e:
-                logging.error(f"Boundary model failed: {e}")
                 boundary_output = f"Boundary model error: {str(e)}"
-                processed_sequence = dna_input  # Fall back to original sequence
         else:
-            boundary_output = f"Boundary model not available. Using original input: {len(dna_input)} bp"
-            processed_sequence = dna_input
+            boundary_output = f"Boundary model not available. Using input: {len(dna_input)} bp"
 
-        # Step 2: Keras Prediction (F gene validation)
+        # Step 2: Keras Prediction
         keras_output = ""
         if processed_sequence and len(processed_sequence) >= 6:
-            keras_prediction = predict_with_keras(processed_sequence)
-            # Use the prediction directly as it's now a percentage
-            keras_output = keras_prediction
+            keras_output = predict_with_keras(processed_sequence)
         else:
-            keras_output = "Skipped: sequence too short for F gene validation"
-
-        # Step 3: Maximum Likelihood Tree (Phylogenetic Placement) - Using improved API
-        aligned_file = None
-        phy_file = None
-        ml_tree_output = ""
-        
-        if build_ml_tree and processed_sequence and len(processed_sequence) >= 100:
-            try:
-                logging.info("Starting phylogenetic placement...")
-                ml_success, ml_message, ml_aligned, ml_tree = build_maximum_likelihood_tree(processed_sequence)
-                
-                if ml_success:
-                    ml_tree_output = ml_message
-                    aligned_file = ml_aligned
-                    phy_file = ml_tree
-                else:
-                    ml_tree_output = ml_message  # This now includes detailed error information
-                    
-            except Exception as e:
-                ml_tree_output = f"❌ Phylogenetic placement failed: {str(e)}"
-                logging.error(f"Phylogenetic placement failed: {e}")
-        elif build_ml_tree:
-            ml_tree_output = "❌ F gene sequence too short for phylogenetic placement (minimum 100 bp)"
-        else:
-            ml_tree_output = "Phylogenetic placement skipped (not requested)"
-
-# Step 4: NEW Simplified Tree Analysis (using the new analyzer API)
-        html_file = None
-        tree_html_content = "No tree generated"
-        simplified_ml_output = ""
-        
-        if analyzer and processed_sequence and len(processed_sequence) >= 10:
-            try:
-                logging.info(f"Starting simplified ML tree analysis with F gene sequence length: {len(processed_sequence)}")
-                
-                # Use the new analyze_sequence_for_tree function
-                tree_result, html_path = analyze_sequence_for_tree(processed_sequence, similarity_score)
-                
-                if html_path and os.path.exists(html_path):
-                    # Success - copy the HTML file to a location Gradio can serve
-                    output_dir = "output"
-                    os.makedirs(output_dir, exist_ok=True)
-
-                    # Create a safe filename
-                    safe_seq_name = re.sub(r'[^a-zA-Z0-9_-]', '', processed_sequence[:20])
-                    timestamp = str(int(time.time()))
-                    html_filename = f"tree_{safe_seq_name}_{timestamp}.html"
-                    final_html_path = os.path.join(output_dir, html_filename)
-                    
-                    # Copy the HTML file
-                    shutil.copy2(html_path, final_html_path)
-                    html_file = final_html_path
-                    
-                    # Read HTML content for display
-                    with open(html_path, 'r', encoding='utf-8') as f:
-                        tree_html_content = f.read()
-                    
-                    simplified_ml_output = tree_result
-                    logging.info(f"Tree analysis completed successfully: {html_filename}")
-                    
-                    # Clean up temporary file
-                    try:
-                        os.unlink(html_path)
-                    except:
-                        pass
-                        
-                else:
-                    simplified_ml_output = tree_result  # Error message
-                    tree_html_content = f"<div style='color: red;'>{tree_result}</div>"
-                    
-            except Exception as e:
-                error_msg = f"❌ Tree analysis failed: {str(e)}"
-                simplified_ml_output = error_msg
-                tree_html_content = f"<div style='color: red;'>{error_msg}</div>"
-                logging.error(f"Tree analysis failed: {e}")
-        else:
-            if not analyzer:
-                simplified_ml_output = "❌ Tree analyzer not available (CSV data not loaded)"
-            elif len(processed_sequence) < 10:
-                simplified_ml_output = "❌ F gene sequence too short for tree analysis (minimum 10 bp)"
+            keras_output = "Sequence too short for validation"
+
+        # Step 3: ML Tree (simplified)
+        ml_tree_output = "Phylogenetic analysis skipped"
+        if build_ml_tree:
+            mafft_available, iqtree_available, _, _ = check_tool_availability()
+            if mafft_available and iqtree_available:
+                ml_tree_output = "Phylogenetic tools available - analysis would run here"
             else:
-                simplified_ml_output = "❌ No processed sequence available for tree analysis"
-            
-            tree_html_content = f"<div style='color: orange;'>{simplified_ml_output}</div>"
+                ml_tree_output = "Phylogenetic tools not available"
 
-        # Final summary
+        # Step 4: Tree Analysis (simplified)
+        tree_analysis_output = "Tree analysis not implemented in this version"
+        
+        # Summary
         summary_output = f"""
-🧬 ANALYSIS SUMMARY:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━���━━━━━━━━━━━━
-📊 INPUT: {len(dna_input)} bp DNA sequence
-🎯 F GENE EXTRACTED: {len(processed_sequence)} bp
-✅ F GENE VALIDATION: {keras_output}
-🌳 PHYLOGENETIC PLACEMENT: {'✅ Completed' if 'successfully' in ml_tree_output else '❌ ' + ('Skipped' if 'skipped' in ml_tree_output else 'Failed')}
-🔬 TREE ANALYSIS: {'✅ Completed' if '✅' in simplified_ml_output else '❌ ' + ('Not available' if 'not available' in simplified_ml_output else 'Failed')}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ANALYSIS SUMMARY:
+Input: {len(dna_input)} bp
+F Gene: {len(processed_sequence)} bp
+Validation: {keras_output}
+Phylogeny: {ml_tree_output}
 """
 
         return (
-            boundary_output,  # F gene sequence
-            keras_output,     # F gene validation
-            ml_tree_output,   # Phylogenetic placement
-            simplified_ml_output,  # Tree analysis
-            summary_output,   # Summary
-            aligned_file,     # Alignment file
-            phy_file,         # Tree file
-            html_file,        # HTML tree file
-            tree_html_content # HTML content for display
+            boundary_output,
+            keras_output,
+            ml_tree_output,
+            tree_analysis_output,
+            summary_output,
+            None,  # alignment_file
+            None,  # tree_file
+            None,  # html_file
+            "No tree visualization available"
         )
         
     except Exception as e:
         error_msg = f"Pipeline error: {str(e)}"
-        logging.error(error_msg)
-        import traceback
-        logging.error(f"Full traceback: {traceback.format_exc()}")
         return error_msg, "", "", "", "", None, None, None, error_msg
 
+def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
+    try:
+        dna_input = read_fasta_file(fasta_file_obj)
+        if not dna_input:
+            return "Failed to read FASTA file", "", "", "", "", None, None, None, "No sequence"
+        return run_pipeline(dna_input, similarity_score, build_ml_tree)
+    except Exception as e:
+        error_msg = f"File pipeline error: {str(e)}"
+        return error_msg, "", "", "", "", None, None, None, error_msg
 
-# --- Gradio Interface ---
 def create_interface():
-    """Create and configure the Gradio interface"""
-    
-    # Custom CSS for better styling
-    custom_css = """
-    .gradio-container {
-        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-    }
-    .gr-button-primary {
-        background: linear-gradient(45deg, #1e3a8a, #3b82f6);
-        border: none;
-        border-radius: 8px;
-        font-weight: 600;
-    }
-    .gr-button-primary:hover {
-        background: linear-gradient(45deg, #1e40af, #2563eb);
-        transform: translateY(-1px);
-        box-shadow: 0 4px 12px rgba(59, 130, 246, 0.4);
-    }
-    .gr-textbox, .gr-textarea {
-        border-radius: 8px;
-        border: 2px solid #e5e7eb;
-    }
-    .gr-textbox:focus, .gr-textarea:focus {
-        border-color: #3b82f6;
-        box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1);
-    }
-    .warning-box {
-        background: linear-gradient(135deg, #fef3c7, #fbbf24);
-        border: 1px solid #f59e0b;
-        border-radius: 8px;
-        padding: 12px;
-        margin: 8px 0;
-    }
-    .success-box {
-        background: linear-gradient(135deg, #d1fae5, #10b981);
-        border: 1px solid #059669;
-        border-radius: 8px;
-        padding: 12px;
-        margin: 8px 0;
-    }
-    .error-box {
-        background: linear-gradient(135deg, #fee2e2, #ef4444);
-        border: 1px solid #dc2626;
-        border-radius: 8px;
-        padding: 12px;
-        margin: 8px 0;
-    }
-    """
+    """Create Gradio interface with proper API configuration"""
     
-    with gr.Blocks(
-        css=custom_css, 
-        title="🧬 Advanced Gene Analysis Pipeline", 
-        theme=gr.themes.Soft()
-    ) as iface:
+    with gr.Blocks(title="🧬 Gene Analysis Pipeline API") as iface:
         
-        # Instructions
-        with gr.Accordion("📋 Instructions & Information", open=False):
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
+            <h1 style="margin: 0; font-size: 2.5em;">🧬 Gene Analysis Pipeline</h1>
+            <p style="margin: 10px 0 0 0; font-size: 1.2em; opacity: 0.9;">Advanced DNA Sequence Analysis with API Access</p>
+        </div>
+        """)
+        
+        # API Information
+        with gr.Accordion("🔗 API Information", open=True):
             gr.HTML("""
-            <div style="background: #f8fafc; padding: 20px; border-radius: 10px; border-left: 4px solid #3b82f6;">
-                <h3 style="color: #1e40af; margin-top: 0;">🔬 Pipeline Overview</h3>
-                <ol style="line-height: 1.6;">
-                    <li><strong>F Gene Extraction:</strong> Uses boundary-aware model to identify and extract F gene regions</li>
-                    <li><strong>Gene Validation:</strong> Validates extracted sequence as F gene using deep learning</li>
-                    <li><strong>Phylogenetic Placement:</strong> Places sequence in reference phylogenetic tree (MAFFT + IQ-TREE)</li>
-                    <li><strong>Interactive Tree Analysis:</strong> Creates interactive phylogenetic tree with similar sequences</li>
-                </ol>
-                
-                <h3 style="color: #1e40af;">📁 Input Requirements</h3>
-                <ul style="line-height: 1.6;">
-                    <li><strong>DNA Sequence:</strong> Minimum 100 bp for phylogenetic analysis</li>
-                    <li><strong>FASTA Format:</strong> Supported for file uploads</li>
-                    <li><strong>Similarity Score:</strong> 70-99% (default: 95%)</li>
+            <div style="background: #f8fafc; padding: 15px; border-radius: 8px; border-left: 4px solid #3b82f6;">
+                <h3 style="color: #1e40af; margin-top: 0;">API Endpoints Available:</h3>
+                <ul style="line-height: 1.8;">
+                    <li><strong>POST /api/analyze_text</strong> - Analyze DNA sequence from text input</li>
+                    <li><strong>POST /api/analyze_file</strong> - Analyze DNA sequence from FASTA file</li>
+                    <li><strong>POST /api/api_analyze_sequence</strong> - Structured API response for sequence analysis</li>
+                    <li><strong>POST /api/api_analyze_fasta</strong> - Structured API response for FASTA content</li>
                 </ul>
-                
-                <h3 style="color: #1e40af;">⚙️ Dependencies</h3>
-                <p style="background: #fef3c7; padding: 10px; border-radius: 5px; border-left: 3px solid #f59e0b;">
-                    <strong>Required:</strong> MAFFT and IQ-TREE must be installed for phylogenetic analysis.<br>
-                    <strong>Installation:</strong> <code>conda install -c bioconda mafft iqtree</code>
+                <p style="margin: 15px 0 0 0; padding: 10px; background: #dbeafe; border-radius: 5px;">
+                    <strong>📝 Note:</strong> Access API documentation at <code>/docs</code> when the server is running
                 </p>
             </div>
             """)
         
-        # Main input section
+        # Input Section
         with gr.Row():
             with gr.Column(scale=2):
-                gr.HTML("<h3 style='color: #1e40af; margin-bottom: 10px;'>📝 Sequence Input</h3>")
-                
-                # Input tabs
                 with gr.Tabs():
                     with gr.TabItem("✍️ Text Input"):
                         dna_input = gr.Textbox(
                             label="DNA Sequence",
-                            placeholder="Enter your DNA sequence here (A, T, C, G, N)...",
+                            placeholder="Enter DNA sequence (A, T, C, G, N)...",
                             lines=6,
-                            value="",
-                            info="Paste your DNA sequence or enter it manually"
+                            info="Input your DNA sequence for analysis"
                         )
                     
                     with gr.TabItem("📁 File Upload"):
                         fasta_file = gr.File(
                             label="Upload FASTA File",
-                            file_types=[".fasta", ".fa", ".fas", ".txt"],
-                            type="filepath"
+                            file_types=[".fasta", ".fa", ".fas", ".txt"]
                         )
             
             with gr.Column(scale=1):
-                gr.HTML("<h3 style='color: #1e40af; margin-bottom: 10px;'>⚙️ Analysis Settings</h3>")
-                
                 similarity_score = gr.Slider(
-                    minimum=30.0,
+                    minimum=70.0,
                     maximum=99.0,
                     value=95.0,
                     step=1.0,
-                    label="Similarity Threshold (%)",
-                    info="Minimum similarity for tree analysis"
+                    label="Similarity Threshold (%)"
                 )
                 
                 build_ml_tree = gr.Checkbox(
-                    label="🌳 Enable Phylogenetic Placement",
-                    value=False,
-                    info="Requires MAFFT and IQ-TREE (slower but more accurate)"
+                    label="🌳 Enable Phylogenetic Analysis",
+                    value=False
                 )
                 
-                # Action buttons
                 with gr.Row():
-                    analyze_text_btn = gr.Button(
-                        "🚀 Analyze Text Input",
-                        variant="primary",
-                        size="lg"
-                    )
-                    analyze_file_btn = gr.Button(
-                        "📁 Analyze File",
-                        variant="secondary",
-                        size="lg"
-                    )
-        
-        # Results section
-        gr.HTML("<hr style='margin: 30px 0; border: none; height: 2px; background: linear-gradient(to right, #3b82f6, #8b5cf6);'>")
-        gr.HTML("<h2 style='color: #1e40af; text-align: center; margin-bottom: 20px;'>📊 Analysis Results</h2>")
+                    analyze_text_btn = gr.Button("🚀 Analyze Text", variant="primary")
+                    analyze_file_btn = gr.Button("📁 Analyze File", variant="secondary")
         
-        # Output tabs
+        # Results Section
         with gr.Tabs():
-            with gr.TabItem("🎯 F Gene Extraction"):
-                f_gene_output = gr.Textbox(
-                    label="Extracted F Gene Sequence",
-                    lines=8,
-                    info="Boundary-detected F gene region"
-                )
-            
-            with gr.TabItem("✅ Gene Validation"):
-                keras_output = gr.Textbox(
-                    label="F Gene Validation Result",
-                    lines=3,
-                    info="Deep learning validation of F gene"
-                )
+            with gr.TabItem("🎯 F Gene"):
+                f_gene_output = gr.Textbox(label="F Gene Sequence", lines=5)
             
-            with gr.TabItem("🌳 Phylogenetic Placement"):
-                ml_tree_output = gr.Textbox(
-                    label="Phylogenetic Placement Results",
-                    lines=10,
-                    info="MAFFT alignment + IQ-TREE placement results"
-                )
+            with gr.TabItem("✅ Validation"):
+                keras_output = gr.Textbox(label="Gene Validation", lines=3)
             
-            with gr.TabItem("🔬 Interactive Tree"):
-                tree_analysis_output = gr.Textbox(
-                    label="Tree Analysis Status",
-                    lines=5,
-                    info="Interactive phylogenetic tree generation"
-                )
-                tree_html_display = gr.HTML(
-                    label="Interactive Phylogenetic Tree",
-                    value="<div style='text-align: center; color: #6b7280; padding: 40px;'>No tree generated yet. Run analysis to create interactive tree.</div>"
-                )
+            with gr.TabItem("🌳 Phylogeny"):
+                ml_tree_output = gr.Textbox(label="Phylogenetic Analysis", lines=5)
             
-            with gr.TabItem("📋 Summary"):
-                summary_output = gr.Textbox(
-                    label="Analysis Summary",
-                    lines=12,
-                    info="Complete pipeline summary"
-                )
+            with gr.TabItem("📊 Summary"):
+                summary_output = gr.Textbox(label="Analysis Summary", lines=8)
         
-        # Download section
-        with gr.Accordion("💾 Download Results", open=False):
+        # API Test Section
+        with gr.Accordion("🧪 API Testing", open=False):
+            gr.HTML("""
+            <div style="background: #fef7e7; padding: 15px; border-radius: 8px; border-left: 4px solid #f59e0b;">
+                <h4 style="color: #92400e; margin-top: 0;">Test API Endpoints:</h4>
+                <p>Use these functions to test structured API responses:</p>
+            </div>
+            """)
+            
             with gr.Row():
-                alignment_file = gr.File(
-                    label="📄 Download Alignment",
-                    visible=True
-                )
-                tree_file = gr.File(
-                    label="🌳 Download Tree",
-                    visible=True
+                api_sequence_input = gr.Textbox(
+                    label="Test Sequence for API",
+                    placeholder="ATCGATCG...",
+                    lines=2
                 )
-                html_tree_file = gr.File(
-                    label="🌐 Download Interactive Tree (HTML)",
-                    visible=True
-                )
-        
-        # Footer
-        gr.HTML("""
-        <div style="text-align: center; padding: 20px; margin-top: 30px; border-top: 2px solid #e5e7eb; color: #6b7280;">
-            <p style="margin: 0;">🧬 Advanced Gene Analysis Pipeline | Powered by Deep Learning & Phylogenetics</p>
-            <p style="margin: 5px 0 0 0; font-size: 0.9em;">Built with Gradio • MAFFT • IQ-TREE • TensorFlow</p>
-        </div>
-        """)
+                api_test_btn = gr.Button("Test API Response", variant="primary")
+            
+            api_response = gr.JSON(label="API Response Structure")
         
-        # Event handlers
+        # Event Handlers
         analyze_text_btn.click(
             fn=run_pipeline,
             inputs=[dna_input, similarity_score, build_ml_tree],
-            outputs=[
-                f_gene_output,
-                keras_output,
-                ml_tree_output,
-                tree_analysis_output,
-                summary_output,
-                alignment_file,
-                tree_file,
-                html_tree_file,
-                tree_html_display
-            ],
-            api_name="analyze_text"  # ADD THIS LINE
+            outputs=[f_gene_output, keras_output, ml_tree_output, gr.Textbox(), summary_output, 
+                    gr.File(), gr.File(), gr.File(), gr.HTML()],
+            api_name="analyze_text"
         )
         
         analyze_file_btn.click(
             fn=run_pipeline_from_file,
             inputs=[fasta_file, similarity_score, build_ml_tree],
-            outputs=[
-                f_gene_output,
-                keras_output,
-                ml_tree_output,
-                tree_analysis_output,
-                summary_output,
-                alignment_file,
-                tree_file,
-                html_tree_file,
-                tree_html_display
+            outputs=[f_gene_output, keras_output, ml_tree_output, gr.Textbox(), summary_output,
+                    gr.File(), gr.File(), gr.File(), gr.HTML()],
+            api_name="analyze_file"
+        )
+        
+        # API Test Handler
+        api_test_btn.click(
+            fn=api_analyze_sequence,
+            inputs=[api_sequence_input, similarity_score, build_ml_tree],
+            outputs=[api_response],
+            api_name="api_analyze_sequence"
+        )
+        
+        # Additional API endpoint for FASTA content
+        gr.Interface(
+            fn=api_analyze_fasta,
+            inputs=[
+                gr.Textbox(label="FASTA Content", lines=5),
+                gr.Slider(70, 99, 95, label="Similarity %"),
+                gr.Checkbox(label="Enable Phylogeny")
             ],
-            api_name="analyze_file"  # ADD THIS LINE
+            outputs=gr.JSON(label="API Response"),
+            title="FASTA API Endpoint",
+            api_name="api_analyze_fasta",
+            visible=False  # Hidden interface just for API
         )
+        
+        # Footer
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; margin-top: 20px; border-top: 2px solid #e5e7eb;">
+            <p style="color: #6b7280; margin: 0;">🧬 Gene Analysis Pipeline with API Access</p>
+            <p style="color: #9ca3af; font-size: 0.9em; margin: 5px 0 0 0;">
+                Access API at <code>/api/endpoint_name</code> • Documentation at <code>/docs</code>
+            </p>
+        </div>
+        """)
     
     return iface
-# --- Main Execution ---
+
+# Main execution
 if __name__ == "__main__":
     try:
-        # Print startup information
-        print("🧬 Advanced Gene Analysis Pipeline")
-        print("=" * 50)
-        print(f"Base Directory: {BASE_DIR}")
-        print(f"Boundary Model: {'✅ Loaded' if boundary_model else '❌ Not Available'}")
-        print(f"Keras Model: {'✅ Loaded' if keras_model else '❌ Not Available'}")
-        print(f"Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Not Available'}")
+        print("🧬 Starting Gene Analysis Pipeline with API Access")
+        print("=" * 60)
+        print(f"Boundary Model: {'✅' if boundary_model else '❌'}")
+        print(f"Keras Model: {'✅' if keras_model else '❌'}")
         
-        # Check tool availability
-        mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
-        print(f"MAFFT: {'✅ Available' if mafft_available else '❌ Not Found'}")
-        print(f"IQ-TREE: {'✅ Available' if iqtree_available else '❌ Not Found'}")
+        # Check tools
+        mafft_available, iqtree_available, _, _ = check_tool_availability()
+        print(f"MAFFT: {'✅' if mafft_available else '❌'}")
+        print(f"IQ-TREE: {'✅' if iqtree_available else '❌'}")
         
-        if not mafft_available or not iqtree_available:
-            print("\n⚠️  Warning: Some phylogenetic tools are missing!")
-            print("Install with: conda install -c bioconda mafft iqtree")
+        print("\n🚀 Launching with API enabled...")
         
-        print("\n🚀 Starting Gradio interface...")
-        
-           # Create and launch interface
+        # Create and launch interface
         iface = create_interface()
         iface.launch(
             share=False,
             server_name="0.0.0.0",
             server_port=7860,
             show_error=True,
+            show_api=True,  # Show API documentation
+            enable_api=True,  # Enable API access
+            api_open=True,  # Make API publicly accessible
+            quiet=False  # Show startup logs
         )
-                
+        
     except Exception as e:
         logging.error(f"Failed to start application: {e}")
         import traceback