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()
multiple triggers at once.
- /rmblacklist <triggers>: Same as above.
- /blacklistmode <ban/kick/mute/tban/tmute> <value>: select the action perform when warnings have been exceeded. ban/kick/mute/tmute/tban
Note:
- Value must be filled for tban and tmute, Can be:
`4m` = 4 minutes
`3h` = 4 hours
`2d` = 2 days
`1w` = 1 week
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist)
BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode",
blacklist_mode,
pass_args=True)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.group, del_blacklist)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
return text
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 f"This chat is enforcing *gbans*: `{sql.does_chat_gban(chat_id)}`."
__help__ = True
GBAN_HANDLER = CommandHandler("gban", gban, pass_args=True, filters=Filters.user(OWNER_ID))
UNGBAN_HANDLER = CommandHandler("ungban", ungban, pass_args=True, filters=Filters.user(OWNER_ID))
GBAN_LIST = CommandHandler("gbanlist", gbanlist, filters=Filters.user(OWNER_ID))
GBAN_STATUS = CommandHandler("antispam", gbanstat, filters=Filters.group, pass_args=True)
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)
__mod_name__ = "Anti-Spam"
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
#__handlers.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
return build_curr_disabled(chat_id)
__mod_name__ = "Command disabling"
__help__ = """
- /cmds: check the current status of disabled commands
*Admin only:*
- /enable <cmd name>: enable that command
- /disable <cmd name>: disable that command
- /listcmds: list all possible toggleable commands
- /disabledel: delete message when command is disabled
"""
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)
DISABLEDEL_HANDLER = CommandHandler("disabledel", disable_del)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
dispatcher.add_handler(DISABLEDEL_HANDLER)
else:
DisableAbleCommandHandler = CommandHandler
DisableAbleMessageHandler = MessageHandler
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)
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
__mod_name__ = "Bios/Abouts"
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 __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)
SECURITY_BUTTONTXT_HANDLER = CommandHandler("setmutetext",
security_text,
pass_args=True,
filters=Filters.group)
SECURITY_BUTTONRESET_HANDLER = CommandHandler("resetmutetext",
security_text_reset,
filters=Filters.group)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
cleanservice,
pass_args=True,
filters=Filters.group)
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(help_callback_handler)
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)
MY_FEDS_LIST = CommandHandler("myfeds", get_myfeds_list)
DELETEBTN_FED_HANDLER = CallbackQueryHandler(del_fed_button, pattern=r"rmfed_")
FED_USERBAN_HANDLER = CommandHandler("fbanlist", fed_ban_list, pass_args=True)
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)
dispatcher.add_handler(MY_FEDS_LIST)
if user_id == dispatcher.bot.id:
return "I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me."
num_chats = sql.get_user_num_chats(user_id)
return "I've seen them in <code>{}</code> chats in total.".format(
num_chats)
def __stats__():
return "{} users, across {} chats".format(sql.num_users(), sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
__mod_name__ = "Users"
BROADCAST_HANDLER = CommandHandler("broadcast",
broadcast,
filters=Filters.user(OWNER_ID))
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist",
chats,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start, pass_args=True)
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_")
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(M_CONNECT_BTN_HANDLER)
# 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("Using long polling.")
updater.start_polling(timeout=15, read_latency=4)
updater.idle()
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)
- /permanentpin: Set a permanent pin for supergroup chat, when an admin or telegram channel change pinned message, bot will change pinned message immediatelly
- /promote: promotes the user replied to
- /demote: demotes the user replied to
"""
__mod_name__ = "Admin"
PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
PERMAPIN_HANDLER = CommandHandler("permapin", permapin, filters=Filters.group)
# INVITE_HANDLER = CommandHandler("invitelink", invite, filters=Filters.group)
PROMOTE_HANDLER = CommandHandler("promote", promote, pass_args=True, filters=Filters.group)
DEMOTE_HANDLER = CommandHandler("demote", demote, pass_args=True, filters=Filters.group)
PERMANENT_PIN_SET_HANDLER = CommandHandler("permanentpin", permanent_pin_set, pass_args=True, filters=Filters.group)
PERMANENT_PIN_HANDLER = MessageHandler(Filters.status_update.pinned_message | Filters.user(777000), permanent_pin)
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"], adminlist)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(PERMAPIN_HANDLER)
# dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(PERMANENT_PIN_SET_HANDLER)
dispatcher.add_handler(PERMANENT_PIN_HANDLER)
dispatcher.add_handler(ADMINLIST_HANDLER)
update.effective_message.reply_to_message.delete()
try:
update.effective_message.delete()
except BadRequest:
pass
return "<b>{}:</b>" \
"\n#DEL" \
"\n<b>• Admin:</b> {}" \
"\nMessage deleted.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
else:
send_message(update.effective_message, "Whadya want to delete?")
return ""
__help__ = """
*Admin only:*
- /del: deletes the message you replied to
- /purge: deletes all messages between this and the replied to message.
- /purge <integer X>: deletes the replied message, and X messages following it.
"""
__mod_name__ = "Purges"
DELETE_HANDLER = CommandHandler("del", del_message, filters=Filters.group)
PURGE_HANDLER = CommandHandler("purge", purge, filters=Filters.group, pass_args=True)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(PURGE_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)
# 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("stopfilter", 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)
else:
res = "{} is AFK! says its because of : {}".format(
fst_name, reason)
send_message(update.effective_message, res)
__help__ = """
- /afk <reason>: mark yourself as AFK.
- 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!
"""
__mod_name__ = "AFK"
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(
Filters.all & Filters.group & ~Filters.update.edited_message,
no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
# AFK_REPLY_HANDLER = MessageHandler(Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION),
# 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)
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)
return
chat_name = context.bot.get_chat(chat_id).title
context.bot.edit_message_media(
chat.id,
message_id=query.message.message_id,
media=InputMediaPhoto(
media="https://telegra.ph/file/32dbdc63c6957b8345a32.jpg",
caption=
"*Success!*\n\nGood work human, you can now chat in: *{}*".
format(chat_name),
parse_mode="markdown"))
query.answer(text="Success! You can chat in {} now".format(chat_name),
show_alert=True)
else:
context.bot.edit_message_media(
chat.id,
message_id=query.message.message_id,
media=InputMediaPhoto(
media="https://telegra.ph/file/32dbdc63c6957b8345a32.jpg",
caption=
"Sorry robot, you are clicked wrong button.\n\nTry again by click welcome security button.",
parse_mode="markdown"))
query.answer(text="Failed! You are clicked wrong button",
show_alert=True)
verify_callback_handler = CallbackQueryHandler(verify_button_pressed,
pattern=r"verify_me")
dispatcher.add_handler(verify_callback_handler)
msg.reply_text(
"Sending more messages than flood limit will result in {} in {}.".format(
settypeflood, chat.title
)
)
else:
msg.reply_text(
"Sending more message than flood limit will result in {}.".format(
settypeflood
)
)
return ""
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
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)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode, 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(SET_FLOOD_MODE_HANDLER)
parse_mode=ParseMode.HTML)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
send_message(update.effective_message,
"Well damn, I can't mute that user.")
return ""
__help__ = """
*Admin only:*
- /mute <userhandle>: silences a user. Can also be used as a reply, muting the replied to user.
- /tmute <userhandle> x(m/h/d): mutes a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
- /unmute <userhandle>: unmutes a user. Can also be used as a reply, muting the replied to user.
"""
__mod_name__ = "Muting"
MUTE_HANDLER = CommandHandler("mute", mute, pass_args=True)
UNMUTE_HANDLER = CommandHandler("unmute", unmute, pass_args=True)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
MYWARNS_HANDLER = DisableAbleCommandHandler(
"warns", warns, pass_args=True) #, filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn",
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)
WARN_MODE_HANDLER = CommandHandler("warnmode", set_warn_mode, pass_args=True)
# WARN_BTNSET_HANDLER = CallbackQueryHandler(WARN_EDITBTN, pattern=r"set_wlim")
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_MODE_HANDLER)
dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
# dispatcher.add_handler(WARN_BTNSET_HANDLER)
__help__ = """
Organize your group via PM easily.
- /connect <chatid/tag>: Connect to remote chat
- /connection: Request a list of supported command commands
- /disconnect: Disconnect from chat
- /allowconnect on/yes/off/no: Allow connecting non-admin users to groups
- /helpconnect: Get command help for connections
"""
__mod_name__ = "Connection"
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,
pass_args=True)
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)
return user_id, "This group has all it's logs sent to: {} (`{}`)".format(
escape_markdown(log_channel_info.title), log_channel)
return user_id, "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__ = "Channel Log"
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 __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__mod_name__ = "Users"
BROADCAST_HANDLER = CommandHandler("broadcast",
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))
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(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
for x in range(len(time_list)):
time_list[x] = str(time_list[x]) + time_suffix_list[x]
if len(time_list) == 4:
ping_time += time_list.pop() + ", "
time_list.reverse()
ping_time += ":".join(time_list)
return ping_time
@run_async
@user_admin
def ping(bot: Bot, update: Update):
msg = update.effective_message
start_time = time.time()
message = msg.reply_text("Just A Sec...")
end_time = time.time()
telegram_ping = str(round((end_time - start_time) * 1000, 3)) + " ms"
uptime = get_readable_time((time.time() - StartTime))
message.edit_text(
"<b>Ping:</b> <code>{}</code>\n"
"<b>Bot Uptime:</b> <code>{}</code>".format(telegram_ping, uptime),
parse_mode=ParseMode.HTML,
)
PING_HANDLER = DisableAbleCommandHandler("uptime", ping)
dispatcher.add_handler(PING_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)
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)
send_message(update.effective_message, text)
return
send_message(update.effective_message, text, parse_mode=ParseMode.HTML)
return
__help__ = """
- /cleanbluetext <on/off/yes/no> - clean commands after sending
- /ignorecleanbluetext <word> - prevent auto cleaning of the command
- /unignorecleanbluetext <word> - remove prevent auto cleaning of the command
- /listcleanbluetext - list currently whitelisted commands
"""
__mod_name__ = "Cleaner"
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanbluetext", set_blue_text_must_click, pass_args=True)
ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignorecleanbluetext", add_bluetext_ignore, 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)
__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.
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)