yee88 0.3.0__py3-none-any.whl

yee88/telegram/outbox.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, TYPE_CHECKING
+from collections.abc import Awaitable, Callable, Hashable
+
+import anyio
+
+from .client_api import RetryAfter
+
+SEND_PRIORITY = 0
+DELETE_PRIORITY = 1
+EDIT_PRIORITY = 2
+
+
+@dataclass(slots=True)
+class OutboxOp:
+    execute: Callable[[], Awaitable[Any]]
+    priority: int
+    queued_at: float
+    chat_id: int | None
+    label: str | None = None
+    done: anyio.Event = field(default_factory=anyio.Event)
+    result: Any = None
+
+    def set_result(self, result: Any) -> None:
+        if self.done.is_set():
+            return
+        self.result = result
+        self.done.set()
+
+
+class TelegramOutbox:
+    def __init__(
+        self,
+        *,
+        interval_for_chat: Callable[[int | None], float],
+        clock: Callable[[], float] = time.monotonic,
+        sleep: Callable[[float], Awaitable[None]] = anyio.sleep,
+        on_error: Callable[[OutboxOp, Exception], None] | None = None,
+        on_outbox_error: Callable[[Exception], None] | None = None,
+    ) -> None:
+        self._interval_for_chat = interval_for_chat
+        self._clock = clock
+        self._sleep = sleep
+        self._on_error = on_error
+        self._on_outbox_error = on_outbox_error
+        self._pending: dict[Hashable, OutboxOp] = {}
+        self._cond = anyio.Condition()
+        self._start_lock = anyio.Lock()
+        self._closed = False
+        self._tg: TaskGroup | None = None
+        self.next_at = 0.0
+        self.retry_at = 0.0
+
+    async def ensure_worker(self) -> None:
+        async with self._start_lock:
+            if self._tg is not None or self._closed:
+                return
+            self._tg = await anyio.create_task_group().__aenter__()
+            self._tg.start_soon(self.run)
+
+    async def enqueue(self, *, key: Hashable, op: OutboxOp, wait: bool = True) -> Any:
+        await self.ensure_worker()
+        async with self._cond:
+            if self._closed:
+                op.set_result(None)
+                return op.result
+            previous = self._pending.get(key)
+            if previous is not None:
+                op.queued_at = previous.queued_at
+                previous.set_result(None)
+            self._pending[key] = op
+            self._cond.notify()
+        if not wait:
+            return None
+        await op.done.wait()
+        return op.result
+
+    async def drop_pending(self, *, key: Hashable) -> None:
+        async with self._cond:
+            pending = self._pending.pop(key, None)
+            if pending is not None:
+                pending.set_result(None)
+            self._cond.notify()
+
+    async def close(self) -> None:
+        async with self._cond:
+            self._closed = True
+            self.fail_pending()
+            self._cond.notify_all()
+        if self._tg is not None:
+            await self._tg.__aexit__(None, None, None)
+            self._tg = None
+
+    def fail_pending(self) -> None:
+        for pending in list(self._pending.values()):
+            pending.set_result(None)
+        self._pending.clear()
+
+    def pick_locked(self) -> tuple[Hashable, OutboxOp] | None:
+        if not self._pending:
+            return None
+        return min(
+            self._pending.items(),
+            key=lambda item: (item[1].priority, item[1].queued_at),
+        )
+
+    async def execute_op(self, op: OutboxOp) -> Any:
+        try:
+            return await op.execute()
+        except Exception as exc:  # noqa: BLE001
+            if isinstance(exc, RetryAfter):
+                raise
+            if self._on_error is not None:
+                self._on_error(op, exc)
+            return None
+
+    async def sleep_until(self, deadline: float) -> None:
+        delay = deadline - self._clock()
+        if delay > 0:
+            await self._sleep(delay)
+
+    async def run(self) -> None:
+        cancel_exc = anyio.get_cancelled_exc_class()
+        try:
+            while True:
+                async with self._cond:
+                    while not self._pending and not self._closed:
+                        await self._cond.wait()
+                    if self._closed and not self._pending:
+                        return
+                blocked_until = max(self.next_at, self.retry_at)
+                if self._clock() < blocked_until:
+                    await self.sleep_until(blocked_until)
+                    continue
+                async with self._cond:
+                    if self._closed and not self._pending:
+                        return
+                    picked = self.pick_locked()
+                    if picked is None:
+                        continue
+                    key, op = picked
+                    self._pending.pop(key, None)
+                started_at = self._clock()
+                try:
+                    result = await self.execute_op(op)
+                except RetryAfter as exc:
+                    self.retry_at = max(self.retry_at, self._clock() + exc.retry_after)
+                    async with self._cond:
+                        if self._closed:
+                            op.set_result(None)
+                        elif key not in self._pending:
+                            self._pending[key] = op
+                            self._cond.notify()
+                        else:
+                            op.set_result(None)
+                    continue
+                self.next_at = started_at + self._interval_for_chat(op.chat_id)
+                op.set_result(result)
+        except cancel_exc:
+            return
+        except Exception as exc:  # noqa: BLE001
+            async with self._cond:
+                self._closed = True
+                self.fail_pending()
+                self._cond.notify_all()
+            if self._on_outbox_error is not None:
+                self._on_outbox_error(exc)
+            return
+
+
+if TYPE_CHECKING:
+    from anyio.abc import TaskGroup
+else:
+    TaskGroup = object

