Update app.py

app.py

@@ -39,9 +39,9 @@ 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])
+    logging.basicConfig(level=logging.DEBUG, handlers=[log_handler, file_handler])  # Changed to DEBUG
 except Exception as e:
-    logging.basicConfig(level=logging.INFO, handlers=[log_handler])
+    logging.basicConfig(level=logging.DEBUG, handlers=[log_handler])
     logging.warning(f"Failed to set up file logging: {e}")
 logger = logging.getLogger(__name__)
 logger.info(f"Gradio version: {gr.__version__}")
@@ -82,7 +82,7 @@ def load_models_safely():
         else:
             logger.error(f"❌ Boundary model file not found.")
     except Exception as e:
-        logger.error(f"❌ Failed to load boundary model: {e}")
+        logger.error(f"❌ Failed to load boundary model: {e}", exc_info=True)
         boundary_model = None
     try:
         keras_path = hf_hub_download(repo_id=MODEL_REPO, filename="best_model.keras", token=None)
@@ -95,7 +95,7 @@ def load_models_safely():
         else:
             logger.error(f"❌ Keras model files not found.")
     except Exception as e:
-        logger.error(f"❌ Failed to load Keras model: {e}")
+        logger.error(f"❌ Failed to load Keras model: {e}", exc_info=True)
         keras_model = None
         kmer_to_index = None
     try:
@@ -115,7 +115,7 @@ def load_models_safely():
                         csv_loaded = True
                         break
                 except Exception as e:
-                    logger.warning(f"CSV load failed for {csv_candidate}: {e}")
+                    logger.warning(f"CSV load failed for {csv_candidate}: {e}", exc_info=True)
         if not csv_loaded:
             logger.error("❌ Failed to load CSV data.")
             analyzer = None
@@ -126,9 +126,9 @@ def load_models_safely():
                 else:
                     logger.warning("⚠️ AI model training failed.")
             except Exception as e:
-                logger.warning(f"⚠️ AI model training failed: {e}")
+                logger.warning(f"⚠️ AI model training failed: {e}", exc_info=True)
     except Exception as e:
-        logger.error(f"❌ Tree analyzer initialization failed: {e}")
+        logger.error(f"❌ Tree analyzer initialization failed: {e}", exc_info=True)
         analyzer = None
 
 load_models_safely()
@@ -141,7 +141,7 @@ def setup_binary_permissions():
                 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}")
+                logger.warning(f"Failed to set permission on {binary}: {e}", exc_info=True)
 
 def check_tool_availability():
     setup_binary_permissions()
@@ -177,57 +177,73 @@ def check_tool_availability():
 
 # --- Pipeline Functions ---
 def phylogenetic_placement(sequence: str, mafft_cmd: str, iqtree_cmd: str):
+    query_fasta = None
     try:
         if len(sequence.strip()) < 100:
             return False, "Sequence too short (<100 bp).", None, None
         query_id = f"QUERY_{uuid.uuid4().hex[:8]}"
         query_fasta = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}.fa")
         aligned_with_query = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_aligned.fa")
-        output_prefix = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_placed_tree")
+        output_prefix = os.path.join(QUERY_OUTPUT_DIR, f"{query_id}_")
         if not os.path.exists(ALIGNMENT_PATH) or not os.path.exists(TREE_PATH):
+            logger.error(f"Reference alignment or tree not found: {ALIGNMENT_PATH}, {TREE_PATH}")
             return False, "Reference alignment or tree not found.", None, None
+        logger.debug(f"Writing query FASTA to: {query_fasta}")
         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:
+        SeqIO.write(query_fasta, [query_fasta], "write([query_record])")
+        logger.debug("Running MAFFT alignment...")
+        with open(aligned_with_query, "subprocess") as subprocess:
             subprocess.run([
-                mafft_cmd, "--add", query_fasta, "--reorder", ALIGNMENT_PATH
-            ], stdout=output_file, stderr=subprocess.PIPE, text=True, timeout=600, check=True)
-        if not os.path.exists(aligned_with_query) or os.path.getsize(aligned_with_query) == 0:
+                open, mafft_cmd, "--add", "--reorder", "subprocess.PIPEALIGNMENT_PATH"
+                query_f, aligned_with_query, query_fasta
+            ], "subprocess.PIPE=stdout", text=True, timeout_ms=600000, check=True)
+        if not os.path.exists("aligned_with_query") or not os.path.getsize(aligned_with_query):
+            logger.error(f"MAFFT alignment failed: {aligned_with_query}")
             return False, "MAFFT alignment failed.", None, None
