Automated sync from GitHub

.gitattributes

@@ -1,8 +1,8 @@
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
 *.otf filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.mp3 filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

app/common.py

@@ -157,9 +157,7 @@ async def push_edit(client, ch, p, *, replace_media: bool = False) -> None:
         await with_media(
             p.media_file_id,
             lambda media: client.edit_message(
-                # Do not send reply markup while replacing media. Telegram keeps the existing buttons when the field
-                # is omitted, and rejects an edit that tries to set buttons owned by another bot.
-                peer, p.message_id, text=p.text or "", formatting_entities=ents, file=media
+                peer, p.message_id, text=p.text or "", formatting_entities=ents, buttons=markup, file=media
             ),
         )
     else:

app/handlers/replace.py

@@ -383,8 +383,7 @@ def register(ctx: Ctx) -> None:
 
                 try:
                     res = await apply_channel(
-                        client, db, s, o, batch_id, event.sender_id, edit_delay=cfg.edit_delay, progress=prog,
-                        userbot=ctx.userbot,
+                        client, db, s, o, batch_id, event.sender_id, edit_delay=cfg.edit_delay, progress=prog
                     )
                 except Exception as e:
                     log.exception("apply failed in %s", s.channel.id)

app/replace_engine.py

@@ -21,7 +21,6 @@ from .tgutil import (
     ser_markup,
     state_of,
 )
-from .userbot import UserbotEditor, UserbotError
 
 log = logging.getLogger(__name__)
 
@@ -187,23 +186,6 @@ async def _do_edit(client, peer, m, change, markup, preview) -> None:
         await edit_raw(client, peer, m.id, markup=markup)
 
 
