"""Emoji
Available Commands:
.tp"""
import asyncio
from telethon import events
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="tp", outgoing=True))
@bot.on(sudo_cmd(pattern="tp", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
animation_interval = 0.3
animation_ttl = range(0, 28)
# input_str = event.pattern_match.group(1)
# if input_str == "tp":
await edit_or_reply(event, "Time Pass...")
animation_chars = [
"◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◻️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◻️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◻️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◼️◻️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◼️◼️◻️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◻️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◼️◼️◼️\n◼️◼️◼️◻️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
"◼️◼️◼️◼️◼️\n◼️◼️◻️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️\n◼️◼️◼️◼️◼️",
#
# Licensed under the Raphielscape Public License, Version 1.b (the "License");
# you may not use this file except in compliance with the License.
#
# You can find misc modules, which dont fit in anything xD
""" Userbot module for other small commands. """
from random import randint
from time import sleep
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="random", outgoing=True))
@bot.on(sudo_cmd(pattern="random", allow_sudo=True))
async def randomise(items):
""" For .random command, get a random item from the list of items. """
if not items.text[0].isalpha() and items.text[0] not in ("/", "#", "@",
"!"):
itemo = (items.text[8:]).split()
index = randint(1, len(itemo) - 1)
await edit_or_reply(
items, "**Query: **\n`" + items.text[8:] + "`\n**Output: **\n`" +
itemo[index] + "`")
@bot.on(admin_cmd(pattern="sleep([0-9]+)?$", outgoing=True))
@bot.on(sudo_cmd(pattern="sleep([0-9]+)?$", allow_sudo=True))
async def sleepybot(time):
""" For .sleep command, let the userbot snooze for a few second. """
"""Type `.poto` for get **All profile pics of that User**
\n Or type `.poto (number)` to get the **desired number of photo of a User** .
"""
import logging
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
name = "Profile Photos"
@bot.on(admin_cmd(pattern="poto ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="poto ?(.*)", allow_sudo=True))
async def potocmd(event):
"""Gets the profile photos of replied users, channels or chats"""
uid = "".join(event.raw_text.split(maxsplit=1)[1:])
user = await event.get_reply_message()
chat = event.input_chat
if user:
photos = await event.client.get_profile_photos(user.sender)
u = True
else:
photos = await event.client.get_profile_photos(chat)
u = False
if uid.strip() == "":
uid = 1
if int(uid) <= (len(photos)):
send_photos = await event.client.download_media(photos[uid - 1])
await event.client.send_file(event.chat_id, send_photos)
else:
import os
import asyncio
from userbot import CmdHelp
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot import bot as AuraXBot
@AuraXBot.on(admin_cmd(pattern=r"unpack", outgoing=True))
@AuraXBot.on(sudo_cmd(pattern=r"unpack"))
async def _(event):
b = await event.client.download_media(await event.get_reply_message())
a = open(b, "r")
c = a.read()
a.close()
a = await edit_or_reply(event, "```unpacking...```")
if len(c) > 4095:
await a.edit("`word limit of telegram is exceded!!! aborting...`")
else:
await event.client.send_message(event.chat_id, f"```{c}```")
await a.delete()
os.remove(b)
@AuraXBot.on(admin_cmd(pattern="repack ?(.*)", outgoing=True))
@AuraXBot.on(sudo_cmd(pattern="repack ?(.*)", allow_sudo=True))
async def _(event):
a = await event.get_reply_message()
input_str = event.pattern_match.group(1)
b = open(input_str, "w")
b.write(str(a.message))
await var.edit("`Getting information to deleting variable...`")
try:
variable = var.pattern_match.group(2).split()[0]
except IndexError:
return await var.edit(
"`Please specify ConfigVars you want to delete`")
await asyncio.sleep(1.5)
if variable in heroku_var:
await var.edit(f"**{variable}** `successfully deleted`")
del heroku_var[variable]
else:
return await var.edit(f"**{variable}** `is not exists`")
@bot.on(admin_cmd(pattern="usage(?: |$)", outgoing=True))
@bot.on(sudo_cmd(pattern="usage(?: |$)", allow_sudo=True))
async def dyno_usage(dyno):
if dyno.fwd_from:
return
"""
Get your account Dyno Usage
"""
await edit_or_reply(dyno, "`Processing...`")
useragent = ("Mozilla/5.0 (Linux; Android 10; SM-G975F) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/80.0.3987.149 Mobile Safari/537.36")
user_id = Heroku.account().id
headers = {
"User-Agent": useragent,
"Authorization": f"Bearer {Var.HEROKU_API_KEY}",
"Accept": "application/vnd.heroku+json; version=3.account-quotas",
import requests
from bs4 import BeautifulSoup
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot import CMD_HELP
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="filext (.*)"))
@bot.on(sudo_cmd(pattern="filext (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
sample_url = "https://www.fileext.com/file-extension/{}.html"
input_str = event.pattern_match.group(1).lower()
response_api = requests.get(sample_url.format(input_str))
status_code = response_api.status_code
if status_code == 200:
raw_html = response_api.content
soup = BeautifulSoup(raw_html, "html.parser")
ext_details = soup.find_all("td", {"colspan": "3"})[-1].text
await edit_or_reply(
event,
"**File Extension**: `{}`\n**Description**: `{}`".format(
input_str, ext_details),
)
else:
await edit_or_reply(
event,
"https://www.fileext.com/ responded with {} for query: {}".format(
status_code, input_str),
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from telethon.tl.functions.messages import SaveDraftRequest
from userbot import CMD_HELP
from AuraXBot.utils import admin_cmd, sudo_cmd
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="chain$"))
@bot.on(sudo_cmd(pattern="chain$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
await event.edit("Counting...")
count = -1
message = event.message
while message:
reply = await message.get_reply_message()
if reply is None:
await event.client(
SaveDraftRequest(await event.get_input_chat(),
"",
reply_to_msg_id=message.id))
message = reply
count += 1
await event.edit(f"Chain length: {count}")
CmdHelp("chain").add_command(
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (c) Shrimadhav U K
import asyncio
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="type (.*)"))
@bot.on(sudo_cmd(pattern="type (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
# https://t.me/AnotherGroup/176551
input_str = event.pattern_match.group(1)
shiiinabot = "\u2060"
for i in range(601):
shiiinabot += "\u2060"
try:
await edit_or_reply(event, shiiinabot)
except Exception as e:
logger.warn(str(e))
typing_symbol = "_"
DELAY_BETWEEN_EDITS = 0.3
previous_text = ""
await edit_or_reply(event, typing_symbol)
await asyncio.sleep(DELAY_BETWEEN_EDITS)
for character in input_str:
previous_text = previous_text + "" + character
typing_text = previous_text + "" + typing_symbol
return None
except (TypeError, ValueError):
await event.reply("`Invalid channel/group`")
return None
return chat_info
def user_full_name(user):
names = [user.first_name, user.last_name]
names = [i for i in list(names) if i]
full_name = " ".join(names)
return full_name
@bot.on(admin_cmd(pattern="inviteall ?(.*)"))
@bot.on(sudo_cmd(pattern="inviteall ?(.*)", allow_sudo=True))
async def get_users(event):
sender = await event.get_sender()
me = await event.client.get_me()
if not sender.id == me.id:
AuraX = await edit_or_reply(event, "`processing...`")
else:
AuraX = await edit_or_reply(event, "`processing...`")
aura = await get_chatinfo(event)
chat = await event.get_chat()
if event.is_private:
return await AuraX.edit("`Sorry, Cant add users here`")
s = 0
f = 0
error = "None"
# credits: @Mr_Hops
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from userbot import CMD_HELP
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="recognize ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="recognize ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await edit_or_reply(event, "Reply to any user's media message.")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await edit_or_reply(event, "reply to media file")
return
chat = "@Rekognition_Bot"
reply_message.sender
if reply_message.sender.bot:
await edit_or_reply(event, "Reply to actual users message.")
return
AuraX = await edit_or_reply(event, "recognizeing this media")
async with event.client.conversation(chat) as conv:
try:
response = conv.wait_event(
)
async def add_frame(imagefile, endname, x, color):
image = Image.open(imagefile)
inverted_image = PIL.ImageOps.expand(image, border=x, fill=color)
inverted_image.save(endname)
async def crop(imagefile, endname, x):
image = Image.open(imagefile)
inverted_image = PIL.ImageOps.crop(image, border=x)
inverted_image.save(endname)
@AuraXBot.on(admin_cmd(pattern="invert$", outgoing=True))
@AuraXBot.on(sudo_cmd(pattern="invert$", allow_sudo=True))
async def memes(AuraX):
if AuraX.fwd_from:
return
reply = await AuraX.get_reply_message()
if not (reply and (reply.media)):
await edit_or_reply(AuraX, "`Reply to supported Media...`")
return
AuraXid = AuraX.reply_to_msg_id
if not os.path.isdir("./temp/"):
os.mkdir("./temp/")
AuraX = await edit_or_reply(AuraX, "`Fetching media data`")
from telethon.tl.functions.messages import ImportChatInviteRequest as Get
await asyncio.sleep(2)
AuraXsticker = await reply.download_media(file="./temp/")
import random
import textwrap
from PIL import Image, ImageDraw, ImageFont
from telethon.tl.types import InputMessagesFilterDocument
from userbot import bot
from userbot.helpers.functions import deEmojify
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
# RegEx by https://t.me/c/1220993104/50065
@bot.on(admin_cmd(pattern="waifu(?: |$)(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="waifu(?: |$)(.*)", allow_sudo=True))
async def waifu(animu):
# """Creates random anime sticker!"""
text = animu.pattern_match.group(1)
if not text:
if animu.is_reply:
text = (await animu.get_reply_message()).message
else:
await animu.edit("`You haven't written any article, Waifu is going away.`")
return
animus = [1, 3, 7, 9, 13, 22, 34, 35, 36, 37, 43, 44, 45, 52, 53, 55]
sticcers = await bot.inline_query(
"stickerizerbot", f"#{random.choice(animus)}{(deEmojify(text))}"
)
await sticcers[0].click(
import asyncio
from userbot import CMD_HELP
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern=f"quickheal$", outgoing=True))
@bot.on(sudo_cmd(pattern=f"quickheal$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
animation_interval = 5
animation_ttl = range(11)
event = await edit_or_reply(event, "quickheal")
animation_chars = [
"`Downloading File..`",
"`File Downloaded....`",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 0%\n▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 4%\n█▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 8%\n██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 20%\n█████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 36%\n█████████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 52%\n█████████████▒▒▒▒▒▒▒▒▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 84%\n█████████████████████▒▒▒▒ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nFile Scanned... 100%\n█████████████████████████ `",
"`Quick Heal Total Security Checkup\n\n\nSubscription: Pru User\nValid Until: 31/12/2099\n\nTask: 01 of 01 Files Scanned...\n\nResult: No Virus Found...`",
]
for i in animation_ttl:
await asyncio.sleep(animation_interval)
await event.edit(animation_chars[i % 11])
import asyncio
import hashlib
import json
import os
import time
from datetime import datetime
import aiohttp
import magic
import requests
from AuraXBot.utils import admin_cmd, progress, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="verystream ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="verystream ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
mone = await edit_or_reply(event, "Processing ...")
if Config.VERY_STREAM_LOGIN is None or Config.VERY_STREAM_KEY is None:
await mone.edit(
"This module requires API key from https://verystream.com. Aborting!"
)
return False
input_str = event.pattern_match.group(1)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
required_file_name = None
start = datetime.now()
if event.reply_to_msg_id and not input_str:
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from userbot import ALIVE_NAME, CMD_HELP
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "AuraX User"
USERID = bot.uid
mention = f"[{DEFAULTUSER}](tg://user?id={USERID})"
@bot.on(admin_cmd("ascii ?(.*)"))
@bot.on(sudo_cmd(pattern="ascii ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await edit_or_reply(event, "Reply to any user message.😒🤐")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await edit_or_reply(event, "Reply to media message😒🤐")
return
chat = "@asciiart_bot"
reply_message.sender
if reply_message.sender.bot:
await edit_or_reply(event, "Reply to actual users message.😒🤐")
return
from userbot import CMD_HELP
from userbot.helpers.functions import (
convert_toimage,
deEmojify,
phcomment,
threats,
trap,
trash,
)
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
from . import *
@bot.on(admin_cmd(pattern="threats(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="threats(?: |$)(.*)", allow_sudo=True))
async def AuraXBot(AuraXmemes):
replied = await AuraXmemes.get_reply_message()
if not os.path.isdir("./temp/"):
os.makedirs("./temp/")
if not replied:
await edit_or_reply(
AuraXmemes, "`Media file not supported. Reply to a supported media`"
)
return
if replied.media:
AuraXmemmes = await edit_or_reply(AuraXmemes, "`Detecting Threats.........`")
else:
await edit_or_reply(
AuraXmemes, "`Media file not supported. Reply to a suported media`"
)
import asyncio
from collections import deque
from userbot import *
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "AuraX User"
@bot.on(admin_cmd(pattern=r"boxs$", outgoing=True))
@bot.on(sudo_cmd(pattern=r"boxs$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
event = await edit_or_reply(event, "`boxs...`")
deq = deque(list("🟥🟧🟨🟩🟦🟪🟫⬛⬜"))
for _ in range(999):
await asyncio.sleep(0.3)
await event.edit("".join(deq))
deq.rotate(1)
@bot.on(admin_cmd(pattern=r"rain$", outgoing=True))
@bot.on(sudo_cmd(pattern=r"rain$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
event = await edit_or_reply(event, "`Raining.......`")
deq = deque(list("🌬☁️🌩🌨🌧🌦🌥⛅🌤"))
for _ in range(48):
from userbot import ALIVE_NAME
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
AuraX_NAME = str(ALIVE_NAME) if ALIVE_NAME else "AuraX User"
aura = bot.uid
telegraph = Telegraph()
r = telegraph.create_account(short_name=Config.TELEGRAPH_SHORT_NAME)
auth_url = r["auth_url"]
@bot.on(admin_cmd(pattern="t(m|t) ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="t(m|t) ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if Config.PLUGIN_CHANNEL is None:
await edit_or_reply(
event,
"Please set the required environment variable `PLUGIN_CHANNEL` for this plugin to work\n\nGo to [AuraXBot Chat Group](t.me/AuraXSupport) for assistance"
)
return
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
await event.client.send_message(
Config.PLUGIN_CHANNEL,
"Created New Telegraph account {} for the current session. \n**Do not give this url to anyone, even if they say they are from Telegram!**"
.format(auth_url),
os.remove(image)
return filename
def convert_tosticker(response, filename=None):
filename = filename or os.path.join("./temp/", "temp.webp")
image = Image.open(response)
if image.mode != "RGB":
image.convert("RGB")
image.save(filename, "webp")
os.remove(response)
return filename
@bot.on(admin_cmd(pattern="(rmbg|srmbg) ?(.*)"))
@bot.on(sudo_cmd(pattern="(rmbg|srmbg) ?(.*)", allow_sudo=True))
async def remove_background(event):
if Config.REM_BG_API_KEY is None:
return await edit_or_reply(
event,
"You have to set `REM_BG_API_KEY` in Config vars with API token from remove.bg to use this module"
)
cmd = event.pattern_match.group(1)
input_str = event.pattern_match.group(2)
message_id = await reply_id(event)
if event.reply_to_msg_id and not input_str:
reply_message = await event.get_reply_message()
AuraXevent = await edit_or_reply(event, "`Analysing...`")
file_name = os.path.join(TEMP_DIR, "rmbg.png")
try:
await event.client.download_media(reply_message, file_name)
"""Get Poll Info on non supported clients
Syntax: .get_poll"""
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="get_poll$", outgoing=True))
@bot.on(sudo_cmd(pattern="get_poll$", allow_sudo=True))
async def _(event):
reply_message = await event.get_reply_message()
if reply_message.media is None:
await edit_or_reply(
event,
"Please reply to a media_type == @gPoll to view the questions and answers"
)
elif reply_message.media.poll is None:
await edit_or_reply(
event,
"Please reply to a media_type == @gPoll to view the questions and answers"
)
else:
media = reply_message.media
poll = media.poll
closed_status = poll.closed
answers = poll.answers
question = poll.question
edit_caption = """Poll is Closed: {}
Question: {}
Answers: \n""".format(closed_status, question)
if closed_status:
results = media.results
import asyncio
from userbot import ALIVE_NAME, CMD_HELP
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "AuraX user"
@bot.on(admin_cmd(outgoing=True, pattern="kiler( (.*)|$)"))
@bot.on(sudo_cmd(pattern="kiler( (.*)|$)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
name = event.pattern_match.group(1)
if not name:
name = "die"
animation_interval = 0.7
animation_ttl = range(8)
event = await edit_or_reply(event, f"**Ready Commando **__{DEFAULTUSER}....")
animation_chars = [
"Ｆｉｉｉｉｉｒｅ",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - \n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - -\n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - - -\n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n<,︻╦╤─ ҉ - -\n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - \n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - -\n _/﹋\_\n",
f"__**Commando **__{DEFAULTUSER} \n\n_/﹋\_\n (҂`_´)\n <,︻╦╤─ ҉ - - - {name}\n _/﹋\_\n",
]
for i in animation_ttl:
# display iterables one after another at the base indentation level
result.append("\n")
indent += 2
for x in obj:
result.append(" " * indent)
result.append(yaml_format(x, indent))
result.append("\n")
result.pop()
indent -= 2
result.append(" " * indent)
else:
result.append(repr(obj))
return "".join(result)
@bot.on(admin_cmd(pattern=r"new", outgoing=True))
@bot.on(sudo_cmd(pattern=r"new", allow_sudo=True))
async def _(event):
if not event.message.is_reply:
return
msg = await event.message.get_reply_message()
yaml_text = yaml_format(msg)
await edit_or_reply(event, yaml_text, parse_mode=parse_pre)
CmdHelp("new").add_command(
"new", None,
"Pretty formats the given object as a YAML string which is returned.(based on TLObject.pretty_format)"
).add()
import asyncio
import io
import time
import os
import sys
import traceback
from AuraXBot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot import *
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="exec(?: |$|\n)(.*)", command="exec"))
@bot.on(sudo_cmd(pattern="exec(?: |$|\n)(.*)", command="exec",
allow_sudo=True))
async def _(event):
if event.fwd_from:
return
cmd = "".join(event.text.split(maxsplit=1)[1:])
if not cmd:
return await edit_delete(event, "`What should i execute?..`")
AuraXevent = await edit_or_reply(event, "`Executing.....`")
process = await asyncio.create_subprocess_sAuraX(
cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
stdout, stderr = await process.communicate()
result = str(stdout.decode().strip()) + str(stderr.decode().strip())
AuraXuser = await event.client.get_me()
if AuraXuser.username:
curruser = AuraXuser.username
else:
curruser = "******"
"Ⓟ",
"Ⓠ",
"Ⓡ",
"Ⓢ",
"Ⓣ",
"Ⓤ",
"Ⓥ",
"Ⓦ",
"Ⓧ",
"Ⓨ",
"Ⓩ",
]
@bot.on(admin_cmd(pattern="weeb(?: |$)(.*)", command="weeb"))
@bot.on(sudo_cmd(pattern="weeb(?: |$)(.*)", command="weeb", allow_sudo=True))
async def weebify(event):
if event.fwd_from:
return
args = event.pattern_match.group(1)
if not args:
get = await event.get_reply_message()
args = get.text
if not args:
await edit_or_reply(event, "`What I am Supposed to Weebify U Dumb`")
return
string = "".join(args).lower()
for normiecharacter in string:
if normiecharacter in normiefont:
weebycharacter = weebyfont[normiefont.index(normiecharacter)]
string = string.replace(normiecharacter, weebycharacter)
media = "Round Video"
elif message and message.gif:
media = "Gif"
elif message and message.sticker:
media = "Sticker"
elif message and message.video:
media = "Video"
elif message and message.document:
media = "Document"
else:
media = None
return media
@bot.on(admin_cmd(pattern="ffmpegsave$"))
@bot.on(sudo_cmd(pattern="ffmpegsave$", allow_sudo=True))
async def ff_mpeg_trim_cmd(event):
if event.fwd_from:
return
if not os.path.exists(FF_MPEG_DOWN_LOAD_MEDIA_PATH):
reply_message = await event.get_reply_message()
if reply_message:
start = datetime.now()
media = media_type(reply_message)
if media not in ["Video", "Audio", "Voice", "Round Video", "Gif"]:
return await edit_delete(event,
"`Only media files are supported`", 5)
AuraXevent = await edit_or_reply(event, "`Saving the file...`")
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
send_media=None,
send_stickers=None,
send_gifs=None,
send_games=None,
send_inline=None,
embed_links=None,
)
MUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=True)
UNMUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=False)
# ================================================
@bot.on(admin_cmd(pattern=f"zombies ?(.*)"))
@bot.on(sudo_cmd(pattern="zombies ?(.*)", allow_sudo=True))
async def rm_deletedacc(show):
if show.fwd_from:
return
con = show.pattern_match.group(1).lower()
del_u = 0
del_status = "`No zombies or deleted accounts found in this group, Group is clean`"
if con != "clean":
event = await edit_or_reply(
show, "`Searching for ghost/deleted/zombie accounts...`"
)
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
await sleep(0.5)
if del_u > 0:
"""Get Telegram Profile Picture and other information
Syntax: .ppg @username"""
import html
from telethon.tl.functions.photos import GetUserPhotosRequest
from telethon.tl.functions.users import GetFullUserRequest
from telethon.tl.types import MessageEntityMentionName
from telethon.utils import get_input_location
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
@borg.on(admin_cmd(pattern="ppg ?(.*)", outgoing=True))
@borg.on(sudo_cmd(pattern="ppg ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
replied_user, error_i_a = await get_full_user(event)
if replied_user is None:
await edit_or_reply(event, str(error_i_a))
return False
replied_user_profile_photos = await borg(
GetUserPhotosRequest(user_id=replied_user.user.id,
offset=42,
max_id=0,
limit=80))
replied_user_profile_photos_count = "NaN"
try:
replied_user_profile_photos_count = replied_user_profile_photos.count
except AttributeError:
add_channel,
get_all_channels,
in_channels,
rm_channel,
)
logs_id = Config.FBAN_LOGGER_GROUP
bot = "@MissRose_bot"
AuraX_logo = "./AURAX/AuraXBot_logo.jpg"
# Keep all credits pls
# madewith great effort by @HeisenbergTheDanger
# modified by @Kraken_The_BadAss for fbans
@AuraXBot.on(admin_cmd(pattern="fban ?(.*)"))
@AuraXBot.on(sudo_cmd(pattern="fban ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
mssg = await eor(event, "`...`")
if not event.is_reply:
await mssg.edit("Reply to a message to start fban....")
return
channels = get_all_channels()
error_count = 0
sent_count = 0
await mssg.edit("Fbanning....")
if event.reply_to_msg_id:
previous_message = await event.get_reply_message()
if previous_message.sticker or previous_message.poll:
await mssg.edit(
from telethon.tl.types import (
ChannelParticipantsKicked,
ChatBannedRights,
UserStatusEmpty,
UserStatusLastMonth,
UserStatusLastWeek,
UserStatusOffline,
UserStatusOnline,
UserStatusRecently,
)
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern=r"unbanall ?(.*)"))
@bot.on(sudo_cmd(pattern=r"unbanall ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
if input_str:
logger.info("TODO: Not yet Implemented")
else:
if event.is_private:
return False
await edit_or_reply(event, "Searching Participant Lists.")
p = 0
async for i in borg.iter_participants(event.chat_id,
filter=ChannelParticipantsKicked,
aggressive=True):
rights = ChatBannedRights(until_date=0, view_messages=False)
import os
import time
from telethon import events
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
if not os.path.isdir("./SAVED"):
os.makedirs("./SAVED")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
@bot.on(admin_cmd(pattern="ls ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="ls ?(.*)", allow_sudo=True))
async def lst(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
if input_str:
msg = "📂 **Files in {} :**\n".format(input_str)
files = os.listdir(input_str)
else:
msg = "📂 **Files in Current Directory :**\n"
files = os.listdir(os.getcwd())
for file in files:
msg += "📑 `{}`\n".format(file)
if len(msg) <= Config.MAX_MESSAGE_SIZE_LIMIT:
await edit_or_reply(event, msg)
else:
