realtimex-deeptutor 0.5.0.post1__py3-none-any.whl

src/api/utils/history.py

@@ -0,0 +1,172 @@
+from enum import Enum
+import json
+from pathlib import Path
+import time
+
+
+class ActivityType(str, Enum):
+    SOLVE = "solve"
+    QUESTION = "question"
+    RESEARCH = "research"
+    CHAT = "chat"
+
+
+class HistoryManager:
+    def __init__(self, base_dir: str | None = None):
+        """
+        History record manager
+
+        Args:
+            base_dir: History record directory. Default fixed to "project root/user",
+                      at the same level as user/question, user/solve, user/research,
+                      does not depend on current working directory, avoids path misalignment
+                      when uvicorn / IDE start differently.
+        """
+        if base_dir is None:
+            # Current file: DeepTutor/src/api/utils/history.py
+            # Project root should be three levels up: DeepTutor/
+            project_root = Path(__file__).resolve().parents[3]
+            base_dir_path = project_root / "data" / "user"
+        else:
+            base_dir_path = Path(base_dir)
+
+        self.base_dir = base_dir_path
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+        self.history_file = self.base_dir / "user_history.json"
+        self._ensure_file()
+
+    def _ensure_file(self):
+        """
+        Ensure history file exists with correct format.
+        If file exists but has wrong format, it will be fixed on next save.
+        """
+        if not self.history_file.exists():
+            # Create file with correct dict format (matching user_dir_init.py)
+            initial_history = {"version": "1.0", "created_at": None, "sessions": []}
+            try:
+                with open(self.history_file, "w", encoding="utf-8") as f:
+                    json.dump(initial_history, f, indent=2, ensure_ascii=False)
+            except Exception:
+                # If we can't create the file, that's okay - it will be handled in _load_history
+                pass
+        else:
+            # File exists, verify it's in correct format
+            # If not, it will be fixed on next save operation
+            try:
+                with open(self.history_file, encoding="utf-8") as f:
+                    data = json.load(f)
+                    # If file is in old list format, we'll convert it on next save
+                    if isinstance(data, list):
+                        # File is in old format, but that's okay - _load_history handles it
+                        pass
+            except Exception:
+                # File exists but is corrupted, will be recreated on next save
+                pass
+
+    def _load_history(self) -> list[dict]:
+        """
+        Load history from file. Handles multiple formats for backward compatibility.
+        Returns a list of history entries.
+        """
+        try:
+            if not self.history_file.exists():
+                return []
+
+            with open(self.history_file, encoding="utf-8") as f:
+                data = json.load(f)
+
+                # Handle both list format and dict format (with 'sessions' key)
+                if isinstance(data, dict):
+                    # If it's a dict, try to get 'sessions' field
+                    sessions = data.get("sessions", [])
+                    # Ensure sessions is a list
+                    if isinstance(sessions, list):
+                        return sessions
+                    # If sessions is not a list, return empty list and log warning
+                    return []
+                if isinstance(data, list):
+                    # Legacy format: direct list
+                    return data
+                # Unknown format, return empty list
+                return []
+        except json.JSONDecodeError:
+            # File exists but is corrupted, return empty list
+            # Could log this error in production
+            return []
+        except Exception:
+            # Any other error, return empty list
+            return []
+
+    def _save_history(self, history: list[dict]):
+        # Load existing file to preserve metadata if it's in dict format
+        try:
+            with open(self.history_file, encoding="utf-8") as f:
+                existing_data = json.load(f)
+                if isinstance(existing_data, dict):
+                    # Preserve dict structure, update sessions
+                    existing_data["sessions"] = history
+                    data_to_save = existing_data
+                else:
+                    # If it was a list, convert to dict format
+                    data_to_save = {
+                        "version": "1.0",
+                        "created_at": existing_data[0].get("timestamp") if existing_data else None,
+                        "sessions": history,
+                    }
+        except Exception:
+            # If file doesn't exist or can't be read, create new dict format
+            data_to_save = {
+                "version": "1.0",
+                "created_at": history[0].get("timestamp") if history else None,
+                "sessions": history,
+            }
+
+        with open(self.history_file, "w", encoding="utf-8") as f:
+            json.dump(data_to_save, f, indent=2, ensure_ascii=False)
+
+    def add_entry(self, activity_type: ActivityType, title: str, content: dict, summary: str = ""):
+        """
+        Add a new history entry.
+
+        Args:
+            activity_type: The type of activity (solve, question, research)
+            title: A short title (e.g. the question asked, or topic)
+            content: The full result/payload
+            summary: A short summary if applicable
+        """
+        entry = {
+            "id": str(int(time.time() * 1000)),
+            "timestamp": time.time(),
+            "type": activity_type,
+            "title": title,
+            "summary": summary,
+            "content": content,
+        }
+
+        history = self._load_history()
+        history.insert(0, entry)  # Prepend to show latest first
+
+        # Optional: Limit history size
+        if len(history) > 100:
+            history = history[:100]
+
+        self._save_history(history)
+        return entry
+
+    def get_recent(self, limit: int = 10, type_filter: str | None = None) -> list[dict]:
+        history = self._load_history()
+        if type_filter:
+            history = [h for h in history if h["type"] == type_filter]
+        return history[:limit]
+
+    def get_entry(self, entry_id: str) -> dict | None:
+        history = self._load_history()
+        for entry in history:
+            if entry["id"] == entry_id:
+                return entry
+        return None
+
+
+# Global instance
+history_manager = HistoryManager()

