def main():
"""Start the bot."""
# 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(BOT_TOKEN, use_context=True)
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[
CommandHandler('start', selecting_buro, pass_user_data=True)
],
states={
SELECTING_TERMIN_TYPE:
[CallbackQueryHandler(select_termin_type, pass_user_data=True)],
QUERING_TERMINS:
[CallbackQueryHandler(quering_termins, pass_user_data=True)],
SCHEDULE_APPOINTMENT:
[CallbackQueryHandler(set_retry_interval, pass_user_data=True)],
SELECT_INTERVAL:
[MessageHandler(Filters.text, start_interval_checking)],
STOP_CHECKING:
[CallbackQueryHandler(stop_checking, pass_user_data=True)]
},
fallbacks=[CommandHandler('start', selecting_buro)],
allow_reentry=True)
dp.add_handler(conv_handler)
dp.add_error_handler(error)
# scheduler for checking appointments with interval
scheduler.start()
# Start the Bot
if DEBUG:
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()
else:
PORT = int(os.environ.get("PORT", "8443"))
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME")
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=BOT_TOKEN)
updater.bot.set_webhook("https://{}.herokuapp.com/{}".format(
HEROKU_APP_NAME, BOT_TOKEN))
# heroku makes the app sleep after an hour of no incoming requests, so we will ping our app every 20 minutes
scheduler.add_job(ping_myself_and_clear_jobs,
"interval",
args=[HEROKU_APP_NAME],
minutes=20,
id="ping")
def main():
"""Start the bot."""
# 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(bot=get_bot(), use_context=True)
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', main_handler, pass_user_data=True),
CommandHandler('stats', stat_handler, pass_user_data=True)],
states={
MAIN: [CallbackQueryHandler(main_handler, pass_user_data=True)],
SELECTING_TERMIN_TYPE: [CallbackQueryHandler(termin_type_handler, pass_user_data=True)],
QUERING_TERMINS: [CallbackQueryHandler(quering_termins_handler, pass_user_data=True)],
SCHEDULE_APPOINTMENT: [CallbackQueryHandler(interval_handler, pass_user_data=True)],
SELECT_INTERVAL: [MessageHandler(Filters.text, interval_handler)],
},
fallbacks=[CommandHandler('start', main_handler)],
allow_reentry=True
)
dp.add_handler(conv_handler)
dp.add_error_handler(error)
job_storage.init_scheduler()
# Start the Bot
if DEBUG:
logger.info('Starting bot in debug polling mode')
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()
else:
logger.info('Starting bot in production webhook mode')
HOST_URL = os.environ.get("HOST_URL")
if HOST_URL is None:
logger.critical('HOST URL is not set!')
sys.exit(-1)
updater.start_webhook(listen="0.0.0.0",
port='8443',
url_path=BOT_TOKEN)
updater.bot.set_webhook("https://{}/{}".format(HOST_URL, BOT_TOKEN))
def main() -> None:
updater = Updater(token=config.TOKEN, use_context=True)
dispatcher = updater.dispatcher
down_handler = ConversationHandler(
entry_points=[CommandHandler('download', download)],
states = {
TYPE: [MessageHandler(Filters.regex('^('+'|'.join([i for i in config.ALLOWED_TYPES])+')$'), type)],
MAGNET: [MessageHandler(Filters.regex('^magnet*'), magnet)],
CONFIRM: [MessageHandler(Filters.regex('^OK$'), confirm)],
},
fallbacks=[CommandHandler('cancel', cancel),],
)
dispatcher.add_handler(down_handler)
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('status', status))
dispatcher.add_handler(CommandHandler('clear', clear))
dispatcher.add_handler(CommandHandler('help', help))
dispatcher.add_handler(MessageHandler(Filters.command, unknown))
updater.start_polling()
updater.idle()
def main():
"""Start the bot."""
# 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(BOT_TOKEN, use_context=True)
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[
CommandHandler('start', selecting_buro, pass_user_data=True)
],
states={
SELECTING_TERMIN_TYPE:
[CallbackQueryHandler(select_termin_type, pass_user_data=True)],
QUERING_TERMINS: [MessageHandler(Filters.text, quering_termins)],
},
fallbacks=[CommandHandler('start', selecting_buro)],
allow_reentry=True)
dp.add_handler(conv_handler)
dp.add_error_handler(error)
# Start the Bot
if DEBUG:
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()
else:
PORT = int(os.environ.get("PORT", "8443"))
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME")
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=BOT_TOKEN)
updater.bot.set_webhook("https://{}.herokuapp.com/{}".format(
HEROKU_APP_NAME, BOT_TOKEN))
def main():
# - COMMENT WHEN DEPLOYING TO HEROKU
TOKEN = os.environ.get('TOKEN')
updater = Updater(token=TOKEN, use_context=True)
dp = updater.dispatcher
if not local:
# CODE IS RUN ON SERVER
PORT = int(os.environ.get('PORT', '5000'))
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
updater.bot.set_webhook("https://fff-transparency-wg.herokuapp.com/" +
TOKEN)
# Commands
#dp.add_handler(MessageHandler(Filters.status_update.new_chat_members, new_group))
dp.add_handler(CommandHandler("help", help))
#dp.add_handler(CommandHandler("newgroup", save_group))
group_handler = ConversationHandler(
entry_points=[
MessageHandler(Filters.status_update.new_chat_members, new_group),
CommandHandler("newgroup", save_group)
],
states={
GROUP_INFO: [],
EDIT_GROUP: [],
CATEGORY: [CallbackQueryHandler(category)],
REGION: [CallbackQueryHandler(region)],
RESTRICTION: [CallbackQueryHandler(restriction)],
IS_SUBGROUP: [CallbackQueryHandler(is_subgroup)],
PARENT_GROUP: [CallbackQueryHandler(parent_group)],
PURPOSE: [
MessageHandler(Filters.text, purpose),
CallbackQueryHandler(purpose)
],
ONBOARDING: [
MessageHandler(Filters.text, onboarding),
CallbackQueryHandler(onboarding)
],
},
fallbacks=[])
call_handler = ConversationHandler(
entry_points=[
CommandHandler('newcall', new_call),
CommandHandler('editcall', edit_call)
],
states={
CALL_DETAILS: [
CallbackQueryHandler(edit_call,
pattern='^' + str(EDIT_CALL) + '$')
],
EDIT_CALL: [],
EDIT_ARGUMENT: [],
ADD_TITLE: [
MessageHandler(Filters.text, add_title),
CallbackQueryHandler(cancel_call)
],
ADD_DATE: [
MessageHandler(Filters.text, add_date),
CallbackQueryHandler(cancel_call)
],
ADD_TIME: [
MessageHandler(Filters.text, add_time),
CallbackQueryHandler(cancel_call)
],
},
fallbacks=[CallbackQueryHandler(cancel_call)],
)
delete_group_handler = ConversationHandler(
entry_points=[CommandHandler('deletegroup', delete_group)],
states={
CONFIRM_DELETE_GROUP: [CallbackQueryHandler(confirm_delete_group)],
DOUBLE_CONFIRM_DELETE_GROUP:
[CallbackQueryHandler(double_confirm_delete_group)]
},
fallbacks=[],
)
dp.add_handler(call_handler)
dp.add_handler(group_handler)
dp.add_handler(delete_group_handler)
dp.add_error_handler(error)
if local:
updater.start_polling()
updater.idle()
main_conversation_handler = ConversationHandler(
entry_points=[
CommandHandler('start',
start,
pass_chat_data=True,
pass_job_queue=True)
],
states={
'Menu': [
CommandHandler('add', birthdays.ask_name),
CommandHandler('remove', birthdays.remove, pass_args=True),
CommandHandler('year', birthdays.show_year, pass_chat_data=True),
CommandHandler('month', birthdays.show_month, pass_chat_data=True),
CommandHandler('help', m_help),
CommandHandler('set', settings.set1, pass_chat_data=True)
],
'Add_AddNameIsLink': [
MessageHandler([Filters.text], birthdays.add_name_is_link),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'Add_IsLinkProvideOrAskDay': [
MessageHandler([Filters.text], birthdays.is_link),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'Add_ProvideLinkAskDay': [
MessageHandler([Filters.text], birthdays.provide_link_ask_day),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'Add_AddDayAskMonth': [
MessageHandler([Filters.text], birthdays.add_day_ask_month),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'Add_AddMonthAddBirthday': [
MessageHandler([Filters.text], birthdays.add_month_add_birthday),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'SettingsAnswer': [
MessageHandler([Filters.text],
settings.settings_result,
pass_job_queue=True,
pass_chat_data=True),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'TimeZone': [
MessageHandler([Filters.text],
settings.time_zone2,
pass_chat_data=True,
pass_job_queue=True),
CommandHandler('help', m_help),
CommandHandler('reset', reset)
],
'Settings1_Wait_Answer': [
CommandHandler('time_zone', settings.time_zone1),
CommandHandler('skip', settings.skip_time_zone_settings),
CommandHandler('reset', reset)
],
'Settings2_Wait_Answer': [
CommandHandler('alarm_time', settings.notifications_time),
CommandHandler('disable',
settings.disable_notifications,
pass_chat_data=True),
CommandHandler('skip',
settings.skip_alarm_time_settings,
pass_chat_data=True),
CommandHandler('reset', reset)
]
},
fallbacks=[CommandHandler("exit", stop)])
msg.reply_text('Выберите оценку, или введите свою',
reply_markup=ReplyKeyboardMarkup(kb, True, True))
return State.task_process
hw_handler = CommandHandler('hw',
handle_hw,
Filters.private,
pass_user_data=True)
conv_handler = ConversationHandler(
entry_points=[hw_handler],
states={
State.task_choose:
[CallbackQueryHandler(on_choose, pass_user_data=True)],
State.task_process: [
RegexHandler('^{}$'.format(SKIP), handle_hw, pass_user_data=True),
RegexHandler('^{}$'.format(ACCEPT_RE),
on_accept,
pass_user_data=True),
RegexHandler('^{}$'.format(DECLINE),
on_decline,
pass_user_data=True),
RegexHandler('^\.\.\.$', on_mark, pass_user_data=True),
MessageHandler(Filters.text, on_comment, pass_user_data=True),
CallbackQueryHandler(on_get_img, pass_user_data=True)
]
},
fallbacks=[hw_handler])
'Введите /hw'.format(sid))
else:
reply = ('Добро пожаловать на борт, салага!\n'
'Ваш новый sid: {}.'.format(sid))
else:
reply = 'Неверный логин и/или пароль'
update.message.reply_text(reply)
return ConversationHandler.END
conv_handler = ConversationHandler(
entry_points=[CommandHandler('login', handle_login, Filters.private)],
states={
States.username:
[MessageHandler(Filters.text, handle_username, pass_user_data=True)],
States.password:
[MessageHandler(Filters.text, handle_password, pass_user_data=True)]
},
fallbacks=[])
def get_user(message: Message) -> LyceumUser:
q = LyceumUser.filter(tgid=message.from_user.id)
return q[0] if q else None
class ProfileParser(Parser):
course_links = []
in_proper_card = False
return ConversationHandler.END
def bot_lang_button(update, context):
query = update.callback_query
query.answer()
data = query.data.split(';')
queries.change_bot_lang(query.message.chat.id, data[1])
phrases = queries.get_phrases(query.message.chat.id)
query.message.reply_text(phrases['bot_lang_choise_done'])
handlers = [
ConversationHandler(
entry_points=[CommandHandler('find', find)],
states={
1: [MessageHandler(Filters.text & ~Filters.command, find_results)],
},
fallbacks=[CommandHandler('cancel', stop)]),
ConversationHandler(
entry_points=[
CallbackQueryHandler(save_button,
pattern='^s;*',
pass_user_data=True,
pass_chat_data=True)
],
states={
1: [MessageHandler(Filters.text & ~Filters.command, save_first)],
2: [MessageHandler(Filters.text & ~Filters.command, save_second)],
},
fallbacks=[CommandHandler('cancel', stop)]),
CommandHandler('start', start),
text = COVER + str(style)
if arg == 'ready' and name == 'ready':
next_state = ConversationHandler.END
text = '<b>Настройки сохранены.</b>\n\n' + str(style)
msg.delete()
msg.reply_text(text, reply_markup=start.reply_markup,
parse_mode=ParseMode.HTML)
elif msg.text != text:
msg.edit_text(text,
reply_markup=InlineKeyboardMarkup(keyboard))
return next_state
def on_fallback(bot, update: Update):
msg: Message = update.message
msg.reply_text('Вы всё ещё в диалоге настройки стиля. '
'Если вам надоело, щёлкните кнопку "Готово"',
reply_markup=InlineKeyboardMarkup(ready_keyboard))
return State.choice
conv_handler = ConversationHandler(
entry_points=[CommandHandler('style', on_style, Filters.private,
pass_user_data=True)],
states={
State.choice: [CallbackQueryHandler(on_choose,
pass_user_data=True)],
},
fallbacks=[MessageHandler(Filters.all, on_fallback)]
)
def done(update, context):
try:
context.bot.send_message(chat_id=context.bot_data['admin'],
text=messages['notification'].format(
username=update.effective_user.username
or update.effective_user.id,
user_id=update.effective_user.id,
name=context.user_data['name'],
phone=context.user_data['phone'],
),
disable_notification=False)
except TelegramError as err:
logging.error("Ошибка пересылки заявки - %s", err)
update.callback_query.answer(messages['fail'], show_alert=True)
else:
update.callback_query.answer(messages['success'], show_alert=True)
return back(update, context)
contact_form = ConversationHandler(
entry_points=[CallbackQueryHandler(ask_name, pattern=r'^contact$')],
states={
1: [MessageHandler(Filters.text, ask_phone)],
2: [MessageHandler(Filters.text, ask_confirm)],
3: [CallbackQueryHandler(done, pattern=r'^confirm$')],
},
fallbacks=[CallbackQueryHandler(back, pattern=r'^back$')],
allow_reentry=True)
def cancel(bot, update):
user = update.message.from_user
log.info("User %s canceled the conversation." % user.first_name)
bot.sendMessage(update.message.chat_id, text='Operation canceled')
return ConversationHandler.END
show_movies_cnv_handler = RegexHandler('\w', show_movies)
add_movie_cnv_handler = ConversationHandler(
entry_points=[RegexHandler('\w', add_movies)],
states={
MOVIE_NAME: [MessageHandler([Filters.text], movie_name)],
MOVIE_YEAR: [
RegexHandler(r'[\d]{4}', movie_year),
CommandHandler('skip', skip_movie_year)
]
},
fallbacks=[CommandHandler('cancel', cancel)])
movie_list_handler = ConversationHandler(
entry_points=[CommandHandler('movie_list', main_menu)],
states={
ACTION_SELECTOR: [MessageHandler([Filters.text], action_selection)],
LIST_MOVIES: [show_movies_cnv_handler],
ADD_MOVIES: [add_movie_cnv_handler]
},
fallbacks=[CommandHandler('cancel', cancel)])