async def test_invalid_json_string_given(self): bad_user_data = '["this", "is", "json"]' bad_chat_data = '["this", "is", "json"]' bad_bot_data = '["this", "is", "json"]' bad_conversations = '["this", "is", "json"]' bad_callback_data_1 = '[[["str", 3.14, {"di": "ct"}]], "is"]' bad_callback_data_2 = '[[["str", "non-float", {"di": "ct"}]], {"di": "ct"}]' bad_callback_data_3 = '[[[{"not": "a str"}, 3.14, {"di": "ct"}]], {"di": "ct"}]' bad_callback_data_4 = '[[["wrong", "length"]], {"di": "ct"}]' bad_callback_data_5 = '["this", "is", "json"]' with pytest.raises(TypeError, match="user_data"): DictPersistence(user_data_json=bad_user_data) with pytest.raises(TypeError, match="chat_data"): DictPersistence(chat_data_json=bad_chat_data) with pytest.raises(TypeError, match="bot_data"): DictPersistence(bot_data_json=bad_bot_data) for bad_callback_data in [ bad_callback_data_1, bad_callback_data_2, bad_callback_data_3, bad_callback_data_4, bad_callback_data_5, ]: with pytest.raises(TypeError, match="callback_data"): DictPersistence(callback_data_json=bad_callback_data) with pytest.raises(TypeError, match="conversations"): DictPersistence(conversations_json=bad_conversations)
def test_bad_json_string_given(self): bad_user_data = 'thisisnojson99900()))(' bad_chat_data = 'thisisnojson99900()))(' bad_conversations = 'thisisnojson99900()))(' with pytest.raises(TypeError, match='user_data'): DictPersistence(user_data_json=bad_user_data) with pytest.raises(TypeError, match='chat_data'): DictPersistence(chat_data_json=bad_chat_data) with pytest.raises(TypeError, match='conversations'): DictPersistence(conversations_json=bad_conversations)
def test_invalid_json_string_given(self, pickle_persistence, bad_pickle_files): bad_user_data = '["this", "is", "json"]' bad_chat_data = '["this", "is", "json"]' bad_conversations = '["this", "is", "json"]' with pytest.raises(TypeError, match='user_data'): DictPersistence(user_data_json=bad_user_data) with pytest.raises(TypeError, match='chat_data'): DictPersistence(chat_data_json=bad_chat_data) with pytest.raises(TypeError, match='conversations'): DictPersistence(conversations_json=bad_conversations)
def test_json_changes(self, user_data, user_data_json, chat_data, chat_data_json, conversations, conversations_json): dict_persistence = DictPersistence( user_data_json=user_data_json, chat_data_json=chat_data_json, conversations_json=conversations_json) user_data_two = user_data.copy() user_data_two.update({4: {5: 6}}) dict_persistence.update_user_data(4, {5: 6}) assert dict_persistence.user_data == user_data_two assert dict_persistence.user_data_json != user_data_json assert dict_persistence.user_data_json == json.dumps(user_data_two) chat_data_two = chat_data.copy() chat_data_two.update({7: {8: 9}}) dict_persistence.update_chat_data(7, {8: 9}) assert dict_persistence.chat_data == chat_data_two assert dict_persistence.chat_data_json != chat_data_json assert dict_persistence.chat_data_json == json.dumps(chat_data_two) conversations_two = conversations.copy() conversations_two.update({'name3': {(1, 2): 3}}) dict_persistence.update_conversation('name3', (1, 2), 3) assert dict_persistence.conversations == conversations_two assert dict_persistence.conversations_json != conversations_json assert dict_persistence.conversations_json == enocde_conversations_to_json( conversations_two)
async def test_bad_json_string_given(self): bad_user_data = "thisisnojson99900()))(" bad_chat_data = "thisisnojson99900()))(" bad_bot_data = "thisisnojson99900()))(" bad_callback_data = "thisisnojson99900()))(" bad_conversations = "thisisnojson99900()))(" with pytest.raises(TypeError, match="user_data"): DictPersistence(user_data_json=bad_user_data) with pytest.raises(TypeError, match="chat_data"): DictPersistence(chat_data_json=bad_chat_data) with pytest.raises(TypeError, match="bot_data"): DictPersistence(bot_data_json=bad_bot_data) with pytest.raises(TypeError, match="callback_data"): DictPersistence(callback_data_json=bad_callback_data) with pytest.raises(TypeError, match="conversations"): DictPersistence(conversations_json=bad_conversations)
async def test_no_data_on_init(self, bot_data, user_data, chat_data, conversations, callback_data): dict_persistence = DictPersistence() assert dict_persistence.user_data is None assert dict_persistence.chat_data is None assert dict_persistence.bot_data is None assert dict_persistence.conversations is None assert dict_persistence.callback_data is None assert dict_persistence.user_data_json == "null" assert dict_persistence.chat_data_json == "null" assert dict_persistence.bot_data_json == "null" assert dict_persistence.conversations_json == "null" assert dict_persistence.callback_data_json == "null" await dict_persistence.update_bot_data(bot_data) await dict_persistence.update_user_data(12345, user_data[12345]) await dict_persistence.update_chat_data(-12345, chat_data[-12345]) await dict_persistence.update_conversation("name", (1, 1), "new_state") await dict_persistence.update_callback_data(callback_data) assert dict_persistence.user_data[12345] == user_data[12345] assert dict_persistence.chat_data[-12345] == chat_data[-12345] assert dict_persistence.bot_data == bot_data assert dict_persistence.conversations["name"] == {(1, 1): "new_state"} assert dict_persistence.callback_data == callback_data
async def test_slot_behaviour(self, mro_slots, recwarn): inst = DictPersistence() for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set( mro_slots(inst))), "duplicate slot"
def main(): # isso serve pra fazer a ligação com o telegram (?) upd = Updater(config['api_token'], use_context=True, persistence=DictPersistence(bot_data_json=botdb)) # coloca as funções GetNewEmails e autosave para rodarem periodicamente # tz = timezone tz = datetime.timezone(datetime.timedelta(days=-1, seconds=75600), '-03') upd.job_queue.run_repeating(getmail.GetNewEmails, interval=config['email_delay'], first=0) upd.job_queue.run_repeating(autosave, interval=config['autosave_interval'], first=0) # coloca os comandos seguintes disponíveis para o usuario upd.dispatcher.add_handler(CommandHandler('start', start)) upd.dispatcher.add_handler(CommandHandler('help', help_)) upd.dispatcher.add_handler(CommandHandler('quack', quack)) upd.dispatcher.add_handler(CommandHandler('aulas', manager.aulas)) upd.dispatcher.add_handler(CommandHandler('grupos', manager.grupos)) upd.dispatcher.add_handler(CommandHandler('edit', manager.edit)) # deixa rodando as coisas (??) upd.start_polling() upd.idle()
def test_with_conversationHandler(self, dp, update, conversations_json): dict_persistence = DictPersistence(conversations_json=conversations_json) dp.persistence = dict_persistence dp.use_context = True NEXT, NEXT2 = range(2) def start(update, context): return NEXT start = CommandHandler('start', start) def next(update, context): return NEXT2 next = MessageHandler(None, next) def next2(update, context): return ConversationHandler.END next2 = MessageHandler(None, next2) ch = ConversationHandler([start], {NEXT: [next], NEXT2: [next2]}, [], name='name2', persistent=True) dp.add_handler(ch) assert ch.conversations[ch._get_key(update)] == 1 dp.process_update(update) assert ch._get_key(update) not in ch.conversations update.message.text = '/start' update.message.entities = [MessageEntity(MessageEntity.BOT_COMMAND, 0, 6)] dp.process_update(update) assert ch.conversations[ch._get_key(update)] == 0 assert ch.conversations == dict_persistence.conversations['name2']
async def test_no_json_given(self): dict_persistence = DictPersistence() assert await dict_persistence.get_user_data() == {} assert await dict_persistence.get_chat_data() == {} assert await dict_persistence.get_bot_data() == {} assert await dict_persistence.get_callback_data() is None assert await dict_persistence.get_conversations("noname") == {}
def __init__(self, app=None, persistence=None): self.app = app self.persistence = persistence or DictPersistence() self.bot = None self.dispatcher = None if app is not None: self.init_app(app, persistence)
def test_json_outputs(self, user_data_json, chat_data_json, conversations_json): dict_persistence = DictPersistence( user_data_json=user_data_json, chat_data_json=chat_data_json, conversations_json=conversations_json) assert dict_persistence.user_data_json == user_data_json assert dict_persistence.chat_data_json == chat_data_json assert dict_persistence.conversations_json == conversations_json
def main(): bot_persistence = DictPersistence() updater = Updater(os.environ['SYNC_BOT_TOKEN'], persistence=bot_persistence, use_context=True) dp = updater.dispatcher conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], states={ CONFIGURE: [MessageHandler(Filters.regex('^(Done)$'), configure)], TYPING_REPLY: [MessageHandler(Filters.text, received_config_information)], CHOOSE_SERVER: [ MessageHandler(Filters.regex('^(Pick a server)$'), make_a_choice) ], TYPING_CHOICE: [MessageHandler(Filters.text, received_server_choice)], API_CALL: [ MessageHandler(Filters.regex('^(Server info)$'), show_current_server), MessageHandler(Filters.regex('^(Start all ACs)$'), start_sync_all), MessageHandler(Filters.regex('^(Start KMD)$'), start_kmd), MessageHandler(Filters.regex('^(Stop KMD)$'), stop_kmd), MessageHandler(Filters.regex('^(Available tickers)$'), get_available_tickers), MessageHandler(Filters.regex('^(Launch params)$'), dummy_func), MessageHandler(Filters.regex('^(Restart API)$'), dummy_func), MessageHandler(Filters.regex('^(Stop all ACs)$'), stop_sync_all), MessageHandler(Filters.regex('^(Get status)$'), get_current_sync_status), MessageHandler(Filters.regex('^(Change server)$'), make_a_choice), MessageHandler(Filters.document.mime_type("text/x-python"), dummy_func), CommandHandler('setup_binary', setup_binary), CommandHandler('start_sync', start_sync), CommandHandler('stop_sync', stop_sync) ], TYPING_CONFIRMATION: [ MessageHandler(Filters.regex('^(Yes)$'), cleanup), MessageHandler(Filters.regex('^(No)$'), no_cleanup) ], }, fallbacks=[ CommandHandler('help', help), CommandHandler('start', start) ]) dp.add_handler(conv_handler) dp.add_error_handler(error) updater.start_polling() updater.idle()
def test_with_handler(self, bot, update): dict_persistence = DictPersistence() u = Updater(bot=bot, persistence=dict_persistence, use_context=True) dp = u.dispatcher def first(update, context): if not context.user_data == {}: pytest.fail() if not context.chat_data == {}: pytest.fail() if not context.bot_data == {}: pytest.fail() context.user_data['test1'] = 'test2' context.chat_data[3] = 'test4' context.bot_data['test1'] = 'test2' def second(update, context): if not context.user_data['test1'] == 'test2': pytest.fail() if not context.chat_data[3] == 'test4': pytest.fail() if not context.bot_data['test1'] == 'test2': pytest.fail() h1 = MessageHandler(None, first, pass_user_data=True, pass_chat_data=True) h2 = MessageHandler(None, second, pass_user_data=True, pass_chat_data=True) dp.add_handler(h1) dp.process_update(update) del (dp) del (u) user_data = dict_persistence.user_data_json chat_data = dict_persistence.chat_data_json bot_data = dict_persistence.bot_data_json del (dict_persistence) dict_persistence_2 = DictPersistence(user_data_json=user_data, chat_data_json=chat_data, bot_data_json=bot_data) u = Updater(bot=bot, persistence=dict_persistence_2) dp = u.dispatcher dp.add_handler(h2) dp.process_update(update)
def test_dict_outputs(self, user_data, user_data_json, chat_data, chat_data_json, bot_data, bot_data_json, conversations, conversations_json): dict_persistence = DictPersistence(user_data_json=user_data_json, chat_data_json=chat_data_json, bot_data_json=bot_data_json, conversations_json=conversations_json) assert dict_persistence.user_data == user_data assert dict_persistence.chat_data == chat_data assert dict_persistence.bot_data == bot_data assert dict_persistence.conversations == conversations
def test_good_json_input(self, user_data_json, chat_data_json, conversations_json): dict_persistence = DictPersistence( user_data_json=user_data_json, chat_data_json=chat_data_json, conversations_json=conversations_json) user_data = dict_persistence.get_user_data() assert isinstance(user_data, defaultdict) assert user_data[12345]['test1'] == 'test2' assert user_data[67890][3] == 'test4' assert user_data[54321] == {} chat_data = dict_persistence.get_chat_data() assert isinstance(chat_data, defaultdict) assert chat_data[-12345]['test1'] == 'test2' assert chat_data[-67890][3] == 'test4' assert chat_data[-54321] == {} conversation1 = dict_persistence.get_conversations('name1') assert isinstance(conversation1, dict) assert conversation1[(123, 123)] == 3 assert conversation1[(456, 654)] == 4 with pytest.raises(KeyError): conversation1[(890, 890)] conversation2 = dict_persistence.get_conversations('name2') assert isinstance(conversation1, dict) assert conversation2[(123, 321)] == 1 assert conversation2[(890, 890)] == 2 with pytest.raises(KeyError): conversation2[(123, 123)]
async def test_no_json_dumping_if_data_did_not_change( self, bot_data, user_data, chat_data, conversations, callback_data, monkeypatch): dict_persistence = DictPersistence() await dict_persistence.update_bot_data(bot_data) await dict_persistence.update_user_data(12345, user_data[12345]) await dict_persistence.update_chat_data(-12345, chat_data[-12345]) await dict_persistence.update_conversation("name", (1, 1), "new_state") await dict_persistence.update_callback_data(callback_data) assert dict_persistence.user_data_json == json.dumps( {12345: user_data[12345]}) assert dict_persistence.chat_data_json == json.dumps( {-12345: chat_data[-12345]}) assert dict_persistence.bot_data_json == json.dumps(bot_data) assert (dict_persistence.conversations_json == DictPersistence._encode_conversations_to_json( {"name": { (1, 1): "new_state" }})) assert dict_persistence.callback_data_json == json.dumps(callback_data) flag = False def dumps(*args, **kwargs): nonlocal flag flag = True # Since the data doesn't change, json.dumps shoduln't be called beyond this point! monkeypatch.setattr(json, "dumps", dumps) await dict_persistence.update_bot_data(bot_data) await dict_persistence.update_user_data(12345, user_data[12345]) await dict_persistence.update_chat_data(-12345, chat_data[-12345]) await dict_persistence.update_conversation("name", (1, 1), "new_state") await dict_persistence.update_callback_data(callback_data) assert not flag
def test_json_changes(self, user_data, user_data_json, chat_data, chat_data_json, bot_data, bot_data_json, conversations, conversations_json): dict_persistence = DictPersistence(user_data_json=user_data_json, chat_data_json=chat_data_json, bot_data_json=bot_data_json, conversations_json=conversations_json) user_data_two = user_data.copy() user_data_two.update({4: {5: 6}}) dict_persistence.update_user_data(4, {5: 6}) assert dict_persistence.user_data == user_data_two assert dict_persistence.user_data_json != user_data_json assert dict_persistence.user_data_json == json.dumps(user_data_two) chat_data_two = chat_data.copy() chat_data_two.update({7: {8: 9}}) dict_persistence.update_chat_data(7, {8: 9}) assert dict_persistence.chat_data == chat_data_two assert dict_persistence.chat_data_json != chat_data_json assert dict_persistence.chat_data_json == json.dumps(chat_data_two) bot_data_two = bot_data.copy() bot_data_two.update({'7': {'8': '9'}}) bot_data['7'] = {'8': '9'} dict_persistence.update_bot_data(bot_data) assert dict_persistence.bot_data == bot_data_two assert dict_persistence.bot_data_json != bot_data_json assert dict_persistence.bot_data_json == json.dumps(bot_data_two) conversations_two = conversations.copy() conversations_two.update({'name4': {(1, 2): 3}}) dict_persistence.update_conversation('name4', (1, 2), 3) assert dict_persistence.conversations == conversations_two assert dict_persistence.conversations_json != conversations_json assert dict_persistence.conversations_json == encode_conversations_to_json( conversations_two)
def create_bot(self, app, persistence): self.app = app self.persistence = persistence or DictPersistence() token = app.config.get("API_TOKEN") autodiscovery(app.config.get("APPS", [])) self.bot = telegram.Bot(token=token) self.dispatcher = Dispatcher(self.bot, None, workers=0, use_context=True, persistence=self.persistence) setup_handlers(self.dispatcher) # log all errors self.dispatcher.add_error_handler(self.error)
async def test_good_json_input(self, user_data_json, chat_data_json, bot_data_json, conversations_json, callback_data_json): dict_persistence = DictPersistence( user_data_json=user_data_json, chat_data_json=chat_data_json, bot_data_json=bot_data_json, conversations_json=conversations_json, callback_data_json=callback_data_json, ) user_data = await dict_persistence.get_user_data() assert isinstance(user_data, dict) assert user_data[12345]["test1"] == "test2" assert user_data[67890][3] == "test4" chat_data = await dict_persistence.get_chat_data() assert isinstance(chat_data, dict) assert chat_data[-12345]["test1"] == "test2" assert chat_data[-67890][3] == "test4" bot_data = await dict_persistence.get_bot_data() assert isinstance(bot_data, dict) assert bot_data["test1"] == "test2" assert bot_data["test3"]["test4"] == "test5" assert "test6" not in bot_data callback_data = await dict_persistence.get_callback_data() assert isinstance(callback_data, tuple) assert callback_data[0] == [("test1", 1000, { "button1": "test0", "button2": "test1" })] assert callback_data[1] == {"test1": "test2"} conversation1 = await dict_persistence.get_conversations("name1") assert isinstance(conversation1, dict) assert conversation1[(123, 123)] == 3 assert conversation1[(456, 654)] == 4 with pytest.raises(KeyError): conversation1[(890, 890)] conversation2 = await dict_persistence.get_conversations("name2") assert isinstance(conversation1, dict) assert conversation2[(123, 321)] == 1 assert conversation2[(890, 890)] == 2 with pytest.raises(KeyError): conversation2[(123, 123)]
def main(): my_persistence = DictPersistence() updater = Updater(token=config.token, persistence=my_persistence, use_context=True) disp = updater.dispatcher start_handler = CommandHandler('start', start) disp.add_handler(start_handler) echo_handler = MessageHandler(Filters.text & (~Filters.command), echo) disp.add_handler(echo_handler) test_handler = CommandHandler('test', test) disp.add_handler(test_handler) disp.add_error_handler(error) callback_query_handler = CallbackQueryHandler(echo) disp.add_handler(callback_query_handler) updater.start_polling() updater.idle()
def __init__(self): super().__init__() dp = DictPersistence() self.updater = Updater(self.token, persistence=dp, use_context=True) self.dispatch = self.updater.dispatcher get_location_handler = MessageHandler(Filters.location, loc, pass_job_queue=True, pass_chat_data=True, pass_user_data=True) self.dispatch.add_handler(get_location_handler) self.dispatch.add_handler( CommandHandler("location", get_location, pass_args=True, pass_job_queue=True, pass_chat_data=True)) self.dispatch.add_handler(CommandHandler("help", start)) self.dispatch.add_handler(CommandHandler("start", start)) self.dispatch.add_handler( CommandHandler("now", starter, pass_args=True, pass_job_queue=True, pass_chat_data=True)) self.dispatch.add_handler( CommandHandler("daily", starter, pass_args=True, pass_job_queue=True, pass_chat_data=True)) self.dispatch.add_handler( CommandHandler("forecast", starter, pass_args=True, pass_job_queue=True, pass_chat_data=True)) self.dispatch.add_handler( CommandHandler("unset", unset, pass_chat_data=True)) self.dispatch.add_error_handler(error) self.updater.start_polling() self.updater.idle()
def main(): # Create the Updater and pass it your bot's token. pp = DictPersistence() updater = Updater("612692236:AAEFhww1ILsXFKK07nj1QqFYhtmGB8h07WM", persistence=pp, 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=[CustomCommandHandle(get_valid_commands, start)], states={ CHOOSING: [ MessageHandler(Filters.regex("^(Age|Favourite colour|Number of siblings)$"), regular_choice), MessageHandler(Filters.regex("^Something else...$"), custom_choice), ], TYPING_CHOICE: [MessageHandler(Filters.text, regular_choice)], TYPING_REPLY: [MessageHandler(Filters.text, received_information)], }, fallbacks=[MessageHandler(Filters.regex("^Done$"), done)], name="my_conversation", persistent=True, ) dp.add_handler(conv_handler) show_data_handler = CommandHandler("show_data", show_data) dp.add_handler(show_data_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. logger.info("Listening ...") updater.idle()
import logging import os from telegram.ext import Updater, DictPersistence logger = logging.getLogger(__name__) try: token = os.environ['ROUTE_TIME_BOT_TOKEN'] except KeyError: message = 'You have to set ROUTE_TIME_BOT_TOKEN' logger.error(message) raise ValueError(message) in_memory_persistence = DictPersistence(store_chat_data=False) class RouteTimeBotUpdater(Updater): def register_handler(self, handler_cls, **kwargs): logger.debug('Add handler for {func.__name__}') dispatcher = self.dispatcher def decorator(func): handler = handler_cls(callback=func, **kwargs) dispatcher.add_handler(handler) return func return decorator bot_updater = RouteTimeBotUpdater(token=token,
async def test_updating( self, user_data_json, chat_data_json, bot_data_json, callback_data, callback_data_json, conversations, conversations_json, ): dict_persistence = DictPersistence( user_data_json=user_data_json, chat_data_json=chat_data_json, bot_data_json=bot_data_json, callback_data_json=callback_data_json, conversations_json=conversations_json, ) user_data = await dict_persistence.get_user_data() user_data[12345]["test3"]["test4"] = "test6" assert dict_persistence.user_data != user_data assert dict_persistence.user_data_json != json.dumps(user_data) await dict_persistence.update_user_data(12345, user_data[12345]) assert dict_persistence.user_data == user_data assert dict_persistence.user_data_json == json.dumps(user_data) await dict_persistence.drop_user_data(67890) assert 67890 not in dict_persistence.user_data dict_persistence._user_data = None await dict_persistence.drop_user_data(123) assert isinstance(await dict_persistence.get_user_data(), dict) chat_data = await dict_persistence.get_chat_data() chat_data[-12345]["test3"]["test4"] = "test6" assert dict_persistence.chat_data != chat_data assert dict_persistence.chat_data_json != json.dumps(chat_data) await dict_persistence.update_chat_data(-12345, chat_data[-12345]) assert dict_persistence.chat_data == chat_data assert dict_persistence.chat_data_json == json.dumps(chat_data) await dict_persistence.drop_chat_data(-67890) assert -67890 not in dict_persistence.chat_data dict_persistence._chat_data = None await dict_persistence.drop_chat_data(123) assert isinstance(await dict_persistence.get_chat_data(), dict) bot_data = await dict_persistence.get_bot_data() bot_data["test3"]["test4"] = "test6" assert dict_persistence.bot_data != bot_data assert dict_persistence.bot_data_json != json.dumps(bot_data) await dict_persistence.update_bot_data(bot_data) assert dict_persistence.bot_data == bot_data assert dict_persistence.bot_data_json == json.dumps(bot_data) callback_data = await dict_persistence.get_callback_data() callback_data[1]["test3"] = "test4" callback_data[0][0][2]["button2"] = "test41" assert dict_persistence.callback_data != callback_data assert dict_persistence.callback_data_json != json.dumps(callback_data) await dict_persistence.update_callback_data(callback_data) assert dict_persistence.callback_data == callback_data assert dict_persistence.callback_data_json == json.dumps(callback_data) conversation1 = await dict_persistence.get_conversations("name1") conversation1[(123, 123)] = 5 assert not dict_persistence.conversations["name1"] == conversation1 await dict_persistence.update_conversation("name1", (123, 123), 5) assert dict_persistence.conversations["name1"] == conversation1 conversations["name1"][(123, 123)] = 5 assert (dict_persistence.conversations_json == DictPersistence._encode_conversations_to_json(conversations)) assert await dict_persistence.get_conversations("name1" ) == conversation1 dict_persistence._conversations = None await dict_persistence.update_conversation("name1", (123, 123), 5) assert dict_persistence.conversations["name1"] == {(123, 123): 5} assert await dict_persistence.get_conversations("name1") == { (123, 123): 5 } assert (dict_persistence.conversations_json == DictPersistence._encode_conversations_to_json( {"name1": { (123, 123): 5 }}))
def test_no_json_given(self): dict_persistence = DictPersistence() assert dict_persistence.get_user_data() == defaultdict(dict) assert dict_persistence.get_chat_data() == defaultdict(dict) assert dict_persistence.get_conversations('noname') == {}
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, persistence = DictPersistence()) # Get the dispatcher to register handlers dp = updater.dispatcher conv_handler_nitrogen_oxides = ConversationHandler( entry_points=[CommandHandler('start_calc_nitrogen_oxides', start_calc_nitrogen_oxides)], states={ K: [MessageHandler(Filters.regex('^[-+]?\d*\.?\d*$'), get_k)], ETA1: [MessageHandler(~Filters.command, get_eta1)], D0: [MessageHandler(Filters.regex('^[-+]?\d*\.?\d*$'), get_d0)], W: [MessageHandler(~Filters.command, get_w)], Z: [MessageHandler(~Filters.command, get_z)], ETA2: [MessageHandler(~Filters.command, get_eta2)] }, fallbacks=[CommandHandler('cancel', cancel)], name = "calc_nitrogen_oxides", persistent = True ) conv_handler = ConversationHandler( entry_points=[CommandHandler('start_calc_sulfur_dioxide', start_calc_sulfur_dioxide)], states={ Q: [MessageHandler(Filters.regex('^[-+]?\d*\.?\d*$'), get_q)], Type: [MessageHandler(~Filters.command, get_type)], S: [MessageHandler(~Filters.command, get_s)], N1: [MessageHandler(~Filters.command, get_n1)], N2: [MessageHandler(~Filters.command, get_n2)] }, fallbacks=[CommandHandler('cancel', cancel)], name = "calc_sulfur_dioxide", persistent = True ) dp.add_handler(conv_handler) dp.add_handler(conv_handler_nitrogen_oxides) dp.add_handler(CommandHandler('start', start)) dp.add_handler(CommandHandler('start_calc_sulfur_dioxide', start_calc_sulfur_dioxide)) dp.add_handler(CommandHandler('start_calc_nitrogen_oxides', start_calc_nitrogen_oxides)) # 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://telegram-calc-ecology-bot.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 # start_polling() is non-blocking and will stop the bot gracefully. updater.idle()
def persistence_mock(): return DictPersistence()
def test_mutual_exclude_persistence_dispatcher(self, bot): dispatcher = Dispatcher(bot, None) persistence = DictPersistence() with pytest.raises(ValueError): Updater(dispatcher=dispatcher, persistence=persistence)
def intro_handler(update, context): update.message.reply_text( "Initialize Yourself : https://telegra.ph/Introduce-Yourself-09-02") def hi_handler(update, context): user_name = update.effective_user["username"] texts = [ 'Hello {{user}}', 'Heya {{user}}', 'Hi {{user}}', "what's up bruh ?" ] update.message.reply_text(texts[random.randint(0, len(texts) - 1)].replace( '{{user}}', user_name)) if __name__ == '__main__': logger.info("Starting bot") bot = Bot(token=TOKEN) bot_perst = DictPersistence() updater = Updater(TOKEN, use_context=True, persistence=bot_perst) updater.dispatcher.add_handler(CommandHandler("start", start_handler)) updater.dispatcher.add_handler(CommandHandler("random", random_handler)) updater.dispatcher.add_handler(CommandHandler("pin", pin_handler)) updater.dispatcher.add_handler(CommandHandler("intro", intro_handler)) updater.dispatcher.add_handler(CommandHandler("hi", hi_handler)) updater.dispatcher.add_handler(CommandHandler("idiot", idiot_handler)) run(updater)