Update app.py

app.py

@@ -1,17 +1,14 @@
-import base64
-import io
 import os
-from dataclasses import dataclass
 from typing import List, Optional, Tuple, Dict, Any
-import json
+import base64
+import io
 
 import gradio as gr
 import pandas as pd
 import numpy as np
-import plotly.express as px
 import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 from litellm import completion
+
 class DataAnalyzer:
     """Handles data analysis and visualization"""
     
@@ -42,7 +39,6 @@ class DataAnalyzer:
             template="plotly_white"
         )
         
-        # Convert to HTML string
         return fig.to_html(include_plotlyjs=True, full_html=False)
     
     def create_scatter(self, x_col: str, y_col: str, color_col: Optional[str] = None, 
@@ -89,12 +85,11 @@ class DataAnalyzer:
             
         fig = go.Figure()
         
-        # Create box plot for each category
         for category in self.data[x_col].unique():
             fig.add_trace(go.Box(
                 y=self.data[self.data[x_col] == category][y_col],
                 name=str(category),
-                boxpoints='all',  # show all points
+                boxpoints='all',
                 jitter=0.3,
                 pointpos=-1.8
             ))
@@ -189,65 +184,65 @@ class ChatAnalyzer:
             return self.history
     
     def chat(self, message: str, api_key: str) -> Tuple[List[Tuple[str, str]], str]:
-    """Process chat message and generate visualizations"""
-    if self.analyzer.data is None:
-        return [(message, "Please upload a data file first.")], ""
-        
-    if not api_key:
-        return [(message, "Please provide an OpenAI API key.")], ""
-        
-    try:
-        os.environ["OPENAI_API_KEY"] = api_key
-        
-        # Get data context
-        context = self._get_data_context()
-        
-        # Get AI response
-        completion_response = completion(
-            model="gpt-4o-mini",
-            messages=[
-                {"role": "system", "content": self._get_system_prompt()},
-                {"role": "user", "content": f"{context}\n\nUser question: {message}"}
-            ],
-            temperature=0.7
-        )
-        
-        analysis = completion_response.choices[0].message.content
-        
-        # Create visualizations
-        plots_html = ""
+        """Process chat message and generate visualizations"""
+        if self.analyzer.data is None:
+            return [(message, "Please upload a data file first.")], ""
+            
+        if not api_key:
+            return [(message, "Please provide an OpenAI API key.")], ""
+            
         try:
-            # Extract code blocks
-            import re
-            code_blocks = re.findall(r'```python\n(.*?)```', analysis, re.DOTALL)
+            os.environ["OPENAI_API_KEY"] = api_key
+            
+            # Get data context
+            context = self._get_data_context()
+            
+            # Get AI response
+            completion_response = completion(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": self._get_system_prompt()},
+                    {"role": "user", "content": f"{context}\n\nUser question: {message}"}
+                ],
+                temperature=0.7
+            )
+            
+            analysis = completion_response.choices[0].message.content
             
-            for code in code_blocks:
-                # Create namespace for execution
-                namespace = {
-                    'analyzer': self.analyzer,
-                    'df': self.analyzer.data,
-                    'print': lambda x: x
-                }
+            # Create visualizations
+            plots_html = ""
+            try:
+                # Extract code blocks
+                import re
+                code_blocks = re.findall(r'```python\n(.*?)```', analysis, re.DOTALL)
                 
-                # Execute the code
-                try:
-                    result = eval(code, namespace)
-                    if isinstance(result, str) and ('<div' in result or '<script' in result):
-                        plots_html += f'<div class="plot-container">{result}</div>'
-                except:
-                    exec(code, namespace)
+                for code in code_blocks:
+                    # Create namespace for execution
+                    namespace = {
+                        'analyzer': self.analyzer,
+                        'df': self.analyzer.data,
+                        'print': lambda x: x
+                    }
+                    
+                    # Execute the code
+                    try:
+                        result = eval(code, namespace)
+                        if isinstance(result, str) and ('<div' in result or '<script' in result):
+                            plots_html += f'<div class="plot-container">{result}</div>'
+                    except:
+                        exec(code, namespace)
                 
