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\n" "Example: `/tr en ml` to translate from English to Malayalam\n" "Or use: `/tr ml` for automatic detection and translating it into Malayalam.\n" "See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.", parse_mode="markdown", disable_web_page_preview=True) except ValueError: update.effective_message.reply_text( "The intended language is not found!") else: return __help__ = """ • `/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. """ TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate) dispatcher.add_handler(TRANSLATE_HANDLER) __mod_name__ = "Translator" __command_list__ = ["tr", "tl"] __handlers__ = [TRANSLATE_HANDLER]
def main(): test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) help_handler = CommandHandler("help", get_help) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") donate_handler = CommandHandler("donate", donate) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) dispatcher.add_handler(donate_handler) dispatcher.add_error_handler(error_callback) if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="127.0.0.1", port=PORT, url_path=TOKEN) if CERT_PATH: updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, 'rb'))
text = f"<b>Common chats with {name}</b>\n" for chat in common_list: try: chat_name = bot.get_chat(chat).title sleep(0.3) text += f"• <code>{chat_name}</code>\n" except BadRequest: pass except Unauthorized: pass except RetryAfter as e: sleep(e.retry_after) if len(text) < 4096: msg.reply_text(text, parse_mode="HTML") else: with open("common_chats.txt", 'w') as f: f.write(text) with open("common_chats.txt", 'rb') as f: msg.reply_document(f) os.remove("common_chats.txt") COMMON_CHATS_HANDLER = CommandHandler( "getchats", get_user_common_chats, filters=Filters.user(OWNER_ID), pass_args=True ) dispatcher.add_handler(COMMON_CHATS_HANDLER)
print(e) if e.message == "Sticker set name is already occupied": msg.reply_text(f"Your pack can be found [here](t.me/addstickers/{packname})", parse_mode=ParseMode.MARKDOWN) elif e.message == "Peer_id_invalid": msg.reply_text("Contact me in PM first.", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton( text="Start", url=f"t.me/{bot.username}")]])) return if success: msg.reply_text(f"Sticker pack successfully created. Get it [here](t.me/addstickers/{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. """ __mod_name__ = "Stickers" STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker) KANG_HANDLER = DisableAbleCommandHandler("kang", kang, pass_args=True, admin_ok=True) dispatcher.add_handler(STICKERID_HANDLER) dispatcher.add_handler(GETSTICKER_HANDLER) dispatcher.add_handler(KANG_HANDLER)
"(*´з`)口゚。゚口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-c(・・ )", "(ノ≧∀≦)ノ ‥…━━━★", "╰( ͡° ͜ʖ ͡° )つ──☆*:・゚", "(∩ᄑ_ᄑ)⊃━☆゚*・。*・:≡( ε:)" ] @run_async def react(bot: Bot, update: Update): 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) __help__ = """ • `/react`*:* Reacts with a random reaction """ REACT_HANDLER = DisableAbleCommandHandler("react", react) dispatcher.add_handler(REACT_HANDLER) __mod_name__ = "React" __command_list__ = ["react"] __handlers__ = [REACT_HANDLER]
if can_delete(chat, bot.id): update.effective_message.reply_to_message.delete() update.effective_message.delete() return (f"<b>{html.escape(chat.title)}:</b>\n" f"#DEL\n" f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"Message deleted.") else: update.effective_message.reply_text("Whadya want to delete?") return "" __help__ = """ *Admins only:* • `/del`*:* deletes the message you replied to • `/purge`*:* deletes all messages between this and the replied to message. • `/purge <integer X>`*:* deletes the replied message, and X messages following it if replied to a message. • `/purge <integer X>`*:* deletes the number of messages starting from bottom. (Counts manaully deleted messages too) """ DELETE_HANDLER = DisableAbleCommandHandler("del", del_message, filters=Filters.group) PURGE_HANDLER = DisableAbleCommandHandler("purge", purge, filters=Filters.group, pass_args=True) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(PURGE_HANDLER) __mod_name__ = "Purges" __command_list__ = ["del", "purge"] __handlers__ = [DELETE_HANDLER, PURGE_HANDLER]
@run_async def pingall(bot: Bot, update: Update): 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) __help__ = """ • `/ping`*:* get ping time of bot to telegram server • `/pingall`*:* get all listed ping time """ PING_HANDLER = DisableAbleCommandHandler("ping", ping) PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall) dispatcher.add_handler(PING_HANDLER) dispatcher.add_handler(PINGALL_HANDLER) __mod_name__ = "Ping" __command_list__ = ["ping", "pingall"] __handlers__ = [PING_HANDLER, PINGALL_HANDLER]
stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) stdout, stderr = process.communicate() reply = '' stderr = stderr.decode() stdout = stdout.decode() if stdout: reply += f"*Stdout*\n`{stdout}`\n" LOGGER.info(f"Shell - {cmd} - {stdout}") if stderr: reply += f"*Stderr*\n`{stderr}`\n" LOGGER.error(f"Shell - {cmd} - {stderr}") if len(reply) > 3000: with open('shell_output.txt', 'w') as file: file.write(reply) with open('shell_output.txt', 'rb') as doc: bot.send_document(document=doc, filename=f.name, reply_to_message_id=message.message_id, chat_id=message.chat_id) else: message.reply_text(reply, parse_mode=ParseMode.MARKDOWN) SHELL_HANDLER = CommandHandler(['sh', 'shell', 'term', 'terminal'], shell) dispatcher.add_handler(SHELL_HANDLER) __mod_name__ = "Shell" __command_list__ = ['sh', 'shell', 'term', 'terminal'] __handlers__ = [SHELL_HANDLER]
return res = "{} is afk".format(fst_name) update.effective_message.reply_text(res) else: if int(userc_id) == int(user_id): return res = "{} is afk.\nReason: {}".format(fst_name, user.reason) update.effective_message.reply_text(res) __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 = 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) __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)]
• `/id`*:* get the current group id. If used by replying to a message, gets that user's id. • `/gifid`*:* reply to a gif to me to tell you its file ID. • `/info`*:* get information about a user. • `/markdownhelp`*:* quick summary of how markdown works in telegram - can only be called in private chats. """ ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True) GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid) INFO_HANDLER = DisableAbleCommandHandler(["info", "appraise", "appraisal"], info, pass_args=True) ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, filters=Filters.private) STATS_HANDLER = CommandHandler("stats", stats) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(GIFID_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) dispatcher.add_handler(STATS_HANDLER) __mod_name__ = "Misc" __command_list__ = ["id", "info", "echo"] __handlers__ = [ ID_HANDLER, GIFID_HANDLER, INFO_HANDLER, ECHO_HANDLER, MD_HELP_HANDLER, STATS_HANDLER ]
if excp.message == "Reply message not found": # Do not reply message.reply_text(f"Muted for {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) message.reply_text("Well damn, I can't mute that user.") return "" __help__ = """ *Admins only:* • `/mute <userhandle>`*:* silences a user. Can also be used as a reply, muting the replied to user. • `/tmute <userhandle> x(m/h/d)`*:* mutes a user for x time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`. • `/unmute <userhandle>`*:* unmutes a user. Can also be used as a reply, muting the replied to user. """ MUTE_HANDLER = CommandHandler("mute", mute, pass_args=True) UNMUTE_HANDLER = CommandHandler("unmute", unmute, pass_args=True) TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute, pass_args=True) dispatcher.add_handler(MUTE_HANDLER) dispatcher.add_handler(UNMUTE_HANDLER) dispatcher.add_handler(TEMPMUTE_HANDLER) __mod_name__ = "Muting" __handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
• `/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__ = "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) dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
pass __help__ = """ • `/addrss <link>`*:* add an RSS link to the subscriptions. • `/removerss <link>`*:* removes the RSS link from the subscriptions. • `/rss <link>`*:* shows the link's data and the last entry, for testing purposes. • `/listrss`*:* shows the list of rss feeds that the chat is currently subscribed to. *NOTE:* In groups, only admins can add/remove RSS links to the group's subscription """ __mod_name__ = "RSS Feed" job = updater.job_queue job_rss_set = job.run_once(rss_set, 5) job_rss_update = job.run_repeating(rss_update, interval=60, first=60) job_rss_set.enabled = True job_rss_update.enabled = True SHOW_URL_HANDLER = CommandHandler("rss", show_url, pass_args=True) ADD_URL_HANDLER = CommandHandler("addrss", add_url, pass_args=True) REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url, pass_args=True) LIST_URLS_HANDLER = CommandHandler("listrss", list_urls) dispatcher.add_handler(SHOW_URL_HANDLER) dispatcher.add_handler(ADD_URL_HANDLER) dispatcher.add_handler(REMOVE_URL_HANDLER) dispatcher.add_handler(LIST_URLS_HANDLER)
return f"<b>About user:</b>\n{me}\n<b>What others say:</b>\n{bio}" elif bio: return f"<b>What others say:</b>\n{bio}\n" elif me: return f"<b>About user:</b>\n{me}" else: return "" __help__ = """ • `/setbio <text>`*:* while replying, will save another user's bio • `/bio`*:* will get your or another user's bio. This cannot be set by yourself. • `/setme <text>`*:* will set your info • `/me`*:* will get your or another user's info """ 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) __mod_name__ = "Bios and Abouts" __command_list__ = ["setbio", "bio", "setme", "me"] __handlers__ = [SET_BIO_HANDLER, GET_BIO_HANDLER, SET_ABOUT_HANDLER, GET_ABOUT_HANDLER]
message = update.effective_message 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) __help__ = """ • `/paste`*:* Do a paste at `neko.bin` """ PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, pass_args=True) dispatcher.add_handler(PASTE_HANDLER) __mod_name__ = "Paste" __command_list__ = ["paste"] __handlers__ = [PASTE_HANDLER]
'尸', '㔿', '尺', '丂', '丅', '凵', 'リ', '山', '乂', '丫', '乙' ] @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]
def __chat_settings__(chat_id, user_id): limit = sql.get_flood_limit(chat_id) if limit == 0: return "*Not* currently enforcing flood control." else: return "Antiflood is set to `{}` messages.".format(limit) __help__ = """ • `/flood`*:* Get the current flood control setting *Admins only:* • `/setflood <int/'no'/'off'>`*:* enables or disables flood control *Example:* `/setflood 10` This will mute users if they send more than 10 messages in a row, bots are ignored. """ FLOOD_BAN_HANDLER = MessageHandler(Filters.all & ~Filters.status_update & Filters.group, check_flood) FLOOD_QUERY_HANDLER = CallbackQueryHandler(flood_button, pattern=r"unmute_flooder") SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, pass_args=True, filters=Filters.group) FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group) dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP) dispatcher.add_handler(FLOOD_QUERY_HANDLER) dispatcher.add_handler(SET_FLOOD_HANDLER) dispatcher.add_handler(FLOOD_HANDLER) __mod_name__ = "AntiFlood" __handlers__ = [(FLOOD_BAN_HANDLER, FLOOD_GROUP), SET_FLOOD_HANDLER, FLOOD_HANDLER] dispatcher.add_handler(FLOOD_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) • `/punch <userhandle>`*:* Punches a user out of the group, (via handle, or reply) """ BAN_HANDLER = CommandHandler("ban", ban, pass_args=True) TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True) PUNCH_HANDLER = CommandHandler("punch", punch, pass_args=True) UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True) ROAR_HANDLER = CommandHandler("roar", selfunban, pass_args=True) PUNCHME_HANDLER = DisableAbleCommandHandler("punchme", punchme, filters=Filters.group) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(PUNCH_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(ROAR_HANDLER) dispatcher.add_handler(PUNCHME_HANDLER) __mod_name__ = "Bans" __handlers__ = [ BAN_HANDLER, TEMPBAN_HANDLER, PUNCH_HANDLER, UNBAN_HANDLER, ROAR_HANDLER, PUNCHME_HANDLER ]
update.effective_message.reply_text(message, parse_mode=ParseMode.HTML) def __user_info__(user_id): is_blacklisted = sql.is_user_blacklisted(user_id) text = "Blacklisted: <b>{}</b>" if is_blacklisted: text = text.format("Yes") reason = sql.get_reason(user_id) if reason: text += f"\nReason: <code>{reason}</code>" else: text = text.format("No") return text BL_HANDLER = CommandHandler("ignore", bl_user, pass_args=True) UNBL_HANDLER = CommandHandler("notice", unbl_user, pass_args=True) BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users) dispatcher.add_handler(BL_HANDLER) dispatcher.add_handler(UNBL_HANDLER) dispatcher.add_handler(BLUSERS_HANDLER) __mod_name__ = "Blacklisting Users" __handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
# set chat rules rules = data.get('info', {}).get('rules', "") sql.set_rules(chat_id, rules) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return f"This chat has had it's rules set: `{bool(sql.get_rules(chat_id))}`" __help__ = """ • `/rules`*:* get the rules for this chat. *Admins only:* • `/setrules <your rules here>`*:* set the rules for this chat. • `/clearrules`*:* clear the rules for this chat. """ __mod_name__ = "Rules" GET_RULES_HANDLER = CommandHandler("rules", get_rules, filters=Filters.group) SET_RULES_HANDLER = CommandHandler("setrules", set_rules, filters=Filters.group) RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, filters=Filters.group) dispatcher.add_handler(GET_RULES_HANDLER) dispatcher.add_handler(SET_RULES_HANDLER) dispatcher.add_handler(RESET_RULES_HANDLER)
• `/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 """ ANIME_HANDLER = DisableAbleCommandHandler("anime", anime) 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(USER_HANDLER) dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER) dispatcher.add_handler(KAYO_SEARCH_HANDLER) dispatcher.add_handler(UPCOMING_HANDLER) __mod_name__ = "MyAnimeList" __command_list__ = ["anime", "manga", "character", "user", "upcoming", "kaizoku", "kayo"] __handlers__ = [ANIME_HANDLER, CHARACTER_HANDLER, MANGA_HANDLER, USER_HANDLER, UPCOMING_HANDLER, KAIZOKU_SEARCH_HANDLER, KAYO_SEARCH_HANDLER, BUTTON_HANDLER]
NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members, new_member, pass_job_queue=True) LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member, left_member) WELC_PREF_HANDLER = CommandHandler("welcome", welcome, pass_args=True, filters=Filters.group) GOODBYE_PREF_HANDLER = CommandHandler("goodbye", goodbye, pass_args=True, filters=Filters.group) SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.group) SET_GOODBYE = CommandHandler("setgoodbye", set_goodbye, filters=Filters.group) RESET_WELCOME = CommandHandler("resetwelcome", reset_welcome, filters=Filters.group) RESET_GOODBYE = CommandHandler("resetgoodbye", reset_goodbye, filters=Filters.group) WELCOMEMUTE_HANDLER = CommandHandler("welcomemute", welcomemute, pass_args=True, filters=Filters.group) CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice", cleanservice, pass_args=True, filters=Filters.group) CLEAN_WELCOME = CommandHandler("cleanwelcome", clean_welcome, pass_args=True, filters=Filters.group) WELCOME_HELP = CommandHandler("welcomehelp", welcome_help) WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help) BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button, pattern=r"user_join_") dispatcher.add_handler(NEW_MEM_HANDLER) dispatcher.add_handler(LEFT_MEM_HANDLER) dispatcher.add_handler(WELC_PREF_HANDLER) dispatcher.add_handler(GOODBYE_PREF_HANDLER) dispatcher.add_handler(SET_WELCOME) dispatcher.add_handler(SET_GOODBYE) dispatcher.add_handler(RESET_WELCOME) dispatcher.add_handler(RESET_GOODBYE) dispatcher.add_handler(CLEAN_WELCOME) dispatcher.add_handler(WELCOME_HELP) dispatcher.add_handler(WELCOMEMUTE_HANDLER) dispatcher.add_handler(CLEAN_SERVICE_HANDLER) dispatcher.add_handler(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(WELCOME_MUTE_HELP) __mod_name__ = "Welcomes/Goodbyes"
result = f'{repr(eval(body, env))}' except: pass else: result = f'{value}{func_return}' if result: if len(str(result)) > 2000: result = 'Output is too long' return result @dev_plus @run_async def clear(bot, update): log_input(update) global namespaces if update.message.chat_id in namespaces: del namespaces[update.message.chat_id] send("Cleared locals.", bot, update) eval_handler = CommandHandler(('e', 'ev', 'eva', 'eval'), evaluate) exec_handler = CommandHandler(('x', 'ex', 'exe', 'exec', 'py'), execute) clear_handler = CommandHandler('clearlocals', clear) dispatcher.add_handler(eval_handler) dispatcher.add_handler(exec_handler) dispatcher.add_handler(clear_handler) __mod_name__ = "Eval Module"
from Manager import dispatcher from Manager.modules.disable import DisableAbleCommandHandler @run_async def ud(bot: Bot, update: Update): message = update.effective_message text = message.text[len('/ud '):] results = requests.get( f'http://api.urbandictionary.com/v0/define?term={text}').json() try: reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_' except: reply_text = "No results found." message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) __help__ = """ • `/ud <word>`*:* Type the word or expression you want to search use. • `/urban <word>`*:* Same as `/ud` """ UD_HANDLER = DisableAbleCommandHandler(["ud", "urban"], ud) dispatcher.add_handler(UD_HANDLER) __mod_name__ = "Urban dictionary" __command_list__ = ["ud", "urban"] __handlers__ = [UD_HANDLER]
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate, pass_args=True) ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, pass_args=True) TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, pass_args=True) AREA_HANDLER = DisableAbleCommandHandler("area", area, pass_args=True) COS_HANDLER = DisableAbleCommandHandler("cos", cos, pass_args=True) SIN_HANDLER = DisableAbleCommandHandler("sin", sin, pass_args=True) TAN_HANDLER = DisableAbleCommandHandler("tan", tan, pass_args=True) ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, pass_args=True) ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, pass_args=True) ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, pass_args=True) ABS_HANDLER = DisableAbleCommandHandler("abs", abs, pass_args=True) LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=True) dispatcher.add_handler(SIMPLIFY_HANDLER) dispatcher.add_handler(FACTOR_HANDLER) dispatcher.add_handler(DERIVE_HANDLER) dispatcher.add_handler(INTEGRATE_HANDLER) dispatcher.add_handler(ZEROES_HANDLER) dispatcher.add_handler(TANGENT_HANDLER) dispatcher.add_handler(AREA_HANDLER) dispatcher.add_handler(COS_HANDLER) dispatcher.add_handler(SIN_HANDLER) dispatcher.add_handler(TAN_HANDLER) dispatcher.add_handler(ARCCOS_HANDLER) dispatcher.add_handler(ARCSIN_HANDLER) dispatcher.add_handler(ARCTAN_HANDLER) dispatcher.add_handler(ABS_HANDLER) dispatcher.add_handler(LOG_HANDLER)
EDIT_SLEEP = 2 #edit how many times in 'police' EDIT_TIMES = 3 police_siren = [ "🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵", "🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴" ] @user_admin @run_async def police(bot: Bot, update: Update): msg = update.effective_message.reply_text('Police is coming!') for x in range(EDIT_TIMES): msg.edit_text(police_siren[x % 2]) time.sleep(EDIT_SLEEP) msg.edit_text('Police is here!') __help__ = """ • `/police`*:* Sends a police emoji animation. """ POLICE_HANDLER = DisableAbleCommandHandler("police", police) dispatcher.add_handler(POLICE_HANDLER) __mod_name__ = "Animation" __command_list__ = ["police"] __handlers__ = [POLICE_HANDLER]
__mod_name__ = "Chatbot" __help__ = f""" Chatbot utilizes the CoffeeHouse API and allows Saitama to talk and provides a more interactive group chat experience. *Commands:* *Admins only:* • `/addchat`*:* Enables Chatbot mode in the chat. • `/rmchat`*:* Disables Chatbot mode in the chat. *Dragons or higher only:* • `/listaichats`*:* Lists the chats the chatmode is enabled in. Reports bugs at {SUPPORT_CHAT} *Powered by CoffeeHouse* (https://coffeehouse.intellivoid.net/) from @Intellivoid """ ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat) REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat) CHATBOT_HANDLER = MessageHandler(Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^s\/")), chatbot) LIST_CB_CHATS_HANDLER = CommandHandler("listaichats", list_chatbot_chats, filters=CustomFilters.dev_filter) # Filters for ignoring #note messages, !commands and sed. dispatcher.add_handler(ADD_CHAT_HANDLER) dispatcher.add_handler(REMOVE_CHAT_HANDLER) dispatcher.add_handler(CHATBOT_HANDLER) dispatcher.add_handler(LIST_CB_CHATS_HANDLER)
UNSUPPORT_HANDLER = CommandHandler(("removesupport", "removedemon"), removesupport, pass_args=True) UNTIGER_HANDLER = CommandHandler(("removetiger"), removetiger, pass_args=True) UNWHITELIST_HANDLER = CommandHandler(("removewhitelist", "removewolf"), removewhitelist, pass_args=True) WHITELISTLIST_HANDLER = CommandHandler(["whitelistlist", "wolves"], whitelistlist) TIGERLIST_HANDLER = CommandHandler(["tigers"], tigerlist) SUPPORTLIST_HANDLER = CommandHandler(["supportlist", "demons"], supportlist) SUDOLIST_HANDLER = CommandHandler(["sudolist", "dragons"], sudolist) DEVLIST_HANDLER = CommandHandler(["devlist", "heroes"], devlist) dispatcher.add_handler(SUDO_HANDLER) dispatcher.add_handler(SUPPORT_HANDLER) dispatcher.add_handler(TIGER_HANDLER) dispatcher.add_handler(WHITELIST_HANDLER) dispatcher.add_handler(UNSUDO_HANDLER) dispatcher.add_handler(UNSUPPORT_HANDLER) dispatcher.add_handler(UNTIGER_HANDLER) dispatcher.add_handler(UNWHITELIST_HANDLER) dispatcher.add_handler(WHITELISTLIST_HANDLER) dispatcher.add_handler(TIGERLIST_HANDLER) dispatcher.add_handler(SUPPORTLIST_HANDLER) dispatcher.add_handler(SUDOLIST_HANDLER) dispatcher.add_handler(DEVLIST_HANDLER) __mod_name__ = "Disasters"
""" ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"], adminlist) PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group) UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group) INVITE_HANDLER = DisableAbleCommandHandler("invitelink", invite, filters=Filters.group) PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, pass_args=True) DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, pass_args=True) SET_TITLE_HANDLER = CommandHandler("settitle", set_title, pass_args=True) dispatcher.add_handler(ADMINLIST_HANDLER) dispatcher.add_handler(PIN_HANDLER) dispatcher.add_handler(UNPIN_HANDLER) dispatcher.add_handler(INVITE_HANDLER) dispatcher.add_handler(PROMOTE_HANDLER) dispatcher.add_handler(DEMOTE_HANDLER) dispatcher.add_handler(SET_TITLE_HANDLER) __mod_name__ = "Admin" __command_list__ = ["adminlist", "admins", "invitelink", "promote", "demote"] __handlers__ = [ ADMINLIST_HANDLER, PIN_HANDLER, UNPIN_HANDLER, INVITE_HANDLER, PROMOTE_HANDLER, DEMOTE_HANDLER, SET_TITLE_HANDLER ]
__help__ = """ • `/get <notename>`*:* get the note with this notename • `#<notename>`*:* same as /get • `/notes` or `/saved`*:* list all saved notes in this chat If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \ be useful when updating a current note. *Admins only:* • `/save <notename> <notedata>`*:* saves notedata as a note with name notename A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \ `buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check `/markdownhelp` for more info. • `/save <notename>`*:* save the replied message as a note with name notename • `/clear <notename>`*:* clear note with this name *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, pass_args=True) HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get) SAVE_HANDLER = CommandHandler("save", save) 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)