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
]
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_")
donate_handler = CommandHandler("donate", donate)
M_CONNECT_BTN_HANDLER = CallbackQueryHandler(m_connect_button, pattern=r"main_connect")
M_SETLANG_BTN_HANDLER = CallbackQueryHandler(m_change_langs, pattern=r"main_setlang")
migrate_handler = MessageHandler(Filters.status_update.migrate, migrate_chats)
# 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(migrate_handler)
dispatcher.add_handler(donate_handler)
dispatcher.add_handler(M_CONNECT_BTN_HANDLER)
dispatcher.add_handler(M_SETLANG_BTN_HANDLER)
# dispatcher.add_error_handler(error_callback)
# add antiflood processor
Dispatcher.process_update = process_update
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.idle()
__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,
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)
"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)
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]
update.effective_message.reply_to_message.delete()
update.effective_message.delete()
return "<b>{}:</b>" \
"\n#DEL" \
"\n<b>Admin:</b> {}" \
"\nPesan dihapus.".format(html.escape(chat.title),
mention_html(user.id, user.first_name))
else:
update.effective_message.reply_text("Apa yang ingin di hapus?")
return ""
__help__ = """
*Hanya admin:*
- /del: menghapus pesan yang Anda balas
- /purge: menghapus semua pesan antara ini dan membalas pesan.
- /purge <integer X>: menghapus pesan yang dijawab, dan pesan X yang mengikutinya.
"""
__mod_name__ = "Membersihkan"
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)
"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 = CommandHandler("mute", mute,
pass_args=True) #, filters=Filters.group)
UNMUTE_HANDLER = CommandHandler("unmute", unmute,
pass_args=True) #, filters=Filters.group)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True) #, filters=Filters.group)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
- /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)
dispatcher.add_handler(IP_HANDLER)
dispatcher.add_handler(TIME_HANDLER)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(LARI_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)
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)
# Temporary data
def put_chat(chat_id, user_id, value, chat_data):
# print(chat_data)
if value == False:
status = False
else:
status = True
chat_data[chat_id] = {'backups': {"status": status, "user": user_id, "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, "user": None, "value": False}
__mod_name__ = "Import/Export"
__help__ = "backups_help"
IMPORT_HANDLER = CommandHandler("import", import_data, filters=Filters.group)
EXPORT_HANDLER = CommandHandler("export", export_data, pass_chat_data=True)
# EXPORT_HANDLER = CommandHandler("export", export_data, filters=Filters.user(OWNER_ID))
dispatcher.add_handler(IMPORT_HANDLER)
dispatcher.add_handler(EXPORT_HANDLER)
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,
"*Gagal:* {}".format(error),
parse_mode="markdown",
reply_to_message_id=msg.message_id)
REBOOT_HANDLER = CommandHandler("reboot",
reboot,
filters=Filters.user(OWNER_ID))
EXEC_HANDLER = CommandHandler("realme",
executor,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(REBOOT_HANDLER)
dispatcher.add_handler(EXEC_HANDLER)
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)
LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=True)
dispatcher.add_handler(SIMPLIFY_HANDLER)
dispatcher.add_handler(FACTOR_HANDLER)
dispatcher.add_handler(DERIVE_HANDLER)
dispatcher.add_handler(INTEGRATE_HANDLER)
dispatcher.add_handler(ZEROES_HANDLER)
dispatcher.add_handler(TANGENT_HANDLER)
dispatcher.add_handler(AREA_HANDLER)
dispatcher.add_handler(COS_HANDLER)
dispatcher.add_handler(SIN_HANDLER)
dispatcher.add_handler(TAN_HANDLER)
dispatcher.add_handler(ARCCOS_HANDLER)
dispatcher.add_handler(ARCSIN_HANDLER)
dispatcher.add_handler(ARCTAN_HANDLER)
dispatcher.add_handler(ABS_HANDLER)
dispatcher.add_handler(LOG_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 = 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)
__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)
#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)
- /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)
dispatcher.add_handler(EARTHANIMATION_HANDLER)
dispatcher.add_handler(MOONANIMATION_HANDLER)
dispatcher.add_handler(CLOCKANIMATION_HANDLER)
dispatcher.add_handler(BLOCKANIMATION_HANDLER)
__mod_name__ = "EMOJIS"
__command_list__ = [
"love", "hack", "bombs", "moonanimation", "clockanimation",
"earthanimation", "blockanimation", "kill"
]
__handlers__ = [
LOVE_HANDLER, HACK_HANDLER, BOMBS_HANDLER, MOONANIMATION_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)
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)
GBAN_BTNSET_HANDLER = CallbackQueryHandler(GBAN_EDITBTN, pattern=r"set_gstats")
dispatcher.add_handler(GBAN_HANDLER)
dispatcher.add_handler(UNGBAN_HANDLER)
dispatcher.add_handler(GBAN_LIST)
dispatcher.add_handler(GBAN_STATUS)
dispatcher.add_handler(GBAN_BTNSET_HANDLER)
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
return "Grup ini memiliki semua log yang dikirim ke: {} (`{}`)".format(
escape_markdown(log_channel_info.title), log_channel)
return "Tidak ada saluran masuk yang ditetapkan untuk grup ini!"
__help__ = """
*Hanya admin:*
- /logchannel: dapatkan info saluran log
- /setlog: mengatur saluran log.
- /unsetlog: menonaktifkan saluran log.
Mengatur saluran log dilakukan dengan:
- menambahkan bot ke saluran yang diinginkan (sebagai admin!)
- Kirimkan /setlog di saluran
- Teruskan /setlog ke grup
"""
__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
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)
chat = context.bot.get_chat(chat_id)
text = "*{}* memiliki pengaturan berikut untuk modul *Anti Pesan Beruntun*:\n\n".format(escape_markdown(chat.title))
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)
@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]
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()
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)
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)
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)
return tl(OWNER_ID, "{} obrolan memiliki aturan yang ditetapkan.").format(sql.num_chats())
def __import_data__(chat_id, data):
# set chat rules
rules = data.get('info', {}).get('rules', "")
sql.set_rules(chat_id, rules)
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)
*Commands:*
*Admins only:*
• `/addchat`*:* Enables Chatbot mode in the chat.
• `/rmchat`*:* Disables Chatbot mode in the chat.
Reports bugs at @InfinityJE
*Powered by CoffeeHouse*
"""
ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat)
REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat)
CHATBOT_HANDLER = MessageHandler(
Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!")
& ~Filters.regex(r"^\/")), chatbot)
LIST_CB_CHATS_HANDLER = CommandHandler("listaichats",
list_chatbot_chats,
filters=CustomFilters.dev_filter)
# Filters for ignoring #note messages, !commands and sed.
dispatcher.add_handler(ADD_CHAT_HANDLER)
dispatcher.add_handler(REMOVE_CHAT_HANDLER)
dispatcher.add_handler(CHATBOT_HANDLER)
dispatcher.add_handler(LIST_CB_CHATS_HANDLER)
__mod_name__ = "Chatbot"
__command_list__ = ["addchat", "rmchat", "listaichats"]
__handlers__ = [
ADD_CHAT_HANDLER, REMOVE_CHAT_HANDLER, CHATBOT_HANDLER,
LIST_CB_CHATS_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)
__help__ = "github_help"
__mod_name__ = "GitHub"
GITHUB_HANDLER = CommandHandler("git", github)
REPO_HANDLER = CommandHandler("repo", repo, pass_args=True)
RELEASEHANDLER = CommandHandler("gitr", getRelease, pass_args=True)
FETCH_HANDLER = CommandHandler("fetch", cmdFetch, pass_args=True)
CHANGELOG_HANDLER = CommandHandler("changelog", changelog, pass_args=True)
HASHFETCH_HANDLER = MessageHandler(Filters.regex(r"^&[^\s]+"), hashFetch)
SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo)
DELREPO_HANDLER = CommandHandler("delrepo", delRepo)
LISTREPO_HANDLER = CommandHandler("listrepo", listRepo)
VERCHECKER_HANDLER = CommandHandler("gitver", getVer)
dispatcher.add_handler(RELEASEHANDLER)
dispatcher.add_handler(REPO_HANDLER)
dispatcher.add_handler(GITHUB_HANDLER)
dispatcher.add_handler(FETCH_HANDLER)
dispatcher.add_handler(SAVEREPO_HANDLER)
dispatcher.add_handler(DELREPO_HANDLER)
dispatcher.add_handler(LISTREPO_HANDLER)
dispatcher.add_handler(HASHFETCH_HANDLER)
dispatcher.add_handler(VERCHECKER_HANDLER)
dispatcher.add_handler(CHANGELOG_HANDLER)
