Update utils/state.py

utils/state.py

@@ -1,296 +1,327 @@
-from typing import Dict, Any, List, Optional
-import datetime
 import uuid
-from pathlib import Path
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Union
+import json
 
-from utils.config import DATA_DIR, DEFAULT_SETTINGS
-from utils.storage import load_data, save_data
+# Import utilities
 from utils.logging import get_logger
 from utils.error_handling import handle_exceptions, ValidationError, safe_get
+from utils.storage import save_data, load_data
 
-# Initialize logger
 logger = get_logger(__name__)
 
-def generate_id() -> str:
+# Global state storage
+_state_storage = {}
+_activity_log = []
+
+@handle_exceptions
+def generate_id(prefix: str = "") -> str:
     """
     Generate a unique ID
     
+    Args:
+        prefix: Optional prefix for the ID
+    
     Returns:
-        A UUID string
+        str: Unique identifier
     """
-    return str(uuid.uuid4())
+    unique_id = str(uuid.uuid4())[:8]
+    if prefix:
+        return f"{prefix}_{unique_id}"
+    return unique_id
 
-def get_timestamp() -> str:
+@handle_exceptions
+def get_timestamp(format_type: str = "iso") -> str:
     """
-    Get current timestamp in ISO format
+    Get current timestamp
+    
+    Args:
+        format_type: Format type ('iso', 'unix', 'readable')
     
     Returns:
-        Current timestamp as ISO formatted string
+        str: Formatted timestamp
     """
-    return datetime.datetime.now().isoformat()
+    now = datetime.now(timezone.utc)
+    
+    if format_type == "iso":
+        return now.isoformat()
+    elif format_type == "unix":
+        return str(int(now.timestamp()))
+    elif format_type == "readable":
+        return now.strftime("%Y-%m-%d %H:%M:%S UTC")
+    else:
+        return now.isoformat()
 
 @handle_exceptions
-def initialize_state() -> Dict[str, Any]:
+def record_activity(activity_type: str, details: Dict[str, Any] = None) -> bool:
     """
-    Initialize the application state with default values
+    Record an activity in the activity log
+    
+    Args:
+        activity_type: Type of activity
+        details: Additional details about the activity
     
     Returns:
-        Dictionary containing the application state
-        
-    Raises:
-        DataError: If there's an error loading data files
+        bool: True if recorded successfully
     """
-    logger.info("Initializing application state")
-    
-    # Create data directory if it doesn't exist
-    DATA_DIR.mkdir(exist_ok=True, parents=True)
-    
-    # Load existing data or create defaults
-    logger.debug("Loading data files")
-    tasks = load_data(DATA_DIR / "tasks.json", default=[])
-    notes = load_data(DATA_DIR / "notes.json", default=[])
-    goals = load_data(DATA_DIR / "goals.json", default=[])
-    settings = load_data(DATA_DIR / "settings.json", default=DEFAULT_SETTINGS)
-    
-    # Calculate stats
-    tasks_total = len(tasks)
-    tasks_completed = sum(1 for task in tasks if safe_get(task, "completed", False))
-    notes_total = len(notes)
-    goals_total = len(goals)
-    goals_completed = sum(1 for goal in goals if safe_get(goal, "completed", False))
-    streak_days = calculate_streak_days()
-    
-    logger.info(f"Loaded {tasks_total} tasks, {notes_total} notes, {goals_total} goals")
-    
-    # Initialize state
-    state = {
-        # Data
-        "tasks": tasks,
-        "notes": notes,
-        "goals": goals,
-        "settings": settings,
+    try:
+        activity = {
+            "id": generate_id("activity"),
+            "type": activity_type,
+            "timestamp": get_timestamp(),
+            "details": details or {}
+        }
         
-        # Session state
-        "current_page": "🏠 Dashboard",
-        "selected_task": None,
-        "selected_note": None,
-        "selected_goal": None,
+        _activity_log.append(activity)
         
-        # UI state containers (will be populated during app creation)
-        "page_containers": {},
+        # Keep only last 1000 activities
+        if len(_activity_log) > 1000:
+            _activity_log.pop(0)
         
-        # Stats
-        "stats": {
-            "tasks_total": tasks_total,
-            "tasks_completed": tasks_completed,
-            "notes_total": notes_total,
-            "goals_total": goals_total,
-            "goals_completed": goals_completed,
-            "streak_days": streak_days
-        },
+        logger.info(f"Activity recorded: {activity_type}")
+        return True
         
-        # Activity feed
-        "activity_feed": load_recent_activity()
-    }
-    
-    logger.info("Application state initialized successfully")
-    return state
+    except Exception as e:
+        logger.error(f"Failed to record activity: {e}")
+        return False
 
 @handle_exceptions
-def calculate_streak_days() -> int:
+def get_state(key: str, default: Any = None) -> Any:
     """
-    Calculate the current streak of consecutive days using the app
+    Get value from global state
+    
+    Args:
+        key: State key
+        default: Default value if key not found
     
     Returns:
-        Number of consecutive days
-        
-    Raises:
-        DataError: If there's an error loading usage data
+        Any: State value or default
+    """
+    return safe_get(_state_storage, key, default)
+
+@handle_exceptions
+def set_state(key: str, value: Any) -> bool:
     """
-    logger.debug("Calculating streak days")
-    usage_file = DATA_DIR / "usage.json"
-    usage_data = load_data(usage_file, default=[])
+    Set value in global state
     
-    if not usage_data:
-        return 0
+    Args:
+        key: State key
+        value: Value to set
     
-    # Extract dates from usage data
+    Returns:
+        bool: True if set successfully
+    """
     try:
-        dates = [datetime.datetime.fromisoformat(safe_get(entry, "timestamp", "")).date() 
-                for entry in usage_data if "timestamp" in entry]
-    except (ValueError, TypeError) as e:
-        logger.warning(f"Error parsing dates in usage data: {str(e)}")
-        return 0
-    
-    # Sort and get unique dates
-    unique_dates = sorted(set(dates), reverse=True)
-    
-    if not unique_dates:
-        return 0
-    
-    # Calculate streak
-    streak = 1
-    today = datetime.date.today()
+        _state_storage[key] = value
+        logger.debug(f"State set: {key}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to set state {key}: {e}")
+        return False
+
+@handle_exceptions
+def update_state(key: str, updates: Dict[str, Any]) -> bool:
+    """
+    Update nested state values
     
-    # If no usage today, check if there was usage yesterday to continue the streak
-    if unique_dates[0] != today:
-        if unique_dates[0] != today - datetime.timedelta(days=1):
-            return 0
-        reference_date = unique_dates[0]
-    else:
-        reference_date = today
+    Args:
+        key: State key
+        updates: Dictionary of updates to apply
     
-    # Count consecutive days
-    for i in range(1, len(unique_dates)):
-        expected_date = reference_date - datetime.timedelta(days=i)
-        if expected_date in unique_dates:
-            streak += 1
+    Returns:
+        bool: True if updated successfully
+    """
+    try:
+        current = get_state(key, {})
+        if isinstance(current, dict):
+            current.update(updates)
+            return set_state(key, current)
         else:
-            break
-    
-    logger.debug(f"Current streak: {streak} days")
-    return streak
+            logger.warning(f"Cannot update non-dict state: {key}")
+            return False
+    except Exception as e:
+        logger.error(f"Failed to update state {key}: {e}")
+        return False
 
 @handle_exceptions
-def load_recent_activity(limit: int = 20) -> List[Dict[str, Any]]:
+def clear_state(key: Optional[str] = None) -> bool:
     """
-    Load recent activity from various data sources
+    Clear state (specific key or all)
     
     Args:
-        limit: Maximum number of activities to return
-        
+        key: Specific key to clear, or None to clear all
+    
     Returns:
-        List of activity entries
-        
-    Raises:
-        DataError: If there's an error loading data files
-        ValidationError: If limit is not a positive integer
+        bool: True if cleared successfully
     """
