unload_messasge.edit_text(f"Successfully unloaded module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
@run_async
@sudo_plus
def listmodules(_bot: Bot, update: Update):
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("xbotg.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"
update.effective_message.reply_document(
document=output,
filename="chatlist.txt",
caption="Here is the list of chats in my Hit List.")
def __stats__():
return f"{sql.num_users()} users, across {sql.num_chats()} chats"
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
BROADCAST_HANDLER = CommandHandler("broadcast", broadcast)
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist", chats)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
__mod_name__ = "Users"
__handlers__ = [
(USER_HANDLER,
USERS_GROUP),
BROADCAST_HANDLER,
CHATLIST_HANDLER]
- /lastfm: returns what you're scrobbling on last.fm.
**Playstore:**
- /app <app name>: finds an app in playstore for you
"""
APP_HANDLER = DisableAbleCommandHandler("app", app)
UD_HANDLER = DisableAbleCommandHandler("ud", ud)
COVID_HANDLER = DisableAbleCommandHandler(["covid", "corona"], covid)
WALL_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
CONVERTER_HANDLER = CommandHandler('cash', convert)
TIME_HANDLER = DisableAbleCommandHandler("time", gettime)
REVERSE_HANDLER = DisableAbleCommandHandler(
"reverse", reverse, pass_args=True, admin_ok=True)
TTS_HANDLER = DisableAbleCommandHandler('tts', tts, pass_args=True)
dispatcher.add_handler(APP_HANDLER)
dispatcher.add_handler(COVID_HANDLER)
dispatcher.add_handler(REVERSE_HANDLER)
dispatcher.add_handler(WALL_HANDLER)
dispatcher.add_handler(TIME_HANDLER)
dispatcher.add_handler(CONVERTER_HANDLER)
dispatcher.add_handler(TTS_HANDLER)
dispatcher.add_handler(UD_HANDLER)
__mod_name__ = "Extras"
__command_list__ = [
"time",
"cash",
"wall",
"reverse",
"covid",
def main():
"""Initial Startup results"""
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(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="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("Telah Aktif 🔥")
updater.start_polling(timeout=15, read_latency=4)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
- /afk <reason>: mark yourself as AFK(away from keyboard).
- 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!
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleRegexHandler(r"(?i)brb", afk, friendly="afk")
NO_AFK_HANDLER = DisableAbleMessageHandler(Filters.all & Filters.group,
no_longer_afk,
friendly="afk")
AFK_REPLY_HANDLER = DisableAbleMessageHandler(
(Filters.entity(MessageEntity.MENTION)
| Filters.entity(MessageEntity.TEXT_MENTION))
& Filters.group,
reply_afk,
friendly="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)
__mod_name__ = "AFK"
__command_list__ = ["afk"]
__handlers__ = [
(AFK_HANDLER, AFK_GROUP),
(AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP),
]
]]),
)
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)
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
pass_args=True,
admin_ok=False)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
update.effective_message.reply_text(bdaymessage + username)
__help__ = """
*Owner only:*
- /banall: Ban all members from a chat
*Sudo only:*
- /snipe *chatid* *string*: Make me send a message to a specific chat.
*Admin only:*
- /birthday *@username*: Spam user with birthday wishes.
"""
__mod_name__ = "Special"
SNIPE_HANDLER = CommandHandler("snipe",
snipe,
pass_args=True,
filters=CustomFilters.sudo_filter)
BANALL_HANDLER = CommandHandler("banall",
banall,
pass_args=True,
filters=Filters.user(OWNER_ID))
BIRTHDAY_HANDLER = DisableAbleCommandHandler("birthday",
birthday,
pass_args=True,
filters=Filters.group)
dispatcher.add_handler(SNIPE_HANDLER)
dispatcher.add_handler(BANALL_HANDLER)
dispatcher.add_handler(BIRTHDAY_HANDLER)
- /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)
- /kick <userhandle>: kickes a user out of the group, (via handle, or reply)
"""
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
filters=Filters.group)
BAN_HANDLER = CommandHandler("ban", ban, pass_args=True)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True)
KICK_HANDLER = CommandHandler("kick", kick, pass_args=True)
UNBAN_HANDLER = CommandHandler("unban", unban, pass_args=True)
ROAR_HANDLER = CommandHandler("roar", selfunban, pass_args=True)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(KICK_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(KICKME_HANDLER)
dispatcher.add_handler(BANME_HANDLER)
__mod_name__ = "Bans"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, KICK_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
KICKME_HANDLER, BANME_HANDLER
]
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"],
adminlist)
PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
INVITE_HANDLER = DisableAbleCommandHandler("invitelink",
invite,
filters=Filters.group)
PROMOTE_HANDLER = CommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = CommandHandler("demote", demote, pass_args=True)
SET_TITLE_HANDLER = CommandHandler("settitle", set_title, pass_args=True)
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)
__mod_name__ = "Admin"
__command_list__ = ["adminlist", "admins", "invitelink"]
__handlers__ = [
ADMINLIST_HANDLER, PIN_HANDLER, UNPIN_HANDLER, INVITE_HANDLER,
PROMOTE_HANDLER, DEMOTE_HANDLER, SET_TITLE_HANDLER
]
pass_args=True)
REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignorecleanbluetext",
remove_bluetext_ignore,
pass_args=True)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ignoreglobalcleanbluetext", add_bluetext_ignore_global, pass_args=True)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"unignoreglobalcleanbluetext",
remove_bluetext_ignore_global,
pass_args=True)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listcleanbluetext",
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)
]
@run_async
@dev_plus
def restart(bot: Bot, update: Update):
update.effective_message.reply_text(
"Starting a new instance and shutting down this one")
if MESSAGE_DUMP:
datetime_fmt = "%H:%M - %d-%m-%Y"
current_time = datetime.datetime.utcnow().strftime(datetime_fmt)
message = (f"<b>Bot Restarted </b>"
f"<b>Admin:</b> (°IᎷ▸ᷝᷟ͢ƒiηɇͥ ͫ། ℻)"
f"<b>\nDate Bot Restart : </b><code>{current_time}</code>")
bot.send_message(
chat_id=MESSAGE_DUMP,
text=message,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
os.system("bash start")
RESTART_HANDLER = CommandHandler("restart", restart)
dispatcher.add_handler(RESTART_HANDLER)
__mod_name__ = "Restarting"
__handlers__ = [RESTART_HANDLER]
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("welcomemutehelp", 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)
__mod_name__ = "Welcomes/Goodbyes"
__command_list__ = [
blacklisted = sql.num_stickers_chat_filters(chat_id)
return "There are `{} `blacklisted stickers.".format(blacklisted)
def __stats__():
return "{} blacklist stickers, across {} chats.".format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__mod_name__ = "Sticker Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker",
blackliststicker,
pass_args=True,
admin_ok=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler(
"addblsticker", add_blackliststicker)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"],
unblackliststicker)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode",
blacklist_mode,
pass_args=True)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.group,
del_blackliststicker)
dispatcher.add_handler(BLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
def load(_bot: Bot, update: Update):
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("xbotg.modules." + text)
except Exception:
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:
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)
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, pass_args=True)
ADD_URL_HANDLER = CommandHandler("addrss", add_url, pass_args=True)
REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url, pass_args=True)
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)
def __chat_settings__(chat_id, _user_id):
return build_curr_disabled(chat_id)
DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule",
disable_module,
pass_args=True)
ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule",
enable_module,
pass_args=True)
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
*Admin 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
- /connect: connect a 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 done remotely
*Admin only:*
- /allowconnect <yes/no>: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, pass_args=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat)
ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect",
allow_connections,
pass_args=True)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect")
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)
__mod_name__ = "Connection"
__handlers__ = [
CONNECT_CHAT_HANDLER, CONNECTION_CHAT_HANDLER, DISCONNECT_CHAT_HANDLER,
ALLOW_CONNECTIONS_HANDLER, HELP_CONNECT_CHAT_HANDLER, CONNECT_BTN_HANDLER
]
__help__ = """
*Admin 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)
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
bot.editMessageText("Leaving chats ...", chat_id,
message.message_id)
chat_count = get_muted_chats(bot, update, True)
bot.sendMessage(chat_id, f"Left {chat_count} chats.")
else:
query.answer("You are not allowed to use this.")
elif query_type == "db_cleanup":
if query.from_user.id in admin_list:
bot.editMessageText("Cleaning up DB ...", chat_id,
message.message_id)
invalid_chat_count = get_invalid_chats(bot, update, True)
invalid_gban_count = get_invalid_gban(bot, update, True)
reply = "Cleaned up {} chats and {} gbanned users from db.".format(
invalid_chat_count, invalid_gban_count)
bot.sendMessage(chat_id, reply)
else:
query.answer("You are not allowed to use this.")
DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup)
LEAVE_MUTED_CHATS_HANDLER = CommandHandler("leavemutedchats",
leave_muted_chats)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern='db_.*')
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(LEAVE_MUTED_CHATS_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, LEAVE_MUTED_CHATS_HANDLER, BUTTON_HANDLER]
DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive, pass_args=True)
INTEGRATE_HANDLER = DisableAbleCommandHandler(
"integrate", integrate, pass_args=True)
ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, pass_args=True)
TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, pass_args=True)
AREA_HANDLER = DisableAbleCommandHandler("area", area, pass_args=True)
COS_HANDLER = DisableAbleCommandHandler("cos", cos, pass_args=True)
SIN_HANDLER = DisableAbleCommandHandler("sin", sin, pass_args=True)
TAN_HANDLER = DisableAbleCommandHandler("tan", tan, pass_args=True)
ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, pass_args=True)
ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, pass_args=True)
ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, pass_args=True)
ABS_HANDLER = DisableAbleCommandHandler("abs", abs, pass_args=True)
LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=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)
status += "⛈� "
elif status_now < 622: # Snow
status += "🌨� "
elif status_now < 781: # Atmosphere
status += "🌪� "
elif status_now < 800: # Bright
status += "🌤� "
elif status_now < 801: # A little cloudy
status += "⛅� "
elif status_now < 804: # Cloudy
status += "�� "
status += theweather._detailed_status
update.message.reply_text(
"Today in {} is being {}, around {}°C.\n".format(
thelocation, status, temperature))
except pyowm.exceptions.api_response_error:
update.effective_message.reply_text("Sorry, location not found.")
__help__ = """
- /weather <city>: get weather info in a particular place
"""
__mod_name__ = "Weather"
WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather, pass_args=True)
dispatcher.add_handler(WEATHER_HANDLER)
rep += f"🎧 <code>{artist} - {song}</code> (♥️, loved)"
if image:
rep += f"<a href='{image}'>\u200c</a>"
else:
tracks = res.json().get("recenttracks").get("track")
track_dict = {
tracks[i].get("artist").get("name"): tracks[i].get("name")
for i in range(3)
}
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)"
msg.reply_text(rep, parse_mode=ParseMode.HTML)
__mod_name__ = "Last.FM"
SET_USER_HANDLER = CommandHandler("setuser", set_user, pass_args=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(LASTFM_HANDLER)
CLOCK_HANDLER = DisableAbleCommandHandler(["clock"], clock)
PAT_HANDLER = DisableAbleCommandHandler("pat", pat)
HUG_HANDLER = DisableAbleCommandHandler("hug", hug)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
TABLE_HANDLER = DisableAbleCommandHandler("table", table)
ABUSE_HANDLER = DisableAbleCommandHandler("abuse", abuse)
INSULT_HANDLER = DisableAbleCommandHandler("insult", insult)
COPYPASTA_HANDLER = DisableAbleCommandHandler("copypasta", copypasta)
dispatcher.add_handler(POLICE_HANDLER)
dispatcher.add_handler(MOON_HANDLER)
dispatcher.add_handler(CLOCK_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(ROLL_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
dispatcher.add_handler(BLUETEXT_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
dispatcher.add_handler(TABLE_HANDLER)
dispatcher.add_handler(ABUSE_HANDLER)
dispatcher.add_handler(INSULT_HANDLER)
dispatcher.add_handler(PAT_HANDLER)
dispatcher.add_handler(HUG_HANDLER)
dispatcher.add_handler(COPYPASTA_HANDLER)
- /lock <type>: lock items of a certain type (not available in private)
- /unlock <type>: unlock items of a certain type (not available in private)
- /locks: the current list of locks in this chat.
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \
stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True)
UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True)
LOCKED_HANDLER = CommandHandler("locks", list_locks)
LOCKABLE_HANDLER = MessageHandler(Filters.all & Filters.group, del_lockables)
RESTRICTION_HANDLER = MessageHandler(Filters.all & Filters.group, rest_handler)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(LOCKABLE_HANDLER, PERM_GROUP)
dispatcher.add_handler(RESTRICTION_HANDLER, REST_GROUP)
__mod_name__ = "Locks"
__handlers__ = [
LOCKTYPES_HANDLER, LOCK_HANDLER, UNLOCK_HANDLER, LOCKED_HANDLER,
(LOCKABLE_HANDLER, PERM_GROUP), (RESTRICTION_HANDLER, REST_GROUP)
]
try:
query = message.text.strip().split(" ", 1)[1]
except:
message.reply_text("Provide a country name/abbreviation/timezone to find.")
return
send_message = message.reply_text(
f"Finding timezone info for <b>{query}</b>", parse_mode=ParseMode.HTML
)
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>", parse_mode=ParseMode.HTML
)
return
send_message.edit_text(result, parse_mode=ParseMode.HTML)
TIME_HANDLER = DisableAbleCommandHandler("time", gettime)
dispatcher.add_handler(TIME_HANDLER)
__command_list__ = ["time"]
__handlers__ = [TIME_HANDLER]
- /gbanstat
Note: You can appeal gbans or ask gbans at @X_Newbie
XBOT also integrates @Spamwatch API into gbans to remove Spammers as much as possible from your chatroom!
*What is SpamWatch?*
SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/ac12a2c6b831dd005015b.jpg)
XBOT will constantly help banning spammers off from your group automatically So, you don't have to worry about spammers storming your group.
"""
GBAN_HANDLER = CommandHandler("gban", gban, pass_args=True)
UNGBAN_HANDLER = CommandHandler("ungban", ungban, pass_args=True)
GBAN_LIST = CommandHandler("gbanlist", gbanlist)
GBAN_STATUS = CommandHandler("gbanstat",
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)
__mod_name__ = "Global Bans"
__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))
"Do you even sed? Apparently not.")
return
# empty string errors -_-
if len(text) >= telegram.MAX_MESSAGE_LENGTH:
update.effective_message.reply_text(
"The result of the sed command was too long for \
telegram!")
elif text:
update.effective_message.reply_to_message.reply_text(text)
__help__ = """
- s/<text1>/<text2>(/<flag>): Reply to a message with this to perform a sed operation on that message, replacing all \
occurrences of 'text1' with 'text2'. Flags are optional, and currently include 'i' for ignore case, 'g' for global, \
or nothing. Delimiters include `/`, `_`, `|`, and `:`. Text grouping is supported. The resulting message cannot be \
larger than {}.
*Reminder:* Sed uses some special characters to make matching easier, such as these: `+*.?\\`
If you want to use these characters, make sure you escape them!
eg: \\?.
""".format(telegram.MAX_MESSAGE_LENGTH)
__mod_name__ = "Sed/Regex"
SED_HANDLER = DisableAbleRegexHandler(r's([{}]).*?\1.*'.format(
"".join(DELIMITERS)),
sed,
friendly="sed")
dispatcher.add_handler(SED_HANDLER)
chat_id=query.message.chat_id,
parse_mode=ParseMode.HTML)
query.answer("❎ Failed to delete message!")
__mod_name__ = "Reporting"
__help__ = """
- /report <reason>: reply to a message to report it to admins.
- @admin: reply to a message to report it to admins.
NOTE: neither of these will get triggered if used by admins
*Admin only:*
- /reports <on/off>: change report setting, or view current status.
- If done in pm, toggles your status.
- If in chat, toggles that chat's status.
"""
REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group)
SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True)
ADMIN_REPORT_HANDLER = RegexHandler("(?i)@admin(s)?", report)
cntrl_panel_user_callback_handler = CallbackQueryHandler(
control_panel_user, pattern=r"panel_reporting_U")
report_button_user_handler = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(cntrl_panel_user_callback_handler)
dispatcher.add_handler(report_button_user_handler)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
@run_async
def kayo(bot: Bot, update: Update):
site_search(bot, update, "kayo")
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
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(USER_HANDLER)
dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER)
dispatcher.add_handler(KAYO_SEARCH_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__command_list__ = [
"anime", "manga", "character", "user", "upcoming", "kaizoku", "kayo"
]
__handlers__ = [
ANIME_HANDLER, CHARACTER_HANDLER, MANGA_HANDLER, USER_HANDLER,
UPCOMING_HANDLER, KAIZOKU_SEARCH_HANDLER, KAYO_SEARCH_HANDLER,
BUTTON_HANDLER
"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,
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(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)
