]
@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]
scale = 512 / size1
size1new = 512
size2new = size2 * scale
else:
scale = 512 / size2
size1new = size1 * scale
size2new = 512
size1new = math.floor(size1new)
size2new = math.floor(size2new)
sizenew = (size1new, size2new)
im = im.resize(sizenew)
else:
im.thumbnail(maxsize)
return im
__help__ = """
- /stickerid: Gives the ID of the sticker you've replied to.
- /sticker: Uploads the .png of the sticker you've replied to.
- /kang: Reply to a sticker to add it to your pack or makes a new one if it doesn't exist.
"""
__mod_name__ = "Stickers"
STICKERID_HANDLER = DisableAbleCommandHandler("stickerid", stickerid)
GETSTICKER_HANDLER = DisableAbleCommandHandler("sticker", getsticker)
KANG_HANDLER = DisableAbleCommandHandler("kang", kang, pass_args=True)
dispatcher.add_handler(STICKERID_HANDLER)
dispatcher.add_handler(GETSTICKER_HANDLER)
dispatcher.add_handler(KANG_HANDLER)
"(´･ᴗ･ ` )", "( ͡° ʖ̯ ͡°)", "( ఠ ͟ʖ ఠ)", "( ಥ ʖ̯ ಥ)", "(≖ ͜ʖ≖)", "ヘ(￣ω￣ヘ)",
"(ﾉ≧∀≦)ﾉ", "└(￣-￣└))", "┌(＾＾)┘", "(^_^♪)", "(〜￣△￣)〜", "(｢• ω •)｢",
"( ˘ ɜ˘) ♬♪♫", "( 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]
- /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__ = "Math"
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)
LOG_HANDLER = DisableAbleCommandHandler("log", log, pass_args=True)
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]
__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)
- /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn",
warn_user,
pass_args=True,
filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
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(CustomFilters.has_text & Filters.group,
reply_filter)
WARN_LIMIT_HANDLER = CommandHandler("warnlimit",
set_warn_limit,
- /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)
message.reply_text(reply_text,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
@run_async
@sudo_plus
def speedtestxyz(bot: Bot, update: Update):
s = speedtest.Speedtest()
msg = update.effective_message.reply_text("Stella doing Speedtest.... ")
s.get_best_server()
s.download()
s.upload()
speedtest_image = s.results.share()
update.effective_message.reply_photo(photo=speedtest_image,
caption='Done!')
msg.delete()
__mod_name__ = "Paste bin"
__help__ = """
- /paste
"""
PASTE_HANDLER = DisableAbleCommandHandler("paste", paste, pass_args=True)
SpeedTest_handler = CommandHandler("speedtest", speedtestxyz)
dispatcher.add_handler(SpeedTest_handler)
dispatcher.add_handler(PASTE_HANDLER)
the message will immediately be deleted. A good combo is sometimes to pair this up with warn filters!
*NOTE:* blacklists do not affect group admins.
- /blacklist: View the current blacklisted words.
*Admin only:*
- /addblacklist <triggers>: Add a trigger to the blacklist. Each line is considered one trigger, so using different \
lines will allow you to add multiple triggers.
- /unblacklist <triggers>: Remove triggers from the blacklist. Same newline logic applies here, so you can remove \
multiple triggers at once.
- /rmblacklist <triggers>: Same as above.
"""
BLACKLIST_HANDLER = DisableAbleCommandHandler("blacklist",
blacklist,
pass_args=True,
admin_ok=True)
ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist)
UNBLACKLIST_HANDLER = CommandHandler(["unblacklist", "rmblacklist"],
unblacklist)
BLACKLIST_DEL_HANDLER = MessageHandler(
(Filters.text | Filters.command | Filters.sticker | Filters.photo)
& Filters.group,
del_blacklist,
edited_updates=True)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP)
__mod_name__ = "Word Blacklists"
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? 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.
"""
__mod_name__ = "Lyrics"
LYRICS_HANDLER = DisableAbleCommandHandler("lyrics", lyrics, pass_args=True)
dispatcher.add_handler(LYRICS_HANDLER)
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:
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)
__help__ = """
WIKIPEDIA!!
*Available commands:*
- /wiki <query>: wiki your query.
"""
__mod_name__ = "Wiki"
WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki)
dispatcher.add_handler(WIKI_HANDLER)
if not wallpapers:
msg.reply_text("No results found!")
return
else:
index = randint(0, len(wallpapers) - 1) # Choose random index
wallpaper = wallpapers[index]
wallpaper = wallpaper.get("url_image")
wallpaper = wallpaper.replace("\\", "")
bot.send_photo(chat_id,
photo=wallpaper,
caption='Preview',
reply_to_message_id=msg_id,
timeout=60)
bot.send_document(chat_id,
document=wallpaper,
filename='wallpaper',
caption=caption,
reply_to_message_id=msg_id,
timeout=60)
__help__ = """
- /wall <query> to get wallpaper
"""
__mod_name__ = " Wallpaper "
WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall, pass_args=True)
dispatcher.add_handler(WALLPAPER_HANDLER)
elif bio:
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
]
*Username:* `{usr['login']}`
*Account ID:* `{usr['id']}`
*Account type:* `{usr['type']}`
*Location:* `{usr['location']}`
*Bio:* `{usr['bio']}`
*Followers:* `{usr['followers']}`
*Following:* `{usr['following']}`
*Hireable:* `{usr['hireable']}`
*Public Repos:* `{usr['public_repos']}`
*Public Gists:* `{usr['public_gists']}`
*Email:* `{usr['email']}`
*Company:* `{usr['company']}`
*Website:* `{usr['blog']}`
*Last updated:* `{usr['updated_at']}`
*Account created at:* `{usr['created_at']}`
"""
else:
reply_text = "User not found. Make sure you entered valid username!"
message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN)
__help__ = """
- /git:{GitHub username} Returns info about a GitHub user or organization.
"""
__mod_name__ = "GitHub username info"
github_handle = DisableAbleCommandHandler("git", github)
dispatcher.add_handler(github_handle)
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]
text += "\nThis person is one of my sudo users! " \
"Nearly as powerful as my owner - so watch it.."
elif user.id in SUPPORT_USERS:
text += "\nThis person is one of my support users! " \
"Not quite a sudo user, but can still gban you off the map."
elif user.id in WHITELIST_USERS:
text += "\nThis person has been whitelisted! " \
"That means I'm not allowed to ban/kick them."
text += "\n"
for mod in USER_INFO:
if mod.__mod_name__ == "Users":
continue
try:
mod_info = mod.__user_info__(user.id)
except TypeError:
mod_info = mod.__user_info__(user.id, chat.id)
if mod_info:
text += "\n" + mod_info
update.effective_message.reply_text(text,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True)
INFO_HANDLER = DisableAbleCommandHandler("info", info, pass_args=True)
dispatcher.add_handler(INFO_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)
base_string = "Current <b>blacklisted</b> domains:\n"
blacklisted = sql.get_blacklisted_urls(chat.id)
if not blacklisted:
message.reply_text("There are no blacklisted domains here!")
return
for domain in blacklisted:
base_string += "- <code>{}</code>\n".format(domain)
message.reply_text(base_string, parse_mode=ParseMode.HTML)
URL_BLACKLIST_HANDLER = DisableAbleCommandHandler(
"blacklist",
add_blacklist_url,
filters=Filters.group,
pass_args=True,
admin_ok=True)
ADD_URL_BLACKLIST_HANDLER = CommandHandler(
"addurl", add_blacklist_url, filters=Filters.group)
RM_BLACKLIST_URL_HANDLER = CommandHandler(
"delurl", rm_blacklist_url, filters=Filters.group)
GET_BLACKLISTED_URLS = CommandHandler(
"geturl",
get_blacklisted_urls,
filters=Filters.group)
URL_DELETE_HANDLER = MessageHandler(
Filters.entity("url"),
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)
__help__ = """
- /runs: reply a random string from an array of replies.
- /slap: slap a user, or get slapped if not a reply.
- /shrug : get shrug XD.
- /table : get flip/unflip :v.
- /decide : Randomly answers yes/no/maybe
- /toss : Tosses A coin
- /abuse : Abuses the c**t
- /bluetext : check urself :V
- /roll : Roll a dice.
- /rlg : Join ears,nose,mouth and create an emo ;-;
"""
RUNS_HANDLER = DisableAbleCommandHandler("runs", runs)
SLAP_HANDLER = DisableAbleCommandHandler("slap", slap, pass_args=True)
ROLL_HANDLER = DisableAbleCommandHandler("roll", roll)
TOSS_HANDLER = DisableAbleCommandHandler("toss", toss)
SHRUG_HANDLER = DisableAbleCommandHandler("shrug", shrug)
BLUETEXT_HANDLER = DisableAbleCommandHandler("bluetext", bluetext)
RLG_HANDLER = DisableAbleCommandHandler("rlg", rlg)
DECIDE_HANDLER = DisableAbleCommandHandler("decide", decide)
TABLE_HANDLER = DisableAbleCommandHandler("table", table)
SEND_HANDLER = DisableAbleCommandHandler("send", send)
dispatcher.add_handler(RUNS_HANDLER)
dispatcher.add_handler(SLAP_HANDLER)
dispatcher.add_handler(ROLL_HANDLER)
dispatcher.add_handler(TOSS_HANDLER)
dispatcher.add_handler(SHRUG_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]
__help__ = """
- /filters: list all active filters in this chat.
*Admin only:*
- /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword'\
is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \
keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \
doin?
- /stop <filter keyword>: stop that filter.
"""
FILTER_HANDLER = CommandHandler("filter", filters)
STOP_HANDLER = CommandHandler("stop", stop_filter)
LIST_HANDLER = DisableAbleCommandHandler("filters",
list_handlers,
admin_ok=True)
CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter)
dispatcher.add_handler(FILTER_HANDLER)
dispatcher.add_handler(STOP_HANDLER)
dispatcher.add_handler(LIST_HANDLER)
dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
__mod_name__ = "Filters"
__handlers__ = [
FILTER_HANDLER, STOP_HANDLER, LIST_HANDLER,
(CUST_FILTER_HANDLER, HANDLER_GROUP)
]
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]
"administrator", "creator"))
__help__ = """
- /adminlist: list of admins in the chat
*Admin only:*
- /pin: silently pins the message replied to - add 'loud' or 'notify' to give notifs to users.
- /unpin: unpins the currently pinned message
- /invitelink: gets invitelink
- /promote: promotes the user replied to
- /demote: demotes the user replied to
- /settitle: sets a custom title for an admin that the bot promoted
"""
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"],
adminlist)
PIN_HANDLER = CommandHandler("pin", pin, pass_args=True, filters=Filters.group)
UNPIN_HANDLER = CommandHandler("unpin", unpin, filters=Filters.group)
INVITE_HANDLER = DisableAbleCommandHandler("invitelink",
invite,
filters=Filters.group)
PROMOTE_HANDLER = CommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = CommandHandler("demote", demote, pass_args=True)
SET_TITLE_HANDLER = CommandHandler("settitle", set_title, pass_args=True)
GITPULL_HANDLER = CommandHandler("gitpull", gitpull)
RESTART_HANDLER = CommandHandler("restart", restart)
- /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)
@run_async
@sudo_plus
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"]
SAFEMODE_HANDLER = CommandHandler("safemode",
safemode,
pass_args=True,
filters=Filters.group)
DEL_JOINED = CommandHandler("rmjoin",
del_joined,
pass_args=True,
filters=Filters.group)
WELCOME_HELP = CommandHandler("welcomehelp", welcome_help)
BUTTON_VERIFY_HANDLER = CallbackQueryHandler(user_button,
pattern=r"userverify_")
SETCAS_HANDLER = CommandHandler("setcas", setcas, filters=Filters.group)
GETCAS_HANDLER = CommandHandler("getcas",
get_current_setting,
filters=Filters.group)
GETVER_HANDLER = DisableAbleCommandHandler("casver", get_version)
CASCHECK_HANDLER = CommandHandler("cascheck", caschecker, pass_args=True)
CASQUERY_HANDLER = CommandHandler("casquery",
casquery,
pass_args=True,
filters=CustomFilters.sudo_filter)
SETBAN_HANDLER = CommandHandler("setban", setban, filters=Filters.group)
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)
from telegram import Update, Bot, ParseMode
from telegram.ext import run_async
from stella.modules.disable import DisableAbleCommandHandler
from stella import dispatcher
from requests import get
@run_async
def ud(bot: Bot, update: Update):
message = update.effective_message
text = message.text[len('/ud '):]
results = get(
f'http://api.urbandictionary.com/v0/define?term={text}').json()
reply_text = f'`{text}`\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_'
message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN)
__help__ = """
- /ud:{word} Type the word or expression you want to search use. like /ud telegram Word: Telegram Definition: A once-popular system of telecommunications, in which the sender would contact the telegram service and speak their [message] over the [phone]. The person taking the message would then send it, via a teletype machine, to a telegram office near the receiver's [address]. The message would then be hand-delivered to the addressee. From 1851 until it discontinued the service in 2006, Western Union was the best-known telegram service in the world.
"""
__mod_name__ = "Urban dictionary"
ud_handle = DisableAbleCommandHandler("ud", ud)
dispatcher.add_handler(ud_handle)
