Update app.py

app.py

@@ -27,22 +27,22 @@ except ImportError:
 from huggingface_hub import hf_hub_download
 
 # --- Global Variables ---
-MAFFT_PATH = "mafft/mafftdir/bin/mafft"  # Update this path as needed
-IQTREE_PATH = "iqtree/bin/iqtree2"  # Update this path as needed
-CSV_PATH = "f_cleaned.csv"  # Updated to match your naming
+MAFFT_PATH = "/usr/bin/mafft"  # Common path in Hugging Face Spaces
+IQTREE_PATH = "/usr/bin/iqtree2"  # Common path in Hugging Face Spaces
+CSV_PATH = "/data/f_cleaned.csv"  # Persistent storage in Hugging Face
+MODEL_REPO = "GGproject10/best_boundary_aware_model"
 
 # --- Logging Setup ---
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
     handlers=[
-        logging.FileHandler('gene_analysis.log'),
+        logging.FileHandler('/data/gene_analysis.log'),
         logging.StreamHandler(sys.stdout)
     ]
 )
 
-# --- Model Paths and Variables ---
-MODEL_REPO = "GGproject10/best_boundary_aware_model"
+# --- Model Variables ---
 boundary_model = None
 keras_model = None
 kmer_to_index = None
@@ -51,7 +51,7 @@ analyzer = None
 # --- Load Models ---
 def load_models():
     global boundary_model, keras_model, kmer_to_index
-    hf_token = os.getenv("HF_TOKEN")
+    hf_token = os.getenv("HF_TOKEN", None)
     
     # Load boundary model
     if GenePredictor:
@@ -59,7 +59,8 @@ def load_models():
             boundary_path = hf_hub_download(
                 repo_id=MODEL_REPO,
                 filename="best_boundary_aware_model.pth",
-                token=hf_token
+                token=hf_token,
+                cache_dir="/data/models"
             )
             boundary_model = GenePredictor(boundary_path)
             logging.info("Boundary model loaded successfully.")
@@ -75,12 +76,14 @@ def load_models():
             keras_path = hf_hub_download(
                 repo_id=MODEL_REPO,
                 filename="best_model.keras",
-                token=hf_token
+                token=hf_token,
+                cache_dir="/data/models"
             )
             kmer_path = hf_hub_download(
                 repo_id=MODEL_REPO,
                 filename="kmer_to_index.pkl",
-                token=hf_token
+                token=hf_token,
+                cache_dir="/data/models"
             )
             keras_model = load_model(keras_path)
             with open(kmer_path, "rb") as f:
@@ -101,11 +104,6 @@ def init_tree_analyzer():
             analyzer = ml_simplified_tree.PhylogeneticTreeAnalyzer()
             if analyzer.load_data(CSV_PATH):
                 logging.info("Tree analyzer initialized successfully.")
-                try:
-                    if not analyzer.train_ai_model():
-                        logging.warning("AI model training failed.")
-                except Exception as e:
-                    logging.warning(f"AI model training failed: {e}")
             else:
                 logging.error("Failed to load CSV data.")
                 analyzer = None
@@ -118,44 +116,28 @@ def init_tree_analyzer():
 
 # --- Tool Detection ---
 def check_tool_availability():
-    mafft_candidates = [
-        MAFFT_PATH, 'mafft', '/usr/bin/mafft', '/usr/local/bin/mafft', 'mafft.bat'
-    ]
-    iqtree_candidates = [
-        IQTREE_PATH, 'iqtree2', 'iqtree', '/usr/bin/iqtree2', '/usr/local/bin/iqtree2',
-        '/usr/bin/iqtree', '/usr/local/bin/iqtree', 'iqtree2.exe', 'iqtree.exe'
-    ]
-    
-    mafft_cmd = next((cmd for cmd in mafft_candidates if cmd and (os.path.exists(cmd) or shutil.which(cmd))), None)
-    iqtree_cmd = next((cmd for cmd in iqtree_candidates if cmd and (os.path.exists(cmd) or shutil.which(cmd))), None)
-    
+    mafft_cmd = shutil.which(MAFFT_PATH) or shutil.which("mafft")
+    iqtree_cmd = shutil.which(IQTREE_PATH) or shutil.which("iqtree2")
     return bool(mafft_cmd), bool(iqtree_cmd), mafft_cmd, iqtree_cmd
 
 # --- Installation Guide ---
 def install_dependencies_guide():
     return """
-🔧 INSTALLATION GUIDE FOR MISSING DEPENDENCIES:
+🔧 DEPENDENCY SETUP FOR HUGGING FACE SPACES:
 
-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/
-
-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 mafft iqtree
+1. Add to requirements.txt:
+   - mafft
+   - iqtree
+2. Place f_cleaned.csv in the repository root.
+3. Ensure HF_TOKEN is set in Space secrets for model downloads.
+4. If dependencies fail, contact Hugging Face support or use a custom Docker image.
 """
 
 # --- MAFFT and IQ-TREE Functions ---
 def run_mafft_alignment(input_fasta, output_fasta, mafft_cmd):
     try:
         cmd = [mafft_cmd, '--auto', '--quiet', input_fasta]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)  # Reduced timeout for HF
         if result.returncode == 0:
             with open(output_fasta, 'w') as f:
                 f.write(result.stdout)
