feat: add session context and confirmations

这个提交存在于:
Codex 2026-07-20 22:19:04 +08:00
父节点 d60788d6c9
当前提交 4faaa1180c
共有 4 个文件被更改,包括 309 次插入 和 0 次删除

104
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()]

122
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()

48
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

查看文件

@ -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") == []