intial commit

app.py

@@ -0,0 +1,244 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt 
+import seaborn as sns
+from utils import readData, getAgent
+
+def analyze_data_types(df):
+    num_numeric = df.select_dtypes(include=['int64', 'float64']).shape[1]
+    num_categorical = df.select_dtypes(include=['object', 'category']).shape[1]
+    return num_numeric, num_categorical
+
+st.set_page_config(
+    page_title="DataBot",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state for code display only
+if 'show_code' not in st.session_state:
+    st.session_state.show_code = False
+
+# Single sidebar control for code display
+with st.sidebar:
+    st.markdown("<h1 style='color: white;'>Settings</h1>", unsafe_allow_html=True)
+    show_code = st.checkbox('Show Python Code', 
+                          value=st.session_state.show_code,
+                          key='code_toggle_single')
+
+# Set dark mode directly
+st.markdown(
+    """
+    <style>
+    .stApp {
+        background-color: #000000;
+        color: #FFFFFF;
+    }
+    .stSidebar {
+        background-color: #000000;
+        color: #FFFFFF;
+    }
+    header[data-testid="stHeader"] {
+        background-color: #000000;
+    }
+    .stButton button {
+        background-color: #4A4A4A;
+        color: #FFFFFF;
+        border: 1px solid #404040;
+    }
+    .dataframe {
+        background-color: #000000; /* Black background for tables */
+        color: #FFFFFF;
+        border: 1px solid #404040;
+    }
+    .stMarkdown h1, .stMarkdown h2, .stMarkdown h3, .stMarkdown h4, 
+    .stMarkdown h5, .stMarkdown h6 {
+        color: #FFFFFF;
+    }
+    .stTextInput input, .stSelectbox select {
+        background-color: #333333;
+        color: #FFFFFF;
+        border: 1px solid #404040;
+    }
+    .stFileUploader {
+        background-color: #000000; /* Black background for drag-and-drop */
+        color: #FFFFFF;
+        border: 1px solid #808080; /* Grey border */
+    }
+    .stCheckbox > div:first-child {
+        color: #FFFFFF;
+    }
+    .stChatMessage {
+        background-color: #808080; /* Grey background for text responses */
+        color: #FFFFFF;
+        border-radius: 8px;
+        padding: 8px 12px;
+    }
+    .stChatMessage-user {
+        background-color: #808080; /* Grey background for user responses */
+        color: #FFFFFF;
+        align-self: flex-end;
+    }
+    .stChatMessage-assistant {
+        background-color: #808080; /* Grey background for assistant responses */
+        color: #FFFFFF;
+        align-self: flex-start;
+    }
+    .stChatInput {
+        background-color: #808080; /* Grey background for chat input */
+        color: #FFFFFF;
+        border: 1px solid #404040;
+    }
+    .stSlider > div > div > div {
+        background-color: #4A4A4A;
+    }
+    .element-container {
+        background-color: #000000 !important; /* Black background for plots */
+    }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+# Single main title
+st.markdown("<h1 style='color: white;'>DataBot: Your AI-Driven Data Analyst 😊</h1>", unsafe_allow_html=True)
+
+# Function to update code display
+def update_code_display(code_snippet, section_key):
+    if show_code:
+        st.sidebar.code(code_snippet, language="python", key=f'code_section_{section_key}')
+
+# Theme and Code Display Configuration
+if 'theme' not in st.session_state:
+    st.session_state.theme = 'dark'
+    st.session_state.show_code = False
+    st.session_state.current_code = ""
+
+# Define tabs first
+# File uploader
+uploaded_file = st.file_uploader("Upload a CSV file", type="csv")
+
+if uploaded_file is not None:
+    try:
+        df = readData(uploaded_file)
+        num_numeric, num_categorical = analyze_data_types(df)
+        
+        # Sidebar stats
+        st.sidebar.markdown("<h1 style='color: white;'>Data Overview 📊</h1>", unsafe_allow_html=True)
+        st.sidebar.write(f"Total columns: {df.shape[1]}")
+        st.sidebar.write(f"Total rows: {df.shape[0]}")
+        st.sidebar.write(f"Numeric columns: {num_numeric}")
+        st.sidebar.write(f"Categorical columns: {num_categorical}")
+
+        if num_numeric <= 1:
+            st.warning("This dataset is mostly descriptive. Limited statistical analysis available.")
+            st.write("Data Preview:")
+            st.dataframe(df.head())
+            st.write("Data Types:")
+            st.write(df.dtypes)
+        else:
+            # Define tabs after file upload
+            tabs = st.tabs(["Analysis", "Visualization", "Chat"])
+            
+            with tabs[0]:
+                st.header("Data Analysis")
+                st.dataframe(df.head())
+                if num_numeric > 0:
+                    st.write("Statistical Summary:")
+                    st.write(df.describe())
+                
+            # Visualization section with multiple column selection
+            with tabs[1]:
+                st.header("Data Visualization")
+                if num_numeric > 1:
+                    numeric_cols = df.select_dtypes(include=['int64', 'float64']).columns
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        plot_type = st.selectbox("Select Plot Type", ["Bar", "Scatter", "Histogram", "Box", "Line"])
+                        selected_columns = st.multiselect("Select Columns to Visualize", numeric_cols, default=numeric_cols[0])
+                    
+                    with col2:
+                        fig_width = st.slider("Plot width", 4, 12, 6)
+                        fig_height = st.slider("Plot height", 3, 8, 4)
+                        if plot_type == "Bar":
+                            n_bars = st.slider("Number of bars", 5, 50, 20)
+                        
+                    if st.button("Generate Plot", key='gen_plot'):
+                        fig, ax = plt.subplots(figsize=(fig_width, fig_height))
+                        
+                        if plot_type == "Bar":
+                            data_subset = df[selected_columns].head(n_bars)
+                            data_subset.plot(kind='bar', ax=ax)
+                        elif plot_type == "Scatter":
+                            if len(selected_columns) >= 2:
+                                sns.scatterplot(data=df, x=selected_columns[0], y=selected_columns[1], ax=ax)
+                        elif plot_type == "Box":
+                            df[selected_columns].boxplot(ax=ax)
+                        elif plot_type == "Line":
+                            df[selected_columns].plot(ax=ax)
+                        elif plot_type == "Histogram":
+                            df[selected_columns].hist(ax=ax)
+                        
+                        plt.xticks(rotation=45)
+                        plt.tight_layout()
+                        st.pyplot(fig)
+                else:
+                    st.info("Not enough numerical columns for visualization")
+                    
+            # Chat Interface
+            def format_response(response):
+                if isinstance(response, pd.DataFrame):
+                    return response.to_html()
+                elif isinstance(response, str):
+                    if 'Action Input:' in response:
+                        output_start = response.find('Action Input:') + len('Action Input:')
+                        return response[output_start:].strip()
+                    return response
+                return str(response)
+
+            with tabs[2]:
+                st.header("Chat with your Data")
+                
+                if "messages" not in st.session_state:
+                    st.session_state.messages = []
+
+                # Display chat history
+                for message in st.session_state.messages:
+                    with st.chat_message(message["role"]):
+                        if message["role"] == "assistant" and st.session_state.show_code:
+                            st.code(message["content"], language="python")
+                        else:
+                            st.markdown(f"<span style='background-color: #808080; color: white;'>{message['content']}</span>", unsafe_allow_html=True)
+
+                # Chat input and response
+                if prompt := st.chat_input("Ask about your data"):
+                    st.session_state.messages.append({"role": "user", "content": prompt})
+                    with st.chat_message("user"):
+                        st.markdown(f"<span style='background-color: #808080; color: white;'>{prompt}</span>", unsafe_allow_html=True)
+
+                    with st.chat_message("assistant"):
+                        try:
+                            agent = getAgent(df)
+                            response = agent.run(prompt)
+                            formatted_response = format_response(response)
+                            
+                            if st.session_state.show_code:
+                                st.code(formatted_response, language="python")
+                            else:
+                                st.markdown(f"<span style='background-color: #808080; color: white;'>{formatted_response}</span>", unsafe_allow_html=True)
+                            
+                            st.session_state.messages.append({
+                                "role": "assistant", 
+                                "content": formatted_response
+                            })
+                            analysis_code = "agent.run(prompt)"
+                            update_code_display(analysis_code, "chat")
+                        except Exception as e:
+                            st.error(f"Error: {str(e)}")
+                        
+    except Exception as e:
+        st.error(f"Error loading file: {str(e)}")
+else:
+    st.info("Please upload a CSV file to begin analysis")

utils.py

@@ -0,0 +1,42 @@
+import os
+from langchain_experimental.agents import create_pandas_dataframe_agent
+from langchain_google_genai import ChatGoogleGenerativeAI
+import pandas as pd
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def format_agent_output(output):
+    if isinstance(output, pd.DataFrame):
+        return output
+    elif isinstance(output, str):
+        if 'DataFrame' in output or 'describe' in output:
+            return pd.DataFrame(eval(output.split('Input:')[-1].strip()))
+        return output
+    return str(output)
+
+def readData(path):
+    try:
+        df = pd.read_csv(path)
+        return df
+    except Exception as e:
+        raise Exception(f"Error reading data: {str(e)}")
+
+def getAgent(data):
+    try:
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-pro",
+            temperature=0.5,
+            google_api_key=os.environ.get("GOOGLE_API_KEY")
+        )
+        
+        agent = create_pandas_dataframe_agent(
+            llm, 
+            data,
+            verbose=True,
+            handle_parsing_errors=True,
+            allow_dangerous_code=True  # Enable code execution
+        )
+        return agent
+    except Exception as e:
+        raise Exception(f"Error creating agent: {str(e)}")