"The result of the sed command was too long for \ telegram!" ) elif text: update.effective_message.reply_to_message.reply_text( "<b>Did you mean:</b>\n" + text, parse_mode=ParseMode.HTML ) __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! eg: \\?. """.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)
]]), ) elif e.message == "Internal Server Error: created sticker set not found (500)": msg.reply_text( "Sticker pack successfully created! Get it [here](t.me/addstickers/%s)" % packname, parse_mode=ParseMode.MARKDOWN, ) return if success: msg.reply_text( "Sticker pack successfully created! Get it [here](t.me/addstickers/%s)" % packname, parse_mode=ParseMode.MARKDOWN, ) else: msg.reply_text("Failed to create sticker pack.") STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker) STEAL_HANDLER = DisableAbleCommandHandler("steal", steal, pass_args=True, admin_ok=False) dispatcher.add_handler(STICKERID_HANDLER) dispatcher.add_handler(GETSTICKER_HANDLER) dispatcher.add_handler(STEAL_HANDLER)
# 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 TOTRANSLATE_HANDLER = DisableAbleCommandHandler("tl", totranslate) dispatcher.add_handler(TOTRANSLATE_HANDLER)
cmd = update.message.text.split(" ", maxsplit=1) if len(cmd) == 1: sendMessage("No command provided!", bot, update) return LOGGER.info(cmd) output = shell(cmd[1]) if output[1].decode(): LOGGER.error(f"Shell: {output[1].decode()}") if len(output[0].decode()) > 4000: with open("shell.txt", "w") as f: f.write(f"Output\n-----------\n{output[0].decode()}\n") if output[1]: f.write(f"STDError\n-----------\n{output[1].decode()}\n") with open("shell.txt", "rb") as f: bot.send_document( document=f, filename=f.name, reply_to_message_id=update.message.message_id, chat_id=update.message.chat_id, ) else: if output[1].decode(): sendMessage(f"<code>{output[1].decode()}</code>", bot, update) return else: sendMessage(f"<code>{output[0].decode()}</code>", bot, update) shell_handler = CommandHandler(("sh", "shell"), shellExecute) dispatcher.add_handler(shell_handler)
GBAN_LIST = CommandHandler( "gbanlist", gbanlist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter, ) CHECK_GBAN_HANDLER = CommandHandler( "checkgb", check_gbans, filters=Filters.user(OWNER_ID) ) CLEAN_GBAN_HANDLER = CommandHandler( "cleangb", clear_gbans, filters=Filters.user(OWNER_ID) ) GBAN_STATUS = CommandHandler( "antispam", gbanstat, pass_args=True, filters=Filters.group ) GBAN_STATUS = CommandHandler( "spamshield", gbanstat, pass_args=True, filters=Filters.group ) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) dispatcher.add_handler(CHECK_GBAN_HANDLER) dispatcher.add_handler(CLEAN_GBAN_HANDLER) if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
msg = update.effective_message query = " ".join(args) song = "" if not query: msg.reply_text("You haven't specified which song to look for!") return else: song = Song.find_song(query) if song: if song.lyrics: reply = song.format() else: reply = "Couldn't find any lyrics for that song!" else: reply = "Song not found!" if len(reply) > 4090: with open("lyrics.txt", "w") as f: f.write(f"{reply}\n\n\nOwO UwU OmO") with open("lyrics.txt", "rb") as f: msg.reply_document( document=f, caption="Message length exceeded max limit! Sending as a text file.", ) else: msg.reply_text(reply) LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True) dispatcher.add_handler(LYRICS_HANDLER)
elif me: return "<b>About user:</b>\n{me}" "".format(me=me, bio=bio) else: return "" def __gdpr__(user_id): sql.clear_user_info(user_id) sql.clear_user_bio(user_id) __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 """ __mod_name__ = "Bios and Abouts" 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)
CLASSIC_HANDLER = DisableAbleCommandHandler("classic", classic) KUNI_HANDLER = DisableAbleCommandHandler("kuni", kuni) WAIFU_HANDLER = DisableAbleCommandHandler("waifu", waifu) LEWD_HANDLER = DisableAbleCommandHandler("lewd", lewd) KISS_HANDLER = DisableAbleCommandHandler("kiss", kiss) FEMDOM_HANDLER = DisableAbleCommandHandler("femdom", femdom) CUDDLE_HANDLER = DisableAbleCommandHandler("cuddle", cuddle) EROK_HANDLER = DisableAbleCommandHandler("erok", erok) FOXGIRL_HANDLER = DisableAbleCommandHandler("foxgirl", foxgirl) TITSGIF_HANDLER = DisableAbleCommandHandler("titsgif", titsgif) ERO_HANDLER = DisableAbleCommandHandler("ero", ero) SMUG_HANDLER = DisableAbleCommandHandler("smug", smug) BAKA_HANDLER = DisableAbleCommandHandler("baka", baka) DVA_HANDLER = DisableAbleCommandHandler("dva", dva) dispatcher.add_handler(LEWDKEMO_HANDLER) dispatcher.add_handler(NEKO_HANDLER) dispatcher.add_handler(FEET_HANDLER) dispatcher.add_handler(YURI_HANDLER) dispatcher.add_handler(TRAP_HANDLER) dispatcher.add_handler(FUTANARI_HANDLER) dispatcher.add_handler(HOLOLEWD_HANDLER) dispatcher.add_handler(SOLOGIF_HANDLER) dispatcher.add_handler(CUMGIF_HANDLER) dispatcher.add_handler(EROKEMO_HANDLER) dispatcher.add_handler(LESBIAN_HANDLER) dispatcher.add_handler(WALLPAPER_HANDLER) dispatcher.add_handler(LEWDK_HANDLER) dispatcher.add_handler(NGIF_HANDLER) dispatcher.add_handler(TICKLE_HANDLER) dispatcher.add_handler(LEWD_HANDLER)
def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return "This chat has had it's rules set: `{}`".format( bool(sql.get_rules(chat_id))) __help__ = """ - /rules: get the rules for this chat. *Admin 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)
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 build_lock_message(chat_id) 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)
else: wallpapers = json_rep.get("wallpapers") if not wallpapers: msg.reply_text("No results found!") 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)
except Exception: msg.reply_text( "An exception occured while restoring your data. The process may not be complete. If " "you're having issues with this, message @MarieSupport with your backup file so the " "issue can be debugged. My owners would be happy to help, and every bug " "reported makes me better! Thanks! :)") LOGGER.exception( "Import for chatid %s with name %s failed.", str(chat.id), str(chat.title), ) return # TODO: some of that link logic # NOTE: consider default permissions stuff? msg.reply_text("Backup fully imported. Welcome back! :D") @run_async @user_admin def export_data(bot: Bot, update: Update): msg = update.effective_message # type: Optional[Message] msg.reply_text("") IMPORT_HANDLER = CommandHandler("import", import_data) EXPORT_HANDLER = CommandHandler("export", export_data) dispatcher.add_handler(IMPORT_HANDLER) # dispatcher.add_handler(EXPORT_HANDLER)
return 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)
- /blacklist: View the current blacklisted words. *Admin only:* - /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different \ lines will allow you to add multiple triggers. - /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove \ multiple triggers at once. - /rmblacklist <triggers>: Same as above. """ BLACKLIST_HANDLER = DisableAbleCommandHandler( "blacklist", blacklist, filters=Filters.group, pass_args=True, admin_ok=True ) ADD_BLACKLIST_HANDLER = CommandHandler( "addblacklist", add_blacklist, filters=Filters.group ) UNBLACKLIST_HANDLER = CommandHandler( ["unblacklist", "rmblacklist"], unblacklist, filters=Filters.group ) 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)
filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(WARN_HANDLER) dispatcher.add_handler(UNWARN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_HANDLER) dispatcher.add_handler(RESET_WARN_HANDLER) dispatcher.add_handler(MYWARNS_HANDLER) dispatcher.add_handler(ADD_WARN_HANDLER) dispatcher.add_handler(RM_WARN_HANDLER) dispatcher.add_handler(LIST_WARN_HANDLER) dispatcher.add_handler(WARN_LIMIT_HANDLER) dispatcher.add_handler(WARN_STRENGTH_HANDLER) dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
SBAN_HANDLER = CommandHandler("sban", sban, pass_args=True, filters=Filters.group) TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True, filters=Filters.group) KICK_HANDLER = CommandHandler("kick", kick, pass_args=True, filters=Filters.group) UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True, filters=Filters.group) KICKME_HANDLER = DisableAbleCommandHandler("kickme", kickme, filters=Filters.group) BANME_HANDLER = DisableAbleCommandHandler("banme", banme, filters=Filters.group) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(SBAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(KICK_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(KICKME_HANDLER) dispatcher.add_handler(BANME_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) # add antiflood processor Dispatcher.process_update = process_update 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()
res = "{} is AFK!\nReason: {}".format(fst_name, reason) message.reply_text(res) def __gdpr__(user_id): sql.rm_afk(user_id) __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 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.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION), 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)
msg += f"_{json.get('description', None)}_" if image: try: update.effective_message.reply_photo( photo=image, caption=msg, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(buttons)) except: msg += f" [〽️]({image})" update.effective_message.reply_text( msg, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(buttons)) else: update.effective_message.reply_text( msg, parse_mode=ParseMode.MARKDOWN, reply_markup=InlineKeyboardMarkup(buttons)) AIRING_HANDLER = CommandHandler("airing", airing) ANIME_HANDLER = CommandHandler("anime", anime) CHARACTER_HANDLER = CommandHandler("character", character) MANGA_HANDLER = CommandHandler("manga", manga) dispatcher.add_handler(AIRING_HANDLER) dispatcher.add_handler(ANIME_HANDLER) dispatcher.add_handler(MANGA_HANDLER) dispatcher.add_handler(CHARACTER_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 settings. *Admin only:* - /setflood <int/'no'/'off'>: enables or disables flood control. """ __mod_name__ = "Anti-Flood" FLOOD_BAN_HANDLER = MessageHandler( Filters.all & ~Filters.status_update & Filters.group, check_flood) 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(SET_FLOOD_HANDLER) dispatcher.add_handler(FLOOD_HANDLER)
update.effective_message.delete() return ("<b>{}:</b>" "\n#DEL" "\n<b>Admin:</b> {}" "\nMessage deleted.".format( html.escape(chat.title), mention_html(user.id, user.first_name))) else: update.effective_message.reply_text("Whadya want to delete?") return "" __help__ = """ *Admin 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. """ __mod_name__ = "Purges" DELETE_HANDLER = CommandHandler("del", del_message, filters=Filters.group) PURGE_HANDLER = CommandHandler("purge", purge, filters=Filters.group, pass_args=True) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(PURGE_HANDLER)
@dev_user @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) def error_callback(bot, update, error): try: raise error except (TimedOut, NetworkError): log.debug(error, exc_info=True) except: log.info(error, exc_info=True) __mod_name__ = "Eval" eval_handle = CommandHandler(("e", "ev", "eva", "eval"), evaluate) exec_handle = CommandHandler(("x", "ex", "exe", "exec", "py"), execute) clear_handle = CommandHandler("clearlocals", clear) dispatcher.add_handler(eval_handle) dispatcher.add_handler(exec_handle) dispatcher.add_handler(clear_handle)
def ud(bot: Bot, update: Update): msg = (update.effective_message.reply_to_message if update.message.reply_to_message else update.effective_message) if msg == update.effective_message: text = msg.text[len("/ud "):] # Args should take more precedence. Hence even if it's a reply, it'll query what you typed elif (msg == update.effective_message.reply_to_message and len(update.effective_message.text) > 3): text = update.effective_message.text[len("/ud "):] else: text = msg.text if text == "": update.message.reply_text( "Please enter a query to look up on Urban Dictionary!") else: results = 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 IndexError: reply_text = None if reply_text: update.message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) else: update.message.reply_text("No results found!") ud_handle = DisableAbleCommandHandler("ud", ud) dispatcher.add_handler(ud_handle)
def __stats__(): return "{} users, across {} chats".format(sql.num_users(), sql.num_chats()) def __gdpr__(user_id): sql.del_user(user_id) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = "" # no help string __mod_name__ = "Users" BROADCAST_HANDLER = CommandHandler( "broadcast", broadcast, filters=Filters.user(OWNER_ID) ) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter) DELETE_CHATS_HANDLER = CommandHandler( "cleanchats", rem_chat, filters=Filters.user(OWNER_ID) ) dispatcher.add_handler(USER_HANDLER, USERS_GROUP) dispatcher.add_handler(BROADCAST_HANDLER) dispatcher.add_handler(CHATLIST_HANDLER) dispatcher.add_handler(DELETE_CHATS_HANDLER)
sesh, exp = sql.get_ses(chat_id) except ValueError: pass try: bot.send_chat_action(chat_id, action="typing") rep = api_client.think_thought(sesh, query) sleep(0.3) msg.reply_text(rep, timeout=60) except CFError as e: bot.send_message(OWNER_ID, f"Chatbot error: {e} occurred in {chat_id}!") ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat, filters=CustomFilters.dev_filter) REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat, filters=CustomFilters.dev_filter) CHATBOT_HANDLER = MessageHandler( Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^s\/")), chatbot, ) # 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)
*Admin only:* - /enable <cmd name>: enable that command - /disable <cmd name>: disable that command - /listcmds: list all possible toggleable commands """ DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True, filters=Filters.group) ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True, filters=Filters.group) COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands, filters=Filters.group) TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds, filters=Filters.group) dispatcher.add_handler(DISABLE_HANDLER) dispatcher.add_handler(ENABLE_HANDLER) dispatcher.add_handler(COMMANDS_HANDLER) dispatcher.add_handler(TOGGLE_HANDLER) else: DisableAbleCommandHandler = CommandHandler DisableAbleRegexHandler = RegexHandler
def __stats__(): return "{} notes, across {} 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) def __chat_settings__(chat_id, user_id): notes = sql.get_all_chat_notes(chat_id) return "There are `{}` notes in this chat.".format(len(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)
rep.reply_text("User removed from blacklist!") else: rep.reply_text("User isn't even blacklisted!") 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( "bluser", bl_user, pass_args=True, filters=Filters.user(OWNER_ID) ) UNBL_HANDLER = CommandHandler( "unbluser", unbl_user, pass_args=True, filters=Filters.user(OWNER_ID) ) BLUSERS_HANDLER = CommandHandler("blusers", bl_users, filters=Filters.user(OWNER_ID)) dispatcher.add_handler(BL_HANDLER) dispatcher.add_handler(UNBL_HANDLER) dispatcher.add_handler(BLUSERS_HANDLER)
filters=Filters.group) RESET_GOODBYE = CommandHandler("resetgoodbye", reset_goodbye, filters=Filters.group) WELCOMEMUTE_HANDLER = CommandHandler("welcomemute", welcomemute, 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("wlcmutehelp", 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(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(WELCOME_MUTE_HELP)
message.reply_text("Well damn, I can't mute that user.") return "" __help__ = """ *Admin 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. """ __mod_name__ = "Muting" MUTE_HANDLER = CommandHandler(["stfu", "mute", "gay"], mute, pass_args=True, filters=Filters.group) UNMUTE_HANDLER = CommandHandler(["unmute", "talk"], unmute, pass_args=True, filters=Filters.group) TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute", "tgay"], temp_mute, pass_args=True, filters=Filters.group) dispatcher.add_handler(MUTE_HANDLER) dispatcher.add_handler(UNMUTE_HANDLER) dispatcher.add_handler(TEMPMUTE_HANDLER)