-    if not isinstance(limit, int) or limit <= 0:
-        logger.error(f"Invalid limit for load_recent_activity: {limit}")
-        raise ValidationError(f"Limit must be a positive integer, got {limit}")
-        
-    logger.debug(f"Loading recent activity (limit: {limit})")
-    activities = []
-    
-    # Load tasks
-    tasks = load_data(DATA_DIR / "tasks.json", default=[])
-    for task in tasks:
-        if "created_at" in task:
-            activities.append({
-                "timestamp": safe_get(task, "created_at", ""),
-                "type": "task_created",
-                "title": safe_get(task, "title", "Untitled Task"),
-                "id": safe_get(task, "id", "")
-            })
-        if "completed_at" in task and safe_get(task, "completed", False):
-            activities.append({
-                "timestamp": safe_get(task, "completed_at", ""),
-                "type": "task_completed",
-                "title": safe_get(task, "title", "Untitled Task"),
-                "id": safe_get(task, "id", "")
-            })
-    
-    # Load notes
-    notes = load_data(DATA_DIR / "notes.json", default=[])
-    for note in notes:
-        if "created_at" in note:
-            activities.append({
-                "timestamp": safe_get(note, "created_at", ""),
-                "type": "note_created",
-                "title": safe_get(note, "title", "Untitled Note"),
-                "id": safe_get(note, "id", "")
-            })
-        if "updated_at" in note and safe_get(note, "updated_at", "") != safe_get(note, "created_at", ""):
-            activities.append({
-                "timestamp": safe_get(note, "updated_at", ""),
-                "type": "note_updated",
-                "title": safe_get(note, "title", "Untitled Note"),
-                "id": safe_get(note, "id", "")
-            })
+    try:
+        if key:
+            if key in _state_storage:
+                del _state_storage[key]
+                logger.info(f"State cleared: {key}")
+        else:
+            _state_storage.clear()
+            logger.info("All state cleared")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to clear state: {e}")
+        return False
+
+@handle_exceptions
+def get_activity_log(limit: int = 100) -> List[Dict[str, Any]]:
+    """
+    Get recent activity log entries
     
-    # Load goals
-    goals = load_data(DATA_DIR / "goals.json", default=[])
-    for goal in goals:
-        if "created_at" in goal:
-            activities.append({
-                "timestamp": safe_get(goal, "created_at", ""),
-                "type": "goal_created",
-                "title": safe_get(goal, "title", "Untitled Goal"),
-                "id": safe_get(goal, "id", "")
-            })
-        if "completed_at" in goal and safe_get(goal, "completed", False):
-            activities.append({
-                "timestamp": safe_get(goal, "completed_at", ""),
-                "type": "goal_completed",
-                "title": safe_get(goal, "title", "Untitled Goal"),
-                "id": safe_get(goal, "id", "")
-            })
+    Args:
+        limit: Maximum number of entries to return
     
-    # Sort by timestamp (newest first) and limit
+    Returns:
+        List[Dict]: Activity log entries
+    """
     try:
-        activities.sort(key=lambda x: x["timestamp"], reverse=True)
-    except (KeyError, TypeError) as e:
-        logger.warning(f"Error sorting activities: {str(e)}")
-    
-    logger.debug(f"Loaded {len(activities)} activities")
-    return activities[:limit]
+        return _activity_log[-limit:] if _activity_log else []
+    except Exception as e:
+        logger.error(f"Failed to get activity log: {e}")
+        return []
 
 @handle_exceptions
-def record_activity(state: Dict[str, Any], activity_type: str, title: str, 
-                   item_id: Optional[str] = None) -> None:
+def save_state_to_file(filename: str = "app_state.json") -> bool:
     """
-    Record a new activity in the activity feed
+    Save current state to file
     
     Args:
-        state: Application state
-        activity_type: Type of activity
-        title: Title of the related item
-        item_id: ID of the related item
-        
-    Raises:
-        DataError: If there's an error saving activity data
-        ValidationError: If required parameters are missing or invalid
+        filename: Name of the file to save to
+    
+    Returns:
+        bool: True if saved successfully
     """
-    if not state:
-        logger.error("Cannot record activity: state is empty or None")
-        raise ValidationError("Application state is required")
+    try:
+        state_data = {
+            "state": _state_storage,
+            "activity_log": _activity_log[-100:],  # Save last 100 activities
+            "timestamp": get_timestamp(),
+            "version": "1.0"
+        }
         
-    if not activity_type:
-        logger.error("Cannot record activity: activity_type is empty or None")
-        raise ValidationError("Activity type is required")
+        return save_data(state_data, filename, "json")
         
