sirchmunk 0.0.1.post1__py3-none-any.whl → 0.0.2__py3-none-any.whl

sirchmunk/api/components/settings_storage.py

@@ -0,0 +1,353 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+Settings Storage using DuckDB
+Provides persistent storage for application settings
+"""
+
+import os
+import json
+from typing import Dict, Any, Optional
+from pathlib import Path
+from datetime import datetime
+from loguru import logger
+
+from sirchmunk.storage.duckdb import DuckDBManager
+from sirchmunk.utils.constants import DEFAULT_SIRCHMUNK_WORK_PATH
+
+
+class SettingsStorage:
+    """
+    Manages persistent storage of application settings using DuckDB
+    
+    Architecture:
+    - Stores UI settings, environment variables, and configuration
+    - Follows Single Responsibility Principle (SRP)
+    - Provides clean interface for CRUD operations
+    """
+    
+    def __init__(self, work_path: Optional[str] = None):
+        """
+        Initialize Settings Storage
+        
+        Args:
+            work_path: Base work path. If None, uses SIRCHMUNK_WORK_PATH env variable
+        """
+        # Get work path from env if not provided, and expand ~ in path
+        if work_path is None:
+            work_path = os.getenv("SIRCHMUNK_WORK_PATH", DEFAULT_SIRCHMUNK_WORK_PATH)
+        
+        # Create settings storage path (expand ~ and resolve to absolute path)
+        self.settings_path = Path(work_path).expanduser().resolve() / ".cache" / "settings"
+        self.settings_path.mkdir(parents=True, exist_ok=True)
+        
+        # Initialize DuckDB
+        self.db_path = str(self.settings_path / "settings.db")
+        self.db = DuckDBManager(db_path=self.db_path)
+        
+        # Create tables if not exist
+        self._initialize_tables()
+        
+        logger.info(f"Settings storage initialized at: {self.db_path}")
+    
+    def _initialize_tables(self):
+        """Create database tables for settings"""
+        
+        # Settings table (key-value store)
+        settings_schema = {
+            "key": "VARCHAR PRIMARY KEY",
+            "value": "TEXT NOT NULL",
+            "category": "VARCHAR NOT NULL",
+            "updated_at": "TIMESTAMP NOT NULL",
+        }
+        self.db.create_table("settings", settings_schema, if_not_exists=True)
+        
+        # Environment variables table
+        env_schema = {
+            "key": "VARCHAR PRIMARY KEY",
+            "value": "TEXT",
+            "description": "TEXT",
+            "category": "VARCHAR",
+            "updated_at": "TIMESTAMP NOT NULL",
+        }
+        self.db.create_table("environment", env_schema, if_not_exists=True)
+    
+    def save_setting(self, key: str, value: Any, category: str = "general") -> bool:
+        """
+        Save or update a setting
+        
+        Args:
+            key: Setting key
+            value: Setting value (will be JSON serialized)
+            category: Setting category (ui, llm, env, etc.)
+        
+        Returns:
+            True if successful
+        """
+        try:
+            # Serialize value to JSON
+            value_str = json.dumps(value) if not isinstance(value, str) else value
+            
+            # Check if setting exists
+            existing = self.db.fetch_one(
+                "SELECT key FROM settings WHERE key = ?",
+                [key]
+            )
+            
+            data = {
+                "key": key,
+                "value": value_str,
+                "category": category,
+                "updated_at": datetime.now().isoformat(),
+            }
+            
+            if existing:
+                # Update existing setting
+                set_clause = {k: v for k, v in data.items() if k != "key"}
+                self.db.update_data(
+                    "settings",
+                    set_clause=set_clause,
+                    where_clause="key = ?",
+                    where_params=[key]
+                )
+                logger.debug(f"Updated setting: {key}")
+            else:
+                # Insert new setting
+                self.db.insert_data("settings", data)
+                logger.debug(f"Created new setting: {key}")
+            
+            return True
+        
+        except Exception as e:
+            logger.error(f"Failed to save setting {key}: {e}")
+            return False
+    
+    def get_setting(self, key: str, default: Any = None) -> Any:
+        """
+        Get a setting value
+        
+        Args:
+            key: Setting key
+            default: Default value if not found
+        
+        Returns:
+            Setting value (deserialized from JSON) or default
+        """
+        try:
+            row = self.db.fetch_one(
+                "SELECT value FROM settings WHERE key = ?",
+                [key]
+            )
+            
+            if row:
+                value_str = row[0]
+                try:
+                    return json.loads(value_str)
+                except json.JSONDecodeError:
+                    return value_str
+            
+            return default
+        
+        except Exception as e:
+            logger.error(f"Failed to get setting {key}: {e}")
+            return default
+    
+    def get_settings_by_category(self, category: str) -> Dict[str, Any]:
+        """
+        Get all settings in a category
+        
+        Args:
+            category: Category name
+        
+        Returns:
+            Dictionary of key-value pairs
+        """
+        try:
+            rows = self.db.fetch_all(
+                "SELECT key, value FROM settings WHERE category = ?",
+                [category]
+            )
+            
+            settings = {}
+            for row in rows:
+                key, value_str = row
+                try:
+                    settings[key] = json.loads(value_str)
+                except json.JSONDecodeError:
+                    settings[key] = value_str
+            
+            return settings
+        
+        except Exception as e:
+            logger.error(f"Failed to get settings for category {category}: {e}")
+            return {}
+    
+    def get_all_settings(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get all settings grouped by category
+        
+        Returns:
+            Dictionary with categories as keys
+        """
+        try:
+            rows = self.db.fetch_all(
+                "SELECT key, value, category FROM settings"
+            )
+            
+            settings_by_category = {}
+            for row in rows:
+                key, value_str, category = row
+                
+                if category not in settings_by_category:
+                    settings_by_category[category] = {}
+                
+                try:
+                    settings_by_category[category][key] = json.loads(value_str)
+                except json.JSONDecodeError:
+                    settings_by_category[category][key] = value_str
+            
+            return settings_by_category
+        
+        except Exception as e:
+            logger.error(f"Failed to get all settings: {e}")
+            return {}
+    
+    def save_env_variable(self, key: str, value: str, description: str = "", category: str = "general") -> bool:
+        """
+        Save or update an environment variable
+        
+        Args:
+            key: Environment variable key
+            value: Environment variable value
+            description: Description of the variable
+            category: Category (llm, system, etc.)
+        
+        Returns:
+            True if successful
+        """
+        try:
+            # Check if env var exists
+            existing = self.db.fetch_one(
+                "SELECT key FROM environment WHERE key = ?",
+                [key]
+            )
+            
+            data = {
+                "key": key,
+                "value": value,
+                "description": description,
+                "category": category,
+                "updated_at": datetime.now().isoformat(),
+            }
+            
+            if existing:
+                # Update existing env var
+                set_clause = {k: v for k, v in data.items() if k != "key"}
+                self.db.update_data(
+                    "environment",
+                    set_clause=set_clause,
+                    where_clause="key = ?",
+                    where_params=[key]
+                )
+                logger.debug(f"Updated env var: {key}")
+            else:
+                # Insert new env var
+                self.db.insert_data("environment", data)
+                logger.debug(f"Created new env var: {key}")
+            
+            return True
+        
+        except Exception as e:
+            logger.error(f"Failed to save env var {key}: {e}")
+            return False
+    
+    def get_env_variable(self, key: str, default: str = "") -> str:
+        """
+        Get an environment variable value
+        
+        Args:
+            key: Environment variable key
+            default: Default value if not found
+        
+        Returns:
+            Environment variable value or default
+        """
+        try:
+            row = self.db.fetch_one(
+                "SELECT value FROM environment WHERE key = ?",
+                [key]
+            )
+            
+            return row[0] if row and row[0] else default
+        
+        except Exception as e:
+            logger.error(f"Failed to get env var {key}: {e}")
+            return default
+    
+    def get_all_env_variables(self) -> Dict[str, Dict[str, str]]:
+        """
+        Get all environment variables grouped by category
+        
+        Returns:
+            Dictionary with categories as keys
+        """
+        try:
+            rows = self.db.fetch_all(
+                "SELECT key, value, description, category FROM environment"
+            )
+            
+            env_by_category = {}
+            for row in rows:
+                key, value, description, category = row
+                
+                if category not in env_by_category:
+                    env_by_category[category] = {}
+                
+                env_by_category[category][key] = {
+                    "value": value or "",
+                    "description": description or ""
+                }
+            
+            return env_by_category
+        
+        except Exception as e:
+            logger.error(f"Failed to get all env vars: {e}")
+            return {}
+    
+    def delete_setting(self, key: str) -> bool:
+        """Delete a setting"""
+        try:
+            self.db.delete_data("settings", "key = ?", [key])
+            logger.info(f"Deleted setting: {key}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete setting {key}: {e}")
+            return False
+    
+    def delete_env_variable(self, key: str) -> bool:
+        """Delete an environment variable"""
+        try:
+            self.db.delete_data("environment", "key = ?", [key])
+            logger.info(f"Deleted env var: {key}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to delete env var {key}: {e}")
+            return False
+    
+    def close(self):
+        """Close database connection"""
+        if self.db:
+            self.db.close()
+            logger.info("Settings storage closed")
+    
+    def __enter__(self):
+        """Context manager entry"""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()
+    
+    def __del__(self):
+        """Destructor to ensure connection is closed"""
+        if hasattr(self, 'db') and self.db:
+            self.close()

