def test_single_slash(self, dp, message):
# Regression test for https://github.com/python-telegram-bot/python-telegram-bot/issues/871
handler = CommandHandler('test', self.callback_basic)
dp.add_handler(handler)
message.text = '/'
assert not handler.check_update(Update(0, message))
def test_directed_commands(self, message):
handler = CommandHandler('test', self.callback_basic)
message.text = '/test@{}'.format(message.bot.username)
assert handler.check_update(Update(0, message))
message.text = '/test@otherbot'
assert not handler.check_update(Update(0, message))
def test_newline(self, dp, message):
handler = CommandHandler('test', self.callback_basic)
dp.add_handler(handler)
message.text = '/test\nfoobar'
assert handler.check_update(Update(0, message))
dp.process_update(Update(0, message))
assert self.test_flag
def test_with_filter(self, message):
handler = CommandHandler('test', self.callback_basic, Filters.group)
message.chat = Chat(-23, 'group')
message.text = '/test'
assert handler.check_update(Update(0, message))
message.chat = Chat(23, 'private')
assert not handler.check_update(Update(0, message))
def do_process(cls, target, method, dispatcher, *args, **kwargs):
names = [(k[1:] if k[0] == '/' else k)
for k in args]
handler = CommandHandler(names, bot_callback(method))
from gdgajubot.bot import AdminFilter
if kwargs.get('admin', False):
handler.filters = AdminFilter(names[0], target.resources)
dispatcher.add_handler(handler)
def test_command_list(self, message):
handler = CommandHandler(['test', 'start'], self.callback_basic)
message.text = '/test'
assert handler.check_update(Update(0, message))
message.text = '/start'
assert handler.check_update(Update(0, message))
message.text = '/stop'
assert not handler.check_update(Update(0, message))
def test_basic(self, dp, message):
handler = CommandHandler('test', self.callback_basic)
dp.add_handler(handler)
message.text = '/test'
assert handler.check_update(Update(0, message))
dp.process_update(Update(0, message))
assert self.test_flag
message.text = '/nottest'
assert not handler.check_update(Update(0, message))
message.text = 'test'
assert not handler.check_update(Update(0, message))
message.text = 'not /test at start'
assert not handler.check_update(Update(0, message))
def test_edited(self, message):
handler = CommandHandler('test', self.callback_basic, allow_edited=False)
message.text = '/test'
assert handler.check_update(Update(0, message))
assert not handler.check_update(Update(0, edited_message=message))
handler.allow_edited = True
assert handler.check_update(Update(0, message))
assert handler.check_update(Update(0, edited_message=message))
def test_other_update_types(self, false_update):
handler = CommandHandler('test', self.callback_basic)
assert not handler.check_update(false_update)
sql.migrate_chat(old_chat_id, new_chat_id)
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)
def main():
updater = Updater(token=config.TOKEN, use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# Use conversation handler to handle states
ask_conversation = ConversationHandler(
[CommandHandler('ask', ask, pass_user_data=True, pass_chat_data=True)],
{
ASK_INPUT: [
MessageHandler(Filters.text,
ask_text,
pass_user_data=True,
pass_chat_data=True)
],
ASK_PHOTO: [
MessageHandler(Filters.photo | Filters.text,
ask_photo,
pass_user_data=True,
pass_chat_data=True)
],
},
[CommandHandler('help', help)],
)
answer_conversation = ConversationHandler(
[
CommandHandler(
'answer', answer, pass_user_data=True, pass_chat_data=True)
],
{
ANSWER_INPUT: [
MessageHandler(Filters.text,
answer_text,
pass_user_data=True,
pass_chat_data=True)
],
ANSWER_PHOTO: [
MessageHandler(Filters.photo | Filters.text,
answer_photo,
pass_user_data=True,
pass_chat_data=True)
],
},
[CommandHandler('help', help)],
)
dp.add_handler(ask_conversation)
dp.add_handler(answer_conversation)
dp.add_handler(
CommandHandler('start',
start,
pass_user_data=True,
pass_chat_data=True))
dp.add_handler(
CommandHandler('menu', menu, pass_user_data=True, pass_chat_data=True))
# Log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
• *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__ = "AntiFlood 🛡"
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]
__help__ = """
Blue text cleaner removed any made up commands that people send in your chat.
• `/cleanblue <on/off/yes/no>`*:* clean commands after sending
• `/ignoreblue <word>`*:* prevent auto cleaning of the command
• `/unignoreblue <word>`*:* remove prevent auto cleaning of the command
• `/listblue`*:* list currently whitelisted commands
*Following are Disasters only commands, admins cannot use these:*
• `/gignoreblue <word>`*:* globally ignorea bluetext cleaning of saved word across Saitama.
• `/ungignoreblue <word>`*:* remove said command from global cleaning list
"""
SET_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("cleanblue",
set_blue_text_must_click,
pass_args=True)
ADD_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("ignoreblue",
add_bluetext_ignore,
pass_args=True)
REMOVE_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("unignoreblue",
remove_bluetext_ignore,
pass_args=True)
ADD_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler("gignoreblue",
add_bluetext_ignore_global,
pass_args=True)
REMOVE_CLEAN_BLUE_TEXT_GLOBAL_HANDLER = CommandHandler(
"ungignoreblue", remove_bluetext_ignore_global, pass_args=True)
LIST_CLEAN_BLUE_TEXT_HANDLER = CommandHandler("listblue", bluetext_ignore_list)
CLEAN_BLUE_TEXT_HANDLER = MessageHandler(Filters.command & Filters.group,
clean_blue_text_must_click)
@u.check_permissions(required_permission=Permissions.READ)
@u.failwithmessage
def on_json_command(_, update):
logger.info('/json command from %s', update.message.from_user.first_name)
torrents = qb.torrents(filter='all')
logger.info('qbittirrent request returned %d torrents', len(torrents))
if not torrents:
update.message.reply_html('There is no torrent')
return
result_dict = defaultdict(list)
for torrent in torrents:
result_dict[torrent.state].append(torrent.dict())
file_path = os.path.join('downloads', '{}.json'.format(update.message.message_id))
with open(file_path, 'w+') as f:
json.dump(result_dict, f, indent=4)
update.message.reply_document(open(file_path, 'rb'), caption='#torrents_list', timeout=60 * 10)
os.remove(file_path)
updater.add_handler(CommandHandler('json', on_json_command))
*Admin only:*
× /spamshield <on/off/yes/no>: Will disable or enable the effect of Spam protection in your group.
Spam shield uses @Spamwatch API and Global bans 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.
spiderman will constantly help banning spammers off from your group automatically So, you don't have to worry about spammers storming your group[.](https://telegra.ph/file/c1051d264a5b4146bd71e.jpg)
"""
__mod_name__ = "Spam Shield"
GBAN_HANDLER = CommandHandler("gban",
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("spamshield",
gbanstat,
pass_args=True,
• `/resetwelcome`*:* reset to the default welcome message.
• `/resetgoodbye`*:* reset to the default goodbye message.
• `/cleanwelcome <on/off>`*:* On new member, try to delete the previous welcome message to avoid spamming the chat.
• `/welcomemutehelp`*:* gives information about welcome mutes.
• `/cleanservice <on/off`*:* deletes telegrams welcome/left service messages.
*Example:*
user joined chat, user left chat.
*Welcome markdown:*
• `/welcomehelp`*:* view more formatting information for custom welcome/goodbye messages.
"""
NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members,
new_member)
LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member,
left_member)
WELC_PREF_HANDLER = CommandHandler("welcome", welcome, filters=Filters.group)
GOODBYE_PREF_HANDLER = CommandHandler("goodbye",
goodbye,
filters=Filters.group)
SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.group)
SET_GOODBYE = CommandHandler("setgoodbye", set_goodbye, filters=Filters.group)
RESET_WELCOME = CommandHandler("resetwelcome",
reset_welcome,
filters=Filters.group)
RESET_GOODBYE = CommandHandler("resetgoodbye",
reset_goodbye,
filters=Filters.group)
WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
welcomemute,
filters=Filters.group)
CLEAN_SERVICE_HANDLER = CommandHandler("cleanservice",
• `/warns <userhandle>`*:* get a user's number, and reason, of warns.
• `/warnlist`*:* list of all current warning filters
*Admins only:*
• `/warn <userhandle>`*:* warn a user. After 3 warns, the user will be banned from the group. Can also be used as a reply.
• `/resetwarn <userhandle>`*:* reset the warns for a user. Can also be used as a reply.
• `/addwarn <keyword> <reply message>`*:* set a warning filter on a certain keyword. If you want your keyword to \
be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`.
• `/nowarn <keyword>`*:* stop a warning filter
• `/warnlimit <num>`*:* set the warning limit
• `/strongwarn <on/yes/off/no>`*:* If set to on, exceeding the warn limit will result in a ban. Else, will just punch.
"""
__mod_name__ = "Warnings"
WARN_HANDLER = CommandHandler("warn", warn_user, filters=Filters.group)
RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"],
reset_warns,
filters=Filters.group)
CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn")
MYWARNS_HANDLER = DisableAbleCommandHandler("warns",
warns,
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,
import os
import logging
from telegram.ext import Updater, CommandHandler, CallbackQueryHandler, MessageHandler, Filters
from actions import start, buttons, input_text
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
updater = Updater(token=os.environ['TOKEN_BOT'], use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CallbackQueryHandler(buttons))
dispatcher.add_handler(MessageHandler(Filters.text & (~Filters.command), input_text))
updater.start_polling()
updater.idle()
sql.does_chat_gban(chat_id))
__help__ = """
*Admin only:*
- /gbanstat <on/off/yes/no>: Will disable the effect of global bans on your group, or return your current settings.
Gbans, also known as global bans, are used by the bot owners to ban 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 \
/gbanstat
"""
__mod_name__ = "Global Bans"
GBAN_HANDLER = CommandHandler("gban",
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,
(fileid, ext) = os.path.splitext(filename)
out_path = os.path.join(path, fileid)
if os.path.isdir(out_path):
if len(list(filter(lambda s: s.endswith(".wav"), os.listdir(out_path)))) == 2:
print("Already spleeted, skipping...")
return out_path
separator.separate_to_file(file_path, path)
return out_path
updater = Updater(bot_key)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('ls', ls, filters=filters['admins']))
dispatcher.add_handler(CommandHandler('loadconfig', reloadconfig, filters=filters['admins']))
dispatcher.add_handler(MessageHandler(Filters.audio & filters['authorized'], audio))
dispatcher.add_handler(MessageHandler(Filters.text & (~Filters.command), echo))
updater.start_polling()
updater.idle()
def _init(self) -> None:
"""
Initializes this module with the given config,
registers all known command handlers
and starts polling for message updates
"""
self._updater = Updater(token=self._config['telegram']['token'],
workers=0,
use_context=True)
# Register command handler and start telegram message polling
handles = [
CommandHandler('status', self._status),
CommandHandler('profit', self._profit),
CommandHandler('balance', self._balance),
CommandHandler('start', self._start),
CommandHandler('stop', self._stop),
CommandHandler('forcesell', self._forcesell),
CommandHandler('forcebuy', self._forcebuy),
CommandHandler('trades', self._trades),
CommandHandler('delete', self._delete_trade),
CommandHandler('performance', self._performance),
CommandHandler('stats', self._stats),
CommandHandler('daily', self._daily),
CommandHandler('count', self._count),
CommandHandler('locks', self._locks),
CommandHandler(['unlock', 'delete_locks'], self._delete_locks),
CommandHandler(['reload_config', 'reload_conf'],
self._reload_config),
CommandHandler(['show_config', 'show_conf'], self._show_config),
CommandHandler('stopbuy', self._stopbuy),
CommandHandler('whitelist', self._whitelist),
CommandHandler('blacklist', self._blacklist),
CommandHandler('logs', self._logs),
CommandHandler('edge', self._edge),
CommandHandler('help', self._help),
CommandHandler('version', self._version),
]
callbacks = [
CallbackQueryHandler(self._status_table,
pattern='update_status_table'),
CallbackQueryHandler(self._daily, pattern='update_daily'),
CallbackQueryHandler(self._profit, pattern='update_profit'),
CallbackQueryHandler(self._balance, pattern='update_balance'),
CallbackQueryHandler(self._performance,
pattern='update_performance'),
CallbackQueryHandler(self._count, pattern='update_count'),
CallbackQueryHandler(self._forcebuy_inline),
]
for handle in handles:
self._updater.dispatcher.add_handler(handle)
for callback in callbacks:
self._updater.dispatcher.add_handler(callback)
self._updater.start_polling(
bootstrap_retries=-1,
timeout=30,
read_latency=60,
drop_pending_updates=True,
)
logger.info('rpc.telegram is listening for following commands: %s',
[h.command for h in handles])
changes = json.loads(res.text).get('LightGingerTheTextResult')
curr_string = ""
prev_end = 0
for change in changes:
start = change.get('From')
end = change.get('To') + 1
suggestions = change.get('Suggestions')
if suggestions:
sugg_str = suggestions[0].get(
'Text') # should look at this list more
curr_string += msg.text[prev_end:start] + sugg_str
prev_end = end
curr_string += msg.text[prev_end:]
print(curr_string)
update.effective_message.reply_text(curr_string)
__help__ = """
- /t: පණිවිඩයකට පිළිතුරු දෙන අතරම, ව්යාකරණ නිවැරදි කරන ලද අනුවාදයකින් පිළිතුරු දෙනු ඇත
"""
__mod_name__ = "Translator"
TRANSLATE_HANDLER = CommandHandler('t', translate)
dispatcher.add_handler(TRANSLATE_HANDLER)
try:
region = context.user_data['region']
except KeyError:
region = 'kr'
images = get_page(context.user_data['champ'], region, line)
for image in images:
bio = BytesIO()
bio.name = 'image.png'
image.save(bio, 'PNG')
bio.seek(0)
updater.bot.send_photo(chat_id=update.callback_query.message.chat_id,
photo=bio)
if __name__ == '__main__':
with open('champions_out.json', 'r+') as champs:
champions = json.load(champs)
updater = Updater(token=TOKEN, use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('reg', region))
dispatcher.add_handler(CommandHandler('region', region))
dispatcher.add_handler(CommandHandler('r', runes))
dispatcher.add_handler(CommandHandler('runes', runes))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
updater.start_polling()
updater.idle()
from telegram.ext import Updater, MessageHandler, Filters, CommandHandler
def start(update, context):
chat = update.effective_chat
context.bot.send_message(chat_id=chat.id, text="Hello! This is own finances bot.")
def echo(update, context):
update.message.reply_text(update.message.text)
updater = Updater("")
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(MessageHandler(Filters.all, echo))
updater.start_polling()
updater.idle()
❍ /setbio <text>*:* while replying, will save another user's bio
*Examples:* 💡
➩ /bio @username(defaults to yours if not specified).`
➩ /setbio This user is a wolf` (reply to the user)
*Overall Information about you:*
❍ /info*:* get information about a user.
*What is that health thingy?*
Come and see [HP System explained](https://t.me/OnePunchUpdates/192)
"""
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)
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.
• `/gifid`*:* reply to a gif to me to tell you its file ID.
• `/info`*:* get information about a user.
• `/markdownhelp`*:* quick summary of how markdown works in telegram - can only be called in private chats.
"""
ID_HANDLER = DisableAbleCommandHandler("id", get_id)
GIFID_HANDLER = DisableAbleCommandHandler("gifid", gifid)
INFO_HANDLER = DisableAbleCommandHandler(["info"], info)
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(INFO_HANDLER)
dispatcher.add_handler(ECHO_HANDLER)
dispatcher.add_handler(MD_HELP_HANDLER)
dispatcher.add_handler(STATS_HANDLER)
__mod_name__ = "Misc"
__command_list__ = ["id", "info", "echo"]
__handlers__ = [
ID_HANDLER, GIFID_HANDLER, INFO_HANDLER, ECHO_HANDLER, MD_HELP_HANDLER,
STATS_HANDLER
def main():
"""Run bot."""
# Create the Updater and pass it your bot's token.
# Make sure to set use_context=True to use the new context based callbacks
# Post version 12 this will no longer be necessary
#updater = Updater("", use_context=True)
updater = Updater(TOKEN, use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("bots", bots))
dp.add_handler(CommandHandler("news", news))
dp.add_handler(CommandHandler("lifestyle", lifestyle))
dp.add_handler(CommandHandler("food", food))
dp.add_handler(CommandHandler("deals", deals))
dp.add_handler(CommandHandler("transport", transport))
dp.add_handler(CommandHandler("jobs", jobs))
dp.add_handler(CommandHandler("airfare", airfare))
dp.add_handler(CommandHandler("finance", finance))
dp.add_handler(CommandHandler("donate", donate))
# log all errors
dp.add_error_handler(error)
# Start the Bot
#comment this line to host on heroku
#updater.start_polling()
#Uncomment below lines for heroku
updater.start_webhook(listen="0.0.0.0",
port=int(PORT),
url_path=TOKEN)
updater.bot.setWebhook('https://bot4bots.herokuapp.com/' + TOKEN)
# Block until you press Ctrl-C or the process receives SIGINT, SIGTERM or
# SIGABRT. This should be used most of the time, since start_polling() is
# non-blocking and will stop the bot gracefully.
updater.idle()
@connection_status
def commands(update: Update, context: CallbackContext):
chat = update.effective_chat
update.effective_message.reply_text(build_curr_disabled(chat.id),
parse_mode=ParseMode.MARKDOWN)
def __stats__():
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
LOGGER.info(f'{link}: {e}')
listener = MirrorListener(bot, update, isTar, tag)
ariaDlManager.add_download(link, f'{DOWNLOAD_DIR}/{listener.uid}/',
listener)
sendStatusMessage(update, bot)
if len(Interval) == 0:
Interval.append(
setInterval(DOWNLOAD_STATUS_UPDATE_INTERVAL, update_all_messages))
@run_async
def mirror(update, context):
_mirror(context.bot, update)
@run_async
def tar_mirror(update, context):
_mirror(context.bot, update, True)
mirror_handler = CommandHandler(BotCommands.MirrorCommand,
mirror,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user)
tar_mirror_handler = CommandHandler(BotCommands.TarMirrorCommand,
tar_mirror,
filters=CustomFilters.authorized_chat
| CustomFilters.authorized_user)
dispatcher.add_handler(mirror_handler)
dispatcher.add_handler(tar_mirror_handler)
__help__ = """
• `/admins`*:* list of admins in the chat
*Admins 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
• `/title <title here>`*:* sets a custom title for an admin that the bot promoted
• `/admincache`*:* force refresh the admins list
"""
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)
SET_TITLE_HANDLER = CommandHandler("title", set_title)
ADMIN_REFRESH_HANDLER = CommandHandler("admincache",
refresh_admin,
filters=Filters.group)
dispatcher.add_handler(ADMINLIST_HANDLER)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
bot.answer_callback_query(query.id)
if query_type == "db_leave_chat":
if query.from_user.id in admin_list:
bot.editMessageText("Leaving chats ...", chat_id, message.message_id)
chat_count = get_muted_chats(update, context, True)
bot.sendMessage(chat_id, f"Left {chat_count} chats.")
else:
query.answer("You are not allowed to use this.")
elif query_type == "db_cleanup":
if query.from_user.id in admin_list:
bot.editMessageText("Cleaning up DB ...", chat_id, message.message_id)
invalid_chat_count = get_invalid_chats(update, context, True)
invalid_gban_count = get_invalid_gban(update, context, True)
reply = "Cleaned up {} chats and {} gbanned users from db.".format(
invalid_chat_count, invalid_gban_count
)
bot.sendMessage(chat_id, reply)
else:
query.answer("You are not allowed to use this.")
DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup)
BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*")
dispatcher.add_handler(DB_CLEANUP_HANDLER)
dispatcher.add_handler(BUTTON_HANDLER)
__mod_name__ = "DB Cleanup"
__handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER]
- /blacklist: Lihat kata-kata daftar hitam saat ini.
*Hanya admin:*
- /addblacklist <pemicu>: Tambahkan pemicu ke daftar hitam. Setiap baris dianggap sebagai pemicu, jadi gunakan garis yang \
berbeda akan memungkinkan Anda menambahkan beberapa pemicu.
- /unblacklist <pemicu>: Hapus pemicu dari daftar hitam. Logika newline yang sama berlaku di sini, sehingga Anda dapat \
menghapus beberapa pemicu sekaligus.
- /rmblacklist <pemicu>: Sama seperti di atas.
"""
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,
edited_updates=True)
dispatcher.add_handler(BLACKLIST_HANDLER)
dispatcher.add_handler(ADD_BLACKLIST_HANDLER)
dispatcher.add_handler(UNBLACKLIST_HANDLER)
dispatcher.add_handler(BLACKLISTMODE_HANDLER)
def __migrate__(old_chat_id, new_chat_id):
sql.migrate_chat(old_chat_id, new_chat_id)
def __stats__():
return "• `{}` blacklist triggers, across `{}` chats.".format(
sql.num_blacklist_filters(), sql.num_blacklist_filter_chats())
__help__ = True
#TODO: Add blacklist alternative modes: warn, ban, kick, or mute.
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)
data = load(f)
assert token_str in data.keys()
os.environ[token_str] = data[token_str]
assert token_str in os.environ.keys()
TOKEN = os.environ.get(token_str)
PORT = int(os.environ.get('PORT', '5000'))
#################################################
updater = Updater(TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('hello', hello))
dispatcher.add_handler(MessageHandler(Filters.text, echo))
print("finish set up bot.")
updater.start_webhook(listen="0.0.0.0",
port=PORT,
url_path="" + TOKEN)
updater.bot.set_webhook("https://yodabotrus.herokuapp.com/" + TOKEN)
# time to try webhooks
# updater.start_polling()
print("before idle")
def return_to_news_list(update, context):
bot_message = form_news_list()
keyboard_markup = InlineKeyboardMarkup([
[InlineKeyboardButton(text="Подробнее", callback_data='news_more'),
InlineKeyboardButton(text='Показать все', callback_data='news_show_all')]
])
context.bot.edit_message_text(
chat_id=update.callback_query.message.chat_id,
message_id=update.callback_query.message.message_id,
text=bot_message
)
context.bot.edit_message_reply_markup(
chat_id=update.callback_query.message.chat_id,
message_id=update.callback_query.message.message_id,
reply_markup=keyboard_markup
)
dp.add_handler(CommandHandler(command='news', callback=do_news), group=1)
dp.add_handler(CallbackQueryHandler(callback=more_news, pattern='news_more'), group=1)
dp.add_handler(CallbackQueryHandler(callback=show_all_news, pattern='news_show_all'), group=1)
dp.add_handler(CallbackQueryHandler(callback=find_news, pattern=r'news: .+'), group=1)
dp.add_handler(CallbackQueryHandler(callback=news_back, pattern='news_back'), group=1)
dp.add_handler(CallbackQueryHandler(callback=news_back_to_all, pattern='news_to_all'), group=1)
dp.add_handler(CallbackQueryHandler(callback=return_to_news_list, pattern='news_return'), group=1)
chat.id, "admin_reaction_status").format('enabled' if status ==
True else 'disabled'),
parse_mode=ParseMode.MARKDOWN)
__help__ = True
PIN_HANDLER = DisableAbleCommandHandler("pin",
pin,
pass_args=True,
filters=Filters.group)
UNPIN_HANDLER = DisableAbleCommandHandler("unpin",
unpin,
filters=Filters.group)
INVITE_HANDLER = CommandHandler("invitelink", invite)
PROMOTE_HANDLER = DisableAbleCommandHandler("promote", promote, pass_args=True)
DEMOTE_HANDLER = DisableAbleCommandHandler("demote", demote, pass_args=True)
REACT_HANDLER = DisableAbleCommandHandler("reaction",
reaction,
pass_args=True,
filters=Filters.group)
ADMINLIST_HANDLER = DisableAbleCommandHandler(["adminlist", "admins"],
adminlist)
dispatcher.add_handler(PIN_HANDLER)
dispatcher.add_handler(UNPIN_HANDLER)
dispatcher.add_handler(INVITE_HANDLER)
def __chat_settings__(chat_id, user_id):
return build_curr_disabled(chat_id)
__mod_name__ = "Command disabling"
__help__ = """
- /cmds: check the current status of disabled commands
*Admin only:*
- /enable <cmd name>: enable that command
- /disable <cmd name>: disable that command
- /listcmds: list all possible toggleable commands
"""
DISABLE_HANDLER = CommandHandler("disable",
disable,
pass_args=True,
filters=Filters.group)
ENABLE_HANDLER = CommandHandler("enable",
enable,
pass_args=True,
filters=Filters.group)
COMMANDS_HANDLER = CommandHandler(["cmds", "disabled"],
commands,
filters=Filters.group)
TOGGLE_HANDLER = CommandHandler("listcmds",
list_cmds,
filters=Filters.group)
dispatcher.add_handler(DISABLE_HANDLER)
dispatcher.add_handler(ENABLE_HANDLER)
dispatcher.add_handler(COMMANDS_HANDLER)
__help__ = """
*Add multiple RSS feeds in your groups!*
- /addrss <link>: Add an RSS link to the subscriptions.
- /removerss <link>: Removes the RSS link from the subscriptions.
- /rss <link>: Shows the link's data and the last entry, for testing purposes.
- /listrss: Shows the list of RSS feeds that the chat is currently subscribed to.
*NOTE:* In groups, only admins can add/remove RSS links to the group's subscription.
"""
__mod_name__ = "RSS Feed"
job = updater.job_queue
job_rss_set = job.run_once(rss_set, 5)
job_rss_update = job.run_repeating(rss_update, interval=60, first=60)
job_rss_set.enabled = True
job_rss_update.enabled = True
SHOW_URL_HANDLER = CommandHandler("rss", show_url, pass_args=True)
ADD_URL_HANDLER = CommandHandler("addrss", add_url, pass_args=True)
REMOVE_URL_HANDLER = CommandHandler("removerss", remove_url, pass_args=True)
LIST_URLS_HANDLER = CommandHandler("listrss", list_urls)
dispatcher.add_handler(SHOW_URL_HANDLER)
dispatcher.add_handler(ADD_URL_HANDLER)
dispatcher.add_handler(REMOVE_URL_HANDLER)
dispatcher.add_handler(LIST_URLS_HANDLER)
)
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("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}"
)
elif len(args) == 1:
update.effective_message.reply_text(__help__, parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
f"*Invalid Args!!:* Required 3 But Passed {len(args) -1}",
parse_mode=ParseMode.MARKDOWN,
)
CONVERTER_HANDLER = CommandHandler("cash", convert, run_async=True)
dispatcher.add_handler(CONVERTER_HANDLER)
__command_list__ = ["cash"]
__handlers__ = [CONVERTER_HANDLER]
