def test_pass_job_or_update_queue(self, dp, poll_answer):
handler = PollAnswerHandler(self.callback_queue_1, pass_job_queue=True)
dp.add_handler(handler)
dp.process_update(poll_answer)
assert self.test_flag
dp.remove_handler(handler)
handler = PollAnswerHandler(self.callback_queue_1,
pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll_answer)
assert self.test_flag
dp.remove_handler(handler)
handler = PollAnswerHandler(self.callback_queue_2,
pass_job_queue=True,
pass_update_queue=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll_answer)
assert self.test_flag
def test_basic(self, dp, poll_answer):
handler = PollAnswerHandler(self.callback_basic)
dp.add_handler(handler)
assert handler.check_update(poll_answer)
dp.process_update(poll_answer)
assert self.test_flag
def test_slot_behaviour(self, recwarn, mro_slots):
handler = PollAnswerHandler(self.callback_basic)
for attr in handler.__slots__:
assert getattr(handler, attr,
'err') != 'err', f"got extra slot '{attr}'"
assert not handler.__dict__, f"got missing slot(s): {handler.__dict__}"
assert len(mro_slots(handler)) == len(set(
mro_slots(handler))), "duplicate slot"
handler.custom, handler.callback = 'should give warning', self.callback_basic
assert len(recwarn) == 1 and 'custom' in str(
recwarn[0].message), recwarn.list
def main():
persistance = init_persistance()
defaults = Defaults(parse_mode=ParseMode.HTML)
updater = Updater(token, persistence=persistance, use_context=True, defaults=defaults,
request_kwargs={'read_timeout': timeout, 'connect_timeout': timeout})
job_queue = updater.job_queue
SELF_CHAT_ID = f'@{updater.bot.get_me().username}'
logger.info(f'SELF_CHAT_ID {SELF_CHAT_ID}')
logger.info(f'CHATID {CHATID}')
conversation_handler = ConversationHandler(
entry_points=deco.entry_points,
states=deco.entry_states,
fallbacks=deco.entry_fallbacks,
name="order",
persistent=True,
allow_reentry=True,
per_user=True,
per_chat=True,
# per_message=True
)
updater.dispatcher.add_handler(conversation_handler)
for dispather in deco.global_dispatchers:
updater.dispatcher.add_handler(dispather)
updater.dispatcher.add_handler(PollAnswerHandler(utils.poll_callback, pass_update_queue=True, pass_user_data=True, pass_chat_data=True))
#updater.dispatcher.add_error_handler(error)
updater.start_polling()
updater.idle()
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
BOT = MessageCounter()
updater = Updater("1181981103:AAGKnUqVXKu7OR5DDfMqXpuxn00uaCeOD-8", use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', start))
# dp.add_handler(CommandHandler('poll', poll))
dp.add_handler(CommandHandler('quiz', BOT.custom_quiz))
# dp.add_handler(CommandHandler('next-question', BOT.custom_quiz))
# dp.add_handler(PollHandler(receive_quiz_answer))
# dp.add_handler(CommandHandler('preview', preview))
# dp.add_handler(MessageHandler(Filters.poll, receive_poll))
# dp.add_handler(CommandHandler('help', help_handler))
# dp.add_handler(PollAnswerHandler(receive_poll_answer))
dp.add_handler(PollAnswerHandler(BOT.custom_quiz_handler))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def test_slot_behaviour(self, mro_slots):
handler = PollAnswerHandler(self.callback)
for attr in handler.__slots__:
assert getattr(handler, attr,
"err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(handler)) == len(set(
mro_slots(handler))), "duplicate slot"
def initialize_bot(self, is_env):
updater = Updater(token=self.TOKEN, use_context=True)
dispatcher = updater.dispatcher
self.foo = dispatcher
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=logging.INFO,
)
start_handler = CommandHandler("start", self.start)
dispatcher.add_handler(start_handler)
askdelete_handler = MessageHandler(
Filters.regex("^@" + updater.bot.username + "$"), self.askdelete)
askdelete_ban_handler = MessageHandler(
Filters.regex("^@" + updater.bot.username + " ban$"),
self.askdelete_ban)
set_handler = CommandHandler("settings", self.set_cmd)
dispatcher.add_handler(askdelete_handler)
dispatcher.add_handler(askdelete_ban_handler)
dispatcher.add_handler(PollAnswerHandler(self.receive_poll_answer))
dispatcher.add_handler(PollHandler(self.delete))
dispatcher.add_handler(set_handler)
dispatcher.add_handler(CallbackQueryHandler(self.query_func))
if is_env:
updater.start_webhook(
listen="0.0.0.0",
# (c) https://t.me/c/1186975633/22915
port=self.config.port,
url_path=self.config.bot_api,
)
updater.bot.set_webhook(url=self.config.url + self.config.bot_api)
else:
updater.start_polling()
def addPreOrderHandlersTo(dispatcher):
# Build handlers
start_conv = ConversationHandler(
entry_points=[CommandHandler("LetsMakan", LetsMakan)],
states={sub_1: [CallbackQueryHandler(LetsMakan_helper)]},
fallbacks=[CommandHandler("cancel", Cancel)],
per_user=True,
per_chat=False)
end_conv = ConversationHandler(
entry_points=[CommandHandler("EndMakan", EndMakan)],
states={
sub_1: [
MessageHandler(
Filters.regex('^Confirm plus chop$')
| Filters.regex('^Hol up$'), EndMakan_helper)
],
sub_2: [MessageHandler(Filters.regex('^[0-9]*$'), save_phone)],
sub_3: [CallbackQueryHandler(save_address)],
},
fallbacks=[CommandHandler("cancel", Cancel)],
per_user=True,
per_chat=False)
# Add to dispatcher
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(start_conv)
dispatcher.add_handler(end_conv)
dispatcher.add_handler(CommandHandler("cancelmakan", CancelMakan))
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater(TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
# Start the Bot
#updater.start_polling()
#added to deploy to heroku
updater.start_webhook(listen="0.0.0.0",
port=int(PORT),
url_path=TOKEN,
webhook_url='https://cawpawbot.herokuapp.com/' +
TOKEN)
#updater.bot.setWebhook(webhook_url='https://cawpawbot.herokuapp.com/'+TOKEN)
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
async def test_context(self, app, poll_answer):
handler = PollAnswerHandler(self.callback)
app.add_handler(handler)
async with app:
await app.process_update(poll_answer)
assert self.test_flag
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(TOKEN, use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("update", update_scores))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(Filters.text, mensaje_handler))
dp.add_handler(PollAnswerHandler(receive_poll_answer))
# log all errors
dp.add_error_handler(error)
# Start the Bot
# updater.start_webhook(listen="0.0.0.0",
# port=int(PORT),
# url_path=TOKEN)
# updater.bot.setWebhook('https://botteelgramajedrez.herokuapp.com/' + TOKEN)
# 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
# is non-blocking and will stop the bot gracefully.
updater.start_polling()
updater.idle()
def main(updater: Updater):
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater('963449057:AAHIO6AWfT9SoM6davoXBr2Y1TdRd9eROnQ')
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_bot))
dispatcher.add_handler(CommandHandler('close', close))
updater.start_polling()
updater.idle()
def main():
# Create the Updater and pass it your bot's token.
updater = Updater(os.getenv("TOKEN"), use_context=True)
# Get the dispatcher to register handlers
dp = updater.dispatcher
dp.add_handler(CommandHandler("help", help))
dp.add_handler(PollAnswerHandler(receive_poll_answer))
dp.add_handler(CallbackQueryHandler(help_button, pattern="^help_[0-9]$"))
# Setup conversation handler with the states FIRST and SECOND
# Use the pattern parameter to pass CallbackQueries with specific
# data pattern to the corresponding handlers.
# ^ means "start of line/string"
# $ means "end of line/string"
# So ^ABC$ will only allow 'ABC'
conv_handler = ConversationHandler(
entry_points=[CommandHandler("start", start)],
states={
CLOSED: [
CallbackQueryHandler(question_with_options,
pattern="^closed_[0-9]+$"),
CallbackQueryHandler(end, pattern="^survey_finish$"),
],
OPEN: [
CallbackQueryHandler(question_without_options,
pattern="^open_[0-9]+$"),
],
REGULAR_ANSWER: [
MessageHandler(Filters.regex("^(?!/).*"), regular_answer),
],
},
fallbacks=[
CommandHandler("start", start),
MessageHandler(Filters.regex("^(?!/).*"), edited),
],
)
# Add ConversationHandler to dispatcher that will be used for handling
# updates
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 start(self):
updater = Updater(self.token, use_context=True)
always_available_handlers = [
CommandHandler("add_me", self.add_me_command),
CommandHandler("remove_me", self.remove_me_command),
CommandHandler("scores", self.scores_command)
]
dispatcher = updater.dispatcher
dispatcher.add_handler(
ConversationHandler(
entry_points=[CommandHandler("start", self.start_command)],
states={
Bot.State.INIT_STATE: [
CommandHandler("start_game", self.start_game_command),
*always_available_handlers
],
Bot.State.WAIT_ANS: [
CommandHandler("skip", self.skip_command),
CommandHandler("vote", self.vote_command),
*always_available_handlers
],
Bot.State.WAIT_VOTE: [
CommandHandler("results", self.results_command),
*always_available_handlers
],
Bot.State.ROUND_FINISH: [
CommandHandler("next", self.next_command),
*always_available_handlers
],
},
state_entry_callbacks={
ConversationHandler.END: self.end_state_entry
},
state_reentry_callback={
Bot.State.WAIT_ANS: self.wait_ans_entry
},
fallbacks=[
CommandHandler("stop_game", self.stop_game_command)
],
per_chat=True,
per_user=False,
per_message=False,
allow_reentry=True,
))
dispatcher.add_handler(PollAnswerHandler(self.vote_poll_answer))
dispatcher.add_handler(
MessageHandler(Filters.chat_type.private,
self.receive_description_from_user))
updater.start_polling()
updater.idle()
def run(self) -> None:
self.dispatcher.add_handler(
CommandHandler('start', self.selectLanguagePoll))
self.dispatcher.add_handler(
PollAnswerHandler(self.receive_language_poll_answer))
print("selected_language = " + str(self.selected_language) + "\n")
Q.selectLang(self.selected_language + 1)
Q.ask(Q.langs[0], Q.langs[1])
self.dispatcher.add_handler(CommandHandler('quiz', self.quiz))
self.dispatcher.add_handler(PollAnswerHandler(
self.receive_quiz_answer))
self.dispatcher.add_handler(CommandHandler('preview', self.preview))
self.dispatcher.add_handler(
MessageHandler(Filters.poll, self.receive_poll))
self.dispatcher.add_handler(CommandHandler('help', self.help_handler))
# Start the Bot
self.updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
self.updater.idle()
def test_pass_user_or_chat_data(self, dp, poll_answer):
handler = PollAnswerHandler(self.callback_data_1, pass_user_data=True)
dp.add_handler(handler)
dp.process_update(poll_answer)
assert self.test_flag
dp.remove_handler(handler)
handler = PollAnswerHandler(self.callback_data_1, pass_chat_data=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll_answer)
assert self.test_flag
dp.remove_handler(handler)
handler = PollAnswerHandler(self.callback_data_2,
pass_chat_data=True,
pass_user_data=True)
dp.add_handler(handler)
self.test_flag = False
dp.process_update(poll_answer)
assert self.test_flag
def main() -> None:
# load environment variables
# config = dotenv_values(".env")
load_dotenv()
updater = Updater(token=os.environ["TRANSCRIBEBOT_TELEGRAM_TOKEN"], use_context=True)
dispatcher: Dispatcher = updater.dispatcher
# add handlers
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(MessageHandler(ZockenFilter(), make_poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
# start polling
updater.start_polling()
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater("1533382326:AAF1z4pEVZTzfxBppjX7QUAyVOwUFaNgU88")
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('bet', poll))
dispatcher.add_handler(CommandHandler('get_stat', get_stat))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main() -> None:
# 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(__TOKEN__, use_context=True)
job = updater.job_queue
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('cook', cook))
dispatcher.add_handler(CommandHandler('bd', bd))
dispatcher.add_handler(MessageHandler(Filters.text, kovra))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
dispatcher.add_handler(CommandHandler("set", set_timer))
dispatcher.add_handler(CommandHandler("unset", unset))
dispatcher.add_handler(CommandHandler("news", news))
dispatcher.add_handler(CommandHandler('coinflip', coinflip,
pass_args=True))
dispatcher.add_handler(
CommandHandler('random', random_number, pass_args=True))
target_time = datetime.time(hour=8, minute=0)
news_time = datetime.time(hour=6, minute=12)
joke_time = datetime.time(hour=6, minute=0)
picture_time = datetime.time(hour=6, minute=6)
horoscope_time = datetime.time(hour=5, minute=55)
job.run_daily(daily_job, target_time, days=range(7))
job.run_daily(daily_news, news_time, days=range(7))
job.run_daily(daily_joke, joke_time, days=range(7))
job.run_daily(daily_pciture, picture_time, days=range(7))
job.run_daily(daily_horoscope, horoscope_time, days=range(7))
# on noncommand i.e message - echo the message on Telegram
#dispatcher.add_handler(MessageHandler(Filters.text, echo))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater("1733062635:AAEfN_XL5R5x7ZOfBaQjw_Wu0eGLcejHS-o")
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(CommandHandler('quiz', quiz))
dispatcher.add_handler(PollHandler(receive_quiz_answer))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(MessageHandler(Filters.poll, receive_poll))
dispatcher.add_handler(CommandHandler('help', help_handler))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def main():
# Создаем экземпляр Updater и передаем токен бота.
updater = Updater(get_settings()['bot_token'])
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start))
# dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(CommandHandler('results', results))
dispatcher.add_handler(CommandHandler('startcrawler', start_crawler_run))
dispatcher.add_handler(CommandHandler('stopcrawler', stop_crawler))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
# dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(CommandHandler('help', help_handler))
# Старт бота
updater.start_polling()
# Запускаем бота до тех пор, пока пользователь не нажмет Ctrl-C или процесс не получит SIGINT
# SIGTERM или SIGABRT
updater.idle()
def main():
# Initiate the bot and add command handler
updater = Updater(os.environ.get("BOT_KEY"), use_context=True)
updater.dispatcher.add_handler(CommandHandler('newword', send_word))
updater.dispatcher.add_handler(CommandHandler('setsource', set_source))
updater.dispatcher.add_handler(CommandHandler('setdestination', set_dest))
updater.dispatcher.add_handler(CommandHandler('source', source))
updater.dispatcher.add_handler(CommandHandler('dest', dest))
updater.dispatcher.add_handler(CommandHandler('transcribe', transcribe))
updater.dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
updater.dispatcher.add_handler(MessageHandler(Filters.voice, voice_handler))
# Run the bot
updater.start_polling()
updater.idle()
def main():
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('bop', bop))
dispatcher.add_handler(CommandHandler('start', start))
echo_handler = MessageHandler(Filters.text & (~Filters.command), echo)
dispatcher.add_handler(echo_handler)
dispatcher.add_handler(CommandHandler('caps', caps))
dispatcher.add_handler(CommandHandler('help', help))
dispatcher.add_handler(CommandHandler('get_amazon', get_amazon))
dispatcher.add_handler(CommandHandler('preview', preview))
dispatcher.add_handler(CommandHandler('poll', poll))
dispatcher.add_handler(PollAnswerHandler(receive_poll_answer))
dispatcher.add_handler(InlineQueryHandler(inline_caps))
dispatcher.add_handler(MessageHandler(Filters.command, unknown))
updater.start_polling()
updater.idle()
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(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', start))
dp.add_handler(CommandHandler('poll', poll))
dp.add_handler(PollAnswerHandler(receive_poll_answer))
dp.add_handler(CommandHandler('quiz', quiz))
dp.add_handler(PollHandler(receive_quiz_answer))
dp.add_handler(CommandHandler('preview', preview))
dp.add_handler(MessageHandler(Filters.poll, receive_poll))
dp.add_handler(CommandHandler('help', help_handler))
# Start the Bot
updater.start_polling()
# Run the bot until the user presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT
updater.idle()
def __init__(self):
"""
Setup Telegram Bot instance
Register command handler
"""
self.updater = Updater(TELEGRAM_SECRET_TOKEN, use_context=True)
# Get the dispatcher to register handlers
dp = self.updater.dispatcher
# log all errors
dp.add_error_handler(self.error)
for c in self.commands:
dp.add_handler(CommandHandler(c['cmd'], getattr(self, c['func'])))
# handle poll answers
dp.add_handler(PollAnswerHandler(self.receive_poll_answer))
# Button Handler
# self.updater.dispatcher.add_handler(CallbackQueryHandler(self.button))
# Start the Bot
self.updater.start_polling()
def main(self):
req = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
self.bot = bot = Bot(token=self.tg_token, request=req)
updater = Updater(
bot=bot,
use_context=True,
)
# Проверить что бот корректно подключился к Telegram API
logging.info(bot.get_me())
# Навесить обработчики команд
add_movie_handler = ConversationHandler(
entry_points=[
CommandHandler('add', self.add_handler, pass_user_data=True),
],
states={
FIND_MOVIE: [
MessageHandler(Filters.all,
self.find_movie_handler,
pass_user_data=True),
],
FIND_DONE: [
CallbackQueryHandler(self.find_done_handler,
pass_user_data=True),
],
CHECK_SEQUEL: [
CallbackQueryHandler(self.check_sequel_handler,
pass_user_data=True),
],
FINNALY_DONE: [
CallbackQueryHandler(self.finally_find_done,
pass_user_data=True),
],
},
fallbacks=[
CommandHandler('cancel', self.cancel_handler),
],
)
viewlist_movie_handler = ConversationHandler(
entry_points=[
# CallbackQueryHandler(self.start_handler, pass_user_data=True),
CommandHandler('viewlist',
self.viewlist_handler,
pass_user_data=True),
],
states={
NEXT: [
CallbackQueryHandler(self.viewlist_next_handler,
pass_user_data=True),
],
DETAIL_VIEW: [
CallbackQueryHandler(self.viewlist_detail_handler,
pass_user_data=True),
],
FINAL_VIEW: [
CallbackQueryHandler(self.viewlist_filnal_handler,
pass_user_data=True),
],
},
fallbacks=[
CommandHandler('cancel', self.cancel_handler),
],
)
updater.dispatcher.add_handler(add_movie_handler)
updater.dispatcher.add_handler(viewlist_movie_handler)
updater.dispatcher.add_handler(
CommandHandler('create_poll', self.create_poll_handler))
updater.dispatcher.add_handler(
CommandHandler('who_income', self.create_poll_income))
updater.dispatcher.add_handler(
PollAnswerHandler(self.receive_poll_answer))
updater.dispatcher.add_handler(
CommandHandler('start', self.start_handler))
updater.dispatcher.add_handler(
CommandHandler('help', self.help_handler))
updater.dispatcher.add_handler(
CommandHandler('statistic', self.view_statistics))
updater.dispatcher.add_handler(
CommandHandler('normalno', self.normalno_handler))
updater.dispatcher.add_handler(
CommandHandler('rus_rulet', self.rus_rulet_handler))
updater.dispatcher.add_handler(
CommandHandler('get_rep_fys', self.get_rep_fys_handler))
updater.dispatcher.add_handler(
CommandHandler('insert_phrase', self.insert_main_phrase_handler))
updater.dispatcher.add_handler(
MessageHandler(Filters.text, self.all_message))
# Начать бесконечную обработку входящих сообщений
try:
updater.start_polling()
updater.idle()
except:
pass
def test_context(self, cdp, poll_answer):
handler = PollAnswerHandler(self.callback_context)
cdp.add_handler(handler)
cdp.process_update(poll_answer)
assert self.test_flag
def test_other_update_types(self, false_update):
handler = PollAnswerHandler(self.callback)
assert not handler.check_update(false_update)
def register_dispatcher(
updater: Updater,
admins: Union[int, List[int]],
chats: Union[int, List[int]],
default_settings: Dict,
gsheets_file: str,
gsheets_email: str,
) -> None:
dispatcher = updater.dispatcher
dispatcher.add_handler(TypeHandler(Update, access.check), group=-2)
dispatcher.add_handler(PollAnswerHandler(poll.collect_answer), group=-1)
# dispatcher.add_handler(InlineQueryHandler(inline.surveys))
dispatcher.add_handler(CommandHandler("add_admin", commands.add_admin))
dispatcher.add_handler(CommandHandler("add_chat", commands.add_chat))
dispatcher.add_handler(CommandHandler("help", commands.help))
dispatcher.add_handler(
CommandHandler("restart", partial(commands.restart, updater=updater)))
dispatcher.add_handler(
CommandHandler("remove_admin", commands.remove_admin))
dispatcher.add_handler(CommandHandler("remove_chat", commands.remove_chat))
dispatcher.add_handler(
CommandHandler("reset_ongoing", commands.reset_ongoing))
dispatcher.add_handler(CommandHandler("rotate_log", commands.rotate_log))
dispatcher.add_handler(
CommandHandler("show_chat_id", commands.show_chat_id))
dispatcher.add_handler(
CommandHandler("show_current_survey", commands.show_current_survey))
dispatcher.add_handler(CommandHandler("show_id", commands.show_id))
edit_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(
partial(edit.pick_part, source="compose"),
pattern="^{}$".format(cc.EDIT_SURVEY_COMPOSE_CB),
),
CallbackQueryHandler(
partial(edit.pick_part, source="manage"),
pattern="^{}$".format(cc.EDIT_SURVEY_MANAGE_CB),
),
],
states={
cc.PICK_PART_STATE: [
CallbackQueryHandler(edit.title,
pattern="^{}$".format(cc.EDIT_TITLE_CB)),
CallbackQueryHandler(edit.desc,
pattern="^{}$".format(cc.EDIT_DESC_CB)),
CallbackQueryHandler(edit.pick_question,
pattern="^{}$".format(
cc.EDIT_QUESTIONS_CB)),
CallbackQueryHandler(edit.save_confirm,
pattern="^{}$".format(
cc.SAVE_AND_EXIT_CB)),
CallbackQueryHandler(edit.discard_confirm,
pattern="^{}$".format(
cc.DISCARD_AND_EXIT_CB)),
],
cc.EDIT_TITLE_STATE: [
CallbackQueryHandler(
partial(compose.get_title, mode="edit"),
pattern="^{}$".format(cc.NEW_TITLE_CB),
),
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(
cc.KEEP_CURRENT_TITLE_CB)),
],
cc.GET_TITLE_STATE:
[MessageHandler(filters.Filters.text, compose.save_title)],
cc.SAVE_TITLE_STATE: [
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.SAVE_TITLE_CB)),
CallbackQueryHandler(compose.get_title,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.EDIT_DESC_STATE: [
CallbackQueryHandler(compose.get_desc,
pattern="^{}$".format(cc.NEW_DESC_CB)),
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(
cc.KEEP_CURRENT_DESC_CB)),
],
cc.GET_DESC_STATE:
[MessageHandler(filters.Filters.text, compose.save_desc)],
cc.SAVE_DESC_STATE: [
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.SAVE_DESC_CB)),
CallbackQueryHandler(compose.get_desc,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.PICK_QUESTION_STATE: [
CallbackQueryHandler(edit.question, pattern="^\d+$"),
CallbackQueryHandler(
edit.pick_question,
pattern="^(prev page|next page|PAGENUM)$"),
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.RETURN_CB)),
],
cc.PICK_QUESTION_PART_STATE: [
CallbackQueryHandler(edit.question_text,
pattern="^{}$".format(
cc.EDIT_QUESTION_TEXT_CB)),
CallbackQueryHandler(edit.multi,
pattern="^{}$".format(cc.EDIT_MULTI_CB)),
CallbackQueryHandler(edit.answers,
pattern="^{}$".format(
cc.EDIT_ANSWERS_CB)),
CallbackQueryHandler(
edit.remove_question_confirm,
pattern="^{}$".format(cc.REMOVE_QUESTION_CB),
),
CallbackQueryHandler(edit.pick_question,
pattern="^{}$".format(cc.RETURN_CB)),
],
cc.EDIT_QUESTION_TEXT_STATE: [
CallbackQueryHandler(
partial(compose.get_question, mode="edit"),
pattern="^{}$".format(cc.NEW_QUESTION_TEXT_CB),
),
CallbackQueryHandler(
edit.question,
pattern="^{}$".format(cc.KEEP_CURRENT_QUESTION_TEXT_CB),
),
CallbackQueryHandler(
edit.remove_question_confirm,
pattern="^{}$".format(cc.REMOVE_QUESTION_CB),
),
],
cc.GET_QUESTION_STATE: [
MessageHandler(filters.Filters.text,
partial(compose.save_question, mode="edit"))
],
cc.SAVE_QUESTION_STATE: [
CallbackQueryHandler(
partial(edit.save_result, result="question"),
pattern="^{}$".format(cc.SAVE_QUESTION_CB),
),
CallbackQueryHandler(
partial(compose.get_question, mode="edit"),
pattern="^{}$".format(cc.ENTER_AGAIN_CB),
),
],
cc.EDIT_MULTI_STATE: [
CallbackQueryHandler(
partial(compose.get_multi, mode="edit"),
pattern="^{}$".format(cc.NEW_MULTI_CB),
),
CallbackQueryHandler(edit.question,
pattern="^{}$".format(
cc.KEEP_CURRENT_MULTI_CB)),
],
cc.GET_MULTIANS_STATE: [
CallbackQueryHandler(
partial(compose.save_multi, multi=True, mode="edit"),
pattern="^{}$".format(cc.YES_CB),
),
CallbackQueryHandler(
partial(compose.save_multi, multi=False, mode="edit"),
pattern="^{}$".format(cc.NO_CB),
),
],
cc.SAVE_MULTIANS_STATE: [
CallbackQueryHandler(
partial(edit.save_result, result="multi"),
pattern="^{}$".format(cc.YES_CB),
),
CallbackQueryHandler(compose.get_multi,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.EDIT_ANSWERS_STATE: [
CallbackQueryHandler(edit.pick_answer,
pattern="^{}$".format(
cc.EDIT_EXISTING_ANSWER_CB)),
CallbackQueryHandler(
partial(compose.get_answer, mode="edit"),
pattern="^{}$".format(cc.ADD_NEW_ANSWER_CB),
),
CallbackQueryHandler(edit.question,
pattern="^{}$".format(cc.RETURN_CB)),
],
cc.PICK_ANSWER_STATE: [
MessageHandler(filters.Filters.text, edit.answer),
CallbackQueryHandler(edit.question,
pattern="^{}$".format(cc.RETURN_CB)),
],
cc.EDIT_ANSWER_STATE: [
CallbackQueryHandler(
partial(compose.get_answer, mode="edit"),
pattern="^{}$".format(cc.EDIT_ANSWER_CB),
),
CallbackQueryHandler(
edit.remove_answer_confirm,
pattern="^{}$".format(cc.REMOVE_ANSWER_CB),
),
],
cc.GET_ANSWER_STATE: [
MessageHandler(filters.Filters.text,
partial(compose.save_answer, mode="edit"))
],
cc.SAVE_ANSWER_STATE: [
CallbackQueryHandler(
partial(edit.save_result, result="answers"),
pattern="^{}$".format(cc.SAVE_ANSWER_CB),
),
CallbackQueryHandler(
partial(compose.get_question, mode="edit"),
pattern="^{}$".format(cc.ENTER_AGAIN_CB),
),
],
cc.REMOVE_ANSWER_CONFIRM_STATE: [
CallbackQueryHandler(edit.remove_answer,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(edit.pick_answer,
pattern="^{}$".format(cc.NO_CB)),
],
cc.REMOVE_QUESTION_CONFIRM_STATE: [
CallbackQueryHandler(edit.remove_question,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(edit.question,
pattern="^{}$".format(cc.NO_CB)),
],
cc.EDIT_AFTER_SAVE_STATE: [
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.TO_PARTS_CB)),
CallbackQueryHandler(edit.pick_question,
pattern="^{}$".format(
cc.TO_QUESTIONS_CB)),
],
cc.SAVE_CONFIRM_STATE: [
CallbackQueryHandler(edit.save_changes,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.NO_CB)),
],
cc.DISCARD_CONFIRM_STATE: [
CallbackQueryHandler(edit.discard_changes,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(edit.pick_part,
pattern="^{}$".format(cc.NO_CB)),
],
},
fallbacks=[
CallbackQueryHandler(root.confirm_return_to_main,
pattern="^{}$".format(cc.RETURN_TO_MAIN_CB)),
],
map_to_parent={
cc.END_COMPOSE: cc.REVIEW_STATE,
cc.END_MANAGE: cc.MANAGE_SURVEYS_STATE,
cc.MAIN_MENU_STATE: cc.MAIN_MENU_STATE
},
)
compose_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(compose.get_title,
pattern="^{}$".format(cc.CREATE_SURVEY_CB))
],
states={
cc.GET_TITLE_STATE: [
MessageHandler(filters.Filters.text, compose.save_title),
CallbackQueryHandler(compose.return_to_step,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(compose.get_title,
pattern="^{}$".format(cc.NO_CB)),
],
cc.SAVE_TITLE_STATE: [
CallbackQueryHandler(compose.get_desc,
pattern="^{}$".format(cc.SAVE_TITLE_CB)),
CallbackQueryHandler(compose.get_title,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.GET_DESC_STATE:
[MessageHandler(filters.Filters.text, compose.save_desc)],
cc.SAVE_DESC_STATE: [
CallbackQueryHandler(compose.get_question,
pattern="^{}$".format(cc.SAVE_DESC_CB)),
CallbackQueryHandler(compose.get_desc,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.GET_QUESTION_STATE:
[MessageHandler(filters.Filters.text, compose.save_question)],
cc.SAVE_QUESTION_STATE: [
CallbackQueryHandler(compose.get_multi,
pattern="^{}$".format(
cc.SAVE_QUESTION_CB)),
CallbackQueryHandler(
partial(compose.get_question, returning=True),
pattern="^{}$".format(cc.ENTER_AGAIN_CB),
),
],
cc.GET_MULTIANS_STATE: [
CallbackQueryHandler(
partial(compose.save_multi, multi=True),
pattern="^{}$".format(cc.YES_CB),
),
CallbackQueryHandler(
partial(compose.save_multi, multi=False),
pattern="^{}$".format(cc.NO_CB),
),
],
cc.SAVE_MULTIANS_STATE: [
CallbackQueryHandler(compose.get_answer,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(compose.get_multi,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.GET_ANSWER_STATE:
[MessageHandler(filters.Filters.text, compose.save_answer)],
cc.SAVE_ANSWER_STATE: [
CallbackQueryHandler(compose.checkpoint,
pattern="^{}$".format(cc.SAVE_ANSWER_CB)),
CallbackQueryHandler(
partial(compose.get_answer, returning=True),
pattern="^{}$".format(cc.ENTER_AGAIN_CB),
),
],
cc.CHECKPOINT_STATE: [
CallbackQueryHandler(compose.get_answer,
pattern="^{}$".format(cc.NEXT_ANSWER_CB)),
CallbackQueryHandler(compose.get_question,
pattern="^{}$".format(
cc.NEXT_QUESTION_CB)),
CallbackQueryHandler(compose.review,
pattern="^{}$".format(
cc.FINISH_CREATING_CB)),
],
cc.REVIEW_STATE: [
CallbackQueryHandler(compose.finish,
pattern="^{}$".format(
cc.CREATION_COMPLETE_CB)),
edit_conv,
],
cc.START_OVER_STATE: [
CallbackQueryHandler(compose.get_title,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(
partial(compose.review, returning=True),
pattern="^{}$".format(cc.NO_CB),
),
],
},
fallbacks=[CommandHandler("start", root.start)],
map_to_parent={
cc.END: cc.START_STATE,
cc.START_STATE: cc.START_STATE,
cc.MAIN_MENU_STATE: cc.MAIN_MENU_STATE,
},
)
manage_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(manage.start,
pattern="^{}$".format(cc.MANAGE_SURVEYS_CB))
],
states={
cc.MANAGE_SURVEYS_STATE: [
compose_conv,
CallbackQueryHandler(manage.pick,
pattern="^{}$".format(
cc.CHOOSE_SURVEY_CB)),
],
cc.MANAGE_PICK_SURVEY_STATE: [
CallbackQueryHandler(manage.survey, pattern="^\d+$"),
CallbackQueryHandler(
manage.pick, pattern="^(prev page|next page|PAGENUM)$"),
compose_conv,
],
cc.MANAGE_SURVEY_STATE: [
edit_conv,
CallbackQueryHandler(
manage.confirm_delete,
pattern="^{}$".format(cc.MANAGE_DELETE_SURVEY_CB),
),
CallbackQueryHandler(manage.print_survey,
pattern="^{}$".format(
cc.PRINT_SURVEY_CB)),
],
cc.MANAGE_DELETE_CONFIRM_STATE: [
CallbackQueryHandler(manage.delete,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(manage.survey,
pattern="^{}$".format(cc.NO_CB)),
],
cc.MANAGE_AFTER_DELETE_STATE: [
CallbackQueryHandler(manage.pick,
pattern="^{}$".format(
cc.CHOOSE_SURVEY_CB))
],
cc.MAIN_MENU_STATE: [
CallbackQueryHandler(root.start,
pattern="^{}$".format(cc.YES_CB)),
CallbackQueryHandler(manage.start,
pattern="^{}$".format(cc.NO_CB)),
],
},
fallbacks=[
CallbackQueryHandler(root.confirm_return_to_main,
pattern="^{}$".format(cc.RETURN_TO_MAIN_CB))
],
map_to_parent={
cc.START_STATE: cc.START_STATE,
cc.MAIN_MENU_STATE: cc.MAIN_MENU_STATE,
},
)
settings_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(settings.pick,
pattern="^{}$".format(cc.SETTINGS_CB))
],
states={
cc.PICK_SETTING_STATE: [
CallbackQueryHandler(settings.lang,
pattern="^{}$".format(
cc.SETTINGS_LANG_CB)),
CallbackQueryHandler(settings.page_len,
pattern="^{}$".format(
cc.SETTINGS_PAGE_LEN_CB)),
CallbackQueryHandler(settings.row_len,
pattern="^{}$".format(
cc.SETTINGS_ROW_LEN_CB)),
],
cc.SETTINGS_PAGE_LEN_STATE: [
CallbackQueryHandler(
partial(settings.change_setting, setting="page_len"),
pattern="^\d+$",
),
CallbackQueryHandler(settings.pick,
pattern="^{}$".format(cc.RETURN_CB)),
],
cc.SETTINGS_ROW_LEN_STATE: [
CallbackQueryHandler(partial(settings.change_setting,
setting="row_len"),
pattern="^\d+$"),
CallbackQueryHandler(settings.pick,
pattern="^{}$".format(cc.RETURN_CB)),
],
},
fallbacks=[],
map_to_parent={
cc.SETTINGS_LANG_STATE: cc.LANG_STATE,
cc.MAIN_MENU_STATE: cc.MAIN_MENU_STATE,
},
)
poll_conv = ConversationHandler(
entry_points=[
CallbackQueryHandler(poll.pick_survey,
pattern="^{}$".format(cc.START_SURVEY_CB))
],
states={
cc.POLL_PICK_STATE: [
CallbackQueryHandler(poll.preview, pattern="^\d+$"),
CallbackQueryHandler(
poll.pick_survey,
pattern="^(prev page|next page|PAGENUM)$"),
compose_conv,
],
cc.POLL_PREVIEW_STATE: [
CallbackQueryHandler(poll.pick_chat,
pattern="^{}$".format(cc.PICK_CHAT_CB)),
CallbackQueryHandler(poll.pick_survey,
pattern="^{}$".format(
cc.CHOOSE_SURVEY_CB)),
],
cc.PICK_CHAT_STATE: [
CallbackQueryHandler(poll.set_cap, pattern="^\d+$"),
CallbackQueryHandler(
poll.pick_chat, pattern="^(prev page|next page|PAGENUM)$"),
],
cc.SET_CAP_STATE: [
CallbackQueryHandler(poll.confirm,
pattern="^{}$".format(
cc.USE_RECOMMENDED_CB)),
CallbackQueryHandler(poll.get_cap,
pattern="^{}$".format(cc.SET_OWN_CAP_CB)),
],
cc.GET_CAP_STATE:
[MessageHandler(filters.Filters.text, poll.validate_cap)],
cc.VALIDATE_CAP_STATE: [
CallbackQueryHandler(poll.confirm,
pattern="^{}$".format(
cc.USE_RECOMMENDED_CB)),
CallbackQueryHandler(poll.confirm,
pattern="^{}$".format(cc.USE_CUSTOM_CB)),
CallbackQueryHandler(poll.get_cap,
pattern="^{}$".format(cc.ENTER_AGAIN_CB)),
],
cc.POLL_CONFIRM_STATE: [
CallbackQueryHandler(poll.launch,
pattern="^{}$".format(
cc.START_SURVEY_CB)),
CallbackQueryHandler(poll.pick_survey,
pattern="^{}$".format(
cc.CHANGE_SURVEY_CB)),
CallbackQueryHandler(poll.pick_chat,
pattern="^{}$".format(cc.CHANGE_CHAT_CB)),
CallbackQueryHandler(poll.set_cap,
pattern="^{}$".format(cc.CHANGE_CAP_CB)),
],
},
fallbacks=[
CallbackQueryHandler(root.confirm_return_to_main,
pattern="^{}$".format(cc.RETURN_TO_MAIN_CB))
],
map_to_parent={
cc.START_STATE: cc.START_STATE,
cc.MAIN_MENU_STATE: cc.MAIN_MENU_STATE,
},
)
main_conv = ConversationHandler(
entry_points=[CommandHandler("start", root.start)],
states={
cc.LANG_STATE: [
CallbackQueryHandler(
partial(commands.set_lang, lang="ru"),
pattern="^{}$".format(cc.RU_CB),
),
CallbackQueryHandler(
partial(commands.set_lang, lang="en"),
pattern="^{}$".format(cc.EN_CB),
),
],
cc.START_STATE: [poll_conv, manage_conv, settings_conv],
cc.MAIN_MENU_STATE: [
CallbackQueryHandler(root.start,
pattern="^{}$".format(cc.YES_CB))
],
},
fallbacks=[
CallbackQueryHandler(root.to_prev_step,
pattern="^{}$".format(cc.RETURN_CB)),
CallbackQueryHandler(root.confirm_return_to_main,
pattern="^{}$".format(cc.RETURN_TO_MAIN_CB)),
CommandHandler("start", root.start),
],
)
dispatcher.add_handler(main_conv)
bot_data = dispatcher.bot_data
if not bot_data.get(consts.SURVEYS_KEY):
bot_data[consts.SURVEYS_KEY] = []
if not bot_data.get(consts.ADMINS_KEY):
bot_data[consts.ADMINS_KEY] = admins
if not bot_data.get(consts.SHEETS_KEY):
bot_data[consts.SHEETS_KEY] = {
"file": gsheets_file,
"email": gsheets_email
}
if not bot_data.get(consts.CHATS_KEY):
bot_data[consts.CHATS_KEY] = chats
if (not bot_data.get(consts.DEFAULTS_KEY)
or bot_data[consts.DEFAULTS_KEY] != default_settings):
bot_data[consts.DEFAULTS_KEY] = default_settings