Update app.py

app.py

@@ -520,9 +520,12 @@ async def analyze_file(
 def create_gradio_interface():
     logger.info("Attempting to create Gradio interface...")
     try:
+        # Use a more basic theme to avoid compatibility issues
+        theme = gr.themes.Base()
+        
         with gr.Blocks(
             title="🧬 Gene Analysis Pipeline",
-            theme=gr.themes.Default(),  # Use proper theme object
+            theme=theme,
             css="""
             .gradio-container { max-width: 1200px !important; }
             .status-box { padding: 10px; border-radius: 5px; margin: 5px 0; }
@@ -533,26 +536,36 @@ def create_gradio_interface():
         ) as iface:
             logger.info("Gradio Blocks initialized")
             gr.Markdown("# 🧬 Gene Analysis Pipeline")
+            
+            # System Status
             with gr.Row():
                 with gr.Column():
+                    try:
+                        mafft_avail, iqtree_avail, _, _ = check_tool_availability()
+                    except:
+                        mafft_avail, iqtree_avail = False, False
+                    
                     status_display = gr.HTML(value=f"""
                     <div class="status-box">
                         <h3>🔧 System Status</h3>
                         <p>🤖 Boundary Model: {'✅ Loaded' if boundary_model else '❌ Missing'}</p>
                         <p>🧠 Keras Model: {'✅ Loaded' if keras_model else '❌ Missing'}</p>
                         <p>🌳 Tree Analyzer: {'✅ Loaded' if analyzer else '❌ Missing'}</p>
-                        <p>🧬 MAFFT: {'✅ Available' if check_tool_availability()[0] else '❌ Missing'}</p>
-                        <p>🌲 IQ-TREE: {'✅ Available' if check_tool_availability()[1] else '❌ Missing'}</p>
+                        <p>🧬 MAFFT: {'✅ Available' if mafft_avail else '❌ Missing'}</p>
+                        <p>🌲 IQ-TREE: {'✅ Available' if iqtree_avail else '❌ Missing'}</p>
                     </div>
                     """)
+            
+            # Input Tabs
             with gr.Tabs():
                 with gr.TabItem("📝 Text Input"):
                     with gr.Row():
                         with gr.Column(scale=2):
                             dna_input = gr.Textbox(
-                                label="🧬 DNA Sequence - Paste your DNA sequence here",
+                                label="🧬 DNA Sequence",
                                 placeholder="Enter DNA sequence (ATCG format)...",
-                                lines=5
+                                lines=5,
+                                max_lines=10
                             )
                         with gr.Column(scale=1):
                             similarity_score = gr.Slider(
@@ -560,18 +573,19 @@ def create_gradio_interface():
                                 maximum=99,
                                 value=95.0,
                                 step=1.0,
-                                label="🎯 Similarity Threshold (%) - Minimum similarity for tree analysis"
+                                label="🎯 Similarity Threshold (%)"
                             )
                             build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree - Generate phylogenetic placement (slower)",
+                                label="🌲 Build ML Tree",
                                 value=False
                             )
                             analyze_btn = gr.Button("🔬 Analyze Sequence", variant="primary")
+                
                 with gr.TabItem("📁 File Upload"):
                     with gr.Row():
                         with gr.Column(scale=2):
                             file_input = gr.File(
-                                label="📄 Upload FASTA File - Upload a FASTA file containing your sequence",
+                                label="📄 Upload FASTA File",
                                 file_types=[".fasta", ".fa", ".fas", ".txt"]
                             )
                         with gr.Column(scale=1):
@@ -580,14 +594,18 @@ def create_gradio_interface():
                                 maximum=99,
                                 value=95.0,
                                 step=1.0,
-                                label="🎯 Similarity Threshold (%) - Minimum similarity for tree analysis"
+                                label="🎯 Similarity Threshold (%)"
                             )
                             file_build_ml_tree = gr.Checkbox(
-                                label="🌲 Build ML Tree - Generate phylogenetic placement (slower)",
+                                label="🌲 Build ML Tree",
                                 value=False
                             )
                             analyze_file_btn = gr.Button("🔬 Analyze File", variant="primary")
+            
+            # Results Section
             gr.Markdown("## 📊 Analysis Results")
+            
+            # Main Results
             with gr.Row():
                 with gr.Column():
                     boundary_output = gr.Textbox(
@@ -611,47 +629,95 @@ def create_gradio_interface():
                         interactive=False,
                         lines=2
                     )
+            
+            # Summary
             summary_output = gr.Textbox(
                 label="📋 Summary",
                 interactive=False,
                 lines=8
             )
+            
+            # File outputs (hidden by default)
             with gr.Row():
                 aligned_file = gr.File(label="📄 Alignment File", visible=False)
                 tree_file = gr.File(label="🌲 Tree File", visible=False)
+            
+            # Visualization Tabs
             with gr.Tabs():
                 with gr.TabItem("🌳 Interactive Tree"):
                     tree_html = gr.HTML(
-                        label="Phylogenetic Tree",
                         value="<div style='text-align: center; padding: 20px; color: #666;'>No tree generated yet.</div>"
                     )
                 with gr.TabItem("📊 Detailed Report"):
                     report_html = gr.HTML(
-                        label="Analysis Report",
                         value="<div style='text-align: center; padding: 20px; color: #666;'>No report generated yet.</div>"
                     )
 
-            # Event handlers
+            # Create a wrapper function to handle the outputs properly
+            def run_pipeline_wrapper(*args):
+                try:
+                    result = run_pipeline(*args)
+                    # Ensure we return exactly 11 outputs
+                    if len(result) < 11:
+                        # Pad with default values
+                        result = list(result) + [None] * (11 - len(result))
+                    return result[:11]  # Truncate if too many
+                except Exception as e:
+                    logger.error(f"Pipeline wrapper error: {e}")
+                    error_msg = f"❌ Error: {str(e)}"
+                    return (error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg)
+
+            def run_pipeline_from_file_wrapper(*args):
+                try:
+                    result = run_pipeline_from_file(*args)
+                    # Ensure we return exactly 11 outputs
+                    if len(result) < 11:
+                        # Pad with default values
+                        result = list(result) + [None] * (11 - len(result))
+                    return result[:11]  # Truncate if too many
+                except Exception as e:
+                    logger.error(f"Pipeline file wrapper error: {e}")
+                    error_msg = f"❌ Error: {str(e)}"
+                    return (error_msg, "", "", "", "", None, None, None, None, error_msg, error_msg)
+
+            # Event handlers with explicit output specification
             analyze_btn.click(
-                fn=run_pipeline,
+                fn=run_pipeline_wrapper,
                 inputs=[dna_input, similarity_score, build_ml_tree],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output, tree_analysis_output,
-                    summary_output, aligned_file, tree_file, gr.File(visible=False), 
-                    gr.File(visible=False), tree_html, report_html
+                    boundary_output, 
+                    keras_output, 
+                    ml_tree_output, 
+                    tree_analysis_output,
+                    summary_output, 
+                    aligned_file, 
+                    tree_file, 
+                    gr.File(visible=False),  # dummy output 1
+                    gr.File(visible=False),  # dummy output 2
+                    tree_html, 
+                    report_html
                 ]
             )
 
             analyze_file_btn.click(
-                fn=run_pipeline_from_file,
+                fn=run_pipeline_from_file_wrapper,
                 inputs=[file_input, file_similarity_score, file_build_ml_tree],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output, tree_analysis_output,
-                    summary_output, aligned_file, tree_file, gr.File(visible=False), 
-                    gr.File(visible=False), tree_html, report_html
+                    boundary_output, 
+                    keras_output, 
+                    ml_tree_output, 
+                    tree_analysis_output,
+                    summary_output, 
+                    aligned_file, 
+                    tree_file, 
+                    gr.File(visible=False),  # dummy output 1
+                    gr.File(visible=False),  # dummy output 2
+                    tree_html, 
+                    report_html
                 ]
             )
 
+            # Instructions
             gr.Markdown("""
             ## 📖 Instructions
             
@@ -685,26 +751,81 @@ def create_gradio_interface():
 
     except Exception as e:
         logger.error(f"❌ Failed to create Gradio interface: {e}")
-        # Fallback simple interface
+        logger.error(f"Error details: {type(e).__name__}: {str(e)}")
+        
+        # Enhanced fallback interface
         try:
+            def simple_analysis(sequence):
+                if not sequence:
+                    return "Please enter a DNA sequence"
+                
+                try:
+                    # Basic sequence validation
+                    sequence = sequence.upper().strip()
+                    valid_chars = set('ATCGN')
+                    if not all(c in valid_chars for c in sequence):
+                        return "Invalid characters in sequence. Use only A, T, C, G, N"
+                    
+                    # Try basic analysis
+                    if len(sequence) < 10:
+                        return "Sequence too short (minimum 10 bp)"
+                    
+                    # Simple analysis result
+                    result = f"""
+                    ✅ Sequence Analysis Complete
+                    Length: {len(sequence)} bp
+                    GC Content: {((sequence.count('G') + sequence.count('C')) / len(sequence) * 100):.1f}%
+                    
+                    Note: Full analysis pipeline unavailable due to interface error.
+                    Error: {str(e)}
+                    """
+                    return result
+                    
+                except Exception as analysis_error:
+                    return f"Analysis error: {str(analysis_error)}"
+            
             simple_iface = gr.Interface(
-                fn=lambda x: f"Error creating interface: {str(e)}",
-                inputs=gr.Textbox(label="Input"),
-                outputs=gr.Textbox(label="Output"),
-                title="🧬 Gene Analysis Pipeline - Error"
+                fn=simple_analysis,
+                inputs=gr.Textbox(
+                    label="🧬 DNA Sequence",
+                    placeholder="Enter DNA sequence (ATCG format)...",
+                    lines=5
+                ),
+                outputs=gr.Textbox(
+                    label="📊 Analysis Result",
+                    lines=10
+                ),
+                title="🧬 Gene Analysis Pipeline - Fallback Mode",
+                description=f"Simplified interface due to error: {str(e)}"
             )
             logger.info("⚠️ Fallback interface created")
             return simple_iface
+            
         except Exception as fallback_error:
             logger.error(f"❌ Even fallback interface failed: {fallback_error}")
             return None
 
-# --- App Mounting and Launch ---
+# Additional helper function to handle Gradio mounting issues
+def safe_gradio_mount(app, gradio_app, path="/gradio"):
+    """Safely mount Gradio app with error handling"""
+    try:
+        # Try the standard mounting approach
+        if hasattr(gr, 'mount_gradio_app'):
+            return gr.mount_gradio_app(app, gradio_app, path=path)
+        else:
+            # Alternative approach for older Gradio versions
+            gradio_app.mount_path = path
+            return app.mount(path, gradio_app.app)
+    except Exception as e:
+        logger.error(f"Failed to mount Gradio: {e}")
+        raise e
+
+# Enhanced main function with better error handling
 def main():
-    """Main function to launch the application."""
+    """Main function to launch the application with enhanced error handling."""
     logger.info("🚀 Starting Gene Analysis Pipeline...")
     
-    # Check if we should run in simple mode (environment variable)
+    # Check if we should run in simple mode
     simple_mode = os.environ.get("SIMPLE_MODE", "false").lower() == "true"
     
     if simple_mode:
@@ -713,48 +834,48 @@ def main():
         return
     
     try:
-        # Create Gradio interface
+        # Create Gradio interface with enhanced error handling
         gradio_app = create_gradio_interface()
         
         if gradio_app is None:
-            logger.error("❌ Failed to create Gradio interface")
+            logger.error("❌ Failed to create Gradio interface, launching API-only mode")
+            launch_fastapi_only()
             return
         
-        # Mount Gradio app to FastAPI
+        # Try to mount Gradio app to FastAPI
         try:
-            # Use the proper Gradio mounting method
-            gradio_app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
+            safe_gradio_mount(app, gradio_app, path="/gradio")
             logger.info("✅ Gradio mounted to FastAPI at /gradio")
-        except Exception as e:
-            logger.error(f"❌ Failed to mount Gradio: {e}")
-            # Try alternative approach - launch separately
-            try:
-                # Launch Gradio in a separate thread
-                import threading
-                
-                def launch_gradio():
+        except Exception as mount_error:
+            logger.error(f"❌ Failed to mount Gradio: {mount_error}")
+            logger.info("🔄 Launching Gradio and FastAPI separately...")
+            
+            # Launch Gradio in a separate thread
+            import threading
+            
+            def launch_gradio_separate():
+                try:
                     gradio_app.launch(
                         server_name="0.0.0.0",
-                        server_port=7861,  # Different port to avoid conflicts
+                        server_port=7861,
                         share=False,
                         debug=False,
                         prevent_thread_lock=True
                     )
-                
-                gradio_thread = threading.Thread(target=launch_gradio, daemon=True)
-                gradio_thread.start()
-                logger.info("✅ Gradio launched on separate port 7861")
-            except Exception as alt_error:
-                logger.error(f"❌ Alternative Gradio launch failed: {alt_error}")
+                except Exception as gradio_error:
+                    logger.error(f"❌ Separate Gradio launch failed: {gradio_error}")
+            
+            gradio_thread = threading.Thread(target=launch_gradio_separate, daemon=True)
+            gradio_thread.start()
+            logger.info("✅ Gradio launched on separate port 7861")
         
         # Launch configuration
         port = int(os.environ.get("PORT", 7860))
         host = "0.0.0.0"
         
         logger.info(f"🌐 Launching FastAPI on {host}:{port}")
-        logger.info(f"📱 FastAPI docs: http://{host}:{port}/docs")
-        logger.info(f"🧬 Gradio interface: http://{host}:7861 (if mounted separately)")
-        logger.info(f"🧬 Gradio interface: http://{host}:{port}/gradio (if mounted successfully)")
+        logger.info(f"📱 API docs available at: http://{host}:{port}/docs")
+        logger.info(f"🧬 Gradio interface at: http://{host}:{port}/gradio")
         
         # Launch the server
         uvicorn.run(
@@ -763,34 +884,18 @@ def main():
             port=port,
             log_level="info",
             access_log=True,
-            reload=False  # Set to True for development
+            reload=False
         )
         
     except Exception as e:
-        logger.error(f"❌ Failed to launch application: {e}")
-        # Fallback: Launch only Gradio
+        logger.error(f"❌ Main application launch failed: {e}")
+        # Final fallback: Launch only Gradio
         try:
-            logger.info("🔄 Attempting fallback Gradio-only launch...")
+            logger.info("🔄 Final fallback: Gradio-only launch...")
             launch_gradio_only()
-        except Exception as fallback_error:
-            logger.error(f"❌ Fallback launch failed: {fallback_error}")
-
-if __name__ == "__main__":
-    main()
-
-# Alternative entry points for different deployment scenarios
-def launch_gradio_only():
-    """Launch only Gradio interface (for simpler deployments)"""
-    logger.info("🚀 Launching Gradio-only mode...")
-    gradio_app = create_gradio_interface()
-    if gradio_app:
-        gradio_app.launch(
-            server_name="0.0.0.0",
-            server_port=int(os.environ.get("PORT", 7860)),
-            share=False,
-            debug=False
-        )
-
+        except Exception as final_error:
+            logger.error(f"❌ Final fallback failed: {final_error}")
+            logger.error("❌ All launch methods failed. Check your environment and dependencies.")
 def launch_fastapi_only():
     """Launch only FastAPI (for API-only deployments)"""
     logger.info("🚀 Launching FastAPI-only mode...")