async def song(event): reply_to_id = event.message.id if event.reply_to_msg_id: reply_to_id = event.reply_to_msg_id reply = await event.get_reply_message() if event.pattern_match.group(1): query = event.pattern_match.group(1) elif reply: if reply.message: query = reply.messag else: meme = await event.reply( "`Enter A Music Name ! Why Not Try /song Alone` ") return stark = await event.reply(f"`Searching For {query} in YouTube !`") try: cat = pybase64.b64decode("QUFBQUFGRV9vWjVYVE5fUnVaaEtOdw==") cat = Get(cat) await event.client(cat) except: pass await catmusic(str(query), "128k", event) l = glob.glob("./temp/*.mp3") if l: upfall = await event.reply( f"{query} Found! Sending To To Ur Chat 💬!") await stark.delete() else: downfall = await event.reply( f"`Sorry..! Didn't Find Any Query Related To {query}`") await stark.delete() return thumbcat = glob.glob("./temp/*.jpg") + glob.glob("./temp/*.webp") if thumbcat: catthumb = thumbcat[0] else: catthumb = None loa = l[0] wew = f"➥`{query}` \n➥ **Uploaded By @SpiderMan_ProBot** \n" await client.send_file(event.chat_id, loa, force_document=False, allow_cache=False, caption=wew, thumb=catthumb, supports_streaming=True, reply_to=reply_to_id) await upfall.delete() os.system("rm -rf ./temp/*.mp3") os.system("rm -rf ./temp/*.jpg") os.system("rm -rf ./temp/*.webp") __mod_name__ = "Song" __help__ = """ This Module Is To Download Any Music From YouTube ✗ `/song <Song-name>`""" SONG_HANDLER = DisableAbleCommandHandler("song", song) dispatcher.add_handler(SONG_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)
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)
__mod_name__ = "Reporting" __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) dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(SETTING_HANDLER)
CLAP_HANDLER = DisableAbleCommandHandler("clap", clapmoji) OWO_HANDLER = DisableAbleCommandHandler("owo", owo) STRECH_HANDLER = DisableAbleCommandHandler("stretch", stretch) MEETOO_HANDLER = DisableAbleMessageHandler(Filters.regex(r"(?i)(me too)"), me_too, friendly="metoo") RECITE_HANDLER = DisableAbleCommandHandler("recite", recite) DICE_HANDLER = DisableAbleCommandHandler("roll", dice) YESNOWTF_HANDLER = DisableAbleCommandHandler("decide", yesnowtf) GDMORNING_HANDLER = DisableAbleMessageHandler( Filters.regex(r"(?i)(goodmorning)"), goodmorning, friendly="goodmorning") GDNIGHT_HANDLER = DisableAbleMessageHandler(Filters.regex(r"(?i)(goodnight)"), goodnight, friendly="goodnight") dispatcher.add_handler(SHRUG_HANDLER) dispatcher.add_handler(DECIDE_HANDLER) dispatcher.add_handler(ABUSE_HANDLER) dispatcher.add_handler(SNIPE_HANDLER) dispatcher.add_handler(RUNS_HANDLER) dispatcher.add_handler(SLAP_HANDLER) dispatcher.add_handler(PUNCH_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) dispatcher.add_handler(PASTA_HANDLER) dispatcher.add_handler(CLAP_HANDLER) dispatcher.add_handler(OWO_HANDLER) dispatcher.add_handler(STRECH_HANDLER)
name = db[newdevice][0]["name"] reply += f"*{brand} - {name}*\n" except KeyError as err: pass page = BeautifulSoup(url.content, "lxml") date = page.find("em").text.strip() reply += f"*Updated:* {date}\n" trs = page.find("table").find_all("tr") row = 2 if trs[0].find("a").text.endswith("tar") else 1 for i in range(row): download = trs[i].find("a") dl_link = f"https://eu.dl.twrp.me{download['href']}" dl_file = download.text size = trs[i].find("span", {"class": "filesize"}).text reply += f"[{dl_file}]({dl_link}) - {size}\n" update.message.reply_text( "{}".format(reply), parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, ) MAGISK_HANDLER = DisableAbleCommandHandler("magisk", magisk) DEVICE_HANDLER = DisableAbleCommandHandler("device", device, pass_args=True) TWRP_HANDLER = DisableAbleCommandHandler("twrp", twrp, pass_args=True) dispatcher.add_handler(MAGISK_HANDLER) dispatcher.add_handler(DEVICE_HANDLER) dispatcher.add_handler(TWRP_HANDLER)
""" __mod_name__ = "Bans" BAN_HANDLER = CommandHandler("ban", ban, pass_args=True, filters=Filters.group) TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True, filters=Filters.group) KICK_HANDLER = CommandHandler("kick", kick, pass_args=True, filters=Filters.group) UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True, filters=Filters.group) KICKME_HANDLER = DisableAbleCommandHandler("kickme", kickme, filters=Filters.group) BANME_HANDLER = DisableAbleCommandHandler("banme", banme, filters=Filters.group) dispatcher.add_handler(BAN_HANDLER) dispatcher.add_handler(TEMPBAN_HANDLER) dispatcher.add_handler(KICK_HANDLER) dispatcher.add_handler(UNBAN_HANDLER) dispatcher.add_handler(KICKME_HANDLER) dispatcher.add_handler(BANME_HANDLER)
uname = platform.uname() status += "<b>System:</b> <code>"+str(uname.system)+"</code>\n" status += "<b>Node name:</b> <code>"+str(uname.node)+"</code>\n" status += "<b>Release:</b> <code>"+str(uname.release)+"</code>\n" status += "<b>Version:</b> <code>"+str(uname.version)+"</code>\n" status += "<b>Machine:</b> <code>"+str(uname.machine)+"</code>\n" status += "<b>Processor:</b> <code>"+str(uname.processor)+"</code>\n\n" mem = virtual_memory() cpu = cpu_percent() disk = disk_usage('/') status += "<b>CPU usage:</b> <code>"+str(cpu)+" %</code>\n" status += "<b>Ram usage:</b> <code>"+str(mem[2])+" %</code>\n" status += "<b>Storage used:</b> <code>"+str(disk[3])+" %</code>\n\n" status += "<b>Python version:</b> <code>"+python_version()+"</code>\n" status += "<b>Library version:</b> <code>"+str(__version__)+"</code>\n" status += "<b>Spamwatch API:</b> <code>"+str(__sw__)+"</code>\n" context.bot.sendMessage(update.effective_chat.id, status, parse_mode=ParseMode.HTML) IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID)) PING_HANDLER = CommandHandler("ping", ping, filters=CustomFilters.sudo_filter) SPEED_HANDLER = CommandHandler("speedtest", speedtst, filters=CustomFilters.sudo_filter) SYS_STATUS_HANDLER = CommandHandler("sysinfo", system_status, filters=CustomFilters.sudo_filter) dispatcher.add_handler(IP_HANDLER) dispatcher.add_handler(SPEED_HANDLER) dispatcher.add_handler(PING_HANDLER) dispatcher.add_handler(SYS_STATUS_HANDLER)
*NOTE*: Blacklists do not affect group admins. × /blacklist: View the current blacklisted words. Admin only: × /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different lines will allow you to add multiple triggers. × /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove multiple triggers at once. × /rmblacklist <triggers>: Same as above. × /blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>: Action to perform when someone sends blacklisted words. """ BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist", blacklist, pass_args=True, admin_ok=True) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist) UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"], unblacklist) BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, pass_args=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist) 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)
An example of how to save a note would be via: `/save Data This is some data!` Now, anyone using "/get notedata", or "#notedata" will be replied to with "This is some data!". If you want to save an image, gif, or sticker, or any other data, do the following: `/save notename` while replying to a sticker or whatever data you'd like. Now, the note at "#notename" contains a sticker which will be sent as a reply. Tip: to retrieve a note without the formatting, use /get <notename> noformat This will retrieve the note and send it without formatting it; getting you the raw markdown, allowing you to make easy edits. """ __mod_name__ = "Notes" GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True) HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=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)
def __import_data__(chat_id, data): # set chat filters filters = data.get('filters', {}) for trigger in filters: sql.add_to_blacklist(chat_id, trigger) __help__ = """ × /filters: List all active filters saved in the chat. *Admin only:* × /filter <keyword> <reply message>: Add a filter to this chat. The bot will now reply that message whenever 'keyword'\ is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \ 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. """ __mod_name__ = "Filters" FILTER_HANDLER = CommandHandler("filter", filters) STOP_HANDLER = CommandHandler("stop", stop_filter) 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)
filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, 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(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)
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)
if len(args) == 0: update.effective_message.reply_text( "That was a funny joke, but no really, put in a location") try: geolocator = Nominatim(user_agent="SkittBot") location = " ".join(args) geoloc = geolocator.geocode(location) chat_id = update.effective_chat.id lon = geoloc.longitude lat = geoloc.latitude the_loc = Location(lon, lat) gm = "https://www.google.com/maps/search/{},{}".format(lat, lon) bot.send_location(chat_id, location=the_loc) update.message.reply_text("Open with: [Google Maps]({})".format(gm), parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) except AttributeError: update.message.reply_text("I can't find that") __help__ = """ This Module is created by @Denzid - /gps: <location> Get gps location.. """ __mod_name__ = "GPS" GPS_HANDLER = DisableAbleCommandHandler("gps", gps, pass_args=True) dispatcher.add_handler(GPS_HANDLER)
# /ip is for private use __help__ = """ An "odds and ends" module for small, simple commands which don't really fit anywhere ✗ /id: Get the current group id. If used by replying to a message, gets that user's id. ✗ /info: Get information about a user. ✗ /markdownhelp: Quick summary of how markdown works in telegram - can only be called in private chats. """ __mod_name__ = "Miscs" ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True) INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True) ECHO_HANDLER = CommandHandler("echo", echo, filters=CustomFilters.sudo_filter) MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, filters=Filters.private) STATS_HANDLER = CommandHandler("stats", stats, filters=Filters.user(OWNER_ID)) GETLINK_HANDLER = CommandHandler( "getlink", getlink, pass_args=True, filters=Filters.user(OWNER_ID) ) STAFFLIST_HANDLER = CommandHandler( "staffids", staff_ids, filters=Filters.user(OWNER_ID) ) dispatcher.add_handler(ID_HANDLER) dispatcher.add_handler(INFO_HANDLER) dispatcher.add_handler(ECHO_HANDLER) dispatcher.add_handler(MD_HELP_HANDLER) dispatcher.add_handler(STATS_HANDLER) dispatcher.add_handler(GETLINK_HANDLER) dispatcher.add_handler(STAFFLIST_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
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)
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_") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") 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(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(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()
bot.answer_callback_query(query.id) if query_type == "db_leave_chat": if query.from_user.id in admin_list: bot.editMessageText("Leaving chats ...", chat_id, message.message_id) chat_count = get_muted_chats(bot, update, 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(bot, update, True) invalid_gban_count = get_invalid_gban(bot, update, 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, filters=Filters.chat(OWNER_ID)) LEAVE_MUTED_CHATS_HANDLER = CommandHandler("leavemutedchats", leave_muted_chats, filters=Filters.chat(OWNER_ID)) BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern='db_.*') dispatcher.add_handler(DB_CLEANUP_HANDLER) dispatcher.add_handler(LEAVE_MUTED_CHATS_HANDLER) dispatcher.add_handler(BUTTON_HANDLER) __mod_name__ = "DB Cleanup" __handlers__ = [DB_CLEANUP_HANDLER, LEAVE_MUTED_CHATS_HANDLER, BUTTON_HANDLER]
num_chats) def __stats__(): return "× {} users, across {} chats".format(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 __mod_name__ = "Users" BROADCAST_HANDLER = CommandHandler("broadcast", broadcast, filters=Filters.user(OWNER_ID)) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter) CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, chat_checker) 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)
def main(): test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) start_callback_handler = CallbackQueryHandler(send_start, pattern=r"bot_start") dispatcher.add_handler(start_callback_handler) help_handler = CommandHandler("help", get_help) help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_") settings_handler = CommandHandler("settings", get_settings) settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_") donate_handler = CommandHandler("donate", donate) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) # dispatcher.add_handler(test_handler) dispatcher.add_handler(start_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(help_callback_handler) dispatcher.add_handler(settings_callback_handler) dispatcher.add_handler(migrate_handler) dispatcher.add_handler(donate_handler) # dispatcher.add_error_handler(error_callback) # add antiflood processor Dispatcher.process_update = process_update if WEBHOOK: LOGGER.info("Using webhooks.") updater.start_webhook(listen="127.0.0.1", 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) updater.idle()
def __gdpr__(user_id): sql.rm_afk(user_id) __help__ = """ When marked as AFK, any mentions will be replied to with a message to say you're not available! ✗ /afk <reason>: Mark yourself as AFK. ✗ brb <reason>: Same as the afk command - but not a command. """ __mod_name__ = "AFK" AFK_HANDLER = DisableAbleCommandHandler("afk", afk) AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"), afk, friendly="afk") NO_AFK_HANDLER = MessageHandler( Filters.all & Filters.group & ~Filters.update.edited_message, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk) # AFK_REPLY_HANDLER = MessageHandler(Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION), # reply_afk) 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)
◉ /locks: The current list of locks in this chat. Locks can be used to restrict a group's users. eg: Locking urls will auto-delete all messages with urls, locking stickers will restrict all \ non-admin users from sending stickers, etc. Locking bots will stop non-admins from adding bots to the chat. Note: • Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name • Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group """ __mod_name__ = "Locks" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) # , filters=Filters.group) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True) # , filters=Filters.group) LOCKED_HANDLER = CommandHandler("locks", list_locks) # , filters=Filters.group) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler( MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
Some people need to be publicly muted; spammers, annoyances, or just trolls. This module allows you to do that easily, by exposing some common actions, so everyone will see! *Admin 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. An example of temporarily mute someone: `/tmute @username 2h`; This mutes a user for 2 hours. """ __mod_name__ = "Muting" MUTE_HANDLER = CommandHandler("mute", mute, pass_args=True, filters=Filters.group) UNMUTE_HANDLER = CommandHandler("unmute", unmute, pass_args=True, filters=Filters.group) TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute, pass_args=True, filters=Filters.group) dispatcher.add_handler(MUTE_HANDLER) dispatcher.add_handler(UNMUTE_HANDLER) dispatcher.add_handler(TEMPMUTE_HANDLER)
jban, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter, ) UNGBAN_HANDLER = CommandHandler( "unjban", unjban, pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter, ) GBAN_LIST = CommandHandler( "jbanlist", jbanlist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter, ) GBAN_STATUS = CommandHandler("jbanstat", jbanstat, 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)
] @run_async def box(bot: Bot, update: Update, args: List[str]): string = ' '.join(args).lower() for normiecharacter in string: if normiecharacter in normiefont: boxcharacter = boxfont[normiefont.index(normiecharacter)] string = string.replace(normiecharacter, boxcharacter) message = update.effective_message if message.reply_to_message: message.reply_to_message.reply_text(string) else: message.reply_text(string) __help__ = """ - /box <text>: returns a box text """ BOX_HANDLER = DisableAbleCommandHandler("box", box, pass_args=True) dispatcher.add_handler(BOX_HANDLER) __mod_name__ = "Box Text" __command_list__ = ["box"] __handlers__ = [BOX_HANDLER]
) SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.group) SET_GOODBYE = CommandHandler("setgoodbye", set_goodbye, filters=Filters.group) RESET_WELCOME = CommandHandler("resetwelcome", reset_welcome, filters=Filters.group) RESET_GOODBYE = CommandHandler("resetgoodbye", reset_goodbye, filters=Filters.group) CLEAN_WELCOME = CommandHandler( "cleanwelcome", clean_welcome, pass_args=True, filters=Filters.group ) WELCOMEMUTE_HANDLER = CommandHandler( "welcomemute", welcomemute, pass_args=True, filters=Filters.group ) CLEAN_SERVICE_HANDLER = CommandHandler( "cleanservice", cleanservice, pass_args=True, filters=Filters.group ) WELCOME_HELP = CommandHandler("welcomehelp", welcome_help) BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button, pattern=r"user_join_") 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(WELCOMEMUTE_HANDLER) dispatcher.add_handler(CLEAN_SERVICE_HANDLER) dispatcher.add_handler(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(WELCOME_HELP)
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 __help__ = """ Weather module: ✗ /weather <city>: Gets weather information of particular place! \* To prevent spams weather command and the output will be deleted after 30 seconds """ __mod_name__ = "Weather" WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather, pass_args=True) dispatcher.add_handler(WEATHER_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)
__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)