+        logger.debug("Running IQ-TREE placement...")
         subprocess.run([
             iqtree_cmd, "-s", aligned_with_query, "-g", TREE_PATH,
             "-m", "GTR+G", "-pre", output_prefix, "-redo"
         ], capture_output=True, text=True, timeout=1200, check=True)
         treefile = f"{output_prefix}.treefile"
         if not os.path.exists(treefile):
+            logger.error(f"IQ-TREE placement failed: {treefile} not found")
             return False, "IQ-TREE placement failed.", aligned_with_query, None
         success_msg = f"Placement completed!\nQuery ID: {query_id}\nAlignment: {os.path.basename(aligned_with_query)}\nTree: {os.path.basename(treefile)}"
+        logger.info(success_msg)
         return True, success_msg, aligned_with_query, treefile
     except Exception as e:
         logger.error(f"Phylogenetic placement failed: {e}", exc_info=True)
         return False, f"Error: {str(e)}", None, None
     finally:
-        if 'query_fasta' in locals() and os.path.exists(query_fasta):
+        if query_fasta and os.path.exists(query_fasta):
             try:
                 os.unlink(query_fasta)
-            except Exception as e:  # Fixed bare 'except'
-                logger.warning(f"Failed to clean up {query_fasta}: {e}")
+                logger.debug(f"Cleaned up {query_fasta}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up {query_fasta}: {e}", exc_info=True)
 
 def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
     try:
         logger.debug("Starting tree analysis...")
         if not analyzer:
+            logger.error("Tree analyzer not initialized")
             return "❌ Tree analyzer not initialized.", None, None
+        logger.debug("Validating sequence...")
         if not sequence or len(sequence.strip()) < 10:
+            logger.error("Invalid sequence: too short or empty")
             return "❌ Invalid sequence.", None, None
         if not (1 <= matching_percentage <= 99):
+            logger.error(f"Invalid matching percentage: {matching_percentage}")
             return "❌ Matching percentage must be 1-99.", None, None
         logger.debug("Finding query sequence...")
         if not analyzer.find_query_sequence(sequence):
+            logger.error("Sequence not accepted by analyzer")
             return "❌ Sequence not accepted.", None, None
         logger.debug("Finding similar sequences...")
         matched_ids, actual_percentage = analyzer.find_similar_sequences(matching_percentage)
         if not matched_ids:
+            logger.warning(f"No similar sequences found at {matching_percentage}% threshold")
             return f"❌ No similar sequences at {matching_percentage}% threshold.", None, None
         logger.debug("Building tree structure...")
         analyzer.build_tree_structure_with_ml_safe(matched_ids)
@@ -241,7 +257,7 @@ def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
         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")
+        logger.debug(f"Tree analysis completed: {len(matched_ids)} matches at {actual_percentage:.2f}%")
         return f"✅ Found {len(matched_ids)} sequences at {actual_percentage:.2f}% similarity.", tree_html_path, report_html_path
     except Exception as e:
         logger.error(f"Tree analysis failed: {e}", exc_info=True)
@@ -249,16 +265,22 @@ def analyze_sequence_for_tree(sequence: str, matching_percentage: float):
 
 def predict_with_keras(sequence):
     try:
+        logger.debug("Starting Keras prediction...")
         if not keras_model or not kmer_to_index:
+            logger.error("Keras model or kmer index not available")
             return "❌ Keras model not available."
         if len(sequence) < 6:
+            logger.error("Sequence too short for Keras prediction")
             return "❌ Sequence too short (<6 bp)."
+        logger.debug("Generating kmers...")
         kmers = [sequence[i:i+6] for i in range(len(sequence)-5)]
         indices = [kmer_to_index.get(kmer, 0) for kmer in kmers]
         input_arr = np.array([indices])
+        logger.debug("Running Keras prediction...")
         prediction = keras_model.predict(input_arr, verbose=0)[0]
         f_gene_prob = prediction[-1]
         percentage = min(100, max(0, int(f_gene_prob * 100 + 5)))
+        logger.debug(f"Keras prediction completed: {percentage}% confidence")
         return f"✅ {percentage}% F gene confidence"
     except Exception as e:
         logger.error(f"Keras prediction failed: {e}", exc_info=True)
