DNA-Diffusion

Runtime error

App Files Files Community

openfree commited on Jul 2, 2025

Commit

61c8731

verified ·

1 Parent(s): 53401a6

Update app.py

Browse files

Files changed (1) hide show

app.py +415 -394

app.py CHANGED Viewed

@@ -1,33 +1,31 @@
 """
-Fixed and Enhanced DNA-Diffusion Gradio Application
-Resolves compatibility issues and adds practical features
 """
 import gradio as gr
 import logging
 import json
 import os
-from typing import Dict, Any, Tuple, List, Optional
-import html
-import requests
 import time
 import numpy as np
-from dataclasses import dataclass
 from datetime import datetime
-import asyncio
-import threading
-from queue import Queue
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
-# Try to import spaces for GPU decoration
 try:
     import spaces
     SPACES_AVAILABLE = True
 except ImportError:
     SPACES_AVAILABLE = False
     class spaces:
         @staticmethod
         def GPU(duration=60):
@@ -35,266 +33,132 @@ except ImportError:
                 return func
             return decorator
-# Mock model for demonstration
-class MockDNAModel:
-    """Mock DNA generation model for testing"""
-    def generate(self, cell_type: str, guidance_scale: float = 1.0):
-        import random
-        bases = ['A', 'T', 'C', 'G']
-        sequence = ''.join(random.choice(bases) for _ in range(200))
-        # Simulate some realistic patterns
-        if cell_type == "K562":
-            # Add some GC-rich regions for K562
-            sequence = sequence[:50] + 'GCGCGCGC' + sequence[58:150] + 'CGCGCGCG' + sequence[158:]
-        return {
-            'sequence': sequence,
-            'metadata': {
-                'cell_type': cell_type,
-                'guidance_scale': guidance_scale,
-                'generation_time': 2.0,
-                'model_version': 'mock_v1'
-            }
-        }
-# Global model instance
-mock_model = MockDNAModel()
-# HTML template for the main interface
-HTML_TEMPLATE = """
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DNA Casino - Molecular Engineering Suite</title>
-    <style>
-        body {
-            margin: 0;
-            padding: 20px;
-            background: #0a0a0a;
-            color: #fff;
-            font-family: 'Arial', sans-serif;
-        }
-        .container {
-            max-width: 1200px;
-            margin: 0 auto;
-        }
-        .header {
-            text-align: center;
-            margin-bottom: 30px;
-        }
-        .title {
-            font-size: 3rem;
-            background: linear-gradient(45deg, #ff00ff, #00ffff);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            margin: 0;
-        }
-        .sequence-display {
-            background: #1a1a1a;
-            border: 2px solid #00ff00;
-            border-radius: 10px;
-            padding: 20px;
-            font-family: monospace;
-            word-break: break-all;
-            margin: 20px 0;
-            min-height: 100px;
-        }
-        .controls {
-            display: flex;
-            gap: 20px;
-            justify-content: center;
-            margin: 20px 0;
-        }
-        .btn {
-            padding: 15px 30px;
-            background: linear-gradient(145deg, #ff0066, #ff00ff);
-            border: none;
-            border-radius: 25px;
-            color: white;
-            font-size: 18px;
-            cursor: pointer;
-            transition: all 0.3s;
-        }
-        .btn:hover {
-            transform: translateY(-2px);
-            box-shadow: 0 5px 20px rgba(255,0,255,0.5);
-        }
-        .stats {
-            display: grid;
-            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-            gap: 20px;
-            margin: 30px 0;
-        }
-        .stat-card {
-            background: rgba(255,255,255,0.1);
-            border-radius: 10px;
-            padding: 20px;
-            text-align: center;
-        }
-        .stat-value {
-            font-size: 2rem;
-            color: #00ff00;
-        }
-        .loading {
-            display: none;
-            text-align: center;
-            margin: 20px 0;
-        }
-        .spinner {
-            border: 3px solid rgba(255,255,255,0.1);
-            border-top-color: #00ff00;
-            border-radius: 50%;
-            width: 40px;
-            height: 40px;
-            animation: spin 1s linear infinite;
-            margin: 0 auto;
-        }
-        @keyframes spin {
-            to { transform: rotate(360deg); }
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <div class="header">
-            <h1 class="title">🧬 DNA Casino 🧬</h1>
-            <p>Advanced Molecular Engineering Suite</p>
-        </div>
-        <div class="controls">
-            <select id="cellType" class="btn">
-                <option value="K562">K562</option>
-                <option value="GM12878">GM12878</option>
-                <option value="HepG2">HepG2</option>
-            </select>
-            <button class="btn" onclick="generateSequence()">Generate Sequence</button>
-        </div>
-        <div class="loading" id="loading">
-            <div class="spinner"></div>
-            <p>Generating sequence...</p>
-        </div>
-        <div class="sequence-display" id="sequenceDisplay">
-            Click "Generate Sequence" to start
-        </div>
-        <div class="stats" id="stats"></div>
-    </div>
-    <script>
-        function generateSequence() {
-            const cellType = document.getElementById('cellType').value;
-            const loading = document.getElementById('loading');
-            const display = document.getElementById('sequenceDisplay');
-            loading.style.display = 'block';
-            display.textContent = '';
-            // Send message to parent
-            window.parent.postMessage({
-                type: 'generate',
-                cellType: cellType
-            }, '*');
-        }
-        // Listen for results
-        window.addEventListener('message', (event) => {
-            if (event.data.type === 'result') {
-                const loading = document.getElementById('loading');
-                const display = document.getElementById('sequenceDisplay');
-                const stats = document.getElementById('stats');
-                loading.style.display = 'none';
-                display.textContent = event.data.sequence;
-                // Update stats
-                stats.innerHTML = `
-                    <div class="stat-card">
-                        <div class="stat-label">Length</div>
-                        <div class="stat-value">${event.data.length} bp</div>
-                    </div>
-                    <div class="stat-card">
-                        <div class="stat-label">GC Content</div>
-                        <div class="stat-value">${event.data.gc_content}%</div>
-                    </div>
-                    <div class="stat-card">
-                        <div class="stat-label">Cell Type</div>
-                        <div class="stat-value">${event.data.cell_type}</div>
-                    </div>
-                `;
-            }
-        });
-    </script>
-</body>
-</html>
-"""
-# Simplified app class
-class DNAApp:
-    """Simplified DNA application without complex UI components that cause errors"""
     def __init__(self):
         self.current_sequence = ""
         self.current_analysis = {}
