Update app.py

app.py

@@ -1,144 +1,282 @@
-import gradio as gr
-import os
-import json
-import datetime
+"""
+Main application file for MONA
+Fixed version with proper imports and error handling
+"""
+
+import streamlit as st
+import sys
 from pathlib import Path
 
-# Import pages
-from pages.dashboard import create_dashboard_page
-from pages.tasks import create_tasks_page
-from pages.notes import create_notes_page
-from pages.goals import create_goals_page
-from pages.ai_assistant import create_ai_assistant_page
-from pages.search import create_search_page
-from pages.analytics import create_analytics_page
-from pages.focus import create_focus_page
-from pages.integrations_new import create_integrations_page  # Using the new integrations page
-from pages.settings import create_settings_page
-from pages.multimedia import create_multimedia_page
-
-# Import utilities
-from utils.storage import load_data, save_data
-from utils.state import initialize_state, record_activity
-from utils.config import DATA_DIR, LOGGING_CONFIG
-from utils.logging import get_logger
-from utils.error_handling import handle_exceptions
-
-# Initialize logger
-logger = get_logger(__name__)
-
-# Define sidebar items
-sidebar_items = [
-    "🏠 Dashboard",
-    "📋 Tasks & Projects",
-    "📝 Notes & Docs",
-    "🎯 Goals & Planning",
-    "🤖 AI Assistant Hub",
-    "🔍 Smart Search",
-    "📊 Analytics",
-    "🧘 Focus & Wellness",
-    "🖼️ Multimedia",
-    "🔄 Integrations",
-    "⚙️ Settings"
-]
-
-# Map sidebar items to page creation functions
-page_creators = {
-    "🏠 Dashboard": create_dashboard_page,
-    "📋 Tasks & Projects": create_tasks_page,
-    "📝 Notes & Docs": create_notes_page,
-    "🎯 Goals & Planning": create_goals_page,
-    "🤖 AI Assistant Hub": create_ai_assistant_page,
-    "🔍 Smart Search": create_search_page,
-    "📊 Analytics": create_analytics_page,
-    "🧘 Focus & Wellness": create_focus_page,
-    "🖼️ Multimedia": create_multimedia_page,
-    "🔄 Integrations": create_integrations_page,
-    "⚙️ Settings": create_settings_page
-}
-
-@handle_exceptions
-def create_app():
-    """Create and configure the Gradio application"""
-    logger.info("Initializing Mona application")
+# Add the current directory to Python path for imports
+current_dir = Path(__file__).parent
+sys.path.append(str(current_dir))
+
+try:
+    from pages.dashboard import create_dashboard_page
+    from utils.logging import setup_logging, get_logger, log_info, log_error
+    from utils.error_handling import ErrorHandler
+    from utils.storage import initialize_sample_data
+except ImportError as e:
+    st.error(f"Import Error: {str(e)}")
+    st.error("Please ensure all required files are present and properly configured.")
+    st.stop()
+
+
+def setup_streamlit_config():
+    """Configure Streamlit page settings"""
+    st.set_page_config(
+        page_title="MONA - Dashboard",
+        page_icon="🎯",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+
+
+def create_sidebar():
+    """Create application sidebar"""
+    with st.sidebar:
+        st.title("🎯 MONA")
+        st.markdown("---")
+        
+        # Navigation
+        st.subheader("Navigation")
+        page = st.selectbox(
+            "Select Page",
+            ["Dashboard", "Analytics", "Settings", "Help"],
+            index=0
+        )
+        
+        st.markdown("---")
+        
+        # Quick Stats
+        st.subheader("Quick Stats")
+        try:
+            from utils.storage import load_data
+            metrics = load_data("dashboard_metrics.json", default={})
+            
+            if metrics:
+                st.metric("Total Users", f"{metrics.get('total_users', 0):,}")
+                st.metric("Active Sessions", f"{metrics.get('active_sessions', 0):,}")
+                st.metric("System Health", f"{metrics.get('system_health', 0):.1f}%")
+        except Exception as e:
+            st.warning("Could not load quick stats")
+        
+        st.markdown("---")
+        
+        # System Status
+        st.subheader("System Status")
+        st.success("🟢 All Systems Operational")
+        
+        return page
+
+
+def create_header():
+    """Create application header"""
+    col1, col2, col3 = st.columns([2, 6, 2])
+    
+    with col1:
+        st.image("https://via.placeholder.com/100x50/4CAF50/FFFFFF?text=MONA", width=100)
+    
+    with col2:
+        st.markdown("""
+        <h1 style='text-align: center; color: #1f77b4;'>
+            MONA Monitoring & Analytics Platform
+        </h1>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        if st.button("🔄 Refresh All"):
+            from utils.storage import clear_cache
+            clear_cache()
+            st.rerun()
+
+
+def create_footer():
+    """Create application footer"""
+    st.markdown("---")
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        st.markdown("""
+        <div style='text-align: center; color: #666;'>
+            <p>MONA Platform v2.1.0 | Built with Streamlit</p>
+            <p>© 2024 MONA Systems. All rights reserved.</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+
+def create_analytics_page():
+    """Create analytics page (placeholder)"""
+    st.title("📈 Analytics")
+    st.info("Analytics page coming soon...")
+    
+    # Placeholder content
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("Data Overview")
+        st.write("• Total Records: 10,000+")
+        st.write("• Data Sources: 5")
+        st.write("• Last Update: Just now")
+    
+    with col2:
+        st.subheader("Quick Actions")
+        if st.button("Generate Report"):
+            st.success("Report generation initiated")
+        if st.button("Export Data"):
+            st.success("Data export started")
+
+
+def create_settings_page():
+    """Create settings page (placeholder)"""
+    st.title("⚙️ Settings")
     
-    # Initialize application state
-    state = initialize_state()
+    tab1, tab2, tab3 = st.tabs(["General", "Security", "Advanced"])
     
-    # Create the Gradio Blocks app
-    with gr.Blocks(title="Mona - AI Productivity Platform", theme=gr.themes.Soft()) as app:
-        # Create header
-        with gr.Row(elem_id="header"):
-            gr.Markdown("# Mona - AI Productivity Platform")
+    with tab1:
+        st.subheader("General Settings")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.text_input("Application Name", value="MONA")
+            st.selectbox("Theme", ["Light", "Dark", "Auto"])
+            st.selectbox("Language", ["English", "Spanish", "French"])
+        
+        with col2:
+            st.number_input("Refresh Interval (seconds)", min_value=1, max_value=300, value=30)
+            st.checkbox("Enable Notifications", value=True)
+            st.checkbox("Auto-save Settings", value=True)
+    
+    with tab2:
+        st.subheader("Security Settings")
+        st.text_input("Admin Password", type="password")
+        st.checkbox("Enable Two-Factor Authentication")
+        st.checkbox("Enable Audit Logging", value=True)
+        st.selectbox("Session Timeout", ["15 minutes", "30 minutes", "1 hour", "4 hours"])
+    
+    with tab3:
+        st.subheader("Advanced Settings")
+        st.code("""
+        {
+            "debug_mode": false,
+            "cache_size": 100,
+            "max_connections": 20,
+            "log_level": "INFO"
+        }
+        """)
+        
+        if st.button("Reset to Defaults"):
+            st.warning("Settings reset to default values")
+
+
+def create_help_page():
+    """Create help page"""
+    st.title("❓ Help & Documentation")
+    
+    col1, col2 = st.columns([1, 2])
+    
+    with col1:
+        st.subheader("Quick Links")
+        st.markdown("""
+        - [Getting Started](#getting-started)
+        - [Dashboard Guide](#dashboard)
+        - [Analytics](#analytics)
+        - [Troubleshooting](#troubleshooting)
+        - [API Documentation](#api)
+        """)
+    
+    with col2:
+        st.subheader("Getting Started")
+        st.markdown("""
+        Welcome to MONA! This platform provides comprehensive monitoring 
+        and analytics capabilities for your systems.
+        
+        **Key Features:**
+        - Real-time dashboard with key metrics
+        - System performance monitoring
+        - User activity tracking
+        - Event logging and analysis
+        - Customizable alerts and notifications
+        
+        **Navigation:**
+        Use the sidebar to navigate between different sections of the application.
+        The dashboard provides an overview of system health and key metrics.
+        """)
+        
+        st.subheader("Dashboard Guide")
+        st.markdown("""
+        The dashboard displays:
+        - **Key Metrics:** Total users, active sessions, system health
+        - **Activity Charts:** User activity over time
+        - **Performance Graphs:** CPU, memory, and disk usage
+        - **Recent Events:** Latest system events and alerts
+        - **System Status:** Current status of all services
+        """)
+        
+        st.subheader("Troubleshooting")
+        with st.expander("Common Issues"):
+            st.markdown("""
+            **Data not loading:**
+            - Check your internet connection
+            - Try refreshing the page
+            - Contact support if issue persists
             
-        # Create main layout with sidebar and content area
-        with gr.Row():
-            # Sidebar navigation
-            with gr.Column(scale=1, elem_id="sidebar"):
-                # User profile section
-                with gr.Group(elem_id="user-profile"):
-                    gr.Markdown("### Welcome!")
-                
-                # Navigation menu
-                selected_page = gr.Radio(
-                    choices=sidebar_items,
-                    value=sidebar_items[0],
-                    label="Navigation",
-                    elem_id="nav-menu"
-                )
-                
-                # App info
-                with gr.Group(elem_id="app-info"):
-                    gr.Markdown("v0.1.0 | Using Free AI Models")
+            **Charts not displaying:**
+            - Ensure JavaScript is enabled
+            - Try a different browser
+            - Clear browser cache
+            """)
+
+
+def main():
+    """Main application function"""
+    try:
+        # Setup logging
+        setup_logging()
+        logger = get_logger(__name__)
+        log_info("Starting MONA application")
+        
+        # Configure Streamlit
+        setup_streamlit_config()
+        
+        with ErrorHandler("main_application", raise_on_error=False):
+            # Create header
+            create_header()
+            
+            # Create sidebar and get selected page
+            selected_page = create_sidebar()
             
             # Main content area
-            with gr.Column(scale=4, elem_id="content-area"):
-                # Create a container for each page
-                for page_name, create_page in page_creators.items():
-                    with gr.Group(visible=(page_name == sidebar_items[0])) as page_container:
-                        create_page(state)
-                    # Store the container in state for navigation
-                    state[f"{page_name}_container"] = page_container
-        
-        # Handle navigation changes
-        @handle_exceptions
-        def change_page(page_name):
-            """Show the selected page and hide others"""
-            logger.debug(f"Navigating to page: {page_name}")
-            return [gr.update(visible=(name == page_name)) for name in sidebar_items]
-        
-        # Set up navigation event handler
-        page_containers = [state[f"{name}_container"] for name in sidebar_items]
-        selected_page.change(change_page, inputs=selected_page, outputs=page_containers)
-        
-        # Record app usage for analytics
-        @handle_exceptions
-        def record_app_usage():
-            """Record app usage for analytics"""
-            logger.info("Recording app usage")
+            st.markdown("---")
             
-            # Record activity using the centralized function
-            # Commented out due to incorrect parameters
-            # record_activity requires state, activity_type, and title
-            # record_activity({
-            #     "type": "app_opened",
-            #     "timestamp": datetime.datetime.now().isoformat()
-            # })
+            # Route to appropriate page
+            if selected_page == "Dashboard":
+                create_dashboard_page()
+            elif selected_page == "Analytics":
+                create_analytics_page()
+            elif selected_page == "Settings":
+                create_settings_page()
+            elif selected_page == "Help":
+                create_help_page()
+            else:
+                st.error(f"Unknown page: {selected_page}")
             
-            # Correct implementation would be:
-            # record_activity(state, "app_opened", "Application Started")
+            # Create footer
+            create_footer()
         
-        # Record app usage on load
-        app.load(record_app_usage)
-    
-    logger.info("Mona application initialized successfully")
-    return app
+        log_info("MONA application loaded successfully")
+        
+    except Exception as e:
+        log_error("Critical error in main application", error=e)
+        st.error("⚠️ Application Error")
+        st.error("A critical error occurred. Please check the logs and try again.")
+        
+        # Show error details for debugging
+        with st.expander("Error Details"):
+            st.code(str(e))
+            import traceback
+            st.code(traceback.format_exc())
+
 
 if __name__ == "__main__":
-    try:
-        logger.info("Starting Mona application")
-        app = create_app()
-        app.launch()
-    except Exception as e:
-        logger.error(f"Failed to start application: {str(e)}")
-        raise
+    main()