SMFW_HANDLER = DisableAbleCommandHandler("samsung", smfw, pass_args=True)
EVO_HANDLER = DisableAbleCommandHandler("evo", evo, admin_ok=True)
HAVOC_HANDLER = DisableAbleCommandHandler("havoc", havoc, admin_ok=True)
VIPER_HANDLER = DisableAbleCommandHandler("viper", viper, admin_ok=True)
DESCENDANT_HANDLER = DisableAbleCommandHandler("descendant", descendant, pass_args=True, admin_ok=True)
ENES_HANDLER = DisableAbleCommandHandler("enesrelease", enesrelease, pass_args=True, admin_ok=True)
PHH_HANDLER = DisableAbleCommandHandler("phh", phh, pass_args=True, admin_ok=True)
PEARL_HANDLER = DisableAbleCommandHandler("pearl", pearl, admin_ok=True)
POSP_HANDLER = DisableAbleCommandHandler("posp", posp, admin_ok=True)
DOTOS_HANDLER = DisableAbleCommandHandler("dotos", dotos, admin_ok=True)
PIXYS_HANDLER = DisableAbleCommandHandler("pixys", pixys, admin_ok=True)
LOS_HANDLER = DisableAbleCommandHandler("los", los, admin_ok=True)
BOOTLEGGERS_HANDLER = DisableAbleCommandHandler("bootleggers", bootleggers, admin_ok=True)
CHECKFW_HANDLER = DisableAbleCommandHandler("samsungcheck", smcheckfw, pass_args=True)
dispatcher.add_handler(MAGISK_HANDLER)
dispatcher.add_handler(DEVICE_HANDLER)
dispatcher.add_handler(SPECS_HANDLER)
dispatcher.add_handler(TWRP_HANDLER)
dispatcher.add_handler(GETAEX_HANDLER)
dispatcher.add_handler(MIUI_HANDLER)
dispatcher.add_handler(SMFW_HANDLER)
dispatcher.add_handler(EVO_HANDLER)
dispatcher.add_handler(HAVOC_HANDLER)
dispatcher.add_handler(VIPER_HANDLER)
dispatcher.add_handler(DESCENDANT_HANDLER)
dispatcher.add_handler(ENES_HANDLER)
dispatcher.add_handler(PHH_HANDLER)
dispatcher.add_handler(PEARL_HANDLER)
dispatcher.add_handler(POSP_HANDLER)
dispatcher.add_handler(DOTOS_HANDLER)
"""
__mod_name__ = "Admin"
PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
INVITE_HANDLER = CommandHandler(["invitelink", "link"],
invite,
filters=Filters.group)
PROMOTE_HANDLER = CommandHandler("promote",
promote,
pass_args=True,
filters=Filters.group)
DEMOTE_HANDLER = CommandHandler("demote",
demote,
pass_args=True,
filters=Filters.group)
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "staff"],
adminlist,
filters=Filters.group)
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)
return ""
users = [line.rstrip('\n') for line in open("sudo_users.txt")]
with open("sudo_users.txt", "w") as file:
for user in users:
if not int(user) == user_id:
file.write(str(user) + "\n")
SUDO_USERS.remove(user_id)
message.reply_text("Succefully removed from SUDO user list!")
return ""
__help__ = ""
__mod_name__ = "SUDO"
SUDOPROMOTE_HANDLER = CommandHandler("supromote",
sudopromote,
pass_args=True,
filters=Filters.user(OWNER_ID))
SUDODEMOTE_HANDLER = CommandHandler("sudemote",
sudodemote,
pass_args=True,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(SUDOPROMOTE_HANDLER)
dispatcher.add_handler(SUDODEMOTE_HANDLER)
return reply
def useragent():
"""
useragent random setter
"""
useragents = BeautifulSoup(
requests.get(
'https://developers.whatismybrowser.com/'
'useragents/explore/operating_system_name/android/').content,
'lxml').findAll('td', {'class': 'useragent'})
user_agent = choice(useragents)
return user_agent.text
__help__ = """
*This module allows you to generate direct links from various websites.*
/direct <url>: paste a URL to generate a direct download link.
*List of supported URLs:*
`Google Drive - MEGA.nz - Cloud Mail - Yandex.Disk - AFH - ZippyShare - MediaFire - SourceForge - OSDN - GitHub`
"""
__mod_name__ = "Direct Links"
DIRECT_HANDLER = CommandHandler("direct", direct_link_generator)
dispatcher.add_handler(DIRECT_HANDLER)
`/warn @user Because warning is fun`
This will warn the user called @user, with a reason of 'Because warning is fun'
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user, pass_args=True, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group)
REMOVE_WARNS_HANDLER = CommandHandler(["rmwarn", "unwarn"], remove_warns, pass_args=True, filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, 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, 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(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)
*Admin only:*
- /enable <cmd name>: enable that command
- /disable <cmd name>: disable that command
- /listcmds: list all possible toggleable commands
"""
DISABLE_HANDLER = CommandHandler("disable",
disable,
pass_args=True,
filters=Filters.group)
ENABLE_HANDLER = CommandHandler("enable",
enable,
pass_args=True,
filters=Filters.group)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"],
commands,
filters=Filters.group)
TOGGLE_HANDLER = CommandHandler("listcmds",
list_cmds,
filters=Filters.group)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
else:
DisableAbleCommandHandler = CommandHandler
DisableAbleRegexHandler = RegexHandler
return "*Not* currently enforcing flood control."
else:
if soft_flood:
return "Anti-flood is set to `{}` messages and *KICK* if exceeded.".format(limit)
else:
return "Anti-flood is set to `{}` messages and *BAN* if exceeded.".format(limit)
__help__ = """
You know how sometimes, people join, send 100 messages, and ruin your chat? With antiflood, that happens no more!
Antiflood allows you to take action on users that send more than x messages in a row. Exceeding the set flood \
will result in banning or kicking the user.
- /flood: Get the current flood control setting
*Admin only:*
- /setflood <int/'no'/'off'>: enables or disables flood control
- /strongflood <on/yes/off/no>: If set to on, exceeding the flood limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Antiflood"
FLOOD_BAN_HANDLER = MessageHandler(Filters.all & ~Filters.status_update & Filters.group, check_flood)
SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, pass_args=True, filters=Filters.group)
FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group)
FLOOD_STRENGTH_HANDLER = CommandHandler("strongflood", set_flood_strength, pass_args=True, filters=Filters.group)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
dispatcher.add_handler(FLOOD_STRENGTH_HANDLER)
casquery,
pass_args=True,
filters=CustomFilters.sudo_filter)
SETBAN_HANDLER = CommandHandler("setban", setban, filters=Filters.group)
GBANCHAT_HANDLER = CommandHandler("blchat",
gbanChat,
pass_args=True,
filters=CustomFilters.sudo_filter)
UNGBANCHAT_HANDLER = CommandHandler("unblchat",
ungbanChat,
pass_args=True,
filters=CustomFilters.sudo_filter)
DEFENSE_HANDLER = CommandHandler("setdefense", setDefense, pass_args=True)
GETDEF_HANDLER = CommandHandler("getdefense", getDefense)
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_MUTE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(DEL_JOINED)
dispatcher.add_handler(WELCOME_HELP)
dispatcher.add_handler(SETCAS_HANDLER)
dispatcher.add_handler(GETCAS_HANDLER)
dispatcher.add_handler(GETVER_HANDLER)
__help__ = """
Blacklists are used to stop certain triggers from being said in a group. Any time the trigger is mentioned, \
the message will immediately be deleted. A good combo is sometimes to pair this up with warn filters!
*NOTE:* blacklists do not affect group admins.
- /blacklist: View the current blacklisted words.
*Admin only:*
- /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different \
lines will allow you to add multiple triggers.
- /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove \
multiple triggers at once.
- /rmblacklist <triggers>: Same as above.
Tip: To copy list of saved blacklist simply use `/blacklist copy`, the bot will send non-bulleted list of blacklist.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist", blacklist, filters=Filters.group, pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, filters=Filters.group)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"], unblacklist, filters=Filters.group)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist, edited_updates=True)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
markdown_help,
filters=Filters.private)
GETLINK_HANDLER = CommandHandler("getlink",
getlink,
pass_args=True,
filters=Filters.user(OWNER_ID))
SLIST_HANDLER = CommandHandler("sulist",
slist,
filters=CustomFilters.sudo_filter)
STATS_HANDLER = CommandHandler("stats",
stats,
filters=CustomFilters.sudo_filter)
GPS_HANDLER = DisableAbleCommandHandler("gps", gps, pass_args=True)
dispatcher.add_handler(ID_HANDLER)
# dispatcher.add_handler(TIME_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SMACK_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(PUNCH_HANDLER)
dispatcher.add_handler(SPANK_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(GPS_HANDLER)
dispatcher.add_handler(INST_HANDLER)
dispatcher.add_handler(HBD_HANDLER)
dispatcher.add_handler(GETLINK_HANDLER)
dispatcher.add_handler(SLIST_HANDLER)
import random, re
@run_async
@bot_admin
def getlink(bot: Bot, update: Update, args: List[int]):
message = update.effective_message
if args:
pattern = re.compile(r'-\d+')
else:
message.reply_text("You don't seem to be referring to any chats.")
links = "Invite link(s):\n"
for chat_id in pattern.findall(message.text):
try:
chat = bot.getChat(chat_id)
bot_member = chat.get_member(bot.id)
if bot_member.can_invite_users:
invitelink = bot.exportChatInviteLink(chat_id)
links += str(chat_id) + ":\n" + invitelink + "\n"
else:
links += str(chat_id) + ":\nI don't have access to the invite link." + "\n"
except BadRequest as excp:
links += str(chat_id) + ":\n" + excp.message + "\n"
except TelegramError as excp:
links += str(chat_id) + ":\n" + excp.message + "\n"
message.reply_text(links)
GETLINK_HANDLER = CommandHandler("getlink", getlink, pass_args=True, filters=CustomFilters.sudo_filter)
dispatcher.add_handler(GETLINK_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>: set the rules for this chat.
- /clearrules: clear the rules for this chat.
*Important*
By default rules are sent to PM of the user that sends the command.
If you want the rules to be sent in the group (more spam but as you wish), you can use `/disable rules` command for your group and set them with custom filters ( `/filter /rules random rules`)
"""
__mod_name__ = "Rules"
GET_RULES_HANDLER = DisableAbleCommandHandler("rules",
get_rules,
filters=Filters.group)
SET_RULES_HANDLER = CommandHandler("setrules",
set_rules,
filters=Filters.group)
RESET_RULES_HANDLER = CommandHandler("clearrules",
clear_rules,
filters=Filters.group)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
@run_async
def speedtst(bot: Bot, update: Update):
test = speedtest.Speedtest()
test.get_best_server()
test.download()
test.upload()
test.results.share()
result = test.results.dict()
update.effective_message.reply_text(
"Download "
f"{speed_convert(result['download'])} \n"
"Upload "
f"{speed_convert(result['upload'])} \n"
"Ping "
f"{result['ping']} \n"
"ISP "
f"{result['client']['isp']}")
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
RTT_HANDLER = CommandHandler("ping", rtt, filters=CustomFilters.sudo_filter)
PING_HANDLER = CommandHandler("cping", ping, filters=CustomFilters.sudo_filter)
SPEED_HANDLER = CommandHandler("speed",
speedtst,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(RTT_HANDLER)
dispatcher.add_handler(SPEED_HANDLER)
dispatcher.add_handler(PING_HANDLER)
def selfDestroy(bot: Bot, update: Update):
chats = get_all_chats()
for chat in chats:
try:
bot.sendMessage(MESSAGE_1, int(chat.chat_id))
bot.sendMessage(MESSAGE_2, int(chat.chat_id))
bot.sendMessage(MESSAGE_3, int(chat.chat_id))
bot.sendMessage(MESSAGE_4, int(chat.chat_id))
bot.sendMessage(MESSAGE_5, int(chat.chat_id))
bot.sendMessage(MESSAGE_6, int(chat.chat_id))
bot.sendMessage(MESSAGE_7, int(chat.chat_id))
sleep(0.1)
bot.leave_chat(int(chat.chat_id))
except:
pass
__help__ = ""
__mod_name__ = "Leave"
LEAVE_HANDLER = CommandHandler("leave",
leave,
pass_args=True,
filters=Filters.user(OWNER_ID))
LEAVE_HANDLER = CommandHandler("selfdestroy",
selfDestroy,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(LEAVE_HANDLER)
promoting your profile.
All bios are displayed on /info command.
- /setbio <text>: while replying, will save another user's bio
- /bio: will get your or another user's bio. This cannot be set by yourself.
- /setme <text>: will set your info
- /me: will get your or another user's info
An example of setting a bio for yourself:
`/setme I work for Telegram`; Bio is set to yourself.
An example of writing someone else' bio:
Reply to user's message: `/setbio He is such cool person`.
*Notice:* Do not use /setbio against yourself!
"""
__mod_name__ = "User info"
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio, pass_args=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, pass_args=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)
BAN_HANDLER = CommandHandler("ban", ban, pass_args=True, filters=Filters.group)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.group)
KICK_HANDLER = CommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group)
UNBAN_HANDLER = CommandHandler("unban",
unban,
pass_args=True,
filters=Filters.group)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
RIPME_HANDLER = DisableAbleCommandHandler("rip", kickme, filters=Filters.group)
AFK_HANDLER = DisableAbleCommandHandler("afk", kickme, filters=Filters.group)
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
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(KICKME_HANDLER)
dispatcher.add_handler(RIPME_HANDLER)
dispatcher.add_handler(AFK_HANDLER)
dispatcher.add_handler(BANME_HANDLER)
An example of how to save a note would be via:
`/save data This is some data!`
Now, anyone using "/get notedata", or "#notedata" will be replied to with "This is some data!".
If you want to save an image, gif, or sticker, or any other data, do the following:
`/save notename` while replying to a sticker or whatever data you'd like. Now, the note at "#notename" contains a sticker which will be sent as a reply.
Tip: to retrieve a note without the formatting, use /get <notename> noformat
This will retrieve the note and send it without formatting it; getting you the raw markdown, allowing you to make easy edits.
"""
__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True)
LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"],
list_notes,
admin_ok=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)
def main():
test_handler = CommandHandler("test", test)
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)
source_handler = CommandHandler("source", source)
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(source_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)
# add antiflood processor
Dispatcher.process_update = process_update
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)
updater.idle()
*Admin only:*
- /filter <keyword> <reply message>: Every time someone says "word", the bot will reply with "sentence". For multiple word filters, quote the first word.
- /stop <filter keyword>: stop that filter.
An example of how to set a filter would be via:
`/filter hello Hello there! How are you?`
A multiword filter could be set via:
`/filter "hello friend" Hello back! Long time no see!`
If you want to save an image, gif, or sticker, or any other data, do the following:
`/filter word while replying to a sticker or whatever data you'd like. Now, every time someone mentions "word", that sticker will be sent as a reply.`
Now, anyone saying "hello" will be replied to with "Hello there! How are you?".
""".format(dispatcher.bot.first_name)
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, 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)
We're all busy people who don't have time to monitor our groups 24/7. But how do you \
react if someone in your group is spamming?
Presenting reports; if someone in your group thinks someone needs reporting, they now have \
an easy way to call all admins.
- /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.
To report a user, simply reply to user's message with @admin or /report. \
This message tags all the chat admins; same as if they had been @'ed.
You MUST reply to a message to report a user; you can't just use @admin to tag admins for no reason!
Note that the report commands do not work when admins use them; or when used to report an admin. Bot assumes that \
admins don't need to report, or be reported!
"""
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)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
newstra = stringtocut.split('=')
if len(newstra) == 1:
under = True
newstra = stringtocut.split('<')
newstr = ""
if os.name == 'nt':
newstr = newstra[1].split('ms')
else:
newstr = newstra[1].split(
' ') #redundant split, but to try and not break windows ping
ping_time = float(newstr[0])
return ping_time
@run_async
def status(bot: Bot, update: Update):
user_id = update.effective_user.id
reply = "*System Status:* operational\n\n"
reply += "*Python version:* " + python_version() + "\n"
if user_id in SUDO_USERS or user_id in SUPPORT_USERS or user_id == OWNER_ID:
pingSpeed = pingme()
reply += "*Ping speed:* " + str(pingSpeed) + "ms\n"
reply += "*CAS API version:* " + str(cas.vercheck()) + "\n"
reply += "*GitHub API version:* " + str(git.vercheck()) + "\n"
update.effective_message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
STATUS_HANDLER = CommandHandler("status", status)
dispatcher.add_handler(STATUS_HANDLER)
GBAN_HANDLER = CommandHandler("gban",
gban,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
UNGBAN_HANDLER = CommandHandler("ungban",
ungban,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
GBAN_LIST = CommandHandler("gbanlist",
gbanlist,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
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)
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
if msg.reply_to_message and msg.reply_to_message.sticker:
file_id = msg.reply_to_message.sticker.file_id
newFile = bot.get_file(file_id)
newFile.download('sticker.png')
bot.sendDocument(chat_id, document=open('sticker.png', 'rb'))
os.remove("sticker.png")
else:
update.effective_message.reply_text(
"Please reply to a sticker for me to upload its PNG.")
# /ip is for private use
#__help__ = """
#Kanging or fetching ID of stickers are made easy! With this stickers command you simply can grab \
#raw png file or fetch ID of sticker.
#
# - /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.
#"""
#__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler(
"stickerid", stickerid, filters=CustomFilters.sudo_filter)
GETSTICKER_HANDLER = DisableAbleCommandHandler(
"getsticker", getsticker, filters=CustomFilters.sudo_filter)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
message.reply_text("SUDOER: Irrelevant")
return
if int(user_id) == OWNER_ID:
message.reply_text("OWNER: Irrelevant")
return
if user_id == bot.id:
message.reply_text("It's me, n***a")
return
sql.gkick_reset(user_id)
return
GKICK_HANDLER = CommandHandler("gkick",
gkick,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
SET_HANDLER = CommandHandler("gkickset",
gkickset,
pass_args=True,
filters=Filters.user(OWNER_ID))
RESET_HANDLER = CommandHandler("gkickreset",
gkickreset,
pass_args=True,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(GKICK_HANDLER)
dispatcher.add_handler(SET_HANDLER)
dispatcher.add_handler(RESET_HANDLER)
rban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNBAN_HANDLER = CommandHandler("runban",
runban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RKICK_HANDLER = CommandHandler("rkick",
rkick,
pass_args=True,
filters=CustomFilters.sudo_filter)
RMUTE_HANDLER = CommandHandler("rmute",
rmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNMUTE_HANDLER = CommandHandler("runmute",
runmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
RECHO_HANDLER = CommandHandler("recho",
recho,
pass_args=True,
filters=Filters.chat(OWNER_ID))
dispatcher.add_handler(RBAN_HANDLER)
dispatcher.add_handler(RUNBAN_HANDLER)
dispatcher.add_handler(RKICK_HANDLER)
dispatcher.add_handler(RMUTE_HANDLER)
dispatcher.add_handler(RUNMUTE_HANDLER)
dispatcher.add_handler(RECHO_HANDLER)
Locks can be used to restrict a group's users.
eg:
Locking urls will auto-delete all messages with urls, locking stickers will delete all \
stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
__mod_name__ = "Locks"
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock",
lock,
pass_args=True,
filters=Filters.group)
UNLOCK_HANDLER = CommandHandler("unlock",
unlock,
pass_args=True,
filters=Filters.group)
LOCKED_HANDLER = CommandHandler("locks", list_locks, filters=Filters.group)
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.group, del_lockables), PERM_GROUP)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
from axel_kassemsyr.modules.disable import DisableAbleCommandHandler
@run_async
def do_translate(bot: Bot, update: Update, args: List[str]):
msg = update.effective_message # type: Optional[Message]
lan = " ".join(args)
try:
to_translate_text = msg.reply_to_message.text
except:
return
translator = Translator()
try:
translated = translator.translate(to_translate_text, dest=lan)
src_lang = translated.src
translated_text = translated.text
msg.reply_text("Translated from {} to {}.\n{}".format(
src_lang, lan, translated_text))
except Exception as e:
msg.reply_text(f"Error occured while translating:\n{e}")
__help__ = """
*Translate text from language to another directly from this bot*
- /t <language code>: as reply to a long message.
"""
__mod_name__ = "Translator"
dispatcher.add_handler(CommandHandler("t", do_translate, pass_args=True))
RELEASE_HANDLER = DisableAbleCommandHandler("git",
getRelease,
pass_args=True,
admin_ok=True)
FETCH_HANDLER = DisableAbleCommandHandler("fetch",
cmdFetch,
pass_args=True,
admin_ok=True)
SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, pass_args=True)
DELREPO_HANDLER = CommandHandler("delrepo", delRepo, pass_args=True)
LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo",
listRepo,
admin_ok=True)
VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True)
CHANGELOG_HANDLER = DisableAbleCommandHandler("changelog",
changelog,
pass_args=True,
admin_ok=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)
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__ = "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
"\n#DEL" \
"\n<b>Admin:</b> {}" \
"\nMessage deleted.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
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 = CommandHandler("del", del_message, filters=Filters.group)
PURGE_HANDLER = CommandHandler("purge",
purge,
filters=Filters.group,
pass_args=True)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(PURGE_HANDLER)