-        self.chat_history = []
-    def generate_sequence(self, cell_type: str, guidance_scale: float = 1.0):
-        """Generate DNA sequence"""
         try:
-            result = mock_model.generate(cell_type, guidance_scale)
-            self.current_sequence = result['sequence']
-            # Perform analysis
-            analysis = self.analyze_sequence(self.current_sequence)
-            self.current_analysis = {
-                'sequence': self.current_sequence,
-                'cell_type': cell_type,
-                'length': len(self.current_sequence),
-                'gc_content': analysis['gc_content'],
-                'melting_temp': analysis['melting_temp'],
-                'restriction_sites': analysis['restriction_sites']
-            }
-            return self.current_sequence, json.dumps(self.current_analysis)
         except Exception as e:
-            logger.error(f"Generation error: {e}")
-            return "", json.dumps({"error": str(e)})
     def analyze_sequence(self, sequence: str) -> Dict[str, Any]:
-        """Basic sequence analysis"""
         gc_count = sequence.count('G') + sequence.count('C')
-        gc_content = (gc_count / len(sequence) * 100) if sequence else 0
-        # Simple melting temperature calculation
         if len(sequence) < 14:
             tm = 4 * (sequence.count('G') + sequence.count('C')) + 2 * (sequence.count('A') + sequence.count('T'))
         else:
             tm = 81.5 + 0.41 * gc_content - 675 / len(sequence)
         # Find restriction sites
