Update pages/dashboard.py

pages/dashboard.py

@@ -1,166 +1,220 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-from datetime import datetime, timedelta
 import plotly.express as px
 import plotly.graph_objects as go
-from utils.storage import load_data, save_data, get_session_data, set_session_data
+from datetime import datetime, timedelta
+
+from utils.storage import load_data, save_data, load_dataframe, save_dataframe
+from utils.config import load_config, get_config_value
 from utils.error_handling import handle_ui_exceptions
-from utils.logging import log_info, log_error
+from utils.logging import get_logger
+
+logger = get_logger(__name__)
 
 @handle_ui_exceptions
 def create_dashboard_page():
-    """Create the main dashboard page with enhanced features"""
+    """Create the main dashboard page"""
+    st.title("📊 MONA Dashboard")
+    
+    config = load_config()
     
-    st.title("🏠 Dashboard")
-    st.markdown("---")
+    # Create tabs for different dashboard sections
+    tab1, tab2, tab3, tab4 = st.tabs(["Overview", "Analytics", "Data Upload", "Real-time"])
     
-    # Key metrics section
-    create_metrics_section()
+    with tab1:
+        create_overview_section()
     
-    # Charts section
-    create_charts_section()
+    with tab2:
+        create_analytics_section()
     
-    # Recent activity
-    create_activity_section()
+    with tab3:
+        create_data_upload_section()
     
-    # Quick actions
-    create_quick_actions()
+    with tab4:
+        create_realtime_section()
 
 @handle_ui_exceptions
-def create_metrics_section():
-    """Create the key metrics display"""
-    st.subheader("📊 Key Metrics")
+def create_overview_section():
+    """Create the overview section of the dashboard"""
+    st.header("📈 Overview")
     
-    # Sample metrics - in a real app, these would come from your data
+    # Create sample metrics
     col1, col2, col3, col4 = st.columns(4)
     
     with col1:
-        st.metric(
-            label="Total Users",
-            value="2,847",
-            delta="12%",
-            help="Total registered users"
-        )
+        st.metric("Total Records", "1,234", "12%")
     
     with col2:
-        st.metric(
-            label="Active Sessions",
-            value="456",
-            delta="8%",
-            help="Currently active user sessions"
-        )
+        st.metric("Active Users", "567", "8%")
     
     with col3:
-        st.metric(
-            label="Messages Today",
-            value="1,234",
-            delta="-3%",
-            help="Messages sent today"
-        )
+        st.metric("Processing Time", "2.3s", "-0.5s")
     
     with col4:
-        st.metric(
-            label="System Uptime",
-            value="99.9%",
-            delta="0.1%",
-            help="System availability"
-        )
-
-@handle_ui_exceptions
-def create_charts_section():
-    """Create charts and visualizations"""
-    st.subheader("📈 Analytics")
+        st.metric("Success Rate", "98.5%", "1.2%")
     
+    # Create sample charts
     col1, col2 = st.columns(2)
     
     with col1:
-        # Line chart for usage over time
-        st.write("**Usage Trend (Last 30 Days)**")
-        
+        st.subheader("📊 Trend Analysis")
         # Generate sample data
-        dates = pd.date_range(start=datetime.now() - timedelta(days=30), 
-                             end=datetime.now(), 
-                             freq='D')
+        dates = pd.date_range(start='2024-01-01', end='2024-12-31', freq='D')
+        values = np.random.randn(len(dates)).cumsum() + 100
         
