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]
msg = f"*{cityname}, {fullc_n}*\n" msg += f"`Longitude: {longitude}`\n" msg += f"`Latitude: {latitude}`\n\n" msg += f"• **Time:** `{time}`\n" msg += f"• **Temperature:** `{celsius(curtemp)}°C\n`" msg += f"• **Feels like:** `{celsius(feels_like)}°C\n`" msg += f"• **Condition:** `{condmain}, {conddet}` " + f"{icon}\n" msg += f"• **Humidity:** `{humidity}%`\n" msg += f"• **Wind:** `{kmph[0]} km/h`\n" msg += f"• **Sunrise**: `{sun(sunrise)}`\n" msg += f"• **Sunset**: `{sun(sunset)}`" else: msg = "Please specify a city or country" delmsg = message.reply_text( text=msg, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, ) context.dispatcher.run_async(delete, delmsg, 60) WEATHER_HANDLER = CommandHandler(["weather"], weather, run_async=True) dispatcher.add_handler(WEATHER_HANDLER) __command_list__ = ["weather"] __handlers__ = [WEATHER_HANDLER]
"Disambiguated pages found! Adjust your query accordingly.\n<i>{}</i>" .format(e), parse_mode=ParseMode.HTML, ) except PageError as e: update.message.reply_text("<code>{}</code>".format(e), parse_mode=ParseMode.HTML) if res: result = f"<b>{search}</b>\n\n" result += f"<i>{res}</i>\n" result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>""" if len(result) > 4000: with open("result.txt", "w") as f: f.write(f"{result}\n\nUwU OwO OmO UmU") with open("result.txt", "rb") as f: context.bot.send_document( document=f, filename=f.name, reply_to_message_id=update.message.message_id, chat_id=update.effective_chat.id, parse_mode=ParseMode.HTML, ) else: update.message.reply_text(result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True) dispatcher.add_handler(WIKI_HANDLER)
__mod_name__ = "Connection" __help__ = """ Sometimes, you just want to add some notes and filters to a group chat, but you don't want everyone to see; This is where connections come in... This allows you to connect to a chat's database, and add things to it without the commands appearing in chat! For obvious reasons, you need to be an admin to add things; but any member in the group can view your data. • `/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)
query = msg.text[len("/lyrics "):] song = "" if not query: msg.reply_text("You haven't specified which song to look for!") return else: song = Song.find_song(query) if song: if song.lyrics: reply = song.format() else: reply = "Couldn't find any lyrics for that song!" else: reply = "Song not found!" if len(reply) > 4090: with open("lyrics.txt", "w") as f: f.write(f"{reply}\n\n\nOwO UwU OmO") with open("lyrics.txt", "rb") as f: msg.reply_document( document=f, caption= "Message length exceeded max limit! Sending as a text file.", ) else: msg.reply_text(reply) LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, run_async=True) dispatcher.add_handler(LYRICS_HANDLER)
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()
• `/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",
*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))
• `/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, admin_ok=True, run_async=True ) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, run_async=True) UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist, run_async=True) BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, run_async=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.chat_type.groups, del_blacklist, allow_edit=True, 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), ]
`5m` = 5 minutes `6h` = 6 hours `3d` = 3 days `1w` = 1 week """ __mod_name__ = "Anti-Flood" FLOOD_BAN_HANDLER = MessageHandler( Filters.all & ~Filters.status_update & Filters.chat_type.groups, check_flood, run_async=True ) SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, filters=Filters.chat_type.groups, run_async=True) SET_FLOOD_MODE_HANDLER = CommandHandler( "setfloodmode", set_flood_mode, run_async=True ) # , filters=Filters.chat_type.groups) FLOOD_QUERY_HANDLER = CallbackQueryHandler(flood_button, pattern=r"unmute_flooder", run_async=True) FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.chat_type.groups, run_async=True) 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, ]
"(〜 ̄△ ̄)〜", "(「• ω •)「", "( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-", "(*´з`)口゚。゚口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-c(・・ )", "(ノ≧∀≦)ノ ‥…━━━★", "╰( ͡° ͜ʖ ͡° )つ──☆*:・゚", "(∩ᄑ_ᄑ)⊃━☆゚*・。*・:≡( ε:)", ] 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, run_async=True) dispatcher.add_handler(REACT_HANDLER) __command_list__ = ["react"] __handlers__ = [REACT_HANDLER]
sent_msg.edit_text("Restarted.") os.system("restart.bat") os.execv("start.bat", sys.argv) @dev_plus def restart(update: Update, context: CallbackContext): update.effective_message.reply_text( "Starting a new instance and shutting down this one") os.system("restart.bat") os.execv("start.bat", sys.argv) LEAVE_HANDLER = CommandHandler("leave", leave, run_async=True) GITPULL_HANDLER = CommandHandler("gitpull", gitpull, run_async=True) RESTART_HANDLER = CommandHandler("reboot", restart, run_async=True) ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups, run_async=True) dispatcher.add_handler(ALLOWGROUPS_HANDLER) dispatcher.add_handler(LEAVE_HANDLER) dispatcher.add_handler(GITPULL_HANDLER) dispatcher.add_handler(RESTART_HANDLER) __mod_name__ = "Dev" __handlers__ = [ LEAVE_HANDLER, GITPULL_HANDLER, RESTART_HANDLER, ALLOWGROUPS_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 DRAGONS: 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]
LOGGER.warning(update) LOGGER.exception( "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__ = """ *Admins only:* • `/mute <userhandle> <reason>(optional)`*:* silences a user. Can also be used as a reply, muting the replied to user. • `/tmute <userhandle> x(m/h/d) <reason>(optional)`*:* 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__ = "Muting" __handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
*Powered by CoffeeHouse* (https://coffeehouse.intellivoid.net/) from @Intellivoid """ ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat, run_async=True) REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat, run_async=True) CHATBOT_HANDLER = MessageHandler( Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^\/")), chatbot, run_async=True) LIST_CB_CHATS_HANDLER = CommandHandler("listaichats", list_chatbot_chats, filters=CustomFilters.dev_filter, run_async=True) # 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, ]
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, filters=Filters.chat_type.groups, 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)
result = generate_time(query_timezone, ["zoneName", "countryName"]) if not result: send_message.edit_text( f"Timezone info not available for <b>{query}</b>\n" '<b>All Timezones:</b> <a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">List here</a>', parse_mode=ParseMode.HTML, disable_web_page_preview=True, ) return send_message.edit_text(result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) __help__ = """ • `/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) """ TIME_HANDLER = DisableAbleCommandHandler("time", gettime, run_async=True) dispatcher.add_handler(TIME_HANDLER) __mod_name__ = "Time" __command_list__ = ["time"] __handlers__ = [TIME_HANDLER]
) message.reply_text("Well damn, I can't unmute that user.") RBAN_HANDLER = CommandHandler("rban", rban, filters=CustomFilters.sudo_filter, run_async=True) RUNBAN_HANDLER = CommandHandler("runban", runban, filters=CustomFilters.sudo_filter, run_async=True) RKICK_HANDLER = CommandHandler("rpunch", rkick, filters=CustomFilters.sudo_filter, run_async=True) RMUTE_HANDLER = CommandHandler("rmute", rmute, filters=CustomFilters.sudo_filter, run_async=True) RUNMUTE_HANDLER = CommandHandler("runmute", runmute, filters=CustomFilters.sudo_filter, run_async=True) 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)
if query.from_user.id in admin_list: bot.editMessageText("Leaving chats ...", chat_id, message.message_id) chat_count = get_muted_chats(update, context, True) bot.sendMessage(chat_id, f"Left {chat_count} chats.") else: query.answer("You are not allowed to use this.") elif query_type == "db_cleanup": if query.from_user.id in admin_list: bot.editMessageText("Cleaning up DB ...", chat_id, message.message_id) invalid_chat_count = get_invalid_chats(update, context, True) invalid_gban_count = get_invalid_gban(update, context, True) reply = "Cleaned up {} chats and {} gbanned users from db.".format( invalid_chat_count, invalid_gban_count) bot.sendMessage(chat_id, reply) else: query.answer("You are not allowed to use this.") DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup, run_async=True) BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*", run_async=True) dispatcher.add_handler(DB_CLEANUP_HANDLER) dispatcher.add_handler(BUTTON_HANDLER) __mod_name__ = "DB Cleanup" __handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER]
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)
*Overall Information about you:* • `/info`*:* get information about a user. """ SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio, run_async=True) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio) 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) 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(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,
f"&to_currency={new_cur}" f"&apikey={CASH_API_KEY}") response = requests.get(request_url).json() try: current_rate = float(response["Realtime Currency Exchange Rate"] ["5. Exchange Rate"]) except KeyError: update.effective_message.reply_text("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, run_async=True) dispatcher.add_handler(CONVERTER_HANDLER) __command_list__ = ["cash"] __handlers__ = [CONVERTER_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), ]
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)
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), ]
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",
import requests from YukinonBot import dispatcher from YukinonBot.modules.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]
*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
• `/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, 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)
msg = f"*Corona Virus Info*\n\n" msg += f"• Country: `{country}`\n" msg += f"• Confirmed: `{country_data['confirmed']}`\n" msg += f"• Active: `{country_data['active']}`\n" msg += f"• Deaths: `{country_data['deaths']}`\n" msg += f"• Recovered: `{country_data['recovered']}`\n" msg += ( "Last update: " f"`{datetime.utcfromtimestamp(country_data['last_update'] // 1000).strftime('%Y-%m-%d %H:%M:%S')}`\n" ) msg += f"__Data provided by__ [Johns Hopkins University](https://j.mp/2xf6oxF)" else: msg = "Please specify a country" delmsg = message.reply_text( text=msg, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, ) context.dispatcher.run_async(delete, delmsg, 60) covid_handler = CommandHandler(["covid"], covid, run_async=True) dispatcher.add_handler(covid_handler) __command_list__ = ["covid"] __handlers__ = [covid_handler]