sirchmunk/api/history.py

@@ -0,0 +1,254 @@
+# Copyright (c) ModelScope Contributors. All rights reserved.
+"""
+History API endpoints integrated with persistent storage
+Provides unified history tracking with DuckDB backend
+"""
+
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any, List, Optional
+import json
+from datetime import datetime, timedelta
+
+# Import chat sessions and history storage from chat module
+from .chat import chat_sessions, history_storage
+
+router = APIRouter(prefix="/api/v1", tags=["history"])
+
+# Create a second router for dashboard endpoints
+from fastapi import APIRouter as FastAPIRouter
+dashboard_router = FastAPIRouter(prefix="/api/v1/dashboard", tags=["dashboard"])
+
+
+@router.get("/chat/sessions")
+async def get_chat_sessions(limit: int = 20, offset: int = 0):
+    """Get list of chat sessions from persistent storage"""
+    # Get sessions from persistent storage
+    sessions_list = history_storage.get_all_sessions(limit=limit, offset=offset)
+    
+    # Format for response
+    formatted_sessions = []
+    for session in sessions_list:
+        # Get full session data to access messages for title generation
+        full_session = history_storage.get_session(session["session_id"])
+        
+        title = session.get("title", "Chat Session")
+        if full_session and full_session.get("messages"):
+            first_user_message = next((m for m in full_session["messages"] if m["role"] == "user"), None)
+            if first_user_message:
+                title = first_user_message["content"][:50] + "..." if len(first_user_message["content"]) > 50 else first_user_message["content"]
+        
+        last_message = ""
+        if full_session and full_session.get("messages"):
+            last_msg = full_session["messages"][-1]
+            last_message = last_msg["content"][:100] + "..." if len(last_msg["content"]) > 100 else last_msg["content"]
+        
+        # Convert ISO timestamps to Unix timestamps
+        created_at = session["created_at"]
+        updated_at = session["updated_at"]
+        if isinstance(created_at, str):
+            created_at = int(datetime.fromisoformat(created_at).timestamp())
+        if isinstance(updated_at, str):
+            updated_at = int(datetime.fromisoformat(updated_at).timestamp())
+        
+        formatted_sessions.append({
+            "session_id": session["session_id"],
+            "title": title,
+            "message_count": session.get("message_count", 0),
+            "last_message": last_message,
+            "created_at": created_at,
+            "updated_at": updated_at,
+            "topics": [] # Placeholder
+        })
+    
+    # Get total count
+    total_count = history_storage.get_session_count()
+    
+    return {
+        "success": True,
+        "data": formatted_sessions,
+        "pagination": {
+            "limit": limit,
+            "offset": offset,
+            "total": total_count
+        }
+    }
+
+
+@router.get("/chat/sessions/{session_id}")
+async def get_chat_session(session_id: str):
+    """Get specific chat session details from persistent storage"""
+    # Try to get from persistent storage first
+    session = history_storage.get_session(session_id)
+    
+    # Fallback to in-memory cache if not in persistent storage
+    if not session and session_id in chat_sessions:
+        session = chat_sessions[session_id]
+    
+    if not session:
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    
+    # Convert ISO timestamps to Unix timestamps for frontend compatibility
+    messages_with_unix_timestamps = []
+    for msg in session.get("messages", []):
+        msg_copy = msg.copy()
+        if "timestamp" in msg_copy:
+            if isinstance(msg_copy["timestamp"], str):
+                msg_copy["timestamp"] = int(datetime.fromisoformat(msg_copy["timestamp"]).timestamp())
+        messages_with_unix_timestamps.append(msg_copy)
+    
+    # Handle created_at and updated_at
+    created_at = session.get("created_at")
+    updated_at = session.get("updated_at")
+    
+    if isinstance(created_at, str):
+        created_at = int(datetime.fromisoformat(created_at).timestamp())
+    if isinstance(updated_at, str):
+        updated_at = int(datetime.fromisoformat(updated_at).timestamp())
+    
+    return {
+        "success": True,
+        "data": {
+            "session_id": session["session_id"],
+            "title": session.get("title", "Chat Session"),
+            "messages": messages_with_unix_timestamps,
+            "settings": session.get("settings", {}),
+            "created_at": created_at,
+            "updated_at": updated_at
+        }
+    }
+
+
+@router.delete("/chat/sessions/{session_id}")
+async def delete_chat_session(session_id: str):
+    """Delete a specific chat session from both memory and persistent storage"""
+    # Delete from persistent storage
+    success = history_storage.delete_session(session_id)
+    
+    # Also delete from in-memory cache
+    if session_id in chat_sessions:
+        chat_sessions.pop(session_id)
+    
+    if not success:
+        raise HTTPException(status_code=404, detail="Chat session not found")
+    
+    return {
+        "success": True,
+        "message": "Chat session deleted successfully",
+        "data": {
+            "session_id": session_id
+        }
+    }
+
+
+@router.get("/history/search")
+async def search_history(query: str, limit: int = 20):
+    """Search chat history by content"""
+    sessions = history_storage.search_sessions(query, limit=limit)
+    
+    # Format for response
+    formatted_sessions = []
+    for session in sessions:
+        # Convert timestamps
+        created_at = session["created_at"]
+        updated_at = session["updated_at"]
+        if isinstance(created_at, str):
+            created_at = int(datetime.fromisoformat(created_at).timestamp())
+        if isinstance(updated_at, str):
+            updated_at = int(datetime.fromisoformat(updated_at).timestamp())
+        
+        formatted_sessions.append({
+            "session_id": session["session_id"],
+            "title": session.get("title", "Chat Session"),
+            "message_count": session.get("message_count", 0),
+            "created_at": created_at,
+            "updated_at": updated_at,
+        })
+    
+    return {
+        "success": True,
+        "data": formatted_sessions,
+        "query": query
+    }
+
+
+@router.get("/history/stats")
+async def get_history_statistics():
+    """Get history statistics from persistent storage"""
+    total_sessions = history_storage.get_session_count()
+    
+    # Get recent sessions (last 7 days)
+    all_sessions = history_storage.get_all_sessions(limit=1000)
+    week_ago = datetime.now() - timedelta(days=7)
+    
+    recent_sessions = []
+    total_messages = 0
+    
+    for session in all_sessions:
+        updated_at = session.get("updated_at")
+        if isinstance(updated_at, str):
+            updated_at = datetime.fromisoformat(updated_at)
+        
+        if updated_at > week_ago:
+            recent_sessions.append(session)
+        
+        total_messages += session.get("message_count", 0)
+    
+    return {
+        "success": True,
+        "data": {
+            "total_sessions": total_sessions,
+            "total_messages": total_messages,
+            "recent_activity": {
+                "last_7_days": len(recent_sessions),
+                "daily_average": len(recent_sessions) / 7
+            }
+        }
+    }
+
+
+@dashboard_router.get("/recent")
+async def get_recent_activity(limit: int = 50, type: Optional[str] = None):
+    """
+    Get recent activity (chat sessions)
+    
+    Query params:
+        limit: Maximum number of items to return
+        type: Filter by type (currently only "chat" is supported)
+    """
+    try:
+        # Get recent sessions
+        sessions_list = history_storage.get_all_sessions(limit=limit, offset=0)
+        
+        # Format as activity items
+        activities = []
+        for session in sessions_list:
+            # Get full session data
+            full_session = history_storage.get_session(session["session_id"])
+            
+            title = session.get("title", "Chat Session")
+            if full_session and full_session.get("messages"):
+                first_user_message = next((m for m in full_session["messages"] if m["role"] == "user"), None)
+                if first_user_message:
+                    title = first_user_message["content"][:50] + "..." if len(first_user_message["content"]) > 50 else first_user_message["content"]
+            
+            # Convert timestamps
+            created_at = session["created_at"]
+            if isinstance(created_at, str):
+                created_at = int(datetime.fromisoformat(created_at).timestamp())
+            
+            activities.append({
+                "id": session["session_id"],
+                "type": "chat",
+                "title": title,
+                "timestamp": created_at,
+                "message_count": session.get("message_count", 0),
+            })
+    
+        return {
+            "success": True,
+                "data": activities,
+                "count": len(activities),
+            }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))