app.py

import os
import tempfile
import json
import pandas as pd
import numpy as np
import gradio as gr
import matplotlib.pyplot as plt
import plotly.express as px
import plotly.graph_objects as go
from sqlalchemy import create_engine
from pandasai import SmartDataframe
from pandasai.llm import OpenAI
import sqlite3
from dotenv import load_dotenv
import atexit
import base64
import io

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

app_instance = None

class DataChatApp:
    def __init__(self):
        self.df = None
        self.data_source = None
        self.llm = OpenAI(api_token=OPENAI_API_KEY)
        self.smart_df = None
        self.chat_history = []
        self.temp_files = []
        self.db_connection = None
        global app_instance
        app_instance = self
    
    def load_file(self, file):
        """Load data from uploaded file"""
        if file is None:
            return "No file uploaded", None, None
        
        file_path = file.name
        file_name = os.path.basename(file_path)
        file_ext = os.path.splitext(file_name)[1].lower()
        
        try:
            if file_ext == '.csv':
                self.df = pd.read_csv(file_path)
            elif file_ext == '.xlsx' or file_ext == '.xls':
                self.df = pd.read_excel(file_path)
            elif file_ext == '.json':
                self.df = pd.read_json(file_path)
            else:
                return f"Unsupported file format: {file_ext}", None, None
            
            # Initialize the SmartDataframe
            self.smart_df = SmartDataframe(self.df, config={"llm": self.llm})
            self.data_source = f"File: {file_name}"
            preview = self.df.head().to_html()
            info = self._get_dataframe_info()
            return f"Loaded successfully: {file_name}", preview, info
        except Exception as e:
            return f"Error loading file: {str(e)}", None, None
        
        return self.df
    
    def connect_database(self, connection_string, query):
        """Connect to database using connection string"""
        try:
            if connection_string.startswith('sqlite:'):
                if 'memory' in connection_string:
                    self.db_connection = sqlite3.connect(':memory:')
                else:
                    db_path = connection_string.replace('sqlite:///', '')
                    self.db_connection = sqlite3.connect(db_path)
            else:
                self.db_connection = create_engine(connection_string)
            
            if not query:
                return "Please provide a SQL query", None, None
            
            self.df = pd.read_sql(query, self.db_connection)
            self.smart_df = SmartDataframe(self.df, config={"llm": self.llm})
            self.data_source = f"Database: {connection_string.split('://')[0]}"
            preview = self.df.head().to_html()
            info = self._get_dataframe_info()
            return "Database connected successfully", preview, info
        except Exception as e:
            return f"Database connection error: {str(e)}", None, None
            
        return self.df
    
    def _get_dataframe_info(self):
        """Get information about the dataframe"""
        if self.df is None:
            return None
        
        info = {
            "Shape": self.df.shape,
            "Columns": list(self.df.columns),
            "Data Types": {col: str(dtype) for col, dtype in self.df.dtypes.items()},
            "Missing Values": self.df.isnull().sum().to_dict()
        }
        return json.dumps(info, indent=2)
    
    def chat_with_data(self, query, history):
        """Process natural language query against the loaded data"""
        if self.df is None or self.smart_df is None:
            return "Please load data first before querying.", history
        
        if not query:
            return "Please enter a query.", history
        
        try:
            if history is None:
                history = []
            
            response = self.smart_df.chat(query)
            
            if isinstance(response, plt.Figure):
                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
                response.savefig(temp_file.name)
                temp_file.close()
                self.temp_files.append(temp_file.name)
                
                response_text = f"<img src='file={temp_file.name}' alt='Visualization' />"
            
            elif isinstance(response, pd.DataFrame):
                response_text = f"<div style='overflow-x: auto;'>{response.to_html(index=False)}</div>"
            else:
                response_text = str(response)
            
            history.append({"role": "user", "content": query})
            history.append({"role": "assistant", "content": response_text})
            
            return "", history
        except Exception as e:
            if not history:
                history = []
            history.append({"role": "user", "content": query})
            history.append({"role": "assistant", "content": f"Error processing query: {str(e)}"})
            return "", history
    
    def create_visualization(self, viz_type, x_axis, y_axis, title):
        """Create visualization based on user selection"""
        if self.df is None:
            return "Please load data first before creating visualizations."
        
        if not x_axis or (viz_type != 'pie' and viz_type != 'histogram' and not y_axis):
            return "Please select both X and Y axis for the visualization."
        
        try:
            if x_axis not in self.df.columns:
                return f"Column '{x_axis}' not found in the data."
            
            if viz_type != 'pie' and viz_type != 'histogram' and y_axis not in self.df.columns:
                return f"Column '{y_axis}' not found in the data."
            
            plt.figure(figsize=(10, 6))
            
            if viz_type == 'bar':
                plt.bar(self.df[x_axis], self.df[y_axis])
                plt.xlabel(x_axis)
                plt.ylabel(y_axis)
                plt.title(title or f"Bar Chart: {y_axis} by {x_axis}")
                
            elif viz_type == 'line':
                plt.plot(self.df[x_axis], self.df[y_axis])
                plt.xlabel(x_axis)
                plt.ylabel(y_axis)
                plt.title(title or f"Line Chart: {y_axis} over {x_axis}")
                
            elif viz_type == 'scatter':
                plt.scatter(self.df[x_axis], self.df[y_axis])
                plt.xlabel(x_axis)
                plt.ylabel(y_axis)
                plt.title(title or f"Scatter Plot: {y_axis} vs {x_axis}")
                
            elif viz_type == 'pie':
                if y_axis and y_axis in self.df.columns:
                    pie_data = self.df.groupby(x_axis)[y_axis].sum()
                    plt.pie(pie_data, labels=pie_data.index, autopct='%1.1f%%')
                else:
                    counts = self.df[x_axis].value_counts()
                    plt.pie(counts, labels=counts.index, autopct='%1.1f%%')
                plt.title(title or f"Pie Chart: Distribution of {x_axis}")
                
            elif viz_type == 'histogram':
                plt.hist(self.df[x_axis], bins=20)
                plt.xlabel(x_axis)
                plt.ylabel('Frequency')
                plt.title(title or f"Histogram: Distribution of {x_axis}")
            
            plt.tight_layout()
            
            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
            plt.savefig(temp_file.name, dpi=100, bbox_inches='tight')
            temp_file.close()
            self.temp_files.append(temp_file.name)
            
            with open(temp_file.name, 'rb') as img_file:
                img_data = base64.b64encode(img_file.read()).decode('utf-8')
            
            html_content = f"""
            <div style="text-align: center; padding: 20px; background-color: white; border-radius: 10px; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);">
                <img src="data:image/png;base64,{img_data}" style="max-width: 100%; height: auto;" alt="Visualization">
            </div>
            """
            
            plt.close()
            
            return html_content
                
        except Exception as e:
            plt.close()
            return f"Error creating visualization: {str(e)}"
    
    def generate_summary_cards(self):
        """Generate summary cards (KPIs) for numerical columns"""
        if self.df is None:
            return "Please load data first before generating summary cards."
        
        try:
            num_cols = self.df.select_dtypes(include=[np.number]).columns.tolist()
            
            if not num_cols:
                return "No numerical columns found for summary cards."
            
            cards_html = """
            <style>
                .summary-card {
                    background-color: #f5f5f5; 
                    border-radius: 5px; 
                    padding: 15px; 
                    min-width: 200px; 
                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
                    margin: 10px;
                }
                .summary-card h3 {
                    margin-top: 0; 
                    color: #333 !important;
                    font-weight: bold;
                }
                .summary-card p {
                    color: #333 !important;
                    margin: 8px 0;
                }
                .summary-card strong {
                    font-weight: bold;
                    color: #333 !important;
                }
                .summary-container {
                    display: flex; 
                    flex-wrap: wrap; 
                    gap: 10px;
                }
            </style>
            <div class="summary-container">
            """
            
            for col in num_cols:
                mean_val = self.df[col].mean()
                median_val = self.df[col].median()
                min_val = self.df[col].min()
                max_val = self.df[col].max()
                
                card_html = f"""
                <div class="summary-card">
                    <h3>{col}</h3>
                    <p><strong>Mean:</strong> {mean_val:.2f}</p>
                    <p><strong>Median:</strong> {median_val:.2f}</p>
                    <p><strong>Min:</strong> {min_val:.2f}</p>
                    <p><strong>Max:</strong> {max_val:.2f}</p>
                </div>
                """
                cards_html += card_html
            
            cards_html += "</div>"
            return cards_html
        
        except Exception as e:
            return f"Error generating summary cards: {str(e)}"
    
    def cleanup(self):
        """Clean up temporary files"""
        for file in self.temp_files:
            try:
                if os.path.exists(file):
                    os.unlink(file)
            except Exception:
                pass
        
        if self.db_connection is not None:
            try:
                if hasattr(self.db_connection, 'close'):
                    self.db_connection.close()
                elif hasattr(self.db_connection, 'dispose'):
                    self.db_connection.dispose()
            except Exception:
                pass

