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)