@@ -266,7 +288,9 @@ def predict_with_keras(sequence):
 
 def read_fasta_file(file_obj):
     try:
+        logger.debug("Reading FASTA file...")
         if file_obj is None:
+            logger.error("No file object provided")
             return ""
         if isinstance(file_obj, str):
             with open(file_obj, "r") as f:
@@ -275,20 +299,26 @@ def read_fasta_file(file_obj):
             content = file_obj.read().decode("utf-8")
         lines = content.strip().split("\n")
         seq_lines = [line.strip() for line in lines if not line.startswith(">")]
-        return ''.join(seq_lines)
+        sequence = ''.join(seq_lines)
+        logger.debug(f"FASTA file read successfully: {len(sequence)} bp")
+        return sequence
     except Exception as e:
         logger.error(f"Failed to read FASTA file: {e}", exc_info=True)
         return ""
 
 def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
     try:
+        logger.debug("Starting pipeline...")
         dna_input = dna_input.upper().strip()
         if not dna_input:
+            logger.error("Empty input sequence")
             return "❌ Empty input", "", "", "", "", None, None, None, None, "No input", "No input", None, None
         if not re.match('^[ACTGN]+$', dna_input):
+            logger.debug("Cleaning invalid characters from input")
             dna_input = ''.join(c if c in 'ACTGN' else 'N' for c in dna_input)
         processed_sequence = dna_input
         boundary_output = ""
+        logger.debug("Running boundary detection...")
         if boundary_model:
             try:
                 result = boundary_model.predict_sequence(dna_input)
@@ -296,19 +326,25 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                 if regions:
                     processed_sequence = regions[0]["sequence"]
                     boundary_output = f"✅ F gene region found: {len(processed_sequence)} bp"
+                    logger.debug(f"Boundary detection: F gene found, {len(processed_sequence)} bp")
                 else:
                     boundary_output = "⚠️ No F gene regions found."
                     processed_sequence = dna_input
+                    logger.debug("Boundary detection: No F gene regions found")
             except Exception as e:
                 boundary_output = f"❌ Boundary prediction error: {str(e)}"
                 processed_sequence = dna_input
+                logger.error(f"Boundary prediction error: {e}", exc_info=True)
         else:
             boundary_output = f"⚠️ Boundary model not available. Using full input: {len(dna_input)} bp"
+            logger.warning("Boundary model not available")
+        logger.debug("Running Keras validation...")
         keras_output = predict_with_keras(processed_sequence) if processed_sequence and len(processed_sequence) >= 6 else "❌ Sequence too short."
         aligned_file = None
         phy_file = None
         ml_tree_output = ""
         if build_ml_tree and processed_sequence and len(processed_sequence) >= 100:
+            logger.debug("Running phylogenetic placement...")
             try:
                 mafft_available, iqtree_available, mafft_cmd, iqtree_cmd = check_tool_availability()
                 if mafft_available and iqtree_available:
@@ -316,41 +352,53 @@ def run_pipeline(dna_input, similarity_score=95.0, build_ml_tree=False):
                     ml_tree_output = ml_message
                     aligned_file = ml_aligned
                     phy_file = ml_tree
+                    logger.debug(f"Phylogenetic placement: {ml_message}")
                 else:
                     ml_tree_output = "❌ MAFFT or IQ-TREE not available"
+                    logger.error("MAFFT or IQ-TREE not available")
             except Exception as e:
                 ml_tree_output = f"❌ ML tree error: {str(e)}"
+                logger.error(f"ML tree error: {e}", exc_info=True)
         elif build_ml_tree:
             ml_tree_output = "❌ Sequence too short for placement (<100 bp)."
+            logger.error("Sequence too short for phylogenetic placement")
         else:
             ml_tree_output = "⚠️ Phylogenetic placement skipped."
+            logger.debug("Phylogenetic placement skipped")
         tree_html_content = "No tree generated."
         report_html_content = "No report generated."
         tree_html_path = None
         report_html_path = None
         simplified_ml_output = ""
         if analyzer and processed_sequence and len(processed_sequence) >= 10:
+            logger.debug("Running tree analysis...")
             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()
+                    logger.debug(f"Tree HTML generated: {tree_html_path}")
                 else:
                     tree_html_content = f"<div style='color: red;'>{tree_result}</div>"
+                    logger.debug("No tree HTML generated")
                 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()
+                    logger.debug(f"Report HTML generated: {report_html_path}")
                 else:
                     report_html_content = f"<div style='color: red;'>{tree_result}</div>"
