Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-DNA-Diffusion Gradio Application - Fixed for Hugging Face Spaces
-Properly implements @spaces.GPU decorator for ZeroGPU environment
+DNA-Diffusion Gradio Application with Integrated 3D Viewer
+Combines Gradio interface with HTML-based 3D molecular visualization
 """
 
 import gradio as gr
@@ -33,7 +33,7 @@ except ImportError:
                 return func
             return decorator
 
-# Genetic code table
+# DNA Model and genetic code table (same as before)
 CODON_TABLE = {
     'TTT': 'F', 'TTC': 'F', 'TTA': 'L', 'TTG': 'L',
     'TCT': 'S', 'TCC': 'S', 'TCA': 'S', 'TCG': 'S',
@@ -53,28 +53,21 @@ CODON_TABLE = {
     '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:]
             
@@ -82,13 +75,9 @@ class DNAModel:
         
         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 = {}
@@ -96,17 +85,12 @@ class DNADiffusionApp:
         
     @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
+            time.sleep(2)
             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)
             
@@ -120,16 +104,13 @@ class DNADiffusionApp:
             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
+            "K562": "GGGACTTTCC",
+            "GM12878": "TGACGTCA",
+            "HepG2": "TGTTGGTGG"
         }
         
         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):]
@@ -137,21 +118,17 @@ class DNADiffusionApp:
         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',
@@ -169,7 +146,6 @@ class DNADiffusionApp:
             if positions:
                 restriction_sites[enzyme] = positions
         
-        # Translate to protein
         protein = self.translate_to_protein(sequence)
         
         return {
@@ -182,53 +158,311 @@ class DNADiffusionApp:
         }
     
     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
+                if amino_acid == '*':
                     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")
+
+app = DNADiffusionApp()
+
+# HTML for 3D Viewer
+HTML_3D_VIEWER = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+            background: #000;
+            font-family: Arial, sans-serif;
+            color: #fff;
+            height: 100vh;
+            overflow: hidden;
+        }
+        #viewer-container {
+            width: 100%;
+            height: 100%;
+            position: relative;
+        }
+        #canvas3d {
+            width: 100%;
+            height: 100%;
+        }
+        .controls-panel {
+            position: absolute;
+            top: 20px;
+            right: 20px;
+            background: rgba(0,0,0,0.8);
+            padding: 20px;
+            border-radius: 10px;
+            border: 2px solid #00ff88;
+            max-width: 300px;
+        }
+        .controls-panel h3 {
+            color: #00ff88;
+            margin-top: 0;
+        }
+        .control-btn {
+            background: #00ff88;
+            color: #000;
+            border: none;
+            padding: 8px 16px;
+            margin: 5px;
+            border-radius: 5px;
+            cursor: pointer;
+            font-weight: bold;
+        }
+        .control-btn:hover {
+            background: #00cc66;
+        }
+        .info-display {
+            position: absolute;
+            bottom: 20px;
+            left: 20px;
+            background: rgba(0,0,0,0.8);
+            padding: 15px;
+            border-radius: 8px;
+            border: 1px solid #0088ff;
+        }
+        #sequence-display {
+            font-family: monospace;
+            color: #00ff88;
+            word-break: break-all;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+<body>
+    <div id="viewer-container">
+        <canvas id="canvas3d"></canvas>
         
-        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
-            })
+        <div class="controls-panel">
+            <h3>3D View Controls</h3>
+            <button class="control-btn" onclick="setViewMode('cartoon')">Cartoon</button>
+            <button class="control-btn" onclick="setViewMode('stick')">Stick</button>
+            <button class="control-btn" onclick="setViewMode('sphere')">Sphere</button>
+            <button class="control-btn" onclick="toggleRotation()">Toggle Rotation</button>
+            <button class="control-btn" onclick="resetView()">Reset View</button>
+        </div>
         
-        return results
+        <div class="info-display">
+            <strong>Current Sequence:</strong>
+            <div id="sequence-display">No sequence loaded</div>
+        </div>
+    </div>
 
-# Create app instance
-app = DNADiffusionApp()
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script>
+        let scene, camera, renderer;
+        let moleculeGroup;
+        let currentSequence = '';
+        let autoRotate = true;
+        let viewMode = 'cartoon';
+
+        function init() {
+            scene = new THREE.Scene();
+            scene.background = new THREE.Color(0x000000);
+            
+            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+            camera.position.z = 50;
+            
+            renderer = new THREE.WebGLRenderer({ canvas: document.getElementById('canvas3d'), antialias: true });
+            renderer.setSize(window.innerWidth, window.innerHeight);
+            
+            const ambientLight = new THREE.AmbientLight(0x404040, 1.5);
+            scene.add(ambientLight);
+            
+            const directionalLight = new THREE.DirectionalLight(0xffffff, 1);
+            directionalLight.position.set(50, 50, 50);
+            scene.add(directionalLight);
+            
+            moleculeGroup = new THREE.Group();
+            scene.add(moleculeGroup);
+            
+            animate();
+            
+            // Listen for sequence updates from parent
+            window.addEventListener('message', function(e) {
+                if (e.data.type === 'updateSequence') {
+                    updateSequence(e.data.sequence);
+                }
+            });
+        }
+
+        function updateSequence(sequence) {
+            currentSequence = sequence;
+            document.getElementById('sequence-display').textContent = sequence;
+            generateDNAStructure(sequence);
+        }
+
+        function generateDNAStructure(sequence) {
+            moleculeGroup.clear();
+            
+            const radius = 10;
+            const rise = 3.4;
+            const basesPerTurn = 10;
+            const anglePerBase = (2 * Math.PI) / basesPerTurn;
+
+            // Create double helix
+            const curve1Points = [];
+            const curve2Points = [];
+            
+            for (let i = 0; i < sequence.length; i++) {
+                const angle = i * anglePerBase;
+                const height = i * rise / basesPerTurn;
+                
+                curve1Points.push(new THREE.Vector3(
+                    radius * Math.cos(angle),
+                    height,
+                    radius * Math.sin(angle)
+                ));
+                
+                curve2Points.push(new THREE.Vector3(
+                    radius * Math.cos(angle + Math.PI),
+                    height,
+                    radius * Math.sin(angle + Math.PI)
+                ));
+            }
+            
+            // Create backbone curves
+            const curve1 = new THREE.CatmullRomCurve3(curve1Points);
+            const curve2 = new THREE.CatmullRomCurve3(curve2Points);
+            
+            const tubeGeometry1 = new THREE.TubeGeometry(curve1, 100, 0.5, 8, false);
+            const tubeGeometry2 = new THREE.TubeGeometry(curve2, 100, 0.5, 8, false);
+            
+            const material1 = new THREE.MeshPhongMaterial({ color: 0xff0000 });
+            const material2 = new THREE.MeshPhongMaterial({ color: 0x0000ff });
+            
+            moleculeGroup.add(new THREE.Mesh(tubeGeometry1, material1));
+            moleculeGroup.add(new THREE.Mesh(tubeGeometry2, material2));
+            
+            // Add base pairs
+            for (let i = 0; i < Math.min(sequence.length, 50); i++) {
+                const p1 = curve1Points[i];
+                const p2 = curve2Points[i];
+                
+                const direction = new THREE.Vector3().subVectors(p2, p1);
+                const distance = direction.length();
+                direction.normalize();
+                
+                const geometry = new THREE.CylinderGeometry(0.3, 0.3, distance, 8);
+                const material = new THREE.MeshPhongMaterial({ 
+                    color: getBaseColor(sequence[i])
+                });
+                
+                const cylinder = new THREE.Mesh(geometry, material);
+                cylinder.position.copy(p1).add(direction.multiplyScalar(distance / 2));
+                cylinder.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction);
+                
+                moleculeGroup.add(cylinder);
+            }
+            
+            // Center the molecule
+            const box = new THREE.Box3().setFromObject(moleculeGroup);
+            const center = box.getCenter(new THREE.Vector3());
+            moleculeGroup.position.sub(center);
+        }
+
+        function getBaseColor(base) {
+            const colors = {
+                'A': 0xff0000,
+                'T': 0x00ff00,
+                'G': 0x0000ff,
+                'C': 0xffff00
+            };
+            return colors[base] || 0xffffff;
+        }
+
+        function setViewMode(mode) {
+            viewMode = mode;
+            if (currentSequence) {
+                generateDNAStructure(currentSequence);
+            }
+        }
+
+        function toggleRotation() {
+            autoRotate = !autoRotate;
+        }
+
+        function resetView() {
+            camera.position.set(0, 0, 50);
+            moleculeGroup.rotation.set(0, 0, 0);
+        }
+
+        function animate() {
+            requestAnimationFrame(animate);
+            
+            if (autoRotate) {
+                moleculeGroup.rotation.y += 0.01;
+            }
+            
+            renderer.render(scene, camera);
+        }
+
+        // Mouse controls
+        let isDragging = false;
+        let previousMousePosition = { x: 0, y: 0 };
+
+        document.addEventListener('mousedown', function(e) {
+            isDragging = true;
+        });
+
+        document.addEventListener('mouseup', function(e) {
+            isDragging = false;
+        });
+
+        document.addEventListener('mousemove', function(e) {
+            if (isDragging) {
+                const deltaMove = {
+                    x: e.clientX - previousMousePosition.x,
+                    y: e.clientY - previousMousePosition.y
+                };
+
+                moleculeGroup.rotation.y += deltaMove.x * 0.01;
+                moleculeGroup.rotation.x += deltaMove.y * 0.01;
+            }
+
+            previousMousePosition = {
+                x: e.clientX,
+                y: e.clientY
+            };
+        });
+
+        document.addEventListener('wheel', function(e) {
+            camera.position.z += e.deltaY * 0.1;
+            camera.position.z = Math.max(10, Math.min(200, camera.position.z));
+        });
+
+        window.addEventListener('resize', function() {
+            camera.aspect = window.innerWidth / window.innerHeight;
+            camera.updateProjectionMatrix();
+            renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+
+        // Initialize
+        init();
+    </script>
+</body>
+</html>
+"""
 