yee88/telegram/parsing.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+
+import anyio
+import msgspec
+
+from ..logging import get_logger
+from .api_schemas import (
+    CallbackQuery,
+    Document,
+    Message,
+    PhotoSize,
+    Sticker,
+    Update,
+    Video,
+)
+from .client_api import BotClient
+from .types import (
+    TelegramCallbackQuery,
+    TelegramDocument,
+    TelegramIncomingMessage,
+    TelegramIncomingUpdate,
+    TelegramVoice,
+)
+
+logger = get_logger(__name__)
+
+
+def parse_incoming_update(
+    update: Update,
+    *,
+    chat_id: int | None = None,
+    chat_ids: set[int] | None = None,
+) -> TelegramIncomingUpdate | None:
+    if update.message is not None:
+        return _parse_incoming_message(
+            update.message,
+            chat_id=chat_id,
+            chat_ids=chat_ids,
+        )
+    if update.callback_query is not None:
+        return _parse_callback_query(
+            update.callback_query,
+            chat_id=chat_id,
+            chat_ids=chat_ids,
+        )
+    return None
+
+
+def _parse_incoming_message(
+    msg: Message,
+    *,
+    chat_id: int | None = None,
+    chat_ids: set[int] | None = None,
+) -> TelegramIncomingMessage | None:
+    raw_text = msg.text
+    caption = msg.caption
+    text = raw_text if raw_text is not None else caption
+    if text is None:
+        text = ""
+    file_command = False
+    stripped = text.lstrip()
+    if stripped.startswith("/"):
+        token = stripped.split(maxsplit=1)[0]
+        file_command = token.startswith("/file")
+    voice_payload: TelegramVoice | None = None
+    if msg.voice is not None:
+        voice_payload = TelegramVoice(
+            file_id=msg.voice.file_id,
+            mime_type=msg.voice.mime_type,
+            file_size=msg.voice.file_size,
+            duration=msg.voice.duration,
+            raw=msgspec.to_builtins(msg.voice),
+        )
+        if raw_text is None and caption is None:
+            text = ""
+    document_payload: TelegramDocument | None = None
+    if msg.document is not None:
+        document_payload = _document_from_media(msg.document)
+    if document_payload is None and msg.video is not None:
+        document_payload = _document_from_media(msg.video)
+    if document_payload is None:
+        best = _best_photo(msg.photo)
+        if best is not None:
+            document_payload = _document_from_photo(best)
+    if document_payload is None and file_command and msg.sticker is not None:
+        document_payload = _document_from_sticker(msg.sticker)
+    has_text = raw_text is not None or caption is not None
+    if not has_text and voice_payload is None and document_payload is None:
+        return None
+    msg_chat_id = msg.chat.id
+    chat_type = msg.chat.type
+    is_forum = msg.chat.is_forum
+    allowed = chat_ids
+    if allowed is None and chat_id is not None:
+        allowed = {chat_id}
+    if allowed is not None and msg_chat_id not in allowed:
+        return None
+    reply = msg.reply_to_message
+    reply_to_message_id = reply.message_id if reply is not None else None
+    reply_to_text = reply.text if reply is not None else None
+    reply_to_is_bot = (
+        reply.from_.is_bot if reply is not None and reply.from_ is not None else None
+    )
+    reply_to_username = (
+        reply.from_.username if reply is not None and reply.from_ is not None else None
+    )
+    sender_id = msg.from_.id if msg.from_ is not None else None
+    media_group_id = msg.media_group_id
+    thread_id = msg.message_thread_id
+    is_topic_message = msg.is_topic_message
+    if thread_id is not None and reply_to_message_id == thread_id:
+        reply_to_message_id = None
+        reply_to_text = None
+        reply_to_is_bot = None
+        reply_to_username = None
+    return TelegramIncomingMessage(
+        transport="telegram",
+        chat_id=msg_chat_id,
+        message_id=msg.message_id,
+        text=text,
+        reply_to_message_id=reply_to_message_id,
+        reply_to_text=reply_to_text,
+        reply_to_is_bot=reply_to_is_bot,
+        reply_to_username=reply_to_username,
+        sender_id=sender_id,
+        media_group_id=media_group_id,
+        thread_id=thread_id,
+        is_topic_message=is_topic_message,
+        chat_type=chat_type,
+        is_forum=is_forum,
+        voice=voice_payload,
+        document=document_payload,
+        raw=msgspec.to_builtins(msg),
+    )
+
+
+def _parse_callback_query(
+    query: CallbackQuery,
+    *,
+    chat_id: int | None = None,
+    chat_ids: set[int] | None = None,
+) -> TelegramCallbackQuery | None:
+    callback_id = query.id
+    msg = query.message
+    if msg is None:
+        return None
+    msg_chat_id = msg.chat.id
+    allowed = chat_ids
+    if allowed is None and chat_id is not None:
+        allowed = {chat_id}
+    if allowed is not None and msg_chat_id not in allowed:
+        return None
+    data = query.data
+    sender_id = query.from_.id if query.from_ is not None else None
+    return TelegramCallbackQuery(
+        transport="telegram",
+        chat_id=msg_chat_id,
+        message_id=msg.message_id,
+        callback_query_id=callback_id,
+        data=data,
+        sender_id=sender_id,
+        raw=msgspec.to_builtins(query),
+    )
+
+
+def _best_photo(photos: list[PhotoSize] | None) -> PhotoSize | None:
+    if not photos:
+        return None
+    best = None
+    best_score = -1
+    for item in photos:
+        size = item.file_size
+        score = size if size is not None else item.width * item.height
+        if score > best_score:
+            best_score = score
+            best = item
+    return best
+
+
+def _document_from_media(media: Document | Video) -> TelegramDocument:
+    return TelegramDocument(
+        file_id=media.file_id,
+        file_name=media.file_name,
+        mime_type=media.mime_type,
+        file_size=media.file_size,
+        raw=msgspec.to_builtins(media),
+    )
+
+
+def _document_from_photo(photo: PhotoSize) -> TelegramDocument:
+    return TelegramDocument(
+        file_id=photo.file_id,
+        file_name=None,
+        mime_type=None,
+        file_size=photo.file_size,
+        raw=msgspec.to_builtins(photo),
+    )
+
+
+def _document_from_sticker(sticker: Sticker) -> TelegramDocument:
+    return TelegramDocument(
+        file_id=sticker.file_id,
+        file_name=None,
+        mime_type=None,
+        file_size=sticker.file_size,
+        raw=msgspec.to_builtins(sticker),
+    )
+
+
+async def poll_incoming(
+    bot: BotClient,
+    *,
+    chat_id: int | None = None,
+    chat_ids: Iterable[int] | Callable[[], Iterable[int]] | None = None,
+    offset: int | None = None,
+    sleep: Callable[[float], Awaitable[None]] = anyio.sleep,
+) -> AsyncIterator[TelegramIncomingUpdate]:
+    while True:
+        updates = await bot.get_updates(
+            offset=offset,
+            timeout_s=50,
+            allowed_updates=["message", "callback_query"],
+        )
+        if updates is None:
+            logger.info("loop.get_updates.failed")
+            await sleep(2)
+            continue
+        logger.debug("loop.updates", updates=updates)
+        resolved_chat_ids = chat_ids() if callable(chat_ids) else chat_ids
+        allowed = set(resolved_chat_ids) if resolved_chat_ids is not None else None
+        if allowed is None and chat_id is not None:
+            allowed = {chat_id}
+        for upd in updates:
+            offset = upd.update_id + 1
+            msg = parse_incoming_update(upd, chat_ids=allowed)
+            if msg is not None:
+                yield msg