-    if not title:
-        logger.warning("Recording activity with empty title")
-        title = "Untitled"
-    
-    timestamp = get_timestamp()
-    logger.debug(f"Recording activity: {activity_type} - {title} at {timestamp}")
+    except Exception as e:
+        logger.error(f"Failed to save state to file: {e}")
+        return False
+
+@handle_exceptions
+def load_state_from_file(filename: str = "app_state.json") -> bool:
+    """
+    Load state from file
     
-    new_activity = {
-        "timestamp": timestamp,
-        "type": activity_type,
-        "title": title,
-        "id": item_id
-    }
+    Args:
+        filename: Name of the file to load from
     
-    # Add to state
-    if "activity_feed" not in state:
-        state["activity_feed"] = []
+    Returns:
+        bool: True if loaded successfully
+    """
+    try:
+        global _state_storage, _activity_log
+        
+        state_data = load_data(filename, "json")
+        if state_data:
+            _state_storage = safe_get(state_data, "state", {})
+            _activity_log = safe_get(state_data, "activity_log", [])
+            
+            logger.info("State loaded from file successfully")
+            record_activity("state_loaded", {"filename": filename})
+            return True
+        else:
+            logger.warning(f"No state file found: {filename}")
+            return False
+            
+    except Exception as e:
+        logger.error(f"Failed to load state from file: {e}")
+        return False
+
+@handle_exceptions
+def get_state_info() -> Dict[str, Any]:
+    """
+    Get information about current state
     
-    state["activity_feed"].insert(0, new_activity)
+    Returns:
+        Dict: State information
+    """
+    try:
+        return {
+            "state_keys": list(_state_storage.keys()),
+            "state_size": len(_state_storage),
+            "activity_count": len(_activity_log),
+            "last_activity": _activity_log[-1] if _activity_log else None,
+            "timestamp": get_timestamp()
+        }
+    except Exception as e:
+        logger.error(f"Failed to get state info: {e}")
+        return {}
+
+# Session state management for Streamlit compatibility
+@handle_exceptions
+def init_session_state():
+    """
+    Initialize session state for Streamlit
+    """
+    try:
+        import streamlit as st
+        
+        if 'mona_initialized' not in st.session_state:
+            st.session_state.mona_initialized = True
+            st.session_state.mona_state = {}
+            record_activity("session_initialized")
+            
+    except ImportError:
+        # Not in Streamlit environment
+        pass
+    except Exception as e:
+        logger.error(f"Failed to initialize session state: {e}")
+
+@handle_exceptions
+def get_session_state(key: str, default: Any = None) -> Any:
+    """
+    Get value from Streamlit session state
     
-    # Limit to 20 items
-    state["activity_feed"] = state["activity_feed"][:20]
+    Args:
+        key: Session state key
+        default: Default value
     
-    # Save to file
-    activities = load_data(DATA_DIR / "activities.json", default=[])
-    activities.insert(0, new_activity)
-    activities = activities[:100]  # Keep last 100 activities
-    save_data(DATA_DIR / "activities.json", activities)
+    Returns:
+        Any: Session state value or default
+    """
+    try:
+        import streamlit as st
+        return st.session_state.get(key, default)
+    except ImportError:
+        return get_state(key, default)
+    except Exception as e:
+        logger.error(f"Failed to get session state {key}: {e}")
+        return default
+
+@handle_exceptions
+def set_session_state(key: str, value: Any) -> bool:
+    """
+    Set value in Streamlit session state
     
-    # Log the activity - commented out due to incompatible parameters
-    # The log_user_activity function requires user_id as first parameter
-    # log_user_activity(activity_type, {"title": title, "id": item_id})
+    Args:
+        key: Session state key
+        value: Value to set
     
-    logger.debug("Activity recorded successfully")
+    Returns:
+        bool: True if set successfully
+    """
+    try:
+        import streamlit as st
+        st.session_state[key] = value
+        return True
+    except ImportError:
+        return set_state(key, value)
+    except Exception as e:
+        logger.error(f"Failed to set session state {key}: {e}")
+        return False
+
+# Initialize on module import
+record_activity("state_module_loaded")