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 test_other_update_types(self, false_update):
handler = RegexHandler('.*', self.callback_basic, edited_updates=True)
assert not handler.check_update(false_update)
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()
