def test_pass_job_or_update_queue(self, dp, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_queue_1, pass_job_queue=True)
dp.add_handler(handler)
dp.process_update(chosen_inline_result)
assert self.test_flag
dp.remove_handler(handler)
handler = ChosenInlineResultHandler(self.callback_queue_1, pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(chosen_inline_result)
assert self.test_flag
dp.remove_handler(handler)
handler = ChosenInlineResultHandler(self.callback_queue_2,
pass_job_queue=True,
pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(chosen_inline_result)
assert self.test_flag
def main():
config = {
'handlers': [
{
'sink': sys.stdout,
'level': 'INFO'
},
{
'sink': 'logs/logs.log',
'serialize': False,
'level': 'DEBUG'
},
],
}
logger.configure(**config)
logger.info('Bot has started')
NotetonUsersManager.init_instance()
updater = Updater(token, use_context=True)
dp = updater.dispatcher
updater.logger = logger
dp.logger = logger
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("create_list", create_list))
dp.add_handler(CommandHandler("my_lists", my_lists))
dp.add_handler(CommandHandler("info_and_help", info_and_help))
dp.add_handler(CommandHandler("send_feedback", feedback))
dp.add_handler(CommandHandler("stat", get_stat))
dp.add_handler(CommandHandler("help", info_and_help))
dp.add_handler(InlineQueryHandler(inline_query))
dp.add_handler(ChosenInlineResultHandler(chosen_inline_result_handler))
dp.add_handler(CallbackQueryHandler(callback_query_handler))
dp.add_handler(MessageHandler(Filters.text, message_handler))
dp.add_handler(MessageHandler(Filters.photo, photo_handler))
dp.add_handler(MessageHandler(Filters.sticker, sticker_handler))
dp.add_handler(MessageHandler(Filters.animation, gif_handler))
dp.add_handler(MessageHandler(Filters.audio, audio_handler))
dp.add_handler(MessageHandler(Filters.document, document_handler))
dp.add_handler(MessageHandler(Filters.all, test_handler))
updater.start_polling()
updater.idle()
def set_handlers(dp):
add_handler = ConversationHandler(
entry_points=[
MessageHandler(VideoFilter(), video_msg, pass_user_data=True)
],
states={
CAPTION:
[MessageHandler(Filters.text, caption_msg, pass_user_data=True)]
},
fallbacks=[CommandHandler('cancel', cancel)])
dp.add_handler(add_handler)
dp.add_handler(CommandHandler('start', start))
dp.add_handler(CommandHandler('help', help))
dp.add_handler(ChosenInlineResultHandler(inline_result))
dp.add_handler(InlineQueryHandler(inline_query))
dp.add_handler(MessageHandler(Filters.all, other_msg))
dp.add_error_handler(error)
def main():
# Create the Updater and pass it your bot's token.
updater = Updater(os.getenv('TELEGRAM_TOKEN'))
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(InlineQueryHandler(inlinequery))
dp.add_handler(ChosenInlineResultHandler(appendimage))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Block until the user presses 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()
def main():
updater = Updater(config.TOKEN)
dp = updater.dispatcher
dp.add_handler(handlers.conversation)
dp.add_handler(MessageHandler(is_in_database, handlers.meme))
dp.add_handler(CommandHandler('name', handlers.name))
dp.add_handler(CommandHandler('delete', handlers.delete))
dp.add_handler(CommandHandler('rename', handlers.rename, pass_args=True))
dp.add_handler(CommandHandler('fix', handlers.fix))
dp.add_handler(CommandHandler('my', handlers.my))
dp.add_handler(CommandHandler(['start', 'help'], handlers.help_))
dp.add_handler(RegexHandler('/(?P<id>\d+)', handlers.get_by_id, pass_groupdict=True))
dp.add_handler(InlineQueryHandler(handlers.inlinequery))
dp.add_handler(ChosenInlineResultHandler(handlers.chosen_inline_result))
dp.add_error_handler(error_handler)
updater.start_polling()
updater.idle()
def main():
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
print('bot start')
updater.dispatcher.add_handler(
CommandHandler('mmsi', vesselinfo, None, False, True))
updater.dispatcher.add_handler(
CommandHandler('globallastposdate',
globallastposdate,
None,
False,
pass_args=True))
updater.dispatcher.add_handler(InlineQueryHandler(inlinequery))
updater.dispatcher.add_handler(
ChosenInlineResultHandler(process_chosen,
pass_user_data=True,
pass_chat_data=True,
pass_update_queue=True))
updater.start_polling()
updater.idle()
def main():
users = defaultdict(User)
updater = Updater(BOT_TOKEN)
dp = updater.dispatcher
dp.add_handler(InlineQueryHandler(on_inline))
dp.add_handler(ChosenInlineResultHandler(on_inline_chosen))
dp.add_handler(
CallbackQueryHandler(
lambda bot, update: on_callback_query(bot, update, users)))
dp.add_handler(
CommandHandler(
'start',
lambda bot, update, args: cmd_start(bot, update, args, users),
pass_args=True))
dp.add_handler(
CommandHandler('cancel',
lambda bot, update: cmd_cancel(bot, update, users)))
dp.add_handler(CommandHandler('clear', cmd_clear))
dp.add_handler(CommandHandler('help', cmd_help))
dp.add_handler(CommandHandler('unban', cmd_unban, pass_args=True))
dp.add_handler(
MessageHandler(Filters.all,
lambda bot, update: on_message(bot, update, users)))
dp.add_error_handler(error)
j = updater.job_queue
j.run_repeating(lambda bot, job: database.store_request_count(),
interval=5,
first=0)
j.run_repeating(job_forget_old_owners, interval=60, first=0)
updater.start_polling()
updater.idle()
def main():
global popularity
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO,
)
# load popularity numbers from disk
if popularity_filename:
try:
with open(popularity_filename, "r") as popularity_data:
popularity = json.load(popularity_data)
logging.info(
f"popularity numbers loaded from {popularity_filename}.")
except FileNotFoundError:
logging.warning(
f"popularity data could not be found at {popularity_filename}; counting from scratch."
)
else:
logging.warning(
"POPULARITY_DATA not set, popularity will not be saved for this session."
)
u = Updater(token=api_token, use_context=True)
d = u.dispatcher
d.add_handler(InlineQueryHandler(callback=process_query, ))
d.add_handler(ChosenInlineResultHandler(callback=count_hits, ))
d.add_error_handler(report_error)
j = u.job_queue
if ranking_update_frequency:
j.run_repeating(update_ranking, ranking_update_frequency)
else:
update_ranking(None) # guarantees update_ranking runs on startup
u.start_polling()
u.idle()
def __init__(self, token):
super().__init__(token)
self.dispatcher.add_handler(InlineQueryHandler(self.inline_query_dispatcher))
self.inline_query = []
#
def callback_query_handler(bot, update):
logging.log(logging.WARNING, "Unimplemented event callback_query_handler:")
print("\t" + str(update))
def message_handler(bot, update):
logging.log(logging.WARNING, "Unimplemented event message_handler:")
print("\t" + str(update))
def chosen_inline_result_handler(bot, update):
logging.log(logging.WARNING, "Unimplemented event chosen_inline_result_handler:")
print("\t" + str(update))
self.dispatcher.add_handler(CallbackQueryHandler(callback_query_handler))
# self.dispatcher.add_handler(MessageHandler([], message_handler)) TODO except commands
self.dispatcher.add_handler(ChosenInlineResultHandler(chosen_inline_result_handler))
def main():
module_logger.info("Vigibot starting...")
updater = Updater(token=BOT_TOKEN, use_context=True)
dispatcher = updater.dispatcher
# bot's error handler
dispatcher.add_error_handler(error)
# bot's command handlers
ola_handler = CommandHandler('ola', bom_dia, run_async=True)
dispatcher.add_handler(ola_handler)
# ola_handler2 = CommandHandler('olá', bom_dia)
# dispatcher.add_handler(ola_handler2)
alerta_handler = CommandHandler('alerta',
alerta,
pass_args=True,
pass_user_data=True,
run_async=True)
dispatcher.add_handler(alerta_handler)
unknown_handler = MessageHandler(Filters.command, unknown, run_async=True)
dispatcher.add_handler(unknown_handler)
location_handler = MessageHandler(Filters.location,
location,
pass_user_data=True,
run_async=True)
dispatcher.add_handler(location_handler)
dispatcher.add_handler(InlineQueryHandler(inlinequery, run_async=True))
result_chosen_handler = ChosenInlineResultHandler(on_inline_result_chosen)
dispatcher.add_handler(result_chosen_handler)
updater.start_polling()
updater.idle()
def main():
# 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
persistence = PicklePersistence(filename=USERPREF_PATH,
store_user_data=True,
store_chat_data=False,
singe_file=False,
on_flush=False)
updater = Updater(os.environ["TOKEN"],
use_context=True,
persistence=persistence)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("ayuda", help))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("start", help))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(InlineQueryHandler(inlinequery))
# Handle selection so we store that for latter use.
dp.add_handler(ChosenInlineResultHandler(inlinequeryselected))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Block until the user presses 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()
def main():
updater = Updater(config.TOKEN)
dp = updater.dispatcher
dp.add_handler(CommandHandler(['start', 'help'], handlers.help_))
dp.add_handler(handlers.conversation)
dp.add_handler(
MessageHandler(Filters.private & Filters.sticker & is_in_database,
handlers.sticker))
dp.add_handler(CommandHandler(['info', 'stats'], handlers.info))
dp.add_handler(
CommandHandler('add_tags', handlers.add_tags, pass_args=True))
dp.add_handler(
CommandHandler('delete_tag', handlers.delete_tag, pass_args=True))
dp.add_handler(CommandHandler('delete', handlers.delete))
dp.add_handler(CommandHandler('my', handlers.my))
dp.add_handler(
RegexHandler('/(?P<id>\d+)', handlers.get_by_id, pass_groupdict=True))
dp.add_handler(InlineQueryHandler(handlers.inlinequery))
dp.add_handler(ChosenInlineResultHandler(handlers.chosen_inline_result))
with open('admins.json') as f:
admins = json.load(f)
dp.add_handler(
CommandHandler('admin_delete_tag',
filter_user_ids(admins, handlers.admin_delete_tag),
pass_args=True))
dp.add_handler(
CommandHandler('admin_delete',
filter_user_ids(admins, handlers.admin_delete)))
dp.add_error_handler(error_handler)
updater.start_polling()
updater.idle()
def main():
load_files()
updater = Updater(config['token'], use_context=True, workers=10)
dispatcher = updater.dispatcher
global bot
bot = updater.bot
# register a handler to ignore all non-private updates
dispatcher.add_handler(MessageHandler(~Filters.private,
do_fucking_nothing))
# register commands
dispatcher.add_handler(CommandHandler('broadcast', broadcast_command))
dispatcher.add_handler(CommandHandler('donate', donate_command))
dispatcher.add_handler(CommandHandler('help', help_command))
dispatcher.add_handler(CommandHandler('icon', icon_command))
dispatcher.add_handler(CommandHandler('info', info_command))
dispatcher.add_handler(CommandHandler('lang', change_lang_command))
dispatcher.add_handler(CommandHandler('langstats', lang_stats_command))
dispatcher.add_handler(CommandHandler('log', log_command))
dispatcher.add_handler(CommandHandler(['optin', 'optout'], opt_command))
dispatcher.add_handler(CommandHandler('restart', restart_command))
dispatcher.add_handler(CommandHandler('start', start_command))
dispatcher.add_handler(CommandHandler('stats', stats_command))
# register invalid command handler
dispatcher.add_handler(MessageHandler(Filters.command, invalid_command))
# register media listener
dispatcher.add_handler(
MessageHandler((Filters.photo | Filters.document), image_received))
dispatcher.add_handler(MessageHandler(Filters.sticker, sticker_received))
dispatcher.add_handler(MessageHandler(Filters.text, url_received))
dispatcher.add_handler(MessageHandler(Filters.all, invalid_content))
# register button handlers
dispatcher.add_handler(
CallbackQueryHandler(change_lang_callback, pattern="lang"))
dispatcher.add_handler(
CallbackQueryHandler(icon_cancel_callback, pattern="icon_cancel"))
# register inline handlers
dispatcher.add_handler(
InlineQueryHandler(share_query_received,
pattern=re.compile("^share$", re.IGNORECASE)))
dispatcher.add_handler(
InlineQueryHandler(file_id_query_received, pattern=re.compile("")))
dispatcher.add_handler(InlineQueryHandler(share_query_received))
dispatcher.add_handler(ChosenInlineResultHandler(inline_result_chosen))
# register variable dump loop
updater.job_queue.run_repeating(save_files, config['save_interval'],
config['save_interval'])
# register error handler
dispatcher.add_error_handler(handle_error)
updater.start_polling(clean=True, timeout=99999)
print("Bot finished starting")
updater.idle()
def main(updater):
dispatcher = updater.dispatcher
dbFuncs.initDB()
newcomm = CommandHandler('new', new, Filters.private)
startcomm = CommandHandler('start', start, Filters.private, pass_args=True)
cancelcomm = CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
sendcomm = CommandHandler(
'send', sendAll, Filters.private & Filters.chat(chat_id=[114951690]))
helpcomm = CommandHandler('help', help, Filters.private)
backupcomm = CommandHandler('backup', backup, Filters.private)
settingscomm = CommandHandler('settings', settings, Filters.private)
pushinlinecall = CallbackQueryHandler(pushInline,
pattern=r"^" + patterns[0])
pushadmincall = CallbackQueryHandler(pushAdmin, pattern=r"^" + patterns[1])
settingsmaincall = CallbackQueryHandler(settings_main,
pattern=r"^" + patterns[2])
settingslangcall = CallbackQueryHandler(settings_language,
pattern=r"^" + patterns[3])
setnamemess = MessageHandler(Filters.text & Filters.private, setName)
blankcodemess = MessageHandler(Filters.private & Filters.regex(r'^\/.*'),
blankCode)
editmessagemess = MessageHandler(
Filters.private & Filters.text & Filters.update.edited_message,
editMessage)
rcvreplymess = MessageHandler(
Filters.private & Filters.text & Filters.reply &
(~Filters.update.edited_message), rcvReply)
rcvmessagemess = MessageHandler(
Filters.private & Filters.text & (~Filters.update.edited_message),
rcvMessage)
newlistconv = ConversationHandler(entry_points=[newcomm, startcomm],
states={SETNAME: [setnamemess]},
fallbacks=[cancelcomm],
persistent=True,
name="newlist")
listhandlerconv = ConversationHandler(
entry_points=[pushinlinecall],
states={SETTINGS: [pushadmincall]},
fallbacks=[pushinlinecall, cancelcomm],
persistent=True,
name="listhandler",
per_message=True)
settingshandlerconv = ConversationHandler(entry_points=[settingsmaincall],
states={
SETTINGS: [settingsmaincall],
LANGUAGE: [settingslangcall]
},
fallbacks=[cancelcomm],
persistent=True,
name="settingshandler",
per_message=True)
dispatcher.add_handler(newlistconv)
dispatcher.add_handler(listhandlerconv)
dispatcher.add_handler(settingshandlerconv)
dispatcher.add_handler(pushinlinecall)
dispatcher.add_handler(CallbackQueryHandler(fixButtons))
dispatcher.add_handler(sendcomm)
dispatcher.add_handler(helpcomm)
dispatcher.add_handler(backupcomm)
dispatcher.add_handler(settingscomm)
dispatcher.add_handler(InlineQueryHandler(inlineQuery))
dispatcher.add_handler(ChosenInlineResultHandler(chosenQuery))
dispatcher.add_handler(blankcodemess)
dispatcher.add_handler(editmessagemess)
dispatcher.add_handler(rcvreplymess)
dispatcher.add_handler(rcvmessagemess)
dispatcher.add_error_handler(contextCallback)
updater.start_polling()
updater.idle()
name1=player.prev.user.first_name,
name2=player.user.first_name))
try:
player.draw()
except DeckEmptyError:
send_async(bot,
player.game.chat.id,
text=__("There are no more cards in the deck.",
multi=game.translate))
game.turn()
# Add all handlers to the dispatcher and run the bot
dispatcher.add_handler(InlineQueryHandler(reply_to_query))
dispatcher.add_handler(ChosenInlineResultHandler(process_result))
dispatcher.add_handler(CallbackQueryHandler(select_game))
dispatcher.add_handler(CommandHandler('start', start_game, pass_args=True))
dispatcher.add_handler(CommandHandler('new', new_game))
dispatcher.add_handler(CommandHandler('join', join_game))
dispatcher.add_handler(CommandHandler('leave', leave_game))
dispatcher.add_handler(CommandHandler('open', open_game))
dispatcher.add_handler(CommandHandler('close', close_game))
dispatcher.add_handler(
CommandHandler('enable_translations', enable_translations))
dispatcher.add_handler(
CommandHandler('disable_translations', disable_translations))
dispatcher.add_handler(CommandHandler('skip', skip_player))
dispatcher.add_handler(CommandHandler('notify_me', notify_me))
simple_commands.register()
settings.register()
def test_context(self, cdp, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_context)
cdp.add_handler(handler)
cdp.process_update(chosen_inline_result)
assert self.test_flag
if player.waiting_time < WAITING_TIME:
player.waiting_time = WAITING_TIME
send_async(bot,
chat.id,
text=__(
"Waiting time for {name} has been reset to {time} "
"seconds",
multi=player.game.translate).format(name=display_name(
player.user),
time=WAITING_TIME))
# Add all handlers to the dispatcher and run the bot
dispatcher.add_handler(InlineQueryHandler(reply_to_query))
dispatcher.add_handler(
ChosenInlineResultHandler(process_result, pass_job_queue=True))
dispatcher.add_handler(CallbackQueryHandler(select_game))
dispatcher.add_handler(
CommandHandler('start', start_game, pass_args=True, pass_job_queue=True))
dispatcher.add_handler(CommandHandler('new', new_game))
dispatcher.add_handler(CommandHandler('kill', kill_game))
dispatcher.add_handler(CommandHandler('join', join_game))
dispatcher.add_handler(CommandHandler('leave', leave_game))
dispatcher.add_handler(CommandHandler('kick', kick_player))
dispatcher.add_handler(CommandHandler('open', open_game))
dispatcher.add_handler(CommandHandler('close', close_game))
dispatcher.add_handler(
CommandHandler('enable_translations', enable_translations))
dispatcher.add_handler(
CommandHandler('disable_translations', disable_translations))
dispatcher.add_handler(CommandHandler('skip', skip_player))
bot.answerCallbackQuery(query.id, 'Message not found')
return
if user.lower() == sender.lower() or user.lower() in receivers.lower(
) or user.lower() in gods.lower():
bot.answerCallbackQuery(query.id, message, show_alert=True)
else:
bot.answerCallbackQuery(query.id,
"You can't read this message",
show_alert=True)
def error(bot, update, error):
logging.warning('Update "%s" caused error "%s"' % (update, error))
updater = Updater(token)
dp = updater.dispatcher
dp.add_handler(InlineQueryHandler(inline_whisper))
dp.add_handler(CallbackQueryHandler(show_message))
dp.add_handler(ChosenInlineResultHandler(chosen))
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
dispatcher.add_handler(
CallbackQueryHandler(handle_callback_query,
pattern=get_callback_mapping_regex()))
dispatcher.add_handler(
CallbackQueryHandler(
handle_async_callback_query,
pattern=get_async_callback_mapping_regex(),
run_async=True,
))
# InlineQuery handler
dispatcher.add_handler(InlineQueryHandler(search, run_async=True))
# InlineQuery result handler
dispatcher.add_handler(
ChosenInlineResultHandler(handle_chosen_inline_result, run_async=True))
# Set the log level for apscheduler to WARNING
# There's a lot of log output spam otherwise
logging.getLogger("apscheduler").setLevel(logging.WARNING)
# Register all jobs
minute = 60
hour = 60 * minute
job_queue = updater.job_queue
job_queue.run_repeating(
delete_polls,
interval=5,
first=0,
name="Delete polls that are scheduled for deletion.",
)
def main():
updater = None
dp = None
bot = None
botnick = "bot"
connected = False
parse_mode = "IRC"
tsleep = 0
batching = False
batchtarget = ""
batchmsg = ""
try:
send("X :Waiting for PASS with Telegram bot token")
import sys
while True:
line = sys.stdin.readline()
if not line:
break
prefix, cmd_orig, args = irc_parse(line)
cmd = cmd_orig.upper()
chat_id = None # make sure this isn't set to the old value.
anywork = True
if cmd == "PASS":
if not updater:
updater = Updater(args[0])
dp = updater.dispatcher
bot = dp.bot
botnick = bot.username or botnick
#dp.add_handler(CommandHandler("start", start))
dp.add_handler(MessageHandler([Filters.text], on_msg))
dp.add_handler(MessageHandler([Filters.command], on_msg))
dp.add_handler(
MessageHandler([Filters.sticker], on_sticker))
dp.add_handler(InlineQueryHandler(on_inlinequery))
dp.add_handler(
ChosenInlineResultHandler(on_inlinequeryresult))
updater.dispatcher.add_handler(
CallbackQueryHandler(on_button_pressed))
dp.add_error_handler(error) # log all errors
#updater.job_queue.put(Job(asdfasdf, 10, repeat=True, context=None))
updater.start_polling()
elif cmd == "NICK":
#botnick = args[0]
if not connected:
connected = True
send(":" + SERVER_NAME + " 001 " + botnick +
" :Welcome to Telegram")
send((
":" + SERVER_NAME + " 005 " + botnick +
" NETWORK=Telegram CASEMAPPING=ascii" +
" CHANTYPES=#&!+ TPARSEMODE=IRC,Plain,HTML,Markdown NICKLEN=500 TSLEEP TBATCHMSG :are supported by this server"
))
send(":" + SERVER_NAME + " 422 " + botnick + " :No MOTD")
elif cmd == "TSLEEP":
if len(args) > 0:
tsleep = float(args[0])
send(":" + SERVER_NAME + " 300 " + cmd + " :" + str(tsleep))
elif cmd == "USER":
anywork = False
elif cmd == "JOIN":
anywork = False
elif cmd == "PART":
anywork = False
elif cmd == "BATCH":
anywork = False
try:
if batching and batchtarget and batchmsg:
sendbotmsg(bot, batchtarget, batchmsg, parse_mode)
anywork = True
finally:
batching = False
batchtarget = ""
batchmsg = ""
if len(args) >= 2 and args[0][0] == '+' and args[
1] == SERVER_NAME + "/TBATCHMSG":
batching = True
elif cmd == "PRIVMSG":
if bot:
chat_id = target_to_chat_id(args[0])
msg = args[1]
sticker = msg[18:].rstrip("\1") if msg.startswith(
"\1TELEGRAM-STICKER ") else None
if batching:
if not batchtarget:
batchtarget = chat_id
if batchmsg and (sticker is not None
or batchtarget != chat_id):
try:
sendbotmsg(bot, batchtarget, batchmsg,
parse_mode)
finally:
batching = False
batchtarget = ""
batchmsg = ""
if sticker is not None:
msg = ""
sendbotsticker(bot, chat_id, sticker)
elif args[1].startswith("\1ACTION "):
msg = args[1][8:].rstrip("\1")
if msg:
if batchtarget == chat_id:
if batchmsg:
batchmsg += "\n" + msg
else:
batchmsg = msg
anywork = False
else:
sendbotmsg(bot, chat_id, msg, parse_mode)
elif cmd == "NOTICE":
if bot:
chat_id = target_to_chat_id(args[0])
sendbotmsg(bot, chat_id, "Notice: " + args[1], parse_mode)
elif cmd == "PING":
send(":" + SERVER_NAME + " PONG " + SERVER_NAME + " :" +
(args[0] if len(args) else ""))
elif cmd == "PONG":
pass
elif cmd == "TPARSEMODE":
if len(args) > 0:
parse_mode = None if args[0].upper(
) == "PLAIN" else args[0]
send(":" + SERVER_NAME + " 300 " + cmd + " :" +
("Plain" if not parse_mode else parse_mode))
elif cmd == "QUIT":
send("X :Quit: " + ("" if len(args) == 0 else args[0]))
break
elif cmd == "CAP":
subcmd = args[0].upper() if len(args) > 0 else ""
if subcmd == "LS":
# List supported caps.
send("CAP " + botnick + " ACK :" +
" ".join(caps_supported))
elif subcmd == "REQ":
# Doesn't bother with capability modifiers.
new_caps_str = args[1] if len(args) > 1 else ""
new_caps = new_caps_str.split()
okcaps = True
if new_caps:
for newcap in new_caps:
if newcap not in caps_supported:
okcaps = False
break
if okcaps:
for newcap in new_caps:
if newcap not in caps_enabled:
caps_enabled.append(newcap)
if okcaps:
send("CAP " + botnick + " ACK :" + new_caps_str)
else:
send("CAP " + botnick + " NAK :" + new_caps_str)
elif subcmd == "LIST":
# List enabled caps.
send("CAP " + botnick + " ACK :" + " ".join(caps_enabled))
elif subcmd == "END":
pass
else:
send(":" + SERVER_NAME + " 410 " +
(args[0].partition(' ')[0] if len(args) > 0 else "") +
" :Invalid CAP subcommand")
anywork = False
elif cmd == "":
anywork = False
else:
send(":" + SERVER_NAME + " 421 " + cmd + " :Unknown command")
flush()
if anywork:
time.sleep(tsleep)
except KeyboardInterrupt as e:
send("X :Interrupted")
except Exception as e:
logger.error(e, exc_info=True)
send("X :Error")
finally:
if updater:
updater.stop()
flush()
interval=10,
first=0,
name='Scan new sticker sets')
job_queue.run_repeating(distribute_tasks_job,
interval=minute,
first=2 * minute,
name='Distribute new tasks')
job_queue.run_repeating(cleanup_job,
interval=2 * hour,
first=0,
name='Perform some database cleanup tasks')
# Create private message handler
dispatcher.add_handler(
MessageHandler(Filters.sticker & Filters.private,
handle_private_sticker))
dispatcher.add_handler(
MessageHandler(
Filters.text & Filters.private & (~Filters.update.edited_message) &
(~Filters.reply), handle_private_text))
dispatcher.add_handler(
MessageHandler(Filters.update.edited_message, handle_edited_messages))
# Inline callback handler
dispatcher.add_handler(CallbackQueryHandler(handle_callback_query))
dispatcher.add_handler(
ChosenInlineResultHandler(handle_chosen_inline_result))
# Error handling
dispatcher.add_error_handler(error_callback)
def main():
init_sentry()
db_engine = create_engine(settings.DATABASE["url"])
init_sqlalchemy(db_engine)
init_translations()
updater = Updater(token=settings.BOT_TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("nothing", cancel_callback))
feedback_handler = ConversationHandler(
entry_points=[CommandHandler("feedback", feedback_callback)],
states={1: [MessageHandler(Filters.text, send_feedback_callback)]},
fallbacks=[CommandHandler("nothing", cancel_callback)],
)
dp.add_handler(feedback_handler)
settings_handler = ConversationHandler(
entry_points=[
CommandHandler("settings",
personal_settings.main.settings_callback)
],
states={
personal_settings.SettingsSteps.main: [
MessageHandler(Filters.regex(r"^↩️"), cancel_callback),
MessageHandler(Filters.regex(r"^1. "),
personal_settings.language.menu_callback),
MessageHandler(
Filters.regex(r"^2. "),
personal_settings.default_currency.menu_callback,
),
MessageHandler(
Filters.regex(r"^3. "),
personal_settings.default_currency_position.menu_callback,
),
MessageHandler(
Filters.regex(r"^4. "),
personal_settings.onscreen_menu.menu_callback,
),
],
personal_settings.SettingsSteps.language: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.main.settings_callback),
MessageHandler(Filters.text,
personal_settings.language.set_callback),
],
personal_settings.SettingsSteps.default_currency: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.main.settings_callback),
MessageHandler(
Filters.text,
personal_settings.default_currency.set_callback),
],
personal_settings.SettingsSteps.default_currency_position: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.main.settings_callback),
MessageHandler(
Filters.text,
personal_settings.default_currency_position.set_command,
),
],
personal_settings.SettingsSteps.onscreen_menu: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.main.settings_callback),
MessageHandler(
Filters.regex(r"^1. "),
personal_settings.onscreen_menu.visibility_callback,
),
MessageHandler(
Filters.regex(r"^2. "),
personal_settings.onscreen_menu.size_callback,
),
MessageHandler(
Filters.regex(r"^3. "),
personal_settings.onscreen_menu.edit_history_callback,
),
],
personal_settings.SettingsSteps.onscreen_menu_visibility: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.onscreen_menu.menu_callback),
MessageHandler(
Filters.regex(r"^1. "),
personal_settings.onscreen_menu.
visibility_set_true_callback,
),
MessageHandler(
Filters.regex(r"^2. "),
personal_settings.onscreen_menu.
visibility_set_false_callback,
),
],
personal_settings.SettingsSteps.onscreen_menu_edit_history: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.onscreen_menu.menu_callback),
MessageHandler(
Filters.regex(r"^🅾️"),
personal_settings.onscreen_menu.
edit_history_delete_old_callback,
),
MessageHandler(
Filters.regex(r"^🆑"),
personal_settings.onscreen_menu.
edit_history_delete_all_callback,
),
MessageHandler(
Filters.regex(r"^❌"),
personal_settings.onscreen_menu.
edit_history_delete_one_callback,
),
],
personal_settings.SettingsSteps.onscreen_menu_size: [
MessageHandler(Filters.regex(r"^↩️"),
personal_settings.onscreen_menu.menu_callback),
MessageHandler(
Filters.text,
personal_settings.onscreen_menu.set_size_callback),
],
},
fallbacks=[CommandHandler("cancel", cancel_callback)],
)
dp.add_handler(settings_handler)
dp.add_handler(CommandHandler("currencies", currencies_callback))
dp.add_handler(CommandHandler("disclaimers", disclaimers_callback))
dp.add_handler(CommandHandler("feedback", feedback_callback))
dp.add_handler(CommandHandler("help", help_callback))
dp.add_handler(CommandHandler("p", price.price_callback, pass_args=True))
dp.add_handler(
CommandHandler("settings", personal_settings.main.settings_callback))
dp.add_handler(CommandHandler("start", start_callback))
dp.add_handler(CommandHandler("stop", stop_callback))
dp.add_handler(CommandHandler("sources", sources_callback))
dp.add_handler(CommandHandler("tutorial", tutorial_callback))
dp.add_handler(MessageHandler(Filters.regex(r"^/donate"), donate_callback))
dp.add_handler(
MessageHandler(Filters.regex(r"^/"), price.on_slash_callback))
dp.add_handler(InlineQueryHandler(price.inline_query_callback))
dp.add_handler(ChosenInlineResultHandler(price.inline_result_callback))
dp.add_handler(MessageHandler(Filters.text, price.message_callback))
# log all errors
dp.add_error_handler(error_callback)
# Start the Bot
updater.start_polling(poll_interval=0.5, timeout=10)
# 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()
if player is game.players[-1]:
game.complete_trick()
request_card(chatId, context)
def error(update, context):
logger.warning('\nUpdate "%s" caused error "%s"', update, context.error)
if __name__ == '__main__':
token = os.environ['TELEGRAM_TOKEN']
updater = Updater(token=token,
use_context=True,
request_kwargs={
'read_timeout': 20,
'connect_timeout': 20
})
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger = logging.getLogger(__name__)
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CommandHandler('stop', stop))
updater.dispatcher.add_handler(CommandHandler('help', help))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
updater.dispatcher.add_handler(InlineQueryHandler(inline_action))
updater.dispatcher.add_error_handler(error)
updater.dispatcher.add_handler(ChosenInlineResultHandler(action))
updater.start_polling()
updater.idle()
def test_other_update_types(self, false_update):
handler = ChosenInlineResultHandler(self.callback_basic)
assert not handler.check_update(false_update)
def register(dp: Dispatcher, bot_checker: "BotChecker"):
def add(*args, **kwargs):
dp.add_handler(*args, **kwargs)
keywords_handler = ConversationHandler(
entry_points=[
InlineCallbackHandler(
CallbackActions.EDIT_BOT_KEYWORDS,
botproperties.set_keywords_init,
serialize=lambda data: dict(to_edit=Bot.get(id=data["id"])),
pass_chat_data=True,
)
],
states={
BotStates.SENDING_KEYWORDS: [
MessageHandler(Filters.text,
botproperties.add_keyword,
pass_chat_data=True),
InlineCallbackHandler(
CallbackActions.REMOVE_KEYWORD,
botproperties.remove_keyword,
serialize=lambda data: dict(
to_edit=Bot.get(id=data["id"]),
keyword=Keyword.get(id=data["kwid"]),
),
pass_chat_data=True,
),
InlineCallbackHandler(
CallbackActions.DELETE_KEYWORD_SUGGESTION,
botproperties.delete_keyword_suggestion,
serialize=lambda data: dict(
to_edit=Bot.get(id=data["id"]),
suggestion=Suggestion.get(id=data["suggid"]),
),
pass_chat_data=True,
),
]
},
fallbacks=[
CallbackQueryHandler(
callback_router,
pass_chat_data=True,
pass_user_data=True,
pass_job_queue=True,
)
],
per_user=True,
allow_reentry=False,
)
add(keywords_handler)
broadcasting_handler = ConversationHandler(
entry_points=[
InlineCallbackHandler("broadcast",
broadcasts.broadcast,
pass_user_data=True),
CommandHandler("broadcast",
broadcasts.broadcast,
pass_user_data=True),
CommandHandler("bc", broadcasts.broadcast, pass_user_data=True),
],
states={
BotStates.BROADCASTING: [
MessageHandler(Filters.text,
broadcasts.broadcast_preview,
pass_user_data=True)
]
},
fallbacks=[],
per_user=True,
per_chat=False,
allow_reentry=True,
)
add(broadcasting_handler)
add(
CallbackQueryHandler(
callback_router,
pass_chat_data=True,
pass_user_data=True,
pass_job_queue=True,
))
add(
CommandHandler(("cat", "category", "categories"),
select_category,
pass_chat_data=True))
add(
CommandHandler(("s", "search"),
search_handler,
pass_args=True,
pass_chat_data=True))
add(MessageHandler(Filters.reply, reply_router, pass_chat_data=True),
group=-1)
add(MessageHandler(Filters.forwarded, forward_router, pass_chat_data=True))
add(CommandHandler("admin", admin.menu))
add(CommandHandler("a", admin.menu))
add(
CommandHandler(("rej", "reject"),
admin.reject_bot_submission,
pass_args=True))
add(
CommandHandler(
("rejsil", "rejectsil", "rejsilent", "rejectsilent"),
lambda bot, update: admin.reject_bot_submission(
bot, update, None, notify_submittant=False),
))
# admin menu
add(RegexHandler(captions.APPROVE_BOTS + ".*", admin.approve_bots))
add(
RegexHandler(captions.APPROVE_SUGGESTIONS + ".*",
admin.approve_suggestions))
add(RegexHandler(captions.PENDING_UPDATE + ".*", admin.pending_update))
add(
RegexHandler(captions.SEND_BOTLIST,
admin.prepare_transmission,
pass_chat_data=True))
add(RegexHandler(captions.FIND_OFFLINE, admin.send_offline))
add(RegexHandler(captions.SEND_CONFIG_FILES, admin.send_runtime_files))
add(RegexHandler(captions.SEND_ACTIVITY_LOGS, admin.send_activity_logs))
# main menu
add(RegexHandler(captions.ADMIN_MENU, admin.menu))
add(RegexHandler(captions.REFRESH, admin.menu))
add(RegexHandler(captions.CATEGORIES, select_category,
pass_chat_data=True))
add(RegexHandler(captions.EXPLORE, explore.explore, pass_chat_data=True))
add(RegexHandler(captions.FAVORITES, favorites.send_favorites_list))
add(RegexHandler(captions.NEW_BOTS, show_new_bots, pass_chat_data=True))
add(RegexHandler(captions.SEARCH, search_handler, pass_chat_data=True))
add(RegexHandler(captions.CONTRIBUTING, help.contributing))
add(RegexHandler(captions.EXAMPLES, help.examples))
add(RegexHandler(captions.HELP, help.help))
add(RegexHandler("^/edit\d+$", admin.edit_bot, pass_chat_data=True),
group=1)
add(RegexHandler("^/approve\d+$", admin.edit_bot, pass_chat_data=True),
group=1)
add(CommandHandler("approve", admin.short_approve_list))
add(CommandHandler(("manybot", "manybots"), admin.manybots))
add(
CommandHandler(
"new",
partial(contributions.new_bot_submission, bot_checker=bot_checker),
pass_args=True,
pass_chat_data=True,
))
add(
RegexHandler(
".*#new.*",
lambda bot, update, chat_data: contributions.new_bot_submission(
bot, update, chat_data, args=None, bot_checker=bot_checker),
pass_chat_data=True,
),
group=1,
)
add(
CommandHandler("offline",
contributions.notify_bot_offline,
pass_args=True))
add(RegexHandler(".*#offline.*", contributions.notify_bot_offline),
group=1)
add(CommandHandler("spam", contributions.notify_bot_spam, pass_args=True))
add(RegexHandler(".*#spam.*", contributions.notify_bot_spam), group=1)
add(CommandHandler("help", help.help))
add(CommandHandler(("contribute", "contributing"), help.contributing))
add(CommandHandler("examples", help.examples))
add(CommandHandler("rules", help.rules))
add(
CommandHandler(("addfav", "addfavorite"),
favorites.add_favorite_handler,
pass_args=True))
add(
CommandHandler(("f", "fav", "favorites"),
favorites.send_favorites_list))
add(CommandHandler(("e", "explore"), explore.explore, pass_chat_data=True))
add(CommandHandler("official", explore.show_official))
add(
CommandHandler(
"ban",
partial(admin.ban_handler, ban_state=True),
pass_args=True,
pass_chat_data=True,
))
add(
CommandHandler(
"unban",
partial(admin.ban_handler, ban_state=False),
pass_args=True,
pass_chat_data=True,
))
add(CommandHandler("t3chno", t3chnostats))
add(CommandHandler("random", eastereggs.send_random_bot))
add(
CommandHandler("easteregg",
eastereggs.send_next,
pass_args=True,
pass_job_queue=True))
add(CommandHandler("subscribe", manage_subscription))
add(CommandHandler("newbots", show_new_bots, pass_chat_data=True))
add(CommandHandler("accesstoken", access_token))
add(
CommandHandler(("stat", "stats", "statistic", "statistics"),
admin.send_statistic))
add(
CommandHandler(("log", "logs"),
admin.send_activity_logs,
pass_args=True))
add(
CommandHandler(
("debug", "analysis", "ana", "analyze"),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.ANALYSIS),
pass_args=True,
))
add(
CommandHandler(
"info",
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.INFO),
pass_args=True,
))
add(
CommandHandler(
("detail", "detailed"),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.DETAILED),
pass_args=True,
))
add(
CommandHandler(
("warn", "warning"),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.WARN),
pass_args=True,
))
add(
CommandHandler(
"important",
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.IMPORTANT),
pass_args=True,
))
add(
MessageHandler(
Filters.text,
lambda bot, update: botlistchat.text_message_logger(
bot, update, log),
),
group=99,
)
for hashtag in HINTS.keys():
add(
RegexHandler(r"{}.*".format(hashtag),
botlistchat.hint_handler,
pass_job_queue=True),
group=1,
)
add(CommandHandler(("hint", "hints"), botlistchat.show_available_hints))
add(
RegexHandler(
"^{}$".format(settings.REGEX_BOT_ONLY),
send_bot_details,
pass_chat_data=True,
))
add(
ChosenInlineResultHandler(inlinequeries.chosen_result,
pass_chat_data=True))
add(
InlineQueryHandler(inlinequeries.inlinequery_handler,
pass_chat_data=True))
add(MessageHandler(Filters.all, all_handler, pass_chat_data=True),
group=98)
def register(dp):
keywords_handler = ConversationHandler(
entry_points=[
InlineCallbackHandler(
CallbackActions.EDIT_BOT_KEYWORDS,
botproperties.set_keywords_init,
serialize=lambda data: dict(to_edit=Bot.get(id=data['id'])),
pass_chat_data=True)
],
states={
BotStates.SENDING_KEYWORDS: [
MessageHandler(Filters.text,
botproperties.add_keyword,
pass_chat_data=True),
InlineCallbackHandler(
CallbackActions.REMOVE_KEYWORD,
botproperties.remove_keyword,
serialize=lambda data: dict(to_edit=Bot.get(id=data['id']),
keyword=Keyword.get(id=data[
'kwid'])),
pass_chat_data=True)
],
},
fallbacks=[
CallbackQueryHandler(callback_router,
pass_chat_data=True,
pass_user_data=True,
pass_job_queue=True)
],
per_user=True,
allow_reentry=False)
dp.add_handler(keywords_handler)
broadcasting_handler = ConversationHandler(
entry_points=[
InlineCallbackHandler('broadcast',
broadcasts.broadcast,
pass_user_data=True),
CommandHandler("broadcast",
broadcasts.broadcast,
pass_user_data=True),
CommandHandler("bc", broadcasts.broadcast, pass_user_data=True)
],
states={
BotStates.BROADCASTING: [
MessageHandler(Filters.text,
broadcasts.broadcast_preview,
pass_user_data=True),
],
},
fallbacks=[],
per_user=True,
per_chat=False,
allow_reentry=True)
dp.add_handler(broadcasting_handler)
dp.add_handler(
CallbackQueryHandler(callback_router,
pass_chat_data=True,
pass_user_data=True,
pass_job_queue=True))
dp.add_handler(
CommandHandler(('cat', 'category', 'categories'),
select_category,
pass_chat_data=True))
dp.add_handler(
CommandHandler(('s', 'search'),
search_handler,
pass_args=True,
pass_chat_data=True))
dp.add_handler(MessageHandler(Filters.reply,
reply_router,
pass_chat_data=True),
group=0)
dp.add_handler(
MessageHandler(Filters.forwarded, forward_router, pass_chat_data=True))
dp.add_handler(CommandHandler("admin", admin.menu))
dp.add_handler(CommandHandler("a", admin.menu))
# admin menu
dp.add_handler(
RegexHandler(captions.APPROVE_BOTS + '.*', admin.approve_bots))
dp.add_handler(
RegexHandler(captions.APPROVE_SUGGESTIONS + '.*',
admin.approve_suggestions))
dp.add_handler(
RegexHandler(captions.PENDING_UPDATE + '.*', admin.pending_update))
dp.add_handler(
RegexHandler(captions.SEND_BOTLIST,
admin.prepare_transmission,
pass_chat_data=True))
dp.add_handler(RegexHandler(captions.FIND_OFFLINE, admin.send_offline))
dp.add_handler(
RegexHandler(captions.SEND_CONFIG_FILES, admin.send_runtime_files))
dp.add_handler(
RegexHandler(captions.SEND_ACTIVITY_LOGS, admin.send_activity_logs))
# main menu
dp.add_handler(RegexHandler(captions.ADMIN_MENU, admin.menu))
dp.add_handler(RegexHandler(captions.REFRESH, admin.menu))
dp.add_handler(
RegexHandler(captions.CATEGORIES, select_category,
pass_chat_data=True))
dp.add_handler(
RegexHandler(captions.EXPLORE, explore.explore, pass_chat_data=True))
dp.add_handler(
RegexHandler(captions.FAVORITES, favorites.send_favorites_list))
dp.add_handler(
RegexHandler(captions.NEW_BOTS, show_new_bots, pass_chat_data=True))
dp.add_handler(
RegexHandler(captions.SEARCH, search_handler, pass_chat_data=True))
dp.add_handler(RegexHandler(captions.CONTRIBUTING, help.contributing))
dp.add_handler(RegexHandler(captions.EXAMPLES, help.examples))
dp.add_handler(RegexHandler(captions.HELP, help.help))
dp.add_handler(RegexHandler("^/edit\d+$",
admin.edit_bot,
pass_chat_data=True),
group=1)
dp.add_handler(CommandHandler('reject', admin.reject_bot_submission))
dp.add_handler(CommandHandler('rej', admin.reject_bot_submission))
dp.add_handler(RegexHandler("^/approve\d+$",
admin.edit_bot,
pass_chat_data=True),
group=1)
dp.add_handler(CommandHandler('approve', admin.short_approve_list))
dp.add_handler(CommandHandler(('manybot', 'manybots'), admin.manybots))
dp.add_handler(
CommandHandler('new',
contributions.new_bot_submission,
pass_args=True,
pass_chat_data=True))
dp.add_handler(RegexHandler('.*#new.*',
contributions.new_bot_submission,
pass_chat_data=True),
group=1)
dp.add_handler(
CommandHandler('offline',
contributions.notify_bot_offline,
pass_args=True))
dp.add_handler(RegexHandler('.*#offline.*',
contributions.notify_bot_offline),
group=1)
dp.add_handler(
CommandHandler('spam', contributions.notify_bot_spam, pass_args=True))
dp.add_handler(RegexHandler('.*#spam.*', contributions.notify_bot_spam),
group=1)
dp.add_handler(
RegexHandler('^{}$'.format(settings.REGEX_BOT_ONLY),
send_bot_details,
pass_chat_data=True))
dp.add_handler(CommandHandler('help', help.help))
dp.add_handler(
CommandHandler(("contribute", "contributing"), help.contributing))
dp.add_handler(CommandHandler("examples", help.examples))
dp.add_handler(CommandHandler("rules", help.rules))
dp.add_handler(
CommandHandler(("addfav", "addfavorite"),
favorites.add_favorite_handler,
pass_args=True))
dp.add_handler(
CommandHandler(("f", "fav", "favorites"),
favorites.send_favorites_list))
dp.add_handler(
CommandHandler(("e", "explore"), explore.explore, pass_chat_data=True))
dp.add_handler(CommandHandler("official", explore.show_official))
dp.add_handler(
CommandHandler('ban',
lambda bot, update, args: admin.ban_handler(
bot, update, args, True),
pass_args=True))
dp.add_handler(
CommandHandler('unban',
lambda bot, update, args: admin.ban_handler(
bot, update, args, False),
pass_args=True))
dp.add_handler(CommandHandler('t3chno', t3chnostats))
dp.add_handler(CommandHandler('random', eastereggs.send_random_bot))
dp.add_handler(
CommandHandler('easteregg', eastereggs.send_next, pass_args=True))
dp.add_handler(CommandHandler("subscribe", manage_subscription))
dp.add_handler(
CommandHandler("newbots", show_new_bots, pass_chat_data=True))
dp.add_handler(CommandHandler("accesstoken", access_token))
dp.add_handler(
CommandHandler(('stat', 'stats', 'statistic', 'statistics'),
admin.send_statistic))
dp.add_handler(
CommandHandler(('log', 'logs'),
admin.send_activity_logs,
pass_args=True))
dp.add_handler(
CommandHandler(('debug', 'analysis', 'ana', 'analyze'),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.ANALYSIS),
pass_args=True))
dp.add_handler(
CommandHandler('info',
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.INFO),
pass_args=True))
dp.add_handler(
CommandHandler(('detail', 'detailed'),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.DETAILED),
pass_args=True))
dp.add_handler(
CommandHandler(('warn', 'warning'),
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.WARN),
pass_args=True))
dp.add_handler(
CommandHandler('important',
lambda bot, update, args: admin.send_activity_logs(
bot, update, args, Statistic.IMPORTANT),
pass_args=True))
dp.add_handler(MessageHandler(
Filters.text,
lambda bot, update: botlistchat.text_message_logger(bot, update, log)),
group=99)
for hashtag in HINTS.keys():
dp.add_handler(RegexHandler(r'{}.*'.format(hashtag),
botlistchat.hint_handler),
group=1)
dp.add_handler(
CommandHandler(('hint', 'hints'), botlistchat.show_available_hints))
dp.add_handler(
ChosenInlineResultHandler(inlinequeries.chosen_result,
pass_chat_data=True))
dp.add_handler(
InlineQueryHandler(inlinequeries.inlinequery_handler,
pass_chat_data=True))
dp.add_handler(MessageHandler(Filters.all,
all_handler,
pass_chat_data=True),
group=98)
dispatcher.add_handler(CommandHandler('refresh', refresh_sticker_sets))
dispatcher.add_handler(CommandHandler('refresh_ocr', refresh_ocr))
dispatcher.add_handler(CommandHandler('cleanup', cleanup))
dispatcher.add_handler(CommandHandler('tasks', start_tasks))
dispatcher.add_handler(CommandHandler('stats', stats))
# Regular tasks
minute = 60
hour = minute*60
job_queue = updater.job_queue
job_queue.run_repeating(newsfeed_job, interval=minute*5, first=0, name='Process newsfeed')
job_queue.run_repeating(maintenance_job, interval=hour*2, first=0, name='Create new maintenance tasks')
job_queue.run_repeating(scan_sticker_sets_job, interval=10, first=0, name='Scan new sticker sets')
job_queue.run_repeating(distribute_tasks_job, interval=minute, first=minute*2, name='Distribute new tasks')
job_queue.run_repeating(cleanup_job, interval=hour*2, first=0, name='Perform some database cleanup tasks')
# Create private message handler
dispatcher.add_handler(
MessageHandler(Filters.sticker & Filters.private, handle_private_sticker))
dispatcher.add_handler(
MessageHandler(Filters.text & Filters.private & (~Filters.update.edited_message) & (~Filters.reply), handle_private_text))
dispatcher.add_handler(
MessageHandler(Filters.update.edited_message, handle_edited_messages))
# Inline callback handler
dispatcher.add_handler(CallbackQueryHandler(handle_callback_query))
dispatcher.add_handler(ChosenInlineResultHandler(handle_chosen_inline_result))
# Error handling
dispatcher.add_error_handler(error_callback)
def main(updater):
dispatcher = updater.dispatcher
dbFuncs.initDB()
newList = ConversationHandler(
entry_points=[
CommandHandler('new', new, Filters.private),
CommandHandler('start', start, Filters.private, pass_args=True)
],
states={
SETNAME: [MessageHandler(Filters.text & Filters.private, setName)]
},
fallbacks=[
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
])
listHandler = ConversationHandler(
entry_points=[CallbackQueryHandler(pushInline)],
states={SETTINGS: [CallbackQueryHandler(pushAdmin)]},
fallbacks=[
CallbackQueryHandler(pushInline),
CommandHandler('cancel',
cancel,
Filters.private,
pass_user_data=True)
],
per_message=True)
dispatcher.add_handler(newList)
dispatcher.add_handler(listHandler)
dispatcher.add_handler(CallbackQueryHandler(pushInline))
dispatcher.add_handler(
CommandHandler('send', sendAll,
Filters.private & Filters.chat(chat_id=[114951690])))
dispatcher.add_handler(CommandHandler('help', help, Filters.private))
dispatcher.add_handler(CommandHandler('backup', backup, Filters.private))
dispatcher.add_handler(InlineQueryHandler(inlineQuery))
dispatcher.add_handler(ChosenInlineResultHandler(chosenQuery))
dispatcher.add_handler(
MessageHandler(Filters.private & Filters.regex(r'^\/.*'), blankCode))
dispatcher.add_handler(
MessageHandler(
Filters.text & Filters.private & Filters.update.edited_message,
editMessage))
dispatcher.add_handler(
MessageHandler(
Filters.private & Filters.text & Filters.reply &
(~Filters.update.edited_message), rcvReply))
dispatcher.add_handler(
MessageHandler(
Filters.text & Filters.private & (~Filters.update.edited_message),
rcvMessage))
dispatcher.add_error_handler(contextCallback)
try:
with open('{0}/userdata'.format(backupsDir), 'rb') as file:
dispatcher.user_data = pload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/newList'.format(backupsDir), 'rb') as file:
newList.conversations = pload(file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/listHandler'.format(backupsDir), 'rb') as file:
listHandler.conversations = pload(file)
except Exception as e:
logger.warning(repr(e))
updater.start_polling()
updater.idle()
try:
with open('{0}/userdata'.format(backupsDir), 'wb+') as file:
pdump(dispatcher.user_data, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/newList'.format(backupsDir), 'wb+') as file:
pdump(newList.conversations, file)
except Exception as e:
logger.warning(repr(e))
try:
with open('{0}/listHandler'.format(backupsDir), 'wb+') as file:
pdump(listHandler.conversations, file)
except Exception as e:
logger.warning(repr(e))
results = [
InlineQueryResultArticle(
id=ARTICLE_ID_REGEXP.search(article['url']).group(1),
title=article['source']['article']['title'],
input_message_content=InputTextMessageContent(
message_text='FAQ page: <a href="{}">{}</a>'.format(
FRESHDESK_URL + article['url'],
escape_HTML(article['source']['article']['title'])),
parse_mode='HTML',
disable_web_page_preview=True),
description=article['source']['article']['desc_un_html'][:80] +
'...') for article in results
]
bot.answer_inline_query(update.inline_query.id, results)
@run_async
def chosen_result(bot, update):
result_id = update.chosen_inline_result.result_id
with urllib.request.urlopen(ARTICLE_URL + result_id + '.json') as response:
article = json.loads(response.read())
sql.increment(result_id, article['article']['title'])
INLINE_HANDLER = InlineQueryHandler(inline_search)
CHOSEN_HANDLER = ChosenInlineResultHandler(chosen_result)
dispatcher.add_handler(INLINE_HANDLER)
dispatcher.add_handler(CHOSEN_HANDLER, -1)
else:
store_results = store.get_all(user_id=user.id)
results = [
inline_result_creators.get_for(doc.doc_type)(doc)
for doc in store_results
]
inline_query.answer(
results=results,
is_personal=True,
cache_time=0,
auto_pagination=True,
)
def update_last_used_at(update: Update, context: CallbackContext):
user = update.chosen_inline_result.from_user
logger.info(f'User {user.name}({user.id}) selected a query result. Updating last used date.')
doc_id = update.chosen_inline_result.result_id
doc = store.get(doc_id)
doc.last_used_at = datetime.now()
store.update(doc_id, doc)
inline_result_creators = InlineResultCreatorLoader()
inline_result_creator = inline_result_creators.decorator
inline_search_handler = InlineQueryHandler(inline_search)
chosen_inline_result_handler = ChosenInlineResultHandler(update_last_used_at)