+            except Exception as e:
+                analysis += f"\n\nError creating visualization: {str(e)}"
+            
+            # Update chat history
+            self.history.append((message, analysis))
+            
+            return self.history, plots_html
+            
         except Exception as e:
-            analysis += f"\n\nError creating visualization: {str(e)}"
-        
-        # Update chat history
-        self.history.append((message, analysis))
-        
-        return self.history, plots_html
-        
-    except Exception as e:
-        self.history.append((message, f"Error: {str(e)}"))
-        return self.history, ""
+            self.history.append((message, f"Error: {str(e)}"))
+            return self.history, ""
     
     def _get_data_context(self) -> str:
         """Get current data context for AI"""
@@ -270,17 +265,15 @@ class ChatAnalyzer:
         {stats}
         
         Available visualization functions:
-        - analyzer.create_scatter(x_col, y_col, color_col, title)
-        - analyzer.create_line(x_col, y_cols, title)
-        - analyzer.create_bar(x_col, y_col, color_col, title)
         - analyzer.create_histogram(column, bins, title)
-        - analyzer.create_box(x_col, y_col, color_col, title)
-        - analyzer.create_correlation_matrix(title)
+        - analyzer.create_scatter(x_col, y_col, color_col, title)
+        - analyzer.create_box(x_col, y_col, title)
+        - analyzer.create_line(x_col, y_col, color_col, title)
         """
     
     def _get_system_prompt(self) -> str:
-    """Get system prompt for AI"""
-    return """You are a data analysis assistant specialized in creating interactive visualizations.
+        """Get system prompt for AI"""
+        return """You are a data analysis assistant specialized in creating interactive visualizations.
 
 Available visualization functions:
 1. create_histogram(column, bins, title) - For distribution analysis
@@ -298,7 +291,7 @@ result = analyzer.create_histogram(
 )
 print(result)
 
-# Create scatter plot
+# Create scatter plot with time series
 result = analyzer.create_scatter(
     x_col='Date',
     y_col='Salary',
@@ -316,7 +309,7 @@ result = analyzer.create_box(
 print(result)
 ```
 
-Always wrap code in Python code blocks and use print() to display the visualizations. 
+Always wrap code in Python code blocks and use print() to display the visualizations.
 Provide analysis and insights about what the visualizations show."""
 
 def create_interface():
@@ -324,7 +317,7 @@ def create_interface():
     
     analyzer = ChatAnalyzer()
     
-    # Custom CSS for better visualization display
+    # Custom CSS
     css = """
     .container { max-width: 1200px; margin: auto; }
     .plot-container {
@@ -341,157 +334,75 @@ def create_interface():
         border-radius: 8px;
         background: #f8f9fa;
     }
-    .title {
-        text-align: center;
-        margin-bottom: 20px;
-    }
-    .footer {
-        text-align: center;
-        margin-top: 20px;
-        font-size: 0.9em;
-        color: #666;
-    }
     """
     