-        sites = {}
         enzymes = {
             'EcoRI': 'GAATTC',
             'BamHI': 'GGATCC',
-            'HindIII': 'AAGCTT'
         }
         for enzyme, pattern in enzymes.items():
@@ -303,193 +167,350 @@ class DNAApp:
                 if sequence[i:i+len(pattern)] == pattern:
                     positions.append(i)
             if positions:
-                sites[enzyme] = positions
         return {
             'gc_content': round(gc_content, 1),
             'melting_temp': round(tm, 1),
-            'restriction_sites': sites
         }
-    def chat_response(self, message: str) -> str:
-        """Simple chat response"""
-        self.chat_history.append(("user", message))
-        # Simple rule-based responses
-        response = "I can help you analyze DNA sequences. "
-        if "gc" in message.lower() or "content" in message.lower():
-            if self.current_analysis:
-                response = f"The GC content of your sequence is {self.current_analysis.get('gc_content', 0)}%"
-            else:
-                response = "Please generate a sequence first to analyze GC content."
-        elif "restriction" in message.lower() or "enzyme" in message.lower():
-            if self.current_analysis:
-                sites = self.current_analysis.get('restriction_sites', {})
-                if sites:
-                    response = f"Found restriction sites for: {', '.join(sites.keys())}"
-                else:
-                    response = "No common restriction sites found in the sequence."
-            else:
-                response = "Please generate a sequence first to analyze restriction sites."
-        elif "primer" in message.lower():
-            response = "For primer design, consider: 18-25 bp length, 50-60% GC content, Tm around 55-65°C"
-        self.chat_history.append(("assistant", response))
-        return response
 # Create app instance
-app = DNAApp()
-def create_interface():
-    """Create a simplified Gradio interface that avoids the schema error"""
     # Custom CSS
     css = """
     .gradio-container {
-        background-color: #0a0a0a !important;
     }
     """
-    with gr.Blocks(css=css, title="DNA Casino") as demo:
-        gr.Markdown("# 🧬 DNA Casino - Molecular Engineering Suite")
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### Controls")
-                cell_type = gr.Dropdown(
-                    ["K562", "GM12878", "HepG2"],
-                    value="K562",
-                    label="Cell Type"
-                )
-                guidance_scale = gr.Slider(
-                    1.0, 10.0, 1.0,
-                    label="Guidance Scale"
-                )
-                generate_btn = gr.Button("🎲 Generate Sequence", variant="primary")
-                gr.Markdown("### Analysis Results")
-                analysis_output = gr.JSON(label="Analysis Data")
-            with gr.Column(scale=2):
-                # Main display using HTML component
-                main_display = gr.HTML(HTML_TEMPLATE)
-                # Sequence output (hidden, used for backend)
-                sequence_output = gr.Textbox(
-                    label="Generated Sequence",
-                    visible=False
                 )
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### AI Assistant")
-                chatbot = gr.Chatbot(height=300)
-                msg = gr.Textbox(
-                    label="Ask about your sequence",
-                    placeholder="E.g., What's the GC content? Find restriction sites."
-                )
-                clear = gr.Button("Clear Chat")
         # Event handlers
-        def generate_and_update(cell_type, guidance_scale):
-            seq, analysis = app.generate_sequence(cell_type, guidance_scale)
-            # Update the HTML display via JavaScript
-            analysis_dict = json.loads(analysis)
-            # Create JavaScript to update the embedded HTML
-            update_script = f"""
-            <script>
-                // Update the embedded iframe
-                const iframe = document.querySelector('iframe');
-                if (iframe && iframe.contentWindow) {{
-                    iframe.contentWindow.postMessage({{
-                        type: 'result',
-                        sequence: '{seq}',
-                        length: {len(seq)},
-                        gc_content: {analysis_dict.get('gc_content', 0)},
-                        cell_type: '{cell_type}'
-                    }}, '*');
-                }}
-            </script>
-            """
-            return seq, analysis, main_display.update(value=HTML_TEMPLATE + update_script)
         generate_btn.click(
-            fn=generate_and_update,
-            inputs=[cell_type, guidance_scale],
-            outputs=[sequence_output, analysis_output, main_display]
         )
