*Admin only:*
- /lock <type>: Lock items of a certain type (not available in private)
- /unlock <type>: Unlock items of a certain type (not available in private)
- /locks: The current list of locks in this chat.
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will restrict all \
non-admin users from sending stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CustomCommandHandler("lock", lock,
pass_args=True) #, filters=Filters.group)
UNLOCK_HANDLER = CustomCommandHandler(
"unlock", unlock, pass_args=True) #, filters=Filters.group)
LOCKED_HANDLER = CustomCommandHandler("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)
message.reply_text("Muted for {}!".format(time_val))
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 = CustomCommandHandler("mute",
mute,
pass_args=True,
filters=Filters.group)
UNMUTE_HANDLER = CustomCommandHandler("unmute",
unmute,
pass_args=True,
filters=Filters.group)
TEMPMUTE_HANDLER = CustomCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True,
filters=Filters.group)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
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 __gdpr__(user_id):
sql.del_user(user_id)
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 = CustomCommandHandler("chatlist",
chatlist,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
- /warns <userhandle>: get a user's number, and reason, of warnings.
- /warnlist: list of all current warning filters
*Admin only:*
- /warn <userhandle>: warn a user. After 3 warns, the user will be banned from the group. Can also be used as a reply.
- /resetwarn <userhandle>: reset the warnings for a user. Can also be used as a reply.
- /addwarn <keyword> <reply message>: set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
- /nowarn <keyword>: stop a warning filter
- /warnlimit <num>: set the warning limit
- /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CustomCommandHandler("warn", warn_user, pass_args=True, filters=Filters.group)
RESET_WARN_HANDLER = CustomCommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, filters=Filters.group)
ADD_WARN_HANDLER = CustomCommandHandler("addwarn", add_warn_filter, filters=Filters.group)
RM_WARN_HANDLER = CustomCommandHandler(["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 = CustomCommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group)
WARN_STRENGTH_HANDLER = CustomCommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(MYWARNS_HANDLER)
dispatcher.add_handler(ADD_WARN_HANDLER)
def __chat_settings__(chat_id, user_id):
return "This chat has had it's rules set: `{}`".format(
bool(sql.get_rules(chat_id)))
__help__ = """
- /rules: get the rules for this chat.
*Admin only:*
- /setrules <your rules here>: set the rules for this chat.
- /clearrules: clear the rules for this chat.
"""
__mod_name__ = "Rules"
GET_RULES_HANDLER = CustomCommandHandler("rules",
get_rules,
filters=Filters.group)
SET_RULES_HANDLER = CustomCommandHandler("setrules",
set_rules,
filters=Filters.group)
RESET_RULES_HANDLER = CustomCommandHandler("clearrules",
clear_rules,
filters=Filters.group)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
- /welcome noformat: shows current welcome settings, without the formatting - useful to recycle your welcome messages!
- /goodbye -> same usage and args as /welcome.
- /setwelcome <sometext>: set a custom welcome message. If used replying to media, uses that media.
- /setgoodbye <sometext>: set a custom goodbye message. If used replying to media, uses that media.
- /resetwelcome: reset to the default welcome message.
- /resetgoodbye: reset to the default goodbye message.
- /cleanwelcome <on/off>: On new member, try to delete the previous welcome message to avoid spamming the chat.
- /welcomehelp: view more formatting information for custom welcome/goodbye messages.
""".format(WELC_HELP_TXT)
__mod_name__ = "Greetings"
NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members, new_member)
LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member, left_member)
WELC_PREF_HANDLER = CustomCommandHandler("welcome", welcome, pass_args=True, filters=Filters.group)
GOODBYE_PREF_HANDLER = CustomCommandHandler("goodbye", goodbye, pass_args=True, filters=Filters.group)
SET_WELCOME = CustomCommandHandler("setwelcome", set_welcome, filters=Filters.group)
SET_GOODBYE = CustomCommandHandler("setgoodbye", set_goodbye, filters=Filters.group)
RESET_WELCOME = CustomCommandHandler("resetwelcome", reset_welcome, filters=Filters.group)
RESET_GOODBYE = CustomCommandHandler("resetgoodbye", reset_goodbye, filters=Filters.group)
CLEAN_WELCOME = CustomCommandHandler("cleanwelcome", clean_welcome, pass_args=True, filters=Filters.group)
WELCOME_HELP = CustomCommandHandler("welcomehelp", welcome_help)
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)
- /blacklist: View the current blacklisted words.
*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,
filters=Filters.group,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CustomCommandHandler("addblacklist",
add_blacklist,
filters=Filters.group)
UNBLACKLIST_HANDLER = CustomCommandHandler(["unblacklist", "rmblacklist"],
unblacklist,
filters=Filters.group)
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(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
def __chat_settings__(chat_id, user_id):
limit = sql.get_flood_limit(chat_id)
if limit == 0:
return "*Not* currently enforcing flood control."
else:
return "Antiflood is set to `{}` messages.".format(limit)
__help__ = """
- /flood: Get the current flood control setting
*Admin only:*
- /setflood <int/'no'/'off'>: enables or disables flood control
"""
__mod_name__ = "AntiFlood"
FLOOD_MUTE_HANDLER = MessageHandler(
Filters.all & ~Filters.status_update & Filters.group, check_flood)
SET_FLOOD_HANDLER = CustomCommandHandler("setflood",
set_flood,
pass_args=True,
filters=Filters.group)
FLOOD_HANDLER = CustomCommandHandler("flood", flood, filters=Filters.group)
dispatcher.add_handler(FLOOD_MUTE_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "There are `{}` custom filters here.".format(len(cust_filters))
__help__ = """
- /filters: list all active filters in this chat.
*Admin only:*
- /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword'\
is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \
keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \
doin?
- /stop <filter keyword>: stop that filter.
"""
__mod_name__ = "Filters"
FILTER_HANDLER = CustomCommandHandler("filter", filters)
STOP_HANDLER = CustomCommandHandler("stop", stop_filter)
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(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
- /notes or /saved: list all saved notes in this chat
If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \
be useful when updating a current note.
*Admin only:*
- /save <notename> <notedata>: saves notedata as a note with name notename
A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \
`buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check /markdownhelp for more info.
- /save <notename>: save the replied message as a note with name notename
- /clear <notename>: clear note with this name
"""
__mod_name__ = "Notes"
GET_HANDLER = CustomCommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get)
SAVE_HANDLER = CustomCommandHandler("save", save)
DELETE_HANDLER = CustomCommandHandler("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)
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 = CustomCommandHandler("logchannel", logging)
SET_LOG_HANDLER = CustomCommandHandler("setlog", setlog)
UNSET_LOG_HANDLER = CustomCommandHandler("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
sql.chat_should_report(chat_id))
def __user_settings__(user_id):
return "You receive reports from chats you're admin in: `{}`.\nToggle this with /reports in PM.".format(
sql.user_should_report(user_id))
__mod_name__ = "Reporting"
__help__ = """
- /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
*Admin only:*
- /reports <on/off>: change report setting, or view current status.
- If done in pm, toggles your status.
- If in chat, toggles that chat's status.
"""
REPORT_HANDLER = CustomCommandHandler("report", report, filters=Filters.group)
SETTING_HANDLER = CustomCommandHandler("reports",
report_setting,
pass_args=True)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex("(?i)@admin(s)?"), report)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
# /ip is for private use
__help__ = """
- /id: get the current group id. If used by replying to a message, gets that user's id.
- /runs: reply a random string from an array of replies.
- /slap: slap a user, or get slapped if not a reply.
- /info: get information about a user.
- /gdpr: deletes your information from the bot's database. Private chats only.
- /markdownhelp: quick summary of how markdown works in telegram - can only be called in private chats.
"""
__mod_name__ = "Misc"
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
IP_HANDLER = CustomCommandHandler("ip",
get_bot_ip,
filters=Filters.chat(OWNER_ID))
TIME_HANDLER = CustomCommandHandler("time", get_time, pass_args=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True)
ECHO_HANDLER = CustomCommandHandler("echo",
echo,
filters=CustomFilters.sudo_filter)
MD_HELP_HANDLER = CustomCommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)