| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102 |
- """Route a client-created Telegram DM topic's thread-less opener into that topic (#136567).
- Telegram for Android (13.0.x) delivers the opening message of a topic created from the "All
- messages" view with no ``message_thread_id``. The ``Message`` carrying ``forum_topic_created`` is then
- the only update that names the new topic (``ForumTopicCreated`` itself has only name/icon fields).
- Recording authorized, non-bot private-chat creations lets the thread-less messages that follow adopt
- the new topic instead of arriving lobby-shaped, where gateway topic recovery would pin them to the
- most recently bound topic.
- Adoption follows time and per-chat order, never message-id adjacency: private-chat message ids come
- from one sequence shared by every private chat of the bot account (bot replies included), so a send
- elsewhere between the creation and the opener breaks ``creation + 1``. Per-chat FIFO update
- processing guarantees nothing from this chat lands in between.
- """
- import logging
- import time
- from typing import Any, Optional
- logger = logging.getLogger("plugins.platforms.telegram.adapter")
- class TelegramTopicRoutingMixin:
- """Topic-creation bookkeeping for ``TelegramAdapter`` (relies on its ``_chat_type_str``/``_chat_id_str``)."""
- # A thread-less message from the creator adopts the new topic while it was SENT within this many
- # seconds of the creation or of the previous adopted message (the client sends the opener
- # ~0.2-1 s after the creation; a split long text or an album follows within the same second).
- # Measured on Telegram's ``Message.date`` stamps, never on handler time: per-chat FIFO holds a
- # follow-up behind the previous handler (a photo download, STT), and it must not age out there.
- _NEW_TOPIC_FOLLOW_SECONDS = 5.0
- _NEW_TOPIC_OPENER_MAX_PENDING = 256
- # Memory bound only (local clock), far above any handler backlog; adoption never reads it.
- _NEW_TOPIC_RECORD_TTL_SECONDS = 600.0
- @staticmethod
- def _creator_key(message) -> str:
- return str(getattr(getattr(message, "from_user", None), "id", ""))
- @staticmethod
- def _sent_at(message) -> Optional[float]:
- """Telegram's send stamp (whole seconds); an edit keeps its message's original ``date``."""
- date = getattr(message, "date", None)
- return date.timestamp() if hasattr(date, "timestamp") else None
- async def _handle_forum_topic_created(self, update: Any, context: Any) -> None:
- """Record an authorized, non-bot private-chat topic creation (#136567).
- Routing signal only, never an agent turn. The user-chosen name is NOT cached in ``_dm_topics``:
- entries there mark operator-declared topics, which session-title auto-rename skips.
- """
- message = getattr(update, "effective_message", None)
- if message is None or getattr(message, "forum_topic_created", None) is None:
- return
- # Private chats only: in a forum group a thread-less message is General, never an opener.
- if self._chat_type_str(getattr(message, "chat", None)) != "private":
- return
- thread_id = getattr(message, "message_thread_id", None)
- sender = getattr(message, "from_user", None)
- sent_at = self._sent_at(message)
- if thread_id is None or sent_at is None or sender is None or getattr(sender, "is_bot", False) is True:
- return
- if not self._is_user_authorized_from_message(message):
- return
- pending = self.__dict__.setdefault("_pending_created_topics", {})
- now = time.monotonic()
- for key in [k for k, rec in pending.items() if now - rec[2] > self._NEW_TOPIC_RECORD_TTL_SECONDS]:
- del pending[key]
- while len(pending) >= self._NEW_TOPIC_OPENER_MAX_PENDING:
- del pending[min(pending, key=lambda k: pending[k][2])]
- chat_id = self._chat_id_str(message)
- pending[(chat_id, self._creator_key(message))] = (str(thread_id), sent_at, now)
- logger.debug("[%s] Recorded new Telegram topic %s (chat=%s)", self.name, thread_id, chat_id)
- def _adopt_created_topic_thread(self, message: Any, chat_type: str, thread_id: Optional[str]) -> Optional[str]:
- """Thread id of the topic this sender just created, for its thread-less follow-up messages.
- A threaded message (the topic now routes normally) or a send gap longer than
- ``_NEW_TOPIC_FOLLOW_SECONDS`` ends the follow; each adoption extends it, so every chunk of a
- split opener lands in the same topic.
- """
- # .get: adapters built without __init__ (object.__new__ in tests) have no store yet.
- pending = self.__dict__.get("_pending_created_topics")
- if chat_type != "dm" or not pending:
- return thread_id
- key = (self._chat_id_str(message), self._creator_key(message))
- record = pending.get(key)
- sent_at = self._sent_at(message)
- # An edit of a message sent before the creation stays where that message lived and leaves
- # the record for the real opener.
- if record is None or sent_at is None or sent_at < record[1]:
- return thread_id
- del pending[key]
- if thread_id is not None or getattr(message, "message_thread_id", None) is not None:
- return thread_id
- created_thread_id, last_sent_at, _recorded = record
- if sent_at - last_sent_at > self._NEW_TOPIC_FOLLOW_SECONDS:
- return thread_id
- pending[key] = (created_thread_id, sent_at, time.monotonic())
- logger.info("[%s] Thread-less message %s adopted by new Telegram topic %s (chat=%s)",
- self.name, getattr(message, "message_id", "?"), created_thread_id, key[0])
- return created_thread_id
|