'尸', '㔿', '尺', '丂', '丅', '凵', 'リ', '山', '乂', '丫', '乙' ] @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): return build_curr_disabled(chat_id) DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True) DISABLE_MODULE_HANDLER = CommandHandler("disablemodule", disable_module, pass_args=True) ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True) ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module, pass_args=True) COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands) TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds) dispatcher.add_handler(DISABLE_HANDLER) dispatcher.add_handler(DISABLE_MODULE_HANDLER) dispatcher.add_handler(ENABLE_HANDLER) dispatcher.add_handler(ENABLE_MODULE_HANDLER) dispatcher.add_handler(COMMANDS_HANDLER) dispatcher.add_handler(TOGGLE_HANDLER) __help__ = """ • `/cmds`*:* check the current status of disabled commands *Admins only:* • `/enable <cmd name>`*:* enable that command • `/disable <cmd name>`*:* disable that command • `/enablemodule <module name>`*:* enable all commands in that module • `/disablemodule <module name>`*:* disable all commands in that module • `/listcmds`*:* list all possible toggleable commands
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')) else: updater.bot.set_webhook(url=URL + TOKEN) else: LOGGER.info("Using long polling.") updater.start_polling(timeout=15, read_latency=4, clean=True) updater.idle()
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]
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)
__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)
__help__ = "" __mod_name__ = "Remote Commands" RBAN_HANDLER = CommandHandler("rban", rban, pass_args=True, filters=CustomFilters.sudo_filter) RUNBAN_HANDLER = CommandHandler("runban", runban, pass_args=True, filters=CustomFilters.sudo_filter) RKICK_HANDLER = CommandHandler("rkick", rkick, pass_args=True, filters=CustomFilters.sudo_filter) RMUTE_HANDLER = CommandHandler("rmute", rmute, pass_args=True, filters=CustomFilters.sudo_filter) RUNMUTE_HANDLER = CommandHandler("runmute", runmute, pass_args=True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(RBAN_HANDLER) dispatcher.add_handler(RUNBAN_HANDLER) dispatcher.add_handler(RKICK_HANDLER) dispatcher.add_handler(RMUTE_HANDLER) dispatcher.add_handler(RUNMUTE_HANDLER)
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]
f"&to_currency={new_cur}" f"&apikey={CASH_API_KEY}") response = requests.get(request_url).json() try: current_rate = float(response['Realtime Currency Exchange Rate'] ['5. Exchange Rate']) except KeyError: update.effective_message.reply_text(f"Currency Not Supported.") return new_cur_amount = round(orig_cur_amount * current_rate, 5) update.effective_message.reply_text( f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}") else: update.effective_message.reply_text(__help__) __help__ = """ • `/cash`*:* currency converter *Example syntax:* `/cash 1 USD INR` *Outout:* `1.0 USD = 75.505 INR` """ CONVERTER_HANDLER = CommandHandler('cash', convert) dispatcher.add_handler(CONVERTER_HANDLER) __mod_name__ = "Currency Converter" __command_list__ = ["cash"] __handlers__ = [CONVERTER_HANDLER]
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 ]
if user_id == dispatcher.bot.id: return """I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me.""" num_chats = sql.get_user_num_chats(user_id) return f"""I've seen them in <code>{num_chats}</code> chats in total.""" def __stats__(): return f"{sql.num_users()} users, across {sql.num_chats()} chats" def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = "" # no help string BROADCAST_HANDLER = CommandHandler("broadcast", broadcast) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, chat_checker) CHATLIST_HANDLER = CommandHandler("chatlist", chats) dispatcher.add_handler(USER_HANDLER, USERS_GROUP) dispatcher.add_handler(BROADCAST_HANDLER) dispatcher.add_handler(CHATLIST_HANDLER) dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP) __mod_name__ = "Users" __handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER, CHATLIST_HANDLER]
• `/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 ]
*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, pass_args=True) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True) 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__ = [LOCKTYPES_HANDLER, LOCK_HANDLER, UNLOCK_HANDLER, LOCKED_HANDLER, (LOCKABLE_HANDLER, PERM_GROUP), (RESTRICTION_HANDLER, REST_GROUP)]
"Do you even sed? Apparently not.") return # empty string errors -_- if len(text) >= telegram.MAX_MESSAGE_LENGTH: update.effective_message.reply_text( "The result of the sed command was too long for \ telegram!") elif text: update.effective_message.reply_to_message.reply_text(text) __help__ = """ • `s/<text1>/<text2>(/<flag>)`*:* Reply to a message with this to perform a sed operation on that message, replacing all \ occurrences of 'text1' with 'text2'. Flags are optional, and currently include 'i' for ignore case, 'g' for global, \ or nothing. Delimiters include `/`, `_`, `|`, and `:`. Text grouping is supported. The resulting message cannot be \ larger than {}. *Reminder:* Sed uses some special characters to make matching easier, such as these: `+*.?\\` If you want to use these characters, make sure you escape them! *Example:* \\?. """.format(telegram.MAX_MESSAGE_LENGTH) __mod_name__ = "Sed/Regex" SED_HANDLER = DisableAbleRegexHandler(r's([{}]).*?\1.*'.format( "".join(DELIMITERS)), sed, friendly="sed") dispatcher.add_handler(SED_HANDLER)
bot.editMessageText("Leaving chats ...", chat_id, message.message_id) chat_count = get_muted_chats(bot, update, True) bot.sendMessage(chat_id, f"Left {chat_count} chats.") else: query.answer("You are not allowed to use this.") elif query_type == "db_cleanup": if query.from_user.id in admin_list: bot.editMessageText("Cleaning up DB ...", chat_id, message.message_id) invalid_chat_count = get_invalid_chats(bot, update, True) invalid_gban_count = get_invalid_gban(bot, update, True) reply = "Cleaned up {} chats and {} gbanned users from db.".format( invalid_chat_count, invalid_gban_count) bot.sendMessage(chat_id, reply) else: query.answer("You are not allowed to use this.") DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup) LEAVE_MUTED_CHATS_HANDLER = CommandHandler("leavemutedchats", leave_muted_chats) BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern='db_.*') dispatcher.add_handler(DB_CLEANUP_HANDLER) dispatcher.add_handler(LEAVE_MUTED_CHATS_HANDLER) dispatcher.add_handler(BUTTON_HANDLER) __mod_name__ = "DB Cleanup" __handlers__ = [DB_CLEANUP_HANDLER, LEAVE_MUTED_CHATS_HANDLER, BUTTON_HANDLER]
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/suzukabot) 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]
@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]
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`*:* NOT FOR REGULAR USER. """ __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)
Blue text cleaner removed any made up commands that people send in your chat. • `/cleanblue <on/off/yes/no>`*:* clean commands after sending • `/ignoreblue <word>`*:* prevent auto cleaning of the command • `/unignoreblue <word>`*:* remove prevent auto cleaning of the command • `/listblue`*:* list currently whitelisted commands *Following are Disasters only commands, admins cannot use these:* • `/gignoreblue <word>`*:* globally ignorea bluetext cleaning of saved word across suzukabot. • `/ungignoreblue <word>`*:* remove said command from global cleaning list """ SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue", set_blue_text_must_click, pass_args=True) ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore, pass_args=True) REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue", remove_bluetext_ignore, pass_args=True) ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler("gignoreblue", add_bluetext_ignore_global, pass_args=True) REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler("ungignoreblue", remove_bluetext_ignore_global, pass_args=True) LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list) 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(ADD_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP) __mod_name__ = "Bluetext Cleaning" __handlers__ = [SET_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_HANDLER, REMOVE_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, LIST_CLEAN_BLUE_TEXT_HANDLER, (CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)]
if query.from_user.id in DEV_USERS: msg = update.effective_message.edit_text('Running a speedtest....') speed = speedtest.Speedtest() speed.get_best_server() 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]
sql.num_blacklist_filter_chats()) __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, pass_args=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) __mod_name__ = "Blacklist Word" __handlers__ = [BLACKLIST_HANDLER, ADD_BLACKLIST_HANDLER, UNBLACKLIST_HANDLER, (BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP)]
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)]
• `/connect`*:* connect a chat (Can be done in a group by `/connect` or `/connect <chat id>` in PM) • `/connection`*:* list connected chats • `/disconnect`*:* disconnect from a chat • `/helpconnect`*:* list available commands that can be done remotely *Admins only:* • `/allowconnect <yes/no>`*:* allow a user to connect to a chat """ CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, pass_args=True) CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat) DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat) ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect", allow_connections, pass_args=True) HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat) CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect") dispatcher.add_handler(CONNECT_CHAT_HANDLER) dispatcher.add_handler(CONNECTION_CHAT_HANDLER) dispatcher.add_handler(DISCONNECT_CHAT_HANDLER) dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER) dispatcher.add_handler(HELP_CONNECT_CHAT_HANDLER) dispatcher.add_handler(CONNECT_BTN_HANDLER) __mod_name__ = "Connection" __handlers__ = [ CONNECT_CHAT_HANDLER, CONNECTION_CHAT_HANDLER, DISCONNECT_CHAT_HANDLER, ALLOW_CONNECTIONS_HANDLER, HELP_CONNECT_CHAT_HANDLER, CONNECT_BTN_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"
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, pass_args=True) dispatcher.add_handler(WALLPAPER_HANDLER)
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)
name = bot.get_chat(user).first_name 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)
f"Finding timezone info for <b>{query}</b>", parse_mode=ParseMode.HTML) query_timezone = query.lower() if len(query_timezone) == 2: result = generate_time(query_timezone, ["countryCode"]) else: result = generate_time(query_timezone, ["zoneName", "countryName"]) if not result: send_message.edit_text( f"Timezone info not available for <b>{query}</b>", parse_mode=ParseMode.HTML) return send_message.edit_text(result, parse_mode=ParseMode.HTML) __help__ = """ • `/time <query>`*:* Gives information about a timezone. *Available queries:* Country Code/Country Name/Timezone Name """ TIME_HANDLER = DisableAbleCommandHandler("time", gettime) dispatcher.add_handler(TIME_HANDLER) __mod_name__ = "Time" __command_list__ = ["time"] __handlers__ = [TIME_HANDLER]
• `/bluetext`*:* check urself :V • `/roll`*:* Roll a dice. • `/rlg`*:* Join ears,nose,mouth and create an emo ;-; """ RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True) 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(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(ROLL_HANDLER) dispatcher.add_handler(TOSS_HANDLER) dispatcher.add_handler(SHRUG_HANDLER) dispatcher.add_handler(BLUETEXT_HANDLER) dispatcher.add_handler(RLG_HANDLER) dispatcher.add_handler(DECIDE_HANDLER) dispatcher.add_handler(TABLE_HANDLER) __mod_name__ = "Fun" __command_list__ = ["runs", "slap", "roll", "toss", "shrug", "bluetext", "rlg", "decide", "table"] __handlers__ = [RUNS_HANDLER, SLAP_HANDLER, ROLL_HANDLER, TOSS_HANDLER, SHRUG_HANDLER, BLUETEXT_HANDLER, RLG_HANDLER, DECIDE_HANDLER, TABLE_HANDLER]
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]