src/api/utils/log_interceptor.py

@@ -0,0 +1,21 @@
+"""
+Log Interceptor for WebSocket streaming
+=======================================
+
+Re-exports handlers from the unified logging system.
+Kept for backwards compatibility.
+"""
+
+from src.logging.handlers import (
+    JSONFileHandler,
+    LogInterceptor,
+    WebSocketLogHandler,
+    create_task_logger,
+)
+
+__all__ = [
+    "WebSocketLogHandler",
+    "LogInterceptor",
+    "JSONFileHandler",
+    "create_task_logger",
+]

src/api/utils/notebook_manager.py

@@ -0,0 +1,415 @@
+"""
+Notebook Manager - Manages user notebooks and records
+All notebook data is stored in user/notebook/ directory
+"""
+
+from enum import Enum
+import json
+from pathlib import Path
+import time
+import uuid
+
+from pydantic import BaseModel
+
+
+class RecordType(str, Enum):
+    """Record type"""
+
+    SOLVE = "solve"
+    QUESTION = "question"
+    RESEARCH = "research"
+    CO_WRITER = "co_writer"
+
+
+class NotebookRecord(BaseModel):
+    """Single record in notebook"""
+
+    id: str
+    type: RecordType
+    title: str
+    user_query: str
+    output: str
+    metadata: dict = {}
+    created_at: float
+    kb_name: str | None = None
+
+
+class Notebook(BaseModel):
+    """Notebook model"""
+
+    id: str
+    name: str
+    description: str = ""
+    created_at: float
+    updated_at: float
+    records: list[NotebookRecord] = []
+    color: str = "#3B82F6"  # Default blue
+    icon: str = "book"  # Default icon
+
+
+class NotebookManager:
+    """Notebook manager"""
+
+    def __init__(self, base_dir: str | None = None):
+        """
+        Initialize notebook manager
+
+        Args:
+            base_dir: Notebook storage directory, defaults to project root/user/notebook
+        """
+        if base_dir is None:
+            # Current file: DeepTutor/src/api/utils/notebook_manager.py
+            # Project root should be three levels up: DeepTutor/
+            project_root = Path(__file__).resolve().parents[3]
+            base_dir_path = project_root / "data" / "user" / "notebook"
+        else:
+            base_dir_path = Path(base_dir)
+
+        self.base_dir = base_dir_path
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+
+        # Notebook index file
+        self.index_file = self.base_dir / "notebooks_index.json"
+        self._ensure_index()
+
+    def _ensure_index(self):
+        """Ensure index file exists"""
+        if not self.index_file.exists():
+            with open(self.index_file, "w", encoding="utf-8") as f:
+                json.dump({"notebooks": []}, f, indent=2, ensure_ascii=False)
+
+    def _load_index(self) -> dict:
+        """Load index"""
+        try:
+            with open(self.index_file, encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return {"notebooks": []}
+
+    def _save_index(self, index: dict):
+        """Save index"""
+        with open(self.index_file, "w", encoding="utf-8") as f:
+            json.dump(index, f, indent=2, ensure_ascii=False)
+
+    def _get_notebook_file(self, notebook_id: str) -> Path:
+        """Get notebook file path"""
+        return self.base_dir / f"{notebook_id}.json"
+
+    def _load_notebook(self, notebook_id: str) -> dict | None:
+        """Load single notebook"""
+        filepath = self._get_notebook_file(notebook_id)
+        if not filepath.exists():
+            return None
+        try:
+            with open(filepath, encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            return None
+
+    def _save_notebook(self, notebook: dict):
+        """Save single notebook"""
+        filepath = self._get_notebook_file(notebook["id"])
+        with open(filepath, "w", encoding="utf-8") as f:
+            json.dump(notebook, f, indent=2, ensure_ascii=False)
+
+    # === Notebook Operations ===
+
+    def create_notebook(
+        self, name: str, description: str = "", color: str = "#3B82F6", icon: str = "book"
+    ) -> dict:
+        """
+        Create new notebook
+
+        Args:
+            name: Notebook name
+            description: Notebook description
+            color: Color code
+            icon: Icon name
+
+        Returns:
+            Created notebook information
+        """
+        notebook_id = str(uuid.uuid4())[:8]
+        now = time.time()
+
+        notebook = {
+            "id": notebook_id,
+            "name": name,
+            "description": description,
+            "created_at": now,
+            "updated_at": now,
+            "records": [],
+            "color": color,
+            "icon": icon,
+        }
+
+        # Save notebook file
+        self._save_notebook(notebook)
+
+        # Update index
+        index = self._load_index()
+        index["notebooks"].append(
+            {
+                "id": notebook_id,
+                "name": name,
+                "description": description,
+                "created_at": now,
+                "updated_at": now,
+                "record_count": 0,
+                "color": color,
+                "icon": icon,
+            }
+        )
+        self._save_index(index)
+
+        return notebook
+
+    def list_notebooks(self) -> list[dict]:
+        """
+        List all notebooks (summary information)
+
+        Returns:
+            Notebook list
+        """
+        index = self._load_index()
+        notebooks = []
+
+        for nb_info in index.get("notebooks", []):
+            # Get latest information from actual file
+            notebook = self._load_notebook(nb_info["id"])
+            if notebook:
+                notebooks.append(
+                    {
+                        "id": notebook["id"],
+                        "name": notebook["name"],
+                        "description": notebook.get("description", ""),
+                        "created_at": notebook["created_at"],
+                        "updated_at": notebook["updated_at"],
+                        "record_count": len(notebook.get("records", [])),
+                        "color": notebook.get("color", "#3B82F6"),
+                        "icon": notebook.get("icon", "book"),
+                    }
+                )
+
+        # Sort by update time
+        notebooks.sort(key=lambda x: x["updated_at"], reverse=True)
+        return notebooks
+
+    def get_notebook(self, notebook_id: str) -> dict | None:
+        """
+        Get notebook details (includes all records)
+
+        Args:
+            notebook_id: Notebook ID
+
+        Returns:
+            Notebook details
+        """
+        return self._load_notebook(notebook_id)
+
+    def update_notebook(
+        self,
+        notebook_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        color: str | None = None,
+        icon: str | None = None,
+    ) -> dict | None:
+        """
+        Update notebook information
+
+        Args:
+            notebook_id: Notebook ID
+            name: New name
+            description: New description
+            color: New color
+            icon: New icon
+
+        Returns:
+            Updated notebook information
+        """
+        notebook = self._load_notebook(notebook_id)
+        if not notebook:
+            return None
+
+        if name is not None:
+            notebook["name"] = name
+        if description is not None:
+            notebook["description"] = description
+        if color is not None:
+            notebook["color"] = color
+        if icon is not None:
+            notebook["icon"] = icon
+
+        notebook["updated_at"] = time.time()
+        self._save_notebook(notebook)
+
+        # Update index
+        index = self._load_index()
+        for nb_info in index["notebooks"]:
+            if nb_info["id"] == notebook_id:
+                if name is not None:
+                    nb_info["name"] = name
+                if description is not None:
+                    nb_info["description"] = description
+                if color is not None:
+                    nb_info["color"] = color
+                if icon is not None:
+                    nb_info["icon"] = icon
+                nb_info["updated_at"] = notebook["updated_at"]
+                break
+        self._save_index(index)
+
+        return notebook
+
+    def delete_notebook(self, notebook_id: str) -> bool:
+        """
+        Delete notebook
+
+        Args:
+            notebook_id: Notebook ID
+
+        Returns:
+            Whether deletion was successful
+        """
+        filepath = self._get_notebook_file(notebook_id)
+        if not filepath.exists():
+            return False
+
+        # Delete file
+        filepath.unlink()
+
+        # Update index
+        index = self._load_index()
+        index["notebooks"] = [nb for nb in index["notebooks"] if nb["id"] != notebook_id]
+        self._save_index(index)
+
+        return True
+
+    # === Record Operations ===
+
+    def add_record(
+        self,
+        notebook_ids: list[str],
+        record_type: RecordType,
+        title: str,
+        user_query: str,
+        output: str,
+        metadata: dict = None,
+        kb_name: str = None,
+    ) -> dict:
+        """
+        Add record to one or more notebooks
+
+        Args:
+            notebook_ids: Target notebook ID list
+            record_type: Record type
+            title: Title
+            user_query: User input
+            output: Output result
+            metadata: Additional metadata
+            kb_name: Knowledge base name
+
+        Returns:
+            Added record information
+        """
+        record_id = str(uuid.uuid4())[:8]
+        now = time.time()
+
+        record = {
+            "id": record_id,
+            "type": record_type,
+            "title": title,
+            "user_query": user_query,
+            "output": output,
+            "metadata": metadata or {},
+            "created_at": now,
+            "kb_name": kb_name,
+        }
+
+        added_to = []
+        for notebook_id in notebook_ids:
+            notebook = self._load_notebook(notebook_id)
+            if notebook:
+                notebook["records"].append(record)
+                notebook["updated_at"] = now
+                self._save_notebook(notebook)
+                added_to.append(notebook_id)
+
+                # Update update time and record count in index
+                index = self._load_index()
+                for nb_info in index["notebooks"]:
+                    if nb_info["id"] == notebook_id:
+                        nb_info["updated_at"] = now
+                        nb_info["record_count"] = len(notebook["records"])
+                        break
+                self._save_index(index)
+
+        return {"record": record, "added_to_notebooks": added_to}
+
+    def remove_record(self, notebook_id: str, record_id: str) -> bool:
+        """
+        Remove record from notebook
+
+        Args:
+            notebook_id: Notebook ID
+            record_id: Record ID
+
+        Returns:
+            Whether deletion was successful
+        """
+        notebook = self._load_notebook(notebook_id)
+        if not notebook:
+            return False
+
+        original_count = len(notebook["records"])
+        notebook["records"] = [r for r in notebook["records"] if r["id"] != record_id]
+
+        if len(notebook["records"]) == original_count:
+            return False
+
+        notebook["updated_at"] = time.time()
+        self._save_notebook(notebook)
+
+        # Update index
+        index = self._load_index()
+        for nb_info in index["notebooks"]:
+            if nb_info["id"] == notebook_id:
+                nb_info["updated_at"] = notebook["updated_at"]
+                nb_info["record_count"] = len(notebook["records"])
+                break
+        self._save_index(index)
+
+        return True
+
+    def get_statistics(self) -> dict:
+        """
+        Get notebook statistics
+
+        Returns:
+            Statistics information
+        """
+        notebooks = self.list_notebooks()
+
+        total_records = 0
+        type_counts = {"solve": 0, "question": 0, "research": 0, "co_writer": 0}
+
+        for nb_info in notebooks:
+            notebook = self._load_notebook(nb_info["id"])
+            if notebook:
+                for record in notebook.get("records", []):
+                    total_records += 1
+                    record_type = record.get("type", "")
+                    if record_type in type_counts:
+                        type_counts[record_type] += 1
+
+        return {
+            "total_notebooks": len(notebooks),
+            "total_records": total_records,
+            "records_by_type": type_counts,
+            "recent_notebooks": notebooks[:5],
+        }
+
+
+# Global instance
+notebook_manager = NotebookManager()

src/api/utils/progress_broadcaster.py

@@ -0,0 +1,72 @@
+"""
+Progress Broadcaster - Manages WebSocket broadcasting of knowledge base progress
+"""
+
+import asyncio
+from typing import Optional
+
+from fastapi import WebSocket
+
+
+class ProgressBroadcaster:
+    """Manages WebSocket broadcasting of knowledge base progress"""
+
+    _instance: Optional["ProgressBroadcaster"] = None
+    _connections: dict[str, set[WebSocket]] = {}  # kb_name -> Set[WebSocket]
+    _lock = asyncio.Lock()
+
+    @classmethod
+    def get_instance(cls) -> "ProgressBroadcaster":
+        """Get singleton instance"""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    async def connect(self, kb_name: str, websocket: WebSocket):
+        """Connect WebSocket to specified knowledge base"""
+        async with self._lock:
+            if kb_name not in self._connections:
+                self._connections[kb_name] = set()
+            self._connections[kb_name].add(websocket)
+            print(
+                f"[ProgressBroadcaster] Connected WebSocket for KB '{kb_name}' (total: {len(self._connections[kb_name])})"
+            )
+
+    async def disconnect(self, kb_name: str, websocket: WebSocket):
+        """Disconnect WebSocket connection"""
+        async with self._lock:
+            if kb_name in self._connections:
+                self._connections[kb_name].discard(websocket)
+                if not self._connections[kb_name]:
+                    del self._connections[kb_name]
+                print(f"[ProgressBroadcaster] Disconnected WebSocket for KB '{kb_name}'")
+
+    async def broadcast(self, kb_name: str, progress: dict):
+        """Broadcast progress update to all WebSocket connections for specified knowledge base"""
+        async with self._lock:
+            if kb_name not in self._connections:
+                return
+
+            # Create list of connections to remove (closed connections)
+            to_remove = []
+
+            for websocket in self._connections[kb_name]:
+                try:
+                    await websocket.send_json({"type": "progress", "data": progress})
+                except Exception as e:
+                    # Connection closed or error, mark for removal
+                    print(
+                        f"[ProgressBroadcaster] Error sending to WebSocket for KB '{kb_name}': {e}"
+                    )
+                    to_remove.append(websocket)
+
+            # Remove closed connections
+            for ws in to_remove:
+                self._connections[kb_name].discard(ws)
+
+            if not self._connections[kb_name]:
+                del self._connections[kb_name]
+
+    def get_connection_count(self, kb_name: str) -> int:
+        """Get connection count for specified knowledge base"""
+        return len(self._connections.get(kb_name, set()))