Update app.py

app.py

@@ -1,381 +1,400 @@
-import asyncio
-import websockets
 import gradio as gr
 import torch
-from transformers import (
-    BlipProcessor, BlipForConditionalGeneration,
-    TrOCRProcessor, VisionEncoderDecoderModel,
-    AutoProcessor, AutoModelForCausalLM
-)
+from transformers import BlipProcessor, BlipForConditionalGeneration
 from PIL import Image
-import easyocr
-import matplotlib.pyplot as plt
-import pandas as pd
 import numpy as np
-import cv2
 import io
-import base64
 import requests
 import warnings
 
-# Suppress warnings
 warnings.filterwarnings("ignore")
 
 class ChartAnalyzer:
     def __init__(self):
-        # Load models
-        self.load_models()
+        print("🚀 Initializing Chart Analyzer with BLIP...")
+        self.load_blip_model()
         
-    def load_models(self):
-        """Load all required models"""
+    def load_blip_model(self):
+        """Load BLIP model for image understanding"""
         try:
-            print("Loading BLIP model...")
-            # BLIP for image captioning and understanding
+            print("📦 Loading BLIP model...")
             self.blip_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
             self.blip_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
-            
-            print("Loading TrOCR model...")
-            # TrOCR for text extraction
-            self.trocr_processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-printed")
-            self.trocr_model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-printed")
-            
-            print("Loading EasyOCR...")
-            # EasyOCR for backup text extraction
-            self.ocr_reader = easyocr.Reader(['en'], gpu=False)  # Force CPU to avoid GPU issues
-            
-            # Florence-2 for advanced understanding (optional)
-            try:
-                print("Attempting to load Florence-2...")
-                self.florence_processor = AutoProcessor.from_pretrained("microsoft/Florence-2-base", trust_remote_code=True)
-                self.florence_model = AutoModelForCausalLM.from_pretrained("microsoft/Florence-2-base", trust_remote_code=True)
-                self.florence_available = True
-                print("Florence-2 loaded successfully!")
-            except Exception as e:
-                print(f"Florence-2 not available: {e}")
-                self.florence_available = False
-            
-            print("All models loaded successfully!")
-                
+            print("✅ BLIP model loaded successfully!")
         except Exception as e:
-            print(f"Error loading models: {e}")
+            print(f"❌ Error loading BLIP model: {e}")
             raise e
     
-    def analyze_chart(self, image, analysis_type="comprehensive"):
-        """Main function to analyze charts"""
+    def analyze_chart(self, image, analysis_type="detailed"):
+        """Analyze chart using BLIP"""
         if image is None:
-            return "Please upload an image first."
-        
-        results = {}
+            return "❌ Please upload an image first."
         
         try:
-            # Convert to PIL Image if needed
+            # Ensure PIL Image format
             if not isinstance(image, Image.Image):
-                image = Image.fromarray(image).convert('RGB')
-            
-            # Basic image understanding with BLIP
-            results['description'] = self.get_image_description(image)
-            
-            # Extract text using multiple methods
-            results['extracted_text'] = self.extract_text_multi_method(image)
+                if isinstance(image, np.ndarray):
+                    image = Image.fromarray(image)
+                image = image.convert('RGB')
             
-            # Chart type detection
-            results['chart_type'] = self.detect_chart_type(image, results['description'])
+            print(f"🔍 Analyzing image: {image.size} pixels")
             
-            # Data extraction (if possible)
-            if analysis_type in ["comprehensive", "data_extraction"]:
-                results['data_points'] = self.extract_data_points(image, results['chart_type'])
+            # Get comprehensive analysis
+            basic_caption = self.get_basic_caption(image)
+            detailed_analysis = self.get_detailed_analysis(image)
+            chart_type = self.detect_chart_type(basic_caption + " " + detailed_analysis)
+            insights = self.generate_insights(basic_caption, detailed_analysis, chart_type)
             
-            # Advanced analysis with Florence-2 (if available)
-            if self.florence_available and analysis_type == "comprehensive":
-                results['advanced_analysis'] = self.florence_analysis(image)
-            
-            return self.format_results(results)
+            # Format results based on analysis type
+            if analysis_type == "basic":
+                return self.format_basic_results(basic_caption, chart_type)
+            elif analysis_type == "detailed":
+                return self.format_detailed_results(basic_caption, detailed_analysis, chart_type, insights, image)
+            else:  # comprehensive
+                return self.format_comprehensive_results(basic_caption, detailed_analysis, chart_type, insights, image)
             
         except Exception as e:
-            return f"Error analyzing chart: {str(e)}"
+            return f"❌ Error analyzing chart: {str(e)}"
     
-    def get_image_description(self, image):
-        """Get image description using BLIP"""
+    def get_basic_caption(self, image):
+        """Get basic image caption"""
         try:
             inputs = self.blip_processor(image, return_tensors="pt")
-            out = self.blip_model.generate(**inputs, max_length=100)
-            description = self.blip_processor.decode(out[0], skip_special_tokens=True)
-            return description
-        except:
-            return "Unable to generate description"
+            out = self.blip_model.generate(**inputs, max_length=50)
+            caption = self.blip_processor.decode(out[0], skip_special_tokens=True)
+            return caption
+        except Exception as e:
+            return f"Caption generation failed: {str(e)}"
     
-    def extract_text_multi_method(self, image):
-        """Extract text using multiple OCR methods"""
-        extracted_texts = {}
+    def get_detailed_analysis(self, image):
+        """Get detailed analysis using question-based prompting"""
+        questions = [
+            "What type of chart or graph is shown in this image?",
+            "What are the main elements visible in this chart?",
+            "What data or information does this visualization show?"
+        ]
         
-        # Method 1: TrOCR
-        try:
-            pixel_values = self.trocr_processor(image, return_tensors="pt").pixel_values
-            generated_ids = self.trocr_model.generate(pixel_values)
-            trocr_text = self.trocr_processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-            extracted_texts['TrOCR'] = trocr_text
-        except:
-            extracted_texts['TrOCR'] = "Failed"
-        
-        # Method 2: EasyOCR
-        try:
-            # Convert PIL to numpy array
-            image_np = np.array(image)
-            ocr_results = self.ocr_reader.readtext(image_np)
-            easyocr_text = ' '.join([result[1] for result in ocr_results])
-            extracted_texts['EasyOCR'] = easyocr_text
-        except:
-            extracted_texts['EasyOCR'] = "Failed"
+        analyses = []
+        for question in questions:
+            try:
+                inputs = self.blip_processor(image, question, return_tensors="pt")
+                out = self.blip_model.generate(**inputs, max_length=100, do_sample=True, top_k=50)
+                analysis = self.blip_processor.decode(out[0], skip_special_tokens=True)
+                # Remove the question from the response
+                analysis = analysis.replace(question, "").strip()
+                if analysis:
+                    analyses.append(analysis)
+            except:
+                continue
         
-        return extracted_texts
+        return " | ".join(analyses[:2]) if analyses else "Unable to generate detailed analysis"
     
-    def detect_chart_type(self, image, description):
-        """Detect chart type based on image analysis"""
-        description_lower = description.lower()
+    def detect_chart_type(self, text):
+        """Detect chart type from text analysis"""
+        text_lower = text.lower()
         
