return {"status": False, "value": False}
__help__ = True
__mod_name__ = "Federations"
NEW_FED_HANDLER = CommandHandler("newfed", new_fed, pass_args=True)
DEL_FED_HANDLER = CommandHandler("delfed", del_fed, pass_args=True)
JOIN_FED_HANDLER = CommandHandler("joinfed", join_fed, pass_args=True)
LEAVE_FED_HANDLER = CommandHandler("leavefed", leave_fed, pass_args=True)
PROMOTE_FED_HANDLER = CommandHandler("fpromote", user_join_fed, pass_args=True)
DEMOTE_FED_HANDLER = CommandHandler("fdemote", user_demote_fed, pass_args=True)
INFO_FED_HANDLER = CommandHandler("fedinfo", fed_info, pass_args=True)
BAN_FED_HANDLER = DisableAbleCommandHandler(["fban", "fedban"],
fed_ban,
pass_args=True)
UN_BAN_FED_HANDLER = CommandHandler("unfban", unfban, pass_args=True)
FED_SET_RULES_HANDLER = CommandHandler("setfrules", set_frules, pass_args=True)
FED_GET_RULES_HANDLER = CommandHandler("frules", get_frules, pass_args=True)
FED_CHAT_HANDLER = CommandHandler("chatfed", fed_chat, pass_args=True)
FED_ADMIN_HANDLER = CommandHandler("fedadmins", fed_admin, pass_args=True)
FED_NOTIF_HANDLER = CommandHandler("fednotif", fed_notif, pass_args=True)
FED_CHATLIST_HANDLER = CommandHandler("fedchats", fed_chats, pass_args=True)
MY_FEDS_LIST = CommandHandler("myfeds", get_myfeds_list)
DELETEBTN_FED_HANDLER = CallbackQueryHandler(del_fed_button, pattern=r"rmfed_")
FED_USERBAN_HANDLER = CommandHandler("fbanlist", fed_ban_list, pass_args=True)
dispatcher.add_handler(NEW_FED_HANDLER)
dispatcher.add_handler(DEL_FED_HANDLER)
dispatcher.add_handler(JOIN_FED_HANDLER)
- /havoc <device>: Get the Havoc Rom
- /viper <device>: Get the Viper Rom
- /evo <device>: Get the Evolution X Rom
- /dotos <device>: Get the DotOS Rom
- /pixys <device>: Get the Pixy Rom
- /los <device>: Get the LineageOS Rom
- /bootleggers <device>: Get the Bootleggers Rom
*GSI*
- /phh: Get the lastest Phh AOSP Oreo GSI!
- /descendant: Get the lastest Descendant GSI!
- /enesrelease: Get the lastest Enes upload
"""
__mod_name__ = "Android"
EVO_HANDLER = DisableAbleCommandHandler("evo", evo, admin_ok=True)
MAGISK_HANDLER = DisableAbleCommandHandler("magisk", magisk)
BLISS_HANDLER = DisableAbleCommandHandler("bliss", bliss, pass_args=True)
TWRP_HANDLER = DisableAbleCommandHandler("twrp", twrp, pass_args=True)
OFOX_HANDLER = DisableAbleCommandHandler("ofox", ofox, pass_args=True)
SHRP_HANDLER = DisableAbleCommandHandler("shrp", shrp, pass_args=True)
DOTOS_HANDLER = DisableAbleCommandHandler("dotos", dotos, admin_ok=True)
PIXYS_HANDLER = DisableAbleCommandHandler("pixys", pixys, 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)
- /permanentpin: Set a permanent pin for supergroup chat, when an admin or telegram channel change pinned message, bot will change pinned message immediatelly
- /promote: promotes the user replied to
- /demote: demotes the user replied to
"""
__mod_name__ = "Admin"
PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
PERMAPIN_HANDLER = CommandHandler("permapin", permapin, filters=Filters.group)
# INVITE_HANDLER = CommandHandler("invitelink", 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)
PERMANENT_PIN_SET_HANDLER = CommandHandler("permanentpin", permanent_pin_set, pass_args=True, filters=Filters.group)
PERMANENT_PIN_HANDLER = MessageHandler(Filters.status_update.pinned_message | Filters.user(777000), permanent_pin)
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"], adminlist)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(PERMAPIN_HANDLER)
# dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(PERMANENT_PIN_SET_HANDLER)
dispatcher.add_handler(PERMANENT_PIN_HANDLER)
dispatcher.add_handler(ADMINLIST_HANDLER)
def __stats__():
return "• `{}` notes, accross `{}` chats.".format(sql.num_notes(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
REMOVE_ALL_NOTES_HANDLER = CommandHandler("clearall", remove_all_notes)
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)
dispatcher.add_handler(REMOVE_ALL_NOTES_HANDLER)
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text="Start",
url=f"t.me/{bot.username}")
]]))
elif e.message == "Internal Server Error: created sticker set not found (500)":
msg.reply_text(tld(chat.id, 'stickers_kang_success').format(
packname, sticker_emoji),
parse_mode=ParseMode.MARKDOWN)
return
if success:
msg.reply_text(tld(chat.id,
'stickers_kang_success').format(packname, emoji),
parse_mode=ParseMode.MARKDOWN)
else:
msg.reply_text(tld(chat.id, 'stickers_pack_create_error'))
__help__ = True
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang",
kang,
pass_args=True,
admin_ok=True)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
for x in range(len(time_list)):
time_list[x] = str(time_list[x]) + time_suffix_list[x]
if len(time_list) == 4:
ping_time += time_list.pop() + ", "
time_list.reverse()
ping_time += ":".join(time_list)
return ping_time
@run_async
@user_admin
def ping(bot: Bot, update: Update):
msg = update.effective_message
start_time = time.time()
message = msg.reply_text("Just A Sec...")
end_time = time.time()
telegram_ping = str(round((end_time - start_time) * 1000, 3)) + " ms"
uptime = get_readable_time((time.time() - StartTime))
message.edit_text(
"<b>Ping:</b> <code>{}</code>\n"
"<b>Bot Uptime:</b> <code>{}</code>".format(telegram_ping, uptime),
parse_mode=ParseMode.HTML,
)
PING_HANDLER = DisableAbleCommandHandler("uptime", ping)
dispatcher.add_handler(PING_HANDLER)
# for fx in f_flist:
# sql.remove_filter(chat.id, fx)
#
# message.reply_text(tld(chat.id, "cust_filters_cleanup_success").format(x))
def __stats__():
return "• `{}` filters, across `{}` chats.".format(sql.num_filters(),
sql.num_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
FILTER_HANDLER = DisableAbleCommandHandler("filter", filters)
STOP_HANDLER = DisableAbleCommandHandler("stopfilter", stop_filter)
#STOPALL_HANDLER = DisableAbleCommandHandler("stopall", stop_all_filters)
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(STOPALL_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
__help__ = """
- /wiki <text>: search for text written from the wikipedia source
- /ud <text>: search from urban dictionary
- /paste: Create a paste or a shortened url using [dogbin](https://del.dog)
- /getpaste: Get the content of a paste or shortened url from [dogbin](https://del.dog)
- /pastestats: Get stats of a paste or shortened url from [dogbin](https://del.dog)
- /tele <text> - as reply to a long message
"""
__mod_name__ = "special"
GETLINK_HANDLER = CommandHandler("getlink", getlink, pass_args=True, filters=Filters.user(OWNER_ID))
LEAVECHAT_HANDLER = CommandHandler(["leavechat", "leavegroup", "leave"], leavechat, pass_args=True, filters=Filters.user(OWNER_ID))
WIKIPEDIA_HANDLER = DisableAbleCommandHandler("wiki", wiki, pass_args=True)
UD_HANDLER = DisableAbleCommandHandler("ud", urbandictionary)
PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, pass_args=True)
GET_PASTE_HANDLER = DisableAbleCommandHandler("getpaste", get_paste_content, pass_args=True)
PASTE_STATS_HANDLER = DisableAbleCommandHandler("pastestats", get_paste_stats, pass_args=True)
#LOG_HANDLER = DisableAbleCommandHandler("log", log, filters=Filters.user(OWNER_ID))
SLIST_HANDLER = CommandHandler("slist", slist, filters=Filters.user(OWNER_ID))
#eval_handler = CommandHandler('eval', evaluate, filters=Filters.user(OWNER_ID))
#exec_handler = CommandHandler('py', execute, filters=Filters.user(OWNER_ID))
#clear_handler = CommandHandler('clearlocals', clear, filters=Filters.user(OWNER_ID))
dispatcher.add_handler(DisableAbleCommandHandler("tele", post_telegraph, pass_args=True))
dispatcher.add_handler(GETLINK_HANDLER)
dispatcher.add_handler(LEAVECHAT_HANDLER)
dispatcher.add_handler(WIKIPEDIA_HANDLER)
dispatcher.add_handler(UD_HANDLER)
grnd_level = None
try:
wind_speed = response['wind']['speed']
except Exception:
None
try:
wind_deg = response['wind']['deg']
except Exception:
wind_deg = None
msg = "<b>Weather - </b> {0}\n".format(description)
msg += "<b>Temperature - </b> {0}°C actually, but feels like {1}°C\n".format(
temp, feels_like)
msg += "<b>Minimum Temperature - </b> {0}°C\n".format(temp_min)
msg += "<b>Maximum Temperature - </b> {0}°C\n".format(temp_max)
if pressure is not None:
msg += "<b>Pressure - </b> {0} hPa\n".format(pressure)
if humidity is not None:
msg += "<b>Humidity - </b> {0} %%\n".format(humidity)
if wind_speed is not None:
msg += "<b>Wind Speed - </b> {0} m/s\n".format(wind_speed)
if wind_deg is not None:
msg += "<b>Wind Direction - </b> {0}°".format(wind_deg)
context.bot.sendMessage(chat_id,
msg,
parse_mode='HTML',
reply_to_message_id=msg_id)
WEATHER_HANDLER = DisableAbleCommandHandler("weather", weather)
dispatcher.add_handler(WEATHER_HANDLER)
base_string = tld(chat.id, "url_blacklist_current")
blacklisted = sql.get_blacklisted_urls(chat.id)
if not blacklisted:
message.reply_text(tld(chat.id, "url_blacklist_no_existed"))
return
for domain in blacklisted:
base_string += "- <code>{}</code>\n".format(domain)
message.reply_text(base_string, parse_mode=ParseMode.HTML)
URL_BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
add_blacklist_url,
filters=Filters.group,
pass_args=True,
admin_ok=True)
ADD_URL_BLACKLIST_HANDLER = CommandHandler("addurl",
add_blacklist_url,
filters=Filters.group)
RM_BLACKLIST_URL_HANDLER = CommandHandler("delurl",
rm_blacklist_url,
filters=Filters.group)
GET_BLACKLISTED_URLS = CommandHandler("geturl",
get_blacklisted_urls,
filters=Filters.group)
URL_DELETE_HANDLER = MessageHandler(Filters.entity("url"),
msg.reply_text(tld(chat.id, "translator_no_str"))
return
if not args:
msg.reply_text(tld(chat.id, 'translator_no_args'))
return
lang = args[0]
translator = Translator()
try:
translated = translator.translate(to_translate_text, dest=lang)
except ValueError as e:
msg.reply_text(tld(chat.id, 'translator_err').format(e))
return
src_lang = LANGUAGES[f'{translated.src.lower()}'].title()
dest_lang = LANGUAGES[f'{translated.dest.lower()}'].title()
translated_text = translated.text
msg.reply_text(tld(chat.id,
'translator_translated').format(src_lang,
to_translate_text,
dest_lang,
translated_text),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
dispatcher.add_handler(
DisableAbleCommandHandler("tr", do_translate, pass_args=True))
else:
update.effective_message.reply_text(tld(chat.id,
"admin_err_wrong_arg"),
parse_mode=ParseMode.MARKDOWN)
else:
status = sql.command_reaction(chat.id)
update.effective_message.reply_text(tld(
chat.id, "admin_reaction_status").format('enabled' if status ==
True else 'disabled'),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
PIN_HANDLER = DisableAbleCommandHandler("pin",
pin,
pass_args=True,
filters=Filters.group)
UNPIN_HANDLER = DisableAbleCommandHandler("unpin",
unpin,
filters=Filters.group)
INVITE_HANDLER = CommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, pass_args=True)
REACT_HANDLER = DisableAbleCommandHandler("reaction",
reaction,
pass_args=True,
filters=Filters.group)
log += "\n<b>Reason:</b> {}".format(reason)
return log
__help__ = """
- /kickme: kicks the user who issued the command
*Admin only:*
- /ban <userhandle>: bans a user. (via handle, or reply)
- /sban <userhandle>: silent ban a user, bot will not reply and delete your sban message.
- /tban <userhandle> x(m/h/d): bans a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
- /unban <userhandle>: unbans a user. (via handle, or reply)
- /kick <userhandle>: kicks a user, (via handle, or reply)
- /skick <userhandle>: silent kick a user, bot will not reply and delete your skick message.
"""
__mod_name__ = "Bans"
BAN_HANDLER = CommandHandler(["ban", "sban"], ban, pass_args=True)#, filters=Filters.group)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"], temp_ban, pass_args=True)#, filters=Filters.group)
KICK_HANDLER = CommandHandler(["kick", "skick"], 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)
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)
res = bot.restrict_chat_member(chat.id, user_id, can_send_messages=False)
if res:
update.effective_message.reply_text(tld(chat.id, "muteme_muted"))
log = "<b>{}:</b>" \
"\n#MUTEME" \
"\n<b>User:</b> {}" \
"\n<b>ID:</b> <code>{}</code>".format(html.escape(chat.title),
mention_html(user.id, user.first_name), user_id)
return log
else:
update.effective_message.reply_text(tld(chat.id, "mute_cant_mute"))
MUTE_HANDLER = DisableAbleCommandHandler("mute",
mute,
pass_args=True,
admin_ok=True)
UNMUTE_HANDLER = DisableAbleCommandHandler("unmute",
unmute,
pass_args=True,
admin_ok=True)
TEMPMUTE_HANDLER = DisableAbleCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True,
admin_ok=True)
TEMP_NOMEDIA_HANDLER = DisableAbleCommandHandler(["trestrict", "temprestrict"],
temp_nomedia,
pass_args=True,
admin_ok=True)
NOMEDIA_HANDLER = DisableAbleCommandHandler(["restrict", "nomedia"],
nomedia,
def __stats__():
return "• `{}` overall warns, across `{}` chats.\n" \
"• `{}` warn filters, across `{}` chats.".format(sql.num_warns(), sql.num_warn_chats(),
sql.num_warn_filters(), sql.num_warn_filter_chats())
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
WARN_HANDLER = DisableAbleCommandHandler("warn",
warn_user,
pass_args=True,
filters=Filters.group,
admin_ok=True)
RESET_WARN_HANDLER = DisableAbleCommandHandler(["resetwarn", "resetwarns"],
reset_warns,
pass_args=True,
filters=Filters.group)
RMWARN_QUERY_HANDLER = CallbackQueryHandler(rmwarn_handler, pattern=r"rm_warn")
SENDRULES_QUERY_HANDLER = CallbackQueryHandler(sendrules_handler,
pattern=r"send_rules")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
pass_args=True,
filters=Filters.group,
admin_ok=True)
ADD_WARN_HANDLER = DisableAbleCommandHandler("addwarn",
update.effective_message,
"Current stats:\n" + "\n".join([mod.__stats__() for mod in STATS]))
# /ip is for private use
__help__ = """
- /id: get the current group id. If used by replying to a message, gets that user's id.
- /runs: reply a random string from an array of replies.
- /slap: slap a user, or get slapped if not a reply.
- /info: get information about a user.
- /markdownhelp: quick summary of how markdown works in telegram - can only be called in private chats.
"""
__mod_name__ = "Misc"
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True)
ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID))
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)
STATS_HANDLER = CommandHandler("stats", stats, filters=Filters.user(OWNER_ID))
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
- /addwarn <keyword> <reply message>: set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
- /nowarn <keyword>: stop a warning filter
- /warnlimit <num>: set the warning limit
- /warnmode <kick/ban/mute>: Set warn mode, when user exceeding the warn limit will result in that mode.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user,
pass_args=True) #, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns", "rmwarn"],
reset_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)
WARN_MODE_HANDLER = CommandHandler("warnmode", set_warn_mode, pass_args=True)
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "There are `{}` custom filters here.".format(len(cust_filters))
__help__ = """
- /filters: list all active filters in this chat.
*Admin only:*
- /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword' is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker.
NOTE: all filter keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you doin?
- /stopfilter <filter keyword>: stop that filter.
}
"""
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stopfilter", stop_filter)
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)
chat = update.effective_chat
user = update.effective_user
chatname = chat.title
res = build_lock_message(chat, chat, user, chatname)
update.effective_message.reply_text(res, parse_mode=ParseMode.MARKDOWN)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = True
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)
for char in s:
count = count + 1
if count % 3 == 0:
if len(s) == count:
result = char + result
else:
result = thousand_separator + char + result
else:
result = char + result
return result
__help__ = True
ID_HANDLER = DisableAbleCommandHandler("id",
get_id,
pass_args=True,
admin_ok=True)
INFO_HANDLER = DisableAbleCommandHandler("info",
info,
pass_args=True,
admin_ok=True)
GITHUB_HANDLER = DisableAbleCommandHandler("git", github, admin_ok=True)
REPO_HANDLER = DisableAbleCommandHandler("repo",
repo,
pass_args=True,
admin_ok=True)
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)
else:
res = "{} is AFK! says its because of : {}".format(
fst_name, reason)
send_message(update.effective_message, res)
__help__ = """
- /afk <reason>: mark yourself as AFK.
- 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!
"""
__mod_name__ = "AFK"
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"),
afk,
friendly="afk")
NO_AFK_HANDLER = MessageHandler(
Filters.all & Filters.group & ~Filters.update.edited_message,
no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
# AFK_REPLY_HANDLER = MessageHandler(Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION),
# 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)
__help__ = """
Blacklist sticker is used to stop certain stickers. Whenever a sticker is sent, the message will be deleted immediately.
*NOTE:* Blacklist stickers do not affect the group admin.
- /blsticker: See current blacklisted sticker.
*Only admin:*
- /addblsticker <sticker link>: Add the sticker trigger to the black list. Can be added via reply sticker.
- /unblsticker <sticker link>: Remove triggers from blacklist. The same newline logic applies here, so you can delete multiple triggers at once.
- /rmblsticker <sticker link>: Same as above.
Note:
- `<sticker link>` can be `https://t.me/addstickers/<sticker>` or just `<sticker>` or reply to the sticker message.
"""
__mod_name__ = "Sticker Blacklist"
BLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("blsticker", blackliststicker, pass_args=True, admin_ok=True)
ADDBLACKLIST_STICKER_HANDLER = DisableAbleCommandHandler("addblsticker", add_blackliststicker)
UNBLACKLIST_STICKER_HANDLER = CommandHandler(["unblsticker", "rmblsticker"], unblackliststicker)
BLACKLISTMODE_HANDLER = CommandHandler("blstickermode", blacklist_mode, pass_args=True)
BLACKLIST_STICKER_DEL_HANDLER = MessageHandler(Filters.sticker & Filters.group, del_blackliststicker)
dispatcher.add_handler(BLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(ADDBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(UNBLACKLIST_STICKER_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
dispatcher.add_handler(BLACKLIST_STICKER_DEL_HANDLER)
bio = html.escape(sql.get_user_bio(user_id) or "")
me = html.escape(sql.get_user_me_info(user_id) or "")
if bio and me:
return tld(chat_id, "userinfo_what_i_and_other_say").format(me, bio)
elif bio:
return tld(chat_id, "userinfo_what_other_say").format(bio)
elif me:
return tld(chat_id, "userinfo_what_i_say").format(me)
else:
return ""
def __gdpr__(user_id):
sql.clear_user_info(user_id)
sql.clear_user_bio(user_id)
__help__ = True
__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)
- /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.
- /blacklistmode <ban/kick/mute/tban/tmute> <value>: select the action perform when warnings have been exceeded. ban/kick/mute/tmute/tban
Note:
- Value must be filled for tban and tmute, Can be:
`4m` = 4 minutes
`3h` = 4 hours
`2d` = 2 days
`1w` = 1 week
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist)
BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode",
blacklist_mode,
pass_args=True)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.group, del_blacklist)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
except BadRequest as excp:
if excp.message == "Reply message not found":
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
return ""
__help__ = True
BAN_HANDLER = DisableAbleCommandHandler("ban",
ban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
TEMPBAN_HANDLER = DisableAbleCommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.group,
admin_ok=True)
KICK_HANDLER = DisableAbleCommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group,
admin_ok=True)
UNBAN_HANDLER = DisableAbleCommandHandler("unban",
unban,
pass_args=True,
itemp = random.choice(tld_list(chat.id, "memes_items_list"))
itemr = random.choice(tld_list(chat.id, "memes_items_list"))
repl = temp.format(user1=user1,
user2=user2,
item=item,
hits=hit,
throws=throw,
itemp=itemp,
itemr=itemr)
reply_text(repl, parse_mode=ParseMode.MARKDOWN)
__help__ = False
INSULTS_HANDLER = DisableAbleCommandHandler("insults", insults, admin_ok=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs, admin_ok=True)
SLAP_HANDLER = DisableAbleCommandHandler("slap",
slap,
pass_args=True,
admin_ok=True)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
dispatcher.add_handler(INSULTS_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
