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"
import requests
from MinatoNamikaze import dispatcher
from MinatoNamikaze.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]
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)
]
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("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(ADD_NSFW_HANDLER)
dispatcher.add_handler(REMOVE_NSFW_HANDLER)
dispatcher.add_handler(LIST_NSFW_CHATS_HANDLER)
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)
return build_curr_disabled(chat_id)
DISABLE_HANDLER = CommandHandler("disable", disable, run_async=True)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule",
disable_module,
run_async=True)
ENABLE_HANDLER = CommandHandler("enable", enable, run_async=True)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule",
enable_module,
run_async=True)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"],
commands,
run_async=True)
TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds, run_async=True)
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
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)
msg = f"*{cityname}, {fullc_n}*\n"
msg += f"`Longitude: {longitude}`\n"
msg += f"`Latitude: {latitude}`\n\n"
msg += f"• **Time:** `{time}`\n"
msg += f"• **Temperature:** `{celsius(curtemp)}°C\n`"
msg += f"• **Feels like:** `{celsius(feels_like)}°C\n`"
msg += f"• **Condition:** `{condmain}, {conddet}` " + f"{icon}\n"
msg += f"• **Humidity:** `{humidity}%`\n"
msg += f"• **Wind:** `{kmph[0]} km/h`\n"
msg += f"• **Sunrise**: `{sun(sunrise)}`\n"
msg += f"• **Sunset**: `{sun(sunset)}`"
else:
msg = "Please specify a city or country"
delmsg = message.reply_text(
text=msg,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
cleartime = get_clearcmd(chat.id, "weather")
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
WEATHER_HANDLER = CommandHandler(["weather"], weather, run_async=True)
dispatcher.add_handler(WEATHER_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]
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}"
)
support_chat = os.getenv('SUPPORT_CHAT')
@run_async
@dev_plus
def logs(update: Update, context: CallbackContext):
chat_username = update.effective_chat.username
if not chat_username:
return
if chat_username != support_chat:
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)
DEBUG_HANDLER = CommandHandler("debug", debug)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
__mod_name__ = "Connection"
__help__ = """
Sometimes, you just want to add some notes and filters to a group chat, but you don't want everyone to see; This is where connections come in...
This allows you to connect to a chat's database, and add things to it without the commands appearing in chat! For obvious reasons, you need to be an admin to add things; but any member in the group can view your data.
• `/connect`: Connects to chat (Can be done in a group by `/connect` or `/connect <chat id>` in PM)
• `/connection`: List connected chats
• `/disconnect`: Disconnect from a chat
• `/helpconnect`: List available commands that can be used remotely
*Admin only:*
• `/allowconnect <yes/no>`: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, 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, run_async=True
)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat)
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)
msg = "I don't understand what are you trying to do. Check module help for more details"
message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = """
*Get module configuration:*
• `/clearcmd`: provides all commands that has been set in current group with their deletion time
• `/clearcmd list`: list all available commands for this module
• `/clearcmd <command>`: get the deletion time for a specific `<command>`
*Set module configuration:*
• `/clearcmd <command> <time>`: set a deletion `<time>` for a specific `<command>` in current group. All outputs of that command will be deleted in that group after time value in seconds. Time can be set between 5 and 300 seconds
*Restore module configuration:*
• `/clearcmd restore`: the deletion time set for ALL commands will be removed in current group
• `/clearcmd <command> restore`: the deletion time set for a specific `<command>` will be removed in current group
"""
CLEARCMD_HANDLER = CommandHandler("clearcmd", clearcmd, run_async=True)
dispatcher.add_handler(CLEARCMD_HANDLER)
__mod_name__ = "Clear Commands"
__command_list__ = ["clearcmd"]
__handlers__ = [CLEARCMD_HANDLER]
message = update.effective_message
string = ""
if message.reply_to_message:
string = message.reply_to_message.text.lower().replace(" ", " ")
if args:
string = " ".join(args).lower()
if not string:
message.reply_text("Usage is `/weebify <text>`", parse_mode=ParseMode.MARKDOWN)
return
for normiecharacter in string:
if normiecharacter in normiefont:
weebycharacter = weebyfont[normiefont.index(normiecharacter)]
string = string.replace(normiecharacter, weebycharacter)
if message.reply_to_message:
message.reply_to_message.reply_text(string)
else:
message.reply_text(string)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, run_async=True)
dispatcher.add_handler(WEEBIFY_HANDLER)
__command_list__ = ["weebify"]
__handlers__ = [WEEBIFY_HANDLER]
*Commands:*
*Admins only:*
• `/addchat`*:* Enables Chatbot mode in the chat.
• `/rmchat`*:* Disables Chatbot mode in the chat.
Reports bugs at @{SUPPORT_CHAT}
*Powered by CoffeeHouse* (https://coffeehouse.intellivoid.net/) from @Intellivoid
"""
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
]
Reply 2
%%%
Reply 3`
• `/clear <notename>`*:* clear note with this name
• `/removeallnotes`*:* removes all notes from the group
*Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved.
• `/privatenotes <on/yes/1/off/no/0>`: enable or disable private notes in chat
"""
__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)
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)
• `/delrepo <name>`: deletes a repo shortcut
"""
__mod_name__ = "GitHub"
RELEASE_HANDLER = DisableAbleCommandHandler(
"git", getRelease, admin_ok=True, run_async=True
)
FETCH_HANDLER = DisableAbleCommandHandler(
"fetch", cmdFetch, admin_ok=True, run_async=True
)
SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, run_async=True)
DELREPO_HANDLER = CommandHandler("delrepo", delRepo, run_async=True)
LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo", listRepo, admin_ok=True, run_async=True)
VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True, run_async=True)
CHANGELOG_HANDLER = DisableAbleCommandHandler(
"changelog", changelog, admin_ok=True, run_async=True
)
HASHFETCH_HANDLER = RegexHandler(r"^&[^\s]+", hashFetch)
dispatcher.add_handler(RELEASE_HANDLER)
dispatcher.add_handler(FETCH_HANDLER)
dispatcher.add_handler(SAVEREPO_HANDLER)
dispatcher.add_handler(DELREPO_HANDLER)
dispatcher.add_handler(LISTREPO_HANDLER)
dispatcher.add_handler(HASHFETCH_HANDLER)
dispatcher.add_handler(VERCHECKER_HANDLER)
dispatcher.add_handler(CHANGELOG_HANDLER)
*Wallpapers:*
• `/wall <query>`*:* get a wallpaper from wall.alphacoders.com\n
*Currency converter:*
• `/cash`*:* currency converter
Example:
`/cash 1 USD INR`
_OR_
`/cash 1 usd inr`
Output: `1.0 USD = 75.505 INR`\n
*Timezones:*
• `/time <query>`*:* Gives information about a timezone.
*Available queries:* Country Code/Country Name/Timezone Name
• 🕐 [Timezones list](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo",
echo,
filters=Filters.chat_type.groups,
run_async=True)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help, run_async=True)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo", "covid", "weather", "quotly"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
]
if val in ["off", "no", "0", "disable", "false"]:
setprivatenotes(chat.id, False)
msg = f"Private notes has been disabled in *{chat.title}*"
elif val in ["on", "yes", "1", "enable", "true"]:
setprivatenotes(chat.id, True)
msg = f"Private notes has been enabled in *{chat.title}*"
else:
msg = "Sorry, wrong value"
message.reply_text(text=msg, parse_mode=ParseMode.MARKDOWN)
def setprivatenotes(chat_id, setting):
sql.set_private_notes(chat_id, setting)
def getprivatenotes(chat_id):
setting = sql.get_private_notes(chat_id)
return setting
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
PRIVATENOTES_HANDLER = CommandHandler("privatenotes",
privatenotes,
run_async=True)
dispatcher.add_handler(PRIVATENOTES_HANDLER)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
BROADCAST_HANDLER = CommandHandler(
["broadcastall", "broadcastusers", "broadcastgroups"],
broadcast,
run_async=True)
USER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
log_user,
run_async=True)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
chat_checker,
run_async=True)
CHATLIST_HANDLER = CommandHandler(["groups", "chatlist"],
chats,
run_async=True)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
__mod_name__ = "Users"
__handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER,
CHATLIST_HANDLER]
def main():
start_handler = CommandHandler("start", start, run_async=True)
help_handler = CommandHandler("help", get_help, run_async=True)
help_callback_handler = CallbackQueryHandler(help_button,
pattern=r"help_.*",
run_async=True)
settings_handler = CommandHandler("settings", get_settings, run_async=True)
settings_callback_handler = CallbackQueryHandler(settings_button,
pattern=r"stngs_",
run_async=True)
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_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,
drop_pending_updates=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
update.effective_message.reply_text("Done! Lockdown value toggled.")
@dev_plus
def leave(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
if args:
chat_id = str(args[0])
try:
bot.leave_chat(int(chat_id))
except TelegramError:
update.effective_message.reply_text(
"Beep boop, I could not leave that group(dunno why tho).")
return
with suppress(Unauthorized):
update.effective_message.reply_text(
"Beep boop, I left that soup!.")
else:
update.effective_message.reply_text("Send a valid chat ID")
LEAVE_HANDLER = CommandHandler("leave", leave, run_async=True)
ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups, run_async=True)
dispatcher.add_handler(ALLOWGROUPS_HANDLER)
dispatcher.add_handler(LEAVE_HANDLER)
__mod_name__ = "Dev"
__handlers__ = [LEAVE_HANDLER, ALLOWGROUPS_HANDLER]
def main():
if SUPPORT_CHAT is not None and isinstance(SUPPORT_CHAT, str):
try:
dispatcher.bot.sendMessage(f"@{SUPPORT_CHAT}", "I am now online!")
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_")
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()
deletion(update, context, delmsg)
except ValueError:
delmsg = update.effective_message.reply_text("The intended language is not found!")
deletion(update, context, delmsg)
else:
return
def deletion(update: Update, context: CallbackContext, delmsg):
chat = update.effective_chat
cleartime = get_clearcmd(chat.id, "tr")
if cleartime:
context.dispatcher.run_async(delete, delmsg, cleartime.time)
__help__ = """
• `/tr` or `/tl` (language code) as reply to a long message
*Example:*
`/tr en`*:* translates something to english
`/tr hi-en`*:* translates hindi to english
"""
TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate, run_async=True)
dispatcher.add_handler(TRANSLATE_HANDLER)
__mod_name__ = "Translator"
__command_list__ = ["tr", "tl"]
__handlers__ = [TRANSLATE_HANDLER]
__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__ = "Log Channels"
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
from MinatoNamikaze import dispatcher
from MinatoNamikaze.modules.disable import DisableAbleCommandHandler
from telegram import Update
from telegram.ext import CallbackContext, run_async
def shout(update: Update, context: CallbackContext):
args = context.args
text = " ".join(args)
result = []
result.append(" ".join([s for s in text]))
for pos, symbol in enumerate(text[1:]):
result.append(symbol + " " + " " * pos + symbol)
result = list("\n".join(result))
result[0] = text[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, run_async=True)
dispatcher.add_handler(SHOUT_HANDLER)
__command_list__ = ["shout"]
__handlers__ = [SHOUT_HANDLER]
remove_bluetext_ignore,
run_async=True)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler("gignoreblue",
add_bluetext_ignore_global,
run_async=True)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global, run_async=True)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue",
bluetext_ignore_list,
run_async=True)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command
& Filters.chat_type.groups,
clean_blue_text_must_click,
run_async=True)
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,
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(MEME_HANDLER)
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)
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)
__help__ = """
• `/time <query>`*:* Gives information about a timezone.
*Available queries:* Country Code/Country Name/Timezone Name
• 🕐 [Timezones list](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones)
"""
TIME_HANDLER = DisableAbleCommandHandler("time", gettime)
dispatcher.add_handler(TIME_HANDLER)
__mod_name__ = "Time"
__command_list__ = ["time"]
__handlers__ = [TIME_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 = CommandHandler("rss", show_url)
ADD_URL_HANDLER = CommandHandler("addrss", add_url)
REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url)
LIST_URLS_HANDLER = CommandHandler("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)
"(〜￣△￣)〜",
"(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫",
"( 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]