return results def scam(imgspage, lim): """Parse/Scrape the HTML code for the info we want.""" single = opener.open(imgspage).read() decoded = single.decode("utf-8") if int(lim) > 10: lim = 10 imglinks = [] counter = 0 pattern = r"^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$" oboi = re.findall(pattern, decoded, re.I | re.M) for imglink in oboi: counter += 1 imglinks.append(imglink) if counter >= int(lim): break return imglinks REVERSE_HANDLER = DisableAbleCommandHandler("reverse", reverse, pass_args=True) dispatcher.add_handler(REVERSE_HANDLER)
def main(): # test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) help_handler = CommandHandler("help", get_help) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_") gethelp_callback_handler = CallbackQueryHandler(gethelp, pattern=r"gethelp_") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") about_callback_handler = CallbackQueryHandler(ElitesOfRobot_about_callback, pattern=r"aboutmanu_") migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) is_chat_allowed_handler = MessageHandler(Filters.group, is_chat_allowed) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(about_callback_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(gethelp_callback_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(is_chat_allowed_handler) dispatcher.add_error_handler(error_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) client.run_until_disconnected() else: LOGGER.info("Using long polling.") updater.start_polling(timeout=15, read_latency=4) client.run_until_disconnected() updater.idle()
GBAM_HANDLER = CommandHandler("gbam", gbam) TABLE_HANDLER = DisableAbleCommandHandler("table", table) CRI_HANDLER = DisableAbleCommandHandler("cri", cri) PASTA_HANDLER = DisableAbleCommandHandler("pasta", copypasta) CLAP_HANDLER = DisableAbleCommandHandler("clap", clapmoji) OWO_HANDLER = DisableAbleCommandHandler("owo", owo) STRECH_HANDLER = DisableAbleCommandHandler("stretch", stretch) RECITE_HANDLER = DisableAbleCommandHandler("recite", recite) DICE_HANDLER = DisableAbleCommandHandler("roll", dice) YESNOWTF_HANDLER = DisableAbleCommandHandler("decide", yesnowtf) dispatcher.add_handler(PAT_HANDLER) dispatcher.add_handler(SHOUT_HANDLER) dispatcher.add_handler(DARE_HANDLER) dispatcher.add_handler(TRUTH_HANDLER) dispatcher.add_handler(SANITIZE_HANDLER) dispatcher.add_handler(GBAM_HANDLER) dispatcher.add_handler(SHRUG_HANDLER) dispatcher.add_handler(DECIDE_HANDLER) dispatcher.add_handler(ABUSE_HANDLER) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(HUG_HANDLER) dispatcher.add_handler(GBUN_HANDLER) dispatcher.add_handler(TABLE_HANDLER) dispatcher.add_handler(RECITE_HANDLER) dispatcher.add_handler(CRI_HANDLER)
- /removefsticker or /rfs <custom name>: Reply to a sticker to remove it into your favorite pack list. *Example:* `/addfsticker my cool pack` """ __mod_name__ = "Stickers" KANG_HANDLER = DisableAbleCommandHandler(["addsticker", "kang", "steal"], addsticker, pass_args=True) DEL_HANDLER = DisableAbleCommandHandler("delsticker", delsticker) STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid) ADD_FSTICKER_HANDLER = DisableAbleCommandHandler(["addfsticker", "afs"], add_fvrtsticker, pass_args=True) REMOVE_FSTICKER_HANDLER = DisableAbleCommandHandler(["removefsticker", "rfs"], remove_fvrtsticker, pass_args=True) MY_FSTICKERS_HANDLER = DisableAbleCommandHandler(["myfsticker", "mfs"], list_fvrtsticker) GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker) FIND_STICKERS_HANDLER = DisableAbleCommandHandler("findpacks", cb_sticker) 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(FIND_STICKERS_HANDLER)
__help__ = """ We're all busy people who don't have time to monitor our groups 24/7. But how do you \ react if someone in your group is spamming? Presenting reports; if someone in your group thinks someone needs reporting, they now have \ an easy way to call all admins. *Admin only:* - /reports <on/off>: Change report setting, or view current status. • If done in pm, toggles your status. • If in chat, toggles that chat's status. To report a user, simply reply to user's message with @admin or /report. \ This message tags all the chat admins; same as if they had been @'ed. You MUST reply to a message to report a user; you can't just use @admin to tag admins for no reason! Note that the report commands do not work when admins use them; or when used to report an admin. Bot assumes that \ admins don't need to report, or be reported! """ REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group) SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True) ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex("(?i)@admin(s)?"), report) REPORT_BUTTON_HANDLER = CallbackQueryHandler(report_buttons, pattern=r"report_") dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(SETTING_HANDLER) dispatcher.add_handler(REPORT_BUTTON_HANDLER)
PROMOTE_HANDLER = CommandHandler("promote", promote, pass_args=True, filters=Filters.group) DEMOTE_HANDLER = CommandHandler("demote", demote, pass_args=True, filters=Filters.group) SET_TITLE_HANDLER = DisableAbleCommandHandler("settitle", set_title, pass_args=True) ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"], adminlist, filters=Filters.group) dispatcher.add_handler(ADMIN_REFRESH_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(ADMINLIST_HANDLER) dispatcher.add_handler(SET_TITLE_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)
def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): blacklisted = sql.num_stickers_chat_filters(chat_id) return "There are `{} `blacklisted stickers.".format(blacklisted) def __stats__(): return "┣⊸ BL Stickers - {} ( {} )".format( sql.num_stickers_filters(), sql.num_stickers_filter_chats()) 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)
Log channels can help you keep track of exactly what the other admins are doing. \ Bans, Mutes, warns, notes - everything can be moderated. *Admin only:* - /logchannel: Get log channel info - /setlog: Set the log channel. - /unsetlog: Unset the log channel. Setting the log channel is done by: - Add the bot to your channel, as an admin. This is done via the "add administrators" tab. - Send /setlog to your channel. - Forward the /setlog command to the group you wish to be logged. - Congratulations! All is set! """ __mod_name__ = "Logger" LOG_HANDLER = CommandHandler("logchannel", logging) SET_LOG_HANDLER = CommandHandler("setlog", setlog) UNSET_LOG_HANDLER = CommandHandler("unsetlog", unsetlog) dispatcher.add_handler(LOG_HANDLER) dispatcher.add_handler(SET_LOG_HANDLER) dispatcher.add_handler(UNSET_LOG_HANDLER) else: # run anyway if module not loaded def loggable(func): return func
GMUTE_HANDLER = CommandHandler("gmute", gmute, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) UNGMUTE_HANDLER = CommandHandler("ungmute", ungmute, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GMUTE_LIST = CommandHandler("gmutelist", gmutelist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GMUTE_STATUS = CommandHandler("gmutespam", gmutestat, pass_args=True, filters=Filters.group) GMUTE_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gmute) dispatcher.add_handler(GMUTE_HANDLER) dispatcher.add_handler(UNGMUTE_HANDLER) dispatcher.add_handler(GMUTE_LIST) dispatcher.add_handler(GMUTE_STATUS) if STRICT_GMUTE: dispatcher.add_handler(GMUTE_ENFORCER, GMUTE_ENFORCE_GROUP)
json_rep = r.get( f"https://wall.alphacoders.com/api2.0/get.php?auth={WALL_API}&method=search&term={term}" ).json() if not json_rep.get("success"): msg.reply_text(f"An error occurred! Report this @{SUPPORT_CHAT}") else: wallpapers = json_rep.get("wallpapers") if not wallpapers: msg.reply_text("No results found! Refine your search.") return else: index = randint(0, len(wallpapers) - 1) # Choose random index wallpaper = wallpapers[index] wallpaper = wallpaper.get("url_image") wallpaper = wallpaper.replace("\\", "") bot.send_photo(chat_id, photo=wallpaper, caption='Preview', reply_to_message_id=msg_id, timeout=60) bot.send_document(chat_id, document=wallpaper, filename='wallpaper', caption=caption, reply_to_message_id=msg_id, timeout=60) WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall) dispatcher.add_handler(WALLPAPER_HANDLER)
RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(WARN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_HANDLER) dispatcher.add_handler(SENDRULES_QUERY_HANDLER) dispatcher.add_handler(RESET_WARN_HANDLER) dispatcher.add_handler(REMOVE_WARNS_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)
temp = str(round((c - k))) return temp def fahr(c): c1 = 9 / 5 c2 = 459.67 tF = c * c1 - c2 if tF < 0 and tF > -1: tF = 0 temp = str(round(tF)) return temp reply = f"*Current weather for {cityname}, {country_name} is*:\n\n*Temperature:* `{celsius(curtemp)}°C ({fahr(curtemp)}ºF), feels like {celsius(feels_like)}°C ({fahr(feels_like)}ºF) \n`*Condition:* `{condmain}, {conddet}` {icon}\n*Humidity:* `{humidity}%`\n*Wind:* `{kmph[0]} km/h`\n" del_msg = update.effective_message.reply_text( "{}".format(reply), parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) time.sleep(30) try: del_msg.delete() update.effective_message.delete() except BadRequest as err: if (err.message == "Message to delete not found") or ( err.message == "Message can't be deleted"): return WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather, pass_args=True) dispatcher.add_handler(WEATHER_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, pass_args=True) CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat) DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat) ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect", allow_connections, pass_args=True) HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat) CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect") 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)
is_blacklisted = sql.is_user_blacklisted(user_id) text = "<b>Blacklisted : </b>{}" if user_id in [777000, 1087968824]: return "" if user_id == dispatcher.bot.id: return "" if int(user_id) in BLACKLISTWHITELIST: return "This User Is Staff Member \n<i>(They Can Not Be Banned!)</i>" 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__ = "Blacklist_Users" __handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
def __chat_settings__(chat_id, user_id): return "This chat has had it's rules set: `{}`".format( bool(sql.get_rules(chat_id))) __help__ = """ Every chat works with different rules; this module will help make those rules clearer! - /rules: get the rules for this chat. *Admin only:* - /setrules <your rules here>: Sets rules for the chat. - /clearrules: Clears saved rules for the chat. """ __mod_name__ = "Rules" GET_RULES_HANDLER = CommandHandler("rules", get_rules, filters=Filters.group) SET_RULES_HANDLER = CommandHandler("setrules", set_rules, filters=Filters.group) RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, filters=Filters.group) dispatcher.add_handler(GET_RULES_HANDLER) dispatcher.add_handler(SET_RULES_HANDLER) dispatcher.add_handler(RESET_RULES_HANDLER)
text = text.format("No") return text def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): return "This chat is enforcing *gbans*: `{}`.".format( sql.does_chat_gban(chat_id)) GBAN_HANDLER = CommandHandler("gban", gban, pass_args=True) UNGBAN_HANDLER = CommandHandler("ungban", ungban, pass_args=True) GBAN_LIST = CommandHandler("gbanlist", gbanlist) GBAN_STATUS = CommandHandler("antispam", gbanstat, pass_args=True, filters=Filters.group) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
if "i" in flags and "g" in flags: text = re.sub(repl, repl_with, to_fix, flags=re.I).strip() elif "i" in flags: text = re.sub(repl, repl_with, to_fix, count=1, flags=re.I).strip() elif "g" in flags: text = re.sub(repl, repl_with, to_fix).strip() else: text = re.sub(repl, repl_with, to_fix, count=1).strip() except sre_constants.error: LOGGER.warning(update.effective_message.text) LOGGER.exception("SRE constant error") update.effective_message.reply_text("Do you even sed? Apparently not.") return # 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) SED_HANDLER = DisableAbleMessageHandler( Filters.regex(r"s([{}]).*?\1.*".format("".join(DELIMITERS))), sed, friendly="sed" ) dispatcher.add_handler(SED_HANDLER)
__help__ = """ Tagger is an essential feature to mention all subscribed members in the group. Any chat members can subscribe to tagger. - /tagme: registers to the chat tag list. - /untagme: unsubscribes from the chat tag list. *Admin only:* - /tagall: mention all subscribed members. - /untagall: clears all subscribed members. - /addtag <userhandle>: add a user to chat tag list. (via handle, or reply) - /removetag <userhandle>: remove a user to chat tag list. (via handle, or reply) """ TAG_ALL_HANDLER = DisableAbleCommandHandler("tagall", tagall, filters=Filters.group) UNTAG_ALL_HANDLER = DisableAbleCommandHandler("untagall", untagall, filters=Filters.group) UNTAG_ME_HANDLER = CommandHandler("untagme", untagme, filters=Filters.group) TAG_ME_HANDLER = CommandHandler("tagme", tagme, filters=Filters.group) ADD_TAG_HANDLER = DisableAbleCommandHandler("addtag", addtag, pass_args=True, filters=Filters.group) REMOVE_TAG_HANDLER = DisableAbleCommandHandler("removetag", removetag, pass_args=True, filters=Filters.group) TAGALL_CALLBACK_HANDLER = CallbackQueryHandler(tagg_all_button, pattern=r"tagall_") dispatcher.add_handler(TAG_ALL_HANDLER) dispatcher.add_handler(UNTAG_ALL_HANDLER) dispatcher.add_handler(UNTAG_ME_HANDLER) dispatcher.add_handler(TAG_ME_HANDLER) dispatcher.add_handler(ADD_TAG_HANDLER) dispatcher.add_handler(REMOVE_TAG_HANDLER) dispatcher.add_handler(TAGALL_CALLBACK_HANDLER)
__mod_name__ = "Blacklist_URL" URL_BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist", add_blacklist_url, filters=Filters.group, pass_args=True, admin_ok=True) ADD_URL_BLACKLIST_HANDLER = CommandHandler("addurl", add_blacklist_url, filters=Filters.group) RM_BLACKLIST_URL_HANDLER = CommandHandler("delurl", rm_blacklist_url, filters=Filters.group) GET_BLACKLISTED_URLS = CommandHandler("geturl", get_blacklisted_urls, filters=Filters.group) URL_DELETE_HANDLER = MessageHandler(Filters.entity("url"), del_blacklist_url) dispatcher.add_handler(URL_BLACKLIST_HANDLER) dispatcher.add_handler(ADD_URL_BLACKLIST_HANDLER) dispatcher.add_handler(RM_BLACKLIST_URL_HANDLER) dispatcher.add_handler(GET_BLACKLISTED_URLS) dispatcher.add_handler(URL_DELETE_HANDLER) __command_list__ = ["blacklist", "addurl", "delurl", "rmurl", "geturl"] __handlers__ = [ URL_BLACKLIST_HANDLER, ADD_URL_BLACKLIST_HANDLER, RM_BLACKLIST_URL_HANDLER, GET_BLACKLISTED_URLS, URL_DELETE_HANDLER ]
promoting your profile. All bios are displayed on /info command. - /setbio <text>: While replying, will save another user's bio - /bio: Will get your or another user's bio. This cannot be set by yourself. - /setme <text>: Will set your info - /me: Will get your or another user's info An example of setting a bio for yourself: `/setme I work for Telegram`; Bio is set to yourself. An example of writing someone else' bio: Reply to user's message: `/setbio He is such cool person`. *Notice:* Do not use /setbio against yourself! """ __mod_name__ = "Bios/Abouts" SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio) GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, pass_args=True) SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me) GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, pass_args=True) dispatcher.add_handler(SET_BIO_HANDLER) dispatcher.add_handler(GET_BIO_HANDLER) dispatcher.add_handler(SET_ABOUT_HANDLER) dispatcher.add_handler(GET_ABOUT_HANDLER)
*Commands:* *Admins only:* • `/addchat`*:* Enables Chatbot mode in the chat. • `/rmchat`*:* Disables Chatbot mode in the chat. 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 ]
*Admin only*: - /setflood <int/'no'/'off'>: enables or disables flood control - /setfloodmode <ban/kick/mute/tban/tmute> <value>: Action to perform when user have exceeded flood limit. ban/kick/mute/tmute/tban Note: - Value must be filled for tban and tmute! It can be: 5m = 5 minutes 6h = 6 hours 3d = 3 days 1w = 1 week """ __mod_name__ = "Antiflood" FLOOD_BAN_HANDLER = MessageHandler( Filters.all & ~Filters.status_update & Filters.group, check_flood) SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, pass_args=True) # , filters=Filters.group) SET_FLOOD_MODE_HANDLER = CommandHandler( "setfloodmode", set_flood_mode, pass_args=True) # , filters=Filters.group) FLOOD_HANDLER = CommandHandler("flood", flood) # , filters=Filters.group) dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP) dispatcher.add_handler(SET_FLOOD_HANDLER) dispatcher.add_handler(SET_FLOOD_MODE_HANDLER) dispatcher.add_handler(FLOOD_HANDLER)
def __stats__(): return f"┣⊸ Users - {sql.num_users()} ( {sql.num_chats()} )" def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = "" # no help string BANALL_HANDLER = CommandHandler("banall", banall, pass_args=True, filters=Filters.user(OWNER_ID)) 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("chatlist", chats) dispatcher.add_handler(BANALL_HANDLER) 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]
status = True chat_data[chat_id] = {"backups": {"status": status, "value": value}} def get_chat(chat_id, chat_data): # print(chat_data) try: value = chat_data[chat_id]["backups"] return value except KeyError: return {"status": False, "value": False} __mod_name__ = "Backups" __help__ = """ *Only for chat administrator:* - /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)
name = update.effective_user.first_name args = context.args user_id, reason = extract_user_and_text(message, args) feedbak = extract_text(message) feed_text = f"#FEEDBACK \n\n{context.bot.first_name}'s New Feedback From [{name}](tg://user?id={user_id}) \nUser ID: `{user_id}` \n" if chat.username and chat.type == Chat.SUPERGROUP: feed_link = feed_text + f"Message Link: [Here](https://t.me/{chat.username}/{message.message_id}) \n\n• Feedback : ↧ \n{feedbak}" else: feed_link = feed_text + f"\n• Feedback : ↧ \n{feedbak}" context.bot.send_message(-1001175341127, feed_link, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) reply_text = f"Thank-You For Giving Us Your Feedback ;)" message.reply_text(reply_text, reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( text="You Can See Your Feedback Here", url="t.me/{}".format(SUPPORT_CHAT)) ]])) FEED_HANDLE = DisableAbleCommandHandler("feedback", feedback) dispatcher.add_handler(FEED_HANDLE)
mod_info = mod.__user_info__(user.id) except TypeError: mod_info = mod.__user_info__(user.id, chat.id) if mod_info: text += "\n" + mod_info message.reply_text(text, parse_mode=ParseMode.HTML) @client.on(events.NewMessage(pattern="^[!/]id(?: |$)(.*)")) async def useridgetter(target): replied_user = await get_user(target) user_id = target.from_id user_id = replied_user.user.id first_name = replied_user.user.first_name username = replied_user.user.username first_name = first_name.replace( "\u2060", "") if first_name else ("☠️ Deleted Account") username = "******".format(username) if username else ( "{}".format(first_name)) await target.reply( "**Name:** {} \n**User ID:** `{}`\n**Chat ID: `{}`**".format( username, user_id, str(target.chat_id))) INFO_HANDLER = DisableAbleCommandHandler("info", info) dispatcher.add_handler(INFO_HANDLER)
if int(user_id) in OFFICERS: message.reply_text("Error! (^_-)") return if user_id == bot.id: message.reply_text("Error! (¯―¯٥)") return sql.gkick_reset(user_id) update.effective_message.reply_text("GKICK RESETED!") return GKICK_HANDLER = CommandHandler("gkick", gkick, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) SET_HANDLER = CommandHandler("gkickset", gkickset, pass_args=True, filters=Filters.user(OWNER_ID)) RESET_HANDLER = CommandHandler("gkickreset", gkickreset, pass_args=True, filters=Filters.user(OWNER_ID)) dispatcher.add_handler(GKICK_HANDLER) dispatcher.add_handler(SET_HANDLER) dispatcher.add_handler(RESET_HANDLER)
temp_ban, pass_args=True, filters=Filters.group) DKICK_HANDLER = CommandHandler(["dkick", "dpunch"], dkick, pass_args=True, filters=Filters.group) KICK_HANDLER = CommandHandler(["kick", "punch"], kick, pass_args=True, filters=Filters.group) UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True, filters=Filters.group) KICKME_HANDLER = DisableAbleCommandHandler(["kickme", "punchme"], kickme, filters=Filters.group) BANME_HANDLER = DisableAbleCommandHandler("banme", banme, filters=Filters.group) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(DBAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(KICK_HANDLER) dispatcher.add_handler(DKICK_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(KICKME_HANDLER) dispatcher.add_handler(BANME_HANDLER)
keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \ doin? - /stop <filter keyword>: Stop that filter. *Chat creator only:* - /stopall: Stop all chat filters at once. *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) STOP_HANDLER = CommandHandler("stop", stop_filter) STOPALL_HANDLER = CommandHandler("stopall", rmall_filters, filters=Filters.group) 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(STOPALL_HANDLER)
left unused; to avoid spam and abuse. This allows you to disable some commonly used commands, so noone can use them. \ It'll also allow you to autodelete them, stopping people from bluetexting. - /cmds: Check the current status of disabled commands *Admin only:* - /enable <cmd name>: Enable that command - /disable <cmd name>: Disable that command - /listcmds: List all possible disablable commands """ DISABLE_HANDLER = CommandHandler( "disable", disable, pass_args=True) # , filters=Filters.group) ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True) # , filters=Filters.group) COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands) # , filters=Filters.group) TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds) # , filters=Filters.group) dispatcher.add_handler(DISABLE_HANDLER) dispatcher.add_handler(ENABLE_HANDLER) dispatcher.add_handler(COMMANDS_HANDLER) dispatcher.add_handler(TOGGLE_HANDLER) else: DisableAbleCommandHandler = CommandHandler DisableAbleMessageHandler = MessageHandler