Update pages/dashboard.py

pages/dashboard.py

@@ -1,408 +1,157 @@
-import gradio as gr
-import datetime
-from typing import Dict, List, Any, Union, Optional
-import random
+"""
+Dashboard page for the MONA application
+Fixed version with proper imports and error handling
+"""
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+
+from utils.storage import load_data, save_data, get_cached_data, set_cached_data
+from utils.error_handling import handle_data_exceptions, ErrorHandler, ValidationError, DataError
+from utils.logging import get_logger, log_info, log_error, log_warning
 
-# Import utilities
-from utils.storage import load_data, save_data
-from utils.state import generate_id, get_timestamp, record_activity
-from utils.ai_models import generate_motivation_quote, generate_daily_plan, get_weather
-from utils.ui_components import (
-    create_card, create_stat_card, create_progress_ring, create_activity_item,
-    create_deadline_item, create_streak_counter, create_weather_widget
-)
-from utils.config import FILE_PATHS
-from utils.logging import get_logger
-from utils.error_handling import handle_exceptions, ValidationError, safe_get
 
 # Initialize logger
 logger = get_logger(__name__)
 
-@handle_exceptions
-def create_dashboard_page(state: Dict[str, Any]) -> None:
+
+@handle_data_exceptions
+def load_dashboard_data() -> Dict[str, Any]:
+    """
+    Load dashboard data with caching
+    
+    Returns:
+        Dict: Dashboard data including metrics, charts data, etc.
+    """
+    # Try to get from cache first
+    cached_data = get_cached_data("dashboard_data")
+    if cached_data:
+        log_info("Using cached dashboard data")
+        return cached_data
+    
+    try:
+        # Load data from storage
+        data = {
+            "metrics": load_data("dashboard_metrics.json", default={}),
+            "user_activity": load_data("user_activity.json", default=[]),
+            "system_stats": load_data("system_stats.json", default={}),
+            "recent_events": load_data("recent_events.json", default=[]),
+            "performance_data": load_data("performance_data.json", default=[])
+        }
+        
+        # Cache the data
+        set_cached_data("dashboard_data", data)
+        log_info("Dashboard data loaded and cached successfully")
+        
+        return data
+        
+    except Exception as e:
+        log_error("Failed to load dashboard data", error=e)
+        return {
+            "metrics": {},
+            "user_activity": [],
+            "system_stats": {},
+            "recent_events": [],
+            "performance_data": []
+        }
+
+
+@handle_data_exceptions
+def create_metrics_cards(metrics: Dict[str, Any]) -> None:
+    """
+    Create and display metrics cards
+    
+    Args:
+        metrics: Dictionary containing metric values
+    """
+    if not metrics:
+        st.warning("No metrics data available")
+        return
+    
+    # Create columns for metrics
+    cols = st.columns(4)
+    
+    # Total Users
+    with cols[0]:
+        total_users = metrics.get("total_users", 0)
+        st.metric(
+            label="Total Users",
+            value=f"{total_users:,}",
+            delta=metrics.get("users_change", 0)
+        )
+    
+    # Active Sessions
+    with cols[1]:
+        active_sessions = metrics.get("active_sessions", 0)
+        st.metric(
+            label="Active Sessions",
+            value=f"{active_sessions:,}",
+            delta=metrics.get("sessions_change", 0)
+        )
+    
+    # System Health
+    with cols[2]:
+        system_health = metrics.get("system_health", 0)
+        st.metric(
+            label="System Health",
+            value=f"{system_health:.1f}%",
+            delta=f"{metrics.get('health_change', 0):.1f}%"
+        )
+    
+    # Response Time
+    with cols[3]:
+        response_time = metrics.get("avg_response_time", 0)
+        st.metric(
+            label="Avg Response Time",
+            value=f"{response_time:.0f}ms",
+            delta=f"{metrics.get('response_change', 0):.0f}ms",
+            delta_color="inverse"
+        )
+
+
+@handle_data_exceptions
+def create_activity_chart(activity_data: List[Dict]) -> None:
     """
-    Create the dashboard page with various widgets
+    Create user activity chart
     
     Args:
-        state: Application state
+        activity_data: List of activity data points
     """
-    logger.info("Creating dashboard page")
+    if not activity_data:
+        st.warning("No activity data available")
+        return
     
-    # Create the dashboard layout
-    with gr.Column(elem_id="dashboard-page"):
-        gr.Markdown("# 🏠 Dashboard")
+    try:
+        df = pd.DataFrame(activity_data)
+        
+        if df.empty:
+            st.warning("Activity data is empty")
+            return
+        
+        # Ensure required columns exist
+        if 'timestamp' not in df.columns:
+            df['timestamp'] = pd.date_range(start='2024-01-01', periods=len(df), freq='H')
+        
+        if 'users' not in df.columns:
+            df['users'] = [0] * len(df)
         