-    with gr.Blocks(css=css, title="Interactive Data Analysis Chat") as demo:
+    with gr.Blocks(css=css) as demo:
         gr.Markdown("""
         # Interactive Data Analysis Chat
         
         Upload your data and chat with AI to analyze it! Features:
-        - Interactive visualizations with zoom, pan, and hover capabilities
-        - Natural language analysis and insights
-        - Statistical analysis and summaries
-        - Trend detection and pattern analysis
-        
-        Start by uploading a CSV or Excel file.
+        - Interactive visualizations
+        - Natural language analysis
+        - Statistical insights
+        - Trend detection
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
                 file = gr.File(
                     label="Upload Data (CSV or Excel)",
-                    file_types=[".csv", ".xlsx", ".xls"],
-                    elem_classes="file-upload"
+                    file_types=[".csv", ".xlsx", ".xls"]
                 )
                 api_key = gr.Textbox(
                     label="OpenAI API Key",
                     type="password",
-                    placeholder="Enter your API key",
-                    elem_classes="api-input"
+                    placeholder="Enter your API key"
                 )
                 
             with gr.Column(scale=2):
                 chatbot = gr.Chatbot(
                     height=400,
-                    elem_classes="chat-message",
-                    show_label=False
+                    elem_classes="chat-message"
+                )
+                message = gr.Textbox(
+                    label="Ask about your data",
+                    placeholder="e.g., Show me trends in the data",
+                    lines=2
                 )
-                with gr.Row():
-                    message = gr.Textbox(
-                        label="Ask about your data",
-                        placeholder="e.g., Show me trends in the data",
-                        lines=2,
-                        elem_classes="message-input",
-                        scale=4
-                    )
-                    send = gr.Button(
-                        "Send",
-                        scale=1,
-                        elem_classes="send-button"
-                    )
+                send = gr.Button("Send")
         
         # Plot output area
         plot_output = gr.HTML(
             label="Visualizations",
-            elem_classes="plot-container",
-            visible=True  # Always show container even when empty
+            elem_classes="plot-container"
         )
         
         # Event handlers
         file.change(
-            fn=analyzer.process_file,
+            analyzer.process_file,
             inputs=[file],
-            outputs=[chatbot],
-            api_name="upload"
-        )
-        
-        # Handle both click and enter key
-        msg_handler = send.click(
-            fn=analyzer.chat,
-            inputs=[message, api_key],
-            outputs=[chatbot, plot_output],
-            api_name="chat"
+            outputs=[chatbot]
         )
         
-        message.submit(
-            fn=analyzer.chat,
+        send.click(
+            analyzer.chat,
             inputs=[message, api_key],
             outputs=[chatbot, plot_output]
         )
         
-        # Clear message after sending
-        msg_handler.then(
-            fn=lambda: "",
-            inputs=[],
-            outputs=[message]
-        )
-        
         # Example queries
         gr.Examples(
             examples=[
-                ["Show me a scatter plot of the main numerical variables and explain any patterns you see"],
-                ["Create a correlation analysis with heatmap and highlight the strongest relationships"],
-                ["Show the distribution of values using histograms and describe the shapes"],
-                ["Create box plots to analyze categories and identify any outliers"],
-                ["Show trends over time using line plots and explain the patterns"],
-                ["Generate a comprehensive analysis with multiple visualizations"],
-                ["Compare the distribution across different categories using appropriate plots"],
-                ["Identify and visualize any seasonal patterns or cycles in the data"],
+                ["Show me a histogram of salary distribution"],
+                ["Create a scatter plot of salary trends over time"],
+                ["Show me box plots of salaries by title"],
+                ["Analyze the trends and patterns in the data"],
             ],
-            inputs=[message],
-            label="Example Analysis Queries"
-        )
-        
-        # Tips section
-        gr.Markdown("""
-        ### Tips for better analysis:
-        1. **Data Preparation**: Upload clean CSV or Excel files with clear column names
-        2. **Specific Questions**: Ask clear, specific questions about your data
-        3. **Interactive Features**: Use zoom, pan, and hover on visualizations
-        4. **Follow-up Questions**: Ask for deeper analysis of interesting patterns
-        5. **Multiple Views**: Request different visualization types for better insights
-        
-        ### Available Visualization Types:
-        - Scatter plots for relationships
-        - Line plots for trends
-        - Bar charts for comparisons
-        - Histograms for distributions
-        - Box plots for statistical summaries
-        - Correlation matrices for relationship analysis
-        """)
-        
-        # Footer
-        gr.Markdown("""
-        <div class="footer">
-        Built with Gradio • Powered by OpenAI • Interactive Visualizations
-        </div>
-        """)
-        
-        # Theme customization
-        demo.theme = gr.themes.Soft(
-            primary_hue="blue",
-            secondary_hue="gray",
-            neutral_hue="gray",
-            text_size=gr.themes.sizes.text_md
+            inputs=message
         )
     
     return demo
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(
-        share=False,  # Set to True to create a public link
-        debug=True,   # Set to False in production
-        show_error=True,  # Show detailed error messages
-        server_port=7860  # Specify port number
-    )
+    demo.launch()