-        # Chat functionality
-        def respond(message, chat_history):
-            bot_message = app.chat_response(message)
-            chat_history.append((message, bot_message))
-            return "", chat_history
-        msg.submit(respond, [msg, chatbot], [msg, chatbot])
-        clear.click(lambda: None, None, chatbot, queue=False)
-        # Add examples
-        gr.Examples(
-            examples=[
-                "What's the GC content?",
-                "Find restriction enzyme sites",
-                "How do I design primers?",
-                "What's the melting temperature?"
-            ],
-            inputs=msg
         )
     return demo
-# Error-safe launcher
-def safe_launch():
-    """Launch the app with error handling"""
-    try:
-        demo = create_interface()
-        # Detect environment
-        import os
-        if os.getenv("SPACE_ID"):
-            # Running on Hugging Face Spaces
-            demo.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=False
-            )
-        else:
-            # Local development
-            demo.launch(
-                share=True,
-                debug=True
-            )
-    except Exception as e:
-        logger.error(f"Failed to launch: {e}")
-        # Fallback to even simpler interface
-        print("Starting fallback interface...")
-        create_fallback_interface()
-def create_fallback_interface():
-    """Ultra-simple fallback interface"""
-    with gr.Blocks() as demo:
-        gr.Markdown("# DNA Sequence Generator (Fallback Mode)")
-        with gr.Row():
-            cell_type = gr.Dropdown(["K562", "GM12878", "HepG2"], value="K562")
-            generate_btn = gr.Button("Generate")
-        output = gr.Textbox(label="Generated Sequence", lines=5)
-        def simple_generate(cell_type):
-            import random
-            seq = ''.join(random.choice(['A','T','C','G']) for _ in range(200))
-            return seq
-        generate_btn.click(simple_generate, cell_type, output)
-    demo.launch()
 if __name__ == "__main__":
-    safe_launch()

 """
+DNA-Diffusion Gradio Application - Fixed for Hugging Face Spaces
+Properly implements @spaces.GPU decorator for ZeroGPU environment
 """
 import gradio as gr
 import logging
 import json
 import os
+from typing import Dict, Any, Tuple, List
 import time
+import random
 import numpy as np
 from datetime import datetime
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+# Import spaces and handle ZeroGPU
 try:
     import spaces
     SPACES_AVAILABLE = True
+    logger.info("Spaces module loaded successfully")
 except ImportError:
     SPACES_AVAILABLE = False
+    logger.warning("Spaces module not available - running without GPU")
+    # Create dummy decorator
     class spaces:
         @staticmethod
         def GPU(duration=60):
                 return func
             return decorator
