__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, run_async=True) AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex(r"^(?i)brb(.*)$"), afk, friendly="afk") NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups, no_longer_afk, run_async=True) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups, reply_afk, run_async=True) 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), ]
deletion(update, context, delmsg) except ValueError: delmsg = update.effective_message.reply_text("The intended language is not found!") deletion(update, context, delmsg) else: return def deletion(update: Update, context: CallbackContext, delmsg): chat = update.effective_chat cleartime = get_clearcmd(chat.id, "tr") if cleartime: context.dispatcher.run_async(delete, delmsg, cleartime.time) __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, run_async=True) dispatcher.add_handler(TRANSLATE_HANDLER) __mod_name__ = "Translator" __command_list__ = ["tr", "tl"] __handlers__ = [TRANSLATE_HANDLER]
def __stats__(): return "• {} blacklist stickers, across {} chats.".format( sql.num_stickers_filters(), sql.num_stickers_filter_chats()) __mod_name__ = "Stickers Blacklist" BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker", blackliststicker, admin_ok=True, run_async=True) ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("addblsticker", add_blackliststicker, run_async=True) UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"], unblackliststicker, run_async=True) BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode, run_async=True) BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.chat_type.groups, del_blackliststicker, run_async=True) 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)
*What is SpamWatch?* SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/f584b643c6f4be0b1de53.jpg) Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group. *Note:* Users can appeal spamwatch bans at @SpamwatchSupport """ GBAN_HANDLER = CommandHandler("gban", gban, run_async=True) UNGBAN_HANDLER = CommandHandler("ungban", ungban, run_async=True) GBAN_LIST = CommandHandler("gbanlist", gbanlist, run_async=True) GBAN_STATUS = CommandHandler("antispam", gbanstat, filters=Filters.chat_type.groups, run_async=True) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.chat_type.groups, enforce_gban, run_async=True) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) __mod_name__ = "Anti-Spam" __handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS] if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP) __handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
text = f.read() with open("updates.txt", "w+") as f: f.write(text + f"\n-{event.from_id} ({event.chat_id}) : {event.text}") else: with open("updates.txt", "w+") as f: f.write( f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}" ) support_chat = os.getenv("SUPPORT_CHAT") @dev_plus def logs(update: Update, context: CallbackContext): user = update.effective_user with open("log.txt", "rb") as f: context.bot.send_document(document=f, filename=f.name, chat_id=user.id) LOG_HANDLER = CommandHandler("logs", logs, run_async=True) dispatcher.add_handler(LOG_HANDLER) DEBUG_HANDLER = CommandHandler("debug", debug, run_async=True) dispatcher.add_handler(DEBUG_HANDLER) __mod_name__ = "Debug" __command_list__ = ["debug"] __handlers__ = [DEBUG_HANDLER]
def get_chat(chat_id, chat_data): # print(chat_data) try: return chat_data[chat_id]["backups"] except KeyError: return {"status": False, "value": False} __mod_name__ = "Backups" __help__ = """ *Only for group owner:* • `/import`: Reply to the backup file for the butler / emilia group to import as much as possible, making transfers very easy! \ Note that files / photos cannot be imported due to telegram restrictions. • `/export`: Export group data, which will be exported are: rules, notes (documents, images, music, video, audio, voice, text, text buttons) \ """ IMPORT_HANDLER = CommandHandler("import", import_data, run_async=True) EXPORT_HANDLER = CommandHandler("export", export_data, pass_chat_data=True, run_async=True) dispatcher.add_handler(IMPORT_HANDLER) dispatcher.add_handler(EXPORT_HANDLER)
def load(update: Update, context: CallbackContext): message = update.effective_message text = message.text.split(" ", 1)[1] load_messasge = message.reply_text( f"Attempting to load module : <b>{text}</b>", parse_mode=ParseMode.HTML) try: imported_module = importlib.import_module("AnnaBot.modules." + text) except: load_messasge.edit_text("Does that module even exist?") return if not hasattr(imported_module, "__mod_name__"): imported_module.__mod_name__ = imported_module.__name__ if imported_module.__mod_name__.lower() not in IMPORTED: IMPORTED[imported_module.__mod_name__.lower()] = imported_module else: load_messasge.edit_text("Module already loaded.") return if "__handlers__" in dir(imported_module): handlers = imported_module.__handlers__ for handler in handlers: if type(handler) != tuple: dispatcher.add_handler(handler) else: handler_name, priority = handler dispatcher.add_handler(handler_name, priority) else: IMPORTED.pop(imported_module.__mod_name__.lower()) load_messasge.edit_text("The module cannot be loaded.") return if hasattr(imported_module, "__help__") and imported_module.__help__: HELPABLE[imported_module.__mod_name__.lower()] = imported_module # Chats to migrate on chat_migrated events if hasattr(imported_module, "__migrate__"): MIGRATEABLE.append(imported_module) if hasattr(imported_module, "__stats__"): STATS.append(imported_module) if hasattr(imported_module, "__gdpr__"): GDPR.append(imported_module) if hasattr(imported_module, "__user_info__"): USER_INFO.append(imported_module) if hasattr(imported_module, "__import_data__"): DATA_IMPORT.append(imported_module) if hasattr(imported_module, "__export_data__"): DATA_EXPORT.append(imported_module) if hasattr(imported_module, "__chat_settings__"): CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module if hasattr(imported_module, "__user_settings__"): USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module load_messasge.edit_text( "Successfully loaded module : <b>{}</b>".format(text), parse_mode=ParseMode.HTML)
Visit @{SUPPORT_CHAT} for more information. """ SUDO_HANDLER = CommandHandler(("addsudo"), addsudo, run_async=True) SUPPORT_HANDLER = CommandHandler(("addsupport"), addsupport, run_async=True) WHITELIST_HANDLER = CommandHandler(("addwhitelist"), addwhitelist, run_async=True) UNSUDO_HANDLER = CommandHandler(("removesudo"), removesudo, run_async=True) UNSUPPORT_HANDLER = CommandHandler(("removesupport"), removesupport, run_async=True) UNWHITELIST_HANDLER = CommandHandler(("removewhitelist"), removewhitelist, run_async=True) WHITELISTLIST_HANDLER = CommandHandler(("whitelistlist"), whitelistlist, run_async=True) SUPPORTLIST_HANDLER = CommandHandler(("supportlist"), supportlist, run_async=True) SUDOLIST_HANDLER = CommandHandler(("sudolist"), sudolist, run_async=True) DEVLIST_HANDLER = CommandHandler(("devlist"), devlist, run_async=True) dispatcher.add_handler(SUDO_HANDLER) dispatcher.add_handler(SUPPORT_HANDLER) dispatcher.add_handler(WHITELIST_HANDLER) dispatcher.add_handler(UNSUDO_HANDLER) dispatcher.add_handler(UNSUPPORT_HANDLER) dispatcher.add_handler(UNWHITELIST_HANDLER) dispatcher.add_handler(WHITELISTLIST_HANDLER) dispatcher.add_handler(SUPPORTLIST_HANDLER) dispatcher.add_handler(SUDOLIST_HANDLER) dispatcher.add_handler(DEVLIST_HANDLER) __mod_name__ = "Super users" __handlers__ = [ SUDO_HANDLER, SUPPORT_HANDLER,
update.effective_message.reply_text("Done! Lockdown value toggled.") @dev_plus def leave(update: Update, context: CallbackContext): bot = context.bot args = context.args if args: chat_id = str(args[0]) try: bot.leave_chat(int(chat_id)) except TelegramError: update.effective_message.reply_text( "Beep boop, I could not leave that group(dunno why tho).") return with suppress(Unauthorized): update.effective_message.reply_text( "Beep boop, I left that soup!.") else: update.effective_message.reply_text("Send a valid chat ID") LEAVE_HANDLER = CommandHandler("leave", leave, run_async=True) ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups, run_async=True) dispatcher.add_handler(ALLOWGROUPS_HANDLER) dispatcher.add_handler(LEAVE_HANDLER) __mod_name__ = "Dev" __handlers__ = [LEAVE_HANDLER, ALLOWGROUPS_HANDLER]
STOP_HANDLER = CommandHandler("stop", stop_filter) RMALLFILTER_HANDLER = CommandHandler("removeallfilters", rmall_filters, filters=Filters.chat_type.groups, run_async=True) RMALLFILTER_CALLBACK = CallbackQueryHandler(rmall_callback, pattern=r"filters_.*", run_async=True) LIST_HANDLER = DisableAbleCommandHandler("filters", list_handlers, admin_ok=True, run_async=True) CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & ~Filters.update.edited_message, reply_filter, run_async=True) dispatcher.add_handler(FILTER_HANDLER) dispatcher.add_handler(STOP_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP) dispatcher.add_handler(RMALLFILTER_HANDLER) dispatcher.add_handler(RMALLFILTER_CALLBACK) __handlers__ = [ FILTER_HANDLER, STOP_HANDLER, LIST_HANDLER, (CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER), ]
if val in ["off", "no", "0", "disable", "false"]: setprivatenotes(chat.id, False) msg = f"Private notes has been disabled in *{chat.title}*" elif val in ["on", "yes", "1", "enable", "true"]: setprivatenotes(chat.id, True) msg = f"Private notes has been enabled in *{chat.title}*" else: msg = "Sorry, wrong value" message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN) def setprivatenotes(chat_id, setting): sql.set_private_notes(chat_id, setting) def getprivatenotes(chat_id): setting = sql.get_private_notes(chat_id) return setting def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) PRIVATENOTES_HANDLER = CommandHandler("privatenotes", privatenotes, run_async=True) dispatcher.add_handler(PRIVATENOTES_HANDLER)
• `/twrp <devicecodename>`: fetches lastest TWRP available for a given device codename\n *MIUI:* • `/miui <devicecodename>`- fetches latest firmware info for a given device codename\n *Phh:* • `/phh`: get lastest phh builds from github\n *Samsung:* • `/checkfw <model> <csc>` - Samsung only - shows the latest firmware info for the given device, taken from samsung servers • `/getfw <model> <csc>` - Samsung only - gets firmware download links from samfrew, sammobile and sfirmwares for the given device """ MAGISK_HANDLER = CommandHandler(["magisk", "root", "su"], magisk, run_async=True) ORANGEFOX_HANDLER = CommandHandler("orangefox", orangefox, run_async=True) TWRP_HANDLER = CommandHandler("twrp", twrp, run_async=True) GETFW_HANDLER = CommandHandler("getfw", getfw, run_async=True) CHECKFW_HANDLER = CommandHandler("checkfw", checkfw, run_async=True) PHH_HANDLER = CommandHandler("phh", phh, run_async=True) MIUI_HANDLER = CommandHandler("miui", miui, run_async=True) dispatcher.add_handler(MAGISK_HANDLER) dispatcher.add_handler(ORANGEFOX_HANDLER) dispatcher.add_handler(TWRP_HANDLER) dispatcher.add_handler(GETFW_HANDLER) dispatcher.add_handler(CHECKFW_HANDLER) dispatcher.add_handler(PHH_HANDLER) dispatcher.add_handler(MIUI_HANDLER) __mod_name__ = "Android" __command_list__ = ["magisk", "root", "su", "orangefox", "twrp", "checkfw", "getfw", "phh", "miui"] __handlers__ = [MAGISK_HANDLER, ORANGEFOX_HANDLER, TWRP_HANDLER, GETFW_HANDLER, CHECKFW_HANDLER, PHH_HANDLER, MIUI_HANDLER]
filters=Filters.chat_type.groups, run_async=True) INVITE_HANDLER = DisableAbleCommandHandler(["invitelink", "link"], invite, run_async=True) PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, run_async=True) DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, run_async=True) SET_TITLE_HANDLER = CommandHandler("title", set_title, run_async=True) ADMIN_REFRESH_HANDLER = CommandHandler("admincache", refresh_admin, filters=Filters.chat_type.groups) 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) dispatcher.add_handler(ADMIN_REFRESH_HANDLER) __mod_name__ = "Admin" __command_list__ = [ "adminlist", "admins", "invitelink", "promote", "demote",
• `/ud <word>`*:* type the word or expression you want to search use\n *Wikipedia:* • `/wiki <query>`*:* wikipedia your query\n *Wallpapers:* • `/wall <query>`*:* get a wallpaper from wall.alphacoders.com\n *Currency converter:* • `/cash`*:* currency converter Example: `/cash 1 USD INR` _OR_ `/cash 1 usd inr` Output: `1.0 USD = 75.505 INR`\n *Timezones:* • `/time <query>`*:* Gives information about a timezone. *Available queries:* Country Code/Country Name/Timezone Name • 🕐 [Timezones list](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) """ ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.chat_type.groups, run_async=True) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, run_async=True) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) __mod_name__ = "Extras" __command_list__ = ["id", "echo", "covid", "weather", "quotly"] __handlers__ = [ ECHO_HANDLER, MD_HELP_HANDLER, ]
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True) GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid, run_async=True) INFO_HANDLER = DisableAbleCommandHandler(("info", "book"), info, run_async=True) GDPR_HANDLER = CommandHandler("gdpr", gdpr, filters=Filters.chat_type.private, run_async=True) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me, run_async=True) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, run_async=True) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(GIFID_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(GDPR_HANDLER) 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__ = "Info" __command_list__ = ["setbio", "bio", "setme", "me", "info", "gprd"] __handlers__ = [ ID_HANDLER, GIFID_HANDLER, INFO_HANDLER,
filename=f.name, reply_to_message_id=update.message.message_id, chat_id=update.effective_chat.id, parse_mode=ParseMode.HTML, ) try: for f in glob.glob("result.txt"): os.remove(f) except Exception: pass else: msg = 'Give me something to get from Wikipedia, like:\n`/wiki Madrid`' delmsg = message.reply_text( text = msg, parse_mode = ParseMode.MARKDOWN, disable_web_page_preview = True, ) cleartime = get_clearcmd(chat.id, "wiki") if cleartime: context.dispatcher.run_async(delete, delmsg, cleartime.time) WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True) dispatcher.add_handler(WIKI_HANDLER)
update.effective_message.reply_text("'backups' directory has been purged!") def term(cmd, info): process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) stdout, stderr = process.communicate() stderr = stderr.decode() stdout = stdout.decode() if stdout: log.info(f"{info} successful!") log.info(f"{stdout}") if stderr: log.error(f"error while running {info}") log.info(f"{stderr}") from AnnaBot import updater as u # run the backup daliy at 1:00 twhen = datetime.datetime.strptime('01:00', '%H:%M').time() j = u.job_queue cronjob = j.run_daily(callback=backup_db, name="database backups", time=twhen) dispatcher.add_handler(CommandHandler("backupdb", backup_now, run_async=True)) dispatcher.add_handler(CommandHandler("stopjobs", stop_jobs, run_async=True)) dispatcher.add_handler(CommandHandler("startjobs", start_jobs, run_async=True)) dispatcher.add_handler( CommandHandler("purgebackups", del_bkp_fldr, run_async=True))
def main(): test_handler = CommandHandler("test", test, run_async=True) start_handler = CommandHandler("start", start, run_async=True) help_handler = CommandHandler("help", get_help, run_async=True) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*", run_async=True) settings_handler = CommandHandler("settings", get_settings, run_async=True) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_", run_async=True) donate_handler = CommandHandler("donate", donate, run_async=True) 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="0.0.0.0", 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, drop_pending_updates=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle()
unload_messasge.edit_text(f"Successfully unloaded module : <b>{text}</b>", parse_mode=ParseMode.HTML) @sudo_plus def listmodules(update: Update, context: CallbackContext): message = update.effective_message module_list = [] for helpable_module in HELPABLE: helpable_module_info = IMPORTED[helpable_module] file_info = IMPORTED[helpable_module_info.__mod_name__.lower()] file_name = file_info.__name__.rsplit("AnnaBot.modules.", 1)[1] mod_name = file_info.__mod_name__ module_list.append(f"- <code>{mod_name} ({file_name})</code>\n") module_list = "Following modules are loaded : \n\n" + "".join(module_list) message.reply_text(module_list, parse_mode=ParseMode.HTML) LOAD_HANDLER = CommandHandler("load", load, run_async=True) UNLOAD_HANDLER = CommandHandler("unload", unload, run_async=True) LISTMODULES_HANDLER = CommandHandler("listmodules", listmodules, run_async=True) dispatcher.add_handler(LOAD_HANDLER) dispatcher.add_handler(UNLOAD_HANDLER) dispatcher.add_handler(LISTMODULES_HANDLER) __mod_name__ = "Modules"
) 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. • `/stickers`*:* Find stickers for given term on combot sticker catalogue """ __mod_name__ = "Stickers" STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid, run_async=True) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker) KANG_HANDLER = DisableAbleCommandHandler("kang", kang, admin_ok=True, run_async=True) STICKERS_HANDLER = DisableAbleCommandHandler("stickers", cb_sticker, run_async=True) dispatcher.add_handler(STICKERS_HANDLER) dispatcher.add_handler(STICKERID_HANDLER) dispatcher.add_handler(GETSTICKER_HANDLER) dispatcher.add_handler(KANG_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, run_async=True) dispatcher.add_handler(COMMON_CHATS_HANDLER)
• `/connect`: Connects to 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 used remotely *Admin only:* • `/allowconnect <yes/no>`: allow a user to connect to a chat """ CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, run_async=True) CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat, run_async=True) DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat, run_async=True) ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect", allow_connections, run_async=True) HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat) CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect", run_async=True) 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)
RESET_WARN_HANDLER = CommandHandler( ["resetwarn", "resetwarns"], reset_warns, filters=Filters.chat_type.groups, run_async=True ) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn") MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, filters=Filters.chat_type.groups, run_async=True) ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.chat_type.groups, run_async=True) RM_WARN_HANDLER = CommandHandler( ["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.chat_type.groups ) LIST_WARN_HANDLER = DisableAbleCommandHandler( ["warnlist", "warnfilters"], list_warn_filters, filters=Filters.chat_type.groups, admin_ok=True, run_async=True ) WARN_FILTER_HANDLER = MessageHandler( CustomFilters.has_text & Filters.chat_type.groups, reply_filter, run_async=True ) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, filters=Filters.chat_type.groups, run_async=True) WARN_STRENGTH_HANDLER = CommandHandler( "strongwarn", set_warn_strength, filters=Filters.chat_type.groups, run_async=True ) dispatcher.add_handler(WARN_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)
eg: Locking urls will auto-delete all messages with urls, locking stickers will restrict all \ non-admin users from sending stickers, etc. Locking bots will stop non-admins from adding bots to the chat. *Note:* • Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name • Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group """ __mod_name__ = "Locks" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes, run_async=True) LOCK_HANDLER = CommandHandler( "lock", lock) # , filters=Filters.chat_type.groups, run_async=True) UNLOCK_HANDLER = CommandHandler( "unlock", unlock, run_async=True) # , filters=Filters.chat_type.groups) LOCKED_HANDLER = CommandHandler( "locks", list_locks) # , filters=Filters.chat_type.groups, run_async=True) 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.chat_type.groups, del_lockables), PERM_GROUP)
lim = 10 imglinks = [] counter = 0 pattern = r"^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$" oboi = re.findall(pattern, decoded, re.I | re.M) for imglink in oboi: counter += 1 imglinks.append(imglink) if counter >= int(lim): break return imglinks def deletion(update: Update, context: CallbackContext, delmsg): chat = update.effective_chat cleartime = get_clearcmd(chat.id, "reverse") if cleartime: context.dispatcher.run_async(delete, delmsg, cleartime.time) REVERSE_HANDLER = DisableAbleCommandHandler( "reverse", reverse, admin_ok=True, run_async=True ) dispatcher.add_handler(REVERSE_HANDLER)
• `/kaizoku <anime>`*:* search an anime on animekaizoku.com • `/kayo <anime>`*:* search an anime on animekayo.com • `/airing <anime>`*:* returns anime airing info. """ ANIME_HANDLER = DisableAbleCommandHandler("anime", anime, run_async=True) AIRING_HANDLER = DisableAbleCommandHandler("airing", airing, run_async=True) CHARACTER_HANDLER = DisableAbleCommandHandler("character", character, run_async=True) MANGA_HANDLER = DisableAbleCommandHandler("manga", manga, run_async=True) USER_HANDLER = DisableAbleCommandHandler("user", user, run_async=True) UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming, run_async=True) KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku, run_async=True) KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo, run_async=True) dispatcher.add_handler(ANIME_HANDLER) dispatcher.add_handler(CHARACTER_HANDLER) dispatcher.add_handler(MANGA_HANDLER) dispatcher.add_handler(AIRING_HANDLER) dispatcher.add_handler(USER_HANDLER) dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER) dispatcher.add_handler(KAYO_SEARCH_HANDLER) dispatcher.add_handler(UPCOMING_HANDLER) __mod_name__ = "Anime" __command_list__ = [ "anime", "manga", "character", "user", "upcoming",
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue", set_blue_text_must_click, run_async=True) ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore, run_async=True) REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue", remove_bluetext_ignore, run_async=True) ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "gignoreblue", add_bluetext_ignore_global, run_async=True ) REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "ungignoreblue", remove_bluetext_ignore_global, run_async=True ) LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list, run_async=True) CLEAN_BLUE_TEXT_HANDLER = MessageHandler( Filters.command & Filters.chat_type.groups, clean_blue_text_must_click, run_async=True ) 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,
*Admin commands:* - `/approval`*:* Check a user's approval status in this chat. - `/approve`*:* Approve of a user. Locks, blacklists, and antiflood won't apply to them anymore. - `/unapprove`*:* Unapprove of a user. They will now be subject to locks, blacklists, and antiflood again. - `/approved`*:* List all approved users. - `/unapproveall`*:* Unapprove *ALL* users in a chat. This cannot be undone. """ APPROVE = DisableAbleCommandHandler("approve", approve, run_async=True) DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, run_async=True) APPROVED = DisableAbleCommandHandler("approved", approved, run_async=True) APPROVAL = DisableAbleCommandHandler("approval", approval, run_async=True) UNAPPROVEALL = DisableAbleCommandHandler("unapproveall", unapproveall, run_async=True) UNAPPROVEALL_BTN = CallbackQueryHandler(unapproveall_btn, pattern=r"unapproveall_.*", run_async=True) dispatcher.add_handler(APPROVE) dispatcher.add_handler(DISAPPROVE) dispatcher.add_handler(APPROVED) dispatcher.add_handler(APPROVAL) dispatcher.add_handler(UNAPPROVEALL) dispatcher.add_handler(UNAPPROVEALL_BTN) __mod_name__ = "Approvals" __command_list__ = ["approve", "unapprove", "approved", "approval"] __handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
msg = "I don't understand what are you trying to do. Check module help for more details" message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = """ *Get module configuration:* • `/clearcmd`: provides all commands that has been set in current group with their deletion time • `/clearcmd list`: list all available commands for this module • `/clearcmd <command>`: get the deletion time for a specific `<command>` *Set module configuration:* • `/clearcmd <command> <time>`: set a deletion `<time>` for a specific `<command>` in current group. All outputs of that command will be deleted in that group after time value in seconds. Time can be set between 5 and 300 seconds *Restore module configuration:* • `/clearcmd restore`: the deletion time set for ALL commands will be removed in current group • `/clearcmd <command> restore`: the deletion time set for a specific `<command>` will be removed in current group """ CLEARCMD_HANDLER = CommandHandler("clearcmd", clearcmd, run_async=True) dispatcher.add_handler(CLEARCMD_HANDLER) __mod_name__ = "Clear Commands" __command_list__ = ["clearcmd"] __handlers__ = [CLEARCMD_HANDLER]
• `/report <reason>`*:* reply to a message to report it to admins. • `@admin`*:* reply to a message to report it to admins. *NOTE:* Neither of these will get triggered if used by admins. *Admins only:* • `/reports <on/off>`*:* change report setting, or view current status. • If done in pm, toggles your status. • If in group, toggles that groups's status. """ SETTING_HANDLER = CommandHandler("reports", report_setting, run_async=True) REPORT_HANDLER = CommandHandler("report", report, filters=Filters.chat_type.groups, run_async=True) ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex(r"(?i)@admin(s)?"), report) REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_") dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER) dispatcher.add_handler(SETTING_HANDLER) dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP) __mod_name__ = "Reporting" __handlers__ = [ (REPORT_HANDLER, REPORT_GROUP), (ADMIN_REPORT_HANDLER, REPORT_GROUP), (SETTING_HANDLER), ]