Update app.py

app.py

@@ -1,17 +1,443 @@
 import gradio as gr
+import torch
+import numpy as np
+import os
+import traceback
+import logging
+import sys
 
-def test_function(text):
-    return f"You entered: {text}"
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-# Simple test interface
-with gr.Blocks(title="Test App") as demo:
-    gr.Markdown("# Test Interface")
-    with gr.Row():
-        input_box = gr.Textbox(label="Input")
-        output_box = gr.Textbox(label="Output")
+print("=== Gene Prediction App Starting ===")
+print(f"Working directory: {os.getcwd()}")
+print(f"Available files: {os.listdir('.')}")
+print(f"PyTorch version: {torch.__version__}")
+print(f"Gradio version: {gr.__version__}")
+print(f"Python path: {sys.path}")
+
+# Global variables
+predictor = None
+model_loaded = False
+error_message = ""
+
+def initialize_model():
+    """Initialize the model with proper error handling"""
+    global predictor, model_loaded, error_message
+    
+    try:
+        print("Attempting to import predictor...")
+        
+        # Try different import approaches
+        try:
+            from predictor import GenePredictor
+            print("✅ Imported from predictor module")
+        except ImportError:
+            try:
+                # If predictor.py is in the same directory
+                import importlib.util
+                spec = importlib.util.spec_from_file_location("predictor", "predictor.py")
+                predictor_module = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(predictor_module)
+                GenePredictor = predictor_module.GenePredictor
+                print("✅ Imported predictor.py directly")
+            except Exception as e:
+                print(f"Failed to import predictor: {e}")
+                raise ImportError(f"Could not import GenePredictor: {e}")
+        
+        # Look for model file
+        possible_model_paths = [
+            'best_boundary_aware_model.pth',
+            'model/best_boundary_aware_model.pth',
+            './best_boundary_aware_model.pth'
+        ]
+        
+        model_path = None
+        for path in possible_model_paths:
+            if os.path.exists(path):
+                model_path = path
+                break
+        
+        if not model_path:
+            available_models = [f for f in os.listdir('.') if f.endswith('.pth')]
+            if os.path.exists('model'):
+                available_models.extend([f"model/{f}" for f in os.listdir('model') if f.endswith('.pth')])
+            
+            error_message = f"❌ Model file not found. Searched: {possible_model_paths}. Available: {available_models}"
+            print(error_message)
+            return False
+            
+        print(f"Found model file: {model_path}")
+        print(f"Model file size: {os.path.getsize(model_path)} bytes")
+        
+        # Initialize predictor
+        predictor = GenePredictor(model_path=model_path)
+        model_loaded = True
+        print("✅ Model initialized successfully")
+        return True
+        
+    except Exception as e:
+        error_message = f"❌ Model initialization failed: {str(e)}"
+        print(error_message)
+        print("Full traceback:")
+        traceback.print_exc()
+        return False
+
+def predict_genes(sequence):
+    """Gene prediction function with comprehensive error handling"""
+    try:
+        # Check if model is loaded
+        if not model_loaded or predictor is None:
+            return f"🚫 **Model Error**\n\n{error_message}\n\nPlease check that:\n1. predictor.py is in the same directory\n2. Model file (.pth) exists\n3. All dependencies are installed"
+        
+        # Input validation
+        if not sequence or not sequence.strip():
+            return "⚠️ **Input Error**\n\nPlease enter a DNA sequence."
+        
+        # Clean sequence
+        sequence = sequence.strip().upper()
+        sequence = sequence.replace(' ', '').replace('\n', '').replace('\t', '').replace('\r', '')
+        
+        # Character validation
+        valid_chars = set('ATCGN')
+        invalid_chars = set(sequence) - valid_chars
+        if invalid_chars:
+            return f"⚠️ **Invalid Characters**\n\nFound invalid characters: {', '.join(sorted(invalid_chars))}\n\nPlease use only: A, T, C, G, N"
+        
+        # Length validation
+        if len(sequence) < 3:
+            return f"⚠️ **Sequence Too Short**\n\nMinimum length: 3 nucleotides\nYour sequence: {len(sequence)} nucleotides"
+        
+        if len(sequence) > 10000:
+            return f"⚠️ **Sequence Too Long**\n\nMaximum length: 10,000 nucleotides\nYour sequence: {len(sequence)} nucleotides\n\nFor longer sequences, consider splitting them into smaller chunks."
+        
+        print(f"Processing sequence of length: {len(sequence)}")
+        
+        # Make prediction
+        predictions, probs_dict, confidence = predictor.predict(sequence)
+        regions = predictor.extract_gene_regions(predictions, sequence)
+        
+        # Format results
+        result = f"🧬 **Gene Prediction Results**\n\n"
+        result += f"📊 **Analysis Summary:**\n"
+        result += f"• Sequence length: {len(sequence):,} bp\n"
+        result += f"• Gene regions found: {len(regions)}\n"
+        result += f"• Overall confidence: {confidence:.3f}\n"
+        result += f"• Analysis completed successfully ✅\n\n"
+        
+        if not regions:
+            result += f"🔍 **No Gene Regions Detected**\n\n"
+            result += f"The model did not detect any gene regions meeting the minimum criteria in this sequence.\n"
+            result += f"This could mean:\n"
+            result += f"• The sequence may not contain protein-coding genes\n"
+            result += f"• Genes may be partial or fragmented\n"
+            result += f"• The sequence may be non-coding DNA\n"
+            return result
+        
+        result += f"📍 **Detected Gene Regions:**\n\n"
+        
+        total_gene_length = 0
+        for i, region in enumerate(regions, 1):
+            result += f"**🧬 Gene Region {i}:**\n"
+            result += f"├─ Position: {region['start']:,} - {region['end']:,} bp\n"
+            result += f"├─ Length: {region['length']:,} bp\n"
+            result += f"├─ In-frame: {'Yes' if region.get('in_frame', False) else 'No'}\n"
+            
+            # Start codon info
+            start_codon = region.get('start_codon')
+            if start_codon:
+                result += f"├─ Start codon: {start_codon}\n"
+            else:
+                result += f"├─ Start codon: Not detected\n"
+            
+            # Stop codon info
+            stop_codon = region.get('stop_codon')
+            if stop_codon:
+                result += f"├─ Stop codon: {stop_codon}\n"
+            else:
+                result += f"├─ Stop codon: Not detected\n"
+            
+            # Sequence preview
+            seq = region.get('sequence', '')
+            if seq:
+                if len(seq) <= 120:
+                    result += f"└─ Sequence: `{seq}`\n"
+                else:
+                    preview = seq[:60] + '...' + seq[-60:]
+                    result += f"└─ Sequence: `{preview}`\n"
+            
+            total_gene_length += region['length']
+            result += "\n"
+        
+        # Summary statistics
+        result += f"📈 **Statistics:**\n"
+        result += f"• Total gene content: {total_gene_length:,} bp ({total_gene_length/len(sequence)*100:.1f}% of sequence)\n"
+        result += f"• Average gene length: {total_gene_length//len(regions):,} bp\n"
+        result += f"• Gene density: {len(regions)/(len(sequence)/1000):.2f} genes per kb\n"
+        
+        return result
+        
+    except Exception as e:
+        error_msg = f"🚫 **Prediction Error**\n\n"
+        error_msg += f"An error occurred during prediction:\n\n"
+        error_msg += f"```\n{str(e)}\n```\n\n"
+        error_msg += f"**Troubleshooting:**\n"
+        error_msg += f"• Check that predictor.py is in the same directory\n"
+        error_msg += f"• Verify model file exists and is not corrupted\n"
+        error_msg += f"• Ensure sequence contains only valid DNA characters\n"
+        
+        print(f"Prediction error: {e}")
+        traceback.print_exc()
+        return error_msg
+
+def get_sequence_stats(sequence):
+    """Get basic statistics about the input sequence"""
+    if not sequence or not sequence.strip():
+        return ""
+    
+    sequence = sequence.strip().upper().replace(' ', '').replace('\n', '').replace('\t', '')
+    
+    if not sequence:
+        return ""
     
