__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, run_async=True)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex(r"^(?i)brb(.*)$"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
no_longer_afk,
run_async=True)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
reply_afk,
run_async=True)
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),
]
deletion(update, context, delmsg)
except ValueError:
delmsg = update.effective_message.reply_text("The intended language is not found!")
deletion(update, context, delmsg)
else:
return
def deletion(update: Update, context: CallbackContext, delmsg):
chat = update.effective_chat
cleartime = get_clearcmd(chat.id, "tr")
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
__help__ = """
• `/tr` or `/tl` (language code) as reply to a long message
*Example:*
`/tr en`*:* translates something to english
`/tr hi-en`*:* translates hindi to english
"""
TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate, run_async=True)
dispatcher.add_handler(TRANSLATE_HANDLER)
__mod_name__ = "Translator"
__command_list__ = ["tr", "tl"]
__handlers__ = [TRANSLATE_HANDLER]
def __stats__():
return "• {} blacklist stickers, across {} chats.".format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__mod_name__ = "Stickers Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker",
blackliststicker,
admin_ok=True,
run_async=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("addblsticker",
add_blackliststicker,
run_async=True)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"],
unblackliststicker,
run_async=True)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode",
blacklist_mode,
run_async=True)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker
& Filters.chat_type.groups,
del_blackliststicker,
run_async=True)
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)
*What is SpamWatch?*
SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/f584b643c6f4be0b1de53.jpg)
Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group.
*Note:* Users can appeal spamwatch bans at @SpamwatchSupport
"""
GBAN_HANDLER = CommandHandler("gban", gban, run_async=True)
UNGBAN_HANDLER = CommandHandler("ungban", ungban, run_async=True)
GBAN_LIST = CommandHandler("gbanlist", gbanlist, run_async=True)
GBAN_STATUS = CommandHandler("antispam",
gbanstat,
filters=Filters.chat_type.groups,
run_async=True)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.chat_type.groups,
enforce_gban,
run_async=True)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
__mod_name__ = "Anti-Spam"
__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
__handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
text = f.read()
with open("updates.txt", "w+") as f:
f.write(text +
f"\n-{event.from_id} ({event.chat_id}) : {event.text}")
else:
with open("updates.txt", "w+") as f:
f.write(
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}"
)
support_chat = os.getenv("SUPPORT_CHAT")
@dev_plus
def logs(update: Update, context: CallbackContext):
user = update.effective_user
with open("log.txt", "rb") as f:
context.bot.send_document(document=f, filename=f.name, chat_id=user.id)
LOG_HANDLER = CommandHandler("logs", logs, run_async=True)
dispatcher.add_handler(LOG_HANDLER)
DEBUG_HANDLER = CommandHandler("debug", debug, run_async=True)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
def get_chat(chat_id, chat_data):
# print(chat_data)
try:
return chat_data[chat_id]["backups"]
except KeyError:
return {"status": False, "value": False}
__mod_name__ = "Backups"
__help__ = """
*Only for group owner:*
• `/import`: Reply to the backup file for the butler / emilia group to import as much as possible, making transfers very easy! \
Note that files / photos cannot be imported due to telegram restrictions.
• `/export`: Export group data, which will be exported are: rules, notes (documents, images, music, video, audio, voice, text, text buttons) \
"""
IMPORT_HANDLER = CommandHandler("import", import_data, run_async=True)
EXPORT_HANDLER = CommandHandler("export",
export_data,
pass_chat_data=True,
run_async=True)
dispatcher.add_handler(IMPORT_HANDLER)
dispatcher.add_handler(EXPORT_HANDLER)
def load(update: Update, context: CallbackContext):
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("AnnaBot.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 imported_module.__mod_name__.lower() not 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 cannot be loaded.")
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, "__gdpr__"):
GDPR.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)
Visit @{SUPPORT_CHAT} for more information.
"""
SUDO_HANDLER = CommandHandler(("addsudo"), addsudo, run_async=True)
SUPPORT_HANDLER = CommandHandler(("addsupport"), addsupport, run_async=True)
WHITELIST_HANDLER = CommandHandler(("addwhitelist"), addwhitelist, run_async=True)
UNSUDO_HANDLER = CommandHandler(("removesudo"), removesudo, run_async=True)
UNSUPPORT_HANDLER = CommandHandler(("removesupport"), removesupport, run_async=True)
UNWHITELIST_HANDLER = CommandHandler(("removewhitelist"), removewhitelist, run_async=True)
WHITELISTLIST_HANDLER = CommandHandler(("whitelistlist"), whitelistlist, run_async=True)
SUPPORTLIST_HANDLER = CommandHandler(("supportlist"), supportlist, run_async=True)
SUDOLIST_HANDLER = CommandHandler(("sudolist"), sudolist, run_async=True)
DEVLIST_HANDLER = CommandHandler(("devlist"), devlist, run_async=True)
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__ = "Super users"
__handlers__ = [
SUDO_HANDLER,
SUPPORT_HANDLER,
update.effective_message.reply_text("Done! Lockdown value toggled.")
@dev_plus
def leave(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
if args:
chat_id = str(args[0])
try:
bot.leave_chat(int(chat_id))
except TelegramError:
update.effective_message.reply_text(
"Beep boop, I could not leave that group(dunno why tho).")
return
with suppress(Unauthorized):
update.effective_message.reply_text(
"Beep boop, I left that soup!.")
else:
update.effective_message.reply_text("Send a valid chat ID")
LEAVE_HANDLER = CommandHandler("leave", leave, run_async=True)
ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups, run_async=True)
dispatcher.add_handler(ALLOWGROUPS_HANDLER)
dispatcher.add_handler(LEAVE_HANDLER)
__mod_name__ = "Dev"
__handlers__ = [LEAVE_HANDLER, ALLOWGROUPS_HANDLER]
STOP_HANDLER = CommandHandler("stop", stop_filter)
RMALLFILTER_HANDLER = CommandHandler("removeallfilters",
rmall_filters,
filters=Filters.chat_type.groups,
run_async=True)
RMALLFILTER_CALLBACK = CallbackQueryHandler(rmall_callback,
pattern=r"filters_.*",
run_async=True)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True,
run_async=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text
& ~Filters.update.edited_message,
reply_filter,
run_async=True)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
dispatcher.add_handler(RMALLFILTER_HANDLER)
dispatcher.add_handler(RMALLFILTER_CALLBACK)
__handlers__ = [
FILTER_HANDLER,
STOP_HANDLER,
LIST_HANDLER,
(CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER),
]
if val in ["off", "no", "0", "disable", "false"]:
setprivatenotes(chat.id, False)
msg = f"Private notes has been disabled in *{chat.title}*"
elif val in ["on", "yes", "1", "enable", "true"]:
setprivatenotes(chat.id, True)
msg = f"Private notes has been enabled in *{chat.title}*"
else:
msg = "Sorry, wrong value"
message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def setprivatenotes(chat_id, setting):
sql.set_private_notes(chat_id, setting)
def getprivatenotes(chat_id):
setting = sql.get_private_notes(chat_id)
return setting
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
PRIVATENOTES_HANDLER = CommandHandler("privatenotes",
privatenotes,
run_async=True)
dispatcher.add_handler(PRIVATENOTES_HANDLER)
• `/twrp <devicecodename>`: fetches lastest TWRP available for a given device codename\n
*MIUI:*
• `/miui <devicecodename>`- fetches latest firmware info for a given device codename\n
*Phh:*
• `/phh`: get lastest phh builds from github\n
*Samsung:*
• `/checkfw <model> <csc>` - Samsung only - shows the latest firmware info for the given device, taken from samsung servers
• `/getfw <model> <csc>` - Samsung only - gets firmware download links from samfrew, sammobile and sfirmwares for the given device
"""
MAGISK_HANDLER = CommandHandler(["magisk", "root", "su"], magisk, run_async=True)
ORANGEFOX_HANDLER = CommandHandler("orangefox", orangefox, run_async=True)
TWRP_HANDLER = CommandHandler("twrp", twrp, run_async=True)
GETFW_HANDLER = CommandHandler("getfw", getfw, run_async=True)
CHECKFW_HANDLER = CommandHandler("checkfw", checkfw, run_async=True)
PHH_HANDLER = CommandHandler("phh", phh, run_async=True)
MIUI_HANDLER = CommandHandler("miui", miui, run_async=True)
dispatcher.add_handler(MAGISK_HANDLER)
dispatcher.add_handler(ORANGEFOX_HANDLER)
dispatcher.add_handler(TWRP_HANDLER)
dispatcher.add_handler(GETFW_HANDLER)
dispatcher.add_handler(CHECKFW_HANDLER)
dispatcher.add_handler(PHH_HANDLER)
dispatcher.add_handler(MIUI_HANDLER)
__mod_name__ = "Android"
__command_list__ = ["magisk", "root", "su", "orangefox", "twrp", "checkfw", "getfw", "phh", "miui"]
__handlers__ = [MAGISK_HANDLER, ORANGEFOX_HANDLER, TWRP_HANDLER, GETFW_HANDLER, CHECKFW_HANDLER, PHH_HANDLER, MIUI_HANDLER]
filters=Filters.chat_type.groups,
run_async=True)
INVITE_HANDLER = DisableAbleCommandHandler(["invitelink", "link"],
invite,
run_async=True)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, run_async=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, run_async=True)
SET_TITLE_HANDLER = CommandHandler("title", set_title, run_async=True)
ADMIN_REFRESH_HANDLER = CommandHandler("admincache",
refresh_admin,
filters=Filters.chat_type.groups)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(SET_TITLE_HANDLER)
dispatcher.add_handler(ADMIN_REFRESH_HANDLER)
__mod_name__ = "Admin"
__command_list__ = [
"adminlist",
"admins",
"invitelink",
"promote",
"demote",
• `/ud <word>`*:* type the word or expression you want to search use\n
*Wikipedia:*
• `/wiki <query>`*:* wikipedia your query\n
*Wallpapers:*
• `/wall <query>`*:* get a wallpaper from wall.alphacoders.com\n
*Currency converter:*
• `/cash`*:* currency converter
Example:
`/cash 1 USD INR`
_OR_
`/cash 1 usd inr`
Output: `1.0 USD = 75.505 INR`\n
*Timezones:*
• `/time <query>`*:* Gives information about a timezone.
*Available queries:* Country Code/Country Name/Timezone Name
• 🕐 [Timezones list](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.chat_type.groups, run_async=True)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, run_async=True)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo", "covid", "weather", "quotly"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
]
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid, run_async=True)
INFO_HANDLER = DisableAbleCommandHandler(("info", "book"),
info,
run_async=True)
GDPR_HANDLER = CommandHandler("gdpr",
gdpr,
filters=Filters.chat_type.private,
run_async=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme",
set_about_me,
run_async=True)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, run_async=True)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(GDPR_HANDLER)
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__ = "Info"
__command_list__ = ["setbio", "bio", "setme", "me", "info", "gprd"]
__handlers__ = [
ID_HANDLER,
GIFID_HANDLER,
INFO_HANDLER,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.effective_chat.id,
parse_mode=ParseMode.HTML,
)
try:
for f in glob.glob("result.txt"):
os.remove(f)
except Exception:
pass
else:
msg = 'Give me something to get from Wikipedia, like:\n`/wiki Madrid`'
delmsg = message.reply_text(
text = msg,
parse_mode = ParseMode.MARKDOWN,
disable_web_page_preview = True,
)
cleartime = get_clearcmd(chat.id, "wiki")
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True)
dispatcher.add_handler(WIKI_HANDLER)
update.effective_message.reply_text("'backups' directory has been purged!")
def term(cmd, info):
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
log.info(f"{info} successful!")
log.info(f"{stdout}")
if stderr:
log.error(f"error while running {info}")
log.info(f"{stderr}")
from AnnaBot import updater as u
# run the backup daliy at 1:00
twhen = datetime.datetime.strptime('01:00', '%H:%M').time()
j = u.job_queue
cronjob = j.run_daily(callback=backup_db, name="database backups", time=twhen)
dispatcher.add_handler(CommandHandler("backupdb", backup_now, run_async=True))
dispatcher.add_handler(CommandHandler("stopjobs", stop_jobs, run_async=True))
dispatcher.add_handler(CommandHandler("startjobs", start_jobs, run_async=True))
dispatcher.add_handler(
CommandHandler("purgebackups", del_bkp_fldr, run_async=True))
def main():
test_handler = CommandHandler("test", test, run_async=True)
start_handler = CommandHandler("start", start, run_async=True)
help_handler = CommandHandler("help", get_help, run_async=True)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_.*", run_async=True)
settings_handler = CommandHandler("settings", get_settings, run_async=True)
settings_callback_handler = CallbackQueryHandler(settings_button, pattern=r"stngs_", run_async=True)
donate_handler = CommandHandler("donate", donate, run_async=True)
migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(settings_handler)
dispatcher.add_handler(help_callback_handler)
dispatcher.add_handler(settings_callback_handler)
dispatcher.add_handler(migrate_handler)
dispatcher.add_handler(donate_handler)
dispatcher.add_error_handler(error_callback)
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
if CERT_PATH:
updater.bot.set_webhook(url=URL + TOKEN, certificate=open(CERT_PATH, "rb"))
else:
updater.bot.set_webhook(url=URL + TOKEN)
else:
LOGGER.info("Using long polling.")
updater.start_polling(timeout=15, read_latency=4, drop_pending_updates=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
unload_messasge.edit_text(f"Successfully unloaded module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
@sudo_plus
def listmodules(update: Update, context: CallbackContext):
message = update.effective_message
module_list = []
for helpable_module in HELPABLE:
helpable_module_info = IMPORTED[helpable_module]
file_info = IMPORTED[helpable_module_info.__mod_name__.lower()]
file_name = file_info.__name__.rsplit("AnnaBot.modules.", 1)[1]
mod_name = file_info.__mod_name__
module_list.append(f"- <code>{mod_name} ({file_name})</code>\n")
module_list = "Following modules are loaded : \n\n" + "".join(module_list)
message.reply_text(module_list, parse_mode=ParseMode.HTML)
LOAD_HANDLER = CommandHandler("load", load, run_async=True)
UNLOAD_HANDLER = CommandHandler("unload", unload, run_async=True)
LISTMODULES_HANDLER = CommandHandler("listmodules",
listmodules,
run_async=True)
dispatcher.add_handler(LOAD_HANDLER)
dispatcher.add_handler(UNLOAD_HANDLER)
dispatcher.add_handler(LISTMODULES_HANDLER)
__mod_name__ = "Modules"
)
else:
msg.reply_text(
"Failed to create sticker pack. Possibly due to blek mejik.")
__help__ = """
• `/stickerid`*:* reply to a sticker to me to tell you its file ID.
• `/getsticker`*:* reply to a sticker to me to upload its raw PNG file.
• `/kang`*:* reply to a sticker to add it to your pack.
• `/stickers`*:* Find stickers for given term on combot sticker catalogue
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid",
stickerid,
run_async=True)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
admin_ok=True,
run_async=True)
STICKERS_HANDLER = DisableAbleCommandHandler("stickers",
cb_sticker,
run_async=True)
dispatcher.add_handler(STICKERS_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_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,
run_async=True)
dispatcher.add_handler(COMMON_CHATS_HANDLER)
• `/connect`: Connects to chat (Can be done in a group by `/connect` or `/connect <chat id>` in PM)
• `/connection`: List connected chats
• `/disconnect`: Disconnect from a chat
• `/helpconnect`: List available commands that can be used remotely
*Admin only:*
• `/allowconnect <yes/no>`: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, run_async=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection",
connection_chat,
run_async=True)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect",
disconnect_chat,
run_async=True)
ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect",
allow_connections,
run_async=True)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button,
pattern=r"connect",
run_async=True)
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)
RESET_WARN_HANDLER = CommandHandler(
["resetwarn", "resetwarns"], reset_warns, filters=Filters.chat_type.groups, run_async=True
)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, filters=Filters.chat_type.groups, run_async=True)
ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.chat_type.groups, run_async=True)
RM_WARN_HANDLER = CommandHandler(
["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.chat_type.groups
)
LIST_WARN_HANDLER = DisableAbleCommandHandler(
["warnlist", "warnfilters"], list_warn_filters, filters=Filters.chat_type.groups, admin_ok=True, run_async=True
)
WARN_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & Filters.chat_type.groups, reply_filter, run_async=True
)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, filters=Filters.chat_type.groups, run_async=True)
WARN_STRENGTH_HANDLER = CommandHandler(
"strongwarn", set_warn_strength, filters=Filters.chat_type.groups, run_async=True
)
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)
eg:
Locking urls will auto-delete all messages with urls, locking stickers will restrict all \
non-admin users from sending stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
*Note:*
• Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name
• Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes",
locktypes,
run_async=True)
LOCK_HANDLER = CommandHandler(
"lock", lock) # , filters=Filters.chat_type.groups, run_async=True)
UNLOCK_HANDLER = CommandHandler(
"unlock", unlock, run_async=True) # , filters=Filters.chat_type.groups)
LOCKED_HANDLER = CommandHandler(
"locks", list_locks) # , filters=Filters.chat_type.groups, run_async=True)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.chat_type.groups, del_lockables),
PERM_GROUP)
lim = 10
imglinks = []
counter = 0
pattern = r"^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$"
oboi = re.findall(pattern, decoded, re.I | re.M)
for imglink in oboi:
counter += 1
imglinks.append(imglink)
if counter >= int(lim):
break
return imglinks
def deletion(update: Update, context: CallbackContext, delmsg):
chat = update.effective_chat
cleartime = get_clearcmd(chat.id, "reverse")
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
REVERSE_HANDLER = DisableAbleCommandHandler(
"reverse", reverse, admin_ok=True, run_async=True
)
dispatcher.add_handler(REVERSE_HANDLER)
• `/kaizoku <anime>`*:* search an anime on animekaizoku.com
• `/kayo <anime>`*:* search an anime on animekayo.com
• `/airing <anime>`*:* returns anime airing info.
"""
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime, run_async=True)
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing, run_async=True)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character, run_async=True)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga, run_async=True)
USER_HANDLER = DisableAbleCommandHandler("user", user, run_async=True)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming, run_async=True)
KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku, run_async=True)
KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo, run_async=True)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(USER_HANDLER)
dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER)
dispatcher.add_handler(KAYO_SEARCH_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__mod_name__ = "Anime"
__command_list__ = [
"anime",
"manga",
"character",
"user",
"upcoming",
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue", set_blue_text_must_click, run_async=True)
ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore, run_async=True)
REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue", remove_bluetext_ignore, run_async=True)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"gignoreblue", add_bluetext_ignore_global, run_async=True
)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global, run_async=True
)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list, run_async=True)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(
Filters.command & Filters.chat_type.groups, clean_blue_text_must_click, run_async=True
)
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,
*Admin commands:*
- `/approval`*:* Check a user's approval status in this chat.
- `/approve`*:* Approve of a user. Locks, blacklists, and antiflood won't apply to them anymore.
- `/unapprove`*:* Unapprove of a user. They will now be subject to locks, blacklists, and antiflood again.
- `/approved`*:* List all approved users.
- `/unapproveall`*:* Unapprove *ALL* users in a chat. This cannot be undone.
"""
APPROVE = DisableAbleCommandHandler("approve", approve, run_async=True)
DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, run_async=True)
APPROVED = DisableAbleCommandHandler("approved", approved, run_async=True)
APPROVAL = DisableAbleCommandHandler("approval", approval, run_async=True)
UNAPPROVEALL = DisableAbleCommandHandler("unapproveall",
unapproveall,
run_async=True)
UNAPPROVEALL_BTN = CallbackQueryHandler(unapproveall_btn,
pattern=r"unapproveall_.*",
run_async=True)
dispatcher.add_handler(APPROVE)
dispatcher.add_handler(DISAPPROVE)
dispatcher.add_handler(APPROVED)
dispatcher.add_handler(APPROVAL)
dispatcher.add_handler(UNAPPROVEALL)
dispatcher.add_handler(UNAPPROVEALL_BTN)
__mod_name__ = "Approvals"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
msg = "I don't understand what are you trying to do. Check module help for more details"
message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = """
*Get module configuration:*
• `/clearcmd`: provides all commands that has been set in current group with their deletion time
• `/clearcmd list`: list all available commands for this module
• `/clearcmd <command>`: get the deletion time for a specific `<command>`
*Set module configuration:*
• `/clearcmd <command> <time>`: set a deletion `<time>` for a specific `<command>` in current group. All outputs of that command will be deleted in that group after time value in seconds. Time can be set between 5 and 300 seconds
*Restore module configuration:*
• `/clearcmd restore`: the deletion time set for ALL commands will be removed in current group
• `/clearcmd <command> restore`: the deletion time set for a specific `<command>` will be removed in current group
"""
CLEARCMD_HANDLER = CommandHandler("clearcmd", clearcmd, run_async=True)
dispatcher.add_handler(CLEARCMD_HANDLER)
__mod_name__ = "Clear Commands"
__command_list__ = ["clearcmd"]
__handlers__ = [CLEARCMD_HANDLER]
• `/report <reason>`*:* reply to a message to report it to admins.
• `@admin`*:* reply to a message to report it to admins.
*NOTE:* Neither of these will get triggered if used by admins.
*Admins only:*
• `/reports <on/off>`*:* change report setting, or view current status.
• If done in pm, toggles your status.
• If in group, toggles that groups's status.
"""
SETTING_HANDLER = CommandHandler("reports", report_setting, run_async=True)
REPORT_HANDLER = CommandHandler("report",
report,
filters=Filters.chat_type.groups,
run_async=True)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex(r"(?i)@admin(s)?"), report)
REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
__mod_name__ = "Reporting"
__handlers__ = [
(REPORT_HANDLER, REPORT_GROUP),
(ADMIN_REPORT_HANDLER, REPORT_GROUP),
(SETTING_HANDLER),
]
