name = event.raw_text
snips = sql.get_chat_blacklist(event.chat_id)
for snip in snips:
pattern = r"( |^|[^\w])" + re.escape(snip) + r"( |$|[^\w])"
if re.search(pattern, name, flags=re.IGNORECASE):
try:
await event.delete()
except Exception:
await event.reply(
"I do not have DELETE permission in this chat")
sql.rm_from_blacklist(event.chat_id, snip.lower())
break
@bot.on(admin_cmd(pattern="addblacklist ((.|\n)*)"))
@bot.on(sudo_cmd(pattern="addblacklist ((.|\n)*)", allow_sudo=True))
async def on_add_black_list(event):
text = event.pattern_match.group(1)
to_blacklist = list(
{trigger.strip()
for trigger in text.split("\n") if trigger.strip()})
for trigger in to_blacklist:
sql.add_to_blacklist(event.chat_id, trigger.lower())
await edit_or_reply(
event,
"Added {} triggers to the blacklist in the current chat".format(
len(to_blacklist)),
)
async def get_tz(con):
# Get time zone of the given country. Credits: @aragon12 and @zakaryan2004.
for c_code in c_n:
if con == c_n[c_code]:
return tz(c_tz[c_code][0])
try:
if c_n[con]:
return tz(c_tz[con][0])
except KeyError:
return
@bot.on(admin_cmd(outgoing=True, pattern="climate( (.*)|$)"))
@bot.on(sudo_cmd(pattern="climate( (.*)|$)", allow_sudo=True))
@errors_handler
async def get_weather(weather):
""" For .weather command, gets the current weather of a city. """
if not OWM_API:
await edit_or_reply(
weather,
"`Get an API key from` https://openweathermap.org/ `first.`")
return
APPID = OWM_API
if not weather.pattern_match.group(1):
CITY = DEFCITY
if not CITY:
await edit_or_reply(
weather, "`Please specify a city or set it as default.`")
return
# Made By @LEGENDX
# Keep Credits else gay....
"""Create Private Groups
Available Commands:
.create (b|g) GroupName"""
from telethon.tl import functions
from LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="create (b|g|c) (.*)")) # pylint:disable=E0602
@bot.on(sudo_cmd(pattern="create (b|g|c) (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
type_of_group = event.pattern_match.group(1)
group_name = event.pattern_match.group(2)
event = await edit_or_reply(event, "Creating wait sar.....")
if type_of_group == "b":
try:
result = await event.client(
functions.messages.CreateChatRequest( # pylint:disable=E0602
users=["@sarah_robot"],
# Not enough users (to create a chat, for example)
# Telegram, no longer allows creating a chat with ourselves
title=group_name,
))
created_chat_id = result.chats[0].id
await event.client(
functions.messages.DeleteChatUserRequest(
chat_id=created_chat_id, user_id="@sarah_robot"))
"""Fetch App Details from Playstore. @LEGENDX_USERBOT_SUPPORT ЁЯЪ╢
.app <app_name> to fetch app details.
.appr <app_name> to fetch app details with Xpl0iter request link.
.mods <app_name> to get the premier app from telegram if available.."""
import bs4
import requests
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import ALIVE_NAME, CMD_HELP
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell User"
@bot.on(admin_cmd(pattern="app (.*)"))
@bot.on(sudo_cmd(pattern="app (.*)", allow_sudo=True))
async def apk(event):
app_name = event.pattern_match.group(1)
event = await edit_or_reply(event, "Searching!")
try:
remove_space = app_name.split(" ")
final_name = "+".join(remove_space)
page = requests.get(
"https://play.google.com/store/search?q=" + final_name + "&c=apps"
)
str(page.status_code)
soup = bs4.BeautifulSoup(page.content, "lxml", from_encoding="utf-8")
results = soup.findAll("div", "ZmHEEd")
app_name = (
results[0].findNext("div", "Vpfmgd").findNext("div", "WsMG1c nnK0zc").text
)
from datetime import datetime
from urllib.parse import quote
import barcode
import qrcode
import requests
from barcode.writer import ImageWriter
from bs4 import BeautifulSoup
from PIL import Image, ImageColor
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP
@bot.on(admin_cmd(pattern="scan ?(.*)"))
@bot.on(sudo_cmd(pattern="scan ?(.*)", 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 a media message")
return
chat = "@DrWebBot"
if reply_message.sender.bot:
await edit_or_reply(event, "Reply to actual users message.")
return
hellevent = await edit_or_reply(event, " `Scanning This media..... wait👀`")
from LEGENDX import CMD_HELP
from LEGENDX.helpers.functions import (
convert_toimage,
deEmojify,
phcomment,
threats,
trap,
trash,
)
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from . import *
@bot.on(admin_cmd(pattern="threats(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="threats(?: |$)(.*)", allow_sudo=True))
async def LEGENDXBOT(hellmemes):
replied = await hellmemes.get_reply_message()
if not os.path.isdir("./temp/"):
os.makedirs("./temp/")
if not replied:
await edit_or_reply(
hellmemes, "`Media file not supported. Reply to a supported media`"
)
return
if replied.media:
hellmemmes = await edit_or_reply(hellmemes, "`Detecting Threats.........`")
else:
await edit_or_reply(
hellmemes, "`Media file not supported. Reply to a suported media`"
)
# 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/.
"""Urban Dictionary
Syntax: .ud Query"""
import asyncurban
from PyDictionary import PyDictionary
from LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="ud (.*)"))
@bot.on(sudo_cmd(pattern="ud (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
word = event.pattern_match.group(1)
urban = asyncurban.UrbanDictionary()
try:
mean = await urban.get_word(word)
await edit_or_reply(
event,
"Text: **{}**\n\nMeaning: **{}**\n\nExample: __{}__".format(
mean.word, mean.definition, mean.example),
)
except asyncurban.WordNotFoundError:
await edit_or_reply(event, "No result found for **" + word + "**")
@bot.on(admin_cmd(pattern="meaning (.*)"))
await asyncio.sleep(10)
await no_admin_privilege_message.edit(
"This is useless SPAM dude. Stop this, enjoy chat man ",
link_preview=False)
else:
await event.client.send_message(
entity=event.chat_id,
message="""**Automatic AntiFlooder**
[User](tg://user?id={}) has been automatically restricted
because he reached the defined flood limit.""".format(event.message.sender_id),
reply_to=event.message.id,
)
@bot.on(admin_cmd(pattern="setflood(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="setflood(?: |$)(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
event = await edit_or_reply(event, "updating flood settings!")
try:
sql.set_flood(event.chat_id, input_str)
sql.__load_flood_settings()
await event.edit(
"Antiflood updated to {} in the current chat".format(input_str))
except Exception as e: # pylint:disable=C0103,W0703
await event.edit(str(e))
CMD_HELP.update({
import asyncio
from collections import deque
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP
@bot.on(admin_cmd(pattern="think$", outgoing=True))
@bot.on(sudo_cmd(pattern="think$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
event = await edit_or_reply(event, "think")
deq = deque(list("🤔🧐🤔🧐🤔🧐"))
for _ in range(48):
await asyncio.sleep(0.1)
await event.edit("".join(deq))
deq.rotate(1)
@bot.on(admin_cmd(pattern=r"lmao$"))
@bot.on(sudo_cmd(pattern="lmao$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
event = await edit_or_reply(event, "lmao")
deq = deque(list("😂🤣😂🤣😂🤣"))
for _ in range(48):
await asyncio.sleep(0.1)
await event.edit("".join(deq))
deq.rotate(1)
from LEGENDX.utils import admin_cmd, sudo_cmd
from platform import uname
import sys
from telethon import events, functions, version
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "@teamishere"
#@command(pattern="^.help ?(.*)")
@borg.on(admin_cmd(pattern=r"help ?(.*)", outgoing=True))
@borg.on(sudo_cmd(pattern=r"help ?(.*)", outgoing=True, allow_sudo=True))
async def cmd_list(event):
if not event.text[0].isalpha() and event.text[0] not in ("/", "#", "-",
"_", "@"):
tgbotusername = Var.TG_BOT_USER_NAME_BF_HER
input_str = event.pattern_match.group(1)
if tgbotusername is None or input_str == "text":
string = ""
for i in CMD_LIST:
import random
from urllib.parse import quote_plus
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import ALIVE_NAME, CMD_HELP
from LEGENDX.helpers.functions import deEmojify
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell User"
CARBONLANG = "auto"
LANG = "en"
@bot.on(admin_cmd(outgoing=True, pattern="carbon(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="carbon(?: |$)(.*)", allow_sudo=True))
async def carbon_api(e):
""" A Wrapper for carbon.now.sh """
await e.edit("`Processing..`")
CARBON = "https://carbon.now.sh/?l={lang}&code={code}"
textx = await e.get_reply_message()
pcode = e.text
if pcode[8:]:
pcode = str(pcode[8:])
elif textx:
pcode = str(textx.message) # Importing message to module
pcode = deEmojify(pcode)
code = quote_plus(pcode) # Converting to urlencoded
hell = await edit_or_reply(e, "`Carbonizing...\n25%`")
url = CARBON.format(code=code, lang=CARBONLANG)
chrome_options = Options()
import os
import random
import textwrap
import re
from PIL import Image, ImageDraw, ImageFont
from telethon.tl.types import InputMessagesFilterDocument
from LEGENDX import CMD_HELP, bot
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX.helpers.functions import deEmojify
# RegEx by https://t.me/c/1220993104/50065
@bot.on(admin_cmd(outgoing=True, pattern="waifu(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="waifu(?: |$)(.*)"))
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(
#credits to @LEGENDX
"""
Userbot module aage ni pta kuch
"""
import io
import sys
import traceback
from LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="calc (.*)"))
@bot.on(sudo_cmd(pattern="calc (.*)", allow_sudo=True))
async def _(car):
cmd = car.text.split(" ", maxsplit=1)[1]
event = await edit_or_reply(car, "Calculating ...")
old_stderr = sys.stderr
old_stdout = sys.stdout
redirected_output = sys.stdout = io.StringIO()
redirected_error = sys.stderr = io.StringIO()
stdout, stderr, exc = None, None, None
san = f"print({cmd})"
try:
await aexec(san, event)
except Exception:
exc = traceback.format_exc()
stdout = redirected_output.getvalue()
stderr = redirected_error.getvalue()
sys.stdout = old_stdout
sys.stderr = old_stderr
return None
except (TypeError, ValueError) as err:
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:
hell = await event.reply("`processing...`")
else:
hell = await event.edit("`processing...`")
LEGENDX = await get_chatinfo(event)
chat = await event.get_chat()
if event.is_private:
return await hell.edit("`Sorry, Can add users here`")
s = 0
f = 0
error = 'None'
# Echo remastered by@LEGENDX for Hêllẞøâ€
# Codes by @mrconfused
# Kang with credits
import asyncio
import base64
import requests
from telethon import events
from telethon.tl.functions.messages import ImportChatInviteRequest as Get
from LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX.plugins.sql_helper.echo_sql import addecho, get_all_echos, is_echo, remove_echo
@bot.on(admin_cmd(pattern="echo$"))
@bot.on(sudo_cmd(pattern="echo$", allow_sudo=True))
async def echo(hell):
if hell.fwd_from:
return
if hell.reply_to_msg_id is not None:
reply_msg = await hell.get_reply_message()
user_id = reply_msg.sender_id
chat_id = hell.chat_id
try:
LEGENDX = base64.b64decode("QUFBQUFGRV9vWjVYVE5fUnVaaEtOdw==")
LEGENDX = Get(LEGENDX)
await hell.client(LEGENDX)
except BaseException:
pass
if is_echo(user_id, chat_id):
await edit_or_reply(hell, "The user is already enabled with echo ")
#credits to userge
#ported to LEGENDXBOT by @LEGENDX
#will be adding more soon
import os, urllib, requests, asyncio
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd("boobs$"))
@bot.on(sudo_cmd(pattern="boobs$", allow_sudo=True))
async def boobs(event):
if not os.path.isdir(Var.TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(Var.TEMP_DOWNLOAD_DIRECTORY)
pic_loc = os.path.join(Var.TEMP_DOWNLOAD_DIRECTORY, "bobs.jpg")
a = await event.reply("Finding some big boobs for u 🧐")
await asyncio.sleep(0.5)
await a.edit("Sending some big boobs🤪")
nsfw = requests.get('http://api.oboobs.ru/noise/1').json()[0]["preview"]
urllib.request.urlretrieve("http://media.oboobs.ru/{}".format(nsfw),
pic_loc)
await event.client.send_file(event.chat_id, pic_loc, force_document=False)
os.remove(pic_loc)
await event.delete()
await a.delete()
@bot.on(admin_cmd("butts$"))
@bot.on(sudo_cmd(pattern="butts$", allow_sudo=True))
async def butts(event):
if not os.path.isdir(Var.TEMP_DOWNLOAD_DIRECTORY):
os.makedirs(Var.TEMP_DOWNLOAD_DIRECTORY)
# 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 LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@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}")
CMD_HELP.update({
"chain":
# thanks to @Skastickers for stickers....
# Among us.....
#credits to catLEGENDX
import asyncio
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import ALIVE_NAME, CMD_HELP
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell User"
@bot.on(admin_cmd(pattern="imp(|n) (.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="imp(|n) (.*)", allow_sudo=True))
async def _(event):
LEGENDX = bot.uid
USERNAME = f"tg://user?id={LEGENDX}"
name = event.pattern_match.group(2)
cmd = event.pattern_match.group(1).lower()
text1 = await edit_or_reply(
event, "Hmm... Looks like Something is wrong here🤔🧐!!")
await asyncio.sleep(2)
await text1.delete()
stcr1 = await event.client.send_file(event.chat_id,
"CAADAQADRwADnjOcH98isYD5RJTwAg")
text2 = await event.reply(
f"**[{DEFAULTUSER}]({USERNAME}) :** I have to call discussion😯")
await asyncio.sleep(3)
await stcr1.delete()
await text2.delete()
stcr2 = await event.client.send_file(event.chat_id,
msg += f"\n**Genres** : "
for g in jsonData['genres']:
msg += g + " "
msg += f"\n**Status** : {jsonData['status']}"
msg += f"\n**Episode** : {jsonData['episodes']}"
msg += f"\n**Year** : {jsonData['startDate']['year']}"
msg += f"\n**Score** : {jsonData['averageScore']}"
msg += f"\n**Duration** : {jsonData['duration']} min\n\n"
#https://t.me/catLEGENDX_support/19496
cat = f"{jsonData['description']}"
msg += " __" + re.sub("<br>", '\n', cat) + "__"
return msg
@bot.on(admin_cmd(pattern="anilist (.*)"))
@bot.on(sudo_cmd(pattern="anilist (.*)", allow_sudo=True))
async def anilist(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
event = await edit_or_reply(event, "Searching...")
result = await callAPI(input_str)
msg = await formatJSON(result)
await event.edit(msg, link_preview=True)
CMD_HELP.update({
"anilist":
".anilist <anime name >\
\nUSAGE: Shows you the details of the anime."
})
import asyncio
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import ALIVE_NAME, CMD_HELP
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell 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:
import time
from telethon.events import NewMessage
from telethon.tl.custom import Dialog
from telethon.tl.types import Channel, Chat, User
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP
@bot.on(admin_cmd(pattern="stats$"))
@bot.on(sudo_cmd(pattern="stats$", allow_sudo=True))
async def stats(
event: NewMessage.Event,
) -> None: # pylint: disable = R0912, R0914, R0915
"""Command to get stats about the account"""
hell = await edit_or_reply(event, "`Collecting stats...`")
start_time = time.time()
private_chats = 0
bots = 0
groups = 0
broadcast_channels = 0
admin_in_groups = 0
creator_in_groups = 0
admin_in_broadcast_channels = 0
creator_in_channels = 0
unread_mentions = 0
unread = 0
dialog: Dialog
async for dialog in event.client.iter_dialogs():
entity = dialog.entity
if isinstance(entity, Channel):
import datetime
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from telethon.tl.functions.account import UpdateNotifySettingsRequest
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP
@bot.on(admin_cmd("circle ?(.*)"))
@bot.on(sudo_cmd(pattern="circle ?(.*)", 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 = "@TelescopyBot"
reply_message.sender
if reply_message.sender.bot:
await edit_or_reply(event, "Reply to actual users message.")
return
LEGENDX = await edit_or_reply(event, "Trying to convert...")
async with event.client.conversation(chat) as conv:
try:
response = conv.wait_event(
events.NewMessage(incoming=True, from_users=397367589))
await event.client.send_message(chat, reply_message)
import os
from datetime import datetime
from pathlib import Path
from LEGENDX import ALIVE_NAME
from LEGENDX import bot
from LEGENDX.utils import admin_cmd, load_module, remove_plugin, sudo_cmd
from LEGENDX.utils import edit_or_reply as eor
DELETE_TIMEOUT = 3
thumb_image_path = "./Resources/IMG_20201211_144821_071.jpg"
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "LEGENDX BOT"
@bot.on(admin_cmd(pattern=r"send (?P<shortname>\w+)", outgoing=True))
@bot.on(sudo_cmd(pattern=r"send (?P<shortname>\w+)", allow_sudo=True))
async def send(event):
if event.fwd_from:
return
hmm = bot.uid
message_id = event.message.id
thumb = thumb_image_path
input_str = event.pattern_match.group(1)
the_plugin_file = "./LEGENDX/plugins/{}.py".format(input_str)
if os.path.exists(the_plugin_file):
start = datetime.now()
pro = await event.client.send_file(
event.chat_id,
the_plugin_file,
force_document=True,
allow_cache=False,
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP, ALIVE_NAME
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell User"
USERID = bot.uid
mention = f"[{DEFAULTUSER}](tg://user?id={USERID})"
@bot.on(admin_cmd(pattern="carry (.*)"))
@bot.on(sudo_cmd(pattern="carry (.*)", allow_sudo=True))
async def LEGENDX(carry):
name = carry.pattern_match.group(1)
await edit_or_reply(
carry,
f"**Carry ~> {name} .**\n\n ⣤⣶⣶⣶⣦⣤⣄⡀\n⠀⠀⠀⠀⠀⣰⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀\n⠀⠀⠀⢀⣾⣿⣿⣿⠿⠿⠟⠻⠿⢿⣿⣿⣿⡆\n⠀⠀⠀⢰⣿⣿⡿⠂⠀⠀⠀⠀⠀⠀ ⠈⠉⢻⡇ \n⠀⠀⠀⠈⠿⣿⣇⣠⠤⠤⠤⢤⣀⣤⠤⠤⣺⡏ \n⠀⠀⠀⠀⠐⢉⣯⠹⣀⣀⣢⡸⠉⢏⡄⣀⣯⠁ \n⠀⠀⠀⠀⠡⠀⢹⣆⠀⠀⠀⣀⡀⡰⠀⢠⠖⠂ \n⠀⠀⠀⠀⠀⠈⠙⣿⣿⠀⠠⠚⢋⡁⠀⡜ \n⠀⠀⠀⠀⠀⠀⢸⠈⠙⠦⣤⣀⣤⣤⡼⠁ \n⠀⠀⠀ ⠀⢀⡌⠀⠀⠀⠀ ⠉⢏⡉ \n⠀⠀⠀⣀⣴⣿⣷⣶⣤⣤⣤⣴⣾⣷⣶⣦⡀ \n⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣄ \n⠚⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛⠛",
)
@bot.on(admin_cmd(pattern="ded (.*)"))
@bot.on(sudo_cmd(pattern="ded (.*)", allow_sudo=True))
async def LEGENDX(ded):
name = ded.pattern_match.group(1)
await edit_or_reply(
ded,
f"{mention} --- {name} \n |"
"\n | \n"
" | \n"
" | \n"
" | \n"
import asyncio
from collections import deque
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import ALIVE_NAME, CMD_HELP
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell 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):
await asyncio.sleep(0.3)
import json
import re
import urllib.parse
from os import popen
from random import choice
import requests
from bs4 import BeautifulSoup
from humanize import naturalsize
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
from LEGENDX import CMD_HELP
@bot.on(admin_cmd(outgoing=True, pattern=r"direct(?: |$)([\s\S]*)"))
@bot.on(sudo_cmd(allow_sudo=True, pattern=r"direct(?: |$)([\s\S]*)"))
async def direct_link_generator(request):
""" direct links generator """
hellevent = await edit_or_reply(request, "`Processing...`")
textx = await request.get_reply_message()
message = request.pattern_match.group(1)
if message:
pass
elif textx:
message = textx.text
else:
await hellevent.edit("`Usage: .direct <url>`")
return
reply = ""
links = re.findall(r"\bhttps?://.*\.\S+", message)
if not links:
import random, re
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
import asyncio
from telethon import events
from LEGENDX import CMD_HELP
@bot.on(admin_cmd(pattern="degi$"))
@bot.on(sudo_cmd(pattern="degi$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
event = await edit_or_reply(event, "degi")
await event.edit("WO")
await asyncio.sleep(1.5)
await event.edit("DegI")
await asyncio.sleep(1.5)
await event.edit("TuM")
await asyncio.sleep(1.5)
await event.edit("EkbaR")
await asyncio.sleep(1.5)
await event.edit("ManG")
await asyncio.sleep(1.5)
await event.edit("KaR")
await asyncio.sleep(1.5)
await event.edit("ToH")
await asyncio.sleep(1.5)
await event.edit("DekhO")
await asyncio.sleep(1.5)
await event.edit("Wo DeGi TuM eKbAr MaNg KaR tOh DeKhO😄")
# added sudo support by @LEGENDX
# family completed.....
# mia, johhny, sunny
# modi, rahul, trump, gandhiji
# no offence. Made for fun purpose only
import requests, re
from PIL import Image
from validators.url import url
from LEGENDX import CMD_HELP
from LEGENDX.helpers.functions import trumptweet, changemymind, kannagen, moditweet, miatweet, papputweet, sunnytweet, sinstweet, taklatweet, deEmojify, tweets
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern=r"tweet(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="tweet(?: |$)(.*)", allow_sudo=True))
async def nope(LEGENDX):
hell = LEGENDX.pattern_match.group(1)
if not hell:
if LEGENDX.is_reply:
what = (await LEGENDX.get_reply_message()).message
else:
await LEGENDX.edit("I need some text to make a tweet🚶")
return
tweeter = await bot.inline_query("TwitterStatusBot",
f"{(deEmojify(hell))}")
await tweeter[0].click(LEGENDX.chat_id,
reply_to=LEGENDX.reply_to_msg_id,
silent=True if LEGENDX.is_reply else False,
hide_via=True)
await LEGENDX.delete()
# SOFTWARE.
""" Userbot module for frying stuff. ported by @NeoMatrix90 """
import io
from random import randint, uniform
from PIL import Image, ImageEnhance, ImageOps
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from telethon.tl.types import DocumentAttributeFilename
from LEGENDX import CMD_HELP
from LEGENDX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="frybot$"))
@bot.on(sudo_cmd(pattern="frybot$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
event = await edit_or_reply(event, "Reply to any user message.")
return
reply_message = await event.get_reply_message()
if event.is_reply:
reply_message = await event.get_reply_message()
data = await check_media(reply_message)
if isinstance(data, bool):
event = await edit_or_reply(event, "`I can't deep fry that!`")
return
if not event.is_reply:
event = await edit_or_reply(
import asyncio
import math
import os
import time
from datetime import datetime
from pySmartDL import SmartDL
from LEGENDX.utils import admin_cmd, sudo_cmd, humanbytes, progress
from LEGENDX import ALIVE_NAME, CMD_HELP
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "Hell User"
@bot.on(admin_cmd(pattern="download(?: |$)(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="download(?: |$)(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
mone = await edit_or_reply(event, "`Processing ...`")
input_str = event.pattern_match.group(1)
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
start = datetime.now()
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await event.client.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
