Update app.py

app.py

@@ -8,390 +8,127 @@ import os
 import traceback
 
 # Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Debug info for Hugging Face Spaces
-print("=== Hugging Face Spaces Debug Info ===")
-print(f"Current working directory: {os.getcwd()}")
-print(f"Files in current directory: {os.listdir('.')}")
-print(f"Python path: {os.environ.get('PYTHONPATH', 'Not set')}")
+# Debug info
+print("=== Debug Info ===")
+print(f"Working directory: {os.getcwd()}")
+print(f"Files: {os.listdir('.')}")
 print(f"PyTorch version: {torch.__version__}")
-print(f"CUDA available: {torch.cuda.is_available()}")
-print(f"Device count: {torch.cuda.device_count() if torch.cuda.is_available() else 0}")
-if torch.cuda.is_available():
-    print(f"Current device: {torch.cuda.current_device()}")
-    print(f"Device name: {torch.cuda.get_device_name()}")
-print("==========================================")
+print("==================")
 
-# Initialize the predictor globally with error handling
+# Initialize predictor
 predictor = None
 initialization_error = None
 
 try:
-    print("Attempting to import predictor...")
     from predictor import GenePredictor
-    print("✅ Predictor module imported successfully")
-    
-    # Check if model file exists
     model_path = 'best_boundary_aware_model.pth'
+    
     if os.path.exists(model_path):
-        print(f"✅ Model file found: {model_path}")
         predictor = GenePredictor(model_path=model_path)
-        print("✅ Gene predictor initialized successfully")
-        logger.info("Gene predictor initialized successfully")
+        print("✅ Model loaded successfully")
     else:
-        print(f"❌ Model file not found: {model_path}")
-        print(f"Available files: {[f for f in os.listdir('.') if f.endswith('.pth')]}")
         initialization_error = f"Model file {model_path} not found"
+        print(f"❌ {initialization_error}")
         
-except ImportError as e:
-    print(f"❌ Import Error: {e}")
-    print("Make sure predictor.py is in the same directory as app.py")
-    logger.error(f"Failed to import predictor: {e}")
-    initialization_error = f"Import error: {e}"
-except FileNotFoundError as e:
-    print(f"❌ File Error: {e}")
-    logger.error(f"Model file not found: {e}")
-    initialization_error = f"File not found: {e}"
 except Exception as e:
-    print(f"❌ Unexpected error during initialization: {e}")
-    logger.error(f"Failed to initialize predictor: {e}")
-    initialization_error = f"Initialization error: {e}"
+    initialization_error = str(e)
+    print(f"❌ Error: {e}")
 
-def predict_gene_regions(sequence: str, 
-                        ground_truth_labels: Optional[str] = None,
-                        ground_truth_start: Optional[int] = None,
-                        ground_truth_end: Optional[int] = None) -> Tuple[str, str, str]:
-    """
-    Main prediction function for Gradio interface
-    
-    Returns:
-        - regions_display: Formatted string showing predicted regions
-        - metrics_display: Formatted string showing accuracy metrics (if ground truth provided)
-        - detailed_json: JSON string with full prediction details
-    """
-    
+def predict_genes(sequence):
+    """Simple prediction function"""
     try:
-        if predictor is None:
-            error_msg = f"""❌ **Model not loaded**
-            
-Error: {initialization_error or 'Unknown initialization error'}
-
-Please check:
-1. predictor.py file exists
-2. best_boundary_aware_model.pth file exists  
-3. All dependencies are installed
-4. Check the Hugging Face Spaces logs for specific errors"""
-            return error_msg, "", "{}"
+        if not predictor:
+            return f"❌ Model not loaded: {initialization_error}"
         
-        # Input validation
         if not sequence or not sequence.strip():
-            return "❌ Sequence cannot be empty", "", "{}"
+            return "❌ Please enter a DNA sequence"
         
         sequence = sequence.strip().upper()
         
-        # Check for valid DNA characters
+        # Validate sequence
         valid_chars = set('ACTGN')
-        invalid_chars = set(sequence) - valid_chars
-        if invalid_chars:
-            return f"❌ Sequence contains invalid characters: {', '.join(sorted(invalid_chars))}. Only A, C, T, G, N allowed", "", "{}"
+        if not set(sequence).issubset(valid_chars):
+            return "❌ Invalid characters. Use only A, C, T, G, N"
         
-        # Check sequence length
         if len(sequence) < 3:
-            return "❌ Sequence too short. Minimum length is 3 nucleotides", "", "{}"
+            return "❌ Sequence too short (minimum 3 nucleotides)"
         
-        if len(sequence) > 10000:  # Add reasonable upper limit
-            return "❌ Sequence too long. Maximum length is 10,000 nucleotides", "", "{}"
-        
-        # Process ground truth if provided
-        labels = None
-        try:
-            if ground_truth_labels and ground_truth_labels.strip():
-                # Parse comma-separated labels
-                label_strings = [x.strip() for x in ground_truth_labels.split(',')]
-                labels = [int(x) for x in label_strings if x]  # Skip empty strings
-                
-                if len(labels) != len(sequence):
-                    return f"❌ Labels length ({len(labels)}) must match sequence length ({len(sequence)})", "", "{}"
-                
-                if not all(x in (0, 1) for x in labels):
-                    return "❌ Labels must be 0 or 1", "", "{}"
-                    
-            elif ground_truth_start is not None and ground_truth_end is not None:
-                start = int(ground_truth_start)
-                end = int(ground_truth_end)
-                
-                if start < 0 or end > len(sequence) or start >= end:
-                    return f"❌ Invalid coordinates: start={start}, end={end}, sequence_length={len(sequence)}", "", "{}"
-                
-                # Create labels array
-                labels = [0] * len(sequence)
-                for i in range(start, end):
-                    labels[i] = 1
-                    
-        except ValueError as e:
-            return f"❌ Invalid ground truth format: {str(e)}", "", "{}"
+        if len(sequence) > 10000:
+            return "❌ Sequence too long (maximum 10,000 nucleotides)"
         
         # Make prediction
-        print(f"Making prediction for sequence of length {len(sequence)}")
         predictions, probs_dict, confidence = predictor.predict(sequence)
-        print(f"Prediction completed. Confidence: {confidence}")
-        
-        # Extract gene regions
         regions = predictor.extract_gene_regions(predictions, sequence)
-        print(f"Extracted {len(regions)} regions")
-        
-        # Format regions display
-        regions_display = format_regions_display(regions, confidence)
         
-        # Compute metrics if ground truth provided
-        metrics_display = ""
-        metrics = None
-        if labels is not None:
-            print("Computing accuracy metrics...")
-            metrics = predictor.compute_accuracy(predictions, labels)
-            metrics_display = format_metrics_display(metrics)
+        # Format output
+        if not regions:
+            return f"🔍 No gene regions detected (Confidence: {confidence:.3f})"
         
-        # Create detailed JSON response
-        detailed_response = {
-            "regions": regions,
-            "confidence": float(confidence),
-            "metrics": metrics,
-            "sequence_length": len(sequence),
-            "num_predicted_genes": len(regions),
-            "prediction_summary": {
-                "total_gene_positions": int(np.sum(predictions)),
-                "gene_coverage": float(np.sum(predictions) / len(predictions))
-            }
-        }
+        result = f"🧬 Found {len(regions)} gene region(s) (Confidence: {confidence:.3f})\n\n"
         
-        detailed_json = json.dumps(detailed_response, indent=2)
-        print("Prediction completed successfully")
+        for i, region in enumerate(regions, 1):
+            result += f"**Gene {i}:**\n"
+            result += f"  • Position: {region['start']} - {region['end']}\n"
+            result += f"  • Length: {region['length']} bp\n"
+            
+            # Safe sequence preview
+            seq = region.get('sequence', '')
+            if seq:
+                preview = seq[:60] + ('...' if len(seq) > 60 else '')
+                result += f"  • Preview: {preview}\n\n"
+            else:
+                result += f"  • Preview: Not available\n\n"
         
-        return regions_display, metrics_display, detailed_json
+        return result
         
     except Exception as e:
-        print(f"Error during prediction: {e}")
-        print(f"Error type: {type(e).__name__}")
-        print(f"Full traceback: {traceback.format_exc()}")
-        logger.error(f"Prediction failed: {e}")
-        
-        error_msg = f"❌ Prediction failed: {str(e)}\n\nError type: {type(e).__name__}"
-        return error_msg, "", "{}"
+        print(f"Prediction error: {e}")
+        return f"❌ Prediction failed: {str(e)}"
 
-def format_regions_display(regions: List[Dict], confidence: float) -> str:
-    """Format the regions for display in the Gradio interface"""
-    
-    if not regions:
-        return f"🔍 **No gene regions detected** (Confidence: {confidence:.3f})\n\nThe model did not identify any gene regions in the provided sequence."
-    
-    display = f"🧬 **Found {len(regions)} gene region(s)** (Overall Confidence: {confidence:.3f})\n\n"
-    
-    for i, region in enumerate(regions, 1):
-        display += f"**Gene {i}:**\n"
-        display += f"  • Position: {region['start']} - {region['end']}\n"
-        display += f"  • Length: {region['length']} bp\n"
-        display += f"  • Start Codon: {region.get('start_codon', 'None detected') or 'None detected'}\n"
-        display += f"  • Stop Codon: {region.get('stop_codon', 'None detected') or 'None detected'}\n"
-        display += f"  • In Frame: {'✅ Yes' if region.get('in_frame', False) else '❌ No'}\n"
-        
-        # Safe sequence preview
-        seq = region.get('sequence', '')
-        if seq:
-            preview = seq[:60] + ('...' if len(seq) > 60 else '')
-            display += f"  • Sequence Preview: {preview}\n\n"
-        else:
-            display += f"  • Sequence Preview: Not available\n\n"
-    
-    return display
+def load_example():
+    """Load example DNA sequence"""
+    return "ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGGGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGACTACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTGCGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCTCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCCGGCCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGG"
+
+# Status message
+if predictor:
+    status_msg = "✅ Model loaded successfully!"
+    status_color = "green"
+else:
+    status_msg = f"❌ Model loading failed: {initialization_error}"
+    status_color = "red"
 
