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)
else:
break
# check if there's any new entries queued from the last check
if new_entry_links:
sql.update_url(row_id, new_entry_links)
else:
pass
__help__ = "rss_help"
__mod_name__ = "RSS Feed"
job = updater.job_queue
job_rss_set = job.run_once(rss_set, 5)
job_rss_update = job.run_repeating(rss_update, interval=60, first=60)
job_rss_set.enabled = True
job_rss_update.enabled = True
SHOW_URL_HANDLER = CommandHandler("rss", show_url, pass_args=True, filters=Filters.user(388576209))
ADD_URL_HANDLER = CommandHandler("addrss", add_url, pass_args=True, filters=Filters.user(388576209))
REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url, pass_args=True, filters=Filters.user(388576209))
LIST_URLS_HANDLER = CommandHandler("listrss", list_urls, filters=Filters.user(388576209))
dispatcher.add_handler(SHOW_URL_HANDLER)
dispatcher.add_handler(ADD_URL_HANDLER)
dispatcher.add_handler(REMOVE_URL_HANDLER)
dispatcher.add_handler(LIST_URLS_HANDLER)
"""
__mod_name__ = "Bans"
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)
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(BANME_HANDLER)
USER_HANDLER = DisableAbleCommandHandler("user", user)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
WATCHLIST_HANDLER = DisableAbleCommandHandler("watchlist", watchlist)
MANGALIST_HANDLER = DisableAbleCommandHandler("mangalist", readmanga)
FVRT_CHAR_HANDLER = DisableAbleCommandHandler(["characterlist", "fcl"],
fvrtchar)
REMOVE_WATCHLIST_HANDLER = DisableAbleCommandHandler(
["removewatchlist", "rwl"], removewatchlist)
REMOVE_FVRT_CHAR_HANDLER = DisableAbleCommandHandler(["rfcharacter", "rfcl"],
removefvrtchar)
REMOVE_MANGA_CHAR_HANDLER = DisableAbleCommandHandler(["rmanga", "rml"],
removemangalist)
BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*')
ANIME_STUFFS_HANDLER = CallbackQueryHandler(animestuffs, pattern='xanime_.*')
dispatcher.add_handler(BUTTON_HANDLER)
dispatcher.add_handler(ANIME_STUFFS_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(AIRING_HANDLER)
dispatcher.add_handler(USER_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
dispatcher.add_handler(WATCHLIST_HANDLER)
dispatcher.add_handler(MANGALIST_HANDLER)
dispatcher.add_handler(FVRT_CHAR_HANDLER)
dispatcher.add_handler(REMOVE_FVRT_CHAR_HANDLER)
dispatcher.add_handler(REMOVE_MANGA_CHAR_HANDLER)
dispatcher.add_handler(REMOVE_WATCHLIST_HANDLER)
__mod_name__ = "Anime"
)
SETSTICKET_HANDLER = CommandHandler("setsticker", set_sticker, filters=Filters.group)
SETDESC_HANDLER = CommandHandler(["setdescription", "setdes"], set_desc, 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)
SET_TITLE_HANDLER = DisableAbleCommandHandler("settitle", set_title, pass_args=True)
ADMINLIST_HANDLER = DisableAbleCommandHandler(
["adminlist", "admins"], adminlist, filters=Filters.group
)
ADMIN_REFRESH_HANDLER = CommandHandler(
"admincache", refresh_admin, 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)
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)
dispatcher.add_handler(ADMIN_REFRESH_HANDLER)
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("antispam",
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)
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)
__mod_name__ = "Command disabling"
__help__ = "disable_help"
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)
DISABLEDEL_HANDLER = CommandHandler("disabledel", disable_del)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
dispatcher.add_handler(DISABLEDEL_HANDLER)
else:
DisableAbleCommandHandler = CommandHandler
DisableAbleMessageHandler = MessageHandler
status = True
chat_data[chat_id] = {"backups": {"status": status, "value": value}}
def get_chat(chat_id, chat_data):
# print(chat_data)
try:
value = chat_data[chat_id]["backups"]
return value
except KeyError:
return {"status": False, "value": False}
__mod_name__ = "Backups"
__help__ = """
*Only for chat administrator:*
✗ /import: Reply to the backup file for the butler / emilia group to import as much as possible, making transfers very easy! \
Note that files / photos cannot be imported due to telegram restrictions.
✗ /export: Export group data, which will be exported are: rules, notes (documents, images, music, video, audio, voice, text, text buttons) \
"""
IMPORT_HANDLER = CommandHandler("import", import_data)
EXPORT_HANDLER = CommandHandler("export", export_data, pass_chat_data=True)
dispatcher.add_handler(IMPORT_HANDLER)
dispatcher.add_handler(EXPORT_HANDLER)
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)
__mod_name__ = "Reporting"
__help__ = """
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.group)
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)
return temp
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)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
notes = sql.get_all_chat_notes(chat_id)
return tl(user_id, "Ada catatan `{}` dalam obrolan ini.").format(len(notes))
__help__ = "notes_help"
__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)
PMNOTE_HANDLER = CommandHandler("privatenote", private_note, 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(PMNOTE_HANDLER)
dispatcher.add_handler(HASH_GET_HANDLER)
# /ip is for private use
__help__ = "misc_help"
__mod_name__ = "Misc"
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
TIME_HANDLER = DisableAbleCommandHandler("time", get_time_alt, pass_args=True)
RUNS_HANDLER = DisableAbleCommandHandler(["runs", "lari"], 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=CustomFilters.sudo_filter)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(TIME_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
status += "<b>Machine:</b> <code>" + str(uname.machine) + "</code>\n"
status += "<b>Processor:</b> <code>" + str(uname.processor) + "</code>\n\n"
mem = virtual_memory()
cpu = cpu_percent()
disk = disk_usage("/")
status += "<b>CPU usage:</b> <code>" + str(cpu) + " %</code>\n"
status += "<b>Ram usage:</b> <code>" + str(mem[2]) + " %</code>\n"
status += "<b>Storage used:</b> <code>" + str(disk[3]) + " %</code>\n\n"
status += "<b>Python version:</b> <code>" + python_version() + "</code>\n"
status += "<b>Library version:</b> <code>" + str(__version__) + "</code>\n"
status += "<b>Spamwatch API:</b> <code>" + str(__sw__) + "</code>\n"
context.bot.sendMessage(update.effective_chat.id,
status,
parse_mode=ParseMode.HTML)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
PING_HANDLER = CommandHandler("ping", ping, filters=CustomFilters.sudo_filter)
SPEED_HANDLER = CommandHandler("speedtest",
speedtst,
filters=CustomFilters.sudo_filter)
SYS_STATUS_HANDLER = CommandHandler("sysinfo",
system_status,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(SPEED_HANDLER)
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(SYS_STATUS_HANDLER)
CLAP_HANDLER = DisableAbleCommandHandler("clap", clapmoji)
OWO_HANDLER = DisableAbleCommandHandler("owo", owo)
STRECH_HANDLER = DisableAbleCommandHandler("stretch", stretch)
MEETOO_HANDLER = DisableAbleMessageHandler(Filters.regex(r"(?i)(me too)"),
me_too,
friendly="metoo")
RECITE_HANDLER = DisableAbleCommandHandler("recite", recite)
DICE_HANDLER = DisableAbleCommandHandler("roll", dice)
YESNOWTF_HANDLER = DisableAbleCommandHandler("decide", yesnowtf)
GDMORNING_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"(?i)(goodmorning)"), goodmorning, friendly="goodmorning")
GDNIGHT_HANDLER = DisableAbleMessageHandler(Filters.regex(r"(?i)(goodnight)"),
goodnight,
friendly="goodnight")
dispatcher.add_handler(SHRUG_HANDLER)
dispatcher.add_handler(DECIDE_HANDLER)
dispatcher.add_handler(ABUSE_HANDLER)
dispatcher.add_handler(SNIPE_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(PUNCH_HANDLER)
dispatcher.add_handler(HUG_HANDLER)
dispatcher.add_handler(GBUN_HANDLER)
dispatcher.add_handler(TABLE_HANDLER)
dispatcher.add_handler(RECITE_HANDLER)
dispatcher.add_handler(CRI_HANDLER)
dispatcher.add_handler(PASTA_HANDLER)
dispatcher.add_handler(CLAP_HANDLER)
dispatcher.add_handler(OWO_HANDLER)
dispatcher.add_handler(STRECH_HANDLER)
if valid:
if not reason:
res = tl(update.effective_message,
"{} sedang AFK!").format(fst_name)
else:
res = tl(update.effective_message,
"{} sedang AFK!\nKarena : {}").format(
fst_name, reason)
send_message(update.effective_message, res)
__help__ = "afk_help"
__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)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_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)
UD_HANDLER = DisableAbleCommandHandler("ud", ud)
BIN_HANDLER = DisableAbleCommandHandler("bin", bin)
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)
SRC_HANDLER = CommandHandler("source", src, filters=Filters.private)
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(BIN_HANDLER)
dispatcher.add_handler(STAFFLIST_HANDLER)
dispatcher.add_handler(REDDIT_MEMES_HANDLER)
dispatcher.add_handler(SRC_HANDLER)
teks = tl(update.effective_message,
"*Cuaca di {} saat ini*\n").format(data.get('LocalizedName'))
teks += "{}\n".format(cuaca)
teks += tl(update.effective_message,
"*Lokasi:* `{}`\n\n").format(", ".join(lok))
# try:
# context.bot.send_photo(chat_id, photo=datas.get('Photos')[0].get('LandscapeLink'), caption=teks, parse_mode="markdown", reply_to_message_id=message.message_id, reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="More info", url=datas.get('Link'))]]))
# except:
send_message(update.effective_message,
teks,
parse_mode="markdown",
disable_web_page_preview=True,
reply_markup=InlineKeyboardMarkup([[
InlineKeyboardButton(text="More info",
url=datas.get('Link'))
]]))
__help__ = "weather_help"
__mod_name__ = "Weather"
CUACA_HANDLER = DisableAbleCommandHandler(["cuaca", "weather"],
accuweather,
pass_args=True)
# ACCUWEATHER_HANDLER = DisableAbleCommandHandler("accuweather", accuweather, pass_args=True)
dispatcher.add_handler(CUACA_HANDLER)
# dispatcher.add_handler(ACCUWEATHER_HANDLER)
if update.effective_message.reply_to_message:
user = update.effective_user # type: Optional[User]
chat = update.effective_chat # type: Optional[Chat]
if user_can_delete(chat, user, context.bot.id):
update.effective_message.reply_to_message.delete()
update.effective_message.delete()
return "<b>{}:</b>" \
"\n#DEL" \
"\n<b>Admin:</b> {}" \
"\nMessage deleted.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
else:
send_message(update.effective_message,
tl(update.effective_message, "Apa yang ingin di hapus?"))
return ""
__help__ = "msgdel_help"
__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)
✗ /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 __user_info__(user_id):
if user_id == dispatcher.bot.id:
return """I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me."""
num_chats = sql.get_user_num_chats(user_id)
return """I've seen them in <code>{}</code> chats in total.""".format(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.group, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, 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)
text = tl(update.effective_message,
"Mode timeout saat ini disetel ke *{}*.").format(
settypeblacklist)
send_message(update.effective_message,
text,
parse_mode=ParseMode.MARKDOWN)
return
job = updater.job_queue
job_timeout_set = job.run_repeating(welcome_timeout, interval=10, first=1)
job_timeout_set.enabled = True
WELCVERIFY_HANDLER = CommandHandler("welcomeverify",
set_verify_welcome,
pass_args=True,
filters=Filters.group)
WELTIMEOUT_HANDLER = CommandHandler("wtimeout",
set_welctimeout,
pass_args=True,
filters=Filters.group)
WELMODE_HANDLER = CommandHandler("wtmode",
timeout_mode,
pass_args=True,
filters=Filters.group)
dispatcher.add_handler(WELCVERIFY_HANDLER)
dispatcher.add_handler(WELTIMEOUT_HANDLER)
dispatcher.add_handler(WELMODE_HANDLER)
prev_end = 0
for change in changes:
start = change.get("From")
end = change.get("To") + 1
suggestions = change.get("Suggestions")
if suggestions:
sugg_str = suggestions[0].get(
"Text") # should look at this list more
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))
✗ /setflood <int/'no'/'off'>: enables or disables flood control
✗ /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.group, check_flood
)
SET_FLOOD_HANDLER = CommandHandler(
"setflood", set_flood, pass_args=True
) # , filters=Filters.group)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode, pass_args=True
) # , filters=Filters.group)
FLOOD_HANDLER = CommandHandler("flood", flood) # , filters=Filters.group)
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)
for trigger in filters:
sql.add_to_blacklist(chat_id, trigger)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return tl(user_id,
"Ada `{}` filter khusus di sini.").format(len(cust_filters))
__help__ = "filters_help"
__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 & ~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)
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)
__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)
def __chat_settings__(chat_id, user_id):
return tl(
user_id,
"Obrolan ini disetel untuk mengirim laporan pengguna ke admin, melalui /report dan @admin: `{}`"
).format(sql.chat_should_report(chat_id))
def __user_settings__(user_id):
return tl(
user_id,
"Anda menerima laporan dari obrolan yang Anda ikuti: `{}`.\nAktifkan ini dengan /reports di PM."
).format(sql.user_should_report(user_id))
__mod_name__ = "Reporting"
__help__ = "reporting_help"
REPORT_HANDLER = CommandHandler("report", report_alt, filters=Filters.group)
SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex("(?i)@admin(s)?"),
report_alt)
Callback_Report = CallbackQueryHandler(button, pattern=r"rp_")
Callback_ReportAsk = CallbackQueryHandler(buttonask, pattern=r"ak_")
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(Callback_Report)
dispatcher.add_handler(Callback_ReportAsk)
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 tl(user_id,
"Obrolan ini memiliki aturan yang ditetapkan: `{}`").format(
bool(sql.get_rules(chat_id)))
__help__ = "rules_help"
__mod_name__ = "Rules"
GET_RULES_HANDLER = CommandHandler("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)
PRIVATERULES_HANDLER = CommandHandler("privaterules",
private_rules,
pass_args=True)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
dispatcher.add_handler(PRIVATERULES_HANDLER)
def __stats__():
return tl(OWNER_ID,
"{} pemicu daftar hitam stiker, di seluruh {} obrolan.").format(
sql.num_stickers_filters(), sql.num_stickers_filter_chats())
__help__ = "blstickers_help"
__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)
