Update pages/dashboard.py

pages/dashboard.py

@@ -1,408 +1,234 @@
-import gradio as gr
-import datetime
-from typing import Dict, List, Any, Union, Optional
-import random
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime, timedelta
+import numpy as np
 
 # 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.error_handling import show_error, show_success, show_warning
 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:
+def create_dashboard_page():
     """
-    Create the dashboard page with various widgets
-    
-    Args:
-        state: Application state
+    Create the main dashboard page for MONA
     """
-    logger.info("Creating dashboard page")
+    st.title("🤖 MONA - Monitoring & Analytics Dashboard")
     
-    # Create the dashboard layout
-    with gr.Column(elem_id="dashboard-page"):
-        gr.Markdown("# 🏠 Dashboard")
+    # Sidebar for navigation
+    with st.sidebar:
+        st.header("📊 Dashboard Controls")
+        
+        # Data source selection
+        data_source = st.selectbox(
+            "Select Data Source",
+            ["Sample Data", "Upload File", "Real-time Feed"]
+        )
         
-        # 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")
+        # Time range selection
+        st.subheader("Time Range")
+        time_range = st.selectbox(
+            "Select Time Range",
+            ["Last 24 Hours", "Last 7 Days", "Last 30 Days", "Custom"]
+        )
         
-        # 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)]
-                )
+        if time_range == "Custom":
+            start_date = st.date_input("Start Date", datetime.now() - timedelta(days=7))
+            end_date = st.date_input("End Date", datetime.now())
         
-        # 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))
+        # Refresh button
+        if st.button("🔄 Refresh Data"):
+            st.rerun()
+    
+    # Main dashboard content
+    col1, col2, col3, col4 = st.columns(4)
+    
+    # Key metrics
+    with col1:
+        st.metric(
+            label="System Status",
+            value="Online",
+            delta="✅"
+        )
+    
+    with col2:
+        st.metric(
+            label="Active Connections",
+            value="127",
+            delta="5",
+            delta_color="normal"
+        )
+    
+    with col3:
+        st.metric(
+            label="Data Points",
+            value="1,234",
+            delta="156",
+            delta_color="normal"
+        )
+    
+    with col4:
+        st.metric(
+            label="Success Rate",
+            value="99.8%",
+            delta="0.2%",
+            delta_color="normal"
+        )
+    
+    # Charts section
+    st.header("📈 Analytics")
+    
+    # Generate sample data for demonstration
+    sample_data = generate_sample_data()
+    
+    # Time series chart
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Time Series Analysis")
+        fig_line = px.line(
+            sample_data,
+            x='timestamp',
+            y='value',
+            title='Data Trends Over Time',
+            color_discrete_sequence=['#1f77b4']
+        )
+        fig_line.update_layout(
+            xaxis_title="Time",
+            yaxis_title="Value",
+            showlegend=False
+        )
+        st.plotly_chart(fig_line, use_container_width=True)
+    
+    with col2:
+        st.subheader("Distribution Analysis")
+        fig_hist = px.histogram(
+            sample_data,
+            x='value',
+            bins=20,
+            title='Value Distribution',
+            color_discrete_sequence=['#ff7f0e']
+        )
+        fig_hist.update_layout(
+            xaxis_title="Value",
+            yaxis_title="Frequency",
+            showlegend=False
+        )
+        st.plotly_chart(fig_hist, use_container_width=True)
+    
+    # Data table
+    st.header("📋 Data Overview")
+    
+    # Data filtering options
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        show_raw_data = st.checkbox("Show Raw Data", value=False)
+    
+    with col2:
+        max_rows = st.number_input("Max Rows", min_value=10, max_value=1000, value=100)
+    
+    with col3:
+        if st.button("Export Data"):
+            try:
+                success = save_data(sample_data.to_dict('records'), 'dashboard_export.json')
+                if success:
+                    show_success("Data exported successfully!")
+                else:
+                    show_error("Failed to export data")
+            except Exception as e:
+                show_error(f"Export error: {e}")
+    
+    if show_raw_data:
+        st.dataframe(
+            sample_data.head(max_rows),
+            use_container_width=True,
+            hide_index=True
+        )
+    
+    # System information
+    with st.expander("🔧 System Information"):
+        system_info = {
+            "Application": "MONA Dashboard",
+            "Version": "1.0.0",
+            "Last Updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "Data Points": len(sample_data),
+            "Status": "Operational"
+        }
+        
+        for key, value in system_info.items():
+            st.text(f"{key}: {value}")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        "**MONA Dashboard** - Monitoring & Analytics | "
+        f"Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
+    )
+
+def generate_sample_data():
+    """
+    Generate sample data for demonstration
+    """
+    try:
+        # Create time series data
+        dates = pd.date_range(
+            start=datetime.now() - timedelta(days=30),
+            end=datetime.now(),
+            freq='H'
+        )
+        
+        # Generate synthetic data with trend and noise
+        np.random.seed(42)  # For reproducible results
+        trend = np.linspace(100, 200, len(dates))
+        noise = np.random.normal(0, 10, len(dates))
+        seasonal = 20 * np.sin(2 * np.pi * np.arange(len(dates)) / 24)
+        
+        values = trend + seasonal + noise
+        
+        df = pd.DataFrame({
+            'timestamp': dates,
+            'value': values,
+            'category': np.random.choice(['A', 'B', 'C'], len(dates)),
+            'status': np.random.choice(['Active', 'Inactive'], len(dates), p=[0.8, 0.2])
+        })
+        
+        return df
+        
+    except Exception as e:
+        logger.error(f"Error generating sample data: {e}")
+        # Return minimal fallback data
+        return pd.DataFrame({
+            'timestamp': [datetime.now()],
+            'value': [100],
+            'category': ['A'],
+            'status': ['Active']
+        })
+
+def load_dashboard_config():
+    """
+    Load dashboard configuration
+    """
+    try:
+        config = load_data('dashboard_config.json')
+        if config is None:
+            # Create default config
+            default_config = {
+                'theme': 'light',
+                'refresh_interval': 30,
+                'max_data_points': 1000,
+                'charts_enabled': True
+            }
+            save_data(default_config, 'dashboard_config.json')
+            return default_config
+        return config
+    except Exception as e:
+        logger.error(f"Error loading dashboard config: {e}")
+        return {}
+
+# Initialize when module is imported
+if __name__ == "__main__":
+    create_dashboard_page()