+# Genetic code table
+CODON_TABLE = {
+    'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L',
+    'TCT': 'S', 'TCC': 'S', 'TCA': 'S', 'TCG': 'S',
+    'TAT': 'Y', 'TAC': 'Y', 'TAA': '*', 'TAG': '*',
+    'TGT': 'C', 'TGC': 'C', 'TGA': '*', 'TGG': 'W',
+    'CTT': 'L', 'CTC': 'L', 'CTA': 'L', 'CTG': 'L',
+    'CCT': 'P', 'CCC': 'P', 'CCA': 'P', 'CCG': 'P',
+    'CAT': 'H', 'CAC': 'H', 'CAA': 'Q', 'CAG': 'Q',
+    'CGT': 'R', 'CGC': 'R', 'CGA': 'R', 'CGG': 'R',
+    'ATT': 'I', 'ATC': 'I', 'ATA': 'I', 'ATG': 'M',
+    'ACT': 'T', 'ACC': 'T', 'ACA': 'T', 'ACG': 'T',
+    'AAT': 'N', 'AAC': 'N', 'AAA': 'K', 'AAG': 'K',
+    'AGT': 'S', 'AGC': 'S', 'AGA': 'R', 'AGG': 'R',
+    'GTT': 'V', 'GTC': 'V', 'GTA': 'V', 'GTG': 'V',
+    'GCT': 'A', 'GCC': 'A', 'GCA': 'A', 'GCG': 'A',
+    'GAT': 'D', 'GAC': 'D', 'GAA': 'E', 'GAG': 'E',
+    'GGT': 'G', 'GGC': 'G', 'GGA': 'G', 'GGG': 'G'
+}
+# Mock DNA model for demonstration
+class DNAModel:
+    """Mock DNA generation model"""
+    def generate(self, cell_type: str, num_sequences: int = 1, length: int = 200, guidance_scale: float = 1.0):
+        """Generate DNA sequences with cell-type specific patterns"""
+        sequences = []
+        for _ in range(num_sequences):
+            # Base generation
+            sequence = ''.join(random.choice(['A', 'T', 'C', 'G']) for _ in range(length))
+            # Add cell-type specific patterns
+            if cell_type == "K562":
+                # Add GC-rich regions for K562
+                for i in range(0, length-8, 50):
+                    sequence = sequence[:i] + 'GCGCGCGC' + sequence[i+8:]
+            elif cell_type == "GM12878":
+                # Add AT-rich regions for GM12878
+                for i in range(10, length-8, 60):
+                    sequence = sequence[:i] + 'ATATATAT' + sequence[i+8:]
+            elif cell_type == "HepG2":
+                # Add mixed patterns for HepG2
+                for i in range(20, length-12, 70):
+                    sequence = sequence[:i] + 'GCGATCGATCGC' + sequence[i+12:]
+            sequences.append(sequence)
+        return sequences[0] if num_sequences == 1 else sequences
+# Initialize model
+model = DNAModel()
+# Main application class
+class DNADiffusionApp:
+    """Main application with GPU-accelerated functions"""
     def __init__(self):
         self.current_sequence = ""
         self.current_analysis = {}
+        self.generation_count = 0
+    @spaces.GPU(duration=60)
+    def generate_with_gpu(self, cell_type: str, guidance_scale: float = 1.0, use_enhanced: bool = True):
+        """GPU-accelerated sequence generation"""
+        logger.info(f"Generating sequence on GPU for cell type: {cell_type}")
         try:
+            # Simulate GPU computation time
+            time.sleep(2)  # Simulated GPU processing
+            # Generate sequence
+            sequence = model.generate(cell_type, length=200, guidance_scale=guidance_scale)
+            # If enhanced mode, do additional processing
+            if use_enhanced:
+                sequence = self.enhance_sequence(sequence, cell_type)
+            self.generation_count += 1
+            logger.info(f"Successfully generated sequence #{self.generation_count}")
+            return sequence
         except Exception as e:
+            logger.error(f"GPU generation failed: {e}")
+            raise
+    def enhance_sequence(self, sequence: str, cell_type: str) -> str:
+        """Enhance sequence with additional patterns"""
+        # Add enhancer sequences based on cell type
+        enhancers = {
+            "K562": "GGGACTTTCC",  # NF-κB binding site
+            "GM12878": "TGACGTCA",   # CREB binding site
+            "HepG2": "TGTTGGTGG"     # HNF4 binding site
+        }
+        if cell_type in enhancers:
+            # Insert enhancer at a reasonable position
+            pos = len(sequence) // 4
+            enhancer = enhancers[cell_type]
+            sequence = sequence[:pos] + enhancer + sequence[pos+len(enhancer):]
+        return sequence
     def analyze_sequence(self, sequence: str) -> Dict[str, Any]:
