ADMINLIST_HANDLER = DisableAbleCommandHandler("admins", adminlist)
PIN_HANDLER = CommandHandler("pin", pin, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
INVITE_HANDLER = DisableAbleCommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote)
ADMIN_CACHE_HANDLER = CommandHandler(
"admincache", admincache, filters=Filters.group
)
SET_TITLE_HANDLER = CommandHandler("title", set_title)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
dispatcher.add_handler(PROMOTE_HANDLER)
dispatcher.add_handler(ADMIN_CACHE_HANDLER)
dispatcher.add_handler(DEMOTE_HANDLER)
dispatcher.add_handler(SET_TITLE_HANDLER)
__mod_name__ = "Admin"
__command_list__ = ["adminlist", "admins", "invitelink", "promote", "demote", "admincache"]
__handlers__ = [
ADMINLIST_HANDLER, PIN_HANDLER, UNPIN_HANDLER, INVITE_HANDLER,
PROMOTE_HANDLER, DEMOTE_HANDLER, ADMIN_CACHE_HANDLER, SET_TITLE_HANDLER
]
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__ = f"""
*Commands:*
• /reverse: Does a reverse image search of the media which it was replied to.
Reports bugs at @HackfreaksSupport
"""
__mod_name__ = "Image Search"
REVERSE_HANDLER = DisableAbleCommandHandler(
"reverse", reverse, pass_args=True, admin_ok=True
)
dispatcher.add_handler(REVERSE_HANDLER)
is_blacklisted = sql.is_user_blacklisted(user_id)
text = "Blacklisted: <b>{}</b>"
if user_id in [777000, 1087968824]:
return ""
if user_id == dispatcher.bot.id:
return ""
if int(user_id) in DRAGONS + TIGERS + WOLVES:
return ""
if is_blacklisted:
text = text.format("Yes")
reason = sql.get_reason(user_id)
if reason:
text += f"\nReason: <code>{reason}</code>"
else:
text = text.format("No")
return text
BL_HANDLER = CommandHandler("ignore", bl_user)
UNBL_HANDLER = CommandHandler("notice", unbl_user)
BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users)
dispatcher.add_handler(BL_HANDLER)
dispatcher.add_handler(UNBL_HANDLER)
dispatcher.add_handler(BLUSERS_HANDLER)
__mod_name__ = "Blacklisting Users"
__handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER]
except DisambiguationError as e:
update.message.reply_text(
"Disambiguated pages found! Adjust your query accordingly.\n<i>{}</i>"
.format(e),
parse_mode=ParseMode.HTML)
except PageError as e:
update.message.reply_text("<code>{}</code>".format(e),
parse_mode=ParseMode.HTML)
if res:
result = f"<b>{search}</b>\n\n"
result += f"<i>{res}</i>\n"
result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>"""
if len(result) > 4000:
with open("result.txt", 'w') as f:
f.write(f"{result}\n\nUwU OwO OmO UmU")
with open("result.txt", 'rb') as f:
context.bot.send_document(
document=f,
filename=f.name,
reply_to_message_id=update.message.message_id,
chat_id=update.effective_chat.id,
parse_mode=ParseMode.HTML)
else:
update.message.reply_text(result,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
dispatcher.add_handler(WIKI_HANDLER)
def load(update: Update, context: CallbackContext):
message = update.effective_message
text = message.text.split(" ", 1)[1]
load_messasge = message.reply_text(
f"Attempting to load module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
try:
imported_module = importlib.import_module("Hackfreaks.modules." + text)
except:
load_messasge.edit_text("Does that module even exist?")
return
if not hasattr(imported_module, "__mod_name__"):
imported_module.__mod_name__ = imported_module.__name__
if not imported_module.__mod_name__.lower() in IMPORTED:
IMPORTED[imported_module.__mod_name__.lower()] = imported_module
else:
load_messasge.edit_text("Module already loaded.")
return
if "__handlers__" in dir(imported_module):
handlers = imported_module.__handlers__
for handler in handlers:
if type(handler) != tuple:
dispatcher.add_handler(handler)
else:
handler_name, priority = handler
dispatcher.add_handler(handler_name, priority)
else:
IMPORTED.pop(imported_module.__mod_name__.lower())
load_messasge.edit_text("The module cannot be loaded.")
return
if hasattr(imported_module, "__help__") and imported_module.__help__:
HELPABLE[imported_module.__mod_name__.lower()] = imported_module
# Chats to migrate on chat_migrated events
if hasattr(imported_module, "__migrate__"):
MIGRATEABLE.append(imported_module)
if hasattr(imported_module, "__stats__"):
STATS.append(imported_module)
if hasattr(imported_module, "__user_info__"):
USER_INFO.append(imported_module)
if hasattr(imported_module, "__import_data__"):
DATA_IMPORT.append(imported_module)
if hasattr(imported_module, "__export_data__"):
DATA_EXPORT.append(imported_module)
if hasattr(imported_module, "__chat_settings__"):
CHAT_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
if hasattr(imported_module, "__user_settings__"):
USER_SETTINGS[imported_module.__mod_name__.lower()] = imported_module
load_messasge.edit_text(
"Successfully loaded module : <b>{}</b>".format(text),
parse_mode=ParseMode.HTML)
for i in reversed(range(5)):
sent_msg.edit_text(sent_msg_text + str(i + 1))
sleep(1)
sent_msg.edit_text("Restarted.")
os.system('restart.bat')
os.execv('start.bat', sys.argv)
@run_async
@dev_plus
def restart(update: Update, context: CallbackContext):
update.effective_message.reply_text(
"Starting a new instance and shutting down this one")
os.system('restart.bat')
os.execv('start.bat', sys.argv)
LEAVE_HANDLER = CommandHandler("leave", leave)
GITPULL_HANDLER = CommandHandler("gitpull", gitpull)
RESTART_HANDLER = CommandHandler("reboot", restart)
dispatcher.add_handler(LEAVE_HANDLER)
dispatcher.add_handler(GITPULL_HANDLER)
dispatcher.add_handler(RESTART_HANDLER)
__mod_name__ = "Dev"
__handlers__ = [LEAVE_HANDLER, GITPULL_HANDLER, RESTART_HANDLER]
else:
if int(userc_id) == int(user_id):
return
res = "{} is afk.\nReason: <code>{}</code>".format(
html.escape(fst_name), html.escape(user.reason))
update.effective_message.reply_text(res, parse_mode="html")
__help__ = """
• `/afk <reason>`*:* mark yourself as AFK(away from keyboard).
• `brb <reason>`*:* same as the afk command - but not a command.
When marked as AFK, any mentions will be replied to with a message to say you're not available!
"""
AFK_HANDLER = DisableAbleCommandHandler("afk", afk)
AFK_REGEX_HANDLER = DisableAbleMessageHandler(
Filters.regex(r"^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)
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)
__mod_name__ = "AFK"
__command_list__ = ["afk"]
__handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP),
(NO_AFK_HANDLER, AFK_GROUP),
(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
filters=Filters.group)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
welcomemute,
filters=Filters.group)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
cleanservice,
filters=Filters.group)
CLEAN_WELCOME = CommandHandler("cleanwelcome",
clean_welcome,
filters=Filters.group)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help)
WELCOME_MUTE_HELP = CommandHandler("welcomemutehelp", welcome_mute_help)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button,
pattern=r"user_join_")
dispatcher.add_handler(NEW_MEM_HANDLER)
dispatcher.add_handler(LEFT_MEM_HANDLER)
dispatcher.add_handler(WELC_PREF_HANDLER)
dispatcher.add_handler(GOODBYE_PREF_HANDLER)
dispatcher.add_handler(SET_WELCOME)
dispatcher.add_handler(SET_GOODBYE)
dispatcher.add_handler(RESET_WELCOME)
dispatcher.add_handler(RESET_GOODBYE)
dispatcher.add_handler(CLEAN_WELCOME)
dispatcher.add_handler(WELCOME_HELP)
dispatcher.add_handler(WELCOMEMUTE_HANDLER)
dispatcher.add_handler(CLEAN_SERVICE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(WELCOME_MUTE_HELP)
__mod_name__ = "Welcomes/Goodbyes"
"""
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue",
set_blue_text_must_click)
ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue", add_bluetext_ignore)
REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue",
remove_bluetext_ignore)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"gignoreblue", add_bluetext_ignore_global)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list)
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(ADD_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER)
dispatcher.add_handler(LIST_CLEAN_BLUE_TEXT_HANDLER)
dispatcher.add_handler(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)
__mod_name__ = "Bluetext Cleaning"
__handlers__ = [
SET_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_HANDLER, ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER,
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER, LIST_CLEAN_BLUE_TEXT_HANDLER,
(CLEAN_BLUE_TEXT_HANDLER, BLUE_TEXT_CLEAN_GROUP)
]
*What is that health thingy?*
Come and see [HP System explained](https://t.me/indianbotupdate/4)
"""
SET_BIO_HANDLER = DisableAbleCommandHandler("setbio", set_about_bio)
GET_BIO_HANDLER = DisableAbleCommandHandler("bio", about_bio)
STATS_HANDLER = CommandHandler("stats", stats)
ID_HANDLER = DisableAbleCommandHandler("id", get_id)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid)
INFO_HANDLER = DisableAbleCommandHandler(("info", "book"), info)
SET_ABOUT_HANDLER = DisableAbleCommandHandler("setme", set_about_me)
GET_ABOUT_HANDLER = DisableAbleCommandHandler("me", about_me)
dispatcher.add_handler(STATS_HANDLER)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(INFO_HANDLER)
dispatcher.add_handler(SET_BIO_HANDLER)
dispatcher.add_handler(GET_BIO_HANDLER)
dispatcher.add_handler(SET_ABOUT_HANDLER)
dispatcher.add_handler(GET_ABOUT_HANDLER)
__mod_name__ = "Info"
__command_list__ = ["setbio", "bio", "setme", "me", "info"]
__handlers__ = [
ID_HANDLER, GIFID_HANDLER, INFO_HANDLER, SET_BIO_HANDLER, GET_BIO_HANDLER,
SET_ABOUT_HANDLER, GET_ABOUT_HANDLER, STATS_HANDLER
]
• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/dban` <userhandle>*:* bans a user and deletes the message
• `/sban` <userhandle>*:* silently bans the user
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/kick <userhandle>`*:* Kicks a user out of the group, (via handle, or reply)
• `/dkick` <userhandle>*:* Kicks a user and deletes the message.
"""
BAN_HANDLER = CommandHandler("ban", ban)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban)
KICK_HANDLER = CommandHandler("kick", kick)
UNBAN_HANDLER = CommandHandler("unban", unban)
ROAR_HANDLER = CommandHandler("roar", selfunban)
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(ROAR_HANDLER)
dispatcher.add_handler(KICKME_HANDLER)
__mod_name__ = "Restrictions"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, KICK_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
KICKME_HANDLER
]
chat_id=query.message.chat_id,
parse_mode=ParseMode.HTML)
query.answer("🛑 Failed to delete message!")
__help__ = """
• `/report <reason>`*:* reply to a message to report it to admins.
• `@admin`*:* reply to a message to report it to admins.
*NOTE:* Neither of these will get triggered if used by admins.
*Admins only:*
• `/reports <on/off>`*:* change report setting, or view current status.
• If done in pm, toggles your status.
• If in group, toggles that groups's status.
"""
SETTING_HANDLER = CommandHandler("reports", report_setting)
REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group)
ADMIN_REPORT_HANDLER = MessageHandler(Filters.regex(r"(?i)@admin(s)?"), report)
REPORT_BUTTON_USER_HANDLER = CallbackQueryHandler(buttons, pattern=r"report_")
dispatcher.add_handler(REPORT_BUTTON_USER_HANDLER)
dispatcher.add_handler(SETTING_HANDLER)
dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP)
dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP)
__mod_name__ = "Reporting"
__handlers__ = [(REPORT_HANDLER, REPORT_GROUP),
(ADMIN_REPORT_HANDLER, REPORT_GROUP), (SETTING_HANDLER)]
• *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__ = "Anti-Flood"
FLOOD_BAN_HANDLER = MessageHandler(
Filters.all & ~Filters.status_update & Filters.group, check_flood)
SET_FLOOD_HANDLER = CommandHandler("setflood",
set_flood,
filters=Filters.group)
SET_FLOOD_MODE_HANDLER = CommandHandler(
"setfloodmode", set_flood_mode, pass_args=True) #, filters=Filters.group)
FLOOD_QUERY_HANDLER = CallbackQueryHandler(flood_button,
pattern=r"unmute_flooder")
FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group)
dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP)
dispatcher.add_handler(FLOOD_QUERY_HANDLER)
dispatcher.add_handler(SET_FLOOD_HANDLER)
dispatcher.add_handler(SET_FLOOD_MODE_HANDLER)
dispatcher.add_handler(FLOOD_HANDLER)
__handlers__ = [(FLOOD_BAN_HANDLER, FLOOD_GROUP), SET_FLOOD_HANDLER,
FLOOD_HANDLER, SET_FLOOD_MODE_HANDLER]
speed.download()
speed.upload()
replymsg = 'SpeedTest Results:'
if query.data == 'speedtest_image':
speedtest_image = speed.results.share()
update.effective_message.reply_photo(photo=speedtest_image,
caption=replymsg)
msg.delete()
elif query.data == 'speedtest_text':
result = speed.results.dict()
replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`"
update.effective_message.edit_text(replymsg,
parse_mode=ParseMode.MARKDOWN)
else:
query.answer(
"You are required to join Heroes Association to use this command.")
SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz)
SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler(speedtestxyz_callback,
pattern='speedtest_.*')
dispatcher.add_handler(SPEED_TEST_HANDLER)
dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER)
__mod_name__ = "SpeedTest"
__command_list__ = ["speedtest"]
__handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER]
Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \
you and your groups by removing spam flooders as quickly as possible.
*Note:* Users can appeal gbans or report spammers at @{SUPPORT_CHAT}
This also integrates @Spamwatch API to remove Spammers as much as possible from your chatroom!
*What is SpamWatch?*
SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/f584b643c6f4be0b1de53.jpg)
Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group.
*Note:* Users can appeal spamwatch bans at @SpamwatchSupport
"""
GBAN_HANDLER = CommandHandler("gban", gban)
UNGBAN_HANDLER = CommandHandler("ungban", ungban)
GBAN_LIST = CommandHandler("gbanlist", gbanlist)
GBAN_STATUS = CommandHandler("spamprotection", gbanstat, 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)
__mod_name__ = "SpamProtection"
__handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS]
if STRICT_GBAN: # enforce GBANS if this is set
dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP)
__handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
__help__ = """
• `/hitme`*:* hits the user who issued the command
*Admins only:*
• `/ban <userhandle>`*:* bans a user. (via handle, or reply)
• `/tban <userhandle> x(m/h/d)`*:* bans a user for `x` time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
• `/unban <userhandle>`*:* unbans a user. (via handle, or reply)
• `/hit <userhandle>`*:* Hit a user out of the group, (via handle, or reply)
"""
BAN_HANDLER = CommandHandler("ban", ban)
TEMPBAN_HANDLER = CommandHandler(["tban"], temp_ban)
HIT_HANDLER = CommandHandler("hit", hit)
UNBAN_HANDLER = CommandHandler("unban", unban)
ROAR_HANDLER = CommandHandler("roar", selfunban)
HITME_HANDLER = DisableAbleCommandHandler(
"hitme", hitme, filters=Filters.group)
dispatcher.add_handler(BAN_HANDLER)
dispatcher.add_handler(TEMPBAN_HANDLER)
dispatcher.add_handler(HIT_HANDLER)
dispatcher.add_handler(UNBAN_HANDLER)
dispatcher.add_handler(ROAR_HANDLER)
dispatcher.add_handler(HITME_HANDLER)
__mod_name__ = "Restrictions"
__handlers__ = [
BAN_HANDLER, TEMPBAN_HANDLER, HIT_HANDLER, UNBAN_HANDLER, ROAR_HANDLER,
HITME_HANDLER
]
• `/markdownhelp`*:* quick summary of how markdown works in telegram - can only be called in private chats
*Paste:*
• `/paste`*:* Saves replied content to `nekobin.com` and replies with a url
*UrbanDictionnary:*
• `/ud`*:* Search for a word in Urban Disctionary and replies with it's Meaning
*Wikipedia:*
• `/wiki <query>`*:* wikipedia your query
*Currency converter:*
• `/cash`*:* currency converter
Example:
`/cash 1 USD INR`
_OR_
`/cash 1 usd inr`
Output: `1.0 USD = 75.505 INR`
• `/encrypt <texts>` *:* can only be decrypted using this bot
• `/decrypt <encrypted text>` *:* Decrypt Texts encrypted using this bot
"""
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group)
MD_HELP_HANDLER = CommandHandler("markdownhelp", markdown_help)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
__mod_name__ = "Extras"
__command_list__ = ["id", "echo"]
__handlers__ = [
ECHO_HANDLER,
MD_HELP_HANDLER,
]
del args[0]
except TypeError:
update.effective_message.reply_text(
"Please give me a chat to echo to!")
to_send = " ".join(args)
if len(to_send) >= 2:
try:
bot.sendMessage(int(chat_id), str(to_send))
except TelegramError:
LOGGER.warning("Couldn't send to group %s", str(chat_id))
update.effective_message.reply_text(
"Couldn't send the message. Perhaps I'm not part of that group?"
)
__help__ = """
──「 *Sudo only:* 」──
-> /snipe <chatid> <string>
Make me send a message to a specific chat.
"""
__mod_name__ = "Snipe"
SNIPE_HANDLER = CommandHandler("snipe",
snipe,
pass_args=True,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(SNIPE_HANDLER)
reply = song.format()
else:
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? Plus You can get the Song uploaded here on your request
*Available commands:*
- /lyrics <song>: returns the lyrics of that song.
- /song <song>: uploads the song directly to telegram from youtube.
You can either enter just the song name or both the artist and song name.
"""
__mod_name__ = "Music"
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics)
dispatcher.add_handler(LYRICS_HANDLER)
BJ_HANDLER = DisableAbleCommandHandler("bj", bj)
NEKONSFW_HANDLER = DisableAbleCommandHandler("nekonsfw", nekonsfw)
SOLO_HANDLER = DisableAbleCommandHandler("solo", solo)
KEMONOMIMI_HANDLER = DisableAbleCommandHandler("kemonomimi", kemonomimi)
POKEG_HANDLER = DisableAbleCommandHandler("pokegif", pokeg)
ANALG_HANDLER = DisableAbleCommandHandler("analgif", analg)
HENTAI_HANDLER = DisableAbleCommandHandler("hentai", hentai)
EROFEET_HANDLER = DisableAbleCommandHandler("erofeet", erofeet)
HOLO_HANDLER = DisableAbleCommandHandler("holo", holo)
PUSSYG_HANDLER = DisableAbleCommandHandler("pussygif", pussyg)
TITS_HANDLER = DisableAbleCommandHandler("boobs", t**s)
HOLOERO_HANDLER = DisableAbleCommandHandler("holoero", holoero)
CLASSIC_HANDLER = DisableAbleCommandHandler("classic", classic)
KUNI_HANDLER = DisableAbleCommandHandler("kuni", kuni)
dispatcher.add_handler(ADDHENTAI_HANDLER)
dispatcher.add_handler(REMOVEHENTAI_HANDLER)
dispatcher.add_handler(PUSSY_HANDLER)
dispatcher.add_handler(HENTAIG_HANDLER)
dispatcher.add_handler(NEKO_HANDLER)
dispatcher.add_handler(FEET_HANDLER)
dispatcher.add_handler(YURI_HANDLER)
dispatcher.add_handler(TRAP_HANDLER)
dispatcher.add_handler(FUTANARI_HANDLER)
dispatcher.add_handler(HOLOLEWD_HANDLER)
dispatcher.add_handler(LEWDKEMO_HANDLER)
dispatcher.add_handler(SOLOG_HANDLER)
dispatcher.add_handler(FEETG_HANDLER)
dispatcher.add_handler(CUMG_HANDLER)
dispatcher.add_handler(EROKEMO_HANDLER)
*Admins only:*
• `/lock <type>`*:* lock items of a certain type (not available in private)
• `/unlock <type>`*:* unlock items of a certain type (not available in private)
• `/locks`*:* the current list of locks in this chat.
Locks can be used to restrict a group's users.
*Example:*
Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \
stickers, etc.
Locking bots will stop non-admins from adding bots to the chat.
"""
LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes)
LOCK_HANDLER = CommandHandler("lock", lock)
UNLOCK_HANDLER = CommandHandler("unlock", unlock)
LOCKED_HANDLER = CommandHandler("locks", list_locks)
LOCKABLE_HANDLER = MessageHandler(Filters.all & Filters.group, del_lockables)
RESTRICTION_HANDLER = MessageHandler(Filters.all & Filters.group, rest_handler)
dispatcher.add_handler(LOCK_HANDLER)
dispatcher.add_handler(UNLOCK_HANDLER)
dispatcher.add_handler(LOCKTYPES_HANDLER)
dispatcher.add_handler(LOCKED_HANDLER)
dispatcher.add_handler(LOCKABLE_HANDLER, PERM_GROUP)
dispatcher.add_handler(RESTRICTION_HANDLER, REST_GROUP)
__mod_name__ = "Locks"
__handlers__ = [
LOCKTYPES_HANDLER, LOCK_HANDLER, UNLOCK_HANDLER, LOCKED_HANDLER,
(LOCKABLE_HANDLER, PERM_GROUP), (RESTRICTION_HANDLER, REST_GROUP)
]
return """╘══「 Groups count: <code>???</code> 」"""
num_chats = sql.get_user_num_chats(user_id)
return f"""╘══「 Groups count: <code>{num_chats}</code> 」"""
def __stats__():
return f"• {sql.num_users()} users, across {sql.num_chats()} chats"
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
__help__ = "" # no help string
BROADCAST_HANDLER = CommandHandler(
["broadcastall", "broadcastusers", "broadcastgroups"], broadcast)
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group,
chat_checker)
CHATLIST_HANDLER = CommandHandler("groups", chats)
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)
__mod_name__ = "Users"
__handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER,
CHATLIST_HANDLER]
unload_messasge.edit_text(f"Successfully unloaded module : <b>{text}</b>",
parse_mode=ParseMode.HTML)
@run_async
@sudo_plus
def listmodules(update: Update, context: CallbackContext):
message = update.effective_message
module_list = []
for helpable_module in HELPABLE:
helpable_module_info = IMPORTED[helpable_module]
file_info = IMPORTED[helpable_module_info.__mod_name__.lower()]
file_name = file_info.__name__.rsplit("Hackfreaks.modules.", 1)[1]
mod_name = file_info.__mod_name__
module_list.append(f'- <code>{mod_name} ({file_name})</code>\n')
module_list = "Following modules are loaded : \n\n" + ''.join(module_list)
message.reply_text(module_list, parse_mode=ParseMode.HTML)
LOAD_HANDLER = CommandHandler("load", load)
UNLOAD_HANDLER = CommandHandler("unload", unload)
LISTMODULES_HANDLER = CommandHandler("listmodules", listmodules)
dispatcher.add_handler(LOAD_HANDLER)
dispatcher.add_handler(UNLOAD_HANDLER)
dispatcher.add_handler(LISTMODULES_HANDLER)
__mod_name__ = "Modules"
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 group owner:*
• /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)
from telegram import Update
from telegram.ext import CallbackContext, run_async, CommandHandler
from Hackfreaks import dispatcher
from Hackfreaks.modules.helper_funcs.chat_status import dev_plus
@run_async
@dev_plus
def logs(update: Update, context: CallbackContext):
message = update.effective_message
chat_id = message.chat_id
if chat_id != -1001408942668:
return
user = update.effective_user
with open('log.txt', 'rb') as f:
context.bot.send_document(document=f, filename=f.name, chat_id=user.id)
LOG_HANDLER = CommandHandler('logs', logs)
dispatcher.add_handler(LOG_HANDLER)
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
stdout, stderr = process.communicate()
reply = ''
stderr = stderr.decode()
stdout = stdout.decode()
if stdout:
reply += f"*Stdout*\n`{stdout}`\n"
LOGGER.info(f"Shell - {cmd} - {stdout}")
if stderr:
reply += f"*Stderr*\n`{stderr}`\n"
LOGGER.error(f"Shell - {cmd} - {stderr}")
if len(reply) > 3000:
with open('shell_output.txt', 'w') as file:
file.write(reply)
with open('shell_output.txt', 'rb') as doc:
context.bot.send_document(document=doc,
filename=doc.name,
reply_to_message_id=message.message_id,
chat_id=message.chat_id)
else:
message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
SHELL_HANDLER = CommandHandler(['sh', 'shell', 'term', 'terminal'], shell)
dispatcher.add_handler(SHELL_HANDLER)
__mod_name__ = "Shell"
__command_list__ = ['sh', 'shell', 'term', 'terminal']
__handlers__ = [SHELL_HANDLER]
return f"• {sql.num_disabled()} disabled items, across {sql.num_chats()} chats."
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)
DISABLE_HANDLER = CommandHandler("disable", disable)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule", disable_module)
ENABLE_HANDLER = CommandHandler("enable", enable)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule", enable_module)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"], commands)
TOGGLE_HANDLER = CommandHandler("listcmds", list_cmds)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(DISABLE_MODULE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(ENABLE_MODULE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
dispatcher.add_handler(TOGGLE_HANDLER)
__help__ = """
• `/cmds`*:* check the current status of disabled commands
*Admins only:*
• `/enable <cmd name>`*:* enable that command
• `/disable <cmd name>`*:* disable that command
• `/enablemodule <module name>`*:* enable all commands in that module
• `/disablemodule <module name>`*:* disable all commands in that module
• `/listcmds`*:* list all possible toggleable commands
def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start)
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)
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_error_handler(error_callback)
if WEBHOOK:
LOGGER.info("Using webhooks.")
updater.start_webhook(listen="0.0.0.0", 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, clean=True)
if len(argv) not in (1, 3, 4):
telethn.disconnect()
else:
telethn.run_until_disconnected()
updater.idle()
filters=Filters.group)
ADD_WARN_HANDLER = CommandHandler("addwarn",
add_warn_filter,
filters=Filters.group)
RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"],
remove_warn_filter,
filters=Filters.group)
LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"],
list_warn_filters,
filters=Filters.group,
admin_ok=True)
WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group,
reply_filter)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
set_warn_limit,
filters=Filters.group)
WARN_STRENGTH_HANDLER = CommandHandler("strongwarn",
set_warn_strength,
filters=Filters.group)
dispatcher.add_handler(WARN_HANDLER)
dispatcher.add_handler(CALLBACK_QUERY_HANDLER)
dispatcher.add_handler(RESET_WARN_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)
if DEBUG_MODE:
message.reply_text("Debug mode is currently on.")
else:
message.reply_text("Debug mode is currently off.")
@telethn.on(events.NewMessage(pattern="[/!].*"))
async def i_do_nothing_yes(event):
global DEBUG_MODE
if DEBUG_MODE:
print(f"-{event.from_id} ({event.chat_id}) : {event.text}")
if os.path.exists('updates.txt'):
with open('updates.txt', 'r') as f:
text = f.read()
with open('updates.txt', 'w+') as f:
f.write(text +
f"\n-{event.from_id} ({event.chat_id}) : {event.text}")
else:
with open('updates.txt', 'w+') as f:
f.write(
f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}"
)
DEBUG_HANDLER = CommandHandler("debug", debug)
dispatcher.add_handler(DEBUG_HANDLER)
__mod_name__ = "Debug"
__command_list__ = ["debug"]
__handlers__ = [DEBUG_HANDLER]
