__help__ = """
• `/admins`*:* list of admins in the chat
*Admins only:*
• `/tagall`*:* Mention the group members
• `/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
• `/title <title here>`*:* sets a custom title for an admin that the bot promoted
• /zombies: counts the number of deleted account in your group
• /zombies clean: Remove deleted accounts from group..
"""
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)
SET_TITLE_HANDLER = CommandHandler("title", set_title)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
update.effective_message.reply_text(res)
def __user_info__(user_id):
is_afk = is_user_afk(user_id)
text = ""
if is_afk:
since_afk = get_readable_time(
(time.time() - float(REDIS.get(f'afk_time_{user_id}'))))
text = "<i>This user is currently afk (away from keyboard).</i>"
text += f"\n<i>Since: {since_afk}</i>"
else:
text = "<i>This user is currently isn't afk (away from keyboard).</i>"
return text
def __gdpr__(user_id):
end_afk(user_id)
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = MessageHandler(Filters.regex("(?i)brb"), 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)
__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
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"
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)
import html
import random
import ElizaRobot.modules.truth_and_dare_string as truth_and_dare_string
from ElizaRobot import dispatcher
from telegram import ParseMode, Update, Bot
from ElizaRobot.modules.disable import DisableAbleCommandHandler
from telegram.ext import CallbackContext, run_async
@run_async
def truth(update: Update, context: CallbackContext):
args = context.args
update.effective_message.reply_text(
random.choice(truth_and_dare_string.TRUTH))
@run_async
def dare(update: Update, context: CallbackContext):
args = context.args
update.effective_message.reply_text(
random.choice(truth_and_dare_string.DARE))
TRUTH_HANDLER = DisableAbleCommandHandler("truth", truth)
DARE_HANDLER = DisableAbleCommandHandler("dare", dare)
dispatcher.add_handler(TRUTH_HANDLER)
dispatcher.add_handler(DARE_HANDLER)
from ElizaRobot.modules.helper_funcs.extraction import extract_user
def tts(update, context):
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)
TTS_HANDLER = DisableAbleCommandHandler("tts", tts)
dispatcher.add_handler(TTS_HANDLER)
__handlers__ = [
TTS_HANDLER
]
• `/punchme`*:* punchs 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)
• `/kick <userhandle>`*:* kicks a user out of the group, (via handle, or reply)
"""
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("kick",
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__ = "Bans"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, KICK_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
KICKME_HANDLER
]
from ElizaRobot import dispatcher
from ElizaRobot.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]
• `/sin`*:* Sine `/sin 0`
• `/tan`*:* Tangent `/tan 0`
• `/arccos`*:* Inverse Cosine `/arccos 1`
• `/arcsin`*:* Inverse Sine `/arcsin 0`
• `/arctan`*:* Inverse Tangent `/arctan 0`
• `/abs`*:* Absolute Value `/abs -1`
• `/log`*:* Logarithm `/log 2l8`
_Keep in mind_: To find the tangent line of a function at a certain x value, send the request as c|f(x) where c is the given x value and f(x) is the function expression, the separator is a vertical bar '|'. See the table above for an example request.
To find the area under a function, send the request as c:d|f(x) where c is the starting x value, d is the ending x value, and f(x) is the function under which you want the curve between the two x values.
To compute fractions, enter expressions as numerator(over)denominator. For example, to process 2/4 you must send in your expression as 2(over)4. The result expression will be in standard math notation (1/2, 3/4).
"""
__mod_name__ = "Math"
SIMPLIFY_HANDLER = DisableAbleCommandHandler("math", simplify)
FACTOR_HANDLER = DisableAbleCommandHandler("factor", factor)
DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive)
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate)
ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes)
TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent)
AREA_HANDLER = DisableAbleCommandHandler("area", area)
COS_HANDLER = DisableAbleCommandHandler("cos", cos)
SIN_HANDLER = DisableAbleCommandHandler("sin", sin)
TAN_HANDLER = DisableAbleCommandHandler("tan", tan)
ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos)
ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin)
ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan)
ABS_HANDLER = DisableAbleCommandHandler("abs", abs)
LOG_HANDLER = DisableAbleCommandHandler("log", log)
• `/resetwarn <userhandle>`*:* reset the warns for a user. Can also be used as a reply.
• `/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, filters=Filters.group)
WARN_STRENGTH_HANDLER = CommandHandler(
"strongwarn", set_warn_strength, filters=Filters.group)
__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.
Admin 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.
• `/blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>`*:* Action to perform when someone sends blacklisted words.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist)
BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode",
blacklist_mode,
pass_args=True)
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)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
blacklisted = sql.num_stickers_chat_filters(chat_id)
return "There are `{} `blacklisted stickers.".format(blacklisted)
def __stats__():
return "• {} blacklist stickers, across {} chats.".format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
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)
Get information about anime, manga or characters from [AniList](anilist.co).
*Available commands:*
• `/anime <anime>`*:* returns information about the anime.
• `/character <character>`*:* returns information about the character.
• `/manga <manga>`*:* returns information about the manga.
• `/user <user>`*:* returns information about a MyAnimeList user.
• `/upcoming`*:* returns a list of new anime in the upcoming seasons.
• `/kaizoku <anime>`*:* search an anime on animekaizoku.com
• `/kayo <anime>`*:* search an anime on animekayo.com
• `/airing <anime>`*:* returns anime airing info.
"""
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
USER_HANDLER = DisableAbleCommandHandler("user", user)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku)
KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo)
BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*')
dispatcher.add_handler(BUTTON_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(USER_HANDLER)
• `/locks`*:* The current list of locks in this chat.
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls, locking stickers will restrict all \
non-admin users from sending stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
*Note:*
• Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name
• Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock,
pass_args=True) # , filters=Filters.group)
UNLOCK_HANDLER = CommandHandler("unlock", unlock,
pass_args=True) # , filters=Filters.group)
LOCKED_HANDLER = CommandHandler("locks",
list_locks) # , filters=Filters.group)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
• `/save <notename>`*:* save the replied message as a note with name notename
• `/clear <notename>`*:* clear note with this name
• `/removeallnotes`*:* removes all notes from the group
*Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved.
"""
__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get)
SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"), slash_get)
SAVE_HANDLER = CommandHandler("save", save)
DELETE_HANDLER = CommandHandler("clear", clear)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True)
CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall)
CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*")
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
dispatcher.add_handler(SLASH_GET_HANDLER)
dispatcher.add_handler(CLEARALL)
dispatcher.add_handler(CLEARALL_BTN)
f"{member.user['first_name']} is not an approved user. They are affected by normal commands."
)
__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.
"""
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__ = "Approval"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, APPROVAL]
*Application Info:*
➩ /app <App Name>: Get Application Information
*Number Info:*
➩ /phone <full number>: Check Details
*Weather Information:*
➩ /weather <city>: Gets weather information of particular place!
*Date & Time:*
➩ /datetime <country code>: Get date and time by provided country
*TRANSLATER*
➩ /tr or /tl (language code) as reply to a long message
Example:
/tr en: translates something to english
/tr hi-en: translates hindi to english
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
UD_HANDLER = DisableAbleCommandHandler(["ud"], ud)
TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(WIKI_HANDLER)
dispatcher.add_handler(UD_HANDLER)
dispatcher.add_handler(TRANSLATE_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo", "ud", "tr", "tl"]
__handlers__ = [
ECHO_HANDLER,
return results
def scam(imgspage, lim):
"""Parse/Scrape the HTML code for the info we want."""
single = opener.open(imgspage).read()
decoded = single.decode('utf-8')
if int(lim) > 10:
lim = 10
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
REVERSE_HANDLER = DisableAbleCommandHandler(
"reverse", reverse, pass_args=True, admin_ok=True
)
dispatcher.add_handler(REVERSE_HANDLER)
"PONG!!\n"
"<b>Time Taken:</b> <code>{}</code>\n"
"<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]
`/setme I am a wolf.`
`/me @username(defaults to yours if no user specified)`
*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.
"""
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__ = """
*Some dank memes for fun or whatever!
✪ `/slap`: Slap a user, or get slapped if not a reply.
✪ `/hug`: Hug a user warmly, or get hugged if not a reply.
✪ `/roll`: Rolls a dice.
✪ `/clap`: Claps on someones message!
✪ `/owo`: UwU-fy whole text XD.
✪ `/pasta`: Famous copypasta meme, try and see.
"""
__mod_name__ = "Memes"
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap)
HUG_HANDLER = DisableAbleCommandHandler("hug", hug)
DICE_HANDLER = DisableAbleCommandHandler("roll", dice)
CLAP_HANDLER = DisableAbleCommandHandler("clap", clapmoji)
GDMORNING_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"(?i)(gm|good morning)"),
goodmorning,
friendly="goodmorning")
GDNIGHT_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"(?i)(gn|good night)"), goodnight, friendly="goodnight")
OWO_HANDLER = DisableAbleCommandHandler("owo", owo)
STRECH_HANDLER = DisableAbleCommandHandler("stretch", stretch)
PASTA_HANDLER = DisableAbleCommandHandler("pasta", copypasta)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(HUG_HANDLER)
"( ◡‿◡ *)", "(//ω//)", "(￣▽￣*)ゞ", "(„ಡωಡ„)", "(ﾉ´ з `)ノ", "(♡-_-♡)",
"(─‿‿─)♡", "(´ ω `♡)", "(ღ˘⌣˘ღ)", "(´• ω •`) ♡", "╰(*´︶`*)╯♡", "(≧◡≦) ♡",
"♡ (˘▽˘>ԅ( ˘⌣˘)", "σ(≧ε≦σ) ♡", "(˘∀˘)/(μ‿μ) ❤", "Σ>―(〃°ω°〃)♡→",
"(* ^ ω ^)", "(o^▽^o)", "ヽ(・∀・)ﾉ", "(o･ω･o)", "(^人^)", "( ´ ω ` )",
"(´• ω •`)", "╰(▔∀▔)╯", "(✯◡✯)", "(⌒‿⌒)", "(*°▽°*)", "(´｡• ᵕ •｡`)",
"ヽ(>∀<☆)ノ", "＼(￣▽￣)／", "(o˘◡˘o)", "(╯✧▽✧)╯", "( ‾́ ◡ ‾́ )", "(๑˘︶˘๑)",
"(´･ᴗ･ ` )", "( ͡° ʖ̯ ͡°)", "( ఠ ͟ʖ ఠ)", "( ಥ ʖ̯ ಥ)", "(≖ ͜ʖ≖)", "ヘ(￣ω￣ヘ)",
"(ﾉ≧∀≦)ﾉ", "└(￣-￣└))", "┌(＾＾)┘", "(^_^♪)", "(〜￣△￣)〜", "(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-",
"(*´з`)口ﾟ｡ﾟ口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-ｃ(・・ )", "(ﾉ≧∀≦)ﾉ ‥…━━━★",
"╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ", "(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)"
]
@run_async
def react(update: Update, context: CallbackContext):
message = update.effective_message
react = random.choice(reactions)
if message.reply_to_message:
message.reply_to_message.reply_text(react)
else:
message.reply_text(react)
REACT_HANDLER = DisableAbleCommandHandler("react", react)
dispatcher.add_handler(REACT_HANDLER)
__command_list__ = ["react"]
__handlers__ = [REACT_HANDLER]
• `/runs`*:* reply a random string from an array of replies
• `/slap`*:* slap a user, or get slapped if not a reply
• `/shrug`*:* get shrug XD
• `/table`*:* get flip/unflip :v
• `/decide`*:* Randomly answers yes/no/maybe
• `/toss`*:* Tosses A coin
• `/bluetext`*:* check urself :V
• `/roll`*:* Roll a dice
• `/rlg`*:* Join ears,nose,mouth and create an emo ;-;
• `/shout <keyword>`*:* write anything you want to give loud shout
• `/weebify <text>`*:* returns a weebified text
• `/sanitize`*:* always use this before /pat or any contact
• `/pat`*:* pats a user, or get patted
"""
SANITIZE_HANDLER = DisableAbleCommandHandler("sanitize", sanitize)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap)
PAT_HANDLER = DisableAbleCommandHandler("pat", pat)
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
TABLE_HANDLER = DisableAbleCommandHandler("table", table)
dispatcher.add_handler(SANITIZE_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(PAT_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]
• `/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)
]
if message.reply_to_message:
data = message.reply_to_message.text
elif len(args) >= 1:
data = message.text.split(None, 1)[1]
else:
message.reply_text("What am I supposed to do with this?")
return
key = requests.post('https://nekobin.com/api/documents',
json={
"content": data
}).json().get('result').get('key')
url = f'https://nekobin.com/{key}'
reply_text = f'Nekofied to *Nekobin* : {url}'
message.reply_text(reply_text,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
PASTE_HANDLER = DisableAbleCommandHandler("paste", paste)
dispatcher.add_handler(PASTE_HANDLER)
__command_list__ = ["paste"]
__handlers__ = [PASTE_HANDLER]
json_rep = r.get(
f"https://wall.alphacoders.com/api2.0/get.php?auth={WALL_API}&method=search&term={term}"
).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)