+        """Analyze DNA sequence properties"""
+        if not sequence:
+            return {}
+        # GC content
         gc_count = sequence.count('G') + sequence.count('C')
+        gc_content = (gc_count / len(sequence)) * 100
+        # Melting temperature
         if len(sequence) < 14:
             tm = 4 * (sequence.count('G') + sequence.count('C')) + 2 * (sequence.count('A') + sequence.count('T'))
         else:
             tm = 81.5 + 0.41 * gc_content - 675 / len(sequence)
         # Find restriction sites
+        restriction_sites = {}
         enzymes = {
             'EcoRI': 'GAATTC',
             'BamHI': 'GGATCC',
+            'HindIII': 'AAGCTT',
+            'PstI': 'CTGCAG',
+            'XbaI': 'TCTAGA'
         }
         for enzyme, pattern in enzymes.items():
                 if sequence[i:i+len(pattern)] == pattern:
                     positions.append(i)
             if positions:
+                restriction_sites[enzyme] = positions
+        # Translate to protein
+        protein = self.translate_to_protein(sequence)
         return {
+            'length': len(sequence),
             'gc_content': round(gc_content, 1),
             'melting_temp': round(tm, 1),
+            'restriction_sites': restriction_sites,
+            'protein_length': len(protein),
+            'protein_sequence': protein[:50] + '...' if len(protein) > 50 else protein
         }
+    def translate_to_protein(self, dna_sequence: str) -> str:
+        """Translate DNA to protein sequence"""
+        protein = []
+        # Find start codon
+        start_pos = dna_sequence.find('ATG')
+        if start_pos == -1:
+            start_pos = 0
+        # Translate from start position
+        for i in range(start_pos, len(dna_sequence) - 2, 3):
+            codon = dna_sequence[i:i+3]
+            if len(codon) == 3:
+                amino_acid = CODON_TABLE.get(codon, 'X')
+                if amino_acid == '*':  # Stop codon
+                    break
+                protein.append(amino_acid)
+        return ''.join(protein)
+    @spaces.GPU(duration=30)
+    def batch_generate(self, cell_types: List[str], count: int = 5):
+        """Generate multiple sequences with GPU acceleration"""
+        logger.info(f"Batch generating {count} sequences")
+        results = []
+        for i in range(count):
+            cell_type = cell_types[i % len(cell_types)]
+            sequence = model.generate(cell_type)
+            analysis = self.analyze_sequence(sequence)
+            results.append({
+                'id': f'SEQ_{i+1:03d}',
+                'cell_type': cell_type,
+                'sequence': sequence,
+                'analysis': analysis
+            })
+        return results
 # Create app instance
+app = DNADiffusionApp()
+# Create the Gradio interface
+def create_demo():
+    """Create the Gradio interface"""
     # Custom CSS
     css = """
     .gradio-container {
+        font-family: 'Arial', sans-serif;
+    }
+    .sequence-box {
+        font-family: 'Courier New', monospace;
+        background-color: #f0f0f0;
+        padding: 10px;
+        border-radius: 5px;
     }
     """
