Update app.py

app.py

@@ -1,25 +1,18 @@
 import streamlit as st
-import os
 import pandas as pd
-from pandasai import SmartDataframe
+from pandasai import SmartDataLake
 from pandasai.responses.response_parser import ResponseParser
 from pandasai.llm import GoogleGemini
-import plotly.graph_objects as go
+import plotly.express as px
 from PIL import Image
 import io
 import base64
-import requests
 import google.generativeai as genai
 from fpdf import FPDF
 import markdown2
 import re
-
-# API Endpoint and payload
-API_URL = "https://irisplus.elixir.co.zw/public/api/profile/reporting/stock-card/genericReports"
-PAYLOAD = {
-    "stock_card_report_id": "d2f1a0e1-7be1-472c-9610-94287154e544"
-}
-
+import json
+import os
 
 # Configure Gemini API
 gemini_api_key = os.environ.get('GOOGLE_API_KEY')
@@ -30,37 +23,67 @@ if not gemini_api_key:
 genai.configure(api_key=gemini_api_key)
 
 generation_config = {
-  "temperature": 0.2,
-  "top_p": 0.95,
-  "max_output_tokens": 5000,
+    "temperature": 0.2,
+    "top_p": 0.95,
+    "max_output_tokens": 5000,
 }
 
 model = genai.GenerativeModel(
-  model_name="gemini-2.0-flash-thinking-exp",
-  generation_config=generation_config,
+    model_name="gemini-2.0-flash-thinking-exp",
+    generation_config=generation_config,
 )
 
-def fetch_data():
-    """Fetch stock card report data from API and return cleaned DataFrame"""
-    response = requests.post(API_URL, data=PAYLOAD)
-    if response.status_code == 200:
-        try:
-            data = response.json()
-            if isinstance(data, dict) and 'actual_report' in data and isinstance(data['actual_report'], list):
-                df = pd.DataFrame(data['actual_report'])  # Convert list to DataFrame
-                # Remove columns where all values are None
-                df.dropna(axis=1, how='all', inplace=True)
-                return df
-            else:
-                st.error("Unexpected response format from API.")
-                return None
-        except ValueError:
-            st.error("Error: Response is not valid JSON.")
-            return None
-    else:
-        st.error(f"Error fetching data: {response.status_code} - {response.text}")
+def load_data():
+    """Load data from CSV files"""
+    try:
+        events_df = pd.read_csv("Delta-Events.csv")
+        customers_df = pd.read_csv("delta_customers.csv")
+        products_df = pd.read_csv("Customer_Products.csv")
+        return {
+            'events': events_df,
+            'customers': customers_df,
+            'products': products_df
+        }
+    except Exception as e:
+        st.error(f"Error loading data: {e}")
         return None
-        
+
+# Dashboard Tab Functions
+def create_dashboard(data):
+    """Create dashboard visualizations"""
+    st.header("Business Insights Dashboard")
+    
+    # Merge relevant data
+    merged_orders = pd.concat([
+        data['events'][['Surbub', 'Order Value $']].rename(columns={'Surbub': 'Suburb'}),
+        data['customers'][['Surburb', 'Order_Value']].rename(columns={'Surburb': 'Suburb', 'Order_Value': 'Order Value $'})
+    ])
+    
+    with st.container():
+        col1, col2 = st.columns(2)
+        with col1:
+            # Total Orders by Suburb
+            suburb_orders = merged_orders.groupby('Suburb')['Order Value $'].sum().reset_index()
+            fig = px.bar(suburb_orders, x='Suburb', y='Order Value $', 
+                        title='Total Order Value by Suburb')
+            st.plotly_chart(fig, use_container_width=True)
+            
+        with col2:
+            # Event Types Distribution
+            event_counts = data['events']['Event'].value_counts().reset_index()
+            fig = px.pie(event_counts, names='Event', values='count', 
+                         title='Event Type Distribution')
+            st.plotly_chart(fig, use_container_width=True)
+    
+    # Top Products Analysis
+    with st.container():
+        st.subheader("Product Performance")
+        product_sales = data['products'].groupby('Product')['Quantity'].sum().nlargest(10).reset_index()
+        fig = px.bar(product_sales, x='Product', y='Quantity', 
+                     title='Top 10 Products by Quantity Sold')
+        st.plotly_chart(fig, use_container_width=True)
+
+# ... [Keep the md_to_pdf, generate_pdf, StreamLitResponse, and generateResponse functions same as before but update generateResponse]
 def md_to_pdf(md_text, pdf):
     """Renders basic Markdown to PDF using fpdf text functions (limited formatting)."""
     md = markdown2.markdown(md_text)  # Parse Markdown
