""" SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue", set_blue_text_must_click) ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore) REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue", remove_bluetext_ignore) ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "gignoreblue", add_bluetext_ignore_global) REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "ungignoreblue", remove_bluetext_ignore_global) 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,
`6h` = 6 hours `3d` = 3 days `1w` = 1 week """ __mod_name__ = "Anti-Flood" FLOOD_BAN_HANDLER = MessageHandler( Filters.all & ~Filters.status_update & Filters.group, check_flood) SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, filters=Filters.group) SET_FLOOD_MODE_HANDLER = CommandHandler( "setfloodmode", set_flood_mode, pass_args=True) # , filters=Filters.group) FLOOD_QUERY_HANDLER = CallbackQueryHandler(flood_button, pattern=r"unmute_flooder") 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(SET_FLOOD_MODE_HANDLER) dispatcher.add_handler(FLOOD_HANDLER) __handlers__ = [ (FLOOD_BAN_HANDLER, FLOOD_GROUP), SET_FLOOD_HANDLER, FLOOD_HANDLER, SET_FLOOD_MODE_HANDLER, ]
FACTOR_HANDLER = DisableAbleCommandHandler("factor", factor) DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive) INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate) ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes) TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent) AREA_HANDLER = DisableAbleCommandHandler("area", area) COS_HANDLER = DisableAbleCommandHandler("cos", cos) SIN_HANDLER = DisableAbleCommandHandler("sin", sin) TAN_HANDLER = DisableAbleCommandHandler("tan", tan) ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos) ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin) ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan) ABS_HANDLER = DisableAbleCommandHandler("abs", abs) LOG_HANDLER = DisableAbleCommandHandler("log", log) 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)
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"^\/")), 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) __mod_name__ = "Chatbot" __command_list__ = ["addchat", "rmchat", "listaichats"] __handlers__ = [ ADD_CHAT_HANDLER, REMOVE_CHAT_HANDLER, CHATBOT_HANDLER, LIST_CB_CHATS_HANDLER, ]
Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately. *NOTE:* Blacklist stickers do not affect the group admin • `/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 Note: • `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message """ __mod_name__ = "Stickers Blacklist" BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker", blackliststicker, admin_ok=True) ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler( "addblsticker", add_blackliststicker) UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"], unblackliststicker) BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode) 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)
RESET_WARN_HANDLER = CommandHandler( ["resetwarn", "resetwarns"], reset_warns, filters=Filters.group ) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn") MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, filters=Filters.group) ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.group) RM_WARN_HANDLER = CommandHandler( ["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group ) LIST_WARN_HANDLER = DisableAbleCommandHandler( ["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True ) WARN_FILTER_HANDLER = MessageHandler( CustomFilters.has_text & Filters.group, reply_filter ) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler( "strongwarn", set_warn_strength, filters=Filters.group ) 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)
) 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: context.bot.send_document( document=doc, filename=doc.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) dispatcher.add_handler(SHELL_HANDLER) __mod_name__ = "Shell" __command_list__ = ["sh"] __handlers__ = [SHELL_HANDLER]
if user_id == dispatcher.bot.id: return """╘══「 Groups count: <code>???</code> 」""" num_chats = sql.get_user_num_chats(user_id) return f"""╘══「 Groups count: <code>{num_chats}</code> 」""" 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( ["broadcastall", "broadcastusers", "broadcastgroups"], broadcast ) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, chat_checker) CHATLIST_HANDLER = CommandHandler("groups", 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]
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]
unload_messasge.edit_text( f"Successfully unloaded module : <b>{text}</b>", parse_mode=ParseMode.HTML ) @run_async @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("Yui_GBot.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) UNLOAD_HANDLER = CommandHandler("unload", unload) LISTMODULES_HANDLER = CommandHandler("listmodules", listmodules) dispatcher.add_handler(LOAD_HANDLER) dispatcher.add_handler(UNLOAD_HANDLER) dispatcher.add_handler(LISTMODULES_HANDLER) __mod_name__ = "Modules"
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("Yui_GBot.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 not isinstance(handler, tuple): dispatcher.add_handler(handler) else: if isinstance(handler[0], collections.Callable): callback, telethon_event = handler telethn.add_event_handler(callback, telethon_event) 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, "__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 )
• `/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. • `/blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>`*:* Action to perform when someone sends blacklisted words. """ BLACKLIST_HANDLER = DisableAbleCommandHandler( "blacklist", blacklist, pass_args=True, admin_ok=True ) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist) UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist) BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, pass_args=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist, allow_edit=True, ) dispatcher.add_handler(BLACKLIST_HANDLER) dispatcher.add_handler(ADD_BLACKLIST_HANDLER) dispatcher.add_handler(UNBLACKLIST_HANDLER) dispatcher.add_handler(BLACKLISTMODE_HANDLER) dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP) __handlers__ = [ BLACKLIST_HANDLER, ADD_BLACKLIST_HANDLER, UNBLACKLIST_HANDLER, BLACKLISTMODE_HANDLER, (BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP), ]
SANITIZE_HANDLER = DisableAbleCommandHandler("sanitize", sanitize) RUNS_HANDLER = DisableAbleCommandHandler("runs", runs) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap) PAT_HANDLER = DisableAbleCommandHandler("pat", pat) 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) EIGHTBALL_HANDLER = DisableAbleCommandHandler("8ball", eightball) TABLE_HANDLER = DisableAbleCommandHandler("table", table) SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout) WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify) dispatcher.add_handler(WEEBIFY_HANDLER) dispatcher.add_handler(SHOUT_HANDLER) dispatcher.add_handler(SANITIZE_HANDLER) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(PAT_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(EIGHTBALL_HANDLER) dispatcher.add_handler(TABLE_HANDLER) __mod_name__ = "Fun"
• `/locks`*:* The current list of locks in this chat. Locks can be used to restrict a group's users. 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) 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)
"(「• ω •)「", "( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-", "(*´з`)口゚。゚口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-c(・・ )", "(ノ≧∀≦)ノ ‥…━━━★", "╰( ͡° ͜ʖ ͡° )つ──☆*:・゚", "(∩ᄑ_ᄑ)⊃━☆゚*・。*・:≡( ε:)", ] @run_async def react(update: Update, context: CallbackContext): 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) REACT_HANDLER = DisableAbleCommandHandler("react", react) dispatcher.add_handler(REACT_HANDLER) __command_list__ = ["react"] __handlers__ = [REACT_HANDLER]
Maybe not enough to make them admin, but you might be ok with locks, blacklists, and antiflood not applying to them. That's what approvals are for - approve of trustworthy users to allow them to send *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) DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove) APPROVED = DisableAbleCommandHandler("approved", approved) APPROVAL = DisableAbleCommandHandler("approval", approval) UNAPPROVEALL = DisableAbleCommandHandler("unapproveall", unapproveall) UNAPPROVEALL_BTN = CallbackQueryHandler(unapproveall_btn, pattern=r"unapproveall_.*") 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]
# 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 = DisableAbleMessageHandler( Filters.regex(r"s([{}]).*?\1.*".format("".join(DELIMITERS))), sed, friendly="sed" ) dispatcher.add_handler(SED_HANDLER)
LOGGER.warning(update) LOGGER.exception( "ERROR unmnuting 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 unmute that user.") RBAN_HANDLER = CommandHandler("rban", rban, filters=CustomFilters.sudo_filter) RUNBAN_HANDLER = CommandHandler("runban", runban, filters=CustomFilters.sudo_filter) RKICK_HANDLER = CommandHandler("rpunch", rkick, filters=CustomFilters.sudo_filter) RMUTE_HANDLER = CommandHandler("rmute", rmute, filters=CustomFilters.sudo_filter) RUNMUTE_HANDLER = CommandHandler("runmute", runmute, 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)
def main(): if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str): try: dispatcher.bot.sendMessage(f"@{SUPPORT_CHAT}", "I am now online!") except Unauthorized: LOGGER.warning( "Bot isnt able to send message to support_chat, go and check!") except BadRequest as e: LOGGER.warning(e.message) test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start) 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="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, clean=True) if len(argv) not in (1, 3, 4): telethn.disconnect() else: telethn.run_until_disconnected() updater.idle()
• `/sban <userhandle>`*:* Silently ban a user. Deletes command, Replied message and doesn't reply. (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", "sban"], ban) TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban) PUNCH_HANDLER = CommandHandler("punch", punch) UNBAN_HANDLER = CommandHandler("unban", unban) ROAR_HANDLER = CommandHandler("roar", selfunban) 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, ]
# print(chat_data) status = value is not False chat_data[chat_id] = {"backups": {"status": status, "value": value}} 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) EXPORT_HANDLER = CommandHandler("export", export_data, pass_chat_data=True) dispatcher.add_handler(IMPORT_HANDLER) dispatcher.add_handler(EXPORT_HANDLER)
is_blacklisted = sql.is_user_blacklisted(user_id) text = "Blacklisted: <b>{}</b>" if user_id in [777000, 1087968824]: return "" if user_id == dispatcher.bot.id: return "" if int(user_id) in SUDO_USERS + OP_USERS + SAFE_USERS: return "" 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) UNBL_HANDLER = CommandHandler("notice", unbl_user) 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]
try: result = f"{repr(eval(body, env))}" except: pass else: result = f"{value}{func_return}" if result: return result @dev_plus @run_async def clear(update: Update, context: CallbackContext): bot = context.bot 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"
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) PASTE_HANDLER = DisableAbleCommandHandler("paste", paste) dispatcher.add_handler(PASTE_HANDLER) __command_list__ = ["paste"] __handlers__ = [PASTE_HANDLER]
"<b>Service uptime:</b> <code>{}</code>".format(telegram_ping, uptime), parse_mode=ParseMode.HTML, ) @run_async @sudo_plus def pingall(update: Update, context: CallbackContext): 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) PING_HANDLER = DisableAbleCommandHandler("ping", ping) PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall) dispatcher.add_handler(PING_HANDLER) dispatcher.add_handler(PINGALL_HANDLER) __command_list__ = ["ping", "pingall"] __handlers__ = [PING_HANDLER, PINGALL_HANDLER]
Reply 3` • `/clear <notename>`*:* clear note with this name • `/removeallnotes`*:* removes all notes from the group *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) HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get) SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"), slash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall) CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*") dispatcher.add_handler(GET_HANDLER) dispatcher.add_handler(SAVE_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(HASH_GET_HANDLER) dispatcher.add_handler(SLASH_GET_HANDLER) dispatcher.add_handler(CLEARALL) dispatcher.add_handler(CLEARALL_BTN)
) 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("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}" ) elif len(args) == 1: update.effective_message.reply_text(__help__, parse_mode=ParseMode.MARKDOWN) else: update.effective_message.reply_text( f"*Invalid Args!!:* Required 3 But Passed {len(args) -1}", parse_mode=ParseMode.MARKDOWN, ) CONVERTER_HANDLER = CommandHandler("cash", convert) dispatcher.add_handler(CONVERTER_HANDLER) __command_list__ = ["cash"] __handlers__ = [CONVERTER_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)) dispatcher.add_handler(COMMON_CHATS_HANDLER)
*What is that health thingy?* Come and see [HP System explained](https://t.me/OnePunchUpdates/192) """ SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio) STATS_HANDLER = CommandHandler("stats", stats) ID_HANDLER = DisableAbleCommandHandler("id", get_id) GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid) INFO_HANDLER = DisableAbleCommandHandler(("info", "book"), info) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(GIFID_HANDLER) dispatcher.add_handler(INFO_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"] __handlers__ = [ ID_HANDLER, GIFID_HANDLER, INFO_HANDLER, SET_BIO_HANDLER,
""" __mod_name__ = "Filters" FILTER_HANDLER = CommandHandler("filter", filters) STOP_HANDLER = CommandHandler("stop", stop_filter) RMALLFILTER_HANDLER = CommandHandler("removeallfilters", rmall_filters, filters=Filters.group) RMALLFILTER_CALLBACK = CallbackQueryHandler(rmall_callback, pattern=r"filters_.*") LIST_HANDLER = DisableAbleCommandHandler("filters", list_handlers, admin_ok=True) CUST_FILTER_HANDLER = MessageHandler( CustomFilters.has_text & ~Filters.update.edited_message, reply_filter) 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), ]