def test_basic(self, dp, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_basic)
dp.add_handler(handler)
assert handler.check_update(chosen_inline_result)
dp.process_update(chosen_inline_result)
assert self.test_flag
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 test_basic(self, dp, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_basic)
dp.add_handler(handler)
assert handler.check_update(chosen_inline_result)
dp.process_update(chosen_inline_result)
assert self.test_flag
def test_pass_user_or_chat_data(self, dp, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_data_1,
pass_user_data=True)
dp.add_handler(handler)
dp.process_update(chosen_inline_result)
assert self.test_flag
dp.remove_handler(handler)
handler = ChosenInlineResultHandler(self.callback_data_1,
pass_chat_data=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_data_2,
pass_chat_data=True,
pass_user_data=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(chosen_inline_result)
assert self.test_flag
def test_with_pattern(self, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback_basic,
pattern='.*ult.*')
assert handler.check_update(chosen_inline_result)
chosen_inline_result.chosen_inline_result.result_id = 'nothing here'
assert not handler.check_update(chosen_inline_result)
chosen_inline_result.chosen_inline_result.result_id = 'result_id'
def test_slot_behaviour(self, recwarn, mro_slots):
handler = ChosenInlineResultHandler(self.callback_basic)
for attr in handler.__slots__:
assert getattr(handler, attr,
'err') != 'err', f"got extra slot '{attr}'"
assert not handler.__dict__, f"got missing slot(s): {handler.__dict__}"
assert len(mro_slots(handler)) == len(set(
mro_slots(handler))), "duplicate slot"
handler.custom, handler.callback = 'should give warning', self.callback_basic
assert len(recwarn) == 1 and 'custom' in str(
recwarn[0].message), recwarn.list
async def test_context_pattern(self, app, chosen_inline_result):
handler = ChosenInlineResultHandler(
self.callback_pattern, pattern=r"(?P<begin>.*)ult(?P<end>.*)")
app.add_handler(handler)
async with app:
await app.process_update(chosen_inline_result)
assert self.test_flag
app.remove_handler(handler)
handler = ChosenInlineResultHandler(self.callback_pattern,
pattern=r"(res)ult(.*)")
app.add_handler(handler)
await app.process_update(chosen_inline_result)
assert self.test_flag
def test_context_pattern(self, cdp, chosen_inline_result):
handler = ChosenInlineResultHandler(
self.callback_context_pattern,
pattern=r'(?P<begin>.*)ult(?P<end>.*)')
cdp.add_handler(handler)
cdp.process_update(chosen_inline_result)
assert self.test_flag
cdp.remove_handler(handler)
handler = ChosenInlineResultHandler(self.callback_context_pattern,
pattern=r'(res)ult(.*)')
cdp.add_handler(handler)
cdp.process_update(chosen_inline_result)
assert self.test_flag
async def test_context(self, app, chosen_inline_result):
handler = ChosenInlineResultHandler(self.callback)
app.add_handler(handler)
async with app:
await app.process_update(chosen_inline_result)
assert self.test_flag
def test_slot_behaviour(self, mro_slots):
handler = ChosenInlineResultHandler(self.callback_basic)
for attr in handler.__slots__:
assert getattr(handler, attr,
"err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(handler)) == len(set(
mro_slots(handler))), "duplicate slot"
def main():
updater = Updater(BOT_TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(InlineQueryHandler(inline_query))
dispatcher.add_handler(ChosenInlineResultHandler(chosen_result))
dispatcher.add_handler(CallbackQueryHandler(add_me_to_list, pattern="(si\*)|(puede\*)|(no\*)"))
dispatcher.add_handler(CallbackQueryHandler(close_list, pattern="close\*"))
dispatcher.add_handler(CallbackQueryHandler(change_donation_quantity, pattern=r"don\*", pass_user_data=True))
dispatcher.add_handler(CallbackQueryHandler(donate, pattern=r"donate$", pass_user_data=True))
dispatcher.add_handler(CallbackQueryHandler(callback_query_exception))
dispatcher.add_handler(CommandHandler("start", start_command, pass_args=True, pass_user_data=True))
dispatcher.add_handler(MessageHandler(filters=Filters.successful_payment, callback=completed_donation))
dispatcher.add_handler(PreCheckoutQueryHandler(aprove_transaction))
dispatcher.add_error_handler(error)
updater.start_polling()
# CONSOLA
while True:
inp = raw_input("")
if inp:
input_c = inp.split()[0]
args = inp.split()[1:]
strig = ""
for e in args:
strig = strig + " " + e
if input_c == "stop":
stopBot(updater)
break
else:
print "Comando desconocido"
def main():
# Create the Updater and pass it your bot's token.
updater = Updater(TOKEN)
# 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("url", showurl, pass_args=True))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(InlineQueryHandler(inlinequery))
dp.add_handler(ChosenInlineResultHandler(generatelink))
# on callback
dp.add_handler(CallbackQueryHandler(button))
# 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(token=TOKEN, use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(InlineQueryHandler(inline_achv))
dispatcher.add_handler(ChosenInlineResultHandler(get_chosen_achv))
dispatcher.add_handler(CommandHandler('set_chat', set_chat))
dispatcher.add_handler(CommandHandler("status", status))
dispatcher.add_handler(CommandHandler("achievements", achievements))
dispatcher.add_handler(CommandHandler("titles", titles))
dispatcher.add_handler(CommandHandler("rank", get_rank))
dispatcher.add_handler(
ConversationHandler(
entry_points=[CommandHandler("change_title", change_title)],
states={MAINTITLE: [MessageHandler(Filters.text, main_title)]},
fallbacks=[]))
updater.start_polling()
def __init__(self):
self.handlers = [
InlineQueryHandler(self.inline_query),
CallbackQueryHandler(self.callback_handler),
ChosenInlineResultHandler(self.inline_stats)
]
self.store = TinyDBStore()
def main():
# Create the Updater and pass it your bot's token.
logger.info('Bot started')
test = "964957577:AAHQlnTDLdyLxDsrnsSE8M0HcxRwMup6YDk"
token = env["TOKEN"] if "TOKEN" in env else test
updater = Updater(token)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start_or_help))
dp.add_handler(CommandHandler("help", start_or_help))
dp.add_handler(CommandHandler('status', status))
dp.add_handler(CommandHandler("rate", rate))
# on pressing buttons from inline keyboards
dp.add_handler(CallbackQueryHandler(handle_inline_callback))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(InlineQueryHandler(inlinequery))
# on creating game
dp.add_handler(ChosenInlineResultHandler(chose_inline_result))
# 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():
# initialize algolia client
client = algoliasearch.Client(ALGOLIA_APP_ID, ALGOLIA_API_KEY)
index = client.init_index(ALGOLIA_INDEX_NAME)
index.set_settings({
"searchableAttributes": ["keywords", "file_id"],
'customRanking': ['asc(created)'], # fresh on top
"typoTolerance": True,
"disableTypoToleranceOnAttributes": ["file_id"],
"ignorePlurals": True
})
# initialize bot
upd = Updater(token=BOT_TOKEN)
upd.bot.index = index
dp = upd.dispatcher
dp.add_handler(remove_gif_conversation)
dp.add_handler(add_gif_conversation)
dp.add_handler(CommandHandler('help', help))
dp.add_handler(CommandHandler('start', start))
dp.add_handler(InlineQueryHandler(inline_search))
dp.add_handler(ChosenInlineResultHandler(inline_result))
dp.add_handler(MessageHandler(Filters.all, unknown_message))
dp.add_error_handler(error)
upd.start_polling(timeout=30)
upd.idle()
def __init__(self, config: AppConfig, persistence: ImageDataPersistence, image_analysers: [ImageAnalyser]):
"""
Creates an instance.
:param config: configuration object
:param persistence: image persistence
:param image_analysers: list of image analysers
"""
self._config = config
self._persistence = persistence
self._image_analysers = image_analysers
self._updater = Updater(token=self._config.TELEGRAM_BOT_TOKEN.value, use_context=True)
LOGGER.debug("Using bot id '{}' ({})".format(self._updater.bot.id, self._updater.bot.name))
self._dispatcher = self._updater.dispatcher
handlers = [
CommandHandler(COMMAND_START,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._start_callback),
CommandHandler(COMMAND_INSPIRE,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._inspire_callback),
CommandHandler(COMMAND_FORCE_ANALYSIS,
filters=(~ Filters.forwarded),
callback=self._forceanalysis_callback),
CommandHandler(COMMAND_STATS,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._stats_callback),
CommandHandler(REPLY_COMMAND_INFO,
filters=Filters.reply & (~ Filters.forwarded),
callback=self._reply_info_command_callback),
CommandHandler(REPLY_COMMAND_TEXT,
filters=Filters.reply & (~ Filters.forwarded),
callback=self._reply_text_command_callback),
CommandHandler(REPLY_COMMAND_DELETE,
filters=Filters.reply & (~ Filters.forwarded),
callback=self._reply_delete_command_callback),
CommandHandler(COMMAND_VERSION,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._version_command_callback),
CommandHandler(COMMAND_CONFIG,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._config_command_callback),
CommandHandler(COMMAND_COMMANDS,
filters=(~ Filters.reply) & (~ Filters.forwarded),
callback=self._commands_command_callback),
# unknown command handler
MessageHandler(
filters=Filters.command & (~ Filters.forwarded),
callback=self._unknown_command_callback),
InlineQueryHandler(self._inline_query_callback),
ChosenInlineResultHandler(self._inline_result_chosen_callback)
]
for handler in handlers:
self._updater.dispatcher.add_handler(handler)
def main():
updater = Updater(TOKEN)
updater.dispatcher.add_handler(InlineQueryHandler(inline_query_handler))
updater.dispatcher.add_handler(
ChosenInlineResultHandler(inline_query_result_handler))
updater.start_polling()
updater.idle()
def main():
"""
Create the updater and dispatcher handlers
"""
# Create the bot's alert database
movie.Alert(DATABASE).create_db()
# Create the updater and pass the bot's token.
updater = Updater(TOKEN, use_context=True, workers=32)
# Create repeating job to notify users
job_start_time = datetime.time(datetime.now().replace(
hour=int(JOB_TIME[0]), minute=int(JOB_TIME[1])))
job = updater.job_queue
job.run_repeating(notify_users, interval=86400, first=job_start_time)
# Get the dispatcher to register handlers
dispatch = updater.dispatcher
# On different commands - answer in Telegram
dispatch.add_handler(CommandHandler("start", help_cmd))
dispatch.add_handler(CommandHandler("help", help_cmd))
dispatch.add_handler(CommandHandler("alerts", alerts_cmd))
# Add the inline query handler
dispatch.add_handler(InlineQueryHandler(in_line_query))
# On chosing result, get its ID
dispatch.add_handler(ChosenInlineResultHandler(chosen_result))
# On button selection call appropriate function
dispatch.add_handler(
CallbackQueryHandler(enable_alert,
pattern='^' + str(enable_alert) + '$'))
dispatch.add_handler(
CallbackQueryHandler(disable_alert,
pattern='^' + str(disable_alert) + '$'))
dispatch.add_handler(
CallbackQueryHandler(dismiss, pattern='^' + str(dismiss) + '$'))
# Answer to non-commands
dispatch.add_handler(
MessageHandler(
(~Filters.entity('url')) & (~Filters.entity('text_link')),
unknown_cmd))
# Log all errors
dispatch.add_error_handler(log_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():
load_files()
updater = Updater(config['1292603883:AAFCiKSUlAHnVCtPrim_uui2xahlmPjEBs0'],
use_context=True,
workers=10)
dispatcher = updater.dispatcher
global bot
bot = updater.bot
dispatcher.add_handler(MessageHandler(~Filters.private,
do_fucking_nothing))
dispatcher.add_handler(CommandHandler('broadcast', broadcast_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))
dispatcher.add_handler(MessageHandler(Filters.command, invalid_command))
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))
dispatcher.add_handler(
CallbackQueryHandler(change_lang_callback, pattern="lang"))
dispatcher.add_handler(
CallbackQueryHandler(icon_cancel_callback, pattern="icon_cancel"))
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))
updater.job_queue.run_repeating(save_files, config['save_interval'],
config['save_interval'])
dispatcher.add_error_handler(handle_error)
updater.start_polling(clean=True, timeout=99999)
print("Bot finished starting")
updater.idle()
def main():
updater = Updater(TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(CallbackQueryHandler(game))
dispatcher.add_handler(ChosenInlineResultHandler(inline))
dispatcher.add_handler(InlineQueryHandler(show))
if len(sys.argv) > 1 and sys.argv[1] == "-p":
updater.start_polling()
else:
updater.start_webhook(webhook_url=LOCAL_URL, url_path=TOKEN)
updater.bot.setWebhook(APP_URL + TOKEN)
def _set_handlers(self):
# Commands
self._dispatcher.add_handler(CommandHandler("start", self._start_command_handler))
self._dispatcher.add_handler(CommandHandler("help", self._start_command_handler))
self._dispatcher.add_handler(CommandHandler("login", self._login_to_web_sound_bank_command_handler))
# Inline query
self._dispatcher.add_handler(InlineQueryHandler(self._inlinequery_handler))
self._dispatcher.add_handler(ChosenInlineResultHandler(self._chosen_inline_query_result))
# Error
self._dispatcher.add_error_handler(self._error_handler)
def main():
if BOT_TOKEN == "":
logger.error("TOKEN not defined. Put your bot token on bot_tokens.py")
return
updater = Updater(BOT_TOKEN)
h = updater.dispatcher.add_handler
const.aux.BOT_USERNAME = updater.bot.get_me().username
# Assigning handlers
h(CommandHandler("start", handlers.start, pass_args=True))
h(CommandHandler("help", handlers.help))
h(CommandHandler("more", handlers.more))
h(CommandHandler("ping", handlers.ping))
h(CommandHandler("donate", handlers.donate, pass_user_data=True))
h(CommandHandler("support", handlers.support, filters=Filters.private))
h(CommandHandler("support", handlers.support_group, filters=Filters.group))
h(CommandHandler("about", handlers.about))
h(CallbackQueryHandler(handlers.change_donation_quantity, pattern=r"don\*", pass_user_data=True))
h(CallbackQueryHandler(handlers.send_donation_receipt, pattern=r"donate$", pass_user_data=True))
h(MessageHandler(filters=Filters.successful_payment, callback=handlers.completed_donation))
h(PreCheckoutQueryHandler(handlers.approve_transaction))
h(InlineQueryHandler(handlers.full_query, pattern=".+"))
h(InlineQueryHandler(handlers.empty_query))
h(ChosenInlineResultHandler(handlers.chosen_result))
h(CallbackQueryHandler(handlers.cast_vote, pattern=r"vote\*.*\*"))
h(CallbackQueryHandler(handlers.get_clist, pattern=r"get_clist\*.*\*"))
updater.dispatcher.add_error_handler(handlers.error)
updater.start_polling()
# CONSOLE
while True:
inp = input("")
if inp:
input_c = inp.split()[0]
args = inp.split()[1:]
strig = ""
for e in args:
strig = strig + " " + e
if input_c == "stop":
stop_bot(updater)
break
else:
print("Unknown command")
def main() -> None:
token = os.getenv('token')
updater = Updater(token)
dp = updater.dispatcher
dp.add_handler(ChosenInlineResultHandler(callback=chosen_result))
dp.add_handler(InlineQueryHandler(inline_tweets, run_async=True))
dp.add_handler(CallbackQueryHandler(callback=edit_msg, pattern='\d', run_async=True))
dp.add_handler(CommandHandler(command='start', callback=command_start))
dp.add_handler(CommandHandler(command='help', callback=command_help))
# for heroku-
updater.start_webhook(listen="0.0.0.0", port=int(os.environ.get('PORT', 8443)), url_path=token)
updater.bot.setWebhook(f"https://tweets-on-telegram-bot.herokuapp.com/{token}")
updater.idle()
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():
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():
# 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():
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 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 test_other_update_types(self, false_update):
handler = ChosenInlineResultHandler(self.callback_basic)
assert not handler.check_update(false_update)