@@ -155,50 +178,29 @@ class StreamLitResponse(ResponseParser):
             'value': str(result['value'])
         }
 
-def generateResponse(prompt, df):
-    """Generate response using PandasAI with SmartDataframe"""
+def generateResponse(prompt, data):
+    """Generate response using PandasAI with SmartDataLake"""
     llm = GoogleGemini(api_key=gemini_api_key)
-    pandas_agent = SmartDataframe(df, config={
-        "llm": llm, 
-        "response_parser": StreamLitResponse
-    })
+    pandas_agent = SmartDataLake(
+        data.values(),
+        config={
+            "llm": llm, 
+            "response_parser": StreamLitResponse
+        }
+    )
     return pandas_agent.chat(prompt)
 
-def render_chat_message(message):
-    """Render different types of chat messages"""
-    if "dataframe" in message:
-        st.dataframe(message["dataframe"])
-    elif "plot" in message:
-        try:
-            plot_data = message["plot"]
-            if isinstance(plot_data, str):
-                st.image(f"data:image/png;base64,{plot_data}")
-            elif isinstance(plot_data, Image.Image):
-                st.image(plot_data)
-            elif isinstance(plot_data, go.Figure):
-                st.plotly_chart(plot_data)
-            elif isinstance(plot_data, bytes):
-                image = Image.open(io.BytesIO(plot_data))
-                st.image(image)
-            else:
-                st.write("Unsupported plot format")
-        except Exception as e:
-            st.error(f"Error rendering plot: {e}")
-    if "content" in message:
-        st.markdown(message["content"])
-
-def handle_userinput(question, df):
-    """Enhanced input handling with robust content processing"""
+def handle_userinput(question, data):
+    """Handle user input with SmartDataLake"""
     try:
-        # Ensure data is loaded and not empty
-        if df is not None and not df.empty:
-            # Append user input to chat history
+        if data and all(not df.empty for df in data.values()):
             st.session_state.chat_history.append({
                 "role": "user",
                 "content": question
             })
-            # Generate response with PandasAI
-            result = generateResponse(question, df)
+            
+            result = generateResponse(question, data)
+            # ... [Keep the rest of handle_userinput same as before]
             if isinstance(result, dict):
                 response_type = result.get('type', 'text')
                 response_value = result.get('value')
@@ -229,22 +231,30 @@ def handle_userinput(question, df):
     except Exception as e:
         st.error(f"Error processing input: {e}")
 
+
 def main():
-    st.set_page_config(page_title="AI Chat with Your Data", page_icon="📊")
+    st.set_page_config(page_title="Business Analytics Suite", page_icon="📊", layout="wide")
 
-    # Initialize session state variables if not present
+    # Initialize session state
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = []
-    if "dfs" not in st.session_state:
-        st.session_state.dfs = fetch_data()  # Load DataFrame at startup
+    if "data" not in st.session_state:
+        st.session_state.data = load_data()
 
-    # Create two tabs: Chat and Reports
-    tab_chat, tab_reports = st.tabs(["Chat", "Reports"])
+    # Create tabs
+    tab_dashboard, tab_chat, tab_reports = st.tabs(["📊 Dashboard", "💬 Chat", "📈 Reports"])
 
-    # --- Chat Tab ---
+    # Dashboard Tab
+    with tab_dashboard:
+        if st.session_state.data:
+            create_dashboard(st.session_state.data)
+        else:
+            st.error("Failed to load data for dashboard")
+
+    # Chat Tab
     with tab_chat:
-        st.title("AI Chat with Your Data 📊")
-        # Container for chat messages so they update smoothly
+        st.title("AI Data Analyst")
+        # ... [Keep chat interface similar but update handle_userinput calls to use st.session_state.data]
         chat_container = st.container()
         with chat_container:
             for message in st.session_state.chat_history:
@@ -260,32 +270,44 @@ def main():
                 for message in st.session_state.chat_history:
                     with st.chat_message(message["role"]):
                         render_chat_message(message)
-
-    # --- Reports Tab ---
-    # --- Reports Tab ---
+    # Reports Tab
     with tab_reports:
-        st.title("Reports")
-        st.write("Filter by product to generate a report")
-        df_report = fetch_data()
-        if df_report is not None and not df_report.empty:
-            product_names = df_report["product"].unique().tolist() if "product" in df_report.columns else []
-            selected_products = st.multiselect("Select Product(s)", product_names, default=product_names)
-            if st.button("Apply Filters and Generate Report"):
-                filtered_df = df_report.copy()
-                if selected_products:
-                    filtered_df = filtered_df[filtered_df["product"].isin(selected_products)]
-
-                st.write("Filtered DataFrame Preview:")
-                with st.expander("Preview"):
-                    st.dataframe(filtered_df.head())
-
-                with st.spinner("Generating Report, Please Wait...."):
+        st.title("Custom Reports")
+        if st.session_state.data:
+            # Suburb Filter
+            suburbs = pd.concat([
+                st.session_state.data['events']['Surbub'],
+                st.session_state.data['customers']['Surburb']
+            ]).unique()
+            selected_suburbs = st.multiselect("Select Suburbs", suburbs)
+            
+            if st.button("Generate Report"):
+                with st.spinner("Analyzing data..."):
+                    # Prepare filtered data
+                    filtered_data = {
+                        'events': st.session_state.data['events'][
+                            st.session_state.data['events']['Surbub'].isin(selected_suburbs)
+                        ] if selected_suburbs else st.session_state.data['events'],
+                        'customers': st.session_state.data['customers'][
+                            st.session_state.data['customers']['Surburb'].isin(selected_suburbs)
+                        ] if selected_suburbs else st.session_state.data['customers'],
+                        'products': st.session_state.data['products']
+                    }
+                    
+                    # Convert to JSON
+                    json_data = {k: v.to_json(orient='records') for k, v in filtered_data.items()}
+                    
+                    # Generate report
                     prompt = f"""
-                        You are an expert business analyst. Analyze the following data and generate a comprehensive and insightful business report including key performance indicators and recommendations.\n\nData:\n{filtered_df.to_markdown(index=False)}
-                    """  # Use to_markdown for better formatting
+                        Analyze this business data and generate a comprehensive report with key insights and recommendations.
+                        Data:
+                        {json.dumps(json_data, indent=2)}
+                    """
                     response = model.generate_content(prompt)
                     report = response.text
-
+                    
+                    # PDF Generation and display
+                    # ... [Keep the PDF generation code from original]
                     try:
                         pdf_bytes = generate_pdf(report)  # Use generate_pdf
                         st.download_button(
@@ -297,20 +319,17 @@ def main():
                         st.markdown(report)  # Display the report below the download button
                     except Exception as e:
                         st.error(f"Error generating PDF: {e}")
-                        st.markdown(report)  # Fallback to displaying report in markdown if PDF fails
+                        st.markdown(report)
         else:
-            st.error("No data available for reports.")
+            st.error("No data available for reports")
 
-    # --- Sidebar Options ---
+    # Sidebar
     with st.sidebar:
-        st.subheader("Options")
+        st.header("Data Management")
         if st.button("Reload Data"):
-            with st.spinner("Fetching latest data..."):
-                st.session_state.dfs = fetch_data()
-            st.success("Data refreshed!")
+            st.session_state.data = load_data()
         if st.button("Clear Chat"):
             st.session_state.chat_history = []
-            st.experimental_rerun()
-
+            
 if __name__ == "__main__":
     main()