def test_basic(self, dp, message): handler = RegexHandler('.*', self.callback_basic) dp.add_handler(handler) assert handler.check_update(Update(0, message)) dp.process_update(Update(0, message)) assert self.test_flag
def test_pattern(self, message): handler = RegexHandler('.*est.*', self.callback_basic) assert handler.check_update(Update(0, message)) handler = RegexHandler('.*not in here.*', self.callback_basic) assert not handler.check_update(Update(0, message))
def test_multiple_flags(self, message): handler = RegexHandler('.*', self.callback_basic, edited_updates=True, message_updates=True, channel_post_updates=True) assert handler.check_update(Update(0, edited_message=message)) assert handler.check_update(Update(0, message=message)) assert handler.check_update(Update(0, channel_post=message)) assert handler.check_update(Update(0, edited_channel_post=message))
def test_allow_edited(self, message): with pytest.warns(UserWarning): handler = RegexHandler('.*', self.callback_basic, message_updates=True, allow_edited=True) assert handler.check_update(Update(0, edited_message=message)) assert handler.check_update(Update(0, message=message)) assert not handler.check_update(Update(0, channel_post=message)) assert handler.check_update(Update(0, edited_channel_post=message))
def close(bot, update): """Defining Function for remove keyboard""" bot.sendMessage(update.message.chat_id, 'Ho chiuso le news!', reply_markup=telegram.ReplyKeyboardRemove()) return ConversationHandler.END NEWS_CONV = ConversationHandler( entry_points=[CommandHandler('news', section_keyboard)], states={ "department": [ RegexHandler('^(Univaq)$', univaq.univaq), RegexHandler('^(Disim)$', disim.disim), RegexHandler('^(Mesva)$', mesva.mesva_keyboard), RegexHandler('^(Discab)$', discab.discab_keyboard), ], "univaq": [ RegexHandler('^(Ultimissime)$', univaq.ultimissime), RegexHandler('^(In Evidenza)$', univaq.inevidenza) ], "mesva": [ RegexHandler( '^(In Evidenza)$', lambda bot, update: mesva.mesva_news( bot, update, 'mesva_general')), RegexHandler( '^(Area Medicina)$', lambda bot, update: mesva.mesva_news( bot, update, 'mesva_medical')),
Taxopark.register_driver(driver, tg_name, tg_id) update.effective_chat.send_message( "Водитель зарегистрирован. Проверьте данные:\n" f"{driver.name} {driver.surname}\n" f"Рабочий телефон: {driver.phone}\n" f"Telegram username: {driver.tg.name}\n" f"Telegram ID: {driver.tg.id}") return ConversationHandler.END add_driver_handler = ConversationHandler( entry_points=[CommandHandler(CD_ADD_DRIVER[1:], add_drivers)], states={ STATE_ASK_FOR_TG_CREDS: [CallbackQueryHandler(ask_for_tg_creds)], STATE_REGISTER_DRIVER: [RegexHandler(r"^@.{1,40} \d{3,11}$", register_driver)], }, fallbacks=[CommandHandler("cancel", cancel)], ) """ END ADD DRIVER CONVERSATION """ """ BEGIN MODIFY DRIVER CONVERSATION """ CD_MODIFY_DRIVER = "/данныеВодителей" STATE_SHOW_DRIVER, STATE_ASK_MODIFY, STATE_COMPLETE_MODIFY = range(3) def registered_drivers_list(bot: Bot, update: Update): if not Taxopark.is_admin(update.effective_user.id): return drivers = Taxopark.get_registered_drivers()
chat_id=query.message.chat_id, parse_mode=ParseMode.HTML) query.answer("❎ Failed to delete message!") __mod_name__ = "Reporting" __help__ = """ - /report <reason>: reply to a message to report it to admins. - @admin: reply to a message to report it to admins. NOTE: neither of these will get triggered if used by admins *Admin only:* - /reports <on/off>: change report setting, or view current status. - If done in pm, toggles your status. - If in chat, toggles that chat's status. """ REPORT_HANDLER = CommandHandler("report", report, filters=Filters.group) SETTING_HANDLER = CommandHandler("reports", report_setting, pass_args=True) ADMIN_REPORT_HANDLER = RegexHandler("(?i)@admin(s)?", report) cntrl_panel_user_callback_handler = CallbackQueryHandler( control_panel_user, pattern=r"panel_reporting_U") report_button_user_handler = CallbackQueryHandler(buttons, pattern=r"report_") dispatcher.add_handler(cntrl_panel_user_callback_handler) dispatcher.add_handler(report_button_user_handler) dispatcher.add_handler(REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(ADMIN_REPORT_HANDLER, REPORT_GROUP) dispatcher.add_handler(SETTING_HANDLER)
def main(): # Create the EventHandler and pass it your bot's token. updater = Updater(passw["token"]) # Get the dispatcher to register handlers dp = updater.dispatcher # Add conversation handler with the states GENDER, PHOTO, LOCATION and BIO conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ PERMINIT: [RegexHandler('^(Nuevo Permiso de Aulas|Nuevo Permiso de Aulas)$', permInit)], NOMBRE: [MessageHandler(Filters.text, nombre)], DNI: [MessageHandler(Filters.text, dni)], CLUB: [MessageHandler(Filters.text, club)], ACTIVIDAD: [MessageHandler(Filters.text, actividad)], TELEFONO: [MessageHandler(Filters.text, telefono)], EDIFICIO: [RegexHandler('^(A|B|C|D)$', edificio), RegexHandler('^(Otro)',edificio_otro)], EDIFICIO_OTRO: [MessageHandler(Filters.text, edificio)], DEPENDENCIA: [MessageHandler(Filters.text, dependencia)], FECHA: [MessageHandler(Filters.text, fecha)], HENTRADA: [MessageHandler(Filters.text, hentrada)], HSALIDA: [MessageHandler(Filters.text, hsalida)], SUMMARY: [RegexHandler('^(Si)$', summary), RegexHandler('^(No)$', rest)], MAIL: [MessageHandler(Filters.text, mail)], }, fallbacks=[CommandHandler('exit', exit), CommandHandler('cancel',cancel)] ) dp.add_handler(conv_handler) # log all errors dp.add_error_handler(error) # Start the Bot #updater.start_polling() ''' updater.start_webhook(listen=WEBHOOK_LISTEN, port=WEBHOOK_PORT, url_path=passw["token"], key=WEBHOOK_SSL_PRIV, cert=WEBHOOK_SSL_CERT, webhook_url=('https://'+WEBHOOK_HOST+':'+str(WEBHOOK_PORT)+"/"+passw["token"]+"/")) # Build ssl context with certs and keys context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) context.load_cert_chain(WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV) web.run_app( app, host=WEBHOOK_LISTEN, port=WEBHOOK_PORT, ssl_context=context, ) ''' updater.start_webhook(listen=WEBHOOK_LISTEN, port=WEBHOOK_PORT, url_path=passw["token"]) updater.bot.set_webhook( webhook_url=('https://'+WEBHOOK_HOST+':'+str(WEBHOOK_PORT)+"/"+passw["token"]+"/"), certificate=open('cert.pem', 'rb')) context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2) context.load_cert_chain(WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV) web.run_app( app, host=WEBHOOK_LISTEN, port=WEBHOOK_PORT, ssl_context=context, ) # 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()
RELEASE_HANDLER = DisableAbleCommandHandler("git", getRelease, pass_args=True, admin_ok=True) FETCH_HANDLER = DisableAbleCommandHandler("fetch", cmdFetch, pass_args=True, admin_ok=True) SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, pass_args=True) DELREPO_HANDLER = CommandHandler("delrepo", delRepo, pass_args=True) LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo", listRepo, admin_ok=True) VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True) CHANGELOG_HANDLER = DisableAbleCommandHandler("changelog", changelog, pass_args=True, admin_ok=True) HASHFETCH_HANDLER = RegexHandler(r"^&[^\s]+", hashFetch) dispatcher.add_handler(RELEASE_HANDLER) dispatcher.add_handler(FETCH_HANDLER) dispatcher.add_handler(SAVEREPO_HANDLER) dispatcher.add_handler(DELREPO_HANDLER) dispatcher.add_handler(LISTREPO_HANDLER) dispatcher.add_handler(HASHFETCH_HANDLER) dispatcher.add_handler(VERCHECKER_HANDLER) dispatcher.add_handler(CHANGELOG_HANDLER)
change_current_lang_and_return("ru-RU") return "default_state" def help_handler(bot, update): update.message.reply_text( "Hi! I will help you generate text from speech and visa versa.\n" + "To generate speech just send me some text.\n" + "If you whant generate text - record or forward me audio message.\n" + "To change language - use command /lang.\n" + "If something went wrong - try /start commant again" ) conversation = ConversationHandler( entry_points=[CommandHandler("start", start_handler, pass_user_data=True)], states={ "default_state": [ MessageHandler(Filters.text, text_handler, pass_user_data=True), MessageHandler(Filters.voice, voice_handler, pass_user_data=True), CommandHandler("lang", lang_handler, pass_user_data=True), CommandHandler("help", help_handler), ], "lang_choise_state": [ RegexHandler("^(Eng)$", change_lang_to_eng_handler, pass_user_data=True), RegexHandler("^(Rus)$", change_lang_to_rus_handler, pass_user_data=True), ], }, fallbacks=[], )
from keys import BOT_COMMAND from InfoBot import InfoBot logging.info('project run') updater = Updater(token=BOT_TOKEN) dispatcher = updater.dispatcher InfoBot = InfoBot() logging.info('init InfoBot, telegram dispatcher') command_start_handler = CommandHandler(BOT_COMMAND['START'], InfoBot.start) message_text_handler = MessageHandler(Filters.text, InfoBot.text_handler) inline_query_handler = CallbackQueryHandler(InfoBot.inline_handler) command_id_handler = RegexHandler(BOT_ID_HANDLE_PATTERN, InfoBot.command_id_handler) command_user_handler = RegexHandler(USER_ID_HANDLE_PATTERN, InfoBot.command_user_id_handler) document_handler = MessageHandler(Filters.document, InfoBot.document_handler) dispatcher.add_handler(command_start_handler) dispatcher.add_handler(message_text_handler) dispatcher.add_handler(inline_query_handler) dispatcher.add_handler(command_id_handler) dispatcher.add_handler(command_user_handler) dispatcher.add_handler(document_handler) logging.info("=" * 10 + ' add handlers, start polling, start pool with ' + str(len(multiprocessing.active_children())) + ' process ' + "=" * 10)
def main(): # Create the Updater and pass it your bot's token. # Make sure to set use_context=True to use the new context based callbacks # Post version 12 this will no longer be necessary updater = Updater("711948397:AAF1NNp3m1uWkcCyttkGVVQd21UzQakIfRg", use_context=True) # Get the dispatcher to register handlers dp = updater.dispatcher # Add conversation handler with the states CHOOSING, TYPING_CHOICE and TYPING_REPLY conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ CHOOSING: [ RegexHandler('^Help/FAQ$', help, pass_user_data=True), RegexHandler('^Mini Reports$', mini_reports, pass_user_data=True), RegexHandler('^Get RNR Status$', get_msd_code, pass_user_data=True), RegexHandler('^Subscribe$', subscribe, pass_user_data=True), RegexHandler('^Go back to Main Menu', start, pass_user_data=True), RegexHandler('^Get District Reporting Rate', coming_soon, pass_user_data=True) ], MAIN_MENU: [ CallbackQueryHandler(main_menu, pass_chat_data=True), ], START: [ CallbackQueryHandler(start_menu, pass_chat_data=True), ], HELP: [ CallbackQueryHandler(help_actions, pass_chat_data=True), ], FILL_LOGIN_CREDENTIALS: [ CallbackQueryHandler(fill_login_credentials, pass_chat_data=True), ], SIGN_IN: [ CallbackQueryHandler(sign_in, pass_chat_data=True), ], CLEAR_CACHE: [ CallbackQueryHandler(clear_cache, pass_chat_data=True), ], CLEAR_CACHE_STEPS_TWO: [ CallbackQueryHandler(clear_cache_chrome_two, pass_chat_data=True), ], ADD_PRODUCT: [ CallbackQueryHandler(add_product, pass_user_data=True), ], ADD_PRODUCT_STEP_TWO: [ CallbackQueryHandler(add_product_step_two, pass_chat_data=True), ], DISTRICT_REPORTING_RATE: [ MessageHandler(Filters.text, district_reporting_rate, pass_user_data=True), ], DISTRICT_REPORTING_RATE_PROGRAM: [ MessageHandler(Filters.text, district_reporting_rate_program, pass_user_data=True), ], GET_MSD_CODE: [ MessageHandler(Filters.text, program_name, pass_chat_data=True), ], GET_PROGRAME_NAME: [ MessageHandler(Filters.text, getrnrstatusbyfacilitycode, pass_chat_data=True), ], MIN_REPORT: [ CallbackQueryHandler(get_msd_code, pass_chat_data=True), ], COMING_SOON: [ CallbackQueryHandler(coming_soon, pass_chat_data=True), ], RNR_STATUS: [CallbackQueryHandler(get_msd_code, pass_chat_data=True)], }, fallbacks=[ RegexHandler('^Other$', custom_choice, pass_user_data=True) ]) dp.add_handler(conv_handler) # log all errors dp.add_error_handler(custom_choice) # 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(): # Create the Updater and pass it your bot's token. updater = TOKEN conv_handler = ConversationHandler( entry_points=[ CommandHandler('start', start, pass_user_data=True), MessageHandler(Filters.text, start_text, pass_user_data=True), ], states={ CHOOSING: [ CommandHandler('start', start, pass_user_data=True), # CallbackQueryHandler(set_command_REGISTERED_button, pass_user_data=True), MessageHandler(Filters.text, auth_code, pass_user_data=True), ], REGISTERED: [ CommandHandler('addlesson', add_lesson, pass_user_data=True), CommandHandler('choosegroup', choose_group, pass_user_data=True), CallbackQueryHandler(set_command_REGISTERED_button, pass_user_data=True), ], ONE_STUDENT: [ MessageHandler(Filters.text, get_one_surname, pass_user_data=True), CallbackQueryHandler(delete_student_button, pass_user_data=True), CommandHandler('back', back_to_edit_students, pass_user_data=True), ], ONE_STUDENT_CHANGE: [ MessageHandler(Filters.text, get_one_surname, pass_user_data=True), CallbackQueryHandler(change_student_button, pass_user_data=True), CommandHandler('back', back_to_edit_students, pass_user_data=True), ], CHOOSE_GROUP: [ CallbackQueryHandler(group_button, pass_user_data=True), CommandHandler('back', back_to_registered, pass_user_data=True), ], TYPE_FOR_LESSON: [ CallbackQueryHandler(type_for_lesson, pass_user_data=True), CommandHandler('back', back_to_registered, pass_user_data=True), ], EDIT_GROUP: [ CommandHandler('back', back_to_registered, pass_user_data=True), CommandHandler('addstudents', add_students, pass_user_data=True), CommandHandler('showstudents', show_students, pass_user_data=True), CommandHandler('addsubgroup', add_subgroup, pass_user_data=True), CommandHandler('stop', stop_addition, pass_user_data=True), CallbackQueryHandler(set_command_EDIT_GROUP_button, pass_user_data=True), MessageHandler(Filters.text, add_student, pass_user_data=True), ], CREATE_LIST: [ MessageHandler(Filters.text, add_student, pass_user_data=True), CommandHandler('stop', stop_addition, pass_user_data=True), ], ADD_LESSON: [ MessageHandler(Filters.text, add_lesson_text, pass_user_data=True), CommandHandler('back', back_to_registered, pass_user_data=True), CallbackQueryHandler(add_lesson_button, pass_user_data=True) ], EDIT_STUDENTS: [ CommandHandler('add', add_one_student, pass_user_data=True), CommandHandler('delete', delete_one_student, pass_user_data=True), CommandHandler('change', change_one_student, pass_user_data=True), CommandHandler('show', show_students, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), CallbackQueryHandler(set_command_EDIT_STUDENTS_button, pass_user_data=True) ], GROUP_CHOSEN_FIRST: [ CommandHandler('back', back_to_registered, pass_user_data=True), CallbackQueryHandler(set_command_GROUP_CHOSEN_FIRTST_button, pass_user_data=True) ], GROUP_CHOSEN: [ CommandHandler('rollcall', start_rolcall, pass_user_data=True), CommandHandler('editstudents', edit_students, pass_user_data=True), # CommandHandler('edit', # edit_old_data, # pass_user_data=True), CommandHandler('delete', delete_subject, pass_user_data=True), CommandHandler('change', change_subject_info, pass_user_data=True), CommandHandler('showmarks', show_marks, pass_user_data=True), CommandHandler('setdefault', set_default, pass_user_data=True), CommandHandler('setmarks', set_marks, pass_user_data=True), MessageHandler(Filters.text, get_marks, pass_user_data=True), CommandHandler('back', back_to_registered, pass_user_data=True), CallbackQueryHandler(set_command_GROUP_CHOSEN_button, pass_user_data=True) ], CHANGE_SUBJECT_INFO: [ CommandHandler('back', back_to_group, pass_user_data=True), MessageHandler(Filters.text, get_new_name, pass_user_data=True), CallbackQueryHandler(set_command_CHANGE_SUBJECT_button, pass_user_data=True), ], ROLL_CALL: [ CallbackQueryHandler(rollcall_button, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), ], HAVE_MARKS: [ CommandHandler('edit', edit_group, pass_user_data=True), CallbackQueryHandler(set_command_HAVE_MARKS_button, pass_user_data=True), CommandHandler('showlist', show_list, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), ], GET_STUDENT: [ CallbackQueryHandler(edit_button, pass_user_data=True), ], SHOW_FOR_ONE: [ CallbackQueryHandler(choose_one_student, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), ], EDIT_FOR_ONE: [ CallbackQueryHandler(choose_one_student_for_editing_marks, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), ], CHANGE_MARK: [ MessageHandler(Filters.text, get_new_mark, pass_user_data=True), CallbackQueryHandler(change_mark, pass_user_data=True), CommandHandler('back', back_to_group, pass_user_data=True), ], STUDENT_CHOSEN: [ MessageHandler(Filters.text, get_marks, pass_user_data=True), ] }, fallbacks=[RegexHandler('^[D,d]one$', done, pass_user_data=True)]) updater.dispatcher.add_handler(conv_handler) updater.dispatcher.add_handler( CommandHandler('help', help, pass_user_data=True)) updater.dispatcher.add_error_handler(error) # Start the Bot updater.start_polling() print("bot started") updater.idle()
def test_context(self, cdp, message): handler = RegexHandler(r'(t)est(.*)', self.callback_context) cdp.add_handler(handler) cdp.process_update(Update(0, message=message)) assert self.test_flag
def test_other_update_types(self, false_update): handler = RegexHandler('.*', self.callback_basic, edited_updates=True) assert not handler.check_update(false_update)
def test_deprecation_Warning(self): with pytest.warns(TelegramDeprecationWarning, match='RegexHandler is deprecated.'): RegexHandler('.*', self.callback_basic)
@user_language def unknown(bot, update): """ Placeholder command when the user sends an unknown command. """ msg = _("Sorry, I don't know what you're asking for.") bot.send_message(chat_id=update.message.chat_id, text=msg) # creating handlers start_handler = CommandHandler('start', start) support_handler = CommandHandler('support', support) support_msg_handler = MessageHandler([Filters.text], support_message) settings_handler = CommandHandler('settings', settings) get_language_handler = RegexHandler('^([a-z]{2}_[A-Z]{2}) - .*', kb_settings_select, pass_groups=True) help_handler = CommandHandler('help', start) unknown_handler = MessageHandler([Filters.command], unknown) # adding handlers dispatcher.add_handler(start_handler) dispatcher.add_handler(support_handler) dispatcher.add_handler(settings_handler) dispatcher.add_handler(get_language_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(unknown_handler) # Message handler must be the last one dispatcher.add_handler(support_msg_handler)
def botmain() -> None: """The main function for processing messages from the user. """ mybot = Updater(connect_settings.API_KEY) dp = mybot.dispatcher logger.info(settings.BOT_RUN) reminder_create = ConversationHandler( entry_points=[ RegexHandler('^(Добавить напоминание)$', reminder_add, pass_user_data=True) ], states={ "reminder_add_date": [ RegexHandler('^(Ввести дату)$', manual_add_date, pass_user_data=True), RegexHandler('^([0-9][0-9]-[0-9][0-9]-[0-9][0-9][0-9][0-9])$', predefined_add_date, pass_user_data=True) ], "manual_add_date_year": [ RegexHandler('^([0-9][0-9][0-9][0-9])$', manual_add_date_year, pass_user_data=True) ], "manual_add_date_month": [ RegexHandler('^([1-9]|0[0-9]|1[0-2])$', manual_add_date_month, pass_user_data=True) ], "manual_add_date_day": [ RegexHandler('^([1-9]|0[0-9]|1[0-9]|2[0-9]|3[0-1])$', manual_add_date_day, pass_user_data=True) ], "manual_add_date_hour": [ RegexHandler('^([0-9]|[0-2][0-9])$', manual_add_date_hour, pass_user_data=True) ], "manual_add_date_minute": [ RegexHandler('^([0-9]|[0-5][0-9])$', manual_add_date_minute, pass_user_data=True) ], "reminder_add_comment": [ MessageHandler(Filters.text, reminder_add_comment, pass_user_data=True), CommandHandler('skip', reminder_skip_comment, pass_user_data=True) ] }, fallbacks=[ MessageHandler(Filters.text | Filters.video | Filters.photo | Filters.document, dontknow, pass_user_data=True) ]) reminder_delete = ConversationHandler( entry_points=[ RegexHandler('^(Удалить напоминание)$', reminder_deleting_list, pass_user_data=True) ], states={ 'reminder_confirm_for_delete': [ RegexHandler('^([0-9]|[0-9][0-9])$', reminder_confirm_for_delete, pass_user_data=True) ], 'reminder_commit_for_delete': [ RegexHandler('^(Да)$', reminder_commit_for_delete, pass_user_data=True) ] }, fallbacks=[ RegexHandler('^(Нет)$', reminder_cancel_for_delete, pass_user_data=True), MessageHandler(Filters.text | Filters.video | Filters.photo | Filters.document, dontknow, pass_user_data=True) ]) dp.add_handler(CommandHandler("start", greet_user, pass_user_data=True)) dp.add_handler(reminder_create) dp.add_handler(reminder_delete) dp.add_handler( RegexHandler('^(Хочу пользоваться!)$', join_user, pass_user_data=True)) dp.add_handler( RegexHandler('^(Расхотел)$', unjoin_user, pass_user_data=True)) dp.add_handler( RegexHandler('^(Список напоминаний)$', reminder_list, pass_user_data=True)) dp.add_handler(MessageHandler(Filters.text, dontknow, pass_user_data=True)) mybot.start_polling() mybot.idle()
def main(): updater = Updater(config.token) # Get the dispatcher to register handlers dp = updater.dispatcher # Базовые команды dp.add_handler(CommandHandler("start", start.start)) dp.add_handler(CommandHandler("help", help.help)) # Просмотр dp.add_handler(CommandHandler("list", list.all)) #dp.add_handler(CommandHandler("view", view.all_items)) # so many messages dp.add_handler(RegexHandler('^\/view(\d+).*', view.item, pass_groups=True)) # Подписка dp.add_handler(CommandHandler("subscribe", subscription.activate)) dp.add_handler(CommandHandler("unsubscribe", subscription.deactivate)) # Добавление dp.add_handler(ConversationHandler( entry_points=[CommandHandler('add', add.add, pass_user_data=True)], states={ add.NAME: [MessageHandler(Filters.text, add.name)], add.DESCRIPTION: [MessageHandler(Filters.text, add.description)], add.PHOTO: [MessageHandler(Filters.photo, add.photo), CommandHandler('skip', add.skip_photo)], add.PUBLISH: [CommandHandler('publish', add.publish, pass_user_data=True), ], }, fallbacks=[CommandHandler(u'cancel', add.cancel, pass_user_data=True)] )) # Редактирование dp.add_handler(CommandHandler("edit", edit.list_items)) edit_handler = ConversationHandler( entry_points=[RegexHandler('^/edit(\d+).*', edit.edit, pass_groups=True, pass_user_data=True)], states={ edit.NAME: [MessageHandler(Filters.text, edit.name, pass_user_data=True), CommandHandler('skip', edit.skip_name, pass_user_data=True)], edit.DESCRIPTION: [MessageHandler(Filters.text, edit.description, pass_user_data=True), CommandHandler('skip', edit.skip_description, pass_user_data=True)], edit.PHOTO: [MessageHandler(Filters.photo, edit.photo, pass_user_data=True), CommandHandler('skip', edit.skip_photo, pass_user_data=True)], edit.PUBLISH: [CommandHandler('save', edit.publish, pass_user_data=True), ], }, fallbacks=[CommandHandler('cancel', edit.cancel, pass_user_data=True)] ) dp.add_handler(edit_handler) # Удаление dp.add_handler(CommandHandler("delete", delete.list_items)) dp.add_handler(RegexHandler(u'^\/delete(\d+).*', delete.delete_item, pass_groups=True)) # Другое dp.add_handler(RegexHandler(u'.*(\s|^)(С|с)тил{1,2}и(\s|$).*', jokes.stilli)) dp.add_handler(CommandHandler("support", support.support)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # Block until the you 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 telegram_bot(token, camera_save_path, camera_capture_length, camera_mode): """ This function runs the telegram bot that responds to commands like /enable, /disable or /status. """ def prepare_status(alarm_state_dict): def readable_delta(then, now=time.time()): td = timedelta(seconds=now - then) days, hours, minutes = td.days, td.seconds // 3600, td.seconds // 60 % 60 text = '%s minutes' % minutes if hours > 0: text = '%s hours and ' % hours + text if days > 0: text = '%s days, ' % days + text return text return '*rpi-security status*\nCurrent state: _%s_\nLast state: _%s_\nLast change: _%s ago_\nUptime: _%s_\nLast MAC detected: _%s %s ago_\nAlarm triggered: _%s_\nMotion on: %s' % ( alarm_state_dict['current_state'], alarm_state_dict['previous_state'], readable_delta(alarm_state_dict['last_state_change']), readable_delta(alarm_state_dict['start_time']), alarm_state_dict['last_packet_mac'], readable_delta(alarm_state_dict['last_packet']), alarm_state_dict['alarm_triggered'], msg) def save_chat_id(bot, update): if 'telegram_chat_id' not in state: state['telegram_chat_id'] = update.message.chat_id write_state_file(state_file=args.state_file, state_data=state) logger.debug('Set Telegram chat_id %s' % update.message.chat_id) def debug(bot, update): logger.debug('Received Telegram bot message: %s' % update.message.text) def check_chat_id(update): if update.message.chat_id != state['telegram_chat_id']: logger.debug( 'Ignoring Telegam update with filtered chat id %s: %s' % (update.message.chat_id, update.message.text)) return False else: return True def help(bot, update): if check_chat_id(update): bot.sendMessage( update.message.chat_id, parse_mode='Markdown', text= '/status: Request status\n/disable: Disable alarm\n/enable: Enable alarm\n/photo feed: Take a photo\n/gif feed: Take a gif\n', timeout=10) def status(bot, update): if check_chat_id(update): bot.sendMessage(update.message.chat_id, parse_mode='Markdown', text=prepare_status(alarm_state), timeout=10) def disable(bot, update): if check_chat_id(update): update_alarm_state('disabled') def enable(bot, update): if check_chat_id(update): update_alarm_state('disarmed') def photo(bot, update, args): if check_chat_id(update): activefeed = args[0] if config['pir']: activefeed = 'picam' frame = [1] else: feed, thefeed = videofeeds.getactivefeed( activefeed) # get the active feed for capturing frame = videofeeds.getframes(feed, thefeed) # get frame file_path = camera_save_path + "/rpi-security-" + datetime.now( ).strftime("%Y-%m-%d-%H%M%S") + '-' + str(activefeed) + '.jpeg' for i, f in enumerate(frame): # have to get frame to save photo take_photo(f, file_path) telegram_send_file(file_path) def gif(bot, update, args): if check_chat_id(update): activefeed = args[0] if config['pir']: activefeed = 'picam' file_path = camera_save_path + "/rpi-security-" + datetime.now( ).strftime("%Y-%m-%d-%H%M%S") + '-' + str(activefeed) + '.gif' take_gif(activefeed, file_path, camera_capture_length, camera_save_path) telegram_send_file(file_path) def error(bot, update, error): logger.error('Update "%s" caused error "%s"' % (update, error)) updater = Updater(token) dp = updater.dispatcher dp.add_handler(RegexHandler('.*', save_chat_id), group=1) dp.add_handler(RegexHandler('.*', debug), group=2) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("status", status)) dp.add_handler(CommandHandler("disable", disable)) dp.add_handler(CommandHandler("enable", enable)) dp.add_handler(CommandHandler("photo", photo, pass_args=True)) dp.add_handler(CommandHandler("gif", gif, pass_args=True)) dp.add_error_handler(error) logger.info("thread running") updater.start_polling(timeout=10)
def main(): #Crear el Actualizador y pasalo el token de tu bot. updater = Updater("1083595635:AAHNMxJKqJAcu8k8IHtkkLKTD5zqc8k8kNU") #Obtener el despachador para registrar los controladores dp = updater.dispatcher #Agregue manejador de conversacion con los estados GENDER, PHOTO, LOCATION Y BIO conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ CHOOSING: [ RegexHandler( '^(Nombre|Estado de animo|Promesa importante||Color favorito|Estado civil|Habilidad o pasatiempo...)$', regular_choice, pass_user_data=True), ], TYPING_CHOICE: [ MessageHandler(Filters.text, regular_choice, pass_user_data=True), ], TYPING_REPLY: [ MessageHandler(Filters.text, received_information, pass_user_data=True), ], }, fallbacks=[RegexHandler('^Done$', done, pass_user_data=True)]) dp.add_handler(conv_handler) #Agregue manejador de conversacion con los estados GENDER, PHOTO, LOCATION Y BIO conv_handler = ConversationHandler( entry_points=[CommandHandler('help', help)], states={ CHOOSING: [ RegexHandler( '^(Nombre|Edad|Color favorito|Genero|Numero de hermanos)$', regular_choice, pass_user_data=True), RegexHandler('^Algunas cosas...$', custom_choice), ], TYPING_CHOICE: [ MessageHandler(Filters.text, regular_choice, pass_user_data=True), ], TYPING_REPLY: [ MessageHandler(Filters.text, received_information, pass_user_data=True), ], }, fallbacks=[RegexHandler('^Done$', done, pass_user_data=True)]) dp.add_handler(conv_handler) #log all errors dp.add_error_handler(error) #Empieza el BOT updater.start_polling() #Ejecute el bot hasta que presione Ctrl-C o el proceso recibe SIGINT, # SIGTERM o sigabrt. Esto debe usarse la mayor parte del teimpo, ya que # start_polling() no bloquea y detendra el bot con gracia. updater.idle()
def main(): args = parse_args(None) updater = Updater(token=args.token, use_context=True) j = updater.job_queue # updater = Updater(TOKEN, request_kwargs=REQUEST_KWARGS) generate_teams(num=25) bot_changing_job = j.run_repeating(changing_bots_callback, interval=20, first=0) weekly_rating_job = j.run_repeating(weekly_rating_callback, interval=60 * 2, first=0) energy_job = j.run_repeating(energy_callback, interval=60 * 2, first=0) conv_handler = ConversationHandler( entry_points=[ CommandHandler('start', partial(action, transfer_to='start')) ], states={ 'start': [ RegexHandler('🌐Форум🌐', forum), RegexHandler('Обучение Олега', partial(action, transfer_to='oleg')), RegexHandler('📈Биржа📈', partial(start_stock_action, transfer_to='stock')), RegexHandler('Квизы', partial(action, transfer_to='game')), RegexHandler( 'Рейтинг команд🏆', partial(action, transfer_to='start', additional_action=print_team_rating)), RegexHandler('Профиль', partial(action, transfer_to='profile')), RegexHandler('^((?!(🌐Форум🌐)|(📈Биржа📈)|(Обучение Олега)).)*$', partial(action, transfer_to='start')) ], 'forum': [ RegexHandler('Подойти к рационалистам', forum_game, pass_user_data=True), RegexHandler('Уйти', partial(action, transfer_to='start')) ], 'forum_game': [ RegexHandler('Да', forum_game_play, pass_user_data=True), RegexHandler('Нет', partial(action, transfer_to='start')) ], 'forum_game_playing': [ MessageHandler(Filters.text, forum_game_check, pass_user_data=True) ], 'stock': [ RegexHandler( 'Готов!', partial(plot_action, args=args, transfer_to='bet')), RegexHandler('Назад🔙', partial(action, transfer_to='start')), ], 'bet': [ RegexHandler('Вверх☝️', partial(action, transfer_to='bet up')), RegexHandler('Вниз👇', partial(action, transfer_to='bet down')), RegexHandler('Назад🔙', partial(action, transfer_to='stock')), RegexHandler('Меню📋', partial(action, transfer_to='start')), ], 'bet up': [ RegexHandler('^[0-9]', partial(bet_action_up, args=args)), RegexHandler('Назад🔙', partial(action, transfer_to='bet')), ], 'bet down': [ RegexHandler('^[0-9]', partial(bet_action_down, args=args)), RegexHandler('Назад🔙', partial(action, transfer_to='bet')), ], 'results_win': [ RegexHandler('Назад🔙', partial(leave_stock_action, transfer_to='stock')), RegexHandler('Меню📋', partial(action, transfer_to='start')), ], 'results_lose': [ RegexHandler('Назад🔙', partial(leave_stock_action, transfer_to='stock')), RegexHandler('Меню📋', partial(action, transfer_to='start')), ], 'results_draw': [ RegexHandler('Назад🔙', partial(leave_stock_action, transfer_to='stock')), RegexHandler('Меню📋', partial(action, transfer_to='start')), ], # 'oleg' : [ # RegexHandler('Назад🔙', partial(action, transfer_to='start')), # RegexHandler('Меню📋', partial(action, transfer_to='start')), # # ], 'profile': [ RegexHandler( 'Поиск команды', partial(action, transfer_to='teaming', additional_action=print_team_list)), RegexHandler( 'Моя команда', partial(action, transfer_to='profile', additional_action=list_user_team)), RegexHandler( 'Статус', partial(action, transfer_to='profile', additional_action=show_user)), RegexHandler('Назад🔙', partial(action, transfer_to='start')), RegexHandler('Меню📋', partial(action, transfer_to='start')), ], 'teaming': [ RegexHandler('Назад🔙', partial(action, transfer_to='profile')), RegexHandler('Меню📋', partial(action, transfer_to='start')), RegexHandler( '^([a-z]|[A-Z]|[а-я]|[A-Я])', partial(action, transfer_to='profile', additional_action=assign_team)), ], 'game': [ RegexHandler('Назад🔙', partial(action, transfer_to='start')), RegexHandler('Меню📋', partial(action, transfer_to='start')), RegexHandler('^((?!(Назад🔙)|(Меню📋)).)*$', partial(action, transfer_to='game2', additional_action=show_question), pass_user_data=True) ], 'game2': [ RegexHandler('Назад🔙', partial(action, transfer_to='game')), RegexHandler('Меню📋', partial(action, transfer_to='start')), RegexHandler('^((?!(Назад🔙)|(Меню📋)).)*$', partial(action, transfer_to='game3', additional_action=show_answer), pass_user_data=True) ], 'game3': [ RegexHandler('Назад🔙', partial(action, transfer_to='game')), RegexHandler('Меню📋', partial(action, transfer_to='start')), RegexHandler('Продолжаем!', partial(action, transfer_to='game'), pass_user_data=True) ], }, fallbacks=[ CommandHandler('cancel', cancel), CommandHandler('help', help) ]) # conv_handler.states.update(list_of_meetings_states) # conv_handler.states.update(workspace_states) # conv_handler.states.update(cancel_states) # conv_handler.states.update(meeting_states) # conv_handler.states.update(location_states) updater.dispatcher.add_handler(conv_handler) updater.dispatcher.add_error_handler(error) updater.start_polling() updater.idle()
def run_bot(): pp = PicklePersistence(filename='conversationbot') updater = Updater(token=BOT_TOKEN, persistence=pp) dispatcher = updater.dispatcher add_dialog_handler = CommandHandler('add', add, pass_user_data=True) add_classes_handler = CommandHandler('add_schedule', add_schedule_continue, pass_args=True) callback_handler = CallbackQueryHandler(inline_handler, pass_user_data=True) show_schedule_handler = CommandHandler('schedule', schedule, pass_args=True) cancel_handler = CommandHandler('cancel', end_conversation) allow_handler = CommandHandler('open', allow) disallow_handler = CommandHandler('close', disallow) register_handler = CommandHandler('reg', register, pass_user_data=True) remove_schedule_handler = ConversationHandler( entry_points=[ CommandHandler('remove', remove, pass_args=True, pass_user_data=True) ], states={ REMOVE_SCHEDULE_STATE: [ MessageHandler(Filters.text, remove_schedule_continue, pass_user_data=True) ], }, fallbacks=[CommandHandler('cancel', end_conversation)], name="remove_schedule", # persistent=True ) unknown_handler = MessageHandler(Filters.command, unknown) # Add user identity handler on /start command identity_handler = ConversationHandler( entry_points=[CommandHandler('start', start_cmd)], states={ ASK_GROUP_NUM_STATE: [MessageHandler(Filters.text, store_group_num)], ASK_LAST_NAME_STATE: [MessageHandler(Filters.text, store_last_name)], }, fallbacks=[CommandHandler('cancel', end_conversation)], name="identity_conversation", # persistent=True ) dispatcher.add_handler(identity_handler) dispatcher.add_handler(add_dialog_handler) dispatcher.add_handler(add_classes_handler) dispatcher.add_handler(callback_handler) dispatcher.add_handler(show_schedule_handler) dispatcher.add_handler(cancel_handler) dispatcher.add_handler(allow_handler) dispatcher.add_handler(disallow_handler) dispatcher.add_handler(register_handler) dispatcher.add_handler(remove_schedule_handler) dispatcher.add_handler(unknown_handler) # Add subscribe handler with the states ASK_DATE_STATE, ASK_TIME_STATE sign_up_conv_handler = ConversationHandler( entry_points=[RegexHandler(".*([Зз]апиши меня).*", ask_place)], states={ ASK_PLACE_STATE: [MessageHandler(Filters.text, ask_date, pass_user_data=True)], ASK_DATE_STATE: [MessageHandler(Filters.text, ask_time, pass_user_data=True)], ASK_TIME_STATE: [MessageHandler(Filters.text, store_sign_up, pass_user_data=True)], }, fallbacks=[CommandHandler('cancel', end_conversation)], name="subscribe_conversation", # persistent=True ) dispatcher.add_handler(sign_up_conv_handler) # Add unsubscribe handler with the states unsubscribe_conv_handler = ConversationHandler( entry_points=[ RegexHandler(".*([Оо]тпиши меня|[Оо]тмени запись).*", ask_unsubscribe) ], states={ RETURN_UNSUBSCRIBE_STATE: [MessageHandler(Filters.text, unsubscribe)], }, fallbacks=[CommandHandler('cancel', end_conversation)], name="unsubscribe_conversation", # persistent=True ) dispatcher.add_handler(unsubscribe_conv_handler) text_msg_handler = MessageHandler(Filters.text, unknown) dispatcher.add_handler(text_msg_handler) # log all errors dispatcher.add_error_handler(error) updater.start_polling(clean=True) updater.idle()
"confirmation", one_time_keyboard=True)) return "confirm_delete_category" else: logging.info("delete_category_type is not in user_data") update.message.reply_text( "Не получается определить категорию, выбери еще раз желаемое \ действие", reply_markup=get_keyboard("main_menu")) clear_user_data(user_data, "categories_menu") return ConversationHandler.END conversation = ConversationHandler( entry_points=[ RegexHandler(make_re_template_for_menu([main_menu.categories]), start) ], states={ "menu_choice": [ RegexHandler(make_re_template_for_menu(list(action_choices)), menu_choice, pass_user_data=True) ], "delete_category": [MessageHandler(Filters.text, delete_category, pass_user_data=True)], "confirm_delete_category": [ MessageHandler(Filters.text, confirm_delete_category, pass_user_data=True) ], "add_category":
from telegram.ext import Updater from telegram.ext import CommandHandler, RegexHandler from .main import RssBot updater = Updater(token="XXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") rss_bot = { 'subscribe': RegexHandler('🔔 Subsscribe', RssBot.add_member, pass_user_data=True), 'unsubscribe': RegexHandler('🚫 Unsubscribe', RssBot.del_member, pass_user_data=True), 'start': CommandHandler('start', RssBot.start, pass_user_data=True), }
elif 'g' in flags: text = re.sub(repl, repl_with, to_fix).strip() else: text = re.sub(repl, repl_with, to_fix, count=1).strip() except sre_constants.error: update.effective_message.reply_text( "Do you even sed? Apparently not.") return # empty string errors -_- if len(text) >= telegram.MAX_MESSAGE_LENGTH: update.effective_message.reply_text( "The result of the sed command was too long for \ telegram!") elif text: update.effective_message.reply_to_message.reply_text(text) __help__ = """ - s/<text1>/<text2>(/<flag>): Reply to a message with this to perform a sed operation on that message, replacing all \ occurrences of 'text1' with 'text2'. Flags are optional, and currently include 'i' for ignore case, 'g' for global, \ or nothing. Delimiters include '/', '_', '|' and ':'. Text grouping is supported. The resulting message cannot be \ larger than {} """.format(telegram.MAX_MESSAGE_LENGTH) __name__ = "Sed/Regex" SED_HANDLER = RegexHandler(r's([{}]).*?\1.*'.format("".join(DELIMITERS)), sed) dispatcher.add_handler(SED_HANDLER)
logger.warning('Update "%s" caused error "%s"', update, error) # Create the Updater and pass it your bot's token. updater = Updater("545110014:AAFL9tBt7h93I2fywdCnFU-U7FYeLi77aQY") # Get the dispatcher to register handlers dp = updater.dispatcher # Add conversation handler with the states GENDER, PHOTO, LOCATION and BIO conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ CHOOSING: [ RegexHandler('^(Age|Favourite colour|Number of siblings)$', regular_choice, pass_user_data=True), RegexHandler('^Something else...$', custom_choice), ], TYPING_CHOICE: [ MessageHandler(Filters.text, regular_choice, pass_user_data=True), ], TYPING_REPLY: [ MessageHandler(Filters.text, received_information, pass_user_data=True), ], }, fallbacks=[RegexHandler('^Done$', done, pass_user_data=True)]) dp.add_handler(conv_handler)
- /notes or /saved: list all saved notes in this chat If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \ be useful when updating a current note. *Admin only:* - /save <notename> <notedata>: saves notedata as a note with name notename A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \ `buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check /markdownhelp for more info. - /save <notename>: save the replied message as a note with name notename - /clear <notename>: clear note with this name """ __mod_name__ = "Notes" GET_HANDLER = CommandHandler("get", cmd_get, pass_args=True) HASH_GET_HANDLER = RegexHandler(r"^#[^\s]+", hash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear, pass_args=True) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) dispatcher.add_handler(GET_HANDLER) dispatcher.add_handler(SAVE_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(HASH_GET_HANDLER)
# -*- coding: utf-8 -*- # This package contains handlers for text messages import importlib from telegram.ext import MessageHandler, RegexHandler from telegram.ext.filters import Filters import re msg_list = [('inventario', '@.*, possiedi( \(pg \d+/\d+\))?:\n.*'), ('mostra', '@.*, mostri orgogliosamente di possedere \d+x (?P<item>.*)'), ('esporta', Filters.document), ('users_stats', 'Avventuriero @.+(\n.*)*.*Oggetti unici:(?P<items>.+(\n.*)*)')] handlers = [] for c in msg_list: m = importlib.import_module('.' + c[0], __name__) groups = m.pass_args if type(c[1]) is str: handlers.append(RegexHandler(c[1], m.run, pass_groupdict=groups)) else: handlers.append(MessageHandler(c[1], m.run))
@restricted def restart(bot, update): bot.send_message(update.message.chat_id, "Bot is restarting...") count = 0 time.sleep(0.2) os.execl(sys.executable, sys.executable, *sys.argv) if __name__ == '__main__': updater = Updater(telegram_info['service_accesstoken']) dispatcher = updater.dispatcher google_handler = ConversationHandler( entry_points=[CommandHandler('google', google)], states={ CHOOSING: [ RegexHandler('^(USE)$', use_account), RegexHandler('^(ADD)$', add_account), ], ACCOUNTING: [ MessageHandler(Filters.text, input_account, pass_user_data=True), ], DONE: [ MessageHandler(Filters.text, done, pass_user_data=True), ], }, fallbacks=[RegexHandler('^Done$', done, pass_user_data=True)]) dispatcher.add_handler(google_handler) dispatcher.add_handler(CommandHandler('start', start)) dispatcher.add_handler(CommandHandler('hello', hello))
def main(): # Create the EventHandler and pass it your bot's token. updater = Updater("432054548:AAHCaswKTTFEPCfrhyO0Z-sdJhxT-b7xeYM") # Get the dispatcher to register handlers dp = updater.dispatcher # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", start, pass_user_data=True)) dp.add_handler(CommandHandler("help", help, pass_user_data=True)) dp.add_handler( CommandHandler("send_purchase_singly", send_purchase_singly, pass_user_data=True)) dp.add_handler( CommandHandler("add_products", add_products, pass_user_data=True)) conv_handler_stats = ConversationHandler( entry_points=[CommandHandler('stats', stats, pass_user_data=True)], states={ ANY: [ RegexHandler('^max_spending$', max_spending, pass_user_data=True), RegexHandler('^days_of_week_spending$', days_of_week_spending, pass_user_data=True), RegexHandler('^categories_spending$', categories_spending, pass_user_data=True), RegexHandler('^general_stats$', general_stats, pass_user_data=True) ], WAIT_DATE: [ RegexHandler( '^\d{4}\-(0?[1-9]|1[012])\-(0?[1-9]|[12][0-9]|3[01])$', enter_data, pass_user_data=True) ], WAIT_INT: [RegexHandler("^[-+]?[0-9]+$", enter_data, pass_user_data=True)], WAIT_DAY: [MessageHandler(Filters.text, enter_data, pass_user_data=True)], WAIT_CATG: [MessageHandler(Filters.text, enter_data, pass_user_data=True)] }, fallbacks=[CommandHandler('quit', quit, pass_user_data=True)]) dp.add_handler(conv_handler_stats) # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.photo, image_processor)) dp.add_handler( MessageHandler(Filters.text, handle_text, pass_user_data=True)) # 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 telegram_bot(network, camera): """ This function runs the telegram bot that responds to commands like /enable, /disable or /status. """ def save_chat_id(bot, update): if 'telegram_chat_id' not in network.saved_data or network.saved_data['telegram_chat_id'] is None: network.save_telegram_chat_id(update.message.chat_id) logger.debug('Set Telegram chat_id {0}'.format(update.message.chat_id)) def debug(bot, update): logger.debug('Received Telegram bot message: {0}'.format(update.message.text)) def check_chat_id(update): if 'telegram_chat_id' in network.saved_data and update.message.chat_id != network.saved_data['telegram_chat_id']: logger.debug('Ignoring Telegam update with filtered chat id {0}: {1}'.format(update.message.chat_id, update.message.text)) return False else: return True def help(bot, update): if check_chat_id(update): bot.sendMessage(update.message.chat_id, parse_mode='Markdown', text='/status: Request status\n/disable: Disable alarm\n/enable: Enable alarm\n/photo: Take a photo\n/gif: Take a gif\n', timeout=10) def status(bot, update): if check_chat_id(update): bot.sendMessage(update.message.chat_id, parse_mode='Markdown', text=network.state.generate_status_text(), timeout=10) def disable(bot, update): if check_chat_id(update): network.state.update_state('disabled') def enable(bot, update): if check_chat_id(update): network.state.update_state('disarmed') def photo(bot, update): if check_chat_id(update): photo = camera.take_photo() network.telegram_send_file(photo) def gif(bot, update): if check_chat_id(update): gif = camera.take_gif() network.telegram_send_file(gif) def error_callback(bot, update, error): logger.error('Update "{0}" caused error "{1}"'.format(update, error)) try: updater = Updater(network.telegram_bot_token) dp = updater.dispatcher dp.add_handler(RegexHandler('.*', save_chat_id), group=1) dp.add_handler(RegexHandler('.*', debug), group=2) dp.add_handler(CommandHandler("help", help), group=3) dp.add_handler(CommandHandler("status", status), group=3) dp.add_handler(CommandHandler("disable", disable), group=3) dp.add_handler(CommandHandler("enable", enable), group=3) dp.add_handler(CommandHandler("photo", photo), group=3) dp.add_handler(CommandHandler("gif", gif), group=3) dp.add_error_handler(error_callback) updater.start_polling(timeout=10) except Exception as e: logger.error('Telegram Updater failed to start with error {0}'.format(repr(e))) _thread.interrupt_main() else: logger.info("thread running")
else: return False, f'Response not ok {r.status_code} - {r.reason}' @classmethod def post_snippet_pastebin(cls, snippet): try: r = requests.post(cls.ALT_URL, data=cls._pastebin_args(snippet.encode('utf-8'))) except Exception: msg = 'Error uploading snippet to pastebin.' logger.exception(msg) return False, 'Error uploading' if r.status_code == 200: return True, r.text else: return False, f'Response not ok {r.status_code} - {r.reason}' @classmethod def post_snippet(cls, snippet): success, msg = cls.post_snippet_hastebin(snippet) if not success: success, msg = cls.post_snippet_pastebin(snippet) return success, msg hastebin_handler = RegexHandler(CODELINK_PREFIX, code_paster, pass_groupdict=True)
def main(): """ The entrypoint for omnbot-frontend. The main function adds all handlers to the telegram dispatcher, informs the admin about the startup and runs the dispatcher forever. """ global frontend_fh global message_fh global cache frontend_fh = logging.handlers.TimedRotatingFileHandler('logs/frontend.log', when='midnight', backupCount=60) frontend_fh.setLevel(logging.DEBUG) frontend_fh.setFormatter(formatter) frontend_logger.addHandler(frontend_fh) message_fh = logging.handlers.TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=60) message_fh.setLevel(logging.DEBUG) message_fh.setFormatter(formatter) message_logger.addHandler(message_fh) redis_host = os.environ.get('OMNOMNOM_REDIS_HOST') or 'localhost' frontend_logger.debug('Redis host: %s' % redis_host) cache = redis.Redis(host=redis_host, decode_responses=True) token = os.environ.get('OMNOMNOM_AUTH_TOKEN') if not token: frontend_logger.error('You have to set your auth token as environment variable in OMNOMNOM_AUTH_TOKEN') sys.exit() admin = os.environ.get('OMNOMNOM_ADMIN') if not admin: frontend_logger.error('You have to specify an Admin account.') sys.exit() frontend_logger.debug('Admin ID: %s' % admin) updater = Updater(token=token) dispatcher = updater.dispatcher # Add an error handler to log and report errors dispatcher.add_error_handler(error_handler) # React to /start, /about and /help messages dispatcher.add_handler(CommandHandler('start', help_message), 2) dispatcher.add_handler(CommandHandler('about', about), 2) dispatcher.add_handler(CommandHandler('help', help_message), 2) # Send typing action and log incoming messages dispatcher.add_handler(RegexHandler('.*', send_typing_action), 0) dispatcher.add_handler(RegexHandler('.*', log_incoming_messages), 1) # Handle all messages beginning with a '/' dispatcher.add_handler(RegexHandler('/.*', menu), 2) # Handle normal text messages that are no reply and answer with a help_message dispatcher.add_handler(MessageHandler(Filters.text & (~ Filters.reply), help_message), 2) # Handle group member changes dispatcher.add_handler(MessageHandler(Filters.group & (~ Filters.reply), group_message_handler), 3) send_message_to_admin.delay('*Bot Started*\n\nID: %s\nFirstname: %s\nLastname: %s\nUsername: %s\nName: %s' % (updater.bot.id, updater.bot.first_name, updater.bot.last_name, updater.bot.username, updater.bot.name)) frontend_logger.info('Start polling') updater.start_polling() updater.idle()