parse_mode=ParseMode.MARKDOWN,
reply_markup=InlineKeyboardMarkup(button))
context.bot.answer_callback_query(query.id)
"""
__help__ = "warns_help"
__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(Filters.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)
"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)
*Cat commands:*
- /dog: Get pictures of cute dogs
- /doghd: Get images of cute dogs in high definition
- /doggif: Get gifs of cute dogs
*Dog commands:*
- /cat: Get pictures of cute kittens
- /cathd: Get images of cute kittens in high definition
- /catgif: Get gifs of cute kittens
"""
__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",
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,
"{} 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 = DisableAbleRegexHandler("(?i)brb", afk, friendly="afk")
NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk)
# 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)
def get_lst_of_files(input_directory, output_lst):
filesinfolder = os.listdir(input_directory)
for file_name in filesinfolder:
current_file_name = os.path.join(input_directory, file_name)
if os.path.isdir(current_file_name):
return get_lst_of_files(current_file_name, output_lst)
output_lst.append(current_file_name)
return output_lst
__help__ = """
➩ /zip: reply to a telegram file to compress it in .zip format
➩ /unzip: reply to a telegram file to decompress it from the .zip format
"""
__mod_name__ = "ZIPPER"
ZIP_HANDLER = DisableAbleCommandHandler("zip",
_zip,
pass_args=True,
admin_ok=True)
UNZIP_HANDLER = DisableAbleCommandHandler("unzip",
_unzip,
pass_args=True,
admin_ok=True)
dispatcher.add_handler(ZIP_HANDLER)
dispatcher.add_handler(UNZIP_HANDLER)
__command_list__ = ["zip"]
__handlers__ = [ZIP_HANDLER, UNZIP_HANDLER]
__help__ = """
- /id: dapatkan ID grup saat ini. Jika digunakan dengan membalas pesan, dapatkan id pengguna itu.
- /runs: balas string acak dari larik balasan.
- /lari: sama seperti runs.
- /slap: menampar pengguna, atau ditampar jika bukan balasan.
- /time <tempat>: memberi waktu lokal di tempat yang ditentukan.
- /info: mendapatkan informasi tentang seorang pengguna.
- /stickerid: balas pesan stiker untuk mendapatkan id stiker
- /ping: mengecek kecepatan bot
- /markdownhelp: ringkasan singkat tentang cara kerja markdown di telegram - hanya dapat dipanggil dalam obrolan pribadi.
"""
__mod_name__ = "Lainnya"
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
IP_HANDLER = CommandHandler("ip", get_bot_ip, filters=Filters.chat(OWNER_ID))
TIME_HANDLER = CommandHandler("time", get_time_alt, pass_args=True)
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
LARI_HANDLER = DisableAbleCommandHandler("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)
@run_async
def weebify(update, context):
args = context.args
args = str(args)
string = ' '.join(args).lower()
for normiecharacter in string:
if normiecharacter in normiefont:
weebycharacter = weebyfont[normiefont.index(normiecharacter)]
string = string.replace(normiecharacter, weebycharacter)
message = update.effective_message
if message.reply_to_message:
message.reply_to_message.reply_text(string)
else:
message.reply_text(string)
__help__ = """
- /weebify <text>: returns a weebified text
"""
WEEBIFY_HANDLER = DisableAbleCommandHandler("weebify", weebify, pass_args=True)
dispatcher.add_handler(WEEBIFY_HANDLER)
__mod_name__ = "Weebify"
__command_list__ = ["weebify"]
__handlers__ = [WEEBIFY_HANDLER]
__help__ = "admin_help"
__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)
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(ADMINLIST_HANDLER)
def tts(update: Update, context: CallbackContext):
args = context.args
current_time = datetime.strftime(datetime.now(), "%d.%m.%Y %H:%M:%S")
filename = datetime.now().strftime("%d%m%y-%H%M%S%f")
reply = " ".join(args)
update.message.chat.send_action(ChatAction.RECORD_AUDIO)
lang = "ml"
tts = gTTS(reply, lang)
tts.save("k.mp3")
with open("k.mp3", "rb") as f:
linelist = list(f)
linecount = len(linelist)
if linecount == 1:
update.message.chat.send_action(ChatAction.RECORD_AUDIO)
lang = "en"
tts = gTTS(reply, lang)
tts.save("k.mp3")
with open("k.mp3", "rb") as speech:
update.message.reply_voice(speech, quote=False)
__help__ = """
• `/tts <text>`*:* convert text to speech
"""
TTS_HANDLER = DisableAbleCommandHandler("tts", tts, pass_args=True)
dispatcher.add_handler(TTS_HANDLER)
__mod_name__ = "Text to speech"
__command_list__ = ["tts"]
__handlers__ = [TTS_HANDLER]
if conn:
text = tl(update.effective_message, "Penghapus pesan biru telah di *non-aktifka*n di *{}*.").format(chat_name)
else:
text = tl(update.effective_message, "Penghapus pesan biru telah di *non-aktifkan*.")
send_message(update.effective_message, text, parse_mode="markdown")
elif val == "yes" or val == "ya" or val == "on":
sql.set_cleanbt(chat_id, True)
if conn:
text = tl(update.effective_message, "Penghapus pesan biru telah di *aktifkan* di *{}*.").format(chat_name)
else:
text = tl(update.effective_message, "Penghapus pesan biru telah di *aktifkan*.")
send_message(update.effective_message, text, parse_mode="markdown")
else:
send_message(update.effective_message, tl(update.effective_message, "Argumen tidak dikenal - harap gunakan 'yes', atau 'no'."))
else:
send_message(update.effective_message, tl(update.effective_message, "Pengaturan untuk penghapus pesan biru saat ini di {}: *{}*").format(chat_name, "Enabled" if sql.is_enable(chat_id) else "Disabled"), parse_mode="markdown")
__help__ = "cleaner_help"
__mod_name__ = "Cleaner"
SET_CLEAN_BLUE_TEXT_HANDLER = DisableAbleCommandHandler("cleanbluetext", set_blue_text_must_click, pass_args=True)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group, clean_blue_text_must_click)
dispatcher.add_handler(SET_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, 15)
if bio and me:
return tl(
chat_id,
"<b>Tentang pengguna:</b>\n{me}\n<b>Apa yang orang lain katakan:</b>\n{bio}"
).format(me=me, bio=bio)
elif bio:
return tl(chat_id,
"<b>Apa yang orang lain katakan:</b>\n{bio}\n").format(
me=me, bio=bio)
elif me:
return tl(chat_id, "<b>Tentang pengguna:</b>\n{me}").format(me=me,
bio=bio)
else:
return ""
__help__ = "userinfo_help"
__mod_name__ = "Bios and About"
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)
else:
query.answer("You are not allowed to use this.")
__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,
reply = "Couldn't find any lyrics for that song!"
else:
reply = "Song not found!"
if len(reply) > 4090:
with open("lyrics.txt", 'w') as f:
f.write(f"{reply}\n\n\nOwO UwU OmO")
with open("lyrics.txt", 'rb') as f:
msg.reply_document(
document=f,
caption=
"Message length exceeded max limit! Sending as a text file."
)
else:
msg.reply_text(reply)
__help__ = """
Want to get the lyrics of your favorite songs straight from the app? This module is perfect for that!
*Available commands:*
- /lyrics <song>: returns the lyrics of that song.
You can either enter just the song name or both the artist and song name.
"""
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True)
dispatcher.add_handler(LYRICS_HANDLER)
__mod_name__ = "Songslyrics"
__command_list__ = ["lyrics"]
__handlers__ = [LYRICS_HANDLER]
result = []
result.append(' '.join([s for s in data]))
for pos, symbol in enumerate(data[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = data[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
__help__ = "memes_help"
__mod_name__ = "Memes and etc."
COPYPASTA_HANDLER = DisableAbleCommandHandler("cp", copypasta, pass_args=True)
CLAPMOJI_HANDLER = DisableAbleCommandHandler("clap", clapmoji, pass_args=True)
BMOJI_HANDLER = DisableAbleCommandHandler("bify", bmoji, pass_args=True)
MOCK_HANDLER = DisableAbleCommandHandler("mock",
spongemocktext,
pass_args=True)
OWO_HANDLER = DisableAbleCommandHandler("owo", owo, pass_args=True)
FORBES_HANDLER = DisableAbleCommandHandler("forbes", forbesify, pass_args=True)
STRETCH_HANDLER = DisableAbleCommandHandler("stretch", stretch, pass_args=True)
VAPOR_HANDLER = DisableAbleCommandHandler("vapor", vapor, pass_args=True)
ZALGO_HANDLER = DisableAbleCommandHandler("zalgofy", zalgotext, pass_args=True)
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True)
CHINESEMEMES_HANDLER = DisableAbleCommandHandler("dllm",
chinesememes,
pass_args=True)
DEEPFRY_HANDLER = DisableAbleCommandHandler("deepfry",
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 = 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)
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))
def changed(update, context):
message = update.effective_message
message.reply_text("Use /addfilter to add filters with Daisy")
__help__ = "filters_help"
__mod_name__ = "Filters"
FILTER_HANDLER = CommandHandler("addfilter", filters)
CHANGE_HANDLER = CommandHandler("filter", changed)
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(CHANGE_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
- /cos: Cosine `/cos pi`
- /sin: Sine `/sin 0`
- /tan: Tangent `/tan 0`
- /arccos: Inverse Cosine `/arccos 1`
- /arcsin: Inverse Sine `/arcsin 0`
- /arctan: Inverse Tangent `/arctan 0`
- /abs: Absolute Value `/abs -1`
- /log: Logarithm `/log 2l8`
__Keep in mind__: To find the tangent line of a function at a certain x value, send the request as c|f(x) where c is the given x value and f(x) is the function expression, the separator is a vertical bar '|'. See the table above for an example request.
To find the area under a function, send the request as c:d|f(x) where c is the starting x value, d is the ending x value, and f(x) is the function under which you want the curve between the two x values.
To compute fractions, enter expressions as numerator(over)denominator. For example, to process 2/4 you must send in your expression as 2(over)4. The result expression will be in standard math notation (1/2, 3/4).
"""
__mod_name__ = "MATHS"
SIMPLIFY_HANDLER = DisableAbleCommandHandler("math", simplify, pass_args=True)
FACTOR_HANDLER = DisableAbleCommandHandler("factor", factor, pass_args=True)
DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive, pass_args=True)
INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate",
integrate,
pass_args=True)
ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes, pass_args=True)
TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent, pass_args=True)
AREA_HANDLER = DisableAbleCommandHandler("area", area, pass_args=True)
COS_HANDLER = DisableAbleCommandHandler("cos", cos, pass_args=True)
SIN_HANDLER = DisableAbleCommandHandler("sin", sin, pass_args=True)
TAN_HANDLER = DisableAbleCommandHandler("tan", tan, pass_args=True)
ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos, pass_args=True)
ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin, pass_args=True)
ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan, pass_args=True)
ABS_HANDLER = DisableAbleCommandHandler("abs", abs, pass_args=True)
except:
update.effective_message.reply_text("Reboot Gagal!",
parse_mode=ParseMode.MARKDOWN)
@run_async
def executor(bot: Bot, update: Update):
msg = update.effective_message
if msg.text:
args = msg.text.split(None, 1)
code = args[1]
chat = msg.chat.id
try:
exec(code)
except Exception as error:
bot.send_message(chat,
"<b>Gagal:</b> {}".format(error),
parse_mode=ParseMode.HTML,
reply_to_message_id=msg.message_id)
REBOOT_HANDLER = DisableAbleCommandHandler("emreboot",
reboot,
filters=Filters.user(OWNER_ID))
EXEC_HANDLER = DisableAbleCommandHandler("emil",
executor,
filters=Filters.user(OWNER_ID))
#dispatcher.add_handler(REBOOT_HANDLER)
dispatcher.add_handler(EXEC_HANDLER)
msg.edit_text('⚰')
__help__ = """
- /love ❣️
- /hack 👨💻
- /bombs 💣
- /moonanimation 🌚
- /clockanimation 🕛
- /earthanimation 🌍
- /blockanimation 🟥
- /kill ⚰
- /police 🚓
"""
KILL_HANDLER = DisableAbleCommandHandler("kill", kill)
LOVE_HANDLER = DisableAbleCommandHandler("love", love)
HACK_HANDLER = DisableAbleCommandHandler("hack", hack)
BOMBS_HANDLER = DisableAbleCommandHandler("bombs", bombs)
MOONANIMATION_HANDLER = DisableAbleCommandHandler("moonanimation",
moonanimation)
CLOCKANIMATION_HANDLER = DisableAbleCommandHandler("clockanimation",
clockanimation)
BLOCKANIMATION_HANDLER = DisableAbleCommandHandler("blockanimation",
blockanimation)
EARTHANIMATION_HANDLER = DisableAbleCommandHandler("earthanimation",
earthanimation)
dispatcher.add_handler(KILL_HANDLER)
dispatcher.add_handler(LOVE_HANDLER)
dispatcher.add_handler(HACK_HANDLER)
dispatcher.add_handler(BOMBS_HANDLER)
@run_async
def stats(bot: Bot, update: Update):
send_message(
update.effective_message,
tl(update.effective_message, "Statistik saat ini:\n") +
"\n".join([mod.__stats__() for mod in STATS]))
# /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,
pass
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)
imglinks = []
counter = 0
pattern = r'^,\[\"(.*[.png|.jpg|.jpeg])\",[0-9]+,[0-9]+\]$'
oboi = re.findall(pattern, decoded, re.I | re.M)
for imglink in oboi:
counter += 1
imglinks.append(imglink)
if counter >= int(lim):
break
return imglinks
__help__ = """
- /reverse: Does a reverse image search of the media which it was replied to.
"""
REVERSE_HANDLER = DisableAbleCommandHandler("reverse",
reverse,
pass_args=True,
admin_ok=True)
dispatcher.add_handler(REVERSE_HANDLER)
__mod_name__ = "Image Lookup"
__command_list__ = ["reverse"]
__handlers__ = [REVERSE_HANDLER]
@run_async
def log(update, context):
message = update.effective_message
eventdict = message.to_dict()
jsondump = json.dumps(eventdict, indent=4)
send_message(update.effective_message, jsondump)
def deEmojify(inputString):
return inputString.encode('ascii', 'ignore').decode('ascii')
__help__ = "exclusive_help"
__mod_name__ = "🤖 Dora 🤖"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
#GETSTICKER_HANDLER = DisableAbleCommandHandler("getsticker", getsticker)
PING_HANDLER = DisableAbleCommandHandler("ping", ping)
STIKER_HANDLER = CommandHandler("stiker", stiker, filters=Filters.user(OWNER_ID))
FILE_HANDLER = CommandHandler("file", file, filters=Filters.user(OWNER_ID))
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)
lok.append(
data.get('SupplementalAdminAreas')[x].get('LocalizedName'))
lok.append(data.get('Country').get('LocalizedName'))
teks = "*Cuaca di {} saat ini*\n".format(data.get('LocalizedName'))
teks += "{}\n".format(cuaca)
teks += "*Lokasi:* `{}`\n\n".format(", ".join(lok))
teks += "Untuk lebih lanjut silahkan cek cuacanya [disini]({}) atau [disini]({})".format(
datas.get('MobileLink'), datas.get('Link'))
#try:
bot.send_photo(chat_id,
photo=datas.get('Photos')[0].get('LandscapeLink'),
caption=teks,
parse_mode="markdown",
reply_to_message_id=message.message_id)
#except:
# update.message.reply_text(teks, parse_mode="markdown", disable_web_page_preview=True)
__help__ = """
- /cuaca <kota>: mendapatkan info cuaca di tempat tertentu
"""
__mod_name__ = "Cuaca"
CUACA_HANDLER = DisableAbleCommandHandler("cuaca", accuweather, pass_args=True)
# ACCUWEATHER_HANDLER = DisableAbleCommandHandler("accuweather", accuweather, pass_args=True)
dispatcher.add_handler(CUACA_HANDLER)
# dispatcher.add_handler(ACCUWEATHER_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):
blacklisted = sql.num_blacklist_chat_filters(chat_id)
return tl(user_id, "Ada `{}` kata daftar hitam.").format(blacklisted)
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)
"\n<b>Admin:</b> {}" \
"\n<b>User:</b> {} (<code>{}</code>)".format(html.escape(chat.title),
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)
@run_async
def stats(update, context):
send_message(
update.effective_message,
tl(update.effective_message, "Statistik saat ini:\n") +
"\n".join([mod.__stats__() for mod in STATS]))
# /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))
PASTE_HANDLER = CommandHandler("paste", paste, pass_args=True)
GET_PASTE_HANDLER = CommandHandler("getpaste",
get_paste_content,
pass_args=True)
PASTE_STATS_HANDLER = CommandHandler("pastestats",
get_paste_stats,
pass_args=True)
ECHO_HANDLER = CommandHandler("echo", echo, filters=Filters.user(OWNER_ID))
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)
SUDO_LIST_HANDLER = CommandHandler("sudolist",
addedimg = Image.new('RGBA', [x + value.size[0] + tracking.size[0], y], (0, 0, 0))
addedimg.paste(image, [0, 0])
addedimg.paste(tracking, [x, 0])
addedimg.paste(value, [x + tracking.size[0], 0])
image = addedimg
x = x + value.size[0] + tracking.size[0]
maxsize = 1024, 896
if image.size[0] > maxsize[0]:
image.thumbnail(maxsize, Image.ANTIALIAS)
# put processed image in a buffer and then upload cause async
with BytesIO() as buffer:
buffer.name = 'image.png'
image.save(buffer, 'PNG')
buffer.seek(0)
context.bot.send_sticker(chat_id=message.chat_id, sticker=buffer)
PLET_HANDLER = DisableAbleCommandHandler("plet", plet)
dispatcher.add_handler(PLET_HANDLER)
__help__ = """
`/plet` *:-* text get funny emojify
"""
__mod_name__ = "Plet"
__handlers__ = [
PLET_HANDLER
]
blacklisted = sql.num_stickers_chat_filters(chat_id)
return tl(user_id, "Ada `{}` daftar hitam stiker.").format(blacklisted)
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)
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)
