def main(dp, group): for i in [ tg_ext.CommandHandler('reboot', bot_reboot), tg_ext.CommandHandler('shutdown', bot_shutdown), tg_ext.CommandHandler('usage', bot_usage), tg_ext.CommandHandler('leave', bot_leave), ]: dp.add_handler(i, group)
def start_telegram_bot(): updater = telegram.Updater("576999277:AAGFOfw8WUOz2FB-TGgTVkNjBdkLZC1AAUU") # Get the dispatcher to register handlers dp = updater.dispatcher # on different commands - answer in Telegram dp.add_handler(telegram.CommandHandler("start", start)) dp.add_handler(telegram.CommandHandler("help", start)) dp.add_handler( telegram.CommandHandler("set", set_timer, pass_args=True, pass_job_queue=True, pass_chat_data=True)) dp.add_handler(telegram.CommandHandler("unset", unset, pass_chat_data=True)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # Block until you press Ctrl-C or the process receives SIGINT, SIGTERM or # SIGABRT. This should be used most of the time, since start_polling() is # non-blocking and will stop the bot gracefully. pool = ThreadPool(1) pool.map(updater.idle, []) return updater
def main(): console.log('Starting...') exchanges['bitstamp'] = Exchange( ccxt.bitstamp(config=config.bitstamp.to_dict())) exchanges['binance'] = Exchange( ccxt.binance(config=config.binance.to_dict())) exchanges['bittrex'] = Exchange( ccxt.bittrex(config=config.bittrex.to_dict())) exchanges['cryptopia'] = Exchange( ccxt.cryptopia(config=config.cryptopia.to_dict())) exchanges['hitbtc'] = Exchange( ccxt.hitbtc2(config=config.hitbtc.to_dict())) telebot.add_handler( telegram.CommandHandler(command='balance', callback=TelegramCommands.get_balance)) telebot.add_handler( telegram.CommandHandler(command='start', callback=TelegramCommands.start)) telebot.add_handler( telegram.CommandHandler(command='help', callback=TelegramCommands.show_help)) telebot.start() console.log('Ready...') telebot.idle()
def init_handlers(dispatcher): global debug_mode debug_mode = False # start command start_handler = ext.CommandHandler('start', start) dispatcher.add_handler(start_handler) # add to follower list # TODO: do a thing when not given an argument follow_handler = ext.CommandHandler('follow', follow, pass_args=True) dispatcher.add_handler(follow_handler) # list followers list_handler = ext.CommandHandler('list_followed', list_followed) dispatcher.add_handler(list_handler) # help command help_handler = ext.CommandHandler("help", help) dispatcher.add_handler(help_handler) # debug command debug_handler = ext.CommandHandler("debug", debug) dispatcher.add_handler(debug_handler)
def run_tbot(ip): updater = ext.Updater(token=token) sounds = get_sounds() sound_keys = sorted(list(sounds.keys())) def generic(bot, update): sound = sounds[update.message.text[1:]] requests.get('http://{}:5000/play_sound/{}'.format(ip, sound)) bot.send_message(chat_id=update.message.chat_id, text='sent: {}'.format(sound)) def play(bot, update): keyboard = [ [ InlineKeyboardButton(sound_keys[2*i], callback_data=sounds[sound_keys[2*i]]), InlineKeyboardButton(sound_keys[2*i+1], callback_data=sounds[sound_keys[2*i+1]]) \ if 2*i+1 < len(sound_keys) else InlineKeyboardButton('', callback_data=sounds[sound_keys[2*i]]), ] for i in range((len(sound_keys) +1 ) //2) ] reply_markup = InlineKeyboardMarkup(keyboard) update.message.reply_text('Buttons:', reply_markup=reply_markup) def button(bot, update): query = update.callback_query requests.get('http://{}:5000/play_sound/{}'.format(ip, query.data)) bot.edit_message_text(text="sent: {}".format(query.data), chat_id=query.message.chat_id, message_id=query.message.message_id) updater.dispatcher.add_handler(ext.CallbackQueryHandler(button)) updater.dispatcher.add_handler(ext.CommandHandler('play', play)) for key in sound_keys: updater.dispatcher.add_handler(ext.CommandHandler(key, generic)) updater.start_polling()
def main(dp, group): for i in [ tg_ext.CommandHandler('audio', youtube_audio, pass_args = True), tg_ext.CommandHandler('video', youtube_video, pass_args = True), tg_ext.CommandHandler('nightcore', youtube_nightcore, pass_args = True), tg_ext.CommandHandler('daycore', youtube_daycore, pass_args = True), tg_ext.CommandHandler('debug', youtube_debug, pass_args = True), ]: dp.add_handler(i, group)
def group_conv(): conv_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('view', group_view)], states={}, fallbacks=[ext.CommandHandler('cancel', cancel)], ) dispatcher.add_handler(conv_handler)
def change_logiks(): conv_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('change', logik_change)], states={ LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, enter_logiks)], }, fallbacks=[ext.CommandHandler('cancel', cancel)], ) dispatcher.add_handler(conv_handler)
def main(): global welcome_message global command_list_message try: with open("welcome.txt", 'r', encoding='utf8') as welcome_file: welcome_message = welcome_file.read() except FileNotFoundError: logger.error('failed to load welcome.txt') try: with open("commands.txt", 'r', encoding='utf8') as commands_file: command_list_message = commands_file.read() except FileNotFoundError: logger.error('failed to load welcome.txt') updater = ext.Updater(os.environ['TELEGRAM_BOT_KEY']) dispatcher = updater.dispatcher dispatcher.add_handler(ext.CommandHandler('cadastro', register)) dispatcher.add_handler(ext.CommandHandler('start', hello)) #dispatcher.add_handler(ext.CommandHandler('cadastrar', signup)) dispatcher.add_handler(ext.CommandHandler('email', update_email, pass_args=True)) dispatcher.add_handler(ext.CommandHandler('planilha', register_spreadsheet_name, pass_args=True)) dispatcher.add_handler(ext.CommandHandler('telegram', change_alert_telegram, pass_args=True)) dispatcher.add_handler(ext.CommandHandler('limpar_email', clear_email)) dispatcher.add_handler(ext.CommandHandler('ajuda', help)) dispatcher.add_handler(ext.CommandHandler('dia', show_weekday_keyboard)) dispatcher.add_handler(ext.CommandHandler('teste', show_names_suggestion)) dispatcher.add_handler(ext.CallbackQueryHandler(callback_handler)) dispatcher.add_handler(ext.MessageHandler(ext.Filters.text, text_decoder)) logger.info("Starting polling") updater.start_polling() logger.info("Bot in idle, awaiting users messages") updater.idle()
def people_conv(): conv_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('teacher_admin', teacher_admin)], states={ GR_ID: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, gr_id)], USERNAME: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, username)], LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, logiks)], }, fallbacks=[ext.CommandHandler('cancel', cancel)], ) dispatcher.add_handler(conv_handler)
def main(): print("Connection to Telegram established; starting bot.") conv_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('start', start, pass_user_data=True)], states={ CHOOSING: [ ext.RegexHandler('^(Nama|NIM_or_NIP|Email)$', regular_choice, pass_user_data=True), ], TYPING_CHOICE: [ ext.MessageHandler(ext.Filters.text, regular_choice, pass_user_data=True), ], TYPING_REPLY: [ ext.MessageHandler(ext.Filters.text, received_information, pass_user_data=True), ], }, fallbacks=[ext.RegexHandler('^Done$', done, pass_user_data=True)]) dp.add_handler(conv_handler) # log all errors dp.add_error_handler(error) # Start command # dp.add_handler(ext.CommandHandler( # ('start'), start)) # Home command dp.add_handler(ext.CommandHandler(('home'), home)) # Tata Tulis PKL dan TA dp.add_handler(ext.CommandHandler(('tatatulis'), tatatulis)) # Layanan TA dp.add_handler(ext.CommandHandler(('layananta'), layananta)) # Layanan PKL dp.add_handler(ext.CommandHandler(('layananpkl'), layananpkl)) # Button Handler dp.add_handler(ext.CallbackQueryHandler(button)) # Filter Command dp.add_handler(ext.MessageHandler((ext.Filters.command), unknowncommand)) updater.start_polling() updater.idle()
def main(): """ Inicie o bot e habilite o reconhecimento dos comandos iniciar, twitter e tts. Além disso, permita a identificação de áudio enviado ao grupo. """ updater = ext.Updater(bot_key) dp = updater.dispatcher dp.add_handler(ext.MessageHandler(ext.Filters.voice, voz)) dp.add_handler(ext.CommandHandler('iniciar', iniciar)) dp.add_handler(ext.CommandHandler('twitter', twitter)) dp.add_handler(ext.CommandHandler('tts', tts)) updater.start_polling() updater.idle()
def main(dispatcher): send_broadcast_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('send_broadcast', __send_broadcast)], states={ REVIEW: [ext.MessageHandler(ext.Filters.text, __review_message)], CONFIRMATION: [ ext.MessageHandler(ext.Filters.regex('Yes|No'), __confirm_broadcast) ] }, fallbacks=[ext.CommandHandler('cancel', __send_broadcast_cancel)]) dispatcher.add_handler(send_broadcast_handler)
def __set_handlers(self) -> None: self.__dispatcher.add_handler( tg_ext.MessageHandler(filters=tg_ext.Filters.text & ~tg_ext.Filters.command, callback=self.__send_weather_callback)) self.__dispatcher.add_handler( tg_ext.CommandHandler(command='start', callback=self.__start_command_callback)) self.__dispatcher.add_handler( tg_ext.CommandHandler(command='help', callback=self.__help_command_callback))
def main(): ''' Main function to run the bot. ''' # set up updater and dispatcher updater = tg.Updater(_get_token()) dp = updater.dispatcher jq = updater.job_queue # JobQueue functions job_bday = jq.run_repeating(callback_birthday, interval=timedelta(days=1), first=_get_tmr()) # Event related dp.add_handler(tg.CommandHandler('event', event)) # dp.add_handler(tg.CommandHandler('trophy', trophy)) # dp.add_handler(tg.RegexHandler(patterns['top'], top)) # Gacha related dp.add_handler(tg.CommandHandler('gacha', gacha)) # dp.add_handler(tg.CommandHandler('nextgacha', next_gacha)) # dp.add_handler(tg.RegexHandler(patterns['roll'], roll)) # Others dp.add_handler(tg.RegexHandler(patterns['help'], help)) dp.add_handler(tg.RegexHandler(patterns['calmdown'], calmdown)) dp.add_handler(tg.RegexHandler(patterns['ken'], ken)) dp.add_handler(tg.RegexHandler(patterns['epluslomo'], epluslomo)) # Twitter forwarding dp.add_handler( tg.MessageHandler(tg.Filters.chat(chat_id=_get_forward('Chihiro')), forward)) # Debug dp.add_handler( tg.MessageHandler(tg.Filters.user(username=_get_username()), debug)) # log 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 create_tg_conversation_handler(self) -> tg.ConversationHandler: return tg.ConversationHandler( entry_points=[tg.CommandHandler('start', self.start)], states={ STAGE_SET_KEY: [tg.MessageHandler(Filters.text, self.set_key)] }, fallbacks=[])
def __init__(self, config: Config, engine: Engine): self.updater = tg.Updater(config.token, workers=1, request_kwargs={ 'proxy_url': config.proxy_url, 'urllib3_proxy_kwargs': { 'username': config.proxy_username, 'password': config.proxy_password, }, }) self.config = config self.engine = engine self.logger = logging.getLogger(__name__) dp = self.updater.dispatcher rm_setting_handler = RedmineSettingHandler( engine, self.config, self.logger).create_tg_conversation_handler() dp.add_handler(rm_setting_handler) rm_task_handler = RedmineTrackHandler( engine, self.config, self.logger).create_tg_conversation_handler() dp.add_handler(rm_task_handler) dp.add_handler(tg.CommandHandler('help', self.help)) dp.add_error_handler(self.error)
def main(dispatcher): add_word_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('add_word', __add_word)], states={ WORD: [ext.MessageHandler(ext.Filters.text, __set_word)], MEANING: [ ext.MessageHandler(ext.Filters.text, __set_meaning), ext.CallbackQueryHandler(__word_meaning_verification, pattern=r'^word_meaning:\d$') ], MEANING_ERROR: [ext.MessageHandler(ext.Filters.text, __handle_meaning_error)], }, fallbacks=[ext.CommandHandler('cancel', __add_word_cancel)]) dispatcher.add_handler(add_word_handler)
def add_handlers(dispatcher: tg.ext.Dispatcher): start_handler = tge.CommandHandler('start', start_callback) dispatcher.add_handler(start_handler) tree_handler = tge.CommandHandler('tree', tree_callback) dispatcher.add_handler(tree_handler) callback_handler = tge.CallbackQueryHandler(query_callback) dispatcher.add_handler(callback_handler) link_handler = tge.MessageHandler( filters=tgFilters.text & (tgFilters.entity(tg.MessageEntity.URL) | tgFilters.entity(tg.MessageEntity.TEXT_LINK)), callback=link_callback) dispatcher.add_handler(link_handler)
def create_updater(token): updater = tg.Updater(token=token) for command in commands: handler = tg.CommandHandler(command.__name__, command) updater.dispatcher.add_handler(handler) return updater
def main(): try: console.log('Starting...') target_user_trades = queue.Queue() target_user_trades_fetched = threading.Event() trader = Trader(ex_api=exchange_api) trader.start() analyzer = Analyzer(ex_api=exchange_api, target_user_trades=target_user_trades, target_user_trades_fetched=target_user_trades_fetched) analyzer.start() trade_book_loader = TradeBookWatcher(ex_api=exchange_api, target_user_trades=target_user_trades, target_user_trades_fetched=target_user_trades_fetched) trade_book_loader.start() market_price_watcher = MarketPriceWatcher(ex_api=exchange_api) market_price_watcher.start() telebot.add_handler(telegram.CommandHandler(command='prices', callback=telegram_get_market_prices)) telebot.add_handler(telegram.CommandHandler(command='buy', callback=telegram_create_buy_order)) telebot.add_handler(telegram.CommandHandler(command='sell', callback=telegram_create_sell_order)) telebot.start() console.log('Ready!') try: while trader.is_alive() \ and analyzer.is_alive() \ and trade_book_loader.is_alive() \ and market_price_watcher.is_alive() \ and telebot.is_alive(): time.sleep(5) except: telebot.stop() while telebot.is_alive(): time.sleep(1) raise except KeyboardInterrupt: return except: raise finally: console.log('', n=1)
def main_bot(): persistence = te.PicklePersistence( filename=configuration["filenames"]["persistence"]) defaults = te.Defaults(parse_mode=tele.ParseMode.HTML) token = get_secret_token() updater = te.Updater(token=token, use_context=True, persistence=persistence, defaults=defaults) dispatcher = updater.dispatcher dispatcher.add_handler(te.CommandHandler("start", start_callback)) dispatcher.add_handler(te.CommandHandler("help", help_callback)) dispatcher.add_handler(te.CommandHandler("aiuto", help_callback)) dispatcher.add_handler( te.MessageHandler(te.Filters.regex(r'^/id'), id_callback)) dispatcher.add_handler(te.CommandHandler("dosi", dosi_callback)) dispatcher.add_handler(te.CommandHandler("stagione", stagione_callback)) dispatcher.add_handler(te.CommandHandler("categorie", categorie_callback)) dispatcher.add_handler(te.CommandHandler("portate", portate_callback)) dispatcher.add_handler(te.CallbackQueryHandler(portate_button_callback)) dispatcher.add_handler(te.MessageHandler(te.Filters.text, query_callback)) dispatcher.add_error_handler(error_callback) updater.start_polling() updater.idle()
def setup_handlers(self): """ Cria os comandos do bot """ # Começar self.dispatcher.add_handler( tgm.CommandHandler(command="start", callback=self.start_handler)) # Ajuda self.dispatcher.add_handler( tgm.CommandHandler(command="ajuda", callback=self.help_handler)) # Informações self.dispatcher.add_handler( tgm.CommandHandler(command="info", callback=self.info_handler)) # Cadastrar chat self.dispatcher.add_handler( tgm.CommandHandler(command="cadastrar", callback=self.subscribe_handler)) # Descadastrar chat self.dispatcher.add_handler( tgm.CommandHandler(command="descadastrar", callback=self.unsubscribe_handler)) # Listar sites self.dispatcher.add_handler( tgm.CommandHandler(command="listar_sites", callback=self.list_scrapers)) # Atualizar tudo self.dispatcher.add_handler( tgm.CommandHandler(command="atualizar_tudo", callback=self.update_all)) # Comandos concurso self.dispatcher.add_handler( tgm.CallbackQueryHandler(callback=self.button_actions)) # Erro self.dispatcher.add_error_handler(callback=self.error_handler)
def main(dispatcher): get_suggestions_handler = ext.CommandHandler('get_suggestions', __get_suggestions) get_suggestions_callback_handler = ext.CallbackQueryHandler( __handle_suggestion_callback, pattern=r'^[1,0],.*$') dispatcher.add_handler(get_suggestions_handler) dispatcher.add_handler(get_suggestions_callback_handler)
def main(dp, group): for i in [ tg_ext.CommandHandler('set', set_parser, pass_args=True), tg_ext.CommandHandler('get', get_parser, pass_args=True), tg_ext.CommandHandler('del', del_parser, pass_args=True), tg_ext.CommandHandler('reg', registry_search, pass_args=True), tg_ext.CommandHandler('s', set_parser, pass_args=True), tg_ext.CommandHandler('g', get_parser, pass_args=True), tg_ext.CommandHandler('d', del_parser, pass_args=True), tg_ext.CommandHandler('r', registry_search, pass_args=True), tg_ext.MessageHandler(tg_ext.Filters.all, register), ]: dp.add_handler(i, group)
def main(): logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s") updater = tex.Updater( token='1611542237:AAGPMlkeNxp3geL0urxsSsBncnOBROjctsg') dp = updater.dispatcher # Handler do jogo game_handler = tex.ConversationHandler( entry_points=[tex.CommandHandler('start', start)], states={'ROUND': [tex.CallbackQueryHandler(round)]}, fallbacks=[tex.CommandHandler('start', start)]) dp.add_handler(game_handler) updater.start_polling() logging.info("=== Bot running! ===") updater.idle() logging.info("=== Bot shutting down! ===")
def main(dp, group): for i in [ tg_ext.CommandHandler('info', info_meta, pass_args=True), tg_ext.CommandHandler('i', info_meta, pass_args=True), tg_ext.CommandHandler('iu', info_user, pass_args=True), tg_ext.CommandHandler('ic', info_chat, pass_args=True), tg_ext.CommandHandler('im', info_message, pass_args=True), tg_ext.CommandHandler('if', info_forward, pass_args=True), tg_ext.CommandHandler('iF', info_full, pass_args=True), ]: dp.add_handler(i, group=group)
def run(self): """ Run your bot with all command added """ self._generate_help() self._dispatcher.add_handler(handler=ext.CommandHandler( "help", self._help()), group=ext.dispatcher.DEFAULT_GROUP) self._dispatcher.add_handler(handler=ext.MessageHandler( ext.Filters.command, self._unknown_command), group=ext.dispatcher.DEFAULT_GROUP) self._updater.start_polling() self.stop()
def main(): parser = create_parser() args = parser.parse_args() # bot auth updater = te.Updater(token=args.token) dispatcher = updater.dispatcher # database client = pymongo.MongoClient('localhost', username=args.dbuser, password=args.dbpasswd, authSource='training', authMechanism='SCRAM-SHA-1') db = client.training # TODO one config file with open('keys.json', 'r') as f: keys = json.loads(f.read()) with open('attributes.json', 'r') as f: attrs = json.loads(f.read()) with open('collections.json', 'r') as f: collections = json.loads(f.read()) gym_bot = logbot.LogBot(db=db, keys=keys, attrs=attrs, collections=collections) # TODO better logging! logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') # help_handler = te.CommandHandler('help', gym_bot.send_help) # dispatcher.add_handler(help_handler) stronglift_handler = te.CommandHandler('stronglift', gym_bot.stronglift) dispatcher.add_handler(stronglift_handler) # message handler msg_handler = te.MessageHandler(te.Filters.chat(args.user_id), gym_bot.analyze_msg) dispatcher.add_handler(msg_handler) # t0 = datetime.time(hour=0, minute=8) job_queue = dispatcher.job_queue # job_queue.run_repeating(callback=gym_bot.job, interval=30, first=0) updater.start_polling()
def register_command_route(self, route: CommandRoute) -> None: """ Registers given command handler. ......... Arguments --------- route: CommandRoute, required route to register """ self.__command_routes.append(route) self.__tg.add_handler( tg_ext.CommandHandler(command=route.command, callback=self.__serve_command_route))