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)