)
except Exception as e: # pylint:disable=C0103,W0703
await borg.send_message( # pylint:disable=E0602
event.chat_id,
"Please set `PLUGIN_CHANNEL` " +
"for the proper functioning of night functionality " +
"report in [AuraXBot](t.me/AuraXSupport)\n\n `{}`".format(
str(e)),
reply_to=event.message.id,
silent=True,
)
USER_night = {} # pylint:disable=E0602
night_time = None # pylint:disable=E0602
@borg.on(admin_cmd(pattern=r"night ?(.*)"))
async def _(event):
if event.fwd_from:
return
global USER_night # pylint:disable=E0602
global night_time # pylint:disable=E0602
global last_night_message # pylint:disable=E0602
global reason
USER_night = {}
night_time = None
last_night_message = {}
reason = event.pattern_match.group(1)
if not USER_night: # pylint:disable=E0602
last_seen_status = await borg( # pylint:disable=E0602
functions.account.GetPrivacyRequest(
types.InputPrivacyKeyStatusTimestamp()))
"""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:
from telethon.tl import functions
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):
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
# =====================================
Heroku = heroku3.from_key(Config.HEROKU_API_KEY)
Heroku = heroku3.from_key(Var.HEROKU_API_KEY)
heroku_api = "https://api.heroku.com"
HEROKU_APP_NAME = Config.HEROKU_APP_NAME
HEROKU_API_KEY = Config.HEROKU_API_KEY
Heroku = heroku3.from_key(Var.HEROKU_API_KEY)
heroku_api = "https://api.heroku.com"
AuraX_logo = "./AURAX/AuraXBot_logo.jpg"
@borg.on(
admin_cmd(pattern="(set|get|del) var(?: |$)(.*)(?: |$)([\s\S]*)",
outgoing=True))
async def variable(var):
if var.fwd_from:
return
"""
Manage most of ConfigVars setting, set new var, get current var,
or delete var...
"""
if Var.HEROKU_APP_NAME is not None:
app = Heroku.app(Var.HEROKU_APP_NAME)
else:
return await var.edit("`[HEROKU]:"
"\nPlease setup your` **HEROKU_APP_NAME**")
exe = var.pattern_match.group(1)
heroku_var = app.config()
if exe == "get":
# Copyright (C) 2019 The Raphielscape Company LLC.
#
# 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):
# 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(
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))
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`"
from telegraph import Telegraph, exceptions, upload_file
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!**"
await event.reply("`Channel or supergroup doesn't exist`")
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"
"""
thx to @r4v4n4
"""
import random
import re
from AuraXBot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@borg.on(admin_cmd(pattern="scramble(\s+[\S\s]+|$)"))
async def scramble_message(e):
reply_message = await e.get_reply_message()
text = e.pattern_match.group(1) or reply_message.text
words = re.split(r"\s", text)
scrambled = map(scramble_word, words)
text = " ".join(scrambled)
await e.edit(text)
def scramble_word(word):
if len(word) < 4:
return word
first_letter = word[0]
last_letter = word[-1]
middle_letters = list(word[1:-1])
random.shuffle(middle_letters)
return first_letter + "".join(middle_letters) + last_letter
from userbot import BOTLOG, BOTLOG_CHATID, bot
from userbot.Config import Config
from AuraXBot.utils import admin_cmd, register
from userbot.cmdhelp import CmdHelp
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=logging.WARN)
NO_PM_LOG_USERS = []
BOTLOG = True
BOTLOG_CHATID = Config.PM_LOGGR_BOT_API_ID
@bot.on(admin_cmd(pattern=r"save(?: |$)([\s\S]*)", outgoing=True))
async def log(log_text):
""" For .log command, forwards a message or the command argument to the bot logs group """
if BOTLOG:
if log_text.reply_to_msg_id:
reply_msg = await log_text.get_reply_message()
await reply_msg.forward_to(BOTLOG_CHATID)
elif log_text.pattern_match.group(1):
user = f"#LOG / Chat ID: {log_text.chat_id}\n\n"
textx = user + log_text.pattern_match.group(1)
await bot.send_message(BOTLOG_CHATID, textx)
else:
await log_text.edit("`What am I supposed to save?`")
return
await log_text.edit("`Saved Successfully`")
else:
#!/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
process.pid,
)
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)
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),
"""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
img.save(filename, "jpeg")
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:
# 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
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:
"Ⓞ",
"Ⓟ",
"Ⓠ",
"Ⓡ",
"Ⓢ",
"Ⓣ",
"Ⓤ",
"Ⓥ",
"Ⓦ",
"Ⓧ",
"Ⓨ",
"Ⓩ",
]
@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)]
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 = "******"
send_messages=None,
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)
elif message and message.video_note:
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()
from AuraXBot.plugins.sql_helper.fban_sql import (
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:
"""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:
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.😒🤐")
# credits: SNAPDRAGON (@s_n_a_p_s)
import asyncio
import time
from AuraXBot.utils import admin_cmd
from userbot.cmdhelp import CmdHelp
@bot.on(
admin_cmd(
pattern=
"webup ?(.+?|) (?:--)(anonfiles|transfer|filebin|anonymousfiles|megaupload|bayfiles)"
))
async def _(event):
if event.fwd_from:
return
await event.edit("Processing ...")
PROCESS_RUN_TIME = 100
input_str = event.pattern_match.group(1)
selected_transfer = event.pattern_match.group(2)
if input_str:
file_name = input_str
else:
reply = await event.get_reply_message()
file_name = await bot.download_media(reply.media,
Var.TEMP_DOWNLOAD_DIRECTORY)
event.message.id
CMD_WEB = {
"anonfiles": 'curl -F "file=@{}" https://anonfiles.com/api/upload',
"transfer":
'curl --upload-file "{}" https://transfer.sh/{os.path.basename(file_name)}',
"filebin":
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):
# PLUGIN MADE BY @AuraXOwner FOR AuraXBot
# KEEP CREDITS ELSE GAY
import random, re
from AuraXBot.utils import admin_cmd
import asyncio
from telethon import events
@borg.on(admin_cmd(pattern="hklove", outgoing=True))
async def _(event):
await event.edit(
"❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘❤😘"
)
await asyncio.sleep(1)
await event.edit(
"🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘🧡😘"
)
await asyncio.sleep(1)
await event.edit(
"💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘💛😘"
)
await asyncio.sleep(1)
await event.edit(
"💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘💚😘"
)
await asyncio.sleep(1)
await event.edit(
"💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘💙😘"
)
await asyncio.sleep(1)
# 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(
