def cancel(bot, update):
user = update.message.from_user
update.message.reply_text('Operación cancelada',
reply_markup=ReplyKeyboardRemove())
return ConversationHandler.END
updater.dispatcher.add_handler(CommandHandler('start', handler_start_help))
updater.dispatcher.add_handler(CommandHandler('help', handler_start_help))
updater.dispatcher.add_handler(CommandHandler('todas', handler_todas))
updater.dispatcher.add_handler(CommandHandler('licencia', handler_licencia))
updater.dispatcher.add_handler(RegexHandler('^(/id [\d]+)$', handler_id))
updater.dispatcher.add_handler(RegexHandler('id', handler_id))
updater.dispatcher.add_error_handler(error)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('nueva_fuente', handler_nueva)],
states={
TITULO: [MessageHandler(Filters.text, nueva_titulo)],
TIPO: [
MessageHandler(Filters.regex('^(public|restricted|private)$'),
nueva_tipo)
],
DIR: [MessageHandler(Filters.text, nueva_dir)],
DESC: [MessageHandler(Filters.text, nueva_desc)],
HORA: [MessageHandler(Filters.text, nueva_hora)],
def test_deprecation_Warning(self):
with pytest.warns(TelegramDeprecationWarning,
match='RegexHandler is deprecated.'):
RegexHandler('.*', self.callback_basic)
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 start(self):
insert_handler = ConversationHandler(
entry_points=[CommandHandler('action', self.action_command)],
states={
CHOOSING: [
RegexHandler('^(Expense|Payment)$',
self.first_choice,
pass_user_data=True)
],
TAKE_INFORMATION: [
RegexHandler('^(Price|Description|Debtor)$',
self.take_information,
pass_user_data=True)
],
TAKE_DATA: [
MessageHandler(Filters.text,
self.take_data,
pass_user_data=True)
],
SET_PAYMENT: [
MessageHandler(Filters.text,
self.set_payment,
pass_user_data=True)
],
USER_PAYMENT: [
MessageHandler(Filters.text,
self.user_payment,
pass_user_data=True)
],
REGISTER_PAYMENT: [
CallbackQueryHandler(self.register_payment,
pass_user_data=True)
]
},
fallbacks=[
RegexHandler('^(Submit|Cancel)$',
self.end_action,
pass_user_data=True)
],
)
try:
self.updater = Updater(token=self.cfg.get('token'), workers=10)
self.dispatcher = self.updater.dispatcher
self.updater.start_polling(clean=True)
self.dispatcher.add_error_handler(self.error_callback)
self.dispatcher.add_handler(
CommandHandler('start', self.start_command))
self.dispatcher.add_handler(
CommandHandler('ping', self.ping_command))
self.dispatcher.add_handler(
CommandHandler('help', self.help_command))
self.dispatcher.add_handler(
CommandHandler('register', self.register_command))
self.dispatcher.add_handler(
CommandHandler('total', self.total_command))
#self.dispatcher.add_handler(CommandHandler('print', self.print_command))
#self.dispatcher.add_handler(CallbackQueryHandler(self.button))
self.dispatcher.add_handler(insert_handler)
self.updater.idle()
except Exception as ecc:
logging.error('error: ' + str(ecc))
pass
__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 handler(self):
return ConversationHandler(
entry_points=[RegexHandler('\S*', self.home)],
states={HOME: [CallbackQueryHandler(self.home)]},
fallbacks=[])
dispatcher.add_handler(CommandHandler("restart", restart_bot))
dispatcher.add_handler(CommandHandler("shutdown", shutdown_bot))
dispatcher.add_handler(CommandHandler("wiki", wiki, pass_args=True))
dispatcher.add_handler(CommandHandler("config", change_cfg, pass_args=True))
dispatcher.add_handler(CommandHandler("feedback", feedback, pass_args=True))
# ConversationHandler for poll
poll_handler = ConversationHandler(
entry_points=[CommandHandler("poll", poll, pass_args=True)],
states={
SAVE_ANSWER: [MessageHandler(Filters.text, poll_save_answer)],
CREATE_TOPIC: [MessageHandler(Filters.text, poll_create_topic, pass_user_data=True)],
CREATE_ANSWERS: [MessageHandler(Filters.text, poll_create_answers, pass_user_data=True)],
CREATE_END: [MessageHandler(Filters.text, poll_create_end, pass_user_data=True)],
DELETE_POLL: [RegexHandler("^(yes|no)$", poll_delete)]
},
fallbacks=[CommandHandler('cancel', poll_cancel)],
allow_reentry=True)
dispatcher.add_handler(poll_handler)
# MessageHandlers that filter on specific content
dispatcher.add_handler(MessageHandler(Filters.status_update.new_chat_members, welcome))
dispatcher.add_handler(MessageHandler(Filters.text, check_msg))
# Start the bot
updater.start_polling(clean=True)
def on_schedon_button_quick(_, update):
logger.info('quick info: schedon button')
qb.set_preferences(**{'scheduler_enabled': True})
text = get_quick_info_text()
update.callback_query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=kb.QUICK_MENU_BUTTON)
update.callback_query.answer('Scheduled altenrative speed on')
@u.check_permissions(required_permission=Permissions.EDIT)
@u.failwithmessage
@u.ignore_not_modified_exception
def on_schedoff_button_quick(_, update):
logger.info('quick info: schedoff button')
qb.set_preferences(**{'scheduler_enabled': False})
text = get_quick_info_text()
update.callback_query.edit_message_text(text, parse_mode=ParseMode.HTML, reply_markup=kb.QUICK_MENU_BUTTON)
update.callback_query.answer('Scheduled altenrative speed off')
updater.add_handler(CommandHandler(['quick'], on_quick_info_command, pass_user_data=True))
updater.add_handler(RegexHandler(r'^[aA]$', on_quick_info_refresh, pass_user_data=True))
updater.add_handler(CallbackQueryHandler(on_refresh_button_quick, pattern=r'^quick:refresh:(\w+)$', pass_groups=True))
updater.add_handler(CallbackQueryHandler(on_alton_button_quick, pattern=r'^quick:alton$'))
updater.add_handler(CallbackQueryHandler(on_altoff_button_quick, pattern=r'^quick:altoff$'))
updater.add_handler(CallbackQueryHandler(on_schedon_button_quick, pattern=r'^quick:schedon'))
updater.add_handler(CallbackQueryHandler(on_schedoff_button_quick, pattern=r'^quick:schedoff'))
def test_none_allowed(self):
with pytest.raises(ValueError, match='are all False'):
RegexHandler('.*', self.callback_basic, message_updates=False,
channel_post_updates=False, edited_updates=False)
• `/delrepo <name>`: deletes a repo shortcut
"""
__mod_name__ = "GitHub"
RELEASE_HANDLER = DisableAbleCommandHandler(
"git", getRelease, admin_ok=True, run_async=True
)
FETCH_HANDLER = DisableAbleCommandHandler(
"fetch", cmdFetch, admin_ok=True, run_async=True
)
SAVEREPO_HANDLER = CommandHandler("saverepo", saveRepo, run_async=True)
DELREPO_HANDLER = CommandHandler("delrepo", delRepo, run_async=True)
LISTREPO_HANDLER = DisableAbleCommandHandler("listrepo", listRepo, admin_ok=True, run_async=True)
VERCHECKER_HANDLER = DisableAbleCommandHandler("gitver", getVer, admin_ok=True, run_async=True)
CHANGELOG_HANDLER = DisableAbleCommandHandler(
"changelog", changelog, admin_ok=True, run_async=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)
def main():
Token = '484837035:AAHmnHWN7KEGLX9vAIsgyDW0duOX7YWi0jU'
updater = Updater(Token)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('analizar', analizar)],
states={
SEXO: [RegexHandler('^([0-9][0-9]?)$', sexo)],
LANGUAGE: [RegexHandler('^(Chico|Chica)$', language)],
GENRE: [RegexHandler('^(EN|ES)$', genre)],
CANCIONES: [
RegexHandler('^(pop|pop en español|romántica|reguetón)$',
canciones)
],
ESTEROTIPO:
[RegexHandler('^(otra canción|continuar)$', estereotipo)],
AWNSER1:
[RegexHandler('^([0-9][0-9]?|ninguna|\U0001f51a)$', awnser1)],
ROLES: [MessageHandler(Filters.text, roles)],
AWNSER2:
[RegexHandler('^([0-9][0-9]?|ninguna|\U0001f51a)$', awnser2)],
PODER: [MessageHandler(Filters.text, poder)],
AWNSER3:
[RegexHandler('^([0-9][0-9]?|ninguna|\U0001f51a)$', awnser3)],
CUERPO: [MessageHandler(Filters.text, cuerpo)],
AWNSER4:
[RegexHandler('^([0-9][0-9]?|ninguna|\U0001f51a)$', awnser4)],
GENERAL: [MessageHandler(Filters.text, general)],
AWNSER5: [RegexHandler('^(Si|No|si|no|sí|Sí)$', awnser5)],
END1: [RegexHandler('^([0-9][0-9]?|\U0001f51a)$', end)]
},
fallbacks=[CommandHandler('cancel', cancel)])
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(conv_handler)
updater.dispatcher.add_handler(CommandHandler('cancion', cancion))
updater.dispatcher.add_handler(CommandHandler('conceptos', conceptos))
updater.dispatcher.add_handler(CommandHandler('ayuda', ayuda))
updater.dispatcher.add_handler(CommandHandler('acerca_de', acerca_de))
updater.start_polling()
#updater.start_webhook(listen='0.0.0.0',
# port=8443,
# url_path=Token,
# key='private.key',
# cert='cert.pem',
# webhook_url=':8443/{}'.format(Token))
updater.idle()
path_to_file = os.environ['PATH_TO_FILE']
file_encoding = os.environ['FILE_ENCODING']
question_dict = handler_dictionary.get_dict_with_questions_and_answers(
path_to_file, file_encoding)
telegram_token = os.environ['TELEGRAM_TOKEN']
updater = Updater(telegram_token)
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
function.SEND_QUESTION: [
RegexHandler(
'^Новый вопрос$',
partial(handle_new_question_request, r, question_dict))
],
function.SURRENDER: [
RegexHandler('^Сдаться$', partial(handle_loss, r,
question_dict))
],
function.CHECK_ANSWER: [
RegexHandler(
'^Новый вопрос$',
partial(handle_new_question_request, r, question_dict)),
MessageHandler(
Filters.text,
partial(handle_solution_attempt, r, question_dict))
]
},
reply_markup=generate_inline())
bot.answer_callback_query(callback_query_id=query.id,
text="Тест завершен")
delete_query(query.message)
else:
count_result(query.message, int(generate_result(step, result=result)))
bot.edit_message_text(chat_id=query.message.chat_id,
message_id=query.message.message_id,
text=generate_text(step),
reply_markup=generate_inline(step))
bot.answer_callback_query(callback_query_id=query.id,
text="Вы выбрали вариант №" + str(result))
# Handlers for bot
bot_handlers = [
CommandHandler('start', start),
RegexHandler('Да', choice_yes),
RegexHandler('Расписание Магистров', schedule_mag),
RegexHandler('Нет', choice_no),
RegexHandler('На главную', main_menu),
RegexHandler('Преимущества', advantages),
RegexHandler('Специальности', specialty),
RegexHandler('Пройти тест', test_start),
RegexHandler('Соцсети', social),
RegexHandler('Контакты', cont),
RegexHandler('Адрес', point),
CallbackQueryHandler(callback_handler)
]
for admin in os.environ['ADMIN'].split(' '):
bot.sendMessage(admin, feedback_user, parse_mode='HTML')
bot.sendMessage(update.message.chat_id, 'Grazie per la collaborazione, '
'il messaggio è stato inviato agli sviluppatori.',
reply_markup=telegram.ReplyKeyboardRemove())
return ConversationHandler.END
def close(bot, update):
"""Defining Function for remove keyboard"""
bot.sendMessage(update.message.chat_id,
'Davvero non vuoi nemmeno salutarci? Che peccato...',
reply_markup=telegram.ReplyKeyboardRemove())
return ConversationHandler.END
FEEDBACK_CONV = ConversationHandler(
entry_points=[CommandHandler('feedback', feedback_command)],
states={
"send_feedback": [
RegexHandler('^(Lascia un messaggio agli sviluppatori)$',
receiving_user_feedback)
],
"message": [RegexHandler('.*', send_to_developers)]
},
fallbacks=[RegexHandler('^(Chiudi)$', close)])
async def execute(windowManager):
global myWindowManager
myWindowManager = windowManager
# Create the Updater and pass it your bot's token.
updater = Updater(BOT_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={
STATES.COMMAND_WAIT: [
RegexHandler('^Open/Close windows', operate_select_windows),
RegexHandler('^Toggle Child Lock$',
childlock_windows_selection),
RegexHandler('^Set Time$', timeset_windows_selection),
RegexHandler('^Toggle Sensors$', sensors_windows_selection)
],
STATES.OPERATE: [
RegexHandler('^Open all windows$', open_all_windows),
RegexHandler('^Close all windows$', close_all_windows),
MessageHandler(Filters.text, operate_execute)
],
STATES.CHILDLOCK:
[MessageHandler(Filters.text, childlock_execute)],
STATES.SENSORS: [
RegexHandler('^Enable all sensors$', enable_all_sensors),
RegexHandler('^Disable all sensors$', disable_all_sensors),
MessageHandler(Filters.text, sensors_execute_individual)
],
STATES.TIME: [
MessageHandler(Filters.text,
timeset_to_add_or_remove,
pass_user_data=True)
],
STATES.TIME_EDITING: [
RegexHandler('^Add a time to open/close window$', timeset_add),
RegexHandler('^Remove a time to open/close window$',
timeset_remove,
pass_user_data=True)
],
STATES.TIME_ADDING: [
RegexHandler('^Open|Close$',
timeset_input_time,
pass_user_data=True)
],
STATES.TIME_AWAITING_INPUT: [
RegexHandler(TimeManager.time_pattern,
add_time_job,
pass_job_queue=True,
pass_user_data=True)
],
STATES.TIME_REMOVING: [
RegexHandler('^Remove every operation$',
remove_job_all,
pass_user_data=True,
pass_job_queue=True),
RegexHandler('^Opens at|Closes at',
remove_job_one,
pass_job_queue=True,
pass_user_data=True),
],
STATES.END_TIME: [
RegexHandler('^Continue editing time settings$',
timeset_windows_selection,
pass_user_data=True),
RegexHandler("^Return to main menu$",
main_menu,
pass_user_data=True)
]
},
fallbacks=[
CommandHandler('main', main_menu, pass_user_data=True),
CommandHandler('exit', exit),
MessageHandler(Filters.text, error_instruction)
])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start the Bot
await 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 = Updater("431912337:AAEobNaW1QN9bNfLgVKTN05n2ufzdQaWRvc")
# 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),
RegexHandler(u'^Начать отчет$', new_report),
MessageHandler(Filters.location,
address_input,
pass_user_data=True)
],
states={
CHOOSING: [
RegexHandler(u'^Начать отчет$', new_report),
RegexHandler(u'^Помощь$', show_help),
RegexHandler(u'^О программе$', show_about)
],
ADDRESS: [
MessageHandler(Filters.location,
address_input,
pass_user_data=True)
],
APARTMENTS_AMOUNT: [
MessageHandler(Filters.text,
apartments_amount_input,
pass_user_data=True)
],
APARTMENTS_OPENED: [
MessageHandler(Filters.text,
apartments_opened_input,
pass_user_data=True)
],
COMMENT:
[MessageHandler(Filters.text, comment_input, pass_user_data=True)],
EDIT: [
RegexHandler(
u'^(Адресс|Квартир пройдено|Квартир открыло|Отправить)$',
edit_field,
pass_user_data=True)
],
EDIT_ADDRESS: [
MessageHandler(Filters.location,
edit_address,
pass_user_data=True)
],
EDIT_APARTMENTS_AMOUNT: [
MessageHandler(Filters.text,
edit_apartments_amount,
pass_user_data=True)
],
EDIT_APARTMENTS_OPENED: [
MessageHandler(Filters.text,
edit_apartments_opened,
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)
# 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 _get_back_handler(self):
return RegexHandler(f"^({lbl.BACK})$", self.back)
bot = telegram.Bot(token)
updater = Updater(token)
dispatcher = updater.dispatcher
# Register commands
registerCommand(dispatcher, "my_house_letters", my_house_letters)
registerCommand(dispatcher, "all_house_letters", all_house_letters)
registerCommand(dispatcher, "station_overview", station_overview)
registerCommand(dispatcher, "help", help)
# 'Start' conversation handler -- register house with bot
start_conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
CONFIRMATION_REQUEST: [
RegexHandler('^(Ursaia|Nocturna|Ianthe|Triton|Ankaa|Saren)$',
registerHouse)
],
},
fallbacks=[
CommandHandler('remove', remove),
CommandHandler('cancel', cancel)
])
dispatcher.add_handler(start_conv_handler)
# 'Play' conversation handler -- output station instructions
play_conv_handler = ConversationHandler(
entry_points=[CommandHandler('play', play)],
states={
CONFIRMATION_REQUEST: [MessageHandler(Filters.text, get_instructions)],
},
fallbacks=[CommandHandler('cancel', cancel)])
def mailing(update, context):
if update.message.chat.type == 'private':
user = str(update.message.chat.username)
if user in admins:
update.message.reply_text('Введи пост:')
data["process"][user] = "post"
if __name__ == '__main__':
data = json.load(open('users.json', 'r'))
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start)) #обработчики команд
dp.add_handler(CommandHandler("admin", admin))
dp.add_handler(RegexHandler("^👨💻Profile$", profile))
dp.add_handler(RegexHandler("^📈About$", about))
dp.add_handler(RegexHandler("^💣Withdraw$", withdraw))
dp.add_handler(RegexHandler("^👥Referral$", ref))
dp.add_handler(RegexHandler("^💰Balance$", bal))
dp.add_handler(RegexHandler("^К-во$", users))
dp.add_handler(RegexHandler("^Рассылка$", mailing))
dp.add_handler(RegexHandler("^База$", get_file))
dp.add_handler(MessageHandler(Filters.text, extra))
if DEV is not True:
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
updater.bot.set_webhook(webhook_url + TOKEN)
else:
updater.start_polling()
print("Bot Started")
updater.idle()
@run_async
@log_time
@admin_only
def delete_snippet(bot, update, **kwargs):
key = kwargs['groupdict'].get('key')
if not key:
update.message.reply_text('Te faltó poner qué snippet borrar')
return
removed = remove_snippet(key)
if removed:
message = f"✅ El snippet `{key}` fue borrado"
else:
message = 'No se pudo borrar la pregunta.'
update.message.reply_text(message, parse_mode='markdown')
save_snippet_handler = RegexHandler(SAVE_REGEX,
save_snippet,
pass_groupdict=True)
get_snippet_handler = RegexHandler(GET_REGEX, get_snippet, pass_groupdict=True)
delete_snippet_handler = RegexHandler(DELETE_REGEX,
delete_snippet,
pass_groupdict=True)
snippet_get_command = CommandHandler('get',
get_snippet_command,
pass_args=True)
show_snippets_handler = CommandHandler('snippets', show_snippets)
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()
chat = bot.get_chat(user_id)
if not user.reason:
res = "{} is AFK!".format(chat.first_name)
else:
res = "{} is AFK!\nReason: {}".format(
chat.first_name, user.reason)
message.reply_text(res)
else:
return
__help__ = """
- /afk <reason>: mark yourself as AFK - any mentions will be replied to with a message to say you're not available!
- brb <reason>: same as the afk command - but not a command.
"""
__name__ = "AFK"
AFK_HANDLER = CommandHandler("afk", afk)
AFK_REGEX_HANDLER = RegexHandler("(?i)brb", afk)
NO_AFK_HANDLER = MessageHandler(Filters.all, no_longer_afk)
AFK_REPLY_HANDLER = MessageHandler(
Filters.entity(MessageEntity.MENTION)
| Filters.entity(MessageEntity.TEXT_MENTION), reply_afk)
dispatcher.add_handler(AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP)
dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP)
dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
- /get <notename>: get the note with this notename
- #<notename>: same as /get
- /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)
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
logger.setLevel(logging.INFO)
logger.addHandler(MyLogsHandler(logging_bot, CHAT_ID))
logger.info('Бот tg-quiz запущен')
updater = Updater(TG_QUIZBOT_TOKEN)
dp = updater.dispatcher
send_question = partial(handle_new_question_request, questions=questions)
send_answer = partial(handle_give_up_attempt, questions=questions)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
State.QUESTION: [RegexHandler('^(Новый вопрос)$', send_question)],
State.SOLUTION: [
RegexHandler('^(Сдаться)$', send_answer),
MessageHandler(Filters.text, handle_solution_attempt)
]
},
fallbacks=[CommandHandler('cancel', cancel)])
dp.add_handler(conv_handler)
dp.add_error_handler(error)
while True:
try:
updater.start_polling()
updater.idle()
updater = Updater(token=app.get_config().get('bot_token'))
except ValueError as e:
updater = None
bot_logger.log(logging.FATAL, str(e))
exit("Can not init Bot Updater object")
updater.dispatcher.add_handler(CommandHandler("help", base.help_msg))
updater.dispatcher.add_handler(CommandHandler("my_coins", coins.my_coins))
updater.dispatcher.add_handler(CommandHandler("show_rates", coins.my_coins))
hello_handler = ConversationHandler(
entry_points=[CommandHandler('start', base.start)],
states={
base.CmdStates.START_SAVE_USER: [
MessageHandler(Filters.location, base.update_user),
RegexHandler('^Skip$', base.update_user)
],
},
fallbacks=[CommandHandler('cancel', base.cancel)])
updater.dispatcher.add_handler(hello_handler)
add_coin_handler = ConversationHandler(
entry_points=[CommandHandler('add_coin', coins.add_coin_start)],
states={
coins.AddCoinStates.ADD: [
RegexHandler(coins.helper.get_coins_pattern(), coins.add_coin),
CommandHandler('cancel', base.cancel)
],
coins.AddCoinStates.COMPLETE_ADD: [
CommandHandler('add_coin', coins.add_coin_start),
def get_handler(self):
handler = ConversationHandler(
entry_points=[
RegexHandler("^Уведомления", self.entry, pass_user_data=True)
],
states={
RemindersMenu.States.ACTION: [
RegexHandler("^Текст",
self.entry_text_reminders,
pass_user_data=True),
RegexHandler("^Срок",
self.entry_term_reminders,
pass_user_data=True),
RegexHandler("^Периодичность",
self.entry_interval_reminders,
pass_user_data=True),
RegexHandler("^Перезапустить",
self.start_reminders,
pass_user_data=True,
pass_job_queue=True),
RegexHandler('^Назад',
self.go_previous_menu,
pass_user_data=True,
pass_job_queue=True),
MessageHandler(Filters.all,
to_state(RemindersMenu.States.ACTION),
pass_user_data=True),
],
RemindersMenu.States.SET_TEXT: [
RegexHandler('^Назад', self.entry, pass_user_data=True),
MessageHandler(Filters.text,
self.save_text_reminders,
pass_user_data=True),
MessageHandler(~Filters.text,
to_state(RemindersMenu.States.SET_TEXT),
pass_user_data=True),
],
RemindersMenu.States.SET_TERM: [
RegexHandler('^Назад', self.entry, pass_user_data=True),
MessageHandler(Filters.text,
self.save_term_reminders,
pass_user_data=True),
MessageHandler(~Filters.text,
to_state(RemindersMenu.States.SET_TERM),
pass_user_data=True),
],
RemindersMenu.States.SET_INTERVAL: [
RegexHandler('^Назад', self.entry, pass_user_data=True),
MessageHandler(Filters.text,
self.save_interval_reminders,
pass_user_data=True),
MessageHandler(~Filters.text,
to_state(RemindersMenu.States.SET_INTERVAL),
pass_user_data=True),
],
},
fallbacks=[
MessageHandler(Filters.all,
unknown_command(-1),
pass_user_data=True)
],
allow_reentry=True)
return handler
def test_other_update_types(self, false_update):
handler = RegexHandler('.*', self.callback_basic, edited_updates=True)
assert not handler.check_update(false_update)
def main():
updater = Updater(config.BOT_TOKEN)
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[
CommandHandler('add_faq', add_faq, pass_user_data=True),
CommandHandler('add_mat', add_materials, pass_user_data=True),
CommandHandler('del_faq', del_faq, pass_user_data=False),
CommandHandler('del_mat', del_materials, pass_user_data=False),
CommandHandler('update_pb', update_phonebook,
pass_user_data=False),
CommandHandler('faq', Postgres.faq_choice, pass_user_data=False),
CommandHandler('phonebook', phonebook_choice,
pass_user_data=False),
CommandHandler('manual',
Postgres.materials_choice,
pass_user_data=False),
CommandHandler('send_invite', send_invite, pass_user_data=False),
],
states={
TYPING_REPLY: [
MessageHandler(
Filters.text,
Postgres.received_contact,
pass_user_data=True,
),
],
Postgres.FINISH_MATERIALS_TO_DB: [
MessageHandler(Filters.text,
add_materials,
pass_user_data=True),
],
Postgres.FINISH_FAQ_TO_DB: [
MessageHandler(Filters.text, add_faq, pass_user_data=True),
],
Postgres.INSERT_FAQ_TO_DB: [
MessageHandler(Filters.text,
Postgres.insert_faq_to_db,
pass_user_data=True),
],
Postgres.INSERT_MATERIALS_TO_DB: [
MessageHandler(Filters.text,
Postgres.insert_materials_to_db,
pass_user_data=True),
],
Postgres.DELETE_FAQ: [
MessageHandler(
Filters.text,
Postgres.delete_faq_from_db_1,
pass_user_data=True,
),
],
Postgres.DELETE_MATERIALS: [
MessageHandler(
Filters.text,
Postgres.delete_materials_from_db,
pass_user_data=True,
),
],
Postgres.UPDATE_PHONEBOOK: [
MessageHandler(
Filters.document,
Postgres.download_and_update_phonebook,
pass_user_data=True,
),
],
},
conversation_timeout=180,
fallbacks=[RegexHandler('^Выход$', done, pass_user_data=True)])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
PLAY_KEYBOARD = [['Новый вопрос', 'Мой счет']]
START_REPLY_MARKUP = ReplyKeyboardMarkup(START_KEYBOARD,
resize_keyboard=True)
ANSWER_REPLY_MARKUP = ReplyKeyboardMarkup(ANSWER_KEYBOARD,
resize_keyboard=True)
PLAY_REPLY_MARKUP = ReplyKeyboardMarkup(PLAY_KEYBOARD,
resize_keyboard=True)
PLAY, ANSWER = range(2)
handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
PLAY: [
RegexHandler('Новый вопрос', handle_new_question_request),
RegexHandler('Мой счет', handle_count)
],
ANSWER: [
RegexHandler('Мой счет', handle_count),
RegexHandler('Сдаться', handle_give_up),
RegexHandler('.{1,}', handle_solution_attempt)
],
},
fallbacks=[CommandHandler('cancel', cancel)])
try:
db = redis.Redis(REDIS_HOST,
REDIS_PORT,
password=REDIS_PASSWORD,
decode_responses=True)
logger_handler = TelegramBotHandler(telegram_token, telegram_chat_id)
logger_handler.setLevel(logging.WARNING)
logger_handler.formatter = logging.Formatter(
'%(name)s - %(levelname)s - %(message)s')
logger.addHandler(logger_handler)
updater = Updater(telegram_token)
updater.logger.addHandler(logger_handler)
dispatcher = updater.dispatcher
dispatcher.logger.addHandler(logger_handler)
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
question: [
RegexHandler('^Новый вопрос$', handle_new_question_request),
CommandHandler('cancel', cancel)
],
answer: [
RegexHandler('^Сдаться$', handle_show_answer),
MessageHandler(Filters.text, handle_solution_attempt),
CommandHandler('cancel', cancel)
]
},
fallbacks=[CommandHandler('cancel', cancel)])
dispatcher.add_handler(conv_handler)
dispatcher.add_error_handler(error_handler)
updater.start_polling()
updater.idle()