-        # Top row - Today's Focus and Quick Stats
-        with gr.Row():
-            # Today's Focus Widget
-            with gr.Column(scale=2):
-                with gr.Group(elem_classes=["focus-widget"]):
-                    gr.Markdown("### 🎯 Today's Focus")
-                    focus_input = gr.Textbox(
-                        placeholder="What's your main focus for today?",
-                        label="",
-                        elem_id="focus-input"
-                    )
-                    motivation_text = gr.Markdown(
-                        "*Set your focus for today to get an AI-powered motivation boost!*"
-                    )
-                    
-                    @handle_exceptions
-                    def update_focus(focus_text):
-                        """Update the focus and generate motivation"""
-                        if not focus_text.strip():
-                            logger.debug("Empty focus text submitted")
-                            return "*Set your focus for today to get an AI-powered motivation boost!*"
-                        
-                        logger.info(f"Setting focus: {focus_text[:30]}...")
-                        
-                        # Generate a motivational response
-                        motivation = generate_motivation_quote()
-                        
-                        # Record the activity
-                        record_activity({
-                            "type": "focus_set",
-                            "title": focus_text,
-                            "timestamp": datetime.datetime.now().isoformat()
-                        })
-                        
-                        return f"*{motivation}*"
-                    
-                    focus_input.change(update_focus, inputs=[focus_input], outputs=[motivation_text])
-            
-            # Quick Stats Cards
-            with gr.Column(scale=2):
-                with gr.Row():
-                    create_stat_card("Tasks", safe_get(state, ["stats", "tasks_total"], 0), icon="📋", color="blue")
-                    create_stat_card("Completed", safe_get(state, ["stats", "tasks_completed"], 0), icon="✅", color="green")
-                
-                with gr.Row():
-                    create_stat_card("Notes", safe_get(state, ["stats", "notes_total"], 0), icon="📝", color="yellow")
-                    create_stat_card("Goals", safe_get(state, ["stats", "goals_total"], 0), icon="🎯", color="purple")
+        # Convert timestamp to datetime if it's not already
+        df['timestamp'] = pd.to_datetime(df['timestamp'])
         
-        # Middle row - Activity Feed, AI Daily Planner, and Weather
-        with gr.Row():
-            # Activity Feed
-            with gr.Column(scale=2):
-                with gr.Group(elem_classes=["activity-feed"]):
-                    gr.Markdown("### 📊 Activity Feed")
-                    
-                    # Display activity items
-                    if safe_get(state, "activity_feed", []):
-                        for activity in state["activity_feed"][:10]:  # Show up to 10 activities
-                            create_activity_item(activity)
-                    else:
-                        gr.Markdown("*No recent activity*")
-            
-            # Right column - AI Daily Planner and Weather
-            with gr.Column(scale=2):
-                # AI Daily Planner
-                with gr.Group(elem_classes=["daily-planner"]):
-                    gr.Markdown("### 📅 AI Daily Planner")
-                    
-                    # Generate a daily plan based on tasks and goals
-                    daily_plan = generate_daily_plan(
-                        safe_get(state, "tasks", []), 
-                        safe_get(state, "goals", [])
-                    )
-                    
-                    gr.Markdown(daily_plan)
-                    
-                    refresh_plan_btn = gr.Button("Refresh Plan")
-                    
-                    @handle_exceptions
-                    def refresh_daily_plan():
-                        """Refresh the daily plan"""
-                        logger.debug("Refreshing daily plan")
-                        return generate_daily_plan(
-                            safe_get(state, "tasks", []), 
-                            safe_get(state, "goals", [])
-                        )
-                    
-                    refresh_plan_btn.click(refresh_daily_plan, inputs=[], outputs=[gr.Markdown(visible=False)])
-                
-                # Weather Widget
-                weather_data = get_weather("New York")  # Default city
-                create_weather_widget(weather_data)
-                
-                # City input for weather
-                with gr.Row():
-                    city_input = gr.Textbox(
-                        placeholder="Enter city name",
-                        label="Change Location",
-                        elem_id="weather-city-input"
-                    )
-                    update_weather_btn = gr.Button("Update")
-                
-                @handle_exceptions
-                def update_weather(city):
-                    """Update weather for the specified city"""
-                    if not city.strip():
-                        logger.debug("Empty city name, using default")
-                        city = "New York"  # Default city
-                    
-                    logger.info(f"Updating weather for city: {city}")
-                    weather_data = get_weather(city)
-                    return create_weather_widget(weather_data)
-                
-                update_weather_btn.click(
-                    update_weather, 
-                    inputs=[city_input], 
-                    outputs=[gr.Group(visible=False)]
-                )
+        # Create the chart
+        fig = px.line(
+            df,
+            x='timestamp',
+            y='users',
+            title='User Activity Over Time',
+            labels={'users': 'Active Users', 'timestamp': 'Time'}
+        )
         