+    with gr.Blocks(css=css, title="DNA-Diffusion") as demo:
+        # Header
+        gr.Markdown(
+            """
+            # 🧬 DNA-Diffusion: AI-Powered Sequence Generation
+            Generate cell-type specific DNA sequences using advanced AI models.
+            This app uses GPU acceleration for optimal performance.
+            """
+        )
+        # GPU status indicator
+        gpu_status = gr.Markdown(
+            f"🖥️ **GPU Status**: {'✅ Available' if SPACES_AVAILABLE else '❌ Not Available (CPU mode)'}"
+        )
+        with gr.Tabs():
+            # Tab 1: Single Sequence Generation
+            with gr.TabItem("🎯 Single Generation"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        cell_type = gr.Dropdown(
+                            choices=["K562", "GM12878", "HepG2"],
+                            value="K562",
+                            label="Cell Type",
+                            info="Select the cell type for sequence generation"
+                        )
+                        guidance_scale = gr.Slider(
+                            minimum=1.0,
+                            maximum=10.0,
+                            value=1.0,
+                            step=0.5,
+                            label="Guidance Scale",
+                            info="Higher values create more cell-type specific patterns"
+                        )
+                        enhanced_mode = gr.Checkbox(
+                            value=True,
+                            label="Enhanced Mode",
+                            info="Add cell-type specific enhancer sequences"
+                        )
+                        generate_btn = gr.Button(
+                            "🚀 Generate Sequence",
+                            variant="primary",
+                            size="lg"
+                        )
+                    with gr.Column(scale=2):
+                        sequence_output = gr.Textbox(
+                            label="Generated DNA Sequence",
+                            lines=5,
+                            max_lines=10,
+                            elem_classes="sequence-box"
+                        )
+                        analysis_output = gr.JSON(
+                            label="Sequence Analysis"
+                        )
+                # Examples
+                gr.Examples(
+                    examples=[
+                        ["K562", 1.0, True],
+                        ["GM12878", 5.0, True],
+                        ["HepG2", 3.0, False]
+                    ],
+                    inputs=[cell_type, guidance_scale, enhanced_mode]
+                )
+            # Tab 2: Batch Generation
+            with gr.TabItem("📦 Batch Generation"):
+                with gr.Row():
+                    with gr.Column():
+                        batch_cell_types = gr.CheckboxGroup(
+                            choices=["K562", "GM12878", "HepG2"],
+                            value=["K562", "GM12878"],
+                            label="Cell Types for Batch"
+                        )
+                        batch_count = gr.Slider(
+                            minimum=1,
+                            maximum=10,
+                            value=5,
+                            step=1,
+                            label="Number of Sequences"
+                        )
+                        batch_generate_btn = gr.Button(
+                            "🚀 Generate Batch",
+                            variant="primary"
+                        )
+                    with gr.Column():
+                        batch_output = gr.Dataframe(
+                            headers=["ID", "Cell Type", "Length", "GC%", "Tm(°C)"],
+                            label="Batch Results"
+                        )
+                        download_btn = gr.Button("💾 Download Results")
+            # Tab 3: Analysis Tools
+            with gr.TabItem("🔬 Analysis Tools"):
+                gr.Markdown("### Paste or generate a sequence to analyze")
+                analysis_input = gr.Textbox(
+                    label="DNA Sequence",
+                    placeholder="Paste your DNA sequence here...",
+                    lines=3
                 )
+                analyze_btn = gr.Button("🔍 Analyze")
+                with gr.Row():
+                    gc_plot = gr.Plot(label="GC Content Distribution")
+                    restriction_plot = gr.Plot(label="Restriction Sites")
+                detailed_analysis = gr.JSON(label="Detailed Analysis")
+        # Status bar
+        status_text = gr.Textbox(
+            label="Status",
+            value="Ready to generate sequences...",
+            interactive=False
+        )
         # Event handlers
+        def generate_single(cell_type, guidance_scale, enhanced):
+            """Handle single sequence generation"""
+            try:
+                status_text.value = "🔄 Generating sequence on GPU..."
+                # Generate sequence using GPU
+                sequence = app.generate_with_gpu(cell_type, guidance_scale, enhanced)
+                # Analyze the sequence
+                analysis = app.analyze_sequence(sequence)
+                status_text.value = f"✅ Successfully generated sequence for {cell_type}"
+                return sequence, analysis, status_text.value
+            except Exception as e:
+                error_msg = f"❌ Error: {str(e)}"
+                logger.error(error_msg)
+                return "", {}, error_msg
+        def generate_batch(cell_types, count):
+            """Handle batch generation"""
+            if not cell_types:
+                return None, "❌ Please select at least one cell type"
+            try:
+                status_text.value = "🔄 Generating batch on GPU..."
+                # Generate batch
+                results = app.batch_generate(cell_types, count)
+                # Format for dataframe
+                df_data = []
+                for r in results:
+                    df_data.append([
+                        r['id'],
+                        r['cell_type'],
+                        r['analysis']['length'],
+                        r['analysis']['gc_content'],
+                        r['analysis']['melting_temp']
+                    ])
+                status_text.value = f"✅ Generated {len(results)} sequences"
+                return df_data, status_text.value
+            except Exception as e:
+                error_msg = f"❌ Error: {str(e)}"
+                logger.error(error_msg)
+                return None, error_msg
+        def analyze_sequence(sequence):
+            """Analyze a given sequence"""
+            if not sequence:
+                return None, None, {}
+            analysis = app.analyze_sequence(sequence.upper())
+            # Create GC content plot
+            import matplotlib.pyplot as plt
+            fig1, ax1 = plt.subplots(figsize=(6, 4))
+            gc = analysis['gc_content']
+            at = 100 - gc
+            ax1.bar(['GC%', 'AT%'], [gc, at], color=['#4CAF50', '#2196F3'])
+            ax1.set_ylabel('Percentage')
+            ax1.set_title('Nucleotide Composition')
+            # Create restriction site plot
+            fig2, ax2 = plt.subplots(figsize=(8, 3))
+            if analysis['restriction_sites']:
+                y_pos = 0
+                colors = plt.cm.tab10(range(len(analysis['restriction_sites'])))
+                for (enzyme, positions), color in zip(analysis['restriction_sites'].items(), colors):
+                    for pos in positions:
+                        ax2.vlines(pos, y_pos - 0.4, y_pos + 0.4, color=color, linewidth=3)
+                    ax2.text(-10, y_pos, enzyme, ha='right', va='center')
+                    y_pos += 1
+                ax2.set_xlim(-50, len(sequence))
+                ax2.set_ylim(-0.5, len(analysis['restriction_sites']) - 0.5)
+                ax2.set_xlabel('Position (bp)')
+                ax2.set_title('Restriction Enzyme Sites')
+                ax2.grid(axis='x', alpha=0.3)
+            else:
+                ax2.text(0.5, 0.5, 'No restriction sites found',
+                        ha='center', va='center', transform=ax2.transAxes)
+            return fig1, fig2, analysis
+        # Connect event handlers
         generate_btn.click(
+            fn=generate_single,
+            inputs=[cell_type, guidance_scale, enhanced_mode],
+            outputs=[sequence_output, analysis_output, status_text]
         )
+        batch_generate_btn.click(
+            fn=generate_batch,
+            inputs=[batch_cell_types, batch_count],
+            outputs=[batch_output, status_text]
+        )
+        analyze_btn.click(
+            fn=analyze_sequence,
+            inputs=[analysis_input],
+            outputs=[gc_plot, restriction_plot, detailed_analysis]
+        )
+        # Auto-analyze generated sequences
+        sequence_output.change(
+            fn=lambda seq: app.analyze_sequence(seq) if seq else {},
+            inputs=[sequence_output],
+            outputs=[analysis_output]
         )
     return demo
+# Main launch function
 if __name__ == "__main__":
+    # Print startup info
+    logger.info("=" * 50)
+    logger.info("DNA-Diffusion App Starting...")
+    logger.info(f"GPU Available: {SPACES_AVAILABLE}")
+    logger.info(f"Environment: {'Hugging Face Spaces' if os.getenv('SPACE_ID') else 'Local'}")
+    logger.info("=" * 50)
+    # Create and launch the demo
+    demo = create_demo()
+    # Launch with appropriate settings
+    if os.getenv("SPACE_ID"):
+        # Running on Hugging Face Spaces
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,  # Don't set share=True on Spaces
+            show_error=True
+        )
+    else:
+        # Local development
+        demo.launch(
+            share=True,
+            show_error=True,
+            debug=True
+        )