"The result of the sed command was too long for \
telegram!"
)
elif text:
update.effective_message.reply_to_message.reply_text(
"<b>Did you mean:</b>\n" + text, parse_mode=ParseMode.HTML
)
__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)
]]),
)
elif e.message == "Internal Server Error: created sticker set not found (500)":
msg.reply_text(
"Sticker pack successfully created! Get it [here](t.me/addstickers/%s)"
% packname,
parse_mode=ParseMode.MARKDOWN,
)
return
if success:
msg.reply_text(
"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.")
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
STEAL_HANDLER = DisableAbleCommandHandler("steal",
steal,
pass_args=True,
admin_ok=False)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(STEAL_HANDLER)
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.text), parse_mode=ParseMode.MARKDOWN)
# else:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(detection.lang, target, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
else:
tekstr = trl.translate(text, dest=target2, src=target)
message.reply_text(
"Translated from `{}` to `{}`:\n`{}`".format(
target, target2, tekstr.text),
parse_mode=ParseMode.MARKDOWN,
)
# if tekstr.pronunciation == None:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.text), parse_mode=ParseMode.MARKDOWN)
# else:
# return message.reply_text("Translated from `{}` to `{}`:\n`{}`".format(target, target2, tekstr.pronunciation), parse_mode=ParseMode.MARKDOWN)
except IndexError:
update.effective_message.reply_text(
"Reply to messages or write messages from other languages for translating into the intended language\n\nExample: `/tl en-ja` to translate from English to Japanese\nOr use: `/tl ja` for automatic detection and translating it into Japanese.",
parse_mode="markdown",
)
except ValueError:
update.effective_message.reply_text(
"The intended language is not found!")
else:
return
TOTRANSLATE_HANDLER = DisableAbleCommandHandler("tl", totranslate)
dispatcher.add_handler(TOTRANSLATE_HANDLER)
cmd = update.message.text.split(" ", maxsplit=1)
if len(cmd) == 1:
sendMessage("No command provided!", bot, update)
return
LOGGER.info(cmd)
output = shell(cmd[1])
if output[1].decode():
LOGGER.error(f"Shell: {output[1].decode()}")
if len(output[0].decode()) > 4000:
with open("shell.txt", "w") as f:
f.write(f"Output\n-----------\n{output[0].decode()}\n")
if output[1]:
f.write(f"STDError\n-----------\n{output[1].decode()}\n")
with open("shell.txt", "rb") as f:
bot.send_document(
document=f,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.message.chat_id,
)
else:
if output[1].decode():
sendMessage(f"<code>{output[1].decode()}</code>", bot, update)
return
else:
sendMessage(f"<code>{output[0].decode()}</code>", bot, update)
shell_handler = CommandHandler(("sh", "shell"), shellExecute)
dispatcher.add_handler(shell_handler)
GBAN_LIST = CommandHandler(
"gbanlist",
gbanlist,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter,
)
CHECK_GBAN_HANDLER = CommandHandler(
"checkgb", check_gbans, filters=Filters.user(OWNER_ID)
)
CLEAN_GBAN_HANDLER = CommandHandler(
"cleangb", clear_gbans, filters=Filters.user(OWNER_ID)
)
GBAN_STATUS = CommandHandler(
"antispam", gbanstat, pass_args=True, filters=Filters.group
)
GBAN_STATUS = CommandHandler(
"spamshield", gbanstat, pass_args=True, filters=Filters.group
)
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(CHECK_GBAN_HANDLER)
dispatcher.add_handler(CLEAN_GBAN_HANDLER)
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
msg = update.effective_message
query = " ".join(args)
song = ""
if not query:
msg.reply_text("You haven't specified which song to look for!")
return
else:
song = Song.find_song(query)
if song:
if song.lyrics:
reply = song.format()
else:
reply = "Couldn't find any lyrics for that song!"
else:
reply = "Song not found!"
if len(reply) > 4090:
with open("lyrics.txt", "w") as f:
f.write(f"{reply}\n\n\nOwO UwU OmO")
with open("lyrics.txt", "rb") as f:
msg.reply_document(
document=f,
caption="Message length exceeded max limit! Sending as a text file.",
)
else:
msg.reply_text(reply)
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True)
dispatcher.add_handler(LYRICS_HANDLER)
elif me:
return "<b>About user:</b>\n{me}" "".format(me=me, bio=bio)
else:
return ""
def __gdpr__(user_id):
sql.clear_user_info(user_id)
sql.clear_user_bio(user_id)
__help__ = """
- /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
"""
__mod_name__ = "Bios and 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)
CLASSIC_HANDLER = DisableAbleCommandHandler("classic", classic)
KUNI_HANDLER = DisableAbleCommandHandler("kuni", kuni)
WAIFU_HANDLER = DisableAbleCommandHandler("waifu", waifu)
LEWD_HANDLER = DisableAbleCommandHandler("lewd", lewd)
KISS_HANDLER = DisableAbleCommandHandler("kiss", kiss)
FEMDOM_HANDLER = DisableAbleCommandHandler("femdom", femdom)
CUDDLE_HANDLER = DisableAbleCommandHandler("cuddle", cuddle)
EROK_HANDLER = DisableAbleCommandHandler("erok", erok)
FOXGIRL_HANDLER = DisableAbleCommandHandler("foxgirl", foxgirl)
TITSGIF_HANDLER = DisableAbleCommandHandler("titsgif", titsgif)
ERO_HANDLER = DisableAbleCommandHandler("ero", ero)
SMUG_HANDLER = DisableAbleCommandHandler("smug", smug)
BAKA_HANDLER = DisableAbleCommandHandler("baka", baka)
DVA_HANDLER = DisableAbleCommandHandler("dva", dva)
dispatcher.add_handler(LEWDKEMO_HANDLER)
dispatcher.add_handler(NEKO_HANDLER)
dispatcher.add_handler(FEET_HANDLER)
dispatcher.add_handler(YURI_HANDLER)
dispatcher.add_handler(TRAP_HANDLER)
dispatcher.add_handler(FUTANARI_HANDLER)
dispatcher.add_handler(HOLOLEWD_HANDLER)
dispatcher.add_handler(SOLOGIF_HANDLER)
dispatcher.add_handler(CUMGIF_HANDLER)
dispatcher.add_handler(EROKEMO_HANDLER)
dispatcher.add_handler(LESBIAN_HANDLER)
dispatcher.add_handler(WALLPAPER_HANDLER)
dispatcher.add_handler(LEWDK_HANDLER)
dispatcher.add_handler(NGIF_HANDLER)
dispatcher.add_handler(TICKLE_HANDLER)
dispatcher.add_handler(LEWD_HANDLER)
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 "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 = CommandHandler("rules", get_rules, filters=Filters.group)
SET_RULES_HANDLER = CommandHandler("setrules",
set_rules,
filters=Filters.group)
RESET_RULES_HANDLER = CommandHandler("clearrules",
clear_rules,
filters=Filters.group)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
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 build_lock_message(chat_id)
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)
else:
wallpapers = json_rep.get("wallpapers")
if not wallpapers:
msg.reply_text("No results found!")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
bot.send_photo(
chat_id,
photo=wallpaper,
caption="Preview",
reply_to_message_id=msg_id,
timeout=60,
)
bot.send_document(
chat_id,
document=wallpaper,
filename="wallpaper",
caption=caption,
reply_to_message_id=msg_id,
timeout=60,
)
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
except Exception:
msg.reply_text(
"An exception occured while restoring your data. The process may not be complete. If "
"you're having issues with this, message @MarieSupport with your backup file so the "
"issue can be debugged. My owners would be happy to help, and every bug "
"reported makes me better! Thanks! :)")
LOGGER.exception(
"Import for chatid %s with name %s failed.",
str(chat.id),
str(chat.title),
)
return
# TODO: some of that link logic
# NOTE: consider default permissions stuff?
msg.reply_text("Backup fully imported. Welcome back! :D")
@run_async
@user_admin
def export_data(bot: Bot, update: Update):
msg = update.effective_message # type: Optional[Message]
msg.reply_text("")
IMPORT_HANDLER = CommandHandler("import", import_data)
EXPORT_HANDLER = CommandHandler("export", export_data)
dispatcher.add_handler(IMPORT_HANDLER)
# dispatcher.add_handler(EXPORT_HANDLER)
return
name = bot.get_chat(user).first_name
text = f"<b>Common chats with {name}</b>\n"
for chat in common_list:
try:
chat_name = bot.get_chat(chat).title
sleep(0.3)
text += f"• <code>{chat_name}</code>\n"
except BadRequest:
pass
except Unauthorized:
pass
except RetryAfter as e:
sleep(e.retry_after)
if len(text) < 4096:
msg.reply_text(text, parse_mode="HTML")
else:
with open("common_chats.txt", "w") as f:
f.write(text)
with open("common_chats.txt", "rb") as f:
msg.reply_document(f)
os.remove("common_chats.txt")
COMMON_CHATS_HANDLER = CommandHandler(
"getchats", get_user_common_chats, filters=Filters.user(OWNER_ID), pass_args=True
)
dispatcher.add_handler(COMMON_CHATS_HANDLER)
- /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 = CommandHandler(
"addblacklist", add_blacklist, filters=Filters.group
)
UNBLACKLIST_HANDLER = CommandHandler(
["unblacklist", "rmblacklist"], unblacklist, filters=Filters.group
)
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)
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)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(UNWARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(MYWARNS_HANDLER)
dispatcher.add_handler(ADD_WARN_HANDLER)
dispatcher.add_handler(RM_WARN_HANDLER)
dispatcher.add_handler(LIST_WARN_HANDLER)
dispatcher.add_handler(WARN_LIMIT_HANDLER)
dispatcher.add_handler(WARN_STRENGTH_HANDLER)
dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
SBAN_HANDLER = CommandHandler("sban",
sban,
pass_args=True,
filters=Filters.group)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.group)
KICK_HANDLER = CommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group)
UNBAN_HANDLER = CommandHandler("unban",
unban,
pass_args=True,
filters=Filters.group)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(SBAN_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)
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_")
donate_handler = CommandHandler("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)
# add antiflood processor
Dispatcher.process_update = process_update
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, clean=True)
updater.idle()
res = "{} is AFK!\nReason: {}".format(fst_name, reason)
message.reply_text(res)
def __gdpr__(user_id):
sql.rm_afk(user_id)
__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 = DisableAbleRegexHandler("(?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)
msg += f"_{json.get('description', None)}_"
if image:
try:
update.effective_message.reply_photo(
photo=image,
caption=msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(buttons))
except:
msg += f" [〽️]({image})"
update.effective_message.reply_text(
msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(buttons))
else:
update.effective_message.reply_text(
msg,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(buttons))
AIRING_HANDLER = CommandHandler("airing", airing)
ANIME_HANDLER = CommandHandler("anime", anime)
CHARACTER_HANDLER = CommandHandler("character", character)
MANGA_HANDLER = CommandHandler("manga", manga)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
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 settings.
*Admin only:*
- /setflood <int/'no'/'off'>: enables or disables flood control.
"""
__mod_name__ = "Anti-Flood"
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)
update.effective_message.delete()
return ("<b>{}:</b>"
"\n#DEL"
"\n<b>Admin:</b> {}"
"\nMessage deleted.".format(
html.escape(chat.title),
mention_html(user.id, user.first_name)))
else:
update.effective_message.reply_text("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)
@dev_user
@run_async
def clear(bot, update):
log_input(update)
global namespaces
if update.message.chat_id in namespaces:
del namespaces[update.message.chat_id]
send("Cleared locals.", bot, update)
def error_callback(bot, update, error):
try:
raise error
except (TimedOut, NetworkError):
log.debug(error, exc_info=True)
except:
log.info(error, exc_info=True)
__mod_name__ = "Eval"
eval_handle = CommandHandler(("e", "ev", "eva", "eval"), evaluate)
exec_handle = CommandHandler(("x", "ex", "exe", "exec", "py"), execute)
clear_handle = CommandHandler("clearlocals", clear)
dispatcher.add_handler(eval_handle)
dispatcher.add_handler(exec_handle)
dispatcher.add_handler(clear_handle)
def ud(bot: Bot, update: Update):
msg = (update.effective_message.reply_to_message
if update.message.reply_to_message else update.effective_message)
if msg == update.effective_message:
text = msg.text[len("/ud "):]
# Args should take more precedence. Hence even if it's a reply, it'll query what you typed
elif (msg == update.effective_message.reply_to_message
and len(update.effective_message.text) > 3):
text = update.effective_message.text[len("/ud "):]
else:
text = msg.text
if text == "":
update.message.reply_text(
"Please enter a query to look up on Urban Dictionary!")
else:
results = get(
f"http://api.urbandictionary.com/v0/define?term={text}").json()
try:
reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_'
except IndexError:
reply_text = None
if reply_text:
update.message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN)
else:
update.message.reply_text("No results found!")
ud_handle = DisableAbleCommandHandler("ud", ud)
dispatcher.add_handler(ud_handle)
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 = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter)
DELETE_CHATS_HANDLER = CommandHandler(
"cleanchats", rem_chat, filters=Filters.user(OWNER_ID)
)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
dispatcher.add_handler(DELETE_CHATS_HANDLER)
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}!")
ADD_CHAT_HANDLER = CommandHandler("addchat",
add_chat,
filters=CustomFilters.dev_filter)
REMOVE_CHAT_HANDLER = CommandHandler("rmchat",
remove_chat,
filters=CustomFilters.dev_filter)
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)
*Admin only:*
- /enable <cmd name>: enable that command
- /disable <cmd name>: disable that command
- /listcmds: list all possible toggleable commands
"""
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
def __stats__():
return "{} notes, across {} 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)
def __chat_settings__(chat_id, user_id):
notes = sql.get_all_chat_notes(chat_id)
return "There are `{}` notes in this chat.".format(len(notes))
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
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)
rep.reply_text("User removed from blacklist!")
else:
rep.reply_text("User isn't even blacklisted!")
def __user_info__(user_id):
is_blacklisted = sql.is_user_blacklisted(user_id)
text = "Blacklisted: <b>{}</b>"
if is_blacklisted:
text = text.format("Yes")
reason = sql.get_reason(user_id)
if reason:
text += f"\nReason: <code>{reason}</code>"
else:
text = text.format("No")
return text
BL_HANDLER = CommandHandler(
"bluser", bl_user, pass_args=True, filters=Filters.user(OWNER_ID)
)
UNBL_HANDLER = CommandHandler(
"unbluser", unbl_user, pass_args=True, filters=Filters.user(OWNER_ID)
)
BLUSERS_HANDLER = CommandHandler("blusers", bl_users, filters=Filters.user(OWNER_ID))
dispatcher.add_handler(BL_HANDLER)
dispatcher.add_handler(UNBL_HANDLER)
dispatcher.add_handler(BLUSERS_HANDLER)
filters=Filters.group)
RESET_GOODBYE = CommandHandler("resetgoodbye",
reset_goodbye,
filters=Filters.group)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
welcomemute,
pass_args=True,
filters=Filters.group)
CLEAN_WELCOME = CommandHandler("cleanwelcome",
clean_welcome,
pass_args=True,
filters=Filters.group)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help)
WELCOME_MUTE_HELP = CommandHandler("wlcmutehelp", welcome_mute_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(WELCOME_HELP)
dispatcher.add_handler(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_MUTE_HELP)
message.reply_text("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(["stfu", "mute", "gay"],
mute,
pass_args=True,
filters=Filters.group)
UNMUTE_HANDLER = CommandHandler(["unmute", "talk"],
unmute,
pass_args=True,
filters=Filters.group)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute", "tgay"],
temp_mute,
pass_args=True,
filters=Filters.group)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
