• `/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, 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)
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)
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, admin_ok=True, run_async=True
)
dispatcher.add_handler(REVERSE_HANDLER)
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)
dispatcher.add_handler(WEEBIFY_HANDLER)
__command_list__ = ["weebify"]
__handlers__ = [WEEBIFY_HANDLER]
cleanservice,
filters=Filters.chat_type.groups,
run_async=True)
CLEAN_WELCOME = CommandHandler("cleanwelcome",
clean_welcome,
filters=Filters.chat_type.groups,
run_async=True)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help, run_async=True)
WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp",
welcome_mute_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(WELCOME_HELP)
dispatcher.add_handler(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_MUTE_HELP)
__mod_name__ = "Welcomes/Goodbyes"
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, filters=Filters.chat_type.groups, 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, filters=Filters.chat_type.groups, 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)
x = 0
y = 896
image = Image.new('RGBA', [x, y], (0, 0, 0))
for character in msg:
value = thonkifydict.get(character)
addedimg = Image.new('RGBA', [x + value.size[0] + tracking.size[0], y],
(0, 0, 0))
addedimg.paste(image, [0, 0])
addedimg.paste(tracking, [x, 0])
addedimg.paste(value, [x + tracking.size[0], 0])
image = addedimg
x = x + value.size[0] + tracking.size[0]
maxsize = 1024, 896
if image.size[0] > maxsize[0]:
image.thumbnail(maxsize, Image.ANTIALIAS)
# put processed image in a buffer and then upload cause async
with BytesIO() as buffer:
buffer.name = 'image.png'
image.save(buffer, 'PNG')
buffer.seek(0)
context.bot.send_sticker(chat_id=message.chat_id, sticker=buffer)
PLET_HANDLER = DisableAbleCommandHandler("plet", plet)
dispatcher.add_handler(PLET_HANDLER)
__handlers__ = [PLET_HANDLER]
ID_HANDLER = DisableAbleCommandHandler("id", get_id, run_async=True)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid, run_async=True)
INFO_HANDLER = DisableAbleCommandHandler(("info", "book"),
info,
run_async=True)
GDPR_HANDLER = CommandHandler("gdpr",
gdpr,
filters=Filters.chat_type.private,
run_async=True)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme",
set_about_me,
run_async=True)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me, run_async=True)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(GDPR_HANDLER)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
__mod_name__ = "Info"
__command_list__ = ["setbio", "bio", "setme", "me", "info", "gprd"]
__handlers__ = [
ID_HANDLER,
GIFID_HANDLER,
INFO_HANDLER,
)
else:
msg.reply_text(
"Failed to create sticker pack. Possibly due to blek mejik.")
__help__ = """
• `/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.
• `/stickers`*:* Find stickers for given term on combot sticker catalogue
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid",
stickerid,
run_async=True)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
admin_ok=True,
run_async=True)
STICKERS_HANDLER = DisableAbleCommandHandler("stickers",
cb_sticker,
run_async=True)
dispatcher.add_handler(STICKERS_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
return f"• {sql.num_disabled()} disabled items, across {sql.num_chats()} chats."
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
return build_curr_disabled(chat_id)
DISABLE_HANDLER = CommandHandler("disable", disable)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule", disable_module)
ENABLE_HANDLER = CommandHandler("enable", enable)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module)
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
*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
filters=Filters.chat_type.groups,
run_async=True)
INVITE_HANDLER = DisableAbleCommandHandler(["invitelink", "link"],
invite,
run_async=True)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, run_async=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, run_async=True)
SET_TITLE_HANDLER = CommandHandler("title", set_title, run_async=True)
ADMIN_REFRESH_HANDLER = CommandHandler("admincache",
refresh_admin,
filters=Filters.chat_type.groups)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(SET_TITLE_HANDLER)
dispatcher.add_handler(ADMIN_REFRESH_HANDLER)
__mod_name__ = "Admin"
__command_list__ = [
"adminlist",
"admins",
"invitelink",
"promote",
"demote",
*Admin commands:*
- `/approval`*:* Check a user's approval status in this chat.
- `/approve`*:* Approve of a user. Locks, blacklists, and antiflood won't apply to them anymore.
- `/unapprove`*:* Unapprove of a user. They will now be subject to locks, blacklists, and antiflood again.
- `/approved`*:* List all approved users.
- `/unapproveall`*:* Unapprove *ALL* users in a chat. This cannot be undone.
"""
APPROVE = DisableAbleCommandHandler("approve", approve, run_async=True)
DISAPPROVE = DisableAbleCommandHandler("unapprove", disapprove, run_async=True)
APPROVED = DisableAbleCommandHandler("approved", approved, run_async=True)
APPROVAL = DisableAbleCommandHandler("approval", approval, run_async=True)
UNAPPROVEALL = DisableAbleCommandHandler("unapproveall",
unapproveall,
run_async=True)
UNAPPROVEALL_BTN = CallbackQueryHandler(unapproveall_btn,
pattern=r"unapproveall_.*",
run_async=True)
dispatcher.add_handler(APPROVE)
dispatcher.add_handler(DISAPPROVE)
dispatcher.add_handler(APPROVED)
dispatcher.add_handler(APPROVAL)
dispatcher.add_handler(UNAPPROVEALL)
dispatcher.add_handler(UNAPPROVEALL_BTN)
__mod_name__ = "Approvals"
__command_list__ = ["approve", "unapprove", "approved", "approval"]
__handlers__ = [APPROVE, DISAPPROVE, APPROVED, APPROVAL]
• `/paste`*:* Saves replied content to `nekobin.com` and replies with a url
*React:*
• `/react`*:* Reacts with a random reaction
*Urban Dictonary:*
• `/ud <word>`*:* Type the word or expression you want to search use
*Wikipedia:*
• `/wiki <query>`*:* wikipedia your query
*Wallpapers:*
• `/wall <query>`*:* get a wallpaper from wall.alphacoders.com
*Currency converter:*
• `/cash`*:* currency converter
Example:
`/cash 1 USD INR`
_OR_
`/cash 1 usd inr`
Output: `1.0 USD = 75.505 INR`
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo", "covid", "weather"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
]
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
reply += f"*Stdout*\n`{stdout}`\n"
LOGGER.info(f"Shell - {cmd} - {stdout}")
if stderr:
reply += f"*Stderr*\n`{stderr}`\n"
LOGGER.error(f"Shell - {cmd} - {stderr}")
if len(reply) > 3000:
with open("shell_output.txt", "w") as file:
file.write(reply)
with open("shell_output.txt", "rb") as doc:
context.bot.send_document(
document=doc,
filename=doc.name,
reply_to_message_id=message.message_id,
chat_id=message.chat_id,
)
else:
message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
SHELL_HANDLER = CommandHandler(["sh"],
shell,
filters=Filters.user(OWNER_ID),
run_async=True)
dispatcher.add_handler(SHELL_HANDLER)
__mod_name__ = "Shell"
__command_list__ = ["sh"]
__handlers__ = [SHELL_HANDLER]
*Admins only:*
• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/punch <userhandle>`*:* Punches a user out of the group, (via handle, or reply)
• `/kick <userhandle>`*:* same as punch
"""
BAN_HANDLER = DisableAbleCommandHandler("ban", ban)
TEMPBAN_HANDLER = DisableAbleCommandHandler(["tban"], temp_ban)
PUNCH_HANDLER = DisableAbleCommandHandler(["punch", "kick"], punch)
UNBAN_HANDLER = DisableAbleCommandHandler("unban", unban)
ROAR_HANDLER = DisableAbleCommandHandler("roar", selfunban)
PUNCHME_HANDLER = DisableAbleCommandHandler(["punchme", "kickme"],
punchme,
filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(PUNCH_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(PUNCHME_HANDLER)
__mod_name__ = "Bans"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, PUNCH_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
PUNCHME_HANDLER
]
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>\n"
'<b>All Timezones:</b> <a href="https://en.wikipedia.org/wiki/List_of_tz_database_time_zones">List here</a>',
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
)
return
send_message.edit_text(result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
TIME_HANDLER = DisableAbleCommandHandler("time", gettime, run_async=True)
dispatcher.add_handler(TIME_HANDLER)
__mod_name__ = "Time"
__command_list__ = ["time"]
__handlers__ = [TIME_HANDLER]
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)
]
__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.
*Admins only:*
• `/reports <on/off>`*:* change report setting, or view current status.
• If done in pm, toggles your status.
• If in group, toggles that groups's status.
"""
SETTING_HANDLER = CommandHandler("reports", report_setting)
REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex(r"(?i)@admin(s)?"), report)
REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
__mod_name__ = "Reporting"
__handlers__ = [
(REPORT_HANDLER, REPORT_GROUP),
(ADMIN_REPORT_HANDLER, REPORT_GROUP),
(SETTING_HANDLER),
]
if int(userc_id) == int(user_id):
return
res = "{} is afk.\nReason: <code>{}</code>".format(
fst_name, user.reason)
update.effective_message.reply_text(res, parse_mode="html")
__help__ = """
• `/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 = DisableAbleMessageHandler(Filters.regex(r"(?i)^brb$"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_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)]
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()
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)
def __stats__():
return "• {} blacklist stickers, across {} chats.".format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__mod_name__ = "Stickers Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker",
blackliststicker,
admin_ok=True,
run_async=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("addblsticker",
add_blackliststicker,
run_async=True)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"],
unblackliststicker,
run_async=True)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode",
blacklist_mode,
run_async=True)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker
& Filters.chat_type.groups,
del_blackliststicker,
run_async=True)
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)
if DEBUG_MODE:
message.reply_text("Debug mode is currently on.")
else:
message.reply_text("Debug mode is currently off.")
@telethn.on(events.NewMessage(pattern="[/!].*"))
async def i_do_nothing_yes(event):
global DEBUG_MODE
if DEBUG_MODE:
print(f"-{event.from_id} ({event.chat_id}) : {event.text}")
if os.path.exists('updates.txt'):
with open('updates.txt', 'r') as f:
text = f.read()
with open('updates.txt', 'w+') as f:
f.write(text +
f"\n-{event.from_id} ({event.chat_id}) : {event.text}")
else:
with open('updates.txt', 'w+') as f:
f.write(
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}"
)
DEBUG_HANDLER = CommandHandler("debug", debug)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
Note:
• `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler(
"blacklist", blacklist, admin_ok=True, run_async=True
)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist, run_async=True)
UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist, run_async=True)
BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, run_async=True)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.chat_type.groups,
del_blacklist,
allow_edit=True,
run_async=True,
)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
__handlers__ = [
BLACKLIST_HANDLER,
ADD_BLACKLIST_HANDLER,
UNBLACKLIST_HANDLER,
BLACKLISTMODE_HANDLER,
(BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP),
]
• `/addchat`*:* Enables Chatbot mode in the chat.
• `/rmchat`*:* Disables Chatbot mode in the chat.
*Dragons or higher only:*
• `/listaichats`*:* Lists the chats the chatmode is enabled in.
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
]
is_blacklisted = sql.is_user_blacklisted(user_id)
text = "Blacklisted: <b>{}</b>"
if user_id in [777000, 1087968824]:
return ""
if user_id == dispatcher.bot.id:
return ""
if int(user_id) in SUDO_USERS:
return ""
if is_blacklisted:
text = text.format("Yes")
reason = sql.get_reason(user_id)
if reason:
text += f"\nReason: <code>{reason}</code>"
else:
text = text.format("No")
return text
BL_HANDLER = CommandHandler("ignore", bl_user, run_async=True)
UNBL_HANDLER = CommandHandler("notice", unbl_user, run_async=True)
BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users, run_async=True)
dispatcher.add_handler(BL_HANDLER)
dispatcher.add_handler(UNBL_HANDLER)
dispatcher.add_handler(BLUSERS_HANDLER)
__mod_name__ = "Blacklisting Users"
__handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
RESET_WARN_HANDLER = CommandHandler(
["resetwarn", "resetwarns"], reset_warns, filters=Filters.chat_type.groups, run_async=True
)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, filters=Filters.chat_type.groups, run_async=True)
ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.chat_type.groups, run_async=True)
RM_WARN_HANDLER = CommandHandler(
["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.chat_type.groups
)
LIST_WARN_HANDLER = DisableAbleCommandHandler(
["warnlist", "warnfilters"], list_warn_filters, filters=Filters.chat_type.groups, 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, filters=Filters.chat_type.groups, run_async=True)
WARN_STRENGTH_HANDLER = CommandHandler(
"strongwarn", set_warn_strength, filters=Filters.chat_type.groups, run_async=True
)
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)
Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \
you and your groups by removing spam flooders as quickly as possible.
*Note:* Users can appeal gbans or report spammers at @{SUPPORT_CHAT}
This also integrates @Spamwatch API 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/f584b643c6f4be0b1de53.jpg)
Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group.
*Note:* Users can appeal spamwatch bans at @SpamwatchSupport
"""
GBAN_HANDLER = CommandHandler("gban", gban)
UNGBAN_HANDLER = CommandHandler("ungban", ungban)
GBAN_LIST = CommandHandler("gbanlist", gbanlist)
GBAN_STATUS = CommandHandler("antispam", gbanstat, filters=Filters.group)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
__mod_name__ = "Anti-Spam"
__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
__handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
"<b>Service uptime:</b> <code>{}</code>".format(telegram_ping, uptime),
parse_mode=ParseMode.HTML,
)
@run_async
@sudo_plus
def pingall(update: Update, context: CallbackContext):
to_ping = ["Kaizoku", "Kayo", "Telegram", "Jikan"]
pinged_list = ping_func(to_ping)
pinged_list.insert(2, "")
uptime = get_readable_time((time.time() - StartTime))
reply_msg = "⏱Ping results are:\n"
reply_msg += "\n".join(pinged_list)
reply_msg += "\n<b>Service uptime:</b> <code>{}</code>".format(uptime)
update.effective_message.reply_text(reply_msg,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
PING_HANDLER = DisableAbleCommandHandler("ping", ping)
PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(PINGALL_HANDLER)
__command_list__ = ["ping", "pingall"]
__handlers__ = [PING_HANDLER, PINGALL_HANDLER]
if query_type == "db_leave_chat":
if query.from_user.id in admin_list:
bot.editMessageText("Leaving chats ...", chat_id,
message.message_id)
chat_count = get_muted_chats(update, context, 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(update, context, True)
invalid_gban_count = get_invalid_gban(update, context, 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)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*")
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER]
from AstrakoBot import dispatcher
from AstrakoBot.modules.disable import DisableAbleCommandHandler
@run_async
def magisk(bot, update):
url = 'https://raw.githubusercontent.com/topjohnwu/magisk_files/'
releases = "*Latest Magisk Releases: *\n"
for magisk_type, path in {
"*Stable*": "master/stable",
"*Beta*": "master/beta",
"*Canary (debug)*": "canary/debug"
}.items():
data = get(url + path + '.json').json()
releases += f'{magisk_type}:\n' \
f'》Installer - [Zip v{data["magisk"]["version"]}]({data["magisk"]["link"]}) \n' \
f'》Manager - [App v{data["app"]["version"]}]({data["app"]["link"]}) \n' \
f'》Uninstaller - [Uninstaller v{data["magisk"]["version"]}]({data["uninstaller"]["link"]}) \n'
bot.send_message(chat_id=update.effective_message.chat_id,
text=releases,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
MAGISK_HANDLER = DisableAbleCommandHandler("Magisk", magisk)
dispatcher.add_handler(MAGISK_HANDLER)
__mod_name__ = "Magisk"
__command_list__ = ["magisk"]
__handlers__ = [MAGISK_HANDLER]