-        chart_keywords = {
-            'bar_chart': ['bar', 'column', 'histogram'],
-            'line_chart': ['line', 'trend', 'time series'],
-            'pie_chart': ['pie', 'circular', 'slice'],
-            'scatter_plot': ['scatter', 'correlation', 'points'],
-            'area_chart': ['area', 'filled'],
-            'box_plot': ['box', 'whisker'],
-            'heatmap': ['heat', 'color coded', 'matrix']
+        chart_types = {
+            '📊 Bar Chart': ['bar', 'bars', 'column', 'columns', 'histogram'],
+            '📈 Line Chart': ['line', 'lines', 'trend', 'time series', 'linear', 'curve'],
+            '🥧 Pie Chart': ['pie', 'circular', 'slice', 'slices', 'donut', 'wheel'],
+            '📉 Scatter Plot': ['scatter', 'points', 'dots', 'correlation', 'plotted'],
+            '📋 Table/Data': ['table', 'data', 'rows', 'columns', 'grid'],
+            '🔄 Flowchart': ['flow', 'diagram', 'process', 'boxes', 'flowchart'],
+            '📊 Area Chart': ['area', 'filled', 'shaded region'],
+            '📦 Box Plot': ['box', 'whisker', 'quartile'],
+            '🌡️ Heatmap': ['heat', 'color coded', 'matrix', 'intensity']
         }
         
-        for chart_type, keywords in chart_keywords.items():
-            if any(keyword in description_lower for keyword in keywords):
-                return chart_type.replace('_', ' ').title()
+        for chart_type, keywords in chart_types.items():
+            if any(keyword in text_lower for keyword in keywords):
+                return chart_type
         
-        return "Unknown Chart Type"
+        return "📊 Data Visualization"
     
-    def extract_data_points(self, image, chart_type):
-        """Attempt to extract data points (simplified approach)"""
-        try:
-            # This is a simplified version - real implementation would be more sophisticated
-            # Convert to grayscale for analysis
-            image_np = np.array(image.convert('L'))
-            
-            # Basic edge detection
-            edges = cv2.Canny(image_np, 50, 150)
-            
-            # Find contours
-            contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-            
-            data_info = {
-                'contours_found': len(contours),
-                'image_dimensions': image_np.shape,
-                'note': 'This is a simplified data extraction. Advanced algorithms needed for accurate data point extraction.'
-            }
-            
-            return data_info
-            
-        except Exception as e:
-            return f"Data extraction failed: {str(e)}"
+    def generate_insights(self, caption, analysis, chart_type):
+        """Generate insights from the analysis"""
+        insights = []
+        text = (caption + " " + analysis).lower()
+        
+        # Color insights
+        colors = ['blue', 'red', 'green', 'yellow', 'orange', 'purple', 'pink']
+        found_colors = [color for color in colors if color in text]
+        if found_colors:
+            insights.append(f"🎨 Uses {', '.join(found_colors)} color scheme")
+        
+        # Trend insights
+        if any(word in text for word in ['increasing', 'rising', 'upward', 'growth']):
+            insights.append("📈 Shows increasing/upward trend")
+        elif any(word in text for word in ['decreasing', 'falling', 'downward', 'decline']):
+            insights.append("📉 Shows decreasing/downward trend")
+        
+        # Data insights
+        if any(word in text for word in ['multiple', 'several', 'many', 'various']):
+            insights.append("📊 Contains multiple data series or categories")
+        
+        if 'comparison' in text or 'compare' in text:
+            insights.append("⚖️ Designed for comparison analysis")
+        
+        # Chart-specific insights
+        if 'Bar Chart' in chart_type:
+            insights.append("📊 Effective for categorical data comparison")
+        elif 'Line Chart' in chart_type:
+            insights.append("📈 Shows trends over continuous data")
+        elif 'Pie Chart' in chart_type:
+            insights.append("🥧 Represents parts of a whole")
+        
+        return insights[:4]  # Limit to 4 insights
+    
+    def format_basic_results(self, caption, chart_type):
+        return f"""# 📊 Basic Chart Analysis
+
+## 🤖 AI Description
+{caption}
+
+## 📈 Chart Type
+{chart_type}
+
+---
+*Powered by BLIP (Bootstrapping Language-Image Pre-training)*
+"""
     
-    def florence_analysis(self, image):
-        """Advanced analysis using Florence-2"""
-        if not self.florence_available:
-            return "Florence-2 model not available"
+    def format_detailed_results(self, caption, analysis, chart_type, insights, image):
+        insight_text = "\n".join([f"• {insight}" for insight in insights])
         
-        try:
-            # Florence-2 prompts for different tasks
-            prompts = [
-                "<OD>",  # Object Detection
-                "<DENSE_REGION_CAPTION>",  # Dense captioning
-                "<OCR_WITH_REGION>"  # OCR with regions
-            ]
-            
-            results = {}
-            for prompt in prompts:
-                inputs = self.florence_processor(text=prompt, images=image, return_tensors="pt")
-                generated_ids = self.florence_model.generate(
-                    input_ids=inputs["input_ids"],
-                    pixel_values=inputs["pixel_values"],
-                    max_new_tokens=1024,
-                    num_beams=3
-                )
-                generated_text = self.florence_processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
-                results[prompt] = generated_text
-            
-            return results
-        except:
-            return "Florence-2 analysis failed"
+        return f"""# 📊 Detailed Chart Analysis
+
+## 🤖 AI Description  
+**Basic Caption:** {caption}
+
+**Detailed Analysis:** {analysis}
+
+## 📈 Chart Type
+{chart_type}
+
+## 💡 Key Insights
+{insight_text if insight_text.strip() else "• Analysis provides valuable data visualization insights"}
+
+## 📏 Technical Details
+- **Image Size:** {image.size[0]} × {image.size[1]} pixels
+- **Color Mode:** {image.mode}
+- **Analysis Model:** BLIP (Salesforce)
+
+---
+*Analysis completed using state-of-the-art vision-language AI*
+"""
     
-    def format_results(self, results):
-        """Format results for display"""
-        formatted = "# Chart Analysis Results\n\n"
+    def format_comprehensive_results(self, caption, analysis, chart_type, insights, image):
+        insight_text = "\n".join([f"• {insight}" for insight in insights])
         
-        if 'description' in results:
-            formatted += f"## Image Description\n{results['description']}\n\n"
+        # Additional comprehensive analysis
+        recommendations = self.get_recommendations(chart_type, insights)
+        rec_text = "\n".join([f"• {rec}" for rec in recommendations])
         
-        if 'chart_type' in results:
-            formatted += f"## Chart Type\n{results['chart_type']}\n\n"
+        return f"""# 📊 Comprehensive Chart Analysis
+
+## 🤖 AI-Powered Description
+**Quick Summary:** {caption}
+
+**Detailed Analysis:** {analysis}
+
+## 📈 Chart Classification
+{chart_type}
+
+## 💡 Visual Insights
+{insight_text if insight_text.strip() else "• Professional data visualization with clear visual elements"}
+
+## 🎯 Recommendations
+{rec_text}
+
+## 📊 Technical Specifications
+- **Resolution:** {image.size[0]} × {image.size[1]} pixels  
+- **Aspect Ratio:** {round(image.size[0]/image.size[1], 2)}:1
+- **Color Depth:** {image.mode}
+- **File Format:** {image.format if hasattr(image, 'format') else 'Unknown'}
+
+## 🔧 Analysis Details
+- **Primary Model:** BLIP (Bootstrapping Language-Image Pre-training)
+- **Publisher:** Salesforce Research
+- **Capability:** Vision-Language Understanding
+- **Processing:** Real-time AI analysis
+
+---
+*🚀 Advanced chart analysis powered by cutting-edge AI technology*
+"""
+    
+    def get_recommendations(self, chart_type, insights):
+        """Generate recommendations based on chart type and insights"""
+        recs = []
         
-        if 'extracted_text' in results:
-            formatted += "## Extracted Text\n"
-            for method, text in results['extracted_text'].items():
-                formatted += f"**{method}:** {text}\n\n"
+        if 'Bar Chart' in chart_type:
+            recs.append("Consider adding data labels for precise values")
+            recs.append("Ensure consistent spacing between bars")
+        elif 'Line Chart' in chart_type:
+            recs.append("Add gridlines for better readability")
+            recs.append("Consider trend lines for data analysis")
+        elif 'Pie Chart' in chart_type:
+            recs.append("Limit to 5-7 categories for clarity")
+            recs.append("Consider using percentages on slices")
         
-        if 'data_points' in results:
-            formatted += f"## Data Analysis\n{results['data_points']}\n\n"
+        # General recommendations
+        recs.append("Verify axis labels and titles are clear")
+        recs.append("Consider accessibility for color-blind users")
         
-        if 'advanced_analysis' in results:
-            formatted += f"## Advanced Analysis\n{results['advanced_analysis']}\n\n"
+        return recs[:3]  # Limit recommendations
+
+# Initialize analyzer
+print("🔄 Starting Chart Analyzer initialization...")
+try:
+    analyzer = ChartAnalyzer()
+    print("✅ Chart Analyzer ready!")
+except Exception as e:
+    print(f"❌ Failed to initialize: {e}")
+    analyzer = None
+
+def load_image_from_url(url):
+    """Load image from URL"""
+    if not url.strip():
+        return None, "Please enter a valid URL"
+    
+    try:
+        print(f"🌐 Loading image from: {url}")
+        response = requests.get(url, timeout=15, headers={
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+        })
+        response.raise_for_status()
+        
+        image = Image.open(io.BytesIO(response.content))
+        print(f"✅ Image loaded: {image.size} pixels")
+        return image, f"✅ Successfully loaded image ({image.size[0]}×{image.size[1]})"
         
-        return formatted
+    except Exception as e:
+        print(f"❌ URL load error: {e}")
+        return None, f"❌ Failed to load image: {str(e)}"
+
+def analyze_chart_interface(image, analysis_type):
+    """Main interface function"""
+    if analyzer is None:
+        return "❌ Analyzer not initialized. Please refresh the page."
+    
+    if image is None:
+        return "📤 Please upload an image or load one from URL first."
+    
+    print(f"🔍 Starting {analysis_type} analysis...")
+    result = analyzer.analyze_chart(image, analysis_type)
+    print("✅ Analysis complete!")
+    return result
 
-# Initialize the analyzer
-analyzer = ChartAnalyzer()
+def clear_interface():
+    """Clear all inputs"""
+    return None, "", "📤 Ready for new image analysis!"
 
-# Create Gradio interface
-def analyze_uploaded_chart(image, analysis_type):
-    return analyzer.analyze_chart(image, analysis_type)
+# Create Gradio Interface
+print("🎨 Building user interface...")
 
-# Create the Gradio app
-with gr.Blocks(title="Chart Analyzer & Data Extractor", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 📊 Chart Analyzer & Data Extractor")
-    gr.Markdown("Upload a chart image to extract data and analyze its contents using multiple AI models including BLIP, TrOCR, and Florence-2.")
+interface = gr.Blocks(
+    title="AI Chart Analyzer with BLIP",
+    css="""
+    .gradio-container {
+        max-width: 1000px !important;
+        margin: auto !important;
+    }
+    .main-header {
+        text-align: center;
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    """
+)
+
+with interface:
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🤖 AI Chart Analyzer</h1>
+        <p>Upload any chart or graph to get intelligent analysis powered by BLIP AI</p>
+    </div>
+    """)
     
     with gr.Row():
+        # Left Column - Input
         with gr.Column(scale=1):
-            gr.Markdown("## 📁 Upload Your Chart")
-            
-            # Multiple upload options
-            with gr.Tabs():
-                with gr.Tab("📤 Upload Image"):
-                    image_input = gr.Image(
-                        type="pil", 
-                        label="Upload Chart Image",
-                        height=400,
-                        sources=["upload", "webcam", "clipboard"],
-                        format="png"
-                    )
-                    gr.Markdown("**Supported formats:** PNG, JPG, JPEG, GIF, BMP")
-                    gr.Markdown("**Max size:** 10MB")
-                
-                with gr.Tab("🔗 From URL"):
-                    url_input = gr.Textbox(
-                        label="Image URL", 
-                        placeholder="https://example.com/chart.png"
-                    )
-                    load_url_btn = gr.Button("Load from URL")
+            gr.Markdown("### 📁 Upload Your Chart")
             
-            # Analysis options
-            gr.Markdown("## ⚙️ Analysis Settings")
-            analysis_type = gr.Dropdown(
-                choices=["basic", "comprehensive", "data_extraction"],
-                value="comprehensive",
-                label="Analysis Type",
-                info="Choose the depth of analysis"
-            )
-            
-            with gr.Accordion("Advanced Options", open=False):
-                confidence_threshold = gr.Slider(
-                    minimum=0.1,
-                    maximum=1.0,
-                    value=0.5,
-                    label="OCR Confidence Threshold"
+            # Image input options
+            with gr.Tab("📤 Upload File"):
+                image_input = gr.Image(
+                    label="Drop chart image here or click to browse",
+                    type="pil"
                 )
-                use_florence = gr.Checkbox(
-                    label="Use Florence-2 (Advanced Analysis)",
-                    value=True
+            
+            with gr.Tab("🌐 Load from URL"):
+                url_input = gr.Textbox(
+                    label="Image URL",
+                    placeholder="https://example.com/chart.png"
                 )
+                load_btn = gr.Button("🔄 Load Image", variant="secondary")
+            
+            gr.Markdown("### ⚙️ Analysis Settings")
+            analysis_type = gr.Radio(
+                choices=["basic", "detailed", "comprehensive"],
+                value="detailed",
+                label="Analysis Depth"
+            )
             
-            analyze_btn = gr.Button("🔍 Analyze Chart", variant="primary", size="lg")
-            clear_btn = gr.Button("🗑️ Clear All", variant="secondary")
+            # Action buttons
+            with gr.Row():
+                analyze_btn = gr.Button("🚀 Analyze Chart", variant="primary")
+                clear_btn = gr.Button("🧹 Clear All", variant="secondary")
         
+        # Right Column - Output
         with gr.Column(scale=2):
-            gr.Markdown("## 📊 Analysis Results")
+            gr.Markdown("### 📊 Analysis Results")
             output = gr.Markdown(
-                value="Upload an image and click 'Analyze Chart' to see results here.",
-                label="Results"
+                value="🎯 **Ready to analyze!** Upload a chart image and click 'Analyze Chart' to see AI-powered insights.",
+                height=500
             )
-            
-            # Additional output components
-            with gr.Accordion("Raw Data Export", open=False):
-                json_output = gr.JSON(label="Structured Data")
-                csv_download = gr.File(label="Download CSV", visible=False)
-    
-    # Function to load image from URL
-    def load_image_from_url(url):
-        try:
-            import requests
-            response = requests.get(url)
-            response.raise_for_status()
-            image = Image.open(io.BytesIO(response.content))
-            return image, "Image loaded successfully!"
-        except Exception as e:
-            return None, f"Error loading image: {str(e)}"
-    
-    # Enhanced analysis function
-    def analyze_uploaded_chart(image, analysis_type, confidence_threshold, use_florence):
-        if image is None:
-            return "Please upload an image first.", {}, None
-        
-        try:
-            result = analyzer.analyze_chart(image, analysis_type)
-            
-            # Create structured data for JSON output
-            structured_data = {
-                "analysis_type": analysis_type,
-                "confidence_threshold": confidence_threshold,
-                "models_used": ["BLIP", "TrOCR", "EasyOCR"],
-                "timestamp": pd.Timestamp.now().isoformat()
-            }
-            
-            if use_florence and analyzer.florence_available:
-                structured_data["models_used"].append("Florence-2")
-            
-            return result, structured_data, None
-            
-        except Exception as e:
-            error_msg = f"Error analyzing chart: {str(e)}"
-            return error_msg, {"error": error_msg}, None
     
-    # Clear function
-    def clear_all():
-        return None, "Upload an image and click 'Analyze Chart' to see results here.", {}, None
-    
-    # Examples
-    gr.Examples(
+    # Examples section
+    gr.Markdown("### 🎯 Try These Example Charts")
+    examples = gr.Examples(
         examples=[
-            ["https://via.placeholder.com/600x400/0066CC/FFFFFF?text=Sample+Bar+Chart", "comprehensive"],
-            ["https://via.placeholder.com/600x400/FF6B35/FFFFFF?text=Sample+Line+Chart", "data_extraction"],
+            [Image.new('RGB', (400, 300), color='lightblue'), "detailed"],
         ],
         inputs=[image_input, analysis_type],
-        label="Try these examples:"
+        label="Click examples to test the analyzer"
     )
     
     # Event handlers
     analyze_btn.click(
-        fn=analyze_uploaded_chart,
-        inputs=[image_input, analysis_type, confidence_threshold, use_florence],
-        outputs=[output, json_output, csv_download]
+        fn=analyze_chart_interface,
+        inputs=[image_input, analysis_type],
+        outputs=output
     )
     
-    load_url_btn.click(
+    load_btn.click(
         fn=load_image_from_url,
         inputs=[url_input],
         outputs=[image_input, output]
     )
     
     clear_btn.click(
-        fn=clear_all,
-        outputs=[image_input, output, json_output, csv_download]
+        fn=clear_interface,
+        outputs=[image_input, url_input, output]
     )
 
+# Launch application
 if __name__ == "__main__":
-    print("Starting Chart Analyzer...")
+    print("🚀 Launching Chart Analyzer...")
     try:
-        demo.launch(
+        interface.launch(
             server_name="0.0.0.0",
             server_port=7860,
-            share=False,
-            show_error=True,
-            quiet=False
+            share=True,
+            debug=True
         )
     except Exception as e:
-        print(f"Error launching app: {e}")
-        # Fallback launch
-        demo.launch()
+        print(f"❌ Launch error: {e}")
+        print("🔄 Trying alternative launch...")
+        interface.launch()