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 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(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 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 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 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 main(): updater = ext.Updater('1267970793:AAFIiTln0imXgRAQQOk3rX-byuEmZXf7A_s', use_context=True) dp = updater.dispatcher dp.add_handler(ext.MessageHandler(ext.Filters.text, route)) dp.add_handler(ext.CallbackQueryHandler(call, pattern=r'[^0]')) dp.add_handler(ext.CallbackQueryHandler(final_times, pattern=r'[0]')) updater.start_polling() updater.idle()
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 __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 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 decorator(callback): self._dispatcher.add_handler(handler=ext.MessageHandler( filters=filters, callback=callback, allow_edited=allow_edited, pass_update_queue=pass_update_queue, pass_job_queue=pass_job_queue, pass_user_data=pass_user_data, pass_chat_data=pass_chat_data, message_updates=message_updates, channel_post_updates=channel_post_updates, edited_updates=edited_updates), group=group)
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(): """ 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(): 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_document_route(self, route: DocumentRoute) -> None: """ Registers given document handler. ......... Arguments --------- route: DocumentRoute, required route to register """ self.__doсument_routes.append(route) self.__tg.add_handler( tg_ext.MessageHandler(filters=tg_ext.Filters.document, callback=self.__serve_document_route))
def register_image_route(self, route: ImageRoute) -> None: """ Registers given image handler. ......... Arguments --------- route: ImageRoute, required route to register """ self.__image_routes.append(route) self.__tg.add_handler( tg_ext.MessageHandler(filters=tg_ext.Filters.photo, callback=self.__serve_image_route))
def register_message_route(self, route: MessageRoute) -> None: """ Registers given text message handler. ......... Arguments --------- route: MessageRoute, required route to register """ self.__message_routes.append(route) self.__tg.add_handler( tg_ext.MessageHandler(filters=tg_ext.Filters.regex(route.message), callback=self.__serve_message_route))
def start_telegram_updater(): updater = t_ext.Updater(os.environ["CECIBOT_TELEGRAM_SECRET"]) updater.dispatcher.add_handler(t_ext.ConversationHandler( entry_points=[ t_ext.CommandHandler("start", start), t_ext.MessageHandler(t_ext.Filters.text, only) ], allow_reentry=True, states={}, fallbacks=[], )) updater.dispatcher.add_error_handler(error) updater.start_polling()
def __init__(self): self.Pyborg = pyborg.pyborg(settings.get('gentbot')) self.Learning = settings.get('gentbot').get('learning') self.ReplyRate = settings.get('gentbot').get('replyrate') self.Name = settings.get('gentbot').get('name') self.updater = telext.Updater( token=settings.get('telegram').get('token')) # Setting up handlers dispatcher = self.updater.dispatcher gent_handler = telext.MessageHandler(telext.Filters.text, self.process) # Adding handlers dispatcher.add_handler(gent_handler) dispatcher.add_handler(telext.CommandHandler("save", self.save))
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 main(): with open('config.json') as json_file: config = json.load(json_file) updater = tgext.Updater(token=config['token'], use_context=True) valid_user: Set[int] = set(config['valid_user']) lamp_url = config['url'] auth = config['auth'] start_handler = tgext.CommandHandler('start', start) dispatcher = updater.dispatcher dispatcher.add_handler(start_handler) control_light_handler = tgext.MessageHandler( tgext.Filters.text, make_control_light(valid_user, lamp_url, auth)) dispatcher.add_handler(control_light_handler) updater.start_polling()
def main(dp, group): for chat_id in [ i for i in configs if check_conf(i + '.questions.enabled', bool, False) ]: name = 'question' + chat_id dp.chat_data[int(chat_id)][name] = dp.job_queue.run_repeating( callback=send_question, interval=check_conf(chat_id + '.questions.timer', int, 60 * 60), context=chat_id, name=name, ) for i in [ tg_ext.MessageHandler(tg_ext.Filters.all, queue_question, pass_job_queue=True, pass_chat_data=True), ]: dp.add_handler(i, group)
def main(): token_filename = 'token.txt' if os.path.exists(token_filename): with open(token_filename, 'r') as token_file: token = token_file.read().strip() else: token = os.environ['TOKEN'] updater = ext.Updater( token=token, use_context=True, ) dispatcher = updater.dispatcher start_handler = ext.CommandHandler('start', start) dispatcher.add_handler(start_handler) country_handler = ext.MessageHandler(ext.Filters.text, get_country_info) dispatcher.add_handler(country_handler) logger.info("Ready!") mode = os.environ.get('MODE', 'dev') if mode == 'prod': port = int(os.environ.get("PORT", "8443")) HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", "covid19-infobot") # Code from https://github.com/python-telegram-bot/python-telegram-bot/wiki/Webhooks#heroku updater.start_webhook(listen="0.0.0.0", port=port, url_path=token) updater.bot.set_webhook( "https://{}.herokuapp.com/{}".format(HEROKU_APP_NAME, token)) elif mode == 'dev': updater.start_polling() else: logger.error("No MODE specified!") sys.exit(1)
def create_tg_conversation_handler(self): return tg.ConversationHandler( entry_points=[ tg.CommandHandler('track', self.start, pass_user_data=True) ], states={ SET_SPENT_ON: [ tg.CallbackQueryHandler(self.spent_on, pattern='^\d{4}-\d{2}-\d{2}$', pass_user_data=True) ], SET_ISSUE: [ tg.CallbackQueryHandler(self.issue, pattern='^\d+$', pass_user_data=True) ], SET_COMMENTS: [ tg.MessageHandler(Filters.text, self.comment, pass_user_data=True) ], SET_HOURS: [ tg.CallbackQueryHandler(self.add_hours, pattern='^[\\d.]+$', pass_user_data=True), tg.CallbackQueryHandler(self.reset_hours, pattern='^Reset$', pass_user_data=True) ], }, fallbacks=[ tg.CallbackQueryHandler(self.done, pattern='^Done$', pass_user_data=True), tg.CommandHandler('cancel', self.cancel, pass_user_data=True) ], )
def cancel(update, context): user = update.message.from_user logger.info("User %s canceled the conversation.", user.first_name) update.message.reply_text('Oh no! :(') return ext.ConversationHandler.END VOICE, COMUNE = range(2) conv_handler = ext.ConversationHandler( entry_points=[ext.CommandHandler('sample', sample)], states={ COMUNE: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, comune)], VOICE: [ext.MessageHandler(ext.Filters.audio | ext.Filters.voice, audio)] }, fallbacks=[ext.CommandHandler('cancel', cancel)]) with open('token', 'r') as tok_f: token = tok_f.read().strip() updater = ext.Updater(token=token, use_context=True) dispatcher = updater.dispatcher dispatcher.add_handler(start_handler) dispatcher.add_handler(debug_handler) dispatcher.add_handler(conv_handler)
dotenv.load_dotenv() TG_BOT_TOKEN = os.getenv('TG_BOT_TOKEN') PROXY = os.getenv('PROXY') # Fill in .env if you are from mother Russia DF_PROJECT_ID = os.getenv('DF_PROJECT_ID') DF_CREDENTIALS_PATH = os.getenv('DF_CREDENTIALS_PATH') DF_SESSION_ID = os.getenv('DF_SESSION_ID') DF_LANGUAGE_CODE = os.getenv('DF_LANGUAGE_CODE') # For deploy local if DF_CREDENTIALS_PATH is not None: os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = DF_CREDENTIALS_PATH # create updater. More highlevel interface of Bot request_kwargs = None if PROXY is not None: request_kwargs = {'proxy_url': PROXY} updater = ext.Updater(token=TG_BOT_TOKEN, request_kwargs=request_kwargs) # add handlers msg_handler = lambda bot, update: dialog_flow_answer( bot, update, DF_PROJECT_ID, DF_SESSION_ID, DF_LANGUAGE_CODE) updater.dispatcher.add_handler(ext.CommandHandler('start', start)) updater.dispatcher.add_handler( ext.MessageHandler(ext.Filters.text, msg_handler)) while True: try: updater.start_polling() except Exception: logger.exception('Critical error in ')
username = update.effective_user.username user = active_users.get_user(username) update.message.reply_text(ans.answers[ans.BYE][user.language]) user.delete_document() return tg_ext.ConversationHandler.END create_pdf_handler = tg_ext.ConversationHandler( entry_points=[tg_ext.CommandHandler('create_pdf', create_pdf)], states={ FILENAME: [ tg_ext.MessageHandler( tg_ext.Filters.text & ~tg_ext.Filters.command, get_filename) ], AMOUNT_OF_PHOTOS: [ tg_ext.MessageHandler( tg_ext.Filters.text & ~tg_ext.Filters.command, get_amount_of_photo) ], PHOTO: [tg_ext.MessageHandler(tg_ext.Filters.photo, get_photo)], ADD_OR_END: [ tg_ext.CommandHandler("add", add_photos), tg_ext.CommandHandler("end", end_pdf) ], }, fallbacks=[tg_ext.CommandHandler("cancel", cancel)]) dispatcher.add_handler(create_pdf_handler)
updater.dispatcher.add_handler(tg_ext.CommandHandler('info', info)) @handle_chat_data def read_hw(update, context): keyword = HW_SEARCH.search(update.message.text).groups()[0] buttons = tg.InlineKeyboardMarkup([ [tg.InlineKeyboardButton(text='Из электронного дневника', callback_data=f"READ_HW#EXT#{keyword}#{'1' if 'сегодня' in update.message.text else ''}")], [tg.InlineKeyboardButton(text='Из этого чата', callback_data=f"READ_HW#LOCAL#{keyword}#{'1' if 'сегодня' in update.message.text else ''}")], [tg.InlineKeyboardButton(text='Отмена', callback_data="READ_HW#CANCEL")] ]) answer = update.message.reply_text(text='Откуда получить Д/З?', reply_markup=buttons) context.bot_data.update({answer.message_id: answer}) p1 = re.compile(f"\\b((что|че|чё|чо|шо|що)\\b.*по.?({'|'.join(LESSONS_SHORTCUTS)})|по.?({'|'.join(LESSONS_SHORTCUTS)}).+(что|че)[- ]?(то)?.*зад.*)", re.IGNORECASE) updater.dispatcher.add_handler(tg_ext.MessageHandler(tg_ext.Filters.regex(p1), read_hw)) p2 = re.compile(f"^({'|'.join(LESSONS_SHORTCUTS)}).*[:-] (.*)", re.IGNORECASE+re.MULTILINE) @handle_chat_data def write_hw(update, context): if update.message.photo: if update.message.media_group_id in list(context.chat_data['media_groups'].keys()): #проверка на id альбома в памяти context.chat_data['hw'][context.chat_data['media_groups'][update.message.media_group_id]]['photoid'].append( update.message.photo[0].file_id ) #добавление фото из сообщения к дз с одинаковым id альбома, что и у нового фото else: hw_match = HW_SEARCH.search(update.message.caption if update.message.caption else '') if hw_match: keyword = hw_match.groups()[0].lower()