"""Bounded, reload-safe chat sessions for confirmations and selection.""" from __future__ import annotations from dataclasses import dataclass, field from datetime import datetime, timedelta, timezone from threading import RLock from typing import Any from pathlib import Path import json from core.config_writer import write_text_atomic from core.runtime_paths import resolve_data_path @dataclass class ChatSession: key: str action: str payload: dict[str, Any] expires_at: datetime created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc)) class ChatSessionStore: def __init__(self, *, ttl_seconds: int = 600, max_sessions: int = 1000, persistence_path: str | Path | None = None): self.ttl_seconds = ttl_seconds self.max_sessions = max_sessions self._items: dict[str, ChatSession] = {} self._lock = RLock() self.persistence_path = Path(persistence_path) if persistence_path is not None else resolve_data_path("data/chat_sessions.json") self._load() def put(self, key: str, action: str, payload: dict[str, Any]) -> ChatSession: with self._lock: self._prune() if len(self._items) >= self.max_sessions: oldest = min(self._items.values(), key=lambda item: item.created_at) self._items.pop(oldest.key, None) session = ChatSession(key, action, dict(payload), datetime.now(timezone.utc) + timedelta(seconds=self.ttl_seconds)) self._items[key] = session self._save() return session def get(self, key: str) -> ChatSession | None: with self._lock: self._prune() return self._items.get(key) def pop(self, key: str) -> ChatSession | None: with self._lock: self._prune() session = self._items.pop(key, None) self._save() return session def _prune(self) -> None: now = datetime.now(timezone.utc) for key in [key for key, item in self._items.items() if item.expires_at <= now]: self._items.pop(key, None) def _load(self) -> None: try: payload = json.loads(self.persistence_path.read_text(encoding="utf-8")) except (OSError, ValueError, TypeError): return for item in payload if isinstance(payload, list) else []: try: session = ChatSession( key=str(item["key"]), action=str(item["action"]), payload=dict(item.get("payload") or {}), expires_at=datetime.fromisoformat(item["expires_at"]), created_at=datetime.fromisoformat(item["created_at"]), ) self._items[session.key] = session except (KeyError, TypeError, ValueError): continue self._prune() def _save(self) -> None: payload = [ {"key": item.key, "action": item.action, "payload": item.payload, "expires_at": item.expires_at.isoformat(), "created_at": item.created_at.isoformat()} for item in self._items.values() ] try: write_text_atomic(self.persistence_path, json.dumps(payload, ensure_ascii=False, indent=2)) except OSError: return