def load(bot: Bot, update: Update): 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("cinderella.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 not imported_module.__mod_name__.lower() 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 type(handler) != tuple: dispatcher.add_handler(handler) 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 doesn't have a handler list specified!") 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)
else: update.effective_message.reply_text('Unknown error occured') r.raise_for_status() document = r.json()['document'] key = document['_id'] views = document['viewCount'] reply = f'Stats for **[/{key}]({BASE_URL}/{key})**:\nViews: `{views}`' update.effective_message.reply_text(reply, parse_mode=ParseMode.MARKDOWN) __help__ = """ - /paste: Create a paste or a shortened url using [dogbin](https://del.dog) - /getpaste: Get the content of a paste or shortened url from [dogbin](https://del.dog) - /pastestats: Get stats of a paste or shortened url from [dogbin](https://del.dog) """ __mod_name__ = "DOGBIN" PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, pass_args=True) GET_PASTE_HANDLER = DisableAbleCommandHandler("getpaste", get_paste_content, pass_args=True) PASTE_STATS_HANDLER = DisableAbleCommandHandler("pastestats", get_paste_stats, pass_args=True) dispatcher.add_handler(PASTE_HANDLER) dispatcher.add_handler(GET_PASTE_HANDLER) dispatcher.add_handler(PASTE_STATS_HANDLER)
chatfile += "{}. {} | {} | {} | {}\n".format(P, chat.chat_name, chat.chat_id, chat_members, invitelink) P = P + 1 except: pass with BytesIO(str.encode(chatfile)) as output: output.name = "chatlist.txt" update.effective_message.reply_document(document=output, filename="chatlist.txt", caption="Here is the list of chats in my database.") 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("broadcast", broadcast) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHATLIST_HANDLER = CommandHandler("chatlist", chats) dispatcher.add_handler(USER_HANDLER, USERS_GROUP) dispatcher.add_handler(BROADCAST_HANDLER) dispatcher.add_handler(CHATLIST_HANDLER) __mod_name__ = "Users" __handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER, CHATLIST_HANDLER]
- /lock <type>: lock items of a certain type (not available in private) - /unlock <type>: unlock items of a certain type (not available in private) - /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 which haven't been whitelisted, locking stickers will delete all \ stickers, etc. Locking bots will stop non-admins from adding bots to the chat. """ LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True) LOCKED_HANDLER = CommandHandler("locks", list_locks) LOCKABLE_HANDLER = MessageHandler(Filters.all & Filters.group, del_lockables) RESTRICTION_HANDLER = MessageHandler(Filters.all & Filters.group, rest_handler) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler(LOCKABLE_HANDLER, PERM_GROUP) dispatcher.add_handler(RESTRICTION_HANDLER, REST_GROUP) __mod_name__ = "LOCKS" __handlers__ = [ LOCKTYPES_HANDLER, LOCK_HANDLER, UNLOCK_HANDLER, LOCKED_HANDLER, (LOCKABLE_HANDLER, PERM_GROUP), (RESTRICTION_HANDLER, REST_GROUP) ]
def gps(bot: Bot, update: Update, args: List[str]): message = update.effective_message 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__ = """ - /gps <location>: get gps location """ __mod_name__ = "GPS" GPS_HANDLER = DisableAbleCommandHandler("gps", gps, pass_args=True) dispatcher.add_handler(GPS_HANDLER)
@run_async def repo(bot: Bot, update: Update, args: [str]): message = update.effective_message text = message.text[len('/repo '):] usr = get(f'https://api.github.com/users/{text}/repos?per_page=40').json() reply_text = "*Repo*\n" for i in range(len(usr)): reply_text += f"[{usr[i]['name']}]({usr[i]['html_url']})\n" message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) __help__ = """ - /git:{GitHub username} Returns info about a GitHub user or organization. - /repo: Return the GitHub user or organization repository list (Limited at 40) """ __mod_name__ = "GITHUB" github_handle = DisableAbleCommandHandler("git", github) REPO_HANDLER = DisableAbleCommandHandler("repo", repo, pass_args=True, admin_ok=True) dispatcher.add_handler(github_handle) dispatcher.add_handler(REPO_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), pass_args=True) dispatcher.add_handler(COMMON_CHATS_HANDLER)
def main(): test_handler = CommandHandler("test", test) start_handler = CommandHandler("start", start, pass_args=True) IMDB_HANDLER = CommandHandler('imdb', imdb, pass_args=True) IMDB_SEARCHDATAHANDLER = CallbackQueryHandler(imdb_searchdata) 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_") source_handler = CommandHandler("source", source) migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats) M_CONNECT_BTN_HANDLER = CallbackQueryHandler(m_connect_button, pattern=r"main_connect") # 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(source_handler) dispatcher.add_handler(M_CONNECT_BTN_HANDLER) dispatcher.add_handler(IMDB_HANDLER) dispatcher.add_handler(IMDB_SEARCHDATAHANDLER) # dispatcher.add_error_handler(error_callback) 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("Cinderella running...") updater.start_polling(timeout=15, read_latency=4) client.run_until_disconnected() updater.idle()
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: 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) __help__ = """ WIKIPEDIA!! *Available commands:* - /wiki <query>: wiki your query. """ __mod_name__ = "WIKIPEDIA" WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki) dispatcher.add_handler(WIKI_HANDLER)
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate, pass_args=True) ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, pass_args=True) TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, pass_args=True) AREA_HANDLER = DisableAbleCommandHandler("area", area, pass_args=True) COS_HANDLER = DisableAbleCommandHandler("cos", cos, pass_args=True) SIN_HANDLER = DisableAbleCommandHandler("sin", sin, pass_args=True) TAN_HANDLER = DisableAbleCommandHandler("tan", tan, pass_args=True) ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, pass_args=True) ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, pass_args=True) ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, pass_args=True) ABS_HANDLER = DisableAbleCommandHandler("abs", abs, pass_args=True) LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=True) dispatcher.add_handler(SIMPLIFY_HANDLER) dispatcher.add_handler(FACTOR_HANDLER) dispatcher.add_handler(DERIVE_HANDLER) dispatcher.add_handler(INTEGRATE_HANDLER) dispatcher.add_handler(ZEROES_HANDLER) dispatcher.add_handler(TANGENT_HANDLER) dispatcher.add_handler(AREA_HANDLER) dispatcher.add_handler(COS_HANDLER) dispatcher.add_handler(SIN_HANDLER) dispatcher.add_handler(TAN_HANDLER) dispatcher.add_handler(ARCCOS_HANDLER) dispatcher.add_handler(ARCSIN_HANDLER) dispatcher.add_handler(ARCTAN_HANDLER) dispatcher.add_handler(ABS_HANDLER) dispatcher.add_handler(LOG_HANDLER)
- /police 🚓 """ KILL_HANDLER = DisableAbleCommandHandler("kill", kill) LOVE_HANDLER = DisableAbleCommandHandler("love", love) HACK_HANDLER = DisableAbleCommandHandler("hack", hack) BOMBS_HANDLER = DisableAbleCommandHandler("bombs", bombs) MOONANIMATION_HANDLER = DisableAbleCommandHandler("moonanimation", moonanimation) CLOCKANIMATION_HANDLER = DisableAbleCommandHandler("clockanimation", clockanimation) BLOCKANIMATION_HANDLER = DisableAbleCommandHandler("blockanimation", blockanimation) EARTHANIMATION_HANDLER = DisableAbleCommandHandler("earthanimation", earthanimation) dispatcher.add_handler(KILL_HANDLER) dispatcher.add_handler(LOVE_HANDLER) dispatcher.add_handler(HACK_HANDLER) dispatcher.add_handler(BOMBS_HANDLER) dispatcher.add_handler(EARTHANIMATION_HANDLER) dispatcher.add_handler(MOONANIMATION_HANDLER) dispatcher.add_handler(CLOCKANIMATION_HANDLER) dispatcher.add_handler(BLOCKANIMATION_HANDLER) __mod_name__ = "EMOJIS" __command_list__ = [ "love", "hack", "bombs", "moonanimation", "clockanimation", "earthanimation", "blockanimation", "kill" ] __handlers__ = [ LOVE_HANDLER, HACK_HANDLER, BOMBS_HANDLER, MOONANIMATION_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): return build_curr_disabled(chat_id) DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True) DISABLE_MODULE_HANDLER = CommandHandler("disablemodule", disable_module, pass_args=True) ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True) ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module, pass_args=True) COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands) TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds) dispatcher.add_handler(DISABLE_HANDLER) dispatcher.add_handler(DISABLE_MODULE_HANDLER) dispatcher.add_handler(ENABLE_HANDLER) dispatcher.add_handler(ENABLE_MODULE_HANDLER) dispatcher.add_handler(COMMANDS_HANDLER) dispatcher.add_handler(TOGGLE_HANDLER) __help__ = """ - /cmds: check the current status of disabled commands *Admin only:* - /enable <cmd name>: enable that command - /disable <cmd name>: disable that command - /enablemodule <module name>: enable all commands in that module - /disablemodule <module name>: disable all commands in that module - /listcmds: list all possible toggleable commands """
pass_args=True, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_LIST = CommandHandler("gbanlist", gbanlist, filters=CustomFilters.sudo_filter | CustomFilters.support_filter) GBAN_STATUS = CommandHandler("gbanstat", gbanstat, pass_args=True, filters=Filters.group) CHECK_GBAN_HANDLER = CommandHandler("checkgb", check_gbans, filters=Filters.user(OWNER_ID)) CLEAN_GBAN_HANDLER = CommandHandler("cleangb", clear_gbans, filters=Filters.user(OWNER_ID)) 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) dispatcher.add_handler(CHECK_GBAN_HANDLER) dispatcher.add_handler(CLEAN_GBAN_HANDLER) if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
limit = sql.get_flood_limit(chat_id) soft_flood = sql.get_flood_strength(chat_id) if limit == 0: return "*Not* currently enforcing flood control." else: if soft_flood: return "Anti-flood is set to `{}` messages and *KICK* if exceeded.".format(limit) else: return "Anti-flood is set to `{}` messages and *BAN* if exceeded.".format(limit) __help__ = """ You know how sometimes, people join, send 100 messages, and ruin your chat? With antiflood, that happens no more! Antiflood allows you to take action on users that send more than x messages in a row. Exceeding the set flood \ will result in banning or kicking the user. - /flood: Get the current flood control setting *Admin only:* - /setflood <int/'no'/'off'>: enables or disables flood control - /strongflood <on/yes/off/no>: If set to on, exceeding the flood limit will result in a ban. Else, will just kick. """ __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) FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group) FLOOD_STRENGTH_HANDLER = CommandHandler("strongflood", set_flood_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP) dispatcher.add_handler(SET_FLOOD_HANDLER) dispatcher.add_handler(FLOOD_HANDLER) dispatcher.add_handler(FLOOD_STRENGTH_HANDLER)
return f"<b>What others say:</b>\n{bio}\n" elif me: return f"<b>About user:</b>\n{me}" else: return "" __help__ = """ - /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 """ 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__ = "BIOS/ABOUTS" __command_list__ = ["setbio", "bio", "setme", "me"] __handlers__ = [ SET_BIO_HANDLER, GET_BIO_HANDLER, SET_ABOUT_HANDLER, GET_ABOUT_HANDLER ]
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 __help__ = """ /ignore : blacklist users /notice : /ignoredlist : List of blacklisted users """ __mod_name__ = "Ignore/Notice" BL_HANDLER = CommandHandler("ignore", bl_user, pass_args=True) UNBL_HANDLER = CommandHandler("notice", unbl_user, pass_args=True) BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users) dispatcher.add_handler(BL_HANDLER) dispatcher.add_handler(UNBL_HANDLER) dispatcher.add_handler(BLUSERS_HANDLER) __mod_name__ = "BLACKLISTING USERS" __handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
addwhitelist, pass_args=True) UNSUDO_HANDLER = CommandHandler(("removesudo"), removesudo, pass_args=True) UNSUPPORT_HANDLER = CommandHandler(("removesupport"), removesupport, pass_args=True) UNWHITELIST_HANDLER = CommandHandler(("removewhitelist"), removewhitelist, pass_args=True) WHITELISTLIST_HANDLER = CommandHandler(["whitelistlist"], whitelistlist) SUPPORTLIST_HANDLER = CommandHandler(["supportlist"], supportlist) SUDOLIST_HANDLER = CommandHandler(["sudolist"], sudolist) DEVLIST_HANDLER = CommandHandler(["devlist"], devlist) dispatcher.add_handler(SUDO_HANDLER) dispatcher.add_handler(SUPPORT_HANDLER) dispatcher.add_handler(WHITELIST_HANDLER) dispatcher.add_handler(UNSUDO_HANDLER) dispatcher.add_handler(UNSUPPORT_HANDLER) dispatcher.add_handler(UNWHITELIST_HANDLER) dispatcher.add_handler(WHITELISTLIST_HANDLER) dispatcher.add_handler(SUPPORTLIST_HANDLER) dispatcher.add_handler(SUDOLIST_HANDLER) dispatcher.add_handler(DEVLIST_HANDLER) __mod_name__ = "DEV.PROMOTER" __handlers__ = [ SUDO_HANDLER, SUPPORT_HANDLER, WHITELIST_HANDLER, UNSUDO_HANDLER, UNSUPPORT_HANDLER, UNWHITELIST_HANDLER, WHITELISTLIST_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): return "This chat has had it's rules set: `{}`".format( bool(sql.get_rules(chat_id))) __help__ = """ - /rules: get the rules for this chat. *Admin 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, 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)
changes = json.loads(res.text).get('LightGingerTheTextResult') curr_string = "" 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:] print(curr_string) update.effective_message.reply_text(curr_string) __help__ = """ - /t: while replying to a message, will reply with a grammar corrected version """ __mod_name__ = "GRAMMER" TRANSLATE_HANDLER = CommandHandler('t', translate) dispatcher.add_handler(TRANSLATE_HANDLER)
f"🔎Finding timezone info for <b>{query}</b>", parse_mode=ParseMode.HTML) query_timezone = query.lower() if len(query_timezone) == 2: result = generate_time(query_timezone, ["countryCode"]) else: result = generate_time(query_timezone, ["zoneName", "countryName"]) if not result: send_message.edit_text( f"Timezone info not available for <b>{query}</b>", parse_mode=ParseMode.HTML) return send_message.edit_text(result, parse_mode=ParseMode.HTML) __help__ = """ - /time <query> : Gives information about a timezone. Available queries : Country Code/Country Name/Timezone Name """ TIME_HANDLER = DisableAbleCommandHandler("time", gettime) dispatcher.add_handler(TIME_HANDLER) __mod_name__ = "TIME" __command_list__ = ["time"] __handlers__ = [TIME_HANDLER]
add_warn_filter, filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, 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(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)
__help__ = """ *Admin only:* - /gmutespam <on/off/yes/no>: Will disable the effect of global mutes on your group, or return your current settings. Gmutes, also known as global mutes, are used by the bot owners to mute spammers across all groups. This helps protect \ you and your groups by removing spam flooders as quickly as possible. They can be disabled for you group by calling \ """ __mod_name__ = "GLOBAL MUTES" 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)
"Total Confirmed: `" + str(total_confirmed_global) + "`\n" "Total Deaths: `" + str(total_deaths_global) + "`\n" "Total Recovered: `" + str(total_recovered_global) + "`\n" "Active Cases: `" + str(active_cases_covid19) + "`") message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) return elif fetch.status_code == 404: reply_text = "The API is currently down." message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True) __help__ = """ - /covid: get worldwide corona status - /covindia <state>: Get real time COVID-19 stats for the input Indian state """ __mod_name__ = 'COVID-19 Tracker' COV_INDIA_HANDLER = CommandHandler('covindia', covindia) CORONA_HANDLER = DisableAbleCommandHandler("covid", corona, admin_ok=True) dispatcher.add_handler(CORONA_HANDLER) dispatcher.add_handler(COV_INDIA_HANDLER)
gbanChat, pass_args=True, filters=CustomFilters.sudo_filter) UNGBANCHAT_HANDLER = CommandHandler("unblchat", ungbanChat, pass_args=True, filters=CustomFilters.sudo_filter) DEFENSE_HANDLER = CommandHandler("setdefense", setDefense, pass_args=True) GETDEF_HANDLER = CommandHandler("defense", getDefense) GETTIMESET_HANDLER = CommandHandler("kicktime", getTimeSetting) SETTIMER_HANDLER = CommandHandler("setkicktime", setTimeSetting, pass_args=True) ABOUT_CAS_HANDLER = CommandHandler("cas", about_cas) 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(SAFEMODE_HANDLER) dispatcher.add_handler(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(DEL_JOINED) dispatcher.add_handler(WELCOME_HELP) dispatcher.add_handler(SETCAS_HANDLER) dispatcher.add_handler(GETCAS_HANDLER) dispatcher.add_handler(GETVER_HANDLER)
if value == False: status = False else: 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 a group butler backup file to import as much as possible, making the transfer super simple! Note \ that files/photos can't 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)
import random, re @run_async @bot_admin def getlink(bot: Bot, update: Update, args: List[int]): message = update.effective_message if args: pattern = re.compile(r'-\d+') else: message.reply_text("You don't seem to be referring to any chats.") links = "Invite link(s):\n" for chat_id in pattern.findall(message.text): try: chat = bot.getChat(chat_id) bot_member = chat.get_member(bot.id) if bot_member.can_invite_users: invitelink = bot.exportChatInviteLink(chat_id) links += str(chat_id) + ":\n" + invitelink + "\n" else: links += str(chat_id) + ":\nI don't have access to the invite link." + "\n" except BadRequest as excp: links += str(chat_id) + ":\n" + excp.message + "\n" except TelegramError as excp: links += str(chat_id) + ":\n" + excp.message + "\n" message.reply_text(links) GETLINK_HANDLER = CommandHandler("getlink", getlink, pass_args=True, filters=CustomFilters.sudo_filter) dispatcher.add_handler(GETLINK_HANDLER)
try: result = '{}'.format(repr(eval(body, env))) except: pass else: result = '{}{}'.format(value, func_return) if result: if len(str(result)) > 2000: result = 'Output is too long' return result @dev_plus @run_async def clear(bot, update): log_input(update) global namespaces if update.message.chat_id in namespaces: del namespaces[update.message.chat_id] send("Cleared locals.", bot, update) eval_handler = CommandHandler(('e', 'ev', 'eva', 'eval'), evaluate) exec_handler = CommandHandler(('x', 'ex', 'exe', 'exec', 'py'), execute) clear_handler = CommandHandler('clearlocals', clear) dispatcher.add_handler(eval_handler) dispatcher.add_handler(exec_handler) dispatcher.add_handler(clear_handler) __mod_name__ = "Eval Module"
pass_args=True) REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignorecleanbluetext", remove_bluetext_ignore, pass_args=True) ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "ignoreglobalcleanbluetext", add_bluetext_ignore_global, pass_args=True) REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler( "unignoreglobalcleanbluetext", remove_bluetext_ignore_global, pass_args=True) LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listcleanbluetext", bluetext_ignore_list) CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group, clean_blue_text_must_click) dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER) dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER) dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP) __mod_name__ = "BLUETEXT CLEANING" __handlers__ = [ SET_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_HANDLER, REMOVE_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, LIST_CLEAN_BLUE_TEXT_HANDLER, (CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP) ]
try: new_cur = args[3].upper() except IndexError: update.effective_message.reply_text("You forgot to mention the currency code to convert into.") return request_url = f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency={orig_cur}&to_currency={new_cur}&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(f"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}") else: update.effective_message.reply_text(__help__) __help__ = """ - /cash : currency converter example syntax: /cash 1 USD INR """ CONVERTER_HANDLER = CommandHandler('cash', convert) dispatcher.add_handler(CONVERTER_HANDLER) __mod_name__ = "CURRENCY CONVERTER" __command_list__ = ["cash"] __handlers__ = [CONVERTER_HANDLER]
result = cas.banchecker(user.id) text += str(result) for mod in USER_INFO: if mod.__mod_name__ == "Users": continue try: 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 try: profile = bot.get_user_profile_photos(user.id).photos[0][-1] bot.sendChatAction(chat.id, "upload_photo") bot.send_photo(chat.id, photo=profile, caption=(text), parse_mode=ParseMode.HTML, disable_web_page_preview=True) except IndexError: update.effective_message.reply_text(text, parse_mode=ParseMode.HTML, disable_web_page_preview=True) INFO_HANDLER = DisableAbleCommandHandler(["info", "whois"], info, pass_args=True) dispatcher.add_handler(INFO_HANDLER)