• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/dban` <userhandle>*:* bans a user and deletes the message
• `/sban` <userhandle>*:* silently bans the user
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/kick <userhandle>`*:* Kicks a user out of the group, (via handle, or reply)
• `/dkick` <userhandle>*:* Kicks a user and deletes the message.
"""
BAN_HANDLER = CommandHandler("ban", ban)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban)
KICK_HANDLER = CommandHandler("kick", kick)
UNBAN_HANDLER = CommandHandler("unban", unban)
ROAR_HANDLER = CommandHandler("roar", selfunban)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(KICK_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(KICKME_HANDLER)
__mod_name__ = "Restrictions"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, KICK_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
KICKME_HANDLER
]
__help__ = """
• `/hitme`*:* hits the user who issued the command
*Admins only:*
• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/hit <userhandle>`*:* Hit a user out of the group, (via handle, or reply)
"""
BAN_HANDLER = CommandHandler("ban", ban)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban)
HIT_HANDLER = CommandHandler("hit", hit)
UNBAN_HANDLER = CommandHandler("unban", unban)
ROAR_HANDLER = CommandHandler("roar", selfunban)
HITME_HANDLER = DisableAbleCommandHandler(
"hitme", hitme, filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(HIT_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(HITME_HANDLER)
__mod_name__ = "Restrictions"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, HIT_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
HITME_HANDLER
]
from Hackfreaks import dispatcher
from Hackfreaks.modules.disable import DisableAbleCommandHandler
from telegram import Update
from telegram.ext import CallbackContext, run_async
@run_async
def shout(update: Update, context: CallbackContext):
args = context.args
text = " ".join(args)
result = []
result.append(' '.join([s for s in text]))
for pos, symbol in enumerate(text[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = text[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout)
dispatcher.add_handler(SHOUT_HANDLER)
__command_list__ = ["shout"]
__handlers__ = [SHOUT_HANDLER]
*Information others add on you:*
• `/bio`*:* will get your or another user's bio. This cannot be set by yourself.
• `/setbio <text>`*:* while replying, will save another user's bio
Examples:
`/bio @username(defaults to yours if not specified).`
`/setbio This user is a wolf` (reply to the user)
*Overall Information about you:*
• `/info`*:* get information about a user.
*What is that health thingy?*
Come and see [HP System explained](https://t.me/indianbotupdate/4)
"""
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio)
STATS_HANDLER = CommandHandler("stats", stats)
ID_HANDLER = DisableAbleCommandHandler("id", get_id)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid)
INFO_HANDLER = DisableAbleCommandHandler(("info", "book"), info)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(SET_BIO_HANDLER)
__help__ = """
• `/locktypes`*:* a list of possible locktypes
*Admins only:*
• `/lock <type>`*:* lock items of a certain type (not available in private)
• `/unlock <type>`*:* unlock items of a certain type (not available in private)
• `/locks`*:* the current list of locks in this chat.
Locks can be used to restrict a group's users.
*Example:*
Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \
stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock)
UNLOCK_HANDLER = CommandHandler("unlock", unlock)
LOCKED_HANDLER = CommandHandler("locks", list_locks)
LOCKABLE_HANDLER = MessageHandler(Filters.all & Filters.group, del_lockables)
RESTRICTION_HANDLER = MessageHandler(Filters.all & Filters.group, rest_handler)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(LOCKABLE_HANDLER, PERM_GROUP)
dispatcher.add_handler(RESTRICTION_HANDLER, REST_GROUP)
__mod_name__ = "Locks"
__handlers__ = [
imglinks = []
counter = 0
pattern = r'^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$'
oboi = re.findall(pattern, decoded, re.I | re.M)
for imglink in oboi:
counter += 1
imglinks.append(imglink)
if counter >= int(lim):
break
return imglinks
__help__ = f"""
*Commands:*
• /reverse: Does a reverse image search of the media which it was replied to.
Reports bugs at @HackfreaksSupport
"""
__mod_name__ = "Image Search"
REVERSE_HANDLER = DisableAbleCommandHandler(
"reverse", reverse, pass_args=True, admin_ok=True
)
dispatcher.add_handler(REVERSE_HANDLER)
"<b>Service uptime:</b> <code>{}</code>".format(
telegram_ping, uptime),
parse_mode=ParseMode.HTML)
@run_async
@sudo_plus
def pingall(update: Update, context: CallbackContext):
to_ping = ["Kaizoku", "Kayo", "Telegram", "Jikan"]
pinged_list = ping_func(to_ping)
pinged_list.insert(2, '')
uptime = get_readable_time((time.time() - StartTime))
reply_msg = "⏱Ping results are:\n"
reply_msg += "\n".join(pinged_list)
reply_msg += '\n<b>Service uptime:</b> <code>{}</code>'.format(uptime)
update.effective_message.reply_text(reply_msg,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
PING_HANDLER = DisableAbleCommandHandler("ping", ping)
PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(PINGALL_HANDLER)
__command_list__ = ["ping", "pingall"]
__handlers__ = [PING_HANDLER, PINGALL_HANDLER]
reply = song.format()
else:
reply = "Couldn't find any lyrics for that song!"
else:
reply = "Song not found!"
if len(reply) > 4090:
with open("lyrics.txt", 'w') as f:
f.write(f"{reply}\n\n\nOwO UwU OmO")
with open("lyrics.txt", 'rb') as f:
msg.reply_document(
document=f,
caption=
"Message length exceeded max limit! Sending as a text file.")
else:
msg.reply_text(reply)
__help__ = """
Want to get the lyrics of your favorite songs straight from the app? Plus You can get the Song uploaded here on your request
*Available commands:*
- /lyrics <song>: returns the lyrics of that song.
- /song <song>: uploads the song directly to telegram from youtube.
You can either enter just the song name or both the artist and song name.
"""
__mod_name__ = "Music"
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics)
dispatcher.add_handler(LYRICS_HANDLER)
).json()
if not json_rep.get("success"):
msg.reply_text(f"An error occurred! Report this @{SUPPORT_CHAT}")
else:
wallpapers = json_rep.get("wallpapers")
if not wallpapers:
msg.reply_text("No results found! Refine your search.")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
bot.send_photo(
chat_id,
photo=wallpaper,
caption='Preview',
reply_to_message_id=msg_id,
timeout=60)
bot.send_document(
chat_id,
document=wallpaper,
filename='wallpaper',
caption=caption,
reply_to_message_id=msg_id,
timeout=60)
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall)
dispatcher.add_handler(WALLPAPER_HANDLER)
buttons=[[Button.inline('Unapprove all users', b'rmapp')],
[Button.inline('Cancel', b'can')]],
reply_to=event.id)
__help__ = """
Sometimes, you might trust a user not to send unwanted content.
Maybe not enough to make them admin, but you might be ok with locks, blacklists, and antiflood not applying to them.
That's what approvals are for - approve of trustworthy users to allow them to send
*Admin commands:*
- `/approval`*:* Check a user's approval status in this chat.
- `/approve`*:* Approve of a user. Locks, blacklists, and antiflood won't apply to them anymore.
- `/unapprove`*:* Unapprove of a user. They will now be subject to locks, blacklists, and antiflood again.
- `/approved`*:* List all approved users.
- `/unapproveall`*:* Unapprove *ALL* users in a chat. This cannot be undone.
"""
APPROVE = DisableAbleCommandHandler("approve", approve)
DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove)
LIST_APPROVED = DisableAbleCommandHandler("approved", approved)
APPROVAL = DisableAbleCommandHandler("approval", approval)
dispatcher.add_handler(APPROVE)
dispatcher.add_handler(DISAPPROVE)
dispatcher.add_handler(LIST_APPROVED)
dispatcher.add_handler(APPROVAL)
__mod_name__ = "Approvals"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, LIST_APPROVED, APPROVAL]
• `/removeallfilters`*:* Remove all chat filters at once.
*Note*: Filters also support markdown formatters like: {first}, {last} etc.. and buttons.
Check `/markdownhelp` to know more!
"""
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
RMALLFILTER_HANDLER = CommandHandler(
"removeallfilters", rmall_filters, filters=Filters.group)
RMALLFILTER_CALLBACK = CallbackQueryHandler(
rmall_callback, pattern=r"filters_.*")
LIST_HANDLER = DisableAbleCommandHandler(
"filters", list_handlers, admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
dispatcher.add_handler(RMALLFILTER_HANDLER)
dispatcher.add_handler(RMALLFILTER_CALLBACK)
__handlers__ = [
FILTER_HANDLER, STOP_HANDLER, LIST_HANDLER,
(CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER)
]
return
if success:
msg.reply_text(
"Sticker pack successfully created. Get it [here](t.me/addstickers/%s)"
% packname,
parse_mode=ParseMode.MARKDOWN,
)
else:
msg.reply_text(
"Failed to create sticker pack. Possibly due to blek mejik.")
__help__ = """
• `/stickerid`*:* reply to a sticker to me to tell you its file ID.
• `/getsticker`*:* reply to a sticker to me to upload its raw PNG file.
• `/kang`*:* reply to a sticker to add it to your pack.
• `/stickers`*:* Find stickers for given term on combot sticker catalogue
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang", kang, admin_ok=True)
STICKERS_HANDLER = DisableAbleCommandHandler("stickers", cb_sticker)
dispatcher.add_handler(STICKERS_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately.
*NOTE:* Blacklist stickers do not affect the group admin.
• `/blsticker`*:* See current blacklisted sticker.
*Only admin:*
• `/addblsticker <sticker link>`*:* Add the sticker trigger to the black list. Can be added via reply sticker.
• `/unblsticker <sticker link>`*:* Remove triggers from blacklist. The same newline logic applies here, so you can delete multiple triggers at once.
• `/rmblsticker <sticker link>`*:* Same as above.
• `/blstickermode <ban/tban/mute/tmute>`*:* sets up a default action on what to do if users use blacklisted stickers. (`tmute seems broken right now`)
Note:
• `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message.
"""
__mod_name__ = "Stickers Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker",
blackliststicker,
admin_ok=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
"addblsticker", add_blackliststicker)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"],
unblackliststicker)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.group,
del_blackliststicker)
dispatcher.add_handler(BLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
- /neko
- /walls
"""
__mod_name__ = "Hentai"
ADDHENTAI_HANDLER = CommandHandler("addhentai",
addhentai,
pass_args=True,
filters=CustomFilters.sudo_filter)
REMOVEHENTAI_HANDLER = CommandHandler("removehentai",
removehentai,
pass_args=True,
filters=CustomFilters.sudo_filter)
PUSSY_HANDLER = DisableAbleCommandHandler("pussy", pussy)
HENTAIG_HANDLER = DisableAbleCommandHandler("hentaigif", hentaig)
NEKO_HANDLER = DisableAbleCommandHandler("neko", neko)
FEET_HANDLER = DisableAbleCommandHandler("feet", feet)
YURI_HANDLER = DisableAbleCommandHandler("yuri", yuri)
TRAP_HANDLER = DisableAbleCommandHandler("trap", trap)
FUTANARI_HANDLER = DisableAbleCommandHandler("futanari", futanari)
HOLOLEWD_HANDLER = DisableAbleCommandHandler("hololewd", hololewd)
LEWDKEMO_HANDLER = DisableAbleCommandHandler("lewdkemo", lewdkemo)
SOLOG_HANDLER = DisableAbleCommandHandler("sologif", solog)
FEETG_HANDLER = DisableAbleCommandHandler("feetgif", feetg)
CUMG_HANDLER = DisableAbleCommandHandler("cumgif", cumg)
EROKEMO_HANDLER = DisableAbleCommandHandler("erokemo", erokemo)
LESBIAN_HANDLER = DisableAbleCommandHandler("lesbian", lesbian)
WALLPAPER_HANDLER = DisableAbleCommandHandler("walls", wallpaper)
LEWDK_HANDLER = DisableAbleCommandHandler("lewdk", lewdk)
string = ""
if message.reply_to_message:
string = message.reply_to_message.text.lower().replace(" ", " ")
if args:
string = ' '.join(args).lower()
if not string:
message.reply_text(
"Usage is `/weebify <text>`", parse_mode=ParseMode.MARKDOWN)
return
for normiecharacter in string:
if normiecharacter in normiefont:
weebycharacter = weebyfont[normiefont.index(normiecharacter)]
string = string.replace(normiecharacter, weebycharacter)
if message.reply_to_message:
message.reply_to_message.reply_text(string)
else:
message.reply_text(string)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify)
dispatcher.add_handler(WEEBIFY_HANDLER)
__command_list__ = ["weebify"]
__handlers__ = [WEEBIFY_HANDLER]
• `/markdownhelp`*:* quick summary of how markdown works in telegram - can only be called in private chats
*Paste:*
• `/paste`*:* Saves replied content to `nekobin.com` and replies with a url
*UrbanDictionnary:*
• `/ud`*:* Search for a word in Urban Disctionary and replies with it's Meaning
*Wikipedia:*
• `/wiki <query>`*:* wikipedia your query
*Currency converter:*
• `/cash`*:* currency converter
Example:
`/cash 1 USD INR`
_OR_
`/cash 1 usd inr`
Output: `1.0 USD = 75.505 INR`
• `/encrypt <texts>` *:* can only be decrypted using this bot
• `/decrypt <encrypted text>` *:* Decrypt Texts encrypted using this bot
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
]
def tts(update: Update, context: CallbackContext):
args = context.args
current_time = datetime.strftime(datetime.now(), "%d.%m.%Y %H:%M:%S")
filename = datetime.now().strftime("%d%m%y-%H%M%S%f")
reply = " ".join(args)
update.message.chat.send_action(ChatAction.RECORD_AUDIO)
lang = "ml"
tts = gTTS(reply, lang)
tts.save("k.mp3")
with open("k.mp3", "rb") as f:
linelist = list(f)
linecount = len(linelist)
if linecount == 1:
update.message.chat.send_action(ChatAction.RECORD_AUDIO)
lang = "en"
tts = gTTS(reply, lang)
tts.save("k.mp3")
with open("k.mp3", "rb") as speech:
update.message.reply_voice(speech, quote=False)
__help__ = """
- /tts <text>: convert text to speech
"""
TTS_HANDLER = DisableAbleCommandHandler("tts", tts, pass_args=True)
dispatcher.add_handler(TTS_HANDLER)
__mod_name__ = "Tts"
__command_list__ = ["tts"]
__handlers__ = [TTS_HANDLER]
update.effective_message.reply_text(res)
else:
if int(userc_id) == int(user_id):
return
res = "{} is afk.\nReason: <code>{}</code>".format(
html.escape(fst_name), html.escape(user.reason))
update.effective_message.reply_text(res, parse_mode="html")
__help__ = """
• `/afk <reason>`*:* mark yourself as AFK(away from keyboard).
• `brb <reason>`*:* same as the afk command - but not a command.
When marked as AFK, any mentions will be replied to with a message to say you're not available!
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"^brb(.*)$"), afk, friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
__mod_name__ = "AFK"
__command_list__ = ["afk"]
__handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
__help__ = """
• `/admins`*:* list of admins in the chat
*Admins only:*
• `/pin`*:* silently pins the message replied to - add `'loud'` or `'notify'` to give notifs to users.
• `/unpin`*:* unpins the currently pinned message
• `/invitelink`*:* gets invitelink
• `/promote`*:* promotes the user replied to
• `/demote`*:* demotes the user replied to
• `/admincache`*:* Updates the admin cache of the Group in Database.
• `/title <title here>`*:* sets a custom title for an admin that the bot promoted
"""
ADMINLIST_HANDLER = DisableAbleCommandHandler("admins", adminlist)
PIN_HANDLER = CommandHandler("pin", pin, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
INVITE_HANDLER = DisableAbleCommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote)
ADMIN_CACHE_HANDLER = CommandHandler(
"admincache", admincache, filters=Filters.group
)
SET_TITLE_HANDLER = CommandHandler("title", set_title)
dispatcher.add_handler(ADMINLIST_HANDLER)
except DisambiguationError as e:
update.message.reply_text(
"Disambiguated pages found! Adjust your query accordingly.\n<i>{}</i>"
.format(e),
parse_mode=ParseMode.HTML)
except PageError as e:
update.message.reply_text("<code>{}</code>".format(e),
parse_mode=ParseMode.HTML)
if res:
result = f"<b>{search}</b>\n\n"
result += f"<i>{res}</i>\n"
result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>"""
if len(result) > 4000:
with open("result.txt", 'w') as f:
f.write(f"{result}\n\nUwU OwO OmO UmU")
with open("result.txt", 'rb') as f:
context.bot.send_document(
document=f,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.effective_chat.id,
parse_mode=ParseMode.HTML)
else:
update.message.reply_text(result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
dispatcher.add_handler(WIKI_HANDLER)
speed.download()
speed.upload()
replymsg = 'SpeedTest Results:'
if query.data == 'speedtest_image':
speedtest_image = speed.results.share()
update.effective_message.reply_photo(photo=speedtest_image,
caption=replymsg)
msg.delete()
elif query.data == 'speedtest_text':
result = speed.results.dict()
replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`"
update.effective_message.edit_text(replymsg,
parse_mode=ParseMode.MARKDOWN)
else:
query.answer(
"You are required to join Heroes Association to use this command.")
SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz)
SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback,
pattern='speedtest_.*')
dispatcher.add_handler(SPEED_TEST_HANDLER)
dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER)
__mod_name__ = "SpeedTest"
__command_list__ = ["speedtest"]
__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
• `/addwarn <keyword> <reply message>`*:* set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
• `/nowarn <keyword>`*:* stop a warning filter
• `/warnlimit <num>`*:* set the warning limit
• `/strongwarn <on/yes/off/no>`*:* If set to on, exceeding the warn limit will result in a ban. Else, will just punch.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
reset_warns,
filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn",
add_warn_filter,
filters=Filters.group)
RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"],
remove_warn_filter,
filters=Filters.group)
LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"],
list_warn_filters,
filters=Filters.group,
admin_ok=True)
WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group,
reply_filter)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
set_warn_limit,
__help__ = """
Blacklists are used to stop certain triggers from being said in a group. Any time the trigger is mentioned, \
the message will immediately be deleted. A good combo is sometimes to pair this up with warn filters!
*NOTE:* blacklists do not affect group admins.
• `/blacklist`*:* View the current blacklisted words.
*Admins only:*
• `/addblacklist <triggers>`*:* Add a trigger to the blacklist. Each line is considered one trigger, so using different \
lines will allow you to add multiple triggers.
• `/unblacklist <triggers>`*:* Remove triggers from the blacklist. Same newline logic applies here, so you can remove \
multiple triggers at once.
• `/rmblacklist <triggers>`*:* Same as above.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist", blacklist)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.group,
del_blacklist,
allow_edit=True)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
__mod_name__ = "Blacklist"
__handlers__ = [