@@ -171,10 +153,10 @@ def run_mafft_alignment(input_fasta, output_fasta, mafft_cmd):
 def run_iqtree_analysis(aligned_fasta, output_prefix, iqtree_cmd):
     try:
         cmd = [
-            iqtree_cmd, '-s', aligned_fasta, '-m', 'MFP', '-bb', '1000',
-            '-alrt', '1000', '-nt', 'AUTO', '--prefix', output_prefix, '--quiet'
+            iqtree_cmd, '-s', aligned_fasta, '-m', 'GTR', '-nt', '1',  # Simplified for HF resources
+            '--prefix', output_prefix, '--quiet'
         ]
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=1200)
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)  # Reduced timeout
         tree_file = f"{output_prefix}.treefile"
         if result.returncode == 0 and os.path.exists(tree_file) and os.path.getsize(tree_file) > 0:
             logging.info(f"IQ-TREE completed: {tree_file}")
@@ -184,26 +166,12 @@ def run_iqtree_analysis(aligned_fasta, output_prefix, iqtree_cmd):
         logging.error(f"IQ-TREE failed: {e}")
         return False, f"IQ-TREE failed: {str(e)}"
 
-# --- Fallback Tree Construction ---
-def create_simple_tree(sequences_dict):
-    try:
-        seq_names = list(sequences_dict.keys())
-        if len(seq_names) < 2:
-            return None, "Need at least 2 sequences."
-        tree_str = f"({','.join([f'{name}:0.1' for name in seq_names[:5]])});"
-        tree_file = "simple_tree.nwk"
-        with open(tree_file, 'w') as f:
-            f.write(tree_str)
-        return tree_file, "Simple tree created."
-    except Exception as e:
-        return None, f"Simple tree creation failed: {str(e)}"
-
 # --- Create Multi-FASTA ---
 def create_multi_fasta(query_sequence, query_id="Query_F_Gene"):
     try:
-        temp_fasta = tempfile.NamedTemporaryFile(mode='w', suffix='.fasta', delete=False)
+        temp_fasta = tempfile.NamedTemporaryFile(mode='w', suffix='.fasta', delete=False, dir="/data")
         temp_fasta.write(f">{query_id}\n{query_sequence}\n")
-        ref_fasta_path = "f_gene_sequences_aligned.fasta"
+        ref_fasta_path = "/data/f_gene_sequences_aligned.fasta"
         if os.path.exists(ref_fasta_path):
             with open(ref_fasta_path, 'r') as ref_file:
                 temp_fasta.write(ref_file.read())
@@ -213,7 +181,7 @@ def create_multi_fasta(query_sequence, query_id="Query_F_Gene"):
                 if 'sequence' in row and len(str(row['sequence'])) > 50:
                     temp_fasta.write(f">{row.get('id', f'Ref_{count}')}\n{str(row['sequence']).upper()}\n")
                     count += 1
-                    if count >= 20:
+                    if count >= 10:  # Reduced for HF
                         break
         temp_fasta.close()
         return temp_fasta.name
@@ -237,26 +205,26 @@ def build_maximum_likelihood_tree(sequence):
             guide = install_dependencies_guide()
             return False, f"{status_msg}\n❌ Missing tools:\n{guide}", None, None
         
-        os.makedirs("ml_tree_output", exist_ok=True)
+        os.makedirs("/data/ml_tree_output", exist_ok=True)
         multi_fasta = create_multi_fasta(sequence)
         if not multi_fasta:
             return False, f"{status_msg}\n❌ Failed to create input FASTA.", None, None
         
-        aligned_fasta = "ml_tree_output/aligned_sequences.fasta"
+        aligned_fasta = "/data/ml_tree_output/aligned_sequences.fasta"
         mafft_success, mafft_result = run_mafft_alignment(multi_fasta, aligned_fasta, mafft_cmd)
         os.unlink(multi_fasta)
         
         if not mafft_success:
             return False, f"{status_msg}\n❌ MAFFT failed: {mafft_result}", None, None
         
-        tree_prefix = "ml_tree_output/ml_tree"
+        tree_prefix = "/data/ml_tree_output/ml_tree"
         iqtree_success, iqtree_result = run_iqtree_analysis(aligned_fasta, tree_prefix, iqtree_cmd)
         if not iqtree_success:
             return False, f"{status_msg}\n❌ IQ-TREE failed: {iqtree_result}", aligned_fasta, None
         
         tree_file = iqtree_result
-        shutil.copy2(aligned_fasta, "f_gene_sequences_aligned.fasta")
-        shutil.copy2(tree_file, "f_gene_sequences.phy.treefile")
+        shutil.copy2(aligned_fasta, "/data/f_gene_sequences_aligned.fasta")
+        shutil.copy2(tree_file, "/data/f_gene_sequences.phy.treefile")
         
         success_msg = f"{status_msg}\n✅ ML tree built:\n- Alignment: {os.path.basename(aligned_fasta)}\n- Tree: {os.path.basename(tree_file)}"
         return True, success_msg, aligned_fasta, tree_file
@@ -352,6 +320,49 @@ def build_tree(sequence):
     success, message, aligned_fasta, tree_file = build_maximum_likelihood_tree(sequence)
     return format_results({"message": message, "tree_file": tree_file}, sequence, "tree")
 
+# --- File Processing ---
+def process_fasta_file(file):
+    try:
+        if not file:
+            return "Please upload a FASTA file."
+        
+        sequences = {}
+        current_seq = ""
+        current_name = ""
+        with open(file.name, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith('>'):
+                    if current_name and current_seq:
+                        sequences[current_name] = current_seq
+                    current_name = line[1:]
+                    current_seq = ""
+                else:
+                    current_seq += line.upper()
+        if current_name and current_seq:
+            sequences[current_name] = current_seq
+        
+        if not sequences:
+            return "No valid sequences in FASTA file."
+        
+        results = [f"📁 FASTA FILE ANALYSIS\nFound {len(sequences)} sequences\n{'=' * 50}"]
+        for i, (name, seq) in enumerate(sequences.items()):
+            if i >= 3:  # Reduced for HF
+                results.append(f"\n... and {len(sequences) - 3} more sequences")
+                break
+            results.append(f"\n🧬 Sequence: {name}\nLength: {len(seq)} bp")
+            clean_seq = re.sub(r'[^ATCG]', '', seq)
+            if len(clean_seq) >= 10:
+                results.append(analyze_sequence(clean_seq))
+            else:
+                results.append("❌ Sequence too short or invalid")
+            results.append("-" * 40)
+        
+        return "\n".join(results)
+    except Exception as e:
+        logging.error(f"FASTA processing failed: {e}")
+        return f"FASTA processing failed: {str(e)}"
+
 # --- Gradio Interface ---
 def create_gradio_interface():
     css = """
@@ -385,8 +396,8 @@ def create_gradio_interface():
             with gr.Column(scale=2):
                 output = gr.Textbox(
                     label="Results",
-                    lines=20,
-                    max_lines=30,
+                    lines=15,
+                    max_lines=20,
                     elem_classes=["output-text"]
                 )
         
@@ -408,53 +419,11 @@ def create_gradio_interface():
     
     return interface
 
-# --- File Processing ---
-def process_fasta_file(file):
-    try:
-        if not file:
-            return "Please upload a FASTA file."
-        
-        sequences = {}
-        current_seq = ""
-        current_name = ""
-        with open(file.name, 'r') as f:
-            for line in f:
-                line = line.strip()
-                if line.startswith('>'):
-                    if current_name and current_seq:
-                        sequences[current_name] = current_seq
-                    current_name = line[1:]
-                    current_seq = ""
-                else:
-                    current_seq += line.upper()
-        if current_name and current_seq:
-            sequences[current_name] = current_seq
-        
-        if not sequences:
-            return "No valid sequences in FASTA file."
-        
-        results = [f"📁 FASTA FILE ANALYSIS\nFound {len(sequences)} sequences\n{'=' * 50}"]
-        for i, (name, seq) in enumerate(sequences.items()):
-            if i >= 5:
-                results.append(f"\n... and {len(sequences) - 5} more sequences")
-                break
-            results.append(f"\n🧬 Sequence: {name}\nLength: {len(seq)} bp")
-            clean_seq = re.sub(r'[^ATCG]', '', seq)
-            if len(clean_seq) >= 10:
-                results.append(analyze_sequence(clean_seq))
-            else:
-                results.append("❌ Sequence too short or invalid")
-            results.append("-" * 40)
-        
-        return "\n".join(results)
-    except Exception as e:
-        logging.error(f"FASTA processing failed: {e}")
-        return f"FASTA processing failed: {str(e)}"
-
 # --- Main ---
 if __name__ == "__main__":
-    os.makedirs("output", exist_ok=True)
-    os.makedirs("ml_tree_output", exist_ok=True)
+    os.makedirs("/data", exist_ok=True)
+    os.makedirs("/data/ml_tree_output", exist_ok=True)
+    os.makedirs("/data/models", exist_ok=True)
     
     load_models()
     init_tree_analyzer()
@@ -467,11 +436,9 @@ if __name__ == "__main__":
     try:
         interface = create_gradio_interface()
         interface.launch(
-            share=False,
             server_name="0.0.0.0",
             server_port=7860,
-            show_error=True,
-            debug=True
+            share=False  # Managed by Hugging Face
         )
     except Exception as e:
         logging.error(f"Interface launch failed: {e}")