def main():
# test_handler = CommandHandler("test", test) #Unused variable
start_handler = DisableAbleCommandHandler("start", start, pass_args=True)
help_handler = DisableAbleCommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
start_callback_handler = CallbackQueryHandler(send_start,
pattern=r"bot_start")
migrate_handler = MessageHandler(Filters.status_update.migrate,
migrate_chats)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(start_callback_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(help_callback_handler)
dispatcher.add_handler(migrate_handler)
# dispatcher.add_error_handler(error_callback)
# add antiflood processor
Dispatcher.process_update = process_update
LOGGER.info("Using long polling.")
# updater.start_polling(timeout=15, read_latency=4, clean=True)
updater.start_polling(poll_interval=0.0,
timeout=10,
clean=True,
bootstrap_retries=-1,
read_latency=3.0)
LOGGER.info("Successfully loaded")
if len(argv) not in (1, 3, 4):
tbot.disconnect()
else:
tbot.run_until_disconnected()
updater.idle()
"\n#MUTEME"
"\n<b>• User:</b> {}"
"\n<b>• ID:</b> <code>{}</code>".format(
html.escape(chat.title),
mention_html(user.id, user.first_name),
user_id,
)
)
else:
update.effective_message.reply_text(tld(chat.id, "mute_cant_mute"))
MUTE_HANDLER = DisableAbleCommandHandler("mute",
mute,
pass_args=True,
admin_ok=True)
UNMUTE_HANDLER = DisableAbleCommandHandler("unmute",
unmute,
pass_args=True,
admin_ok=True)
TEMPMUTE_HANDLER = DisableAbleCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True,
admin_ok=True)
TEMP_NOMEDIA_HANDLER = DisableAbleCommandHandler(["trestrict", "temprestrict"],
temp_nomedia,
pass_args=True,
admin_ok=True)
NOMEDIA_HANDLER = DisableAbleCommandHandler(["restrict", "nomedia"],
nomedia,
#if tekstr.pronunciation == None:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
#else:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
else:
tekstr = trl.translate(text, dest=target2, src=target)
message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
#if tekstr.pronunciation == None:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
#else:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
except IndexError:
update.effective_message.reply_text("Reply to messages or write messages from other languages for translating into the intended language\n\nExample: `/tl en-ja` to translate from English to Japanese\nOr use: `/tl ja` for automatic detection and translating it into Japanese.", parse_mode="markdown")
except ValueError:
update.effective_message.reply_text("The intended language is not found!")
else:
return
__help__ = """
*This module uses Google Translate to do the translations.*
- /tr <language code>: as reply to a long message.
"""
__mod_name__ = "Translator"
TOTRANSLATE_HANDLER = DisableAbleCommandHandler("tr", totranslate)
dispatcher.add_handler(TOTRANSLATE_HANDLER)
__help__ = """
Do stickers annoy you? or want to avoid people sharing links? or pictures? You're in the right place!
The locks module allows you to lock away some common items in the telegram world; the bot will automatically delete them!
Available commands are:
- /lock <item(s)>: lock the usage of "item". Now, only admins will be able to use this type!
- /unlock <item(s)>: unlock "item". Everyone can use them again.
- /locks: list the lock status in the chat.
- /locktypes: gets a list of all things that can be locked. (have a look at this!)
eg: lock stickers with:
/lock sticker
"""
__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)
dispatcher.add_handler(MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
'尸', '㔿', '尺', '丂', '丅', '凵', 'リ', '山', '乂', '丫', '乙'
]
@run_async
def weebify(bot: Bot, update: Update, args: List[str]):
string = ' '.join(args).lower()
for normiecharacter in string:
if normiecharacter in normiefont:
weebycharacter = weebyfont[normiefont.index(normiecharacter)]
string = string.replace(normiecharacter, weebycharacter)
message = update.effective_message
if message.reply_to_message:
message.reply_to_message.reply_text(string)
else:
message.reply_text(string)
__help__ = """
- /weebify <text>: returns a weebified text
"""
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, pass_args=True)
dispatcher.add_handler(WEEBIFY_HANDLER)
__mod_name__ = "Weebify"
__command_list__ = ["weebify"]
__handlers__ = [WEEBIFY_HANDLER]
message.reply_text(rhappy)
@run_async
def rangry(bot: Bot, update: Update):
message = update.effective_message
rangry = random.choice(reactionangry)
if message.reply_to_message:
message.reply_to_message.reply_text(rangry)
else:
message.reply_text(rangry)
__help__ = """
*Use these commands to let the bot express reactions for you!*
- /react: reacts with normal reactions.
- /happy: reacts with happiness.
- /angry: reacts angrily.
"""
__mod_name__ = "Reactions"
REACT_HANDLER = DisableAbleCommandHandler("react", react)
RHAPPY_HANDLER = DisableAbleCommandHandler("happy", rhappy)
RANGRY_HANDLER = DisableAbleCommandHandler("angry", rangry)
dispatcher.add_handler(REACT_HANDLER)
dispatcher.add_handler(RHAPPY_HANDLER)
dispatcher.add_handler(RANGRY_HANDLER)
chat = update.effective_chat # type: Optional[Chat]
if sql.is_afk(user_id):
user = sql.check_afk_status(user_id)
if not user.reason:
res = tld(chat.id, f"{fst_name} is AFK!")
else:
res = tld(
chat.id,
f"{fst_name} is AFK! says its because of:\n{user.reason}")
update.effective_message.reply_text(res)
__help__ = """
- /afk <reason>: mark yourself as AFK.
- 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 that you're not available!
"""
__mod_name__ = "AFK"
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleRegexHandler("(?i)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)
text = tl(update.effective_message,
"Blue text cleaner was *enabled*.")
send_message(update.effective_message, text, parse_mode="markdown")
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Unknown argument - please use 'yes', or 'no'."))
else:
send_message(
update.effective_message,
tl(update.effective_message,
"Curent settings for Blue text cleaner at {}: *{}*").format(
chat_name,
"Enabled" if sql.is_enable(chat_id) else "Disabled"),
parse_mode="markdown")
__help__ = "cleaner_help"
__mod_name__ = "Cleaner"
SET_CLEAN_BLUE_TEXT_HANDLER = DisableAbleCommandHandler(
"cleanbluetext", set_blue_text_must_click, pass_args=True)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group,
clean_blue_text_must_click)
dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, 15)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __stats__():
return "• <code>{}</code> blacklist triggers, across <code>{}</code> chats.".format(
sql.num_blacklist_filters(), sql.num_blacklist_filter_chats())
__help__ = True
# TODO: Add blacklist alternative modes: warn, ban, kick, or mute.
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
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,
edited_updates=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)
base_string = tld(chat.id, "url_blacklist_current")
blacklisted = sql.get_blacklisted_urls(chat.id)
if not blacklisted:
message.reply_text(tld(chat.id, "url_blacklist_no_existed"))
return
for domain in blacklisted:
base_string += "- <code>{}</code>\n".format(domain)
message.reply_text(base_string, parse_mode=ParseMode.HTML)
URL_BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
add_blacklist_url,
filters=Filters.group,
pass_args=True,
admin_ok=True)
ADD_URL_BLACKLIST_HANDLER = CommandHandler("addurl",
add_blacklist_url,
filters=Filters.group)
RM_BLACKLIST_URL_HANDLER = CommandHandler("delurl",
rm_blacklist_url,
filters=Filters.group)
GET_BLACKLISTED_URLS = CommandHandler("geturl",
get_blacklisted_urls,
filters=Filters.group)
URL_DELETE_HANDLER = MessageHandler(Filters.entity("url"),
except BadRequest as excp:
if excp.message == "Reply message not found":
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
return ""
__help__ = True
BAN_HANDLER = DisableAbleCommandHandler("ban",
ban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
TEMPBAN_HANDLER = DisableAbleCommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
KICK_HANDLER = DisableAbleCommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group,
admin_ok=True)
UNBAN_HANDLER = DisableAbleCommandHandler("unban",
unban,
pass_args=True,
result = []
result.append(' '.join([s for s in data]))
for pos, symbol in enumerate(data[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = data[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
__help__ = "memes_help"
__mod_name__ = "Memes and etc."
COPYPASTA_HANDLER = DisableAbleCommandHandler("cp", copypasta, pass_args=True)
CLAPMOJI_HANDLER = DisableAbleCommandHandler("clap", clapmoji, pass_args=True)
BMOJI_HANDLER = DisableAbleCommandHandler("bify", bmoji, pass_args=True)
MOCK_HANDLER = DisableAbleCommandHandler("mock",
spongemocktext,
pass_args=True)
OWO_HANDLER = DisableAbleCommandHandler("owo", owo, pass_args=True)
STRETCH_HANDLER = DisableAbleCommandHandler("stretch", stretch, pass_args=True)
VAPOR_HANDLER = DisableAbleCommandHandler("vapor", vapor, pass_args=True)
ZALGO_HANDLER = DisableAbleCommandHandler("zalgofy", zalgotext, pass_args=True)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True)
CHINESEMEMES_HANDLER = DisableAbleCommandHandler("dllm",
chinesememes,
pass_args=True)
DEEPFRY_HANDLER = DisableAbleCommandHandler("deepfry",
deepfryer,
disable_web_page_preview=False)
progress_message.delete()
else:
query.answer("You are not allowed to use this.")
__help__ = """
Get information about anime, manga or characters from [MyAnimeList](https://myanimelist.net).
*Available commands:*
- /anime <anime>: returns information about the anime.
- /character <character>: returns information about the character.
- /manga <manga>: returns information about the manga.
- /upcoming: returns a list of new anime in the upcoming seasons.
"""
__mod_name__ = "MyAnimeList"
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
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(UPCOMING_HANDLER)
def __stats__():
return "• <code>{}</code> overall warns, across <code>{}</code> chats.\n" \
"• <code>{}</code> warn filters, across <code>{}</code> chats.".format(sql.num_warns(), sql.num_warn_chats(),
sql.num_warn_filters(), sql.num_warn_filter_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
WARN_HANDLER = DisableAbleCommandHandler("warn",
warn_user,
pass_args=True,
filters=Filters.group,
admin_ok=True)
RESET_WARN_HANDLER = DisableAbleCommandHandler(["resetwarn", "resetwarns"],
reset_warns,
pass_args=True,
filters=Filters.group)
RMWARN_QUERY_HANDLER = CallbackQueryHandler(rmwarn_handler, pattern=r"rm_warn")
SENDRULES_QUERY_HANDLER = CallbackQueryHandler(sendrules_handler,
pattern=r"send_rules")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
pass_args=True,
filters=Filters.group,
admin_ok=True)
ADD_WARN_HANDLER = DisableAbleCommandHandler("addwarn",
send_message(update.effective_message,
tl(update.effective_message,
"Dibisukan untuk *{}*!").format(time_val),
quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
send_message(
update.effective_message,
tl(update.effective_message,
"Yah sial, aku tidak bisa membisukan pengguna itu."))
return ""
__help__ = "mute_help"
__mod_name__ = "Muting"
MUTE_HANDLER = DisableAbleCommandHandler("mute", mute, pass_args=True)
UNMUTE_HANDLER = DisableAbleCommandHandler("unmute", unmute, pass_args=True)
TEMPMUTE_HANDLER = DisableAbleCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
for fx in f_flist:
sql.remove_filter(chat.id, fx)
message.reply_text(tld(chat.id, "cust_filters_cleanup_success").format(x))
def __stats__():
return "• `{}` filters, across `{}` chats.".format(sql.num_filters(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
FILTER_HANDLER = DisableAbleCommandHandler("filter", filters)
STOP_HANDLER = DisableAbleCommandHandler("stop", stop_filter)
STOPALL_HANDLER = DisableAbleCommandHandler("stopall", stop_all_filters)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(STOPALL_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
def __user_info__(user_id, chat_id):
bio = html.escape(sql.get_user_bio(user_id) or "")
me = html.escape(sql.get_user_me_info(user_id) or "")
if bio and me:
return tld(chat_id, "userinfo_what_i_and_other_say").format(me, bio)
elif bio:
return tld(chat_id, "userinfo_what_other_say").format(bio)
elif me:
return tld(chat_id, "userinfo_what_i_say").format(me)
else:
return ""
def __gdpr__(user_id):
sql.clear_user_info(user_id)
sql.clear_user_bio(user_id)
__help__ = True
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, pass_args=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, pass_args=True)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
- /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn",
warn_user,
pass_args=True,
filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
reset_warns,
pass_args=True,
filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
pass_args=True,
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,
edited_updates=True)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
if msg.reply_to_message:
to_translate_text = remove_emoji(msg.reply_to_message.text)
else:
msg.reply_text(tld(chat.id, "translator_no_str"))
return
if not args:
msg.reply_text(tld(chat.id, 'translator_no_args'))
return
translator = Translator()
try:
translated = translator.translate(to_translate_text, dest=lan)
except ValueError as e:
msg.reply_text(tld(chat.id, 'translator_err').format(e))
src_lang = LANGUAGES[f'{translated.src.lower()}'].title()
dest_lang = LANGUAGES[f'{translated.dest.lower()}'].title()
translated_text = translated.text
msg.reply_text(tld(chat.id,
'translator_translated').format(src_lang, dest_lang,
translated_text),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
dispatcher.add_handler(
DisableAbleCommandHandler("tr", do_translate, pass_args=True))
temp = str((c - 273.15)).split(".")
return temp[0]
def sun(unix):
xx = datetime.fromtimestamp(
unix,
tz=ctimezone).strftime("%H:%M").lstrip("0").replace(" 0", " ")
return xx
if city:
info = f"*{cityname}, {fullc_n}*\n"
info += f"`{time}`\n\n"
info += tld(chat_id, "weather_temp") + f"`{celsius(curtemp)}°C\n`"
info += tld(chat_id, "weather_cond") + \
f"`{condmain}, {conddet}` " + f"{icon}\n"
info += tld(chat_id, "weather_hum") + f"`{humidity}%`\n"
info += tld(chat_id, "weather_wind") + f"`{kmph[0]} km/h`\n"
info += tld(chat_id, "weather_sunrise") + f"`{sun(sunrise)}`\n"
info += tld(chat_id, "weather_sunset") + f"`{sun(sunset)}`"
bot.send_message(chat_id=update.effective_chat.id,
text=info,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
__help__ = True
WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather)
dispatcher.add_handler(WEATHER_HANDLER)
__help__ = "exclusive_help"
__mod_name__ = "🚀 Hitsuki Exclusive 🚀"
PING_HANDLER = CommandHandler("ping", ping, filters=Filters.user(OWNER_ID))
GETLINK_HANDLER = CommandHandler("getlink",
getlink,
pass_args=True,
filters=Filters.user(OWNER_ID))
LEAVECHAT_HANDLER = CommandHandler(["leavechat", "leavegroup", "leave"],
leavechat,
pass_args=True,
filters=Filters.user(OWNER_ID))
FORTUNE_HANDLER = DisableAbleCommandHandler("fortune", fortune)
TRANSLATE_HANDLER = DisableAbleCommandHandler("tr", translate)
WIKIPEDIA_HANDLER = DisableAbleCommandHandler("wiki", wiki)
UD_HANDLER = DisableAbleCommandHandler("ud", urbandictionary, pass_args=True)
LOG_HANDLER = CommandHandler("log", log, filters=Filters.user(OWNER_ID))
REACT_HANDLER = DisableAbleCommandHandler("react", react)
RHAPPY_HANDLER = DisableAbleCommandHandler("happy", rhappy)
RANGRY_HANDLER = DisableAbleCommandHandler("angry", rangry)
STATUS_HANDLER = DisableAbleCommandHandler("status", status)
dispatcher.add_handler(STATUS_HANDLER)
dispatcher.add_handler(REACT_HANDLER)
dispatcher.add_handler(RHAPPY_HANDLER)
dispatcher.add_handler(RANGRY_HANDLER)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(GETLINK_HANDLER)
def __stats__():
return "• <code>{}</code> notes, accross <code>{}</code> chats.".format(
sql.num_notes(), sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
REMOVE_ALL_NOTES_HANDLER = CommandHandler("clearall", remove_all_notes)
DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True)
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(REMOVE_ALL_NOTES_HANDLER)
@run_async
def stats(update, context):
update.effective_message.reply_text(
# This text doesn't get translated as it is internal message.
"*Current Stats:*\n" + "\n".join([mod.__stats__() for mod in STATS]),
parse_mode=ParseMode.MARKDOWN)
# /ip is for private use
__help__ = "misc_help"
__mod_name__ = "Misc"
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
PASTE_HANDLER = CommandHandler("paste", paste, pass_args=True)
GET_PASTE_HANDLER = CommandHandler("getpaste",
get_paste_content,
pass_args=True)
PASTE_STATS_HANDLER = CommandHandler("pastestats",
get_paste_stats,
pass_args=True)
ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID))
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)
SUDO_LIST_HANDLER = CommandHandler("sudolist",
repl = temp.format(user1=user1,
user2=user2,
item=item,
hits=hit,
throws=throw,
itemp=itemp,
itemr=itemr)
reply_text(repl, parse_mode=ParseMode.MARKDOWN)
__help__ = True
OWO_HANDLER = DisableAbleCommandHandler("owo",
owo,
admin_ok=True,
pass_args=True)
STRETCH_HANDLER = DisableAbleCommandHandler("stretch", stretch, pass_args=True)
VAPOR_HANDLER = DisableAbleCommandHandler("vapor",
vapor,
pass_args=True,
admin_ok=True)
ZALGO_HANDLER = DisableAbleCommandHandler("zalgofy", zalgotext, pass_args=True)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True)
INSULTS_HANDLER = DisableAbleCommandHandler("insults", insults, admin_ok=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs, admin_ok=True)
SLAP_HANDLER = DisableAbleCommandHandler("slap",
slap,
pass_args=True,
admin_ok=True)
- /insults: reply a random string from an array of replies.
- /slap: slap a user, or get slapped if not a reply.
- /decide: Randomly answers yes/no/maybe.
- /status: Shows some bot information
- /weebify: as a reply to a message, "weebifies" the message.
- /pat: give a headpat :3
- /shg or /shrug: pretty self-explanatory.
- /hug: give a hug and spread the love :)
"""
__mod_name__ = "Misc"
ID_HANDLER = CommandHandler("id", get_id, pass_args=True, admin_ok=True)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID), admin_ok=True)
PING_HANDLER = CommandHandler("ping", ping, admin_ok=True)
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True, admin_ok=True)
INSULTS_HANDLER = DisableAbleCommandHandler("insults", insults, admin_ok=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs, admin_ok=True)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True, admin_ok=True)
INFO_HANDLER = CommandHandler("info", info, pass_args=True, admin_ok=True)
ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID))
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, filters=Filters.private)
STATS_HANDLER = CommandHandler("stats", stats, filters=Filters.user(OWNER_ID))
EXECUTE_HANDLER = CommandHandler("exec", execute, pass_args=True, filters=CustomFilters.sudo_filter)
PASTE_HANDLER = CommandHandler("paste", paste, pass_args=True)
GET_PASTE_HANDLER = CommandHandler("getpaste", get_paste_content, pass_args=True)
PASTE_STATS_HANDLER = CommandHandler("pastestats", get_paste_stats, pass_args=True)
rep += tld(chat.id, "misc_lastfm_pn_loved").format(artist, song)
if image:
rep += f"<a href='{image}'>\u200c</a>"
else:
tracks = res.json().get("recenttracks").get("track")
track_dict = {
tracks[i].get("artist").get("name"): tracks[i].get("name")
for i in range(3)
}
rep = tld(chat.id, "misc_lastfm_np").format(user)
for artist, song in track_dict.items():
rep += tld(chat.id, "misc_lastfm_scrr").format(artist, song)
last_user = requests.get(
f"{base_url}?method=user.getinfo&user={username}&api_key={LASTFM_API_KEY}&format=json"
).json().get("user")
scrobbles = last_user.get("playcount")
rep += tld(chat.id, "misc_lastfm_scr").format(scrobbles)
msg.reply_text(rep, parse_mode=ParseMode.HTML)
__help__ = True
SET_USER_HANDLER = CommandHandler("setuser", set_user, pass_args=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(LASTFM_HANDLER)
else:
update.effective_message.reply_text(tld(chat.id,
"admin_err_wrong_arg"),
parse_mode=ParseMode.MARKDOWN)
else:
status = sql.command_reaction(chat.id)
update.effective_message.reply_text(tld(
chat.id, "admin_reaction_status").format('enabled' if status is
True else 'disabled'),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
PIN_HANDLER = DisableAbleCommandHandler("pin",
pin,
pass_args=True,
filters=Filters.group)
UNPIN_HANDLER = DisableAbleCommandHandler("unpin",
unpin,
filters=Filters.group)
INVITE_HANDLER = CommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, pass_args=True)
REACT_HANDLER = DisableAbleCommandHandler("reaction",
reaction,
pass_args=True,
filters=Filters.group)
return value
except KeyError:
return {"status": False, "value": False}
__help__ = True
NEW_FED_HANDLER = CommandHandler("newfed", new_fed, pass_args=True)
DEL_FED_HANDLER = CommandHandler("delfed", del_fed, pass_args=True)
JOIN_FED_HANDLER = CommandHandler("joinfed", join_fed, pass_args=True)
LEAVE_FED_HANDLER = CommandHandler("leavefed", leave_fed, pass_args=True)
PROMOTE_FED_HANDLER = CommandHandler("fpromote", user_join_fed, pass_args=True)
DEMOTE_FED_HANDLER = CommandHandler("fdemote", user_demote_fed, pass_args=True)
INFO_FED_HANDLER = CommandHandler("fedinfo", fed_info, pass_args=True)
BAN_FED_HANDLER = DisableAbleCommandHandler(["fban", "fedban"],
fed_ban,
pass_args=True)
UN_BAN_FED_HANDLER = CommandHandler("unfban", unfban, pass_args=True)
FED_SET_RULES_HANDLER = CommandHandler("setfrules", set_frules, pass_args=True)
FED_GET_RULES_HANDLER = CommandHandler("frules", get_frules, pass_args=True)
FED_CHAT_HANDLER = CommandHandler("chatfed", fed_chat, pass_args=True)
FED_ADMIN_HANDLER = DisableAbleCommandHandler("fedadmins", fed_admin,
pass_args=True)
FED_CHATLIST_HANDLER = DisableAbleCommandHandler("fedchats", fed_chats,
pass_args=True)
FED_USERBAN_HANDLER = CommandHandler("fbanlist", fed_ban_list,
pass_args=True,
pass_chat_data=True)
FED_IMPORTBAN_HANDLER = CommandHandler("importfbans", fed_import_bans,
pass_chat_data=True)
for char in s:
count = count + 1
if count % 3 == 0:
if len(s) == count:
result = char + result
else:
result = thousand_separator + char + result
else:
result = char + result
return result
__help__ = True
ID_HANDLER = DisableAbleCommandHandler("id",
get_id,
pass_args=True,
admin_ok=True)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
INFO_HANDLER = DisableAbleCommandHandler("info",
info,
pass_args=True,
admin_ok=True)
GITHUB_HANDLER = DisableAbleCommandHandler("git", github, admin_ok=True)
REPO_HANDLER = DisableAbleCommandHandler("repo",
repo,
pass_args=True,
admin_ok=True)
ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID))
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
blacklisted = sql.num_stickers_chat_filters(chat_id)
return tl(user_id, "Ada `{}` daftar hitam stiker.").format(blacklisted)
def __stats__():
return tl(OWNER_ID,
"{} pemicu daftar hitam stiker, di seluruh {} obrolan.").format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__help__ = "blstickers_help"
__mod_name__ = "Sticker Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker",
blackliststicker,
pass_args=True,
admin_ok=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
"addblsticker", add_blackliststicker)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"],
unblackliststicker)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode",
blacklist_mode,
pass_args=True)
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)
