def main(): if load._cfg['Servers']['Mod']['mod'] == 'long': bot = load.bot updater = Updater(bot=bot, use_context=True) dp = updater.dispatcher dp.add_handler(CH("help", _h._help)) dp.add_handler(CH('search',sA.searchALL)) dp.add_handler(InlineQueryHandler(ilQuery.inlinequery,run_async=True)) ''' Start TGBOT ''' updater.start_polling() LOG.info("Fxxkr LAB :: Bingo" + __version__.__version__ + " is Started") updater.idle() else: print('Wrong Arguments')
def main(): # Lanzamos el updater y lo asignamos al TOKEN updater = Updater("TOKEN_AQUI") # Get the dispatcher to register handlers dp = updater.dispatcher # Comandos a los que responder dp.add_handler(CommandHandler("mimimi", mimimi)) # sin comando respondemos inline dp.add_handler(InlineQueryHandler(inlinequery)) # log de errores dp.add_error_handler(error) # arranque del bot updater.start_polling() # El bot correrá hasta que pulsemo Ctrl+C updater.idle()
def main() -> None: # Create the Updater and pass it your bot's token. updater = Updater("TOKEN") # Get the dispatcher to register handlers dispatcher = updater.dispatcher # on different commands - answer in Telegram dispatcher.add_handler(CommandHandler("start", start)) dispatcher.add_handler(CommandHandler("help", help_command)) # on noncommand i.e message - echo the message on Telegram dispatcher.add_handler(InlineQueryHandler(inlinequery)) # 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(): #676428333:AAEYXfSt7tDKsqSzEloCwUDlgFdv-2tq3UU debug #873370289:AAEl2az5yYNkZg5cs57J2-_AThtpC_qOVso main TOKEN = "873370289:AAEl2az5yYNkZg5cs57J2-_AThtpC_qOVso" updater = Updater(TOKEN) dispatcher = updater.dispatcher #Handlers dispatcher.add_handler(InlineQueryHandler(inlinequery)) dispatcher.add_handler(MessageHandler(Filters.text, message)) dispatcher.add_handler(CommandHandler("start", start)) dispatcher.add_handler(CallbackQueryHandler(button)) updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN) updater.bot.setWebhook("https://iranmeteorologybot.herokuapp.com/" + TOKEN) #updater.start_polling() updater.idle()
def main(): updater = Updater('TOKEN') dp = updater.dispatcher dp.add_handler(CommandHandler("start", start)) dp.add_handler(CallbackQueryHandler(echo_photo)) dp.add_handler(CommandHandler("photo", photo)) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("lang_code", lang_code)) dp.add_handler(CommandHandler("def", defenition, pass_args=True, pass_chat_data=True)) dp.add_handler(MessageHandler(Filters.text, echo)) dp.add_handler(MessageHandler(Filters.document, echo_file)) dp.add_handler(MessageHandler(Filters.photo, get_photo)) dp.add_handler(InlineQueryHandler(inlinequery)) dp.add_error_handler(error) 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 __init__(self, bot_token, bot_db): self.db = bot_db self.token = bot_token read_timeout = Cfg.get("telegram", "read_timeout") connect_timeout = Cfg.get("telegram", "connect_timeout") kwargs = dict() if read_timeout: kwargs["read_timeout"] = read_timeout if connect_timeout: kwargs["connect_timeout"] = connect_timeout try: self.updater = Updater(bot_token, request_kwargs=kwargs) except InvalidToken as e: cls_name = f"Class: {type(self).__name__}" logging.error(f"{repr(e)} - {cls_name}") exit("ERROR: Bot token not valid") self.job_queue = self.updater.job_queue self.dispatcher = self.updater.dispatcher # Handler for command-links self._add_link_handler() # Load classes in folder 'plugins' self._load_plugins() # Handler for inline-mode self.dispatcher.add_handler(InlineQueryHandler(self._inline)) # Handle all Telegram related errors self.dispatcher.add_error_handler(self._handle_tg_errors) # Refresh cache periodically self._refresh_cache() # Check for updates periodically self._update_check()
def main(): """Start the bot.""" # Create the EventHandler and pass it your bot's token. updater = Updater("TOKEN") j = updater.job_queue # 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("gitname", gitname)) dp.add_handler(CommandHandler("help", help)) # dp.add_handler(CommandHandler("todo", todo)) dp.add_handler(CommandHandler("done", done)) dp.add_handler(CommandHandler("completed", completed)) dp.add_handler(CommandHandler("tasks", tasks_)) dp.add_handler(CommandHandler("leaderboard", leaderboard)) dp.add_handler(CommandHandler("streak", streak)) dp.add_handler(InlineQueryHandler(inlinequery)) dp.add_handler(CommandHandler("todo", todo)) dp.add_handler(CommandHandler("reminder",reminder, pass_args=True, pass_job_queue=True, pass_chat_data=True)) # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.text, echo)) dp.add_handler(MessageHandler(Filters.command, command_handler)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # Run the bot until you press Ctrl-C or the process receives SIGINT, # SIGTERM or SIGABRT. This should be used most of the time, since # start_polling() is non-blocking and will stop the bot gracefully. updater.idle()
def run(self): print("Starting server...") self.updater = Updater(token = BotServer.TOKEN) self.dispatcher = self.updater.dispatcher self.job_queue = self.updater.job_queue # self.ipchecker = ipchecker.IPChecker(self) # self.ipchecker.start() # self.db = database.Database() # self.db.connect() self.api = APIClient() logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) start_handler = CommandHandler('start', self.start) echo_handler = MessageHandler(Filters.text, BotServer.echo) caps_handler = CommandHandler('caps', BotServer.caps, pass_args=True) inline_caps_handler = InlineQueryHandler(BotServer.inline_caps) # checkip_handler = CommandHandler('checkip', self.check_ip) get_languages_handler = CommandHandler('get_languages', self.get_languages) unknown_handler = MessageHandler(Filters.command, BotServer.unknown) self.dispatcher.add_handler(start_handler) self.dispatcher.add_handler(echo_handler) self.dispatcher.add_handler(caps_handler) self.dispatcher.add_handler(inline_caps_handler) # self.dispatcher.add_handler(checkip_handler) self.dispatcher.add_handler(get_languages_handler) self.dispatcher.add_handler(unknown_handler) print("Server started.") self.updater.start_polling() try: while True: pass except KeyboardInterrupt: print("Stopping server. Please wait...") # self.db.close() # self.ipchecker.join() self.updater.stop() print("Server stopped.")
def main(): # Create the EventHandler and pass it to the bot's token updater = Updater(token=TOKEN) # Get the dispathcher to register handlers dispatcher = updater.dispatcher # Add handlers start_handler = CommandHandler('start', startMsg) list_exchanges_handler = CommandHandler('list', listExchangesMsg) price_handler = CommandHandler('price', priceMsg) fx_handler = CommandHandler('fx', fxMsg) exchange_handler = CommandHandler('exchange', exchangeMsg) summary_handler = CommandHandler('summary', summaryMsg) bitmex_handler = CommandHandler('bitmex', bitmexMsg) inline_query_handler = InlineQueryHandler(inline_query) dispatcher.add_handler(start_handler) dispatcher.add_handler(list_exchanges_handler) dispatcher.add_handler(price_handler) dispatcher.add_handler(fx_handler) dispatcher.add_handler(exchange_handler) dispatcher.add_handler(summary_handler) dispatcher.add_handler(bitmex_handler) dispatcher.add_handler(inline_query_handler) unknown_handler = MessageHandler(Filters.text, unknownMsg) dispatcher.add_handler(unknown_handler) # log all errors dispatcher.add_error_handler(error) # start the bot logger.info("Starting bot.") updater.start_polling() # The above runs the bot until CTRL-C or SIGINT, SIGTERM, or SIGABRT is # received. start_polling() is non-blocking and this will stop the bot # gracefully updater.idle() logger.info("Exiting bot.")
def __init__(self, token): # Creating the Updater and the dispatcher: self.logger = logging.getLogger(__name__) self.bot = Bot(token) self.updater = Updater(token) dp = self.updater.dispatcher # Adding some CommandHandlers: dp.add_handler(CommandHandler("start", self.start)) dp.add_handler(CommandHandler("help", self.help)) # This CommandHandler will receive arguments from the user: dp.add_handler(CommandHandler("search", self.search, pass_args=True)) dp.add_handler(CommandHandler("list", self.get_list)) # These will handler callback queries and inline queries: dp.add_handler(CallbackQueryHandler(self.callback_query_handler)) dp.add_handler(InlineQueryHandler(self.inline_query_handler)) # Log all errors: dp.add_error_handler(self.error)
def test_illegal_handlers(self): with self.assertRaises(ValueError): ConversationHandler(entry_points=[ CommandHandler('/test', lambda bot, update: None) ], states={}, fallbacks=[], per_message=True) with self.assertRaises(ValueError): ConversationHandler( entry_points=[CallbackQueryHandler(lambda bot, update: None)], states={}, fallbacks=[], per_message=False) with self.assertRaises(ValueError): ConversationHandler( entry_points=[InlineQueryHandler(lambda bot, update: None)], states={}, fallbacks=[], per_chat=True)
def main(bot=None): token = bot_token updater = Updater(token) for item in parse_data['items']: updater.dispatcher.add_handler(CommandHandler(item, commands)) updater.dispatcher.add_handler(CommandHandler('help', start)) updater.dispatcher.add_handler(CommandHandler('start', start)) updater.dispatcher.add_handler(CommandHandler('ping', ping)) updater.dispatcher.add_handler(CommandHandler('info', info)) updater.dispatcher.add_handler(MessageHandler(Filters.text, messages)) updater.dispatcher.add_handler(CallbackQueryHandler(callback)) updater.dispatcher.add_handler(InlineQueryHandler(inline)) updater.dispatcher.add_error_handler(error) try: updater.start_polling(clean=True, timeout=120) updater.idle() except Exception: traceback.print_exc() finally: sys.exit(1)
def start(): """Connects to Telegram and starts the bot.""" bot = Updater(token=API_KEY, use_context=True) dp = bot.dispatcher # Register inline query handler dp.add_handler(InlineQueryHandler(on_inline_query)) # Register command handlers dp.add_handler(CommandHandler("start", on_command_start)) dp.add_handler(CommandHandler("help", on_command_help)) # Register text message handler dp.add_handler(MessageHandler(Filters.text, on_message_text)) log.info("Bot ready, dood! Connected as {username} (with ID {id}).".format( username=bot.bot.username, id=bot.bot.id )) bot.start_polling() bot.idle()
def run_bot(): """Start the bot.""" updater = Updater(config['telegram']['token']) dp = updater.dispatcher dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("about", about)) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("ipsum", ipsum)) dp.add_handler(CommandHandler("feedback", feedback)) dp.add_handler(CallbackQueryHandler(button)) dp.add_handler(InlineQueryHandler(inlinequery)) dp.add_handler(MessageHandler(Filters.text, translation)) dp.add_error_handler(error) updater.start_polling() updater.idle()
def add_handlers(dispatcher): """Adding inline handlers to dispatcher :param dispatcher: dispatcher object :type dispatcher: telegram.dispatcher """ dispatcher.add_handler( CallbackQueryHandler( Inline.join_program, pattern='{0}:.+' .format(Actions.JOIN_PROGRAM))) # Inline show link to channel dispatcher.add_handler( CallbackQueryHandler( Inline.show_link, pattern=r'.{60}')) # On noncommand i.e message - echo the message on Telegram dispatcher.add_handler( InlineQueryHandler( Inline.inline_query_handler))
def start(): # configure logging logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) logger = logging.getLogger(__name__) logger.info("logger initialized. starting bot..") # get bot token try: from bot.api_tokens import get_bot_token bot_token = get_bot_token() except TokenNotFoundError: sys.exit() tg_updater = tg_ext.Updater(token=bot_token, use_context=True) dispatcher = tg_updater.dispatcher # configure command handlers # general help_handler = tg_ext.CommandHandler('help', help.help) dispatcher.add_handler(help_handler) # popular_locations popularity_now_handler = CommandHandler('wievolljetzt', send_current_popularity) dispatcher.add_handler(popularity_now_handler) setlocation_handler = CommandHandler('setlocation', set_location) dispatcher.add_handler(setlocation_handler) popularity_handler = CommandHandler('wievoll', start_popularity_dialog) dispatcher.add_handler(popularity_handler) # inline inline_query_handler = InlineQueryHandler(inline.handle_inline_query) dispatcher.add_handler(inline_query_handler) callback_handler = CallbackQueryHandler(inline.handle_inline_callback) dispatcher.add_handler(callback_handler) tg_updater.start_polling()
def main(): config = configparser.ConfigParser() config.read('config.ini') token = config['DEFAULT']['API_KEY'] Global.games = config['DEFAULT']['GAMES'].split(',') Global.host = config['DEFAULT']['HOST'] Global.port = config['DEFAULT']['PORT'] Global.featured = config['DEFAULT']['FEATURED'] updater = Updater(token=token) updater.dispatcher.add_handler(CommandHandler('start', start)) updater.dispatcher.add_handler(InlineQueryHandler(inlinequery)) updater.dispatcher.add_handler(CallbackQueryHandler(button)) updater.dispatcher.add_error_handler(error) Global.bot = updater.bot print("Polling telegram") updater.start_polling() print("Starting http server") http = HTTPServer((Global.host, int(Global.port)), GameHTTPRequestHandler) http.serve_forever()
def main(): TOKEN = os.environ.get('TOKEN') PORT = int(os.environ.get('PORT', '5000')) # Create the Updater and pass it your bot's token. updater = Updater(TOKEN) updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN) updater.bot.set_webhook("https://filmaffinitybot.herokuapp.com/" + TOKEN) # Get the dispatcher to register handlers dp = updater.dispatcher filmaffinity = FilmaffinityBot() # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", filmaffinity.start)) dp.add_handler(CommandHandler("help", filmaffinity.help)) dp.add_handler( CommandHandler("top_filmaffinity", filmaffinity.top_filmaffinity)) dp.add_handler(CommandHandler("top_netflix", filmaffinity.top_netflix)) dp.add_handler(CommandHandler("top_hbo", filmaffinity.top_hbo)) dp.add_handler(CommandHandler("top_dvd", filmaffinity.top_dvd)) dp.add_handler(CommandHandler("top_movistar", filmaffinity.top_movistar)) dp.add_handler(CommandHandler("top_rakuten", filmaffinity.top_rakuten)) dp.add_handler(CommandHandler("top_tv_series", filmaffinity.top_tv_series)) dp.add_handler( CommandHandler("recommend_netflix", filmaffinity.recommend_netflix)) dp.add_handler( CommandHandler("recommend_movistar", filmaffinity.recommend_movistar)) dp.add_handler(CommandHandler("recommend_hbo", filmaffinity.recommend_hbo)) dp.add_handler(CommandHandler("premieres", filmaffinity.premieres)) # on noncommand i.e message - echo the message on Telegram dp.add_handler(InlineQueryHandler(filmaffinity.inlinequery)) # log all errors dp.add_error_handler(filmaffinity.error) # Start the Bot updater.start_polling() updater.idle()
def main(): updater = Updater(token = '1105160055:AAGkIIuk_M4B3r_uwumehJwJ8ZLwQDqylqo', use_context = True) dispatcher = updater.dispatcher conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ #CPF: [MessageHandler(Filters.text, cpf)], CPF: [InlineQueryHandler(cpf)], SENHA: [MessageHandler(Filters.text, senha)] }, fallbacks = [CommandHandler("sair", sair)] ) dispatcher.add_handler(conv_handler) #Log errors dispatcher.add_error_handler(error) #Start the bot updater.start_polling() updater.idle()
def main(): updater = Updater(token=TOKEN) dispatcher = updater.dispatcher dispatcher.add_handler(CommandHandler('r', command_roll, pass_args=True, pass_chat_data=True)) dispatcher.add_handler(CommandHandler('coc7', coc7stats, pass_args=True)) dispatcher.add_handler(CommandHandler('dnd5e', dnd5e_attributes)) dispatcher.add_handler(CommandHandler('coctrait', coc_trait)) dispatcher.add_handler(CommandHandler('name', random_text('name'), pass_args=True)) dispatcher.add_handler(CommandHandler('male', random_text('name_male'), pass_args=True)) dispatcher.add_handler(CommandHandler('female', random_text('name_female'), pass_args=True)) dispatcher.add_handler(CommandHandler('company', random_text('company'), pass_args=True)) dispatcher.add_handler(CommandHandler('address', random_text('address'), pass_args=True)) dispatcher.add_handler(CommandHandler('city', random_text('city'), pass_args=True)) dispatcher.add_handler(CommandHandler('decide', select, pass_args=True)) dispatcher.add_handler(CommandHandler('choice', select, pass_args=True)) dispatcher.add_handler(CommandHandler('select', select, pass_args=True)) dispatcher.add_handler(InlineQueryHandler(inline_query)) dispatcher.add_error_handler(error) updater.start_polling() updater.idle()
def main(): token = "207013186:AAGimWjXwN9PlvHIW_EWfOgbLAQ3SVIESik" updater = Updater(token, workers=2) dp = updater.dispatcher dp.add_handler(InlineQueryHandler(inlinequery)) # Commands dp.add_handler(CommandHandler("fact", send_fact)) dp.add_handler(CommandHandler("help", send_help)) dp.add_error_handler(error) updater.start_webhook( port=int(os.environ.get("DOKKU_PROXY_PORT")), url_path=token, ) print('Listening...') logging.info('Listening...') updater.idle()
def __init__(self): load_dotenv() token = os.getenv('TOKEN') # proxy_url = os.getenv('PROXY_URL') # proxy_username = os.getenv('PROXY_USERNAME') # proxy_password = os.getenv('PROXY_PASSWORD') # request_kwargs = { # 'proxy_url': proxy_url, # 'urllib3_proxy_kwargs': { # 'username': proxy_username, # 'password': proxy_password, # } # } self.updater = Updater(token, use_context=True) self.dp = self.updater.dispatcher self.dp.add_handler(CommandHandler('tags', self.get_tags)) self.dp.add_handler(CommandHandler('start', self.start_command)) self.dp.add_handler(CommandHandler('help', self.help_command)) self.dp.add_handler(InlineQueryHandler(self.inlinequery)) self.dp.add_error_handler(self.error)
def main(): # Create the Updater and pass it your bot's token. updater = Updater(BOT_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(InlineQueryHandler(inlinequery)) # 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(): # creating bot bot = Updater(TOKEN, use_context=True, request_kwargs=PROXY) # creating dispatcher dp = bot.dispatcher # creating job for regular sync database bot.job_queue.run_repeating(callback=sync_current_leagues, interval=3600, first=10) bot.job_queue.run_repeating(callback=sync_game_current_league, interval=3600, first=10) bot.job_queue.run_repeating(callback=sync_league_baner, interval=3600, first=40) # TODO get_baner # creating write in log about start bot logging.info("Bot is run") # creating handlers dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help_me)) dp.add_handler( MessageHandler(Filters.regex("OK, search informations about(.*)"), view_league_info)) dp.add_handler( CallbackQueryHandler(view_game_info, pattern="^view_game_info \d+$")) dp.add_handler(CallbackQueryHandler(subs_video, pattern="^subs_video \d+$")) dp.add_handler(CallbackQueryHandler(subs_text, pattern="^subs_text \d+$")) dp.add_handler(InlineQueryHandler(inlinequery)) # dp.add_handler(CommandHandler("alarm", set_alarm, pass_args=True, pass_job_queue=True)) # run bot bot.start_polling() bot.idle()
def main(): updater = Updater(token=TOKEN, request_kwargs=REQUEST_KWARGS) dispatcher = updater.dispatcher # Add conversation handler conv_handler = ConversationHandler( entry_points=[CommandHandler("start", start)], states={ CHOOSING: [CallbackQueryHandler(button)], WEATHER: [ MessageHandler(Filters.location | Filters.text, get_weather), CommandHandler("back", back) ], CURRENCY: [ MessageHandler(Filters.text, get_currency), CommandHandler("back", back) ], }, fallbacks=[CommandHandler("finish", finish)]) # handlers help_handler = CommandHandler("help", help) inline_switch_pm_handler = InlineQueryHandler(inline_switch_pm) unknown_handler = MessageHandler(Filters.command, unknown) # registration handlers dispatcher.add_handler(help_handler) dispatcher.add_handler(conv_handler) dispatcher.add_handler(inline_switch_pm_handler) dispatcher.add_handler(unknown_handler) # log all errors dispatcher.add_error_handler(error) # start the bot updater.start_polling(timeout=5) # stop the bot gracefully updater.idle()
def main(): # Create the EventHandler and pass it your bot's token. updater = Updater(CONFIGURATION["telegram_token"]) global RESPONSE_DICT # Load the responses RESPONSE_DICT = EmojiconFinder.load_response_json( CONFIGURATION["responses_file"]) # Get the dispatcher to register handlers dp = updater.dispatcher # Add conversation handler with the states EMOJICONNAME e EMOJICON conv_handler = ConversationHandler( entry_points=[CommandHandler('addemojicon', addemojicon_command)], states={ EMOJICONNAME: [MessageHandler(Filters.text, emojiconname_command)], EMOJICON: [MessageHandler(Filters.text, newemojicon_command)] }, fallbacks=[CommandHandler('cancel', cancel)]) dp.add_handler(conv_handler) dp.add_handler(CommandHandler("start", start_command)) dp.add_handler(CommandHandler("starten", starten_command)) dp.add_handler(CommandHandler("help", help_command)) dp.add_handler(CommandHandler("helpen", helpen_command)) dp.add_handler(InlineQueryHandler(inline_busca_emojicon)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # Run the bot until you press Ctrl-C or the process receives SIGINT, # SIGTERM or SIGABRT. This should be used most of the time, since # start_polling() is non-blocking and will stop the bot gracefully. updater.idle()
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 worker(inherit, **kwargs): global logger # app = command.app(inherit.logger, inherit.config) app = command.app(inherit) token = kwargs['token'] # for test purposes limit global throughput to 30 messages per 2 sec q = messagequeue.MessageQueue(all_burst_limit=2, all_time_limit_ms=3000) request = Request(con_pool_size=14) testbot = MQBot(token, request=request, mqueue=q) updater = Updater(bot=testbot, workers=10) # admin admins = list() for x in inherit.config.get('admins', 'list').split(','): admins.append(int(x)) # Get the dispatcher to register handlers dp = updater.dispatcher logger = inherit.logger logger = logging.getLogger(__name__) logger.info(f'{testbot.get_me().first_name} is listening...') dp.add_handler(CommandHandler('update', app.update_dict, Filters.user(user_id=admins)), group=1) dp.add_handler(InlineQueryHandler(app.dong), group=1) # non command dp.add_error_handler(app.error) # updater.start_polling(clean=False) # updater.idle() try: updater.start_polling(clean=False) updater.idle() except KeyboardInterrupt: updater.stop() updater.is_idle = False
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()