def __user_info__(user_id): 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 INSPECTOR: 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, run_async=True) UNBL_HANDLER = CommandHandler("notice", unbl_user, run_async=True) BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users, run_async=True) 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]
company = result['company'] bio = result['bio'] created_at = result['created_at'] avatar_url = result['avatar_url'] blog = result['blog'] location = result['location'] repositories = result['public_repos'] followers = result['followers'] following = result['following'] caption = f"""**Info Of {name}** **Username:** `{username}` **Bio:** `{bio}` **Profile Link:** [Here]({url}) **Company:** `{company}` **Created On:** `{created_at}` **Repositories:** `{repositories}` **Blog:** `{blog}` **Location:** `{location}` **Followers:** `{followers}` **Following:** `{following}`""" except Exception as e: print(str(e)) pass message.reply_photo(photo=avatar_url, caption=caption, parse_mode=ParseMode.MARKDOWN) GIT_HANDLER = DisableAbleCommandHandler("github", github, run_async=True) dispatcher.add_handler(GIT_HANDLER)
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.group, no_longer_afk, run_async=True) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.chat_type.group, 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) __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! """ __mod_name__ = "AFK" __command_list__ = ["afk"] __handlers__ = [ (AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP),
def list_errors(update: Update, context: CallbackContext): if update.effective_user.id not in DEV_USERS: return e = { k: v for k, v in sorted( errors.items(), key=lambda item: item[1], reverse=True) } msg = "<b>Errors List:</b>\n" for x, value in e.items(): msg += f'• <code>{x}:</code> <b>{value}</b> #{x.identifier}\n' msg += f"{len(errors)} have occurred since startup." if len(msg) > 4096: with open("errors_msg.txt", "w+") as f: f.write(msg) context.bot.send_document( update.effective_chat.id, open("errors_msg.txt", "rb"), caption='Too many errors have occured..', parse_mode="html", ) return update.effective_message.reply_text(msg, parse_mode="html") dispatcher.add_error_handler(error_callback) dispatcher.add_handler(CommandHandler("errors", list_errors))
import requests from Yone import dispatcher from Yone.Plugins.disable import DisableAbleCommandHandler from telegram import ParseMode, Update from telegram.ext import CallbackContext, run_async def ud(update: Update, context: CallbackContext): message = update.effective_message text = message.text[len("/ud ") :] results = requests.get( f"https://api.urbandictionary.com/v0/define?term={text}", ).json() try: reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_' except: reply_text = "No results found." message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) UD_HANDLER = DisableAbleCommandHandler(["ud"], ud, run_async=True) dispatcher.add_handler(UD_HANDLER) __command_list__ = ["ud"] __handlers__ = [UD_HANDLER]
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute", welcomemute, run_async=True) CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice", cleanservice, run_async=True) CLEAN_WELCOME = CommandHandler("cleanwelcome", clean_welcome, run_async=True) WELCOME_HELP = CommandHandler("welcomehelp", welcome_help, run_async=True) WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help, run_async=True) BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button, pattern=r"user_join_", run_async=True) dispatcher.add_handler(NEW_MEM_HANDLER) dispatcher.add_handler(LEFT_MEM_HANDLER) dispatcher.add_handler(WELC_PREF_HANDLER) dispatcher.add_handler(GOODBYE_PREF_HANDLER) dispatcher.add_handler(SET_WELCOME) dispatcher.add_handler(SET_GOODBYE) dispatcher.add_handler(RESET_WELCOME) dispatcher.add_handler(RESET_GOODBYE) dispatcher.add_handler(CLEAN_WELCOME) dispatcher.add_handler(WELCOME_HELP) dispatcher.add_handler(WELCOMEMUTE_HANDLER) dispatcher.add_handler(CLEAN_SERVICE_HANDLER) dispatcher.add_handler(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(WELCOME_MUTE_HELP) __mod_name__ = "Welcome"
filters=Filters.chat_type.groups, run_async=True) SETCHAT_TITLE_HANDLER = CommandHandler("setgtitle", setchat_title, filters=Filters.chat_type.groups, run_async=True) SETSTICKET_HANDLER = CommandHandler("setsticker", set_sticker, filters=Filters.chat_type.groups, run_async=True) SETDESC_HANDLER = CommandHandler("setdescription", set_desc, filters=Filters.chat_type.groups, run_async=True) dispatcher.add_handler(ADMINLIST_HANDLER) dispatcher.add_handler(PIN_HANDLER) dispatcher.add_handler(UNPIN_HANDLER) dispatcher.add_handler(UNPINALL_HANDLER) dispatcher.add_handler(UNPINALL_BTN_HANDLER) dispatcher.add_handler(INVITE_HANDLER) dispatcher.add_handler(PROMOTE_HANDLER) dispatcher.add_handler(FULL_PROMOTE_HANDLER) dispatcher.add_handler(DEMOTE_HANDLER) dispatcher.add_handler(SET_TITLE_HANDLER) dispatcher.add_handler(ADMIN_REFRESH_HANDLER) dispatcher.add_handler(CHAT_PIC_HANDLER) dispatcher.add_handler(DEL_CHAT_PIC_HANDLER) dispatcher.add_handler(SETCHAT_TITLE_HANDLER) dispatcher.add_handler(SETSTICKET_HANDLER) dispatcher.add_handler(SETDESC_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), run_async=True ) dispatcher.add_handler(COMMON_CHATS_HANDLER)
prev_end = 0 for change in changes: start = change.get("From") end = change.get("To") + 1 suggestions = change.get("Suggestions") if suggestions: sugg_str = suggestions[0].get( "Text") # should look at this list more curr_string += msg.text[prev_end:start] + sugg_str prev_end = end curr_string += msg.text[prev_end:] update.effective_message.reply_text(curr_string) else: update.effective_message.reply_text( "Reply to some message to get grammar corrected text!") dispatcher.add_handler( DisableAbleCommandHandler("tts", gtts, pass_args=True, run_async=True)) dispatcher.add_handler( DisableAbleCommandHandler("splcheck", spellcheck, run_async=True)) __help__ = """ ‣ `/tts`: Convert Text in Bot Audio *Usage*: reply to text or write message with command. Example `/tts hello` ‣ `/slpcheck`: Check the right spelling of text """ __mod_name__ = "Speech Text" __command_list__ = ["tts"]
run_async=True) ADD_FSTICKER_HANDLER = DisableAbleCommandHandler(["addfsticker", "afs"], add_fvrtsticker, pass_args=True, run_async=True) REMOVE_FSTICKER_HANDLER = DisableAbleCommandHandler(["removefsticker", "rfs"], remove_fvrtsticker, pass_args=True, run_async=True) MY_FSTICKERS_HANDLER = DisableAbleCommandHandler(["myfsticker", "mfs"], list_fvrtsticker, run_async=True) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker, run_async=True) STICKERS_HANDLER = DisableAbleCommandHandler("stickers", cb_sticker, run_async=True) CBSCALLBACK_HANDLER = CallbackQueryHandler(cbs_callback, pattern='cbs_', run_async=True) dispatcher.add_handler(KANG_HANDLER) dispatcher.add_handler(DEL_HANDLER) dispatcher.add_handler(STICKERID_HANDLER) dispatcher.add_handler(ADD_FSTICKER_HANDLER) dispatcher.add_handler(REMOVE_FSTICKER_HANDLER) dispatcher.add_handler(MY_FSTICKERS_HANDLER) dispatcher.add_handler(GETSTICKER_HANDLER) dispatcher.add_handler(STICKERS_HANDLER) dispatcher.add_handler(CBSCALLBACK_HANDLER)
__help__ = """ ‣ `/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, run_async=True) REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_", run_async=True) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(rm_button, pattern=r"rm_report", run_async=True) dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_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), ]
if "//" in args: source = args.split("//")[0] dest = args.split("//")[1] else: source = trans.detect(to_translate) dest = args except IndexError: source = trans.detect(to_translate) dest = "en" translation = trans(to_translate, sourcelang=source, targetlang=dest) reply = f"<b>Translated from {source} to {dest}</b>:\n" \ f"<code>{translation.text}</code>" message.reply_text(reply, parse_mode=ParseMode.HTML) __help__ = """ You can translate messages on telegram in a simple way ‣ `/tr [List of Language Codes]`:- as reply to a long message. ‣ `/tl [List of Language Codes]`:- as reply to a long message. """ __mod_name__ = "Translator" TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate, run_async=True) dispatcher.add_handler(TRANSLATE_HANDLER) __command_list__ = ["tr", "tl"] __handlers__ = [TRANSLATE_HANDLER]
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, run_async=True) UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist, run_async=True) BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, pass_args=True, run_async=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.chat_type.groups, del_blacklist, run_async=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, ]
def __import_data__(chat_id, data): # set chat rules rules = data.get("info", {}).get("rules", "") sql.set_rules(chat_id, rules) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return f"This chat has had it's rules set: `{bool(sql.get_rules(chat_id))}`" __help__ = """ ‣ `/rules`*:* get the rules for this chat. ‣ `/rules here`*:* get the rules for this chat but send it in the chat. *Admins only:* ‣ `/setrules <your rules here>`*:* set the rules for this chat. ‣ `/clearrules`*:* clear the rules for this chat. """ __mod_name__ = "Rules" GET_RULES_HANDLER = CommandHandler("rules", get_rules, run_async=True) SET_RULES_HANDLER = CommandHandler("setrules", set_rules, run_async=True) RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, run_async=True) dispatcher.add_handler(GET_RULES_HANDLER) dispatcher.add_handler(SET_RULES_HANDLER) dispatcher.add_handler(RESET_RULES_HANDLER)
*Note*: Filters also support markdown formatters like: {first}, {last} etc.. and buttons. Check ‣ `/markdownhelp` to know more! """ __mod_name__ = "Filters" FILTER_HANDLER = CommandHandler("filter", filters, run_async=True) STOP_HANDLER = CommandHandler("stop", stop_filter, run_async=True) 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), ]
filters=Filters.chat_type.groups, run_async=True) 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, ) 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)
*Admins only:* ‣ `/allowconnect <yes/no>`: allow a user to connect to a chat """ CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, pass_args=True, 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, pass_args=True, run_async=True) HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat, run_async=True) 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)
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, run_async=True) SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback, pattern="speedtest_.*", run_async=True) 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]
SANITIZE_HANDLER = DisableAbleCommandHandler("sanitize", sanitize, run_async=True) RUNS_HANDLER = DisableAbleCommandHandler("runs", runs, run_async=True) SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, run_async=True) PAT_HANDLER = DisableAbleCommandHandler("pat", pat, run_async=True) ROLL_HANDLER = DisableAbleCommandHandler("roll", roll, run_async=True) TOSS_HANDLER = DisableAbleCommandHandler("toss", toss, run_async=True) SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug, run_async=True) BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext, run_async=True) RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg, run_async=True) DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide, run_async=True) EIGHTBALL_HANDLER = DisableAbleCommandHandler("8ball", eightball, run_async=True) TABLE_HANDLER = DisableAbleCommandHandler("table", table, run_async=True) SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, run_async=True) WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, run_async=True) 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"
USER_SETTINGS.pop(imported_module.__mod_name__.lower()) 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("YoneRobot.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)
*Admins only:* ‣ `/antispam <on/off/yes/no>`*:* Will toggle our antispam tech or return your current settings. Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \ you and your groups by removing spam flooders as quickly as possible. *Note:* Users can appeal gbans or report spammers at @{SUPPORT_CHAT} """ 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.group, run_async=True) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.chat_type.group, 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))
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("YoneRobot.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)
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.chat_type.groups, log_user, run_async=True) CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups, chat_checker, run_async=True) CHATLIST_HANDLER = CommandHandler("groups", chats, run_async=True) 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__ = "User" __handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER, CHATLIST_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, 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]
def main(): if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str): try: stringz = "My dear Owner , I'm Working Again. Thanks to make me live." dispatcher.bot.sendMessage(f"@{OWNER_ID}", stringz) except Unauthorized: LOGGER.warning( "Bot isnt able to send message to support_chat, go and check!") except BadRequest as e: LOGGER.warning(e.message) start_handler = CommandHandler("start", start, pass_args=True, run_async=True) help_handler = CommandHandler("help", get_help, run_async=True) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*", run_async=True) admin_help_callback_handler = CallbackQueryHandler(admin_help_button, pattern=r"admin_.*", run_async=True) user_help_callback_handler = CallbackQueryHandler(user_help_button, pattern=r"user_.*", run_async=True) tools_help_callback_handler = CallbackQueryHandler(tools_help_button, pattern=r"tools_.*", run_async=True) about_callback_handler = CallbackQueryHandler(yone_about_callback, pattern=r"yone_", run_async=True) settings_handler = CommandHandler("settings", get_settings, run_async=True) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_", run_async=True) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats, run_async=True) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(about_callback_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(admin_help_callback_handler) dispatcher.add_handler(user_help_callback_handler) dispatcher.add_handler(tools_help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) 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(allowed_updates=Update.ALL_TYPES, 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()
await event.respond(text, parse_mode="markdown") __help__ = """ *Admins only:* ‣ `/del`*:* deletes the message you replied to ‣ `/purge`*:* deletes all messages between this and the replied to message. ‣ `/purge <number>`*:* if replied to with a number, deletes that many messages from target message, if sent normally in group then delete from current to previous messages ‣ `/purgefrom`*:* marks a start point to purge from ‣ `/purgeto`*:* marks the end point, messages bet to and from are deleted """ #Telethon CMDs PURGE_HANDLER = purge_messages, events.NewMessage(pattern=r"^[!/]purge(?!\S+)") PURGETO_HANDLER = purgeto_messages, events.NewMessage(pattern="^[!/]purgeto$") DEL_HANDLER = delete_messages, events.NewMessage(pattern="^[!/]del$") #PTB CMDs PURGEFROM_HANDLER = CommandHandler("purgefrom", purgefrom, filters=Filters.chat_type.group, run_async=True) dispatcher.add_handler(PURGEFROM_HANDLER) telethn.add_event_handler(*PURGE_HANDLER) telethn.add_event_handler(*PURGETO_HANDLER) telethn.add_event_handler(*DEL_HANDLER) __mod_name__ = "Purges" __command_list__ = ["del", "purge", "purgefrom", "purgeto"] __handlers__ = [PURGE_HANDLER, DEL_HANDLER]
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio, run_async=True) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, run_async=True) STATS_HANDLER = CommandHandler("stats", stats, run_async=True) 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) GINFO_HANDLER = DisableAbleCommandHandler("ginfo", group_info, 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(GINFO_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) __help__ = """ *ID:* ‣ `/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. *Self addded information:*
"ERROR muting user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message, ) message.reply_text("Well damn, I can't mute that user.") return "" # Help moved to admins __help__ = """ *Admins only:* ‣ `/mute <userhandle>`*:* silences a user. Can also be used as a reply, muting the replied to user. ‣ `/tmute <userhandle> x(m/h/d)`*:* mutes a user for x time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`. ‣ `/unmute <userhandle>`*:* unmutes a user. Can also be used as a reply, muting the replied to user. """ MUTE_HANDLER = CommandHandler("mute", mute, run_async=True) UNMUTE_HANDLER = CommandHandler("unmute", unmute, run_async=True) TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute, run_async=True) dispatcher.add_handler(MUTE_HANDLER) dispatcher.add_handler(UNMUTE_HANDLER) dispatcher.add_handler(TEMPMUTE_HANDLER) __mod_name__ = "Mute" __handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
*Admins only:* ‣ `/mute <userhandle>`*:* silences a user. Can also be used as a reply, muting the replied to user. ‣ `/tmute <userhandle> x(m/h/d)`*:* mutes a user for x time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`. ‣ `/unmute <userhandle>`*:* unmutes a user. Can also be used as a reply, muting the replied to user. """ BAN_HANDLER = CommandHandler(["ban", "sban"], ban, run_async=True) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"un_ban", run_async=True) TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban, run_async=True) PUNCH_HANDLER = CommandHandler(["punch", "kick"], punch, run_async=True) UNBAN_HANDLER = CommandHandler("unban", unban, run_async=True) ROAR_HANDLER = CommandHandler("roar", selfunban, run_async=True) PUNCHME_HANDLER = DisableAbleCommandHandler("punchme", punchme, filters=Filters.chat_type.groups, run_async=True) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_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__ = "Ban" __handlers__ = [ BAN_HANDLER, TEMPBAN_HANDLER, PUNCH_HANDLER, UNBAN_HANDLER, ROAR_HANDLER, PUNCHME_HANDLER,
GET_HANDLER = CommandHandler("get", cmd_get, run_async=True) HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get, run_async=True) SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"), slash_get, run_async=True) SAVE_HANDLER = CommandHandler("save", save, run_async=True) DELETE_HANDLER = CommandHandler("clear", clear, run_async=True) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True, run_async=True) CLEARALL = DisableAbleCommandHandler("removeallnotes", clearall, run_async=True) CLEARALL_BTN = CallbackQueryHandler(clearall_btn, pattern=r"notes_.*", run_async=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) dispatcher.add_handler(SLASH_GET_HANDLER) dispatcher.add_handler(CLEARALL) dispatcher.add_handler(CLEARALL_BTN)