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("megumin.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)
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)
pass
__help__ = """
- /addrss <link>: add an RSS link to the subscriptions.
- /removerss <link>: removes the RSS link from the subscriptions.
- /rss <link>: shows the link's data and the last entry, for testing purposes.
- /listrss: shows the list of rss feeds that the chat is currently subscribed to.
NOTE: In groups, only admins can add/remove RSS links to the group's subscription
"""
__mod_name__ = "RSS FEED"
job = updater.job_queue
job_rss_set = job.run_once(rss_set, 5)
job_rss_update = job.run_repeating(rss_update, interval=60, first=60)
job_rss_set.enabled = True
job_rss_update.enabled = True
SHOW_URL_HANDLER = CommandHandler("rss", show_url, pass_args=True)
ADD_URL_HANDLER = CommandHandler("addrss", add_url, pass_args=True)
REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url, pass_args=True)
LIST_URLS_HANDLER = CommandHandler("listrss", list_urls)
dispatcher.add_handler(SHOW_URL_HANDLER)
dispatcher.add_handler(ADD_URL_HANDLER)
dispatcher.add_handler(REMOVE_URL_HANDLER)
dispatcher.add_handler(LIST_URLS_HANDLER)
cpuu += "--- CPU Usage Per Core ---\n"
for i, percentage in enumerate(psutil.cpu_percent(percpu=True)):
cpuu += f"Core {i}: `{percentage}%`\n"
cpuu += f"Total CPU Usage: `{psutil.cpu_percent()}%`\n"
# RAM Usage
svmem = psutil.virtual_memory()
memm = "--- Memory Usage ---\n"
memm += f"Total: `{get_size(svmem.total)}`\n"
memm += f"Available: `{get_size(svmem.available)}`\n"
memm += f"Used: `{get_size(svmem.used)}`\n"
memm += f"Percentage: `{svmem.percent}%`\n"
reply = str(stat)+ str(softw) + str(cpuu) + str(memm) + "\n"
bot.send_message(chat.id, reply, parse_mode=ParseMode.MARKDOWN)
__help__ = """
- /system : To know System status
- /speed or - /speedtest: To find Speed
"""
SPEED_TEST_HANDLER = DisableAbleCommandHandler(["speedtest","speed"], speedtestxyz, filters=CustomFilters.sudo_filter)
SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback, pattern='speedtest_.*')
STATUS_HANDLER = CommandHandler("system", status, filters=CustomFilters.sudo_filter)
dispatcher.add_handler(SPEED_TEST_HANDLER)
dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER)
dispatcher.add_handler(STATUS_HANDLER)
__mod_name__ = "SYSTEM INFO"
__command_list__ = ["speedtest"]
__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
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)
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)
*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.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.group,
del_blacklist,
edited_updates=True)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
__mod_name__ = "WORD BLACKLISTS"
__handlers__ = [
BLACKLIST_HANDLER, ADD_BLACKLIST_HANDLER, UNBLACKLIST_HANDLER,
(BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP)
]
else:
wallpapers = json_rep.get("wallpapers")
if not wallpapers:
msg.reply_text("No results found!")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
bot.send_photo(chat_id,
photo=wallpaper,
reply_to_message_id=msg_id,
timeout=60)
bot.send_document(chat_id,
document=wallpaper,
filename='wallpaper',
reply_to_message_id=msg_id,
timeout=60)
__help__ = """
- /wall <query> to get wallpaper
"""
__mod_name__ = "WALLPAPER"
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
def __stats__():
return "{} blacklist stickers, across {} chats.".format(sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__help__ = """
Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately.
*NOTE:* Blacklist stickers do not affect the group admin.
- /blsticker: See current blacklisted sticker.
*Only admin:*
- /addblsticker <sticker link>: Add the sticker trigger to the black list. Can be added via reply sticker.
- /unblsticker <sticker link>: Remove triggers from blacklist. The same newline logic applies here, so you can delete multiple triggers at once.
- /rmblsticker <sticker link>: Same as above.
- /blstickermode ban/tban/mute/tmute .
Note:
- `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message.
"""
__mod_name__ = "STICKER BLACKLIST"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker", blackliststicker, pass_args=True, admin_ok=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("addblsticker", add_blackliststicker)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"], unblackliststicker)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode, pass_args=True)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.group, del_blackliststicker)
dispatcher.add_handler(BLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
@run_async
def abuse(bot: Bot, update: Update):
bot.sendChatAction(update.effective_chat.id, "typing") # Bot typing before send messages
message = update.effective_message
if message.reply_to_message:
message.reply_to_message.reply_text(random.choice(ABUSE_STRINGS))
else:
message.reply_text(random.choice(ABUSE_STRINGS))
@run_async
def sing(bot: Bot, update: Update):
bot.sendChatAction(update.effective_chat.id, "typing") # Bot typing before send messages
message = update.effective_message
if message.reply_to_message:
message.reply_to_message.reply_text(random.choice(SONG_STRINGS))
else:
message.reply_text(random.choice(SONG_STRINGS))
__help__ = """
- /abuse : Abuse someone in malayalam.
- /sing : First lines of some random English Songs.
"""
__mod_name__ = "EXTRAS"
ABUSE_HANDLER = DisableAbleCommandHandler("abuse", abuse)
SING_HANDLER = DisableAbleCommandHandler("sing", sing)
dispatcher.add_handler(ABUSE_HANDLER)
dispatcher.add_handler(SING_HANDLER)
res = "{} is afk".format(fst_name)
update.effective_message.reply_text(res)
else:
if int(userc_id) == int(user_id):
return
res = "{} is AFK.\nReason: {}".format(fst_name, user.reason)
update.effective_message.reply_text(res)
__help__ = """
- /afk <reason>: mark yourself as AFK(away from keyboard).
- brb <reason>: same as the afk command - but not a command.
When marked as AFK, any mentions will be replied to with a message to say you're not available!
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleRegexHandler("(?i)brb", afk, friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, 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)
__mod_name__ = "AFK"
__command_list__ = ["afk"]
__handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
query.message.edit_text("Closed.\nTo open again, type /connect")
else:
connect_chat(bot, update, [])
__help__ = """
- /connect: connect a 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 done 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)
__mod_name__ = "CONNECTIONS"
__handlers__ = [CONNECT_CHAT_HANDLER, CONNECTION_CHAT_HANDLER, DISCONNECT_CHAT_HANDLER, ALLOW_CONNECTIONS_HANDLER, HELP_CONNECT_CHAT_HANDLER, CONNECT_BTN_HANDLER]
"""
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
TABLE_HANDLER = DisableAbleCommandHandler("table", table)
JUDGE_HANDLER = DisableAbleCommandHandler("judge", judge)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, pass_args=True)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(ROLL_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
dispatcher.add_handler(BLUETEXT_HANDLER)
dispatcher.add_handler(RLG_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
dispatcher.add_handler(TABLE_HANDLER)
dispatcher.add_handler(JUDGE_HANDLER)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(SHOUT_HANDLER)
__mod_name__ = "FUN"
__command_list__ = [
"runs", "slap", "roll", "toss", "shrug", "bluetext", "rlg", "decide",
@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)
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
"""
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)
return f"This group has all it's logs sent to: {escape_markdown(log_channel_info.title)} (`{log_channel}`)"
return "No log channel is set for this group!"
__help__ = """
*Admin only:*
- /logchannel: get log channel info
- /setlog: set the log channel.
- /unsetlog: unset the log channel.
Setting the log channel is done by:
- adding the bot to the desired channel (as an admin!)
- sending /setlog in the channel
- forwarding the /setlog to the group
"""
__mod_name__ = "LOG CHANNELS"
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 gloggable(func):
return func
time_list.reverse()
ping_time += ":".join(time_list)
return ping_time
@run_async
def ping(bot: Bot, update: Update):
start_time = time.time()
requests.get('https://api.telegram.org')
end_time = time.time()
ping_time = str(round((end_time - start_time), 2) % 60)
uptime = get_readable_time((time.time() - StartTime))
update.effective_message.reply_text(f"✨ Pong!\n��<b>Reply took:</b> {ping_time}s\n🔮<b>Service Uptime:</b> {uptime}", parse_mode=ParseMode.HTML)
@run_async
def uptime(bot: Bot, update: Update):
uptime = get_readable_time((time.time() - StartTime))
update.effective_message.reply_text(f"🔮Service Uptime: {uptime}")
__help__ = """
- /ping :get ping time of bot to telegram server
- /uptime: Find last service update time
"""
__mod_name__ = "PING"
PING_HANDLER = DisableAbleCommandHandler("ping", ping)
UPTIME_HANDLER = DisableAbleCommandHandler("uptime", uptime)
dispatcher.add_handler(UPTIME_HANDLER)
dispatcher.add_handler(PING_HANDLER)
"""
__mod_name__ = "REMOTE COMMANDS"
RBAN_HANDLER = CommandHandler("rban",
rban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNBAN_HANDLER = CommandHandler("runban",
runban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RKICK_HANDLER = CommandHandler("rkick",
rkick,
pass_args=True,
filters=CustomFilters.sudo_filter)
RMUTE_HANDLER = CommandHandler("rmute",
rmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNMUTE_HANDLER = CommandHandler("runmute",
runmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(RBAN_HANDLER)
dispatcher.add_handler(RUNBAN_HANDLER)
dispatcher.add_handler(RKICK_HANDLER)
dispatcher.add_handler(RMUTE_HANDLER)
dispatcher.add_handler(RUNMUTE_HANDLER)
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)
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)
from megumin.modules.helper_funcs.chat_status import is_user_admin, user_admin
from megumin.modules.helper_funcs.extraction import extract_user
#sleep how many times after each edit in 'police'
EDIT_SLEEP = 1
#edit how many times in 'police'
EDIT_TIMES = 6
police_siren = [
"🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵",
"🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴"
]
@user_admin
@run_async
def police(bot: Bot, update: Update):
msg = update.effective_message.reply_text('Police is coming!')
for x in range(EDIT_TIMES):
msg.edit_text(police_siren[x % 2])
time.sleep(EDIT_SLEEP)
msg.edit_text('🚴♂️Pling! Police Car was Breakdown')
POLICE_HANDLER = DisableAbleCommandHandler("police", police)
dispatcher.add_handler(POLICE_HANDLER)
__command_list__ = ["police"]
__handlers__ = [POLICE_HANDLER]
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)
LEAVE_MUTED_CHATS_HANDLER = CommandHandler("leavemutedchats", leave_muted_chats)
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]
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)
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
]
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]
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)
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)
msg.reply_text(rep, timeout=60)
except CFError as e:
bot.send_message(OWNER_ID,
f"lydia error: {e} occurred in {chat_id}!")
__mod_name__ = "LYDIA/CHATBOT"
__help__ = """
Commands
- /elydia : Enables Lydia mode in the chat.
- /dlydia : Disables Lydia mode in the chat.
"""
ADD_CHAT_HANDLER = CommandHandler("elydia",
add_chat,
filters=CustomFilters.dev_filter)
REMOVE_CHAT_HANDLER = CommandHandler("dlydia",
remove_chat,
filters=CustomFilters.dev_filter)
LYDIA_HANDLER = MessageHandler(
Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!")
& ~Filters.regex(r"^s\/")), lydia)
# Filters for ignoring #note messages, !commands and sed.
dispatcher.add_handler(ADD_CHAT_HANDLER)
dispatcher.add_handler(REMOVE_CHAT_HANDLER)
dispatcher.add_handler(LYDIA_HANDLER)
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"