| from asyncio import sleep |
| from typing import List |
|
|
| from pyrogram.errors import ( |
| FloodWait, |
| ChatAdminRequired, |
| ChannelPrivate, |
| MessageDeleteForbidden, |
| MessageAuthorRequired, |
| PeerIdInvalid, |
| UserNotParticipant, |
| AuthKeyUnregistered, |
| SessionRevoked, |
| RPCError, |
| ) |
|
|
| from Backend.logger import LOGGER |
| from Backend.pyrofork.bot import StreamBot, Userbot |
|
|
| DELETE_BATCH_SIZE = 10 |
| _FALLBACK_WORTHY = ( |
| ChatAdminRequired, |
| ChannelPrivate, |
| MessageDeleteForbidden, |
| MessageAuthorRequired, |
| PeerIdInvalid, |
| UserNotParticipant, |
| RPCError, |
| ) |
| _SESSION_DEAD = (AuthKeyUnregistered, SessionRevoked) |
| _userbot_session_dead = False |
|
|
|
|
| def _userbot_usable() -> bool: |
| return Userbot is not None and not _userbot_session_dead |
|
|
|
|
| |
| async def edit_message(chat_id: int, msg_id: int, new_caption: str): |
| try: |
| await StreamBot.edit_message_caption(chat_id=chat_id, message_id=msg_id, caption=new_caption) |
| await sleep(2) |
| return |
| except FloodWait as e: |
| LOGGER.warning(f"FloodWait for {e.value}s while editing message {msg_id} in {chat_id}") |
| await sleep(e.value) |
| try: |
| await StreamBot.edit_message_caption(chat_id=chat_id, message_id=msg_id, caption=new_caption) |
| return |
| except Exception as e2: |
| LOGGER.error(f"Retry after FloodWait failed while editing {msg_id} in {chat_id}: {e2}") |
| except _FALLBACK_WORTHY as e: |
| if not _userbot_usable(): |
| LOGGER.error(f"Error while editing message {msg_id} in {chat_id}: {e}") |
| return |
| LOGGER.info(f"[USERBOT] Fallback triggered: edit_message {msg_id} in {chat_id} (StreamBot: {e})") |
| await _userbot_edit(chat_id, msg_id, new_caption) |
| except Exception as e: |
| LOGGER.error(f"Error while editing message {msg_id} in {chat_id}: {e}") |
|
|
|
|
| async def _userbot_edit(chat_id: int, msg_id: int, new_caption: str): |
| global _userbot_session_dead |
| try: |
| await Userbot.edit_message_caption(chat_id=chat_id, message_id=msg_id, caption=new_caption) |
| await sleep(2) |
| except FloodWait as e: |
| LOGGER.warning(f"[USERBOT] FloodWait detected: sleeping {e.value}s (edit {msg_id} in {chat_id})") |
| await sleep(e.value) |
| try: |
| await Userbot.edit_message_caption(chat_id=chat_id, message_id=msg_id, caption=new_caption) |
| except Exception as e2: |
| LOGGER.error(f"[USERBOT] Retry after FloodWait failed while editing {msg_id} in {chat_id}: {e2}") |
| except _SESSION_DEAD as e: |
| _userbot_session_dead = True |
| LOGGER.error(f"[USERBOT] Session invalid ({type(e).__name__}): {e}. Disabling Userbot fallback for this run.") |
| except Exception as e: |
| LOGGER.error(f"[USERBOT] Error while editing message {msg_id} in {chat_id}: {e}") |
|
|
|
|
| async def delete_message(chat_id: int, msg_id: int): |
| await delete_messages_batch(chat_id, [msg_id]) |
|
|
|
|
| |
| async def delete_messages_batch(chat_id: int, msg_ids: List[int]): |
| if not msg_ids: |
| return |
|
|
| for i in range(0, len(msg_ids), DELETE_BATCH_SIZE): |
| chunk = msg_ids[i:i + DELETE_BATCH_SIZE] |
|
|
| remaining = await _delete_chunk(StreamBot, "StreamBot", chat_id, chunk) |
|
|
| if remaining and _userbot_usable(): |
| LOGGER.info(f"[USERBOT] Fallback triggered: deleting {len(remaining)} message(s) in {chat_id}") |
| remaining = await _delete_chunk(Userbot, "Userbot", chat_id, remaining) |
|
|
| if remaining: |
| LOGGER.error( |
| f"Could not delete {len(remaining)} message(s) in {chat_id} " |
| f"(no usable Userbot fallback)" if not _userbot_usable() else |
| f"Could not delete {len(remaining)} message(s) in {chat_id} even with Userbot fallback" |
| ) |
|
|
| await sleep(1) |
|
|
|
|
| async def _delete_chunk(client, client_label: str, chat_id: int, msg_ids: List[int]) -> List[int]: |
| global _userbot_session_dead |
| try: |
| await client.delete_messages(chat_id=chat_id, message_ids=msg_ids) |
| LOGGER.info(f"[{client_label.upper()}] Deleted {len(msg_ids)} message(s) in {chat_id}") |
| return [] |
| except FloodWait as e: |
| LOGGER.warning(f"[{client_label.upper()}] FloodWait detected: sleeping {e.value}s ({len(msg_ids)} msg(s) in {chat_id})") |
| await sleep(e.value) |
| try: |
| await client.delete_messages(chat_id=chat_id, message_ids=msg_ids) |
| LOGGER.info(f"[{client_label.upper()}] Deleted {len(msg_ids)} message(s) in {chat_id} after FloodWait retry") |
| return [] |
| except Exception as e2: |
| LOGGER.error(f"[{client_label.upper()}] Retry after FloodWait failed in {chat_id}: {e2}") |
| return msg_ids |
| except _SESSION_DEAD as e: |
| if client_label == "Userbot": |
| _userbot_session_dead = True |
| LOGGER.error(f"[{client_label.upper()}] Session invalid ({type(e).__name__}): {e}") |
| return msg_ids |
| except _FALLBACK_WORTHY as e: |
| LOGGER.warning(f"[{client_label.upper()}] Cannot delete in {chat_id} ({type(e).__name__}): {e}") |
| return msg_ids |
| except Exception as e: |
| LOGGER.error(f"[{client_label.upper()}] Unexpected error deleting in {chat_id}: {e}") |
| return msg_ids |
|
|
