diff --git a/confirmation.py b/confirmation.py new file mode 100644 index 0000000..503b85e --- /dev/null +++ b/confirmation.py @@ -0,0 +1,104 @@ +"""Short-lived confirmation requests for side-effecting operations.""" + +from __future__ import annotations + +import secrets +import time +from dataclasses import asdict, dataclass +from typing import Any, Callable + + +@dataclass(frozen=True, slots=True) +class ConfirmationRequest: + code: str + session_origin: str + user_id: str + operation: str + target: dict[str, Any] + created_at: float + expires_at: float + + +class ConfirmationStore: + """In-memory confirmation store bound to the originating session and user.""" + + def __init__( + self, + *, + ttl: int = 120, + clock: Callable[[], float] = time.time, + ) -> None: + self.ttl = max(int(ttl), 1) + self._clock = clock + self._requests: dict[str, ConfirmationRequest] = {} + + def _purge_expired(self) -> None: + now = self._clock() + expired = [ + code + for code, request in self._requests.items() + if request.expires_at <= now + ] + for code in expired: + self._requests.pop(code, None) + + def create( + self, + *, + session_origin: str, + user_id: str, + operation: str, + target: dict[str, Any], + ) -> ConfirmationRequest: + self._purge_expired() + now = self._clock() + code = secrets.token_hex(3) + while code in self._requests: + code = secrets.token_hex(3) + request = ConfirmationRequest( + code=code, + session_origin=session_origin, + user_id=user_id, + operation=operation, + target=target, + created_at=now, + expires_at=now + self.ttl, + ) + self._requests[code] = request + return request + + def get( + self, + code: str, + *, + session_origin: str, + user_id: str, + ) -> ConfirmationRequest | None: + self._purge_expired() + request = self._requests.get(code.strip().lower()) + if request is None: + return None + if request.session_origin != session_origin or request.user_id != user_id: + return None + return request + + def consume( + self, + code: str, + *, + session_origin: str, + user_id: str, + ) -> ConfirmationRequest | None: + request = self.get(code, session_origin=session_origin, user_id=user_id) + if request is None: + return None + self._requests.pop(request.code, None) + return request + + def cancel(self, code: str) -> bool: + self._purge_expired() + return self._requests.pop(code.strip().lower(), None) is not None + + def snapshot(self) -> list[dict[str, Any]]: + self._purge_expired() + return [asdict(request) for request in self._requests.values()] diff --git a/session_context.py b/session_context.py new file mode 100644 index 0000000..263fb33 --- /dev/null +++ b/session_context.py @@ -0,0 +1,122 @@ +"""Persistent per-conversation search context.""" + +from __future__ import annotations + +import json +import os +import tempfile +import time +from pathlib import Path +from typing import Any, Callable + + +class SessionContextStore: + """Store recent media/resource results without mixing conversations.""" + + def __init__( + self, + path: str | Path, + *, + ttl: int = 600, + clock: Callable[[], float] = time.time, + ) -> None: + self.path = Path(path) + self.ttl = max(int(ttl), 1) + self._clock = clock + self._sessions: dict[str, dict[str, Any]] = {} + self._load() + + def _load(self) -> None: + if not self.path.exists(): + return + try: + payload = json.loads(self.path.read_text(encoding="utf-8")) + except (OSError, ValueError): + return + if isinstance(payload, dict): + self._sessions = { + str(key): value + for key, value in payload.items() + if isinstance(value, dict) + } + self._purge_expired(save=False) + + def _save(self) -> None: + self.path.parent.mkdir(parents=True, exist_ok=True) + fd, temp_name = tempfile.mkstemp( + prefix=f"{self.path.name}.", suffix=".tmp", dir=self.path.parent + ) + try: + with os.fdopen(fd, "w", encoding="utf-8") as output: + json.dump(self._sessions, output, ensure_ascii=False, indent=2) + output.write("\n") + os.replace(temp_name, self.path) + finally: + if os.path.exists(temp_name): + os.remove(temp_name) + + def _purge_expired(self, *, save: bool = True) -> None: + now = self._clock() + expired = [ + origin + for origin, session in self._sessions.items() + if float(session.get("updated_at", 0)) + self.ttl <= now + ] + for origin in expired: + self._sessions.pop(origin, None) + if expired and save: + self._save() + + def _session(self, origin: str) -> dict[str, Any]: + self._purge_expired() + return self._sessions.setdefault(origin, {}) + + def _touch(self, origin: str) -> dict[str, Any]: + session = self._session(origin) + session["updated_at"] = self._clock() + return session + + def set_media_results(self, origin: str, results: list[dict[str, Any]]) -> None: + session = self._touch(origin) + session["media_results"] = results + session.pop("resource_results", None) + self._save() + + def get_media_results(self, origin: str) -> list[dict[str, Any]]: + results = self._session(origin).get("media_results", []) + return results if isinstance(results, list) else [] + + def get_media_result(self, origin: str, index: int) -> dict[str, Any] | None: + results = self.get_media_results(origin) + if index < 1 or index > len(results): + return None + item = results[index - 1] + return item if isinstance(item, dict) else None + + def set_resource_results( + self, origin: str, media: dict[str, Any], results: list[dict[str, Any]] + ) -> None: + session = self._touch(origin) + session["resource_media"] = media + session["resource_results"] = results + self._save() + + def get_resource_results(self, origin: str) -> list[dict[str, Any]]: + results = self._session(origin).get("resource_results", []) + return results if isinstance(results, list) else [] + + def get_resource_result(self, origin: str, index: int) -> dict[str, Any] | None: + results = self.get_resource_results(origin) + if index < 1 or index > len(results): + return None + item = results[index - 1] + return item if isinstance(item, dict) else None + + def get_resource_media(self, origin: str) -> dict[str, Any] | None: + media = self._session(origin).get("resource_media") + return media if isinstance(media, dict) else None + + def clear(self, origin: str) -> None: + if origin in self._sessions: + self._sessions.pop(origin, None) + self._save() diff --git a/tests/test_confirmation.py b/tests/test_confirmation.py new file mode 100644 index 0000000..bb6a426 --- /dev/null +++ b/tests/test_confirmation.py @@ -0,0 +1,48 @@ +from confirmation import ConfirmationStore + + +def test_confirmation_is_bound_to_session_and_user() -> None: + store = ConfirmationStore(ttl=30, clock=lambda: 100) + request = store.create( + session_origin="qq:group:1", + user_id="100", + operation="download", + target={"resource_id": 1}, + ) + + assert store.get( + request.code, session_origin="qq:group:1", user_id="100" + ) == request + assert store.get( + request.code, session_origin="qq:group:2", user_id="100" + ) is None + assert store.get( + request.code, session_origin="qq:group:1", user_id="999" + ) is None + + +def test_confirmation_is_consumed_once() -> None: + store = ConfirmationStore(ttl=30, clock=lambda: 100) + request = store.create( + session_origin="session", + user_id="100", + operation="delete", + target={"id": 1}, + ) + + assert store.consume(request.code, session_origin="session", user_id="100") + assert store.consume(request.code, session_origin="session", user_id="100") is None + + +def test_expired_confirmation_cannot_be_consumed() -> None: + now = [100.0] + store = ConfirmationStore(ttl=30, clock=lambda: now[0]) + request = store.create( + session_origin="session", + user_id="100", + operation="delete", + target={"id": 1}, + ) + now[0] = 131.0 + + assert store.consume(request.code, session_origin="session", user_id="100") is None diff --git a/tests/test_session_context.py b/tests/test_session_context.py new file mode 100644 index 0000000..6620d5a --- /dev/null +++ b/tests/test_session_context.py @@ -0,0 +1,35 @@ +from pathlib import Path + +from session_context import SessionContextStore + + +def test_session_results_are_isolated_and_persisted(tmp_path: Path) -> None: + now = [100.0] + path = tmp_path / "sessions.json" + store = SessionContextStore(path, ttl=10, clock=lambda: now[0]) + store.set_media_results("qq:group:1", [{"id": "tmdb:1"}]) + store.set_resource_results( + "qq:group:1", {"id": "tmdb:1"}, [{"download": "one"}] + ) + + restored = SessionContextStore(path, ttl=10, clock=lambda: now[0]) + assert restored.get_media_result("qq:group:1", 1) == {"id": "tmdb:1"} + assert restored.get_resource_result("qq:group:1", 1) == {"download": "one"} + assert restored.get_media_result("qq:group:2", 1) is None + + +def test_new_media_search_clears_previous_resources(tmp_path: Path) -> None: + store = SessionContextStore(tmp_path / "sessions.json", ttl=10, clock=lambda: 100) + store.set_resource_results("session", {"id": "tmdb:1"}, [{"id": 1}]) + store.set_media_results("session", [{"id": "tmdb:2"}]) + + assert store.get_resource_results("session") == [] + + +def test_expired_session_is_removed(tmp_path: Path) -> None: + now = [100.0] + store = SessionContextStore(tmp_path / "sessions.json", ttl=10, clock=lambda: now[0]) + store.set_media_results("session", [{"id": 1}]) + now[0] = 111.0 + + assert store.get_media_results("session") == []