× /setfloodmode <ban/kick/mute/tban/tmute> <value>: Action to perform when user have exceeded flood limit. ban/kick/mute/tmute/tban
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)
SET_FLOOD_HANDLER = CommandHandler(
"setflood", set_flood,
pass_args=True) # , filters=Filters.chat_type.groups)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode,
pass_args=True) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
FLOOD_HANDLER = CommandHandler("flood", flood)
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)
caption="Message length exceeded max limit! Sending as a text file.",
)
else:
msg.reply_text(reply)
__help__ = """
Like name this module, you can search anything about music
× /music <flag> <query> <quality> : Download music [more info](https://telegra.ph/Music-Downloader-Info-01-20)
× /lyrics <query>: search lyrics can be song name or artist name
*Last.FM*
× /setuser <username>: sets your last.fm username.
× /clearuser: removes your last.fm username from the bot's database.
× /lastfm: returns what you're scrobbling on last.fm.
"""
__mod_name__ = "Music"
SET_USER_HANDLER = CommandHandler("setuser", set_user, pass_args=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user)
MUSIC_HANDLER = DisableAbleCommandHandler("music", music, pass_args=True)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm)
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(MUSIC_HANDLER)
dispatcher.add_handler(LASTFM_HANDLER)
dispatcher.add_handler(LYRICS_HANDLER)
num_chats)
def __stats__():
return "× {} users, across {} chats".format(sql.num_users(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.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))
USER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist",
chats,
filters=CustomFilters.sudo_filter)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
chat_checker)
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)
parse_mode=ParseMode.HTML,
)
else:
update.effective_message.reply_text(
"Hello " +
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)
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
dispatcher.add_handler(KANG_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_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__ = "Bios/Abouts"
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.chat_type.groups)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.chat_type.groups)
KICK_HANDLER = CommandHandler("kick",
kick,
pass_args=True,
filters=Filters.chat_type.groups)
UNBAN_HANDLER = CommandHandler("unban",
unban,
pass_args=True,
filters=Filters.chat_type.groups)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.chat_type.groups)
BANME_HANDLER = DisableAbleCommandHandler("banme",
banme,
filters=Filters.chat_type.groups)
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)
This allows you to disable some commonly used commands, so noone can use them. \
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) # , filters=Filters.chat_type.groups)
ENABLE_HANDLER = CommandHandler(
"enable", enable,
pass_args=True) # , filters=Filters.chat_type.groups)
COMMANDS_HANDLER = CommandHandler(
["cmds", "disabled"], commands) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds)
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
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,
)
WARN_FILTER_HANDLER = MessageHandler(
CustomFilters.has_text & Filters.chat_type.groups, reply_filter)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
set_warn_limit,
pass_args=True,
filters=Filters.chat_type.groups)
WARN_STRENGTH_HANDLER = CommandHandler("strongwarn",
set_warn_strength,
pass_args=True,
filters=Filters.chat_type.groups)
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)
keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \
doin?
× /stop <filter keyword>: Stop that filter.
*Chat creator only:*
× /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)
RMALLFILTER_HANDLER = CommandHandler("rmallfilter",
rmall_filters,
filters=Filters.chat_type.groups)
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)
× /latin <text>: latinify your text!
× /lined <text>: lined your text!
"""
__mod_name__ = "StyleText"
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify)
BUBBLE_HANDLER = DisableAbleCommandHandler("bubble", bubble)
FBUBBLE_HANDLER = DisableAbleCommandHandler("fbubble", fbubble)
SQUARE_HANDLER = DisableAbleCommandHandler("square", square)
FSQUARE_HANDLER = DisableAbleCommandHandler("fsquare", fsquare)
BLUE_HANDLER = DisableAbleCommandHandler("blue", blue)
LATIN_HANDLER = DisableAbleCommandHandler("latin", latin)
LINED_HANDLER = DisableAbleCommandHandler("lined", lined)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(BUBBLE_HANDLER)
dispatcher.add_handler(FBUBBLE_HANDLER)
dispatcher.add_handler(SQUARE_HANDLER)
dispatcher.add_handler(FSQUARE_HANDLER)
dispatcher.add_handler(BLUE_HANDLER)
dispatcher.add_handler(LATIN_HANDLER)
dispatcher.add_handler(LINED_HANDLER)
__command_list__ = ["weebify"]
__command_list__ = ["bubble"]
__command_list__ = ["fbubble"]
__command_list__ = ["square"]
__command_list__ = ["fsquare"]
__command_list__ = ["blue"]
__command_list__ = ["latin"]
filters=Filters.chat_type.groups)
PROMOTE_HANDLER = CommandHandler("promote",
promote,
pass_args=True,
filters=Filters.chat_type.groups)
DEMOTE_HANDLER = CommandHandler("demote",
demote,
pass_args=True,
filters=Filters.chat_type.groups)
SET_TITLE_HANDLER = DisableAbleCommandHandler("settitle",
set_title,
pass_args=True)
ADMINLIST_HANDLER = DisableAbleCommandHandler("adminlist",
adminlist,
filters=Filters.chat_type.groups)
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(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)
Some people need to be publicly muted; spammers, annoyances, or just trolls.
This module allows you to do that easily, by exposing some common actions, so everyone will see!
*Admin only:*
× /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)
UNMUTE_HANDLER = CommandHandler("unmute",
unmute,
pass_args=True,
filters=Filters.chat_type.groups)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True,
filters=Filters.chat_type.groups)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_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)
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
text = re.sub(repl, repl_with, to_fix, flags=re.I).strip()
elif "i" in flags:
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")
dispatcher.add_handler(SED_HANDLER)
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.
*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.chat_type.groups)
SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex("(?i)@admin(s)?"), report)
REPORT_BUTTON_HANDLER = CallbackQueryHandler(report_buttons,
pattern=r"report_")
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(REPORT_BUTTON_HANDLER)
AIRING_HANDLER = DisableAbleCommandHandler("airing", airing)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
MAL_HANDLER = DisableAbleCommandHandler("mal", mal)
ANILIST_HANDLER = DisableAbleCommandHandler("anilist", anilist)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
KAIZOKU_SEARCH_HANDLER = DisableAbleCommandHandler("kaizoku", kaizoku)
KAYO_SEARCH_HANDLER = DisableAbleCommandHandler("kayo", kayo)
KUSO_SEARCH_HANDLER = DisableAbleCommandHandler("kuso", kuso)
DRIVE_SEARCH_HANDLER = DisableAbleCommandHandler("drive", drive)
OPLOVERZ_SEARCH_HANDLER = DisableAbleCommandHandler("oploverz", oploverz)
NEO_SEARCH_HANDLER = DisableAbleCommandHandler("neo", neo)
SAME_SEARCH_HANDLER = DisableAbleCommandHandler("same", same)
OTAKU_SEARCH_HANDLER = DisableAbleCommandHandler("otaku", otaku)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(MAL_HANDLER)
dispatcher.add_handler(ANILIST_HANDLER)
dispatcher.add_handler(KAIZOKU_SEARCH_HANDLER)
dispatcher.add_handler(KAYO_SEARCH_HANDLER)
dispatcher.add_handler(KUSO_SEARCH_HANDLER)
dispatcher.add_handler(DRIVE_SEARCH_HANDLER)
dispatcher.add_handler(OPLOVERZ_SEARCH_HANDLER)
dispatcher.add_handler(NEO_SEARCH_HANDLER)
dispatcher.add_handler(SAME_SEARCH_HANDLER)
dispatcher.add_handler(OTAKU_SEARCH_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
return str(round(tF))
reply = f"*Current weather for {cityname}, {country_name} is*:\n\n*Temperature:* `{celsius(curtemp)}°C ({fahr(curtemp)}ºF), feels like {celsius(feels_like)}°C ({fahr(feels_like)}ºF) \n`*Condition:* `{condmain}, {conddet}` {icon}\n*Humidity:* `{humidity}%`\n*Wind:* `{kmph[0]} km/h`\n"
del_msg = update.effective_message.reply_text(
"{}".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)
dispatcher.add_handler(WEATHER_HANDLER)
"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(
"spamshield", gbanstat, pass_args=True, filters=Filters.chat_type.groups
)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.chat_type.groups, 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)
`/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 = MessageHandler(Filters.regex(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)
CLEARALLNOTES_HANDLER = CommandHandler("rmallnotes",
clear_notes,
filters=Filters.chat_type.groups)
RMBTN_HANDLER = CallbackQueryHandler(rmbutton, pattern=r"rmnotes_")
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)
filters=CustomFilters.sudo_filter)
SYS_STATUS_HANDLER = CommandHandler("sysinfo",
system_status,
filters=CustomFilters.sudo_filter)
LEAVECHAT_HANDLER = CommandHandler(
["leavechat", "leavegroup", "leave"],
leavechat,
pass_args=True,
filters=CustomFilters.sudo_filter,
)
GITPULL_HANDLER = CommandHandler("gitpull",
gitpull,
filters=CustomFilters.sudo_filter)
RESTART_HANDLER = CommandHandler("reboot",
restart,
filters=CustomFilters.sudo_filter)
EVAL_HANDLER = CommandHandler("eval",
evaluator,
filters=Filters.user(OWNER_ID))
EXEC_HANDLER = CommandHandler("exec", executor, filters=Filters.user(OWNER_ID))
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)
dispatcher.add_handler(EVAL_HANDLER)
dispatcher.add_handler(EXEC_HANDLER)
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)
# , filters=Filters.chat_type.groups)
LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True)
UNLOCK_HANDLER = CommandHandler(
"unlock", unlock, pass_args=True) # , filters=Filters.chat_type.groups)
# , filters=Filters.chat_type.groups)
LOCKED_HANDLER = CommandHandler("locks", list_locks)
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)
dl_file = download.text
size = trs[i].find("span", {"class": "filesize"}).text
reply += f"[{dl_file}]({dl_link}) - {size}\n"
update.message.reply_text(
"{}".format(reply),
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
)
__help__ = """
Get Latest magisk relese, Twrp for your device or info about some device using its codename, Directly from Bot!
*Android related commands:*
× /magisk - Gets the latest magisk release for Stable/Beta/Canary.
× /device <codename> - Gets android device basic info from its codename.
× /twrp <codename> - Gets latest twrp for the android device using the codename.
"""
__mod_name__ = "Android"
MAGISK_HANDLER = DisableAbleCommandHandler("magisk", magisk)
DEVICE_HANDLER = DisableAbleCommandHandler("device", device, pass_args=True)
TWRP_HANDLER = DisableAbleCommandHandler("twrp", twrp, pass_args=True)
dispatcher.add_handler(MAGISK_HANDLER)
dispatcher.add_handler(DEVICE_HANDLER)
dispatcher.add_handler(TWRP_HANDLER)
elif flag == "-s":
stkr = "sticker.webp"
x = open(stkr, "wb")
x.write(requests.get(img).content)
message.reply_sticker(sticker=open(stkr, "rb"))
os.remove("sticker.webp")
elif flag == "-v":
message.reply_video(video=img, parse_mode=ParseMode.MARKDOWN)
else:
message.reply_text("Put flags correctly!!!")
except Exception as excp:
message.reply_text(f"Failed to find image. Error: {excp}")
__help__ = """
× /neko <flags> <query>: Get random images from [Nekos API](nekos.life)
*Available flags:*
-i = send as image
-d = send as document(full resolution)
-s = send as sticker
-v = send as video(only for some query)
*Available query:*
Check this : [List Query](https://telegra.ph/List-Query-of-Nekos-01-19)
"""
__mod_name__ = "Nekos"
NEKO_HANDLER = DisableAbleCommandHandler("neko", neko)
dispatcher.add_handler(NEKO_HANDLER)
def main():
# test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start",
start,
pass_args=True,
run_async=True)
start_callback_handler = CallbackQueryHandler(send_start,
pattern=r"bot_start")
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
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(settings_callback_handler)
dispatcher.add_handler(start_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)
client.run_until_disconnected()
else:
LOGGER.info("Using long polling.")
updater.start_polling(timeout=15, read_latency=4)
client.run_until_disconnected()
updater.idle()
prev_end = 0
for change in changes:
start = change.get("From")
end = change.get("To") + 1
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!
× /splcheck: - 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))
dispatcher.add_handler(DisableAbleCommandHandler("tts", gtts, pass_args=True))
dispatcher.add_handler(DisableAbleCommandHandler("splcheck", spellcheck))
__help__ = """
When marked as AFK, any mentions will be replied to with a message to say you're not available!
× /afk <reason>: Mark yourself as AFK.
× brb <reason>: Same as the afk command - but not a command.
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.chat_type.groups,
no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(
Filters.all & Filters.chat_type.groups & ~Filters.update.edited_message,
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),
]
chat_data[chat_id] = {"backups": {"status": status, "value": value}}
def get_chat(chat_id, chat_data):
# print(chat_data)
try:
return chat_data[chat_id]["backups"]
except KeyError:
return {"status": False, "value": False}
__mod_name__ = "Backups"
__help__ = """
*Only for 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)
EXPORT_HANDLER = CommandHandler("export", export_data, pass_chat_data=True)
dispatcher.add_handler(IMPORT_HANDLER)
dispatcher.add_handler(EXPORT_HANDLER)
__mod_name__ = "Connection"
__help__ = """
Sometimes, you just want to add some notes and filters to a group chat, but you don't want everyone to see; This is where connections come in...
This allows you to connect to a chat's database, and add things to it without the commands appearing in chat! For obvious reasons, you need to be an admin to add things; but any member in the group can view your data.
× /connect: Connects to chat (Can be done in a group by /connect or /connect <chat id> in PM)
× /connection: List connected chats
× /disconnect: Disconnect from a chat
× /helpconnect: List available commands that can be used remotely
*Admin only:*
× /allowconnect <yes/no>: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, 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)
filters=Filters.chat_type.groups)
CLEAN_WELCOME = CommandHandler("cleanwelcome",
clean_welcome,
pass_args=True,
filters=Filters.chat_type.groups)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
welcomemute,
pass_args=True,
filters=Filters.chat_type.groups)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
cleanservice,
pass_args=True,
filters=Filters.chat_type.groups)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_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(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_HELP)
filters=Filters.private)
STATS_HANDLER = CommandHandler("stats", stats, filters=Filters.user(OWNER_ID))
GDPR_HANDLER = CommandHandler("gdpr", gdpr, filters=Filters.private)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
IMDB_HANDLER = DisableAbleCommandHandler("imdb", imdb, pass_args=True)
UD_HANDLER = DisableAbleCommandHandler("ud", ud)
GETLINK_HANDLER = CommandHandler("getlink",
getlink,
pass_args=True,
filters=Filters.user(OWNER_ID))
STAFFLIST_HANDLER = CommandHandler("staffids",
staff_ids,
filters=Filters.user(OWNER_ID))
REDDIT_MEMES_HANDLER = DisableAbleCommandHandler("rmeme", rmemes)
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(REDDIT_MEMES_HANDLER)
dispatcher.add_handler(IMDB_HANDLER)
