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)