-        usage_data = pd.DataFrame({
+        df = pd.DataFrame({
             'Date': dates,
-            'Users': np.random.randint(50, 200, len(dates)),
-            'Messages': np.random.randint(100, 500, len(dates))
+            'Value': values
         })
         
-        fig = px.line(usage_data, x='Date', y=['Users', 'Messages'],
-                     title="Daily Usage Statistics")
+        fig = px.line(df, x='Date', y='Value', title='Daily Trend')
         st.plotly_chart(fig, use_container_width=True)
     
     with col2:
-        # Pie chart for user distribution
-        st.write("**User Distribution**")
-        
-        user_types = ['Free Users', 'Premium Users', 'Enterprise']
-        user_counts = [1200, 800, 400]
+        st.subheader("📦 Category Distribution")
+        categories = ['A', 'B', 'C', 'D', 'E']
+        values = np.random.randint(10, 100, size=len(categories))
         
-        fig = px.pie(values=user_counts, names=user_types,
-                    title="User Type Distribution")
+        fig = px.pie(values=values, names=categories, title='Category Distribution')
         st.plotly_chart(fig, use_container_width=True)
 
 @handle_ui_exceptions
-def create_activity_section():
-    """Create recent activity feed"""
-    st.subheader("🔔 Recent Activity")
-    
-    # Sample activity data
-    activities = [
-        {"time": "2 minutes ago", "action": "New user registered", "user": "[email protected]"},
-        {"time": "5 minutes ago", "action": "Message sent", "user": "[email protected]"},
-        {"time": "10 minutes ago", "action": "File uploaded", "user": "[email protected]"},
-        {"time": "15 minutes ago", "action": "Settings updated", "user": "[email protected]"},
-        {"time": "20 minutes ago", "action": "Login", "user": "[email protected]"}
-    ]
-    
-    for activity in activities:
-        with st.container():
-            col1, col2, col3 = st.columns([2, 4, 2])
-            with col1:
-                st.write(activity["time"])
-            with col2:
-                st.write(f"**{activity['action']}** - {activity['user']}")
-            with col3:
-                st.write("✓")
-        st.markdown("---")
-
-@handle_ui_exceptions
-def create_quick_actions():
-    """Create quick action buttons"""
-    st.subheader("⚡ Quick Actions")
+def create_analytics_section():
+    """Create the analytics section"""
+    st.header("🔍 Analytics")
     
-    col1, col2, col3, col4 = st.columns(4)
+    # Data filtering options
+    col1, col2, col3 = st.columns(3)
     
     with col1:
-        if st.button("💬 Start Chat", use_container_width=True):
-            st.switch_page("pages/chat.py")
+        date_range = st.date_input(
+            "Select Date Range",
+            value=(datetime.now() - timedelta(days=30), datetime.now()),
+            max_value=datetime.now()
+        )
     
     with col2:
-        if st.button("📊 View Analytics", use_container_width=True):
-            st.switch_page("pages/analytics.py")
+        chart_type = st.selectbox(
+            "Chart Type",
+            ["Line", "Bar", "Scatter", "Area", "Histogram"]
+        )
     
     with col3:
-        if st.button("⚙️ Settings", use_container_width=True):
-            st.switch_page("pages/settings.py")
+        metric = st.selectbox(
+            "Metric",
+            ["Revenue", "Users", "Sessions", "Conversions"]
+        )
     
-    with col4:
-        if st.button("📁 File Manager", use_container_width=True):
-            st.switch_page("pages/files.py")
+    # Generate analytics data based on selections
+    if len(date_range) == 2:
+        start_date, end_date = date_range
+        days = (end_date - start_date).days + 1
+        
+        # Generate sample data
+        dates = pd.date_range(start=start_date, end=end_date, freq='D')
+        values = np.random.randn(len(dates)).cumsum() + np.random.randint(50, 200)
+        
+        df = pd.DataFrame({
+            'Date': dates,
+            metric: values
+        })
+        
+        # Create chart based on selection
+        if chart_type == "Line":
+            fig = px.line(df, x='Date', y=metric, title=f'{metric} Over Time')
+        elif chart_type == "Bar":
+            fig = px.bar(df, x='Date', y=metric, title=f'{metric} by Day')
+        elif chart_type == "Scatter":
+            df['Random'] = np.random.randn(len(df))
+            fig = px.scatter(df, x='Random', y=metric, title=f'{metric} Scatter Plot')
+        elif chart_type == "Area":
+            fig = px.area(df, x='Date', y=metric, title=f'{metric} Area Chart')
+        elif chart_type == "Histogram":
+            fig = px.histogram(df, x=metric, title=f'{metric} Distribution')
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Show data table
+        with st.expander("View Raw Data"):
+            st.dataframe(df)
 
-# Export the main function
-def main():
-    """Main function for the dashboard page"""
-    try:
-        create_dashboard_page()
-        log_info("Dashboard page loaded successfully")
-    except Exception as e:
-        log_error("Error loading dashboard page", error=e)
-        st.error("Failed to load dashboard. Please try refreshing the page.")
+@handle_ui_exceptions
+def create_data_upload_section():
+    """Create the data upload section"""
+    st.header("📤 Data Upload")
+    
+    # File upload
+    uploaded_file = st.file_uploader(
+        "Upload your data file",
+        type=['csv', 'xlsx', 'json'],
+        help="Supported formats: CSV, Excel, JSON"
+    )
+    
+    if uploaded_file is not None:
+        try:
+            # Read the uploaded file
+            if uploaded_file.name.endswith('.csv'):
+                df = pd.read_csv(uploaded_file)
+            elif uploaded_file.name.endswith('.xlsx'):
+                df = pd.read_excel(uploaded_file)
+            elif uploaded_file.name.endswith('.json'):
+                df = pd.read_json(uploaded_file)
+            
+            st.success(f"File uploaded successfully! Shape: {df.shape}")
+            
+            # Display data preview
+            st.subheader("Data Preview")
+            st.dataframe(df.head())
+            
+            # Data summary
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("Data Info")
+                st.write(f"**Rows:** {len(df)}")
+                st.write(f"**Columns:** {len(df.columns)}")
+                st.write(f"**File Size:** {uploaded_file.size} bytes")
+            
+            with col2:
+                st.subheader("Column Types")
+                for col, dtype in df.dtypes.items():
+                    st.write(f"**{col}:** {dtype}")
+            
+            # Save data option
+            if st.button("Save Data"):
+                save_dataframe(df, f"uploaded_data_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+                st.success("Data saved successfully!")
+            
+            # Basic analytics on uploaded data
+            if len(df.select_dtypes(include=[np.number]).columns) > 0:
+                st.subheader("Quick Analytics")
+                numeric_cols = df.select_dtypes(include=[np.number]).columns
+                
+                selected_col = st.selectbox("Select column for analysis", numeric_cols)
+                
+                if selected_col:
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        fig = px.histogram(df, x=selected_col, title=f'Distribution of {selected_col}')
+                        st.plotly_chart(fig, use_container_width=True)
+                    
+                    with col2:
+                        fig = px.box(df, y=selected_col, title=f'Box Plot of {selected_col}')
+                        st.plotly_chart(fig, use_container_width=True)
+        
+        except Exception as e:
+            st.error(f"Error processing file: {str(e)}")
+            logger.error(f"File processing error: {str(e)}")
 
-if __name__ == "__main__":
-    main()
+@handle_ui_exceptions
+def create_realtime_section():
+    """Create the real-time monitoring section"""
+    st.header("⚡ Real-time Monitoring")
+    
+    # Auto-refresh toggle
+    auto_refresh = st.checkbox("Enable Auto-refresh", value=False)
+    
+    if auto_refresh:
+        refresh_interval = st.slider("Refresh Interval (seconds)",