support_list,
filters=CustomFilters.sudo_filter)
STATS_HANDLER = CommandHandler("stats",
stats,
filters=CustomFilters.sudo_filter)
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, pass_args=True)
PAT_HANDLER = DisableAbleCommandHandler("pat", pat)
SHRUG_HANDLER = DisableAbleCommandHandler(["shrug", "shg"], shrug)
HUG_HANDLER = DisableAbleCommandHandler("hug", hug)
RUNS_HANDLER = DisableAbleCommandHandler(["runs", "lari"], runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(IP_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)
dispatcher.add_handler(SUDO_LIST_HANDLER)
dispatcher.add_handler(SUPPORT_LIST_HANDLER)
dispatcher.add_handler(PASTE_HANDLER)
dispatcher.add_handler(GET_PASTE_HANDLER)
dispatcher.add_handler(PASTE_STATS_HANDLER)
dispatcher.add_handler(WEEBIFY_HANDLER)
dispatcher.add_handler(PAT_HANDLER)
dispatcher.add_handler(SHRUG_HANDLER)
rep += f"<a href='{image}'>\u200c</a>"
else:
tracks = res.json().get("recenttracks").get("track")
track_dict = {
tracks[i].get("artist").get("name"): tracks[i].get("name")
for i in range(3)
}
rep = f"{user} was listening to:\n"
for artist, song in track_dict.items():
rep += f"🎧 <code>{artist} - {song}</code>\n"
last_user = requests.get(
f"{base_url}?method=user.getinfo&user={username}&api_key={LASTFM_API_KEY}&format=json"
).json().get("user")
scrobbles = last_user.get("playcount")
rep += f"\n(<code>{scrobbles}</code> scrobbles so far)"
msg.reply_text(rep, parse_mode=ParseMode.HTML)
__help__ = "lastfm_help"
__mod_name__ = "Last.FM"
SET_USER_HANDLER = CommandHandler("setuser", set_user, pass_args=True)
CLEAR_USER_HANDLER = CommandHandler("clearuser", clear_user)
LASTFM_HANDLER = DisableAbleCommandHandler("lastfm", last_fm)
dispatcher.add_handler(SET_USER_HANDLER)
dispatcher.add_handler(CLEAR_USER_HANDLER)
dispatcher.add_handler(LASTFM_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):
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
context.bot.editMessageText("Leaving chats... 😘", chat_id,
message.message_id)
chat_count = get_muted_chats(bot, update, True)
context.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:
context.bot.editMessageText("Cleaning up DB... 🙂", chat_id,
message.message_id)
invalid_chat_count = get_invalid_chats(context.bot, update, True)
invalid_gban_count = get_invalid_gban(context.bot, update, True)
reply = "Cleaned up {} chats and {} gbanned users from db! 😎".format(
invalid_chat_count, invalid_gban_count)
context.bot.sendMessage(chat_id, reply)
else:
query.answer("You are not allowed to use this.")
DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup)
LEAVE_MUTED_CHATS_HANDLER = CommandHandler("leavemutedchats",
leave_muted_chats)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern='db_.*')
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(LEAVE_MUTED_CHATS_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, LEAVE_MUTED_CHATS_HANDLER, BUTTON_HANDLER]
mention_html(user.id, user.first_name),
mention_html(member.user.id, member.user.first_name),
member.user.id)
if reason:
log += "\n<b>Reason:</b> {}".format(reason)
return log
__help__ = "bans_help"
__mod_name__ = "Bans"
BAN_HANDLER = DisableAbleCommandHandler(
["ban", "sban"], ban, pass_args=True) #, filters=Filters.group)
TEMPBAN_HANDLER = DisableAbleCommandHandler(
["tban", "tempban"], temp_ban, pass_args=True) #, filters=Filters.group)
KICK_HANDLER = DisableAbleCommandHandler(
["kick", "skick"], kick, pass_args=True) #, filters=Filters.group)
UNBAN_HANDLER = DisableAbleCommandHandler(
"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)
__help__ = """
Get information about anime, manga or characters from [MyAnimeList](https://myanimelist.net).
*Available commands:*
- /anime <anime>: returns information about the anime.
- /character <character>: returns information about the character.
- /manga <manga>: returns information about the manga.
- /upcoming: returns a list of new anime in the upcoming seasons.
"""
ANIME_HANDLER = DisableAbleCommandHandler("anime", anime)
CHARACTER_HANDLER = DisableAbleCommandHandler("character", character)
MANGA_HANDLER = DisableAbleCommandHandler("manga", manga)
UPCOMING_HANDLER = DisableAbleCommandHandler("upcoming", upcoming)
BUTTON_HANDLER = CallbackQueryHandler(button, pattern='anime_.*')
dispatcher.add_handler(BUTTON_HANDLER)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
__mod_name__ = "MyAnimeList"
__command_list__ = ["anime", "manga", "character", "upcoming"]
__handlers__ = [
ANIME_HANDLER, CHARACTER_HANDLER, MANGA_HANDLER, UPCOMING_HANDLER,
BUTTON_HANDLER
]
__mod_name__ = "Dogs and Cats"
if (DOG_API_KEY != None):
DOG_HANDLER = DisableAbleCommandHandler("dog",
dog,
admin_ok=True,
pass_args=False)
DOGHD_HANDLER = DisableAbleCommandHandler("doghd",
doghd,
admin_ok=True,
pass_args=False)
DOGGIF_HANDLER = DisableAbleCommandHandler("doggif",
doggif,
admin_ok=True,
pass_args=False)
dispatcher.add_handler(DOG_HANDLER)
dispatcher.add_handler(DOGHD_HANDLER)
dispatcher.add_handler(DOGGIF_HANDLER)
if (CAT_API_KEY != None):
CAT_HANDLER = DisableAbleCommandHandler("cat",
cat,
admin_ok=True,
pass_args=False)
CATHD_HANDLER = DisableAbleCommandHandler("cathd",
cathd,
admin_ok=True,
pass_args=False)
CATGIF_HANDLER = DisableAbleCommandHandler("catgif",
catgif,
admin_ok=True,
"Bahasa di *{}* saat ini adalah:\n{}.\n\nPilih bahasa:").format(
chatname, currlang),
parse_mode="markdown",
reply_markup=keyboard)
@run_async
@user_admin_no_reply
def button(update, context):
query = update.callback_query # type: Optional[CallbackQuery]
user = update.effective_user # type: Optional[User]
match = re.match(r"set_lang\((.+?)\)", query.data)
if match:
set_lang = match.group(1)
chat = update.effective_chat # type: Optional[Chat]
sql.set_lang(chat.id, set_lang)
update.effective_message.edit_text(
tl(query.message,
"Bahasa telah di ubah ke {}!").format(LANGS_TEXT.get(set_lang)))
__help__ = "language_help"
__mod_name__ = "Languages"
SETLANG_HANDLER = DisableAbleCommandHandler("setlang", set_language)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"set_lang")
dispatcher.add_handler(SETLANG_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
message = update.effective_message
base_string = "Current <b>blacklisted</b> domains:\n"
blacklisted = sql.get_blacklisted_urls(chat.id)
if not blacklisted:
message.reply_text("There are no blacklisted domains here!")
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"), del_blacklist_url)
__mod_name__ = "Domain Blacklists"
__help__ = "urlblacklist_help"
dispatcher.add_handler(URL_BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_URL_BLACKLIST_HANDLER)
dispatcher.add_handler(RM_BLACKLIST_URL_HANDLER)
dispatcher.add_handler(GET_BLACKLISTED_URLS)
dispatcher.add_handler(URL_DELETE_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)
return languages.tl(
chat_id,
"""Saya telah melihatnya <code>{}</code> obrolan total.""").format(
num_chats)
def __stats__():
return languages.tl(OWNER_ID, "{} pengguna, pada {} obrolan").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)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
return
fst_name = chat.first_name
else:
return
if sql.is_afk(user_id):
valid, reason = sql.check_afk_status(user_id)
if valid:
if not reason:
res = tl(update.effective_message, "{} is AFK!").format(fst_name)
else:
res = tl(update.effective_message, "{} is AFK! says its because of: {}").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)
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)
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))
RAMALAN_HANDLER = DisableAbleCommandHandler(["ramalan", "fortune"], ramalan)
TERJEMAH_HANDLER = DisableAbleCommandHandler(["tr", "tl"], terjemah)
WIKIPEDIA_HANDLER = DisableAbleCommandHandler("wiki", wiki)
KBBI_HANDLER = DisableAbleCommandHandler("kbbi", kamusbesarbahasaindonesia)
UD_HANDLER = DisableAbleCommandHandler("ud", urbandictionary, pass_args=True)
LOG_HANDLER = DisableAbleCommandHandler("log",
log,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(PING_HANDLER)
dispatcher.add_handler(STICKERID_HANDLER)
#dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(STIKER_HANDLER)
dispatcher.add_handler(FILE_HANDLER)
dispatcher.add_handler(GETLINK_HANDLER)
dispatcher.add_handler(LEAVECHAT_HANDLER)
dispatcher.add_handler(RAMALAN_HANDLER)
dispatcher.add_handler(TERJEMAH_HANDLER)
dispatcher.add_handler(WIKIPEDIA_HANDLER)
dispatcher.add_handler(KBBI_HANDLER)
dispatcher.add_handler(UD_HANDLER)
dispatcher.add_handler(LOG_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)
msg = msg.replace(character, "")
# idk PIL. this part was untouched and ask @devrism for better explanation. According to my understanding, Image.new creates a new image and paste "pastes" the character one by one comparing it with "value" variable
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)
THONKIFY_HANDLER = CommandHandler("thonkify", thonkify)
dispatcher.add_handler(THONKIFY_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):
return build_lock_message(chat_id)
__help__ = "locks_help"
__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)
LOCKWARNS_HANDLER = CommandHandler("lockwarns", lock_warns, pass_args=True)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(LOCKWARNS_HANDLER)
dispatcher.add_handler(
MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP)
parse_mode=ParseMode.MARKDOWN)
elif e.message == "Peer_id_invalid":
msg.reply_text("Contact me in PM first.", 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("Sticker pack successfully created. Get it [here](t.me/addstickers/%s)" % packname,
parse_mode=ParseMode.MARKDOWN)
return
if success:
msg.reply_text("Sticker pack successfully created. Get it [here](t.me/addstickers/%s)" % packname,
parse_mode=ParseMode.MARKDOWN)
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.
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = CommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = CommandHandler("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)
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)
else:
context.bot.answer_callback_query(query.id,
languages.tl(update.effective_message, "Anda tidak terkoneksi!"),
show_alert=True)
elif clear_match:
sql.clear_history_conn(query.from_user.id)
query.message.edit_text(languages.tl(update.effective_message, "Riwayat yang terhubung telah dihapus!"))
elif connect_close:
query.message.edit_text(languages.tl(update.effective_message, "Closed.\nTo open again, type /connect"))
else:
connect_chat(update, context)
__help__ = "connection_help"
__mod_name__ = "Connection"
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, pass_args=True)
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)
reply = f"Mirrors for <i>{file_path.split('/')[-1]}</i>\n"
project = re.findall(r'projects?/(.*?)/files', link)[0]
mirrors = f'https://sourceforge.net/settings/mirror_choices?' \
f'projectname={project}&filename={file_path}'
page = BeautifulSoup(requests.get(mirrors).content, 'lxml')
info = page.find('ul', {'id': 'mirrorList'}).findAll('li')
for mirror in info[1:]:
name = re.findall(r'\((.*)\)', mirror.text.strip())[0]
dl_url = f'https://{mirror["id"]}.dl.sourceforge.net/project/{project}/{file_path}'
reply += f'<a href="{dl_url}">{name}</a> '
return reply
def useragent():
useragents = BeautifulSoup(
requests.get(
'https://developers.whatismybrowser.com/'
'useragents/explore/operating_system_name/android/').content,
'lxml').findAll('td', {'class': 'useragent'})
user_agent = choice(useragents)
return user_agent.text
__help__ = "directlinks_help"
__mod_name__ = "Direct Links"
DIRECT_HANDLER = CommandHandler("direct", direct_link_generator)
dispatcher.add_handler(DIRECT_HANDLER)
def __stats__():
return tl(OWNER_ID,
"{} pemicu daftar hitam, di seluruh {} obrolan.").format(
sql.num_blacklist_filters(),
sql.num_blacklist_filter_chats())
__mod_name__ = "Word Blacklists"
__help__ = "blacklist_help"
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)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_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):
log_channel = sql.get_chat_log_channel(chat_id)
if log_channel:
log_channel_info = dispatcher.bot.get_chat(log_channel)
return tl(user_id, "Grup ini memiliki semua log yang dikirim ke: {} (`{}`)").format(escape_markdown(log_channel_info.title),
log_channel)
return tl(user_id, "Tidak ada saluran masuk yang ditetapkan untuk grup ini!")
__help__ = "logchannel_help"
__mod_name__ = "Channel Log"
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
send_message(update.effective_message,
tl(update.effective_message,
"Dibisukan untuk *{}*!").format(time_val),
quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s",
user_id, chat.title, chat.id, excp.message)
send_message(
update.effective_message,
tl(update.effective_message,
"Yah sial, aku tidak bisa membisukan pengguna itu."))
return ""
__help__ = "mute_help"
__mod_name__ = "Muting"
MUTE_HANDLER = DisableAbleCommandHandler("mute", mute, pass_args=True)
UNMUTE_HANDLER = DisableAbleCommandHandler("unmute", unmute, pass_args=True)
TEMPMUTE_HANDLER = DisableAbleCommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
wallpapers = json_rep.get("wallpapers")
if not wallpapers:
msg.reply_text("No results found!")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
context.bot.send_photo(chat_id,
photo=wallpaper,
caption='Preview',
reply_to_message_id=msg_id,
timeout=60)
context.bot.sendDocument(chat_id,
document=wallpaper,
filename='wallpaper',
caption=caption,
reply_to_message_id=msg_id,
timeout=60)
__help__ = """
- /wall <any text> : Search wallpaper.
"""
__mod_name__ = "Wallpapers"
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start, pass_args=True)
help_handler = CommandHandler("help", get_help)
help_callback_handler = CallbackQueryHandler(help_button, pattern=r"help_")
settings_handler = CommandHandler("settings", get_settings)
settings_callback_handler = CallbackQueryHandler(settings_button,
pattern=r"stngs_")
source_handler = CommandHandler("source", source)
M_CONNECT_BTN_HANDLER = CallbackQueryHandler(m_connect_button,
pattern=r"main_connect")
M_SETLANG_BTN_HANDLER = CallbackQueryHandler(m_change_langs,
pattern=r"main_setlang")
# 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(source_handler)
dispatcher.add_handler(M_CONNECT_BTN_HANDLER)
dispatcher.add_handler(M_SETLANG_BTN_HANDLER)
# dispatcher.add_error_handler(error_callback)
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="127.0.0.1", port=PORT, url_path=TOKEN)
if CERT_PATH:
updater.bot.set_webhook(url=URL + TOKEN,
certificate=open(CERT_PATH, 'rb'))
else:
updater.bot.set_webhook(url=URL + TOKEN)
else:
LOGGER.info("Using long polling.")
# updater.start_polling(timeout=15, read_latency=4)
updater.start_polling(poll_interval=0.0,
timeout=10,
clean=True,
bootstrap_retries=-1,
read_latency=3.0)
updater.idle()
chat = update.effective_chat
del_msg = context.bot.send_message(
chat.id,
"<code>🔄 Running speedtest...</code>",
parse_mode=ParseMode.HTML)
test = speedtest.Speedtest()
test.get_best_server()
test.download()
test.upload()
test.results.share()
result = test.results.dict()
del_msg.delete()
update.effective_message.reply_text(
"<b>SpeedTest Results</b> \n\n"
"<b>Download:</b> "
f"<code>{speed_convert(result['download'])}</code> \n"
"<b>Upload:</b> "
f"<code>{speed_convert(result['upload'])}</code> \n"
"<b>Ping:</b> "
f"<code>{result['ping']}</code> \n"
"<b>ISP:</b> "
f"<code>{result['client']['isp']}</code>",
parse_mode=ParseMode.HTML)
SPEED_HANDLER = CommandHandler("speedtest",
speedtst,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(SPEED_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):
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)
text += "Batas maksimal pesan beruntun telah di setel menjadi `{}`.".format(status)
button.append([InlineKeyboardButton(text="➖", callback_data="set_flim=-|{}".format(chat_id)),
InlineKeyboardButton(text="Limit {}".format(limit), callback_data="set_flim=?|{}".format(chat_id)),
InlineKeyboardButton(text="➕", callback_data="set_flim=+|{}".format(chat_id))])
button.append([InlineKeyboardButton(text="{}".format(status), callback_data="set_flim=exec|{}".format(chat_id))])
button.append([InlineKeyboardButton(text="Kembali", callback_data="stngs_back({})".format(chat_id))])
query.message.edit_text(text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(button))
context.bot.answer_callback_query(query.id)
"""
__help__ = "antiflood_help"
__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)
# FLOOD_BTNSET_HANDLER = CallbackQueryHandler(FLOOD_EDITBTN, pattern=r"set_flim")
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)
# dispatcher.add_handler(FLOOD_BTNSET_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)
__mod_name__ = "Global Bans"
GBAN_HANDLER = CommandHandler(
"gban",
gban,
pass_args=True,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
UNGBAN_HANDLER = CommandHandler(
"ungban",
ungban,
pass_args=True,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GBAN_LIST = CommandHandler(
"gbanlist",
gbanlist,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GBAN_STATUS = CommandHandler("gbanstat", gbanstat, pass_args=True,
filters=Filters.group)
GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban)
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
