def register(dispatcher: Dispatcher) -> None:
start_schedule = ConversationHandler(
entry_points=[RegexHandler(START_KEYBOARD[0][0], on_schedule)],
states={
SCHEDULE: [
RegexHandler(SCHEDULE_KEYBOARD[1][0], on_week),
RegexHandler(SCHEDULE_KEYBOARD[0][0], on_day),
RegexHandler(SCHEDULE_KEYBOARD[0][1], on_tomorrow),
RegexHandler(BACK_KEY[0], on_back),
# RegexHandler(TRIGGERS['all'], on_spam)
],
DAY_OF_WEEK: [MessageHandler(Filters.text, choose_dow)]
},
fallbacks=[CommandHandler('start', start)])
dispatcher.add_handler(start_schedule)
def register(dispatcher: Dispatcher) -> None:
settings = ConversationHandler(
entry_points=[
RegexHandler(START_KEYBOARD[1][0], on_settings),
CommandHandler('settings', on_settings)
],
states={
ASK_EMAIL: [MessageHandler(Filters.text, get_email)],
ASK_CITY: [MessageHandler(Filters.text, get_city)],
SETTINGS: [MessageHandler(Filters.text, choose_menu)]
},
fallbacks=(CommandHandler('start', start), )
)
dispatcher.add_handler(settings)
dispatcher.add_handler(CommandHandler('help', show_about))
def test_non_context_deprecation(self, dp):
with pytest.warns(TelegramDeprecationWarning):
Dispatcher(dp.bot,
dp.update_queue,
job_queue=dp.job_queue,
workers=0,
use_context=False)
def test_error_while_saving_chat_data(self, dp, bot):
increment = []
class OwnPersistence(BasePersistence):
def __init__(self):
super(BasePersistence, self).__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
def get_bot_data(self):
return dict()
def update_bot_data(self, data):
raise Exception
def get_chat_data(self):
return defaultdict(dict)
def update_chat_data(self, chat_id, data):
raise Exception
def get_user_data(self):
return defaultdict(dict)
def update_user_data(self, user_id, data):
raise Exception
def start1(b, u):
pass
def error(b, u, e):
increment.append("error")
# If updating a user_data or chat_data from a persistence object throws an error,
# the error handler should catch it
update = Update(1,
message=Message(1,
User(1, "Test", False),
None,
Chat(1, "lala"),
text='/start',
entities=[
MessageEntity(
type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot))
my_persistence = OwnPersistence()
dp = Dispatcher(bot, None, persistence=my_persistence)
dp.add_handler(CommandHandler('start', start1))
dp.add_error_handler(error)
dp.process_update(update)
assert increment == ["error", "error", "error"]
def test_construction_with_bad_persistence(self, caplog, bot):
class my_per:
def __init__(self):
self.store_user_data = False
self.store_chat_data = False
with pytest.raises(TypeError,
match='persistence should be based on telegram.ext.BasePersistence'):
Dispatcher(bot, None, persistence=my_per())
def test_less_than_one_worker_warning(self, dp, recwarn):
Dispatcher(dp.bot,
dp.update_queue,
job_queue=dp.job_queue,
workers=0,
use_context=True)
assert len(recwarn) == 1
assert (
str(recwarn[0].message) ==
'Asynchronous callbacks can not be processed without at least one worker thread.'
)
def _setup():
bot = Bot(settings.BOT_TOKEN)
d = Dispatcher(bot, None, workers=0)
d.add_handler(CommandHandler("bets", bets))
d.add_handler(CommandHandler("help", help))
d.add_handler(CommandHandler("start", start))
d.add_handler(bet_conv_handler)
return d
def register(dispatcher: Dispatcher) -> None:
start_admin = ConversationHandler(
entry_points=[
CommandHandler('mail', whom_to_send, pass_user_data=True)
],
states={
WHOM_TO_SEND: [
MessageHandler(Filters.text, recipients, pass_user_data=True)
],
PREPARE_MAILING: [
RegexHandler(BACK_KEY[0], recipients, pass_user_data=True),
MessageHandler(
Filters.text,
prepare_mailing,
pass_user_data=True
)
],
},
fallbacks=[CommandHandler('start', start)]
)
dispatcher.add_handler(start_admin)
def test_custom_context_init(self, bot):
cc = ContextTypes(
context=CustomContext,
user_data=int,
chat_data=float,
bot_data=complex,
)
dispatcher = Dispatcher(bot, Queue(), context_types=cc)
assert isinstance(dispatcher.user_data[1], int)
assert isinstance(dispatcher.chat_data[1], float)
assert isinstance(dispatcher.bot_data, complex)
def test_custom_context_error_handler(self, bot):
def error_handler(_, context):
self.received = (
type(context),
type(context.user_data),
type(context.chat_data),
type(context.bot_data),
)
dispatcher = Dispatcher(
bot,
Queue(),
context_types=ContextTypes(context=CustomContext,
bot_data=int,
user_data=float,
chat_data=complex),
)
dispatcher.add_error_handler(error_handler)
dispatcher.add_handler(
MessageHandler(Filters.all, self.callback_raise_error))
dispatcher.process_update(self.message_update)
sleep(0.1)
assert self.received == (CustomContext, float, complex, int)
def add_news_handlers(dispatcher:Dispatcher):
dispatcher.add_handler(CommandHandler("news", news))
return
def add_email_handlers(dispatcher:Dispatcher):
dispatcher.add_handler(email_conv_handler)
dispatcher.add_handler(CommandHandler("mymailtemplates", show_email_templates))
return
def add_stock_handlers(dispatcher:Dispatcher):
dispatcher.add_handler(CommandHandler("stock", stock))
dispatcher.add_handler(CommandHandler("deletestockalert", delete_stock_alert))
dispatcher.add_handler(stock_alert_conv_handler)
return
def add_common_handlers(dispatcher: Dispatcher):
dispatcher.add_handler(CommandHandler("help", help))
dispatcher.add_handler(CommandHandler("start", start))
return
def add_handlers(dispatcher: Dispatcher):
dispatcher.add_handler(
CommandHandler('hw', handle_hw, Filters.private, pass_user_data=True))
dispatcher.add_handler(CallbackQueryHandler(on_choose,
pass_user_data=True))
def register(dispatcher: Dispatcher) -> None:
registration = ConversationHandler(
entry_points=[RegexHandler(REGISTER_KEYBOARD[0][0], ask_email)],
states={
ASK_EMAIL:
[MessageHandler(Filters.text, get_email, pass_user_data=True)],
ASK_CITY: [
MessageHandler(Filters.text,
lambda bot, update, user_data: get_city(
bot, update, user_data, verbose=True),
pass_user_data=True)
],
},
fallbacks=(CommandHandler('start', start), ))
dispatcher.add_handler(CommandHandler('about', show_about))
dispatcher.add_handler(CommandHandler('stop', on_stop))
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(registration)
dispatcher.add_handler(RegexHandler(REGISTER_KEYBOARD[1][0], show_about))
dispatcher.add_handler(RegexHandler(TRIGGERS['info'], show_about))
def telegram_dispatcher_callback():
dispatcher = Dispatcher.get_instance()
update = Update.de_json(update_message_text, dispatcher.bot)
dispatcher.process_update(update)
def clear_dispatcher():
"""Clear the singleton that telegram.ext.dispatcher.Dispatcher sets on itself."""
yield
Dispatcher._set_singleton(None)
# This is how python-telegram-bot resets the dispatcher in their test suite
Dispatcher._Dispatcher__singleton_semaphore.release()
