return update.effective_message.reply_text("Song %s not found!" %
song[1],
failed=True)
else:
lyricstext = LYRICSINFO % (song[0].replace(
" ", "_"), song[1].replace(" ", "_"))
return update.effective_message.reply_text(lyrics + lyricstext,
parse_mode="MARKDOWN")
else:
return update.effective_message.reply_text(
"Invalid args- try Artist - Title!", failed=True)
__help__ = """
Do you simply want to find the lyrics of your favourite songs? This command grabs you chunk of \
paragraphs for lyrics.
- /lyrics <keyword> Find your favourite songs' lyrics
An example of using lyrics:
`/lyrics Ariana Grande - God is a woman`; this sends you the lyrics.
`/lyrics Artist - Song title`.
"""
__mod_name__ = "Lyrics"
LYRICS_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "lyrics", lyrics)
dispatcher.add_handler(LYRICS_HANDLER)
fst_name, user.reason)
message.reply_text(res)
def __gdpr__(user_id):
sql.rm_afk(user_id)
__help__ = """
When marked as AFK, any mentions will be replied to with a message to say you're not available!
- /afk <reason>: mark yourself as AFK.
- brb <reason>: same as the afk command - but not a command.
"""
__mod_name__ = "AFK"
AFK_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "afk", afk)
AFK_REGEX_HANDLER = MessageHandler(Filters.regex("(?i)brb"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_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)
| CustomFilters.support_filter)
GBAN_LIST = CustomCommandHandler(CMD_PREFIX,
"gbanlist",
gbanlist,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GBAN_STATUS = CustomCommandHandler(CMD_PREFIX,
"gbanstat",
gbanstat,
filters=Filters.group)
GBAN_ALERT = CustomCommandHandler(CMD_PREFIX,
"gbanalert",
gbanalert,
filters=Filters.group)
PROOF_HANDLER = CustomCommandHandler(CMD_PREFIX, ["proof", "p"],
msg_evidence,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
dispatcher.add_handler(GBAN_ALERT)
dispatcher.add_handler(PROOF_HANDLER)
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
temp_ban,
filters=Filters.group)
KICK_HANDLER = CustomCommandHandler(CMD_PREFIX,
"kick",
kick,
filters=Filters.group)
UNBAN_HANDLER = CustomCommandHandler(CMD_PREFIX,
"unban",
unban,
filters=Filters.group)
KICKME_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"kickme",
kickme,
filters=Filters.group)
BANME_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"banme",
banme,
filters=Filters.group)
SBAN_HANDLER = CustomCommandHandler(CMD_PREFIX,
"sban",
sban,
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)
"""
__mod_name__ = "Locks & Whitelists"
LOCKTYPES_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "locktypes",
locktypes)
LOCK_HANDLER = CustomCommandHandler(CMD_PREFIX,
"lock",
lock,
filters=Filters.group)
UNLOCK_HANDLER = CustomCommandHandler(CMD_PREFIX,
"unlock",
unlock,
filters=Filters.group)
LOCKED_HANDLER = CustomCommandHandler(CMD_PREFIX,
"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 & (~Filters.user(777000)),
del_lockables), PERM_GROUP)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group & (~Filters.user(777000)),
rest_handler), REST_GROUP)
*Admin only:*
- /setrules <your rules here>: set the rules for this chat.
- /clearrules: clear the rules for this chat.
- /chatrules <yes/no/on/off>: should the rules be sent to chat. Default: no.
"""
__mod_name__ = "Rules"
GET_RULES_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"rules",
get_rules,
filters=Filters.group)
SET_RULES_MODE = CustomCommandHandler(CMD_PREFIX,
"chatrules",
chat_rules,
filters=Filters.group)
SET_RULES_HANDLER = CustomCommandHandler(CMD_PREFIX,
"setrules",
set_rules,
filters=Filters.group)
RESET_RULES_HANDLER = CustomCommandHandler(CMD_PREFIX,
"clearrules",
clear_rules,
filters=Filters.group)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_MODE)
dispatcher.add_handler(RESET_RULES_HANDLER)
for domain in all_whitelisted:
filter_list += " • <code>{}</code>\n".format(html.escape(domain))
split_text = split_message(filter_list)
for text in split_text:
if text == BASE_WHITELIST_STRING:
msg.reply_text("There are no whitelisted domains here!")
return
msg.reply_text(text.format(chat_name), parse_mode=ParseMode.HTML)
ADD_URL_WHITELIST_HANDLER = CustomCommandHandler(CMD_PREFIX,
"addwhitelist",
add_whitelist_url,
filters=Filters.group)
RM_WHITELIST_URL_HANDLER = CustomCommandHandler(CMD_PREFIX,
["unwhitelist", "rmwhitelist"],
rm_whitelist_url,
filters=Filters.group)
GET_WHITELISTED_URLS = DisableAbleCommandHandler(CMD_PREFIX,
"whitelist",
get_whitelisted_urls,
filters=Filters.group,
admin_ok=True)
__mod_name__ = "Domain whitelists"
dispatcher.add_handler(ADD_URL_WHITELIST_HANDLER)
dispatcher.add_handler(RM_WHITELIST_URL_HANDLER)
dispatcher.add_handler(GET_WHITELISTED_URLS)
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(CMD_PREFIX, "welcome", welcome, filters=Filters.group) GOODBYE_PREF_HANDLER = CustomCommandHandler(CMD_PREFIX, "goodbye", goodbye, filters=Filters.group) SET_WELCOME = CustomCommandHandler(CMD_PREFIX, "setwelcome", set_welcome, filters=Filters.group) SET_GOODBYE = CustomCommandHandler(CMD_PREFIX, "setgoodbye", set_goodbye, filters=Filters.group) RESET_WELCOME = CustomCommandHandler(CMD_PREFIX, "resetwelcome", reset_welcome, filters=Filters.group) RESET_GOODBYE = CustomCommandHandler(CMD_PREFIX, "resetgoodbye", reset_goodbye, filters=Filters.group) CLEAN_WELCOME = CustomCommandHandler(CMD_PREFIX, "cleanwelcome", clean_welcome, filters=Filters.group) WELCOMEMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX, "welcomemute", welcomemute, filters=Filters.group) DEL_JOINED_HANDLER = CustomCommandHandler(CMD_PREFIX, ["rmjoin", "cleanservice"], del_joined, filters=Filters.group) JOIN_EVENT_HANDLER = CustomCommandHandler(CMD_PREFIX, "joinlog", join_event_log, filters=Filters.group) WELCOME_HELP = CustomCommandHandler(CMD_PREFIX, "welcomehelp", welcome_help) BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button, pattern=r"user_join_") 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(WELCOMEMUTE_HANDLER) dispatcher.add_handler(BUTTON_VERIFY_HANDLER) dispatcher.add_handler(DEL_JOINED_HANDLER) dispatcher.add_handler(JOIN_EVENT_HANDLER) dispatcher.add_handler(WELCOME_HELP)
- /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.
Tip: To copy list of saved blacklist simply use `/blacklist copy`, {} will send non-bulleted list of blacklist.
""".format(dispatcher.bot.first_name)
BLACKLIST_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"blacklist",
blacklist,
filters=Filters.group,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CustomCommandHandler(CMD_PREFIX,
"addblacklist",
add_blacklist,
filters=Filters.group)
UNBLACKLIST_HANDLER = CustomCommandHandler(CMD_PREFIX,
["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)
You can disable the Global mutes by `/gmutestat off` or enable `/gmutestat on`.
*Admin only:*
- /gmutestat <on/off/yes/no>: Will disable the effect of global mutes on your group, or return your current settings.
- /gmutealert <on/off/yes/no>: Whether or not send global mute notification in the chat upon user join/speak in the chat.
""".format(dispatcher.bot.first_name, dispatcher.bot.first_name)
__mod_name__ = "Global Mutes"
GMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX, ["fmute", "gmute"], fmute,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
UNGMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX, ["unfmute", "ungmute"], ungmute,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GMUTE_LIST = CustomCommandHandler(CMD_PREFIX, "gmutelist", gmutelist,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GMUTE_STATUS = CustomCommandHandler(CMD_PREFIX, "gmutestat", gmutestat, filters=Filters.group)
GMUTE_ALERT = CustomCommandHandler(CMD_PREFIX, "gmutealert", gmutealert, filters=Filters.group)
GMUTE_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gmute)
dispatcher.add_handler(GMUTE_HANDLER)
dispatcher.add_handler(UNGMUTE_HANDLER)
dispatcher.add_handler(GMUTE_LIST)
dispatcher.add_handler(GMUTE_STATUS)
dispatcher.add_handler(GMUTE_ALERT)
if STRICT_GMUTE: # enforce GMUTES if this is set
dispatcher.add_handler(GMUTE_ENFORCER, GMUTE_ENFORCE_GROUP)
The above following commands will mute any spam flooders temporarily for 3 hours.
"""
__mod_name__ = "Anti-Flood"
FLOOD_BAN_HANDLER = MessageHandler(
Filters.all & ~Filters.status_update & Filters.group, check_flood)
SET_FLOOD_HANDLER = CustomCommandHandler(CMD_PREFIX,
"setflood",
set_flood,
filters=Filters.group)
SET_FLOOD_TIME_HANDLER = CustomCommandHandler(CMD_PREFIX,
"setfloodtime",
flood_time,
filters=Filters.group)
FLOOD_HANDLER = CustomCommandHandler(CMD_PREFIX,
"flood",
flood,
filters=Filters.group)
FLOOD_STRENGTH_HANDLER = CustomCommandHandler(CMD_PREFIX,
"strongflood",
set_flood_strength,
filters=Filters.group)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(SET_FLOOD_TIME_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_STRENGTH_HANDLER)
filters=Filters.group)
LIST_WARN_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
["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(CMD_PREFIX,
["warnlimit", "setwarnlimit"],
set_warn_limit,
filters=Filters.group)
# WARN_STRENGTH_HANDLER = CommandHandler(CMD_PREFIX, "strongwarn", set_warn_strength, pass_args=True, filters=Filters.group)
WARN_MODE_HANDLER = CustomCommandHandler(CMD_PREFIX,
["warnmode", "setwarnmode"],
set_warn_mode,
filters=Filters.group)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(REMOVE_WARNS_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_MODE_HANDLER)
dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
__help__ = ""
__mod_name__ = "Remote Commands"
RBAN_HANDLER = CustomCommandHandler(CMD_PREFIX,
"rban",
rban,
filters=CustomFilters.sudo_filter)
RUNBAN_HANDLER = CustomCommandHandler(CMD_PREFIX,
"runban",
runban,
filters=CustomFilters.sudo_filter)
RKICK_HANDLER = CustomCommandHandler(CMD_PREFIX,
"rkick",
rkick,
filters=CustomFilters.sudo_filter)
RMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"rmute",
rmute,
filters=CustomFilters.sudo_filter)
RUNMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"runmute",
runmute,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(RBAN_HANDLER)
dispatcher.add_handler(RUNBAN_HANDLER)
dispatcher.add_handler(RKICK_HANDLER)
dispatcher.add_handler(RMUTE_HANDLER)
dispatcher.add_handler(RUNMUTE_HANDLER)
*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.
- /solve <reason>: reply to a message to solve the report.
- /solved: same as /solve.
To report a user, simply reply to his message with @admin or /report; \
{} will then reply with a message stating that admins have been notified.
You MUST reply to a message to report a user; you can't just use @admin to tag admins for no reason!
Note that the report commands do not work when admins use them; or when used to report an admin. {} assumes that \
admins don't need to report, or be reported!
""".format(dispatcher.bot.first_name, dispatcher.bot.first_name)
REPORT_HANDLER = CustomCommandHandler(CMD_PREFIX,
"report",
report,
filters=Filters.group)
SOLVE_HANDLER = CustomCommandHandler(CMD_PREFIX, ["solve", "solved"],
report_solve,
filters=Filters.group)
SETTING_HANDLER = CustomCommandHandler(CMD_PREFIX, "reports", report_setting)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex("(?i)@admin(s)?"), report)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SOLVE_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
pass __help__ = """ - /addrss <link>: add an RSS link to the subscriptions. - /removerss <link>: removes the RSS link from the subscriptions. - /rss <link>: shows the link's data and the last entry, for testing purposes. - /listrss: shows the list of rss feeds that the chat is currently subscribed to. NOTE: In groups, only admins can add/remove RSS links to the group's subscription """ __mod_name__ = "RSS Feed" job = updater.job_queue job_rss_set = job.run_once(rss_set, 5) job_rss_update = job.run_repeating(rss_update, interval=60, first=60) job_rss_set.enabled = True job_rss_update.enabled = True SHOW_URL_HANDLER = CustomCommandHandler(CMD_PREFIX, "rss", show_url) ADD_URL_HANDLER = CustomCommandHandler(CMD_PREFIX, "addrss", add_url) REMOVE_URL_HANDLER = CustomCommandHandler(CMD_PREFIX, "removerss", remove_url) LIST_URLS_HANDLER = CustomCommandHandler(CMD_PREFIX, "listrss", list_urls) dispatcher.add_handler(SHOW_URL_HANDLER) dispatcher.add_handler(ADD_URL_HANDLER) dispatcher.add_handler(REMOVE_URL_HANDLER) dispatcher.add_handler(LIST_URLS_HANDLER)
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 = CustomCommandHandler(CMD_PREFIX,
"broadcast",
broadcast,
filters=Filters.user(OWNER_ID)
| CustomFilters.isudo_filter)
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHATLIST_HANDLER = CustomCommandHandler(CMD_PREFIX,
"chatlist",
chats,
filters=Filters.user(OWNER_ID)
| CustomFilters.isudo_filter)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
from natalie_bot.modules.helper_funcs.filters import CustomFilters
from natalie_bot import dispatcher, OWNER_ID, iSUDO_USERS, CMD_PREFIX
@run_async
@bot_admin
def getlink(update: Update, context: CallbackContext):
if context.args:
chat_id = int(context.args[0])
else:
update.effective_message.reply_text(
"You don't seem to be referring to a chat")
chat = context.bot.get_chat(chat_id)
bot_member = chat.get_member(context.bot.id)
if bot_member.can_invite_users:
invitelink = context.bot.exportChatInviteLink(chat_id)
update.effective_message.reply_text(invitelink)
else:
update.effective_message.reply_text(
"I don't have access to the invite link!")
GETLINK_HANDLER = CustomCommandHandler(CMD_PREFIX,
"getlink",
getlink,
filters=Filters.user(OWNER_ID)
| CustomFilters.isudo_filter)
dispatcher.add_handler(GETLINK_HANDLER)
"Sticker pack successfully created. Get it [here](t.me/addstickers/%s)"
% packname,
parse_mode=ParseMode.MARKDOWN)
else:
msg.reply_text("Failed to create sticker pack.")
__help__ = """
Kanging or fetching ID of stickers are made easy! With this stickers command you simply can grab \
raw png file, creating new pack or fetch ID of sticker.
- /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.
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "stickerid",
stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "getsticker",
getsticker)
KANG_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"kang",
kang,
admin_ok=True)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
""".format(dispatcher.bot.first_name)
DISABLE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"disable",
disable,
filters=Filters.group)
ENABLE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"enable",
enable,
filters=Filters.group)
# DISABLEDEL_HANDLER = CommandHandler("disabledel", disable_del, pass_args=True, filters=Filters.group)
COMMANDS_HANDLER = CustomCommandHandler(CMD_PREFIX, ["cmds", "disabled"],
commands,
filters=Filters.group)
TOGGLE_HANDLER = CustomCommandHandler(CMD_PREFIX,
["disableable", "listcmds"],
list_cmds,
filters=Filters.group)
# DISABLEDEL = MessageHandler(Filters.command & Filters.group, del_cmds)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
# dispatcher.add_handler(DISABLEDEL)
# dispatcher.add_handler(DISABLEDEL_HANDLER)
else:
DisableAbleCommandHandler = CustomCommandHandler
DisableAbleRegexHandler = RegexHandler
- /setbio <text>: while replying, will save another user's bio
- /bio: will get your or another user's bio. This cannot be set by yourself.
- /setme <text>: will set your info
- /me: will get your or another user's info
- /setnick <text>: will set your nickname.
- /nick: will get your or another user's nickname.
An example of setting a bio for yourself:
`/setme I work for Telegram`; Bio is set to yourself.
An example of writing someone else' bio:
Reply to user's message: `/setbio He is such cool person`.
*Notice:* Do not use /setbio against yourself!
"""
__mod_name__ = "Bios and Abouts"
SET_BIO_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "setbio",
set_about_bio)
GET_BIO_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "bio", about_bio)
SET_ABOUT_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "setme",
set_about_me)
GET_ABOUT_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, "me", about_me)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
return
# empty string errors -_-
if len(text) >= telegram.MAX_MESSAGE_LENGTH:
update.effective_message.reply_text(
"The result of the sed command was too long for \
telegram!")
elif text:
update.effective_message.reply_to_message.reply_text(text)
__help__ = """
- s/<text1>/<text2>(/<flag>): Reply to a message with this to perform a sed operation on that message, replacing all \
occurrences of 'text1' with 'text2'. Flags are optional, and currently include 'i' for ignore case, 'g' for global, \
or nothing. Delimiters include `/`, `_`, `|`, and `:`. Text grouping is supported. The resulting message cannot be \
larger than {}.
*Reminder:* Sed uses some special characters to make matching easier, such as these: `+*.?\\`
If you want to use these characters, make sure you escape them!
eg: \\?.
""".format(telegram.MAX_MESSAGE_LENGTH)
__mod_name__ = "Sed/Regex"
SED_HANDLER = DisableAbleRegexHandler(r's([{}]).*?\1.*'.format(
"".join(DELIMITERS)),
sed,
friendly="sed")
dispatcher.add_handler(SED_HANDLER)
from telegram import Update, Bot
from telegram.error import BadRequest
from telegram.ext import MessageHandler, Filters, CommandHandler, CallbackContext
from telegram.ext.dispatcher import run_async
from typing import List
from natalie_bot.modules.helper_funcs.filters import CustomFilters
from natalie_bot.modules.helper_funcs.handlers import CustomCommandHandler
import telegram
from natalie_bot import dispatcher, OWNER_ID, iSUDO_USERS, CMD_PREFIX
@run_async
def leave(update: Update, context: CallbackContext):
if context.args:
chat_id = str(context.args[0])
del context.args[0]
try:
context.bot.leave_chat(int(chat_id))
update.effective_message.reply_text("Left the group successfully!")
except telegram.TelegramError:
update.effective_message.reply_text("Attempt failed.")
else:
update.effective_message.reply_text("Give me a valid chat id")
__help__ = ""
__mod_name__ = "Leave"
LEAVE_HANDLER = CustomCommandHandler(CMD_PREFIX, "leave", leave, filters=Filters.user(OWNER_ID) | CustomFilters.isudo_filter)
dispatcher.add_handler(LEAVE_HANDLER)
def main():
test_handler = CustomCommandHandler(CMD_PREFIX, "test", test)
start_handler = CustomCommandHandler(CMD_PREFIX, "start", start)
help_handler = CustomCommandHandler(CMD_PREFIX, "help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
settings_handler = CustomCommandHandler(CMD_PREFIX, "settings",
get_settings)
settings_callback_handler = CallbackQueryHandler(settings_button,
pattern=r"stngs_")
donate_handler = CustomCommandHandler(CMD_PREFIX, "donate", donate)
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)
updater.idle()
tidy and simplified.
Here is an example of using buttons:
You can create a button using `[Name of button text](buttonurl://example.com)`.
If you wish to add more than 1 buttons simply do the following:
`[Button 1](buttonurl://example.com)`
`[Button 2](buttonurl://github.com:same)`
`[Button 3](buttonurl://google.com)`
The `:same` end of the link merges 2 buttons on same line as 1 button, resulting in 3 button to be separated \
from same line.
""".format(dispatcher.bot.first_name, dispatcher.bot.first_name)
__mod_name__ = "Filters"
FILTER_HANDLER = CustomCommandHandler(CMD_PREFIX, "filter", filters)
STOP_HANDLER = CustomCommandHandler(CMD_PREFIX, "stop", stop_filter)
LIST_HANDLER = DisableAbleCommandHandler(CMD_PREFIX,
"filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter,
Filters.update.edited_message)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
SMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"smute",
smute,
filters=Filters.group)
UNMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"unmute",
unmute,
filters=Filters.group)
TEMPMUTE_HANDLER = CustomCommandHandler(CMD_PREFIX, ["tmute", "tempmute"],
temp_mute,
filters=Filters.group)
TEMP_NOMEDIA_HANDLER = CustomCommandHandler(CMD_PREFIX,
["trestrict", "temprestrict"],
temp_nomedia,
filters=Filters.group)
NOMEDIA_HANDLER = CustomCommandHandler(CMD_PREFIX, ["restrict", "nomedia"],
nomedia,
filters=Filters.group)
MEDIA_HANDLER = CustomCommandHandler(CMD_PREFIX,
"unrestrict",
media,
filters=Filters.group)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(SMUTE_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)
An example of how to save a note would be via:
`/save data This is some data!`
Now, anyone using "/get notedata", or "#notedata" will be replied to with "This is some data!".
If you want to save an image, gif, or sticker, or any other data, do the following:
`/save notename` while replying to a sticker or whatever data you'd like. Now, the note at "#notename" contains a sticker which will be sent as a reply.
Tip: to retrieve a note without the formatting, use /get <notename> noformat
This will retrieve the note and send it without formatting it; getting you the raw markdown, allowing you to make easy edits.
"""
__mod_name__ = "Notes"
GET_HANDLER = CustomCommandHandler(CMD_PREFIX, "get", cmd_get)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get)
SAVE_HANDLER = CustomCommandHandler(CMD_PREFIX, "save", save)
DELETE_HANDLER = CustomCommandHandler(CMD_PREFIX, "clear", clear)
LIST_HANDLER = DisableAbleCommandHandler(CMD_PREFIX, ["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)
mention_html(user.id, user.first_name))
else:
update.effective_message.reply_text("Whadya want to delete?")
return ""
__help__ = """
Deleting messages made easy with this command. Bot purges \
messages all together or individually.
*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 = CustomCommandHandler(CMD_PREFIX,
"del",
del_message,
filters=Filters.group)
PURGE_HANDLER = CustomCommandHandler(CMD_PREFIX,
"purge",
purge,
filters=Filters.group)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(PURGE_HANDLER)
changes = json.loads(res.text).get('LightGingerTheTextResult')
curr_string = ""
prev_end = 0
for change in changes:
start = change.get('From')
end = change.get('To') + 1
suggestions = change.get('Suggestions')
if suggestions:
sugg_str = suggestions[0].get(
'Text') # should look at this list more
curr_string += msg.text[prev_end:start] + sugg_str
prev_end = end
curr_string += msg.text[prev_end:]
print(curr_string)
update.effective_message.reply_text(curr_string)
__help__ = """
- /t: while replying to a message, will reply with a grammar corrected version
"""
__mod_name__ = "Translator"
TRANSLATE_HANDLER = CustomCommandHandler(CMD_PREFIX, 't', translate)
dispatcher.add_handler(TRANSLATE_HANDLER)
from telegram import Update, Bot
from telegram.ext import CallbackContext, CommandHandler, run_async
from natalie_bot.modules.disable import DisableAbleCommandHandler
from natalie_bot import dispatcher, CMD_PREFIX
from requests import get
@run_async
def ud(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text[len('/ud '):]
results = get(f'http://api.urbandictionary.com/v0/define?term={text}').json()
reply_text = f'Word: {text}\nDefinition: {results["list"][0]["definition"]}'
message.reply_text(reply_text)
__help__ = """
Urban Dictionary is made for fun; Urban Dictionary is a crowdsourced online dictionary for slang words and phrases. \
Search for any definition of words. {} sends you results of top most voted definition from Urban Dictionary.
- /ud <keyword>: search for dictionary.
""".format(dispatcher.bot.first_name)
__mod_name__ = "Urban dictionary"
ud_handle = DisableAbleCommandHandler(CMD_PREFIX, "ud", ud)
dispatcher.add_handler(ud_handle)
Log channels can help you keep track of exactly what the other admins are doing. \
bans, mutes, warns, notes - everything can be moderated.
*Admin only:*
- /logchannel: get log channel info
- /setlog: set the log channel.
- /unsetlog: unset the log channel.
Setting the log channel is done by:
- Add the bot to your channel, as an admin. This is done via the "add administrators" tab.
- Send /setlog to your channel.
- Forward the /setlog command to the group you wish to be logged.
- Congratulations! All is set!
""".format(dispatcher.bot.first_name)
__mod_name__ = "Log Channels"
LOG_HANDLER = CustomCommandHandler(CMD_PREFIX, "logchannel", logging)
SET_LOG_HANDLER = CustomCommandHandler(CMD_PREFIX, "setlog", setlog)
UNSET_LOG_HANDLER = CustomCommandHandler(CMD_PREFIX, "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