-def format_metrics_display(metrics: Dict) -> str:
-    """Format the accuracy metrics for display"""
+# Try gr.Interface first (simpler approach)
+demo = gr.Interface(
+    fn=predict_genes,
+    inputs=gr.Textbox(
+        label="DNA Sequence", 
+        placeholder="Enter DNA sequence (A, C, T, G, N)...",
+        lines=6
+    ),
+    outputs=gr.Textbox(
+        label="Prediction Results", 
+        lines=15
+    ),
+    title="🧬 Gene Prediction Tool",
+    description=f"""
+    Predict gene regions in DNA sequences using deep learning.
     
-    display = "📊 **Accuracy Metrics** (vs Ground Truth)\n\n"
-    display += f"  • **Accuracy:** {metrics.get('accuracy', 0):.3f} ({metrics.get('accuracy', 0)*100:.1f}%)\n"
-    display += f"  • **Precision:** {metrics.get('precision', 0):.3f}\n"
-    display += f"  • **Recall:** {metrics.get('recall', 0):.3f}\n"
-    display += f"  • **F1 Score:** {metrics.get('f1', 0):.3f}\n\n"
-    display += f"**Confusion Matrix:**\n"
-    display += f"  • True Positives: {metrics.get('true_positives', 0)}\n"
-    display += f"  • False Positives: {metrics.get('false_positives', 0)}\n"
-    display += f"  • False Negatives: {metrics.get('false_negatives', 0)}\n"
+    **Status:** {status_msg}
     
-    return display
-
-def load_example_sequence():
-    """Load an example DNA sequence for testing"""
-    example = """ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGGGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGACTACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTGCGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCTCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCCGGCCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGG"""
-    return example
+    **Instructions:**
+    1. Enter a DNA sequence using only A, C, T, G, N characters
+    2. Click Submit
+    3. View predicted gene regions with positions and confidence scores
+    """,
+    examples=[
+        ["ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGGGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAAATAAAACATGTCCTGCATGGCATTAGTTTGTTGGGGCAGTGCCCGGATAGCATCAACGCTGCGCTGATTTGCCGTGGCGAGAAAATGTCGATCGCCATTATGGCCGGCGTATTAGAAGCGCGCGGTCACAACGTTACTGTTATCGATCCGGTCGAAAAACTGCTGGCAGTGGGGCATTACCTCGAATCTACCGTCGATATTGCTGAGTCCACCCGCCGTATTGCGGCAAGCCGCATTCCGGCTGATCACATGGTGCTGATGGCAGGTTTCACCGCCGGTAATGAAAAAGGCGAACTGGTGGTGCTTGGACGCAACGGTTCCGACTACTCTGCTGCGGTGCTGGCTGCCTGTTTACGCGCCGATTGTTGCGAGATTTGGACGGACGTTGACGGGGTCTATACCTGCGACCCGCGTCAGGTGCCCGATGCGAGGTTGTTGAAGTCGATGTCCTACCAGGAAGCGATGGAGCTTTCCTACTTCGGCGCTAAAGTTCTTCACCCCCGCACCATTACCCCCATCGCCCAGTTCCAGATCCCTTGCCTGATTAAAAATACCGGAAATCCTCAAGCACCAGGTACGCTCATTGGTGCCAGCCGTGATGAAGACGAATTACCGGTCAAGGGCATTTCCAATCTGAATAACATGGCAATGTTCAGCGTTTCCGGCCCGGGGATGAAAGGGATGGTCGGCATGGCGGCGCGCGTCTTTGCAGCGATGTCACGCGCCCGTATTTCCGTGGTGCTGATTACGCAATCATCTTCCGAATACAGCATCAGTTTCTGCGTTCCACAAAGCGACTGTGTGCGAGCTGAACGGGCAATGCAGGAAGAGTTCTACCTGGAACTGAAAGAAGGCTTACTGGAGCCGCTGGCAGTGACGGAACGGCTGGCCATTATCTCGGTGGTAGG"]
+    ],
+    allow_flagging="never"
+)
 