yee88/telegram/render.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from markdown_it import MarkdownIt
+from sulguk import transform_html
+
+from ..markdown import MarkdownParts, assemble_markdown_parts
+
+MAX_BODY_CHARS = 3500
+
+_MD_RENDERER = MarkdownIt("commonmark", {"html": False})
+_BULLET_RE = re.compile(r"(?m)^(\s*)•")
+_FENCE_RE = re.compile(r"^(?P<indent>[ \t]*)(?P<fence>[`~]{3,})(?P<info>.*)$")
+
+
+@dataclass(frozen=True, slots=True)
+class _FenceState:
+    fence: str
+    indent: str
+    header: str
+
+
+def render_markdown(md: str) -> tuple[str, list[dict[str, Any]]]:
+    html = _MD_RENDERER.render(md or "")
+    rendered = transform_html(html)
+
+    text = _BULLET_RE.sub(r"\1-", rendered.text)
+
+    entities = [dict(e) for e in rendered.entities]
+    return text, entities
+
+
+def _split_line_ending(line: str) -> tuple[str, str]:
+    if line.endswith("\r\n"):
+        return line[:-2], "\r\n"
+    if line.endswith("\n"):
+        return line[:-1], "\n"
+    if line.endswith("\r"):
+        return line[:-1], "\r"
+    return line, ""
+
+
+def _split_long_line(line: str, max_chars: int) -> list[str]:
+    if len(line) <= max_chars:
+        return [line]
+    content, ending = _split_line_ending(line)
+    parts: list[str] = []
+    for idx in range(0, len(content), max_chars):
+        chunk = content[idx : idx + max_chars]
+        if idx + max_chars >= len(content):
+            chunk += ending
+        parts.append(chunk)
+    if not parts and ending:
+        parts.append(ending)
+    return parts
+
+
+def _split_block(block: str, max_chars: int) -> list[str]:
+    if len(block) <= max_chars:
+        return [block]
+    pieces: list[str] = []
+    current = ""
+    for line in block.splitlines(keepends=True):
+        for part in _split_long_line(line, max_chars):
+            if not part:
+                continue
+            if current and len(current) + len(part) > max_chars:
+                pieces.append(current)
+                current = ""
+            current += part
+            if len(current) == max_chars:
+                pieces.append(current)
+                current = ""
+    if current:
+        pieces.append(current)
+    return pieces
+
+
+def _update_fence_state(line: str, state: _FenceState | None) -> _FenceState | None:
+    match = _FENCE_RE.match(line)
+    if match is None:
+        return state
+    fence = match.group("fence")
+    indent = match.group("indent")
+    if state is None:
+        return _FenceState(fence=fence, indent=indent, header=line)
+    if fence[0] == state.fence[0] and len(fence) >= len(state.fence):
+        return None
+    return state
+
+
+def _scan_fence_state(text: str, state: _FenceState | None) -> _FenceState | None:
+    for line in text.splitlines():
+        state = _update_fence_state(line, state)
+    return state
+
+
+def _ensure_trailing_newline(text: str) -> str:
+    if text.endswith("\n") or text.endswith("\r"):
+        return text
+    return text + "\n"
+
+
+def _close_fence_chunk(text: str, state: _FenceState) -> str:
+    return _ensure_trailing_newline(text) + f"{state.indent}{state.fence}\n"
+
+
+def _reopen_fence_prefix(state: _FenceState) -> str:
+    return f"{state.header}\n"
+
+
+def split_markdown_body(body: str, max_chars: int) -> list[str]:
+    if not body or not body.strip():
+        return []
+    max_chars = max(1, int(max_chars))
+    segments = re.split(r"(\n{2,})", body)
+    blocks: list[str] = []
+    for idx in range(0, len(segments), 2):
+        paragraph = segments[idx]
+        separator = segments[idx + 1] if idx + 1 < len(segments) else ""
+        block = paragraph + separator
+        if block:
+            blocks.append(block)
+
+    chunks: list[str] = []
+    current = ""
+    state: _FenceState | None = None
+    for block in blocks:
+        for piece in _split_block(block, max_chars):
+            if not current:
+                current = piece
+                state = _scan_fence_state(piece, state)
+                continue
+            if len(current) + len(piece) <= max_chars:
+                current += piece
+                state = _scan_fence_state(piece, state)
+                continue
+
+            if state is not None:
+                current = _close_fence_chunk(current, state)
+            chunks.append(current)
+            current = _reopen_fence_prefix(state) if state is not None else ""
+            current += piece
+            state = _scan_fence_state(piece, state)
+
+    if current:
+        chunks.append(current)
+
+    return [chunk for chunk in chunks if chunk.strip()]
+
+
+def trim_body(body: str | None, *, max_chars: int = MAX_BODY_CHARS) -> str | None:
+    if not body:
+        return None
+    if len(body) > max_chars:
+        body = body[: max_chars - 1] + "…"
+    return body if body.strip() else None
+
+
+def prepare_telegram(parts: MarkdownParts) -> tuple[str, list[dict[str, Any]]]:
+    trimmed = MarkdownParts(
+        header=parts.header or "",
+        body=trim_body(parts.body, max_chars=MAX_BODY_CHARS),
+        footer=parts.footer,
+    )
+    return render_markdown(assemble_markdown_parts(trimmed))
+
+
+def prepare_telegram_multi(
+    parts: MarkdownParts, *, max_body_chars: int = MAX_BODY_CHARS
+) -> list[tuple[str, list[dict[str, Any]]]]:
+    body = parts.body
+    if body is not None and not body.strip():
+        body = None
+    body_chunks = split_markdown_body(body, max_body_chars) if body is not None else []
+    if not body_chunks:
+        body_chunks = [""]
+    total = len(body_chunks)
+
+    payloads: list[tuple[str, list[dict[str, Any]]]] = []
+    for idx, chunk in enumerate(body_chunks, start=1):
+        header = parts.header or ""
+        if idx > 1:
+            if header:
+                header = f"{header} · continued ({idx}/{total})"
+            else:
+                header = f"continued ({idx}/{total})"
+        payloads.append(
+            render_markdown(
+                assemble_markdown_parts(
+                    MarkdownParts(header=header, body=chunk, footer=parts.footer)
+                )
+            )
+        )
+    return payloads

