report_deleted_telegram_messages.py

# -*- coding: utf-8 -*-
from telethon.sync import TelegramClient,events
from collections import defaultdict
import tempfile
import logging
import time
import os

logging.basicConfig(level=logging.WARNING)
logging.getLogger('asyncio').setLevel(logging.ERROR)

SELF_REPORT = True
API_HASH    = ''
API_ID      = 0
MAX_MEM     = 10000
memory      = {}
client      = TelegramClient('telegram_session', API_ID, API_HASH)

async def on_delete_message(saved):
    user    = saved["user"]
    event   = saved["event"]
    message = event.message.message

    if SELF_REPORT:
        chat = await client.get_entity("me")
    else:
        chat = await client.get_input_entity(user.id)

    chat_from = event.chat if event.chat else (await event.get_chat())
    chat_title = f"| Group: {chat_from.title}" if getattr(chat_from, "title", None) else ''

    first_name = user.first_name if user.first_name else ''
    last_name  = user.last_name if user.last_name else ''
    user_info = f"{first_name} {last_name} (@{user.username}) {chat_title}"
     
    template_msg       = "User: %s\n{message}" % user_info
    template_media     = "User: %s" % user_info
    template_media_msg = "User: %s\n{message}" % user_info

    if not event.media == None:
        temp_name = next(tempfile._get_candidate_names())
        media     = await client.download_media(event.media, temp_name)
        if message:
            await client.send_message(chat,template_media_msg.format(message=message), file=media)
        else:
            await client.send_message(chat,template_media, file=media)
        os.unlink(media)
        return

    await client.send_message(chat,template_msg.format(message=message))


@client.on(events.NewMessage)
async def handle_new_message(event):
    me = await client.get_entity("me")
    from_id = event.from_id.user_id if event.from_id else event.peer_id.user_id
    if me.id == from_id:
        return
    
    memory.update({
        event.id: {
            "event": event,
            "user": await client.get_entity(from_id)
        }
    })

@client.on(events.MessageDeleted)
async def handle_message_deleted(event):
    global memory
    deleted_ids = event.deleted_ids
    for deleted_message in deleted_ids:
        try:
            saved = memory[deleted_message]
            await on_delete_message(saved)
        except:
            pass

    if len(memory) >= MAX_MEM:
        memory = {}

for _ in range(10):
    try:
        client.start()
        client.run_until_disconnected()
    except Exception as e:
        print(e)
        time.sleep(60)