def main():
# test_handler = CommandHandler("test", test) #Unused variable
start_handler = CommandHandler("start", start, pass_args=True)
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
start_callback_handler = CallbackQueryHandler(send_start,
pattern=r"bot_start")
migrate_handler = MessageHandler(Filters.status_update.migrate,
migrate_chats)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(start_callback_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(help_callback_handler)
dispatcher.add_handler(migrate_handler)
# dispatcher.add_error_handler(error_callback)
# add antiflood processor
Dispatcher.process_update = process_update
LOGGER.info("Using long polling.")
# updater.start_polling(timeout=15, read_latency=4, clean=True)
updater.start_polling(poll_interval=0.0,
timeout=10,
clean=True,
bootstrap_retries=-1,
read_latency=3.0)
LOGGER.info("Successfully loaded")
if len(argv) not in (1, 3, 4):
tbot.disconnect()
else:
tbot.run_until_disconnected()
updater.idle()
text += tld(chat.id, "language_sel_user_lang")
bot.edit_message_text(
chat_id=query.message.chat_id,
message_id=query.message.message_id,
text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton("English (US) 🇺🇸",
callback_data="set_lang_en-US"),
InlineKeyboardButton("العربية 🇸🇾",
callback_data="set_lang_ar")
]] + [[
InlineKeyboardButton(f"{tld(chat.id, 'btn_go_back')}",
callback_data="bot_start")
]]))
# query.message.delete()
bot.answer_callback_query(query.id)
LOCALE_HANDLER = CommandHandler(["set_locale", "locale", "lang", "setlang"],
locale,
pass_args=True)
locale_handler = CallbackQueryHandler(locale_button, pattern="chng_lang")
set_locale_handler = CallbackQueryHandler(locale_button, pattern=r"set_lang_")
dispatcher.add_handler(LOCALE_HANDLER)
dispatcher.add_handler(locale_handler)
dispatcher.add_handler(set_locale_handler)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
cleanservice,
pass_args=True,
filters=Filters.group)
SETCAS_HANDLER = CommandHandler("setcas", setcas, filters=Filters.group)
GETCAS_HANDLER = CommandHandler("getcas", get_current_setting, filters=Filters.group)
CASCHECK_HANDLER = CommandHandler("cascheck", caschecker, pass_args=True)
CASQUERY_HANDLER = CommandHandler("casquery", casquery, pass_args=True ,filters=CustomFilters.sudo_filter)
SETBAN_HANDLER = CommandHandler("setban", setban, filters=Filters.group)
DEFENSE_HANDLER = CommandHandler("defense", setDefense, pass_args=True)
help_callback_handler = CallbackQueryHandler(check_bot_button,
pattern=r"check_bot_")
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(SECURITY_HANDLER)
dispatcher.add_handler(SECURITY_MUTE_HANDLER)
dispatcher.add_handler(SECURITY_BUTTONTXT_HANDLER)
dispatcher.add_handler(SECURITY_BUTTONRESET_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(SETCAS_HANDLER)
dispatcher.add_handler(GETCAS_HANDLER)
def __user_info__(user_id, chat_id):
bio = html.escape(sql.get_user_bio(user_id) or "")
me = html.escape(sql.get_user_me_info(user_id) or "")
if bio and me:
return tld(chat_id, "userinfo_what_i_and_other_say").format(me, bio)
elif bio:
return tld(chat_id, "userinfo_what_other_say").format(bio)
elif me:
return tld(chat_id, "userinfo_what_i_say").format(me)
else:
return ""
def __gdpr__(user_id):
sql.clear_user_info(user_id)
sql.clear_user_bio(user_id)
__help__ = True
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)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __stats__():
return "• `{}` blacklist triggers, across `{}` chats.".format(
sql.num_blacklist_filters(), sql.num_blacklist_filter_chats())
__help__ = True
#TODO: Add blacklist alternative modes: warn, ban, kick, or mute.
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)
__help__ = True
PIN_HANDLER = DisableAbleCommandHandler("pin",
pin,
pass_args=True,
filters=Filters.group)
UNPIN_HANDLER = DisableAbleCommandHandler("unpin",
unpin,
filters=Filters.group)
INVITE_HANDLER = CommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, pass_args=True)
REACT_HANDLER = DisableAbleCommandHandler("reaction",
reaction,
pass_args=True,
filters=Filters.group)
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"],
adminlist)
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(ADMINLIST_HANDLER)
dispatcher.add_handler(REACT_HANDLER)
test.download()
test.upload()
test.results.share()
result = test.results.dict()
del_msg.delete()
update.effective_message.reply_text("<b>SpeedTest Results</b> \n\n"
"<b>Download:</b> "
f"<code>{speed_convert(result['download'])}</code> \n"
"<b>Upload:</b> "
f"<code>{speed_convert(result['upload'])}</code> \n"
"<b>Ping:</b> "
f"<code>{result['ping']}</code> \n"
"<b>ISP:</b> "
f"<code>{result['client']['isp']}</code>",
parse_mode=ParseMode.HTML)
STATUS_HANDLER = CommandHandler("status", status, filters=CustomFilters.sudo_filter)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
PING_HANDLER = CommandHandler("cping", ping, filters=CustomFilters.sudo_filter)
SPEED_HANDLER = CommandHandler("speed", speedtst, filters=CustomFilters.sudo_filter)
PONG_HANDLER = CommandHandler("ping", pong)
LOG_HANDLER = DisableAbleCommandHandler("log", log, filters=Filters.user(OWNER_ID))
dispatcher.add_handler(STATUS_HANDLER)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(SPEED_HANDLER)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(PONG_HANDLER)
dispatcher.add_handler(LOG_HANDLER)
DEMOTE_FED_HANDLER = CommandHandler("fdemote", user_demote_fed, pass_args=True)
INFO_FED_HANDLER = CommandHandler("fedinfo", fed_info, pass_args=True)
BAN_FED_HANDLER = DisableAbleCommandHandler(["fban", "fedban"],
fed_ban,
pass_args=True)
UN_BAN_FED_HANDLER = CommandHandler("unfban", unfban, pass_args=True)
FED_SET_RULES_HANDLER = CommandHandler("setfrules", set_frules, pass_args=True)
FED_GET_RULES_HANDLER = CommandHandler("frules", get_frules, pass_args=True)
FED_CHAT_HANDLER = CommandHandler("chatfed", fed_chat, pass_args=True)
FED_ADMIN_HANDLER = CommandHandler("fedadmins", fed_admin, pass_args=True)
FED_NOTIF_HANDLER = CommandHandler("fednotif", fed_notif, pass_args=True)
FED_CHATLIST_HANDLER = CommandHandler("fedchats", fed_chats, pass_args=True)
DELETEBTN_FED_HANDLER = CallbackQueryHandler(del_fed_button, pattern=r"rmfed_")
dispatcher.add_handler(NEW_FED_HANDLER)
dispatcher.add_handler(DEL_FED_HANDLER)
dispatcher.add_handler(JOIN_FED_HANDLER)
dispatcher.add_handler(LEAVE_FED_HANDLER)
dispatcher.add_handler(PROMOTE_FED_HANDLER)
dispatcher.add_handler(DEMOTE_FED_HANDLER)
dispatcher.add_handler(INFO_FED_HANDLER)
dispatcher.add_handler(BAN_FED_HANDLER)
dispatcher.add_handler(UN_BAN_FED_HANDLER)
dispatcher.add_handler(FED_SET_RULES_HANDLER)
dispatcher.add_handler(FED_GET_RULES_HANDLER)
dispatcher.add_handler(FED_CHAT_HANDLER)
dispatcher.add_handler(FED_ADMIN_HANDLER)
# dispatcher.add_handler(FED_NOTIF_HANDLER)
dispatcher.add_handler(FED_CHATLIST_HANDLER)
RELEASE_HANDLER = DisableAbleCommandHandler("git",
getRelease,
pass_args=True,
admin_ok=True)
FETCH_HANDLER = DisableAbleCommandHandler("fetch",
cmdFetch,
pass_args=True,
admin_ok=True)
SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, pass_args=True)
DELREPO_HANDLER = CommandHandler("delrepo", delRepo, pass_args=True)
LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo",
listRepo,
admin_ok=True)
VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True)
CHANGELOG_HANDLER = DisableAbleCommandHandler("changelog",
changelog,
pass_args=True,
admin_ok=True)
HASHFETCH_HANDLER = RegexHandler(r"^&[^\s]+", hashFetch)
dispatcher.add_handler(RELEASE_HANDLER)
dispatcher.add_handler(FETCH_HANDLER)
dispatcher.add_handler(SAVEREPO_HANDLER)
dispatcher.add_handler(DELREPO_HANDLER)
dispatcher.add_handler(LISTREPO_HANDLER)
dispatcher.add_handler(HASHFETCH_HANDLER)
dispatcher.add_handler(VERCHECKER_HANDLER)
dispatcher.add_handler(CHANGELOG_HANDLER)
return ""
except Exception as err:
bot.sendMessage(text="Error: {}".format(err),
chat_id=query.message.chat_id,
parse_mode=ParseMode.HTML)
query.answer("❎ Failed to ban")
elif splitter[1] == "delete":
try:
bot.deleteMessage(splitter[0], splitter[3])
query.answer("✅ Message Deleted")
return ""
except Exception as err:
bot.sendMessage(text="Error: {}".format(err),
chat_id=query.message.chat_id,
parse_mode=ParseMode.HTML)
query.answer("❎ Failed to delete message!")
__help__ = True
REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group)
SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True)
ADMIN_REPORT_HANDLER = RegexHandler("(?i)@admin(s)?", report)
report_button_user_handler = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(report_button_user_handler)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
to_translate_text = remove_emoji(msg.reply_to_message.text)
else:
msg.reply_text(tld(chat.id, "translator_no_str"))
return
if not args:
msg.reply_text(tld(chat.id, 'translator_no_args'))
return
translator = Translator()
try:
translated = translator.translate(to_translate_text, dest=lan)
except ValueError as e:
msg.reply_text(tld(chat.id, 'translator_err').format(e))
src_lang = LANGUAGES[f'{translated.src.lower()}'].title()
dest_lang = LANGUAGES[f'{translated.dest.lower()}'].title()
translated_text = translated.text
msg.reply_text(tld(chat.id,
'translator_translated').format(src_lang,
to_translate_text,
dest_lang,
translated_text),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
dispatcher.add_handler(
DisableAbleCommandHandler("tr", do_translate, pass_args=True))
markdown_help,
filters=Filters.private)
STATS_HANDLER = CommandHandler("stats", stats, filters=Filters.user(OWNER_ID))
GDPR_HANDLER = CommandHandler("gdpr", gdpr, filters=Filters.private)
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)
UD_HANDLER = DisableAbleCommandHandler("ud", ud)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
COVID_HANDLER = DisableAbleCommandHandler("covid", covid, admin_ok=True)
dispatcher.add_handler(UD_HANDLER)
dispatcher.add_handler(PASTE_HANDLER)
dispatcher.add_handler(GET_PASTE_HANDLER)
dispatcher.add_handler(PASTE_STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(GDPR_HANDLER)
dispatcher.add_handler(
DisableAbleCommandHandler("removebotkeyboard", reply_keyboard_remove))
dispatcher.add_handler(WIKI_HANDLER)
dispatcher.add_handler(COVID_HANDLER)
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text="Start",
url=f"t.me/{bot.username}")
]]))
elif e.message == "Internal Server Error: created sticker set not found (500)":
msg.reply_text(tld(chat.id, 'stickers_kang_success').format(
packname, sticker_emoji),
parse_mode=ParseMode.MARKDOWN)
return
if success:
msg.reply_text(tld(chat.id,
'stickers_kang_success').format(packname, emoji),
parse_mode=ParseMode.MARKDOWN)
else:
msg.reply_text(tld(chat.id, 'stickers_pack_create_error'))
__help__ = True
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
pass_args=True,
admin_ok=True)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
def __stats__():
return "• `{}` notes, accross `{}` chats.".format(sql.num_notes(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
REMOVE_ALL_NOTES_HANDLER = CommandHandler("clearall", remove_all_notes)
DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True)
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
dispatcher.add_handler(REMOVE_ALL_NOTES_HANDLER)
filters=Filters.group,
admin_ok=True)
WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group,
reply_filter)
WARN_LIMIT_HANDLER = DisableAbleCommandHandler("warnlimit",
set_warn_limit,
pass_args=True,
filters=Filters.group,
admin_ok=True)
WARN_STRENGTH_HANDLER = CommandHandler("strongwarn",
set_warn_strength,
pass_args=True,
filters=Filters.group)
REMOVE_WARNS_HANDLER = CommandHandler(["rmwarn", "unwarn"],
remove_warns,
pass_args=True,
filters=Filters.group)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(RMWARN_QUERY_HANDLER)
dispatcher.add_handler(SENDRULES_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)
dispatcher.add_handler(REMOVE_WARNS_HANDLER)
URL_BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
add_blacklist_url,
filters=Filters.group,
pass_args=True,
admin_ok=True)
ADD_URL_BLACKLIST_HANDLER = CommandHandler("addurl",
add_blacklist_url,
filters=Filters.group)
RM_BLACKLIST_URL_HANDLER = CommandHandler("delurl",
rm_blacklist_url,
filters=Filters.group)
GET_BLACKLISTED_URLS = CommandHandler("geturl",
get_blacklisted_urls,
filters=Filters.group)
URL_DELETE_HANDLER = MessageHandler(Filters.entity("url"),
del_blacklist_url,
edited_updates=True)
__help__ = False
dispatcher.add_handler(URL_BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_URL_BLACKLIST_HANDLER)
dispatcher.add_handler(RM_BLACKLIST_URL_HANDLER)
dispatcher.add_handler(GET_BLACKLISTED_URLS)
dispatcher.add_handler(URL_DELETE_HANDLER)
admin_ok=True)
TEMPMUTE_HANDLER = DisableAbleCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True,
admin_ok=True)
TEMP_NOMEDIA_HANDLER = DisableAbleCommandHandler(["trestrict", "temprestrict"],
temp_nomedia,
pass_args=True,
admin_ok=True)
NOMEDIA_HANDLER = DisableAbleCommandHandler(["restrict", "nomedia"],
nomedia,
pass_args=True,
admin_ok=True)
MEDIA_HANDLER = DisableAbleCommandHandler("unrestrict",
media,
pass_args=True,
admin_ok=True)
MUTEME_HANDLER = DisableAbleCommandHandler("muteme",
muteme,
pass_args=True,
filters=Filters.group,
admin_ok=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
dispatcher.add_handler(TEMP_NOMEDIA_HANDLER)
dispatcher.add_handler(NOMEDIA_HANDLER)
dispatcher.add_handler(MEDIA_HANDLER)
dispatcher.add_handler(MUTEME_HANDLER)
update.effective_message.reply_text(res, parse_mode=ParseMode.MARKDOWN)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock",
lock,
pass_args=True,
filters=Filters.group)
UNLOCK_HANDLER = CommandHandler("unlock",
unlock,
pass_args=True,
filters=Filters.group)
LOCKED_HANDLER = CommandHandler("locks", list_locks, filters=Filters.group)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
tld(chat.id, "connection_err_no_admin"))
return
else:
return conn_id
else:
update.effective_message.reply_text(
tld(chat.id, "connection_err_unknown"))
disconnect_chat(bot, update)
return
else:
return False
__help__ = True
CONNECT_CHAT_HANDLER = CommandHandler(["connect", "connection"],
connect_chat,
allow_edited=True,
pass_args=True)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect",
disconnect_chat,
allow_edited=True)
ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect",
allow_connections,
allow_edited=True,
pass_args=True)
dispatcher.add_handler(CONNECT_CHAT_HANDLER)
dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER)
conn = connected(bot, update, chat, user.id)
if conn: chat_id = conn
else:
if chat.type == 'private':
msg.reply_text(tld(chat.id, 'common_cmd_group_only'))
return
chat_id = chat.id
sql.set_rules(chat_id, "")
update.effective_message.reply_text(tld(chat.id, 'rules_clean_success'))
def __stats__():
return "• `{}` chats have rules set.".format(sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
GET_RULES_HANDLER = CommandHandler("rules", get_rules)
SET_RULES_HANDLER = CommandHandler("setrules", set_rules)
RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
sql.num_disabled(), sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
DISABLE_HANDLER = CommandHandler("disable",
disable,
pass_args=True,
filters=Filters.group)
ENABLE_HANDLER = CommandHandler("enable",
enable,
pass_args=True,
filters=Filters.group)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"],
commands,
filters=Filters.group)
TOGGLE_HANDLER = CommandHandler("listcmds",
list_cmds,
filters=Filters.group)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
# dispatcher.add_handler(TOGGLE_HANDLER)
else:
DisableAbleCommandHandler = CommandHandler
DisableAbleRegexHandler = RegexHandler
ungban,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
UNGBANQ_HANDLER = CommandHandler("ungban_quicc",
ungban_quicc,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GBAN_LIST = CommandHandler("gbanlist",
gbanlist,
filters=Filters.user(OWNER_ID))
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban)
CLEAN_DELACC_HANDLER = CommandHandler("cleandelacc",
clear_gbans,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(ANTISPAM_STATUS)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(CLEAN_DELACC_HANDLER)
dispatcher.add_handler(UNGBANQ_HANDLER)
dispatcher.add_handler(GBAN_LIST)
if STRICT_ANTISPAM: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
BROADCAST_HANDLER = CommandHandler("broadcasts",
broadcast,
filters=Filters.user(OWNER_ID))
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
SNIPE_HANDLER = CommandHandler("snipe",
snipe,
pass_args=True,
filters=Filters.user(OWNER_ID))
GETLINK_HANDLER = CommandHandler("getlink",
getlink,
pass_args=True,
filters=Filters.user(OWNER_ID))
LEAVECHAT_HANDLER = CommandHandler("leavechat",
leavechat,
pass_args=True,
filters=Filters.user(OWNER_ID))
SLIST_HANDLER = CommandHandler("slist",
slist,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group,
chat_checker)
dispatcher.add_handler(SNIPE_HANDLER)
dispatcher.add_handler(GETLINK_HANDLER)
dispatcher.add_handler(LEAVECHAT_HANDLER)
dispatcher.add_handler(SLIST_HANDLER)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
log_channel = sql.stop_chat_logging(chat.id)
if log_channel:
try:
bot.send_message(
log_channel,
tld(chat.id, "log_channel_unlink_success").format(chat.title))
message.reply_text(tld(chat.id, "Log channel has been un-set."))
except Exception:
print("Nut")
else:
message.reply_text(tld(chat.id, "log_channel_unlink_none"))
def __stats__():
return "• `{}` log channels set.".format(sql.num_logchannels())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
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)
except Exception:
chat_name3 = ""
if chat_name1:
btn1 = "/connect {} - {}".format(history.chat_id1, chat_name1)
else:
btn1 = "/connect - {}".format(tld(chat.id, "keyboard_connect"))
if chat_name2:
btn2 = "/connect {} - {}".format(history.chat_id2, chat_name2)
else:
btn2 = ""
if chat_name3:
btn3 = "/connect {} - {}".format(history.chat_id3, chat_name3)
else:
btn3 = ""
#TODO: Remove except garbage
update.effective_message.reply_text(
tld(chat.id, "keyboard_updated"),
reply_markup=ReplyKeyboardMarkup([[
KeyboardButton("/help"),
KeyboardButton("/notes - {}".format(tld(chat.id,
"keyboard_notes")))
], [KeyboardButton(btn1)], [KeyboardButton(btn2)],
[KeyboardButton(btn3)]]))
KEYBOARD_HANDLER = CommandHandler(["keyboard"], keyboard)
dispatcher.add_handler(KEYBOARD_HANDLER)
admin_ok=True)
KICK_HANDLER = DisableAbleCommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group,
admin_ok=True)
UNBAN_HANDLER = DisableAbleCommandHandler("unban",
unban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
SBAN_HANDLER = DisableAbleCommandHandler("sban",
sban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(KICK_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(KICKME_HANDLER)
dispatcher.add_handler(BANME_HANDLER)
dispatcher.add_handler(SBAN_HANDLER)
query = msg.text
try:
if int(exp) < time():
ses = api_client.create_session()
ses_id = str(ses.id)
expires = str(ses.expires)
sql.set_ses(chat_id, ses_id, expires)
sesh, exp = sql.get_ses(chat_id)
except ValueError:
pass
try:
bot.send_chat_action(chat_id, action='typing')
rep = api_client.think_thought(sesh, query)
sleep(0.3)
msg.reply_text(rep, timeout=60)
except CFError as e:
bot.send_message(OWNER_ID, f"Chatbot error: {e} occurred in {chat_id}!")
__help__ = True
ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat, filters=Filters.user(OWNER_ID))
REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat, filters=Filters.user(OWNER_ID))
CHATBOT_HANDLER = MessageHandler(Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!")
& ~Filters.regex(r"^s\/")), chatbot)
# Filters for ignoring #note messages, !commands and sed.
dispatcher.add_handler(ADD_CHAT_HANDLER)
dispatcher.add_handler(REMOVE_CHAT_HANDLER)
dispatcher.add_handler(CHATBOT_HANDLER)
def check_afk(bot, update, user_id, fst_name, userc_id):
chat = update.effective_chat
if sql.is_afk(user_id):
user = sql.check_afk_status(user_id)
if not user.reason:
if int(userc_id) == int(user_id):
return
res = tld(chat.id, "status_afk_noreason").format(fst_name)
update.effective_message.reply_text(res)
else:
if int(userc_id) == int(user_id):
return
res = tld(chat.id,
"status_afk_reason").format(fst_name, user.reason)
update.effective_message.reply_text(res)
__help__ = True
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)
for fx in f_flist:
sql.remove_filter(chat.id, fx)
message.reply_text(tld(chat.id, "cust_filters_cleanup_success").format(x))
def __stats__():
return "• `{}` filters, across `{}` chats.".format(sql.num_filters(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
FILTER_HANDLER = DisableAbleCommandHandler("filter", filters)
STOP_HANDLER = DisableAbleCommandHandler("stop", stop_filter)
STOPALL_HANDLER = DisableAbleCommandHandler("stopall", stop_all_filters)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(STOPALL_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
def flood(bot: Bot, update: Update):
chat = update.effective_chat
limit = sql.get_flood_limit(chat.id)
if limit == 0:
update.effective_message.reply_text(tld(chat.id, "flood_status_off"))
else:
update.effective_message.reply_text(
tld(chat.id, "flood_status_on").format(limit))
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
# TODO: Add actions: ban/kick/mute/tban/tmute
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)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