yee88/telegram/state_store.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Protocol
+
+import anyio
+import msgspec
+
+from ..utils.json_state import atomic_write_json
+
+
+class _Logger(Protocol):
+    def warning(self, event: str, **fields: Any) -> None: ...
+
+
+class _VersionedState(Protocol):
+    version: int
+
+
+class JsonStateStore[T: _VersionedState]:
+    def __init__(
+        self,
+        path: Path,
+        *,
+        version: int,
+        state_type: type[T],
+        state_factory: Callable[[], T],
+        log_prefix: str,
+        logger: _Logger,
+    ) -> None:
+        self._path = path
+        self._lock = anyio.Lock()
+        self._loaded = False
+        self._mtime_ns: int | None = None
+        self._state_type = state_type
+        self._state_factory = state_factory
+        self._version = version
+        self._log_prefix = log_prefix
+        self._logger = logger
+        self._state = state_factory()
+
+    def _stat_mtime_ns(self) -> int | None:
+        try:
+            return self._path.stat().st_mtime_ns
+        except FileNotFoundError:
+            return None
+
+    def _reload_locked_if_needed(self) -> None:
+        current = self._stat_mtime_ns()
+        if self._loaded and current == self._mtime_ns:
+            return
+        self._load_locked()
+
+    def _load_locked(self) -> None:
+        self._loaded = True
+        self._mtime_ns = self._stat_mtime_ns()
+        if self._mtime_ns is None:
+            self._state = self._state_factory()
+            return
+        try:
+            payload = msgspec.json.decode(
+                self._path.read_bytes(), type=self._state_type
+            )
+        except Exception as exc:  # noqa: BLE001
+            self._logger.warning(
+                f"{self._log_prefix}.load_failed",
+                path=str(self._path),
+                error=str(exc),
+                error_type=exc.__class__.__name__,
+            )
+            self._state = self._state_factory()
+            return
+        if payload.version != self._version:
+            self._logger.warning(
+                f"{self._log_prefix}.version_mismatch",
+                path=str(self._path),
+                version=payload.version,
+                expected=self._version,
+            )
+            self._state = self._state_factory()
+            return
+        self._state = payload
+
+    def _save_locked(self) -> None:
+        payload = msgspec.to_builtins(self._state)
+        atomic_write_json(self._path, payload)
+        self._mtime_ns = self._stat_mtime_ns()