-# Errors that mean the bot cannot edit the message (usually because buttons belong to
-# another bot), but a userbot (normal user account) might still be able to edit the
-# text/caption while leaving the buttons alone.
-_USERBOT_FALLBACK_ERRORS = {
-    "MessageIdInvalidError",
-    "MessageAuthorRequiredError",
-    "InlineBotRequiredError",
-}
-
-
-async def _do_edit_via_userbot(editor: UserbotEditor, m, change, preview) -> None:
-    """Edit only the text/caption of a message through the userbot.  Buttons stay as they are."""
-    if not (change.text_changed or change.entities_changed):
-        return  # nothing the userbot can help with (button-only change)
-    await editor.edit_message(m.id, text=change.new_text, entities=change.new_entities, preview=preview)
-
-
 async def apply_channel(
     client,
     db,
@@ -214,7 +196,6 @@ async def apply_channel(
     *,
     edit_delay: float = 1.2,
     progress: Optional[Callable[[ApplyResult], Awaitable[None]]] = None,
-    userbot=None,
 ) -> ApplyResult:
     ch = scan.channel
     peer = peer_of(ch)
@@ -223,7 +204,6 @@ async def apply_channel(
     ids = sorted(scan.infos)
     buf: list = []
     streak, last_name = 0, None
-    editor: Optional[UserbotEditor] = None  # created lazily on the first fallback
 
     async def flush() -> None:
         nonlocal buf
@@ -250,7 +230,6 @@ async def apply_channel(
                 preview = preview_flag(m)
                 markup = change.new_markup if change.new_markup is not None else m.reply_markup
                 old_state = state_of(m.message, m.entities, m.reply_markup, preview)
-                used_userbot = False
                 try:
                     await flood_retry(lambda: _do_edit(client, peer, m, change, markup, preview))
                 except errors.MessageNotModifiedError:
@@ -258,57 +237,21 @@ async def apply_channel(
                     continue
                 except errors.RPCError as e:
                     name = type(e).__name__
-                    # ---- userbot fallback: edit text/caption only, skip buttons ----
-                    if name in _USERBOT_FALLBACK_ERRORS and (change.text_changed or change.entities_changed):
-                        if userbot is not None and userbot.enabled:
-                            if not userbot.ready:
-                                await userbot.connect()
-                            if userbot.ready:
-                                try:
-                                    if editor is None:
-                                        editor = userbot.editor(ch)
-                                    await flood_retry(
-                                        lambda: _do_edit_via_userbot(editor, m, change, preview)
-                                    )
-                                    used_userbot = True
-                                    log.info(
-                                        "edit of %s/%s succeeded via userbot (bot got %s)",
-                                        ch.id, m.id, name,
-                                    )
-                                except errors.MessageNotModifiedError:
-                                    res.unchanged += 1
-                                    continue
-                                except (errors.RPCError, UserbotError) as ue:
-                                    ub_name = type(ue).__name__
-                                    log.warning(
-                                        "userbot edit of %s/%s also failed: %s",
-                                        ch.id, m.id, ub_name,
-                                    )
-                                    res.failed.append((m.id, f"{name}+{ub_name}"))
-                                    streak = streak + 1 if name == last_name else 1
-                                    last_name = name
-                                    if streak >= ABORT_AFTER:
-                                        res.aborted = name
-                                        break
-                                    continue
-                    if not used_userbot:
-                        log.warning("edit of %s/%s failed: %s", ch.id, m.id, name)
-                        res.failed.append((m.id, name))
-                        streak = streak + 1 if name == last_name else 1
-                        last_name = name
-                        if streak >= ABORT_AFTER:
-                            res.aborted = name
-                            break
-                        continue
+                    log.warning("edit of %s/%s failed: %s", ch.id, m.id, name)
+                    res.failed.append((m.id, name))
+                    streak = streak + 1 if name == last_name else 1
+                    last_name = name
+                    if streak >= ABORT_AFTER:
+                        res.aborted = name
+                        break
+                    continue
                 streak, last_name = 0, None
                 res.edited += 1
                 kind, fid = media_info(m)
-                # when the userbot edited, it could only change text/entities (not buttons)
-                effective_markup = m.reply_markup if used_userbot else markup
                 adopt = {
                     "text": change.new_text,
                     "entities": ser_entities(change.new_entities),
-                    "buttons": ser_markup(effective_markup),
+                    "buttons": ser_markup(markup),
                     "link_preview": bool(preview),
                 }
                 if kind:
@@ -317,7 +260,7 @@ async def apply_channel(
                     {
                         "message_id": m.id,
                         "old_state": old_state,
-                        "new_state": state_of(change.new_text, change.new_entities, effective_markup, preview),
+                        "new_state": state_of(change.new_text, change.new_entities, markup, preview),
                         "adopt": adopt,
                     }
                 )
@@ -329,8 +272,6 @@ async def apply_channel(
             if res.aborted:
                 break
     finally:
-        if editor is not None:
-            await editor.close()
         await flush()
     return res
 

app/tgutil.py

@@ -379,8 +379,8 @@ _HINTS = {
     "InlineBotRequiredError": "That post was sent through another bot's inline mode, so only that bot can edit it.",
     "MessageEditTimeExpiredError": "Telegram no longer allows editing that message.",
     "MessageIdInvalidError": (
-        "Telegram won't let this bot edit that post. Its buttons were left untouched. If the post is still there, "
-        "it was likely sent by another bot or through inline mode; only its original bot can edit it."
+        "Telegram won't let the bot change that message (or it was deleted). If the post is still there, "
+        "the usual reason is that its buttons were added by another bot: only that bot may change them."
     ),
     "ButtonUrlInvalidError": "Telegram rejected one of the button links.",
     "ReplyMarkupInvalidError": "Telegram rejected the buttons.",

app/userbot.py

@@ -20,7 +20,7 @@ from typing import Optional
 from telethon import TelegramClient, errors, functions, types, utils
 from telethon.sessions import StringSession
 
-from .tgutil import edit_raw, flood_retry, get_rights, peer_of
+from .tgutil import flood_retry, get_rights, peer_of
 
 log = logging.getLogger(__name__)
 
@@ -117,9 +117,6 @@ class Userbot:
     def deleter(self, ch) -> "UserbotDeleter":
         return UserbotDeleter(self, ch)
 
-    def editor(self, ch) -> "UserbotEditor":
-        return UserbotEditor(self, ch)
-
     async def fallback_for(self, ch):
         """(delete function, deleter) to hand to the delete step, or (None, None) when no userbot is usable.
 
@@ -401,271 +398,6 @@ class UserbotDeleter:
         )
 
 
-class UserbotEditor:
-    """Everything needed to edit messages in ONE channel with the userbot (text/caption + media only, no buttons).
-
-    The userbot (a normal user account) can edit any message in a channel where it has
-    the \u201cEdit messages of others\u201d admin right, even when a bot cannot because the inline
-    buttons belong to another bot.  Buttons are left untouched.
-
-    Call close() when done, whatever happened.
-    """
-
-    def __init__(self, ub: Userbot, ch):
-        self.ub = ub
-        self.ch = ch
-        self.peer = None
-        self.notes: list = []
-        self._ready = False
-        self._holds_lock = False
-        self._promoted = False
-        self._bot_user = None
-        self._link: Optional[str] = None
-
-    async def edit_message(self, message_id: int, *, text: str, entities=None, preview=None) -> None:
-        """Edit only the text/caption (and entities) of a message via the userbot.  Buttons are not touched."""
-        if not self.ub.ready:
-            raise UserbotError(f"The userbot is not connected: {self.ub.last_error or 'unknown reason'}")
-        if not self._ready:
-            if not self._holds_lock:
-                await self.ub.lock.acquire()
-                self._holds_lock = True
-            await self._prepare()
-            self._ready = True
-        await edit_raw(self.ub.client, self.peer, message_id, text=text, entities=entities, preview=preview)
-
-    async def close(self) -> None:
-        """Undo what this editor changed: take the admin right away again, revoke the temporary link."""
-        bot, ch = self.ub.bot, self.ch
-        try:
-            if self._promoted and self._bot_user is not None and not self.ub.keep_admin:
-                try:
-                    await bot(
-                        functions.channels.EditAdminRequest(
-                            channel=peer_of(ch), user_id=self._bot_user, admin_rights=types.ChatAdminRights(), rank=""
-                        )
-                    )
-                    self.notes.append("took the admin right away from the userbot again")
-                except Exception as e:
-                    log.warning("could not demote the userbot in %s: %s", ch.id, type(e).__name__)
-                    self.notes.append("could not take the admin right away from the userbot - please do it by hand")
-            if self._link:
-                try:
-                    await bot(
-                        functions.messages.EditExportedChatInviteRequest(peer=peer_of(ch), link=self._link, revoked=True)
-                    )
-                except Exception as e:
-                    log.info("could not revoke the temporary invite link: %s", type(e).__name__)
-        finally:
-            self._promoted, self._link = False, None
-            if self._holds_lock:
-                self._holds_lock = False
-                self.ub.lock.release()
-
-    # ----------------------------------------------------------------- prepare
-    async def _prepare(self) -> None:
-        peer = await self._member_peer()
-        if peer is None:
-            peer = await self._join()
-        self.peer = peer
-        await self._ensure_edit_right()
-
-    async def _member_peer(self):
-        ub = self.ub.client
-        try:
-            peer = await ub.get_input_entity(types.PeerChannel(self.ch.id))
-            if not isinstance(peer, types.InputPeerChannel):
-                return None
-            await ub(functions.channels.GetParticipantRequest(peer, types.InputPeerSelf()))
-        except (errors.RPCError, ValueError, TypeError):
-            return None
-        return peer
-
-    async def _invite_link(self) -> Optional[str]:
-        bot, peer = self.ub.bot, peer_of(self.ch)
-        try:
-            expires = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=1)
-            res = await bot(
-                functions.messages.ExportChatInviteRequest(peer=peer, expire_date=expires, usage_limit=1, title="Edit helper")
-            )
-            link = getattr(res, "link", None)
-            if link:
-                self._link = link
-                self.notes.append("made a one-time invite link for the userbot")
-                return link
-        except errors.RPCError as e:
-            log.info("could not create an invite link in %s: %s", self.ch.id, type(e).__name__)
-        try:
-            full = await bot(functions.channels.GetFullChannelRequest(peer))
-            link = getattr(getattr(full.full_chat, "exported_invite", None), "link", None)
-            if link:
-                self.notes.append("used the channel's own invite link")
-                return link
-        except errors.RPCError as e:
-            log.info("could not read the invite link of %s: %s", self.ch.id, type(e).__name__)
-        return None
-
-    async def _join(self):
-        link = await self._invite_link()
-        h = parse_invite_hash(link) if link else None
-        if h:
-            peer = await self._import_invite(h)
-            if peer is not None:
-                self.notes.append("the userbot joined the channel")
-                return peer
-        if self.ch.username:
-            peer = await self._join_public(self.ch.username)
-            self.notes.append("the userbot joined the channel by its public name")
-            return peer
-        raise UserbotError(
-            "I could not get the userbot into this private channel: Telegram gave me no invite link. "
-            "Give the bot the \u201cInvite users via link\u201d admin right, or add the userbot to the channel yourself "
-            "(with the \u201cEdit messages of others\u201d admin right)."
-        )
-
-    async def _import_invite(self, h: str):
-        ub = self.ub.client
-        try:
-            res = await flood_retry(lambda: ub(functions.messages.ImportChatInviteRequest(h)))
-        except errors.UserAlreadyParticipantError:
-            return await self._peer_when_already_in(h)
-        except errors.InviteRequestSentError:
-            raise UserbotError(
-                "This channel\u2019s invite link needs an admin to approve new members. Approve the userbot\u2019s join request "
-                "(or add the userbot yourself) and try again."
-            )
-        except (errors.InviteHashExpiredError, errors.InviteHashInvalidError, errors.InviteHashEmptyError):
-            return None
-        except (errors.ChannelsTooMuchError, errors.UserChannelsTooMuchError):
-            raise UserbotError("The userbot account is in too many channels. Leave a few with that account and try again.")
-        except errors.UserBannedInChannelError:
-            raise UserbotError("The userbot account is banned in this channel. Unban it first.")
-        return self._peer_from_updates(res)
-
-    def _peer_from_updates(self, res):
-        chats = [c for c in (getattr(res, "chats", None) or []) if isinstance(c, types.Channel)]
-        for c in chats:
-            if c.id == self.ch.id:
-                return utils.get_input_peer(c)
-        if len(chats) == 1:
-            return utils.get_input_peer(chats[0])
-        raise UserbotError("The userbot joined, but Telegram did not tell me which channel it is. Try again.")
-
-    async def _peer_when_already_in(self, h: str):
-        ub = self.ub.client
-        try:
-            info = await ub(functions.messages.CheckChatInviteRequest(h))
-            if isinstance(info, types.ChatInviteAlready):
-                return utils.get_input_peer(info.chat)
-        except errors.RPCError:
-            pass
-        async for d in ub.iter_dialogs():
-            if getattr(d.entity, "id", None) == self.ch.id and isinstance(d.entity, types.Channel):
-                return utils.get_input_peer(d.entity)
-        raise UserbotError("The userbot is in the channel, but I could not find it in its chat list.")
-
-    async def _join_public(self, username: str):
-        ub = self.ub.client
-        try:
-            peer = await ub.get_input_entity(username)
-            try:
-                await flood_retry(lambda: ub(functions.channels.JoinChannelRequest(peer)))
-            except errors.UserAlreadyParticipantError:
-                pass
-        except (errors.ChannelsTooMuchError, errors.UserChannelsTooMuchError):
-            raise UserbotError("The userbot account is in too many channels. Leave a few with that account and try again.")
-        except errors.UserBannedInChannelError:
-            raise UserbotError("The userbot account is banned in this channel. Unban it first.")
-        except (errors.UsernameNotOccupiedError, errors.UsernameInvalidError, errors.ChannelPrivateError):
-            raise UserbotError(f"The userbot could not open @{username}. Has the channel\u2019s name changed?")
-        return peer
-
-    # ------------------------------------------------------------------ rights
-    async def _userbot_can_edit(self) -> bool:
-        try:
-            res = await self.ub.client(functions.channels.GetParticipantRequest(self.peer, types.InputPeerSelf()))
-        except errors.RPCError:
-            return False
-        p = res.participant
-        if isinstance(p, types.ChannelParticipantCreator):
-            return True
-        if isinstance(p, types.ChannelParticipantAdmin):
-            return bool(getattr(p.admin_rights, "edit_messages", False))
-        return False
-
-    async def _ensure_edit_right(self) -> None:
-        if await self._userbot_can_edit():
-            return
-        rights = await get_rights(self.ub.bot, self.ch)
-        if rights is None or not (rights.admin and rights.add_admins):
-            raise UserbotError(
-                "The userbot is in the channel but may not edit messages there, and the bot may not add admins. "
-                "Give the bot the \u201cAdd new admins\u201d right (it then promotes the userbot by itself), or make the userbot "
-                "an admin with \u201cEdit messages of others\u201d yourself."
-            )
-        user = await self._bot_view_of_userbot()
-        try:
-            await self.ub.bot(
-                functions.channels.EditAdminRequest(
-                    channel=peer_of(self.ch),
-                    user_id=user,
-                    admin_rights=types.ChatAdminRights(edit_messages=True),
-                    rank="",
-                )
-            )
-        except errors.RPCError as e:
-            name = type(e).__name__
-            hint = {
-                "RightForbiddenError": "The bot may not give that right.",
-                "UserAdminInvalidError": "The bot may not change that user\u2019s admin status.",
-                "AdminsTooMuchError": "The channel already has the maximum number of admins.",
-                "ChatAdminRequiredError": "The bot needs the \u201cAdd new admins\u201d right.",
-            }.get(name, str(e)[:150])
-            raise UserbotError(f"I could not make the userbot an admin ({name}). {hint}")
-        self._promoted, self._bot_user = True, user
-        self.notes.append('made the userbot an admin with only \u201cEdit messages of others\u201d')
-        for _ in range(12):
-            if await self._userbot_can_edit():
-                return
-            await asyncio.sleep(0.5)
-        raise UserbotError("I made the userbot an admin, but Telegram still does not let it edit there. Check its rights.")
-
-    async def _bot_view_of_userbot(self):
-        bot, me = self.ub.bot, self.ub.me
-        uid = me.id
-        try:
-            ent = await bot.get_input_entity(uid)
-            if isinstance(ent, types.InputPeerUser):
-                return types.InputUser(ent.user_id, ent.access_hash)
-        except Exception:
-            pass
-        queries = [types.ChannelParticipantsRecent()]
-        for q in (getattr(me, "username", None), getattr(me, "first_name", None)):
-            if q:
-                queries.append(types.ChannelParticipantsSearch(q))
-        for flt in queries:
-            try:
-                res = await bot(
-                    functions.channels.GetParticipantsRequest(channel=peer_of(self.ch), filter=flt, offset=0, limit=200, hash=0)
-                )
-            except errors.RPCError:
-                continue
-            for u in getattr(res, "users", None) or []:
-                if getattr(u, "id", None) == uid and getattr(u, "access_hash", None) is not None:
-                    return types.InputUser(u.id, u.access_hash)
-        if getattr(me, "username", None):
-            try:
-                ent = await bot.get_input_entity(me.username)
-                if isinstance(ent, types.InputPeerUser):
-                    return types.InputUser(ent.user_id, ent.access_hash)
-            except Exception:
-                pass
-        raise UserbotError(
-            "The userbot joined, but the bot cannot find that account in the channel\u2019s member list, so it cannot "
-            "promote it. Make the userbot an admin with \u201cEdit messages of others\u201d yourself."
-        )
-
-
 def delete_problem_text(ub, *, bot_error: Optional[str] = None, fallback_error: Optional[str] = None, tried: bool = False) -> str:
     """Why some messages could not be deleted, in words for the owner."""
     parts = []

tests/test_wire.py

@@ -115,7 +115,7 @@ def test_media_replacement_edit(client):
     req = capture(push_edit(client, CH, post(media_kind="photo", media_file_id=ref), replace_media=True))
     assert isinstance(req, functions.messages.EditMessageRequest)
     assert isinstance(req.media, types.InputMediaPhoto) and req.message == "Hello 😀"
-    assert req.reply_markup is None  # omit markup: preserve existing buttons, including another bot's buttons
+    assert req.reply_markup is not None
 
 
 def test_reads_deletes_and_rights_requests(client):