-    btn = gr.Button("Process")
-    btn.click(test_function, inputs=input_box, outputs=output_box)
+    stats = f"**Sequence Info:** {len(sequence)} bp"
+    
+    # Base composition
+    a_count = sequence.count('A')
+    t_count = sequence.count('T')
+    c_count = sequence.count('C')
+    g_count = sequence.count('G')
+    n_count = sequence.count('N')
+    
+    total_valid = a_count + t_count + c_count + g_count
+    if total_valid > 0:
+        gc_content = (c_count + g_count) / total_valid * 100
+        stats += f" | GC: {gc_content:.1f}%"
+    
+    if n_count > 0:
+        stats += f" | N's: {n_count}"
+    
+    return stats
+
+def create_interface():
+    """Create the Gradio interface"""
+    # Initialize model on startup
+    print("Initializing model...")
+    model_status = initialize_model()
+
+    # Create custom CSS for better styling
+    custom_css = """
+    .gene-app {
+        font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    }
+
+    .status-ready {
+        background: linear-gradient(135deg, #d4edda 0%, #c3e6cb 100%);
+        border: 2px solid #28a745;
+        border-radius: 10px;
+        padding: 15px;
+        color: #155724;
+        font-weight: bold;
+        box-shadow: 0 2px 10px rgba(40, 167, 69, 0.2);
+    }
 
+    .status-error {
+        background: linear-gradient(135deg, #f8d7da 0%, #f5c6cb 100%);
+        border: 2px solid #dc3545;
+        border-radius: 10px;
+        padding: 15px;
+        color: #721c24;
+        font-weight: bold;
+        box-shadow: 0 2px 10px rgba(220, 53, 69, 0.2);
+    }
+
+    .main-title {
+        text-align: center;
+        background: linear-gradient(135deg, #2E8B57 0%, #20B2AA 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        font-size: 2.5rem;
+        font-weight: bold;
+        margin-bottom: 1rem;
+    }
+
+    .instructions {
+        background: #f8f9fa;
+        border-radius: 10px;
+        padding: 20px;
+        border-left: 4px solid #2E8B57;
+        margin: 1rem 0;
+    }
+
+    .sequence-stats {
+        font-size: 0.9rem;
+        color: #6c757d;
+        font-style: italic;
+        margin-top: 5px;
+    }
+    """
+
+    print("Creating Gradio interface...")
+
+    # Determine status message and styling
+    if model_loaded:
+        status_html = '''
+        <div class="status-ready">
+            <strong>✅ Model Status:</strong> Ready for gene prediction!<br>
+            <small>🔬 Boundary-aware deep learning model loaded successfully</small>
+        </div>
+        '''
+    else:
+        status_html = f'''
+        <div class="status-error">
+            <strong>❌ Model Status:</strong> Model initialization failed<br>
+            <small>📋 Details: {error_message}</small>
+        </div>
+        '''
+
+    # Example sequences
+    examples = [
+        # Short example with clear gene
+        ["ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTAA"],
+        # Longer example
+        ["ATGAAACGCATTAGCACCACCATTACCACCACCATCACCATTACCACAGGTAACGGTGCGGGCTGACGCGTACAGGAAACACAGAAAAAAGCCCGCACCTGACAGTGCGGGCTTTTTTTTTCGACCAAAGGTAACGAGGTAACAACCATGCGAGTGTTGAAGTTCGGCGGTACATCAGTGGCAAATGCAGAACGTTTTCTGCGTGTTGCCGATATTCTGGAAAGCAATGCCAGGCAGGGGCAGGTGGCCACCGTCCTCTCTGCCCCCGCCAAAATCACCAACCACCTGGTGGCGATGATTGAAAAAACCATTAGCGGCCAGGATGCTTTACCCAATATCAGCGATGCCGAACGTATTTTTGCCGAACTTTTGACGGGACTCGCCGCCGCCCAGCCGGGGTTCCCGCTGGCGCAATTGAAAACTTTCGTCGATCAGGAATTTGCCCAATAG"],
+    ]
+
+    # Create the interface with custom theme
+    with gr.Blocks(
+        title="🧬 Gene Prediction Tool", 
+        theme=gr.themes.Soft(primary_hue="emerald", secondary_hue="teal"),
+        css=custom_css
+    ) as interface:
+        
+        gr.HTML('<h1 class="main-title">🧬 Advanced Gene Prediction Tool</h1>')
+        gr.HTML('<p style="text-align: center; font-size: 1.1rem; color: #6c757d; margin-bottom: 2rem;">AI-powered boundary-aware gene detection system</p>')
+        
+        gr.HTML(status_html)
+        
+        with gr.Row():
+            gr.HTML('''
+            <div class="instructions">
+                <h3>🔬 How to Use:</h3>
+                <ol>
+                    <li><strong>Enter DNA sequence:</strong> Paste your sequence using A, T, C, G, N characters</li>
+                    <li><strong>Click Analyze:</strong> The AI model will predict gene regions</li>
+                    <li><strong>Review results:</strong> View detected genes with positions, codons, and confidence</li>
+                </ol>
+                
+                <h4>📏 Requirements:</h4>
+                <ul>
+                    <li>Characters: Only A, T, C, G, N allowed</li>
+                    <li>Length: 3 - 10,000 nucleotides</li>
+                    <li>Format: Raw sequence (FASTA headers will be ignored)</li>
+                </ul>
+            </div>
+            ''')
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                sequence_input = gr.Textbox(
+                    label="🧬 DNA Sequence Input",
+                    placeholder="Enter or paste your DNA sequence here...\nExample: ATGAAACGCATTAGCACC...",
+                    lines=10,
+                    max_lines=20,
+                    show_copy_button=True,
+                    container=True
+                )
+                
+                # Real-time sequence stats
+                sequence_stats = gr.HTML(value="", elem_classes=["sequence-stats"])
+                
+                with gr.Row():
+                    submit_btn = gr.Button("🔬 Analyze Sequence", variant="primary", size="lg", scale=2)
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg", scale=1)
+                
+                # Example buttons
+                gr.Markdown("### 📝 Quick Examples:")
+                with gr.Row():
+                    example1_btn = gr.Button("Short Gene", variant="secondary", size="sm")
+                    example2_btn = gr.Button("Longer Sequence", variant="secondary", size="sm")
+            
+            with gr.Column(scale=2):
+                output = gr.Textbox(
+                    label="🔬 Analysis Results",
+                    lines=25,
+                    max_lines=35,
+                    show_copy_button=True,
+                    container=True,
+                    placeholder="Results will appear here after analysis..."
+                )
+        
+        # Footer
+        gr.HTML('''
+        <div style="text-align: center; margin-top: 2rem; padding: 1rem; border-top: 1px solid #dee2e6; color: #6c757d;">
+            <small>🧬 Powered by boundary-aware deep learning | Built with PyTorch & Gradio</small>
+        </div>
+        ''')
+        
+        # Event handlers
+        def update_stats(sequence):
+            return get_sequence_stats(sequence)
+        
+        # Real-time sequence stats update
+        sequence_input.change(
+            fn=update_stats,
+            inputs=sequence_input,
+            outputs=sequence_stats
+        )
+        
+        # Main prediction
+        submit_btn.click(
+            fn=predict_genes,
+            inputs=sequence_input,
+            outputs=output
+        )
+        
+        # Clear functionality
+        clear_btn.click(
+            fn=lambda: ("", "", ""),
+            outputs=[sequence_input, output, sequence_stats]
+        )
+        
+        # Example buttons
+        example1_btn.click(
+            fn=lambda: examples[0][0],
+            outputs=sequence_input
+        )
+        
+        example2_btn.click(
+            fn=lambda: examples[1][0],
+            outputs=sequence_input
+        )
+        
+        # Allow Enter key to submit
+        sequence_input.submit(
+            fn=predict_genes,
+            inputs=sequence_input,
+            outputs=output
+        )
+    
+    return interface
+
+
+# Create and launch the interface
 if __name__ == "__main__":
-    demo.launch()
+    print("🚀 Launching Gene Prediction App...")
+    
+    # Create the interface
+    demo = create_interface()
+    
+    print(f"Model loaded: {model_loaded}")
+    print(f"Open your browser to see the interface")
+    
+    # Launch with Hugging Face Spaces compatible settings
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=False,
+        show_error=True,
+        quiet=False
+    )