-# Create the Gradio interface
 def create_demo():
-    """Create the Gradio interface"""
+    """Create the Gradio interface with integrated 3D viewer"""
     
-    # Custom CSS
     css = """
     .gradio-container {
         font-family: 'Arial', sans-serif;
@@ -239,27 +473,28 @@ def create_demo():
         padding: 10px;
         border-radius: 5px;
     }
+    iframe {
+        border: none;
+        border-radius: 10px;
+    }
     """
     
-    with gr.Blocks(css=css, title="DNA-Diffusion") as demo:
-        # Header
+    with gr.Blocks(css=css, title="DNA-Diffusion with 3D Viewer") as demo:
         gr.Markdown(
             """
-            # 🧬 DNA-Diffusion: AI-Powered Sequence Generation
+            # 🧬 DNA-Diffusion: AI-Powered Sequence Generation with 3D Visualization
             
-            Generate cell-type specific DNA sequences using advanced AI models.
-            This app uses GPU acceleration for optimal performance.
+            Generate cell-type specific DNA sequences and visualize them in 3D!
             """
         )
         
-        # 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"):
+            # Tab 1: Sequence Generation
+            with gr.TabItem("🎯 Generate Sequence"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         cell_type = gr.Dropdown(
@@ -301,18 +536,27 @@ def create_demo():
                         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
+            # Tab 2: 3D Visualization
+            with gr.TabItem("🔬 3D Structure"):
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("### 3D DNA Structure Visualization")
+                        gr.Markdown("The 3D viewer shows the double helix structure of your generated DNA sequence.")
+                        
+                        # HTML component for 3D viewer
+                        viewer_html = gr.HTML(
+                            value=f'<iframe src="data:text/html;charset=utf-8,{HTML_3D_VIEWER.replace("#", "%23")}" width="100%" height="600px"></iframe>',
+                            label="3D Molecular Viewer"
+                        )
+                        
+                        # Button to update 3D view
+                        update_3d_btn = gr.Button(
+                            "🔄 Update 3D View with Current Sequence",
+                            variant="secondary"
+                        )
+            
+            # Tab 3: Batch Generation
             with gr.TabItem("📦 Batch Generation"):
                 with gr.Row():
                     with gr.Column():
@@ -340,28 +584,7 @@ def create_demo():
                             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...",
@@ -370,14 +593,10 @@ def create_demo():
         
         # 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}"
@@ -388,76 +607,49 @@ def create_demo():
                 logger.error(error_msg)
                 return "", {}, error_msg
         
+        def update_3d_viewer(sequence):
+            if not sequence:
+                return gr.HTML.update()
+            
+            # Create HTML with embedded sequence data
+            html_with_sequence = HTML_3D_VIEWER.replace(
+                "window.addEventListener('message'",
+                f"updateSequence('{sequence}');\n        window.addEventListener('message'"
+            )
+            
+            return gr.HTML.update(
+                value=f'<iframe src="data:text/html;charset=utf-8,{html_with_sequence.replace("#", "%23")}" width="100%" height="600px"></iframe>'
+            )
+        
         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']
+                results = []
+                for i in range(count):
+                    cell_type = cell_types[i % len(cell_types)]
+                    sequence = app.generate_with_gpu(cell_type)
+                    analysis = app.analyze_sequence(sequence)
+                    
+                    results.append([
+                        f'SEQ_{i+1:03d}',
+                        cell_type,
+                        analysis['length'],
+                        analysis['gc_content'],
+                        analysis['melting_temp']
                     ])
                 
                 status_text.value = f"✅ Generated {len(results)} sequences"
-                return df_data, status_text.value
+                return results, 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,
@@ -465,50 +657,44 @@ def create_demo():
             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]
+        update_3d_btn.click(
+            fn=update_3d_viewer,
+            inputs=[sequence_output],
+            outputs=[viewer_html]
         )
         
-        # Auto-analyze generated sequences
+        # Auto-update 3D viewer when sequence is generated
         sequence_output.change(
-            fn=lambda seq: app.analyze_sequence(seq) if seq else {},
+            fn=update_3d_viewer,
             inputs=[sequence_output],
-            outputs=[analysis_output]
+            outputs=[viewer_html]
+        )
+        
+        batch_generate_btn.click(
+            fn=generate_batch,
+            inputs=[batch_cell_types, batch_count],
+            outputs=[batch_output, status_text]
         )
     
     return demo
 
-# Main launch function
 if __name__ == "__main__":
-    # Print startup info
     logger.info("=" * 50)
-    logger.info("DNA-Diffusion App Starting...")
+    logger.info("DNA-Diffusion App with 3D Viewer 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
+            share=False,
             show_error=True
         )
     else:
-        # Local development
         demo.launch(
             share=True,
             show_error=True,