__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get, run_async=True)
HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"),
hash_get,
run_async=True)
SLASH_GET_HANDLER = MessageHandler(Filters.regex(r"^/\d+$"),
slash_get,
run_async=True)
SAVE_HANDLER = CommandHandler("save", save, run_async=True)
DELETE_HANDLER = CommandHandler("clear", clear, run_async=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True,
run_async=True)
CLEARALL = DisableAbleCommandHandler("removeallnotes",
clearall,
run_async=True)
CLEARALL_BTN = CallbackQueryHandler(clearall_btn,
pattern=r"notes_.*",
run_async=True)
dispatcher.add_handler(GET_HANDLER)
dispatcher.add_handler(SAVE_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
dispatcher.add_handler(SLASH_GET_HANDLER)
dispatcher.add_handler(CLEARALL)
dispatcher.add_handler(CLEARALL_BTN)
"""
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue",
set_blue_text_must_click)
ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore)
REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue",
remove_bluetext_ignore)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"gignoreblue", add_bluetext_ignore_global)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group,
clean_blue_text_must_click)
dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)
__mod_name__ = "Bluetext Cleaning"
__handlers__ = [
SET_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, LIST_CLEAN_BLUE_TEXT_HANDLER,
(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)
]
__help__ = """
• `/punchme`*:* punchs the user who issued the command
*Admins only:*
• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/punch <userhandle>`*:* Punches a user out of the group, (via handle, or reply)
"""
BAN_HANDLER = CommandHandler("ban", ban)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban)
PUNCH_HANDLER = CommandHandler("punch", punch)
UNBAN_HANDLER = CommandHandler("unban", unban)
ROAR_HANDLER = CommandHandler("roar", selfunban)
PUNCHME_HANDLER = DisableAbleCommandHandler(
"punchme", punchme, filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(PUNCH_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(PUNCHME_HANDLER)
__mod_name__ = "Bans"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, PUNCH_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
PUNCHME_HANDLER
]
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.chat_type.groups, run_async=True
)
SET_RULES_HANDLER = CommandHandler(
"setrules", set_rules, filters=Filters.chat_type.groups, run_async=True
)
RESET_RULES_HANDLER = CommandHandler(
"clearrules", clear_rules, filters=Filters.chat_type.groups, run_async=True
)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
query_timezone = query.lower()
if len(query_timezone) == 2:
result = generate_time(query_timezone, ["countryCode"])
else:
result = generate_time(query_timezone, ["zoneName", "countryName"])
if not result:
send_message.edit_text(
f"Timezone info not available for <b>{query}</b>\n"
'<b>All Timezones:</b> <a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">List here</a>',
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
return
send_message.edit_text(
result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
TIME_HANDLER = DisableAbleCommandHandler("time", gettime, run_async=True)
dispatcher.add_handler(TIME_HANDLER)
__mod_name__ = "Time"
__command_list__ = ["time"]
__handlers__ = [TIME_HANDLER]
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"
#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("hug", hug)
#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)
dispatcher.add_handler(FEED_HANDLER)
unload_messasge.edit_text(f"Successfully unloaded module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
@run_async
@sudo_plus
def listmodules(update: Update, context: CallbackContext):
message = update.effective_message
module_list = []
for helpable_module in HELPABLE:
helpable_module_info = IMPORTED[helpable_module]
file_info = IMPORTED[helpable_module_info.__mod_name__.lower()]
file_name = file_info.__name__.rsplit("YoneRobot.modules.", 1)[1]
mod_name = file_info.__mod_name__
module_list.append(f"- <code>{mod_name} ({file_name})</code>\n")
module_list = "Following modules are loaded : \n\n" + "".join(module_list)
message.reply_text(module_list, parse_mode=ParseMode.HTML)
LOAD_HANDLER = CommandHandler("load", load)
UNLOAD_HANDLER = CommandHandler("unload", unload)
LISTMODULES_HANDLER = CommandHandler("listmodules", listmodules)
dispatcher.add_handler(LOAD_HANDLER)
dispatcher.add_handler(UNLOAD_HANDLER)
dispatcher.add_handler(LISTMODULES_HANDLER)
__mod_name__ = "Modules"
def load(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text.split(" ", 1)[1]
load_messasge = message.reply_text(
f"Attempting to load module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
try:
imported_module = importlib.import_module("AsunaRobot.modules." + text)
except:
load_messasge.edit_text("Does that module even exist?")
return
if not hasattr(imported_module, "__mod_name__"):
imported_module.__mod_name__ = imported_module.__name__
if imported_module.__mod_name__.lower() not in IMPORTED:
IMPORTED[imported_module.__mod_name__.lower()] = imported_module
else:
load_messasge.edit_text("Module already loaded.")
return
if "__handlers__" in dir(imported_module):
handlers = imported_module.__handlers__
for handler in handlers:
if not isinstance(handler, tuple):
dispatcher.add_handler(handler)
else:
if isinstance(handler[0], collections.Callable):
callback, telethon_event = handler
telethn.add_event_handler(callback, telethon_event)
else:
handler_name, priority = handler
dispatcher.add_handler(handler_name, priority)
else:
IMPORTED.pop(imported_module.__mod_name__.lower())
load_messasge.edit_text("The module cannot be loaded.")
return
if hasattr(imported_module, "__help__") and imported_module.__help__:
HELPABLE[imported_module.__mod_name__.lower()] = imported_module
# Chats to migrate on chat_migrated events
if hasattr(imported_module, "__migrate__"):
MIGRATEABLE.append(imported_module)
if hasattr(imported_module, "__stats__"):
STATS.append(imported_module)
if hasattr(imported_module, "__user_info__"):
USER_INFO.append(imported_module)
if hasattr(imported_module, "__import_data__"):
DATA_IMPORT.append(imported_module)
if hasattr(imported_module, "__export_data__"):
DATA_EXPORT.append(imported_module)
if hasattr(imported_module, "__chat_settings__"):
CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
if hasattr(imported_module, "__user_settings__"):
USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
load_messasge.edit_text(
"Successfully loaded module : <b>{}</b>".format(text),
parse_mode=ParseMode.HTML)
def main():
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_")
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)
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()
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)
EDIT_SLEEP = 2
#edit how many times in 'police'
EDIT_TIMES = 3
POLICE_SIREN = [
"🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵\n🔴🔴🔴⬜️⬜️⬜️🔵🔵🔵",
"🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴\n🔵🔵🔵⬜️⬜️⬜️🔴🔴🔴"
]
@user_admin
@run_async
def police(update: Update, context: CallbackContext):
msg = update.effective_message.reply_text('Police is coming!')
for x in range(EDIT_TIMES):
msg.edit_text(POLICE_SIREN[x % 2])
time.sleep(EDIT_SLEEP)
msg.edit_text('Police is here!')
__help__ = """
• `/police`*:* Sends a police emoji animation.
"""
POLICE_HANDLER = DisableAbleCommandHandler("police", police)
dispatcher.add_handler(POLICE_HANDLER)
__mod_name__ = "Animation"
__command_list__ = ["police"]
__handlers__ = [POLICE_HANDLER]
• `/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__ = [
def get_chat(chat_id, chat_data):
# print(chat_data)
try:
return chat_data[chat_id]["backups"]
except KeyError:
return {"status": False, "value": False}
__mod_name__ = "Backups"
__help__ = """
*Only for group owner:*
• /import: Reply to the backup file for the butler / emilia group to import as much as possible, making transfers very easy! \
Note that files / photos cannot be imported due to telegram restrictions.
• /export: Export group data, which will be exported are: rules, notes (documents, images, music, video, audio, voice, text, text buttons) \
"""
IMPORT_HANDLER = CommandHandler("import", import_data, run_async=True)
EXPORT_HANDLER = CommandHandler("export",
export_data,
pass_chat_data=True,
run_async=True)
dispatcher.add_handler(IMPORT_HANDLER)
dispatcher.add_handler(EXPORT_HANDLER)
CONNECT_CHAT_HANDLER = CommandHandler("connect",
connect_chat,
pass_args=True,
run_async=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection",
connection_chat,
run_async=True)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect",
disconnect_chat,
run_async=True)
ALLOW_CONNECTIONS_HANDLER = CommandHandler(
"allowconnect",
allow_connections,
pass_args=True,
run_async=True,
)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect",
help_connect_chat,
run_async=True)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button,
pattern=r"connect",
run_async=True)
dispatcher.add_handler(CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECTION_CHAT_HANDLER)
dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER)
dispatcher.add_handler(HELP_CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECT_BTN_HANDLER)
sent_msg.edit_text("Restarted.")
os.system("restart.bat")
os.execv("start.bat", sys.argv)
@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, run_async=True)
GITPULL_HANDLER = CommandHandler("gitpull", gitpull, run_async=True)
RESTART_HANDLER = CommandHandler("reboot", restart, run_async=True)
ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups, run_async=True)
dispatcher.add_handler(ALLOWGROUPS_HANDLER)
dispatcher.add_handler(LEAVE_HANDLER)
dispatcher.add_handler(GITPULL_HANDLER)
dispatcher.add_handler(RESTART_HANDLER)
__mod_name__ = "Dev"
__handlers__ = [
LEAVE_HANDLER, GITPULL_HANDLER, RESTART_HANDLER, ALLOWGROUPS_HANDLER
]
f"&to_currency={new_cur}"
f"&apikey={CASH_API_KEY}")
response = requests.get(request_url).json()
try:
current_rate = float(response["Realtime Currency Exchange Rate"]
["5. Exchange Rate"])
except KeyError:
update.effective_message.reply_text("Currency Not Supported.")
return
new_cur_amount = round(orig_cur_amount * current_rate, 5)
update.effective_message.reply_text(
f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}")
elif len(args) == 1:
update.effective_message.reply_text(__help__,
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
f"*Invalid Args!!:* Required 3 But Passed {len(args) -1}",
parse_mode=ParseMode.MARKDOWN,
)
CONVERTER_HANDLER = CommandHandler("cash", convert)
dispatcher.add_handler(CONVERTER_HANDLER)
__command_list__ = ["cash"]
__handlers__ = [CONVERTER_HANDLER]
}
rep = f"{user} was listening to:\n"
for artist, song in track_dict.items():
rep += f"🎧 <code>{artist} - {song}</code>\n"
last_user = (requests.get(
f"{base_url}?method=user.getinfo&user={username}&api_key={LASTFM_API_KEY}&format=json"
).json().get("user"))
scrobbles = last_user.get("playcount")
rep += f"\n(<code>{scrobbles}</code> scrobbles so far)"
buttons = InlineKeyboardMarkup([[
InlineKeyboardButton(
"📺 Youtube",
url=
f"https://www.youtube.com/results?search_query={artist}+-+{song}",
)
]])
msg.reply_text(rep, reply_markup=buttons, parse_mode=ParseMode.HTML)
SET_USER_HANDLER = CommandHandler("setuser",
set_user,
pass_args=True,
run_async=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user, run_async=True)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm, run_async=True)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(LASTFM_HANDLER)
LOGGER.warning(update)
LOGGER.exception(
"ERROR muting user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Well damn, I can't mute that user.")
return ""
# __help__ = """
# *Admins 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.
# """
MUTE_HANDLER = CommandHandler("mute", mute)
UNMUTE_HANDLER = CommandHandler("unmute", unmute)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
__mod_name__ = "Muting"
__handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
"(〜￣△￣)〜",
"(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫",
"( o˘◡˘o) ┌iii┐",
"♨o(>_<)o♨",
"( ・・)つ―{}@{}@{}-",
"(*´з`)口ﾟ｡ﾟ口(・∀・ )",
"( *^^)o∀*∀o(^^* )",
"-●●●-ｃ(・・ )",
"(ﾉ≧∀≦)ﾉ ‥…━━━★",
"╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ",
"(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)",
]
def react(update: Update, context: CallbackContext):
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)
REACT_HANDLER = DisableAbleCommandHandler("react", react, run_async=True)
dispatcher.add_handler(REACT_HANDLER)
__command_list__ = ["react"]
__handlers__ = [REACT_HANDLER]
return "No log channel is set for this group!"
__help__ = """
*Admins only:*
❍ /logchannel*:* get log channel info
❍ /setlog*:* set the log channel.
❍ /unsetlog*:* unset the log channel.
Setting the log channel is done by:
❍ adding the bot to the desired channel (as an admin!)
❍ sending /setlog in the channel
❍ forwarding the /setlog to the group
"""
__mod_name__ = "Channel"
LOG_HANDLER = CommandHandler("logchannel", logging)
SET_LOG_HANDLER = CommandHandler("setlog", setlog)
UNSET_LOG_HANDLER = CommandHandler("unsetlog", unsetlog)
dispatcher.add_handler(LOG_HANDLER)
dispatcher.add_handler(SET_LOG_HANDLER)
dispatcher.add_handler(UNSET_LOG_HANDLER)
else:
# run anyway if module not loaded
def loggable(func):
return func
def gloggable(func):
return func
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll, run_async=True)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss, run_async=True)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug, run_async=True)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext",
bluetext,
run_async=True)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg, run_async=True)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide, run_async=True)
EIGHTBALL_HANDLER = DisableAbleCommandHandler("8ball",
eightball,
run_async=True)
TABLE_HANDLER = DisableAbleCommandHandler("table", table, run_async=True)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, run_async=True)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, run_async=True)
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__ = "Fun"
)
CHAT_PIC_HANDLER = CommandHandler("setgpic", setchatpic, filters=Filters.group)
DEL_CHAT_PIC_HANDLER = CommandHandler(
"delgpic", rmchatpic, filters=Filters.group)
SETCHAT_TITLE_HANDLER = CommandHandler(
"setgtitle", setchat_title, filters=Filters.group
)
SETSTICKET_HANDLER = CommandHandler(
"setsticker", set_sticker, filters=Filters.group)
SETDESC_HANDLER = CommandHandler(
"setdescription",
set_desc,
filters=Filters.group)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_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)
__mod_name__ = "Admin"
__command_list__ = [
shell=True)
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)
dispatcher.add_handler(SHELL_HANDLER)
__mod_name__ = "Shell"
__command_list__ = ["sh"]
__handlers__ = [SHELL_HANDLER]
*Note*: Filters also support markdown formatters like: {first}, {last} etc.. and buttons.
Check `/markdownhelp` to know more!
"""
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
RMALLFILTER_HANDLER = CommandHandler(
"removeallfilters", rmall_filters, filters=Filters.group)
RMALLFILTER_CALLBACK = CallbackQueryHandler(
rmall_callback, pattern=r"filters_.*")
LIST_HANDLER = DisableAbleCommandHandler(
"filters", list_handlers, admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message, 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)
dispatcher.add_handler(RMALLFILTER_HANDLER)
dispatcher.add_handler(RMALLFILTER_CALLBACK)
__handlers__ = [
FILTER_HANDLER, STOP_HANDLER, LIST_HANDLER,
(CUST_FILTER_HANDLER, HANDLER_GROUP, RMALLFILTER_HANDLER)
]
FACTOR_HANDLER = DisableAbleCommandHandler("factor", factor)
DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive)
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate)
ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes)
TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent)
AREA_HANDLER = DisableAbleCommandHandler("area", area)
COS_HANDLER = DisableAbleCommandHandler("cos", cos)
SIN_HANDLER = DisableAbleCommandHandler("sin", sin)
TAN_HANDLER = DisableAbleCommandHandler("tan", tan)
ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos)
ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin)
ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan)
ABS_HANDLER = DisableAbleCommandHandler("abs", abs)
LOG_HANDLER = DisableAbleCommandHandler("log", log)
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)
speed.download()
speed.upload()
replymsg = "SpeedTest Results:"
if query.data == "speedtest_image":
speedtest_image = speed.results.share()
update.effective_message.reply_photo(photo=speedtest_image,
caption=replymsg)
msg.delete()
elif query.data == "speedtest_text":
result = speed.results.dict()
replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`"
update.effective_message.edit_text(replymsg,
parse_mode=ParseMode.MARKDOWN)
else:
query.answer(
"You are required to join Heroes Association to use this command.")
SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz)
SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback,
pattern="speedtest_.*")
dispatcher.add_handler(SPEED_TEST_HANDLER)
dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER)
__mod_name__ = "SpeedTest"
__command_list__ = ["speedtest"]
__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
return text
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
return f"This chat is enforcing *gbans*: `{sql.does_chat_gban(chat_id)}`."
GBAN_HANDLER = CommandHandler("gban", gban)
UNGBAN_HANDLER = CommandHandler("ungban", ungban)
GBAN_LIST = CommandHandler("gbanlist", gbanlist)
GBAN_STATUS = CommandHandler("antispam", gbanstat, 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)
__mod_name__ = "Anti-Spam"
__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
__handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo",
echo,
filters=Filters.chat_type.groups,
run_async=True)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, run_async=True)
PING_HANDLER = DisableAbleCommandHandler("ping", ping, run_async=True)
PASTE_HANDLER = DisableAbleCommandHandler("paste",
paste,
pass_args=True,
run_async=True)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, run_async=True)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(WIKI_HANDLER)
dispatcher.add_handler(WALLPAPER_HANDLER)
dispatcher.add_handler(PASTE_HANDLER)
__mod_name__ = "Extra"
__command_list__ = ["id", "echo", "ping", "paste", "wiki", "wall"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
PING_HANDLER,
PASTE_HANDLER,
WIKI_HANDLER,
WALLPAPER_HANDLER,
from telegram import Update
from telegram.ext import CallbackContext, run_async, CommandHandler
from AsunaRobot import dispatcher
from AsunaRobot.modules.helper_funcs.chat_status import dev_plus
@run_async
@dev_plus
def logs(update: Update, context: CallbackContext):
message = update.effective_message
chat_id = message.chat_id
if chat_id != -1001408942668:
return
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)
dispatcher.add_handler(LOG_HANDLER)