+                    logger.debug("No report HTML generated")
             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>"
+                logger.error(f"Tree analysis error: {e}", exc_info=True)
         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>"
+            logger.error(simplified_ml_output)
         summary_output = f"""
 📊 ANALYSIS SUMMARY:
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -361,6 +409,7 @@ Placement: {'✅ OK' if '✅' in ml_tree_output else '⚠️ Skipped' if 'skippe
 Tree Analysis: {'✅ OK' if 'Found' in simplified_ml_output else '❌ Failed'}
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 """
+        logger.debug("Pipeline completed successfully")
         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,
@@ -371,10 +420,12 @@ Tree Analysis: {'✅ OK' if 'Found' in simplified_ml_output else '❌ Failed'}
         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_file):
+async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
     temp_file_path = None
     try:
+        logger.debug("Starting pipeline from file...")
         if fasta_file_obj is None:
+            logger.error("No file provided")
             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):
@@ -385,9 +436,12 @@ async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_file
                     content = f.read()
                 temp_file.write(content)
             temp_file_path = temp_file.name
+        logger.debug(f"Reading FASTA file: {temp_file_path}")
         dna_input = read_fasta_file(temp_file_path)
         if not dna_input:
+            logger.error("Failed to read FASTA file")
             return "❌ Failed to read FASTA file", "", "", "", "", None, None, None, None, "No input", "No input", None, None
+        logger.debug("Running pipeline with FASTA input...")
         return run_pipeline(dna_input, similarity_score, build_ml_tree)
     except Exception as e:
         logger.error(f"Pipeline from file error: {e}", exc_info=True)
@@ -397,8 +451,9 @@ async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_file
         if temp_file_path and os.path.exists(temp_file_path):
             try:
                 os.unlink(temp_file_path)
+                logger.debug(f"Cleaned up temp file: {temp_file_path}")
             except Exception as e:
-                logger.warning(f"Failed to delete temp file {temp_file_path}: {e}")
+                logger.warning(f"Failed to delete temp file {temp_file_path}: {e}", exc_info=True)
 
 # --- Pydantic Models ---
 class AnalysisRequest(BaseModel):
@@ -460,7 +515,9 @@ async def health_check():
 @app.post("/analyze", response_model=AnalysisResponse)
 async def analyze_sequence(request: AnalysisRequest):
     try:
+        logger.debug("Starting sequence analysis via API...")
         result = run_pipeline(request.sequence, request.similarity_score, request.build_ml_tree)
