GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True, run_async=True)
HASH_GET_HANDLER = MessageHandler(
Filters.regex(r"^#[^\s]+") & ~Filters.chat_type.channel,
hash_get,
run_async=True,
)
SAVE_HANDLER = CommandHandler("save", save, run_async=True)
DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True, run_async=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=True,
run_async=True)
CLEARALLNOTES_HANDLER = CommandHandler("rmallnotes",
clear_notes,
filters=Filters.chat_type.groups,
run_async=True)
RMBTN_HANDLER = CallbackQueryHandler(rmbutton,
pattern=r"rmnotes_",
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(CLEARALLNOTES_HANDLER)
dispatcher.add_handler(RMBTN_HANDLER)
`/setme Saya bekerja untuk Telegram`; Bio diatur untuk diri Anda sendiri.
Contoh penulisan biodata orang lain:
Balas pesan pengguna: `/setbio Dia orang yang keren`.
*Perhatian:* Jangan gunakan /setbio untuk melawan diri sendiri!
"""
__mod_name__ = "Bio/Tentang"
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio",
set_about_bio,
run_async=True)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio",
about_bio,
pass_args=True,
run_async=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme",
set_about_me,
run_async=True)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me",
about_me,
pass_args=True,
run_async=True)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
temp_ban,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True,
)
KICK_HANDLER = CommandHandler("kick",
kick,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True)
UNBAN_HANDLER = CommandHandler("unban",
unban,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.chat_type.groups,
run_async=True)
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
filters=Filters.chat_type.groups,
run_async=True)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(KICK_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(KICKME_HANDLER)
dispatcher.add_handler(BANME_HANDLER)
"{}".format(reply),
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
time.sleep(30)
try:
del_msg.delete()
update.effective_message.delete()
except BadRequest as err:
if (err.message == "Message to delete not found") or (
err.message == "Message can't be deleted"):
return
__help__ = """
Weather module:
× /weather <city>: Gets weather information of particular place!
\* To prevent spams weather command and the output will be deleted after 30 seconds
"""
__mod_name__ = "Weather"
WEATHER_HANDLER = DisableAbleCommandHandler("weather",
weather,
pass_args=True,
run_async=True)
dispatcher.add_handler(WEATHER_HANDLER)
def main():
# test_handler = CommandHandler("test", test)
start_handler = CommandHandler(
"start", start, pass_args=True, run_async=True
)
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(
help_button, pattern=r"help_", run_async=True
)
help_staff_handler = CommandHandler(
"staffhelp",
staff_help,
filters=CustomFilters.support_filter,
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
)
is_chat_allowed_handler = MessageHandler(Filters.chat_type.groups, is_chat_allowed)
# 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(help_staff_handler)
dispatcher.add_handler(settings_callback_handler)
dispatcher.add_handler(migrate_handler)
dispatcher.add_handler(is_chat_allowed_handler)
dispatcher.add_error_handler(error_handler)
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=5, clean=True)
if MESSAGE_DUMP:
updater.bot.send_message(
chat_id=MESSAGE_DUMP, text="System Started..."
)
updater.idle()
LIST_WARN_HANDLER = DisableAbleCommandHandler(
["warnlist", "warnfilters"],
list_warn_filters,
admin_ok=True,
run_async=True,
)
WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text
& Filters.chat_type.groups,
reply_filter,
run_async=True)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
set_warn_limit,
pass_args=True,
run_async=True)
WARN_STRENGTH_HANDLER = CommandHandler("strongwarn",
set_warn_strength,
pass_args=True,
run_async=True)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_HANDLER)
dispatcher.add_handler(REMOVE_WARNS_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)
welcomemute,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True,
)
CLEAN_SERVICE_HANDLER = CommandHandler(
"cleanservice",
cleanservice,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True,
)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help, run_async=True)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(
user_button, pattern=r"user_join_", 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(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_HELP)
× /allowconnect <yes/no>: allow a user to connect to a chat
"""
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)
× /rmallfilter: Stop all chat filters at once.
*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) # Don't Use async for this
RMALLFILTER_HANDLER = CommandHandler("rmallfilter",
rmall_filters,
filters=Filters.chat_type.groups,
run_async=True)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True,
run_async=True)
CUST_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & ~Filters.update.edited_message,
reply_filter,
run_async=True,
)
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)
def get_chat(chat_id, chat_data):
# print(chat_data)
try:
value = chat_data[chat_id]["backups"]
return value
except KeyError:
return {"status": False, "value": False}
__mod_name__ = "Backups"
__help__ = """
*Only for chat administrator:*
× /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)
users_db.num_chats())
def __migrate__(old_chat_id, new_chat_id):
users_db.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
__mod_name__ = "Users"
BROADCAST_HANDLER = CommandHandler("broadcast",
broadcast,
filters=Filters.user(OWNER_ID),
run_async=True)
USER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
log_user,
run_async=True)
CHATLIST_HANDLER = CommandHandler("chatlist",
chats,
filters=CustomFilters.sudo_filter,
run_async=True)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
chat_checker,
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)
It'll also allow you to autodelete them, stopping people from bluetexting.
× /cmds: Check the current status of disabled commands
*Admin only:*
× /enable <cmd name>: Enable that command
× /disable <cmd name>: Disable that command
× /listcmds: List all possible disablable commands
"""
DISABLE_HANDLER = CommandHandler(
"disable", disable, pass_args=True,
run_async=True) # , filters=Filters.chat_type.groups)
ENABLE_HANDLER = CommandHandler(
"enable", enable, pass_args=True,
run_async=True) # , filters=Filters.chat_type.groups)
COMMANDS_HANDLER = CommandHandler(
["cmds", "disabled"], commands,
run_async=True) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds, run_async=True)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
else:
DisableAbleCommandHandler = CommandHandler
DisableAbleMessageHandler = MessageHandler
speedtst,
filters=CustomFilters.sudo_filter,
run_async=True)
SYS_STATUS_HANDLER = CommandHandler("sysinfo",
system_status,
filters=CustomFilters.dev_filter,
run_async=True)
LEAVECHAT_HANDLER = CommandHandler(
["leavechat", "leavegroup", "leave"],
leavechat,
pass_args=True,
filters=CustomFilters.dev_filter,
run_async=True,
)
GITPULL_HANDLER = CommandHandler("gitpull",
gitpull,
filters=CustomFilters.dev_filter,
run_async=True)
RESTART_HANDLER = CommandHandler("reboot",
restart,
filters=CustomFilters.dev_filter,
run_async=True)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(SPEED_HANDLER)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(SYS_STATUS_HANDLER)
dispatcher.add_handler(LEAVECHAT_HANDLER)
dispatcher.add_handler(GITPULL_HANDLER)
dispatcher.add_handler(RESTART_HANDLER)
)
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, filters=CustomFilters.dev_filter, run_async=True
)
LEAVE_MUTED_CHATS_HANDLER = CommandHandler(
"leavemutedchats",
leave_muted_chats,
filters=CustomFilters.dev_filter,
run_async=True,
)
BUTTON_HANDLER = CallbackQueryHandler(
callback_button, pattern="db_.*", run_async=True
)
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]
Note:
- Value must be filled for tban and tmute!
It can be:
5m = 5 minutes
6h = 6 hours
3d = 3 days
1w = 1 week
"""
__mod_name__ = "Antiflood"
FLOOD_BAN_HANDLER = MessageHandler(
Filters.all & ~Filters.status_update & Filters.chat_type.groups,
check_flood,
run_async=True,
)
SET_FLOOD_HANDLER = CommandHandler(
"setflood", set_flood, pass_args=True,
run_async=True) # , filters=Filters.chat_type.groups)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode, pass_args=True,
run_async=True) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
FLOOD_HANDLER = CommandHandler("flood", flood, run_async=True)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(SET_FLOOD_MODE_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
__mod_name__ = "Android"
MAGISK_HANDLER = DisableAbleCommandHandler("magisk", magisk, run_async=True)
DEVICE_HANDLER = DisableAbleCommandHandler("device",
device,
pass_args=True,
run_async=True)
TWRP_HANDLER = DisableAbleCommandHandler("twrp",
twrp,
pass_args=True,
run_async=True)
LOS_HANDLER = DisableAbleCommandHandler("los",
los,
pass_args=True,
run_async=True)
BOOTLEG_HANDLER = DisableAbleCommandHandler("bootleg",
bootleg,
pass_args=True,
run_async=True)
GSI_HANDLER = DisableAbleCommandHandler("gsi",
gsi,
pass_args=True,
run_async=True)
dispatcher.add_handler(MAGISK_HANDLER)
dispatcher.add_handler(DEVICE_HANDLER)
dispatcher.add_handler(TWRP_HANDLER)
dispatcher.add_handler(LOS_HANDLER)
dispatcher.add_handler(GSI_HANDLER)
dispatcher.add_handler(BOOTLEG_HANDLER)
Locking urls will auto-delete all messages with urls, locking stickers will restrict all \
non-admin users from sending stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
Note:
• Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name
• Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes",
locktypes,
run_async=True)
# , filters=Filters.chat_type.groups)
LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True, run_async=True)
UNLOCK_HANDLER = CommandHandler(
"unlock", unlock, pass_args=True,
run_async=True) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
LOCKED_HANDLER = CommandHandler("locks", list_locks, run_async=True)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.chat_type.groups, del_lockables),
PERM_GROUP)
else:
update.effective_message.reply_text("Whadya want to delete?")
return ""
__help__ = """
Deleting messages made easy with this command. Bot purges \
messages all together or individually.
*Admin only:*
× /del: Deletes the message you replied to
× /purge: Deletes all messages between this and the replied to message.
× /purge <integer X>: Deletes the replied message, and X messages following it.
"""
__mod_name__ = "Purges"
DELETE_HANDLER = DisableAbleCommandHandler("del",
del_message,
filters=Filters.chat_type.groups,
run_async=True)
PURGE_HANDLER = DisableAbleCommandHandler("purge",
purge,
filters=Filters.chat_type.groups,
pass_args=True,
run_async=True)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(PURGE_HANDLER)
× /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.
An example of temporarily mute someone:
`/tmute @username 2h`; This mutes a user for 2 hours.
"""
__mod_name__ = "Muting"
MUTE_HANDLER = CommandHandler("mute",
mute,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True)
UNMUTE_HANDLER = CommandHandler("unmute",
unmute,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True)
TEMPMUTE_HANDLER = CommandHandler(
["tmute", "tempmute"],
temp_mute,
pass_args=True,
filters=Filters.chat_type.groups,
run_async=True,
)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
def scam(imgspage, lim):
"""Parse/Scrape the HTML code for the info we want."""
single = opener.open(imgspage).read()
decoded = single.decode("utf-8")
if int(lim) > 10:
lim = 10
imglinks = []
counter = 0
pattern = r"^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$"
oboi = re.findall(pattern, decoded, re.I | re.M)
for imglink in oboi:
counter += 1
imglinks.append(imglink)
if counter >= int(lim):
break
return imglinks
REVERSE_HANDLER = DisableAbleCommandHandler("reverse",
reverse,
pass_args=True,
admin_ok=True,
run_async=True)
dispatcher.add_handler(REVERSE_HANDLER)
suggestions = change.get("Suggestions")
if suggestions:
# should look at this list more
sugg_str = suggestions[0].get("Text")
curr_string += msg.text[prev_end:start] + sugg_str
prev_end = end
curr_string += msg.text[prev_end:]
update.effective_message.reply_text(curr_string)
else:
update.effective_message.reply_text(
"Reply to some message to get grammar corrected text!")
__help__ = """
× /tr or /tl: - To translate to your language, by default language is set to english, use `/tr <lang code>` for some other language!
× /spell: - As a reply to get grammar corrected text of gibberish message.
× /tts: - To some message to convert it into audio format!
"""
__mod_name__ = "Translate"
dispatcher.add_handler(
DisableAbleCommandHandler(["tr", "tl"],
gtrans,
pass_args=True,
run_async=True))
dispatcher.add_handler(
DisableAbleCommandHandler("tts", gtts, pass_args=True, run_async=True))
dispatcher.add_handler(
DisableAbleCommandHandler("spell", spellcheck, run_async=True))
# This source code copy from UserIndoBot Team, <https://github.com/userbotindo/UserIndoBot.git>
# Copyright (C) 2021 FS Project <https://github.com/FS-Project/Ferbot.git>
#
import os
import datetime
from telegram.ext import CommandHandler
from telegram import Update
from ferbot import dispatcher
from ferbot.modules.helper_funcs.filters import CustomFilters
from ferbot.modules.helper_funcs.alternate import typing_action
@typing_action
def logs(update, context):
user = update.effective_user
with open("ubotindo-log.txt", "rb") as f:
context.bot.send_document(
document=f,
filename=f.name,
chat_id=user.id,
caption="This logs that I saved",
)
update.effective_message.reply_text("I am send log to your pm 💌")
LOG_HANDLER = CommandHandler("logs",
logs,
filters=CustomFilters.dev_filter,
run_async=True)
dispatcher.add_handler(LOG_HANDLER)
text = re.sub(repl, repl_with, to_fix, count=1,
flags=re.I).strip()
elif "g" in flags:
text = re.sub(repl, repl_with, to_fix).strip()
else:
text = re.sub(repl, repl_with, to_fix, count=1).strip()
except sre_constants.error:
LOGGER.warning(update.effective_message.text)
LOGGER.exception("SRE constant error")
update.effective_message.reply_text(
"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)
SED_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"s([{}]).*?\1.*".format("".join(DELIMITERS))),
sed,
friendly="sed",
run_async=True,
)
dispatcher.add_handler(SED_HANDLER)
Log channels can help you keep track of exactly what the other admins are doing. \
Bans, Mutes, warns, notes - everything can be moderated.
*Admin only:*
× /logchannel: Get log channel info
× /setlog: Set the log channel.
× /unsetlog: Unset the log channel.
Setting the log channel is done by:
× Add the bot to your channel, as an admin. This is done via the "add administrators" tab.
× Send /setlog to your channel.
× Forward the /setlog command to the group you wish to be logged.
× Congratulations! All is set!
"""
__mod_name__ = "Logger"
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
AFK_HANDLER = DisableAbleCommandHandler("afk", afk, run_async=True)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(
Filters.regex("(?i)brb"), afk, friendly="afk", run_async=True
)
NO_AFK_HANDLER = MessageHandler(
Filters.all, no_longer_afk, run_async=True
)
AFK_REPLY_HANDLER = MessageHandler(
Filters.all & Filters.chat_type.groups & ~Filters.update.edited_message,
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)
__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),
]
yesnowtf,
run_async=True)
GDMORNING_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"(?i)(good morning)"),
goodmorning,
friendly="goodmorning",
run_async=True,
)
GDNIGHT_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"(?i)(good night)"),
goodnight,
friendly="goodnight",
run_async=True,
)
dispatcher.add_handler(POLICE_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
dispatcher.add_handler(ABUSE_HANDLER)
dispatcher.add_handler(SNIPE_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(PUNCH_HANDLER)
dispatcher.add_handler(HUG_HANDLER)
dispatcher.add_handler(GBUN_HANDLER)
dispatcher.add_handler(TABLE_HANDLER)
dispatcher.add_handler(RECITE_HANDLER)
dispatcher.add_handler(CRI_HANDLER)
dispatcher.add_handler(PASTA_HANDLER)
dispatcher.add_handler(CLAP_HANDLER)
dispatcher.add_handler(OWO_HANDLER)
"promote", promote, pass_args=True, filters=Filters.chat_type.groups, run_async=True
)
DEMOTE_HANDLER = CommandHandler(
"demote", demote, pass_args=True, filters=Filters.chat_type.groups, run_async=True
)
SET_TITLE_HANDLER = DisableAbleCommandHandler(
"settitle", set_title, pass_args=True, run_async=True
)
ADMINLIST_HANDLER = DisableAbleCommandHandler(
"adminlist", adminlist, filters=Filters.chat_type.groups, run_async=True
)
ADMIN_REFRESH_HANDLER = CommandHandler(
"admincache", refresh_admin, run_async=True
)
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(ADMINLIST_HANDLER)
dispatcher.add_handler(ADMIN_REFRESH_HANDLER)
dispatcher.add_handler(SET_TITLE_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)
f"{mention_html(msg.from_user.id, msg.from_user.first_name)}" +
", Please reply to sticker message to get id sticker",
parse_mode=ParseMode.HTML,
)
__help__ = """
Kanging Stickers made easy with stickers module!
× /stickerid: Reply to a sticker to me to tell you its file ID.
× /getsticker: Reply to a sticker to me to upload its raw PNG file.
× /kang: Reply to a sticker to add it to your pack.
"""
__mod_name__ = "Stickers"
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
pass_args=True,
admin_ok=True,
run_async=True)
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid",
stickerid,
run_async=True)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker",
getsticker,
run_async=True)
dispatcher.add_handler(KANG_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
__help__ = """
Every chat works with different rules; this module will help make those rules clearer!
× /rules: get the rules for this chat.
*Admin only:*
× /setrules <your rules here>: Sets rules for the chat.
× /clearrules: Clears saved rules for the 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)
UD_HANDLER = DisableAbleCommandHandler("ud", ud, run_async=True)
GETLINK_HANDLER = CommandHandler(
"getlink",
getlink,
pass_args=True,
filters=CustomFilters.dev_filter,
run_async=True,
)
STAFFLIST_HANDLER = CommandHandler("staffids",
staff_ids,
filters=Filters.user(OWNER_ID),
run_async=True)
# SRC_HANDLER = CommandHandler("source", src, filters=Filters.private)
COVID_HANDLER = CommandHandler("covid", covid, run_async=True)
PASTE_HANDLER = CommandHandler("paste", paste, run_async=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
dispatcher.add_handler(UD_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(GDPR_HANDLER)
dispatcher.add_handler(WIKI_HANDLER)
dispatcher.add_handler(GETLINK_HANDLER)
dispatcher.add_handler(STAFFLIST_HANDLER)
# dispatcher.add_handler(SRC_HANDLER)
dispatcher.add_handler(COVID_HANDLER)
dispatcher.add_handler(PASTE_HANDLER)
