Update app.py

app.py

@@ -398,7 +398,7 @@ 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
 
-async def run_pipeline_from_file(fasta_file_obj, similarity_score, build_ml_tree):
+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:
@@ -493,7 +493,7 @@ async def analyze_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)
+        result = run_pipeline_from_file(temp_file_path, similarity_score, build_ml_tree)
         return AnalysisResponse(
             boundary_output=result[0] or "",
             keras_output=result[1] or "",
@@ -516,14 +516,13 @@ async def analyze_file(
             except:
                 pass
 
-# --- Gradio Interface ---
 # --- Gradio Interface ---
 def create_gradio_interface():
     logger.info("Attempting to create Gradio interface...")
     try:
         with gr.Blocks(
             title="🧬 Gene Analysis Pipeline",
-            theme="default",  # Simplify theme to reduce resource usage
+            theme=gr.themes.Default(),  # Use proper theme object
             css="""
             .gradio-container { max-width: 1200px !important; }
             .status-box { padding: 10px; border-radius: 5px; margin: 5px 0; }
@@ -631,115 +630,160 @@ def create_gradio_interface():
                         label="Analysis Report",
                         value="<div style='text-align: center; padding: 20px; color: #666;'>No report generated yet.</div>"
                     )
+
+            # Event handlers
             analyze_btn.click(
                 fn=run_pipeline,
                 inputs=[dna_input, similarity_score, build_ml_tree],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output,
-                    tree_analysis_output, summary_output,
-                    aligned_file, tree_file, gr.State(), gr.State(),
-                    tree_html, report_html
+                    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
                 ]
             )
+
             analyze_file_btn.click(
                 fn=run_pipeline_from_file,
                 inputs=[file_input, file_similarity_score, file_build_ml_tree],
                 outputs=[
-                    boundary_output, keras_output, ml_tree_output,
-                    tree_analysis_output, summary_output,
-                    aligned_file, tree_file, gr.State(), gr.State(),
-                    tree_html, report_html
+                    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
                 ]
             )
-            gr.Markdown("## 🔬 Example Sequences")
-            example_sequences = [
-                ["ATGGACTTCCAAATTAACAACCTCAACAACCTCAACAACATCAACAACATCAACAACATCAACAACATCAACAAC", 90.0, False],
-                ["ATGAAACAAATTAACAACCTCAACAACCTCAACAACATCAACAACATCAACAACATCAACAACATCAACAACATCAACAACATCAACAACATCAACAACATCAACAACATCAACAAC", 85.0, True]
-            ]
-            gr.Examples(
-                examples=example_sequences,
-                inputs=[dna_input, similarity_score, build_ml_tree],
-                label="Click to load example sequences"
-            )
-            with gr.Accordion("❓ Help & Information", open=False):
-                gr.Markdown("""
-                ### 🧬 Gene Analysis Pipeline
-                This tool performs comprehensive analysis of F gene sequences:
-                **🎯 Boundary Detection**: Identifies F gene regions within your sequence
-                **🧠 F Gene Validation**: Validates sequence as F gene using deep learning
-                **🌲 Phylogenetic Placement**: Places sequence in reference phylogeny
-                **🌳 Tree Analysis**: Finds similar sequences and builds interactive trees
-                ### 📋 Input Requirements
-                - DNA sequences in ATCG format
-                - Minimum 10 bp for basic analysis
-                - Minimum 100 bp for phylogenetic placement
-                - FASTA files supported for upload
-                ### ⚙️ Parameters
-                - **Similarity Threshold**: Minimum % similarity for tree analysis (1-99%)
-                - **Build ML Tree**: Enable phylogenetic placement (requires MAFFT/IQ-TREE)
-                ### 📊 Output Files
-                - Alignment files (.fa format)
-                - Tree files (.treefile format)
-                - Interactive HTML visualizations
-                """)
-            logger.info("Gradio interface created successfully")
-            return iface
+
+            gr.Markdown("""
+            ## 📖 Instructions
+            
+            ### 🧬 Input Methods:
+            - **Text Input**: Paste your DNA sequence directly
+            - **File Upload**: Upload a FASTA file (.fasta, .fa, .fas, .txt)
+            
+            ### ⚙️ Parameters:
+            - **Similarity Threshold**: Minimum similarity percentage for phylogenetic tree analysis (1-99%)
+            - **Build ML Tree**: Enable for maximum likelihood phylogenetic placement (computationally intensive)
+            
+            ### 📊 Analysis Steps:
+            1. **Boundary Detection**: Identifies F gene regions within your sequence
+            2. **F Gene Validation**: Validates the sequence as an F gene using neural networks
+            3. **Phylogenetic Placement**: Places sequence in reference phylogenetic tree (optional)
+            4. **Tree Analysis**: Builds similarity-based phylogenetic tree with interactive visualization
+            
+            ### 🔬 Results:
+            - **Interactive Tree**: Explore phylogenetic relationships
+            - **Detailed Report**: Comprehensive analysis including evolutionary insights
+            - **Downloadable Files**: Alignment and tree files for further analysis
+            
+            ### ⚠️ Notes:
+            - Sequences should be in DNA format (A, T, G, C, N)
+            - Minimum 10 bp for basic analysis, 100 bp for phylogenetic placement
+            - ML tree generation may take several minutes for large sequences
+            """)
+
+        logger.info("✅ Gradio interface created successfully")
+        return iface
+
     except Exception as e:
-        logger.error(f"Failed to create Gradio interface: {str(e)}", exc_info=True)
-        return None
-# --- Application Startup ---
-def mount_gradio_app():
-    logger.info("Mounting Gradio app...")
+        logger.error(f"❌ Failed to create Gradio interface: {e}")
+        # Fallback simple interface
+        try:
+            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"
+            )
+            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 ---
+def main():
+    """Main function to launch the application."""
+    logger.info("🚀 Starting Gene Analysis Pipeline...")
+    
     try:
+        # Create Gradio interface
         gradio_app = create_gradio_interface()
-        if gradio_app:
-            global app
-            app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
-            logger.info("✅ Gradio interface mounted at /gradio")
-        else:
+        
+        if gradio_app is None:
             logger.error("❌ Failed to create Gradio interface")
+            return
+        
+        # Mount Gradio app to FastAPI
+        try:
+            app.mount("/gradio", gradio_app.queue(), name="gradio")
+            logger.info("✅ Gradio mounted to FastAPI at /gradio")
+        except Exception as e:
+            logger.error(f"❌ Failed to mount Gradio: {e}")
+            # Try alternative mounting
+            try:
+                gradio_app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
+                logger.info("✅ Gradio mounted using alternative method")
+            except Exception as alt_error:
+                logger.error(f"❌ Alternative mounting also failed: {alt_error}")
+        
+        # Launch configuration
+        port = int(os.environ.get("PORT", 7860))
+        host = "0.0.0.0"
+        
+        logger.info(f"🌐 Launching on {host}:{port}")
+        logger.info(f"📱 FastAPI docs: http://{host}:{port}/docs")
+        logger.info(f"🧬 Gradio interface: http://{host}:{port}/gradio")
+        
+        # Launch the server
+        uvicorn.run(
+            app,
+            host=host,
+            port=port,
+            log_level="info",
+            access_log=True,
+            reload=False  # Set to True for development
+        )
+        
     except Exception as e:
-        logger.error(f"❌ Failed to mount Gradio app: {str(e)}", exc_info=True)
-
-# Initialize Gradio
-mount_gradio_app()
+        logger.error(f"❌ Failed to launch application: {e}")
+        # Fallback: Launch only Gradio
+        try:
+            logger.info("🔄 Attempting fallback Gradio-only launch...")
+            gradio_app = create_gradio_interface()
+            if gradio_app:
+                gradio_app.launch(
+                    server_name="0.0.0.0",
+                    server_port=7860,
+                    share=False,
+                    debug=False
+                )
+        except Exception as fallback_error:
+            logger.error(f"❌ Fallback launch failed: {fallback_error}")
 
-# --- Main Application ---
 if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="🧬 Gene Analysis Pipeline")
-    parser.add_argument("--host", default="0.0.0.0", help="Host address")
-    parser.add_argument("--port", type=int, default=7860, help="Port number")
-    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
-    parser.add_argument("--gradio-only", action="store_true", help="Run Gradio interface only")
-    args = parser.parse_args()
-    if args.gradio_only:
-        logger.info("🚀 Starting Gradio interface only...")
-        iface = create_gradio_interface()
-        if iface:
-            iface.launch(
-                server_name=args.host,
-                server_port=args.port,
-                share=False,
-                show_error=True
-            )
-        else:
-            logger.error("❌ Failed to create Gradio interface")
-            sys.exit(1)
-    else:
-        logger.info(f"🚀 Starting Gene Analysis Pipeline on {args.host}:{args.port}")
-        logger.info("📊 API Documentation: http://localhost:7860/docs")
-        logger.info("🧬 Gradio Interface: http://localhost:7860/gradio")
-        try:
-            uvicorn.run(
-                "app:app" if args.reload else app,
-                host=args.host,
-                port=args.port,
-                reload=args.reload,
-                log_level="info"
-            )
-        except KeyboardInterrupt:
-            logger.info("🛑 Application stopped by user")
-        except Exception as e:
-            logger.error(f"❌ Application failed: {e}")
-            sys.exit(1)
+    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
+        )
+
+def launch_fastapi_only():
+    """Launch only FastAPI (for API-only deployments)"""
+    logger.info("🚀 Launching FastAPI-only mode...")
+    port = int(os.environ.get("PORT", 8000))
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info",
+        access_log=True,
+        reload=False
+    )