-def clear_inputs():
-    """Clear all input fields"""
-    return "", None, None, ""
-
-# Create the Gradio interface with simpler structure
-def create_interface():
-    try:
-        # Show setup status
-        if predictor:
-            status_message = "✅ Model loaded successfully!"
-            status_color = "green"
-        else:
-            status_message = f"❌ Model failed to load: {initialization_error}"
-            status_color = "red"
-        
-        # Create interface with minimal configuration
-        interface = gr.Blocks(
-            title="Gene Prediction Tool",
-            theme=gr.themes.Default()  # Use default theme instead of Soft
-        )
-        
-        with interface:
-            # Header
-            gr.HTML(f"""
-            <div style="text-align: center; padding: 20px;">
-                <h1>🧬 Gene Prediction Tool</h1>
-                <p>This tool predicts gene regions in DNA sequences using a boundary-aware deep learning model.</p>
-                <div style="padding: 10px; border-left: 4px solid {status_color}; background-color: #f9f9f9; margin: 10px 0;">
-                    <strong>Status:</strong> {status_message}
-                </div>
-            </div>
-            """)
-            
-            # Input section
-            gr.Markdown("## 📝 Input")
-            
-            sequence_input = gr.Textbox(
-                label="DNA Sequence",
-                placeholder="Enter your DNA sequence (A, C, T, G, N only)...",
-                lines=5,
-                info="Maximum length: 10,000 nucleotides"
-            )
-            
-            with gr.Row():
-                example_btn = gr.Button("📋 Load Example", size="sm")
-                clear_btn = gr.Button("🗑️ Clear", size="sm")
-                predict_btn = gr.Button("🔬 Predict Genes", variant="primary")
-            
-            # Ground truth section (optional)
-            with gr.Accordion("🎯 Ground Truth (Optional)", open=False):
-                gr.Markdown("*Provide ground truth data to calculate accuracy metrics*")
-                
-                with gr.Row():
-                    gt_start = gr.Number(
-                        label="Start Position",
-                        precision=0,
-                        minimum=0
-                    )
-                    gt_end = gr.Number(
-                        label="End Position", 
-                        precision=0,
-                        minimum=0
-                    )
-                
-                gt_labels = gr.Textbox(
-                    label="OR: Labels (comma-separated 0s and 1s)",
-                    placeholder="0,0,1,1,1,0,0...",
-                    info="Alternative to start/end positions"
-                )
-            
-            # Output section
-            gr.Markdown("## 🔬 Prediction Results")
-            
-            regions_output = gr.Markdown(
-                value="*Results will appear here after prediction...*"
-            )
-            
-            metrics_output = gr.Markdown(
-                value="*Metrics will appear here if ground truth is provided...*"
-            )
-            
-            # Detailed JSON output (collapsible)
-            with gr.Accordion("📄 Detailed JSON Output", open=False):
-                json_output = gr.Code(
-                    language="json",
-                    value="{}",
-                    lines=10
-                )
-            
-            # Event handlers
-            example_btn.click(
-                fn=load_example_sequence,
-                outputs=sequence_input
-            )
-            
-            clear_btn.click(
-                fn=clear_inputs,
-                outputs=[sequence_input, gt_start, gt_end, gt_labels]
-            )
-            
-            predict_btn.click(
-                fn=predict_gene_regions,
-                inputs=[sequence_input, gt_labels, gt_start, gt_end],
-                outputs=[regions_output, metrics_output, json_output]
-            )
-            
-            # Also trigger prediction on Enter in the sequence box
-            sequence_input.submit(
-                fn=predict_gene_regions,
-                inputs=[sequence_input, gt_labels, gt_start, gt_end],
-                outputs=[regions_output, metrics_output, json_output]
-            )
-            
-            # Footer
-            gr.Markdown("""
-            ---
-            **Model Info:** Boundary-aware gene prediction using multi-task deep learning  
-            **Supported:** DNA sequences with A, C, T, G, N nucleotides  
-            **Output:** Gene regions with start/end positions, codons, and confidence scores
-            """)
-        
-        return interface
-        
-    except Exception as e:
-        print(f"❌ Error creating interface: {e}")
-        print(f"Full traceback: {traceback.format_exc()}")
-        
-        # Create a minimal fallback interface
-        fallback_interface = gr.Interface(
-            fn=lambda x: f"Error: {str(e)}",
-            inputs=gr.Textbox(label="DNA Sequence"),
-            outputs=gr.Textbox(label="Output"),
-            title="Gene Prediction Tool - Error Recovery Mode"
-        )
-        return fallback_interface
-
-# Main execution
+# Launch the app
 if __name__ == "__main__":
-    try:
-        print("Creating Gradio interface...")
-        interface = create_interface()
-        print("✅ Gradio interface created successfully")
-        
-        # Launch the interface
-        # Remove custom CSS and use default settings for HF Spaces
-        interface.launch(
-            server_name="0.0.0.0",  # Important for HF Spaces
-            server_port=7860,       # Standard port for HF Spaces
-            share=False,            # Don't create public link on HF Spaces
-            debug=False,            # Turn off debug mode for production
-            show_error=True         # Show errors in interface
-        )
-        
-    except Exception as e:
-        print(f"❌ Failed to launch interface: {e}")
-        print(f"Full traceback: {traceback.format_exc()}")
-        
-        # Last resort - create the simplest possible interface
-        try:
-            simple_interface = gr.Interface(
-                fn=lambda x: "Simple interface loaded - main interface failed",
-                inputs=gr.Textbox(label="Test Input"),
-                outputs=gr.Textbox(label="Test Output"),
-                title="Gene Prediction Tool - Minimal Mode"
-            )
-            simple_interface.launch()
-        except Exception as e2:
-            print(f"❌ Even simple interface failed: {e2}")
-            raise
+    demo.launch()