+        logger.debug("API analysis completed")
         return AnalysisResponse(
             boundary_output=result[0] or "",
             keras_output=result[1] or "",
@@ -488,11 +545,13 @@ async def analyze_file(
 ):
     temp_file_path = None
     try:
+        logger.debug("Starting file analysis via API...")
         with tempfile.NamedTemporaryFile(delete=False, suffix=".fasta", dir="/tmp") as temp_file:
             content = await file.read()
             temp_file.write(content)
             temp_file_path = temp_file.name
         result = await run_pipeline_from_file(temp_file_path, similarity_score, build_ml_tree)
+        logger.debug("API file analysis completed")
         return AnalysisResponse(
             boundary_output=result[0] or "",
             keras_output=result[1] or "",
@@ -515,18 +574,23 @@ async def analyze_file(
         if temp_file_path and os.path.exists(temp_file_path):
             try:
                 os.unlink(temp_file_path)
+                logger.debug(f"Cleaned up API temp file: {temp_file_path}")
             except Exception as e:
-                logger.warning(f"Failed to clean up {temp_file_path}: {e}")
+                logger.warning(f"Failed to clean up {temp_file_path}: {e}", exc_info=True)
 
 @app.get("/download/{file_type}/{query_id}")
 async def download_file(file_type: str, query_id: str):
     try:
+        logger.debug(f"Downloading file: {file_type}/{query_id}")
         if file_type not in ["tree", "report"]:
+            logger.error(f"Invalid file type: {file_type}")
             raise HTTPException(status_code=400, detail="Invalid file type. Use 'tree' or 'report'.")
         file_name = f"phylogenetic_tree_{query_id}.html" if file_type == "tree" else f"detailed_report_{query_id}.html"
         file_path = os.path.join("/tmp", file_name)
         if not os.path.exists(file_path):
+            logger.error(f"File not found: {file_path}")
             raise HTTPException(status_code=404, detail="File not found.")
+        logger.debug(f"Serving file: {file_path}")
         return FileResponse(file_path, filename=file_name, media_type="text/html")
     except Exception as e:
         logger.error(f"Download error: {e}", exc_info=True)
@@ -535,6 +599,7 @@ async def download_file(file_type: str, query_id: str):
 # --- Gradio Interface ---
 def create_gradio_interface():
     try:
+        logger.debug("Creating Gradio interface...")
         with gr.Blocks(
             title="🧬 Gene Analysis Pipeline",
             theme=gr.themes.Soft(),
@@ -566,7 +631,8 @@ def create_gradio_interface():
                             dna_input = gr.Textbox(
                                 label="🧬 DNA Sequence",
                                 placeholder="Enter DNA sequence (ATCG format)...",
-                                lines=5
+                                lines=5,
+                                description="Paste your DNA sequence here"
                             )
                         with gr.Column(scale=1):
                             similarity_score = gr.Slider(
@@ -574,11 +640,13 @@ def create_gradio_interface():
                                 maximum=99,
                                 value=95.0,
                                 step=1.0,
-                                label="🎯 Similarity Threshold (%)"
+                                label="🎯 Similarity Threshold (%)",
+                                description="Minimum similarity for tree analysis"
                             )
                             build_ml_tree = gr.Checkbox(
                                 label="🌲 Build ML Tree",
-                                value=False
+                                value=False,
+                                description="Generate phylogenetic placement (slower)"
                             )
                             analyze_btn = gr.Button("🔬 Analyze Sequence", variant="primary")
                 with gr.TabItem("📁 File Upload"):
@@ -586,7 +654,8 @@ def create_gradio_interface():
                         with gr.Column(scale=2):
                             file_input = gr.File(
                                 label="📄 Upload FASTA File",
-                                file_types=[".fasta", ".fa", ".fas", ".txt"]
+                                file_types=[".fasta", ".fa", ".fas", ".txt"],
+                                description="Upload a FASTA file containing your sequence"
                             )
                         with gr.Column(scale=1):
                             file_similarity_score = gr.Slider(
@@ -594,22 +663,44 @@ def create_gradio_interface():
                                 maximum=99,
                                 value=95.0,
                                 step=1.0,
-                                label="🎯 Similarity Threshold (%)"
+                                label="🎯 Similarity Threshold (%)",
+                                description="Minimum similarity for tree analysis"
                             )
                             file_build_ml_tree = gr.Checkbox(
                                 label="🌲 Build ML Tree",
-                                value=False
+                                value=False,
+                                description="Generate phylogenetic placement (slower)"
                             )
                             analyze_file_btn = gr.Button("🔬 Analyze File", variant="primary")
             gr.Markdown("## 📊 Analysis Results")
             with gr.Row():
                 with gr.Column():
-                    boundary_output = gr.Textbox(label="🎯 Boundary Detection", interactive=False, lines=2)
-                    keras_output = gr.Textbox(label="🧠 F Gene Validation", interactive=False, lines=2)
+                    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)
+                    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)
@@ -617,9 +708,27 @@ def create_gradio_interface():
                 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.</div>")
+                    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(value="<div style='text-align: center; color: #666; padding: 20px;'>No report generated yet.</div>")
+                    report_html = gr.HTML(
+                        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
+                logger.debug("Handling Gradio output...")
+                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,
@@ -627,7 +736,8 @@ def create_gradio_interface():
                 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
-                ]
+                ],
+                _js="""(outputs) => { return outputs; }"""
             )
 
             analyze_file_btn.click(
@@ -636,18 +746,36 @@ def create_gradio_interface():
                 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
-                ]
+                ],
+                _js="""(outputs) => { return outputs; }"""
             )
 
             gr.Examples(
                 examples=[
-                    ["ATCG" * 100, 85.0, False],
-                    ["CGAT" * 100, 90.0, True]
+                    ["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
+            """)
+
+        logger.debug("Gradio interface created successfully")
         return iface
     except Exception as e:
         logger.error(f"Gradio interface creation failed: {e}", exc_info=True)
@@ -661,9 +789,12 @@ def create_gradio_interface():
 # --- Application Startup ---
 def run_application():
     try:
+        logger.debug("Starting application...")
         gradio_app = create_gradio_interface()
         gradio_app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
         logger.info("🚀 Starting Gene Analysis Pipeline...")
+        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",