def create_interface():
    app = DataChatApp()
    
    def update_column_options():
        if app_instance and app_instance.df is not None:
            return gr.update(choices=list(app_instance.df.columns))
        return gr.update(choices=[])
    
    with gr.Blocks(theme=gr.themes.Soft(), title="Data Chat App", css="""
        .plot-container {width: 100% !important; height: 100% !important;}
        .js-plotly-plot {min-height: 500px;}
        .plotly {min-height: 500px;}
    """) as interface:
        gr.Markdown("""
        # GIN Data Chat Application
        Upload your data file or connect to a database, then chat with your data using natural language!
        """)
        
        with gr.Tabs():
            with gr.TabItem("Load Data"):
                with gr.Tab("File Upload"):
                    file_input = gr.File(label="Upload CSV, Excel, or JSON file")
                    file_upload_button = gr.Button("Load File")
                    file_result = gr.Textbox(label="Result")
                
                with gr.Tab("Database Connection"):
                    conn_str = gr.Textbox(
                        label="Connection String", 
                        placeholder="E.g., sqlite:///data.db, postgresql://user:pass@localhost/db"
                    )
                    query = gr.Textbox(
                        label="SQL Query", 
                        placeholder="SELECT * FROM your_table LIMIT 1000"
                    )
                    db_connect_button = gr.Button("Connect to Database")
                    db_result = gr.Textbox(label="Result")
                
                preview = gr.HTML(label="Data Preview")
                info = gr.JSON(label="Data Information")
            
            with gr.TabItem("Chat with Data"):
                chat_interface = gr.Chatbot(height=400, type="messages")
                query_input = gr.Textbox(
                    label="Ask a question about your data",
                    placeholder="E.g., Show me the trend of sales over time",
                    lines=2
                )
                chat_button = gr.Button("Ask")
            
            with gr.TabItem("Visualize Data"):
                with gr.Row():
                    with gr.Column(scale=1):
                        viz_type = gr.Dropdown(
                            choices=["bar", "line", "scatter", "pie", "histogram"],
                            label="Visualization Type",
                            value="bar"  # Set a default value
                        )
                        x_axis = gr.Dropdown(label="X-Axis / Category")
                        y_axis = gr.Dropdown(label="Y-Axis / Values (Optional for Pie & Histogram)")
                        viz_title = gr.Textbox(label="Chart Title (Optional)")
                        viz_button = gr.Button("Generate Visualization", variant="primary")
                    
                    with gr.Column(scale=2):
                        viz_output = gr.HTML(label="Visualization", value="<div style='width:100%; height:500px; display:flex; justify-content:center; align-items:center; color:#666; font-size:16px;'>Your visualization will appear here</div>")
            
            with gr.TabItem("Summary Stats"):
                summary_button = gr.Button("Generate Summary Cards")
                summary_output = gr.HTML(label="Summary Statistics")
        
        # Set up event handlers
        file_upload_button.click(
            app.load_file, 
            inputs=[file_input], 
            outputs=[file_result, preview, info]
        ).then(
            update_column_options,
            inputs=None,
            outputs=[x_axis]
        ).then(
            update_column_options,
            inputs=None,
            outputs=[y_axis]
        )
        
        db_connect_button.click(
            app.connect_database, 
            inputs=[conn_str, query], 
            outputs=[db_result, preview, info]
        ).then(
            update_column_options,
            inputs=None,
            outputs=[x_axis]
        ).then(
            update_column_options,
            inputs=None,
            outputs=[y_axis]
        )
        
        chat_button.click(
            app.chat_with_data, 
            inputs=[query_input, chat_interface], 
            outputs=[query_input, chat_interface]
        )
        
        query_input.submit(
            app.chat_with_data,
            inputs=[query_input, chat_interface],
            outputs=[query_input, chat_interface]
        )
        
        
        viz_button.click(
            app.create_visualization, 
            inputs=[viz_type, x_axis, y_axis, viz_title], 
            outputs=[viz_output]
        )
        
        summary_button.click(
            app.generate_summary_cards, 
            outputs=[summary_output]
        )
        
        # Register cleanup function for when the app closes
        # The on_close method is no longer available in newer Gradio versions
        # Instead, we'll clean up temp files when the server restarts
        app.cleanup()  # Clean up any previous temp files
    
    return interface

if __name__ == "__main__":
    import atexit
    app = DataChatApp()
    atexit.register(app.cleanup)
    
    interface = create_interface()
    interface.launch(share=True)