-        # Bottom row - Motivation Quotes, Quick Entry, Deadline Tracker, Progress, Streak
-        with gr.Row():
-            # Left column - Motivation Quotes and Quick Entry
-            with gr.Column(scale=2):
-                # Motivation Quotes
-                with gr.Group(elem_classes=["motivation-quotes"]):
-                    gr.Markdown("### ✨ Daily Inspiration")
-                    
-                    # Generate a motivational quote
-                    quote = generate_motivation_quote()
-                    quote_display = gr.Markdown(f"*\"{quote}\"*")
-                    
-                    refresh_quote_btn = gr.Button("New Quote")
-                    
-                    @handle_exceptions
-                    def refresh_quote():
-                        """Refresh the motivational quote"""
-                        logger.debug("Refreshing motivational quote")
-                        return f"*\"{generate_motivation_quote()}\"*"
-                    
-                    refresh_quote_btn.click(refresh_quote, inputs=[], outputs=[quote_display])
-                
-                # Quick Entry Panel
-                with gr.Group(elem_classes=["quick-entry"]):
-                    gr.Markdown("### ⚡ Quick Add")
-                    
-                    quick_entry_tabs = gr.Tabs([
-                        ("Task", "task"),
-                        ("Note", "note"),
-                        ("Goal", "goal")
-                    ])
-                    
-                    with quick_entry_tabs.select("task"):
-                        task_title = gr.Textbox(placeholder="Task title", label="Title")
-                        task_desc = gr.Textbox(placeholder="Task description (optional)", label="Description")
-                        task_priority = gr.Dropdown(
-                            choices=["High", "Medium", "Low"],
-                            value="Medium",
-                            label="Priority"
-                        )
-                        add_task_btn = gr.Button("Add Task")
-                    
-                    with quick_entry_tabs.select("note"):
-                        note_title = gr.Textbox(placeholder="Note title", label="Title")
-                        note_content = gr.Textbox(
-                            placeholder="Note content", 
-                            label="Content",
-                            lines=3
-                        )
-                        add_note_btn = gr.Button("Add Note")
-                    
-                    with quick_entry_tabs.select("goal"):
-                        goal_title = gr.Textbox(placeholder="Goal title", label="Title")
-                        goal_desc = gr.Textbox(placeholder="Goal description (optional)", label="Description")
-                        goal_deadline = gr.Textbox(
-                            placeholder="YYYY-MM-DD (optional)",
-                            label="Target Date"
-                        )
-                        add_goal_btn = gr.Button("Add Goal")
-                    
-                    # Add task function
-                    @handle_exceptions
-                    def add_task(title, description, priority):
-                        """Add a new task"""
-                        if not title.strip():
-                            logger.warning("Attempted to add task with empty title")
-                            return "Please enter a task title", task_title, task_desc
-                        
-                        logger.info(f"Adding new task: {title}")
-                        
-                        # Create new task
-                        new_task = {
-                            "id": generate_id(),
-                            "title": title.strip(),
-                            "description": description.strip(),
-                            "priority": priority.lower(),
-                            "status": "todo",
-                            "completed": False,
-                            "created_at": get_timestamp()
-                        }
-                        
-                        # Add to state
-                        state["tasks"].append(new_task)
-                        state["stats"]["tasks_total"] += 1
-                        
-                        # Record activity
-                        record_activity({
-                            "type": "task_created",
-                            "title": title,
-                            "timestamp": datetime.datetime.now().isoformat()
-                        })
-                        
-                        # Save to file
-                        save_data(FILE_PATHS["tasks"], state["tasks"])
-                        
-                        return "Task added successfully!", gr.update(value=""), gr.update(value="")
-                    
-                    add_task_btn.click(
-                        add_task,
-                        inputs=[task_title, task_desc, task_priority],
-                        outputs=[gr.Markdown(visible=False), task_title, task_desc]
-                    )
-                    
-                    # Add note function
-                    @handle_exceptions
-                    def add_note(title, content):
-                        """Add a new note"""
-                        if not title.strip():
-                            logger.warning("Attempted to add note with empty title")
-                            return "Please enter a note title", note_title, note_content
-                        
-                        logger.info(f"Adding new note: {title}")
-                        
-                        # Create new note
-                        new_note = {
-                            "id": generate_id(),
-                            "title": title.strip(),
-                            "content": content.strip(),
-                            "created_at": get_timestamp(),
-                            "updated_at": get_timestamp()
-                        }
-                        
-                        # Add to state
-                        state["notes"].append(new_note)
-                        state["stats"]["notes_total"] += 1
-                        
-                        # Record activity
-                        record_activity({
-                            "type": "note_created",
-                            "title": title,
-                            "timestamp": datetime.datetime.now().isoformat()
-                        })
-                        
-                        # Save to file
-                        save_data(FILE_PATHS["notes"], state["notes"])
-                        
-                        return "Note added successfully!", gr.update(value=""), gr.update(value="")
-                    
-                    add_note_btn.click(
-                        add_note,
-                        inputs=[note_title, note_content],
-                        outputs=[gr.Markdown(visible=False), note_title, note_content]
-                    )
-                    
-                    # Add goal function
-                    @handle_exceptions
-                    def add_goal(title, description, deadline):
-                        """Add a new goal"""
-                        if not title.strip():
-                            logger.warning("Attempted to add goal with empty title")
-                            return "Please enter a goal title", goal_title, goal_desc, goal_deadline
-                        
-                        logger.info(f"Adding new goal: {title}")
-                        
-                        # Validate deadline format if provided
-                        deadline_iso = None
-                        if deadline.strip():
-                            try:
-                                deadline_date = datetime.datetime.strptime(deadline.strip(), "%Y-%m-%d")
-                                deadline_iso = deadline_date.isoformat()
-                            except ValueError as e:
-                                logger.warning(f"Invalid date format: {deadline}, error: {str(e)}")
-                                return "Invalid date format. Use YYYY-MM-DD", goal_title, goal_desc, goal_deadline
-                        
-                        # Create new goal
-                        new_goal = {
-                            "id": generate_id(),
-                            "title": title.strip(),
-                            "description": description.strip(),
-                            "completed": False,
-                            "created_at": get_timestamp()
-                        }
-                        
-                        if deadline_iso:
-                            new_goal["deadline"] = deadline_iso
-                        
-                        # Add to state
-                        state["goals"].append(new_goal)
-                        state["stats"]["goals_total"] += 1
-                        
-                        # Record activity
-                        record_activity({
-                            "type": "goal_created",
-                            "title": title,
-                            "timestamp": datetime.datetime.now().isoformat()
-                        })
-                        
-                        # Save to file
-                        save_data(FILE_PATHS["goals"], state["goals"])
-                        
-                        return "Goal added successfully!", gr.update(value=""), gr.update(value=""), gr.update(value="")
-                    
-                    add_goal_btn.click(
-                        add_goal,
-                        inputs=[goal_title, goal_desc, goal_deadline],
-                        outputs=[gr.Markdown(visible=False), goal_title, goal_desc, goal_deadline]
-                    )
-            
-            # Right column - Deadline Tracker, Progress Rings, Streak Counter
-            with gr.Column(scale=2):
-                # Deadline Tracker
-                with gr.Group(elem_classes=["deadline-tracker"]):
-                    gr.Markdown("### ⏰ Upcoming Deadlines")
-                    
-                    # Get tasks with deadlines
-                    tasks_with_deadlines = []
-                    for task in safe_get(state, "tasks", []):
-                        if "deadline" in task and not safe_get(task, "completed", False):
-                            tasks_with_deadlines.append(task)
-                    
-                    # Sort by deadline (closest first)
-                    tasks_with_deadlines.sort(key=lambda x: x["deadline"])
-                    
-                    # Display deadline items
-                    if tasks_with_deadlines:
-                        for task in tasks_with_deadlines[:5]:  # Show up to 5 deadlines
-                            create_deadline_item(task)
-                    else:
-                        gr.Markdown("*No upcoming deadlines*")
-                
-                # Progress Rings
-                with gr.Group(elem_classes=["progress-rings"]):
-                    gr.Markdown("### 📊 Progress")
-                    
-                    with gr.Row():
-                        # Task completion progress
-                        task_completion = 0
-                        tasks_total = safe_get(state, ["stats", "tasks_total"], 0)
-                        if tasks_total > 0:
-                            task_completion = (safe_get(state, ["stats", "tasks_completed"], 0) / tasks_total) * 100
-                        
-                        create_progress_ring(
-                            value=task_completion,
-                            max_value=100,
-                            size=120,
-                            color="blue",
-                            label="Tasks"
-                        )
-                        
-                        # Goal completion progress
-                        goal_completion = 0
-                        goals_total = safe_get(state, ["stats", "goals_total"], 0)
-                        if goals_total > 0:
-                            goal_completion = (safe_get(state, ["stats", "goals_completed"], 0) / goals_total) * 100
-                        
-                        create_progress_ring(
-                            value=goal_completion,
-                            max_value=100,
-                            size=120,
-                            color="purple",
-                            label="Goals"
-                        )
-                
-                # Streak Counter
-                create_streak_counter(safe_get(state, ["stats", "streak_days"], 0))
+        fig.update_layout(
+            xaxis_title="Time",
+            yaxis_title="Active Users",
+            h