async def _(event): if event.fwd_from: return animation_interval = 0.3 animation_ttl = range(0, 16) input_str = event.pattern_match.group(1) if input_str == "repo": await event.edit(f"Checkout my Repo [ @GITHUB]({REPOLINK}) ") elif input_str == "heroku": await event.edit(f"**Click** [here]({DEPLOYLINK}) **to goto the heroku deploy page.**") elif input_str == "packs": await event.edit(f"**Found the following sticker pack data:**\n{PACKS}") elif input_str == "guide": await event.edit(f"[ Follow this Guide ](https://authoritydmc.github.io/BEASTBOT-REBORN/)") else: pass SYNTAX.update({ "get": "\ **Requested Module --> get**\ \nDetailed usage of fuction(s):\ \n\n```.get repo```\ \nUsage: Prints github repoistory link defined in the env variable [REPO_LINK].\ \n\n```.get heroku```\ \nUsage: Prints the heroku deploy link defined in the env variable [DEPLOY_LINK].\ \n\n```.get packs```\ \nUsage: Prints the sticker pack data defined in the env variable [PACKS_CONTENT].\ " })
await results[0].click(event.chat_id, reply_to=event.reply_to_msg_id, hide_via=True) await event.delete() else: # await event.reply(help_string + "\n\n") await event.delete() await borg.send_message(event.chat_id, help_string + "\n\n", silent=True, link_preview=False) def get_size(bytes, suffix="B"): factor = 1024 for unit in ["", "K", "M", "G", "T", "P"]: if bytes < factor: return f"{bytes:.2f}{unit}{suffix}" bytes /= factor SYNTAX.update({ "alive": "\ **Requested Module --> alive**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.alive```\ \nUsage: Returns BEASTBOT-REBORN's system stats, user's name (only if set).\ " })
return if Config.USER is not None: user = f"\n```User: {Config.USER}```" else: user = "******" uname = platform.uname() memory = psutil.virtual_memory() specs = f"```System: {uname.system}```\n```Release: {uname.release}```\n```Version: {uname.version}```\n```Processor: {uname.processor}```\n```Memory [RAM]: {get_size(memory.total)}```" help_string = f"`🔶🔶🔶🔶🔶🔶🔶🔶🔶🔶\n`**General Account Analysis:**\n```🔧Build: {BUILD}```\nUser: {str(user)}\n```By: @Mr_Tavish007```\n\n**⚙️System Specifications:**\n{specs}\n```🐍Python {sys.version}```\n```💾Telethon {__version__}```\n[🔶🔶🔶🔶🔶🔶🔶🔶🔶🔶](https://da.gd/EMw5)" await event.reply(help_string + "\n\n") await event.delete() def get_size(bytes, suffix="B"): factor = 1024 for unit in ["", "K", "M", "G", "T", "P"]: if bytes < factor: return f"{bytes:.2f}{unit}{suffix}" bytes /= factor SYNTAX.update({ "help": "\ **Requested Module --> help**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.help```\ \nUsage: Returns userbot's system stats, user's name (only if set).\ " })
def progress(current, total): logger.info("Uploaded: {} of {}\nCompleted {}".format( current, total, (current / total) * 100)) def find_instance(items, class_or_tuple): for item in items: if isinstance(item, class_or_tuple): return item return None def zipdir(path, ziph): # ziph is zipfile handle for root, dirs, files in os.walk(path): for file in files: ziph.write(os.path.join(root, file)) os.remove(os.path.join(root, file)) SYNTAX.update({ "kang": "\ **Requested Module --> kang**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.kang <optional_emoji>```\ \nUsage: Adds sticker to your own sticker pack! [NAME = env variables ANIM_PACK_NAME, PACK_NAME]\ " })
async with borg.conversation(bot) as bot_conv: if True: response = await silently_send_message(bot_conv, "/start") if not response.text.startswith("Hey!"): await event.edit(f"{response.text}") return response = await silently_send_message(bot_conv, f"/GetLatestOTA {model}") if response.text.startswith("There"): await event.edit(f"{response.text}") return await event.edit(response.text) async def silently_send_message(conv, text): await conv.send_message(text) response = await conv.get_response() await conv.mark_read(message=response) return response SYNTAX.update({ "rmota": "\ **Requested Module --> rmota**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.rmota <device_model>```\ \nUsage: Returns latest update info for specified device.\nUses @Realme_3ProBot to get update information.\ " })
await event.edit("Error! Please try again later") @borg.on(admin_cmd(pattern="unshorten (.*)")) async def _(event): if event.fwd_from: return input_str = event.pattern_match.group(1) if not input_str.startswith("http"): input_str = "http://" + input_str r = requests.get(input_str, allow_redirects=False) if str(r.status_code).startswith('3'): await event.edit("Input URL: {}\nReDirected URL: {}".format( input_str, r.headers["Location"])) else: await event.edit("Input URL {} returned status_code {}".format( input_str, r.status_code)) SYNTAX.update({ "dagd": "\ **Requested Module --> dagd**\ \nDetailed usage of fuction(s):\ \n\n```.shorten <input_link>```\ \nUsage: Create a shortened da.gd link using <input_link>.\ \n\n```.unshorten <da.gd link>```\ \nUsage: Unshorten a da.gd link.\ " })
for a_user in approved_users: if a_user.reason: APPROVED_PMs += f"👉 [{a_user.chat_id}](tg://user?id={a_user.chat_id}) for {a_user.reason}\n" else: APPROVED_PMs += f"👉 [{a_user.chat_id}](tg://user?id={a_user.chat_id})\n" if len(APPROVED_PMs) > Config.MAX_MESSAGE_SIZE_LIMIT: with io.BytesIO(str.encode(APPROVED_PMs)) as out_file: out_file.name = "approved.pms.text" await borg.send_file(event.chat_id, out_file, force_document=True, allow_cache=False, caption="Current Approved PMs", reply_to=event) await event.delete() else: await event.edit(APPROVED_PMs) SYNTAX.update({ "pmpermit": "\ **Requested Module --> pmpermit**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.approve```\ \nUsage: Approve a user in PMs.\ \n\n```.block```\ \nUsage: Block a user from your PMs.\ " })
else: mentions = "Bots in {} channel: \n".format(input_str) try: chat = await borg.get_entity(input_str) except Exception as e: await event.edit(str(e)) return None try: async for x in borg.iter_participants(chat, filter=ChannelParticipantsBots): if isinstance(x.participant, ChannelParticipantAdmin): mentions += "\n ⚜️ [{}](tg://user?id={}) `{}`".format( x.first_name, x.id, x.id) else: mentions += "\n [{}](tg://user?id={}) `{}`".format( x.first_name, x.id, x.id) except Exception as e: mentions += " " + str(e) + "\n" await event.edit(mentions) SYNTAX.update({ "bots": "\ **Requested Module --> bots**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.bots```\ \nUsage: Prints all the bots in the current chat.\ " })
user_id = "Unknown user" noformat_userid = "Unknown user" if noformat_userid in SUDO_USERS: await event.edit( "**Wait! WHAT?!\nDid you just try to insult my creator?!?!\nBYE!**" ) sys.exit() # probably not needed but meh break else: await event.edit(insult) time.sleep(2) status = f"Insulted [{user_id}] with:\n\n{log_insults}" await log(status) async def log(text): LOGGER = Config.PRIVATE_GROUP_BOT_API_ID await borg.send_message(LOGGER, text) SYNTAX.update({ "insult": "\ **Requested Module --> insult**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.insult <optional_number_of_insults>``` [optionally as a reply to target user][default = 5]\ \nUsage: Insults target user.\ " })
input_str = event.pattern_match.group(1) if input_str: input_str = input_str.lower() if r % 2 == 1: if input_str == "heads": await event.edit("**Heads**. \n You were correct.") elif input_str == "tails": await event.edit("**Heads**. \n Better luck next time!...") else: await event.edit("**Heads**.") elif r % 2 == 0: if input_str == "tails": await event.edit("**Tails**. \n You were correct.") elif input_str == "heads": await event.edit("**Tails**. \n Better luck next time!...") else: await event.edit("**Tails**.") else: await event.edit("¯\_(ツ)_/¯") SYNTAX.update({ "coinflip": "\ **Requested Module --> coinflip**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.coinflip <optional_choice>```\ \nUsage: Flips a virtual coin and prints the outcome, test your lcuk!\ " })
except Exception as e: if " not found" in str(e) or "'file'" in str(e): await log(str(e)) return await event.delete() elif " depth exceeded" in str(e): file.remove(force=True) await log(str(e)) else: await log(str(e)) return await event.delete() SYNTAX.update({ "leech2drive": "\ **Requested Module --> leech2drive**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.l2d <magnet-link> (or as a reply to a magnet link)```\ \nUsage: Mirrors the torrent to gdrive.\ \n\n```.l2d setup```\ \nUsage: Get gdrive setup guide.\ " }) SYNTAX.update({ "leech": "\ **Requested Module --> leech**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.leech <magnet-link> (or as a reply to a magnet link)```\ \nUsage: Downloads the torrent to the local machine.\ " }) SYNTAX.update({
from telethon.tl import functions, types from sql_helpers.global_variables_sql import SYNTAX, MODULE_LIST MODULE_LIST.append("spam") @borg.on(events.NewMessage(pattern=r"\.spam", outgoing=True)) async def spammer(e): if not e.text[0].isalpha() and e.text[0] not in ("/", "#", "@", "!"): message = e.text if type(message[8]) == str: counter = int(message[6:8]) spam_message = str(e.text[8:]) else: counter = int(message[6:9]) spam_message = str(e.text[9:]) for spam in range(counter): await e.delete() await e.reply(spam_message) SYNTAX.update({ "spam": "\ **Requested Module --> spam**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.spam <number of msgs> <text>```\ \nUsage: Spam a specified message upto 999 times.\ " })
await message.edit("Please create the var `HEROKU_APP_NAME` as the key and the name of your bot in heroku as your value.") return else: await message.edit(NO_HEROKU_APP_CFGD) else: msg="""No `HEROKU_API_KEY` found in config \nGoto https://dashboard.heroku.com/account\nThere after scrolling a bit you will see API key tab .. \nclick on **reveal** button you will see your **API key** \n**copy it** \nNow goto **Heroku>your app >Settings>Reveal Config vars** \nNow add `HEROKU_API_KEY` with copied API key""" await message.edit(msg) def generate_change_log(git_repo, diff_marker): out_put_str = "" d_form = "%d/%m/%y" for repo_change in git_repo.iter_commits(diff_marker): out_put_str += f"•[{repo_change.committed_datetime.strftime(d_form)}]: {repo_change.summary} <{repo_change.author}>\n" return out_put_str async def deploy_start(borg, message, refspec, remote): await message.edit(RESTARTING_APP) await message.edit("Updating and Deploying New Branch. Please wait for 5 minutes then use `.alive` to check if i'm working or not.") await remote.push(refspec=refspec) await borg.disconnect() os.execl(sys.executable, sys.executable, *sys.argv) SYNTAX.update({"update":""" \nUpdate your bot with the latest update on Official Repo. \nBut first set HEROKU_API_KEY first . \nIf you have more than one bot set HEROKU_APP_NAME too """})
o = stdout.decode() if not o: o = "**Tip**: \n`Use .syntax bash to get help regarding this module.`" else: _o = o.split("\n") o = "`\n".join(_o) OUTPUT = f"**QUERY:**\n__Command:__\n`{cmd}` \n__PID:__\n`{process.pid}`\n\n**stderr:** \n`{e}`\n**Output:**\n{o}" if len(OUTPUT) > Config.MAX_MESSAGE_SIZE_LIMIT: with io.BytesIO(str.encode(OUTPUT)) as out_file: out_file.name = "exec.text" await borg.send_file( event.chat_id, out_file, force_document=True, allow_cache=False, caption=cmd, reply_to=reply_to_id ) await event.delete() await event.edit(OUTPUT) SYNTAX.update({ "bash": "\ **Requested Module --> bash**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.bash <code>```\ \nUsage: Evaluate bash code.\ " })
'ffmpeg', '-i', file, '-ss', str( int((0, metadata.get('duration').seconds)[metadata.has('duration')] / 2)), '-filter:v', 'scale={}:-1'.format(width), '-vframes', '1', output, ], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) if not p.returncode and os.path.lexists(file): return output SYNTAX.update({ "upload": "\ **Requested Module --> upload**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.file <file_location>```\ \nUsage: Upload a file from your local machine.\ \n\n```.dir <dir_location>```\ \nUsage: Upload a directory from your local machine.\ " })
from telethon import events from datetime import datetime from uniborg.util import admin_cmd from sql_helpers.global_variables_sql import SYNTAX, MODULE_LIST MODULE_LIST.append("ping") @borg.on(admin_cmd("ping")) async def _(event): if event.fwd_from: return start = datetime.now() await event.edit("Pong!") end = datetime.now() ms = (end - start).microseconds / 1000 await event.edit("Pong!\n{}".format(ms)) SYNTAX.update({ "ping": "\ **Requested Module --> ping**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.ping```\ \nUsage: Check your internet connection's ping speed.\ " })
if len(final_output) > Config.MAX_MESSAGE_SIZE_LIMIT: with io.BytesIO(str.encode(final_output)) as out_file: out_file.name = "eval.text" await borg.send_file(event.chat_id, out_file, force_document=True, allow_cache=False, caption=cmd, reply_to=reply_to_id) await event.delete() else: await event.edit(final_output) async def aexec(code, event): exec(f'async def __aexec(event): ' + ''.join(f'\n {l}' for l in code.split('\n'))) return await locals()['__aexec'](event) SYNTAX.update({ "python": "\ **Requested Module --> python**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.python <python_code>```\ \nUsage: Evaluate python code.\ " })
# re-generate session session = api_client.create_session() logger.info(session) session_id = session.id session_expires = session.expires logger.info( add_s(user_id, chat_id, session_id, session_expires)) # Try to think a thought. try: async with event.client.action(event.chat_id, "typing"): await asyncio.sleep(1) output = api_client.think_thought(session_id, query) await event.reply(output) except cf.exception.CoffeeHouseError as e: logger.info(str(e)) SYNTAX.update({ "lydia": "\ **Requested Module --> lydia**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.enableai (as a reply to target user)```\ \nUsage: Enables LydiaAI for the target user in the current chat.\ \n\n```.disableai (as a reply to target user)```\ \nUsage: Disables LydiaAI for the target user in the current chat.\ \n\n```.listai (as a reply to target user)```\ \nUsage: Lists all users on which LydiaAI is enabled.\ " })
for insulting in range(args): start = random.choice(starts) parts_ch = random.choice(parts) animal_ch=random.choice(animal) man_slang_ch = random.choice(man_slang) end = random.choice(ends) insult = start+","+animal_ch+" के "+parts_ch+"\n"+man_slang_ch+" "+end insults+="\n"+insult await event.edit(insult) time.sleep(1) log_insults += f"```{insult}```\n\n" #send message now await event.edit(insults) time.sleep(2) await borg.send_message( LOGGER, f"Insulted [{user_id}] with:\n\n{log_insults}" ) SYNTAX.update({ "gali": "\ **Requested Module --> gali**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.gali <optional_number_of_insults>``` [optionally as a reply to target user][default = 1]\ \nUsage: टारगेट यूजर को गाली दे :>: .\ " })
downloaded_file_name, force_document=True, supports_streaming=False, allow_cache=False, reply_to=event.message.id, thumb=thumb, progress_callback=lambda d, t: asyncio.get_event_loop().create_task( progress(d, t, event, c_time, "trying to upload") ) ) end_two = datetime.now() os.remove(downloaded_file_name) ms_two = (end_two - end).seconds total_ms = int(ms_one) + int(ms_two) await event.edit(f"Uploaded renamed file ```{input_str}``` in {ms_two} seconds!") else: await event.edit("File {} not found.".format(input_str)) else: await event.edit("Syntax // .rnupload file.name as reply to a Telegram media") SYNTAX.update({ "rename": "\ **Requested Module --> rename**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.rename <new_file_name>``` [as a reply to a target file]\ \nUsage: Renames the target file to <new_file_name>.\ " })
MODULE_LIST.append("type") @borg.on(events.NewMessage(pattern=r"\.type (.*)", outgoing=True)) async def _(event): if event.fwd_from: return # https://t.me/AnotherGroup/176551 input_str = event.pattern_match.group(1) typing_symbol = "|" DELAY_BETWEEN_EDITS = 0.3 previous_text = "" await event.edit(typing_symbol) await asyncio.sleep(DELAY_BETWEEN_EDITS) for character in input_str: previous_text = previous_text + "" + character typing_text = previous_text + "" + typing_symbol await event.edit(typing_text) await asyncio.sleep(DELAY_BETWEEN_EDITS) await event.edit(previous_text) await asyncio.sleep(DELAY_BETWEEN_EDITS) SYNTAX.update({ "type": "\ **Requested Module --> type**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.type <text_to_type>```\ \nUsage: Type text with a fancy typing animation.\ " })
async def _(prg): if prg.fwd_from: return if not prg.text[0].isalpha(): await prg.edit("**Purging all notes.**") await prg.edit( "**All notes have been purged successfully.**\n```This auto generated message will be deleted in a few seconds...```" ) rm_all_notes(str(prg.chat_id)) time.sleep(5) await prg.delete() if LOGGER: await borg.send_message( LOGGER, f"**Successfully purged all notes at** ```{prg.chat_id}```") SYNTAX.update({ "notes": "\ ```.get <notename>```\ \nUsage: Gets the note with name <notename>\ \n\n```.save <notename>``` (as a reply to message to save)\ \nUsage: Saves target message as a note with the name <notename>\ \n\n```.clear <notename>```\ \nUsage: Deletes the note with name <notename>.\ \n\n```.notes <notename>```\ \nUsage: Prints the list of notes saved in the current chat.\ " })
afk_since = f"`{int(hours)}h{int(minutes)}m` **ago**" elif minutes > 0: afk_since = f"`{int(minutes)}m{int(seconds)}s` **ago**" else: afk_since = f"`{int(seconds)}s` **ago**" msg = None message_to_reply = f"**My Master is AFK since** {afk_since} " + \ f"**cuz {reason}**" \ if reason \ else f"**My Master is AFK since** {afk_since}" msg = await event.reply(message_to_reply) await asyncio.sleep(5) if event.chat_id in borg.storage.last_afk_message: # pylint:disable=E0602 await borg.storage.last_afk_message[event.chat_id].delete() # pylint:disable=E0602 borg.storage.last_afk_message[event.chat_id] = msg # pylint:disable=E0602 async def log(text): LOGGER = Config.PRIVATE_GROUP_BOT_API_ID await borg.send_message(LOGGER, text) SYNTAX.update({ "afk": "\ **Requested Module --> afk**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.afk <optional_reason>```\ \nUsage: Changed afk mode to **true**.\ " })
''.join(["░" for i in range(20 - math.floor(percentage / 5))]), round(percentage, 2)) estimated_total_time = downloader.get_eta(human=True) try: current_message = f"trying to download\nURL: {url}\nFile Name: {file_name}\n{progress_str}\n{humanbytes(downloaded)} of {humanbytes(total_length)}\nETA: {estimated_total_time}" if current_message != display_message: await mone.edit(current_message) display_message = current_message except Exception as e: logger.info(str(e)) end = datetime.now() ms = (end - start).seconds if downloader.isSuccessful(): await mone.edit("Downloaded to `{}` in {} seconds.".format(downloaded_file_name, ms)) else: await mone.edit("Incorrect URL\n {}".format(input_str)) else: await mone.edit("Reply to a message to download to my local server.") SYNTAX.update({ "download": "\ **Requested Module --> download**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.localdl (as a reply to a telegram media file)```\ \nUsage: Downloads the target file to the temporary local download directory.\ \n\n```.directdl <direct_dl_link>```\ \nUsage: Attempts to download media from the provided link.\ " })
import time from sql_helpers.global_variables_sql import SYNTAX, MODULE_LIST MODULE_LIST.append("restart") @borg.on(admin_cmd("restart")) async def _(event): if event.fwd_from: return await event.edit("Restarting...\n█████░░░") time.sleep(1) await event.edit("Restarting...\n████████") time.sleep(1) await event.edit("Restart Complete!\nSend .alive or .ping to check if i am online.") await borg.disconnect() # https://archive.is/im3rt os.execl(sys.executable, sys.executable, *sys.argv) # You probably don't need it but whatever quit() SYNTAX.update({ "restart": "\ **Requested Module --> restart**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.restart```\ \nUsage: Restart your userbot.\ " })
metadata = extractMetadata(createParser(file)) p = subprocess.Popen([ 'ffmpeg', '-i', file, '-ss', str( int((0, metadata.get('duration').seconds)[metadata.has('duration')] / 2)), '-filter:v', 'scale={}:-1'.format(width), '-vframes', '1', output, ], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) if not p.returncode and os.path.lexists(file): return output SYNTAX.update({ "share": "\ **Requested Module --> share**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.share <module_name>```\ \nUsage: Share a specified module.\ " })
mentions += "\n" async for x in borg.iter_participants( chat, filter=ChannelParticipantsAdmins): if not x.deleted: if isinstance(x.participant, ChannelParticipantAdmin): mentions += "\n ⚜️ [{}](tg://user?id={}) `{}`".format( x.first_name, x.id, x.id) else: mentions += "\n `{}`".format(x.id) except Exception as e: mentions += " " + str(e) + "\n" if should_mention_admins: if reply_message: await reply_message.reply(mentions) else: await event.reply(mentions) await event.delete() else: await event.edit(mentions) SYNTAX.update({ "report": "\ **Requested Module --> report**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.report``` [as a reply to a target message]\ \nUsage: Report the target message to the admins.\ " })
else: OUTPUT = f"**QUERY:**\n__Command:__\n`{cmd}` \n__PID:__\n`{process.pid}`\n**OUTPUT**\n`{o}`" else: if not "No Error" in e: OUTPUT = f"\n**stderror**\n{e}\n **OUTPUT**\n `{o}`" else: OUTPUT = f"**OUTPUT**\n`{o}`" if len(OUTPUT) > Config.MAX_MESSAGE_SIZE_LIMIT: with io.BytesIO(str.encode(OUTPUT)) as out_file: out_file.name = "exec.text" await borg.send_file(event.chat_id, out_file, force_document=True, allow_cache=False, caption=cmd, reply_to=reply_to_id) await event.delete() await event.edit(OUTPUT) SYNTAX.update({ "bash": "\ **Requested Module --> bash**\ \n\n**Detailed usage of fuction(s):**\ \n\nreply to any command with ```.bash [f]( f is optional)``\ \nUsage: Evaluate bash code.\ \nf is optional ,if supplied show full result\ " })
try: await borg(EditBannedRequest(event.chat_id, to_ban_id, rights)) except (Exception) as exc: await event.edit(str(exc)) try: await borg(EditBannedRequest(event.chat_id, to_ban_id, rights2)) except (Exception) as exc: await event.edit(str(exc)) else: await event.edit(f"```{to_ban_id}``` has been yeeted!") SYNTAX.update({ "admin": "\ **Requested Module --> admin**\ \n\n**Detailed usage of fuction(s)**:\ \n\n```.ban <userid>``` (or as a reply to a message of targer user)\ \nUsage: bans target user.\ \n\n```.unban <userid>``` (or as a reply to a message of targer user)\ \nUsage: unbans target user.\ \n\n```.mute <userid>``` (or as a reply to a message of targer user)\ \nUsage: mutes target user.\ \n\n```.unmute <userid>``` (or as a reply to a message of targer user)\ \nUsage: unmutes target user.\ \n\n```.promote <optional_rank>``` (must be a reply to a message of targer user)\ \nUsage: promotes target user.\ \n\n```.demote <userid>``` (or as a reply to a message of targer user)\ \nUsage: demotes target user.\ \n\n```.kick <userid>``` (or as a reply to a message of targer user)\ \nUsage: kicks target user.\ " })
return if text and count != None: await event.delete() for spam in range(int(count)): await event.reply(text) msg = await event.reply( f"Task complete, spammed input text {count} times!") sleep(5) await msg.delete() status = f"SPAMMED\n```{text}```\n in ```{chat}``` ```{count}``` times." await log(status) else: await event.edit("Unexpected Error! Aborting..") return async def log(text): LOGGER = Config.PRIVATE_GROUP_BOT_API_ID await borg.send_message(LOGGER, text) SYNTAX.update({ "spam": "\ **Requested Module --> spam**\ \n\n**Detailed usage of fuction(s):**\ \n\n```.spam <number of msgs> <text>```\ \nUsage: Spam a specified message upto the TG API limit (probably non existent but meh).\ " })