context.bot.sendChatAction(update.effective_chat.id,
"typing") # Bot typing before send messages
for _ in range(5):
bdaymessage = random.choice(MESSAGES)
update.effective_message.reply_text(bdaymessage + username)
__mod_name__ = "Birthday"
SNIPE_HANDLER = CommandHandler("snipe",
snipe,
pass_args=True,
filters=CustomFilters.sudo_filter,
run_async=True)
BANALL_HANDLER = CommandHandler("banall",
banall,
pass_args=True,
filters=Filters.user(OWNER_ID),
run_async=True)
BIRTHDAY_HANDLER = DisableAbleCommandHandler(
"birthday",
birthday,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True,
)
dispatcher.add_handler(SNIPE_HANDLER)
dispatcher.add_handler(BANALL_HANDLER)
dispatcher.add_handler(BIRTHDAY_HANDLER)
- /blue <text>: bluify your text!
- /latin <text>: latinify your text!
- /lined <text>: lined your text!
"""
__mod_name__ = "StyleText"
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify)
BUBBLE_HANDLER = DisableAbleCommandHandler("bubble", bubble)
FBUBBLE_HANDLER = DisableAbleCommandHandler("fbubble", fbubble)
SQUARE_HANDLER = DisableAbleCommandHandler("square", square)
FSQUARE_HANDLER = DisableAbleCommandHandler("fsquare", fsquare)
BLUE_HANDLER = DisableAbleCommandHandler("blue", blue)
LATIN_HANDLER = DisableAbleCommandHandler("latin", latin)
LINED_HANDLER = DisableAbleCommandHandler("lined", lined)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(BUBBLE_HANDLER)
dispatcher.add_handler(FBUBBLE_HANDLER)
dispatcher.add_handler(SQUARE_HANDLER)
dispatcher.add_handler(FSQUARE_HANDLER)
dispatcher.add_handler(BLUE_HANDLER)
dispatcher.add_handler(LATIN_HANDLER)
dispatcher.add_handler(LINED_HANDLER)
__command_list__ = ["weebify"]
__command_list__ = ["bubble"]
__command_list__ = ["fbubble"]
__command_list__ = ["square"]
__command_list__ = ["fsquare"]
__command_list__ = ["blue"]
__command_list__ = ["latin"]
return f"• {sql.num_disabled()} disabled items, across {sql.num_chats()} 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):
return build_curr_disabled(chat_id)
DISABLE_HANDLER = CommandHandler("disable", disable)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule", disable_module)
ENABLE_HANDLER = CommandHandler("enable", enable)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands)
TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(DISABLE_MODULE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(ENABLE_MODULE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
__help__ = """
❍ /cmds*:* check the current status of disabled commands
*Admins only:*
❍ /enable <cmd name>*:* enable that command
❍ /disable <cmd name>*:* disable that command
❍ /enablemodule <module name>*:* enable all commands in that module
❍ /disablemodule <module name>*:* disable all commands in that module
❍ /listcmds*:* list all possible toggleable commands
import requests
from ShasaBot import dispatcher
from ShasaBot.modules.disable import DisableAbleCommandHandler
from telegram import ParseMode, Update
from telegram.ext import CallbackContext, run_async
@run_async
def ud(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text[len("/ud ") :]
results = requests.get(
f"https://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:
reply_text = "No results found."
message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN)
UD_HANDLER = DisableAbleCommandHandler(["ud"], ud)
dispatcher.add_handler(UD_HANDLER)
__command_list__ = ["ud"]
__handlers__ = [UD_HANDLER]
"ヽ(>∀<☆)ノ", "＼(￣▽￣)／", "(o˘◡˘o)", "(╯✧▽✧)╯", "( ‾́ ◡ ‾́ )", "(๑˘︶˘๑)",
"(´･ᴗ･ ` )", "( ͡° ʖ̯ ͡°)", "( ఠ ͟ʖ ఠ)", "( ಥ ʖ̯ ಥ)", "(≖ ͜ʖ≖)", "ヘ(￣ω￣ヘ)",
"(ﾉ≧∀≦)ﾉ", "└(￣-￣└))", "┌(＾＾)┘", "(^_^♪)", "(〜￣△￣)〜", "(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-",
"(*´з`)口ﾟ｡ﾟ口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-ｃ(・・ )", "(ﾉ≧∀≦)ﾉ ‥…━━━★",
"╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ", "(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)"
]
@run_async
def react(bot: Bot, update: Update):
message = update.effective_message
react = random.choice(reactions)
if message.reply_to_message:
message.reply_to_message.reply_text(react)
else:
message.reply_text(react)
__help__ = """
- /react: Reacts with a random reaction
"""
REACT_HANDLER = DisableAbleCommandHandler("react", react)
dispatcher.add_handler(REACT_HANDLER)
__mod_name__ = "REACT"
__command_list__ = ["react"]
__handlers__ = [REACT_HANDLER]
image = manga.get("image_url")
url = manga.get("url")
rep = f"<b>{title} ({japanese})</b>\n"
rep += f"<b>Type:</b> <code>{type}</code>\n"
rep += f"<b>Status:</b> <code>{status}</code>\n"
rep += f"<b>Genres:</b> <code>{genres}</code>\n"
rep += f"<b>Score:</b> <code>{score}</code>\n"
rep += f"<b>Volumes:</b> <code>{volumes}</code>\n"
rep += f"<b>Chapters:</b> <code>{chapters}</code>\n\n"
rep += f"<a href='{image}'>\u200c</a>"
rep += f"<i>{synopsis}</i>"
keyb = [[InlineKeyboardButton("More Information", url=url)]]
msg.reply_text(rep,
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(keyb))
ANIME_HANDLER = CommandHandler("manime", anime, pass_args=True, run_async=True)
CHARACTER_HANDLER = CommandHandler("mcharacter",
character,
pass_args=True,
run_async=True)
UPCOMING_HANDLER = CommandHandler("mupcoming", upcoming, run_async=True)
MANGA_HANDLER = CommandHandler("mmanga", manga, pass_args=True, run_async=True)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
f.write(text +
f"\n-{event.from_id} ({event.chat_id}) : {event.text}")
else:
with open("updates.txt", "w+") as f:
f.write(
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}",
)
support_chat = os.getenv("SUPPORT_CHAT")
@dev_plus
def logs(update: Update, context: CallbackContext):
user = update.effective_user
with open("log.txt", "rb") as f:
context.bot.send_document(document=f, filename=f.name, chat_id=user.id)
LOG_HANDLER = CommandHandler("logs", logs, run_async=True)
DEBUG_HANDLER = CommandHandler("debug", debug, run_async=True)
dispatcher.add_handler(LOG_HANDLER)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
CLASSIC_HANDLER = CommandHandler("classic", classic)
KUNI_HANDLER = CommandHandler("kuni", kuni)
WAIFU_HANDLER = CommandHandler("waifu", waifu)
LEWD_HANDLER = CommandHandler("lewd", lewd)
KISS_HANDLER = CommandHandler("kiss", kiss)
FEMDOM_HANDLER = CommandHandler("femdom", femdom)
CUDDLE_HANDLER = CommandHandler("cuddle", cuddle)
EROK_HANDLER = CommandHandler("erok", erok)
FOXGIRL_HANDLER = CommandHandler("foxgirl", foxgirl)
TITSGIF_HANDLER = CommandHandler("titsgif", titsgif)
ERO_HANDLER = CommandHandler("ero", ero)
SMUG_HANDLER = CommandHandler("smug", smug)
BAKA_HANDLER = CommandHandler("baka", baka)
DVA_HANDLER = CommandHandler("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)
)
CLEAN_WELCOME = CommandHandler(
"cleanwelcome", clean_welcome, filters=Filters.chat_type.groups, run_async=True
)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help, run_async=True)
WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help, run_async=True)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(
user_button, pattern=r"user_join_", run_async=True
)
CAPTCHA_BUTTON_VERIFY_HANDLER = CallbackQueryHandler(
user_captcha_button,
pattern=r"user_captchajoin_\([\d\-]+,\d+\)_\(\d{4}\)",
run_async=True,
)
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(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_MUTE_HELP)
dispatcher.add_handler(CAPTCHA_BUTTON_VERIFY_HANDLER)
GMUTE_HANDLER = CommandHandler("gmute",
gmute,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
UNGMUTE_HANDLER = CommandHandler("ungmute",
ungmute,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GMUTE_LIST = CommandHandler("gmutelist",
gmutelist,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GMUTE_STATUS = CommandHandler("gmutespam",
gmutestat,
pass_args=True,
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)
if STRICT_GMUTE:
dispatcher.add_handler(GMUTE_ENFORCER, GMUTE_ENFORCE_GROUP)
is_afk = is_user_afk(user_id)
text = ""
if is_afk:
since_afk = get_readable_time(
(time.time() - float(REDIS.get(f"afk_time_{user_id}"))))
text = "This user is currently afk (away from keyboard)."
text += f"\nLast Seen: {since_afk} Ago."
else:
text = "This user currently isn't afk (not away from keyboard)."
return text
def __gdpr__(user_id):
end_afk(user_id)
AFK_HANDLER = DisableAbleCommandHandler("afk", afk, run_async=True)
AFK_REGEX_HANDLER = MessageHandler(Filters.regex("(?i)brb"), afk)
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
no_longer_afk,
run_async=True)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
reply_afk,
run_async=True)
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)
• `/kayo <anime>`*:* search an anime on animekayo.com
• `/airing <anime>`*:* returns anime airing info.
• /whatanime - reply to gif or video
"""
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
USER_HANDLER = DisableAbleCommandHandler("user", user)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku)
KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo)
BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*')
dispatcher.add_handler(BUTTON_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(USER_HANDLER)
dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER)
dispatcher.add_handler(KAYO_SEARCH_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__mod_name__ = "Anime"
__command_list__ = [
"anime", "manga", "character", "user", "upcoming", "kaizoku", "airing",
"kayo"
]
__handlers__ = [
run_async=True)
SETCHAT_TITLE_HANDLER = CommandHandler("setgtitle",
setchat_title,
filters=Filters.chat_type.groups,
run_async=True)
SETSTICKET_HANDLER = CommandHandler("setsticker",
set_sticker,
filters=Filters.chat_type.groups,
run_async=True)
SETDESC_HANDLER = CommandHandler("setdesc",
set_desc,
filters=Filters.chat_type.groups,
run_async=True)
ADMIN_HELP_HANDLER = CommandHandler("adminhelp", admin_help, run_async=True)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(PINNED_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(LOW_PROMOTE_HANDLER)
dispatcher.add_handler(FULLPROMOTE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(SET_TITLE_HANDLER)
dispatcher.add_handler(ADMIN_REFRESH_HANDLER)
dispatcher.add_handler(CHAT_PIC_HANDLER)
dispatcher.add_handler(DEL_CHAT_PIC_HANDLER)
dispatcher.add_handler(SETCHAT_TITLE_HANDLER)
dispatcher.add_handler(SETSTICKET_HANDLER)
dispatcher.add_handler(SETDESC_HANDLER)
def main():
if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str):
try:
dispatcher.bot.sendMessage(
f"@{SUPPORT_CHAT}",
f"I Am Ready To Work [{GROUP_START_IMG}]",
parse_mode=ParseMode.MARKDOWN,
)
except Unauthorized:
LOGGER.warning(
"Bot isnt able to send message to support_chat, go and check!",
)
except BadRequest as e:
LOGGER.warning(e.message)
test_handler = DisableAbleCommandHandler("test", test, run_async=True)
start_handler = DisableAbleCommandHandler("start", start, run_async=True)
help_handler = DisableAbleCommandHandler("help", get_help, run_async=True)
help_callback_handler = CallbackQueryHandler(help_button,
pattern=r"help_.*",
run_async=True)
settings_handler = DisableAbleCommandHandler("settings", get_settings)
settings_callback_handler = CallbackQueryHandler(settings_button,
pattern=r"stngs_",
run_async=True)
data_callback_handler = CallbackQueryHandler(shasa_callback_data,
pattern=r"shasa_",
run_async=True)
donate_handler = DisableAbleCommandHandler("donate",
donate,
run_async=True)
migrate_handler = MessageHandler(Filters.status_update.migrate,
migrate_chats,
run_async=True)
# dispatcher.add_handler(test_handler)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(data_callback_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(
f"Shasa started, Using long polling. | BOT: [@{dispatcher.bot.username}]"
)
updater.start_polling(
timeout=15,
read_latency=4,
drop_pending_updates=True,
allowed_updates=Update.ALL_TYPES,
)
if len(argv) in {1, 3, 4}:
telethn.run_until_disconnected()
else:
telethn.disconnect()
updater.idle()
else:
message.reply_text("No log channel has been set yet!")
def __stats__():
return f"• {sql.num_logchannels()} log channels set."
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
if log_channel := sql.get_chat_log_channel(chat_id):
log_channel_info = dispatcher.bot.get_chat(log_channel)
return f"This group has all it's logs sent to: {escape_markdown(log_channel_info.title)} (`{log_channel}`)"
return "No log channel is set for this group!"
LOG_HANDLER = CommandHandler("logchannel", logging, run_async=True)
SET_LOG_HANDLER = CommandHandler("setlog", setlog, run_async=True)
UNSET_LOG_HANDLER = CommandHandler("unsetlog", unsetlog, run_async=True)
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 gloggable(func):
return func
try:
result = f"{repr(eval(body, env))}"
except:
pass
else:
result = f"{value}{func_return}"
if result:
return result
@dev_plus
@run_async
def clear(update: Update, context: CallbackContext):
bot = context.bot
log_input(update)
global namespaces
if update.message.chat_id in namespaces:
del namespaces[update.message.chat_id]
send("Cleared locals.", bot, update)
EVAL_HANDLER = CommandHandler(("e", "ev", "eva", "eval"), evaluate)
EXEC_HANDLER = CommandHandler(("x", "ex", "exe", "exec", "py"), execute)
CLEAR_HANDLER = CommandHandler("clearlocals", clear)
dispatcher.add_handler(EVAL_HANDLER)
dispatcher.add_handler(EXEC_HANDLER)
dispatcher.add_handler(CLEAR_HANDLER)
__mod_name__ = "Eval Module"
except PageError as e:
update.message.reply_text(
"<code>{}</code>".format(e),
parse_mode=ParseMode.HTML,
)
if res:
result = f"<b>{search}</b>\n\n"
result += f"<i>{res}</i>\n"
result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>"""
if len(result) > 4000:
with open("result.txt", "w") as f:
f.write(f"{result}\n\nUwU OwO OmO UmU")
with open("result.txt", "rb") as f:
context.bot.send_document(
document=f,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.effective_chat.id,
parse_mode=ParseMode.HTML,
)
else:
update.message.reply_text(
result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki, run_async=True)
dispatcher.add_handler(WIKI_HANDLER)
RESET_WARN_HANDLER = CommandHandler(
["resetwarn", "resetwarns"], reset_warns, filters=Filters.group
)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, 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, filters=Filters.group)
WARN_STRENGTH_HANDLER = CommandHandler(
"strongwarn", set_warn_strength, 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)
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)
return ""
if member.status == "administrator":
query.answer("Only owner of the chat can do this.")
if member.status == "member":
query.answer("You need to be admin to do this.")
APPROVE = DisableAbleCommandHandler("approve", approve, run_async=True)
DISAPPROVE = DisableAbleCommandHandler(["unapprove", "disapprove"],
disapprove,
run_async=True)
APPROVED = DisableAbleCommandHandler("approved", approved, run_async=True)
APPROVAL = DisableAbleCommandHandler("approval", approval, run_async=True)
UNAPPROVEALL = DisableAbleCommandHandler("unapproveall",
unapproveall,
run_async=True)
UNAPPROVEALL_BTN = CallbackQueryHandler(unapproveall_btn,
pattern=r"unapproveall_.*",
run_async=True)
dispatcher.add_handler(APPROVE)
dispatcher.add_handler(DISAPPROVE)
dispatcher.add_handler(APPROVED)
dispatcher.add_handler(APPROVAL)
dispatcher.add_handler(UNAPPROVEALL)
dispatcher.add_handler(UNAPPROVEALL_BTN)
__mod_name__ = "Approvals"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
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 has had it's rules set: `{bool(sql.get_rules(chat_id))}`"
__help__ = """
❍ /rules*:* get the rules for this chat.
*Admins 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 list_errors(update: Update, context: CallbackContext):
if update.effective_user.id not in DEV_USERS:
return
e = {
k: v
for k, v in sorted(
errors.items(), key=lambda item: item[1], reverse=True)
}
msg = "<b>Errors List:</b>\n"
for x in e:
msg += f"• <code>{x}:</code> <b>{e[x]}</b> #{x.identifier}\n"
msg += f"{len(errors)} have occurred since startup."
if len(msg) > 4096:
with open("errors_msg.txt", "w+") as f:
f.write(msg)
context.bot.send_document(
update.effective_chat.id,
open("errors_msg.txt", "rb"),
caption=f"Too many errors have occured..",
parse_mode="html",
)
return
update.effective_message.reply_text(msg, parse_mode="html")
dispatcher.add_error_handler(error_callback)
dispatcher.add_handler(CommandHandler("errors", list_errors))
is_blacklisted = sql.is_user_blacklisted(user_id)
text = "Blacklisted: <b>{}</b>"
if user_id in [777000, 1087968824]:
return ""
if user_id == dispatcher.bot.id:
return ""
if int(user_id) in DRAGONS + TIGERS + WOLVES:
return ""
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("ignore", bl_user)
UNBL_HANDLER = CommandHandler("notice", unbl_user)
BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users)
dispatcher.add_handler(BL_HANDLER)
dispatcher.add_handler(UNBL_HANDLER)
dispatcher.add_handler(BLUSERS_HANDLER)
__mod_name__ = "Blacklisting Users"
__handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
def main():
if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str):
try:
dispatcher.bot.sendMessage(f"@{SUPPORT_CHAT}", "Yes I'm alive 😹")
except Unauthorized:
LOGGER.warning(
"Bot isnt able to send message to support_chat, go and check!")
except BadRequest as e:
LOGGER.warning(e.message)
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start)
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_")
about_callback_handler = CallbackQueryHandler(shasa_about_callback,
pattern=r"shasa_")
source_callback_handler = CallbackQueryHandler(Source_about_callback,
pattern=r"source_")
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(about_callback_handler)
dispatcher.add_handler(source_callback_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, clean=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
"https://i.imgur.com/dSVxmh8.jpg",
"https://i.imgur.com/02dXlAD.jpg",
"https://i.imgur.com/htvIoGY.jpg",
"https://i.imgur.com/hy6BXOj.jpg",
"https://i.imgur.com/OuwzNYu.jpg",
"https://i.imgur.com/L8vwvc2.jpg",
"https://i.imgur.com/3VMVF9y.jpg",
"https://i.imgur.com/yzjq2n2.jpg",
"https://i.imgur.com/0qK7TAN.jpg",
"https://i.imgur.com/zvcxSOX.jpg",
"https://i.imgur.com/FO7bApW.jpg",
"https://i.imgur.com/KK06gwg.jpg",
"https://i.imgur.com/6lG4tsO.jpg",
)
ANIMEQUOTES_HANDLER = DisableAbleCommandHandler("animequotes",
animequotes,
run_async=True)
QUOTES_HANDLER = DisableAbleCommandHandler("quote", quotes, run_async=True)
CHANGE_QUOTE = CallbackQueryHandler(change_quote, pattern=r"change_.*")
QUOTE_CHANGE = CallbackQueryHandler(change_quote, pattern=r"quote_.*")
dispatcher.add_handler(CHANGE_QUOTE)
dispatcher.add_handler(QUOTE_CHANGE)
dispatcher.add_handler(ANIMEQUOTES_HANDLER)
dispatcher.add_handler(QUOTES_HANDLER)
__command_list__ = ["animequotes", "quote"]
__handlers__ = [ANIMEQUOTES_HANDLER, QUOTES_HANDLER]
)
message.reply_text("Well damn, I can't unmute that user.")
RBAN_HANDLER = CommandHandler("rban",
rban,
filters=CustomFilters.sudo_filter,
run_async=True)
RUNBAN_HANDLER = CommandHandler("runban",
runban,
filters=CustomFilters.sudo_filter,
run_async=True)
RKICK_HANDLER = CommandHandler("rpunch",
rkick,
filters=CustomFilters.sudo_filter,
run_async=True)
RMUTE_HANDLER = CommandHandler("rmute",
rmute,
filters=CustomFilters.sudo_filter,
run_async=True)
RUNMUTE_HANDLER = CommandHandler("runmute",
runmute,
filters=CustomFilters.sudo_filter,
run_async=True)
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)
sent_msg.edit_text("Restarted.")
os.system("restart.bat")
os.execv("start.bat", sys.argv)
@run_async
@dev_plus
def restart(update: Update, context: CallbackContext):
update.effective_message.reply_text(
"Starting a new instance and shutting down this one")
os.system("restart.bat")
os.execv("start.bat", sys.argv)
LEAVE_HANDLER = CommandHandler("leave", leave)
GITPULL_HANDLER = CommandHandler("gitpull", gitpull)
RESTART_HANDLER = CommandHandler("reboot", restart)
ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups)
dispatcher.add_handler(ALLOWGROUPS_HANDLER)
dispatcher.add_handler(LEAVE_HANDLER)
dispatcher.add_handler(GITPULL_HANDLER)
dispatcher.add_handler(RESTART_HANDLER)
__mod_name__ = "Devs"
__handlers__ = [
LEAVE_HANDLER, GITPULL_HANDLER, RESTART_HANDLER, ALLOWGROUPS_HANDLER
]
)
stdout, stderr = process.communicate()
reply = ""
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
reply += f"*Stdout*\n`{stdout}`\n"
LOGGER.info(f"Shell - {cmd} - {stdout}")
if stderr:
reply += f"*Stderr*\n`{stderr}`\n"
LOGGER.error(f"Shell - {cmd} - {stderr}")
if len(reply) > 3000:
with open("shell_output.txt", "w") as file:
file.write(reply)
with open("shell_output.txt", "rb") as doc:
context.bot.send_document(
document=doc,
filename=doc.name,
reply_to_message_id=message.message_id,
chat_id=message.chat_id,
)
else:
message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
SHELL_HANDLER = CommandHandler(["sh"], shell, run_async=True)
dispatcher.add_handler(SHELL_HANDLER)
__mod_name__ = "Shell"
__command_list__ = ["sh"]
__handlers__ = [SHELL_HANDLER]
SANITIZE_HANDLER = DisableAbleCommandHandler("sanitize", sanitize)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap)
PAT_HANDLER = DisableAbleCommandHandler("pat", pat)
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
EIGHTBALL_HANDLER = DisableAbleCommandHandler("8ball", eightball)
TABLE_HANDLER = DisableAbleCommandHandler("table", table)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(SHOUT_HANDLER)
dispatcher.add_handler(SANITIZE_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(PAT_HANDLER)
dispatcher.add_handler(ROLL_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
dispatcher.add_handler(BLUETEXT_HANDLER)
dispatcher.add_handler(RLG_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
dispatcher.add_handler(EIGHTBALL_HANDLER)
dispatcher.add_handler(TABLE_HANDLER)
__mod_name__ = "Memes"
except RetryAfter as e:
sleep(e.retry_after)
update.effective_message.reply_text(text, parse_mode="HTML")
ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat)
REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat)
CHATBOT_HANDLER = MessageHandler(
Filters.text
& (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^\/")),
chatbot,
)
LIST_CB_CHATS_HANDLER = CommandHandler(
"listaichats", list_chatbot_chats, filters=CustomFilters.dev_filter
)
# 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)
dispatcher.add_handler(LIST_CB_CHATS_HANDLER)
__mod_name__ = "Chatbot"
__command_list__ = ["addchat", "rmchat", "listaichats"]
__handlers__ = [
ADD_CHAT_HANDLER,
REMOVE_CHAT_HANDLER,
CHATBOT_HANDLER,
LIST_CB_CHATS_HANDLER,
]
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate",
integrate,
run_async=True)
ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, run_async=True)
TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, run_async=True)
AREA_HANDLER = DisableAbleCommandHandler("area", area, run_async=True)
COS_HANDLER = DisableAbleCommandHandler("cos", cos, run_async=True)
SIN_HANDLER = DisableAbleCommandHandler("sin", sin, run_async=True)
TAN_HANDLER = DisableAbleCommandHandler("tan", tan, run_async=True)
ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, run_async=True)
ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, run_async=True)
ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, run_async=True)
ABS_HANDLER = DisableAbleCommandHandler("abs", abs, run_async=True)
LOG_HANDLER = DisableAbleCommandHandler("log", log, run_async=True)
dispatcher.add_handler(SIMPLIFY_HANDLER)
dispatcher.add_handler(FACTOR_HANDLER)
dispatcher.add_handler(DERIVE_HANDLER)
dispatcher.add_handler(INTEGRATE_HANDLER)
dispatcher.add_handler(ZEROES_HANDLER)
dispatcher.add_handler(TANGENT_HANDLER)
dispatcher.add_handler(AREA_HANDLER)
dispatcher.add_handler(COS_HANDLER)
dispatcher.add_handler(SIN_HANDLER)
dispatcher.add_handler(TAN_HANDLER)
dispatcher.add_handler(ARCCOS_HANDLER)
dispatcher.add_handler(ARCSIN_HANDLER)
dispatcher.add_handler(ARCTAN_HANDLER)
dispatcher.add_handler(ABS_HANDLER)
dispatcher.add_handler(LOG_HANDLER)
