import asyncio import json from collections.abc import Awaitable, Callable from typing import TypeVar from app import config, rediscli from app.errors import AppError T = TypeVar("T") CFG_SINGLEFLIGHT = "cfg:singleflight" CFG_INVALIDATE = "cfg:invalidate" CFG_DELAY_MS = "cfg:delay_ms" SQL_HISTORY = "metrics:sql:messages_select" class SingleFlight: def __init__(self) -> None: self._lock = asyncio.Lock() self._inflight: dict[str, asyncio.Task] = {} async def do(self, key: str, factory: Callable[[], Awaitable[T]]) -> T: async with self._lock: task = self._inflight.get(key) if task is None: task = asyncio.create_task(factory()) self._inflight[key] = task owner = True else: owner = False try: return await asyncio.shield(task) finally: if owner: async with self._lock: self._inflight.pop(key, None) _sf = SingleFlight() async def _flag(name: str, default: bool = True) -> bool: if not config.lab_mode(): return default try: raw = await rediscli.require().get(name) except Exception: return default if raw is None: return default return raw not in {"0", "false", "off"} async def singleflight_enabled() -> bool: return await _flag(CFG_SINGLEFLIGHT, True) async def invalidate_enabled() -> bool: return await _flag(CFG_INVALIDATE, True) async def incr_history_sql() -> None: try: await rediscli.require().incr(SQL_HISTORY) except Exception: pass async def history_sql_count() -> int: try: return int(await rediscli.require().get(SQL_HISTORY) or 0) except Exception: return 0 async def reset_history_sql_count() -> None: try: await rediscli.require().set(SQL_HISTORY, 0) except Exception: pass async def load_delay_seconds() -> float: if not config.lab_mode(): return 0.0 try: raw = await rediscli.require().get(CFG_DELAY_MS) except Exception: return 0.0 try: return max(0.0, float(raw or 0) / 1000.0) except (TypeError, ValueError): return 0.0 async def set_flags( *, singleflight: bool | None = None, invalidate: bool | None = None, delay_ms: int | None = None, ) -> dict: r = rediscli.require() if singleflight is not None: await r.set(CFG_SINGLEFLIGHT, "1" if singleflight else "0") if invalidate is not None: await r.set(CFG_INVALIDATE, "1" if invalidate else "0") if delay_ms is not None: await r.set(CFG_DELAY_MS, str(int(delay_ms))) return { "singleflight": await singleflight_enabled(), "invalidate": await invalidate_enabled(), "history_sql": await history_sql_count(), "delay_ms": int((await load_delay_seconds()) * 1000), } async def get_history_page(chat_id: str, cursor: str, limit: int, loader: Callable[[], Awaitable[dict]]) -> dict: r = rediscli.require() try: version = await r.get("histver:" + chat_id) or "0" key = f"hist:{chat_id}:{version}:{cursor}:{limit}" cached = await r.get(key) if cached: return json.loads(cached) async def load_and_store() -> dict: delay = await load_delay_seconds() if delay: await asyncio.sleep(delay) page = await loader() try: await r.set(key, json.dumps(page, ensure_ascii=False), ex=config.CACHE_TTL_SECONDS) except Exception: pass return page if await singleflight_enabled(): return await _sf.do(key, load_and_store) return await load_and_store() except AppError: raise except Exception: return await loader() async def invalidate_history(chat_id: str) -> None: if not await invalidate_enabled(): return try: await rediscli.require().incr("histver:" + chat_id) except Exception: pass