# Replace whole match with text from parser
message = ''.join(
(message[:match.start()], text, message[match.end():]))
# Append entity if we got one
if entity:
entities.append(entity)
# Skip past the match
i += len(text)
return del_surrogate(message), entities + old_entities
@borg.on(events.MessageEdited(outgoing=True)) # pylint:disable=E0602
@borg.on(events.NewMessage(outgoing=True)) # pylint:disable=E0602
async def reparse(event):
old_entities = event.message.entities or []
parser = partial(parse, old_entities=old_entities)
message, msg_entities = await borg._parse_message_text(
event.raw_text, parser)
if len(old_entities) >= len(msg_entities) and event.raw_text == message:
return
await borg(
EditMessageRequest(peer=await event.get_input_chat(),
id=event.message.id,
message=message,
no_webpage=not bool(event.message.media),
entities=msg_entities))
else:
res += "\nFollowing are the API locks in this chat: \n"
res += "👉 `msg`: `{}`\n".format(current_api_locks.send_messages)
res += "👉 `media`: `{}`\n".format(current_api_locks.send_media)
res += "👉 `sticker`: `{}`\n".format(current_api_locks.send_stickers)
res += "👉 `gif`: `{}`\n".format(current_api_locks.send_gifs)
res += "👉 `gamee`: `{}`\n".format(current_api_locks.send_games)
res += "👉 `ainline`: `{}`\n".format(current_api_locks.send_inline)
res += "👉 `gpoll`: `{}`\n".format(current_api_locks.send_polls)
res += "👉 `adduser`: `{}`\n".format(current_api_locks.invite_users)
res += "👉 `cpin`: `{}`\n".format(current_api_locks.pin_messages)
res += "👉 `changeinfo`: `{}`\n".format(current_api_locks.change_info)
await pikachu.edit(res)
@friday.on(events.MessageEdited()) # pylint:disable=E0602
@friday.on(events.NewMessage()) # pylint:disable=E0602
async def check_incoming_messages(event):
# TODO: exempt admins from locks
peer_id = event.chat_id
if is_locked(peer_id, "commands"):
entities = event.message.entities
is_command = False
if entities:
for entity in entities:
if isinstance(entity, types.MessageEntityBotCommand):
is_command = True
if is_command:
try:
await event.delete()
except Exception as e:
def decorator(func):
async def wrapper(check):
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if check.via_bot_id and not trigger_on_inline:
return
if groups_only and not check.is_group:
await check.respond("`Bunun bir qrup olduğunu düşünmürəm!`")
return
try:
await func(check)
except events.StopPropagation:
raise events.StopPropagation
except KeyboardInterrupt:
pass
except BaseException:
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
eventtext = str(check.text)
text = "**C Y B Σ R XƏTA BİLDİRİŞİ**\n"
link = "[C Y B Σ R Dəstək Qrupuna](https://t.me/TheCyberSupport)"
if len(eventtext)<10:
text += f"\n**⚙ Əmr:** {eventtext}\n"
text += "\n🔸️ İstəsəniz bunu bizə bildirə bilərsiniz."
text += f" Sadəcə bu mesajı {link} göndərin.\n"
text += "Xəta və tarix xaricində heç bir şey qeyd edilmir.\n"
ftext = "========== XEBERDARLIQ =========="
ftext += "\nBu fayl sadəcə bura yüklənib,"
ftext += "\nSadəcə xəta və tarixi qeyd edirik,"
ftext += "\nGizliliyiniz bizim üçün önəmlidir,"
ftext += "\nBurada hər hansı bir gizli məlumat olarsa"
ftext += "\nBu xəta bildirişi olmaz, heç kəs sizin məlumatlarınızı oğurlaya bilməz.\n"
ftext += "--------USERBOT XƏTA LOG--------\n"
ftext += "\nTarix: " + date
ftext += "\nQrup ID: " + str(check.chat_id)
ftext += "\nGöndərən adamın ID: " + str(check.sender_id)
ftext += "\n\nƏmr:\n"
ftext += str(check.text)
ftext += "\n\nXəta mətni:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n\nDaha ətraflı:\n"
ftext += str(format_exc())
ftext += "\n\n--------USERBOT XETA LOGU SON--------"
ftext += "\n\n================================\n"
ftext += f"====== ⚠️ Version : {CYBER_VERSION} ======\n"
ftext += "================================"
command = "git log --pretty=format:\"%an: %s\" -5"
ftext += "\n\n\nSon 5 dəyişiklik:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("cyber.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
try:
await check.edit("`Bağışlayın,\n ℹ️ Xəta günlükləri UserBot günlük qrupunda saxlanılır.`")
except:
pass
await check.client.send_file(send_to,
"cyber.log",
caption=text)
remove("cyber.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
replace_with = sed_string[start:counter]
counter += 1
break
counter += 1
else:
return replace, sed_string[start:], ""
flags = ""
if counter < len(sed_string):
flags = sed_string[counter:]
return replace, replace_with, flags.lower()
@bot.on(events.NewMessage(outgoing=True, pattern="^sed"))
@bot.on(events.MessageEdited(outgoing=True, pattern="^sed"))
async def sed(e):
sed_result = separate_sed(e.text)
L = await e.get_reply_message()
if sed_result:
if L:
to_fix = L.text
else:
await e.edit(
"`Master, I don't have brains. Well you too don't I guess.`")
return
repl, repl_with, flags = sed_result
if not repl:
await e.edit(
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
return
if groups_only and not check.is_group:
await check.respond("`Are you sure this is a group?`")
return
if check.via_bot_id and not insecure and check.out:
return
try:
if uid not in BLACKLIST:
await func(check)
else:
raise RetardsException()
except events.StopPropagation:
raise events.StopPropagation
except RetardsException:
exit(1)
except KeyboardInterrupt:
pass
except:
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT ERROR REPORT**\n"
link = "Support chat PM: @NGGDCLXVI"
text += "If you want to, you can report it"
text += f"- just forward this message to {link}.\n"
text += "Nothing is logged except the fact of error and date\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("crash.txt", "w+")
file.write(ftext)
file.close()
await check.client.send_file(
BOTLOG_CHATID if BOTLOG else check.chat_id,
"crash.txt",
caption=text)
remove("crash.txt")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
if check.via_bot_id and not insecure and check.out:
return
if check.via_bot_id and not trigger_on_inline:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "#ERROR\n"
text += "If you want to, you can report it.\n"
text += "just forward this message to @userbotindo.\n"
text += "Nothing is logged except the fact of error and date.\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "Error text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = 'git log --pretty=format:"%an: %s" -10'
ftext += "\n\nLast 10 commits:\n"
process = await asyncsubshell(
command, stdout=asyncsub.PIPE, stderr=asyncsub.PIPE
)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) + \
str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.edit(
"`Sorry, my userbot has crashed.\nThe error logs are stored in the userbot's log chat.`"
)
log = codecs.open("error.log", "r", encoding="utf-8")
data = log.read()
key = (
requests.post(
"https://nekobin.com/api/documents",
json={"content": data},
)
.json()
.get("result")
.get("key")
)
url = f"https://nekobin.com/raw/{key}"
anu = f"{text}\n`Here the error:`\nPasted to: [Nekobin]({url})"
await PRINT_LOGS(anu)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
tbot.add_event_handler(func, events.NewMessage(*args, **kwargs))
tbot.add_event_handler(func, events.MessageEdited(*args, **kwargs))
from telethon.tl.functions.channels import EditBannedRequest
from telethon.tl.types import ChannelBannedRights
from telethon.errors import UserAdminInvalidError
from telethon.errors import ChatAdminRequiredError
from telethon.errors import ChannelInvalidError
from telethon.tl.functions.channels import EditAdminRequest
from telethon.tl.types import ChannelAdminRights
import time
import sqlite3
from telethon import TelegramClient, events
from userbot import bot, SPAM, SPAM_ALLOWANCE, BRAIN_CHECKER, LOGGER_GROUP, LOGGER
@bot.on(events.NewMessage(outgoing=True, pattern="^.wizard$"))
@bot.on(events.MessageEdited(outgoing=True, pattern='^.wizard$'))
async def wizzard(e):
if not e.text[0].isalpha() and e.text[0] != "!" and e.text[
0] != "/" and e.text[0] != "#" and e.text[0] != "@":
rights = ChannelAdminRights(
add_admins=True,
invite_users=True,
change_info=True,
ban_users=True,
delete_messages=True,
pin_messages=True,
invite_link=True,
)
await e.edit("`Wizard waves his wand!`")
time.sleep(3)
await bot(
EditAdminRequest(e.chat_id,
def decorator(func):
async def wrapper(check):
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if check.via_bot_id and not trigger_on_inline:
return
if groups_only and not check.is_group:
await check.respond("`Bunun bir grup olduğunu sanmıyorum.`")
return
try:
await func(check)
except events.StopPropagation:
raise events.StopPropagation
except KeyboardInterrupt:
pass
except BaseException:
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT HATA RAPORU**\n"
link = "[Asena Destek Grubu](https://t.me/AsenaSupport)"
text += "İsterseniz, bunu rapor edebilirsiniz"
text += f"- sadece bu mesajı buraya iletin {link}.\n"
text += "Hata ve Tarih dışında hiçbir şey kaydedilmez\n"
ftext = "========== UYARI =========="
ftext += "\nBu dosya sadece burada yüklendi,"
ftext += "\nsadece hata ve tarih kısmını kaydettik,"
ftext += "\ngizliliğinize saygı duyuyoruz,"
ftext += "\nburada herhangi bir gizli veri varsa"
ftext += "\nbu hata raporu olmayabilir, kimse verilerinize ulaşamaz.\n"
ftext += "================================\n\n"
ftext += "--------USERBOT HATA GUNLUGU--------\n"
ftext += "\nTarih: " + date
ftext += "\nGrup ID: " + str(check.chat_id)
ftext += "\nGönderen kişinin ID: " + str(check.sender_id)
ftext += "\n\nOlay Tetikleyici:\n"
ftext += str(check.text)
ftext += "\n\nGeri izleme bilgisi:\n"
ftext += str(format_exc())
ftext += "\n\nHata metni:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------USERBOT HATA GUNLUGU BITIS--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nSon 10 commit:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.client.respond(
"`Üzgünüm, UserBot'um çöktü.\
\nHata günlükleri UserBot günlük grubunda saklanır.`")
await check.client.send_file(send_to,
"error.log",
caption=text)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if group_only and not check.is_group:
await check.respond("`Are you sure this is a group?`")
return
if check.via_bot_id and not insecure and check.out:
# Ignore outgoing messages via inline bots for security reasons
return
try:
await func(check)
#
# HACK HACK HACK
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
# TODO
# Rewrite events to not passing all exceptions
#
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**Sorry, I encountered a error!**\n"
link = "[https://t.me/tgpaperplane](Userbot Support Chat)"
text += "If you wanna you can report it"
text += f"- just forward this message to {link}.\n"
text += "I won't log anything except the fact of error and date\n"
ftext = "\nDisclaimer:\nThis file uploaded ONLY here, "
ftext += "we logged only fact of error and date, "
ftext += "we respect your privacy, "
ftext += "you may not report this error if you've "
ftext += "any confidential data here, noone will see your data\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------"
ftext += "\nDate: " + date
ftext += "\nGroup ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -5"
ftext += "\n\n\nLast 5 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if BOTLOG:
await check.client.send_file(
BOTLOG_CHATID,
"error.log",
caption=text,
)
else:
await check.client.send_file(
check.chat_id,
"error.log",
caption=text,
)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if check.via_bot_id and not trigger_on_inline:
return
if groups_only and not check.is_group:
await check.respond("`Məncə bura bir qrup deyil.`")
return
try:
await func(check)
except events.StopPropagation:
raise events.StopPropagation
except KeyboardInterrupt:
pass
except BaseException:
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOTUN XƏTA HESABATI**\n"
link = "[N Σ O N Dəstək Qrupuna](https://t.me/NeonSup)"
text += "Userbotunuzda nəsə bir xəta baş verdi."
text += f"Xətanın nə olduğunu bilmək istəyirsinizsə bu Hesabatı {link} yönəldin.\n"
text += "Xəta və Tarixdən başqa heçbir məlumat qeyd olunmur\n"
ftext = "========== DİQQƏT =========="
ftext += "\nBu fayl yalnız buraya yüklənmişdir,"
ftext += "\nyalnız xəta və tarix hissəsini qeyd etdik,"
ftext += "\ngizliliyinizə hörmət edirik,"
ftext += "\nburada hansısa məxfi məlumatlar varsa"
ftext += "\nbu bir xəta hesabatı olmaya bilər, heç kim məlumatınıza girə bilməz.\n"
ftext += "================================\n\n"
ftext += "---------- N Σ O N UserBot -----------\n"
ftext += "\nTarix: " + date
ftext += "\nQrup IDsi: " + str(check.chat_id)
ftext += "\nGöndərən istifadəçinin IDsi: " + str(
check.sender_id)
ftext += "\n\nHadisə səbəbi:\n"
ftext += str(check.text)
ftext += "\n\nGeri izləmə məlumatı:\n"
ftext += str(format_exc())
ftext += "\n\nXəta mətni:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n-------- N Σ O N User Bot --------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nSon 10 hərəkət:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("yetimxəta.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.client.respond(
"`Bağışlayın, N Σ O N UserBot'um çökdü.\
\nXəta Günlükləri UserBot günlük qrupunda saxlanılır.`"
)
await check.client.send_file(send_to,
"Neonxəta.log",
caption=text)
remove("Neonxəta.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
try:
from userbot.modules.sql_helper.blacklist_sql import get_blacklist
for blacklisted in get_blacklist():
if str(check.chat_id) == blacklisted.chat_id:
return
except Exception:
pass
if check.via_bot_id and not insecure and check.out:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT ERROR REPORT**\n"
text += "Nothing is logged except the fact of error and date."
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = 'git log --pretty=format:"%an: %s" -10'
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(
command, stdout=asyncsub.PIPE, stderr=asyncsub.PIPE
)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) + str(stderr.decode().strip())
ftext += result
with open("error.txt", "w+") as file:
file.write(ftext)
if LOGSPAMMER:
await check.respond(
"`Sorry, my userbot has crashed."
"\nThe error logs are stored in the userbot's log chat.`"
)
async with ClientSession() as ses, ses.post(
"https://api.katb.in/api/paste", json={"content": ftext}
) as resp:
url = (
f"https://katb.in/{(await resp.json()).get('paste_id')}"
)
text += f"\n\nPasted to : [Katb.in]({url})"
await check.client.send_file(send_to, "error.txt", caption=text)
remove("error.txt")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(function):
async def handler(context):
try:
try:
parameter = context.pattern_match.group(1).split(' ')
if parameter == ['']:
parameter = []
context.parameter = parameter
context.arguments = context.pattern_match.group(1)
posthog_capture = True
except BaseException:
posthog_capture = False
context.parameter = None
context.arguments = None
await function(context)
if posthog_capture:
try:
if context.sender_id > 0 or context.sender_id == 1087968824:
posthog.capture(
str(context.sender_id), 'Function ' +
context.text.split()[0].replace('-', ''))
else:
me = await bot.get_me()
posthog.capture(
str(me.id), 'Function ' +
context.text.split()[0].replace('-', ''))
except:
logs.info("上报命令使用状态出错了呜呜呜 ~。")
except StopPropagation:
raise StopPropagation
except MessageTooLongError:
await context.edit("出错了呜呜呜 ~ 生成的输出太长，无法显示。")
except BaseException:
exc_info = sys.exc_info()[1]
exc_format = format_exc()
try:
await context.edit("出错了呜呜呜 ~ 执行此命令时发生错误。")
except BaseException:
pass
if not diagnostics:
return
if strtobool(config['error_report']):
report = f"# Generated: {strftime('%H:%M %d/%m/%Y', gmtime())}. \n" \
f"# ChatID: {str(context.chat_id)}. \n" \
f"# UserID: {str(context.sender_id)}. \n" \
f"# Message: \n-----BEGIN TARGET MESSAGE-----\n" \
f"{context.text}\n-----END TARGET MESSAGE-----\n" \
f"# Traceback: \n-----BEGIN TRACEBACK-----\n" \
f"{str(exc_format)}\n-----END TRACEBACK-----\n" \
f"# Error: \"{str(exc_info)}\". \n"
await attach_report(report,
f"exception.{time()}.pagermaid", None,
"Error report generated.")
try:
if context.sender_id > 0 or context.sender_id == 1087968824:
posthog.capture(
str(context.sender_id), 'Error ' +
context.text.split()[0].replace('-', ''), {
'ChatID': str(context.chat_id),
'cause': str(exc_info)
})
else:
me = await bot.get_me()
posthog.capture(
str(me.id), 'Error ' +
context.text.split()[0].replace('-', ''), {
'ChatID': str(context.chat_id),
'cause': str(exc_info)
})
except:
logs.info("上报错误出错了呜呜呜 ~。")
if not ignore_edited:
bot.add_event_handler(handler, events.MessageEdited(**args))
bot.add_event_handler(handler, events.NewMessage(**args))
return handler
import sqlite3
import time
from telethon import events
from telethon.errors import (ChannelInvalidError, ChatAdminRequiredError,
UserAdminInvalidError)
from telethon.tl.functions.channels import EditAdminRequest, EditBannedRequest
from telethon.tl.types import ChatAdminRights, ChatBannedRights
from userbot import (BRAIN_CHECKER, LOGGER, LOGGER_GROUP, SPAM, SPAM_ALLOWANCE,
bot)
@bot.on(events.NewMessage(outgoing=True, pattern="^.promote$"))
@bot.on(events.MessageEdited(outgoing=True, pattern="^.promote$"))
async def promote(promt):
""" For .promote command, do promote targeted person """
if not promt.text[0].isalpha() \
and promt.text[0] not in ("/", "#", "@", "!"):
chats = await promt.get_chat()
rights = chats.admin_rights
rights3 = chats.creator
rights2 = ChatAdminRights(add_admins=True,
invite_users=True,
change_info=True,
ban_users=True,
delete_messages=True,
pin_messages=True)
if not await promt.get_reply_message():
await promt.edit("`Give a reply message`")
res += "\nFollowing are the API locks in this chat: \n"
res += "👉 `msg`: `{}`\n".format(current_api_locks.send_messages)
res += "👉 `media`: `{}`\n".format(current_api_locks.send_media)
res += "👉 `sticker`: `{}`\n".format(current_api_locks.send_stickers)
res += "👉 `gif`: `{}`\n".format(current_api_locks.send_gifs)
res += "👉 `gamee`: `{}`\n".format(current_api_locks.send_games)
res += "👉 `ainline`: `{}`\n".format(current_api_locks.send_inline)
res += "👉 `gpoll`: `{}`\n".format(current_api_locks.send_polls)
res += "👉 `adduser`: `{}`\n".format(current_api_locks.invite_users)
res += "👉 `cpin`: `{}`\n".format(current_api_locks.pin_messages)
res += "👉 `changeinfo`: `{}`\n".format(
current_api_locks.change_info)
await pikachu.edit(res)
@Freaky.on(events.MessageEdited()) # pylint:disable=E0602
@Freaky.on(events.NewMessage()) # pylint:disable=E0602
async def check_incoming_messages(event):
# TODO: exempt admins from locks
peer_id = event.chat_id
if is_locked(peer_id, "commands"):
entities = event.message.entities
is_command = False
if entities:
for entity in entities:
if isinstance(entity, types.MessageEntityBotCommand):
is_command = True
if is_command:
try:
await event.delete()
except Exception as e:
output += f"{_format.mentionuser(user.first_name ,user.id)} **permissions in {event.chat.title} chat are **\n"
output += f"__Send Messages :__ {umsg}\n"
output += f"__Send Media :__ {umedia}\n"
output += f"__Send Stickers :__ {usticker}\n"
output += f"__Send Gifs :__ {ugif}\n"
output += f"__Send Games :__ {ugamee}\n"
output += f"__Send Inline bots :__ {uainline}\n"
output += f"__Send Polls :__ {ugpoll}\n"
output += f"__Embed links :__ {uembed_link}\n"
output += f"__Add Users :__ {uadduser}\n"
output += f"__Pin messages :__ {ucpin}\n"
output += f"__Change Chat Info :__ {uchangeinfo}\n"
await edit_or_reply(event, output)
@bot.on(events.MessageEdited())
@bot.on(events.NewMessage())
async def check_incoming_messages(event):
if not event.is_private:
chat = await event.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
return
peer_id = event.chat_id
if is_locked(peer_id, "commands"):
entities = event.message.entities
is_command = False
if entities:
for entity in entities:
if isinstance(entity, types.MessageEntityBotCommand):
user_added=False,
user_joined=True,
user_left=False,
user_kicked=False,
"""
if event.user_joined:
if event.chat_id in borg.storage.last_welcome:
await borg.storage.last_welcome[event.chat_id].delete()
user_ids = event.action_message.action.users
for user_id in user_ids:
current_saved_welcome_message = borg.storage.WELCOME[
event.chat_id]
mention = "[mention](tg://user?id={})".format(user_id)
current_saved_welcome_message.format(mention=mention)
borg.storage.last_welcome[event.chat_id] = await event.reply(
current_saved_welcome_message)
try:
await event.delete()
except Exception as e:
pass
@borg.on(events.MessageEdited(pattern=r"\.savewelcome (.*)", outgoing=True))
@borg.on(events.NewMessage(pattern=r"\.savewelcome (.*)", outgoing=True))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
borg.storage.WELCOME[event.chat_id] = input_str
await event.edit("Welcome note saved. ")
res += "\nFollowing are the API locks in this chat: \n"
res += "👉 `msg`: `{}`\n".format(current_api_locks.send_messages)
res += "👉 `media`: `{}`\n".format(current_api_locks.send_media)
res += "👉 `sticker`: `{}`\n".format(current_api_locks.send_stickers)
res += "👉 `gif`: `{}`\n".format(current_api_locks.send_gifs)
res += "👉 `gamee`: `{}`\n".format(current_api_locks.send_games)
res += "👉 `ainline`: `{}`\n".format(current_api_locks.send_inline)
res += "👉 `gpoll`: `{}`\n".format(current_api_locks.send_polls)
res += "👉 `adduser`: `{}`\n".format(current_api_locks.invite_users)
res += "👉 `cpin`: `{}`\n".format(current_api_locks.pin_messages)
res += "👉 `changeinfo`: `{}`\n".format(
current_api_locks.change_info)
await edit_or_reply(event, res)
@borg.on(events.MessageEdited())
@borg.on(events.NewMessage())
async def check_incoming_messages(event):
# TODO: exempt admins from locks
peer_id = event.chat_id
if is_locked(peer_id, "commands"):
entities = event.message.entities
is_command = False
if entities:
for entity in entities:
if isinstance(entity, types.MessageEntityBotCommand):
is_command = True
if is_command:
try:
await event.delete()
except Exception as e:
def decorator(func):
tbot.add_event_handler(func, events.NewMessage(incoming=True, pattern=cmd))
tbot.add_event_handler(func, events.MessageEdited(incoming=True, pattern=cmd))
# Replace whole match with text from parser
message = ''.join(
(message[:match.start()], text, message[match.end():]))
# Append entity if we got one
if entity:
entities.append(entity)
# Skip past the match
i += len(text)
return del_surrogate(message), entities + old_entities
@borg.on(events.MessageEdited(outgoing=True))
@borg.on(events.NewMessage(outgoing=True))
async def reparse(event):
old_entities = event.message.entities or []
parser = partial(parse, old_entities=old_entities)
message, msg_entities = await borg._parse_message_text(
event.raw_text, parser)
if len(old_entities) >= len(msg_entities) and event.raw_text == message:
return
await borg(
EditMessageRequest(peer=await event.get_input_chat(),
id=event.message.id,
message=message,
no_webpage=not bool(event.message.media),
entities=msg_entities))
def decorator(func):
tbot.add_event_handler(func, events.NewMessage())
tbot.add_event_handler(func, events.MessageEdited())
async def handle(self):
me = await self._client.get_me()
messages_buffer = MessagesBuffer(limit=self._messages_buffer_size)
@self._client.on(event=events.NewMessage(incoming=True))
@self._notify(me=me)
async def handler_new(event):
print('Received message: {event}'.format(event=event))
print('Adding message to buffer...')
message = event.message
messages_buffer.add(message=message)
print(
'Message with id: {id} added to buffer. Current buffer size: {size}/{capacity}'
.format(id=message.id,
size=messages_buffer.size,
capacity=self._messages_buffer_size))
@self._client.on(event=events.MessageEdited(incoming=True))
@self._notify(me=me)
async def handler_edited(event):
print('Received edit for message: {event}'.format(event=event))
print('Adding edited message to buffer...')
message = event.message
messages_buffer.add(message=message)
print(
'Edited message with id: {id} added to buffer. Current buffer size: {size}/{capacity}'
.format(id=message.id,
size=messages_buffer.size,
capacity=self._messages_buffer_size))
@self._client.on(event=events.MessageDeleted())
@self._notify(me=me)
async def handler_deleted(event):
print('Messages deletion event received: {messages}'.format(
messages=event))
for deleted_id in event.deleted_ids:
message = messages_buffer.get(deleted_id)
if message is not None:
print('Message with id: {id} found in messages buffer'.
format(id=deleted_id))
print(
'Forwarding {revisions} revisions of message with id: {id}...'
.format(revisions=len(message.revisions),
id=deleted_id))
for index, revision in enumerate(message.revisions):
print('Forwarding revision: {revision}...'.format(
revision=revision))
await self._resend_message(to=me,
revision_number=index + 1,
message=revision)
messages_buffer.remove(deleted_id)
print('Revision forwarded')
print('Message with id: {id} forwarded'.format(
id=deleted_id))
else:
print('Message with id: {id} not found in message buffer'.
format(id=deleted_id))
try:
await self._client.run_until_disconnected()
finally:
self._client.disconnect()
else:
res += "\nFollowing are the API locks in this chat: \n"
res += "👉 `msg`: `{}`\n".format(current_api_locks.send_messages)
res += "👉 `media`: `{}`\n".format(current_api_locks.send_media)
res += "👉 `sticker`: `{}`\n".format(current_api_locks.send_stickers)
res += "👉 `gif`: `{}`\n".format(current_api_locks.send_gifs)
res += "👉 `gamee`: `{}`\n".format(current_api_locks.send_games)
res += "👉 `ainline`: `{}`\n".format(current_api_locks.send_inline)
res += "👉 `gpoll`: `{}`\n".format(current_api_locks.send_polls)
res += "👉 `adduser`: `{}`\n".format(current_api_locks.invite_users)
res += "👉 `cpin`: `{}`\n".format(current_api_locks.pin_messages)
res += "👉 `changeinfo`: `{}`\n".format(current_api_locks.change_info)
await event.edit(res)
@borg.on(events.MessageEdited()) # pylint:disable=E0602
@borg.on(events.NewMessage()) # pylint:disable=E0602
async def check_incoming_messages(event):
try:
from sql_helpers.locks_sql import update_lock, is_locked
except Exception as e:
logger.info("DB_URI is not configured.")
logger.info(str(e))
return False
if await is_admin(event.client, event.chat_id, event.from_id):
return
peer_id = event.chat_id
if is_locked(peer_id, "commands"):
entities = event.message.entities
is_command = False
if entities:
import asyncio
from userbot import bot
from telethon import events
import asyncio
import requests
import json
@bot.on(events.NewMessage(pattern=r"\.git (.*)"))
@bot.on(events.MessageEdited(pattern=r"\.git (.*)"))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
url = "https://api.github.com/users/{}".format(input_str)
r = requests.get(url)
if r.status_code != 404:
b = r.json()
avatar_url = b["avatar_url"]
html_url = b["html_url"]
gh_type = b["type"]
name = b["name"]
company = b["company"]
blog = b["blog"]
location = b["location"]
bio = b["bio"]
created_at = b["created_at"]
await event.edit("""[\u2063]({})Name: [{}]({})
Type: {}
Company: {}
Blog: {}
def decorator(func):
async def wrapper(check):
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group😅.`")
return
try:
await func(check)
# Thanks to @mbbs_lover for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT ERROR REPORT**\n"
link = "[spamreporttt](https://t.me/Spamreporttt)"
text += "If you want to, you can report it"
text += f"- just forward this message to {link}.\n"
text += "Nothing is logged except the fact of error and date\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.client.respond(
"`Sorry, my userbot has crashed😔, check logs for more info.\
\nThe error logs are stored in the userbot's log chat.`"
)
await check.client.send_file(send_to,
"error.log",
caption=text)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
check.chat_id
else:
pass
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
if check.via_bot_id and not insecure and check.out:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException as e:
# Check if we have to disable error logging.
if not disable_errors:
LOGS.exception(e) # Log the error in console
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**USERBOT ERROR REPORT**\n"
link = "[Support Chat](https://t.me/KenVerseChat)"
text += "If you want to, you can report it"
text += f"- just forward this message to {link}.\n"
text += "I won't log anything except the fact of error and date\n"
ftext = "\nDisclaimer:\nThis file uploaded ONLY here, "
ftext += "we logged only fact of error and date, "
ftext += "we respect your privacy, "
ftext += "you may not report this error if you've "
ftext += "any confidential data here, no one will see your data "
ftext += "if you choose not to do so.\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = 'git log --pretty=format:"%an: %s" -10'
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) + \
str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
if LOGSPAMMER:
await check.client.send_file(
BOTLOG_CHATID,
"error.log",
caption=text,
)
else:
await check.client.send_file(
check.chat_id,
"error.log",
caption=text,
)
remove("error.log")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
check.chat_id
else:
pass
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
if check.via_bot_id and not insecure and check.out:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**Userbot ERROR**\n"
link = "Silahkan chat: @xz5pd"
text += "Untuk melaporkan kesalahan"
text += f"- tinggal teruskan pesan ini {link}.\n"
text += "A5N Siap Membantu Kamu\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
file = open("error.log", "w+")
file.write(ftext)
file.close()
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
async def deleted_message_handler(event):
chat_id = event.chat_id
if chat_id not in from_to:
return
logging.info(f"Message deleted in {chat_id}")
event_uid = EventUid(event)
fwded_msgs = _stored.get(event_uid)
if fwded_msgs:
for msg in fwded_msgs:
await msg.delete()
return
ALL_EVENTS = {
"new": (new_message_handler, events.NewMessage()),
"edited": (edited_message_handler, events.MessageEdited()),
"deleted": (deleted_message_handler, events.MessageDeleted()),
}
def start_sync():
client = TelegramClient(SESSION, API_ID, API_HASH)
for key, val in ALL_EVENTS.items():
logging.info(f"Added event handler for {key}")
client.add_event_handler(*val)
client.start()
client.run_until_disconnected()
"""COMMAND : .ae"""
from telethon import events
from userbot.utils import admin_cmd
PRINTABLE_ASCII = range(0x21, 0x7f)
def aesthetify(string):
for c in string:
c = ord(c)
if c in PRINTABLE_ASCII:
c += 0xFF00 - 0x20
elif c == ord(" "):
c = 0x3000
yield chr(c)
@borg.on(admin_cmd(pattern="ae\s+(.+)"))
@borg.on(events.MessageEdited(pattern=r'.ae\s+(.+)', outgoing=True))
async def _(event):
text = event.pattern_match.group(1)
text = "".join(aesthetify(text))
await event.edit(text=text, parse_mode=None, link_preview=False)
raise events.StopPropagation
def decorator(func):
async def wrapper(check):
if check.edit_date and check.is_channel and not check.is_group:
# Messages sent in channels can be edited by other users.
# Ignore edits that take place in channels.
return
if not LOGSPAMMER:
send_to = check.chat_id
else:
send_to = BOTLOG_CHATID
if not trigger_on_fwd and check.fwd_from:
return
if groups_only and not check.is_group:
await check.respond("`I don't think this is a group.`")
return
if check.via_bot_id and not insecure and check.out:
return
if check.via_bot_id and not trigger_on_inline:
return
try:
await func(check)
# Thanks to @kandnub for this HACK.
# Raise StopPropagation to Raise StopPropagation
# This needed for AFK to working properly
except events.StopPropagation:
raise events.StopPropagation
# This is a gay exception and must be passed out. So that it doesnt
# spam chats
except KeyboardInterrupt:
pass
except BaseException:
# Check if we have to disable it.
# If not silence the log spam on the console,
# with a dumb except.
if not disable_errors:
date = strftime("%Y-%m-%d %H:%M:%S", gmtime())
text = "**REMIX ERROR REPORT**\n"
link = "[OUB REMIX](https://t.me/remixsupport)"
text += "If you want to, you can report it"
text += f"- just forward this message to {link}.\n"
text += "Nothing is logged except the fact of error and date\n"
ftext = "========== DISCLAIMER =========="
ftext += "\nThis file uploaded ONLY here,"
ftext += "\nwe logged only fact of error and date,"
ftext += "\nwe respect your privacy,"
ftext += "\nyou may not report this error if you've"
ftext += "\nany confidential data here, no one will see your data\n"
ftext += "================================\n\n"
ftext += "--------BEGIN USERBOT TRACEBACK LOG--------\n"
ftext += "\nDate: " + date
ftext += "\nChat ID: " + str(check.chat_id)
ftext += "\nSender ID: " + str(check.sender_id)
ftext += "\n\nEvent Trigger:\n"
ftext += str(check.text)
ftext += "\n\nTraceback info:\n"
ftext += str(format_exc())
ftext += "\n\nError text:\n"
ftext += str(sys.exc_info()[1])
ftext += "\n\n--------END USERBOT TRACEBACK LOG--------"
command = "git log --pretty=format:\"%an: %s\" -10"
ftext += "\n\n\nLast 10 commits:\n"
process = await asyncsubshell(command,
stdout=asyncsub.PIPE,
stderr=asyncsub.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) \
+ str(stderr.decode().strip())
ftext += result
with open("error.txt", "w+") as file:
file.write(ftext)
#if LOGSPAMMER:
# sorry_msg = await check.respond(
# "`Sorry,userbot has crashed.\
# \nCheck botlog group for error logs.`"
# )
# await asyncio.sleep(3.5)
# await sorry_msg.delete()
# await check.client.send_file(send_to,
# "error.txt",
# caption=text)
remove("error.txt")
else:
pass
if not disable_edited:
bot.add_event_handler(wrapper, events.MessageEdited(**args))
bot.add_event_handler(wrapper, events.NewMessage(**args))
return wrapper
