return f"<b>What others say:</b>\n{bio}\n"
elif me:
return f"<b>About user:</b>\n{me}"
else:
return ""
__help__ = """
- /setbio <text>: while replying, will save another user's bio
- /bio: will get your or another user's bio. This cannot be set by yourself.
- /setme <text>: will set your info
- /me: will get your or another user's info
"""
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)
__mod_name__ = "Bios and Abouts"
__command_list__ = ["setbio", "bio", "setme", "me"]
__handlers__ = [
SET_BIO_HANDLER, GET_BIO_HANDLER, SET_ABOUT_HANDLER, GET_ABOUT_HANDLER
]
- /get <notename>: get the note with this notename
- #<notename>: same as /get
- /notes or /saved: list all saved notes in this chat
If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \
be useful when updating a current note.
*Admin only:*
- /save <notename> <notedata>: saves notedata as a note with name notename
A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \
`buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check /markdownhelp for more info.
- /save <notename>: save the replied message as a note with name notename
- /clear <notename>: clear note with this name
"""
__mod_name__ = "Notes"
GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True)
HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get)
SAVE_HANDLER = CommandHandler("save", save)
DELETE_HANDLER = CommandHandler("clear", clear, 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(HASH_GET_HANDLER)
GBANCHAT_HANDLER = CommandHandler("blchat",
gbanChat,
pass_args=True,
filters=CustomFilters.sudo_filter)
UNGBANCHAT_HANDLER = CommandHandler("unblchat",
ungbanChat,
pass_args=True,
filters=CustomFilters.sudo_filter)
DEFENSE_HANDLER = CommandHandler("setdefense", setDefense, pass_args=True)
GETDEF_HANDLER = CommandHandler("defense", getDefense)
GETTIMESET_HANDLER = CommandHandler("kicktime", getTimeSetting)
SETTIMER_HANDLER = CommandHandler("setkicktime",
setTimeSetting,
pass_args=True)
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(SAFEMODE_HANDLER)
dispatcher.add_handler(BUTTON_VERIFY_HANDLER)
dispatcher.add_handler(DEL_JOINED)
dispatcher.add_handler(WELCOME_HELP)
dispatcher.add_handler(SETCAS_HANDLER)
dispatcher.add_handler(GETCAS_HANDLER)
dispatcher.add_handler(GETVER_HANDLER)
newstra = stringtocut.split('=')
if len(newstra) == 1:
under = True
newstra = stringtocut.split('<')
newstr = ""
if os.name == 'nt':
newstr = newstra[1].split('ms')
else:
newstr = newstra[1].split(
' ') #redundant split, but to try and not break windows ping
ping_time = float(newstr[0])
return ping_time
@run_async
def status(bot: Bot, update: Update):
user_id = update.effective_user.id
reply = "*System Status:* operational\n"
reply += "*Python version:* " + python_version() + "\n"
if user_id in SUDO_USERS or user_id in SUPPORT_USERS or user_id == OWNER_ID:
pingSpeed = pingme()
reply += "*Ping speed:* " + str(pingSpeed) + "ms �\n"
reply += "*CAS API version:* " + str(cas.vercheck()) + "\n"
reply += "*GitHub API version:* " + str(git.vercheck()) + "\n"
update.effective_message.reply_text(reply, parse_mode=ParseMode.MARKDOWN)
STATUS_HANDLER = CommandHandler("status", status)
dispatcher.add_handler(STATUS_HANDLER)
payload = json2_response['payload']
info = '*{0}*'.format(payload['fulltitle'])
try:
bot.send_audio(chat_id=chatId,
audio=json2_response['url'],
parse_mode='Markdown',
text="meanya",
caption=info,
reply_to_message_id=msg_id)
count += 1
print("\033[1m\033[96m" + "Download count: " + str(count) +
"\033[0m")
except:
bot.send_message(
chat_id=chatId,
text=
'Something went wrong with the download..!\nPlease Report there @spookyenvy',
reply_to_message_id=msg_id)
__help__ = """ YOutube audio Downloader
- /music <Youtube link> : stella can download audio file from youtube link.
"""
__mod_name__ = "Music"
music_handler = CommandHandler('music', music, pass_args=True)
dispatcher.add_handler(music_handler)
message.reply_text(f"Muted for {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)
message.reply_text("Well damn, I can't mute that user.")
return ""
__help__ = """
*Admin only:*
- /mute <userhandle>: silences a user. Can also be used as a reply, muting the replied to user.
- /tmute <userhandle> x(m/h/d): mutes a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
- /unmute <userhandle>: unmutes a user. Can also be used as a reply, muting the replied to user.
"""
MUTE_HANDLER = CommandHandler("mute", mute, pass_args=True)
UNMUTE_HANDLER = CommandHandler("unmute", unmute, pass_args=True)
TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"],
temp_mute,
pass_args=True)
dispatcher.add_handler(MUTE_HANDLER)
dispatcher.add_handler(UNMUTE_HANDLER)
dispatcher.add_handler(TEMPMUTE_HANDLER)
__mod_name__ = "Muting"
__handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
f"Message deleted.")
else:
update.effective_message.reply_text("Whadya want to delete?")
return ""
__help__ = """
*Admin only:*
- /del: deletes the message you replied to
- /purge: deletes all messages between this and the replied to message.
- /purge <integer X>: deletes the replied message, and X messages following it if replied to a message.
- /purge <integer X>: deletes the number of messages starting from bottom. (Counts manaully deleted messages too)
"""
DELETE_HANDLER = DisableAbleCommandHandler("del",
del_message,
filters=Filters.group)
PURGE_HANDLER = DisableAbleCommandHandler("purge",
purge,
filters=Filters.group,
pass_args=True)
dispatcher.add_handler(DELETE_HANDLER)
dispatcher.add_handler(PURGE_HANDLER)
__mod_name__ = "Purges"
__command_list__ = ["del", "purge"]
__handlers__ = [DELETE_HANDLER, PURGE_HANDLER]
send_message = message.reply_text(
f"Finding timezone info for <b>{query}</b>", parse_mode=ParseMode.HTML)
query_timezone = query.lower()
if len(query_timezone) == 2:
result = generate_time(query_timezone, ["countryCode"])
else:
result = generate_time(query_timezone, ["zoneName", "countryName"])
if not result:
send_message.edit_text(
f"Timezone info not available for <b>{query}</b>",
parse_mode=ParseMode.HTML)
return
send_message.edit_text(result, parse_mode=ParseMode.HTML)
__help__ = """
- /time <query> : Gives information about a timezone.
Available queries : Country Code/Country Name/Timezone Name
"""
TIME_HANDLER = DisableAbleCommandHandler("time", gettime)
dispatcher.add_handler(TIME_HANDLER)
__mod_name__ = "Time"
__command_list__ = ["time"]
__handlers__ = [TIME_HANDLER]
return "This chat is setup to send user reports to admins, via /report and @admin: `{}`".format(
sql.chat_should_report(chat_id))
def __user_settings__(user_id):
return "You receive reports from chats you're admin in: `{}`.\nToggle this with /reports in PM.".format(
sql.user_should_report(user_id))
__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.
*Admin only:*
- /reports <on/off>: change report setting, or view current status.
- If done in pm, toggles your status.
- If in chat, toggles that chat's status.
"""
SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True)
REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group)
ADMIN_REPORT_HANDLER = RegexHandler("(?i)@admin(s)?", report)
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)]
- /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)
- /kick <userhandle>: kicks a user, (via handle, or reply)
"""
__mod_name__ = "Bans"
BAN_HANDLER = CommandHandler("ban", ban, pass_args=True, filters=Filters.group)
TEMPBAN_HANDLER = CommandHandler(["tban", "tempban"],
temp_ban,
pass_args=True,
filters=Filters.group)
KICK_HANDLER = CommandHandler("kick",
kick,
pass_args=True,
filters=Filters.group)
UNBAN_HANDLER = CommandHandler("unban",
unban,
pass_args=True,
filters=Filters.group)
KICKME_HANDLER = DisableAbleCommandHandler("kickme",
kickme,
filters=Filters.group)
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)
single = opener.open(imgspage).read()
decoded = single.decode('utf-8')
if int(lim) > 10:
lim = 10
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.
"""
__mod_name__ = "Reverse search"
REVERSE_HANDLER = DisableAbleCommandHandler("reverse", reverse, pass_args=True, admin_ok=True)
dispatcher.add_handler(REVERSE_HANDLER)
result.append(' '.join([s for s in text]))
for pos, symbol in enumerate(text[1:]):
result.append(symbol + ' ' + ' ' * pos + symbol)
result = list("\n".join(result))
result[0] = text[0]
result = "".join(result)
msg = "```\n" + result + "```"
return update.effective_message.reply_text(msg, parse_mode="MARKDOWN")
__help__ = """
A little piece of fun wording! Give a loud shout out in the chatroom.
i.e /shout HELP, bot replies with huge coded HELP letters within the square.
- /shout <keyword>: write anything you want to give loud shout.
```
t e s t
e e
s s
t t
```
"""
SHOUT_HANDLER = DisableAbleCommandHandler("shout", shout, pass_args=True)
dispatcher.add_handler(SHOUT_HANDLER)
__mod_name__ = "Shout"
__command_list__ = ["shout"]
__handlers__ = [SHOUT_HANDLER]
message.reply_text("SUDOER: Irrelevant")
return
if int(user_id) == OWNER_ID:
message.reply_text("OWNER: Irrelevant")
return
if user_id == bot.id:
message.reply_text("It's me, n***a")
return
sql.gkick_reset(user_id)
return
GKICK_HANDLER = CommandHandler("gkick",
gkick,
pass_args=True,
filters=CustomFilters.sudo_filter
| CustomFilters.support_filter)
SET_HANDLER = CommandHandler("gkickset",
gkickset,
pass_args=True,
filters=Filters.user(OWNER_ID))
RESET_HANDLER = CommandHandler("gkickreset",
gkickreset,
pass_args=True,
filters=Filters.user(OWNER_ID))
dispatcher.add_handler(GKICK_HANDLER)
dispatcher.add_handler(SET_HANDLER)
dispatcher.add_handler(RESET_HANDLER)
keyb = [[InlineKeyboardButton("More Information", url=url)]]
msg.reply_text(rep,
parse_mode=ParseMode.HTML,
reply_markup=InlineKeyboardMarkup(keyb))
__help__ = """
Get information about anime, manga or characters with the help of this module! All data is fetched 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.
Module credit: Saitama
"""
__mod_name__ = "Anime"
ANIME_HANDLER = CommandHandler("anime", anime, pass_args=True)
CHARACTER_HANDLER = CommandHandler("character", character, pass_args=True)
UPCOMING_HANDLER = CommandHandler("upcoming", upcoming)
MANGA_HANDLER = CommandHandler("manga", manga, pass_args=True)
dispatcher.add_handler(ANIME_HANDLER)
dispatcher.add_handler(CHARACTER_HANDLER)
dispatcher.add_handler(UPCOMING_HANDLER)
dispatcher.add_handler(MANGA_HANDLER)
def __chat_settings__(chat_id, user_id):
return build_curr_disabled(chat_id)
DISABLE_HANDLER = CommandHandler("disable", disable, pass_args=True)
DISABLE_MODULE_HANDLER = CommandHandler("disablemodule",
disable_module,
pass_args=True)
ENABLE_HANDLER = CommandHandler("enable", enable, pass_args=True)
ENABLE_MODULE_HANDLER = CommandHandler("enablemodule",
enable_module,
pass_args=True)
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
*Admin 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
"""
try:
new_cur = args[3].upper()
except IndexError:
update.effective_message.reply_text("You forgot to mention the currency code to convert into.")
return
request_url = f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency={orig_cur}&to_currency={new_cur}&apikey={CASH_API_KEY}"
response = requests.get(request_url).json()
try:
current_rate = float(response['Realtime Currency Exchange Rate']['5. Exchange Rate'])
except KeyError:
update.effective_message.reply_text(f"Currency Not Supported.")
return
new_cur_amount = round(orig_cur_amount * current_rate, 5)
update.effective_message.reply_text(f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}")
else:
update.effective_message.reply_text(__help__)
__help__ = """
- /cash : currency converter
example syntax: /cash 1 USD INR
"""
CONVERTER_HANDLER = CommandHandler('cash', convert)
dispatcher.add_handler(CONVERTER_HANDLER)
__mod_name__ = "Currency Converter"
__command_list__ = ["cash"]
__handlers__ = [CONVERTER_HANDLER]
- /connect: connect a chat (Can be done in a group by /connect or /connect <chat id> in PM)
- /connection: list connected chats
- /disconnect: disconnect from a chat
- /helpconnect: list available commands that can be done remotely
*Admin only:*
- /allowconnect <yes/no>: allow a user to connect to a chat
"""
CONNECT_CHAT_HANDLER = CommandHandler("connect", connect_chat, pass_args=True)
CONNECTION_CHAT_HANDLER = CommandHandler("connection", connection_chat)
DISCONNECT_CHAT_HANDLER = CommandHandler("disconnect", disconnect_chat)
ALLOW_CONNECTIONS_HANDLER = CommandHandler("allowconnect",
allow_connections,
pass_args=True)
HELP_CONNECT_CHAT_HANDLER = CommandHandler("helpconnect", help_connect_chat)
CONNECT_BTN_HANDLER = CallbackQueryHandler(connect_button, pattern=r"connect")
dispatcher.add_handler(CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECTION_CHAT_HANDLER)
dispatcher.add_handler(DISCONNECT_CHAT_HANDLER)
dispatcher.add_handler(ALLOW_CONNECTIONS_HANDLER)
dispatcher.add_handler(HELP_CONNECT_CHAT_HANDLER)
dispatcher.add_handler(CONNECT_BTN_HANDLER)
__mod_name__ = "Connection"
__handlers__ = [
CONNECT_CHAT_HANDLER, CONNECTION_CHAT_HANDLER, DISCONNECT_CHAT_HANDLER,
ALLOW_CONNECTIONS_HANDLER, HELP_CONNECT_CHAT_HANDLER, CONNECT_BTN_HANDLER
]
from requests import get
from telegram import ParseMode, InlineKeyboardMarkup, InlineKeyboardButton
@run_async
def feedback(bot: Bot, update: Update):
name = update.effective_message.from_user.first_name
message = update.effective_message
userid = message.from_user.id
text = message.text[len('/feedback '):]
feed_text = f"Stella's *New* feedback from [{name}](tg://user?id={userid})\n\nfeed: {text}"
bot.send_message(-604968079, feed_text, parse_mode=ParseMode.MARKDOWN)
text = html.escape(text)
reply_text = f"Thankyou for giving us your feedback."
message.reply_text(reply_text)
__help__ = """
- /feedback : You can give us your feedbacks
"""
__mod_name__ = "feedback"
feed_handle = DisableAbleCommandHandler("feedback", feedback)
dispatcher.add_handler(feed_handle)
"(´･ᴗ･ ` )", "( ͡° ʖ̯ ͡°)", "( ఠ ͟ʖ ఠ)", "( ಥ ʖ̯ ಥ)", "(≖ ͜ʖ≖)", "ヘ(￣ω￣ヘ)",
"(ﾉ≧∀≦)ﾉ", "└(￣-￣└))", "┌(＾＾)┘", "(^_^♪)", "(〜￣△￣)〜", "(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫", "( o˘◡˘o) ┌iii┐", "♨o(>_<)o♨", "( ・・)つ―{}@{}@{}-",
"(*´з`)口ﾟ｡ﾟ口(・∀・ )", "( *^^)o∀*∀o(^^* )", "-●●●-ｃ(・・ )", "(ﾉ≧∀≦)ﾉ ‥…━━━★",
"╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ", "(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)"
]
@run_async
def react(bot: Bot, update: Update):
message = update.effective_message
react = random.choice(reactions)
if message.reply_to_message:
message.reply_to_message.reply_text(react)
else:
message.reply_text(react)
__help__ = """
- /react: Reacts with a random reaction
"""
REACT_HANDLER = DisableAbleCommandHandler("react", react)
dispatcher.add_handler(REACT_HANDLER)
__mod_name__ = "React"
__command_list__ = ["react"]
__handlers__ = [REACT_HANDLER]
__help__ = """
*Android related commands:*
- /magisk - gets the latest magisk release for Stable/Beta/Canary
- /device <codename> - gets android device basic info from its codename
- /twrp <codename> - gets latest twrp for the android device using the codename
- /checkfw <model> <csc> - Samsung only - shows the latest firmware info for the given device, taken from samsung servers
- /getfw <model> <csc> - Samsung only - gets firmware download links from samfrew, sammobile and sfirmwares for the given device
*Examples:*
/device greatlte
/twrp a5y17lte
/checkfw SM-A305F INS
/getfw SM-M205FN SER
"""
__mod_name__ = "Android"
MAGISK_HANDLER = DisableAbleCommandHandler("magisk", magisk)
DEVICE_HANDLER = DisableAbleCommandHandler("device", device, pass_args=True)
TWRP_HANDLER = DisableAbleCommandHandler("twrp", twrp, pass_args=True)
GETFW_HANDLER = DisableAbleCommandHandler("getfw", getfw, pass_args=True)
CHECKFW_HANDLER = DisableAbleCommandHandler("checkfw", checkfw, pass_args=True)
dispatcher.add_handler(MAGISK_HANDLER)
dispatcher.add_handler(DEVICE_HANDLER)
dispatcher.add_handler(TWRP_HANDLER)
dispatcher.add_handler(GETFW_HANDLER)
dispatcher.add_handler(CHECKFW_HANDLER)
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)
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)
def main():
test_handler = CommandHandler("test", test)
start_handler = CommandHandler("start", start, pass_args=True)
start_callback_handler = CallbackQueryHandler(send_start, pattern=r"bot_start")
dispatcher.add_handler(start_callback_handler)
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_")
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_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()
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 "This chat has had it's rules set: `{}`".format(
bool(sql.get_rules(chat_id)))
__help__ = """
- /rules: get the rules for this chat.
*Admin only:*
- /setrules <your rules here>: set the rules for this chat.
- /clearrules: clear the rules for this chat.
"""
__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)
dispatcher.add_handler(GET_RULES_HANDLER)
dispatcher.add_handler(SET_RULES_HANDLER)
dispatcher.add_handler(RESET_RULES_HANDLER)
else:
tekstr = trl.translate(text, dest=dest_lang, src=source_lang)
message.reply_text(
"Translated from `{}` to `{}`:\n`{}`".format(
source_lang, dest_lang, tekstr.text),
parse_mode=ParseMode.MARKDOWN)
except IndexError:
update.effective_message.reply_text(
"Reply to messages or write messages from other languages for translating into the intended language\n\nExample: `/tr en ml` to translate from English to Malayalam\nOr use: `/tr ml` for automatic detection and translating it into Malayalam.\nSee [List of Language Codes](t.me/stellatm) for a list of language codes.",
parse_mode="markdown",
disable_web_page_preview=True)
except ValueError:
update.effective_message.reply_text(
"The intended language is not found!")
else:
return
__help__ = """
- /tr (language code) as reply to a long message.
"""
TRANSLATE_HANDLER = DisableAbleCommandHandler("tr", totranslate)
dispatcher.add_handler(TRANSLATE_HANDLER)
__mod_name__ = "Translator"
__command_list__ = ["tr"]
__handlers__ = [TRANSLATE_HANDLER]
chatfile += "{}. {} | {} | {} | {}\n".format(P, chat.chat_name, chat.chat_id, chat_members, invitelink)
P = P + 1
except:
pass
with BytesIO(str.encode(chatfile)) as output:
output.name = "chatlist.txt"
update.effective_message.reply_document(document=output, filename="chatlist.txt",
caption="Here is the list of chats in my database.")
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("broadcast", broadcast)
USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user)
CHATLIST_HANDLER = CommandHandler("chatlist", chats)
dispatcher.add_handler(USER_HANDLER, USERS_GROUP)
dispatcher.add_handler(BROADCAST_HANDLER)
dispatcher.add_handler(CHATLIST_HANDLER)
__mod_name__ = "Users"
__handlers__ = [(USER_HANDLER, USERS_GROUP), BROADCAST_HANDLER, CHATLIST_HANDLER]
__help__ = """
*Admin only:*
- /gmutespam <on/off/yes/no>: Will disable the effect of global mutes on your group, or return your current settings.
Gmutes, also known as global mutes, are used by the bot owners to mute spammers across all groups. This helps protect \
you and your groups by removing spam flooders as quickly as possible. They can be disabled for you group by calling \
"""
__mod_name__ = "Global Mutes"
GMUTE_HANDLER = CommandHandler("gmute", gmute, pass_args=True,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
UNGMUTE_HANDLER = CommandHandler("ungmute", ungmute, pass_args=True,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GMUTE_LIST = CommandHandler("gmutelist", gmutelist,
filters=CustomFilters.sudo_filter | CustomFilters.support_filter)
GMUTE_STATUS = CommandHandler("gmutespam", gmutestat, pass_args=True, filters=Filters.group)
GMUTE_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gmute)
dispatcher.add_handler(GMUTE_HANDLER)
dispatcher.add_handler(UNGMUTE_HANDLER)
dispatcher.add_handler(GMUTE_LIST)
dispatcher.add_handler(GMUTE_STATUS)
if STRICT_GMUTE:
dispatcher.add_handler(GMUTE_ENFORCER, GMUTE_ENFORCE_GROUP)
]
@run_async
def weebify(bot: Bot, update: Update, args: List[str]):
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__ = ""
__mod_name__ = "Remote Commands"
RBAN_HANDLER = CommandHandler("rban",
rban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNBAN_HANDLER = CommandHandler("runban",
runban,
pass_args=True,
filters=CustomFilters.sudo_filter)
RKICK_HANDLER = CommandHandler("rkick",
rkick,
pass_args=True,
filters=CustomFilters.sudo_filter)
RMUTE_HANDLER = CommandHandler("rmute",
rmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
RUNMUTE_HANDLER = CommandHandler("runmute",
runmute,
pass_args=True,
filters=CustomFilters.sudo_filter)
dispatcher.add_handler(RBAN_HANDLER)
dispatcher.add_handler(RUNBAN_HANDLER)
dispatcher.add_handler(RKICK_HANDLER)
dispatcher.add_handler(RMUTE_HANDLER)
dispatcher.add_handler(RUNMUTE_HANDLER)
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(bot: Bot, update: Update):
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, pass_args=True)
GITPULL_HANDLER = CommandHandler("gitpull", gitpull)
RESTART_HANDLER = CommandHandler("restart", 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]
def stats(bot: Bot, update: Update):
stats = "Current stats:\n" + "\n".join([mod.__stats__() for mod in STATS])
result = re.sub(r'(\d+)', r'<code>\1</code>', stats)
update.effective_message.reply_text(result, parse_mode=ParseMode.HTML)
__help__ = """
- /id: get the current group id. If used by replying to a message, gets that user's id.
- /info: get information about a user.
-/gifid: Get gif ID.
- /markdownhelp: quick summary of how markdown works in telegram - can only be called in private chats.
"""
ID_HANDLER = DisableAbleCommandHandler("id", get_id, pass_args=True)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid)
ECHO_HANDLER = DisableAbleCommandHandler("echo", echo, filters=Filters.group)
MD_HELP_HANDLER = CommandHandler("markdownhelp",
markdown_help,
filters=Filters.private)
STATS_HANDLER = CommandHandler("stats", stats)
dispatcher.add_handler(ID_HANDLER)
dispatcher.add_handler(GIFID_HANDLER)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
__mod_name__ = "Misc"
__command_list__ = ["id", "echo"]
__handlers__ = [ID_HANDLER, ECHO_HANDLER, MD_HELP_HANDLER, STATS_HANDLER]
